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  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by the University of
  20  *      California, Berkeley and its contributors.
  21  * 4. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  *
  37  * @(#)tar.c    8.2 (Berkeley) 4/18/94
  38  * $FreeBSD: src/bin/pax/tar.c,v 1.13.2.1 2001/08/01 05:03:12 obrien Exp $
  39  * $DragonFly: src/bin/pax/tar.c,v 1.4 2003/09/28 14:39:14 hmp Exp $
  40  */
  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 (register char *, register int);
  58 static char *name_split (register char *, register int);
  59 static int ul_oct (u_long, register char *, register int, int);
  60 #ifndef NET2_STAT
  61 static int uqd_oct (u_quad_t, register char *, register 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(register char *buf, register int in_resync, register int *cnt)
 109 {
 110         register 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, register char *str, register int len, int term)
 152 {
 153         register 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, register char *str, register int len, int term)
 207 {
 208         register 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(register char *blk, register int len)
 261 {
 262         register char *stop;
 263         register 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(register char *blk, int size)
 302 {
 303         register HD_TAR *hd;
 304         register 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(register ARCHD *arcn, register char *buf)
 373 {
 374         register HD_TAR *hd;
 375         register 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         arcn->nlen = l_strncpy(arcn->name, hd->name, sizeof(arcn->name) - 1);
 391         arcn->name[arcn->nlen] = '\0';
 392         arcn->sb.st_mode = (mode_t)(asc_ul(hd->mode,sizeof(hd->mode),OCT) &
 393             0xfff);
 394         arcn->sb.st_uid = (uid_t)asc_ul(hd->uid, sizeof(hd->uid), OCT);
 395         arcn->sb.st_gid = (gid_t)asc_ul(hd->gid, sizeof(hd->gid), OCT);
 396 #ifdef NET2_STAT
 397         arcn->sb.st_size = (off_t)asc_ul(hd->size, sizeof(hd->size), OCT);
 398 #else
 399         arcn->sb.st_size = (off_t)asc_uqd(hd->size, sizeof(hd->size), OCT);
 400 #endif
 401         arcn->sb.st_mtime = (time_t)asc_ul(hd->mtime, sizeof(hd->mtime), OCT);
 402         arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime;
 403
 404         /*
 405          * have to look at the last character, it may be a '/' and that is used
 406          * to encode this as a directory
 407          */
 408         pt = &(arcn->name[arcn->nlen - 1]);
 409         arcn->pad = 0;
 410         arcn->skip = 0;
 411         switch(hd->linkflag) {
 412         case SYMTYPE:
 413                 /*
 414                  * symbolic link, need to get the link name and set the type in
 415                  * the st_mode so -v printing will look correct.
 416                  */
 417                 arcn->type = PAX_SLK;
 418                 arcn->ln_nlen = l_strncpy(arcn->ln_name, hd->linkname,
 419                         sizeof(arcn->ln_name) - 1);
 420                 arcn->ln_name[arcn->ln_nlen] = '\0';
 421                 arcn->sb.st_mode |= S_IFLNK;
 422                 break;
 423         case LNKTYPE:
 424                 /*
 425                  * hard link, need to get the link name, set the type in the
 426                  * st_mode and st_nlink so -v printing will look better.
 427                  */
 428                 arcn->type = PAX_HLK;
 429                 arcn->sb.st_nlink = 2;
 430                 arcn->ln_nlen = l_strncpy(arcn->ln_name, hd->linkname,
 431                         sizeof(arcn->ln_name) - 1);
 432                 arcn->ln_name[arcn->ln_nlen] = '\0';
 433
 434                 /*
 435                  * no idea of what type this thing really points at, but
 436                  * we set something for printing only.
 437                  */
 438                 arcn->sb.st_mode |= S_IFREG;
 439                 break;
 440         case DIRTYPE:
 441                 /*
 442                  * It is a directory, set the mode for -v printing
 443                  */
 444                 arcn->type = PAX_DIR;
 445                 arcn->sb.st_mode |= S_IFDIR;
 446                 arcn->sb.st_nlink = 2;
 447                 arcn->ln_name[0] = '\0';
 448                 arcn->ln_nlen = 0;
 449                 break;
 450         case AREGTYPE:
 451         case REGTYPE:
 452         default:
 453                 /*
 454                  * If we have a trailing / this is a directory and NOT a file.
 455                  */
 456                 arcn->ln_name[0] = '\0';
 457                 arcn->ln_nlen = 0;
 458                 if (*pt == '/') {
 459                         /*
 460                          * it is a directory, set the mode for -v printing
 461                          */
 462                         arcn->type = PAX_DIR;
 463                         arcn->sb.st_mode |= S_IFDIR;
 464                         arcn->sb.st_nlink = 2;
 465                 } else {
 466                         /*
 467                          * have a file that will be followed by data. Set the
 468                          * skip value to the size field and calculate the size
 469                          * of the padding.
 470                          */
 471                         arcn->type = PAX_REG;
 472                         arcn->sb.st_mode |= S_IFREG;
 473                         arcn->pad = TAR_PAD(arcn->sb.st_size);
 474                         arcn->skip = arcn->sb.st_size;
 475                 }
 476                 break;
 477         }
 478
 479         /*
 480          * strip off any trailing slash.
 481          */
 482         if (*pt == '/') {
 483                 *pt = '\0';
 484                 --arcn->nlen;
 485         }
 486         return(0);
 487 }
 488
 489 /*
 490  * tar_wr()
 491  *      write a tar header for the file specified in the ARCHD to the archive.
 492  *      Have to check for file types that cannot be stored and file names that
 493  *      are too long. Be careful of the term (last arg) to ul_oct, each field
 494  *      of tar has it own spec for the termination character(s).
 495  *      ASSUMED: space after header in header block is zero filled
 496  * Return:
 497  *      0 if file has data to be written after the header, 1 if file has NO
 498  *      data to write after the header, -1 if archive write failed
 499  */
 500
 501 int
 502 tar_wr(register ARCHD *arcn)
 503 {
 504         register HD_TAR *hd;
 505         int len;
 506         char hdblk[sizeof(HD_TAR)];
 507
 508         /*
 509          * check for those file system types which tar cannot store
 510          */
 511         switch(arcn->type) {
 512         case PAX_DIR:
 513                 /*
 514                  * user asked that dirs not be written to the archive
 515                  */
 516                 if (tar_nodir)
 517                         return(1);
 518                 break;
 519         case PAX_CHR:
 520                 paxwarn(1, "Tar cannot archive a character device %s",
 521                     arcn->org_name);
 522                 return(1);
 523         case PAX_BLK:
 524                 paxwarn(1, "Tar cannot archive a block device %s", arcn->org_name);
 525                 return(1);
 526         case PAX_SCK:
 527                 paxwarn(1, "Tar cannot archive a socket %s", arcn->org_name);
 528                 return(1);
 529         case PAX_FIF:
 530                 paxwarn(1, "Tar cannot archive a fifo %s", arcn->org_name);
 531                 return(1);
 532         case PAX_SLK:
 533         case PAX_HLK:
 534         case PAX_HRG:
 535                 if (arcn->ln_nlen > sizeof(hd->linkname)) {
 536                         paxwarn(1,"Link name too long for tar %s", arcn->ln_name);
 537                         return(1);
 538                 }
 539                 break;
 540         case PAX_REG:
 541         case PAX_CTG:
 542         default:
 543                 break;
 544         }
 545
 546         /*
 547          * check file name len, remember extra char for dirs (the / at the end)
 548          */
 549         len = arcn->nlen;
 550         if (arcn->type == PAX_DIR)
 551                 ++len;
 552         if (len >= sizeof(hd->name)) {
 553                 paxwarn(1, "File name too long for tar %s", arcn->name);
 554                 return(1);
 555         }
 556
 557         /*
 558          * copy the data out of the ARCHD into the tar header based on the type
 559          * of the file. Remember many tar readers want the unused fields to be
 560          * padded with zero. We set the linkflag field (type), the linkname
 561          * (or zero if not used),the size, and set the padding (if any) to be
 562          * added after the file data (0 for all other types, as they only have
 563          * a header)
 564          */
 565         hd = (HD_TAR *)hdblk;
 566         l_strncpy(hd->name, arcn->name, sizeof(hd->name) - 1);
 567         hd->name[sizeof(hd->name) - 1] = '\0';
 568         arcn->pad = 0;
 569
 570         if (arcn->type == PAX_DIR) {
 571                 /*
 572                  * directories are the same as files, except have a filename
 573                  * that ends with a /, we add the slash here. No data follows,
 574                  * dirs, so no pad.
 575                  */
 576                 hd->linkflag = AREGTYPE;
 577                 memset(hd->linkname, 0, sizeof(hd->linkname));
 578                 hd->name[len-1] = '/';
 579                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 1))
 580                         goto out;
 581         } else if (arcn->type == PAX_SLK) {
 582                 /*
 583                  * no data follows this file, so no pad
 584                  */
 585                 hd->linkflag = SYMTYPE;
 586                 l_strncpy(hd->linkname,arcn->ln_name, sizeof(hd->linkname) - 1);
 587                 hd->linkname[sizeof(hd->linkname) - 1] = '\0';
 588                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 1))
 589                         goto out;
 590         } else if ((arcn->type == PAX_HLK) || (arcn->type == PAX_HRG)) {
 591                 /*
 592                  * no data follows this file, so no pad
 593                  */
 594                 hd->linkflag = LNKTYPE;
 595                 l_strncpy(hd->linkname,arcn->ln_name, sizeof(hd->linkname) - 1);
 596                 hd->linkname[sizeof(hd->linkname) - 1] = '\0';
 597                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 1))
 598                         goto out;
 599         } else {
 600                 /*
 601                  * data follows this file, so set the pad
 602                  */
 603                 hd->linkflag = AREGTYPE;
 604                 memset(hd->linkname, 0, sizeof(hd->linkname));
 605 #               ifdef NET2_STAT
 606                 if (ul_oct((u_long)arcn->sb.st_size, hd->size,
 607                     sizeof(hd->size), 1)) {
 608 #               else
 609                 if (uqd_oct((u_quad_t)arcn->sb.st_size, hd->size,
 610                     sizeof(hd->size), 1)) {
 611 #               endif
 612                         paxwarn(1,"File is too large for tar %s", arcn->org_name);
 613                         return(1);
 614                 }
 615                 arcn->pad = TAR_PAD(arcn->sb.st_size);
 616         }
 617
 618         /*
 619          * copy those fields that are independent of the type
 620          */
 621         if (ul_oct((u_long)arcn->sb.st_mode, hd->mode, sizeof(hd->mode), 0) ||
 622             ul_oct((u_long)arcn->sb.st_uid, hd->uid, sizeof(hd->uid), 0) ||
 623             ul_oct((u_long)arcn->sb.st_gid, hd->gid, sizeof(hd->gid), 0) ||
 624             ul_oct((u_long)arcn->sb.st_mtime, hd->mtime, sizeof(hd->mtime), 1))
 625                 goto out;
 626
 627         /*
 628          * calculate and add the checksum, then write the header. A return of
 629          * 0 tells the caller to now write the file data, 1 says no data needs
 630          * to be written
 631          */
 632         if (ul_oct(tar_chksm(hdblk, sizeof(HD_TAR)), hd->chksum,
 633             sizeof(hd->chksum), 3))
 634                 goto out;
 635         if (wr_rdbuf(hdblk, sizeof(HD_TAR)) < 0)
 636                 return(-1);
 637         if (wr_skip((off_t)(BLKMULT - sizeof(HD_TAR))) < 0)
 638                 return(-1);
 639         if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG))
 640                 return(0);
 641         return(1);
 642
 643     out:
 644         /*
 645          * header field is out of range
 646          */
 647         paxwarn(1, "Tar header field is too small for %s", arcn->org_name);
 648         return(1);
 649 }
 650
 651 /*
 652  * Routines for POSIX ustar
 653  */
 654
 655 /*
 656  * ustar_strd()
 657  *      initialization for ustar read
 658  * Return:
 659  *      0 if ok, -1 otherwise
 660  */
 661
 662 int
 663 ustar_strd(void)
 664 {
 665         if ((usrtb_start() < 0) || (grptb_start() < 0))
 666                 return(-1);
 667         return(0);
 668 }
 669
 670 /*
 671  * ustar_stwr()
 672  *      initialization for ustar write
 673  * Return:
 674  *      0 if ok, -1 otherwise
 675  */
 676
 677 int
 678 ustar_stwr(void)
 679 {
 680         if ((uidtb_start() < 0) || (gidtb_start() < 0))
 681                 return(-1);
 682         return(0);
 683 }
 684
 685 /*
 686  * ustar_id()
 687  *      determine if a block given to us is a valid ustar header. We have to
 688  *      be on the lookout for those pesky blocks of all zero's
 689  * Return:
 690  *      0 if a ustar header, -1 otherwise
 691  */
 692
 693 int
 694 ustar_id(char *blk, int size)
 695 {
 696         register HD_USTAR *hd;
 697
 698         if (size < BLKMULT)
 699                 return(-1);
 700         hd = (HD_USTAR *)blk;
 701
 702         /*
 703          * check for block of zero's first, a simple and fast test then check
 704          * ustar magic cookie. We should use TMAGLEN, but some USTAR archive
 705          * programs are fouled up and create archives missing the \0. Last we
 706          * check the checksum. If ok we have to assume it is a valid header.
 707          */
 708         if (hd->name[0] == '\0')
 709                 return(-1);
 710         if (strncmp(hd->magic, TMAGIC, TMAGLEN - 1) != 0)
 711                 return(-1);
 712         if (asc_ul(hd->chksum,sizeof(hd->chksum),OCT) != tar_chksm(blk,BLKMULT))
 713                 return(-1);
 714         return(0);
 715 }
 716
 717 /*
 718  * ustar_rd()
 719  *      extract the values out of block already determined to be a ustar header.
 720  *      store the values in the ARCHD parameter.
 721  * Return:
 722  *      0
 723  */
 724
 725 int
 726 ustar_rd(register ARCHD *arcn, register char *buf)
 727 {
 728         register HD_USTAR *hd;
 729         register char *dest;
 730         register int cnt = 0;
 731         dev_t devmajor;
 732         dev_t devminor;
 733
 734         /*
 735          * we only get proper sized buffers
 736          */
 737         if (ustar_id(buf, BLKMULT) < 0)
 738                 return(-1);
 739         arcn->org_name = arcn->name;
 740         arcn->sb.st_nlink = 1;
 741         arcn->pat = NULL;
 742         arcn->nlen = 0;
 743         hd = (HD_USTAR *)buf;
 744
 745         /*
 746          * see if the filename is split into two parts. if, so joint the parts.
 747          * we copy the prefix first and add a / between the prefix and name.
 748          */
 749         dest = arcn->name;
 750         if (*(hd->prefix) != '\0') {
 751                 cnt = l_strncpy(dest, hd->prefix, sizeof(arcn->name) - 2);
 752                 dest += cnt;
 753                 *dest++ = '/';
 754                 cnt++;
 755         }
 756         arcn->nlen = cnt + l_strncpy(dest, hd->name, sizeof(arcn->name) - cnt);
 757         arcn->name[arcn->nlen] = '\0';
 758
 759         /*
 760          * follow the spec to the letter. we should only have mode bits, strip
 761          * off all other crud we may be passed.
 762          */
 763         arcn->sb.st_mode = (mode_t)(asc_ul(hd->mode, sizeof(hd->mode), OCT) &
 764             0xfff);
 765 #ifdef NET2_STAT
 766         arcn->sb.st_size = (off_t)asc_ul(hd->size, sizeof(hd->size), OCT);
 767 #else
 768         arcn->sb.st_size = (off_t)asc_uqd(hd->size, sizeof(hd->size), OCT);
 769 #endif
 770         arcn->sb.st_mtime = (time_t)asc_ul(hd->mtime, sizeof(hd->mtime), OCT);
 771         arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime;
 772
 773         /*
 774          * If we can find the ascii names for gname and uname in the password
 775          * and group files we will use the uid's and gid they bind. Otherwise
 776          * we use the uid and gid values stored in the header. (This is what
 777          * the POSIX spec wants).
 778          */
 779         hd->gname[sizeof(hd->gname) - 1] = '\0';
 780         if (gid_name(hd->gname, &(arcn->sb.st_gid)) < 0)
 781                 arcn->sb.st_gid = (gid_t)asc_ul(hd->gid, sizeof(hd->gid), OCT);
 782         hd->uname[sizeof(hd->uname) - 1] = '\0';
 783         if (uid_name(hd->uname, &(arcn->sb.st_uid)) < 0)
 784                 arcn->sb.st_uid = (uid_t)asc_ul(hd->uid, sizeof(hd->uid), OCT);
 785
 786         /*
 787          * set the defaults, these may be changed depending on the file type
 788          */
 789         arcn->ln_name[0] = '\0';
 790         arcn->ln_nlen = 0;
 791         arcn->pad = 0;
 792         arcn->skip = 0;
 793         arcn->sb.st_rdev = (dev_t)0;
 794
 795         /*
 796          * set the mode and PAX type according to the typeflag in the header
 797          */
 798         switch(hd->typeflag) {
 799         case FIFOTYPE:
 800                 arcn->type = PAX_FIF;
 801                 arcn->sb.st_mode |= S_IFIFO;
 802                 break;
 803         case DIRTYPE:
 804                 arcn->type = PAX_DIR;
 805                 arcn->sb.st_mode |= S_IFDIR;
 806                 arcn->sb.st_nlink = 2;
 807
 808                 /*
 809                  * Some programs that create ustar archives append a '/'
 810                  * to the pathname for directories. This clearly violates
 811                  * ustar specs, but we will silently strip it off anyway.
 812                  */
 813                 if (arcn->name[arcn->nlen - 1] == '/')
 814                         arcn->name[--arcn->nlen] = '\0';
 815                 break;
 816         case BLKTYPE:
 817         case CHRTYPE:
 818                 /*
 819                  * this type requires the rdev field to be set.
 820                  */
 821                 if (hd->typeflag == BLKTYPE) {
 822                         arcn->type = PAX_BLK;
 823                         arcn->sb.st_mode |= S_IFBLK;
 824                 } else {
 825                         arcn->type = PAX_CHR;
 826                         arcn->sb.st_mode |= S_IFCHR;
 827                 }
 828                 devmajor = (dev_t)asc_ul(hd->devmajor,sizeof(hd->devmajor),OCT);
 829                 devminor = (dev_t)asc_ul(hd->devminor,sizeof(hd->devminor),OCT);
 830                 arcn->sb.st_rdev = TODEV(devmajor, devminor);
 831                 break;
 832         case SYMTYPE:
 833         case LNKTYPE:
 834                 if (hd->typeflag == SYMTYPE) {
 835                         arcn->type = PAX_SLK;
 836                         arcn->sb.st_mode |= S_IFLNK;
 837                 } else {
 838                         arcn->type = PAX_HLK;
 839                         /*
 840                          * so printing looks better
 841                          */
 842                         arcn->sb.st_mode |= S_IFREG;
 843                         arcn->sb.st_nlink = 2;
 844                 }
 845                 /*
 846                  * copy the link name
 847                  */
 848                 arcn->ln_nlen = l_strncpy(arcn->ln_name, hd->linkname,
 849                         sizeof(arcn->ln_name) - 1);
 850                 arcn->ln_name[arcn->ln_nlen] = '\0';
 851                 break;
 852         case CONTTYPE:
 853         case AREGTYPE:
 854         case REGTYPE:
 855         default:
 856                 /*
 857                  * these types have file data that follows. Set the skip and
 858                  * pad fields.
 859                  */
 860                 arcn->type = PAX_REG;
 861                 arcn->pad = TAR_PAD(arcn->sb.st_size);
 862                 arcn->skip = arcn->sb.st_size;
 863                 arcn->sb.st_mode |= S_IFREG;
 864                 break;
 865         }
 866         return(0);
 867 }
 868
 869 /*
 870  * ustar_wr()
 871  *      write a ustar header for the file specified in the ARCHD to the archive
 872  *      Have to check for file types that cannot be stored and file names that
 873  *      are too long. Be careful of the term (last arg) to ul_oct, we only use
 874  *      '\0' for the termination character (this is different than picky tar)
 875  *      ASSUMED: space after header in header block is zero filled
 876  * Return:
 877  *      0 if file has data to be written after the header, 1 if file has NO
 878  *      data to write after the header, -1 if archive write failed
 879  */
 880
 881 int
 882 ustar_wr(register ARCHD *arcn)
 883 {
 884         register HD_USTAR *hd;
 885         register char *pt;
 886         char hdblk[sizeof(HD_USTAR)];
 887
 888         /*
 889          * check for those file system types ustar cannot store
 890          */
 891         if (arcn->type == PAX_SCK) {
 892                 paxwarn(1, "Ustar cannot archive a socket %s", arcn->org_name);
 893                 return(1);
 894         }
 895
 896         /*
 897          * check the length of the linkname
 898          */
 899         if (((arcn->type == PAX_SLK) || (arcn->type == PAX_HLK) ||
 900             (arcn->type == PAX_HRG)) && (arcn->ln_nlen >= sizeof(hd->linkname))){
 901                 paxwarn(1, "Link name too long for ustar %s", arcn->ln_name);
 902                 return(1);
 903         }
 904
 905         /*
 906          * split the path name into prefix and name fields (if needed). if
 907          * pt != arcn->name, the name has to be split
 908          */
 909         if ((pt = name_split(arcn->name, arcn->nlen)) == NULL) {
 910                 paxwarn(1, "File name too long for ustar %s", arcn->name);
 911                 return(1);
 912         }
 913         hd = (HD_USTAR *)hdblk;
 914         arcn->pad = 0L;
 915
 916         /*
 917          * split the name, or zero out the prefix
 918          */
 919         if (pt != arcn->name) {
 920                 /*
 921                  * name was split, pt points at the / where the split is to
 922                  * occur, we remove the / and copy the first part to the prefix
 923                  */
 924                 *pt = '\0';
 925                 l_strncpy(hd->prefix, arcn->name, sizeof(hd->prefix) - 1);
 926                 *pt++ = '/';
 927         } else
 928                 memset(hd->prefix, 0, sizeof(hd->prefix));
 929
 930         /*
 931          * copy the name part. this may be the whole path or the part after
 932          * the prefix
 933          */
 934         l_strncpy(hd->name, pt, sizeof(hd->name) - 1);
 935         hd->name[sizeof(hd->name) - 1] = '\0';
 936
 937         /*
 938          * set the fields in the header that are type dependent
 939          */
 940         switch(arcn->type) {
 941         case PAX_DIR:
 942                 hd->typeflag = DIRTYPE;
 943                 memset(hd->linkname, 0, sizeof(hd->linkname));
 944                 memset(hd->devmajor, 0, sizeof(hd->devmajor));
 945                 memset(hd->devminor, 0, sizeof(hd->devminor));
 946                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3))
 947                         goto out;
 948                 break;
 949         case PAX_CHR:
 950         case PAX_BLK:
 951                 if (arcn->type == PAX_CHR)
 952                         hd->typeflag = CHRTYPE;
 953                 else
 954                         hd->typeflag = BLKTYPE;
 955                 memset(hd->linkname, 0, sizeof(hd->linkname));
 956                 if (ul_oct((u_long)MAJOR(arcn->sb.st_rdev), hd->devmajor,
 957                    sizeof(hd->devmajor), 3) ||
 958                    ul_oct((u_long)MINOR(arcn->sb.st_rdev), hd->devminor,
 959                    sizeof(hd->devminor), 3) ||
 960                    ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3))
 961                         goto out;
 962                 break;
 963         case PAX_FIF:
 964                 hd->typeflag = FIFOTYPE;
 965                 memset(hd->linkname, 0, sizeof(hd->linkname));
 966                 memset(hd->devmajor, 0, sizeof(hd->devmajor));
 967                 memset(hd->devminor, 0, sizeof(hd->devminor));
 968                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3))
 969                         goto out;
 970                 break;
 971         case PAX_SLK:
 972         case PAX_HLK:
 973         case PAX_HRG:
 974                 if (arcn->type == PAX_SLK)
 975                         hd->typeflag = SYMTYPE;
 976                 else
 977                         hd->typeflag = LNKTYPE;
 978                 l_strncpy(hd->linkname,arcn->ln_name, sizeof(hd->linkname) - 1);
 979                 hd->linkname[sizeof(hd->linkname) - 1] = '\0';
 980                 memset(hd->devmajor, 0, sizeof(hd->devmajor));
 981                 memset(hd->devminor, 0, sizeof(hd->devminor));
 982                 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3))
 983                         goto out;
 984                 break;
 985         case PAX_REG:
 986         case PAX_CTG:
 987         default:
 988                 /*
 989                  * file data with this type, set the padding
 990                  */
 991                 if (arcn->type == PAX_CTG)
 992                         hd->typeflag = CONTTYPE;
 993                 else
 994                         hd->typeflag = REGTYPE;
 995                 memset(hd->linkname, 0, sizeof(hd->linkname));
 996                 memset(hd->devmajor, 0, sizeof(hd->devmajor));
 997                 memset(hd->devminor, 0, sizeof(hd->devminor));
 998                 arcn->pad = TAR_PAD(arcn->sb.st_size);
 999 #               ifdef NET2_STAT
1000                 if (ul_oct((u_long)arcn->sb.st_size, hd->size,
1001                     sizeof(hd->size), 3)) {
1002 #               else
1003                 if (uqd_oct((u_quad_t)arcn->sb.st_size, hd->size,
1004                     sizeof(hd->size), 3)) {
1005 #               endif
1006                         paxwarn(1,"File is too long for ustar %s",arcn->org_name);
1007                         return(1);
1008                 }
1009                 break;
1010         }
1011
1012         l_strncpy(hd->magic, TMAGIC, TMAGLEN);
1013         l_strncpy(hd->version, TVERSION, TVERSLEN);
1014
1015         /*
1016          * set the remaining fields. Some versions want all 16 bits of mode
1017          * we better humor them (they really do not meet spec though)....
1018          */
1019         if (ul_oct((u_long)arcn->sb.st_mode, hd->mode, sizeof(hd->mode), 3) ||
1020             ul_oct((u_long)arcn->sb.st_uid, hd->uid, sizeof(hd->uid), 3)  ||
1021             ul_oct((u_long)arcn->sb.st_gid, hd->gid, sizeof(hd->gid), 3) ||
1022             ul_oct((u_long)arcn->sb.st_mtime,hd->mtime,sizeof(hd->mtime),3))
1023                 goto out;
1024         l_strncpy(hd->uname,name_uid(arcn->sb.st_uid, 0),sizeof(hd->uname));
1025         l_strncpy(hd->gname,name_gid(arcn->sb.st_gid, 0),sizeof(hd->gname));
1026
1027         /*
1028          * calculate and store the checksum write the header to the archive
1029          * return 0 tells the caller to now write the file data, 1 says no data
1030          * needs to be written
1031          */
1032         if (ul_oct(tar_chksm(hdblk, sizeof(HD_USTAR)), hd->chksum,
1033            sizeof(hd->chksum), 3))
1034                 goto out;
1035         if (wr_rdbuf(hdblk, sizeof(HD_USTAR)) < 0)
1036                 return(-1);
1037         if (wr_skip((off_t)(BLKMULT - sizeof(HD_USTAR))) < 0)
1038                 return(-1);
1039         if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG))
1040                 return(0);
1041         return(1);
1042
1043     out:
1044         /*
1045          * header field is out of range
1046          */
1047         paxwarn(1, "Ustar header field is too small for %s", arcn->org_name);
1048         return(1);
1049 }
1050
1051 /*
1052  * name_split()
1053  *      see if the name has to be split for storage in a ustar header. We try
1054  *      to fit the entire name in the name field without splitting if we can.
1055  *      The split point is always at a /
1056  * Return
1057  *      character pointer to split point (always the / that is to be removed
1058  *      if the split is not needed, the points is set to the start of the file
1059  *      name (it would violate the spec to split there). A NULL is returned if
1060  *      the file name is too long
1061  */
1062
1063 static char *
1064 name_split(register char *name, register int len)
1065 {
1066         register char *start;
1067
1068         /*
1069          * check to see if the file name is small enough to fit in the name
1070          * field. if so just return a pointer to the name.
1071          */
1072         if (len < TNMSZ)
1073                 return(name);
1074         if (len > (TPFSZ + TNMSZ))
1075                 return(NULL);
1076
1077         /*
1078          * we start looking at the biggest sized piece that fits in the name
1079          * field. We walk forward looking for a slash to split at. The idea is
1080          * to find the biggest piece to fit in the name field (or the smallest
1081          * prefix we can find)
1082          */
1083         start = name + len - TNMSZ;
1084         while ((*start != '\0') && (*start != '/'))
1085                 ++start;
1086
1087         /*
1088          * if we hit the end of the string, this name cannot be split, so we
1089          * cannot store this file.
1090          */
1091         if (*start == '\0')
1092                 return(NULL);
1093         len = start - name;
1094
1095         /*
1096          * NOTE: /str where the length of str == TNMSZ can not be stored under
1097          * the p1003.1-1990 spec for ustar. We could force a prefix of / and
1098          * the file would then expand on extract to //str. The len == 0 below
1099          * makes this special case follow the spec to the letter.
1100          */
1101         if ((len >= TPFSZ) || (len == 0))
1102                 return(NULL);
1103
1104         /*
1105          * ok have a split point, return it to the caller
1106          */
1107         return(start);
1108 }