C Error Handling: Using errno and perror()

Error handling is a crucial aspect of writing robust and reliable C programs. When things go wrong, it's essential to have mechanisms in place to detect, report, and handle errors gracefully. In this comprehensive guide, we'll explore two powerful tools in C's error handling arsenal: errno and perror(). These functions work together to provide detailed information about errors that occur during program execution.

Table of Contents

Understanding errno

The errno is a global integer variable defined in the <errno.h> header file. It's set by system calls and some library functions to indicate what went wrong when an error occurs.

🔍 Key Point: errno is not cleared on successful function calls, so it should only be checked immediately after a function call that's known to set it.

Let's start with a simple example to demonstrate how errno works:

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

int main() {
    FILE *file = fopen("nonexistent_file.txt", "r");
    if (file == NULL) {
        printf("Error number: %d\n", errno);
        printf("Error message: %s\n", strerror(errno));
    } else {
        fclose(file);
    }
    return 0;
}

In this example, we're trying to open a file that doesn't exist. When fopen() fails, it sets errno to indicate the reason for the failure. We then print the error number and use strerror() to get a human-readable error message.

Output:

Error number: 2
Error message: No such file or directory

Common errno Values

Here's a table of some common errno values you might encounter:

errno Value	Symbolic Constant	Description
1	EPERM	Operation not permitted
2	ENOENT	No such file or directory
3	ESRCH	No such process
4	EINTR	Interrupted system call
5	EIO	I/O error
13	EACCES	Permission denied
22	EINVAL	Invalid argument

💡 Tip: The complete list of errno values can be found in the <errno.h> header file on your system.

Introducing perror()

While errno provides the error code, perror() is a convenient function that prints a description of the last error that occurred. It's defined in <stdio.h> and takes a single argument: a string that's printed before the error message.

Let's modify our previous example to use perror():

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

int main() {
    FILE *file = fopen("nonexistent_file.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
    } else {
        fclose(file);
    }
    return 0;
}

Output:

Error opening file: No such file or directory

As you can see, perror() automatically prints the error message associated with the current errno value, making our error reporting more concise and readable.

Practical Examples of Error Handling

Let's explore some more practical examples to demonstrate error handling in various scenarios.

Example 1: File Operations

In this example, we'll attempt to read from a file and handle potential errors:

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

int main() {
    FILE *file = fopen("sample.txt", "r");
    if (file == NULL) {
        fprintf(stderr, "Error opening file: %s\n", strerror(errno));
        return 1;
    }

    char buffer[100];
    if (fgets(buffer, sizeof(buffer), file) == NULL) {
        if (ferror(file)) {
            fprintf(stderr, "Error reading file: %s\n", strerror(errno));
            fclose(file);
            return 1;
        } else if (feof(file)) {
            printf("File is empty.\n");
        }
    } else {
        printf("First line of file: %s", buffer);
    }

    fclose(file);
    return 0;
}

This program attempts to open a file named "sample.txt" and read its first line. It handles several potential error scenarios:

If the file can't be opened, it prints an error message using strerror(errno).
If fgets() fails, it checks whether it's due to an error or end-of-file condition.
If successful, it prints the first line of the file.

Example 2: Memory Allocation

Memory allocation failures are another common source of errors. Let's see how to handle them:

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

int main() {
    // Attempt to allocate a large amount of memory
    char *large_buffer = malloc(1000000000000);
    if (large_buffer == NULL) {
        fprintf(stderr, "Memory allocation failed: %s\n", strerror(errno));
        return 1;
    }

    // If successful, use the buffer
    printf("Memory allocation successful!\n");
    free(large_buffer);

    return 0;
}

In this example, we're trying to allocate a very large amount of memory. If the allocation fails, malloc() will return NULL and set errno. We check for this condition and print an error message if it occurs.

Example 3: Network Programming

Error handling is particularly important in network programming. Here's an example of creating a socket and handling potential errors:

#include <stdio.h>
#include <sys/socket.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("Error creating socket");
        return 1;
    }

    // Attempt to bind to a reserved port (requires root privileges)
    struct sockaddr_in addr = {0};
    addr.sin_family = AF_INET;
    addr.sin_port = htons(80);
    addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        fprintf(stderr, "Bind failed: %s\n", strerror(errno));
        close(sockfd);
        return 1;
    }

    printf("Socket bound successfully!\n");
    close(sockfd);
    return 0;
}

This program attempts to create a socket and bind it to port 80 (which typically requires root privileges). It demonstrates error handling for both the socket() and bind() system calls.

Best Practices for Error Handling

To wrap up, here are some best practices for error handling in C:

🔍 Always check return values: Many C functions indicate errors through their return values. Always check these values.
📊 Use errno immediately: Check errno immediately after a function call that's known to set it. Its value may be overwritten by subsequent successful function calls.
🖨️ Provide informative error messages: Use perror() or strerror(errno) to provide meaningful error messages to the user.
🧹 Clean up resources: If an error occurs, make sure to free any allocated resources (close files, free memory, etc.) before exiting.
🔄 Consider error recovery: When appropriate, try to recover from errors rather than immediately terminating the program.
📝 Log errors: In larger applications, consider logging errors to a file for later analysis.

By mastering errno and perror(), and following these best practices, you'll be well-equipped to handle errors effectively in your C programs, making them more robust and user-friendly.

Remember, good error handling is not just about preventing crashes—it's about providing a smooth experience for your users and making your life easier when debugging issues. Happy coding!