filesystems

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

struct inode {
  uint16_t  i_mode;     // bit vector of file 
                        //   type and permissions
  uint8_t   i_nlink;    // number of references 
                        //   to file
  uint8_t   i_uid;      // owner
  uint8_t   i_gid;      // group of owner
  uint8_t   i_size0;    // most significant byte
                        //  of size
  uint16_t  i_size1;    // lower two bytes of size 
                        //  (size is encoded in a 
                        //  three-byte number)
  uint16_t  i_addr[8];  // device addresses 
                        //   constituting file
  uint16_t  i_atime[2]; // access time
  uint16_t  i_mtime[2]; // modify time
};

1
2
3
4

#include <fcntl.h >

int creat(const char *path, mode_t mode);
                  // Returns: file descriptor opened for write-only if OK, −1 on error

1

open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);

1
2
3
4
5
6

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

int open(char *filename, int flags, mode_t mode); 
                               // returns: new file descriptor or -1 on error

1
2
3
4
5

// Create the file
int fd = open("myfile.txt", O_WRONLY | O_CREAT | O_EXCL, 0644);

// Close the file now that we are done with it
close(fd);

1
2
3
4

#include <unistd.h>

int close(int fd);
                                 // return 0 if ok, -1 on error

1
2
3
4

#include <unistd.h>

off_t lseek(int fd, off_t offset, int whence);
                            // return new file offset if OK, -1 on error

1
2
3
4

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
                            // Returns: number of bytes read if OK, 0 on EOF, - 1 on error

1
2
3
4

#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
                    // Returns: number of bytes written if OK, - 1 on error

1
2
3
4
5
6

#include <unistd.h>
#include <sys/stat.h>

int stat(const char *filename , struct stat *buf);
int fstat(int fd , struct stat *buf);
                                    // Returns: 0 if OK, - 1 on error

1
2
3
4
5
6
7
8

struct stat st;
lstat(path, &st);
if (S_ISREG(st.st_mode)) {
	...
}
else if (S_ISDIR(st.st_mode)) {
	...
}

1
2
3
4
5

#include <unistd.h>

int dup(int fd);
int dup2(int oldfd, int newfd);
                        // Returns: nonnegative descriptor if OK, -1 on error

1
2
3

#include <dirent.h>
DIR *opendir(const char *pathname);
                         // return: pointer if OK, NULL on error

1
2
3
4

#include <dirent.h>

struct dirent *readdir(DIR *dp);
            // Returns: pointer if OK, NULL at end of directory or error

1
2
3
4

#include <dirent.h>

int closedir(DIR *dp);
                      // Returns: 0 if OK, −1 on error

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

/**
 * File: touch.c
 * --------------
 * This program shows an example of creating a new file with a given
 * name.  Similar to the `touch` unix command, it creates the file if it
 * doesn't exist. But in this case, if it does exist, it throws an error.
 */

#include <fcntl.h>    // for open
#include <unistd.h>   // for read, write, close
#include <stdio.h>
#include <errno.h>

static const int kDefaultPermissions = 0644; // number equivalent of "rw-r--r--"

int main(int argc, char *argv[]) {
  // Create the file
  int fd = open(argv[1], O_WRONLY | O_CREAT | O_EXCL, kDefaultPermissions);

  // If an error occured, print out more information
  if (fd == -1) {
    printf("There was a problem creating \"%s\"!\n", argv[1]);

    if (errno == EEXIST) {
      printf("The file already exists.\n");
    } else {
      printf("Unknown errno: %d\n", errno);
    }
    return -1;
  }

  // Close the file now that we are done with it
  close(fd);
  return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

/**
 * File: copy.c
 * --------------
 * This program is the starter code for an example that shows how we can
 * make a copy of a specified file into another specified file, similar to the
 * `cp` unix command.
 */

#include <stdbool.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <error.h>

// Constants for different error codes we may return
static const int kWrongArgumentCount = 1;
static const int kSourceFileNonExistent = 2;
static const int kDestinationFileOpenFailure = 4;
static const int kReadFailure = 8;
static const int kWriteFailure = 16;

// The permissions to set if the destination file doesn't exist
static const int kDefaultPermissions = 0644; // number equivalent of "rw-r--r--"

// The number of bytes we copy at once from source to destination
static const int kCopyIncrement = 1024;


/* This function copies the contents of the source file into the destination
 * file in chunks until the entire file is copied.  If an error occurred
 * while reading or writing, this function throws an error.
 */
void copyContents(int sourceFD, int destinationFD) {
  char buffer[kCopyIncrement];
  while (true) {
    // Read the next chunk of bytes from the source
    ssize_t bytesRead = read(sourceFD, buffer, sizeof(buffer));
    if (bytesRead == 0) break;
    if (bytesRead == -1) {
      error(kReadFailure, 0, "lost access to file while reading.");
    }

    // Write that chunk to the destination
    size_t bytesWritten = 0;
    while (bytesWritten < bytesRead) {
      ssize_t count = write(destinationFD, buffer + bytesWritten, bytesRead - bytesWritten);
      if (count == -1) {
        error(kWriteFailure, 0, "lost access to file while writing.");
      }
      bytesWritten += count;
    }
  }
}


int main(int argc, char *argv[]) {
  // Ensure the user specified 3 arguments
  if (argc != 3) {
    error(kWrongArgumentCount, 0, "%s <source-file> <destination-file>.", argv[0]);
  }
  
  // Open the specified source file for reading
  int sourceFD = open(argv[1], O_RDONLY);
  if (sourceFD == -1) {
    error(kSourceFileNonExistent, 0, "%s: source file could not be opened.", argv[1]);
  }
  
  // Open the specified destination file for writing, creating if nonexistent
  int destinationFD = open(argv[2], O_WRONLY | O_CREAT | O_EXCL, kDefaultPermissions);
  if (destinationFD == -1) {
    if (errno == EEXIST) {
      error(kDestinationFileOpenFailure, 0, "%s: destination file already exists.", argv[2]);
    } else {
      error(kDestinationFileOpenFailure, 0, "%s: destination file could not be created.", argv[2]);
    }
  }

  copyContents(sourceFD, destinationFD);

  // Close the source file
  if (close(sourceFD) == -1) {
    error(0, 0, "%s: had trouble closing file.", argv[1]);
  }

  // Close the destination file
  if (close(destinationFD) == -1) {
    error(0, 0, "%s: had trouble closing file.", argv[2]);
  }

  return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

/**
 * File: copy_extended.c
 * --------------
 * This program is an implementation of an extended copy command that shows how we can
 * make a copy of a specified file into multiple other specified files, as well
 * as printing the contents to the terminal.
 */

#include <stdbool.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <error.h>

// Constants for different error codes we may return
static const int kWrongArgumentCount = 1;
static const int kSourceFileNonExistent = 2;
static const int kDestinationFileOpenFailure = 4;
static const int kReadFailure = 8;
static const int kWriteFailure = 16;

// The permissions to set if the destination file doesn't exist
static const int kDefaultPermissions = 0644; // number equivalent of "rw-r--r--"

// The number of bytes we copy at once from source to destination
static const int kCopyIncrement = 1024;


/* This function copies the contents of the source file into each destination
 * file in chunks until the entire file is copied.  If an error occurred
 * while reading or writing, this function throws an error.
 */
void copyContents(int sourceFD, int destinationFDs[], int numDestinationFDs) {
  char buffer[kCopyIncrement];
  while (true) {
    // Read the next chunk of bytes from the source
    ssize_t bytesRead = read(sourceFD, buffer, sizeof(buffer));
    if (bytesRead == 0) break;
    if (bytesRead == -1) {
      error(kReadFailure, 0, "lost access to file while reading.");
    }

    // Write that chunk to every destination
    for (size_t i = 0; i < numDestinationFDs; i++) {
      size_t bytesWritten = 0;
      while (bytesWritten < bytesRead) {
        ssize_t count = write(destinationFDs[i], buffer + bytesWritten, bytesRead - bytesWritten);
        if (count == -1) {
          error(kWriteFailure, 0, "lost access to file while writing.");
        }
        bytesWritten += count;
      }
    }
  }
}

int main(int argc, char *argv[]) {
  // Ensure the user specified 3 arguments
  if (argc < 3) {
    error(kWrongArgumentCount, 0, "%s <source-file> <destination-file1> <destination-file2> ... .", argv[0]);
  }
  
  // Open the specified source file for reading
  int sourceFD = open(argv[1], O_RDONLY);
  if (sourceFD == -1) {
    error(kSourceFileNonExistent, 0, "%s: source file could not be opened.", argv[1]);
  }
  
  // Open the specified destination file(s) for writing, creating if nonexistent
  int destinationFDs[argc - 1];

  // Include the terminal (STDOUT) as the first "file" so it's also printed
  destinationFDs[0] = STDOUT_FILENO;

  for (size_t i = 2; i < argc; i++) {
    destinationFDs[i - 1] = open(argv[i], O_WRONLY | O_CREAT | O_EXCL, kDefaultPermissions);
    if (destinationFDs[i - 1] == -1) {
      if (errno == EEXIST) {
        error(kDestinationFileOpenFailure, 0, "%s: destination file already exists.", argv[2]);
      } else {
        error(kDestinationFileOpenFailure, 0, "%s: destination file could not be created.", argv[2]);
      }
    }
  }

  copyContents(sourceFD, destinationFDs, argc - 1);

  // Close the source file
  if (close(sourceFD) == -1) {
    error(0, 0, "%s: had trouble closing file.", argv[1]);
  }

  // Close the destination files
  for (size_t i = 1; i < argc - 1; i++) {
    if (close(destinationFDs[i]) == -1) {
      error(0, 0, "%s: had trouble closing file.", argv[2 + i]);
    }
  }

  return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

/**
 * File: list.c
 * ------------
 * The program is designed to emulate a very small subset of ls's functionality.
 * Specifically, I require that all items to be listed are directories, and I essentially
 * implement the executable to be the equivalent of "ls -lUa", save for the fact that I don't
 * follow hard links.
 *
 * This example is presented to be clear that many shell commands like ls, pwd, etc, aren't technically
 * shell commands, but standalone executables that just happen to come installed with the OS.  It's
 * hardly intended to be exhaustive (the real ls has scores of different options).
 */

#include <stdbool.h>   // for bool
#include <stddef.h>    // for NULL
#include <stdio.h>     // for printf
#include <sys/types.h> // for mode_t, uid_t, etc.
#include <sys/stat.h>  // for lstat
#include <dirent.h>    // for DIR, opendir, etc
#include <string.h>    // for strlen, strcpy
#include <pwd.h>       // for getpwuid
#include <grp.h>       // for getgrgid
#include <time.h>      // for time, localtime, etc
#include <unistd.h>    // for readlink

static inline void updatePermissionsBit(bool flag, char permissions[], size_t column, char ch) {
  if (flag) permissions[column] = ch;
}

static const size_t kNumPermissionColumns = 10;
static const char kPermissionChars[] = {'r', 'w', 'x'};
static const size_t kNumPermissionChars = sizeof(kPermissionChars);
static const mode_t kPermissionFlags[] = { 
  S_IRUSR, S_IWUSR, S_IXUSR, // user flags
  S_IRGRP, S_IWGRP, S_IXGRP, // group flags
  S_IROTH, S_IWOTH, S_IXOTH  // everyone (other) flags
};
static const size_t kNumPermissionFlags = sizeof(kPermissionFlags)/sizeof(kPermissionFlags[0]);
static void listPermissions(mode_t mode) {
  char permissions[kNumPermissionColumns + 1];
  memset(permissions, '-', sizeof(permissions));
  permissions[kNumPermissionColumns] = '\0';
  updatePermissionsBit(S_ISDIR(mode), permissions, 0, 'd');
  updatePermissionsBit(S_ISLNK(mode), permissions, 0, 'l');
  for (size_t i = 0; i < kNumPermissionFlags; i++) {
    updatePermissionsBit(mode & kPermissionFlags[i], permissions, i + 1, 
			 kPermissionChars[i % kNumPermissionChars]);
  }
  
  printf("%s ", permissions);
}

static void listHardlinkCount(nlink_t count) {
  if (count < 10) printf(" %zu ", count);
  else printf(">9 "); // invention of my own so I don't have to worry about column width
}

static void listUser(uid_t uid) {
  struct passwd *pw = getpwuid(uid); // first call dynamically allocates memory behind scenes, but can't easily be freed :(
  pw == NULL ? printf("%8u ", uid) : printf("%-8s ", pw->pw_name);
}

static void listGroup(gid_t gid) {
  struct group *gr = getgrgid(gid); // first call dynamically allocates memory behind scenes, but can't easily be freed :(
  const char *group = gr == NULL ? "unknown" : gr->gr_name;
  printf("%-8s ", group);
}

static void listSize(off_t size) {
  printf("%6zu ", size);
}

static void listModifiedTime(time_t mtime) {
  time_t now;
  time(&now);
  struct tm *currentTime = localtime(&now); // return value not dynamically allocated, invalidated by next call to localtime!
  char currentYearString[8];
  strftime(currentYearString, sizeof(currentYearString), "%Y", currentTime);
  struct tm *modifiedTime = localtime(&mtime);
  char modifiedTimeString[32];
  strftime(modifiedTimeString, sizeof(modifiedTimeString), "%Y", modifiedTime);
  bool sameYear = strcmp(currentYearString, modifiedTimeString) == 0;
  const char *format = sameYear ? "%b %d %H:%M" : "%b %d  %Y";
  strftime(modifiedTimeString, sizeof(modifiedTimeString), format, modifiedTime);
  printf("%s ", modifiedTimeString);
}

static void listName(const char *name, const struct stat *st, bool link, const char *path) {
  printf("%s", name);
  if (!link) return;
  char target[st->st_size + 1];
  readlink(path, target, sizeof(target));
  target[st->st_size] = '\0'; // readlink doesn't put down '\0' char, drop it in ourselves
  printf(" -> %s", target);
}

static void listEntry(const char *name, const struct stat *st, bool link, const char *path) {
  listPermissions(st->st_mode);
  listHardlinkCount(st->st_nlink);
  listUser(st->st_uid);
  listGroup(st->st_gid);
  listSize(st->st_size);
  listModifiedTime(st->st_mtime);
  listName(name, st, link, path);
  printf("\n");
}

static const size_t kMaxPath = 1024;
static void listDirectory(const char *name, size_t length, const struct stat *st, bool multiple) {
  char path[kMaxPath + 1];
  strcpy(path, name);
  if (multiple) printf("%s:\n", name);
  DIR *dir = opendir(path);
  strcpy(path + length, "/");
  while (true) {
    struct dirent *de = readdir(dir);
    if (de == NULL) break;
    strcpy(path + length + 1, de->d_name);
    struct stat st;
    lstat(path, &st);
    listEntry(de->d_name, &st, S_ISLNK(st.st_mode), path);
  }
  closedir(dir);
}

static void list(const char *name, size_t length, bool multiple) {
  if (strlen(name) == 0 || name[0] == '.') return; // ignore what are normally hidden files and directories
  struct stat st;
  if (lstat(name, &st) == -1) return;
  if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
    listEntry(name, &st, S_ISLNK(st.st_mode), name);
  } else if (S_ISDIR(st.st_mode)) {
    listDirectory(name, length, &st, multiple);
  }
}

static void listEntries(const char *entries[], size_t numEntries) {
  bool multiple = numEntries > 1;
  for (size_t i = 0; i < numEntries; i++) {
    size_t length = strlen(entries[i]);
    if (length <= kMaxPath) {
      list(entries[i], length, multiple);
    } // otherwise ignore
  }
}

static const char *kDefaultEntries[] = {".", NULL};
int main(int argc, char *argv[]) {
  const char **entries = argc == 1 ? kDefaultEntries : (const char **)(argv + 1);
  size_t numEntries = argc == 1 ? 1 : argc - 1;
  listEntries(entries, numEntries);
  return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

/**
 * File: search.c
 * --------------
 * Designed to emulate the properties of the GNU find shell program.
 * The built-in version of find is much more robust than what we provide here.
 *
 * To help focus on the file system directives, I omit most error checking from 
 * this particular implementation.
 */

#include <stdbool.h>   // for bool
#include <stddef.h>    // for size_t
#include <stdio.h>     // for printf, fprintf, etc.
#include <stdlib.h>    // for exit
#include <stdarg.h>    // for va_list, etc.
#include <sys/stat.h>  // for stat
#include <string.h>    // for strlen, strcpy, strcmp
#include <dirent.h>    // for DIR, struct dirent

static const size_t kMaxPath = 1024;

static const int kWrongArgumentCount = 1;
static const int kDirectoryNeeded = 2;

static void exitUnless(bool test, FILE *stream, int code, const char *control, ...) {
  if (test) return;
  va_list arglist;
  va_start(arglist, control);
  vfprintf(stream, control, arglist);
  va_end(arglist);
  exit(code);
}

static void listMatches(char path[], size_t length, const char *pattern) {
  DIR *dir = opendir(path);
  if (dir == NULL) return;
  strcpy(path + length, "/");
  while (true) {
    struct dirent *de = readdir(dir);
    if (de == NULL) break;
    if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
    if (length + strlen(de->d_name) > kMaxPath) continue;
    strcpy(path + length + 1, de->d_name);
    struct stat st;
    lstat(path, &st);
    if (S_ISREG(st.st_mode)) {
      if (strcmp(de->d_name, pattern) == 0) printf("%s\n", path);
    } else if (S_ISDIR(st.st_mode)) {
      listMatches(path, length + 1 + strlen(de->d_name), pattern);
    }
  }
  
  closedir(dir);
}

int main(int argc, char *argv[]) {
  exitUnless(argc == 3, stderr, kWrongArgumentCount, "Usage: %s <directory> <pattern>\n", argv[0]);
  const char *directory = argv[1];
  struct stat st;
  stat(directory, &st);
  exitUnless(S_ISDIR(st.st_mode), stderr, kDirectoryNeeded, "<directory> must be an actual directory, %s is not", directory);
  size_t length = strlen(directory);
  if (length > kMaxPath) return 0;
  const char *pattern = argv[2];
  char path[kMaxPath + 1];
  strcpy(path, directory); // no buffer overflow because of above check
  listMatches(path, length, pattern);
  return 0;
}