Subversion Repositories or1k

/*
 * imfs_load_tar.c,v 1.6 2002/01/08 12:05:36 joel Exp
 */
 
#if HAVE_CONFIG_H
#include "config.h"
#endif
 
/**************************************************************************
 * This file implements the "mount" procedure for tar-based IMFS
 * extensions.  The TAR is not actually mounted under the IMFS.
 * Directories from the TAR file are created as usual in the IMFS.
 * File entries are created as IMFS_LINEAR_FILE nodes with their nods
 * pointing to addresses in the TAR image.
 *************************************************************************/
 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#include <string.h>
 
#include <rtems.h>
#include <rtems/libio_.h>
#include <chain.h>
#include <imfs.h>
 
 
/**************************************************************************
 * TAR file format:
 *
 *   Offset   Length   Contents
 *     0    100 bytes  File name ('\0' terminated, 99 maxmum length)
 *   100      8 bytes  File mode (in octal ascii)
 *   108      8 bytes  User ID (in octal ascii)
 *   116      8 bytes  Group ID (in octal ascii)
 *   124     12 bytes  File size (s) (in octal ascii)
 *   136     12 bytes  Modify time (in octal ascii)
 *   148      8 bytes  Header checksum (in octal ascii)
 *   156      1 bytes  Link flag
 *   157    100 bytes  Linkname ('\0' terminated, 99 maxmum length)
 *   257      8 bytes  Magic ("ustar  \0")
 *   265     32 bytes  User name ('\0' terminated, 31 maxmum length)
 *   297     32 bytes  Group name ('\0' terminated, 31 maxmum length)
 *   329      8 bytes  Major device ID (in octal ascii)
 *   337      8 bytes  Minor device ID (in octal ascii)
 *   345    167 bytes  Padding
 *   512   (s+p)bytes  File contents (s+p) := (((s) + 511) & ~511),
 *                     round up to 512 bytes
 * 
 *   Checksum:
 *   int i, sum;
 *   char* header = tar_header_pointer;
 *   sum = 0;
 *   for(i = 0; i < 512; i++)
 *       sum += 0xFF & header[i];
 *************************************************************************/
 
#define LF_OLDNORMAL  '\0'     /* Normal disk file, Unix compatible */
#define LF_NORMAL     '0'      /* Normal disk file                  */
#define LF_LINK       '1'      /* Link to previously dumped file    */
#define LF_SYMLINK    '2'      /* Symbolic link                     */
#define LF_CHR        '3'      /* Character special file            */
#define LF_BLK        '4'      /* Block special file                */
#define LF_DIR        '5'      /* Directory                         */
#define LF_FIFO       '6'      /* FIFO special file                 */
#define LF_CONFIG     '7'      /* Contiguous file                   */
 
#define MAX_NAME_FIELD_SIZE      99
 
#define MIN(a,b)   ((a)>(b)?(b):(a))
 
static unsigned long octal2ulong(char *octascii, int len);
static int compute_tar_header_checksum(char *bufr);
 
/**************************************************************************
 * rtems_tarfs_load
 *
 * Here we create the mountpoint directory and load the tarfs at
 * that node.  Once the IMFS has been mounted, we work through the
 * tar image and perform as follows:
 *  - For directories, simply call mkdir().  The IMFS creates nodes as
 *    needed.
 *  - For files, we make our own calls to IMFS eval_for_make and 
 *    create_node.
 *************************************************************************/
int
rtems_tarfs_load(char *mountpoint,
                 unsigned char *tar_image,
                 unsigned long tar_size)
{
   rtems_filesystem_location_info_t root_loc;
   rtems_filesystem_location_info_t loc;
   char            *hdr_ptr;
   char            filename[100];
   char            full_filename[256];
   int             hdr_chksum;
   unsigned char   linkflag;
   unsigned long   file_size;
   unsigned long   file_mode;
   int             offset;
   unsigned long   nblocks;
   IMFS_jnode_t    *node;
   int             status;
 
 
   status = rtems_filesystem_evaluate_path(mountpoint, 0, &root_loc, 0);
   if (status != 0)
      return(-1);
 
   if (root_loc.ops != &IMFS_ops)
      return(-1);
 
   /***********************************************************************
    * Create an IMFS node structure pointing to tar image memory.
    **********************************************************************/
   offset = 0;
   while (1)
   {
      if (offset + 512 > tar_size)
         break;
 
      /******************************************************************
       * Read a header.
       ******************************************************************/
      hdr_ptr = &tar_image[offset];
      offset += 512;
      if (strncmp(&hdr_ptr[257], "ustar  ", 7))
         break;
 
      strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
      filename[MAX_NAME_FIELD_SIZE] = '\0';
 
      linkflag   = hdr_ptr[156];
      file_mode  = octal2ulong(&hdr_ptr[100], 8);
      file_size  = octal2ulong(&hdr_ptr[124], 12);
      hdr_chksum = (int)octal2ulong(&hdr_ptr[148], 8);
 
      if (compute_tar_header_checksum(hdr_ptr) != hdr_chksum)
         break;
 
      /******************************************************************
       * Generate an IMFS node depending on the file type.
       * - For directories, just create directories as usual.  IMFS 
       *   will take care of the rest.
       * - For files, create a file node with special tarfs properties.
       *****************************************************************/
      if (linkflag == LF_DIR)
      {
         strcpy(full_filename, mountpoint);
         if (full_filename[strlen(full_filename)-1] != '/')
            strcat(full_filename, "/");
         strcat(full_filename, filename);
         mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
      }
      /******************************************************************
       * Create a LINEAR_FILE node if no user write permission.
       *****************************************************************/
      else if ((linkflag == LF_NORMAL) &&
               ((file_mode & 0200) == 0000))
      {
         const char  *name;
 
         loc = root_loc;
         if (IMFS_evaluate_for_make(filename, &loc, &name) == 0)
         {
            node = IMFS_create_node(&loc,
                                    IMFS_LINEAR_FILE, (char *)name,
                                    (S_IRUSR | S_IRGRP | S_IROTH) | S_IFREG,
                                    NULL);
            node->info.linearfile.size   = file_size;
            node->info.linearfile.direct = &tar_image[offset];
         }
 
         nblocks = (((file_size) + 511) & ~511) / 512;
         offset += 512 * nblocks;
      }
      /******************************************************************
       * Create a regular MEMORY_FILE if write permission exists.
       *****************************************************************/
      else if ((linkflag == LF_NORMAL) &&
               ((file_mode & 0200) == 0200))
      {
         int fd;
         int n, left, ptr;
 
         strcpy(full_filename, mountpoint);
         if (full_filename[strlen(full_filename)-1] != '/')
            strcat(full_filename, "/");
         strcat(full_filename, filename);
 
         fd = creat(full_filename, S_IRUSR|S_IWUSR | S_IRGRP|S_IWGRP);
         if (fd != -1)
         {
            left = file_size;
            ptr  = offset;
            while ((n = write(fd, &tar_image[ptr], left)) > 0)
            {
               left -= n;
               ptr += n;
            }
            close(fd);
         }
 
         nblocks = (((file_size) + 511) & ~511) / 512;
         offset += 512 * nblocks;
      }
   }
 
   return(status);
}
 
/**************************************************************************
 * This converts octal ASCII number representations into an
 * unsigned long.  Only support 32-bit numbers for now.
 *************************************************************************/
static unsigned long
octal2ulong(char *octascii, int len)
{
   int           i;
   unsigned long num;
   unsigned long mult;
 
   num = 0;
   mult = 1;
   for (i=len-1; i>=0; i--)
   {
      if (octascii[i] < '0') 
         continue;
      if (octascii[i] > '9')
         continue;
 
      num  += mult*((unsigned long)(octascii[i] - '0'));
      mult *= 8;
   }
   return(num);
}
 
 
/************************************************************************
 * Compute the TAR checksum and check with the value in 
 * the archive.  The checksum is computed over the entire
 * header, but the checksum field is substituted with blanks.
 ************************************************************************/
static int
compute_tar_header_checksum(char *bufr)
{
   int  i, sum;
 
 
   sum = 0;
   for (i=0; i<512; i++)
   {
      if ((i >= 148) && (i < 156))
         sum += 0xff & ' ';
      else
         sum += 0xff & bufr[i];
   }
   return(sum);
}