PowerShell Obtenir la liste des dossiers partagés

J'essaie d'obtenir une liste des dossiers partagés sur un partage de fichiers. Pour le moment, j'ai deux dossiers de test:

\\MYPC\Test1

\\MYPC\Test2

Voici le code que j'ai en ce moment:

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

Write-Host $FolderList

Mais cela revient à "ne peut pas trouver le chemin". Je peux voir des exemples de la façon de le faire en \\Server\Sharetant que répertoire, mais est-il possible de simplement rechercher le \\Server?

Essaye ça:

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

Ref: Liste des partages dans Windows avec PowerShell

Il n'y a qu'une seule façon d'énumérer les partages à distance depuis la ligne de commande que je connais, et c'est avec 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.

Ce n'est pas particulièrement analysable en soi, mais vous pouvez le jeter dans un tableau pour traiter les données ligne par ligne:

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

Vous avez maintenant un tableau, et à partir de là, $sharedFolders[7]vous avez vos actions. Vous pourriez alors splitsur quelque chose comme un double espace - peu susceptible d'apparaître dans un nom de partage lui-même, et devrait fonctionner à moins que votre nom de partage soit très long, ne laissant qu'un seul espace entre le nom de partage et le champ type:

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

Vous pouvez les traiter en utilisant un ForEach et une logique conditionnelle. Ce ne serait pas parfait, mais cela devrait fonctionner pour la plupart des cas d'utilisation.

Par souci de concision, pour simplement afficher les noms de fichiers sur la console:

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

Si vous voulez trouver les partages de la machine locale, vous pouvez simplement faire Get-SmbShare:

> Get-SmbShare

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

Développant la réponse 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
}

Merci à Mark Henderson pour sa solution . J'ai ajouté une fonction wrapper pour aider à rendre cette fonction plus conviviale pour PowerShell. J'ai utilisé une approche différente pour décomposer les données (plus complexe, pas meilleure); qui peut facilement être changé en fonction des préférences.

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

Sous Windows 8 ou supérieur et Windows Server 2012 ou supérieur, vous pouvez utiliser Get-SmbShare à partir du module SmbShare.

Outil du Kit de ressources Windows: rmtshare .

Exécutez sous id avec des autorisations d'administrateur sur le serveur distant ou établissez une connexion ipc $ au serveur distant.

rmtshare \\servername

Voici une doublure PowerShell qui utilise la vue nette pour énumérer tous les partages distants qu'un utilisateur peut voir - ne signifie pas qu'ils ont accès.

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

Si vous voulez voir s'ils ont (au moins) un accès en lecture, vous pouvez exécuter:

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 vous avez besoin de la sortie enregistrée, vous pouvez toujours la diriger vers Export-CSV en lançant ce qui suit après le dernier crochet:

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

Le tout n'est pas parfait lorsque la vue nette génère une erreur, mais je l'ai écrit sur la base des commentaires ici et cela fonctionne assez bien et est utile pour ce dont j'ai besoin, alors j'ai pensé partager. :)