Directories: creating, removing, changing directories – mkdir, rmdir,
chdir
In Linux, the system calls mkdir, rmdir, and chdir are used to perform operations on
directories at a low level, typically within a C program or other system-level
programming environments. Here’s a brief overview of each:
1. Creating Directories (mkdir)
The mkdir system call is used to create a new directory.
Prototype: int mkdir(const char *pathname, mode_t mode);
Parameters:
o pathname: The path to the directory you want to create.
o mode: The permissions for the new directory (e.g., 0755).
Return Value:
o Returns 0 on success.
o Returns -1 on failure, and errno is set to indicate the error.
Example:
#include <sys/stat.h>
#include <sys/types.h>
int result = mkdir("/path/to/directory", 0755);
if (result == -1) {
// Handle error
}
2. Removing Directories (rmdir)
The rmdir system call is used to remove an empty directory.
Prototype: int rmdir(const char *pathname);
Parameters:
o pathname: The path to the directory you want to remove.
Return Value:
o Returns 0 on success.
o Returns -1 on failure, and errno is set to indicate the error.
Example:
#include <unistd.h>
int result = rmdir("/path/to/directory");
if (result == -1) {
// Handle error
}
3. Changing Directories (chdir)
The chdir system call changes the current working directory of the calling process.
Prototype: int chdir(const char *path);
Parameters:
o path: The path to the directory you want to change to.
Return Value:
o Returns 0 on success.
o Returns -1 on failure, and errno is set to indicate the error.
Example:
#include <unistd.h>
int result = chdir("/path/to/directory");
if (result == -1) {
// Handle error
}
Summary:
mkdir: Creates a new directory.
rmdir: Removes an empty directory.
chdir: Changes the current working directory.
These system calls are fundamental for directory management in low-level
programming on Linux, providing direct interaction with the file system.
Obtaining Current Working Directory – getcwd, directory
contents
In Linux, you can obtain the current working directory using the getcwd system call
and list the contents of a directory using system calls like opendir, readdir, and
closedir. Here's how these work:
1. Obtaining the Current Working Directory (getcwd)
The getcwd system call is used to get the current working directory of the calling
process.
Prototype: char *getcwd(char *buf, size_t size);
Parameters:
o buf: A pointer to a buffer where the current working directory path will
be stored.
o size: The size of the buffer.
Return Value:
o Returns buf on success.
o Returns NULL on failure, and errno is set to indicate the error.
Example:
#include <unistd.h>
#include <stdio.h>
#include <limits.h>
int main() {
char cwd[PATH_MAX];
if (getcwd(cwd, sizeof(cwd)) != NULL) {
printf("Current working directory: %s\n", cwd);
} else {
perror("getcwd() error");
}
return 0;
}
2. Listing Directory Contents Using System Calls
To list the contents of a directory, you typically use the following system calls:
opendir: Opens a directory for reading.
readdir: Reads the next directory entry.
closedir: Closes the directory stream.
opendir: Opening a Directory
Prototype: DIR *opendir(const char *name);
Parameters:
o name: The path of the directory you want to open.
Return Value:
o Returns a pointer to a DIR structure on success.
o Returns NULL on failure, and errno is set to indicate the error.
readdir: Reading Directory Entries
Prototype: struct dirent *readdir(DIR *dirp);
Parameters:
o dirp: A pointer to the DIR structure returned by opendir.
Return Value:
o Returns a pointer to a struct dirent on success.
o Returns NULL when the end of the directory is reached or on error.
struct dirent: This structure typically contains fields like:
o d_name: Name of the directory entry (file or subdirectory).
o d_ino: Inode number.
o (Note: struct dirent may have additional fields depending on the
system.)
closedir: Closing a Directory
Prototype: int closedir(DIR *dirp);
Parameters:
o dirp: A pointer to the DIR structure returned by opendir.
Return Value:
o Returns 0 on success.
o Returns -1 on failure, and errno is set to indicate the error.
Example: Listing Directory Contents
#include <stdio.h>
#include <dirent.h>
int main() {
DIR *d;
struct dirent *dir;
d = opendir("/path/to/directory");
if (d) {
while ((dir = readdir(d)) != NULL) {
printf("%s\n", dir->d_name);
}
closedir(d);
} else {
perror("opendir() error");
}
return 0;
}
Summary:
getcwd: Retrieves the current working directory.
opendir: Opens a directory for reading.
readdir: Reads the contents of the directory.
closedir: Closes the directory stream.
These system calls are essential for navigating and managing directories
programmatically in Linux at a low level.
Scanning Directories – opendir, readdir, closedir, rewinddir
functions
In Linux, scanning directories involves using a combination of system calls to open,
read, and close directory streams, as well as resetting the directory stream to the
beginning. Here’s a detailed overview of the functions opendir, readdir, closedir,
and rewinddir:
1. Opening a Directory (opendir)
The opendir function opens a directory for reading and returns a pointer to a DIR
structure that represents the directory stream.
Prototype: DIR *opendir(const char *name);
Parameters:
o name: The path of the directory to be opened.
Return Value:
o Returns a pointer to a DIR structure on success.
o Returns NULL on failure, and errno is set to indicate the error.
Example:
DIR *dir = opendir("/path/to/directory");
if (dir == NULL) {
perror("opendir");
return 1;
}
2. Reading Directory Entries (readdir)
The readdir function reads the next entry in the directory stream opened by
opendir.
Prototype: struct dirent *readdir(DIR *dirp);
Parameters:
o dirp: A pointer to the DIR structure returned by opendir.
Return Value:
o Returns a pointer to a struct dirent on success.
o Returns NULL when the end of the directory is reached or on error.
struct dirent: This structure typically contains fields like:
o d_name: Name of the directory entry (file or subdirectory).
o d_ino: Inode number.
o (Other fields may be present depending on the system.)
Example:
struct dirent *entry;
while ((entry = readdir(dir)) != NULL) {
printf("%s\n", entry->d_name);
}
3. Rewinding the Directory Stream (rewinddir)
The rewinddir function resets the position of the directory stream to the beginning,
allowing you to re-read the directory entries from the start.
Prototype: void rewinddir(DIR *dirp);
Parameters:
o dirp: A pointer to the DIR structure returned by opendir.
Return Value:
o This function does not return a value.
Example:
rewinddir(dir);
4. Closing a Directory (closedir)
The closedir function closes the directory stream and frees the resources associated
with it.
Prototype: int closedir(DIR *dirp);
Parameters:
o dirp: A pointer to the DIR structure returned by opendir.
Return Value:
o Returns 0 on success.
o Returns -1 on failure, and errno is set to indicate the error.
Example:
if (closedir(dir) == -1) {
perror("closedir");
return 1;
}
Example: Scanning a Directory
Here’s a complete example that demonstrates opening a directory, reading its
contents, rewinding the directory stream, and closing it:
#include <stdio.h>
#include <dirent.h>
int main() {
DIR *dir;
struct dirent *entry;
// Open the directory
dir = opendir("/path/to/directory");
if (dir == NULL) {
perror("opendir");
return 1;
}
// Read and print directory entries
while ((entry = readdir(dir)) != NULL) {
printf("%s\n", entry->d_name);
}
// Rewind and read again
rewinddir(dir);
printf("Re-reading directory entries:\n");
while ((entry = readdir(dir)) != NULL) {
printf("%s\n", entry->d_name);
}
// Close the directory
if (closedir(dir) == -1) {
perror("closedir");
return 1;
}
return 0;
}
Summary:
opendir: Opens a directory stream.
readdir: Reads the next entry from the directory stream.
rewinddir: Resets the directory stream to the beginning.
closedir: Closes the directory stream.
These functions are essential for directory manipulation in C programs on Linux,
providing the means to efficiently scan and manage directory contents.
