open(), open64()

Open a file

Synopsis:

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open( const char * path,
          int oflag, 
          ... );

int open64( const char * path, 
            int oflag, 
            ... );

The open() and open64() functions open the file named by path, creating an open file description that refers to the file, and a file descriptor that refers to the file description. The file status flags and the file access modes of the open file description are set according to the value of oflag.

Advisory locks that may have been set by the fcntl() function are ignored.

The open file description created is new, and therefore not shared with any other process in the system.

The value of oflag is constructed by the bitwise ORing of values from the following list, defined in the <fcntl.h> header file. Applications must specify exactly one of the first three values (file access modes) below in the value of oflag:

O_RDONLY: Open for reading only.
O_RDWR: Open for reading and writing. Opening a FIFO for read-write is unsupported.
O_WRONLY: Open for writing only.

Any combination of the remaining flags may be specified in the value of oflag:

O_APPEND

If set, the file offset is set to the end of the file prior to each write.

O_CREAT

This option requires a third argument, mode, which is of type mode_t. If the file exists, this flag has no effect, except in combination with O_EXCL as noted below.

Otherwise, the file is created; the file's user ID is set to the effective user ID of the process; the group ID is set to the effective group ID of the process or the group ID of the file's parent directory (see chmod()).

The permission bits, as defined in <sys/stat.h>, are set to the value of mode, except those bits set in the process's file mode creation mask (see the function umask() for details). Bits set in mode other than the file permission bits (the file type bits) are ignored. The mode argument doesn't affect whether the file is opened for reading, for writing, or for both.

O_DSYNC

If set, this flag affects subsequent I/O calls. If set, each call to write() waits until all data is successfully transferred to the storage device such that it is readable on any subsequent open of the file (even one that follows a system failure) in the absence of a failure of the physical storage medium. If the physical storage medium implements a non-write-through cache, then a system failure may be interpreted as a failure of the physical storage medium, and data may not be readable even if this flag is set and the write() indicates that it succeeded.

O_EXCL

If O_EXCL and O_CREAT are set, open() fails if the file exists. The check for the existence of the file and the creation of the file if it doesn't exist is atomic with respect to other processes attempting the same operation with the same filename. Specifying O_EXCL without O_CREAT has no effect.

O_LARGEFILE

Allow the file offset to be 64-bits long.

O_NOCTTY

If set, and path identifies a terminal device, the open() function doesn't cause the terminal device to become the controlling terminal for the process.

O_NONBLOCK

When opening a FIFO with O_RDONLY or O_WRONLY set:

If O_NONBLOCK is set:

Calling open() for reading-only returns without delay. Calling open() for writing-only returns an error if no process currently has the FIFO open for reading.

If O_NONBLOCK is clear:

Calling open() for reading-only blocks until a process opens the file for writing. Calling open() for writing-only blocks until a process opens the file for reading.
When opening a block special or character special file that supports nonblocking opens:

If O_NONBLOCK is set:

The open() function returns without waiting for the device to be ready or available. Subsequent behavior of the device is device-specific.

If O_NONBLOCK is clear:

The open() function waits until the device is ready or available before returning. The definition of when a device is ready is device-specific.
Otherwise, the behavior of O_NONBLOCK is unspecified.

O_RSYNC

Read I/O operations on the file descriptor complete at the same level of integrity as specified by the O_DSYNC and O_SYNC flags.

O_SYNC

If set, this flag affects subsequent I/O calls. Each call to read() or write() is complete only when both the data has been successfully transferred (either read or written) and all file system information relevant to that I/O operation (including that required to retrieve said data) is successfully transferred, including file update and/or access times, and so on. See the discussion of a successful data transfer in O_DSYNC, above.

O_TRUNC

If the file exists and is a regular file, and the file is successfully opened O_WRONLY or O_RDWR, the file length is truncated to zero and the mode and owner are left unchanged. O_TRUNC has no effect on FIFO or block or character special files or directories. Using O_TRUNC with O_RDONLY has no effect.

Returns:

A nonnegative integer representing the lowest numbered unused file descriptor. On a file capable of seeking, the file offset is set to the beginning of the file. Otherwise, -1 is returned (errno is set).

In QNX, the returned file descriptor is the same as the connection ID (or coid) used by the QNX-specific functions.

Errors:

EACCES: Search permission is denied on a component of the path prefix, or the file exists and the permissions specified by oflag are denied, or the file doesn't exist and write permission is denied for the parent directory of the file to be created.
EBADFSYS: While attempting to open the named file, either the file itself or a component of the path prefix was found to be corrupted. A system failure -- from which no automatic recovery is possible -- occurred while the file was being written to, or while the directory was being updated. You'll need to invoke appropriate systems-administration procedures to correct this situation before proceeding.
EBUSY: Sharing mode (share) was denied due to a conflicting open (see sopen()), or the value of oflag is invalid.
EEXIST: The O_CREAT and O_EXCL flags are set, and the named file exists.
EINTR: The open() operation was interrupted by a signal.
EINVAL: The requested synchronized modes (O_SYNC, O_DSYNC, O_RSYNC) aren't supported.
EISDIR: The named file is a directory, and the oflag argument specifies write-only or read/write access.
ELOOP: Too many levels of symbolic links or prefixes.
EMFILE: Too many file descriptors are currently in use by this process.
ENAMETOOLONG: The length of the path string exceeds PATH_MAX, or a pathname component is longer than NAME_MAX.
ENFILE: Too many files are currently open in the system.
ENOENT: The O_CREAT flag isn't set, and the named file doesn't exist; or O_CREAT is set and either the path prefix doesn't exist, or the path argument points to an empty string.
ENOSPC: The directory or filesystem that would contain the new file cannot be extended.
ENOSYS: The open() function isn't implemented for the filesystem specified in path.
ENOTDIR: A component of the path prefix isn't a directory.
ENXIO: The O_NONBLOCK flag is set, the named file is a FIFO, O_WRONLY is set, no process has the file open for reading, or the media associated with the file has been removed (e.g. CD, floppy).
EROFS: The named file resides on a read-only filesystem and either O_WRONLY, O_RDWR, O_CREAT (if the file doesn't exist), or O_TRUNC is set in the oflag argument.

Examples:

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>

int main( void )
  {
    int fd;

    /* open a file for output              */
    /* replace existing file if it exists  */
    /* with read/write perms for owner     */

    fd = open( "myfile.dat",
        O_WRONLY | O_CREAT | O_TRUNC,
        S_IRUSR | S_IWUSR );

    /* read a file that is assumed to exist */

    fd = open( "myfile.dat", O_RDONLY );

    /* append to the end of an existing file  */
    /* write a new file if file doesn't exist */
    /* with full read/write permissions       */

    fd = open( "myfile.dat",
        O_WRONLY | O_CREAT | O_APPEND,
        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP
        | S_IROTH | S_IWOTH );
    return EXIT_SUCCESS;
  }

Classification:

open() is POSIX 1003.1; open64() is for large-file support

Safety:
Cancellation point	Yes
Interrupt handler	No
Signal handler	Yes
Thread	Yes

Caveats:

The open() function includes POSIX 1003.1-1996 and QNX extensions.