The errno.h header in C programming

1. What is errno?

In C programming, errno.h is the header file that you include in your source code to access the errno variable and its predefined error macros such as ENOENT, EACCES, etc. The errno variable itself is a global integer that is set by certain system calls and library functions when an error occurs, indicating the specific error that took place.

The errno variable is thread-local in most modern C libraries, so its value is unique per thread rather than shared globally across all threads.

2. List of common errors and macros

errno.h defines a set of macros, each representing a unique error code. Below is a unified list of errno error codes, including some that may not be present on all systems or that are platform-specific (e.g., GNU/Hurd, Linux, BSD, etc.). The descriptions give an overview of each error’s meaning. Always refer to your platform’s documentation for exact usage and numeric values.

The exact set of error codes varies by platform, but all conforming C implementations will have at least a core subset of these.

3. Checking errno in practice

Below is an example of opening a file using fopen() and checking errno if the operation fails. We can use the C library functions perror() or strerror() to print human-readable messages describing the error.

// errno_example.c
#include 
#include 
#include 

int main(void) {
    FILE *fp = fopen("nonexistent.txt", "r");
    if (!fp) {
        // fp is NULL, so an error occurred
        fprintf(stderr, "Error opening file: %s\n", strerror(errno));
        // or use perror("Error opening file");
        return 1;
    }

    // Perform file operations...
    
    fclose(fp);
    return 0;
}

In this code, if fopen() fails, the program prints an error message indicating the reason, as dictated by errno. The function strerror(errno) translates the numeric errno into a descriptive string (e.g., "No such file or directory").

4. Error handling recommendations

• Check return values: always check the return values of functions known to set errno (e.g., fopen, read, write, malloc in some cases, etc.).
• Use perror or strerror: these functions clarify numeric error codes for easier debugging or user feedback.
• Don’t overwrite errno prematurely: if you need to make multiple library calls after an error occurs, store the errno value somewhere before calling other functions that might reset it.
• Thread awareness: in modern implementations, errno is thread-local, so you can safely use it in multi-threaded applications without conflict.

5. Conclusion

By consulting errno after a failed call, you can branch your code to handle specific conditions or provide clear diagnostics to users. Although errno has a global scope, modern implementations ensure it’s maintained per-thread, making it safe for concurrent applications. Together with perror() and strerror(), you can troubleshoot and handle a wide array of system and library errors in your C programs.