write() — Write data on a file or socket

#define _XOPEN_SOURCE_EXTENDED 1
#include <unistd.h>

ssize_t write(int fs, const void *buf, ssize_t N);

#define _OE_SOCKETS
#include <unistd.h>

ssize_t write(int fs, const void *buf, ssize_t N);

• If write() has not written any data yet, it returns -1 and sets errno to EINTR.
• If write() has successfully written some data, it returns the number of bytes it wrote before it was interrupted.

• A pipe has no associated file offset, so every write appends to the end of the pipe.
• If N is less than or equal to PIPE_BUF, the output is not interleaved with data written by other processes that are writing to the same pipe. If N is greater than PIPE_BUF bytes, the output can be interleaved with other data (regardless of the setting of O_NONBLOCK, which is defined in the fcntl.h header file). A write to a pipe never returns with errno set to EINTR if it has transferred any data.
• If O_NONBLOCK (defined in the fcntl.h header file) is not set, write() may block process execution until normal completion.
• If O_NONBLOCK is set, write() does not block process execution. If N is less than or equal to PIPE_BUF, write() succeeds completely and returns the value of N, or else it writes nothing, sets errno to EAGAIN, and returns -1. If N is greater than PIPE_BUF, write() writes as many bytes as it can and returns this number as its result, or else it writes nothing, sets errno to EAGAIN, and returns -1.

• If O_NONBLOCK is not set, write() blocks until the data can be written.
• If O_NONBLOCK is set, write() does not block the process. If some data can be written without blocking the process, write() writes what it can and returns the number of bytes written. Otherwise, it sets errno to EAGAIN and returns -1.

• The process is attempting to write to its controlling terminal and TOSTOP is set as a terminal attribute.
• The process is running in a background process group and the SIGTTOU signal is not blocked or ignored.
• The process is not an orphan.

Parameter

Description

fs

The file or socket descriptor.

buf

The pointer to the buffer holding the data to be written.

N

The length in bytes of the buffer pointed to by the buf parameter.

• Unless FNDELAY or O_NONBLOCK is set, write() blocks until the socket is ready to accept data.
• If FNDELAY is set, write() returns 0.
• If O_NONBLOCK is set, write() does not block the process. If some data can be written without blocking the process, write() writes what it can and returns the number of bytes written. Otherwise, it sets the error code to EAGAIN and returns -1.

Error Code

Description

EAGAIN

Resources temporarily unavailable. Subsequent requests may complete normally.

EBADF

fs is not a valid file or socket descriptor.

ECONNRESET

A connection was forcibly closed by a peer.

EDESTADDRREQ

The socket is not connection-oriented and no peer address is set.

EFAULT

Using the buf and N parameters would result in an attempt to access storage outside the caller's address space.

EFBIG

Writing to the output file would exceed the maximum file size supported by the implementation.

An attempt was made to write a file that exceeds the system established maximum file size or the process's file size limit.

The file is a regular file, nbyte is greater than 0 and the starting position is greater than or equal to the offset maximum established in the open file description associated with fields.

EINTR

write() was interrupted by a signal before it had written any output.

EINVAL

The request is invalid or not supported. The STREAM or multiplexer referenced by fs is linked (directly or indirectly) downstream from a multiplexer.

EIO

The process is in a background process group and is attempting to write to its controlling terminal, but TOSTOP (defined in the termios.h header file) is set, the process is neither ignoring nor blocking SIGTTOU signals, and the process group of the process is orphaned. An I/O error occurred.

EMSGSIZE

The message was too big to be sent as a single datagram.

ENOBUFS

Buffer space is not available to send the message.

ENOSPC

There is no available space left on the output device.

ENOTCONN

The socket is not connected.

ENXIO

A hang-up occurred on the STREAM being written to.

EPIPE

write() is trying to write to a pipe that is not open for reading by any other process. This error also generates a SIGPIPE signal. For a connected stream socket the connection to the peer socket has been lost.

ERANGE

The transfer request size was outside the range supported by the STREAMS file associated with fs.

EWOULDBLOCK

socket is in nonblocking mode and no data buffers are available or the SO_SNDTIMEO timeout value was reached before buffers became available.

⁄* CELEBW35

   This example writes a certain amount of bytes to a file, using write().

 *⁄
#define _POSIX_SOURCE
#include <fcntl.h>
#include <sys⁄stat.h>
#include <sys⁄types.h>
#include <unistd.h>
#undef _POSIX_SOURCE
#include <stdlib.h>
#include <stdio.h>

#define mega_string_len 1000000

main() {
  char *mega_string;
  int  fd, ret;
  char fn[]="write.file";

  if ((mega_string = (char*) malloc(mega_string_len)) == NULL)
    perror("malloc() error");
  else if ((fd = creat(fn, S_IWUSR)) < 0)
    perror("creat() error");
  else {
    memset(mega_string, '0', mega_string_len);
    if ((ret = write(fd, mega_string, mega_string_len)) == -1)
      perror("write() error");
    else printf("write() wrote %d bytes\n", ret);
    close(fd);
    unlink(fn);
  }
}

write() wrote 1000000 bytes