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

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
 
/**
 * Demonstrating that read() fails on directories
 */
void demonstrate_read_failure(void) {
    int fd = open("/tmp", O_RDONLY);
    if (fd == -1) {
        perror("open");
        return;
    }
    
    char buffer[1024];
    ssize_t n = read(fd, buffer, sizeof(buffer));
    
    if (n == -1) {
        // On Linux: EISDIR (Is a directory)
        // On some systems: EBADF or other error
        printf("read() on directory failed: %s (errno=%d)
", 
               strerror(errno), errno);
    }
    
    close(fd);
}
 
/**
 * The correct way: use opendir()/readdir() or getdents()
 */
#include <dirent.h>
 
void demonstrate_readdir(void) {
    DIR *dir = opendir("/tmp");
    if (dir == NULL) {
        perror("opendir");
        return;
    }
    
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        printf("Found: %s (inode: %lu)
", 
               entry->d_name, (unsigned long)entry->d_ino);
    }
    
    closedir(dir);
}

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

#include <dirent.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
 
/**
 * Basic directory listing using opendir/readdir/closedir
 */
int list_directory(const char *path) {
    DIR *dir;
    struct dirent *entry;
    
    // Open the directory stream
    dir = opendir(path);
    if (dir == NULL) {
        perror("opendir");
        return -1;
    }
    
    // Read entries one by one
    // Note: readdir() returns NULL at end-of-directory OR on error
    // To distinguish, reset errno before calling
    errno = 0;
    while ((entry = readdir(dir)) != NULL) {
        printf("%s
", entry->d_name);
        errno = 0;  // Reset for next iteration
    }
    
    // Check if we ended due to error
    if (errno != 0) {
        perror("readdir");
        closedir(dir);
        return -1;
    }
    
    closedir(dir);
    return 0;
}
 
/**
 * The dirent structure (POSIX guaranteed fields)
 *
 * struct dirent {
 *     ino_t  d_ino;       // inode number
 *     char   d_name[];    // filename (null-terminated)
 * };
 *
 * Linux extends this with additional fields (not portable):
 *   off_t  d_off;         // offset to next entry
 *   unsigned char d_type; // file type (DT_REG, DT_DIR, etc.)
 *   unsigned short d_reclen; // length of this record
 */
 
/**
 * More detailed listing using Linux d_type extension
 */
void list_directory_with_types(const char *path) {
    DIR *dir = opendir(path);
    if (!dir) {
        perror("opendir");
        return;
    }
    
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        const char *type;
        
        // d_type is a Linux extension, may not be filled on all filesystems
        switch (entry->d_type) {
            case DT_REG:  type = "file";      break;
            case DT_DIR:  type = "directory"; break;
            case DT_LNK:  type = "symlink";   break;
            case DT_CHR:  type = "char dev";  break;
            case DT_BLK:  type = "block dev"; break;
            case DT_FIFO: type = "fifo";      break;
            case DT_SOCK: type = "socket";    break;
            case DT_UNKNOWN:
            default:      type = "unknown";   break;
        }
        
        printf("[%s] %s (inode %lu)
", 
               type, entry->d_name, (unsigned long)entry->d_ino);
    }
    
    closedir(dir);
}
 
/**
 * Handling the d_type caveat
 *
 * Some filesystems (notably older NFS, some XFS configurations) 
 * don't support d_type and return DT_UNKNOWN. Always fall back
 * to stat() when d_type is DT_UNKNOWN.
 */
int is_directory(int dirfd, const char *name, unsigned char d_type) {
    if (d_type != DT_UNKNOWN) {
        return d_type == DT_DIR;
    }
    
    // Fallback: use stat
    struct stat st;
    if (fstatat(dirfd, name, &st, AT_SYMLINK_NOFOLLOW) == -1) {
        return 0;  // Assume not a directory on error
    }
    
    return S_ISDIR(st.st_mode);
}

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

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/syscall.h>
 
/**
 * Linux directory entry structure (returned by getdents64)
 */
struct linux_dirent64 {
    unsigned long long d_ino;     /* 64-bit inode number */
    long long          d_off;     /* Offset to next entry */
    unsigned short     d_reclen;  /* Length of this entry */
    unsigned char      d_type;    /* File type */
    char               d_name[];  /* Filename (null-terminated) */
};
 
/**
 * Using getdents64() directly (bypassing libc readdir)
 *
 * This is what the C library's readdir() does internally,
 * but with more control over buffer size.
 *
 * The advantage of using getdents directly:
 * - Can read multiple entries at once (more efficient)
 * - Control over buffer size
 * - Access to d_off for seeking
 */
int list_directory_getdents(const char *path) {
    int fd = open(path, O_RDONLY | O_DIRECTORY);
    if (fd == -1) {
        perror("open");
        return -1;
    }
    
    // Buffer for directory entries
    // Larger buffer = fewer system calls = better performance
    char buffer[8192];
    int nread;
    
    while ((nread = syscall(SYS_getdents64, fd, buffer, sizeof(buffer))) > 0) {
        int offset = 0;
        
        while (offset < nread) {
            struct linux_dirent64 *entry = 
                (struct linux_dirent64 *)(buffer + offset);
            
            printf("inode=%llu, reclen=%u, type=%u, name=%s
",
                   entry->d_ino,
                   entry->d_reclen,
                   entry->d_type,
                   entry->d_name);
            
            // Move to next entry
            offset += entry->d_reclen;
        }
    }
    
    if (nread == -1) {
        perror("getdents64");
        close(fd);
        return -1;
    }
    
    close(fd);
    return 0;
}
 
/**
 * Why libc readdir() uses an internal buffer
 *
 * getdents() is expensive (context switch to kernel), so libc
 * reads many entries at once and returns them one at a time:
 *
 * User calls readdir()
 *   If buffer empty or exhausted:
 *     -> Call getdents() to refill buffer
 *   Return next entry from buffer
 */

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

/**
 * Simplified DIR structure (actual implementation varies)
 */
typedef struct {
    int fd;              /* File descriptor from open() */
    char *buf;           /* Buffer for getdents() results */
    size_t buf_size;     /* Size of buffer */
    size_t buf_offset;   /* Current position in buffer */
    size_t buf_end;      /* End of valid data in buffer */
    struct dirent entry; /* Current entry (returned to user) */
} DIR;
 
/**
 * Simplified opendir() implementation
 */
DIR *opendir(const char *path) {
    int fd = open(path, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
    if (fd == -1) {
        return NULL;
    }
    
    DIR *dir = malloc(sizeof(DIR));
    if (!dir) {
        close(fd);
        return NULL;
    }
    
    dir->fd = fd;
    dir->buf_size = 32768;  /* Typical: 32KB buffer */
    dir->buf = malloc(dir->buf_size);
    dir->buf_offset = 0;
    dir->buf_end = 0;
    
    if (!dir->buf) {
        close(fd);
        free(dir);
        return NULL;
    }
    
    return dir;
}
 
/**
 * Simplified readdir() implementation
 */
struct dirent *readdir(DIR *dir) {
    /* Check if we need to refill buffer */
    if (dir->buf_offset >= dir->buf_end) {
        /* Call getdents to get more entries */
        ssize_t n = syscall(SYS_getdents64, dir->fd, 
                           dir->buf, dir->buf_size);
        if (n <= 0) {
            return NULL;  /* End of directory or error */
        }
        dir->buf_end = n;
        dir->buf_offset = 0;
    }
    
    /* Extract current entry from buffer */
    struct linux_dirent64 *linux_entry = 
        (void *)(dir->buf + dir->buf_offset);
    
    /* Copy to standard dirent structure */
    dir->entry.d_ino = linux_entry->d_ino;
    strcpy(dir->entry.d_name, linux_entry->d_name);
    /* ... copy other fields ... */
    
    /* Advance for next call */
    dir->buf_offset += linux_entry->d_reclen;
    
    return &dir->entry;
}

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

#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
/**
 * WRONG: Assuming entries come out sorted
 *
 * This is a common bug - don't do this!
 */
void wrong_assumption(const char *path) {
    DIR *dir = opendir(path);
    struct dirent *entry;
    
    while ((entry = readdir(dir)) != NULL) {
        // BUG: assuming entries are sorted, processing
        // as if first entry is "smallest"
        printf("%s
", entry->d_name);
    }
    closedir(dir);
}
 
/**
 * CORRECT: Sort entries after reading them all
 */
 
// Comparison function for qsort
int compare_dirents(const void *a, const void *b) {
    const struct dirent **da = (const struct dirent **)a;
    const struct dirent **db = (const struct dirent **)b;
    return strcmp((*da)->d_name, (*db)->d_name);
}
 
void list_sorted(const char *path) {
    DIR *dir = opendir(path);
    if (!dir) return;
    
    // First pass: count entries
    int count = 0;
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        count++;
    }
    
    // Allocate array
    struct dirent **entries = malloc(count * sizeof(struct dirent *));
    
    // Second pass: read entries
    rewinddir(dir);
    int i = 0;
    while ((entry = readdir(dir)) != NULL && i < count) {
        // Must copy because readdir returns pointer to static buffer
        entries[i] = malloc(sizeof(struct dirent));
        memcpy(entries[i], entry, sizeof(struct dirent));
        i++;
    }
    closedir(dir);
    
    // Sort
    qsort(entries, count, sizeof(struct dirent *), compare_dirents);
    
    // Print sorted
    for (i = 0; i < count; i++) {
        printf("%s
", entries[i]->d_name);
        free(entries[i]);
    }
    free(entries);
}
 
/**
 * BETTER: Use scandir() which handles allocation and sorting
 *
 * scandir() reads all entries into an allocated array and
 * can apply a filter and/or sort function.
 */
#include <dirent.h>
 
void list_sorted_scandir(const char *path) {
    struct dirent **namelist;
    int n;
    
    // alphasort is a standard comparison function
    // All entries pass (no filter) and are sorted alphabetically
    n = scandir(path, &namelist, NULL, alphasort);
    if (n == -1) {
        perror("scandir");
        return;
    }
    
    for (int i = 0; i < n; i++) {
        printf("%s
", namelist[i]->d_name);
        free(namelist[i]);
    }
    free(namelist);
}
 
/**
 * Custom filter example: only show regular files
 */
int file_filter(const struct dirent *entry) {
    // Skip . and ..
    if (entry->d_name[0] == '.' && 
        (entry->d_name[1] == '\0' || 
         (entry->d_name[1] == '.' && entry->d_name[2] == '\0'))) {
        return 0;
    }
    
    // Only include regular files (requires d_type support)
    return entry->d_type == DT_REG;
}
 
void list_files_only(const char *path) {
    struct dirent **namelist;
    int n = scandir(path, &namelist, file_filter, alphasort);
    
    if (n == -1) {
        perror("scandir");
        return;
    }
    
    printf("Regular files in %s:
", path);
    for (int i = 0; i < n; i++) {
        printf("  %s
", namelist[i]->d_name);
        free(namelist[i]);
    }
    free(namelist);
}

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

#include <dirent.h>
#include <stdio.h>
 
/**
 * rewinddir() - Reset to beginning of directory
 *
 * This is the most reliable positioning function.
 * It's guaranteed to work correctly.
 */
void demonstrate_rewinddir(const char *path) {
    DIR *dir = opendir(path);
    
    // First scan: count entries
    int count = 0;
    while (readdir(dir) != NULL) {
        count++;
    }
    printf("Found %d entries
", count);
    
    // Reset to beginning
    rewinddir(dir);
    
    // Second scan: print entries
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        printf("%s
", entry->d_name);
    }
    
    closedir(dir);
}
 
/**
 * telldir()/seekdir() - Save and restore position
 *
 * WARNING: These functions have portability and reliability issues!
 * The position is only valid for the lifetime of the DIR stream.
 * Directory modifications may invalidate saved positions.
 */
void demonstrate_telldir_seekdir(const char *path) {
    DIR *dir = opendir(path);
    struct dirent *entry;
    long saved_pos = -1;
    
    // Find a specific entry and save its position
    while ((entry = readdir(dir)) != NULL) {
        if (strcmp(entry->d_name, "target_file.txt") == 0) {
            saved_pos = telldir(dir);
            printf("Found target at position %ld
", saved_pos);
            break;
        }
    }
    
    // Continue reading...
    while ((entry = readdir(dir)) != NULL) {
        printf("After target: %s
", entry->d_name);
    }
    
    // Seek back to saved position
    if (saved_pos != -1) {
        seekdir(dir, saved_pos);
        entry = readdir(dir);
        if (entry) {
            printf("Back to: %s
", entry->d_name);
        }
    }
    
    closedir(dir);
}
 
/**
 * The Problems with telldir/seekdir:
 *
 * 1. Position format is implementation-defined (may be offset,
 *    may be cookie, may be something else entirely)
 * 
 * 2. Positions are only valid for the same DIR stream
 *    - Can't save position, close, reopen, and seek
 *
 * 3. Directory modifications may invalidate positions
 *    - Adding/removing entries can shift positions
 *    - Many implementations don't handle this well
 *
 * 4. Some filesystems (especially FUSE, network FS) have trouble
 *    implementing seekdir reliably
 *
 * RECOMMENDATION: Avoid telldir/seekdir unless absolutely necessary.
 * Instead, reread the directory or build an in-memory index.
 */

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

#include <dirent.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
 
/**
 * Optimization 1: Use d_type to avoid stat() calls
 *
 * Many operations only need to know if an entry is a file or directory.
 * Using d_type avoids the expensive stat() syscall per entry.
 */
void list_directories_fast(const char *path) {
    DIR *dir = opendir(path);
    if (!dir) return;
    
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        // Skip . and ..
        if (entry->d_name[0] == '.' && 
            (entry->d_name[1] == '\0' || 
             (entry->d_name[1] == '.' && entry->d_name[2] == '\0'))) {
            continue;
        }
        
        // Use d_type if available - much faster than stat()
        if (entry->d_type == DT_DIR) {
            printf("[DIR] %s
", entry->d_name);
        } else if (entry->d_type == DT_UNKNOWN) {
            // Fallback for filesystems without d_type support
            struct stat st;
            fstatat(dirfd(dir), entry->d_name, &st, 0);
            if (S_ISDIR(st.st_mode)) {
                printf("[DIR] %s
", entry->d_name);
            }
        }
    }
    
    closedir(dir);
}
 
/**
 * Optimization 2: Use openat/fstatat pattern
 *
 * Opening the directory once and using *at() functions
 * avoids repeated path concatenation and parsing.
 */
void list_with_sizes(const char *path) {
    DIR *dir = opendir(path);
    if (!dir) return;
    
    // Get the fd for the directory
    int dfd = dirfd(dir);
    
    struct dirent *entry;
    struct stat st;
    
    while ((entry = readdir(dir)) != NULL) {
        if (entry->d_name[0] == '.' && 
            (entry->d_name[1] == '\0' || 
             (entry->d_name[1] == '.' && entry->d_name[2] == '\0'))) {
            continue;
        }
        
        // fstatat is more efficient than building path + stat()
        if (fstatat(dfd, entry->d_name, &st, AT_SYMLINK_NOFOLLOW) == 0) {
            printf("%10ld %s
", (long)st.st_size, entry->d_name);
        }
    }
    
    closedir(dir);
}
 
/**
 * Optimization 3: Streaming vs collecting
 *
 * For operations that don't need all entries at once:
 * - Process entries as they're read
 * - Don't allocate memory for the full list
 * - Start outputting before finishing enumeration
 */
void count_files_streaming(const char *path) {
    DIR *dir = opendir(path);
    if (!dir) return;
    
    int file_count = 0;
    int dir_count = 0;
    
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        switch (entry->d_type) {
            case DT_REG: file_count++; break;
            case DT_DIR: dir_count++; break;
            default: break;
        }
    }
    
    closedir(dir);
    
    // Only need counters, not the entire list
    printf("Files: %d, Directories: %d
", file_count, dir_count - 2);
}
 
/**
 * Optimization 4: Parallel processing for large directories
 *
 * For directories with thousands of entries where each
 * entry requires expensive processing (like checksumming):
 * - Read entries in batches
 * - Dispatch batches to worker threads
 * - Overlap I/O with processing
 */

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

#include <windows.h>
#include <stdio.h>
 
/**
 * FindFirstFileW / FindNextFileW pattern
 *
 * Key differences from POSIX:
 * - Uses a search pattern (supports wildcards)
 * - Returns full metadata, not just name/inode
 * - No separate stat() needed
 * - Handle-based, not stream-based
 */
void list_directory_windows(const wchar_t *path) {
    WIN32_FIND_DATAW findData;
    wchar_t searchPath[MAX_PATH];
    
    // Build search pattern: "path\*"
    swprintf(searchPath, MAX_PATH, L"%s\\*", path);
    
    // Start enumeration
    HANDLE hFind = FindFirstFileW(searchPath, &findData);
    if (hFind == INVALID_HANDLE_VALUE) {
        DWORD error = GetLastError();
        if (error == ERROR_FILE_NOT_FOUND) {
            wprintf(L"Directory is empty: %s
", path);
        } else if (error == ERROR_PATH_NOT_FOUND) {
            wprintf(L"Directory not found: %s
", path);
        } else {
            wprintf(L"FindFirstFile failed: %lu
", error);
        }
        return;
    }
    
    do {
        // Skip . and ..
        if (wcscmp(findData.cFileName, L".") == 0 ||
            wcscmp(findData.cFileName, L"..") == 0) {
            continue;
        }
        
        wchar_t type[16];
        if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
            wcscpy(type, L"[DIR]");
        } else {
            wcscpy(type, L"[FILE]");
        }
        
        // WIN32_FIND_DATA includes size, timestamps, attributes
        ULARGE_INTEGER fileSize;
        fileSize.LowPart = findData.nFileSizeLow;
        fileSize.HighPart = findData.nFileSizeHigh;
        
        wprintf(L"%-8s %12llu %s
", 
                type, fileSize.QuadPart, findData.cFileName);
        
    } while (FindNextFileW(hFind, &findData));
    
    // Check if we ended due to no more files or error
    DWORD error = GetLastError();
    if (error != ERROR_NO_MORE_FILES) {
        wprintf(L"FindNextFile failed: %lu
", error);
    }
    
    FindClose(hFind);
}
 
/**
 * WIN32_FIND_DATAW structure includes:
 *   - dwFileAttributes (file/dir/system/hidden/etc.)
 *   - ftCreationTime, ftLastAccessTime, ftLastWriteTime
 *   - nFileSizeHigh, nFileSizeLow (64-bit file size)
 *   - cFileName (name up to MAX_PATH)
 *   - cAlternateFileName (8.3 short name)
 *
 * This is more efficient than POSIX readdir() + stat()
 * because all metadata comes in one operation.
 */
 
/**
 * Pattern matching support
 *
 * Unlike POSIX opendir/readdir, Windows FindFirstFile
 * supports glob patterns: *.txt, data_*.csv, etc.
 */
void list_cpp_files(const wchar_t *path) {
    WIN32_FIND_DATAW findData;
    wchar_t searchPath[MAX_PATH];
    
    // Search for *.cpp files only
    swprintf(searchPath, MAX_PATH, L"%s\\*.cpp", path);
    
    HANDLE hFind = FindFirstFileW(searchPath, &findData);
    if (hFind == INVALID_HANDLE_VALUE) {
        return;
    }
    
    wprintf(L"C++ source files:
");
    do {
        wprintf(L"  %s
", findData.cFileName);
    } while (FindNextFileW(hFind, &findData));
    
    FindClose(hFind);
}
 
/**
 * FindFirstFileExW for more control
 *
 * Provides options for:
 * - Case sensitivity
 * - Large fetch (better performance)
 * - Filtering (directories only, etc.)
 */
void list_directories_only(const wchar_t *path) {
    WIN32_FIND_DATAW findData;
    wchar_t searchPath[MAX_PATH];
    swprintf(searchPath, MAX_PATH, L"%s\\*", path);
    
    // FindExInfoBasic: don't retrieve 8.3 names (faster)
    // FindExSearchLimitToDirectories: only directories
    HANDLE hFind = FindFirstFileExW(
        searchPath,
        FindExInfoBasic,             // Less info = faster
        &findData,
        FindExSearchLimitToDirectories,  // Dirs only
        NULL,
        FIND_FIRST_EX_LARGE_FETCH   // Optimized buffering
    );
    
    if (hFind == INVALID_HANDLE_VALUE) {
        return;
    }
    
    do {
        if (findData.cFileName[0] != L'.') {  // Skip . and ..
            wprintf(L"[DIR] %s
", findData.cFileName);
        }
    } while (FindNextFileW(hFind, &findData));
    
    FindClose(hFind);
}