read()

Updated: May 06, 2022

Read bytes from a file

Synopsis:

#include <unistd.h>

ssize_t read( int filedes,
              void* buf,
              size_t nbytes );

Arguments:

filedes
The descriptor of the file that you want to read from.
buf
A pointer to a buffer where the function can store the data that it reads.
nbytes
The number of bytes that you want to read. If nbytes is zero, read() returns zero and has no other effect. If nbytes is greater than SSIZE_MAX (see <limits.h>), the function returns -1 and sets errno to EOVERFLOW.

Library:

libc

Use the -l c option to qcc to link against this library. This library is usually included automatically.

Description:

The read() function attempts to read nbytes bytes from the file associated with the open file descriptor, filedes, into the buffer pointed to by buf.

On a regular file or other file capable of seeking, read() starts at a position in the file given by the file offset associated with filedes. Before successfully returning from read(), the file offset is incremented by the number of bytes actually read.

Note: The read() call ignores advisory locks that you may have set with fcntl().

On a file not capable of seeking, read() starts at the current position.

When read() returns successfully, its return value is the number of bytes actually read and placed in the buffer. POSIX requires that this number never be greater than nbytes, but that depends on the underlying resource manager. The number may be less than nbytes if, for example:

If read() is interrupted by a signal before it reads any data, it returns -1 and sets errno to EINTR. However, if read() is interrupted by a signal after it has successfully read some data, it returns the number of bytes read.

No data is transferred past the current end of file. If the starting position is at or after the end of file, read() returns zero. If the file is a device special file, the result of subsequent calls to read() will work, based on the then-current state of the device (that is, the end of file is transitory).

When attempting to read from an empty pipe or FIFO:

  1. If no process has the pipe open for writing, read() returns 0 to indicate the end of file.
  2. If a process has the pipe open for writing, and O_NONBLOCK is set, read() returns -1, and errno is set to EAGAIN.
  3. If a process has the pipe open for writing, and O_NONBLOCK is clear, read() blocks until some data is written, or the pipe is closed by all processes that had opened it for writing.

When attempting to read from a file (other than a pipe or FIFO) that supports nonblocking reads and has no data currently available:

  1. If O_NONBLOCK is set, read() returns -1, and errno is set to EAGAIN.
  2. If O_NONBLOCK is clear, read() blocks until some data is available.
  3. The O_NONBLOCK flag has no effect if some data is available.

If you call read() on a portion of a file, prior to the end of file, that hasn't been written, it stores bytes with the value zero in buffer.

If read() succeeds, the st_atime field of the file is marked for update.

Returns:

The number of bytes actually read, or -1 (errno is set).

Errors:

EAGAIN
The O_NONBLOCK flag is set for the file descriptor, and the process would be delayed in the read operation.
EBADF
The file descriptor, filedes, isn't a valid file descriptor open for reading.
EINTR
The read operation was interrupted by a signal, and either no data was transferred, or the resource manager responsible for that file doesn't report partial transfers.
EIO
One of the following:
  • A physical I/O error occurred (for example, a bad block on a disk). The precise meaning is device-dependent.
  • The filesystem resides on a removable media device, and the media has been forcibly removed.
EISDIR
The file descriptor is for a directory.
ENOSYS
The read() function isn't implemented for the filesystem specified by filedes.
EOVERFLOW
An attempt was made to read a number of bytes that exceeds the allowable limit.

Examples:

#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

int main( void )
{
    int fd;
    int size_read;
    char buffer[80];

    /* Open a file for input */
    fd = open( "myfile.dat", O_RDONLY );

    /* Read the text */
    size_read = read( fd, buffer,
                      sizeof( buffer ) );

    /* Test for error */
    if( size_read == -1 ) {
        perror( "Error reading myfile.dat" );
        return EXIT_FAILURE;
    }

    /* Close the file */
    close( fd );
    
    return EXIT_SUCCESS;
}

Classification:

POSIX 1003.1 XSI

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