PowerShell Uzyskaj listę udostępnionych folderów

Próbuję uzyskać listę folderów udostępnianych w udziale plików. W tej chwili mam dwa foldery testowe:

\\MYPC\Test1

\\MYPC\Test2

Oto kod, który mam w tej chwili:

$FileServer = Read-Host "Enter file server to search"
$FolderList = Get-ChildItem -Path $FileServer

Write-Host $FolderList

Ale pojawia się „nie można znaleźć ścieżki”. Widzę przykłady jak to zrobić \\Server\Sharejako katalog, ale czy można po prostu przeszukać \\Server?

Spróbuj tego:

get-WmiObject -class Win32_Share -computer dc1.krypted.com

Zobacz: Lista udziałów w Windows w / PowerShell

Istnieje tylko jeden sposób wyliczania udziałów zdalnie z wiersza poleceń, o którym wiem i to za pomocą net view:

C:\Users\mark.henderson>net view \\enetsqnap01
Shared resources at \\enetsqnap01



Share name             Type  Used as  Comment

-------------------------------------------------------------------------------
Backups                Disk
CallRecordings         Disk
Download               Disk           System default share
home                   Disk           Home
homes                  Disk           System default share
Installs               Disk
Justin                 Disk           Copy of files from Justin laptop
michael                Disk
Multimedia             Disk           System default share
Network Recycle Bin 1  Disk           [RAID5 Disk Volume: Drive 1 2 3 4]
Public                 Disk           System default share
Qsync                  Disk           Qsync
Recordings             Disk           System default share
Sales                  Disk           Sales Documents
SalesMechanix          Disk
Server2012             Disk           Windows Server 2012 Install Media
Usb                    Disk           System default share
VMWareTemplates        Disk
Web                    Disk           System default share
The command completed successfully.

Samo to nie jest szczególnie możliwe do przetworzenia, ale możesz wrzucić go do tablicy, aby przetwarzać dane linia po linii:

$sharedFolders = (NET.EXE VIEW \\enetsqnap01) 

Masz teraz tablicę, a zaczynając $sharedFolders[7]od swoich akcji. Możesz wtedy znaleźć splitcoś w rodzaju podwójnej spacji - jest mało prawdopodobne, aby pojawiała się w samej nazwie udziału i powinna działać, chyba że nazwa udziału jest bardzo długa, pozostawiając tylko jedną spację między nazwą udziału a polem typu:

$sharedFolders[7].split('  ')[0]
Backups

Możesz je przetworzyć za pomocą ForEach i logiki warunkowej. Nie byłby idealny, ale powinien działać w większości przypadków użycia.

Dla zwięzłości, aby po prostu wypisać nazwy plików do konsoli:

(net view \\enetsqnap01) | % { if($_.IndexOf(' Disk ') -gt 0){ $_.Split('  ')[0] } }

Jeśli chcesz znaleźć udziały lokalnego komputera, możesz po prostu Get-SmbShare:

> Get-SmbShare

Name                          ScopeName                     Path                          Description
----                          ---------                     ----                          -----------
ADMIN$                        *                             C:\WINDOWS                    Remote Admin
C$                            *                             C:\                           Default share

Rozwijając odpowiedź Marka Hendersona :

$Servers = ( Get-ADComputer -Filter { DNSHostName -Like '*' }  | Select -Expand Name )
foreach ($Server in $Servers)
{
    (net view $Server) | % { if($_.IndexOf(' Disk ') -gt 0){ $_.Split('      ')[0] } } | out-file C:\file_shares\$Server.txt
}

Podziękowania dla Marka Hendersona za jego rozwiązanie . Dodałem funkcję otoki, aby uczynić tę funkcję bardziej przyjazną dla programu PowerShell. Użyłem innego podejścia do podziału danych (bardziej złożone, a nie lepsze); które można łatwo przełączać w zależności od preferencji.

clear-host
function Get-SharedFolder {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true, ValueFromPipeline = $true)]
        [string]$ComputerName 
        ,
        [Parameter(Mandatory = $false)]
        [switch]$GetItem
        ,
        [Parameter(Mandatory = $false)]
        [string[]]$ColumnHeadings = @('Share name','Type','Used as','Comment')  #I suspect these differ depending on OS language?  Therefore made customisable
        ,
        [Parameter(Mandatory = $false)]
        [string]$ShareName = 'Share name' #tell us which of the properties relates to the share name
        #,
        #[Parameter(Mandatory = $false)]
        #[string[]]$Types = @('Disk') # again, likely differs with language.  Also there may be other types to include?
    )
    begin {
        [psobject[]]$Splitter = $ColumnHeadings | %{
            $ColumnHeading = $_
            $obj = new-object -TypeName PSObject -Property @{
                Name = $ColumnHeading
                StartIndex = 0
                Length = 0
            }
            $obj | Add-Member -Name Initialise -MemberType ScriptMethod {
                param([string]$header)
                process {
                    $_.StartIndex = $header.indexOf($_.Name)
                    $_.Length = ($header -replace ".*($($_.Name)\s*).*",'$1').Length
                }
            }
            $obj | Add-Member -Name GetValue -MemberType ScriptMethod {
                param([string]$line)
                process {
                    $line -replace ".{$($_.StartIndex)}(.{$($_.Length)}).*",'$1'
                }
            }
            $obj | Add-Member -Name Process -MemberType ScriptMethod {
                param([psobject]$obj,[string]$line)
                process {
                    $obj | Add-Member -Name $_.Name -MemberType NoteProperty -Value ($_.GetValue($line))
                }
            }
            $obj
        }
    }
    process {
        [string[]]$output = (NET.EXE VIEW $ComputerName)
        [string]$headers = $output[4] #find the data's heading row
        $output = $output[7..($output.Length-3)] #keep only the data rows
        $Splitter | %{$_.Initialise($headers)}
        foreach($line in $output) { 
            [psobject]$result = new-object -TypeName PSObject -Property @{ComputerName=$ComputerName;}
            $Splitter | %{$_.Process($result,$line)}
            $result | Add-Member '_ShareNameColumnName' -MemberType NoteProperty -Value $ShareName
            $result | Add-Member 'Path' -MemberType ScriptProperty -Value {("\\{0}\{1}" -f $this.ComputerName,$this."$($this._ShareNameColumnName)")}
            $result | Add-Member 'Item' -MemberType ScriptProperty -Value {Get-Item ($this.Path)}
            $result | Add-Member -MemberType MemberSet -Name PSStandardMembers -Value ([System.Management.Automation.PSMemberInfo[]]@(New-Object System.Management.Automation.PSPropertySet(‘DefaultDisplayPropertySet’,[string[]](@('ComputerName','Path') + $ColumnHeadings))))
            $result
        }
    }
}

[string[]]$myServers = 'myServer1','myServer2' #amend this line to get the servers you're interested in
[psobject[]]$shares = $myServers | Get-SharedFolder
write-host 'List of Shares' -ForegroundColor Cyan
$shares  | ft -AutoSize
write-host 'Shares as Get-Item output' -ForegroundColor Cyan
$shares  | select -expand Item

W systemie Windows 8 lub nowszym i Windows Server 2012 lub nowszym możesz użyć Get-SmbShare z modułu SmbShare.

Narzędzie Windows Resource Kit: rmtshare .

Uruchom pod identyfikatorem z uprawnieniami administratora na zdalnym serwerze lub nawiąż połączenie ipc $ ze zdalnym serwerem.

rmtshare \\servername

Oto jeden liniowiec PowerShell, który używa widoku netto do wyliczenia wszystkich zdalnych udziałów, które użytkownik może zobaczyć - nie znaczy, że mają dostęp.

net view | Where {$_ -like "\\*"} | %{$comp = $_.Split(" ")[0]; net view $comp | Where {$_ -like "*Disk*"} | %{$share = $_.Split(" ")[0]; $fullpath = Join-Path $comp $share; $fullpath}}

Jeśli chcesz sprawdzić, czy mają (przynajmniej) dostęp do odczytu, możesz uruchomić:

Net view | Where {$_ -like "\\*"} | %{$comp = $_.Split(" ")[0]; net view $comp | Where {$_ -like "*Disk*"} | %{$share = $_.Split(" ")[0]; $fullpath = Join-Path $comp $share; [PSCustomObject]@{Path=$fullpath;HasAccess=$(Test-Path $fullpath -ErrorAction SilentlyContinue)}}}

Jeśli potrzebujesz zapisanych danych wyjściowych, zawsze możesz przesłać je do Export-CSV, dodając następujące elementy po ostatnim nawiasie:

| Export-CSV "\\path\to\file.csv" -NoTypeInformation

Cała rzecz nie jest idealna, gdy widok sieci zgłasza błąd, ale napisałem ją na podstawie komentarzy tutaj i działa całkiem dobrze i jest pomocny w tym, czego potrzebuję, więc pomyślałem, że podzielę się. :)