cpio.c

Go to the documentation of this file.

/*
 * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 * You can also choose to distribute this program under the terms of
 * the Unmodified Binary Distribution Licence (as given in the file
 * COPYING.UBDL), provided that you have satisfied its requirements.
 */

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

/** @file
 *
 * CPIO archives
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ipxe/cpio.h>

/** CPIO default file mode */
#define CPIO_DEFAULT_MODE 0644

/** CPIO directory mode */
#define CPIO_DEFAULT_DIR_MODE 0755

/**
 * Set field within a CPIO header
 *
 * @v field             Field within CPIO header
 * @v value             Value to set
 */
static void cpio_set_field ( char *field, unsigned long value ) {
        char buf[9];

        snprintf ( buf, sizeof ( buf ), "%08lx", value );
        memcpy ( field, buf, 8 );
}

/**
 * Get maximum number of CPIO headers (i.e. number of path components)
 *
 * @v image             Image
 * @ret max             Maximum number of CPIO headers
 */
static unsigned int cpio_max ( struct image *image ) {
        const char *name = cpio_name ( image );
        unsigned int max = 0;
        char c;
        char p;

        /* Check for existence of CPIO filename */
        if ( ! name )
                return 0;

        /* Count number of path components */
        for ( p = '/' ; ( ( ( c = *(name++) ) ) && ( c != ' ' ) ) ; p = c ) {
                if ( ( p == '/' ) && ( c != '/' ) )
                        max++;
        }

        return max;
}

/**
 * Get CPIO image filename
 *
 * @v image             Image
 * @v depth             Path depth
 * @ret len             Filename length
 */
static size_t cpio_name_len ( struct image *image, unsigned int depth ) {
        const char *name = cpio_name ( image );
        size_t len;
        char c;
        char p;

        /* Sanity checks */
        assert ( name != NULL );
        assert ( depth > 0 );

        /* Calculate length up to specified path depth */
        for ( len = 0, p = '/' ; ( ( ( c = name[len] ) ) && ( c != ' ' ) ) ;
              len++, p = c ) {
                if ( ( c == '/' ) && ( p != '/' ) && ( --depth == 0 ) )
                        break;
        }

        return len;
}

/**
 * Parse CPIO image parameters
 *
 * @v image             Image
 * @v mode              Mode to fill in
 * @v count             Number of CPIO headers to fill in
 */
static void cpio_parse_cmdline ( struct image *image, unsigned int *mode,
                                 unsigned int *count ) {
        const char *arg;
        char *end;

        /* Set default values */
        *mode = CPIO_DEFAULT_MODE;
        *count = 1;

        /* Parse "mode=...", if present */
        if ( ( arg = image_argument ( image, "mode=" ) ) ) {
                *mode = strtoul ( arg, &end, 8 /* Octal for file mode */ );
                if ( *end && ( *end != ' ' ) ) {
                        DBGC ( image, "CPIO %s strange \"mode=\" "
                               "terminator '%c'\n", image->name, *end );
                }
        }

        /* Parse "mkdir=...", if present */
        if ( ( arg = image_argument ( image, "mkdir=" ) ) ) {
                *count += strtoul ( arg, &end, 10 );
                if ( *end && ( *end != ' ' ) ) {
                        DBGC ( image, "CPIO %s strange \"mkdir=\" "
                               "terminator '%c'\n", image->name, *end );
                }
        }

        /* Allow "mkdir=-1" to request creation of full directory tree */
        if ( ! *count )
                *count = -1U;
}

/**
 * Construct CPIO header for image, if applicable
 *
 * @v image             Image
 * @v index             CPIO header index
 * @v cpio              CPIO header to fill in
 * @ret len             Length of CPIO header (including name, excluding NUL)
 */
size_t cpio_header ( struct image *image, unsigned int index,
                     struct cpio_header *cpio ) {
        const char *name = cpio_name ( image );
        unsigned int mode;
        unsigned int count;
        unsigned int max;
        unsigned int depth;
        unsigned int i;
        size_t name_len;
        size_t len;

        /* Parse command line arguments */
        cpio_parse_cmdline ( image, &mode, &count );

        /* Determine number of CPIO headers to be constructed */
        max = cpio_max ( image );
        if ( count > max )
                count = max;

        /* Determine path depth of this CPIO header */
        if ( index >= count )
                return 0;
        depth = ( max - count + index + 1 );

        /* Get filename length */
        name_len = cpio_name_len ( image, depth );

        /* Set directory mode or file mode as appropriate */
        if ( name[name_len] == '/' ) {
                mode = ( CPIO_MODE_DIR | CPIO_DEFAULT_DIR_MODE );
        } else {
                mode |= CPIO_MODE_FILE;
        }

        /* Set length on final header */
        len = ( ( depth < max ) ? 0 : image->len );

        /* Construct CPIO header */
        memset ( cpio, '0', sizeof ( *cpio ) );
        memcpy ( cpio->c_magic, CPIO_MAGIC, sizeof ( cpio->c_magic ) );
        cpio_set_field ( cpio->c_mode, mode );
        cpio_set_field ( cpio->c_nlink, 1 );
        cpio_set_field ( cpio->c_filesize, len );
        cpio_set_field ( cpio->c_namesize, ( name_len + 1 /* NUL */ ) );
        DBGC ( image, "CPIO %s %d/%d \"", image->name, depth, max );
        for ( i = 0 ; i < name_len ; i++ )
                DBGC ( image, "%c", name[i] );
        DBGC ( image, "\"\n" );
        DBGC2_HDA ( image, 0, cpio, sizeof ( *cpio ) );

        /* Calculate total length */
        return ( sizeof ( *cpio ) + name_len );
}