Finding paths that exceed MAX_PATH with Powershell

A lot as been said and written about the infamous MAX_PATH limitation imposed by the Windows API. Still in 2013 this keeps being a major pain for Windows File Server administrators and as such has been over-discussed but never properly solved. My opinion is that, unless a major architectural rework is done at Redmond, it is up to system administrators to keep an eye on their filesystems and try to evite as much as possible to have paths going over that hardcoded maximum.

That's why I want to share the Powershell script I use to find those paths that exceed 260 characters in lenght, being 260 the value of MAX_PATH ever since.

1. function Get-Longpaths {  
2. <#   
3. .SYNOPSIS   
4.   Retrieves a list of the paths that are too long for being managed with get-childitem.  
5.     
6. .DESCRIPTION   
7.   Retrieves a list of the paths that are too long for being managed with get-childitem.  
8.   An object is returned containing the list of the paths longer then 260 characters.  
9.   The aim of this function is to help sysadmins to handle paths which could cause the  
10.   “System.IO.PathTooLongException“ due to their excessive length comared to what is  
11.   supported by .NET and Windows API.  
12.   
13. .PARAMETER Path  
14.   The parent path that you need to recursively check.  
15.   
16. .PARAMETER Csvpath
17.   The name of the csv log file you optionally want to export your list of long paths to.  
18.   
19. .EXAMPLE  
20.   Get-Longpaths c:\  
21.   Retrieves long path on the system partition c: and show on the current host.  
22.   
23. .EXAMPLE  
24.   Get-Longpaths f:\documents c:\mylogs\longpathnames.csv -verbose  
25.   Retrieves long path inside the folder f:\documents and saves the  
26.   output to a csv file named longpathnames.csv under c:\mylogs\.  
27.   It also shows additional information on the task being performed.  
28. #>  
29. [CmdletBinding()]  
30.   
31.     param(  
32.         [Parameter(Mandatory=$true)]  
33.         [string] $Path,  
34.         [Parameter(Mandatory=$false)]  
35.         [string] $csvlog  
36.     )  
37.   
38. $options = [system.IO.SearchOption]::AllDirectories  
39. $allfiles = [system.IO.Directory]::GetFiles($path, "*",$options)  
40. $allfolders = [system.IO.Directory]::GetDirectories($path, "*",$options)  
41. $toolongcontainer = @()  
42.   
43. foreach($file in $allfiles)  
44.   {  
45.   if($file.Length -gt 259)  
46.     {  
47.     write-verbose "Adding $file to the list of too long paths"  
48.     $toolongcontainer  += $file  
49.     }  
50.   }  
51.   
52. foreach($folder in $allfolders)  
53.   {  
54.   if(($folder|out-string).Length -gt 259)  
55.     {  
56.     write-verbose "Adding $folder to the list of too long paths"  
57.     $toolongcontainer  += $folder  
58.     }  
59.   }  
60. if(!($toolongcontainer))  
61.   {  
62.   write-verbose "No too long paths found. Good."  
63.   $toolongcontainer = "No invalid path under $path"  
64.   }  
65. if($csvlog)  
66.   {  
67.   write-verbose "Exporting output to $csvpath"  
68.   $toolongcontainer | Export-Csv -Path $csvpath -NoTypeInformation -USECULTURE -ErrorAction Stop   
69.   }  
70. return $toolongcontainer  
71. }  
72.   
73. Get-Longpaths C:\longpath -verbose  

As you can see I used the methods GetFiles and GetDirectories of the system.IO.Directory class. In particular GetFiles returns the names of files in a specified directory, while GetDirectories gets the names of the subdirectories. The cool thing with this methods is that, for some mystical reasons explained here and here, they return the full path as a string or arrays and that's all we need.

Then all the objects returned by these two methods are added as strings to a string array named $toolongcontainer for later analysis. The content of this object can be sent to a CSV file as a  record by passing the csv file path as a parameter.

Once you have this information, you can take appropriate actions such as shortening the path, deleting files and folders that exceed MAX_PATH or moving them to a shorter path. This is up to you.

If you need any clarification about this script, feel free to leave a comment and I'll be happy to answer. But remember that the easier way to get help for a function is to dot source the script then use the built-in help function this way: man Get-Longpaths  -full where 'man' is an interesting alias for get-help.