Files and I/O

At the high level, we operate on streams: unformatted sequences of bytes, with a position. Streams in C a represented by a pointer to a FILE data structure, which are returned by functions such as fopen().

Three predefined streams are opened implicitly when the program is executed:

• FILE *stdin — normal source of input
• FILE *stdout — normal source of output
• FILE *stderr — diagnostics and errors

High level operations on streams are buffered in user memory, which means that printing, sleeping, and then printing again may actually cause everything to be printed out at once. However, low level operations on file descriptors are immediate.

C also gives us several different functions to read and write to files:

// character oriented
int fputc(int c, FILE *fp ); // rtn c or EOF on err
int fputs(const char *s, FILE *fp ); // rtn > 0 or EOF
int fgetc(FILE * fp );
char *fgets(char *buf, int n, FILE *fp );

// block oriented
size_t fread(void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);
size_t fwrite(const void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);

// formatted
int fprintf(FILE *restrict stream, const char *restrict format, ...);
int fscanf(FILE *restrict stream, const char *restrict format, ... );

The file stream also includes a pointer to the current position in the file. These below functions can help with positioning the pointer:

int fseek(FILE *stream, long int offset, int whence);
long int ftell(FILE *stream);
void rewind(FILE *stream);

For fseek(), the offset is interpreted based on the whence argument, which can be set the SEEK_SET (from beginning), SEEK_CUR, or SEEK_END (from end).

The high level C functions presented above are built upon a low level file I/O system call interface:

int open(const char *filename, int flags, mode_t mode);
int creat(const char *filename, mode_t mode);
int close(int filedes);
ssize_t read(int filedes, void *buffer, size_t maxsize);
ssize_t write(int filedes, const void *buffer, size_t size);
off_t lseek(int filedes, off_t offset, int whence);
int dup(int oldfd);
int dup2(int oldfd, int newfd);

Opening a file with open() returns a file descriptor, an integer that represents an open file. STDIN_FILENO, STDOUT_FILENO, and STDERR_FILENO are pre-opened standard descriptors that can be used as macros.

File descriptors are indices into a file descriptor table (FDT). Each process has its own FDT stored in kernel memory, where each entry points to a file description, which is a data structure inside of the kernel that store information about where to find the data on disk and the current position within the file.

We have a hostname (e.g. www.eecs.berkeley.edu) that resolves into some kind of IP address (128.32.244.172), and then finally a port number that identifies a socket. Port numbers are allocated as follows:

• 0-1023 are “well-known” or “system” ports that require superuser privileges
• 1024-49151 are “registered” ports assigned by IANA for specific services
• 49152-65535 are “dynamic” or “private”, and are automatically allocated as “ephemeral ports”

To setup a connection over TCP/IP, the client side must first request a connection to the server via a server socket. If the server accepts, then it will create a new socket to handle communication with the client. A 5-tuple identifies each connection:

1. Source IP address
2. Destination IP address
3. Source port number
4. Destination port number
5. Protocol (always TCP here)