Is there an equivalent to WinAPI's MAX_PATH under linux/unix?

Question

If I want to allocate a char array (in C) that is guaranteed to be large enough to hold any valid absolute path+filename, how big does it need to be.

On Win32, there is the MAX_PATH define. What is the equivalent for Unix/linux?

Solution 1

There is a PATH_MAX, but it is a bit problematic. From the bugs section of the realpath(3) man page:

The POSIX.1-2001 standard version of this function is broken by design, since it is impossible to determine a suitable size for the output buffer, resolved_path. According to POSIX.1-2001 a buffer of size PATH_MAX suffices, but PATH_MAX need not be a defined constant, and may have to be obtained using pathconf(3). And asking pathconf(3) does not really help, since, on the one hand POSIX warns that the result of pathconf(3) may be huge and unsuitable for mallocing memory, and on the other hand pathconf(3) may return -1 to signify that PATH_MAXis not bounded.

Solution 2

The other answers so far all seem right on point about the *nix side of things, but I'll add a warning about it on Windows.

You've been lied to (by omission) by the documentation.

MAX_PATH is indeed defined, and probably even applies to files stored on FAT or FAT32. However, any path name can be prefixed by \\?\ to tell the Windows API to ignore MAX_PATH and let the file system driver make up its own mind. After that, the definitions get fuzzy.

Add to the mix the fact that path names are actually Unicode (well, UTS-16) and that when the "ANSI" API is used the conversion to and from the internal Unicode name is dependent on a bunch of factors including the current code page, and you have a recipe for confusion.

A good description of the rules for Windows is at MSDN. The rules are much more complicated than I've summarized here.

Edit: I changed \\.\ to \\?\ in the above thanks to the comment from KitsuneYMG.

Windows paths and namespaces are complicated. Some might even argue they are too complicated. One source of complexity is that the Win32 (and now Win64) API is a subsystem that lays on top of the Windows NT native system.

A path without any prefix is compatible across the widest range of Windows platforms. If it is restricted to 7-bit ASCII characters, then it is compatible with 16-bit DOS since version 2.0 or so (whenever subdirectories were introduced, which might actually have been in DOS 3; but DOS 1.0 only had root directories and the \ character had no special meaning).

The \\?\ prefix causes the balance of the path name to be passed on verbatim to the appropriate file system driver, which is what produces the effect of dropping the restriction to MAX_PATH characters. If the long path name is also on a network share, then you can use an extended UNC name for it with the prefix \\?\UNC\server\share\ instead of the normal UNC name \\server\share\. Using this prefix restricts portability to Win32 and later Windows platforms, but unless you require support for 16-bit Windows on legacy hardware, that isn't a big issue.

The \\.\ prefix is a different animal. It allows access to device objects beyond the set of specially named devices that are automatically mapped by Windows as special file names into every file folder. Those special names include CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9. Note that all of those names are special whether or not an extension is used, or in any mix of upper or lower case. But it is possible that you have 10 or more COM ports installed. This happens quickly if you play with USB modems, or USB serial port adapters, since each unique USB-based serial port will be assigned a distinct COMn name. If you need to access the 50th serial port, then you can only do so with the name \\.\COM50 because COM50 is not a special name like COM1 is.

The MSDN page I cited above had the distinction right, I simply typed the incorrect prefix in my original answer.

Solution 3

Well, on Linux at least, there is:

• PATH_MAX (defined in limits.h)

• FILENAME_MAX (defined in stdio.h)

both of these are set to 4096 on my system (x86 Linux).

Update: : Some info from the glibc manual on this

Each of the following macros is defined in limits.h only if the system has a fixed, uniform limit for the parameter in question. If the system allows different file systems or files to have different limits, then the macro is undefined; use pathconf or fpathconf to find out the limit that applies to a particular file

Solution 4

FILENAME_MAX is part of the ISO C standard, it works on UNIX and Windows. However, the GNU C library documentation contains the following warnings:

"Unlike PATH_MAX, this macro is defined even if there is no actual limit imposed. In such a case, its value is typically a very large number. This is always the case on the GNU system.

Usage Note: Don't use FILENAME_MAX as the size of an array in which to store a file name! You can't possibly make an array that big! Use dynamic allocation."

Solution 5

You can use pathconf() to figure out at run-time, but there's also a PATH_MAX preprocessor define in <limits.h>.

View more solutions

Comments

[Tom]

That looks like a portability no-no.

[AndrewR]

I suppose the maximum could vary depending on the filesystem type you're using, which would imply a runtime check, not a compile-time constant.

[KitsuneYMG]

Pretty sure you mean ` \\?\ `

[RBerteig]

@KitsuneYMG, right. I cited the wrong prefix. Its fixed now, along with a digression about what the distinction is.

[v.oddou]

\\.\ is not the prefix for named pipes ?

[RBerteig]

@v.oddou It is the prefix for named pipes because named pipes are Win32 Device Objects from the point of view of the kernel, and reside in the device object name space, accessed from User mode with the prefix \\.\

[rr-]

COM1 is special but COM50 isn't - yet another case of stupid MS design.

[RBerteig]

@rr- at the time they did that, compatibility was a very important mandate from their big value customers. So yes it was an unfortunate decision, but it was also one that was mandated by the commercial environment which paid the bills.

[Jasen]

you can use / instead of `\` pretty-much anywhere except on the command-line

[phuclv]

@Jasen incorrect. You can use start path/to/my/file on command line without problem, but you can get into trouble if you paste a path with forward slash into many GUI applications

[Jasen]

@LưuVĩnhPhúc so long as path doesn't start with a slash or contain any spaces, you can...

[Aviv Cohn]

Just walking by to say that holy jesus programming in C can get hairy... I miss the cozy world of Python and Java :\