Directory Operations

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

#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
 
/**
 * Method 1: open() with O_CREAT flag
 * The modern, preferred approach for file creation.
 *
 * Key flags:
 *   O_CREAT  - Create file if it doesn't exist
 *   O_EXCL   - Fail if file already exists (atomic creation)
 *   O_TRUNC  - Truncate to zero length if file exists
 *   O_WRONLY - Open for writing only
 *   O_RDWR   - Open for reading and writing
 */
int create_file_open(const char *path) {
    // Create new file with rw-r--r-- permissions
    // O_EXCL ensures atomic creation: no race conditions
    int fd = open(path, 
                  O_CREAT | O_EXCL | O_WRONLY,
                  S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    
    if (fd == -1) {
        if (errno == EEXIST) {
            fprintf(stderr, "File already exists: %s
", path);
        } else if (errno == EACCES) {
            fprintf(stderr, "Permission denied: %s
", path);
        } else if (errno == ENOENT) {
            fprintf(stderr, "Parent directory doesn't exist: %s
", path);
        } else if (errno == ENOSPC) {
            fprintf(stderr, "No space left on device
");
        }
        return -1;
    }
    
    return fd;  // Caller must close(fd) when done
}
 
/**
 * Method 2: creat() - Legacy system call
 * Equivalent to: open(path, O_CREAT | O_WRONLY | O_TRUNC, mode)
 *
 * Note: creat() truncates existing files, making it unsuitable
 * for atomic file creation. Prefer open() with O_EXCL.
 */
int create_file_creat(const char *path) {
    int fd = creat(path, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        perror("creat failed");
        return -1;
    }
    return fd;
}
 
/**
 * Safe file creation with proper atomic semantics
 * This pattern ensures no race conditions between checking
 * for existence and creating the file.
 */
int safe_create_new_file(const char *path, mode_t mode) {
    int fd = open(path, O_CREAT | O_EXCL | O_RDWR, mode);
    
    if (fd == -1 && errno == EEXIST) {
        // File was created by another process between our
        // check and create - this is NOT a race condition
        // because O_EXCL makes the check-and-create atomic
        return -1;
    }
    
    return fd;
}

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

#include <windows.h>
#include <stdio.h>
 
/**
 * CreateFile() - The universal Windows file operation
 *
 * CreationDisposition values:
 *   CREATE_NEW     - Create new; fail if exists (like O_CREAT|O_EXCL)
 *   CREATE_ALWAYS  - Create new; truncate if exists (like O_CREAT|O_TRUNC)
 *   OPEN_EXISTING  - Open existing; fail if doesn't exist
 *   OPEN_ALWAYS    - Open if exists, create if doesn't
 *   TRUNCATE_EXISTING - Open and truncate; fail if doesn't exist
 */
HANDLE create_file_windows(const wchar_t *path) {
    HANDLE hFile = CreateFileW(
        path,                          // File path
        GENERIC_READ | GENERIC_WRITE,  // Access mode
        0,                             // Share mode (0 = exclusive)
        NULL,                          // Security attributes
        CREATE_NEW,                    // Creation disposition
        FILE_ATTRIBUTE_NORMAL,         // File attributes
        NULL                           // Template file
    );
    
    if (hFile == INVALID_HANDLE_VALUE) {
        DWORD error = GetLastError();
        if (error == ERROR_FILE_EXISTS) {
            wprintf(L"File already exists: %s
", path);
        } else if (error == ERROR_ACCESS_DENIED) {
            wprintf(L"Access denied: %s
", path);
        } else if (error == ERROR_PATH_NOT_FOUND) {
            wprintf(L"Path not found: %s
", path);
        } else if (error == ERROR_DISK_FULL) {
            wprintf(L"Disk full
");
        }
        return INVALID_HANDLE_VALUE;
    }
    
    return hFile;  // Caller must CloseHandle(hFile) when done
}
 
/**
 * Atomic file creation with security descriptor
 * More production-ready example with ownership control
 */
HANDLE create_secure_file(const wchar_t *path) {
    SECURITY_ATTRIBUTES sa;
    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
    sa.lpSecurityDescriptor = NULL;  // Default security
    sa.bInheritHandle = FALSE;       // Not inherited by child processes
    
    HANDLE hFile = CreateFileW(
        path,
        GENERIC_WRITE,
        FILE_SHARE_READ,              // Allow others to read
        &sa,
        CREATE_NEW,                   // Fail if exists
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH,
        NULL
    );
    
    return hFile;
}

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

/**
 * Simplified path resolution algorithm (Linux namei)
 *
 * Given: "/home/user/documents/report.txt"
 *
 * Goal: Find the dentry for "/home/user/documents" (parent)
 *       and extract "report.txt" (final component)
 */
struct path_resolution_result {
    struct dentry *parent_dentry;  // Parent directory
    struct inode  *parent_inode;   // Parent inode  
    const char    *final_name;     // "report.txt"
    int           name_len;        // Length of final name
};
 
int resolve_path_for_create(const char *path, 
                            struct path_resolution_result *result) {
    struct dentry *current_dentry;
    struct inode *current_inode;
    
    // Step 1: Determine starting point
    if (path[0] == '/') {
        // Absolute path: start from root
        current_dentry = current->fs->root.dentry;
    } else {
        // Relative path: start from cwd
        current_dentry = current->fs->pwd.dentry;
    }
    current_inode = current_dentry->d_inode;
    
    // Step 2: Walk each path component (except the last)
    const char *component = path;
    while (has_more_components(component)) {
        // Extract next component: "home", then "user", then "documents"
        char name[NAME_MAX];
        int len = extract_next_component(component, name);
        
        // Check execute permission on current directory
        if (!may_exec(current_inode)) {
            return -EACCES;  // Permission denied
        }
        
        // Look up component in current directory
        struct dentry *next = lookup_in_directory(current_dentry, name, len);
        
        if (next == NULL) {
            return -ENOENT;  // Component doesn't exist
        }
        
        // Handle symbolic links (follow them in most cases)
        if (is_symlink(next->d_inode)) {
            next = follow_symlink(next);
            if (next == NULL) {
                return -ELOOP;  // Too many symlinks
            }
        }
        
        // Ensure it's a directory (for intermediate components)
        if (!S_ISDIR(next->d_inode->i_mode)) {
            return -ENOTDIR;  // Not a directory
        }
        
        current_dentry = next;
        current_inode = next->d_inode;
        component = advance_past_component(component, len);
    }
    
    // Step 3: Extract final component (don't look it up yet)
    result->parent_dentry = current_dentry;
    result->parent_inode = current_inode;
    result->final_name = component;  // "report.txt"
    result->name_len = strlen(component);
    
    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

/**
 * Initialize a newly allocated inode for file creation
 */
void init_inode_for_new_file(struct inode *inode, 
                             mode_t mode,
                             struct inode *parent_dir) {
    struct timespec now;
    current_time(&now);
    
    // Determine effective UID/GID
    uid_t uid = current_fsuid();
    gid_t gid;
    
    if (parent_dir->i_mode & S_ISGID) {
        // Parent has setgid: inherit parent's group
        gid = parent_dir->i_gid;
    } else {
        gid = current_fsgid();
    }
    
    // Apply umask to mode
    mode_t effective_mode = S_IFREG | (mode & ~current_umask() & 0777);
    
    // Initialize inode fields
    inode->i_mode = effective_mode;
    inode->i_uid = uid;
    inode->i_gid = gid;
    inode->i_size = 0;
    inode->i_nlink = 1;        // Will be incremented when dir entry is added
    inode->i_blocks = 0;       // No data blocks yet
    
    // Set all timestamps to now
    inode->i_atime = now;      // Access time
    inode->i_mtime = now;      // Modification time
    inode->i_ctime = now;      // Status change time
    
    // Clear all block pointers
    memset(inode->i_block, 0, sizeof(inode->i_block));
    
    // Inherit some flags from parent
    inode->i_flags = parent_dir->i_flags & (FS_NODUMP_FL | FS_NOATIME_FL);
}

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

#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <sys/stat.h>
 
/**
 * Basic file deletion using unlink()
 *
 * unlink() removes the directory entry, decrements the inode's
 * link count, and if the link count reaches zero AND no processes
 * have the file open, the file's data blocks are freed.
 */
int delete_file(const char *path) {
    if (unlink(path) == -1) {
        switch (errno) {
            case EACCES:
                fprintf(stderr, "No write permission on parent directory
");
                break;
            case EBUSY:
                fprintf(stderr, "File is in use by system
");
                break;
            case EISDIR:
                fprintf(stderr, "Path is a directory (use rmdir())
");
                break;
            case ENOENT:
                fprintf(stderr, "File doesn't exist
");
                break;
            case EPERM:
                fprintf(stderr, "Sticky bit restriction
");
                break;
            case EROFS:
                fprintf(stderr, "File system is read-only
");
                break;
            default:
                perror("unlink failed");
        }
        return -1;
    }
    return 0;
}
 
/**
 * Demonstrating the difference between unlink and actual deletion
 *
 * This shows that a file's data persists as long as any process
 * has the file open, even after unlink() has removed the name.
 */
void demonstrate_unlink_semantics(void) {
    const char *path = "/tmp/test_unlink.txt";
    
    // Step 1: Create and open a file
    int fd = open(path, O_CREAT | O_RDWR, 0644);
    if (fd == -1) {
        perror("open");
        return;
    }
    
    // Step 2: Write some data
    const char *data = "This data survives unlink!";
    write(fd, data, strlen(data));
    
    // Step 3: Unlink the file (remove the name)
    // The file now has no name, but still exists because fd is open
    if (unlink(path) == -1) {
        perror("unlink");
        close(fd);
        return;
    }
    
    printf("File unlinked. It no longer appears in directory listings.
");
    printf("But we can still access it through the open file descriptor!
");
    
    // Step 4: Seek back and read
    lseek(fd, 0, SEEK_SET);
    char buffer[100];
    ssize_t n = read(fd, buffer, sizeof(buffer) - 1);
    buffer[n] = '\0';
    printf("Data read from 'deleted' file: %s
", buffer);
    
    // At this point, the file has:
    // - 0 directory entries (it's invisible)
    // - 1 open file descriptor (our fd)
    // - Data intact on disk
    
    // Step 5: Close the file descriptor
    // NOW the file is truly deleted
    close(fd);
    printf("File descriptor closed. File and data truly deleted.
");
}

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

#include <stdio.h>
 
/**
 * remove() - Standard C library function for deletion
 *
 * Internally calls:
 *   unlink(path) for regular files
 *   rmdir(path)  for directories
 *
 * This is the most portable way to delete files/directories.
 */
int delete_portable(const char *path) {
    if (remove(path) != 0) {
        perror("remove failed");
        return -1;
    }
    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

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
 
/**
 * unlinkat() - Delete file relative to a directory fd
 *
 * Advantages over unlink():
 * 1. Race-condition-free path operations
 * 2. Works with O_PATH file descriptors
 * 3. Can delete directories with AT_REMOVEDIR flag
 *
 * Parameters:
 *   dirfd - File descriptor of directory (or AT_FDCWD for cwd)
 *   path  - Path relative to dirfd
 *   flags - 0 for files, AT_REMOVEDIR for directories
 */
int secure_delete_in_directory(int dirfd, const char *filename) {
    if (unlinkat(dirfd, filename, 0) == -1) {
        perror("unlinkat failed");
        return -1;
    }
    return 0;
}
 
/**
 * Delete a directory using unlinkat
 * Equivalent to rmdir() but relative to a directory fd
 */
int secure_rmdir_in_directory(int dirfd, const char *dirname) {
    if (unlinkat(dirfd, dirname, AT_REMOVEDIR) == -1) {
        perror("unlinkat(AT_REMOVEDIR) failed");
        return -1;
    }
    return 0;
}
 
/**
 * Why dirfd-based operations are more secure:
 *
 * Traditional approach (race-prone):
 *   chdir("/safe/directory");
 *   unlink("secret_file");  // What if cwd changed between calls?
 *
 * Secure approach:
 *   int dirfd = open("/safe/directory", O_RDONLY | O_DIRECTORY);
 *   unlinkat(dirfd, "secret_file", 0);  // Always relative to dirfd
 *   close(dirfd);
 */
void demonstrate_secure_deletion(void) {
    // Open the directory (without changing cwd)
    int dirfd = open("/tmp/safe_dir", O_RDONLY | O_DIRECTORY);
    if (dirfd == -1) {
        perror("open directory");
        return;
    }
    
    // Delete files relative to the directory fd
    // Even if another process modifies our cwd, this is safe
    if (unlinkat(dirfd, "file1.txt", 0) == -1) {
        perror("unlinkat");
    }
    
    // Delete an empty subdirectory
    if (unlinkat(dirfd, "empty_subdir", AT_REMOVEDIR) == -1) {
        perror("unlinkat directory");
    }
    
    close(dirfd);
}

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

/**
 * Journaled file creation (ext4 style)
 *
 * The journal is a circular log of intended operations.
 * Operations become permanent only after journal commit.
 */
int journaled_create_file(const char *path, mode_t mode) {
    struct journal_handle *handle;
    struct inode *new_inode;
    struct dentry *parent_dentry;
    
    /* Phase 1: Start Transaction */
    handle = journal_start(sb->s_journal, credits_needed);
    if (IS_ERR(handle)) {
        return PTR_ERR(handle);
    }
    
    /* Phase 2: Perform Operations (writes go to journal buffer) */
    
    // Allocate new inode
    new_inode = alloc_inode(sb);
    if (!new_inode) {
        journal_abort(handle);
        return -ENOSPC;
    }
    
    // Initialize inode
    init_inode_for_new_file(new_inode, mode, parent_dir);
    
    // Record modified inode to journal
    journal_get_write_access(handle, inode_block_buffer);
    
    // Add directory entry
    result = add_dirent(parent_dentry, name, new_inode);
    if (result < 0) {
        journal_abort(handle);
        free_inode(new_inode);
        return result;
    }
    
    // Record modified directory blocks to journal
    journal_get_write_access(handle, dir_block_buffer);
    
    /* Phase 3: Commit Transaction */
    // This writes all changes to the journal and marks complete
    journal_stop(handle);
    
    /* 
     * At this point, the journal contains a complete record
     * of the file creation. If we crash now, recovery will:
     * 1. Read the journal
     * 2. See this transaction is complete
     * 3. Replay it to the actual disk locations
     * 4. Mark the journal entry as applied
     */
    
    /* Phase 4: Writeback (may happen later) */
    // Eventually, the actual disk blocks are updated
    // and the journal entry is discarded
    
    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

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
 
/**
 * Truly durable file creation pattern
 *
 * After this function returns successfully, the file is
 * guaranteed to survive any subsequent crash or power loss.
 */
int create_file_durable(const char *path, const char *content) {
    // Step 1: Open parent directory
    char parent_path[PATH_MAX];
    get_parent_directory(path, parent_path);
    int dirfd = open(parent_path, O_RDONLY | O_DIRECTORY);
    if (dirfd == -1) {
        perror("open parent dir");
        return -1;
    }
    
    // Step 2: Create and write the file
    int fd = open(path, O_CREAT | O_EXCL | O_WRONLY, 0644);
    if (fd == -1) {
        perror("open");
        close(dirfd);
        return -1;
    }
    
    ssize_t written = write(fd, content, strlen(content));
    if (written < 0) {
        perror("write");
        close(fd);
        close(dirfd);
        unlink(path);  // Clean up partial file
        return -1;
    }
    
    // Step 3: fsync the file to flush data and metadata
    if (fsync(fd) == -1) {
        perror("fsync file");
        close(fd);
        close(dirfd);
        return -1;
    }
    close(fd);
    
    // Step 4: fsync the directory to ensure the entry is durable
    // This is the step most applications forget!
    if (fsync(dirfd) == -1) {
        perror("fsync directory");
        close(dirfd);
        return -1;
    }
    close(dirfd);
    
    // Now the file creation is fully durable
    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

#include <errno.h>
#include <sys/stat.h>
#include <string.h>
#include <libgen.h>
 
/**
 * Create file with parent directory creation if needed
 * Similar to "mkdir -p" + touch behavior
 */
int create_file_with_parents(const char *path, mode_t mode) {
    // Try to create the file directly first
    int fd = open(path, O_CREAT | O_EXCL | O_WRONLY, mode);
    if (fd >= 0) {
        return fd;  // Success on first try
    }
    
    if (errno != ENOENT) {
        return -1;  // Some other error
    }
    
    // Parent doesn't exist - need to create directories
    char *path_copy = strdup(path);
    char *parent = dirname(path_copy);
    
    // Recursively create parent directories
    if (create_directories_recursive(parent, 0755) == -1) {
        free(path_copy);
        return -1;
    }
    free(path_copy);
    
    // Now try again
    fd = open(path, O_CREAT | O_EXCL | O_WRONLY, mode);
    return fd;
}
 
/**
 * Recursively create directories (like mkdir -p)
 */
int create_directories_recursive(const char *path, mode_t mode) {
    struct stat st;
    
    // Check if already exists
    if (stat(path, &st) == 0) {
        if (S_ISDIR(st.st_mode)) {
            return 0;  // Already a directory
        }
        errno = ENOTDIR;  // Exists but not a directory
        return -1;
    }
    
    if (errno != ENOENT) {
        return -1;  // Some other error
    }
    
    // Recursively create parent first
    char *path_copy = strdup(path);
    char *parent = dirname(path_copy);
    
    if (strcmp(parent, ".") != 0 && strcmp(parent, "/") != 0) {
        if (create_directories_recursive(parent, mode) == -1) {
            free(path_copy);
            return -1;
        }
    }
    free(path_copy);
    
    // Create this directory
    if (mkdir(path, mode) == -1) {
        if (errno == EEXIST) {
            // Race condition: another process created it
            return 0;
        }
        return -1;
    }
    
    return 0;
}
 
/**
 * Delete file with retry for transient errors
 */
int delete_file_robust(const char *path, int max_retries) {
    for (int attempt = 0; attempt < max_retries; attempt++) {
        if (unlink(path) == 0) {
            return 0;  // Success
        }
        
        switch (errno) {
            case ENOENT:
                return 0;  // Already deleted - success
                
            case ETXTBSY:
            case EBUSY:
                // Transient - wait and retry
                usleep(100000 * (attempt + 1));  // Exponential backoff
                continue;
                
            case EACCES:
            case EPERM:
            case EROFS:
                // Permanent - no point retrying
                return -1;
                
            default:
                // Unknown - try once more
                if (attempt < max_retries - 1) {
                    continue;
                }
                return -1;
        }
    }
    
    return -1;  // Exhausted retries
}