libcpio/src/cpio.c

/*
 * Copyright 2017, Data61, CSIRO (ABN 41 687 119 230)
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <cpio/cpio.h>

#ifndef NULL
#define NULL ((void *)0)
#endif

struct cpio_header_info {
    char const *filename;
    unsigned long filesize;
    const void *data;
    const struct cpio_header *next;
};

/* Align 'n' up to the value 'align', which must be a power of two. */
static unsigned long align_up(unsigned long n, unsigned long align)
{
    return (n + align - 1) & (~(align - 1));
}

/* Parse an ASCII hex string into an integer. */
static unsigned long parse_hex_str(const char *s, unsigned int max_len)
{
    unsigned long r = 0;
    unsigned long i;

    for (i = 0; i < max_len; i++) {
        r *= 16;
        if (s[i] >= '0' && s[i] <= '9') {
            r += s[i] - '0';
        }  else if (s[i] >= 'a' && s[i] <= 'f') {
            r += s[i] - 'a' + 10;
        }  else if (s[i] >= 'A' && s[i] <= 'F') {
            r += s[i] - 'A' + 10;
        } else {
            return r;
        }
        continue;
    }
    return r;
}

/*
 * Compare up to 'n' characters in a string.
 *
 * We re-implement the wheel to avoid dependencies on 'libc', required for
 * certain environments that are particularly impoverished.
 */
static int cpio_strncmp(const char *a, const char *b, unsigned long n)
{
    unsigned long i;
    for (i = 0; i < n; i++) {
        if (a[i] != b[i]) {
            return a[i] - b[i];
        }
        if (a[i] == 0) {
            return 0;
        }
    }
    return 0;
}

/**
 * This is an implementation of string copy because, cpi doesn't want to
 * use string.h.
 */
static char *cpio_strcpy(char *to, const char *from)
{
    char *save = to;
    while (*from != 0) {
        *to = *from;
        to++;
        from++;
    }
    return save;
}

static unsigned int cpio_strlen(const char *str)
{
    const char *s;
    for (s = str; *s; ++s) {}
    return (s - str);
}

/* Calculate the remaining length in a CPIO file after reading a header. */
static unsigned long cpio_len_next(unsigned long len, const void *prev, const void *next)
{
    unsigned long diff = (unsigned long)(next - prev);
    if (len < diff) {
        return 0;
    }
    return len;
}

/*
 * Parse the header of the given CPIO entry.
 *
 * Return -1 if the header is not valid, 1 if it is EOF.
 */
int cpio_parse_header(const struct cpio_header *archive, unsigned long len,
                      struct cpio_header_info *info)
{
    const char *filename;
    unsigned long filesize;
    unsigned long filename_length;
    const void *data;
    const struct cpio_header *next;

    /* Ensure header is accessible */
    if (len < sizeof(struct cpio_header)) {
        return -1;
    }

    /* Ensure magic header exists. */
    if (cpio_strncmp(archive->c_magic, CPIO_HEADER_MAGIC, sizeof(archive->c_magic)) != 0) {
        return -1;
    }

    /* Get filename and file size. */
    filesize = parse_hex_str(archive->c_filesize, sizeof(archive->c_filesize));
    filename_length = parse_hex_str(archive->c_namesize, sizeof(archive->c_namesize));

    /* Ensure header + filename + file contents are accessible */
    if (len < sizeof(struct cpio_header) + filename_length + filesize) {
        return -1;
    }

    filename = (char *) archive + sizeof(struct cpio_header);
    /* Ensure filename is terminated */
    if (filename[filename_length - 1] != 0) {
        return -1;
    }

    /* Ensure filename is not the trailer indicating EOF. */
    if (filename_length >= sizeof(CPIO_FOOTER_MAGIC) && cpio_strncmp(filename,
                                                                     CPIO_FOOTER_MAGIC, sizeof(CPIO_FOOTER_MAGIC)) == 0) {
        return 1;
    }

    /* Find offset to data. */
    data = (void *) align_up((unsigned long) archive + sizeof(struct cpio_header) +
                             filename_length, CPIO_ALIGNMENT);
    next = (struct cpio_header *) align_up((unsigned long) data + filesize, CPIO_ALIGNMENT);

    if (info) {
        info->filename = filename;
        info->filesize = filesize;
        info->data = data;
        info->next = next;
    }
    return 0;
}

/*
 * Get the location of the data in the n'th entry in the given archive file.
 *
 * We also return a pointer to the name of the file (not NUL terminated).
 *
 * Return NULL if the n'th entry doesn't exist.
 *
 * Runs in O(n) time.
 */
const void *cpio_get_entry(const void *archive, unsigned long len, int n, const char **name, unsigned long *size)
{
    const struct cpio_header *header = archive;
    struct cpio_header_info header_info;

    /* Find n'th entry. */
    for (int i = 0; i <= n; i++) {
        int error = cpio_parse_header(header, len, &header_info);
        if (error) {
            return NULL;
        }
        len = cpio_len_next(len, header, header_info.next);
        header = header_info.next;
    }

    if (name) {
        *name = header_info.filename;
    }
    if (size) {
        *size = header_info.filesize;
    }
    return header_info.data;
}

/*
 * Find the location and size of the file named "name" in the given 'cpio'
 * archive.
 *
 * Return NULL if the entry doesn't exist.
 *
 * Runs in O(n) time.
 */
const void *cpio_get_file(const void *archive, unsigned long len, const char *name, unsigned long *size)
{
    const struct cpio_header *header = archive;
    struct cpio_header_info header_info;

    /* Find n'th entry. */
    while (1) {
        int error = cpio_parse_header(header, len, &header_info);
        if (error) {
            return NULL;
        }
        if (cpio_strncmp(header_info.filename, name, -1) == 0) {
            break;
        }
        len = cpio_len_next(len, header, header_info.next);
        header = header_info.next;
    }

    if (size) {
        *size = header_info.filesize;
    }
    return header_info.data;
}

int cpio_info(const void *archive, unsigned long len, struct cpio_info *info)
{
    const struct cpio_header *header;
    unsigned long current_path_sz;
    struct cpio_header_info header_info;

    if (info == NULL) {
        return 1;
    }
    info->file_count = 0;
    info->max_path_sz = 0;

    header = archive;
    while (1) {
        int error = cpio_parse_header(header, len, &header_info);
        if (error == -1) {
            return error;
        } else if (error == 1) {
            /* EOF */
            return 0;
        }
        info->file_count++;
        len = cpio_len_next(len, header, header_info.next);
        header = header_info.next;

        // Check if this is the maximum file path size.
        current_path_sz = cpio_strlen(header_info.filename);
        if (current_path_sz > info->max_path_sz) {
            info->max_path_sz = current_path_sz;
        }
    }

    return 0;
}

void cpio_ls(const void *archive, unsigned long len, char **buf, unsigned long buf_len)
{
    const struct cpio_header *header;
    struct cpio_header_info header_info;

    header = archive;
    for (unsigned long i = 0; i < buf_len; i++) {
        int error = cpio_parse_header(header, len, &header_info);
        // Break on an error or nothing left to read.
        if (error) {
            break;
        }
        cpio_strcpy(buf[i], header_info.filename);
        len = cpio_len_next(len, header, header_info.next);
        header = header_info.next;
    }
}