# fpathconf

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           fpathconf, pathconf — get configurable pathname variables
    


## SYNOPSIS



           #include <unistd.h>
    
           long fpathconf(int _fildes_ , int _name_);
           long pathconf(const char *_path_ , int _name_);
    


## DESCRIPTION



           The _fpathconf_() and _pathconf_() functions shall determine the
           current value of a configurable limit or option (_variable_) that is
           associated with a file or directory.
    
           For _pathconf_(), the _path_ argument points to the pathname of a file
           or directory.
    
           For _fpathconf_(), the _fildes_ argument is an open file descriptor.
    
           The _name_ argument represents the variable to be queried relative
           to that file or directory. Implementations shall support all of
           the variables listed in the following table and may support
           others. The variables in the following table come from _< limits.h>_
           or _< unistd.h>_ and the symbolic constants, defined in _< unistd.h>_,
           are the corresponding values used for _name_.
       ┌─────────────────────────────┬──────────────────────────┬──────────────┐
       │          **Variable** │      **Value of** _name_       │ **Requirements** │
       ├─────────────────────────────┼──────────────────────────┼──────────────┤
       │ {FILESIZEBITS}              │ _PC_FILESIZEBITS         │ 4,7          │
       │ {LINK_MAX}                  │ _PC_LINK_MAX             │ 1            │
       │ {MAX_CANON}                 │ _PC_MAX_CANON            │ 2            │
       │ {MAX_INPUT}                 │ _PC_MAX_INPUT            │ 2            │
       │ {NAME_MAX}                  │ _PC_NAME_MAX             │ 3,4          │
       │ {PATH_MAX}                  │ _PC_PATH_MAX             │ 4,5          │
       │ {PIPE_BUF}                  │ _PC_PIPE_BUF             │ 6            │
       │ {POSIX2_SYMLINKS}           │ _PC_2_SYMLINKS           │ 4            │
       │ {POSIX_ALLOC_SIZE_MIN}      │ _PC_ALLOC_SIZE_MIN       │ 10           │
       │ {POSIX_REC_INCR_XFER_SIZE}  │ _PC_REC_INCR_XFER_SIZE   │ 10           │
       │ {POSIX_REC_MAX_XFER_SIZE}   │ _PC_REC_MAX_XFER_SIZE    │ 10           │
       │ {POSIX_REC_MIN_XFER_SIZE}   │ _PC_REC_MIN_XFER_SIZE    │ 10           │
       │ {POSIX_REC_XFER_ALIGN}      │ _PC_REC_XFER_ALIGN       │ 10           │
       │ {SYMLINK_MAX}               │ _PC_SYMLINK_MAX          │ 4,9          │
       │ _POSIX_CHOWN_RESTRICTED     │ _PC_CHOWN_RESTRICTED     │ 7            │
       │ _POSIX_NO_TRUNC             │ _PC_NO_TRUNC             │ 3,4          │
       │ _POSIX_VDISABLE             │ _PC_VDISABLE             │ 2            │
       │ _POSIX_ASYNC_IO             │ _PC_ASYNC_IO             │ 8            │
       │ _POSIX_PRIO_IO              │ _PC_PRIO_IO              │ 8            │
       │ _POSIX_SYNC_IO              │ _PC_SYNC_IO              │ 8            │
       │ _POSIX_TIMESTAMP_RESOLUTION │ _PC_TIMESTAMP_RESOLUTION │ 1            │
       └─────────────────────────────┴──────────────────────────┴──────────────┘
    
       **Requirements**
            1. If _path_ or _fildes_ refers to a directory, the value returned
               shall apply to the directory itself.
    
            2. If _path_ or _fildes_ does not refer to a terminal file, it is
               unspecified whether an implementation supports an association
               of the variable name with the specified file.
    
            3. If _path_ or _fildes_ refers to a directory, the value returned
               shall apply to filenames within the directory.
    
            4. If _path_ or _fildes_ does not refer to a directory, it is
               unspecified whether an implementation supports an association
               of the variable name with the specified file.
    
            5. If _path_ or _fildes_ refers to a directory, the value returned
               shall be the maximum length of a relative pathname that would
               not cross any mount points when the specified directory is the
               working directory.
    
            6. If _path_ refers to a FIFO, or _fildes_ refers to a pipe or FIFO,
               the value returned shall apply to the referenced object. If
               _path_ or _fildes_ refers to a directory, the value returned shall
               apply to any FIFO that exists or can be created within the
               directory. If _path_ or _fildes_ refers to any other type of file,
               it is unspecified whether an implementation supports an
               association of the variable name with the specified file.
    
            7. If _path_ or _fildes_ refers to a directory, the value returned
               shall apply to any files, other than directories, that exist
               or can be created within the directory.
    
            8. If _path_ or _fildes_ refers to a directory, it is unspecified
               whether an implementation supports an association of the
               variable name with the specified file.
    
            9. If _path_ or _fildes_ refers to a directory, the value returned
               shall be the maximum length of the string that a symbolic link
               in that directory can contain.
    
           10. If _path_ or _fildes_ des does not refer to a regular file, it is
               unspecified whether an implementation supports an association
               of the variable name with the specified file. If an
               implementation supports such an association for other than a
               regular file, the value returned is unspecified.
    


## RETURN VALUE



           If _name_ is an invalid value, both _pathconf_() and _fpathconf_() shall
           return -1 and set _errno_ to indicate the error.
    
           If the variable corresponding to _name_ is described in _< limits.h>_
           as a maximum or minimum value and the variable has no limit for
           the path or file descriptor, both _pathconf_() and _fpathconf_() shall
           return -1 without changing _errno_.  Note that indefinite limits do
           not imply infinite limits; see _< limits.h>_.
    
           If the implementation needs to use _path_ to determine the value of
           _name_ and the implementation does not support the association of
           _name_ with the file specified by _path_ , or if the process did not
           have appropriate privileges to query the file specified by _path_ ,
           or _path_ does not exist, _pathconf_() shall return -1 and set _errno_
           to indicate the error.
    
           If the implementation needs to use _fildes_ to determine the value
           of _name_ and the implementation does not support the association of
           _name_ with the file specified by _fildes_ , or if _fildes_ is an invalid
           file descriptor, _fpathconf_() shall return -1 and set _errno_ to
           indicate the error.
    
           Otherwise, _pathconf_() or _fpathconf_() shall return the current
           variable value for the file or directory without changing _errno_.
           The value returned shall not be more restrictive than the
           corresponding value available to the application when it was
           compiled with the implementation's _< limits.h>_ or _< unistd.h>_.
    
           If the variable corresponding to _name_ is dependent on an
           unsupported option, the results are unspecified.
    


## ERRORS



           The _pathconf_() function shall fail if:
    
           **EINVAL** The value of _name_ is not valid.
    
           **EOVERFLOW**
                  The value of _name_ is _PC_TIMESTAMP_RESOLUTION and the
                  resolution is larger than {LONG_MAX}.
    
           The _pathconf_() function may fail if:
    
           **EACCES** Search permission is denied for a component of the path
                  prefix.
    
           **EINVAL** The implementation does not support an association of the
                  variable _name_ with the specified file.
    
           **ELOOP** A loop exists in symbolic links encountered during
                  resolution of the _path_ argument.
    
           **ELOOP** More than {SYMLOOP_MAX} symbolic links were encountered
                  during resolution of the _path_ argument.
    
           **ENAMETOOLONG**
                  The length of a component of a pathname is longer than
                  {NAME_MAX}.
    
           **ENAMETOOLONG**
                  The length of a pathname exceeds {PATH_MAX}, or pathname
                  resolution of a symbolic link produced an intermediate
                  result with a length that exceeds {PATH_MAX}.
    
           **ENOENT** A component of _path_ does not name an existing file or _path_
                  is an empty string.
    
           **ENOTDIR**
                  A component of the path prefix names an existing file that
                  is neither a directory nor a symbolic link to a directory,
                  or the _path_ argument contains at least one non-<slash>
                  character and ends with one or more trailing <slash>
                  characters and the last pathname component names an
                  existing file that is neither a directory nor a symbolic
                  link to a directory.
    
           The _fpathconf_() function shall fail if:
    
           **EINVAL** The value of _name_ is not valid.
    
           **EOVERFLOW**
                  The value of _name_ is _PC_TIMESTAMP_RESOLUTION and the
                  resolution is larger than {LONG_MAX}.
    
           The _fpathconf_() function may fail if:
    
           **EBADF** The _fildes_ argument is not a valid file descriptor.
    
           **EINVAL** The implementation does not support an association of the
                  variable _name_ with the specified file.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           Application developers should check whether an option, such as
           _POSIX_ADVISORY_INFO, is supported prior to obtaining and using
           values for related variables such as {POSIX_ALLOC_SIZE_MIN}.
    


## RATIONALE



           The _pathconf_() function was proposed immediately after the
           _sysconf_() function when it was realized that some configurable
           values may differ across file system, directory, or device
           boundaries.
    
           For example, {NAME_MAX} frequently changes between System V and
           BSD-based file systems; System V uses a maximum of 14, BSD 255. On
           an implementation that provides both types of file systems, an
           application would be forced to limit all pathname components to 14
           bytes, as this would be the value specified in _< limits.h>_ on such
           a system.
    
           Therefore, various useful values can be queried on any pathname or
           file descriptor, assuming that appropriate privileges are in
           place.
    
           The value returned for the variable {PATH_MAX} indicates the
           longest relative pathname that could be given if the specified
           directory is the current working directory of the process. A
           process may not always be able to generate a name that long and
           use it if a subdirectory in the pathname crosses into a more
           restrictive file system. Note that implementations are allowed to
           accept pathnames longer than {PATH_MAX} bytes long, but are not
           allowed to return pathnames longer than this unless the user
           specifies a larger buffer using a function that provides a buffer
           size argument.
    
           The value returned for the variable _POSIX_CHOWN_RESTRICTED also
           applies to directories that do not have file systems mounted on
           them. The value may change when crossing a mount point, so
           applications that need to know should check for each directory.
           (An even easier check is to try the _chown_() function and look for
           an error in case it happens.)
    
           Unlike the values returned by _sysconf_(), the pathname-oriented
           variables are potentially more volatile and are not guaranteed to
           remain constant throughout the lifetime of the process.  For
           example, in between two calls to _pathconf_(), the file system in
           question may have been unmounted and remounted with different
           characteristics.
    
           Also note that most of the errors are optional. If one of the
           variables always has the same value on an implementation, the
           implementation need not look at _path_ or _fildes_ to return that
           value and is, therefore, not required to detect any of the errors
           except the meaning of **[EINVAL]** that indicates that the value of
           _name_ is not valid for that variable, and the **[EOVERFLOW]** error
           that indicates the value to be returned is larger than {LONG_MAX}.
    
           If the value of any of the limits is unspecified (logically
           infinite), they will not be defined in _< limits.h>_ and the
           _pathconf_() and _fpathconf_() functions return -1 without changing
           _errno_.  This can be distinguished from the case of giving an
           unrecognized _name_ argument because _errno_ is set to **[EINVAL]** in
           this case.
    
           Since -1 is a valid return value for the _pathconf_() and
           _fpathconf_() functions, applications should set _errno_ to zero
           before calling them and check _errno_ only if the return value is
           -1.
    
           For the case of {SYMLINK_MAX}, since both _pathconf_() and _open_()
           follow symbolic links, there is no way that _path_ or _fildes_ could
           refer to a symbolic link.
    
           It was the intention of IEEE Std 1003.1d‐1999 that the following
           variables:
    
                  {POSIX_ALLOC_SIZE_MIN} {POSIX_REC_INCR_XFER_SIZE}
                  {POSIX_REC_MAX_XFER_SIZE} {POSIX_REC_MIN_XFER_SIZE}
                  {POSIX_REC_XFER_ALIGN}
    
           only applied to regular files, but Note 10 also permits
           implementation of the advisory semantics on other file types
           unique to an implementation (for example, a character special
           device).
    
           The **[EOVERFLOW]** error for _PC_TIMESTAMP_RESOLUTION cannot occur on
           POSIX-compliant file systems because POSIX requires a timestamp
           resolution no larger than one second. Even on 32-bit systems, this
           can be represented without overflow.
    


## FUTURE DIRECTIONS



           None.
    


* * *