pintos-os.org Git - pintos-anon/blob - src/lib/ustar.c

   1 #include <ustar.h>
   2 #include <limits.h>
   3 #include <packed.h>
   4 #include <stdio.h>
   5 #include <string.h>
   6
   7 /* Header for ustar-format tar archive.  See the documentation of
   8    the "pax" utility in [SUSv3] for the the "ustar" format
   9    specification. */
  10 struct ustar_header
  11   {
  12     char name[100];             /* File name.  Null-terminated if room. */
  13     char mode[8];               /* Permissions as octal string. */
  14     char uid[8];                /* User ID as octal string. */
  15     char gid[8];                /* Group ID as octal string. */
  16     char size[12];              /* File size in bytes as octal string. */
  17     char mtime[12];             /* Modification time in seconds
  18                                    from Jan 1, 1970, as octal string. */
  19     char chksum[8];             /* Sum of octets in header as octal string. */
  20     char typeflag;              /* An enum ustar_type value. */
  21     char linkname[100];         /* Name of link target.
  22                                    Null-terminated if room. */
  23     char magic[6];              /* "ustar\0" */
  24     char version[2];            /* "00" */
  25     char uname[32];             /* User name, always null-terminated. */
  26     char gname[32];             /* Group name, always null-terminated. */
  27     char devmajor[8];           /* Device major number as octal string. */
  28     char devminor[8];           /* Device minor number as octal string. */
  29     char prefix[155];           /* Prefix to file name.
  30                                    Null-terminated if room. */
  31     char padding[12];           /* Pad to 512 bytes. */
  32   }
  33 PACKED;
  34
  35 /* Returns the checksum for the given ustar format HEADER. */
  36 static unsigned int
  37 calculate_chksum (const struct ustar_header *h)
  38 {
  39   const uint8_t *header = (const uint8_t *) h;
  40   unsigned int chksum;
  41   size_t i;
  42
  43   chksum = 0;
  44   for (i = 0; i < USTAR_HEADER_SIZE; i++)
  45     {
  46       /* The ustar checksum is calculated as if the chksum field
  47          were all spaces. */
  48       const size_t chksum_start = offsetof (struct ustar_header, chksum);
  49       const size_t chksum_end = chksum_start + sizeof h->chksum;
  50       bool in_chksum_field = i >= chksum_start && i < chksum_end;
  51       chksum += in_chksum_field ? ' ' : header[i];
  52     }
  53   return chksum;
  54 }
  55
  56 /* Drop possibly dangerous prefixes from FILE_NAME and return the
  57    stripped name.  An archive with file names that start with "/"
  58    or "../" could cause a naive tar extractor to write to
  59    arbitrary parts of the file system, not just the destination
  60    directory.  We don't want to create such archives or be such a
  61    naive extractor.
  62
  63    The return value can be a suffix of FILE_NAME or a string
  64    literal. */
  65 static const char *
  66 strip_antisocial_prefixes (const char *file_name)
  67 {
  68   while (*file_name == '/'
  69          || !memcmp (file_name, "./", 2)
  70          || !memcmp (file_name, "../", 3))
  71     file_name = strchr (file_name, '/') + 1;
  72   return *file_name == '\0' || !strcmp (file_name, "..") ? "." : file_name;
  73 }
  74
  75 /* Composes HEADER as a USTAR_HEADER_SIZE (512)-byte archive
  76    header in ustar format for a SIZE-byte file named FILE_NAME of
  77    the given TYPE.  The caller is responsible for writing the
  78    header to a file or device.
  79
  80    If successful, returns true.  On failure (due to an
  81    excessively long file name), returns false. */
  82 bool
  83 ustar_make_header (const char *file_name, enum ustar_type type,
  84                    int size, char header[USTAR_HEADER_SIZE])
  85 {
  86   struct ustar_header *h = (struct ustar_header *) header;
  87
  88   ASSERT (sizeof (struct ustar_header) == USTAR_HEADER_SIZE);
  89   ASSERT (type == USTAR_REGULAR || type == USTAR_DIRECTORY);
  90
  91   /* Check file name. */
  92   file_name = strip_antisocial_prefixes (file_name);
  93   if (strlen (file_name) > 99)
  94     {
  95       printf ("%s: file name too long\n", file_name);
  96       return false;
  97     }
  98
  99   /* Fill in header except for final checksum. */
 100   memset (h, 0, sizeof *h);
 101   strlcpy (h->name, file_name, sizeof h->name);
 102   snprintf (h->mode, sizeof h->mode, "%07o",
 103             type == USTAR_REGULAR ? 0644 : 0755);
 104   strlcpy (h->uid, "0000000", sizeof h->uid);
 105   strlcpy (h->gid, "0000000", sizeof h->gid);
 106   snprintf (h->size, sizeof h->size, "%011o", size);
 107   snprintf (h->mtime, sizeof h->size, "%011o", 1136102400);
 108   h->typeflag = type;
 109   strlcpy (h->magic, "ustar", sizeof h->magic);
 110   h->version[0] = h->version[1] = '0';
 111   strlcpy (h->gname, "root", sizeof h->gname);
 112   strlcpy (h->uname, "root", sizeof h->uname);
 113
 114   /* Compute and fill in final checksum. */
 115   snprintf (h->chksum, sizeof h->chksum, "%07o", calculate_chksum (h));
 116
 117   return true;
 118 }
 119
 120 /* Parses a SIZE-byte octal field in S in the format used by
 121    ustar format.  If successful, stores the field's value in
 122    *VALUE and returns true; on failure, returns false.
 123
 124    ustar octal fields consist of a sequence of octal digits
 125    terminated by a space or a null byte.  The ustar specification
 126    seems ambiguous as to whether these fields must be padded on
 127    the left with '0's, so we accept any field that fits in the
 128    available space, regardless of whether it fills the space. */
 129 static bool
 130 parse_octal_field (const char *s, size_t size, unsigned long int *value)
 131 {
 132   size_t ofs;
 133
 134   *value = 0;
 135   for (ofs = 0; ofs < size; ofs++)
 136     {
 137       char c = s[ofs];
 138       if (c >= '0' && c <= '7')
 139         {
 140           if (*value > ULONG_MAX / 8)
 141             {
 142               /* Overflow. */
 143               return false;
 144             }
 145           *value = c - '0' + *value * 8;
 146         }
 147       else if (c == ' ' || c == '\0')
 148         {
 149           /* End of field, but disallow completely empty
 150              fields. */
 151           return ofs > 0;
 152         }
 153       else
 154         {
 155           /* Bad character. */
 156           return false;
 157         }
 158     }
 159
 160   /* Field did not end in space or null byte. */
 161   return false;
 162 }
 163
 164 /* Returns true if the CNT bytes starting at BLOCK are all zero,
 165    false otherwise. */
 166 static bool
 167 is_all_zeros (const char *block, size_t cnt)
 168 {
 169   while (cnt-- > 0)
 170     if (*block++ != 0)
 171       return false;
 172   return true;
 173 }
 174
 175 /* Parses HEADER as a ustar-format archive header for a regular
 176    file or directory.  If successful, stores the archived file's
 177    name in *FILE_NAME (as a pointer into HEADER or a string
 178    literal), its type in *TYPE, and its size in bytes in *SIZE,
 179    and returns a null pointer.  On failure, returns a
 180    human-readable error message. */
 181 const char *
 182 ustar_parse_header (const char header[USTAR_HEADER_SIZE],
 183                     const char **file_name, enum ustar_type *type, int *size)
 184 {
 185   const struct ustar_header *h = (const struct ustar_header *) header;
 186   unsigned long int chksum, size_ul;
 187
 188   ASSERT (sizeof (struct ustar_header) == USTAR_HEADER_SIZE);
 189
 190   /* Detect end of archive. */
 191   if (is_all_zeros (header, USTAR_HEADER_SIZE))
 192     {
 193       *file_name = NULL;
 194       *type = USTAR_EOF;
 195       *size = 0;
 196       return NULL;
 197     }
 198
 199   /* Validate ustar header. */
 200   if (memcmp (h->magic, "ustar", 6))
 201     return "not a ustar archive";
 202   else if (h->version[0] != '0' || h->version[1] != '0')
 203     return "invalid ustar version";
 204   else if (!parse_octal_field (h->chksum, sizeof h->chksum, &chksum))
 205     return "corrupt chksum field";
 206   else if (chksum != calculate_chksum (h))
 207     return "checksum mismatch";
 208   else if (h->name[sizeof h->name - 1] != '\0' || h->prefix[0] != '\0')
 209     return "file name too long";
 210   else if (h->typeflag != USTAR_REGULAR && h->typeflag != USTAR_DIRECTORY)
 211     return "unimplemented file type";
 212   if (h->typeflag == USTAR_REGULAR)
 213     {
 214       if (!parse_octal_field (h->size, sizeof h->size, &size_ul))
 215         return "corrupt file size field";
 216       else if (size_ul > INT_MAX)
 217         return "file too large";
 218     }
 219   else
 220     size_ul = 0;
 221
 222   /* Success. */
 223   *file_name = strip_antisocial_prefixes (h->name);
 224   *type = h->typeflag;
 225   *size = size_ul;
 226   return NULL;
 227 }
 228