1 /* $NetBSD: tar.c,v 1.67 2009/02/14 08:10:06 lukem Exp $ */ 2 3 /*- 4 * Copyright (c) 1992 Keith Muller. 5 * Copyright (c) 1992, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * This code is derived from software contributed to Berkeley by 9 * Keith Muller of the University of California, San Diego. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #if HAVE_NBTOOL_CONFIG_H 37 #include "nbtool_config.h" 38 #endif 39 40 #include <sys/cdefs.h> 41 #if !defined(lint) 42 #if 0 43 static char sccsid[] = "@(#)tar.c 8.2 (Berkeley) 4/18/94"; 44 #else 45 __RCSID("$NetBSD: tar.c,v 1.67 2009/02/14 08:10:06 lukem Exp $"); 46 #endif 47 #endif /* not lint */ 48 49 #include <sys/types.h> 50 #include <sys/time.h> 51 #include <sys/stat.h> 52 #include <sys/param.h> 53 54 #include <ctype.h> 55 #include <errno.h> 56 #include <grp.h> 57 #include <pwd.h> 58 #include <stdio.h> 59 #include <stdlib.h> 60 #include <string.h> 61 #include <unistd.h> 62 63 #include "pax.h" 64 #include "extern.h" 65 #include "tar.h" 66 67 /* 68 * Routines for reading, writing and header identify of various versions of tar 69 */ 70 71 static int expandname(char *, size_t, char **, size_t *, const char *, size_t); 72 static void longlink(ARCHD *, int); 73 static u_long tar_chksm(char *, int); 74 static char *name_split(char *, int); 75 static int ul_oct(u_long, char *, int, int); 76 #if !defined(_LP64) 77 static int ull_oct(unsigned long long, char *, int, int); 78 #endif 79 static int tar_gnutar_exclude_one(const char *, size_t); 80 static int check_sum(char *, size_t, char *, size_t, int); 81 82 /* 83 * Routines common to all versions of tar 84 */ 85 86 static int tar_nodir; /* do not write dirs under old tar */ 87 int is_gnutar; /* behave like gnu tar; enable gnu 88 * extensions and skip end-of-volume 89 * checks 90 */ 91 static int seen_gnu_warning; /* Have we warned yet? */ 92 static char *gnu_hack_string; /* ././@LongLink hackery */ 93 static int gnu_hack_len; /* len of gnu_hack_string */ 94 char *gnu_name_string; /* ././@LongLink hackery name */ 95 char *gnu_link_string; /* ././@LongLink hackery link */ 96 size_t gnu_name_length; /* ././@LongLink hackery name */ 97 size_t gnu_link_length; /* ././@LongLink hackery link */ 98 static int gnu_short_trailer; /* gnu short trailer */ 99 100 static const char LONG_LINK[] = "././@LongLink"; 101 102 #ifdef _PAX_ 103 char DEV_0[] = "/dev/rst0"; 104 char DEV_1[] = "/dev/rst1"; 105 char DEV_4[] = "/dev/rst4"; 106 char DEV_5[] = "/dev/rst5"; 107 char DEV_7[] = "/dev/rst7"; 108 char DEV_8[] = "/dev/rst8"; 109 #endif 110 111 static int 112 check_sum(char *hd, size_t hdlen, char *bl, size_t bllen, int quiet) 113 { 114 u_long hdck, blck; 115 116 hdck = asc_ul(hd, hdlen, OCT); 117 blck = tar_chksm(bl, bllen); 118 119 if (hdck != blck) { 120 if (!quiet) 121 tty_warn(0, "Header checksum %lo does not match %lo", 122 hdck, blck); 123 return -1; 124 } 125 return 0; 126 } 127 128 129 /* 130 * tar_endwr() 131 * add the tar trailer of two null blocks 132 * Return: 133 * 0 if ok, -1 otherwise (what wr_skip returns) 134 */ 135 136 int 137 tar_endwr(void) 138 { 139 return wr_skip((off_t)(NULLCNT * BLKMULT)); 140 } 141 142 /* 143 * tar_endrd() 144 * no cleanup needed here, just return size of trailer (for append) 145 * Return: 146 * size of trailer BLKMULT 147 */ 148 149 off_t 150 tar_endrd(void) 151 { 152 return (off_t)((gnu_short_trailer ? 1 : NULLCNT) * BLKMULT); 153 } 154 155 /* 156 * tar_trail() 157 * Called to determine if a header block is a valid trailer. We are passed 158 * the block, the in_sync flag (which tells us we are in resync mode; 159 * looking for a valid header), and cnt (which starts at zero) which is 160 * used to count the number of empty blocks we have seen so far. 161 * Return: 162 * 0 if a valid trailer, -1 if not a valid trailer, or 1 if the block 163 * could never contain a header. 164 */ 165 166 int 167 tar_trail(char *buf, int in_resync, int *cnt) 168 { 169 int i; 170 171 gnu_short_trailer = 0; 172 /* 173 * look for all zero, trailer is two consecutive blocks of zero 174 */ 175 for (i = 0; i < BLKMULT; ++i) { 176 if (buf[i] != '\0') 177 break; 178 } 179 180 /* 181 * if not all zero it is not a trailer, but MIGHT be a header. 182 */ 183 if (i != BLKMULT) 184 return -1; 185 186 /* 187 * When given a zero block, we must be careful! 188 * If we are not in resync mode, check for the trailer. Have to watch 189 * out that we do not mis-identify file data as the trailer, so we do 190 * NOT try to id a trailer during resync mode. During resync mode we 191 * might as well throw this block out since a valid header can NEVER be 192 * a block of all 0 (we must have a valid file name). 193 */ 194 if (!in_resync) { 195 ++*cnt; 196 /* 197 * old GNU tar (up through 1.13) only writes one block of 198 * trailers, so we pretend we got another 199 */ 200 if (is_gnutar) { 201 gnu_short_trailer = 1; 202 ++*cnt; 203 } 204 if (*cnt >= NULLCNT) 205 return 0; 206 } 207 return 1; 208 } 209 210 /* 211 * ul_oct() 212 * convert an unsigned long to an octal string. many oddball field 213 * termination characters are used by the various versions of tar in the 214 * different fields. term selects which kind to use. str is '0' padded 215 * at the front to len. we are unable to use only one format as many old 216 * tar readers are very cranky about this. 217 * Return: 218 * 0 if the number fit into the string, -1 otherwise 219 */ 220 221 static int 222 ul_oct(u_long val, char *str, int len, int term) 223 { 224 char *pt; 225 226 /* 227 * term selects the appropriate character(s) for the end of the string 228 */ 229 pt = str + len - 1; 230 switch(term) { 231 case 3: 232 *pt-- = '\0'; 233 break; 234 case 2: 235 *pt-- = ' '; 236 *pt-- = '\0'; 237 break; 238 case 1: 239 *pt-- = ' '; 240 break; 241 case 0: 242 default: 243 *pt-- = '\0'; 244 *pt-- = ' '; 245 break; 246 } 247 248 /* 249 * convert and blank pad if there is space 250 */ 251 while (pt >= str) { 252 *pt-- = '0' + (char)(val & 0x7); 253 if ((val = val >> 3) == (u_long)0) 254 break; 255 } 256 257 while (pt >= str) 258 *pt-- = '0'; 259 if (val != (u_long)0) 260 return -1; 261 return 0; 262 } 263 264 #if !defined(_LP64) 265 /* 266 * ull_oct() 267 * convert an unsigned long long to an octal string. one of many oddball 268 * field termination characters are used by the various versions of tar 269 * in the different fields. term selects which kind to use. str is '0' 270 * padded at the front to len. we are unable to use only one format as 271 * many old tar readers are very cranky about this. 272 * Return: 273 * 0 if the number fit into the string, -1 otherwise 274 */ 275 276 static int 277 ull_oct(unsigned long long val, char *str, int len, int term) 278 { 279 char *pt; 280 281 /* 282 * term selects the appropriate character(s) for the end of the string 283 */ 284 pt = str + len - 1; 285 switch(term) { 286 case 3: 287 *pt-- = '\0'; 288 break; 289 case 2: 290 *pt-- = ' '; 291 *pt-- = '\0'; 292 break; 293 case 1: 294 *pt-- = ' '; 295 break; 296 case 0: 297 default: 298 *pt-- = '\0'; 299 *pt-- = ' '; 300 break; 301 } 302 303 /* 304 * convert and blank pad if there is space 305 */ 306 while (pt >= str) { 307 *pt-- = '0' + (char)(val & 0x7); 308 if ((val = val >> 3) == 0) 309 break; 310 } 311 312 while (pt >= str) 313 *pt-- = '0'; 314 if (val != (unsigned long long)0) 315 return -1; 316 return 0; 317 } 318 #endif 319 320 /* 321 * tar_chksm() 322 * calculate the checksum for a tar block counting the checksum field as 323 * all blanks (BLNKSUM is that value pre-calculated, the sum of 8 blanks). 324 * NOTE: we use len to short circuit summing 0's on write since we ALWAYS 325 * pad headers with 0. 326 * Return: 327 * unsigned long checksum 328 */ 329 330 static u_long 331 tar_chksm(char *blk, int len) 332 { 333 char *stop; 334 char *pt; 335 u_long chksm = BLNKSUM; /* initial value is checksum field sum */ 336 337 /* 338 * add the part of the block before the checksum field 339 */ 340 pt = blk; 341 stop = blk + CHK_OFFSET; 342 while (pt < stop) 343 chksm += (u_long)(*pt++ & 0xff); 344 /* 345 * move past the checksum field and keep going, spec counts the 346 * checksum field as the sum of 8 blanks (which is pre-computed as 347 * BLNKSUM). 348 * ASSUMED: len is greater than CHK_OFFSET. (len is where our 0 padding 349 * starts, no point in summing zero's) 350 */ 351 pt += CHK_LEN; 352 stop = blk + len; 353 while (pt < stop) 354 chksm += (u_long)(*pt++ & 0xff); 355 return chksm; 356 } 357 358 /* 359 * Routines for old BSD style tar (also made portable to sysV tar) 360 */ 361 362 /* 363 * tar_id() 364 * determine if a block given to us is a valid tar header (and not a USTAR 365 * header). We have to be on the lookout for those pesky blocks of all 366 * zero's. 367 * Return: 368 * 0 if a tar header, -1 otherwise 369 */ 370 371 int 372 tar_id(char *blk, int size) 373 { 374 HD_TAR *hd; 375 HD_USTAR *uhd; 376 static int is_ustar = -1; 377 378 if (size < BLKMULT) 379 return -1; 380 hd = (HD_TAR *)blk; 381 uhd = (HD_USTAR *)blk; 382 383 /* 384 * check for block of zero's first, a simple and fast test, then make 385 * sure this is not a ustar header by looking for the ustar magic 386 * cookie. We should use TMAGLEN, but some USTAR archive programs are 387 * wrong and create archives missing the \0. Last we check the 388 * checksum. If this is ok we have to assume it is a valid header. 389 */ 390 if (hd->name[0] == '\0') 391 return -1; 392 if (strncmp(uhd->magic, TMAGIC, TMAGLEN - 1) == 0) { 393 if (is_ustar == -1) { 394 is_ustar = 1; 395 return -1; 396 } else 397 tty_warn(0, 398 "Busted tar archive: has both ustar and old tar " 399 "records"); 400 } else 401 is_ustar = 0; 402 return check_sum(hd->chksum, sizeof(hd->chksum), blk, BLKMULT, 1); 403 } 404 405 /* 406 * tar_opt() 407 * handle tar format specific -o options 408 * Return: 409 * 0 if ok -1 otherwise 410 */ 411 412 int 413 tar_opt(void) 414 { 415 OPLIST *opt; 416 417 while ((opt = opt_next()) != NULL) { 418 if (strcmp(opt->name, TAR_OPTION) || 419 strcmp(opt->value, TAR_NODIR)) { 420 tty_warn(1, 421 "Unknown tar format -o option/value pair %s=%s", 422 opt->name, opt->value); 423 tty_warn(1, 424 "%s=%s is the only supported tar format option", 425 TAR_OPTION, TAR_NODIR); 426 return -1; 427 } 428 429 /* 430 * we only support one option, and only when writing 431 */ 432 if ((act != APPND) && (act != ARCHIVE)) { 433 tty_warn(1, "%s=%s is only supported when writing.", 434 opt->name, opt->value); 435 return -1; 436 } 437 tar_nodir = 1; 438 } 439 return 0; 440 } 441 442 443 /* 444 * tar_rd() 445 * extract the values out of block already determined to be a tar header. 446 * store the values in the ARCHD parameter. 447 * Return: 448 * 0 449 */ 450 451 int 452 tar_rd(ARCHD *arcn, char *buf) 453 { 454 HD_TAR *hd; 455 char *pt; 456 457 /* 458 * we only get proper sized buffers passed to us 459 */ 460 if (tar_id(buf, BLKMULT) < 0) 461 return -1; 462 memset(arcn, 0, sizeof(*arcn)); 463 arcn->org_name = arcn->name; 464 arcn->pat = NULL; 465 arcn->sb.st_nlink = 1; 466 467 /* 468 * copy out the name and values in the stat buffer 469 */ 470 hd = (HD_TAR *)buf; 471 if (hd->linkflag != LONGLINKTYPE && hd->linkflag != LONGNAMETYPE) { 472 arcn->nlen = expandname(arcn->name, sizeof(arcn->name), 473 &gnu_name_string, &gnu_name_length, hd->name, 474 sizeof(hd->name)); 475 arcn->ln_nlen = expandname(arcn->ln_name, sizeof(arcn->ln_name), 476 &gnu_link_string, &gnu_link_length, hd->linkname, 477 sizeof(hd->linkname)); 478 } 479 arcn->sb.st_mode = (mode_t)(asc_ul(hd->mode,sizeof(hd->mode),OCT) & 480 0xfff); 481 arcn->sb.st_uid = (uid_t)asc_ul(hd->uid, sizeof(hd->uid), OCT); 482 arcn->sb.st_gid = (gid_t)asc_ul(hd->gid, sizeof(hd->gid), OCT); 483 arcn->sb.st_size = (off_t)ASC_OFFT(hd->size, sizeof(hd->size), OCT); 484 arcn->sb.st_mtime = (time_t)asc_ul(hd->mtime, sizeof(hd->mtime), OCT); 485 arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime; 486 487 /* 488 * have to look at the last character, it may be a '/' and that is used 489 * to encode this as a directory 490 */ 491 pt = &(arcn->name[arcn->nlen - 1]); 492 arcn->pad = 0; 493 arcn->skip = 0; 494 switch(hd->linkflag) { 495 case SYMTYPE: 496 /* 497 * symbolic link, need to get the link name and set the type in 498 * the st_mode so -v printing will look correct. 499 */ 500 arcn->type = PAX_SLK; 501 arcn->sb.st_mode |= S_IFLNK; 502 break; 503 case LNKTYPE: 504 /* 505 * hard link, need to get the link name, set the type in the 506 * st_mode and st_nlink so -v printing will look better. 507 */ 508 arcn->type = PAX_HLK; 509 arcn->sb.st_nlink = 2; 510 511 /* 512 * no idea of what type this thing really points at, but 513 * we set something for printing only. 514 */ 515 arcn->sb.st_mode |= S_IFREG; 516 break; 517 case LONGLINKTYPE: 518 case LONGNAMETYPE: 519 /* 520 * GNU long link/file; we tag these here and let the 521 * pax internals deal with it -- too ugly otherwise. 522 */ 523 if (hd->linkflag != LONGLINKTYPE) 524 arcn->type = PAX_GLF; 525 else 526 arcn->type = PAX_GLL; 527 arcn->pad = TAR_PAD(arcn->sb.st_size); 528 arcn->skip = arcn->sb.st_size; 529 break; 530 case AREGTYPE: 531 case REGTYPE: 532 case DIRTYPE: /* see below */ 533 default: 534 /* 535 * If we have a trailing / this is a directory and NOT a file. 536 * Note: V7 tar doesn't actually have DIRTYPE, but it was 537 * reported that V7 archives using USTAR directories do exist. 538 */ 539 if (*pt == '/' || hd->linkflag == DIRTYPE) { 540 /* 541 * it is a directory, set the mode for -v printing 542 */ 543 arcn->type = PAX_DIR; 544 arcn->sb.st_mode |= S_IFDIR; 545 arcn->sb.st_nlink = 2; 546 } else { 547 /* 548 * have a file that will be followed by data. Set the 549 * skip value to the size field and calculate the size 550 * of the padding. 551 */ 552 arcn->type = PAX_REG; 553 arcn->sb.st_mode |= S_IFREG; 554 arcn->pad = TAR_PAD(arcn->sb.st_size); 555 arcn->skip = arcn->sb.st_size; 556 } 557 break; 558 } 559 560 /* 561 * strip off any trailing slash. 562 */ 563 if (*pt == '/') { 564 *pt = '\0'; 565 --arcn->nlen; 566 } 567 return 0; 568 } 569 570 /* 571 * tar_wr() 572 * write a tar header for the file specified in the ARCHD to the archive. 573 * Have to check for file types that cannot be stored and file names that 574 * are too long. Be careful of the term (last arg) to ul_oct, each field 575 * of tar has it own spec for the termination character(s). 576 * ASSUMED: space after header in header block is zero filled 577 * Return: 578 * 0 if file has data to be written after the header, 1 if file has NO 579 * data to write after the header, -1 if archive write failed 580 */ 581 582 int 583 tar_wr(ARCHD *arcn) 584 { 585 HD_TAR *hd; 586 int len; 587 char hdblk[sizeof(HD_TAR)]; 588 589 /* 590 * check for those file system types which tar cannot store 591 */ 592 switch(arcn->type) { 593 case PAX_DIR: 594 /* 595 * user asked that dirs not be written to the archive 596 */ 597 if (tar_nodir) 598 return 1; 599 break; 600 case PAX_CHR: 601 tty_warn(1, "Tar cannot archive a character device %s", 602 arcn->org_name); 603 return 1; 604 case PAX_BLK: 605 tty_warn(1, 606 "Tar cannot archive a block device %s", arcn->org_name); 607 return 1; 608 case PAX_SCK: 609 tty_warn(1, "Tar cannot archive a socket %s", arcn->org_name); 610 return 1; 611 case PAX_FIF: 612 tty_warn(1, "Tar cannot archive a fifo %s", arcn->org_name); 613 return 1; 614 case PAX_SLK: 615 case PAX_HLK: 616 case PAX_HRG: 617 if (arcn->ln_nlen > (int)sizeof(hd->linkname)) { 618 tty_warn(1,"Link name too long for tar %s", 619 arcn->ln_name); 620 return 1; 621 } 622 break; 623 case PAX_REG: 624 case PAX_CTG: 625 default: 626 break; 627 } 628 629 /* 630 * check file name len, remember extra char for dirs (the / at the end) 631 */ 632 len = arcn->nlen; 633 if (arcn->type == PAX_DIR) 634 ++len; 635 if (len >= (int)sizeof(hd->name)) { 636 tty_warn(1, "File name too long for tar %s", arcn->name); 637 return 1; 638 } 639 640 /* 641 * copy the data out of the ARCHD into the tar header based on the type 642 * of the file. Remember many tar readers want the unused fields to be 643 * padded with zero. We set the linkflag field (type), the linkname 644 * (or zero if not used),the size, and set the padding (if any) to be 645 * added after the file data (0 for all other types, as they only have 646 * a header) 647 */ 648 memset(hdblk, 0, sizeof(hdblk)); 649 hd = (HD_TAR *)hdblk; 650 strlcpy(hd->name, arcn->name, sizeof(hd->name)); 651 arcn->pad = 0; 652 653 if (arcn->type == PAX_DIR) { 654 /* 655 * directories are the same as files, except have a filename 656 * that ends with a /, we add the slash here. No data follows, 657 * dirs, so no pad. 658 */ 659 hd->linkflag = AREGTYPE; 660 hd->name[len-1] = '/'; 661 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 1)) 662 goto out; 663 } else if (arcn->type == PAX_SLK) { 664 /* 665 * no data follows this file, so no pad 666 */ 667 hd->linkflag = SYMTYPE; 668 strlcpy(hd->linkname, arcn->ln_name, sizeof(hd->linkname)); 669 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 1)) 670 goto out; 671 } else if ((arcn->type == PAX_HLK) || (arcn->type == PAX_HRG)) { 672 /* 673 * no data follows this file, so no pad 674 */ 675 hd->linkflag = LNKTYPE; 676 strlcpy(hd->linkname, arcn->ln_name, sizeof(hd->linkname)); 677 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 1)) 678 goto out; 679 } else { 680 /* 681 * data follows this file, so set the pad 682 */ 683 hd->linkflag = AREGTYPE; 684 if (OFFT_OCT(arcn->sb.st_size, hd->size, sizeof(hd->size), 1)) { 685 tty_warn(1,"File is too large for tar %s", 686 arcn->org_name); 687 return 1; 688 } 689 arcn->pad = TAR_PAD(arcn->sb.st_size); 690 } 691 692 /* 693 * copy those fields that are independent of the type 694 */ 695 if (ul_oct((u_long)arcn->sb.st_mode, hd->mode, sizeof(hd->mode), 0) || 696 ul_oct((u_long)arcn->sb.st_uid, hd->uid, sizeof(hd->uid), 0) || 697 ul_oct((u_long)arcn->sb.st_gid, hd->gid, sizeof(hd->gid), 0) || 698 ul_oct((u_long)arcn->sb.st_mtime, hd->mtime, sizeof(hd->mtime), 1)) 699 goto out; 700 701 /* 702 * calculate and add the checksum, then write the header. A return of 703 * 0 tells the caller to now write the file data, 1 says no data needs 704 * to be written 705 */ 706 if (ul_oct(tar_chksm(hdblk, sizeof(HD_TAR)), hd->chksum, 707 sizeof(hd->chksum), 3)) 708 goto out; /* XXX Something's wrong here 709 * because a zero-byte file can 710 * cause this to be done and 711 * yet the resulting warning 712 * seems incorrect */ 713 714 if (wr_rdbuf(hdblk, sizeof(HD_TAR)) < 0) 715 return -1; 716 if (wr_skip((off_t)(BLKMULT - sizeof(HD_TAR))) < 0) 717 return -1; 718 if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG)) 719 return 0; 720 return 1; 721 722 out: 723 /* 724 * header field is out of range 725 */ 726 tty_warn(1, "Tar header field is too small for %s", arcn->org_name); 727 return 1; 728 } 729 730 /* 731 * Routines for POSIX ustar 732 */ 733 734 /* 735 * ustar_strd() 736 * initialization for ustar read 737 * Return: 738 * 0 if ok, -1 otherwise 739 */ 740 741 int 742 ustar_strd(void) 743 { 744 return 0; 745 } 746 747 /* 748 * ustar_stwr() 749 * initialization for ustar write 750 * Return: 751 * 0 if ok, -1 otherwise 752 */ 753 754 int 755 ustar_stwr(void) 756 { 757 return 0; 758 } 759 760 /* 761 * ustar_id() 762 * determine if a block given to us is a valid ustar header. We have to 763 * be on the lookout for those pesky blocks of all zero's 764 * Return: 765 * 0 if a ustar header, -1 otherwise 766 */ 767 768 int 769 ustar_id(char *blk, int size) 770 { 771 HD_USTAR *hd; 772 773 if (size < BLKMULT) 774 return -1; 775 hd = (HD_USTAR *)blk; 776 777 /* 778 * check for block of zero's first, a simple and fast test then check 779 * ustar magic cookie. We should use TMAGLEN, but some USTAR archive 780 * programs are fouled up and create archives missing the \0. Last we 781 * check the checksum. If ok we have to assume it is a valid header. 782 */ 783 if (hd->name[0] == '\0') 784 return -1; 785 if (strncmp(hd->magic, TMAGIC, TMAGLEN - 1) != 0) 786 return -1; 787 /* This is GNU tar */ 788 if (strncmp(hd->magic, "ustar ", 8) == 0 && !is_gnutar && 789 !seen_gnu_warning) { 790 seen_gnu_warning = 1; 791 tty_warn(0, 792 "Trying to read GNU tar archive with GNU extensions and end-of-volume checks off"); 793 } 794 return check_sum(hd->chksum, sizeof(hd->chksum), blk, BLKMULT, 0); 795 } 796 797 /* 798 * ustar_rd() 799 * extract the values out of block already determined to be a ustar header. 800 * store the values in the ARCHD parameter. 801 * Return: 802 * 0 803 */ 804 805 int 806 ustar_rd(ARCHD *arcn, char *buf) 807 { 808 HD_USTAR *hd; 809 char *dest; 810 int cnt; 811 dev_t devmajor; 812 dev_t devminor; 813 814 /* 815 * we only get proper sized buffers 816 */ 817 if (ustar_id(buf, BLKMULT) < 0) 818 return -1; 819 820 memset(arcn, 0, sizeof(*arcn)); 821 arcn->org_name = arcn->name; 822 arcn->pat = NULL; 823 arcn->sb.st_nlink = 1; 824 hd = (HD_USTAR *)buf; 825 826 /* 827 * see if the filename is split into two parts. if, so joint the parts. 828 * we copy the prefix first and add a / between the prefix and name. 829 */ 830 dest = arcn->name; 831 if (*(hd->prefix) != '\0') { 832 cnt = strlcpy(arcn->name, hd->prefix, sizeof(arcn->name)); 833 dest += cnt; 834 *dest++ = '/'; 835 cnt++; 836 } else { 837 cnt = 0; 838 } 839 840 if (hd->typeflag != LONGLINKTYPE && hd->typeflag != LONGNAMETYPE) { 841 arcn->nlen = expandname(dest, sizeof(arcn->name) - cnt, 842 &gnu_name_string, &gnu_name_length, hd->name, 843 sizeof(hd->name)) + cnt; 844 arcn->ln_nlen = expandname(arcn->ln_name, 845 sizeof(arcn->ln_name), &gnu_link_string, &gnu_link_length, 846 hd->linkname, sizeof(hd->linkname)); 847 } 848 849 /* 850 * follow the spec to the letter. we should only have mode bits, strip 851 * off all other crud we may be passed. 852 */ 853 arcn->sb.st_mode = (mode_t)(asc_ul(hd->mode, sizeof(hd->mode), OCT) & 854 0xfff); 855 arcn->sb.st_size = (off_t)ASC_OFFT(hd->size, sizeof(hd->size), OCT); 856 arcn->sb.st_mtime = (time_t)asc_ul(hd->mtime, sizeof(hd->mtime), OCT); 857 arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime; 858 859 /* 860 * If we can find the ascii names for gname and uname in the password 861 * and group files we will use the uid's and gid they bind. Otherwise 862 * we use the uid and gid values stored in the header. (This is what 863 * the posix spec wants). 864 */ 865 hd->gname[sizeof(hd->gname) - 1] = '\0'; 866 if (gid_from_group(hd->gname, &(arcn->sb.st_gid)) < 0) 867 arcn->sb.st_gid = (gid_t)asc_ul(hd->gid, sizeof(hd->gid), OCT); 868 hd->uname[sizeof(hd->uname) - 1] = '\0'; 869 if (uid_from_user(hd->uname, &(arcn->sb.st_uid)) < 0) 870 arcn->sb.st_uid = (uid_t)asc_ul(hd->uid, sizeof(hd->uid), OCT); 871 872 /* 873 * set the defaults, these may be changed depending on the file type 874 */ 875 arcn->pad = 0; 876 arcn->skip = 0; 877 arcn->sb.st_rdev = (dev_t)0; 878 879 /* 880 * set the mode and PAX type according to the typeflag in the header 881 */ 882 switch(hd->typeflag) { 883 case FIFOTYPE: 884 arcn->type = PAX_FIF; 885 arcn->sb.st_mode |= S_IFIFO; 886 break; 887 case DIRTYPE: 888 arcn->type = PAX_DIR; 889 arcn->sb.st_mode |= S_IFDIR; 890 arcn->sb.st_nlink = 2; 891 892 /* 893 * Some programs that create ustar archives append a '/' 894 * to the pathname for directories. This clearly violates 895 * ustar specs, but we will silently strip it off anyway. 896 */ 897 if (arcn->name[arcn->nlen - 1] == '/') 898 arcn->name[--arcn->nlen] = '\0'; 899 break; 900 case BLKTYPE: 901 case CHRTYPE: 902 /* 903 * this type requires the rdev field to be set. 904 */ 905 if (hd->typeflag == BLKTYPE) { 906 arcn->type = PAX_BLK; 907 arcn->sb.st_mode |= S_IFBLK; 908 } else { 909 arcn->type = PAX_CHR; 910 arcn->sb.st_mode |= S_IFCHR; 911 } 912 devmajor = (dev_t)asc_ul(hd->devmajor,sizeof(hd->devmajor),OCT); 913 devminor = (dev_t)asc_ul(hd->devminor,sizeof(hd->devminor),OCT); 914 arcn->sb.st_rdev = TODEV(devmajor, devminor); 915 break; 916 case SYMTYPE: 917 case LNKTYPE: 918 if (hd->typeflag == SYMTYPE) { 919 arcn->type = PAX_SLK; 920 arcn->sb.st_mode |= S_IFLNK; 921 } else { 922 arcn->type = PAX_HLK; 923 /* 924 * so printing looks better 925 */ 926 arcn->sb.st_mode |= S_IFREG; 927 arcn->sb.st_nlink = 2; 928 } 929 break; 930 case LONGLINKTYPE: 931 case LONGNAMETYPE: 932 if (is_gnutar) { 933 /* 934 * GNU long link/file; we tag these here and let the 935 * pax internals deal with it -- too ugly otherwise. 936 */ 937 if (hd->typeflag != LONGLINKTYPE) 938 arcn->type = PAX_GLF; 939 else 940 arcn->type = PAX_GLL; 941 arcn->pad = TAR_PAD(arcn->sb.st_size); 942 arcn->skip = arcn->sb.st_size; 943 } else { 944 tty_warn(1, "GNU Long %s found in posix ustar archive.", 945 hd->typeflag == LONGLINKTYPE ? "Link" : "File"); 946 } 947 break; 948 case CONTTYPE: 949 case AREGTYPE: 950 case REGTYPE: 951 default: 952 /* 953 * these types have file data that follows. Set the skip and 954 * pad fields. 955 */ 956 arcn->type = PAX_REG; 957 arcn->pad = TAR_PAD(arcn->sb.st_size); 958 arcn->skip = arcn->sb.st_size; 959 arcn->sb.st_mode |= S_IFREG; 960 break; 961 } 962 return 0; 963 } 964 965 static int 966 expandname(char *buf, size_t len, char **gnu_name, size_t *gnu_length, 967 const char *name, size_t nlen) 968 { 969 if (*gnu_name) { 970 len = strlcpy(buf, *gnu_name, len); 971 free(*gnu_name); 972 *gnu_name = NULL; 973 *gnu_length = 0; 974 } else { 975 if (len > ++nlen) 976 len = nlen; 977 len = strlcpy(buf, name, len); 978 } 979 return len; 980 } 981 982 static void 983 longlink(ARCHD *arcn, int type) 984 { 985 ARCHD larc; 986 987 (void)memset(&larc, 0, sizeof(larc)); 988 989 larc.type = type; 990 larc.nlen = strlcpy(larc.name, LONG_LINK, sizeof(larc.name)); 991 992 switch (type) { 993 case PAX_GLL: 994 gnu_hack_string = arcn->ln_name; 995 gnu_hack_len = arcn->ln_nlen + 1; 996 break; 997 case PAX_GLF: 998 gnu_hack_string = arcn->name; 999 gnu_hack_len = arcn->nlen + 1; 1000 break; 1001 default: 1002 errx(1, "Invalid type in GNU longlink %d\n", type); 1003 } 1004 1005 /* 1006 * We need a longlink now. 1007 */ 1008 ustar_wr(&larc); 1009 } 1010 1011 /* 1012 * ustar_wr() 1013 * write a ustar header for the file specified in the ARCHD to the archive 1014 * Have to check for file types that cannot be stored and file names that 1015 * are too long. Be careful of the term (last arg) to ul_oct, we only use 1016 * '\0' for the termination character (this is different than picky tar) 1017 * ASSUMED: space after header in header block is zero filled 1018 * Return: 1019 * 0 if file has data to be written after the header, 1 if file has NO 1020 * data to write after the header, -1 if archive write failed 1021 */ 1022 1023 static int 1024 size_err(const char *what, ARCHD *arcn) 1025 { 1026 /* 1027 * header field is out of range 1028 */ 1029 tty_warn(1, "Ustar %s header field is too small for %s", 1030 what, arcn->org_name); 1031 return 1; 1032 } 1033 1034 int 1035 ustar_wr(ARCHD *arcn) 1036 { 1037 HD_USTAR *hd; 1038 char *pt; 1039 char hdblk[sizeof(HD_USTAR)]; 1040 const char *user, *group; 1041 1042 switch (arcn->type) { 1043 case PAX_SCK: 1044 /* 1045 * check for those file system types ustar cannot store 1046 */ 1047 if (!is_gnutar) 1048 tty_warn(1, "Ustar cannot archive a socket %s", 1049 arcn->org_name); 1050 return 1; 1051 1052 case PAX_SLK: 1053 case PAX_HLK: 1054 case PAX_HRG: 1055 /* 1056 * check the length of the linkname 1057 */ 1058 if (arcn->ln_nlen >= (int)sizeof(hd->linkname)) { 1059 if (is_gnutar) { 1060 longlink(arcn, PAX_GLL); 1061 } else { 1062 tty_warn(1, "Link name too long for ustar %s", 1063 arcn->ln_name); 1064 return 1; 1065 } 1066 } 1067 break; 1068 default: 1069 break; 1070 } 1071 1072 /* 1073 * split the path name into prefix and name fields (if needed). if 1074 * pt != arcn->name, the name has to be split 1075 */ 1076 if ((pt = name_split(arcn->name, arcn->nlen)) == NULL) { 1077 if (is_gnutar) { 1078 longlink(arcn, PAX_GLF); 1079 pt = arcn->name; 1080 } else { 1081 tty_warn(1, "File name too long for ustar %s", 1082 arcn->name); 1083 return 1; 1084 } 1085 } 1086 1087 /* 1088 * zero out the header so we don't have to worry about zero fill below 1089 */ 1090 memset(hdblk, 0, sizeof(hdblk)); 1091 hd = (HD_USTAR *)hdblk; 1092 arcn->pad = 0L; 1093 1094 /* 1095 * split the name, or zero out the prefix 1096 */ 1097 if (pt != arcn->name) { 1098 /* 1099 * name was split, pt points at the / where the split is to 1100 * occur, we remove the / and copy the first part to the prefix 1101 */ 1102 *pt = '\0'; 1103 strlcpy(hd->prefix, arcn->name, sizeof(hd->prefix)); 1104 *pt++ = '/'; 1105 } 1106 1107 /* 1108 * copy the name part. this may be the whole path or the part after 1109 * the prefix 1110 */ 1111 strlcpy(hd->name, pt, sizeof(hd->name)); 1112 1113 /* 1114 * set the fields in the header that are type dependent 1115 */ 1116 switch(arcn->type) { 1117 case PAX_DIR: 1118 hd->typeflag = DIRTYPE; 1119 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3)) 1120 return size_err("DIRTYPE", arcn); 1121 break; 1122 case PAX_CHR: 1123 case PAX_BLK: 1124 if (arcn->type == PAX_CHR) 1125 hd->typeflag = CHRTYPE; 1126 else 1127 hd->typeflag = BLKTYPE; 1128 if (ul_oct((u_long)MAJOR(arcn->sb.st_rdev), hd->devmajor, 1129 sizeof(hd->devmajor), 3) || 1130 ul_oct((u_long)MINOR(arcn->sb.st_rdev), hd->devminor, 1131 sizeof(hd->devminor), 3) || 1132 ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3)) 1133 return size_err("DEVTYPE", arcn); 1134 break; 1135 case PAX_FIF: 1136 hd->typeflag = FIFOTYPE; 1137 if (ul_oct((u_long)0L, hd->size, sizeof(hd->size), 3)) 1138 return size_err("FIFOTYPE", arcn); 1139 break; 1140 case PAX_GLL: 1141 case PAX_SLK: 1142 case PAX_HLK: 1143 case PAX_HRG: 1144 if (arcn->type == PAX_SLK) 1145 hd->typeflag = SYMTYPE; 1146 else if (arcn->type == PAX_GLL) 1147 hd->typeflag = LONGLINKTYPE; 1148 else 1149 hd->typeflag = LNKTYPE; 1150 strlcpy(hd->linkname, arcn->ln_name, sizeof(hd->linkname)); 1151 if (ul_oct((u_long)gnu_hack_len, hd->size, 1152 sizeof(hd->size), 3)) 1153 return size_err("LINKTYPE", arcn); 1154 break; 1155 case PAX_GLF: 1156 case PAX_REG: 1157 case PAX_CTG: 1158 default: 1159 /* 1160 * file data with this type, set the padding 1161 */ 1162 if (arcn->type == PAX_GLF) { 1163 hd->typeflag = LONGNAMETYPE; 1164 arcn->pad = TAR_PAD(gnu_hack_len); 1165 if (OFFT_OCT((u_long)gnu_hack_len, hd->size, 1166 sizeof(hd->size), 3)) { 1167 tty_warn(1,"File is too long for ustar %s", 1168 arcn->org_name); 1169 return 1; 1170 } 1171 } else { 1172 if (arcn->type == PAX_CTG) 1173 hd->typeflag = CONTTYPE; 1174 else 1175 hd->typeflag = REGTYPE; 1176 arcn->pad = TAR_PAD(arcn->sb.st_size); 1177 if (OFFT_OCT(arcn->sb.st_size, hd->size, 1178 sizeof(hd->size), 3)) { 1179 tty_warn(1,"File is too long for ustar %s", 1180 arcn->org_name); 1181 return 1; 1182 } 1183 } 1184 break; 1185 } 1186 1187 strncpy(hd->magic, TMAGIC, TMAGLEN); 1188 if (is_gnutar) 1189 hd->magic[TMAGLEN - 1] = hd->version[0] = ' '; 1190 else 1191 strncpy(hd->version, TVERSION, TVERSLEN); 1192 1193 /* 1194 * set the remaining fields. Some versions want all 16 bits of mode 1195 * we better humor them (they really do not meet spec though).... 1196 */ 1197 if (ul_oct((u_long)arcn->sb.st_mode, hd->mode, sizeof(hd->mode), 3)) 1198 return size_err("MODE", arcn); 1199 if (ul_oct((u_long)arcn->sb.st_uid, hd->uid, sizeof(hd->uid), 3)) 1200 return size_err("UID", arcn); 1201 if (ul_oct((u_long)arcn->sb.st_gid, hd->gid, sizeof(hd->gid), 3)) 1202 return size_err("GID", arcn); 1203 if (ul_oct((u_long)arcn->sb.st_mtime,hd->mtime,sizeof(hd->mtime),3)) 1204 return size_err("MTIME", arcn); 1205 user = user_from_uid(arcn->sb.st_uid, 1); 1206 group = group_from_gid(arcn->sb.st_gid, 1); 1207 strncpy(hd->uname, user ? user : "", sizeof(hd->uname)); 1208 strncpy(hd->gname, group ? group : "", sizeof(hd->gname)); 1209 1210 /* 1211 * calculate and store the checksum write the header to the archive 1212 * return 0 tells the caller to now write the file data, 1 says no data 1213 * needs to be written 1214 */ 1215 if (ul_oct(tar_chksm(hdblk, sizeof(HD_USTAR)), hd->chksum, 1216 sizeof(hd->chksum), 3)) 1217 return size_err("CHKSUM", arcn); 1218 if (wr_rdbuf(hdblk, sizeof(HD_USTAR)) < 0) 1219 return -1; 1220 if (wr_skip((off_t)(BLKMULT - sizeof(HD_USTAR))) < 0) 1221 return -1; 1222 if (gnu_hack_string) { 1223 int res = wr_rdbuf(gnu_hack_string, gnu_hack_len); 1224 int pad = gnu_hack_len; 1225 gnu_hack_string = NULL; 1226 gnu_hack_len = 0; 1227 if (res < 0) 1228 return -1; 1229 if (wr_skip((off_t)(BLKMULT - (pad % BLKMULT))) < 0) 1230 return -1; 1231 } 1232 if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG)) 1233 return 0; 1234 return 1; 1235 } 1236 1237 /* 1238 * name_split() 1239 * see if the name has to be split for storage in a ustar header. We try 1240 * to fit the entire name in the name field without splitting if we can. 1241 * The split point is always at a / 1242 * Return 1243 * character pointer to split point (always the / that is to be removed 1244 * if the split is not needed, the points is set to the start of the file 1245 * name (it would violate the spec to split there). A NULL is returned if 1246 * the file name is too long 1247 */ 1248 1249 static char * 1250 name_split(char *name, int len) 1251 { 1252 char *start; 1253 1254 /* 1255 * check to see if the file name is small enough to fit in the name 1256 * field. if so just return a pointer to the name. 1257 */ 1258 if (len < TNMSZ) 1259 return name; 1260 /* 1261 * GNU tar does not honor the prefix+name mode if the magic 1262 * is not "ustar\0". So in GNU tar compatibility mode, we don't 1263 * split the filename into prefix+name because we are setting 1264 * the magic to "ustar " as GNU tar does. This of course will 1265 * end up creating a LongLink record in cases where it does not 1266 * really need do, but we are behaving like GNU tar after all. 1267 */ 1268 if (is_gnutar || len > (TPFSZ + TNMSZ)) 1269 return NULL; 1270 1271 /* 1272 * we start looking at the biggest sized piece that fits in the name 1273 * field. We walk forward looking for a slash to split at. The idea is 1274 * to find the biggest piece to fit in the name field (or the smallest 1275 * prefix we can find) (the -1 is correct the biggest piece would 1276 * include the slash between the two parts that gets thrown away) 1277 */ 1278 start = name + len - TNMSZ; 1279 while ((*start != '\0') && (*start != '/')) 1280 ++start; 1281 1282 /* 1283 * if we hit the end of the string, this name cannot be split, so we 1284 * cannot store this file. 1285 */ 1286 if (*start == '\0') 1287 return NULL; 1288 len = start - name; 1289 1290 /* 1291 * NOTE: /str where the length of str == TNMSZ cannot be stored under 1292 * the p1003.1-1990 spec for ustar. We could force a prefix of / and 1293 * the file would then expand on extract to //str. The len == 0 below 1294 * makes this special case follow the spec to the letter. 1295 */ 1296 if ((len >= TPFSZ) || (len == 0)) 1297 return NULL; 1298 1299 /* 1300 * ok have a split point, return it to the caller 1301 */ 1302 return start; 1303 } 1304 1305 /* 1306 * convert a glob into a RE, and add it to the list. we convert to 1307 * four different RE's (because we're using BRE's and can't use | 1308 * alternation :-() with this padding: 1309 * .*\/ and $ 1310 * .*\/ and \/.* 1311 * ^ and $ 1312 * ^ and \/.* 1313 */ 1314 static int 1315 tar_gnutar_exclude_one(const char *line, size_t len) 1316 { 1317 /* 2 * buffer len + nul */ 1318 char sbuf[MAXPATHLEN * 2 + 1]; 1319 /* + / + // + .*""/\/ + \/.* */ 1320 char rabuf[MAXPATHLEN * 2 + 1 + 1 + 2 + 4 + 4]; 1321 size_t i; 1322 int j = 0; 1323 1324 if (line[len - 1] == '\n') 1325 len--; 1326 for (i = 0; i < len; i++) { 1327 /* 1328 * convert glob to regexp, escaping everything 1329 */ 1330 if (line[i] == '*') 1331 sbuf[j++] = '.'; 1332 else if (line[i] == '?') { 1333 sbuf[j++] = '.'; 1334 continue; 1335 } else if (!isalnum((unsigned char)line[i]) && 1336 !isblank((unsigned char)line[i])) 1337 sbuf[j++] = '\\'; 1338 sbuf[j++] = line[i]; 1339 } 1340 sbuf[j] = '\0'; 1341 /* don't need the .*\/ ones if we start with /, i guess */ 1342 if (line[0] != '/') { 1343 (void)snprintf(rabuf, sizeof rabuf, "/.*\\/%s$//", sbuf); 1344 if (rep_add(rabuf) < 0) 1345 return (-1); 1346 (void)snprintf(rabuf, sizeof rabuf, "/.*\\/%s\\/.*//", sbuf); 1347 if (rep_add(rabuf) < 0) 1348 return (-1); 1349 } 1350 1351 (void)snprintf(rabuf, sizeof rabuf, "/^%s$//", sbuf); 1352 if (rep_add(rabuf) < 0) 1353 return (-1); 1354 (void)snprintf(rabuf, sizeof rabuf, "/^%s\\/.*//", sbuf); 1355 if (rep_add(rabuf) < 0) 1356 return (-1); 1357 1358 return (0); 1359 } 1360 1361 /* 1362 * deal with GNU tar -X/--exclude-from & --exclude switchs. basically, 1363 * we go through each line of the file, building a string from the "glob" 1364 * lines in the file into RE lines, of the form `/^RE$//', which we pass 1365 * to rep_add(), which will add a empty replacement (exclusion), for the 1366 * named files. 1367 */ 1368 int 1369 tar_gnutar_minus_minus_exclude(path) 1370 const char *path; 1371 { 1372 size_t len = strlen(path); 1373 1374 if (len > MAXPATHLEN) 1375 tty_warn(0, "pathname too long: %s", path); 1376 1377 return (tar_gnutar_exclude_one(path, len)); 1378 } 1379 1380 int 1381 tar_gnutar_X_compat(path) 1382 const char *path; 1383 { 1384 char *line; 1385 FILE *fp; 1386 int lineno = 0; 1387 size_t len; 1388 1389 fp = fopen(path, "r"); 1390 if (fp == NULL) { 1391 tty_warn(1, "cannot open %s: %s", path, 1392 strerror(errno)); 1393 return -1; 1394 } 1395 1396 while ((line = fgetln(fp, &len))) { 1397 lineno++; 1398 if (len > MAXPATHLEN) { 1399 tty_warn(0, "pathname too long, line %d of %s", 1400 lineno, path); 1401 } 1402 if (tar_gnutar_exclude_one(line, len)) 1403 return (-1); 1404 } 1405 return (0); 1406 } 1407