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 } 1109