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. 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 * @(#)cpio.c 8.1 (Berkeley) 5/31/93 34 * $FreeBSD: src/bin/pax/cpio.c,v 1.12.2.1 2001/08/01 05:03:11 obrien Exp $ 35 * $DragonFly: src/bin/pax/cpio.c,v 1.8 2006/09/27 21:58:08 pavalos Exp $ 36 */ 37 38 #include <sys/types.h> 39 #include <sys/time.h> 40 #include <sys/stat.h> 41 #include <string.h> 42 #include <stdio.h> 43 #include <unistd.h> 44 #include <stdlib.h> 45 #include "pax.h" 46 #include "cpio.h" 47 #include "extern.h" 48 49 static int rd_nm (ARCHD *, int); 50 static int rd_ln_nm (ARCHD *); 51 static int com_rd (ARCHD *); 52 53 /* 54 * Routines which support the different cpio versions 55 */ 56 57 static int swp_head; /* binary cpio header byte swap */ 58 59 /* 60 * Routines common to all versions of cpio 61 */ 62 63 /* 64 * cpio_strd() 65 * Fire up the hard link detection code 66 * Return: 67 * 0 if ok -1 otherwise (the return values of lnk_start()) 68 */ 69 70 int 71 cpio_strd(void) 72 { 73 return(lnk_start()); 74 } 75 76 /* 77 * cpio_trail() 78 * Called to determine if a header block is a valid trailer. We are 79 * passed the block, the in_sync flag (which tells us we are in resync 80 * mode; looking for a valid header), and cnt (which starts at zero) 81 * which is used to count the number of empty blocks we have seen so far. 82 * Return: 83 * 0 if a valid trailer, -1 if not a valid trailer, 84 */ 85 86 int 87 cpio_trail(ARCHD *arcn) 88 { 89 /* 90 * look for trailer id in file we are about to process 91 */ 92 if ((strcmp(arcn->name, TRAILER) == 0) && (arcn->sb.st_size == 0)) 93 return(0); 94 return(-1); 95 } 96 97 /* 98 * com_rd() 99 * operations common to all cpio read functions. 100 * Return: 101 * 0 102 */ 103 104 static int 105 com_rd(ARCHD *arcn) 106 { 107 arcn->skip = 0; 108 arcn->pat = NULL; 109 arcn->org_name = arcn->name; 110 switch(arcn->sb.st_mode & C_IFMT) { 111 case C_ISFIFO: 112 arcn->type = PAX_FIF; 113 break; 114 case C_ISDIR: 115 arcn->type = PAX_DIR; 116 break; 117 case C_ISBLK: 118 arcn->type = PAX_BLK; 119 break; 120 case C_ISCHR: 121 arcn->type = PAX_CHR; 122 break; 123 case C_ISLNK: 124 arcn->type = PAX_SLK; 125 break; 126 case C_ISOCK: 127 arcn->type = PAX_SCK; 128 break; 129 case C_ISCTG: 130 case C_ISREG: 131 default: 132 /* 133 * we have file data, set up skip (pad is set in the format 134 * specific sections) 135 */ 136 arcn->sb.st_mode = (arcn->sb.st_mode & 0xfff) | C_ISREG; 137 arcn->type = PAX_REG; 138 arcn->skip = arcn->sb.st_size; 139 break; 140 } 141 if (chk_lnk(arcn) < 0) 142 return(-1); 143 return(0); 144 } 145 146 /* 147 * cpio_end_wr() 148 * write the special file with the name trailer in the proper format 149 * Return: 150 * result of the write of the trailer from the cpio specific write func 151 */ 152 153 int 154 cpio_endwr(void) 155 { 156 ARCHD last; 157 158 /* 159 * create a trailer request and call the proper format write function 160 */ 161 memset(&last, 0, sizeof(last)); 162 last.nlen = sizeof(TRAILER) - 1; 163 last.type = PAX_REG; 164 last.sb.st_nlink = 1; 165 strcpy(last.name, TRAILER); 166 return((*frmt->wr)(&last)); 167 } 168 169 /* 170 * rd_nam() 171 * read in the file name which follows the cpio header 172 * Return: 173 * 0 if ok, -1 otherwise 174 */ 175 176 static int 177 rd_nm(ARCHD *arcn, int nsz) 178 { 179 /* 180 * do not even try bogus values 181 */ 182 if ((nsz == 0) || (nsz > sizeof(arcn->name))) { 183 paxwarn(1, "Cpio file name length %d is out of range", nsz); 184 return(-1); 185 } 186 187 /* 188 * read the name and make sure it is not empty and is \0 terminated 189 */ 190 if ((rd_wrbuf(arcn->name,nsz) != nsz) || (arcn->name[nsz-1] != '\0') || 191 (arcn->name[0] == '\0')) { 192 paxwarn(1, "Cpio file name in header is corrupted"); 193 return(-1); 194 } 195 return(0); 196 } 197 198 /* 199 * rd_ln_nm() 200 * read in the link name for a file with links. The link name is stored 201 * like file data (and is NOT \0 terminated!) 202 * Return: 203 * 0 if ok, -1 otherwise 204 */ 205 206 static int 207 rd_ln_nm(ARCHD *arcn) 208 { 209 /* 210 * check the length specified for bogus values 211 */ 212 if ((arcn->sb.st_size == 0) || 213 (arcn->sb.st_size >= sizeof(arcn->ln_name))) { 214 paxwarn(1, "Cpio link name length is invalid: %jd", 215 (intmax_t)arcn->sb.st_size); 216 return(-1); 217 } 218 219 /* 220 * read in the link name and \0 terminate it 221 */ 222 if (rd_wrbuf(arcn->ln_name, (int)arcn->sb.st_size) != 223 (int)arcn->sb.st_size) { 224 paxwarn(1, "Cpio link name read error"); 225 return(-1); 226 } 227 arcn->ln_nlen = arcn->sb.st_size; 228 arcn->ln_name[arcn->ln_nlen] = '\0'; 229 230 /* 231 * watch out for those empty link names 232 */ 233 if (arcn->ln_name[0] == '\0') { 234 paxwarn(1, "Cpio link name is corrupt"); 235 return(-1); 236 } 237 return(0); 238 } 239 240 /* 241 * Routines common to the extended byte oriented cpio format 242 */ 243 244 /* 245 * cpio_id() 246 * determine if a block given to us is a valid extended byte oriented 247 * cpio header 248 * Return: 249 * 0 if a valid header, -1 otherwise 250 */ 251 252 int 253 cpio_id(char *blk, int size) 254 { 255 if ((size < sizeof(HD_CPIO)) || 256 (strncmp(blk, AMAGIC, sizeof(AMAGIC) - 1) != 0)) 257 return(-1); 258 return(0); 259 } 260 261 /* 262 * cpio_rd() 263 * determine if a buffer is a byte oriented extended cpio archive entry. 264 * convert and store the values in the ARCHD parameter. 265 * Return: 266 * 0 if a valid header, -1 otherwise. 267 */ 268 269 int 270 cpio_rd(ARCHD *arcn, char *buf) 271 { 272 int nsz; 273 HD_CPIO *hd; 274 275 /* 276 * check that this is a valid header, if not return -1 277 */ 278 if (cpio_id(buf, sizeof(HD_CPIO)) < 0) 279 return(-1); 280 hd = (HD_CPIO *)buf; 281 282 /* 283 * byte oriented cpio (posix) does not have padding! extract the octal 284 * ascii fields from the header 285 */ 286 arcn->pad = 0L; 287 arcn->sb.st_dev = (dev_t)asc_ul(hd->c_dev, sizeof(hd->c_dev), OCT); 288 arcn->sb.st_ino = (ino_t)asc_ul(hd->c_ino, sizeof(hd->c_ino), OCT); 289 arcn->sb.st_mode = (mode_t)asc_ul(hd->c_mode, sizeof(hd->c_mode), OCT); 290 arcn->sb.st_uid = (uid_t)asc_ul(hd->c_uid, sizeof(hd->c_uid), OCT); 291 arcn->sb.st_gid = (gid_t)asc_ul(hd->c_gid, sizeof(hd->c_gid), OCT); 292 arcn->sb.st_nlink = (nlink_t)asc_ul(hd->c_nlink, sizeof(hd->c_nlink), 293 OCT); 294 arcn->sb.st_rdev = (dev_t)asc_ul(hd->c_rdev, sizeof(hd->c_rdev), OCT); 295 arcn->sb.st_mtime = (time_t)asc_ul(hd->c_mtime, sizeof(hd->c_mtime), 296 OCT); 297 arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime; 298 arcn->sb.st_size = (off_t)asc_uqd(hd->c_filesize,sizeof(hd->c_filesize), 299 OCT); 300 301 /* 302 * check name size and if valid, read in the name of this entry (name 303 * follows header in the archive) 304 */ 305 if ((nsz = (int)asc_ul(hd->c_namesize,sizeof(hd->c_namesize),OCT)) < 2) 306 return(-1); 307 arcn->nlen = nsz - 1; 308 if (rd_nm(arcn, nsz) < 0) 309 return(-1); 310 311 if (((arcn->sb.st_mode&C_IFMT) != C_ISLNK)||(arcn->sb.st_size == 0)) { 312 /* 313 * no link name to read for this file 314 */ 315 arcn->ln_nlen = 0; 316 arcn->ln_name[0] = '\0'; 317 return(com_rd(arcn)); 318 } 319 320 /* 321 * check link name size and read in the link name. Link names are 322 * stored like file data. 323 */ 324 if (rd_ln_nm(arcn) < 0) 325 return(-1); 326 327 /* 328 * we have a valid header (with a link) 329 */ 330 return(com_rd(arcn)); 331 } 332 333 /* 334 * cpio_endrd() 335 * no cleanup needed here, just return size of the trailer (for append) 336 * Return: 337 * size of trailer header in this format 338 */ 339 340 off_t 341 cpio_endrd(void) 342 { 343 return((off_t)(sizeof(HD_CPIO) + sizeof(TRAILER))); 344 } 345 346 /* 347 * cpio_stwr() 348 * start up the device mapping table 349 * Return: 350 * 0 if ok, -1 otherwise (what dev_start() returns) 351 */ 352 353 int 354 cpio_stwr(void) 355 { 356 return(dev_start()); 357 } 358 359 /* 360 * cpio_wr() 361 * copy the data in the ARCHD to buffer in extended byte oriented cpio 362 * format. 363 * Return 364 * 0 if file has data to be written after the header, 1 if file has NO 365 * data to write after the header, -1 if archive write failed 366 */ 367 368 int 369 cpio_wr(ARCHD *arcn) 370 { 371 HD_CPIO *hd; 372 int nsz; 373 char hdblk[sizeof(HD_CPIO)]; 374 375 /* 376 * check and repair truncated device and inode fields in the header 377 */ 378 if (map_dev(arcn, (u_long)CPIO_MASK, (u_long)CPIO_MASK) < 0) 379 return(-1); 380 381 arcn->pad = 0L; 382 nsz = arcn->nlen + 1; 383 hd = (HD_CPIO *)hdblk; 384 if ((arcn->type != PAX_BLK) && (arcn->type != PAX_CHR)) 385 arcn->sb.st_rdev = 0; 386 387 switch(arcn->type) { 388 case PAX_CTG: 389 case PAX_REG: 390 case PAX_HRG: 391 /* 392 * set data size for file data 393 */ 394 if (uqd_asc((u_quad_t)arcn->sb.st_size, hd->c_filesize, 395 sizeof(hd->c_filesize), OCT)) { 396 paxwarn(1,"File is too large for cpio format %s", 397 arcn->org_name); 398 return(1); 399 } 400 break; 401 case PAX_SLK: 402 /* 403 * set data size to hold link name 404 */ 405 if (ul_asc((u_long)arcn->ln_nlen, hd->c_filesize, 406 sizeof(hd->c_filesize), OCT)) 407 goto out; 408 break; 409 default: 410 /* 411 * all other file types have no file data 412 */ 413 if (ul_asc((u_long)0, hd->c_filesize, sizeof(hd->c_filesize), 414 OCT)) 415 goto out; 416 break; 417 } 418 419 /* 420 * copy the values to the header using octal ascii 421 */ 422 if (ul_asc((u_long)MAGIC, hd->c_magic, sizeof(hd->c_magic), OCT) || 423 ul_asc((u_long)arcn->sb.st_dev, hd->c_dev, sizeof(hd->c_dev), 424 OCT) || 425 ul_asc((u_long)arcn->sb.st_ino, hd->c_ino, sizeof(hd->c_ino), 426 OCT) || 427 ul_asc((u_long)arcn->sb.st_mode, hd->c_mode, sizeof(hd->c_mode), 428 OCT) || 429 ul_asc((u_long)arcn->sb.st_uid, hd->c_uid, sizeof(hd->c_uid), 430 OCT) || 431 ul_asc((u_long)arcn->sb.st_gid, hd->c_gid, sizeof(hd->c_gid), 432 OCT) || 433 ul_asc((u_long)arcn->sb.st_nlink, hd->c_nlink, sizeof(hd->c_nlink), 434 OCT) || 435 ul_asc((u_long)arcn->sb.st_rdev, hd->c_rdev, sizeof(hd->c_rdev), 436 OCT) || 437 ul_asc((u_long)arcn->sb.st_mtime,hd->c_mtime,sizeof(hd->c_mtime), 438 OCT) || 439 ul_asc((u_long)nsz, hd->c_namesize, sizeof(hd->c_namesize), OCT)) 440 goto out; 441 442 /* 443 * write the file name to the archive 444 */ 445 if ((wr_rdbuf(hdblk, (int)sizeof(HD_CPIO)) < 0) || 446 (wr_rdbuf(arcn->name, nsz) < 0)) { 447 paxwarn(1, "Unable to write cpio header for %s", arcn->org_name); 448 return(-1); 449 } 450 451 /* 452 * if this file has data, we are done. The caller will write the file 453 * data, if we are link tell caller we are done, go to next file 454 */ 455 if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG) || 456 (arcn->type == PAX_HRG)) 457 return(0); 458 if (arcn->type != PAX_SLK) 459 return(1); 460 461 /* 462 * write the link name to the archive, tell the caller to go to the 463 * next file as we are done. 464 */ 465 if (wr_rdbuf(arcn->ln_name, arcn->ln_nlen) < 0) { 466 paxwarn(1,"Unable to write cpio link name for %s",arcn->org_name); 467 return(-1); 468 } 469 return(1); 470 471 out: 472 /* 473 * header field is out of range 474 */ 475 paxwarn(1, "Cpio header field is too small to store file %s", 476 arcn->org_name); 477 return(1); 478 } 479 480 /* 481 * Routines common to the system VR4 version of cpio (with/without file CRC) 482 */ 483 484 /* 485 * vcpio_id() 486 * determine if a block given to us is a valid system VR4 cpio header 487 * WITHOUT crc. WATCH it the magic cookies are in OCTAL, the header 488 * uses HEX 489 * Return: 490 * 0 if a valid header, -1 otherwise 491 */ 492 493 int 494 vcpio_id(char *blk, int size) 495 { 496 if ((size < sizeof(HD_VCPIO)) || 497 (strncmp(blk, AVMAGIC, sizeof(AVMAGIC) - 1) != 0)) 498 return(-1); 499 return(0); 500 } 501 502 /* 503 * crc_id() 504 * determine if a block given to us is a valid system VR4 cpio header 505 * WITH crc. WATCH it the magic cookies are in OCTAL the header uses HEX 506 * Return: 507 * 0 if a valid header, -1 otherwise 508 */ 509 510 int 511 crc_id(char *blk, int size) 512 { 513 if ((size < sizeof(HD_VCPIO)) || 514 (strncmp(blk, AVCMAGIC, sizeof(AVCMAGIC) - 1) != 0)) 515 return(-1); 516 return(0); 517 } 518 519 /* 520 * crc_strd() 521 w set file data CRC calculations. Fire up the hard link detection code 522 * Return: 523 * 0 if ok -1 otherwise (the return values of lnk_start()) 524 */ 525 526 int 527 crc_strd(void) 528 { 529 docrc = 1; 530 return(lnk_start()); 531 } 532 533 /* 534 * vcpio_rd() 535 * determine if a buffer is a system VR4 archive entry. (with/without CRC) 536 * convert and store the values in the ARCHD parameter. 537 * Return: 538 * 0 if a valid header, -1 otherwise. 539 */ 540 541 int 542 vcpio_rd(ARCHD *arcn, char *buf) 543 { 544 HD_VCPIO *hd; 545 dev_t devminor; 546 dev_t devmajor; 547 int nsz; 548 549 /* 550 * during the id phase it was determined if we were using CRC, use the 551 * proper id routine. 552 */ 553 if (docrc) { 554 if (crc_id(buf, sizeof(HD_VCPIO)) < 0) 555 return(-1); 556 } else { 557 if (vcpio_id(buf, sizeof(HD_VCPIO)) < 0) 558 return(-1); 559 } 560 561 hd = (HD_VCPIO *)buf; 562 arcn->pad = 0L; 563 564 /* 565 * extract the hex ascii fields from the header 566 */ 567 arcn->sb.st_ino = (ino_t)asc_ul(hd->c_ino, sizeof(hd->c_ino), HEX); 568 arcn->sb.st_mode = (mode_t)asc_ul(hd->c_mode, sizeof(hd->c_mode), HEX); 569 arcn->sb.st_uid = (uid_t)asc_ul(hd->c_uid, sizeof(hd->c_uid), HEX); 570 arcn->sb.st_gid = (gid_t)asc_ul(hd->c_gid, sizeof(hd->c_gid), HEX); 571 arcn->sb.st_mtime = (time_t)asc_ul(hd->c_mtime,sizeof(hd->c_mtime),HEX); 572 arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime; 573 arcn->sb.st_size = (off_t)asc_uqd(hd->c_filesize, 574 sizeof(hd->c_filesize), HEX); 575 arcn->sb.st_nlink = (nlink_t)asc_ul(hd->c_nlink, sizeof(hd->c_nlink), 576 HEX); 577 devmajor = (dev_t)asc_ul(hd->c_maj, sizeof(hd->c_maj), HEX); 578 devminor = (dev_t)asc_ul(hd->c_min, sizeof(hd->c_min), HEX); 579 arcn->sb.st_dev = TODEV(devmajor, devminor); 580 devmajor = (dev_t)asc_ul(hd->c_rmaj, sizeof(hd->c_maj), HEX); 581 devminor = (dev_t)asc_ul(hd->c_rmin, sizeof(hd->c_min), HEX); 582 arcn->sb.st_rdev = TODEV(devmajor, devminor); 583 arcn->crc = asc_ul(hd->c_chksum, sizeof(hd->c_chksum), HEX); 584 585 /* 586 * check the length of the file name, if ok read it in, return -1 if 587 * bogus 588 */ 589 if ((nsz = (int)asc_ul(hd->c_namesize,sizeof(hd->c_namesize),HEX)) < 2) 590 return(-1); 591 arcn->nlen = nsz - 1; 592 if (rd_nm(arcn, nsz) < 0) 593 return(-1); 594 595 /* 596 * skip padding. header + filename is aligned to 4 byte boundaries 597 */ 598 if (rd_skip((off_t)(VCPIO_PAD(sizeof(HD_VCPIO) + nsz))) < 0) 599 return(-1); 600 601 /* 602 * if not a link (or a file with no data), calculate pad size (for 603 * padding which follows the file data), clear the link name and return 604 */ 605 if (((arcn->sb.st_mode&C_IFMT) != C_ISLNK)||(arcn->sb.st_size == 0)) { 606 /* 607 * we have a valid header (not a link) 608 */ 609 arcn->ln_nlen = 0; 610 arcn->ln_name[0] = '\0'; 611 arcn->pad = VCPIO_PAD(arcn->sb.st_size); 612 return(com_rd(arcn)); 613 } 614 615 /* 616 * read in the link name and skip over the padding 617 */ 618 if ((rd_ln_nm(arcn) < 0) || 619 (rd_skip((off_t)(VCPIO_PAD(arcn->sb.st_size))) < 0)) 620 return(-1); 621 622 /* 623 * we have a valid header (with a link) 624 */ 625 return(com_rd(arcn)); 626 } 627 628 /* 629 * vcpio_endrd() 630 * no cleanup needed here, just return size of the trailer (for append) 631 * Return: 632 * size of trailer header in this format 633 */ 634 635 off_t 636 vcpio_endrd(void) 637 { 638 return((off_t)(sizeof(HD_VCPIO) + sizeof(TRAILER) + 639 (VCPIO_PAD(sizeof(HD_VCPIO) + sizeof(TRAILER))))); 640 } 641 642 /* 643 * crc_stwr() 644 * start up the device mapping table, enable crc file calculation 645 * Return: 646 * 0 if ok, -1 otherwise (what dev_start() returns) 647 */ 648 649 int 650 crc_stwr(void) 651 { 652 docrc = 1; 653 return(dev_start()); 654 } 655 656 /* 657 * vcpio_wr() 658 * copy the data in the ARCHD to buffer in system VR4 cpio 659 * (with/without crc) format. 660 * Return 661 * 0 if file has data to be written after the header, 1 if file has 662 * NO data to write after the header, -1 if archive write failed 663 */ 664 665 int 666 vcpio_wr(ARCHD *arcn) 667 { 668 HD_VCPIO *hd; 669 unsigned int nsz; 670 char hdblk[sizeof(HD_VCPIO)]; 671 672 /* 673 * check and repair truncated device and inode fields in the cpio 674 * header 675 */ 676 if (map_dev(arcn, (u_long)VCPIO_MASK, (u_long)VCPIO_MASK) < 0) 677 return(-1); 678 nsz = arcn->nlen + 1; 679 hd = (HD_VCPIO *)hdblk; 680 if ((arcn->type != PAX_BLK) && (arcn->type != PAX_CHR)) 681 arcn->sb.st_rdev = 0; 682 683 /* 684 * add the proper magic value depending whether we were asked for 685 * file data crc's, and the crc if needed. 686 */ 687 if (docrc) { 688 if (ul_asc((u_long)VCMAGIC, hd->c_magic, sizeof(hd->c_magic), 689 OCT) || 690 ul_asc((u_long)arcn->crc,hd->c_chksum,sizeof(hd->c_chksum), 691 HEX)) 692 goto out; 693 } else { 694 if (ul_asc((u_long)VMAGIC, hd->c_magic, sizeof(hd->c_magic), 695 OCT) || 696 ul_asc((u_long)0L, hd->c_chksum, sizeof(hd->c_chksum),HEX)) 697 goto out; 698 } 699 700 switch(arcn->type) { 701 case PAX_CTG: 702 case PAX_REG: 703 case PAX_HRG: 704 /* 705 * caller will copy file data to the archive. tell him how 706 * much to pad. 707 */ 708 arcn->pad = VCPIO_PAD(arcn->sb.st_size); 709 if (uqd_asc((u_quad_t)arcn->sb.st_size, hd->c_filesize, 710 sizeof(hd->c_filesize), HEX)) { 711 paxwarn(1,"File is too large for sv4cpio format %s", 712 arcn->org_name); 713 return(1); 714 } 715 break; 716 case PAX_SLK: 717 /* 718 * no file data for the caller to process, the file data has 719 * the size of the link 720 */ 721 arcn->pad = 0L; 722 if (ul_asc((u_long)arcn->ln_nlen, hd->c_filesize, 723 sizeof(hd->c_filesize), HEX)) 724 goto out; 725 break; 726 default: 727 /* 728 * no file data for the caller to process 729 */ 730 arcn->pad = 0L; 731 if (ul_asc((u_long)0L, hd->c_filesize, sizeof(hd->c_filesize), 732 HEX)) 733 goto out; 734 break; 735 } 736 737 /* 738 * set the other fields in the header 739 */ 740 if (ul_asc((u_long)arcn->sb.st_ino, hd->c_ino, sizeof(hd->c_ino), 741 HEX) || 742 ul_asc((u_long)arcn->sb.st_mode, hd->c_mode, sizeof(hd->c_mode), 743 HEX) || 744 ul_asc((u_long)arcn->sb.st_uid, hd->c_uid, sizeof(hd->c_uid), 745 HEX) || 746 ul_asc((u_long)arcn->sb.st_gid, hd->c_gid, sizeof(hd->c_gid), 747 HEX) || 748 ul_asc((u_long)arcn->sb.st_mtime, hd->c_mtime, sizeof(hd->c_mtime), 749 HEX) || 750 ul_asc((u_long)arcn->sb.st_nlink, hd->c_nlink, sizeof(hd->c_nlink), 751 HEX) || 752 ul_asc((u_long)MAJOR(arcn->sb.st_dev),hd->c_maj, sizeof(hd->c_maj), 753 HEX) || 754 ul_asc((u_long)MINOR(arcn->sb.st_dev),hd->c_min, sizeof(hd->c_min), 755 HEX) || 756 ul_asc((u_long)MAJOR(arcn->sb.st_rdev),hd->c_rmaj,sizeof(hd->c_maj), 757 HEX) || 758 ul_asc((u_long)MINOR(arcn->sb.st_rdev),hd->c_rmin,sizeof(hd->c_min), 759 HEX) || 760 ul_asc((u_long)nsz, hd->c_namesize, sizeof(hd->c_namesize), HEX)) 761 goto out; 762 763 /* 764 * write the header, the file name and padding as required. 765 */ 766 if ((wr_rdbuf(hdblk, (int)sizeof(HD_VCPIO)) < 0) || 767 (wr_rdbuf(arcn->name, (int)nsz) < 0) || 768 (wr_skip((off_t)(VCPIO_PAD(sizeof(HD_VCPIO) + nsz))) < 0)) { 769 paxwarn(1,"Could not write sv4cpio header for %s",arcn->org_name); 770 return(-1); 771 } 772 773 /* 774 * if we have file data, tell the caller we are done, copy the file 775 */ 776 if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG) || 777 (arcn->type == PAX_HRG)) 778 return(0); 779 780 /* 781 * if we are not a link, tell the caller we are done, go to next file 782 */ 783 if (arcn->type != PAX_SLK) 784 return(1); 785 786 /* 787 * write the link name, tell the caller we are done. 788 */ 789 if ((wr_rdbuf(arcn->ln_name, arcn->ln_nlen) < 0) || 790 (wr_skip((off_t)(VCPIO_PAD(arcn->ln_nlen))) < 0)) { 791 paxwarn(1,"Could not write sv4cpio link name for %s", 792 arcn->org_name); 793 return(-1); 794 } 795 return(1); 796 797 out: 798 /* 799 * header field is out of range 800 */ 801 paxwarn(1,"Sv4cpio header field is too small for file %s",arcn->org_name); 802 return(1); 803 } 804 805 /* 806 * Routines common to the old binary header cpio 807 */ 808 809 /* 810 * bcpio_id() 811 * determine if a block given to us is a old binary cpio header 812 * (with/without header byte swapping) 813 * Return: 814 * 0 if a valid header, -1 otherwise 815 */ 816 817 int 818 bcpio_id(char *blk, int size) 819 { 820 if (size < sizeof(HD_BCPIO)) 821 return(-1); 822 823 /* 824 * check both normal and byte swapped magic cookies 825 */ 826 if (((u_short)SHRT_EXT(blk)) == MAGIC) 827 return(0); 828 if (((u_short)RSHRT_EXT(blk)) == MAGIC) { 829 if (!swp_head) 830 ++swp_head; 831 return(0); 832 } 833 return(-1); 834 } 835 836 /* 837 * bcpio_rd() 838 * determine if a buffer is a old binary archive entry. (it may have byte 839 * swapped header) convert and store the values in the ARCHD parameter. 840 * This is a very old header format and should not really be used. 841 * Return: 842 * 0 if a valid header, -1 otherwise. 843 */ 844 845 int 846 bcpio_rd(ARCHD *arcn, char *buf) 847 { 848 HD_BCPIO *hd; 849 int nsz; 850 851 /* 852 * check the header 853 */ 854 if (bcpio_id(buf, sizeof(HD_BCPIO)) < 0) 855 return(-1); 856 857 arcn->pad = 0L; 858 hd = (HD_BCPIO *)buf; 859 if (swp_head) { 860 /* 861 * header has swapped bytes on 16 bit boundaries 862 */ 863 arcn->sb.st_dev = (dev_t)(RSHRT_EXT(hd->h_dev)); 864 arcn->sb.st_ino = (ino_t)(RSHRT_EXT(hd->h_ino)); 865 arcn->sb.st_mode = (mode_t)(RSHRT_EXT(hd->h_mode)); 866 arcn->sb.st_uid = (uid_t)(RSHRT_EXT(hd->h_uid)); 867 arcn->sb.st_gid = (gid_t)(RSHRT_EXT(hd->h_gid)); 868 arcn->sb.st_nlink = (nlink_t)(RSHRT_EXT(hd->h_nlink)); 869 arcn->sb.st_rdev = (dev_t)(RSHRT_EXT(hd->h_rdev)); 870 arcn->sb.st_mtime = (time_t)(RSHRT_EXT(hd->h_mtime_1)); 871 arcn->sb.st_mtime = (arcn->sb.st_mtime << 16) | 872 ((time_t)(RSHRT_EXT(hd->h_mtime_2))); 873 arcn->sb.st_size = (off_t)(RSHRT_EXT(hd->h_filesize_1)); 874 arcn->sb.st_size = (arcn->sb.st_size << 16) | 875 ((off_t)(RSHRT_EXT(hd->h_filesize_2))); 876 nsz = (int)(RSHRT_EXT(hd->h_namesize)); 877 } else { 878 arcn->sb.st_dev = (dev_t)(SHRT_EXT(hd->h_dev)); 879 arcn->sb.st_ino = (ino_t)(SHRT_EXT(hd->h_ino)); 880 arcn->sb.st_mode = (mode_t)(SHRT_EXT(hd->h_mode)); 881 arcn->sb.st_uid = (uid_t)(SHRT_EXT(hd->h_uid)); 882 arcn->sb.st_gid = (gid_t)(SHRT_EXT(hd->h_gid)); 883 arcn->sb.st_nlink = (nlink_t)(SHRT_EXT(hd->h_nlink)); 884 arcn->sb.st_rdev = (dev_t)(SHRT_EXT(hd->h_rdev)); 885 arcn->sb.st_mtime = (time_t)(SHRT_EXT(hd->h_mtime_1)); 886 arcn->sb.st_mtime = (arcn->sb.st_mtime << 16) | 887 ((time_t)(SHRT_EXT(hd->h_mtime_2))); 888 arcn->sb.st_size = (off_t)(SHRT_EXT(hd->h_filesize_1)); 889 arcn->sb.st_size = (arcn->sb.st_size << 16) | 890 ((off_t)(SHRT_EXT(hd->h_filesize_2))); 891 nsz = (int)(SHRT_EXT(hd->h_namesize)); 892 } 893 arcn->sb.st_ctime = arcn->sb.st_atime = arcn->sb.st_mtime; 894 895 /* 896 * check the file name size, if bogus give up. otherwise read the file 897 * name 898 */ 899 if (nsz < 2) 900 return(-1); 901 arcn->nlen = nsz - 1; 902 if (rd_nm(arcn, nsz) < 0) 903 return(-1); 904 905 /* 906 * header + file name are aligned to 2 byte boundaries, skip if needed 907 */ 908 if (rd_skip((off_t)(BCPIO_PAD(sizeof(HD_BCPIO) + nsz))) < 0) 909 return(-1); 910 911 /* 912 * if not a link (or a file with no data), calculate pad size (for 913 * padding which follows the file data), clear the link name and return 914 */ 915 if (((arcn->sb.st_mode & C_IFMT) != C_ISLNK)||(arcn->sb.st_size == 0)){ 916 /* 917 * we have a valid header (not a link) 918 */ 919 arcn->ln_nlen = 0; 920 arcn->ln_name[0] = '\0'; 921 arcn->pad = BCPIO_PAD(arcn->sb.st_size); 922 return(com_rd(arcn)); 923 } 924 925 if ((rd_ln_nm(arcn) < 0) || 926 (rd_skip((off_t)(BCPIO_PAD(arcn->sb.st_size))) < 0)) 927 return(-1); 928 929 /* 930 * we have a valid header (with a link) 931 */ 932 return(com_rd(arcn)); 933 } 934 935 /* 936 * bcpio_endrd() 937 * no cleanup needed here, just return size of the trailer (for append) 938 * Return: 939 * size of trailer header in this format 940 */ 941 942 off_t 943 bcpio_endrd(void) 944 { 945 return((off_t)(sizeof(HD_BCPIO) + sizeof(TRAILER) + 946 (BCPIO_PAD(sizeof(HD_BCPIO) + sizeof(TRAILER))))); 947 } 948 949 /* 950 * bcpio_wr() 951 * copy the data in the ARCHD to buffer in old binary cpio format 952 * There is a real chance of field overflow with this critter. So we 953 * always check the conversion is ok. nobody in their right mind 954 * should write an archive in this format... 955 * Return 956 * 0 if file has data to be written after the header, 1 if file has NO 957 * data to write after the header, -1 if archive write failed 958 */ 959 960 int 961 bcpio_wr(ARCHD *arcn) 962 { 963 HD_BCPIO *hd; 964 int nsz; 965 char hdblk[sizeof(HD_BCPIO)]; 966 off_t t_offt; 967 int t_int; 968 time_t t_timet; 969 970 /* 971 * check and repair truncated device and inode fields in the cpio 972 * header 973 */ 974 if (map_dev(arcn, (u_long)BCPIO_MASK, (u_long)BCPIO_MASK) < 0) 975 return(-1); 976 977 if ((arcn->type != PAX_BLK) && (arcn->type != PAX_CHR)) 978 arcn->sb.st_rdev = 0; 979 hd = (HD_BCPIO *)hdblk; 980 981 switch(arcn->type) { 982 case PAX_CTG: 983 case PAX_REG: 984 case PAX_HRG: 985 /* 986 * caller will copy file data to the archive. tell him how 987 * much to pad. 988 */ 989 arcn->pad = BCPIO_PAD(arcn->sb.st_size); 990 hd->h_filesize_1[0] = CHR_WR_0(arcn->sb.st_size); 991 hd->h_filesize_1[1] = CHR_WR_1(arcn->sb.st_size); 992 hd->h_filesize_2[0] = CHR_WR_2(arcn->sb.st_size); 993 hd->h_filesize_2[1] = CHR_WR_3(arcn->sb.st_size); 994 t_offt = (off_t)(SHRT_EXT(hd->h_filesize_1)); 995 t_offt = (t_offt<<16) | ((off_t)(SHRT_EXT(hd->h_filesize_2))); 996 if (arcn->sb.st_size != t_offt) { 997 paxwarn(1,"File is too large for bcpio format %s", 998 arcn->org_name); 999 return(1); 1000 } 1001 break; 1002 case PAX_SLK: 1003 /* 1004 * no file data for the caller to process, the file data has 1005 * the size of the link 1006 */ 1007 arcn->pad = 0L; 1008 hd->h_filesize_1[0] = CHR_WR_0(arcn->ln_nlen); 1009 hd->h_filesize_1[1] = CHR_WR_1(arcn->ln_nlen); 1010 hd->h_filesize_2[0] = CHR_WR_2(arcn->ln_nlen); 1011 hd->h_filesize_2[1] = CHR_WR_3(arcn->ln_nlen); 1012 t_int = (int)(SHRT_EXT(hd->h_filesize_1)); 1013 t_int = (t_int << 16) | ((int)(SHRT_EXT(hd->h_filesize_2))); 1014 if (arcn->ln_nlen != t_int) 1015 goto out; 1016 break; 1017 default: 1018 /* 1019 * no file data for the caller to process 1020 */ 1021 arcn->pad = 0L; 1022 hd->h_filesize_1[0] = (char)0; 1023 hd->h_filesize_1[1] = (char)0; 1024 hd->h_filesize_2[0] = (char)0; 1025 hd->h_filesize_2[1] = (char)0; 1026 break; 1027 } 1028 1029 /* 1030 * build up the rest of the fields 1031 */ 1032 hd->h_magic[0] = CHR_WR_2(MAGIC); 1033 hd->h_magic[1] = CHR_WR_3(MAGIC); 1034 hd->h_dev[0] = CHR_WR_2(arcn->sb.st_dev); 1035 hd->h_dev[1] = CHR_WR_3(arcn->sb.st_dev); 1036 if (arcn->sb.st_dev != (dev_t)(SHRT_EXT(hd->h_dev))) 1037 goto out; 1038 hd->h_ino[0] = CHR_WR_2(arcn->sb.st_ino); 1039 hd->h_ino[1] = CHR_WR_3(arcn->sb.st_ino); 1040 if (arcn->sb.st_ino != (ino_t)(SHRT_EXT(hd->h_ino))) 1041 goto out; 1042 hd->h_mode[0] = CHR_WR_2(arcn->sb.st_mode); 1043 hd->h_mode[1] = CHR_WR_3(arcn->sb.st_mode); 1044 if (arcn->sb.st_mode != (mode_t)(SHRT_EXT(hd->h_mode))) 1045 goto out; 1046 hd->h_uid[0] = CHR_WR_2(arcn->sb.st_uid); 1047 hd->h_uid[1] = CHR_WR_3(arcn->sb.st_uid); 1048 if (arcn->sb.st_uid != (uid_t)(SHRT_EXT(hd->h_uid))) 1049 goto out; 1050 hd->h_gid[0] = CHR_WR_2(arcn->sb.st_gid); 1051 hd->h_gid[1] = CHR_WR_3(arcn->sb.st_gid); 1052 if (arcn->sb.st_gid != (gid_t)(SHRT_EXT(hd->h_gid))) 1053 goto out; 1054 hd->h_nlink[0] = CHR_WR_2(arcn->sb.st_nlink); 1055 hd->h_nlink[1] = CHR_WR_3(arcn->sb.st_nlink); 1056 if (arcn->sb.st_nlink != (nlink_t)(SHRT_EXT(hd->h_nlink))) 1057 goto out; 1058 hd->h_rdev[0] = CHR_WR_2(arcn->sb.st_rdev); 1059 hd->h_rdev[1] = CHR_WR_3(arcn->sb.st_rdev); 1060 if (arcn->sb.st_rdev != (dev_t)(SHRT_EXT(hd->h_rdev))) 1061 goto out; 1062 hd->h_mtime_1[0] = CHR_WR_0(arcn->sb.st_mtime); 1063 hd->h_mtime_1[1] = CHR_WR_1(arcn->sb.st_mtime); 1064 hd->h_mtime_2[0] = CHR_WR_2(arcn->sb.st_mtime); 1065 hd->h_mtime_2[1] = CHR_WR_3(arcn->sb.st_mtime); 1066 t_timet = (time_t)(SHRT_EXT(hd->h_mtime_1)); 1067 t_timet = (t_timet << 16) | ((time_t)(SHRT_EXT(hd->h_mtime_2))); 1068 if (arcn->sb.st_mtime != t_timet) 1069 goto out; 1070 nsz = arcn->nlen + 1; 1071 hd->h_namesize[0] = CHR_WR_2(nsz); 1072 hd->h_namesize[1] = CHR_WR_3(nsz); 1073 if (nsz != (int)(SHRT_EXT(hd->h_namesize))) 1074 goto out; 1075 1076 /* 1077 * write the header, the file name and padding as required. 1078 */ 1079 if ((wr_rdbuf(hdblk, (int)sizeof(HD_BCPIO)) < 0) || 1080 (wr_rdbuf(arcn->name, nsz) < 0) || 1081 (wr_skip((off_t)(BCPIO_PAD(sizeof(HD_BCPIO) + nsz))) < 0)) { 1082 paxwarn(1, "Could not write bcpio header for %s", arcn->org_name); 1083 return(-1); 1084 } 1085 1086 /* 1087 * if we have file data, tell the caller we are done 1088 */ 1089 if ((arcn->type == PAX_CTG) || (arcn->type == PAX_REG) || 1090 (arcn->type == PAX_HRG)) 1091 return(0); 1092 1093 /* 1094 * if we are not a link, tell the caller we are done, go to next file 1095 */ 1096 if (arcn->type != PAX_SLK) 1097 return(1); 1098 1099 /* 1100 * write the link name, tell the caller we are done. 1101 */ 1102 if ((wr_rdbuf(arcn->ln_name, arcn->ln_nlen) < 0) || 1103 (wr_skip((off_t)(BCPIO_PAD(arcn->ln_nlen))) < 0)) { 1104 paxwarn(1,"Could not write bcpio link name for %s",arcn->org_name); 1105 return(-1); 1106 } 1107 return(1); 1108 1109 out: 1110 /* 1111 * header field is out of range 1112 */ 1113 paxwarn(1,"Bcpio header field is too small for file %s", arcn->org_name); 1114 return(1); 1115 } 1116