access command in linux with examples

The ‘access’ command in Linux is a system call used to determine whether the calling process has access to a specified file or directory. This function is useful for checking file permissions, including whether a file exists, and if it can be read, written, or executed by the process. The check is performed using the real user ID (UID) and group ID (GID) of the calling process, making it an essential tool for verifying permissions in various programming and scripting scenarios.

Syntax of the access Function

int access (const char *pathname, int mode);

where,

• pathname: This argument specifies the path to the file or directory you want to check.
• mode: This argument specifies the type of access to check for. It can include one or more of the following flags:
  • F_OK flag: Used to check for the existence of a file.
  • R_OK flag: Used to check for read permission bit.
  • W_OK flag: Used to check for write permission bit.
  • X_OK flag: Used to check for execute permission bit.

Return Value:

• The ‘access’ function returns ‘0’ if the file has the requested access permissions.
• It returns ‘-1’ if the file does not have the requested permissions or if the file does not exist. In such cases, the global variable ‘errno’ is set to indicate the error.

‘access’ Command Examples in Linux

Let us look at some of the examples of ‘access’ command in Linux to better understand the concept.

Example 1: Checking for File Existence (F_OK Flag)

The first example demonstrates how to use the ‘access’ function to check if a file exists in the current directory using the ‘F_OK’ flag.

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

extern int errno;

int main(int argc, const char *argv[]) {
    int fd = access("sample.txt", F_OK);
    if (fd == -1) {
        printf("Error Number: %d\n", errno);
        perror("Error Description:");
    } else {
        printf("No error\n");
    }
    return 0;
}

Explanation: In the output, we get the message “No error” because the file is present in the current directory. If the file does not exist, the value of fd will become -1. In the above code, the only possible way we will get an error is if the file doesn’t exist for the specified path. It can also give an error if the pathname is too long.

Note: perror() is used to print the error and errno is used to print the error code.

Example 2 : Check for all permission bits (read, write, execute)

The following example demonstrates checking multiple permissions (read, write, and execute) using bitwise OR (|) and bitwise AND (&) operations.

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

extern int errno;

int main(int argc, const char *argv[]) {
    int fd = access("sample.txt", (R_OK | W_OK) & X_OK);
    if (fd == -1) {
        printf("Error Number: %d\n", errno);
        perror("Error Description:");
    } else {
        printf("No error\n");
    }
    return 0;
}

Explanation: In the output, the write and execute user permission bits were set and since we were testing for a case where (R_OK | W_OK) & X_OK, we get no error. The file descriptor value is 0. We can use bitwise operations to decide the mode argument in access () system call.

Example 3: Demonstrating an Error When Required Permissions Are Not Set

Check for all permission bits (read, write, execute) to demonstrate how the code functions, when we get an error.

#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

extern int errno;

int main(int argc, const char *argv[]) {
    int fd = access("sample.txt", R_OK & W_OK & X_OK);
    if (fd == -1) {
        printf("Error Number: %d\n", errno);
        perror("Error Description:");
    } else {
        printf("No error\n");
    }
    return 0;
}

Here, fd = -1 and we get the error message for the reason of failure of the calling process.

Explanation: In this example, the program attempts to check for read, write, and execute permissions using the bitwise AND operation. Since the permissions required are strict, the check fails if any of the permissions are missing, resulting in an error. This shows how the ‘access’ function can be used to validate strict access requirements and handle errors appropriately.

Conclusion

The ‘access’ command is a powerful tool in Linux programming for checking file permissions and existence. By utilizing the ‘access’ function, you can ensure your programs and scripts have the necessary permissions to operate on files, and handle errors gracefully when permissions are not met. Its flexibility in checking various permission bits makes it an essential function for developers working with file operations in Linux.