To execute C programs in Linux, follow these steps:
Step 1: Install GCC Compiler (If Not Installed)
GCC (GNU Compiler Collection) is used to compile C programs.
Check if GCC is installed by running:
gcc --version
If GCC is not installed, install it using:
Ubuntu/Debian:
sudo apt update && sudo apt install gcc
Step 2: Write a C Program
Create a C file using a text editor.
For example, use nano or vim:
nano example.c
Write a simple C program inside:
#include <stdio.h>
int main() {
printf("Hello, Linux System Calls!\n");
return 0;
}
Save the file (CTRL + X, then Y, then Enter in nano).
Step 3: Compile the C Program
Use the gcc command to compile:
gcc example.c -o example
example.c → Source file.
-o example → Output executable named example.
If there are no errors, this will generate an executable file called example.
Step 4: Run the Compiled Program
Execute the compiled program using:
./example
Expected Output:
Hello, Linux System Calls!
Step 5: Debugging (If Needed)
If you get errors, check the error messages and fix them.
For debugging, you can compile with -g for GDB (GNU Debugger):
gcc -g example.c -o example
Run the program in GDB:
gdb ./example
Step 6: Run a Program with Required Permissions
If a program requires root privileges (e.g., system file access), use:
sudo ./example
Additional Compilation Flags
1. Enable Warnings:
2. gcc -Wall example.c -o example
3. Optimize Performance:
4. gcc -O2 example.c -o example
5. Enable Debugging Mode:
6. gcc -g example.c -o example
File Operations (open, read, write, close, fcntl, seek, stat)
These functions are used to perform file operations such as opening, reading, writing,
seeking, and getting file information.
(1) open() - Open a File
fd = open("example.txt", O_CREAT | O_RDWR, 0644);
Opens or creates a file for reading and writing.
Parameters:
o "example.txt" → File name.
o O_CREAT → Creates the file if it does not exist.
o O_RDWR → Opens the file for both reading and writing.
o 0644 → Sets file permissions:
6 (110) → Read & Write for owner.
4 (100) → Read for group.
4 (100) → Read for others.
Returns:
o A file descriptor (integer) if successful.
o -1 on failure.
(2) write() - Write to a File
write(fd, "Hello, Linux System Calls!", 26);
Writes data to the file.
Parameters:
o fd → File descriptor.
o "Hello, Linux System Calls!" → Data to write.
o 26 → Number of bytes to write.
Returns:
o Number of bytes written.
o -1 on failure.
(3) lseek() - Move File Pointer
lseek(fd, 0, SEEK_SET);
Moves the file pointer to a specified position.
Parameters:
o fd → File descriptor.
o 0 → Offset (position in bytes).
o SEEK_SET → Moves to the start of the file.
Returns:
o New file offset on success.
o -1 on failure.
(4) read() - Read from a File
read(fd, buffer, 26);
Reads data from the file.
Parameters:
o fd → File descriptor.
o buffer → Buffer to store the data.
o 26 → Number of bytes to read.
Returns:
o Number of bytes read.
o 0 if end-of-file is reached.
o -1 on failure.
(5) stat() - Get File Information
struct stat file_stat;
stat("example.txt", &file_stat);
printf("File size: %ld bytes\n", file_stat.st_size);
Retrieves file metadata (size, permissions, timestamps, etc.).
Parameters:
o "example.txt" → File name.
o &file_stat → Pointer to a stat structure to store file info.
Returns:
o 0 on success.
o -1 on failure.
(6) close() - Close a File
close(fd);
Closes the file and releases system resources.
Parameters:
o fd → File descriptor.
Returns:
o 0 on success.
o -1 on failure.
2. Directory Handling Functions
These functions are used for working with directories.
(1) opendir() - Open a Directory
DIR *dir = opendir(".");
Opens a directory stream.
Parameters:
o "." → Current directory.
Returns:
o A pointer to DIR structure if successful.
o NULL on failure.
(2) readdir() - Read Directory Entries
while ((entry = readdir(dir)) != NULL) {
printf("%s\n", entry->d_name);
}
Reads entries (files, directories) from a directory stream.
Parameters:
o dir → Pointer to the directory stream.
Returns:
o A pointer to a dirent structure containing:
entry->d_name → File or directory name.
o NULL when all entries are read.
(3) closedir() - Close a Directory
closedir(dir);
Closes the directory stream.
Parameters:
o dir → Pointer to the directory stream.
Returns:
o 0 on success.
o -1 on failure.
Functio Description Parameters Return Value
n
open() Opens or creates a File name, flags, File descriptor or -1 on
file permissions failure
write() Writes data to a file File descriptor, buffer, size Bytes written or -1 on
failure
lseek() Moves file pointer File descriptor, offset, New offset or -1 on
mode failure
read() Reads data from a File descriptor, buffer, size Bytes read or -1 on
file failure
stat() Retrieves file File name, pointer to stat 0 on success, -1 on
information structure failure
close() Closes a file File descriptor 0 on success, -1 on
failure
opendir() Opens a directory Directory name DIR * or NULL on
failure
readdir() Reads directory Pointer to DIR stream dirent * or NULL when
entries finished
closedir() Closes a directory Pointer to DIR stream 0 on success, -1 on
failure
Program: File Handling in Linux (open, read, write, close, lseek, fcntl, stat)
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
int main() {
int fd;
char buffer[100];
// Open a file for reading and writing (create if it doesn’t exist)
fd = open("example.txt", O_CREAT | O_RDWR, 0644);
if (fd == -1) {
perror("Error opening file");
return 1;
}
// Writing to the file
write(fd, "Hello, Linux System Calls!", 26);
// Seek to the beginning
lseek(fd, 0, SEEK_SET);
// Reading from the file
read(fd, buffer, 26);
buffer[26] = '\0';
printf("Read from file: %s\n", buffer);
// Get file information
struct stat file_stat;
if (stat("example.txt", &file_stat) == 0) {
printf("File size: %ld bytes\n", file_stat.st_size);
}
// Close the file
close(fd);
return 0;
}
Compile & Run:
gcc file_handling.c -o file_handling
./file_handling
Step-by-Step Explanation of the Programs
Code:
#include <stdio.h> // For standard input/output functions
#include <fcntl.h> // For file control options (open, fcntl)
#include <unistd.h> // For system calls (read, write, close, lseek)
#include <sys/stat.h> // For file information (stat)
These header files provide functions for handling files, performing read/write
operations, and retrieving file metadata.
Step 1: Opening a File
fd = open("example.txt", O_CREAT | O_RDWR, 0644);
open() is used to open or create a file.
O_CREAT: Creates the file if it does not exist.
O_RDWR: Opens the file for both reading and writing.
0644: Sets file permissions (read/write for owner, read-only for others).
If open() fails, it returns -1.
Step 2: Writing to the File
write(fd, "Hello, Linux System Calls!", 26);
write(fd, buffer, size) writes size bytes from buffer to the file descriptor fd.
Here, we write "Hello, Linux System Calls!" (26 characters) to the file.
Step 3: Moving the File Pointer
lseek(fd, 0, SEEK_SET);
lseek() moves the file pointer.
SEEK_SET moves the pointer to the beginning of the file.
This ensures the next read() operation starts from the beginning.
Step 4: Reading from the File
read(fd, buffer, 26);
buffer[26] = '\0';
printf("Read from file: %s\n", buffer);
read(fd, buffer, size) reads size bytes from fd into buffer.
We add '\0' at the end to make it a valid string for printing.
Step 5: Getting File Information
struct stat file_stat;
if (stat("example.txt", &file_stat) == 0) {
printf("File size: %ld bytes\n", file_stat.st_size);
}
stat() retrieves file details (size, permissions, timestamps).
file_stat.st_size gives the file size.
Step 6: Closing the File
close(fd);
close(fd) releases the file descriptor.
How to Compile & Run
gcc file_handling.c -o file_handling
./file_handling
Compiles the program and runs it.
Directory Operations (opendir, readdir, closedir)
Program: Directory Listing in Linux
#include <stdio.h>
#include <dirent.h>
int main() {
struct dirent *entry;
DIR *dir = opendir(".");
if (dir == NULL) {
perror("Error opening directory");
return 1;
}
printf("Files in the current directory:\n");
while ((entry = readdir(dir)) != NULL) {
printf("%s\n", entry->d_name);
}
closedir(dir);
return 0;
}
Compile & Run:
gcc dir_listing.c -o dir_listing
./dir_listing
Step-by-Step Explanation of the Programs
Step 1: Opening the Directory
DIR *dir = opendir(".");
opendir() opens a directory.
"." represents the current directory.
If the directory fails to open, it returns NULL.
Step 2: Reading Directory Entries
while ((entry = readdir(dir)) != NULL) {
printf("%s\n", entry->d_name);
}
readdir() reads directory entries one by one.
entry->d_name gives the file/directory name.
Step 3: Closing the Directory
closedir(dir);
closedir() closes the directory stream.
How to Compile & Run
gcc dir_listing.c -o dir_listing
./dir_listing
Lists files in the current directory.
Final Output Example
Files in the current directory:
file_handling.c
dir_listing.c
example.txt
