Continuing with Chapter 4

• The open command.
  • You need to include
    • sys/stat.h
    • fcntl.h

  • int open(const char *pathname, int flags);
    int open(const char *pathname, int flags, mode_t mode);
            

  • pathname
    • c style string.
    • or C++stringvar.c_str();
    • if it is a symbolic link, it is followed.
  • Flags:
    • Must include exactly one of:
      • O_RDONLY
      • O_WRONLY
      • O_RDWR
    • In addition there are many other flags, some dependent on what you are doing, the file system, or other influences.
    • The following are a sampling.
      • O_APPEND: before each write, the file pointer is moved to the end of the file. This is problematic with NFS if multiple processes are writing to the same file.
      • O_CLOEXEC: close on exec.
        • Normally when fork is called, the file is open in both processes.
        • Exec follows fork in many situations.
      • O_CREAT : If the file does not exist, create it.
        • This makes use of the mode flags.
          • S_IRWXU 00700 user (file owner) has read, write, and execute permission
          • S_IRUSR 00400 user has read permission
          • S_IWUSR 00200 user has write permission
          • S_IXUSR 00100 user has execute permission
          • S_IRWXG 00070 group has read, write, and execute permission
          • S_IRGRP 00040 group has read permission
          • S_IWGRP 00020 group has write permission
          • S_IXGRP 00010 group has execute permission
          • S_IRWXO 00007 others have read, write, and execute permission
          • S_IROTH 00004 others have read permission
          • S_IWOTH 00002 others have write permission
          • S_IXOTH 00001 others have execute permission
        • And on linux
          • S_ISUID 0004000 set-user-ID bit
          • S_ISGID 0002000 set-group-ID bit (see inode(7)).
          • S_ISVTX 0001000 sticky bit (see inode(7)).
      • O_DIRECT
        • minimize caching.
        • Will degrade performance.
      • O_EXCL :
        • Must be used with O_CREAT
        • Forces creation.
        • Fails if the file already exists.
        • Many special conditions.
      • O_LARGEFILE
        • Allows creation of larger files.
      • O_NOFOLLOW if the last element in the filename is a symbolic link, do not follow it.
      • O_TRUNC: truncate the file if it is opened for writing.
  • Open can produce MANY different error conditions.
• creat
  • Our author claims that this is obsolete, but the man page does not mention this.

  • int creat(const char *pathname, mode_t mode); 

  • Equivalent to

  • fd = open(pathname, O_WONLY | O_CREAT | O_TRUNC, mode);
            

• Read

  • ssize_t read(int fd, void *buf, size_t count);
            

  • fd must be a valid file descriptor
  • buf must be an allocated array of characters at least count characters long.
  • Advances the file offset
  • If count is zero, read may attempt to detect errors.
  • Return
    • ssize_t is defined to be a signed int on linux.
    • the number of bytes read
    • 0 indicates end of file
    • -1 indicates error.
  • This is not a formatted read
    • It reads raw bytes.
    • And the strings read will NOT be null terminated.
    • You will need to do this yourself.

      •  // mostly a book example, sorry
        char buffer[MAX_READ+1];
        ssize_t numRead;
        
        numRead = read(STDIN_FILENO, buffer, MAX_READ);
        if (-1 == numRead) {
            perror("Read Failed");
            exit(0);
        }
        buffer[numRead] = '\n';
        ...
                      

  • Write

    •  ssize_t write(int fd, const void *buf, size_t count); 

    • Attempts to write count bytes from buffer to the file.
    • Returns how many were actually written.
    • Advances the file offset.
      • O_APPEND
    • Writes may be successful but not write the entire buffer
      • File system full
      • Writing to socket or pipe was interrupted
      • In that case, try to write the remaining bytes.
    • There are many errors.
  • Close
    • You should close files when you are finished with them.
    • This frees up kernel resources.