PowerShell Obter lista de pastas compartilhadas

Estou tentando obter uma lista de pastas compartilhadas em um compartilhamento de arquivo. No momento, tenho duas pastas de teste:

\\MYPC\Test1

\\MYPC\Test2

Este é o código que tenho no momento:

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

Write-Host $FolderList

Mas isso surge com "não é possível encontrar o caminho". Eu posso ver exemplos de como fazer isso \\Server\Sharecomo diretório, mas é possível apenas pesquisar no \\Server?

Tente o seguinte:

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

Ref: Listar compartilhamentos no Windows com PowerShell

Há apenas uma maneira de enumerar compartilhamentos remotamente a partir da linha de comando que eu conheço, e é isso 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.

Isso não é particularmente analisável por si só, mas você pode jogá-lo em uma matriz para processar os dados linha por linha:

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

Agora você tem uma matriz e a partir de $sharedFolders[7]suas ações. Você pode, então, splitusar um espaço duplo - é improvável que apareça no próprio nome de compartilhamento e deva funcionar, a menos que o nome do compartilhamento seja muito longo, deixando apenas um espaço entre o nome do compartilhamento e o campo type:

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

Você pode processá-los usando um ForEach e alguma lógica condicional. Não seria perfeito, mas deve funcionar para a maioria dos casos de uso.

Por uma questão de brevidade, basta enviar os nomes dos arquivos para o console:

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

Se você deseja encontrar os compartilhamentos da máquina local, basta Get-SmbShare:

> Get-SmbShare

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

Expandindo resposta de Mark Henderson :

$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
}

Obrigado a Mark Henderson por sua solução . Adicionei uma função de invólucro para ajudar a tornar essa função mais amigável ao PowerShell. Eu usei uma abordagem diferente para dividir os dados (mais complexos, não melhores); que podem ser facilmente trocados com base na preferência.

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

No Windows 8 ou superior e no Windows Server 2012 ou superior, você pode usar o Get-SmbShare no módulo SmbShare.

Ferramenta Windows Resource Kit: rmtshare .

Execute sob id com permissões de administrador no servidor remoto ou faça uma conexão ipc $ com o servidor remoto.

rmtshare \\servername

Aqui está um liner do PowerShell que usa o net view para enumerar todos os compartilhamentos remotos que um usuário pode ver - não significa que eles têm acesso.

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

Se você deseja ver se eles têm (pelo menos) acesso de leitura, você pode executar:

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)}}}

Se você precisar salvar a saída, sempre poderá canalizá-la para Export-CSV, ativando o seguinte após o último colchete:

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

A coisa toda não é perfeita quando o net view gera um erro, mas eu o escrevi com base nos comentários aqui e funciona muito bem e é útil para o que eu preciso, então pensei em compartilhar. :)