PowerShell obtient la liste des dossiers partagés

Essayez ceci :

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

Ref : Liste des actions dans Windows avec PowerShell _

Il n'y a qu'une seule façon d'énumérer les actions à distance de la ligne de commande que je connaisse, 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 lancer dans un tableau pour traiter les données ligne par ligne :

$sharedFolders = (NET.EXE VIEW \enetsqnap01)

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

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

Vous pourriez traiter ces données en utilisant un ForEach et une certaine logique conditionnelle. Ce ne serait pas parfait, mais cela devrait fonctionner pour la plupart des cas d'utilisation.

Pour être bref, il suffit de sortir les noms de fichiers sur la console :

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

Si vous voulez trouver les parts 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évelopper 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 d'habillage pour rendre cette fonction plus conviviale pour PowerShell. J'ai utilisé une approche différente pour décomposer les données (plus complexe, pas mieux) ; on peut facilement changer de méthode 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 du module SmbShare.

Voici un PowerShell one liner qui utilise le net view pour énumérer tous les partages à distance qu'un utilisateur peut voir - ce qui ne veut pas dire qu'il y a 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 vous lancer :

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 sauvegarder la sortie, vous pouvez toujours l'acheminer vers Export-CSV en lançant ce qui suit après la dernière parenthèse :

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

L'ensemble n'est pas parfait quand net view lance une erreur mais je l'ai écrit en me basant sur les commentaires ici et il fonctionne plutôt bien et est utile pour ce dont j'ai besoin donc j'ai pensé que je le partagerais. :)

Outil Windows Resource Kit : rmtshare .

Soit s'exécuter sous id avec les autorisations de l'administrateur sur le serveur distant, soit établir une connexion ipc$ au serveur distant.

rmtshare \servername