bin/pax/tar.c

   1 /*-
   2  * Copyright (c) 1992 Keith Muller.
   3  * Copyright (c) 1992, 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * Keith Muller of the University of California, San Diego.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifndef lint
  35 #if 0
  36 static char sccsid[] = "@(#)tar.c       8.2 (Berkeley) 4/18/94";
  37 #endif
  38 #endif /* not lint */
  39 #include <sys/cdefs.h>
  40 __FBSDID("$FreeBSD$");
  41
  42 #include <sys/types.h>
  43 #include <sys/time.h>
  44 #include <sys/stat.h>
  45 #include <string.h>
  46 #include <stdio.h>
  47 #include <unistd.h>
  48 #include <stdlib.h>
  49 #include "pax.h"
  50 #include "extern.h"
  51 #include "tar.h"
  52
  53 /*
  54  * Routines for reading, writing and header identify of various versions of tar
  55  */
  56
  57 static u_long tar_chksm(char *, int);
  58 static char *name_split(char *, int);
  59 static int ul_oct(u_long, char *, int, int);
  60 #ifndef NET2_STAT
  61 static int uqd_oct(u_quad_t, char *, int, int);
  62 #endif
  63
  64 /*
  65  * Routines common to all versions of tar
  66  */
  67
  68 static int tar_nodir;                   /* do not write dirs under old tar */
  69
  70 /*
  71  * tar_endwr()
  72  *      add the tar trailer of two null blocks
  73  * Return:
  74  *      0 if ok, -1 otherwise (what wr_skip returns)
  75  */
  76
  77 int
  78 tar_endwr(void)
  79 {
  80         return(wr_skip((off_t)(NULLCNT*BLKMULT)));
  81 }
  82
  83 /*
  84  * tar_endrd()
  85  *      no cleanup needed here, just return size of trailer (for append)
  86  * Return:
  87  *      size of trailer (2 * BLKMULT)
  88  */
  89
  90 off_t
  91 tar_endrd(void)
  92 {
  93         return((off_t)(NULLCNT*BLKMULT));
  94 }
  95
  96 /*
  97  * tar_trail()
  98  *      Called to determine if a header block is a valid trailer. We are passed
  99  *      the block, the in_sync flag (which tells us we are in resync mode;
 100  *      looking for a valid header), and cnt (which starts at zero) which is
 101  *      used to count the number of empty blocks we have seen so far.
 102  * Return:
 103  *      0 if a valid trailer, -1 if not a valid trailer, or 1 if the block
 104  *      could never contain a header.
 105  */
 106
 107 int
 108 tar_trail(char *buf, int in_resync, int *cnt)
 109 {
 110         int i;
 111
 112         /*
 113          * look for all zero, trailer is two consecutive blocks of zero
 114          */
 115         for (i = 0; i < BLKMULT; ++i) {
 116                 if (buf[i] != '\0')
 117                         break;
 118         }
 119
 120         /*
 121          * if not all zero it is not a trailer, but MIGHT be a header.
 122          */
 123         if (i != BLKMULT)
 124                 return(-1);
 125
 126         /*
 127          * When given a zero block, we must be careful!
 128          * If we are not in resync mode, check for the trailer. Have to watch
 129          * out that we do not mis-identify file data as the trailer, so we do
 130          * NOT try to id a trailer during resync mode. During resync mode we
 131          * might as well throw this block out since a valid header can NEVER be
 132          * a block of all 0 (we must have a valid file name).
 133          */
 134         if (!in_resync && (++*cnt >= NULLCNT))
 135                 return(0);
 136         return(1);
 137 }
 138
 139 /*
 140  * ul_oct()
 141  *      convert an unsigned long to an octal string. many oddball field
 142  *      termination characters are used by the various versions of tar in the
 143  *      different fields. term selects which kind to use. str is '0' padded
 144  *      at the front to len. we are unable to use only one format as many old
 145  *      tar readers are very cranky about this.
 146  * Return:
 147  *      0 if the number fit into the string, -1 otherwise
 148  */
 149
 150 static int
 151 ul_oct(u_long val, char *str, int len, int term)
 152 {
 153         char *pt;
 154
 155         /*
 156          * term selects the appropriate character(s) for the end of the string
 157          */
 158         pt = str + len - 1;
 159         switch(term) {
 160         case 3:
 161                 *pt-- = '\0';
 162                 break;
 163         case 2:
 164                 *pt-- = ' ';
 165                 *pt-- = '\0';
 166                 break;
 167         case 1:
 168                 *pt-- = ' ';
 169                 break;
 170         case 0:
 171         default:
 172                 *pt-- = '\0';
 173                 *pt-- = ' ';
 174                 break;
 175         }
 176
 177         /*
 178          * convert and blank pad if there is space
 179          */
 180         while (pt >= str) {
 181                 *pt-- = '0' + (char)(val & 0x7);
 182                 if ((val = val >> 3) == (u_long)0)
 183                         break;
 184         }
 185
 186         while (pt >= str)
 187                 *pt-- = '0';
 188         if (val != (u_long)0)
 189                 return(-1);
 190         return(0);
 191 }
 192
 193 #ifndef NET2_STAT
 194 /*
 195  * uqd_oct()
 196  *      convert an u_quad_t to an octal string. one of many oddball field
 197  *      termination characters are used by the various versions of tar in the
 198  *      different fields. term selects which kind to use. str is '0' padded
 199  *      at the front to len. we are unable to use only one format as many old
 200  *      tar readers are very cranky about this.
 201  * Return:
 202  *      0 if the number fit into the string, -1 otherwise
 203  */
 204
 205 static int
 206 uqd_oct(u_quad_t val, char *str, int len, int term)
 207 {
 208         char *pt;
 209
 210         /*
 211          * term selects the appropriate character(s) for the end of the string
 212          */
 213         pt = str + len - 1;
 214         switch(term) {
 215         case 3:
 216                 *pt-- = '\0';
 217                 break;
 218         case 2:
 219                 *pt-- = ' ';
 220                 *pt-- = '\0';
 221                 break;
 222         case 1:
 223                 *pt-- = ' ';
 224                 break;
 225         case 0:
 226         default:
 227                 *pt-- = '\0';
 228                 *pt-- = ' ';
 229                 break;
 230         }
 231
 232         /*
 233          * convert and blank pad if there is space
 234          */
 235         while (pt >= str) {
 236                 *pt-- = '0' + (char)(val & 0x7);
 237                 if ((val = val >> 3) == 0)
 238                         break;
 239         }
 240
 241         while (pt >= str)
 242                 *pt-- = '0';
 243         if (val != (u_quad_t)0)
 244                 return(-1);
 245         return(0);
 246 }
 247 #endif
 248
 249 /*
 250  * tar_chksm()
 251  *      calculate the checksum for a tar block counting the checksum field as
 252  *      all blanks (BLNKSUM is that value pre-calculated, the sum of 8 blanks).
 253  *      NOTE: we use len to short circuit summing 0's on write since we ALWAYS
 254  *      pad headers with 0.
 255  * Return:
 256  *      unsigned long checksum
 257  */
 258
 259 static u_long
 260 tar_chksm(char *blk, int len)
 261 {
 262         char *stop;
 263         char *pt;
 264         u_long chksm = BLNKSUM; /* initial value is checksum field sum */
 265
 266         /*
 267          * add the part of the block before the checksum field
 268          */
 269         pt = blk;
 270         stop = blk + CHK_OFFSET;
 271         while (pt < stop)
 272                 chksm += (u_long)(*pt++ & 0xff);
 273         /*
 274          * move past the checksum field and keep going, spec counts the
 275          * checksum field as the sum of 8 blanks (which is pre-computed as
 276          * BLNKSUM).
 277          * ASSUMED: len is greater than CHK_OFFSET. (len is where our 0 padding
 278          * starts, no point in summing zero's)
 279          */
 280         pt += CHK_LEN;
 281         stop = blk + len;
 282         while (pt < stop)
 283                 chksm += (u_long)(*pt++ & 0xff);
 284         return(chksm);
 285 }
 286
 287 /*
 288  * Routines for old BSD style tar (also made portable to sysV tar)
 289  */
 290
 291 /*
 292  * tar_id()
 293  *      determine if a block given to us is a valid tar header (and not a USTAR
 294  *      header). We have to be on the lookout for those pesky blocks of all
 295  *      zero's.
 296  * Return:
 297  *      0 if a tar header, -1 otherwise
 298  */
 299
 300 int
 301 tar_id(char *blk, int size)
 302 {
 303         HD_TAR *hd;
 304         HD_USTAR *uhd;
 305
 306         if (size < BLKMULT)
 307                 return(-1);
 308         hd = (HD_TAR *)blk;
 309         uhd = (HD_USTAR *)blk;
 310
 311         /*
 312          * check for block of zero's first, a simple and fast test, then make
 313          * sure this is not a ustar header by looking for the ustar magic
 314          * cookie. We should use TMAGLEN, but some USTAR archive programs are
 315          * wrong and create archives missing the \0. Last we check the
 316          * checksum. If this is ok we have to assume it is a valid header.
 317          */
 318         if (hd->name[0] == '\0')
 319                 return(-1);
 320         if (strncmp(uhd->magic, TMAGIC, TMAGLEN - 1) == 0)
 321                 return(-1);
 322         if (asc_ul(hd->chksum,sizeof(hd->chksum),OCT) != tar_chksm(blk,BLKMULT))
 323                 return(-1);
 324         return(0);
 325 }
 326
 327 /*
 328  * tar_opt()
 329  *      handle tar format specific -o options
 330  * Return:
 331  *      0 if ok -1 otherwise
 332  */
 333
 334 int
 335 tar_opt(void)
 336 {
 337         OPLIST *opt;
 338
 339         while ((opt = opt_next()) != NULL) {
 340                 if (strcmp(opt->name, TAR_OPTION) ||
 341                     strcmp(opt->value, TAR_NODIR)) {
 342                         paxwarn(1, "Unknown tar format -o option/value pair %s=%s",
 343                             opt->name, opt->value);
 344                         paxwarn(1,"%s=%s is the only supported tar format option",
 345                             TAR_OPTION, TAR_NODIR);
 346                         return(-1);
 347                 }
 348
 349                 /*
 350                  * we only support one option, and only when writing
 351                  */
 352                 if ((act != APPND) && (act != ARCHIVE)) {
 353                         paxwarn(1, "%s=%s is only supported when writing.",
 354                             opt->name, opt->value);
 355                         return(-1);
 356                 }
 357                 tar_nodir = 1;
 358         }
 359         return(0);
 360 }
 361
 362
 363 /*
 364  * tar_rd()
 365  *      extract the values out of block already determined to be a tar header.
 366  *      store the values in the ARCHD parameter.
 367  * Return:
 368  *      0
 369  */
 370
 371 int
 372 tar_rd(ARCHD *arcn, char *buf)
 373 {
 374         HD_TAR *hd;
 375         char *pt;
 376
 377         /*
 378          * we only get proper sized buffers passed to us
 379          */
 380         if (tar_id(buf, BLKMULT) < 0)
 381                 return(-1);
 382         arcn->org_name = arcn->name;
 383         arcn->sb.st_nlink = 1;
 384         arcn->pat = NULL;
 385
 386         /*
 387          * copy out the name and values in the stat buffer
 388          */
 389         hd = (HD_TAR *)buf;
 390         /*
 391          * old tar format specifies the name always be null-terminated,
 392          * but let's be robust to broken archives.
 393          * the same applies to handling links below.
 394          */
 395         arcn->nlen = l_strncpy(arcn->name, hd->name,
 396             MIN(sizeof(hd->name), sizeof(arcn->name)) - 1);
 397         arcn->name[arcn->nlen] = '\0';
 398         arcn->sb.st_mode = (mode_t)(asc_ul(hd->mode,sizeof(hd->mode),OCT) &
 399             0xfff);
 400         arcn->sb.st_uid = (uid_t)asc_ul(hd->uid, sizeof(hd->uid), OCT);
 401         arcn->sb.st_gid = (gid_t)asc_ul(hd->gid, sizeof(hd->gid), OCT);
 402 #ifdef NET2_STAT
 403         arcn->sb.st_size = (off_t)asc_ul(hd->size, sizeof(hd->size), OCT);
 404         arcn->sb.st_mtime = (time_t)asc_ul(hd->mtime, sizeof(hd->mtime), OCT);
 405 #else
 406         arcn->sb.st_size = (off_t)asc_uqd(hd->size, sizeof(hd->size), OCT);
 407         arcn->sb.st_mtime = (time_t)asc_uqd(hd->mtime, sizeof(hd->mtime), OCT);
 408 #endif
 409         arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime;
 410
 411         /*
 412          * have to look at the last character, it may be a '/' and that is used
 413          * to encode this as a directory
 414          */
 415         pt = &(arcn->name[arcn->nlen - 1]);
 416         arcn->pad = 0;
 417         arcn->skip = 0;
 418         switch(hd->linkflag) {
 419         case SYMTYPE:
 420                 /*
 421                  * symbolic link, need to get the link name and set the type in
 422                  * the st_mode so -v printing will look correct.
 423                  */
 424                 arcn->type = PAX_SLK;
 425                 arcn->ln_nlen = l_strncpy(arcn->ln_name, hd->linkname,
 426                     MIN(sizeof(hd->linkname), sizeof(arcn->ln_name)) - 1);
 427                 arcn->ln_name[arcn->ln_nlen] = '\0';
 428                 arcn->sb.st_mode |= S_IFLNK;
 429                 break;
 430         case LNKTYPE:
 431                 /*
 432                  * hard link, need to get the link name, set the type in the
 433                  * st_mode and st_nlink so -v printing will look better.
 434                  */
 435                 arcn->type = PAX_HLK;
 436                 arcn->sb.st_nlink = 2;
 437                 arcn->ln_nlen = l_strncpy(arcn->ln_name, hd->linkname,
 438                     MIN(sizeof(hd->linkname), sizeof(arcn->ln_name)) - 1);
 439                 arcn->ln_name[arcn->ln_nlen] = '\0';
 440
 441                 /*
 442                  * no idea of what type this thing really points at, but
 443                  * we set something for printing only.
 444                  */
 445                 arcn->sb.st_mode |= S_IFREG;
 446                 break;
 447         case DIRTYPE:
 448                 /*
 449                  * It is a directory, set the mode for -v printing
 450                  */
 451                 arcn->type = PAX_DIR;
 452                 arcn->sb.st_mode |= S_IFDIR;
 453                 arcn->sb.st_nlink = 2;
 454                 arcn->ln_name[0] = '\0';
 455                 arcn->ln_nlen = 0;
 456                 break;
 457         case AREGTYPE:
 458         case REGTYPE:
 459         default:
 460                 /*
 461                  * If we have a trailing / this is a directory and NOT a file.
 462                  */
 463                 arcn->ln_name[0] = '\0';
 464                 arcn->ln_nlen = 0;
 465                 if (*pt == '/') {
 466                         /*
 467                          * it is a directory, set the mode for -v printing
 468                          */
 469                         arcn->type = PAX_DIR;
 470                         arcn->sb.st_mode |= S_IFDIR;
 471                         arcn->sb.st_nlink = 2;
 472                 } else {
 473                         /*
 474                          * have a file that will be followed by data. Set the
 475                          * skip value to the size field and calculate the size
 476                          * of the padding.
 477                          */
 478                         arcn->type = PAX_REG;
 479                         arcn->sb.st_mode |= S_IFREG;
 480                         arcn->pad = TAR_PAD(arcn->sb.st_size);
 481                         arcn->skip = arcn->sb.st_size;
 482                 }
 483                 break;
 484         }
 485
 486         /*
 487          * strip off any trailing slash.
 488          */
 489         if (*pt == '/') {
 490                 *pt = '\0';
 491                 --arcn->nlen;
 492         }
 493         return(0);
 494 }
 495
 496 /*
 497  * tar_wr()
 498  *      write a tar header for the file specified in the ARCHD to the archive.
 499  *      Have to check for file types that cannot be stored and file names that
 500  *      are too long. Be careful of the term (last arg) to ul_oct, each field
 501  *      of tar has it own spec for the termination character(s).
 502  *      ASSUMED: space after header in header block is zero filled
 503  * Return:
 504  *      0 if file has data to be written after the header, 1 if file has NO
 505  *      data to write after the header, -1 if archive write failed
 506  */
 507
 508 int
 509 tar_wr(ARCHD *arcn)
 510 {
 511         HD_TAR *hd;
 512         int len;
 513         HD_TAR hdblk;
 514
 515         /*
 516          * check for those file system types which tar cannot store
 517          */
 518         switch(arcn->type) {
 519         case PAX_DIR:
 520                 /*
 521                  * user asked that dirs not be written to the archive
 522                  */
 523                 if (tar_nodir)
 524                         return(1);
 525                 break;
 526         case PAX_CHR:
 527                 paxwarn(1, "Tar cannot archive a character device %s",
 528                     arcn->org_name);
 529                 return(1);
 530         case PAX_BLK:
 531                 paxwarn(1, "Tar cannot archive a block device %s", arcn->org_name);
 532                 return(1);
 533         case PAX_SCK:
 534                 paxwarn(1, "Tar cannot archive a socket %s", arcn->org_name);
 535                 return(1);
 536         case PAX_FIF:
 537                 paxwarn(1, "Tar cannot archive a fifo %s", arcn->org_name);
 538                 return(1);
 539         case PAX_SLK:
 540         case PAX_HLK:
 541         case PAX_HRG:
 542                 if (arcn->ln_nlen >= (int)sizeof(hd->linkname)) {
 543                         paxwarn(1,"Link name too long for tar %s", arcn->ln_name);
 544                         return(1);
 545                 }
 546                 break;
 547         case PAX_REG:
 548         case PAX_CTG:
 549         default:
 550                 break;
 551         }
 552
 553         /*
 554          * check file name len, remember extra char for dirs (the / at the end)
 555          */
 556         len = arcn->nlen;
 557         if (arcn->type == PAX_DIR)
 558                 ++len;
 559         if (len >= (int)sizeof(hd->name)) {
 560                 paxwarn(1, "File name too long for tar %s", arcn->name);
 561                 return(1);
 562         }
 563
 564         /*
 565          * copy the data out of the ARCHD into the tar header based on the type
 566          * of the file. Remember many tar readers want the unused fields to be
 567          * padded with zero. We set the linkflag field (type), the linkname
 568          * (or zero if not used),the size, and set the padding (if any) to be
 569          * added after the file data (0 for all other types, as they only have
 570          * a header)
 571          */
 572         hd = &hdblk;
 573         l_strncpy(hd->name, arcn->name, sizeof(hd->name) - 1);
 574         hd->name[sizeof(hd->name) - 1] = '\0';
 575         arcn->pad = 0;
 576
 577         if (arcn->type == PAX_DIR) {
 578                 /*
 579                  * directories are the same as files, except have a filename
 580                  * that ends with a /, we add the slash here. No data follows,
 581                  * dirs, so no pad.
 582                  */
 583                 hd->linkflag = AREGTYPE;
 584                 memset(hd->linkname, 0, sizeof(hd->linkname));
 585                 hd->name[len-1] = '/';
 586                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 1))
 587                         goto out;
 588         } else if (arcn->type == PAX_SLK) {
 589                 /*
 590                  * no data follows this file, so no pad
 591                  */
 592                 hd->linkflag = SYMTYPE;
 593                 l_strncpy(hd->linkname,arcn->ln_name, sizeof(hd->linkname) - 1);
 594                 hd->linkname[sizeof(hd->linkname) - 1] = '\0';
 595                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 1))
 596                         goto out;
 597         } else if ((arcn->type == PAX_HLK) || (arcn->type == PAX_HRG)) {
 598                 /*
 599                  * no data follows this file, so no pad
 600                  */
 601                 hd->linkflag = LNKTYPE;
 602                 l_strncpy(hd->linkname,arcn->ln_name, sizeof(hd->linkname) - 1);
 603                 hd->linkname[sizeof(hd->linkname) - 1] = '\0';
 604                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 1))
 605                         goto out;
 606         } else {
 607                 /*
 608                  * data follows this file, so set the pad
 609                  */
 610                 hd->linkflag = AREGTYPE;
 611                 memset(hd->linkname, 0, sizeof(hd->linkname));
 612 #               ifdef NET2_STAT
 613                 if (ul_oct((u_long)arcn->sb.st_size, hd->size,
 614                     sizeof(hd->size), 1)) {
 615 #               else
 616                 if (uqd_oct((u_quad_t)arcn->sb.st_size, hd->size,
 617                     sizeof(hd->size), 1)) {
 618 #               endif
 619                         paxwarn(1,"File is too large for tar %s", arcn->org_name);
 620                         return(1);
 621                 }
 622                 arcn->pad = TAR_PAD(arcn->sb.st_size);
 623         }
 624
 625         /*
 626          * copy those fields that are independent of the type
 627          */
 628         if (ul_oct((u_long)arcn->sb.st_mode, hd->mode, sizeof(hd->mode), 0) ||
 629             ul_oct((u_long)arcn->sb.st_uid, hd->uid, sizeof(hd->uid), 0) ||
 630             ul_oct((u_long)arcn->sb.st_gid, hd->gid, sizeof(hd->gid), 0) ||
 631             ul_oct((u_long)arcn->sb.st_mtime, hd->mtime, sizeof(hd->mtime), 1))
 632                 goto out;
 633
 634         /*
 635          * calculate and add the checksum, then write the header. A return of
 636          * 0 tells the caller to now write the file data, 1 says no data needs
 637          * to be written
 638          */
 639         if (ul_oct(tar_chksm((char *)&hdblk, sizeof(HD_TAR)), hd->chksum,
 640             sizeof(hd->chksum), 3))
 641                 goto out;
 642         if (wr_rdbuf((char *)&hdblk, sizeof(HD_TAR)) < 0)
 643                 return(-1);
 644         if (wr_skip((off_t)(BLKMULT - sizeof(HD_TAR))) < 0)
 645                 return(-1);
 646         if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG))
 647                 return(0);
 648         return(1);
 649
 650     out:
 651         /*
 652          * header field is out of range
 653          */
 654         paxwarn(1, "Tar header field is too small for %s", arcn->org_name);
 655         return(1);
 656 }
 657
 658 /*
 659  * Routines for POSIX ustar
 660  */
 661
 662 /*
 663  * ustar_strd()
 664  *      initialization for ustar read
 665  * Return:
 666  *      0 if ok, -1 otherwise
 667  */
 668
 669 int
 670 ustar_strd(void)
 671 {
 672         if ((usrtb_start() < 0) || (grptb_start() < 0))
 673                 return(-1);
 674         return(0);
 675 }
 676
 677 /*
 678  * ustar_stwr()
 679  *      initialization for ustar write
 680  * Return:
 681  *      0 if ok, -1 otherwise
 682  */
 683
 684 int
 685 ustar_stwr(void)
 686 {
 687         if ((uidtb_start() < 0) || (gidtb_start() < 0))
 688                 return(-1);
 689         return(0);
 690 }
 691
 692 /*
 693  * ustar_id()
 694  *      determine if a block given to us is a valid ustar header. We have to
 695  *      be on the lookout for those pesky blocks of all zero's
 696  * Return:
 697  *      0 if a ustar header, -1 otherwise
 698  */
 699
 700 int
 701 ustar_id(char *blk, int size)
 702 {
 703         HD_USTAR *hd;
 704
 705         if (size < BLKMULT)
 706                 return(-1);
 707         hd = (HD_USTAR *)blk;
 708
 709         /*
 710          * check for block of zero's first, a simple and fast test then check
 711          * ustar magic cookie. We should use TMAGLEN, but some USTAR archive
 712          * programs are fouled up and create archives missing the \0. Last we
 713          * check the checksum. If ok we have to assume it is a valid header.
 714          */
 715         if (hd->name[0] == '\0')
 716                 return(-1);
 717         if (strncmp(hd->magic, TMAGIC, TMAGLEN - 1) != 0)
 718                 return(-1);
 719         if (asc_ul(hd->chksum,sizeof(hd->chksum),OCT) != tar_chksm(blk,BLKMULT))
 720                 return(-1);
 721         return(0);
 722 }
 723
 724 /*
 725  * ustar_rd()
 726  *      extract the values out of block already determined to be a ustar header.
 727  *      store the values in the ARCHD parameter.
 728  * Return:
 729  *      0
 730  */
 731
 732 int
 733 ustar_rd(ARCHD *arcn, char *buf)
 734 {
 735         HD_USTAR *hd;
 736         char *dest;
 737         int cnt = 0;
 738         dev_t devmajor;
 739         dev_t devminor;
 740
 741         /*
 742          * we only get proper sized buffers
 743          */
 744         if (ustar_id(buf, BLKMULT) < 0)
 745                 return(-1);
 746         arcn->org_name = arcn->name;
 747         arcn->sb.st_nlink = 1;
 748         arcn->pat = NULL;
 749         arcn->nlen = 0;
 750         hd = (HD_USTAR *)buf;
 751
 752         /*
 753          * see if the filename is split into two parts. if, so joint the parts.
 754          * we copy the prefix first and add a / between the prefix and name.
 755          */
 756         dest = arcn->name;
 757         if (*(hd->prefix) != '\0') {
 758                 cnt = l_strncpy(dest, hd->prefix,
 759                     MIN(sizeof(hd->prefix), sizeof(arcn->name) - 2));
 760                 dest += cnt;
 761                 *dest++ = '/';
 762                 cnt++;
 763         }
 764         /*
 765          * ustar format specifies the name may be unterminated
 766          * if it fills the entire field.  this also applies to
 767          * the prefix and the linkname.
 768          */
 769         arcn->nlen = cnt + l_strncpy(dest, hd->name,
 770             MIN(sizeof(hd->name), sizeof(arcn->name) - cnt - 1));
 771         arcn->name[arcn->nlen] = '\0';
 772
 773         /*
 774          * follow the spec to the letter. we should only have mode bits, strip
 775          * off all other crud we may be passed.
 776          */
 777         arcn->sb.st_mode = (mode_t)(asc_ul(hd->mode, sizeof(hd->mode), OCT) &
 778             0xfff);
 779 #ifdef NET2_STAT
 780         arcn->sb.st_size = (off_t)asc_ul(hd->size, sizeof(hd->size), OCT);
 781         arcn->sb.st_mtime = (time_t)asc_ul(hd->mtime, sizeof(hd->mtime), OCT);
 782 #else
 783         arcn->sb.st_size = (off_t)asc_uqd(hd->size, sizeof(hd->size), OCT);
 784         arcn->sb.st_mtime = (time_t)asc_uqd(hd->mtime, sizeof(hd->mtime), OCT);
 785 #endif
 786         arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime;
 787
 788         /*
 789          * If we can find the ascii names for gname and uname in the password
 790          * and group files we will use the uid's and gid they bind. Otherwise
 791          * we use the uid and gid values stored in the header. (This is what
 792          * the POSIX spec wants).
 793          */
 794         hd->gname[sizeof(hd->gname) - 1] = '\0';
 795         if (gid_name(hd->gname, &(arcn->sb.st_gid)) < 0)
 796                 arcn->sb.st_gid = (gid_t)asc_ul(hd->gid, sizeof(hd->gid), OCT);
 797         hd->uname[sizeof(hd->uname) - 1] = '\0';
 798         if (uid_name(hd->uname, &(arcn->sb.st_uid)) < 0)
 799                 arcn->sb.st_uid = (uid_t)asc_ul(hd->uid, sizeof(hd->uid), OCT);
 800
 801         /*
 802          * set the defaults, these may be changed depending on the file type
 803          */
 804         arcn->ln_name[0] = '\0';
 805         arcn->ln_nlen = 0;
 806         arcn->pad = 0;
 807         arcn->skip = 0;
 808         arcn->sb.st_rdev = (dev_t)0;
 809
 810         /*
 811          * set the mode and PAX type according to the typeflag in the header
 812          */
 813         switch(hd->typeflag) {
 814         case FIFOTYPE:
 815                 arcn->type = PAX_FIF;
 816                 arcn->sb.st_mode |= S_IFIFO;
 817                 break;
 818         case DIRTYPE:
 819                 arcn->type = PAX_DIR;
 820                 arcn->sb.st_mode |= S_IFDIR;
 821                 arcn->sb.st_nlink = 2;
 822
 823                 /*
 824                  * Some programs that create ustar archives append a '/'
 825                  * to the pathname for directories. This clearly violates
 826                  * ustar specs, but we will silently strip it off anyway.
 827                  */
 828                 if (arcn->name[arcn->nlen - 1] == '/')
 829                         arcn->name[--arcn->nlen] = '\0';
 830                 break;
 831         case BLKTYPE:
 832         case CHRTYPE:
 833                 /*
 834                  * this type requires the rdev field to be set.
 835                  */
 836                 if (hd->typeflag == BLKTYPE) {
 837                         arcn->type = PAX_BLK;
 838                         arcn->sb.st_mode |= S_IFBLK;
 839                 } else {
 840                         arcn->type = PAX_CHR;
 841                         arcn->sb.st_mode |= S_IFCHR;
 842                 }
 843                 devmajor = (dev_t)asc_ul(hd->devmajor,sizeof(hd->devmajor),OCT);
 844                 devminor = (dev_t)asc_ul(hd->devminor,sizeof(hd->devminor),OCT);
 845                 arcn->sb.st_rdev = TODEV(devmajor, devminor);
 846                 break;
 847         case SYMTYPE:
 848         case LNKTYPE:
 849                 if (hd->typeflag == SYMTYPE) {
 850                         arcn->type = PAX_SLK;
 851                         arcn->sb.st_mode |= S_IFLNK;
 852                 } else {
 853                         arcn->type = PAX_HLK;
 854                         /*
 855                          * so printing looks better
 856                          */
 857                         arcn->sb.st_mode |= S_IFREG;
 858                         arcn->sb.st_nlink = 2;
 859                 }
 860                 /*
 861                  * copy the link name
 862                  */
 863                 arcn->ln_nlen = l_strncpy(arcn->ln_name, hd->linkname,
 864                     MIN(sizeof(hd->linkname), sizeof(arcn->ln_name) - 1));
 865                 arcn->ln_name[arcn->ln_nlen] = '\0';
 866                 break;
 867         case CONTTYPE:
 868         case AREGTYPE:
 869         case REGTYPE:
 870         default:
 871                 /*
 872                  * these types have file data that follows. Set the skip and
 873                  * pad fields.
 874                  */
 875                 arcn->type = PAX_REG;
 876                 arcn->pad = TAR_PAD(arcn->sb.st_size);
 877                 arcn->skip = arcn->sb.st_size;
 878                 arcn->sb.st_mode |= S_IFREG;
 879                 break;
 880         }
 881         return(0);
 882 }
 883
 884 /*
 885  * ustar_wr()
 886  *      write a ustar header for the file specified in the ARCHD to the archive
 887  *      Have to check for file types that cannot be stored and file names that
 888  *      are too long. Be careful of the term (last arg) to ul_oct, we only use
 889  *      '\0' for the termination character (this is different than picky tar)
 890  *      ASSUMED: space after header in header block is zero filled
 891  * Return:
 892  *      0 if file has data to be written after the header, 1 if file has NO
 893  *      data to write after the header, -1 if archive write failed
 894  */
 895
 896 int
 897 ustar_wr(ARCHD *arcn)
 898 {
 899         HD_USTAR *hd;
 900         char *pt;
 901         HD_USTAR hdblk;
 902
 903         /*
 904          * check for those file system types ustar cannot store
 905          */
 906         if (arcn->type == PAX_SCK) {
 907                 paxwarn(1, "Ustar cannot archive a socket %s", arcn->org_name);
 908                 return(1);
 909         }
 910
 911         /*
 912          * check the length of the linkname
 913          */
 914         if (((arcn->type == PAX_SLK) || (arcn->type == PAX_HLK) ||
 915             (arcn->type == PAX_HRG)) &&
 916             (arcn->ln_nlen > (int)sizeof(hd->linkname))) {
 917                 paxwarn(1, "Link name too long for ustar %s", arcn->ln_name);
 918                 return(1);
 919         }
 920
 921         /*
 922          * split the path name into prefix and name fields (if needed). if
 923          * pt != arcn->name, the name has to be split
 924          */
 925         if ((pt = name_split(arcn->name, arcn->nlen)) == NULL) {
 926                 paxwarn(1, "File name too long for ustar %s", arcn->name);
 927                 return(1);
 928         }
 929         hd = &hdblk;
 930         arcn->pad = 0L;
 931
 932         /*
 933          * split the name, or zero out the prefix
 934          */
 935         if (pt != arcn->name) {
 936                 /*
 937                  * name was split, pt points at the / where the split is to
 938                  * occur, we remove the / and copy the first part to the prefix
 939                  */
 940                 *pt = '\0';
 941                 l_strncpy(hd->prefix, arcn->name, sizeof(hd->prefix));
 942                 *pt++ = '/';
 943         } else
 944                 memset(hd->prefix, 0, sizeof(hd->prefix));
 945
 946         /*
 947          * copy the name part. this may be the whole path or the part after
 948          * the prefix.  both the name and prefix may fill the entire field.
 949          */
 950         l_strncpy(hd->name, pt, sizeof(hd->name));
 951
 952         /*
 953          * set the fields in the header that are type dependent
 954          */
 955         switch(arcn->type) {
 956         case PAX_DIR:
 957                 hd->typeflag = DIRTYPE;
 958                 memset(hd->linkname, 0, sizeof(hd->linkname));
 959                 memset(hd->devmajor, 0, sizeof(hd->devmajor));
 960                 memset(hd->devminor, 0, sizeof(hd->devminor));
 961                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3))
 962                         goto out;
 963                 break;
 964         case PAX_CHR:
 965         case PAX_BLK:
 966                 if (arcn->type == PAX_CHR)
 967                         hd->typeflag = CHRTYPE;
 968                 else
 969                         hd->typeflag = BLKTYPE;
 970                 memset(hd->linkname, 0, sizeof(hd->linkname));
 971                 if (ul_oct((u_long)MAJOR(arcn->sb.st_rdev), hd->devmajor,
 972                    sizeof(hd->devmajor), 3) ||
 973                    ul_oct((u_long)MINOR(arcn->sb.st_rdev), hd->devminor,
 974                    sizeof(hd->devminor), 3) ||
 975                    ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3))
 976                         goto out;
 977                 break;
 978         case PAX_FIF:
 979                 hd->typeflag = FIFOTYPE;
 980                 memset(hd->linkname, 0, sizeof(hd->linkname));
 981                 memset(hd->devmajor, 0, sizeof(hd->devmajor));
 982                 memset(hd->devminor, 0, sizeof(hd->devminor));
 983                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3))
 984                         goto out;
 985                 break;
 986         case PAX_SLK:
 987         case PAX_HLK:
 988         case PAX_HRG:
 989                 if (arcn->type == PAX_SLK)
 990                         hd->typeflag = SYMTYPE;
 991                 else
 992                         hd->typeflag = LNKTYPE;
 993                 /* the link name may occupy the entire field in ustar */
 994                 l_strncpy(hd->linkname,arcn->ln_name, sizeof(hd->linkname));
 995                 memset(hd->devmajor, 0, sizeof(hd->devmajor));
 996                 memset(hd->devminor, 0, sizeof(hd->devminor));
 997                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3))
 998                         goto out;
 999                 break;
1000         case PAX_REG:
1001         case PAX_CTG:
1002         default:
1003                 /*
1004                  * file data with this type, set the padding
1005                  */
1006                 if (arcn->type == PAX_CTG)
1007                         hd->typeflag = CONTTYPE;
1008                 else
1009                         hd->typeflag = REGTYPE;
1010                 memset(hd->linkname, 0, sizeof(hd->linkname));
1011                 memset(hd->devmajor, 0, sizeof(hd->devmajor));
1012                 memset(hd->devminor, 0, sizeof(hd->devminor));
1013                 arcn->pad = TAR_PAD(arcn->sb.st_size);
1014 #               ifdef NET2_STAT
1015                 if (ul_oct((u_long)arcn->sb.st_size, hd->size,
1016                     sizeof(hd->size), 3)) {
1017 #               else
1018                 if (uqd_oct((u_quad_t)arcn->sb.st_size, hd->size,
1019                     sizeof(hd->size), 3)) {
1020 #               endif
1021                         paxwarn(1,"File is too long for ustar %s",arcn->org_name);
1022                         return(1);
1023                 }
1024                 break;
1025         }
1026
1027         l_strncpy(hd->magic, TMAGIC, TMAGLEN);
1028         l_strncpy(hd->version, TVERSION, TVERSLEN);
1029
1030         /*
1031          * set the remaining fields. Some versions want all 16 bits of mode
1032          * we better humor them (they really do not meet spec though)....
1033          */
1034         if (ul_oct((u_long)arcn->sb.st_mode, hd->mode, sizeof(hd->mode), 3) ||
1035             ul_oct((u_long)arcn->sb.st_uid, hd->uid, sizeof(hd->uid), 3)  ||
1036             ul_oct((u_long)arcn->sb.st_gid, hd->gid, sizeof(hd->gid), 3) ||
1037             ul_oct((u_long)arcn->sb.st_mtime,hd->mtime,sizeof(hd->mtime),3))
1038                 goto out;
1039         l_strncpy(hd->uname,name_uid(arcn->sb.st_uid, 0),sizeof(hd->uname));
1040         l_strncpy(hd->gname,name_gid(arcn->sb.st_gid, 0),sizeof(hd->gname));
1041
1042         /*
1043          * calculate and store the checksum write the header to the archive
1044          * return 0 tells the caller to now write the file data, 1 says no data
1045          * needs to be written
1046          */
1047         if (ul_oct(tar_chksm((char *)&hdblk, sizeof(HD_USTAR)), hd->chksum,
1048            sizeof(hd->chksum), 3))
1049                 goto out;
1050         if (wr_rdbuf((char *)&hdblk, sizeof(HD_USTAR)) < 0)
1051                 return(-1);
1052         if (wr_skip((off_t)(BLKMULT - sizeof(HD_USTAR))) < 0)
1053                 return(-1);
1054         if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG))
1055                 return(0);
1056         return(1);
1057
1058     out:
1059         /*
1060          * header field is out of range
1061          */
1062         paxwarn(1, "Ustar header field is too small for %s", arcn->org_name);
1063         return(1);
1064 }
1065
1066 /*
1067  * name_split()
1068  *      see if the name has to be split for storage in a ustar header. We try
1069  *      to fit the entire name in the name field without splitting if we can.
1070  *      The split point is always at a /
1071  * Return
1072  *      character pointer to split point (always the / that is to be removed
1073  *      if the split is not needed, the points is set to the start of the file
1074  *      name (it would violate the spec to split there). A NULL is returned if
1075  *      the file name is too long
1076  */
1077
1078 static char *
1079 name_split(char *name, int len)
1080 {
1081         char *start;
1082
1083         /*
1084          * check to see if the file name is small enough to fit in the name
1085          * field. if so just return a pointer to the name.
1086          */
1087         if (len <= TNMSZ)
1088                 return(name);
1089         if (len > TPFSZ + TNMSZ)
1090                 return(NULL);
1091
1092         /*
1093          * we start looking at the biggest sized piece that fits in the name
1094          * field. We walk forward looking for a slash to split at. The idea is
1095          * to find the biggest piece to fit in the name field (or the smallest
1096          * prefix we can find)
1097          */
1098         start = name + len - TNMSZ;
1099         while ((*start != '\0') && (*start != '/'))
1100                 ++start;
1101
1102         /*
1103          * if we hit the end of the string, this name cannot be split, so we
1104          * cannot store this file.
1105          */
1106         if (*start == '\0')
1107                 return(NULL);
1108         len = start - name;
1109
1110         /*
1111          * NOTE: /str where the length of str == TNMSZ can not be stored under
1112          * the p1003.1-1990 spec for ustar. We could force a prefix of / and
1113          * the file would then expand on extract to //str. The len == 0 below
1114          * makes this special case follow the spec to the letter.
1115          */
1116         if ((len > TPFSZ) || (len == 0))
1117                 return(NULL);
1118
1119         /*
1120          * ok have a split point, return it to the caller
1121          */
1122         return(start);
1123 }