contrib/libarchive-2.0/libarchive/archive_read_support_format_cpio.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "archive_platform.h"
  27 __FBSDID("$FreeBSD: src/lib/libarchive/archive_read_support_format_cpio.c,v 1.22 2007/03/03 07:37:36 kientzle Exp $");
  28
  29 #ifdef HAVE_SYS_STAT_H
  30 #include <sys/stat.h>
  31 #endif
  32 #ifdef MAJOR_IN_MKDEV
  33 #include <sys/mkdev.h>
  34 #endif
  35
  36 #ifdef HAVE_ERRNO_H
  37 #include <errno.h>
  38 #endif
  39 /* #include <stdint.h> */ /* See archive_platform.h */
  40 #ifdef HAVE_STDLIB_H
  41 #include <stdlib.h>
  42 #endif
  43 #ifdef HAVE_STRING_H
  44 #include <string.h>
  45 #endif
  46 #ifdef HAVE_UNISTD_H
  47 #include <unistd.h>
  48 #endif
  49
  50 #include "archive.h"
  51 #include "archive_entry.h"
  52 #include "archive_private.h"
  53 #include "archive_read_private.h"
  54
  55 struct cpio_bin_header {
  56         unsigned char   c_magic[2];
  57         unsigned char   c_dev[2];
  58         unsigned char   c_ino[2];
  59         unsigned char   c_mode[2];
  60         unsigned char   c_uid[2];
  61         unsigned char   c_gid[2];
  62         unsigned char   c_nlink[2];
  63         unsigned char   c_rdev[2];
  64         unsigned char   c_mtime[4];
  65         unsigned char   c_namesize[2];
  66         unsigned char   c_filesize[4];
  67 };
  68
  69 struct cpio_odc_header {
  70         char    c_magic[6];
  71         char    c_dev[6];
  72         char    c_ino[6];
  73         char    c_mode[6];
  74         char    c_uid[6];
  75         char    c_gid[6];
  76         char    c_nlink[6];
  77         char    c_rdev[6];
  78         char    c_mtime[11];
  79         char    c_namesize[6];
  80         char    c_filesize[11];
  81 };
  82
  83 struct cpio_newc_header {
  84         char    c_magic[6];
  85         char    c_ino[8];
  86         char    c_mode[8];
  87         char    c_uid[8];
  88         char    c_gid[8];
  89         char    c_nlink[8];
  90         char    c_mtime[8];
  91         char    c_filesize[8];
  92         char    c_devmajor[8];
  93         char    c_devminor[8];
  94         char    c_rdevmajor[8];
  95         char    c_rdevminor[8];
  96         char    c_namesize[8];
  97         char    c_crc[8];
  98 };
  99
 100 struct links_entry {
 101         struct links_entry      *next;
 102         struct links_entry      *previous;
 103         int                      links;
 104         dev_t                    dev;
 105         ino_t                    ino;
 106         char                    *name;
 107 };
 108
 109 #define CPIO_MAGIC   0x13141516
 110 struct cpio {
 111         int                       magic;
 112         int                     (*read_header)(struct archive_read *, struct cpio *,
 113                                      struct stat *, size_t *, size_t *);
 114         struct links_entry       *links_head;
 115         struct archive_string     entry_name;
 116         struct archive_string     entry_linkname;
 117         off_t                     entry_bytes_remaining;
 118         off_t                     entry_offset;
 119         off_t                     entry_padding;
 120 };
 121
 122 static int64_t  atol16(const char *, unsigned);
 123 static int64_t  atol8(const char *, unsigned);
 124 static int      archive_read_format_cpio_bid(struct archive_read *);
 125 static int      archive_read_format_cpio_cleanup(struct archive_read *);
 126 static int      archive_read_format_cpio_read_data(struct archive_read *,
 127                     const void **, size_t *, off_t *);
 128 static int      archive_read_format_cpio_read_header(struct archive_read *,
 129                     struct archive_entry *);
 130 static int      be4(const unsigned char *);
 131 static int      header_bin_be(struct archive_read *, struct cpio *, struct stat *,
 132                     size_t *, size_t *);
 133 static int      header_bin_le(struct archive_read *, struct cpio *, struct stat *,
 134                     size_t *, size_t *);
 135 static int      header_newc(struct archive_read *, struct cpio *, struct stat *,
 136                     size_t *, size_t *);
 137 static int      header_odc(struct archive_read *, struct cpio *, struct stat *,
 138                     size_t *, size_t *);
 139 static int      le4(const unsigned char *);
 140 static void     record_hardlink(struct cpio *cpio, struct archive_entry *entry,
 141                     const struct stat *st);
 142
 143 int
 144 archive_read_support_format_cpio(struct archive *_a)
 145 {
 146         struct archive_read *a = (struct archive_read *)_a;
 147         struct cpio *cpio;
 148         int r;
 149
 150         cpio = (struct cpio *)malloc(sizeof(*cpio));
 151         if (cpio == NULL) {
 152                 archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");
 153                 return (ARCHIVE_FATAL);
 154         }
 155         memset(cpio, 0, sizeof(*cpio));
 156         cpio->magic = CPIO_MAGIC;
 157
 158         r = __archive_read_register_format(a,
 159             cpio,
 160             archive_read_format_cpio_bid,
 161             archive_read_format_cpio_read_header,
 162             archive_read_format_cpio_read_data,
 163             NULL,
 164             archive_read_format_cpio_cleanup);
 165
 166         if (r != ARCHIVE_OK)
 167                 free(cpio);
 168         return (ARCHIVE_OK);
 169 }
 170
 171
 172 static int
 173 archive_read_format_cpio_bid(struct archive_read *a)
 174 {
 175         int bid, bytes_read;
 176         const void *h;
 177         const unsigned char *p;
 178         struct cpio *cpio;
 179
 180         cpio = (struct cpio *)*(a->pformat_data);
 181         bid = 0;
 182         bytes_read = (a->compression_read_ahead)(a, &h, 6);
 183         /* Convert error code into error return. */
 184         if (bytes_read < 0)
 185                 return ((int)bytes_read);
 186         if (bytes_read < 6)
 187                 return (-1);
 188
 189         p = (const unsigned char *)h;
 190         if (memcmp(p, "070707", 6) == 0) {
 191                 /* ASCII cpio archive (odc, POSIX.1) */
 192                 cpio->read_header = header_odc;
 193                 bid += 48;
 194                 /*
 195                  * XXX TODO:  More verification; Could check that only octal
 196                  * digits appear in appropriate header locations. XXX
 197                  */
 198         } else if (memcmp(p, "070701", 6) == 0) {
 199                 /* ASCII cpio archive (SVR4 without CRC) */
 200                 cpio->read_header = header_newc;
 201                 bid += 48;
 202                 /*
 203                  * XXX TODO:  More verification; Could check that only hex
 204                  * digits appear in appropriate header locations. XXX
 205                  */
 206         } else if (memcmp(p, "070702", 6) == 0) {
 207                 /* ASCII cpio archive (SVR4 with CRC) */
 208                 /* XXX TODO: Flag that we should check the CRC. XXX */
 209                 cpio->read_header = header_newc;
 210                 bid += 48;
 211                 /*
 212                  * XXX TODO:  More verification; Could check that only hex
 213                  * digits appear in appropriate header locations. XXX
 214                  */
 215         } else if (p[0] * 256 + p[1] == 070707) {
 216                 /* big-endian binary cpio archives */
 217                 cpio->read_header = header_bin_be;
 218                 bid += 16;
 219                 /* Is more verification possible here? */
 220         } else if (p[0] + p[1] * 256 == 070707) {
 221                 /* little-endian binary cpio archives */
 222                 cpio->read_header = header_bin_le;
 223                 bid += 16;
 224                 /* Is more verification possible here? */
 225         } else
 226                 return (ARCHIVE_WARN);
 227
 228         return (bid);
 229 }
 230
 231 static int
 232 archive_read_format_cpio_read_header(struct archive_read *a,
 233     struct archive_entry *entry)
 234 {
 235         struct stat st;
 236         struct cpio *cpio;
 237         size_t bytes;
 238         const void *h;
 239         size_t namelength;
 240         size_t name_pad;
 241         int r;
 242
 243         memset(&st, 0, sizeof(st));
 244
 245         cpio = (struct cpio *)*(a->pformat_data);
 246         r = (cpio->read_header(a, cpio, &st, &namelength, &name_pad));
 247
 248         if (r != ARCHIVE_OK)
 249                 return (r);
 250
 251         /* Assign all of the 'stat' fields at once. */
 252         archive_entry_copy_stat(entry, &st);
 253
 254         /* Read name from buffer. */
 255         bytes = (a->compression_read_ahead)(a, &h, namelength + name_pad);
 256         if (bytes < namelength + name_pad)
 257             return (ARCHIVE_FATAL);
 258         (a->compression_read_consume)(a, namelength + name_pad);
 259         archive_strncpy(&cpio->entry_name, (const char *)h, namelength);
 260         archive_entry_set_pathname(entry, cpio->entry_name.s);
 261         cpio->entry_offset = 0;
 262
 263         /* If this is a symlink, read the link contents. */
 264         if (S_ISLNK(st.st_mode)) {
 265                 bytes = (a->compression_read_ahead)(a, &h,
 266                     cpio->entry_bytes_remaining);
 267                 if ((off_t)bytes < cpio->entry_bytes_remaining)
 268                         return (ARCHIVE_FATAL);
 269                 (a->compression_read_consume)(a, cpio->entry_bytes_remaining);
 270                 archive_strncpy(&cpio->entry_linkname, (const char *)h,
 271                     cpio->entry_bytes_remaining);
 272                 archive_entry_set_symlink(entry, cpio->entry_linkname.s);
 273                 cpio->entry_bytes_remaining = 0;
 274         }
 275
 276         /* Compare name to "TRAILER!!!" to test for end-of-archive. */
 277         if (namelength == 11 && strcmp((const char *)h, "TRAILER!!!") == 0) {
 278             /* TODO: Store file location of start of block. */
 279             archive_set_error(&a->archive, 0, NULL);
 280             return (ARCHIVE_EOF);
 281         }
 282
 283         /* Detect and record hardlinks to previously-extracted entries. */
 284         record_hardlink(cpio, entry, &st);
 285
 286         return (ARCHIVE_OK);
 287 }
 288
 289 static int
 290 archive_read_format_cpio_read_data(struct archive_read *a,
 291     const void **buff, size_t *size, off_t *offset)
 292 {
 293         ssize_t bytes_read;
 294         struct cpio *cpio;
 295
 296         cpio = (struct cpio *)*(a->pformat_data);
 297         if (cpio->entry_bytes_remaining > 0) {
 298                 bytes_read = (a->compression_read_ahead)(a, buff, 1);
 299                 if (bytes_read <= 0)
 300                         return (ARCHIVE_FATAL);
 301                 if (bytes_read > cpio->entry_bytes_remaining)
 302                         bytes_read = cpio->entry_bytes_remaining;
 303                 *size = bytes_read;
 304                 *offset = cpio->entry_offset;
 305                 cpio->entry_offset += bytes_read;
 306                 cpio->entry_bytes_remaining -= bytes_read;
 307                 (a->compression_read_consume)(a, bytes_read);
 308                 return (ARCHIVE_OK);
 309         } else {
 310                 while (cpio->entry_padding > 0) {
 311                         bytes_read = (a->compression_read_ahead)(a, buff, 1);
 312                         if (bytes_read <= 0)
 313                                 return (ARCHIVE_FATAL);
 314                         if (bytes_read > cpio->entry_padding)
 315                                 bytes_read = cpio->entry_padding;
 316                         (a->compression_read_consume)(a, bytes_read);
 317                         cpio->entry_padding -= bytes_read;
 318                 }
 319                 *buff = NULL;
 320                 *size = 0;
 321                 *offset = cpio->entry_offset;
 322                 return (ARCHIVE_EOF);
 323         }
 324 }
 325
 326 static int
 327 header_newc(struct archive_read *a, struct cpio *cpio, struct stat *st,
 328     size_t *namelength, size_t *name_pad)
 329 {
 330         const void *h;
 331         const struct cpio_newc_header *header;
 332         size_t bytes;
 333
 334         /* Read fixed-size portion of header. */
 335         bytes = (a->compression_read_ahead)(a, &h, sizeof(struct cpio_newc_header));
 336         if (bytes < sizeof(struct cpio_newc_header))
 337             return (ARCHIVE_FATAL);
 338         (a->compression_read_consume)(a, sizeof(struct cpio_newc_header));
 339
 340         /* Parse out hex fields into struct stat. */
 341         header = (const struct cpio_newc_header *)h;
 342
 343         if (memcmp(header->c_magic, "070701", 6) == 0) {
 344                 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_SVR4_NOCRC;
 345                 a->archive.archive_format_name = "ASCII cpio (SVR4 with no CRC)";
 346         } else if (memcmp(header->c_magic, "070702", 6) == 0) {
 347                 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_SVR4_CRC;
 348                 a->archive.archive_format_name = "ASCII cpio (SVR4 with CRC)";
 349         } else {
 350                 /* TODO: Abort here? */
 351         }
 352
 353         st->st_dev = makedev(
 354                 atol16(header->c_devmajor, sizeof(header->c_devmajor)),
 355                 atol16(header->c_devminor, sizeof(header->c_devminor)));
 356         st->st_ino = atol16(header->c_ino, sizeof(header->c_ino));
 357         st->st_mode = atol16(header->c_mode, sizeof(header->c_mode));
 358         st->st_uid = atol16(header->c_uid, sizeof(header->c_uid));
 359         st->st_gid = atol16(header->c_gid, sizeof(header->c_gid));
 360         st->st_nlink = atol16(header->c_nlink, sizeof(header->c_nlink));
 361         st->st_rdev = makedev(
 362                 atol16(header->c_rdevmajor, sizeof(header->c_rdevmajor)),
 363                 atol16(header->c_rdevminor, sizeof(header->c_rdevminor)));
 364         st->st_mtime = atol16(header->c_mtime, sizeof(header->c_mtime));
 365         *namelength = atol16(header->c_namesize, sizeof(header->c_namesize));
 366         /* Pad name to 2 more than a multiple of 4. */
 367         *name_pad = (2 - *namelength) & 3;
 368
 369         /*
 370          * Note: entry_bytes_remaining is at least 64 bits and
 371          * therefore guaranteed to be big enough for a 33-bit file
 372          * size.  struct stat.st_size may only be 32 bits, so
 373          * assigning there first could lose information.
 374          */
 375         cpio->entry_bytes_remaining =
 376             atol16(header->c_filesize, sizeof(header->c_filesize));
 377         st->st_size = cpio->entry_bytes_remaining;
 378         /* Pad file contents to a multiple of 4. */
 379         cpio->entry_padding = 3 & -cpio->entry_bytes_remaining;
 380         return (ARCHIVE_OK);
 381 }
 382
 383 static int
 384 header_odc(struct archive_read *a, struct cpio *cpio, struct stat *st,
 385     size_t *namelength, size_t *name_pad)
 386 {
 387         const void *h;
 388         const struct cpio_odc_header *header;
 389         size_t bytes;
 390
 391         a->archive.archive_format = ARCHIVE_FORMAT_CPIO_POSIX;
 392         a->archive.archive_format_name = "POSIX octet-oriented cpio";
 393
 394         /* Read fixed-size portion of header. */
 395         bytes = (a->compression_read_ahead)(a, &h, sizeof(struct cpio_odc_header));
 396         if (bytes < sizeof(struct cpio_odc_header))
 397             return (ARCHIVE_FATAL);
 398         (a->compression_read_consume)(a, sizeof(struct cpio_odc_header));
 399
 400         /* Parse out octal fields into struct stat. */
 401         header = (const struct cpio_odc_header *)h;
 402
 403         st->st_dev = atol8(header->c_dev, sizeof(header->c_dev));
 404         st->st_ino = atol8(header->c_ino, sizeof(header->c_ino));
 405         st->st_mode = atol8(header->c_mode, sizeof(header->c_mode));
 406         st->st_uid = atol8(header->c_uid, sizeof(header->c_uid));
 407         st->st_gid = atol8(header->c_gid, sizeof(header->c_gid));
 408         st->st_nlink = atol8(header->c_nlink, sizeof(header->c_nlink));
 409         st->st_rdev = atol8(header->c_rdev, sizeof(header->c_rdev));
 410         st->st_mtime = atol8(header->c_mtime, sizeof(header->c_mtime));
 411         *namelength = atol8(header->c_namesize, sizeof(header->c_namesize));
 412         *name_pad = 0; /* No padding of filename. */
 413
 414         /*
 415          * Note: entry_bytes_remaining is at least 64 bits and
 416          * therefore guaranteed to be big enough for a 33-bit file
 417          * size.  struct stat.st_size may only be 32 bits, so
 418          * assigning there first could lose information.
 419          */
 420         cpio->entry_bytes_remaining =
 421             atol8(header->c_filesize, sizeof(header->c_filesize));
 422         st->st_size = cpio->entry_bytes_remaining;
 423         cpio->entry_padding = 0;
 424         return (ARCHIVE_OK);
 425 }
 426
 427 static int
 428 header_bin_le(struct archive_read *a, struct cpio *cpio, struct stat *st,
 429     size_t *namelength, size_t *name_pad)
 430 {
 431         const void *h;
 432         const struct cpio_bin_header *header;
 433         size_t bytes;
 434
 435         a->archive.archive_format = ARCHIVE_FORMAT_CPIO_BIN_LE;
 436         a->archive.archive_format_name = "cpio (little-endian binary)";
 437
 438         /* Read fixed-size portion of header. */
 439         bytes = (a->compression_read_ahead)(a, &h, sizeof(struct cpio_bin_header));
 440         if (bytes < sizeof(struct cpio_bin_header))
 441             return (ARCHIVE_FATAL);
 442         (a->compression_read_consume)(a, sizeof(struct cpio_bin_header));
 443
 444         /* Parse out binary fields into struct stat. */
 445         header = (const struct cpio_bin_header *)h;
 446
 447         st->st_dev = header->c_dev[0] + header->c_dev[1] * 256;
 448         st->st_ino = header->c_ino[0] + header->c_ino[1] * 256;
 449         st->st_mode = header->c_mode[0] + header->c_mode[1] * 256;
 450         st->st_uid = header->c_uid[0] + header->c_uid[1] * 256;
 451         st->st_gid = header->c_gid[0] + header->c_gid[1] * 256;
 452         st->st_nlink = header->c_nlink[0] + header->c_nlink[1] * 256;
 453         st->st_rdev = header->c_rdev[0] + header->c_rdev[1] * 256;
 454         st->st_mtime = le4(header->c_mtime);
 455         *namelength = header->c_namesize[0] + header->c_namesize[1] * 256;
 456         *name_pad = *namelength & 1; /* Pad to even. */
 457
 458         cpio->entry_bytes_remaining = le4(header->c_filesize);
 459         st->st_size = cpio->entry_bytes_remaining;
 460         cpio->entry_padding = cpio->entry_bytes_remaining & 1; /* Pad to even. */
 461         return (ARCHIVE_OK);
 462 }
 463
 464 static int
 465 header_bin_be(struct archive_read *a, struct cpio *cpio, struct stat *st,
 466     size_t *namelength, size_t *name_pad)
 467 {
 468         const void *h;
 469         const struct cpio_bin_header *header;
 470         size_t bytes;
 471
 472         a->archive.archive_format = ARCHIVE_FORMAT_CPIO_BIN_BE;
 473         a->archive.archive_format_name = "cpio (big-endian binary)";
 474
 475         /* Read fixed-size portion of header. */
 476         bytes = (a->compression_read_ahead)(a, &h,
 477             sizeof(struct cpio_bin_header));
 478         if (bytes < sizeof(struct cpio_bin_header))
 479             return (ARCHIVE_FATAL);
 480         (a->compression_read_consume)(a, sizeof(struct cpio_bin_header));
 481
 482         /* Parse out binary fields into struct stat. */
 483         header = (const struct cpio_bin_header *)h;
 484         st->st_dev = header->c_dev[0] * 256 + header->c_dev[1];
 485         st->st_ino = header->c_ino[0] * 256 + header->c_ino[1];
 486         st->st_mode = header->c_mode[0] * 256 + header->c_mode[1];
 487         st->st_uid = header->c_uid[0] * 256 + header->c_uid[1];
 488         st->st_gid = header->c_gid[0] * 256 + header->c_gid[1];
 489         st->st_nlink = header->c_nlink[0] * 256 + header->c_nlink[1];
 490         st->st_rdev = header->c_rdev[0] * 256 + header->c_rdev[1];
 491         st->st_mtime = be4(header->c_mtime);
 492         *namelength = header->c_namesize[0] * 256 + header->c_namesize[1];
 493         *name_pad = *namelength & 1; /* Pad to even. */
 494
 495         cpio->entry_bytes_remaining = be4(header->c_filesize);
 496         st->st_size = cpio->entry_bytes_remaining;
 497         cpio->entry_padding = cpio->entry_bytes_remaining & 1; /* Pad to even. */
 498         return (ARCHIVE_OK);
 499 }
 500
 501 static int
 502 archive_read_format_cpio_cleanup(struct archive_read *a)
 503 {
 504         struct cpio *cpio;
 505
 506         cpio = (struct cpio *)*(a->pformat_data);
 507         /* Free inode->name map */
 508         while (cpio->links_head != NULL) {
 509                 struct links_entry *lp = cpio->links_head->next;
 510
 511                 if (cpio->links_head->name)
 512                         free(cpio->links_head->name);
 513                 free(cpio->links_head);
 514                 cpio->links_head = lp;
 515         }
 516
 517         free(cpio);
 518         *(a->pformat_data) = NULL;
 519         return (ARCHIVE_OK);
 520 }
 521
 522 static int
 523 le4(const unsigned char *p)
 524 {
 525         return ((p[0]<<16) + (p[1]<<24) + (p[2]<<0) + (p[3]<<8));
 526 }
 527
 528
 529 static int
 530 be4(const unsigned char *p)
 531 {
 532         return (p[0] + (p[1]<<8) + (p[2]<<16) + (p[3]<<24));
 533 }
 534
 535 /*
 536  * Note that this implementation does not (and should not!) obey
 537  * locale settings; you cannot simply substitute strtol here, since
 538  * it does obey locale.
 539  */
 540 static int64_t
 541 atol8(const char *p, unsigned char_cnt)
 542 {
 543         int64_t l;
 544         int digit;
 545
 546         l = 0;
 547         while (char_cnt-- > 0) {
 548                 if (*p >= '0' && *p <= '7')
 549                         digit = *p - '0';
 550                 else
 551                         return (l);
 552                 p++;
 553                 l <<= 3;
 554                 l |= digit;
 555         }
 556         return (l);
 557 }
 558
 559 static int64_t
 560 atol16(const char *p, unsigned char_cnt)
 561 {
 562         int64_t l;
 563         int digit;
 564
 565         l = 0;
 566         while (char_cnt-- > 0) {
 567                 if (*p >= 'a' && *p <= 'f')
 568                         digit = *p - 'a' + 10;
 569                 else if (*p >= 'A' && *p <= 'F')
 570                         digit = *p - 'A' + 10;
 571                 else if (*p >= '0' && *p <= '9')
 572                         digit = *p - '0';
 573                 else
 574                         return (l);
 575                 p++;
 576                 l <<= 4;
 577                 l |= digit;
 578         }
 579         return (l);
 580 }
 581
 582 static void
 583 record_hardlink(struct cpio *cpio, struct archive_entry *entry,
 584     const struct stat *st)
 585 {
 586         struct links_entry      *le;
 587
 588         /*
 589          * First look in the list of multiply-linked files.  If we've
 590          * already dumped it, convert this entry to a hard link entry.
 591          */
 592         for (le = cpio->links_head; le; le = le->next) {
 593                 if (le->dev == st->st_dev && le->ino == st->st_ino) {
 594                         archive_entry_set_hardlink(entry, le->name);
 595
 596                         if (--le->links <= 0) {
 597                                 if (le->previous != NULL)
 598                                         le->previous->next = le->next;
 599                                 if (le->next != NULL)
 600                                         le->next->previous = le->previous;
 601                                 if (cpio->links_head == le)
 602                                         cpio->links_head = le->next;
 603                                 free(le);
 604                         }
 605
 606                         return;
 607                 }
 608         }
 609
 610         le = (struct links_entry *)malloc(sizeof(struct links_entry));
 611         if (le == NULL)
 612                 __archive_errx(1, "Out of memory adding file to list");
 613         if (cpio->links_head != NULL)
 614                 cpio->links_head->previous = le;
 615         le->next = cpio->links_head;
 616         le->previous = NULL;
 617         cpio->links_head = le;
 618         le->dev = st->st_dev;
 619         le->ino = st->st_ino;
 620         le->links = st->st_nlink - 1;
 621         le->name = strdup(archive_entry_pathname(entry));
 622         if (le->name == NULL)
 623                 __archive_errx(1, "Out of memory adding file to list");
 624 }