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