web-dev-qa-db-fra.com

PowerShell Obtenir la liste des dossiers partagés

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

\\MYPC\Test1

\\MYPC\Test2

C'est le code que j'ai pour le moment:

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

Write-Host $FolderList

Mais cela vient avec "ne peut pas trouver le chemin". Je peux voir des exemples de la façon de procéder pour \\Server\Share en tant que répertoire, mais est-il possible de rechercher simplement le \\Server?

powershellshared-folderspowershell-3.0
17
The Woo

Essaye ça:

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

Réf: Liste des partages sous Windows avec PowerShell

22
Tamerz

Il n'y a qu'un seul moyen d'énumérer les partages à distance à partir 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 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 $sharedFolders[7], vous avez vos partages. Vous pourriez alors split sur quelque chose comme un double espace - il est peu probable qu'il apparaisse dans un nom de partage lui-même et devrait fonctionner à moins que votre nom de partage ne soit très long, ne laissant qu'un seul espace entre le nom du partage et le champ type:

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

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

Par souci de brièveté, il suffit de sortir les noms de fichiers sur la console:

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

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
7
Klas Mellbourn

Développer 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
}
3
DingoCC

Merci à Mark Henderson pour sa solution . J'ai ajouté une fonction wrapper pour rendre cette fonction plus conviviale pour PowerShell. J'ai utilisé une approche différente pour séparer les données (plus complexe, pas mieux); cela 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
3
JohnLBevan

Kit de ressources Windows: rmtshare .

Soit exécuter sous id avec des autorisations d’administrateur sur le serveur distant ou bien établir une connexion ipc $ avec le serveur distant.

rmtshare \\servername
0
Windows Admin

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

0
JamieSee

Voici une couche PowerShell qui utilise Net View pour énumérer tous les partages distants qu'un utilisateur peut voir - cela 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 sauvegarder la sortie, 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

Tout n’est pas parfait lorsque net view renvoie une erreur, mais je l’ai écrite en fonction des commentaires ici. Cela fonctionne plutôt bien et est utile pour ce dont j’ai besoin, alors j’ai pensé partager. :)

0
Ahren Bader-Jarvis