PowerShell Obtener la lista de carpetas compartidas

Estoy tratando de obtener una lista de carpetas que se comparten en un recurso compartido de archivos. Por el momento tengo dos carpetas de prueba:

\\MYPC\Test1

\\MYPC\Test2

Este es el código que tengo en este momento:

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

Write-Host $FolderList

Pero esto surge con "no puedo encontrar el camino". Puedo ver ejemplos de cómo hacer esto \\Server\Sharecomo el directorio, pero ¿es posible simplemente buscar \\Server?

Prueba esto:

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

Ref: Lista de recursos compartidos en Windows con PowerShell

Solo conozco una forma de enumerar recursos compartidos de forma remota desde la línea de comandos, y eso es 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.

Esto no es particularmente analizable por sí solo, pero puede incluirlo en una matriz para procesar los datos línea por línea:

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

Ahora tiene una matriz y, a partir de ahí, $sharedFolders[7]tiene sus acciones. Luego, podría usar splitalgo como un doble espacio: es poco probable que aparezca en un nombre compartido, y debería funcionar a menos que su nombre compartido sea muy largo, dejando solo un espacio entre el nombre compartido y el campo de tipo:

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

Puede procesarlos utilizando ForEach y alguna lógica condicional. No sería perfecto, pero debería funcionar para la mayoría de los casos de uso.

Para abreviar, simplemente enviar los nombres de archivo a la consola:

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

Si desea encontrar los recursos compartidos de la máquina local, simplemente puede hacer Get-SmbShare:

> Get-SmbShare

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

Ampliando la respuesta 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
}

Gracias a Mark Henderson por su solución . Agregué una función de contenedor para ayudar a que esta función llame a PowerShell. He utilizado un enfoque diferente para dividir los datos (más complejo, no mejor); que se puede cambiar fácilmente según la preferencia.

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

En Windows 8 o superior y Windows Server 2012 o superior, puede usar Get-SmbShare desde el módulo SmbShare.

Herramienta del Kit de recursos de Windows: rmtshare .

Ejecútelo con id con permisos de administrador en el servidor remoto o realice una conexión ipc $ al servidor remoto.

rmtshare \\servername

Aquí hay un PowerShell one liner que usa la vista de red para enumerar todos los recursos compartidos remotos que un usuario puede ver, no significa que tengan acceso.

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

Si desea ver si tienen (al menos) acceso de lectura, puede ejecutar:

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

Si necesita guardar la salida, siempre puede canalizarla a Export-CSV agregando lo siguiente después del último paréntesis:

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

Todo esto no es perfecto cuando net view arroja un error, pero lo escribí en base a los comentarios aquí y funciona bastante bien y es útil para lo que necesito, así que pensé en compartirlo. :)