sdbsc.c

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>      // for open()
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdbool.h>
#include <errno.h>


#define MIN_STD_ID 1
#define MAX_STD_ID 100000
#define MIN_STD_GPA 0
#define MAX_STD_GPA 400

/* Filenames for the active database and temporary (compressed) db */
#define DB_FILE "student.db"
#define TMP_DB_FILE ".tmp_student.db"

/* Our student record is exactly 64 bytes.
   We store an integer id (4 bytes), an integer gpa (4 bytes) and two fixed-length strings.
   Using 28 bytes each for first and last names gives:
      4 + 4 + 28 + 28 = 64 bytes.
*/
typedef struct{
    int id;           // 4 bytes
    int gpa;          // 4 bytes; store gpa as an integer (e.g. 345 means 3.45)
    char fname[28];   // 28 bytes
    char lname[28];   // 28 bytes
} student_t;

#define RECORD_SIZE (sizeof(student_t))
#define DB_SIZE (100000 * RECORD_SIZE)

/* Exit codes: note that all error cases exit with status 1 */
#define EXIT_OK         0
#define EXIT_FAIL_ARGS  1
#define EXIT_FAIL_DB    1

/* Function return codes */
#define NO_ERROR         0
#define ERR_DB_FILE     -1
#define ERR_DB_OP       -2
#define SRCH_NOT_FOUND  -3
#define NOT_IMPLEMENTED_YET -4

/* Messages (exact text as expected by the tests) */
#define M_ERR_DB_OPEN         "Error opening database file.\n"
#define M_ERR_DB_READ         "Error reading from database file.\n"
#define M_ERR_DB_WRITE        "Error writing to database file.\n"
#define M_ERR_DB_ADD_DUP      "Cant add student with ID=%d, already exists in db.\n"
#define M_STD_ADDED           "Student %d added to database.\n"
#define M_STD_DEL_MSG         "Student %d was deleted from database.\n"
#define M_STD_NOT_FND_MSG     "Student %d was not found in database.\n"
#define M_ERR_STD_RNG         "Error: Student ID or GPA out of range.\n"
#define M_ERR_STD_PRINT       "Error: Cannot print invalid student.\n"
#define M_DB_EMPTY            "Database contains no student records.\n"
#define M_DB_RECORD_CNT       "Database contains %d student record(s).\n"
#define M_DB_ZERO_OK          "Database file zeroed.\n"
#define M_DB_COMPRESSED_OK    "Database successfully compressed!\n"

/* Strings used for printing a student record.
   Note: the header and record formatting must match the test expectations. */
#define STUDENT_PRINT_HDR_STRING "ID FIRST_NAME LAST_NAME GPA\n"
#define STUDENT_PRINT_FMT_STRING "%d %s %s %.2f\n"


int open_db(char *dbFile, bool should_truncate);
int get_student(int fd, int id, student_t *s);
int add_student(int fd, int id, char *fname, char *lname, int gpa);
int del_student(int fd, int id);
int count_db_records(int fd);
int print_db(int fd);
void print_student(student_t *s);
int compress_db(int fd);
int validate_range(int id, int gpa);
void usage(char *exename);

/*
 * open_db
 *  Opens (or creates) the database file with read/write access.
 *  If should_truncate is true the file is re-created (zeroed) and then pre-allocated to DB_SIZE bytes.
 *  Otherwise, if the file is new (or not already DB_SIZE bytes long) it is extended (with zeros) to DB_SIZE bytes.
 *
 * Returns the file descriptor on success, or ERR_DB_FILE on failure.
 * On error prints M_ERR_DB_OPEN.
 */
int open_db(char *dbFile, bool should_truncate)
{
    // Set permissions: rw-rw----
    mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;

    // Open for read/write and create if necessary.
    int flags = O_RDWR | O_CREAT;
    if (should_truncate)
        flags |= O_TRUNC;

    int fd = open(dbFile, flags, mode);
    if (fd == -1)
    {
        printf(M_ERR_DB_OPEN);
        return ERR_DB_FILE;
    }

    // If the file was just created or we are truncating, preallocate to DB_SIZE bytes.
    struct stat st;
    if (fstat(fd, &st) == -1)
    {
        printf(M_ERR_DB_READ);
        close(fd);
        return ERR_DB_FILE;
    }
    if (st.st_size != DB_SIZE)
    {
        if (ftruncate(fd, DB_SIZE) == -1)
        {
            printf(M_ERR_DB_WRITE);
            close(fd);
            return ERR_DB_FILE;
        }
    }
    return fd;
}

/*
 * get_student
 *   Reads the student record for the given id.
 *   If the record is empty (all zeros) returns SRCH_NOT_FOUND.
 *
 * Returns NO_ERROR on success, ERR_DB_FILE on I/O error, or SRCH_NOT_FOUND if not found.
 */
int get_student(int fd, int id, student_t *s)
{
    off_t offset = (id - MIN_STD_ID) * RECORD_SIZE;
    if (lseek(fd, offset, SEEK_SET) == -1)
        return ERR_DB_FILE;
    ssize_t bytesRead = read(fd, s, RECORD_SIZE);
    if (bytesRead != RECORD_SIZE)
        return ERR_DB_FILE;  // unexpected read error

    student_t empty;
    memset(&empty, 0, RECORD_SIZE);
    if (memcmp(s, &empty, RECORD_SIZE) == 0)
        return SRCH_NOT_FOUND;
    return NO_ERROR;
}

/*
 * add_student
 *   Adds a student to the database at the slot corresponding to its id.
 *   If the slot is already occupied, prints an error and returns ERR_DB_OP.
 *
 * Returns NO_ERROR on success, ERR_DB_FILE on I/O error, or ERR_DB_OP if student exists.
 */
int add_student(int fd, int id, char *fname, char *lname, int gpa)
{
    off_t offset = (id - MIN_STD_ID) * RECORD_SIZE;
    student_t existing;

    /* Seek to the proper offset in the file */
    if (lseek(fd, offset, SEEK_SET) == -1) {
        printf(M_ERR_DB_READ);
        return ERR_DB_FILE;
    }
    
    /* Read the existing record */
    if (read(fd, &existing, RECORD_SIZE) != RECORD_SIZE) {
        printf(M_ERR_DB_READ);
        return ERR_DB_FILE;
    }
    
    /* Create an empty record to compare against */
    student_t empty;
    memset(&empty, 0, RECORD_SIZE);
    
    /* If the record is not empty, a student already exists */
    if (memcmp(&existing, &empty, RECORD_SIZE) != 0) {
        printf(M_ERR_DB_ADD_DUP, id);
        return ERR_DB_OP;
    }
    
    /* Prepare the new student record */
    student_t new_student;
    memset(&new_student, 0, RECORD_SIZE);
    new_student.id = id;
    new_student.gpa = gpa;
    
    /* Copy the names safely into the record */
    strncpy(new_student.fname, fname, sizeof(new_student.fname) - 1);
    new_student.fname[sizeof(new_student.fname) - 1] = '\0';
    strncpy(new_student.lname, lname, sizeof(new_student.lname) - 1);
    new_student.lname[sizeof(new_student.lname) - 1] = '\0';
    
    /* Seek back to the record location and write the new record */
    if (lseek(fd, offset, SEEK_SET) == -1) {
        printf(M_ERR_DB_WRITE);
        return ERR_DB_FILE;
    }
    if (write(fd, &new_student, RECORD_SIZE) != RECORD_SIZE) {
        printf(M_ERR_DB_WRITE);
        return ERR_DB_FILE;
    }
    
    /* Success */
    printf(M_STD_ADDED, id);
    return NO_ERROR;
}

/*
 * del_student
 *   Deletes the student with the given id by writing an empty record (all zeros) in its place.
 *   If the student does not exist, prints an error.
 *
 * Returns NO_ERROR on success, ERR_DB_FILE on I/O error, or ERR_DB_OP if student not found.
 */
int del_student(int fd, int id)
{
    student_t student;
    int rc = get_student(fd, id, &student);
    if (rc == SRCH_NOT_FOUND)
    {
        printf(M_STD_NOT_FND_MSG, id);
        return ERR_DB_OP;
    }
    else if (rc != NO_ERROR)
    {
        printf(M_ERR_DB_READ);
        return ERR_DB_FILE;
    }
    student_t empty;
    memset(&empty, 0, RECORD_SIZE);
    off_t offset = (id - MIN_STD_ID) * RECORD_SIZE;
    if (lseek(fd, offset, SEEK_SET) == -1)
    {
        printf(M_ERR_DB_WRITE);
        return ERR_DB_FILE;
    }
    if (write(fd, &empty, RECORD_SIZE) != RECORD_SIZE)
    {
        printf(M_ERR_DB_WRITE);
        return ERR_DB_FILE;
    }
    printf(M_STD_DEL_MSG, id);
    return NO_ERROR;
}

/*
 * count_db_records
 *   Scans through the entire database file (all 100000 records) and counts the number of valid (non‑empty) records.
 *
 * If count is zero, prints M_DB_EMPTY; otherwise prints M_DB_RECORD_CNT with the count.
 *
 * Returns the count on success or ERR_DB_FILE on error.
 */
int count_db_records(int fd)
{
    if (lseek(fd, 0, SEEK_SET) == -1)
    {
        printf(M_ERR_DB_READ);
        return ERR_DB_FILE;
    }
    int count = 0;
    student_t student;
    student_t empty;
    memset(&empty, 0, RECORD_SIZE);
    ssize_t bytesRead;
    for (int i = 0; i < 100000; i++) {
        bytesRead = read(fd, &student, RECORD_SIZE);
        if (bytesRead != RECORD_SIZE)
        {
            printf(M_ERR_DB_READ);
            return ERR_DB_FILE;
        }
        if (memcmp(&student, &empty, RECORD_SIZE) != 0)
            count++;
    }
    if (count == 0)
        printf(M_DB_EMPTY);
    else
        printf(M_DB_RECORD_CNT, count);
    return count;
}

/*
 * print_db
 *   Scans the entire database file and prints all valid student records.
 *   For the first valid record found, prints the header first.
 *
 * Returns NO_ERROR on success, or ERR_DB_FILE on error.
 */
int print_db(int fd)
{
    if (lseek(fd, 0, SEEK_SET) == -1)
    {
        printf(M_ERR_DB_READ);
        return ERR_DB_FILE;
    }
    student_t student;
    student_t empty;
    memset(&empty, 0, RECORD_SIZE);
    bool headerPrinted = false;
    bool anyRecord = false;
    ssize_t bytesRead;
    for (int i = 0; i < 100000; i++) {
        bytesRead = read(fd, &student, RECORD_SIZE);
        if (bytesRead != RECORD_SIZE)
        {
            printf(M_ERR_DB_READ);
            return ERR_DB_FILE;
        }
        if (memcmp(&student, &empty, RECORD_SIZE) != 0)
        {
            if (!headerPrinted)
            {
                printf(STUDENT_PRINT_HDR_STRING);
                headerPrinted = true;
            }
            float realGpa = student.gpa / 100.0;
            printf(STUDENT_PRINT_FMT_STRING, student.id, student.fname, student.lname, realGpa);
            anyRecord = true;
        }
    }
    if (!anyRecord)
        printf(M_DB_EMPTY);
    return NO_ERROR;
}

/*
 * print_student
 *   If the provided student pointer is valid (non-NULL and id nonzero), prints the header then the record.
 *   Otherwise prints M_ERR_STD_PRINT.
 */
void print_student(student_t *s)
{
    if (s == NULL || s->id == 0)
    {
        printf(M_ERR_STD_PRINT);
        return;
    }
    printf(STUDENT_PRINT_HDR_STRING);
    float realGpa = s->gpa / 100.0;
    printf(STUDENT_PRINT_FMT_STRING, s->id, s->fname, s->lname, realGpa);
}

/*
 * compress_db
 *   (Extra credit) Compresses the database file by copying only valid records into a temporary file,
 *   then renames that file to be the active database.
 *
 * Returns the file descriptor of the new database on success, or ERR_DB_FILE on failure.
 */
int compress_db(int fd)
{
    // Open temporary file.
    mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
    int tmp_fd = open(TMP_DB_FILE, O_RDWR | O_CREAT | O_TRUNC, mode);
    if (tmp_fd == -1)
    {
        printf(M_ERR_DB_OPEN);
        return ERR_DB_FILE;
    }

    if (lseek(fd, 0, SEEK_SET) == -1)
    {
        printf(M_ERR_DB_READ);
        close(tmp_fd);
        return ERR_DB_FILE;
    }
    student_t student;
    student_t empty;
    memset(&empty, 0, RECORD_SIZE);
    ssize_t bytesRead;
    // Copy only valid records.
    for (int i = 0; i < 100000; i++) {
        bytesRead = read(fd, &student, RECORD_SIZE);
        if (bytesRead != RECORD_SIZE)
        {
            printf(M_ERR_DB_READ);
            close(tmp_fd);
            return ERR_DB_FILE;
        }
        if (memcmp(&student, &empty, RECORD_SIZE) != 0)
        {
            if (write(tmp_fd, &student, RECORD_SIZE) != RECORD_SIZE)
            {
                printf(M_ERR_DB_WRITE);
                close(tmp_fd);
                return ERR_DB_FILE;
            }
        }
    }
    close(fd);
    close(tmp_fd);
    // Rename the temporary file to the active database file.
    if (rename(TMP_DB_FILE, DB_FILE) == -1)
    {
        printf(M_ERR_DB_WRITE);
        return ERR_DB_FILE;
    }
    int new_fd = open_db(DB_FILE, false);
    if (new_fd < 0)
    {
        printf(M_ERR_DB_OPEN);
        return ERR_DB_FILE;
    }
    printf(M_DB_COMPRESSED_OK);
    return new_fd;
}

/*
 * validate_range
 *   Validates that the provided id and gpa are within the allowed ranges.
 *
 * Returns NO_ERROR if valid, or EXIT_FAIL_ARGS otherwise.
 */
int validate_range(int id, int gpa)
{
    if ((id < MIN_STD_ID) || (id > MAX_STD_ID))
        return EXIT_FAIL_ARGS;
    if ((gpa < MIN_STD_GPA) || (gpa > MAX_STD_GPA))
        return EXIT_FAIL_ARGS;
    return NO_ERROR;
}

/*
 * usage
 *   Prints the proper usage for this program.
 */
void usage(char *exename)
{
    printf("usage: %s -[h|a|c|d|f|p|x|z] options.  Where:\n", exename);
    printf("\t-h:  prints help\n");
    printf("\t-a id first_name last_name gpa(as 3 digit int):  adds a student\n");
    printf("\t-c:  counts the records in the database\n");
    printf("\t-d id:  deletes a student\n");
    printf("\t-f id:  finds and prints a student in the database\n");
    printf("\t-p:  prints all records in the student database\n");
    printf("\t-x:  compress the database file [EXTRA CREDIT]\n");
    printf("\t-z:  zero db file (remove all records)\n");
}

/*============================================================*/
/*                           MAIN                             */
/*============================================================*/
int main(int argc, char *argv[])
{
    char opt;
    int fd;
    int rc;
    int exit_code = EXIT_OK;
    int id, gpa;
    student_t student = {0};

    if (argc < 2 || argv[1][0] != '-')
    {
        usage(argv[0]);
        exit(EXIT_FAIL_ARGS);
    }

    opt = argv[1][1];

    if (opt == 'h')
    {
        usage(argv[0]);
        exit(EXIT_OK);
    }

    /* For most options open the db without truncation.
       (For -z we will reopen with truncation.) */
    fd = open_db(DB_FILE, false);
    if (fd < 0)
        exit(EXIT_FAIL_DB);

    switch(opt)
    {
        case 'a':
            // Expect: prog -a id first_name last_name gpa
            if (argc != 6)
            {
                usage(argv[0]);
                exit_code = EXIT_FAIL_ARGS;
                break;
            }
            id = atoi(argv[2]);
            gpa = atoi(argv[5]);
            if (validate_range(id, gpa) != NO_ERROR)
            {
                printf(M_ERR_STD_RNG);
                exit_code = EXIT_FAIL_ARGS;
                break;
            }
            rc = add_student(fd, id, argv[3], argv[4], gpa);
            if (rc < 0)
                exit_code = EXIT_FAIL_DB;
            break;

        case 'c':
            rc = count_db_records(fd);
            if (rc < 0)
                exit_code = EXIT_FAIL_DB;
            break;

        case 'd':
            if (argc != 3)
            {
                usage(argv[0]);
                exit_code = EXIT_FAIL_ARGS;
                break;
            }
            id = atoi(argv[2]);
            rc = del_student(fd, id);
            if (rc < 0)
                exit_code = EXIT_FAIL_DB;
            break;

        case 'f':
            if (argc != 3)
            {
                usage(argv[0]);
                exit_code = EXIT_FAIL_ARGS;
                break;
            }
            id = atoi(argv[2]);
            rc = get_student(fd, id, &student);
            if (rc == NO_ERROR)
                print_student(&student);
            else if (rc == SRCH_NOT_FOUND)
            {
                printf(M_STD_NOT_FND_MSG, id);
                exit_code = EXIT_FAIL_DB;
            }
            else
            {
                printf(M_ERR_DB_READ);
                exit_code = EXIT_FAIL_DB;
            }
            break;

        case 'p':
            rc = print_db(fd);
            if (rc < 0)
                exit_code = EXIT_FAIL_DB;
            break;

        case 'x':
            // compress the database file (extra credit)
            fd = compress_db(fd);
            if (fd < 0)
                exit_code = EXIT_FAIL_DB;
            break;

        case 'z':
            // Zero the db: close and reopen with truncation.
            close(fd);
            fd = open_db(DB_FILE, true);
            if (fd < 0)
            {
                exit_code = EXIT_FAIL_DB;
                break;
            }
            printf(M_DB_ZERO_OK);
            exit_code = EXIT_OK;
            break;

        default:
            usage(argv[0]);
            exit_code = EXIT_FAIL_ARGS;
    }

    close(fd);
    exit(exit_code);
}