Files
syno-scripts/NDTrack/NDTrack-Geprueft.ps1
T
2026-10-15 14:46:41 +02:00

465 lines
24 KiB
PowerShell

#Requires -Version 5.1
# Skriptversion: 1.0.3
# Versionsstand: 2026-10-15
<#
Korrigierte Kopie auf Basis des Originalskripts, mit denselben acht Optionen.
Windows-Verwaltungsrechner erforderlich. Die CMD-/SH-Dateien werden separat geliefert.
-LibraryOnly laedt nur Funktionen fuer isolierte Tests; fuehrt keine Aktionen aus.
#>
[CmdletBinding()]
param([switch]$LibraryOnly)
function Initialize-Configuration {
# Ablage auf dem ausfuehrenden Windows-Verwaltungsrechner:
# C:\SCAN\SCRIPT\NDTrack-Geprueft.ps1
$script:ScriptFolder = 'C:\SCAN\SCRIPT'
$script:SourcePath = 'C:\SCAN\NDTRACK'
$script:LinuxSourcePath = 'C:\SCAN\NDTRACK'
$script:DestinationPath = '' # Leer = Systemlaufwerk automatisch per WMI/DCOM ermitteln
$script:ServerDestinationPaths = @{} # Optional: @{ 'sql01.firma.example' = 'D:\ndtrack' }
$script:TaskName = 'NDTRACK'
$script:WindowsLauncher = 'RunNdTrackWindows_Local.cmd'
$script:LinuxLauncher = 'RunNdTrackLinuxUnix_Local.sh'
$script:Ergebnisordner = 'C:\SCAN\RESULTS'
$script:LogFolder = 'C:\SCAN\SCRIPT\Logs'
$script:TargetDomain = '' # Leer = DNS-Domaene des angemeldeten Benutzers
$script:DomainController = '' # Optional: FQDN eines DCs der Zieldomaene
$script:TestServers = @() # Zum Test z.B. @('GARRDSV003'); leer = AD/RDS
$script:RDSConnectionBroker = '' # Leer: wird bei Option 8 abgefragt
# Option 8 verwendet einen VOLLSTAENDIGEN, auf den RDS-Servern erreichbaren CMD-Pfad.
# Bei UNC-Pfaden muss der Remote-Ausfuehrungskontext Zugriff auf die Freigabe haben.
$script:RDSLauncherPath = '' # Kein Freigabepfad wird geraten.
}
function ShowMenu {
Write-Host @'
NDTRACK - Version 1.0.3 (Stand: 2026-10-15)
1: Windows - NDTrack-Dateien auf Server kopieren
2: Windows - Task NDTRACK mit Benutzerkonto erstellen (Start in 5 Minuten)
3: Windows - Scan-Dateien von Servern holen
4: Linux - NDTrack-Dateien auf Server kopieren
5: Linux - Scan per SSH starten
6: Linux - Scan-Dateien von Servern holen
7: Windows - aufraeumen (Task und NDTrack entfernen)
8: Linux - aufraeumen (NDTrack entfernen)
0: Beenden
'@
Read-Host 'Auswahl (0-8)'
}
function Assert-ServerName {
param([string]$Name)
if ($Name -notmatch '^[A-Za-z0-9][A-Za-z0-9.-]*$') {
throw "Ungueltiger Servername: $Name (DNS-Name oder IPv4 verwenden)."
}
}
function Get-DirectoryEndpoint {
# Keine kundenspezifischen Domain-DNs oder Servernamen.
if ($script:DomainController) {
Assert-ServerName $script:DomainController
return $script:DomainController
}
if ($script:TargetDomain) {
Assert-ServerName $script:TargetDomain
return $script:TargetDomain
}
if ($env:USERDNSDOMAIN) {
Assert-ServerName $env:USERDNSDOMAIN
return $env:USERDNSDOMAIN
}
throw 'Keine Benutzerdomaene ermittelbar. TargetDomain oder DomainController konfigurieren oder TestServers mit expliziten Zielservern fuellen.'
}
function GetADServer {
if ($script:TestServers.Count) {
foreach ($server in $script:TestServers) { Assert-ServerName $server }
return $script:TestServers | Sort-Object -Unique
}
$endpoint = Get-DirectoryEndpoint
$root = $null; $entry = $null; $searcher = $null; $results = $null
try {
$root = New-Object System.DirectoryServices.DirectoryEntry("LDAP://$endpoint/RootDSE")
$namingContext = [string]$root.Properties['defaultNamingContext'].Value
$dc = [string]$root.Properties['dnsHostName'].Value
if (-not $namingContext -or -not $dc) { throw 'RootDSE liefert keine AD-Domaene bzw. keinen DC.' }
Assert-ServerName $dc
# Optionalen DC auf Zugehoerigkeit zur expliziten Zieldomaene pruefen.
if ($script:TargetDomain) {
Assert-ServerName $script:TargetDomain
$expected = ($script:TargetDomain.TrimEnd('.').Split('.') | ForEach-Object { 'DC=' + $_ }) -join ','
if ($namingContext -ine $expected) { throw "DC gehoert zu $namingContext, erwartet wurde $expected." }
}
Write-Host "AD-AUSWAHL: $namingContext ueber $dc (aktuelles Windows-Konto)."
$entry = New-Object System.DirectoryServices.DirectoryEntry("LDAP://$dc/$namingContext")
$searcher = New-Object System.DirectoryServices.DirectorySearcher($entry)
$searcher.Filter = '(&(objectCategory=computer)(operatingSystem=*Server*)(!(userAccountControl:1.2.840.113556.1.4.803:=2)))'
$searcher.PageSize = 1000
[void]$searcher.PropertiesToLoad.Add('dnshostname')
[void]$searcher.PropertiesToLoad.Add('name')
$results = $searcher.FindAll()
$servers = @($results | ForEach-Object {
if ($_.Properties['dnshostname'].Count) {
$name = [string]$_.Properties['dnshostname'][0]
Assert-ServerName $name
$name
} else {
Write-Warning "AD-Computer $($_.Properties['name'][0]) ohne DNS-Hostnamen wird uebersprungen."
}
} | Sort-Object -Unique)
if (-not $servers.Count) { throw 'Keine aktivierten Windows-Server mit DNS-Hostnamen gefunden.' }
$servers
}
catch { throw "AD-Abfrage fuer '$endpoint' fehlgeschlagen: $($_.Exception.Message)" }
finally {
if ($null -ne $results) { $results.Dispose() }
if ($null -ne $searcher) { $searcher.Dispose() }
if ($null -ne $entry) { $entry.Dispose() }
if ($null -ne $root) { $root.Dispose() }
}
}
function GetRDSServer {
if ($script:TestServers.Count) { return $script:TestServers }
Import-Module RemoteDesktop -ErrorAction Stop
if (-not $script:RDSConnectionBroker) { $script:RDSConnectionBroker = Read-Host 'RDS Connection Broker (FQDN)' }
Assert-ServerName $script:RDSConnectionBroker
Get-RDServer -ConnectionBroker $script:RDSConnectionBroker -Role 'RDS-RD-SERVER' -ErrorAction Stop |
Select-Object -ExpandProperty Server -Unique
}
function GetLinuxServer {
$path = Read-Host 'Vollstaendiger Pfad zur Linux-Serverliste'
if (-not (Test-Path -LiteralPath $path -PathType Leaf)) { throw "Serverliste nicht gefunden: $path" }
$names = @(Get-Content -LiteralPath $path -ErrorAction Stop | ForEach-Object { $_.Trim() } |
Where-Object { $_ -and -not $_.StartsWith('#') } | Sort-Object -Unique)
foreach ($name in $names) { Assert-ServerName $name }
$names
}
function Resolve-WindowsFolder {
param([string]$Server)
Assert-ServerName $Server
$folder = $script:DestinationPath
$overrides = Get-Variable -Name ServerDestinationPaths -Scope Script -ErrorAction SilentlyContinue
if ($overrides -and $overrides.Value.ContainsKey($Server)) { $folder = $overrides.Value[$Server] }
if (-not $folder) {
$cimSession = $null
try {
$options = New-CimSessionOption -Protocol Dcom -ErrorAction Stop
$cimSession = New-CimSession -ComputerName $Server -SessionOption $options -ErrorAction Stop
$os = Get-CimInstance -CimSession $cimSession -ClassName Win32_OperatingSystem -Property SystemDrive -ErrorAction Stop
$drive = [string]$os.SystemDrive
if ($drive -notmatch '^[A-Za-z]:$') { throw 'Kein gueltiges Systemlaufwerk vom Zielserver erhalten.' }
$folder = $drive + '\ndtrack'
} catch {
throw "Systemlaufwerk von '$Server' konnte per WMI/DCOM nicht ermittelt werden: $($_.Exception.Message)"
} finally {
if ($null -ne $cimSession) { Remove-CimSession -CimSession $cimSession -ErrorAction SilentlyContinue }
}
}
if ($folder -notmatch '^[A-Za-z]:\\[^"\r\n]+$' -or $folder -match '(?:^|\\)\.\.?(?:\\|$)') { throw 'Ungueltiger lokaler NDTrack-Zielpfad.' }
$folder.TrimEnd('\')
}
function Get-WindowsSharePath {
param([string]$Server)
$folder = Resolve-WindowsFolder $Server
'\\{0}\{1}$\{2}' -f $Server,$folder.Substring(0,1),$folder.Substring(3)
}
function CheckDirectory {
$paths = @($script:ScriptFolder,$script:SourcePath,$script:LinuxSourcePath,
$script:Ergebnisordner,$script:LogFolder) | Select-Object -Unique
foreach ($path in $paths) {
if (Test-Path -LiteralPath $path -ErrorAction Stop) {
if (-not (Test-Path -LiteralPath $path -PathType Container -ErrorAction Stop)) {
throw "Pfad ist eine Datei statt eines Ordners: $path"
}
Write-Host "ORDNER VORHANDEN: $path"
} else {
New-Item -Path $path -ItemType Directory -Force -ErrorAction Stop | Out-Null
Write-Host "ORDNER ANGELEGT: $path"
}
}
}
function Test-SourceFiles {
param([string]$Path,[string]$Launcher)
if (-not (Test-Path -LiteralPath $Path -PathType Container -ErrorAction Stop)) {
throw "Quellordner fehlt: $Path"
}
$files = @(Get-ChildItem -LiteralPath $Path -File -Recurse -Force -ErrorAction Stop)
if ($files.Count -eq 0) {
throw "Keine Dateien in $Path gefunden. Bitte das vollstaendige NDTrack-Paket dort ablegen und das Skript erneut starten. Leere Unterordner reichen nicht aus."
}
if ($Launcher) {
$launcherPath = Join-Path $Path $Launcher
if (-not (Test-Path -LiteralPath $launcherPath -PathType Leaf -ErrorAction Stop)) {
throw "Benoetigte Startdatei fehlt: $launcherPath"
}
if ((Get-Item -LiteralPath $launcherPath -ErrorAction Stop).Length -eq 0) {
throw "Startdatei ist leer: $launcherPath"
}
}
Write-Host "QUELLE GEPRUEFT: $Path - $($files.Count) Datei(en) vorhanden."
}
function CopyFile {
param([string[]]$Servers)
Test-SourceFiles -Path $script:SourcePath -Launcher $script:WindowsLauncher
foreach ($server in $Servers) {
try {
$folder = Resolve-WindowsFolder $server
$remote = '\\{0}\{1}$\{2}' -f $server,$folder.Substring(0,1),$folder.Substring(3)
$share = '\\{0}\{1}$' -f $server,$folder.Substring(0,1)
if (-not (Test-Path -LiteralPath $share -PathType Container -ErrorAction Stop)) {
throw "Freigabe nicht erreichbar: $share. Laufwerk, Freigabe und Berechtigungen pruefen."
}
if (Test-Path -LiteralPath ($remote + '\.ndtrack-running') -ErrorAction Stop) {
throw 'Scan-Sperre vorhanden; laufenden Scan bzw. verwaiste Sperre pruefen.'
}
New-Item -Path $remote -ItemType Directory -Force -ErrorAction Stop | Out-Null
Get-ChildItem -LiteralPath $script:SourcePath -Force -ErrorAction Stop |
Where-Object { $_.Name -notin @('inventory','Result','Ergebnisse','.ndtrack-running') } |
Copy-Item -Destination $remote -Recurse -Force -ErrorAction Stop
Write-Host "KOPIERT: $server -> $remote"
$server
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function CreateScheduledTask {
param([string[]]$Servers,[pscredential]$Credential)
if ($null -eq $Credential) { throw 'Kein Task-Konto angegeben.' }
foreach ($server in $Servers) {
$stage = 'Zielpfad ermitteln'
try {
$folder = Resolve-WindowsFolder $server
$share = '\\{0}\{1}$\{2}' -f $server,$folder.Substring(0,1),$folder.Substring(3)
$stage = 'CMD ueber SMB pruefen'
if (-not (Test-Path -LiteralPath ($share + '\' + $script:WindowsLauncher) -PathType Leaf -ErrorAction Stop)) { throw 'CMD fehlt; zuerst Option 1 ausfuehren.' }
$stage = 'Startzeit berechnen'
$now = Get-Date
$start = $now.AddMinutes(5)
if ($start.Date -ne $now.Date) { throw 'Startzeit liegt am Folgetag. Option 2 nach Mitternacht erneut ausfuehren.' }
$stage = 'Task mit urspruenglichem schtasks-Aufruf erstellen'
# Originalablauf: Benutzerkonto, einmaliger Start nach fuenf Minuten.
# Kein XML, kein SYSTEM, kein WinRM und kein zusaetzlicher /Run-Aufruf.
Invoke-NativeChecked 'schtasks.exe' @(
'/Create','/S',$server,'/TN',$script:TaskName,
'/TR',($folder + '\' + $script:WindowsLauncher),
'/SC','Once','/ST',$start.ToString('HH:mm'),
'/RU',$Credential.UserName,'/RP',$Credential.GetNetworkCredential().Password,
'/RL','HIGHEST','/F'
)
Write-Host "GEPLANT: $server - Task $script:TaskName fuer $($start.ToString('HH:mm')) erstellt. Scan-Abschluss noch nicht bestaetigt."
} catch { Write-Warning "${server}: $stage fehlgeschlagen: $($_.Exception.Message)" }
}
}
function Invoke-WindowsScan {
param([string[]]$Servers,[string]$LauncherPath)
foreach ($server in $Servers) {
try {
Assert-ServerName $server
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
param($path)
$ErrorActionPreference = 'Stop'
if (-not (Test-Path -LiteralPath $path -PathType Leaf)) { throw "CMD nicht erreichbar: $path" }
$folder = Split-Path -Parent $path
$lock = Join-Path $folder '.ndtrack-running'
New-Item -Path $lock -ItemType Directory -ErrorAction Stop | Out-Null
try {
$process = Start-Process -FilePath "$env:SystemRoot\System32\cmd.exe" -ArgumentList ('/d /s /c ""{0}""' -f $path) -WorkingDirectory $folder -Wait -PassThru -NoNewWindow -ErrorAction Stop
if ($process.ExitCode -ne 0) { throw "CMD-Exitcode: $($process.ExitCode)" }
} finally { Remove-Item -LiteralPath $lock -Force -ErrorAction Stop }
} -ArgumentList $LauncherPath
Write-Host "BEENDET: $server - CMD-Exitcode 0."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function RunNDTRACKRemotely {
param([string[]]$Servers)
foreach ($server in $Servers) {
try {
$folder = Resolve-WindowsFolder $server
Invoke-WindowsScan @($server) ($folder + '\' + $script:WindowsLauncher)
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function Scan_RDS_SINA {
param([string[]]$Servers)
if (-not $script:RDSLauncherPath) { $script:RDSLauncherPath = Read-Host 'Vollstaendiger CMD-Pfad auf den RDS-Servern (lokal oder UNC)' }
if ($script:RDSLauncherPath -notmatch '^(?:[A-Za-z]:\\|\\\\).+\.cmd$' -or $script:RDSLauncherPath.Contains('"')) { throw 'Gueltigen absoluten RDS-CMD-Pfad konfigurieren.' }
Invoke-WindowsScan $Servers $script:RDSLauncherPath
}
function GetInventoryFiles {
param([string[]]$Servers)
$batch = Join-Path $script:Ergebnisordner ('Windows-' + [guid]::NewGuid().ToString('N'))
foreach ($server in $Servers) {
$session = $null
try {
$remote = Resolve-WindowsFolder $server
$session = New-PSSession -ComputerName $server -ErrorAction Stop
Invoke-Command -Session $session -ErrorAction Stop -ScriptBlock {
param($folder,$name)
$ErrorActionPreference = 'Stop'
if (Test-Path -LiteralPath (Join-Path $folder '.ndtrack-running')) { throw 'Scan laeuft oder Sperre ist verwaist.' }
$task = Get-ScheduledTask | Where-Object { $_.TaskName -eq $name -and $_.TaskPath -eq '\' }
if ($task) {
$info = Get-ScheduledTaskInfo -TaskName $name -TaskPath '\'
if ($task.State -in @('Running','Queued') -or $info.LastTaskResult -ne 0 -or $info.NextRunTime -gt (Get-Date)) { throw 'Task noch ausstehend/aktiv oder letzter Lauf fehlerhaft.' }
}
$inventory = Join-Path $folder 'inventory'
$files = @(Get-ChildItem -LiteralPath $inventory -File -Recurse)
if (-not $files.Count) { throw 'Keine Inventardateien vorhanden.' }
} -ArgumentList $remote,$script:TaskName
$inventory = $remote + '\inventory'
$target = Join-Path $batch $server
New-Item -Path $target -ItemType Directory -Force -ErrorAction Stop | Out-Null
Copy-Item -Path "$inventory\*" -FromSession $session -Destination $target -Recurse -Force -ErrorAction Stop
Write-Host "EINGESAMMELT: $server -> $target (vorhandene Dateien, Alter nicht bewertet)."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
finally { if ($null -ne $session) { Remove-PSSession -Session $session } }
}
}
function DeleteScheduledTask {
param([string[]]$Servers)
foreach ($server in $Servers) {
try {
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
param($name)
$ErrorActionPreference = 'Stop'
$task = Get-ScheduledTask | Where-Object { $_.TaskName -eq $name -and $_.TaskPath -eq '\' }
if ($task) {
Disable-ScheduledTask -TaskName $name -TaskPath '\' | Out-Null
Stop-ScheduledTask -TaskName $name -TaskPath '\'
$deadline = (Get-Date).AddSeconds(30)
do {
$state = (Get-ScheduledTask -TaskName $name -TaskPath '\').State
if ($state -notin @('Running','Queued')) { break }
Start-Sleep -Milliseconds 500
} while ((Get-Date) -lt $deadline)
if ($state -in @('Running','Queued')) { throw 'Task konnte nicht gestoppt werden.' }
Unregister-ScheduledTask -TaskName $name -TaskPath '\' -Confirm:$false
}
} -ArgumentList $script:TaskName
$server
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function DeleteFile {
param([string[]]$Servers)
foreach ($server in $Servers) {
try {
$folder = Resolve-WindowsFolder $server
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
param($folder)
$ErrorActionPreference = 'Stop'
# Nur den dedizierten NDTrack-Ordner entfernen.
if ($folder.TrimEnd('\') -notmatch '^[A-Za-z]:\\.+$' -or $folder -match '(?:^|\\)\.\.?(?:\\|$)' -or (Split-Path $folder.TrimEnd('\') -Leaf) -ne 'ndtrack') { throw 'Loeschen nur fuer einen dedizierten ndtrack-Ordner erlaubt.' }
if (Test-Path -LiteralPath (Join-Path $folder '.ndtrack-running')) { throw 'Direkter Scan aktiv oder Sperre verwaist.' }
$processes = @(Get-CimInstance Win32_Process -Filter "Name = 'ndtrack.exe'")
foreach ($process in $processes) {
if (-not $process.ExecutablePath -or $process.ExecutablePath.StartsWith($folder.TrimEnd('\')+'\',[StringComparison]::OrdinalIgnoreCase)) { throw 'NDTrack-Prozess noch aktiv; keine Dateien geloescht.' }
}
if (Test-Path -LiteralPath $folder) { Remove-Item -LiteralPath $folder -Recurse -Force }
} -ArgumentList $folder
Write-Host "ENTFERNT: $server - NDTrack-Ordner."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
# Native Programme: Exitcode immer direkt pruefen.
function Invoke-NativeChecked {
param([string]$Program,[string[]]$Arguments)
& $Program @Arguments | Out-Host
if ($LASTEXITCODE -ne 0) { throw "$Program fehlgeschlagen (Exitcode $LASTEXITCODE)." }
}
function Get-LinuxUser {
$userName = Read-Host 'Linux-SSH-Benutzer (z.B. scanuser; kein Windows-Domaenenformat)'
if ($userName -notmatch '^[a-zA-Z_][a-zA-Z0-9_.-]*[$]?$') { throw 'Ungueltiger Linux-Benutzername.' }
$userName
}
function Invoke-LinuxCommand {
param([string]$Server,[string]$User,[string]$Command)
Assert-ServerName $Server
Invoke-NativeChecked 'ssh' @('-o','ConnectTimeout=15','-l',$User,$Server,$Command)
}
function CopyFileLinux {
param([string[]]$Servers,[string]$User)
Test-SourceFiles -Path $script:LinuxSourcePath -Launcher $script:LinuxLauncher
foreach ($server in $Servers) {
try {
Invoke-LinuxCommand $server $User 'test ! -d "$HOME/ndtrack/.ndtrack-running" && mkdir -p "$HOME/ndtrack"'
$items = @(Get-ChildItem -LiteralPath $script:LinuxSourcePath -Force -ErrorAction Stop | Where-Object { $_.Name -notin @('inventory','.ndtrack-running') })
foreach ($item in $items) { Invoke-NativeChecked 'scp' @('-r','-o','ConnectTimeout=15',$item.FullName,"${User}@${server}:ndtrack/") }
Write-Host "KOPIERT: $server"
$server
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function RunNDTRACKRemotelyLinux {
param([string[]]$Servers,[string]$User)
foreach ($server in $Servers) {
try {
# Interpreter aus der Shebang verwenden; Startdatei muss synchron laufen.
$command = 'cd "$HOME/ndtrack" && mkdir .ndtrack-running && { trap ''rmdir "$HOME/ndtrack/.ndtrack-running"'' EXIT; chmod u+x ./RunNdTrackLinuxUnix_Local.sh && ./RunNdTrackLinuxUnix_Local.sh; }'
Invoke-LinuxCommand $server $User $command
Write-Host "BEENDET: $server - SH-Exitcode 0."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function GetInventoryFilesLinux {
param([string[]]$Servers,[string]$User)
$batch = Join-Path $script:Ergebnisordner ('Linux-' + [guid]::NewGuid().ToString('N'))
foreach ($server in $Servers) {
try {
Invoke-LinuxCommand $server $User 'test ! -d "$HOME/ndtrack/.ndtrack-running" && test -d "$HOME/ndtrack/inventory" && test -n "$(find "$HOME/ndtrack/inventory" -type f -print -quit)"'
$target = Join-Path $batch $server
New-Item -Path $target -ItemType Directory -Force -ErrorAction Stop | Out-Null
Invoke-NativeChecked 'scp' @('-r','-o','ConnectTimeout=15',"${User}@${server}:ndtrack/inventory",$target)
Write-Host "EINGESAMMELT: $server -> $target (vorhandene Dateien, Alter nicht bewertet)."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function DeleteFileLinux {
param([string[]]$Servers,[string]$User)
foreach ($server in $Servers) {
try {
# Bei fehlendem pgrep ebenfalls abbrechen statt einen laufenden Scan zu riskieren.
$command = 'test -n "$HOME" && test "$HOME" != / && test ! -d "$HOME/ndtrack/.ndtrack-running" && command -v pgrep >/dev/null && { pgrep -x ndtrack >/dev/null; rc=$?; test "$rc" -eq 1; } && rm -rf -- "$HOME/ndtrack"'
Invoke-LinuxCommand $server $User $command
Write-Host "ENTFERNT: $server - NDTrack-Ordner."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function Invoke-MenuOption {
param([string]$Choice)
switch ($Choice) {
'1' { CopyFile @(GetADServer) | Out-Null }
'2' {
$credential = Get-Credential -Message 'Ausfuehrungskonto fuer Task NDTRACK (DOMAENE\Benutzer)'
if ($null -eq $credential) { throw 'Kontoabfrage abgebrochen.' }
CreateScheduledTask @(GetADServer) $credential
}
'3' { GetInventoryFiles @(GetADServer) }
'4' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; CopyFileLinux $servers $userName | Out-Null }
'5' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; RunNDTRACKRemotelyLinux $servers $userName }
'6' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; GetInventoryFilesLinux $servers $userName }
'7' { $servers = @(GetADServer); $cleared = @(DeleteScheduledTask $servers); if ($cleared.Count) { DeleteFile $cleared } }
'8' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; DeleteFileLinux $servers $userName }
'0' { return }
default { throw 'Bitte eine Option zwischen 0 und 8 waehlen.' }
}
}
if (-not $LibraryOnly) {
if ($env:OS -ne 'Windows_NT') { throw 'Auf einem Windows-Verwaltungsrechner ausfuehren; Mac nur zum Bearbeiten/Testen.' }
Initialize-Configuration
CheckDirectory
Test-SourceFiles -Path $script:SourcePath
do {
$choice = ShowMenu
if ($choice -eq '0') { break }
$transcriptStarted = $false
try {
$log = Join-Path $script:LogFolder ('NDTrack-{0}.log' -f (Get-Date -Format 'yyyyMMdd-HHmmss-fff'))
Start-Transcript -Path $log -ErrorAction Stop | Out-Null
$transcriptStarted = $true
Invoke-MenuOption $choice
} catch { Write-Warning $_.Exception.Message }
finally { if ($transcriptStarted) { Stop-Transcript | Out-Null } }
} while ($true)
}