← C

Files & Directories (APUE)

← Files & Directories (APUE)

Select a question from the sidebar

12 questions in this topic

Question 1 / 12

How do stat(), fstat(), and lstat() work, and what information does struct stat contain?

The stat() family of functions retrieves file metadata without opening the file.

Prototypes:

#include <sys/stat.h>
int stat(const char *pathname, struct stat *buf);
int fstat(int fd, struct stat *buf);
int lstat(const char *pathname, struct stat *buf);

Differences:

stat() follows symbolic links (returns info about the target)
lstat() does NOT follow symlinks (returns info about the link itself)
fstat() works on an already-open file descriptor

struct stat fields:

st_dev -- device ID of filesystem
st_ino -- inode number
st_mode -- file type and permissions
st_nlink -- number of hard links
st_uid / st_gid -- owner user/group ID
st_size -- file size in bytes (for regular files)
st_blksize -- optimal I/O block size
st_blocks -- number of 512-byte blocks allocated
st_atime -- last access time
st_mtime -- last modification time
st_ctime -- last status change time (NOT creation time on most UNIX systems)

File type macros (applied to st_mode):

S_ISREG() -- regular file
S_ISDIR() -- directory
S_ISLNK() -- symbolic link
S_ISCHR() / S_ISBLK() -- character/block device
S_ISFIFO() -- FIFO/pipe
S_ISSOCK() -- socket

Pseudo Code

1. Call stat(path, &sb) or lstat(path, &sb) or fstat(fd, &sb)
2. Check return value (0 = success, -1 = error)
3. Use S_ISREG(sb.st_mode), S_ISDIR(sb.st_mode), etc. for file type
4. Use sb.st_mode & 0777 for permission bits
5. sb.st_size for file size, sb.st_nlink for hard link count
6. sb.st_mtime for last modification time

Code

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

void print_file_info(const char *path) {
    struct stat sb;
    if (lstat(path, &sb) == -1) {
        perror(path);
        return;
    }

    printf("File: %s\n", path);
    printf("  Inode: %lu\n", (unsigned long)sb.st_ino);
    printf("  Size:  %lld bytes\n", (long long)sb.st_size);
    printf("  Links: %lu\n", (unsigned long)sb.st_nlink);
    printf("  Mode:  %o\n", (unsigned int)(sb.st_mode & 07777));

    /* File type */
    printf("  Type:  ");
    if (S_ISREG(sb.st_mode))       printf("regular file\n");
    else if (S_ISDIR(sb.st_mode))  printf("directory\n");
    else if (S_ISLNK(sb.st_mode))  printf("symbolic link\n");
    else if (S_ISCHR(sb.st_mode))  printf("character device\n");
    else if (S_ISBLK(sb.st_mode))  printf("block device\n");
    else if (S_ISFIFO(sb.st_mode)) printf("FIFO\n");
    else if (S_ISSOCK(sb.st_mode)) printf("socket\n");

    /* Timestamps */
    char timebuf[64];
    struct tm *tm = localtime(&sb.st_mtime);
    strftime(timebuf, sizeof(timebuf), "%Y-%m-%d %H:%M:%S", tm);
    printf("  Modified: %s\n", timebuf);
}

int main(void) {
    print_file_info("/etc/passwd");
    print_file_info("/tmp");
    return 0;
}

File: /etc/passwd
  Inode: 3541050
  Size:  2773 bytes
  Links: 1
  Mode:  644
  Type:  regular file
  Modified: 2025-01-15 10:30:45
File: /tmp
  Inode: 2
  Size:  4096 bytes
  Links: 18
  Mode:  1777
  Type:  directory
  Modified: 2025-03-18 14:20:00

Key Points

•stat() follows symlinks; lstat() does not; fstat() uses an fd
•struct stat contains inode, size, permissions, timestamps, link count
•Use S_ISREG/S_ISDIR/S_ISLNK macros on st_mode for file type
•st_ctime is status change time, NOT creation time
•st_blocks counts 512-byte blocks regardless of filesystem block size

Gotchas

•stat() on a symlink returns info about the target; use lstat() for the link itself
•st_size for symlinks is the length of the target path string, not the target file size
•st_size for directories is filesystem-dependent and does not reflect content count
•st_ctime changes on chmod/chown/link/unlink, not just content changes

stat() gets file metadata into struct stat. lstat() does not follow symlinks. fstat() works on an fd. Key fields: st_mode (type+perms), st_size, st_ino, st_nlink, st_mtime.

•stat follows symlinks; lstat does not
•S_ISREG/S_ISDIR macros for file type

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

int main(void) {
    struct stat sb;
    if (stat("/etc/passwd", &sb) == -1) { perror("stat"); return 1; }
    printf("Size: %lld, Links: %lu, Mode: %o\n",
           (long long)sb.st_size, (unsigned long)sb.st_nlink,
           (unsigned int)(sb.st_mode & 07777));
    if (S_ISREG(sb.st_mode)) printf("Regular file\n");
    return 0;
}

Size: 2773, Links: 1, Mode: 644
Regular file

st_ctime is NOT creation time -- it is last status change time

Question 2 / 12

How do file permissions work in UNIX, including setuid, setgid, and the sticky bit?

UNIX file permissions are stored in the st_mode field as a 12-bit value.

Standard permission bits (9 bits):

Owner: r(0400) w(0200) x(0100)
Group: r(0040) w(0020) x(0010)
Other: r(0004) w(0002) x(0001)

Special bits (3 bits):

Set-user-ID (setuid, 04000): When set on an executable, the process runs with the effective UID of the file owner, not the invoking user. Example: /usr/bin/passwd is setuid root.
Set-group-ID (setgid, 02000): On an executable, runs with the effective GID of the file's group. On a directory, new files inherit the directory's group (not the creator's).
Sticky bit (01000): On a directory, only the file owner (or root) can delete/rename files within it, even if others have write permission. Example: /tmp has the sticky bit.

Permission checking order:

If effective UID == 0 (root), all access granted
If effective UID == file owner, use owner bits
If effective GID or supplementary group matches file group, use group bits
Otherwise, use other bits

APIs:

chmod(path, mode) / fchmod(fd, mode) -- change permissions
access(path, R_OK|W_OK|X_OK) -- check real UID access (not effective)

Pseudo Code

Permission bits layout (octal):
  04000 = setuid
  02000 = setgid
  01000 = sticky
  00700 = owner rwx
  00070 = group rwx
  00007 = other rwx

Kernel check: root -> owner -> group -> other
setuid: effective UID = file owner UID on exec
setgid on dir: new files inherit directory group
sticky on dir: only owner can delete their files

Code

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

void print_permissions(const char *path) {
    struct stat sb;
    if (stat(path, &sb) == -1) { perror(path); return; }

    printf("%s: ", path);
    /* File type */
    printf("%c", S_ISDIR(sb.st_mode) ? 'd' : '-');
    /* Owner */
    printf("%c%c%c",
        (sb.st_mode & S_IRUSR) ? 'r' : '-',
        (sb.st_mode & S_IWUSR) ? 'w' : '-',
        (sb.st_mode & S_ISUID) ? 's' :
            (sb.st_mode & S_IXUSR) ? 'x' : '-');
    /* Group */
    printf("%c%c%c",
        (sb.st_mode & S_IRGRP) ? 'r' : '-',
        (sb.st_mode & S_IWGRP) ? 'w' : '-',
        (sb.st_mode & S_ISGID) ? 's' :
            (sb.st_mode & S_IXGRP) ? 'x' : '-');
    /* Other */
    printf("%c%c%c",
        (sb.st_mode & S_IROTH) ? 'r' : '-',
        (sb.st_mode & S_IWOTH) ? 'w' : '-',
        (sb.st_mode & S_ISVTX) ? 't' :
            (sb.st_mode & S_IXOTH) ? 'x' : '-');
    printf("\n");
}

int main(void) {
    print_permissions("/etc/passwd");
    print_permissions("/tmp");

    /* Change permissions */
    chmod("myfile.txt", 0755);          /* rwxr-xr-x */
    chmod("script.sh", 04755);          /* setuid + rwxr-xr-x */
    chmod("shared_dir", 01777);         /* sticky + rwxrwxrwx */

    return 0;
}

/etc/passwd: -rw-r--r--
/tmp: drwxrwxrwt

Key Points

•12 permission bits: 3 special + 9 rwx (owner/group/other)
•setuid (04000): process runs as file owner
•setgid (02000): on dirs, new files inherit directory group
•sticky bit (01000): on dirs, only file owner can delete
•Kernel checks: root -> owner -> group -> other (stops at first match)

Gotchas

•setuid on shell scripts is ignored on most modern systems (security risk)
•Group permissions are NOT checked if you are the owner -- owner bits take precedence
•access() checks real UID, not effective UID -- do not use for security decisions in setuid programs
•chmod does not follow symlinks on many systems -- use the target directly

9 rwx bits (owner/group/other) + 3 special bits (setuid/setgid/sticky). setuid makes process run as file owner. Sticky bit on /tmp prevents users from deleting others' files. chmod() changes permissions.

•setuid=04000, setgid=02000, sticky=01000
•Owner bits checked before group bits

#include <sys/stat.h>

int main(void) {
    chmod("prog", 04755);    /* setuid + rwxr-xr-x */
    chmod("/tmp", 01777);    /* sticky + rwxrwxrwx */
    /* Check permissions */
    struct stat sb;
    stat("prog", &sb);
    if (sb.st_mode & S_ISUID) { /* setuid is set */ }
    return 0;
}

setuid scripts ignored on most modern systems

Question 3 / 12

What is the difference between hard links and symbolic links?

Hard links:

A hard link is a directory entry that points directly to an inode
Multiple hard links to the same inode share the same data blocks, size, permissions, and timestamps
st_nlink in struct stat counts the number of hard links
Created with link(oldpath, newpath)
Removed with unlink(path) -- decrements link count; file data is freed when count reaches 0 AND no process has it open
Restrictions: Cannot cross filesystem boundaries (same device only). Cannot hard-link directories (to prevent cycles in the filesystem tree).

Symbolic (soft) links:

A symlink is a special file whose content is the pathname of another file
Has its own inode with file type S_IFLNK
Created with symlink(target, linkpath)
Read target with readlink(linkpath, buf, bufsize)
Can cross filesystem boundaries
Can point to directories
Can become "dangling" if the target is deleted
stat() follows symlinks; lstat() does not

Key difference: A hard link IS the file (another name for the same inode). A symlink is a pointer to a name (indirection).

Pseudo Code

Hard link:
  link("existing.txt", "hardlink.txt")
  Both names -> same inode -> same data
  unlink("existing.txt")  -> hardlink.txt still works (data intact)
  st_nlink decremented; data freed when nlink==0 and no open fds

Symbolic link:
  symlink("existing.txt", "softlink.txt")
  softlink.txt -> contains string "existing.txt"
  unlink("existing.txt") -> softlink.txt becomes dangling

Code

#include <unistd.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <string.h>

int main(void) {
    /* Create a file */
    int fd = open("original.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    write(fd, "hello\n", 6);
    close(fd);

    /* Create hard link */
    if (link("original.txt", "hardlink.txt") == -1)
        perror("link");

    /* Create symbolic link */
    if (symlink("original.txt", "softlink.txt") == -1)
        perror("symlink");

    /* Check link counts */
    struct stat sb;
    stat("original.txt", &sb);
    printf("original.txt: nlink=%lu, inode=%lu\n",
           (unsigned long)sb.st_nlink, (unsigned long)sb.st_ino);

    stat("hardlink.txt", &sb);
    printf("hardlink.txt: nlink=%lu, inode=%lu\n",
           (unsigned long)sb.st_nlink, (unsigned long)sb.st_ino);
    /* Same inode! nlink=2 */

    lstat("softlink.txt", &sb);
    printf("softlink.txt: inode=%lu (different), is_symlink=%d\n",
           (unsigned long)sb.st_ino, S_ISLNK(sb.st_mode));

    /* Read symlink target */
    char target[256];
    ssize_t len = readlink("softlink.txt", target, sizeof(target) - 1);
    if (len != -1) {
        target[len] = '\0';
        printf("softlink.txt -> %s\n", target);
    }

    /* Delete original -- hard link survives, symlink dangles */
    unlink("original.txt");
    /* hardlink.txt still works (nlink=1) */
    /* softlink.txt is now dangling */

    unlink("hardlink.txt");
    unlink("softlink.txt");
    return 0;
}

original.txt: nlink=2, inode=1234567
hardlink.txt: nlink=2, inode=1234567
softlink.txt: inode=1234890 (different), is_symlink=1
softlink.txt -> original.txt

Key Points

•Hard link: another directory entry for the same inode (same data)
•Symlink: a file containing a path string (indirection)
•Hard links cannot cross filesystems or link to directories
•Symlinks can cross filesystems and point to directories
•unlink() decrements link count; data freed when nlink=0 and no open fds

Gotchas

•Deleting the target of a symlink makes it dangling (broken)
•readlink() does NOT null-terminate the buffer -- you must do it
•Hard-linking directories is forbidden to prevent filesystem graph cycles
•rename() is atomic within a filesystem but not across filesystems

Hard link = another name for the same inode (same data, cannot cross filesystems). Symlink = a file containing a path (can cross filesystems, can dangle). link() creates hard links, symlink() creates symlinks, unlink() removes either.

•Hard link = same inode; symlink = path string
•unlink decrements nlink; data freed at nlink=0

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

int main(void) {
    link("file.txt", "hardlink.txt");    /* same inode */
    symlink("file.txt", "softlink.txt"); /* path indirection */
    struct stat sb;
    stat("hardlink.txt", &sb);  /* nlink=2 */
    unlink("file.txt");  /* hardlink survives, softlink dangles */
    return 0;
}

readlink() does not null-terminate the returned string

Question 4 / 12

What is an inode, and what information does it store?

An inode (index node) is the fundamental data structure in UNIX filesystems that stores metadata about a file. Every file and directory has exactly one inode.

What an inode stores:

File type (regular, directory, symlink, device, pipe, socket)
Permissions (rwx bits + setuid/setgid/sticky)
Owner UID and GID
File size in bytes
Number of hard links (nlink)
Timestamps: atime (access), mtime (modification), ctime (status change)
Pointers to data blocks on disk (direct, single indirect, double indirect, triple indirect)
Number of disk blocks allocated

What an inode does NOT store:

The filename! Names are stored in directory entries.
The path -- there is no single canonical path for a file.

A directory is a file whose data blocks contain a list of (name, inode number) pairs. This is why hard links work: multiple directory entries can point to the same inode number.

The inode number is unique within a filesystem (device). Two files on different filesystems may have the same inode number. To uniquely identify a file system-wide, you need the (st_dev, st_ino) pair.

Pseudo Code

Inode contains:
  - File type and permissions (st_mode)
  - Owner UID, GID
  - Size, block count
  - Timestamps (atime, mtime, ctime)
  - Hard link count (nlink)
  - Pointers to data blocks

Directory entry: (name -> inode_number)
  "file.txt" -> inode 12345
  "link.txt" -> inode 12345   (hard link: same inode)
  "."        -> inode 99      (self)
  ".."       -> inode 88      (parent)

Code

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

int main(void) {
    struct stat sb;

    if (stat("/etc/passwd", &sb) == -1) {
        perror("stat");
        return 1;
    }

    printf("Inode information for /etc/passwd:\n");
    printf("  Device:     %lld\n", (long long)sb.st_dev);
    printf("  Inode:      %lu\n", (unsigned long)sb.st_ino);
    printf("  Mode:       %o\n", (unsigned int)sb.st_mode);
    printf("  Hard links: %lu\n", (unsigned long)sb.st_nlink);
    printf("  UID:        %u\n", sb.st_uid);
    printf("  GID:        %u\n", sb.st_gid);
    printf("  Size:       %lld\n", (long long)sb.st_size);
    printf("  Blocks:     %lld\n", (long long)sb.st_blocks);
    printf("  Block size: %ld\n", (long)sb.st_blksize);

    /* Two files are the same if (dev, ino) match */
    struct stat sb2;
    if (stat("/etc/passwd", &sb2) == 0) {
        if (sb.st_dev == sb2.st_dev && sb.st_ino == sb2.st_ino)
            printf("Same file (same device + inode)\n");
    }

    return 0;
}

Inode information for /etc/passwd:
  Device:     66306
  Inode:      3541050
  Mode:       100644
  Hard links: 1
  UID:        0
  GID:        0
  Size:       2773
  Blocks:     8
  Block size: 4096
Same file (same device + inode)

Key Points

•Inode stores all metadata except the filename
•Filenames are stored in directory entries (name -> inode number pairs)
•Unique file identity is (st_dev, st_ino) pair
•Hard links are multiple directory entries pointing to the same inode
•Each filesystem has a fixed pool of inodes (can run out even with free space)

Gotchas

•A filesystem can run out of inodes before running out of disk space (many small files)
•inode numbers are only unique within a filesystem -- not globally
•The filename is NOT in the inode, which is why hard links work
•Deleting a file only removes the directory entry; data survives while nlink > 0 or a process holds it open

An inode stores file metadata (type, permissions, size, timestamps, block pointers) but NOT the filename. Filenames are in directory entries mapping names to inode numbers. Unique file identity = (st_dev, st_ino).

•Inode = all metadata except filename
•(st_dev, st_ino) uniquely identifies a file

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

int main(void) {
    struct stat sb;
    stat("/etc/passwd", &sb);
    printf("inode=%lu, size=%lld, nlinks=%lu\n",
           (unsigned long)sb.st_ino, (long long)sb.st_size,
           (unsigned long)sb.st_nlink);
    return 0;
}

inode=3541050, size=2773, nlinks=1

Filesystem can run out of inodes with free disk space remaining

Question 5 / 12

How do you traverse directories using opendir(), readdir(), and closedir()?

POSIX provides a standard API for reading directory contents:

Functions:

#include <dirent.h>
DIR *opendir(const char *name);
struct dirent *readdir(DIR *dirp);
int closedir(DIR *dirp);

struct dirent fields:

d_ino -- inode number
d_name -- null-terminated filename (no path)
d_type -- file type (DT_REG, DT_DIR, DT_LNK, etc.) -- not portable, may be DT_UNKNOWN

Usage pattern:

opendir() returns a DIR * handle (like FILE * for directories)
readdir() returns the next entry, or NULL when done (or on error)
Always skip . (current dir) and .. (parent dir) entries
closedir() releases the handle

Thread safety: readdir() uses a static buffer in the DIR structure, so it is not thread-safe across different DIR * handles. For thread safety, use readdir_r() (deprecated) or protect with a mutex.

Important: readdir() returns NULL both at end-of-directory and on error. To distinguish, set errno = 0 before the call and check errno after getting NULL.

Pseudo Code

1. DIR *dp = opendir(path)
2. while ((entry = readdir(dp)) != NULL)
3.   skip if entry->d_name is "." or ".."
4.   process entry->d_name
5. closedir(dp)
6. To distinguish EOF from error: check errno after NULL return

Code

#include <dirent.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

int list_directory(const char *path) {
    DIR *dp = opendir(path);
    if (dp == NULL) {
        perror(path);
        return -1;
    }

    struct dirent *entry;
    errno = 0;
    while ((entry = readdir(dp)) != NULL) {
        /* Skip . and .. */
        if (strcmp(entry->d_name, ".") == 0 ||
            strcmp(entry->d_name, "..") == 0)
            continue;

        /* Print file type (d_type is Linux-specific) */
        char type = '?';
        switch (entry->d_type) {
            case DT_REG: type = '-'; break;
            case DT_DIR: type = 'd'; break;
            case DT_LNK: type = 'l'; break;
            default:     type = '?'; break;
        }
        printf("%c %lu %s\n", type,
               (unsigned long)entry->d_ino, entry->d_name);
    }

    if (errno != 0) {
        perror("readdir");
        closedir(dp);
        return -1;
    }

    closedir(dp);
    return 0;
}

int main(void) {
    list_directory("/tmp");
    return 0;
}

Key Points

•opendir/readdir/closedir is the standard directory reading API
•readdir returns NULL at end or on error -- check errno to distinguish
•Always skip "." and ".." entries
•d_type field is not portable (may be DT_UNKNOWN on some filesystems)
•readdir is not thread-safe across DIR handles without synchronization

Gotchas

•d_type is not available on all filesystems (e.g., XFS before Linux 4.0) -- fall back to stat()
•readdir returns a pointer to a static buffer -- copy d_name if you need to keep it
•Modifying the directory during traversal (creating/deleting files) has undefined behavior
•d_name has a max length of NAME_MAX (typically 255), not PATH_MAX

opendir() opens a directory, readdir() iterates entries (d_name, d_ino), closedir() closes it. Skip . and ... Set errno = 0 before loop to detect errors vs EOF.

•readdir returns NULL at end or error
•Skip . and .. entries

#include <dirent.h>
#include <stdio.h>
#include <string.h>

int main(void) {
    DIR *dp = opendir(".");
    struct dirent *e;
    while ((e = readdir(dp)) != NULL) {
        if (e->d_name[0] == '.') continue;
        printf("%s\n", e->d_name);
    }
    closedir(dp);
    return 0;
}

d_type may be DT_UNKNOWN on some filesystems -- use stat() instead

Question 6 / 12

How do you implement recursive directory traversal in C?

There are two main approaches to recursive directory traversal:

1. nftw() -- POSIX standard:

#include <ftw.h>
int nftw(const char *dirpath, 
         int (*fn)(const char *fpath, const struct stat *sb,
                   int typeflag, struct FTW *ftwbuf),
         int nopenfd, int flags);

nftw() walks a directory tree and calls your callback for each entry.

nopenfd limits the number of simultaneously open directories
flags: FTW_PHYS (don't follow symlinks), FTW_DEPTH (post-order traversal)
typeflag: FTW_F (file), FTW_D (directory), FTW_DNR (unreadable dir), etc.
Return 0 from callback to continue, non-zero to stop

2. Manual recursion with opendir/readdir:

Open directory, read entries, recurse into subdirectories
Must construct full paths and handle errors
More control but more code

nftw() is preferred for most uses because it handles fd management, path construction, and cycle detection.

Pseudo Code

nftw approach:
1. Define callback function(path, stat, typeflag, ftwbuf)
2. Call nftw(root_path, callback, max_open_fds, FTW_PHYS)
3. Callback is called for every file/dir in the tree
4. Return 0 to continue, non-zero to stop

Manual approach:
1. opendir(path)
2. For each entry: skip . and ..
3. Construct full_path = path + "/" + d_name
4. lstat(full_path) to get type
5. If directory: recurse
6. If file: process
7. closedir()

Code

#include <ftw.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <dirent.h>
#include <limits.h>

/* Approach 1: nftw (preferred) */
static int print_entry(const char *fpath, const struct stat *sb,
                       int typeflag, struct FTW *ftwbuf) {
    const char *name = fpath + ftwbuf->base;  /* just the filename */
    printf("%*s%s", ftwbuf->level * 2, "", name);
    if (typeflag == FTW_D)
        printf("/");
    printf(" (%lld bytes)\n", (long long)sb->st_size);
    return 0;  /* continue traversal */
}

/* Approach 2: Manual recursion */
void walk_dir(const char *path, int depth) {
    DIR *dp = opendir(path);
    if (dp == NULL) { perror(path); return; }

    struct dirent *entry;
    while ((entry = readdir(dp)) != NULL) {
        if (strcmp(entry->d_name, ".") == 0 ||
            strcmp(entry->d_name, "..") == 0)
            continue;

        char fullpath[PATH_MAX];
        snprintf(fullpath, sizeof(fullpath), "%s/%s", path, entry->d_name);

        struct stat sb;
        if (lstat(fullpath, &sb) == -1) continue;

        printf("%*s%s\n", depth * 2, "", entry->d_name);
        if (S_ISDIR(sb.st_mode))
            walk_dir(fullpath, depth + 1);
    }
    closedir(dp);
}

int main(void) {
    printf("=== nftw traversal ===\n");
    nftw(".", print_entry, 20, FTW_PHYS);

    printf("\n=== Manual traversal ===\n");
    walk_dir(".", 0);

    return 0;
}

Key Points

•nftw() is the POSIX standard for recursive directory walking
•FTW_PHYS prevents following symlinks (avoids infinite loops)
•nftw manages open fd count automatically with nopenfd parameter
•Manual recursion gives more control but requires careful path construction
•Always use lstat() (not stat()) to avoid following symlinks into loops

Gotchas

•Without FTW_PHYS, symlink cycles cause infinite traversal
•Manual recursion can exhaust the stack on deeply nested directories
•PATH_MAX may not be large enough on all systems -- use dynamic allocation for robustness
•nftw is not reentrant and not safe to call from a signal handler

Use nftw() for POSIX-standard recursive traversal with a callback. Use FTW_PHYS to avoid following symlinks. Manual recursion with opendir/readdir gives more control.

•nftw() handles recursion, fd management, and path construction
•FTW_PHYS avoids symlink loops

#include <ftw.h>
#include <stdio.h>

static int callback(const char *path, const struct stat *sb,
                    int type, struct FTW *ftw) {
    printf("%s\n", path);
    return 0;
}

int main(void) {
    nftw(".", callback, 20, FTW_PHYS);
    return 0;
}

Without FTW_PHYS, symlink cycles cause infinite recursion

Question 7 / 12

How do getcwd() and chdir() work for managing the current working directory?

Every process has a current working directory (CWD) that is used as the starting point for resolving relative pathnames.

getcwd() -- get current working directory:

#include <unistd.h>
char *getcwd(char *buf, size_t size);

Returns buf on success, or NULL on error. If buf is NULL (GNU extension), getcwd allocates a buffer with malloc() that the caller must free().

chdir() / fchdir() -- change working directory:

int chdir(const char *path);
int fchdir(int fd);  /* change to directory represented by fd */

The CWD is a per-process attribute (stored as an inode reference in the kernel). When you fork(), the child inherits the parent's CWD. chdir() in the child does NOT affect the parent.

This is why cd must be a shell built-in: if it were an external command, it would change the CWD of the child process (the command) but not the shell itself.

Pseudo Code

1. getcwd(buf, size) -> fills buf with absolute path of CWD
2. chdir(path) -> changes CWD to path (0 on success, -1 on error)
3. fchdir(fd) -> changes CWD to directory of open fd
4. CWD inherited on fork, but changes do not propagate to parent
5. cd is a shell builtin because it must change the shell's own CWD

Code

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int main(void) {
    char cwd[PATH_MAX];

    /* Get current working directory */
    if (getcwd(cwd, sizeof(cwd)) == NULL) {
        perror("getcwd");
        return 1;
    }
    printf("Current dir: %s\n", cwd);

    /* Change to /tmp */
    if (chdir("/tmp") == -1) {
        perror("chdir");
        return 1;
    }

    if (getcwd(cwd, sizeof(cwd)) != NULL)
        printf("After chdir: %s\n", cwd);

    /* Using fchdir to return to original directory */
    /* (Useful when original path might be deleted) */
    int orig_fd = open(".", O_RDONLY);
    chdir("/var");
    /* ... do work in /var ... */
    fchdir(orig_fd);  /* back to /tmp */
    close(orig_fd);

    if (getcwd(cwd, sizeof(cwd)) != NULL)
        printf("After fchdir: %s\n", cwd);

    return 0;
}

Current dir: /home/user/project
After chdir: /tmp
After fchdir: /tmp

Key Points

•getcwd() returns the absolute path of the current working directory
•chdir() changes the CWD; fchdir() uses an open directory fd
•CWD is per-process; inherited on fork but not shared
•cd must be a shell builtin to affect the shell's CWD
•fchdir() is useful to return to a directory even if its path changes

Gotchas

•getcwd() fails if any component of the path lacks read or execute permission
•PATH_MAX may not be sufficient on all systems; GNU getcwd(NULL, 0) auto-allocates
•chdir() in a child process does not affect the parent
•If CWD is deleted, getcwd() fails but the process can still operate with relative paths

getcwd(buf, size) returns the absolute CWD path. chdir(path) changes it. CWD is per-process (inherited on fork, not shared). cd is a shell builtin because external commands cannot change the shell's CWD.

•CWD is per-process, inherited on fork
•cd is a shell builtin for this reason

#include <unistd.h>
#include <stdio.h>
#include <limits.h>

int main(void) {
    char buf[PATH_MAX];
    getcwd(buf, sizeof(buf));
    printf("CWD: %s\n", buf);
    chdir("/tmp");
    getcwd(buf, sizeof(buf));
    printf("Now: %s\n", buf);
    return 0;
}

CWD: /home/user/project
Now: /tmp

chdir in a child does not affect the parent process

Question 8 / 12

How does rename() work, and what guarantees does it provide for atomicity?

rename() atomically changes the name of a file or moves it within the same filesystem.

Prototype:

#include <stdio.h>
int rename(const char *oldpath, const char *newpath);

Atomicity guarantee: If newpath already exists, it is atomically replaced. At no point will another process see newpath as missing -- it goes directly from old content to new content. This makes rename() the standard way to atomically update a file:

Write new content to a temporary file
rename(tmpfile, target) -- atomic swap

Rules:

If oldpath is a file and newpath is a file: newpath is atomically replaced
If oldpath is a directory and newpath is an empty directory: replaced
Cannot rename a file to a directory name or vice versa
Both paths must be on the same filesystem (same mount point)
If oldpath == newpath, no error (no-op)

Cross-filesystem rename: If old and new paths are on different filesystems, rename() fails with EXDEV. You must manually copy + unlink.

Pseudo Code

Atomic file update pattern:
1. Write new data to tmpfile (same filesystem as target)
2. fsync(tmpfile_fd) to ensure data is on disk
3. close(tmpfile_fd)
4. rename(tmpfile, target)  -- atomic replacement
5. fsync on directory fd to ensure rename is durable

Rules:
- Same filesystem only (EXDEV if cross-device)
- File -> existing file: old file atomically unlinked
- Dir -> existing empty dir: old dir atomically replaced
- File -> existing dir: EISDIR error

Code

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

/* Atomic file update: write-to-temp then rename */
int atomic_write(const char *path, const char *data, size_t len) {
    char tmppath[256];
    snprintf(tmppath, sizeof(tmppath), "%s.tmp", path);

    /* Write to temporary file */
    int fd = open(tmppath, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) { perror("open tmp"); return -1; }

    ssize_t nw = write(fd, data, len);
    if (nw != (ssize_t)len) { perror("write"); close(fd); return -1; }

    /* Ensure data is on disk before rename */
    if (fsync(fd) == -1) { perror("fsync"); close(fd); return -1; }
    close(fd);

    /* Atomic rename */
    if (rename(tmppath, path) == -1) {
        perror("rename");
        unlink(tmppath);
        return -1;
    }

    return 0;
}

int main(void) {
    const char *data = "new config data\n";
    if (atomic_write("config.txt", data, strlen(data)) == 0)
        printf("Atomically updated config.txt\n");
    else
        fprintf(stderr, "Update failed\n");
    return 0;
}

Atomically updated config.txt

Key Points

•rename() atomically replaces newpath if it exists
•Standard pattern for atomic file updates: write tmp + rename
•Both paths must be on the same filesystem (EXDEV otherwise)
•fsync before rename ensures data durability on crash
•Cannot rename file to directory or vice versa

Gotchas

•Cross-filesystem rename fails with EXDEV -- must copy + unlink manually
•Without fsync before rename, a crash can leave the new file empty
•rename on a directory requires newpath to be empty if it exists
•rename does not update ctime of the file, but does update ctime of both directories

rename(old, new) atomically moves/renames a file. If new exists, it is atomically replaced. Must be on the same filesystem. Standard atomic update: write to tmp, fsync, rename.

•Atomic replacement of existing file
•Must be same filesystem (EXDEV otherwise)

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>

int main(void) {
    /* Atomic update: write tmp, rename */
    int fd = open("config.tmp", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    write(fd, "new data\n", 9);
    fsync(fd);
    close(fd);
    rename("config.tmp", "config.txt");  /* atomic */
    return 0;
}

Without fsync before rename, crash can leave empty file

Question 9 / 12

How do mkstemp() and mkdtemp() create temporary files and directories safely?

Creating temporary files securely is critical to avoid race conditions and symlink attacks.

Unsafe approaches:

tmpnam() / tempnam(): return a name, but between getting the name and creating the file, another process can create a file (or symlink) with that name. DEPRECATED.
mktemp(): same TOCTOU race. DEPRECATED.

Safe approaches:

mkstemp() -- create temp file:

#include <stdlib.h>
int mkstemp(char *template);  /* template modified in place */

Takes a template like "/tmp/myapp.XXXXXX" (at least 6 X's)
Atomically creates and opens the file with mode 0600
Replaces the X's with random characters
Returns an open file descriptor
The caller must unlink() the file when done (or keep it)

mkdtemp() -- create temp directory:

char *mkdtemp(char *template);

Creates a directory with mode 0700
Returns the modified template string, or NULL on error

Both use a unique random suffix and create the file/directory atomically, eliminating the TOCTOU race.

Pseudo Code

1. Prepare template: char tmpl[] = "/tmp/myapp.XXXXXX"
2. int fd = mkstemp(tmpl)  -- creates file, returns fd
3. tmpl now contains actual filename (e.g., "/tmp/myapp.a3bK9f")
4. Use fd for read/write
5. unlink(tmpl) to remove (or keep if needed)
6. close(fd)

For directory:
1. char dtmpl[] = "/tmp/mydir.XXXXXX"
2. mkdtemp(dtmpl)  -- creates directory
3. Use dtmpl as directory path

Code

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(void) {
    /* Create temporary file */
    char tmpl[] = "/tmp/myapp.XXXXXX";
    int fd = mkstemp(tmpl);
    if (fd == -1) {
        perror("mkstemp");
        return 1;
    }
    printf("Temp file: %s (fd=%d)\n", tmpl, fd);

    /* Write to it */
    const char *data = "temporary data\n";
    write(fd, data, strlen(data));

    /* Unlink immediately -- file stays open until close */
    unlink(tmpl);
    printf("Unlinked %s (still usable via fd)\n", tmpl);

    /* Can still read/write via fd */
    lseek(fd, 0, SEEK_SET);
    char buf[64];
    ssize_t n = read(fd, buf, sizeof(buf) - 1);
    buf[n] = '\0';
    printf("Read back: %s", buf);

    close(fd);  /* file data now freed */

    /* Create temporary directory */
    char dtmpl[] = "/tmp/mydir.XXXXXX";
    if (mkdtemp(dtmpl) == NULL) {
        perror("mkdtemp");
        return 1;
    }
    printf("Temp dir: %s\n", dtmpl);
    rmdir(dtmpl);  /* clean up */

    return 0;
}

Temp file: /tmp/myapp.a1b2c3 (fd=3)
Unlinked /tmp/myapp.a1b2c3 (still usable via fd)
Read back: temporary data
Temp dir: /tmp/mydir.d4e5f6

Key Points

•mkstemp() atomically creates and opens a temp file (no TOCTOU race)
•Template must have at least 6 trailing X characters
•File is created with mode 0600 (owner read/write only)
•mkdtemp() creates a temp directory with mode 0700
•tmpnam() and mktemp() are deprecated due to race conditions

Gotchas

•Template must be a mutable char array, not a string literal (would segfault)
•mkstemp does NOT unlink the file -- caller must clean up
•The unlink-immediately pattern (unlink then use fd) is great for security but the file has no name
•Template path should be in a directory writable by the process (usually /tmp)

mkstemp(template) atomically creates and opens a temp file (mode 0600). mkdtemp(template) creates a temp directory (mode 0700). Template needs trailing XXXXXX. Never use deprecated tmpnam()/mktemp().

•mkstemp is atomic -- no TOCTOU race
•Template must be a mutable array, not a literal

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>

int main(void) {
    char tmpl[] = "/tmp/app.XXXXXX";
    int fd = mkstemp(tmpl);  /* atomic create + open */
    printf("%s\n", tmpl);    /* e.g., /tmp/app.x7kQ2m */
    unlink(tmpl);            /* optional: remove name */
    close(fd);
    return 0;
}

/tmp/app.x7kQ2m

String literal template causes segfault (char *t = "...XXXXXX" is wrong)

Question 10 / 12

How does umask work, and how does it affect file creation permissions?

The umask is a per-process attribute that specifies which permission bits should be turned off when creating new files and directories.

Formula:

actual_permissions = requested_mode & ~umask

Example: If umask is 022 and you call open("f", O_CREAT, 0666):

0666 & ~022 = 0666 & 0755 = 0644 (rw-r--r--)

Prototype:

#include <sys/stat.h>
mode_t umask(mode_t mask);  /* returns previous umask */

Common umask values:

022 -- default on most systems: owner rwx, group/other rx (no write)
077 -- restrictive: owner rwx, no group/other access
002 -- permissive: owner/group rwx, other rx

Important: umask() always succeeds (no error return). It returns the previous umask value. There is no way to query the umask without setting it (until Linux 4.7's /proc/self/status). A common pattern is old = umask(0); umask(old); to read the current value.

Daemons typically call umask(0) during initialization so that file creation modes are fully controlled by the explicit mode argument.

Pseudo Code

actual_mode = mode & ~umask

Example:
  umask = 022 (binary: 000 010 010)
  open("f", O_CREAT, 0666)  (binary: 110 110 110)
  ~umask = 755 (binary: 111 101 101)
  result = 0666 & 0755 = 0644 (rw-r--r--)

To read current umask:
  old = umask(0); umask(old);  /* restore immediately */

Code

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

int main(void) {
    /* Read current umask (no other portable way) */
    mode_t old_mask = umask(0);
    umask(old_mask);  /* restore immediately */
    printf("Current umask: %04o\n", (unsigned int)old_mask);

    /* Create file with umask 022 */
    umask(022);
    int fd1 = open("file1.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    /* Actual permissions: 0666 & ~022 = 0644 */

    /* Create file with umask 077 */
    umask(077);
    int fd2 = open("file2.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
    /* Actual permissions: 0666 & ~077 = 0600 */

    /* Verify */
    struct stat sb;
    fstat(fd1, &sb);
    printf("file1.txt mode: %04o\n", (unsigned int)(sb.st_mode & 07777));  /* 0644 */
    fstat(fd2, &sb);
    printf("file2.txt mode: %04o\n", (unsigned int)(sb.st_mode & 07777));  /* 0600 */

    /* Daemon pattern: clear umask for full control */
    umask(0);
    int fd3 = open("file3.txt", O_WRONLY | O_CREAT | O_TRUNC, 0755);
    fstat(fd3, &sb);
    printf("file3.txt mode: %04o\n", (unsigned int)(sb.st_mode & 07777));  /* 0755 exactly */

    close(fd1); close(fd2); close(fd3);
    umask(old_mask);  /* restore */
    return 0;
}

Current umask: 0022
file1.txt mode: 0644
file2.txt mode: 0600
file3.txt mode: 0755

Key Points

•umask turns OFF permission bits: actual = mode & ~umask
•Common default umask is 022 (removes group/other write)
•umask() always succeeds and returns the previous value
•No portable way to query umask without setting it (read-modify-restore pattern)
•Daemons typically set umask(0) for full control

Gotchas

•umask is inherited by child processes via fork/exec
•umask affects open(), mkdir(), mkfifo() etc. but NOT chmod()
•mkstemp creates files with 0600 regardless of umask on most systems
•There is no atomic way to read the umask in older kernels -- the read-restore pattern is racy in multithreaded programs

umask specifies bits to turn OFF when creating files: actual = mode & ~umask. Default 022 means 0666 becomes 0644. umask() returns previous value. Daemons use umask(0) for full control.

•actual = mode & ~umask
•Default umask 022 removes group/other write

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

int main(void) {
    umask(022);
    int fd = open("f.txt", O_CREAT | O_WRONLY, 0666);
    /* actual mode: 0666 & ~022 = 0644 */
    struct stat sb;
    fstat(fd, &sb);
    printf("%04o\n", (unsigned int)(sb.st_mode & 07777));  /* 0644 */
    return 0;
}

No atomic way to read umask without setting it in older kernels

Question 11 / 12

What are the S_ISREG, S_ISDIR, S_ISLNK and other file type test macros?

POSIX defines macros to test the file type from the st_mode field of struct stat. The file type is encoded in the upper bits of st_mode.

File type macros (applied to st_mode):

Macro	True for	st_mode constant
`S_ISREG(m)`	Regular file	`S_IFREG`
`S_ISDIR(m)`	Directory	`S_IFDIR`
`S_ISLNK(m)`	Symbolic link	`S_IFLNK`
`S_ISCHR(m)`	Character device	`S_IFCHR`
`S_ISBLK(m)`	Block device	`S_IFBLK`
`S_ISFIFO(m)`	FIFO/named pipe	`S_IFIFO`
`S_ISSOCK(m)`	Socket	`S_IFSOCK`

How they work internally: The macros extract the file type bits using S_IFMT mask:

#define S_ISREG(m)  (((m) & S_IFMT) == S_IFREG)

Important: S_ISLNK() only works with lstat(). If you use stat(), it follows the symlink and returns the type of the target file, so S_ISLNK() would never be true.

You can also extract the file type manually:

switch (st.st_mode & S_IFMT) {
    case S_IFREG:  /* regular file */  break;
    case S_IFDIR:  /* directory */     break;
    ...
}

Pseudo Code

1. Call lstat(path, &sb) to get st_mode
2. Test with macros: S_ISREG(sb.st_mode), S_ISDIR(sb.st_mode), etc.
3. For symlinks, must use lstat() -- stat() follows the link
4. Alternative: switch (sb.st_mode & S_IFMT) for all types
5. Permission bits: sb.st_mode & 0777 (or specific masks like S_IRUSR)

Code

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

const char *file_type_str(mode_t mode) {
    if (S_ISREG(mode))  return "regular file";
    if (S_ISDIR(mode))  return "directory";
    if (S_ISLNK(mode))  return "symbolic link";
    if (S_ISCHR(mode))  return "character device";
    if (S_ISBLK(mode))  return "block device";
    if (S_ISFIFO(mode)) return "FIFO/pipe";
    if (S_ISSOCK(mode)) return "socket";
    return "unknown";
}

int main(void) {
    const char *paths[] = {
        "/etc/passwd",     /* regular file */
        "/tmp",            /* directory */
        "/dev/null",       /* character device */
        NULL
    };

    for (int i = 0; paths[i] != NULL; i++) {
        struct stat sb;
        if (lstat(paths[i], &sb) == -1) {
            perror(paths[i]);
            continue;
        }
        printf("%-20s -> %s (mode=%07o)\n",
               paths[i], file_type_str(sb.st_mode),
               (unsigned int)sb.st_mode);
    }

    /* Alternative: switch on masked mode */
    struct stat sb;
    lstat("/dev/null", &sb);
    switch (sb.st_mode & S_IFMT) {
        case S_IFCHR:  printf("/dev/null is a char device\n"); break;
        case S_IFREG:  printf("/dev/null is a regular file\n"); break;
        default:       printf("/dev/null is something else\n"); break;
    }

    return 0;
}

/etc/passwd          -> regular file (mode=0100644)
/tmp                 -> directory (mode=0040755)
/dev/null            -> character device (mode=0020666)
/dev/null is a char device

Key Points

•S_ISREG, S_ISDIR, S_ISLNK etc. test the file type from st_mode
•They work by masking with S_IFMT: (mode & S_IFMT) == S_IFREG
•S_ISLNK only works with lstat(), not stat()
•Can also use a switch on (st_mode & S_IFMT)
•Seven file types: regular, directory, symlink, char dev, block dev, FIFO, socket

Gotchas

•stat() follows symlinks so S_ISLNK will never be true -- use lstat()
•S_ISSOCK may not be available on very old systems
•dirent d_type is NOT the same encoding as st_mode -- different constants
•Pipes created with pipe() show as S_ISFIFO in fstat()

Use S_ISREG(mode), S_ISDIR(mode), S_ISLNK(mode) etc. on st_mode from stat()/lstat(). For symlinks, must use lstat(). Seven UNIX file types: regular, directory, symlink, char/block device, FIFO, socket.

•Seven file types tested via macros on st_mode
•S_ISLNK requires lstat, not stat

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

int main(void) {
    struct stat sb;
    lstat("/etc/passwd", &sb);
    if (S_ISREG(sb.st_mode))  printf("Regular file\n");
    if (S_ISDIR(sb.st_mode))  printf("Directory\n");
    if (S_ISLNK(sb.st_mode))  printf("Symlink\n");
    return 0;
}

Regular file

stat follows symlinks -- S_ISLNK is always false with stat()

Question 12 / 12

How do chmod() and fchmod() change file permissions, and what are common permission patterns?

chmod() and fchmod() change the permission bits of a file.

Prototypes:

#include <sys/stat.h>
int chmod(const char *pathname, mode_t mode);
int fchmod(int fd, mode_t mode);

Key differences from open() mode:

chmod() sets the EXACT permissions -- umask is NOT applied
Only the file owner or root can change permissions
chmod() follows symlinks; there is no lchmod() on most systems

Common permission patterns:

0644 (rw-r--r--)  -- regular files (readable by all, writable by owner)
0755 (rwxr-xr-x)  -- executables and directories
0600 (rw-------)   -- private files (credentials, keys)
0700 (rwx------)   -- private directories
0666 (rw-rw-rw-)   -- world-writable files (before umask)
04755 (rwsr-xr-x)  -- setuid executables (like passwd)
01777 (rwxrwxrwt)  -- sticky directories (like /tmp)

Symbolic constants:

S_IRUSR, S_IWUSR, S_IXUSR -- owner
S_IRGRP, S_IWGRP, S_IXGRP -- group
S_IROTH, S_IWOTH, S_IXOTH -- other
S_ISUID, S_ISGID, S_ISVTX -- special bits

Pseudo Code

1. chmod(path, mode) -- sets exact permissions (umask NOT applied)
2. fchmod(fd, mode) -- same but on open fd
3. Only owner or root can change permissions
4. Use symbolic constants for readability:
   S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH = 0644
5. Can toggle individual bits:
   stat(path, &sb)
   chmod(path, sb.st_mode | S_IXUSR)  -- add owner execute

Code

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

int main(void) {
    /* Create a file */
    int fd = open("script.sh", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) { perror("open"); return 1; }
    write(fd, "#!/bin/sh\necho hello\n", 21);

    /* Make executable using fchmod */
    if (fchmod(fd, 0755) == -1) perror("fchmod");
    close(fd);

    /* Verify */
    struct stat sb;
    stat("script.sh", &sb);
    printf("script.sh mode: %04o\n", (unsigned int)(sb.st_mode & 07777));
    /* Output: 0755 */

    /* Using symbolic constants */
    chmod("script.sh",
          S_IRUSR | S_IWUSR | S_IXUSR |  /* rwx for owner */
          S_IRGRP | S_IXGRP |             /* r-x for group */
          S_IROTH | S_IXOTH);             /* r-x for other */
    /* Same as 0755 */

    /* Add setuid bit */
    stat("script.sh", &sb);
    chmod("script.sh", sb.st_mode | S_ISUID);  /* setuid + existing */
    stat("script.sh", &sb);
    printf("After setuid: %04o\n", (unsigned int)(sb.st_mode & 07777));
    /* Output: 4755 */

    /* Make private (credentials file) */
    chmod("secret.key", S_IRUSR | S_IWUSR);  /* 0600 */

    unlink("script.sh");
    return 0;
}

Key Points

•chmod sets exact permissions (umask NOT applied)
•Only the file owner or root can chmod
•fchmod works on an open fd -- avoids TOCTOU races
•0644 for files, 0755 for executables, 0600 for secrets
•Use symbolic constants (S_IRUSR etc.) for readable code

Gotchas

•chmod on a symlink changes the target, not the link itself
•Setting setuid on a script has no effect on most modern UNIX systems
•The kernel clears setuid/setgid bits when a non-root user writes to a file
•fchmod avoids race conditions but the fd must be open

chmod(path, mode) sets exact permissions (no umask). fchmod(fd, mode) does the same on an open fd. Only owner or root can change permissions. Common: 0644 files, 0755 executables, 0600 secrets.

•chmod sets exact mode; umask not applied
•0644 files, 0755 executables, 0600 secrets

#include <sys/stat.h>

int main(void) {
    chmod("file.txt", 0644);      /* rw-r--r-- */
    chmod("script.sh", 0755);     /* rwxr-xr-x */
    chmod("secret.key", 0600);    /* rw------- */
    chmod("shared/", 01777);      /* sticky + rwxrwxrwx */
    return 0;
}

Kernel clears setuid/setgid bits when non-root writes to the file

Built by onllm.dev

Home GitHub Support awesomePrep