lib/cpio.c

   1 /** \ingroup payload
   2  * \file lib/cpio.c
   3  *  Handle cpio payloads within rpm packages.
   4  *
   5  * \warning FIXME: We don't translate between cpio and system mode bits! These
   6  * should both be the same, but really odd things are going to happen if
   7  * that's not true!
   8  */
   9
  10 #include "system.h"
  11
  12 #include "fsm.h"
  13 #include "rpmerr.h"
  14 #include "debug.h"
  15
  16 /*@access FSM_t @*/
  17
  18 /**
  19  * Convert string to unsigned integer (with buffer size check).
  20  * @param str           input string
  21  * @retval endptr       address of 1st character not processed
  22  * @param base          numerical conversion base
  23  * @param num           max no. of bytes to read
  24  * @return              converted integer
  25  */
  26 static int strntoul(const char *str, /*@out@*/char **endptr, int base, int num)
  27         /*@modifies *endptr @*/
  28 {
  29     char * buf, * end;
  30     unsigned long ret;
  31
  32     buf = alloca(num + 1);
  33     strncpy(buf, str, num);
  34     buf[num] = '\0';
  35
  36     ret = strtoul(buf, &end, base);
  37     if (*end != '\0')
  38         *endptr = ((char *)str) + (end - buf);  /* XXX discards const */
  39     else
  40         *endptr = ((char *)str) + strlen(buf);
  41
  42     return ret;
  43 }
  44
  45 #define GET_NUM_FIELD(phys, log) \
  46         log = strntoul(phys, &end, 16, sizeof(phys)); \
  47         if ( (end - phys) != sizeof(phys) ) return CPIOERR_BAD_HEADER;
  48 #define SET_NUM_FIELD(phys, val, space) \
  49         sprintf(space, "%8.8lx", (unsigned long) (val)); \
  50         memcpy(phys, space, 8);
  51
  52 int cpioTrailerWrite(FSM_t fsm)
  53 {
  54     struct cpioCrcPhysicalHeader * hdr =
  55         (struct cpioCrcPhysicalHeader *)fsm->rdbuf;
  56     int rc;
  57
  58     memset(hdr, '0', PHYS_HDR_SIZE);
  59     memcpy(hdr->magic, CPIO_NEWC_MAGIC, sizeof(hdr->magic));
  60     memcpy(hdr->nlink, "00000001", 8);
  61     memcpy(hdr->namesize, "0000000b", 8);
  62     memcpy(fsm->rdbuf + PHYS_HDR_SIZE, CPIO_TRAILER, sizeof(CPIO_TRAILER));
  63
  64     /* XXX DWRITE uses rdnb for I/O length. */
  65     fsm->rdnb = PHYS_HDR_SIZE + sizeof(CPIO_TRAILER);
  66     rc = fsmStage(fsm, FSM_DWRITE);
  67
  68     /*
  69      * GNU cpio pads to 512 bytes here, but we don't. This may matter for
  70      * tape device(s) and/or concatenated cpio archives. <shrug>
  71      */
  72     if (!rc)
  73         rc = fsmStage(fsm, FSM_PAD);
  74
  75     return rc;
  76 }
  77
  78 int cpioHeaderWrite(FSM_t fsm, struct stat * st)
  79 {
  80     struct cpioCrcPhysicalHeader * hdr = (struct cpioCrcPhysicalHeader *)fsm->rdbuf;
  81     char field[64];
  82     size_t len;
  83     dev_t dev;
  84     int rc = 0;
  85
  86     memcpy(hdr->magic, CPIO_NEWC_MAGIC, sizeof(hdr->magic));
  87     SET_NUM_FIELD(hdr->inode, st->st_ino, field);
  88     SET_NUM_FIELD(hdr->mode, st->st_mode, field);
  89     SET_NUM_FIELD(hdr->uid, st->st_uid, field);
  90     SET_NUM_FIELD(hdr->gid, st->st_gid, field);
  91     SET_NUM_FIELD(hdr->nlink, st->st_nlink, field);
  92     SET_NUM_FIELD(hdr->mtime, st->st_mtime, field);
  93     SET_NUM_FIELD(hdr->filesize, st->st_size, field);
  94
  95     dev = major((unsigned)st->st_dev); SET_NUM_FIELD(hdr->devMajor, dev, field);
  96     dev = minor((unsigned)st->st_dev); SET_NUM_FIELD(hdr->devMinor, dev, field);
  97     dev = major((unsigned)st->st_rdev); SET_NUM_FIELD(hdr->rdevMajor, dev, field);
  98     dev = minor((unsigned)st->st_rdev); SET_NUM_FIELD(hdr->rdevMinor, dev, field);
  99
 100     len = strlen(fsm->path) + 1; SET_NUM_FIELD(hdr->namesize, len, field);
 101     memcpy(hdr->checksum, "00000000", 8);
 102     memcpy(fsm->rdbuf + PHYS_HDR_SIZE, fsm->path, len);
 103
 104     /* XXX DWRITE uses rdnb for I/O length. */
 105     fsm->rdnb = PHYS_HDR_SIZE + len;
 106     rc = fsmStage(fsm, FSM_DWRITE);
 107     if (!rc && fsm->rdnb != fsm->wrnb)
 108         rc = CPIOERR_WRITE_FAILED;
 109     if (!rc)
 110         rc = fsmStage(fsm, FSM_PAD);
 111     return rc;
 112 }
 113
 114 int cpioHeaderRead(FSM_t fsm, struct stat * st)
 115         /*@modifies fsm, *st @*/
 116 {
 117     struct cpioCrcPhysicalHeader hdr;
 118     int nameSize;
 119     char * end;
 120     int major, minor;
 121     int rc = 0;
 122
 123     fsm->wrlen = PHYS_HDR_SIZE;
 124     rc = fsmStage(fsm, FSM_DREAD);
 125     if (!rc && fsm->rdnb != fsm->wrlen)
 126         rc = CPIOERR_READ_FAILED;
 127     if (rc) return rc;
 128     memcpy(&hdr, fsm->wrbuf, fsm->rdnb);
 129
 130     if (strncmp(CPIO_CRC_MAGIC, hdr.magic, sizeof(CPIO_CRC_MAGIC)-1) &&
 131         strncmp(CPIO_NEWC_MAGIC, hdr.magic, sizeof(CPIO_NEWC_MAGIC)-1))
 132         return CPIOERR_BAD_MAGIC;
 133
 134     GET_NUM_FIELD(hdr.inode, st->st_ino);
 135     GET_NUM_FIELD(hdr.mode, st->st_mode);
 136     GET_NUM_FIELD(hdr.uid, st->st_uid);
 137     GET_NUM_FIELD(hdr.gid, st->st_gid);
 138     GET_NUM_FIELD(hdr.nlink, st->st_nlink);
 139     GET_NUM_FIELD(hdr.mtime, st->st_mtime);
 140     GET_NUM_FIELD(hdr.filesize, st->st_size);
 141
 142     GET_NUM_FIELD(hdr.devMajor, major);
 143     GET_NUM_FIELD(hdr.devMinor, minor);
 144     /*@-shiftimplementation@*/
 145     st->st_dev = makedev(major, minor);
 146     /*@=shiftimplementation@*/
 147
 148     GET_NUM_FIELD(hdr.rdevMajor, major);
 149     GET_NUM_FIELD(hdr.rdevMinor, minor);
 150     /*@-shiftimplementation@*/
 151     st->st_rdev = makedev(major, minor);
 152     /*@=shiftimplementation@*/
 153
 154     GET_NUM_FIELD(hdr.namesize, nameSize);
 155     if (nameSize >= fsm->wrsize)
 156         return CPIOERR_BAD_HEADER;
 157
 158     {   char * t = xmalloc(nameSize + 1);
 159         fsm->wrlen = nameSize;
 160         rc = fsmStage(fsm, FSM_DREAD);
 161         if (!rc && fsm->rdnb != fsm->wrlen)
 162             rc = CPIOERR_BAD_HEADER;
 163         if (rc) {
 164             t = _free(t);
 165             fsm->path = NULL;
 166             return rc;
 167         }
 168         memcpy(t, fsm->wrbuf, fsm->rdnb);
 169         t[nameSize] = '\0';
 170         fsm->path = t;
 171     }
 172
 173     return 0;
 174 }
 175
 176 const char *const cpioStrerror(int rc)
 177 {
 178     static char msg[256];
 179     char *s;
 180     int l, myerrno = errno;
 181
 182     strcpy(msg, "cpio: ");
 183     /*@-branchstate@*/
 184     switch (rc) {
 185     default:
 186         s = msg + strlen(msg);
 187         sprintf(s, _("(error 0x%x)"), (unsigned)rc);
 188         s = NULL;
 189         break;
 190     case CPIOERR_BAD_MAGIC:     s = _("Bad magic");             break;
 191     case CPIOERR_BAD_HEADER:    s = _("Bad/unreadable  header");break;
 192
 193     case CPIOERR_OPEN_FAILED:   s = "open";     break;
 194     case CPIOERR_CHMOD_FAILED:  s = "chmod";    break;
 195     case CPIOERR_CHOWN_FAILED:  s = "chown";    break;
 196     case CPIOERR_WRITE_FAILED:  s = "write";    break;
 197     case CPIOERR_UTIME_FAILED:  s = "utime";    break;
 198     case CPIOERR_UNLINK_FAILED: s = "unlink";   break;
 199     case CPIOERR_RENAME_FAILED: s = "rename";   break;
 200     case CPIOERR_SYMLINK_FAILED: s = "symlink"; break;
 201     case CPIOERR_STAT_FAILED:   s = "stat";     break;
 202     case CPIOERR_LSTAT_FAILED:  s = "lstat";    break;
 203     case CPIOERR_MKDIR_FAILED:  s = "mkdir";    break;
 204     case CPIOERR_RMDIR_FAILED:  s = "rmdir";    break;
 205     case CPIOERR_MKNOD_FAILED:  s = "mknod";    break;
 206     case CPIOERR_MKFIFO_FAILED: s = "mkfifo";   break;
 207     case CPIOERR_LINK_FAILED:   s = "link";     break;
 208     case CPIOERR_READLINK_FAILED: s = "readlink";       break;
 209     case CPIOERR_READ_FAILED:   s = "read";     break;
 210     case CPIOERR_COPY_FAILED:   s = "copy";     break;
 211
 212     case CPIOERR_HDR_SIZE:      s = _("Header size too big");   break;
 213     case CPIOERR_UNKNOWN_FILETYPE: s = _("Unknown file type");  break;
 214     case CPIOERR_MISSING_HARDLINK: s = _("Missing hard link(s)"); break;
 215     case CPIOERR_MD5SUM_MISMATCH: s = _("MD5 sum mismatch");    break;
 216     case CPIOERR_INTERNAL:      s = _("Internal error");        break;
 217     case CPIOERR_UNMAPPED_FILE: s = _("Archive file not in header"); break;
 218     }
 219     /*@=branchstate@*/
 220
 221     l = sizeof(msg) - strlen(msg) - 1;
 222     if (s != NULL) {
 223         if (l > 0) strncat(msg, s, l);
 224         l -= strlen(s);
 225     }
 226     /*@-branchstate@*/
 227     if ((rc & CPIOERR_CHECK_ERRNO) && myerrno) {
 228         s = _(" failed - ");
 229         if (l > 0) strncat(msg, s, l);
 230         l -= strlen(s);
 231         if (l > 0) strncat(msg, strerror(myerrno), l);
 232     }
 233     /*@=branchstate@*/
 234     return msg;
 235 }