bin/pax/options.c

   1 /*
   2  * Copyright (c) 1992 Keith Muller.
   3  * Copyright (c) 1992, 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * Keith Muller of the University of California, San Diego.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. 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  * @(#)options.c        8.2 (Berkeley) 4/18/94
  34  * $FreeBSD: src/bin/pax/options.c,v 1.13.2.3 2001/08/01 05:03:11 obrien Exp $
  35  * $DragonFly: src/bin/pax/options.c,v 1.9 2008/06/05 18:06:30 swildner Exp $
  36  */
  37
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40 #include <sys/mtio.h>
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <errno.h>
  44 #include <unistd.h>
  45 #include <stdlib.h>
  46 #include <limits.h>
  47 #include <paths.h>
  48 #include "pax.h"
  49 #include "options.h"
  50 #include "cpio.h"
  51 #include "tar.h"
  52 #include "extern.h"
  53
  54 /*
  55  * Routines which handle command line options
  56  */
  57
  58 static char flgch[] = FLGCH;    /* list of all possible flags */
  59 static OPLIST *ophead = NULL;   /* head for format specific options -x */
  60 static OPLIST *optail = NULL;   /* option tail */
  61
  62 static int no_op (void);
  63 static void printflg (unsigned int);
  64 static int c_frmt (const void *, const void *);
  65 static off_t str_offt (char *);
  66 static char *getline (FILE *);
  67 static void pax_options (int, char **);
  68 static void pax_usage (void);
  69 static void tar_options (int, char **);
  70 static void tar_usage (void);
  71 static void cpio_options (int, char **);
  72 static void cpio_usage (void);
  73 static int mkpath(char *);
  74
  75 /* errors from getline */
  76 #define GETLINE_FILE_CORRUPT 1
  77 #define GETLINE_OUT_OF_MEM 2
  78 static int getline_error;
  79
  80
  81 #define GZIP_CMD        "gzip"          /* command to run as gzip */
  82 #define COMPRESS_CMD    "compress"      /* command to run as compress */
  83 #define BZIP2_CMD       "bzip2"         /* command to run as gzip */
  84
  85 /*
  86  *      Format specific routine table - MUST BE IN SORTED ORDER BY NAME
  87  *      (see pax.h for description of each function)
  88  *
  89  *      name, blksz, hdsz, udev, hlk, blkagn, inhead, id, st_read,
  90  *      read, end_read, st_write, write, end_write, trail,
  91  *      rd_data, wr_data, options
  92  */
  93
  94 FSUB fsub[] = {
  95 /* 0: OLD BINARY CPIO */
  96         {"bcpio", 5120, sizeof(HD_BCPIO), 1, 0, 0, 1, bcpio_id, cpio_strd,
  97         bcpio_rd, bcpio_endrd, cpio_stwr, bcpio_wr, cpio_endwr, cpio_trail,
  98         rd_wrfile, wr_rdfile, bad_opt},
  99
 100 /* 1: OLD OCTAL CHARACTER CPIO */
 101         {"cpio", 5120, sizeof(HD_CPIO), 1, 0, 0, 1, cpio_id, cpio_strd,
 102         cpio_rd, cpio_endrd, cpio_stwr, cpio_wr, cpio_endwr, cpio_trail,
 103         rd_wrfile, wr_rdfile, bad_opt},
 104
 105 /* 2: SVR4 HEX CPIO */
 106         {"sv4cpio", 5120, sizeof(HD_VCPIO), 1, 0, 0, 1, vcpio_id, cpio_strd,
 107         vcpio_rd, vcpio_endrd, cpio_stwr, vcpio_wr, cpio_endwr, cpio_trail,
 108         rd_wrfile, wr_rdfile, bad_opt},
 109
 110 /* 3: SVR4 HEX CPIO WITH CRC */
 111         {"sv4crc", 5120, sizeof(HD_VCPIO), 1, 0, 0, 1, crc_id, crc_strd,
 112         vcpio_rd, vcpio_endrd, crc_stwr, vcpio_wr, cpio_endwr, cpio_trail,
 113         rd_wrfile, wr_rdfile, bad_opt},
 114
 115 /* 4: OLD TAR */
 116         {"tar", 10240, BLKMULT, 0, 1, BLKMULT, 0, tar_id, no_op,
 117         tar_rd, tar_endrd, no_op, tar_wr, tar_endwr, tar_trail,
 118         rd_wrfile, wr_rdfile, tar_opt},
 119
 120 /* 5: POSIX USTAR */
 121         {"ustar", 10240, BLKMULT, 0, 1, BLKMULT, 0, ustar_id, ustar_strd,
 122         ustar_rd, tar_endrd, ustar_stwr, ustar_wr, tar_endwr, tar_trail,
 123         rd_wrfile, wr_rdfile, bad_opt},
 124 };
 125 #define F_OCPIO 0       /* format when called as cpio -6 */
 126 #define F_ACPIO 1       /* format when called as cpio -c */
 127 #define F_CPIO  3       /* format when called as cpio */
 128 #define F_OTAR  4       /* format when called as tar -o */
 129 #define F_TAR   5       /* format when called as tar */
 130 #define DEFLT   5       /* default write format from list above */
 131
 132 /*
 133  * ford is the archive search order used by get_arc() to determine what kind
 134  * of archive we are dealing with. This helps to properly id  archive formats
 135  * some formats may be subsets of others....
 136  */
 137 int ford[] = {5, 4, 3, 2, 1, 0, -1 };
 138
 139 /*
 140  * options()
 141  *      figure out if we are pax, tar or cpio. Call the appropriate options
 142  *      parser
 143  */
 144
 145 void
 146 options(int argc, char **argv)
 147 {
 148
 149         /*
 150          * Are we acting like pax, tar or cpio (based on argv[0])
 151          */
 152         if ((argv0 = strrchr(argv[0], '/')) != NULL)
 153                 argv0++;
 154         else
 155                 argv0 = argv[0];
 156
 157         if (strcmp(NM_TAR, argv0) == 0)
 158                 return(tar_options(argc, argv));
 159         else if (strcmp(NM_CPIO, argv0) == 0)
 160                 return(cpio_options(argc, argv));
 161         /*
 162          * assume pax as the default
 163          */
 164         argv0 = NM_PAX;
 165         return(pax_options(argc, argv));
 166 }
 167
 168 /*
 169  * pax_options()
 170  *      look at the user specified flags. set globals as required and check if
 171  *      the user specified a legal set of flags. If not, complain and exit
 172  */
 173
 174 static void
 175 pax_options(int argc, char **argv)
 176 {
 177         int c;
 178         int i;
 179         unsigned int flg = 0;
 180         unsigned int bflg = 0;
 181         char *pt;
 182         FSUB tmp;
 183
 184         /*
 185          * process option flags
 186          */
 187         while ((c=getopt(argc,argv,"ab:cdf:iklno:p:rs:tuvwx:zB:DE:G:HLOPT:U:XYZ"))
 188             != -1) {
 189                 switch (c) {
 190                 case 'a':
 191                         /*
 192                          * append
 193                          */
 194                         flg |= AF;
 195                         break;
 196                 case 'b':
 197                         /*
 198                          * specify blocksize
 199                          */
 200                         flg |= BF;
 201                         if ((wrblksz = (int)str_offt(optarg)) <= 0) {
 202                                 paxwarn(1, "Invalid block size %s", optarg);
 203                                 pax_usage();
 204                         }
 205                         break;
 206                 case 'c':
 207                         /*
 208                          * inverse match on patterns
 209                          */
 210                         cflag = 1;
 211                         flg |= CF;
 212                         break;
 213                 case 'd':
 214                         /*
 215                          * match only dir on extract, not the subtree at dir
 216                          */
 217                         dflag = 1;
 218                         flg |= DF;
 219                         break;
 220                 case 'f':
 221                         /*
 222                          * filename where the archive is stored
 223                          */
 224                         arcname = optarg;
 225                         flg |= FF;
 226                         break;
 227                 case 'i':
 228                         /*
 229                          * interactive file rename
 230                          */
 231                         iflag = 1;
 232                         flg |= IF;
 233                         break;
 234                 case 'k':
 235                         /*
 236                          * do not clobber files that exist
 237                          */
 238                         kflag = 1;
 239                         flg |= KF;
 240                         break;
 241                 case 'l':
 242                         /*
 243                          * try to link src to dest with copy (-rw)
 244                          */
 245                         lflag = 1;
 246                         flg |= LF;
 247                         break;
 248                 case 'n':
 249                         /*
 250                          * select first match for a pattern only
 251                          */
 252                         nflag = 1;
 253                         flg |= NF;
 254                         break;
 255                 case 'o':
 256                         /*
 257                          * pass format specific options
 258                          */
 259                         flg |= OF;
 260                         if (opt_add(optarg) < 0)
 261                                 pax_usage();
 262                         break;
 263                 case 'p':
 264                         /*
 265                          * specify file characteristic options
 266                          */
 267                         for (pt = optarg; *pt != '\0'; ++pt) {
 268                                 switch(*pt) {
 269                                 case 'a':
 270                                         /*
 271                                          * do not preserve access time
 272                                          */
 273                                         patime = 0;
 274                                         break;
 275                                 case 'e':
 276                                         /*
 277                                          * preserve user id, group id, file
 278                                          * mode, access/modification times
 279                                          */
 280                                         pids = 1;
 281                                         pmode = 1;
 282                                         patime = 1;
 283                                         pmtime = 1;
 284                                         break;
 285                                 case 'm':
 286                                         /*
 287                                          * do not preserve modification time
 288                                          */
 289                                         pmtime = 0;
 290                                         break;
 291                                 case 'o':
 292                                         /*
 293                                          * preserve uid/gid
 294                                          */
 295                                         pids = 1;
 296                                         break;
 297                                 case 'p':
 298                                         /*
 299                                          * preserve file mode bits
 300                                          */
 301                                         pmode = 1;
 302                                         break;
 303                                 default:
 304                                         paxwarn(1, "Invalid -p string: %c", *pt);
 305                                         pax_usage();
 306                                         break;
 307                                 }
 308                         }
 309                         flg |= PF;
 310                         break;
 311                 case 'r':
 312                         /*
 313                          * read the archive
 314                          */
 315                         flg |= RF;
 316                         break;
 317                 case 's':
 318                         /*
 319                          * file name substitution name pattern
 320                          */
 321                         if (rep_add(optarg) < 0) {
 322                                 pax_usage();
 323                                 break;
 324                         }
 325                         flg |= SF;
 326                         break;
 327                 case 't':
 328                         /*
 329                          * preserve access time on filesystem nodes we read
 330                          */
 331                         tflag = 1;
 332                         flg |= TF;
 333                         break;
 334                 case 'u':
 335                         /*
 336                          * ignore those older files
 337                          */
 338                         uflag = 1;
 339                         flg |= UF;
 340                         break;
 341                 case 'v':
 342                         /*
 343                          * verbose operation mode
 344                          */
 345                         vflag = 1;
 346                         flg |= VF;
 347                         break;
 348                 case 'w':
 349                         /*
 350                          * write an archive
 351                          */
 352                         flg |= WF;
 353                         break;
 354                 case 'x':
 355                         /*
 356                          * specify an archive format on write
 357                          */
 358                         tmp.name = optarg;
 359                         if ((frmt = (FSUB *)bsearch((void *)&tmp, (void *)fsub,
 360                             sizeof(fsub)/sizeof(FSUB), sizeof(FSUB), c_frmt)) != NULL) {
 361                                 flg |= XF;
 362                                 break;
 363                         }
 364                         paxwarn(1, "Unknown -x format: %s", optarg);
 365                         fputs("pax: Known -x formats are:", stderr);
 366                         for (i = 0; i < (sizeof(fsub)/sizeof(FSUB)); ++i)
 367                                 fprintf(stderr, " %s", fsub[i].name);
 368                         fputs("\n\n", stderr);
 369                         pax_usage();
 370                         break;
 371                 case 'z':
 372                         /*
 373                          * use gzip.  Non standard option.
 374                          */
 375                         gzip_program = GZIP_CMD;
 376                         break;
 377                 case 'B':
 378                         /*
 379                          * non-standard option on number of bytes written on a
 380                          * single archive volume.
 381                          */
 382                         if ((wrlimit = str_offt(optarg)) <= 0) {
 383                                 paxwarn(1, "Invalid write limit %s", optarg);
 384                                 pax_usage();
 385                         }
 386                         if (wrlimit % BLKMULT) {
 387                                 paxwarn(1, "Write limit is not a %d byte multiple",
 388                                     BLKMULT);
 389                                 pax_usage();
 390                         }
 391                         flg |= CBF;
 392                         break;
 393                 case 'D':
 394                         /*
 395                          * On extraction check file inode change time before the
 396                          * modification of the file name. Non standard option.
 397                          */
 398                         Dflag = 1;
 399                         flg |= CDF;
 400                         break;
 401                 case 'E':
 402                         /*
 403                          * non-standard limit on read faults
 404                          * 0 indicates stop after first error, values
 405                          * indicate a limit, "NONE" try forever
 406                          */
 407                         flg |= CEF;
 408                         if (strcmp(NONE, optarg) == 0)
 409                                 maxflt = -1;
 410                         else if ((maxflt = atoi(optarg)) < 0) {
 411                                 paxwarn(1, "Error count value must be positive");
 412                                 pax_usage();
 413                         }
 414                         break;
 415                 case 'G':
 416                         /*
 417                          * non-standard option for selecting files within an
 418                          * archive by group (gid or name)
 419                          */
 420                         if (grp_add(optarg) < 0) {
 421                                 pax_usage();
 422                                 break;
 423                         }
 424                         flg |= CGF;
 425                         break;
 426                 case 'H':
 427                         /*
 428                          * follow command line symlinks only
 429                          */
 430                         Hflag = 1;
 431                         flg |= CHF;
 432                         break;
 433                 case 'L':
 434                         /*
 435                          * follow symlinks
 436                          */
 437                         Lflag = 1;
 438                         flg |= CLF;
 439                         break;
 440                 case 'O':
 441                         /*
 442                          * Force one volume.  Non standard option.
 443                          */
 444                         force_one_volume = 1;
 445                         break;
 446                 case 'P':
 447                         /*
 448                          * do NOT follow symlinks (default)
 449                          */
 450                         Lflag = 0;
 451                         flg |= CPF;
 452                         break;
 453                 case 'T':
 454                         /*
 455                          * non-standard option for selecting files within an
 456                          * archive by modification time range (lower,upper)
 457                          */
 458                         if (trng_add(optarg) < 0) {
 459                                 pax_usage();
 460                                 break;
 461                         }
 462                         flg |= CTF;
 463                         break;
 464                 case 'U':
 465                         /*
 466                          * non-standard option for selecting files within an
 467                          * archive by user (uid or name)
 468                          */
 469                         if (usr_add(optarg) < 0) {
 470                                 pax_usage();
 471                                 break;
 472                         }
 473                         flg |= CUF;
 474                         break;
 475                 case 'X':
 476                         /*
 477                          * do not pass over mount points in the file system
 478                          */
 479                         Xflag = 1;
 480                         flg |= CXF;
 481                         break;
 482                 case 'Y':
 483                         /*
 484                          * On extraction check file inode change time after the
 485                          * modification of the file name. Non standard option.
 486                          */
 487                         Yflag = 1;
 488                         flg |= CYF;
 489                         break;
 490                 case 'Z':
 491                         /*
 492                          * On extraction check modification time after the
 493                          * modification of the file name. Non standard option.
 494                          */
 495                         Zflag = 1;
 496                         flg |= CZF;
 497                         break;
 498                 default:
 499                         pax_usage();
 500                         break;
 501                 }
 502         }
 503
 504         /*
 505          * figure out the operation mode of pax read,write,extract,copy,append
 506          * or list. check that we have not been given a bogus set of flags
 507          * for the operation mode.
 508          */
 509         if (ISLIST(flg)) {
 510                 act = LIST;
 511                 listf = stdout;
 512                 bflg = flg & BDLIST;
 513         } else if (ISEXTRACT(flg)) {
 514                 act = EXTRACT;
 515                 bflg = flg & BDEXTR;
 516         } else if (ISARCHIVE(flg)) {
 517                 act = ARCHIVE;
 518                 bflg = flg & BDARCH;
 519         } else if (ISAPPND(flg)) {
 520                 act = APPND;
 521                 bflg = flg & BDARCH;
 522         } else if (ISCOPY(flg)) {
 523                 act = COPY;
 524                 bflg = flg & BDCOPY;
 525         } else
 526                 pax_usage();
 527         if (bflg) {
 528                 printflg(flg);
 529                 pax_usage();
 530         }
 531
 532         /*
 533          * if we are writing (ARCHIVE) we use the default format if the user
 534          * did not specify a format. when we write during an APPEND, we will
 535          * adopt the format of the existing archive if none was supplied.
 536          */
 537         if (!(flg & XF) && (act == ARCHIVE))
 538                 frmt = &(fsub[DEFLT]);
 539
 540         /*
 541          * process the args as they are interpreted by the operation mode
 542          */
 543         switch (act) {
 544         case LIST:
 545         case EXTRACT:
 546                 for (; optind < argc; optind++)
 547                         if (pat_add(argv[optind], NULL) < 0)
 548                                 pax_usage();
 549                 break;
 550         case COPY:
 551                 if (optind >= argc) {
 552                         paxwarn(0, "Destination directory was not supplied");
 553                         pax_usage();
 554                 }
 555                 --argc;
 556                 dirptr = argv[argc];
 557                 if (mkpath(dirptr) < 0)
 558                         exit(1);
 559                 /* FALL THROUGH */
 560         case ARCHIVE:
 561         case APPND:
 562                 for (; optind < argc; optind++)
 563                         if (ftree_add(argv[optind], 0) < 0)
 564                                 pax_usage();
 565                 /*
 566                  * no read errors allowed on updates/append operation!
 567                  */
 568                 maxflt = 0;
 569                 break;
 570         }
 571 }
 572
 573
 574 /*
 575  * tar_options()
 576  *      look at the user specified flags. set globals as required and check if
 577  *      the user specified a legal set of flags. If not, complain and exit
 578  */
 579
 580 static void
 581 tar_options(int argc, char **argv)
 582 {
 583         int c;
 584         int fstdin = 0;
 585         int Oflag = 0;
 586         int nincfiles = 0;
 587         int incfiles_max = 0;
 588         struct incfile {
 589                 char *file;
 590                 char *dir;
 591         };
 592         struct incfile *incfiles = NULL;
 593
 594         /*
 595          * Set default values.
 596          */
 597         rmleadslash = 1;
 598
 599         /*
 600          * process option flags
 601          */
 602         while ((c = getoldopt(argc, argv,
 603             "b:cef:hjmopqruts:vwxyzBC:HI:LOPXZ014578")) != -1) {
 604                 switch(c) {
 605                 case 'b':
 606                         /*
 607                          * specify blocksize in 512-byte blocks
 608                          */
 609                         if ((wrblksz = (int)str_offt(optarg)) <= 0) {
 610                                 paxwarn(1, "Invalid block size %s", optarg);
 611                                 tar_usage();
 612                         }
 613                         wrblksz *= 512;         /* XXX - check for int oflow */
 614                         break;
 615                 case 'c':
 616                         /*
 617                          * create an archive
 618                          */
 619                         act = ARCHIVE;
 620                         break;
 621                 case 'e':
 622                         /*
 623                          * stop after first error
 624                          */
 625                         maxflt = 0;
 626                         break;
 627                 case 'f':
 628                         /*
 629                          * filename where the archive is stored
 630                          */
 631                         if ((optarg[0] == '-') && (optarg[1]== '\0')) {
 632                                 /*
 633                                  * treat a - as stdin
 634                                  */
 635                                 fstdin = 1;
 636                                 arcname = NULL;
 637                                 break;
 638                         }
 639                         fstdin = 0;
 640                         arcname = optarg;
 641                         break;
 642                 case 'h':
 643                         /*
 644                          * follow symlinks
 645                          */
 646                         Lflag = 1;
 647                         break;
 648                 case 'j':
 649                 case 'y':
 650                         /*
 651                          * use bzip2.  Non standard option.
 652                          */
 653                         gzip_program = BZIP2_CMD;
 654                         break;
 655                 case 'm':
 656                         /*
 657                          * do not preserve modification time
 658                          */
 659                         pmtime = 0;
 660                         break;
 661                 case 'o':
 662                         if (opt_add("write_opt=nodir") < 0)
 663                                 tar_usage();
 664                 case 'O':
 665                         Oflag = 1;
 666                         break;
 667                 case 'p':
 668                         /*
 669                          * preserve uid/gid and file mode, regardless of umask
 670                          */
 671                         pmode = 1;
 672                         pids = 1;
 673                         break;
 674                 case 'q':
 675                         /*
 676                          * select first match for a pattern only
 677                          */
 678                         nflag = 1;
 679                         break;
 680                 case 'r':
 681                 case 'u':
 682                         /*
 683                          * append to the archive
 684                          */
 685                         act = APPND;
 686                         break;
 687                 case 's':
 688                         /*
 689                          * file name substitution name pattern
 690                          */
 691                         if (rep_add(optarg) < 0) {
 692                                 tar_usage();
 693                                 break;
 694                         }
 695                         break;
 696                 case 't':
 697                         /*
 698                          * list contents of the tape
 699                          */
 700                         act = LIST;
 701                         break;
 702                 case 'v':
 703                         /*
 704                          * verbose operation mode
 705                          */
 706                         vflag++;
 707                         break;
 708                 case 'w':
 709                         /*
 710                          * interactive file rename
 711                          */
 712                         iflag = 1;
 713                         break;
 714                 case 'x':
 715                         /*
 716                          * extract an archive, preserving mode,
 717                          * and mtime if possible.
 718                          */
 719                         act = EXTRACT;
 720                         pmtime = 1;
 721                         break;
 722                 case 'z':
 723                         /*
 724                          * use gzip.  Non standard option.
 725                          */
 726                         gzip_program = GZIP_CMD;
 727                         break;
 728                 case 'B':
 729                         /*
 730                          * Nothing to do here, this is pax default
 731                          */
 732                         break;
 733                 case 'C':
 734                         chdname = optarg;
 735                         break;
 736                 case 'H':
 737                         /*
 738                          * follow command line symlinks only
 739                          */
 740                         Hflag = 1;
 741                         break;
 742                 case 'I':
 743                         if (++nincfiles > incfiles_max) {
 744                                 incfiles_max = nincfiles + 3;
 745                                 incfiles = realloc(incfiles,
 746                                     sizeof(*incfiles) * incfiles_max);
 747                                 if (incfiles == NULL) {
 748                                         paxwarn(0, "Unable to allocate space "
 749                                             "for option list");
 750                                         exit(1);
 751                                 }
 752                         }
 753                         incfiles[nincfiles - 1].file = optarg;
 754                         incfiles[nincfiles - 1].dir = chdname;
 755                         break;
 756                 case 'L':
 757                         /*
 758                          * follow symlinks
 759                          */
 760                         Lflag = 1;
 761                         break;
 762                 case 'P':
 763                         /*
 764                          * do not remove leading '/' from pathnames
 765                          */
 766                         rmleadslash = 0;
 767                         break;
 768                 case 'X':
 769                         /*
 770                          * do not pass over mount points in the file system
 771                          */
 772                         Xflag = 1;
 773                         break;
 774                 case 'Z':
 775                         /*
 776                          * use compress.
 777                          */
 778                         gzip_program = COMPRESS_CMD;
 779                         break;
 780                 case '0':
 781                         arcname = DEV_0;
 782                         break;
 783                 case '1':
 784                         arcname = DEV_1;
 785                         break;
 786                 case '4':
 787                         arcname = DEV_4;
 788                         break;
 789                 case '5':
 790                         arcname = DEV_5;
 791                         break;
 792                 case '7':
 793                         arcname = DEV_7;
 794                         break;
 795                 case '8':
 796                         arcname = DEV_8;
 797                         break;
 798                 default:
 799                         tar_usage();
 800                         break;
 801                 }
 802         }
 803         argc -= optind;
 804         argv += optind;
 805
 806         /* Traditional tar behaviour (pax uses stderr unless in list mode) */
 807         if (fstdin == 1 && act == ARCHIVE)
 808                 listf = stderr;
 809         else
 810                 listf = stdout;
 811
 812         /* Traditional tar behaviour (pax wants to read file list from stdin) */
 813         if ((act == ARCHIVE || act == APPND) && argc == 0 && nincfiles == 0)
 814                 exit(0);
 815
 816         /*
 817          * if we are writing (ARCHIVE) specify tar, otherwise run like pax
 818          * (unless -o specified)
 819          */
 820         if (act == ARCHIVE || act == APPND)
 821                 frmt = &(fsub[Oflag ? F_OTAR : F_TAR]);
 822         else if (Oflag) {
 823                 paxwarn(1, "The -O/-o options are only valid when writing an archive");
 824                 tar_usage();            /* only valid when writing */
 825         }
 826
 827         /*
 828          * process the args as they are interpreted by the operation mode
 829          */
 830         switch (act) {
 831         case LIST:
 832         case EXTRACT:
 833         default:
 834                 {
 835                         int sawpat = 0;
 836                         char *file, *dir = NULL;
 837
 838                         while (nincfiles || *argv != NULL) {
 839                                 /*
 840                                  * If we queued up any include files,
 841                                  * pull them in now.  Otherwise, check
 842                                  * for -I and -C positional flags.
 843                                  * Anything else must be a file to
 844                                  * extract.
 845                                  */
 846                                 if (nincfiles) {
 847                                         file = incfiles->file;
 848                                         dir = incfiles->dir;
 849                                         incfiles++;
 850                                         nincfiles--;
 851                                 } else if (strcmp(*argv, "-I") == 0) {
 852                                         if (*++argv == NULL)
 853                                                 break;
 854                                         file = *argv++;
 855                                         dir = chdname;
 856                                 } else
 857                                         file = NULL;
 858                                 if (file != NULL) {
 859                                         FILE *fp;
 860                                         char *str;
 861
 862                                         if (strcmp(file, "-") == 0)
 863                                                 fp = stdin;
 864                                         else if ((fp = fopen(file, "r")) == NULL) {
 865                                                 paxwarn(1, "Unable to open file '%s' for read", file);
 866                                                 tar_usage();
 867                                         }
 868                                         while ((str = getline(fp)) != NULL) {
 869                                                 if (pat_add(str, dir) < 0)
 870                                                         tar_usage();
 871                                                 sawpat = 1;
 872                                         }
 873                                         if (strcmp(file, "-") != 0)
 874                                                 fclose(fp);
 875                                         if (getline_error) {
 876                                                 paxwarn(1, "Problem with file '%s'", file);
 877                                                 tar_usage();
 878                                         }
 879                                 } else if (strcmp(*argv, "-C") == 0) {
 880                                         if (*++argv == NULL)
 881                                                 break;
 882                                         chdname = *argv++;
 883                                 } else if (pat_add(*argv++, chdname) < 0)
 884                                         tar_usage();
 885                                 else
 886                                         sawpat = 1;
 887                         }
 888                         /*
 889                          * if patterns were added, we are doing chdir()
 890                          * on a file-by-file basis, else, just one
 891                          * global chdir (if any) after opening input.
 892                          */
 893                         if (sawpat > 0)
 894                                 chdname = NULL;
 895                 }
 896                 break;
 897         case ARCHIVE:
 898         case APPND:
 899                 if (chdname != NULL) {  /* initial chdir() */
 900                         if (ftree_add(chdname, 1) < 0)
 901                                 tar_usage();
 902                 }
 903
 904                 while (nincfiles || *argv != NULL) {
 905                         char *file, *dir = NULL;
 906
 907                         /*
 908                          * If we queued up any include files, pull them in
 909                          * now.  Otherwise, check for -I and -C positional
 910                          * flags.  Anything else must be a file to include
 911                          * in the archive.
 912                          */
 913                         if (nincfiles) {
 914                                 file = incfiles->file;
 915                                 dir = incfiles->dir;
 916                                 incfiles++;
 917                                 nincfiles--;
 918                         } else if (strcmp(*argv, "-I") == 0) {
 919                                 if (*++argv == NULL)
 920                                         break;
 921                                 file = *argv++;
 922                                 dir = NULL;
 923                         } else
 924                                 file = NULL;
 925                         if (file != NULL) {
 926                                 FILE *fp;
 927                                 char *str;
 928
 929                                 /* Set directory if needed */
 930                                 if (dir) {
 931                                         if (ftree_add(dir, 1) < 0)
 932                                                 tar_usage();
 933                                 }
 934
 935                                 if (strcmp(file, "-") == 0)
 936                                         fp = stdin;
 937                                 else if ((fp = fopen(file, "r")) == NULL) {
 938                                         paxwarn(1, "Unable to open file '%s' for read", file);
 939                                         tar_usage();
 940                                 }
 941                                 while ((str = getline(fp)) != NULL) {
 942                                         if (ftree_add(str, 0) < 0)
 943                                                 tar_usage();
 944                                 }
 945                                 if (strcmp(file, "-") != 0)
 946                                         fclose(fp);
 947                                 if (getline_error) {
 948                                         paxwarn(1, "Problem with file '%s'",
 949                                             file);
 950                                         tar_usage();
 951                                 }
 952                         } else if (strcmp(*argv, "-C") == 0) {
 953                                 if (*++argv == NULL)
 954                                         break;
 955                                 if (ftree_add(*argv++, 1) < 0)
 956                                         tar_usage();
 957                         } else if (ftree_add(*argv++, 0) < 0)
 958                                 tar_usage();
 959                 }
 960                 /*
 961                  * no read errors allowed on updates/append operation!
 962                  */
 963                 maxflt = 0;
 964                 break;
 965         }
 966         if (!fstdin && ((arcname == NULL) || (*arcname == '\0'))) {
 967                 arcname = getenv("TAPE");
 968                 if ((arcname == NULL) || (*arcname == '\0'))
 969                         arcname = _PATH_DEFTAPE;
 970         }
 971 }
 972
 973 static int
 974 mkpath(char *path)
 975 {
 976         struct stat sb;
 977         char *slash;
 978         int done = 0;
 979
 980         slash = path;
 981
 982         while (!done) {
 983                 slash += strspn(slash, "/");
 984                 slash += strcspn(slash, "/");
 985
 986                 done = (*slash == '\0');
 987                 *slash = '\0';
 988
 989                 if (stat(path, &sb)) {
 990                         if (errno != ENOENT || mkdir(path, 0777)) {
 991                                 paxwarn(1, "%s", path);
 992                                 return (-1);
 993                         }
 994                 } else if (!S_ISDIR(sb.st_mode)) {
 995                         syswarn(1, ENOTDIR, "%s", path);
 996                         return (-1);
 997                 }
 998
 999                 if (!done)
1000                         *slash = '/';
1001         }
1002
1003         return (0);
1004 }
1005 /*
1006  * cpio_options()
1007  *      look at the user specified flags. set globals as required and check if
1008  *      the user specified a legal set of flags. If not, complain and exit
1009  */
1010
1011 static void
1012 cpio_options(int argc, char **argv)
1013 {
1014         int c, i;
1015         char *str;
1016         FSUB tmp;
1017         FILE *fp;
1018
1019         kflag = 1;
1020         pids = 1;
1021         pmode = 1;
1022         pmtime = 0;
1023         arcname = NULL;
1024         dflag = 1;
1025         act = -1;
1026         nodirs = 1;
1027         while ((c=getopt(argc,argv,"abcdfiklmoprstuvzABC:E:F:H:I:LO:SZ6")) != -1)
1028                 switch (c) {
1029                         case 'a':
1030                                 /*
1031                                  * preserve access time on files read
1032                                  */
1033                                 tflag = 1;
1034                                 break;
1035                         case 'b':
1036                                 /*
1037                                  * swap bytes and half-words when reading data
1038                                  */
1039                                 break;
1040                         case 'c':
1041                                 /*
1042                                  * ASCII cpio header
1043                                  */
1044                                 frmt = &(fsub[F_ACPIO]);
1045                                 break;
1046                         case 'd':
1047                                 /*
1048                                  * create directories as needed
1049                                  */
1050                                 nodirs = 0;
1051                                 break;
1052                         case 'f':
1053                                 /*
1054                                  * invert meaning of pattern list
1055                                  */
1056                                 cflag = 1;
1057                                 break;
1058                         case 'i':
1059                                 /*
1060                                  * restore an archive
1061                                  */
1062                                 act = EXTRACT;
1063                                 break;
1064                         case 'k':
1065                                 break;
1066                         case 'l':
1067                                 /*
1068                                  * use links instead of copies when possible
1069                                  */
1070                                 lflag = 1;
1071                                 break;
1072                         case 'm':
1073                                 /*
1074                                  * preserve modification time
1075                                  */
1076                                 pmtime = 1;
1077                                 break;
1078                         case 'o':
1079                                 /*
1080                                  * create an archive
1081                                  */
1082                                 act = ARCHIVE;
1083                                 frmt = &(fsub[F_CPIO]);
1084                                 break;
1085                         case 'p':
1086                                 /*
1087                                  * copy-pass mode
1088                                  */
1089                                 act = COPY;
1090                                 break;
1091                         case 'r':
1092                                 /*
1093                                  * interactively rename files
1094                                  */
1095                                 iflag = 1;
1096                                 break;
1097                         case 's':
1098                                 /*
1099                                  * swap bytes after reading data
1100                                  */
1101                                 break;
1102                         case 't':
1103                                 /*
1104                                  * list contents of archive
1105                                  */
1106                                 act = LIST;
1107                                 listf = stdout;
1108                                 break;
1109                         case 'u':
1110                                 /*
1111                                  * replace newer files
1112                                  */
1113                                 kflag = 0;
1114                                 break;
1115                         case 'v':
1116                                 /*
1117                                  * verbose operation mode
1118                                  */
1119                                 vflag = 1;
1120                                 break;
1121                         case 'z':
1122                                 /*
1123                                  * use gzip.  Non standard option.
1124                                  */
1125                                 gzip_program = GZIP_CMD;
1126                                 break;
1127                         case 'A':
1128                                 /*
1129                                  * append mode
1130                                  */
1131                                 act = APPND;
1132                                 break;
1133                         case 'B':
1134                                 /*
1135                                  * Use 5120 byte block size
1136                                  */
1137                                 wrblksz = 5120;
1138                                 break;
1139                         case 'C':
1140                                 /*
1141                                  * set block size in bytes
1142                                  */
1143                                 wrblksz = atoi(optarg);
1144                                 break;
1145                         case 'E':
1146                                 /*
1147                                  * file with patterns to extract or list
1148                                  */
1149                                 if ((fp = fopen(optarg, "r")) == NULL) {
1150                                         paxwarn(1, "Unable to open file '%s' for read", optarg);
1151                                         cpio_usage();
1152                                 }
1153                                 while ((str = getline(fp)) != NULL) {
1154                                         pat_add(str, NULL);
1155                                 }
1156                                 fclose(fp);
1157                                 if (getline_error) {
1158                                         paxwarn(1, "Problem with file '%s'", optarg);
1159                                         cpio_usage();
1160                                 }
1161                                 break;
1162                         case 'F':
1163                         case 'I':
1164                         case 'O':
1165                                 /*
1166                                  * filename where the archive is stored
1167                                  */
1168                                 if ((optarg[0] == '-') && (optarg[1]== '\0')) {
1169                                         /*
1170                                          * treat a - as stdin
1171                                          */
1172                                         arcname = NULL;
1173                                         break;
1174                                 }
1175                                 arcname = optarg;
1176                                 break;
1177                         case 'H':
1178                                 /*
1179                                  * specify an archive format on write
1180                                  */
1181                                 tmp.name = optarg;
1182                                 if ((frmt = (FSUB *)bsearch((void *)&tmp, (void *)fsub,
1183                                     sizeof(fsub)/sizeof(FSUB), sizeof(FSUB), c_frmt)) != NULL)
1184                                         break;
1185                                 paxwarn(1, "Unknown -H format: %s", optarg);
1186                                 fputs("cpio: Known -H formats are:", stderr);
1187                                 for (i = 0; i < (sizeof(fsub)/sizeof(FSUB)); ++i)
1188                                         fprintf(stderr, " %s", fsub[i].name);
1189                                 fputs("\n\n", stderr);
1190                                 cpio_usage();
1191                                 break;
1192                         case 'L':
1193                                 /*
1194                                  * follow symbolic links
1195                                  */
1196                                 Lflag = 1;
1197                                 break;
1198                         case 'S':
1199                                 /*
1200                                  * swap halfwords after reading data
1201                                  */
1202                                 break;
1203                         case 'Z':
1204                                 /*
1205                                  * use compress.  Non standard option.
1206                                  */
1207                                 gzip_program = COMPRESS_CMD;
1208                                 break;
1209                         case '6':
1210                                 /*
1211                                  * process Version 6 cpio format
1212                                  */
1213                                 frmt = &(fsub[F_OCPIO]);
1214                                 break;
1215                         case '?':
1216                         default:
1217                                 cpio_usage();
1218                                 break;
1219                 }
1220         argc -= optind;
1221         argv += optind;
1222
1223         /*
1224          * process the args as they are interpreted by the operation mode
1225          */
1226         switch (act) {
1227                 case LIST:
1228                 case EXTRACT:
1229                         while (*argv != NULL)
1230                                 if (pat_add(*argv++, NULL) < 0)
1231                                         cpio_usage();
1232                         break;
1233                 case COPY:
1234                         if (*argv == NULL) {
1235                                 paxwarn(0, "Destination directory was not supplied");
1236                                 cpio_usage();
1237                         }
1238                         dirptr = *argv;
1239                         if (mkpath(dirptr) < 0)
1240                                 cpio_usage();
1241                         --argc;
1242                         ++argv;
1243                         /* FALL THROUGH */
1244                 case ARCHIVE:
1245                 case APPND:
1246                         if (*argv != NULL)
1247                                 cpio_usage();
1248                         /*
1249                          * no read errors allowed on updates/append operation!
1250                          */
1251                         maxflt = 0;
1252                         while ((str = getline(stdin)) != NULL) {
1253                                 ftree_add(str, 0);
1254                         }
1255                         if (getline_error) {
1256                                 paxwarn(1, "Problem while reading stdin");
1257                                 cpio_usage();
1258                         }
1259                         break;
1260                 default:
1261                         cpio_usage();
1262                         break;
1263         }
1264 }
1265
1266 /*
1267  * printflg()
1268  *      print out those invalid flag sets found to the user
1269  */
1270
1271 static void
1272 printflg(unsigned int flg)
1273 {
1274         int nxt;
1275         int pos = 0;
1276
1277         fprintf(stderr,"%s: Invalid combination of options:", argv0);
1278         while ((nxt = ffs(flg)) != 0) {
1279                 flg = flg >> nxt;
1280                 pos += nxt;
1281                 fprintf(stderr, " -%c", flgch[pos-1]);
1282         }
1283         putc('\n', stderr);
1284 }
1285
1286 /*
1287  * c_frmt()
1288  *      comparison routine used by bsearch to find the format specified
1289  *      by the user
1290  */
1291
1292 static int
1293 c_frmt(const void *a, const void *b)
1294 {
1295         return(strcmp(((FSUB *)a)->name, ((FSUB *)b)->name));
1296 }
1297
1298 /*
1299  * opt_next()
1300  *      called by format specific options routines to get each format specific
1301  *      flag and value specified with -o
1302  * Return:
1303  *      pointer to next OPLIST entry or NULL (end of list).
1304  */
1305
1306 OPLIST *
1307 opt_next(void)
1308 {
1309         OPLIST *opt;
1310
1311         if ((opt = ophead) != NULL)
1312                 ophead = ophead->fow;
1313         return(opt);
1314 }
1315
1316 /*
1317  * bad_opt()
1318  *      generic routine used to complain about a format specific options
1319  *      when the format does not support options.
1320  */
1321
1322 int
1323 bad_opt(void)
1324 {
1325         OPLIST *opt;
1326
1327         if (ophead == NULL)
1328                 return(0);
1329         /*
1330          * print all we were given
1331          */
1332         paxwarn(1,"These format options are not supported");
1333         while ((opt = opt_next()) != NULL)
1334                 fprintf(stderr, "\t%s = %s\n", opt->name, opt->value);
1335         pax_usage();
1336         return(0);
1337 }
1338
1339 /*
1340  * opt_add()
1341  *      breaks the value supplied to -o into a option name and value. options
1342  *      are given to -o in the form -o name-value,name=value
1343  *      multiple -o may be specified.
1344  * Return:
1345  *      0 if format in name=value format, -1 if -o is passed junk
1346  */
1347
1348 int
1349 opt_add(char *str)
1350 {
1351         OPLIST *opt;
1352         char *frpt;
1353         char *pt;
1354         char *endpt;
1355
1356         if ((str == NULL) || (*str == '\0')) {
1357                 paxwarn(0, "Invalid option name");
1358                 return(-1);
1359         }
1360         if ((str = strdup(str)) == NULL) {
1361                 paxwarn(0, "Unable to allocate space for option list");
1362                 return(-1);
1363         }
1364         frpt = str;
1365
1366         /*
1367          * break into name and values pieces and stuff each one into a
1368          * OPLIST structure. When we know the format, the format specific
1369          * option function will go through this list
1370          */
1371         while ((frpt != NULL) && (*frpt != '\0')) {
1372                 if ((endpt = strchr(frpt, ',')) != NULL)
1373                         *endpt = '\0';
1374                 if ((pt = strchr(frpt, '=')) == NULL) {
1375                         paxwarn(0, "Invalid options format");
1376                         free(str);
1377                         return(-1);
1378                 }
1379                 if ((opt = (OPLIST *)malloc(sizeof(OPLIST))) == NULL) {
1380                         paxwarn(0, "Unable to allocate space for option list");
1381                         free(str);
1382                         return(-1);
1383                 }
1384                 *pt++ = '\0';
1385                 opt->name = frpt;
1386                 opt->value = pt;
1387                 opt->fow = NULL;
1388                 if (endpt != NULL)
1389                         frpt = endpt + 1;
1390                 else
1391                         frpt = NULL;
1392                 if (ophead == NULL) {
1393                         optail = ophead = opt;
1394                         continue;
1395                 }
1396                 optail->fow = opt;
1397                 optail = opt;
1398         }
1399         return(0);
1400 }
1401
1402 /*
1403  * str_offt()
1404  *      Convert an expression of the following forms to an off_t > 0.
1405  *      1) A positive decimal number.
1406  *      2) A positive decimal number followed by a b (mult by 512).
1407  *      3) A positive decimal number followed by a k (mult by 1024).
1408  *      4) A positive decimal number followed by a m (mult by 512).
1409  *      5) A positive decimal number followed by a w (mult by sizeof int)
1410  *      6) Two or more positive decimal numbers (with/without k,b or w).
1411  *         separated by x (also * for backwards compatibility), specifying
1412  *         the product of the indicated values.
1413  * Return:
1414  *      0 for an error, a positive value o.w.
1415  */
1416
1417 static off_t
1418 str_offt(char *val)
1419 {
1420         char *expr;
1421         off_t num, t;
1422
1423         num = strtoq(val, &expr, 0);
1424         if ((num == QUAD_MAX) || (num <= 0) || (expr == val))
1425                 return(0);
1426
1427         switch(*expr) {
1428         case 'b':
1429                 t = num;
1430                 num *= 512;
1431                 if (t > num)
1432                         return(0);
1433                 ++expr;
1434                 break;
1435         case 'k':
1436                 t = num;
1437                 num *= 1024;
1438                 if (t > num)
1439                         return(0);
1440                 ++expr;
1441                 break;
1442         case 'm':
1443                 t = num;
1444                 num *= 1048576;
1445                 if (t > num)
1446                         return(0);
1447                 ++expr;
1448                 break;
1449         case 'w':
1450                 t = num;
1451                 num *= sizeof(int);
1452                 if (t > num)
1453                         return(0);
1454                 ++expr;
1455                 break;
1456         }
1457
1458         switch(*expr) {
1459                 case '\0':
1460                         break;
1461                 case '*':
1462                 case 'x':
1463                         t = num;
1464                         num *= str_offt(expr + 1);
1465                         if (t > num)
1466                                 return(0);
1467                         break;
1468                 default:
1469                         return(0);
1470         }
1471         return(num);
1472 }
1473
1474 char *
1475 getline(FILE *f)
1476 {
1477         char *name, *temp;
1478         size_t len;
1479
1480         name = fgetln(f, &len);
1481         if (!name) {
1482                 getline_error = ferror(f) ? GETLINE_FILE_CORRUPT : 0;
1483                 return(0);
1484         }
1485         if (name[len-1] != '\n')
1486                 len++;
1487         temp = malloc(len);
1488         if (!temp) {
1489                 getline_error = GETLINE_OUT_OF_MEM;
1490                 return(0);
1491         }
1492         memcpy(temp, name, len-1);
1493         temp[len-1] = 0;
1494         return(temp);
1495 }
1496
1497 /*
1498  * no_op()
1499  *      for those option functions where the archive format has nothing to do.
1500  * Return:
1501  *      0
1502  */
1503
1504 static int
1505 no_op(void)
1506 {
1507         return(0);
1508 }
1509
1510 /*
1511  * pax_usage()
1512  *      print the usage summary to the user
1513  */
1514
1515 void
1516 pax_usage(void)
1517 {
1518         fputs("usage: pax [-cdnvz] [-E limit] [-f archive] ", stderr);
1519         fputs("[-s replstr] ... [-U user] ...", stderr);
1520         fputs("\n          [-G group] ... ", stderr);
1521         fputs("[-T [from_date][,to_date]] ... ", stderr);
1522         fputs("[pattern ...]\n", stderr);
1523         fputs("       pax -r [-cdiknuvzDYZ] [-E limit] ", stderr);
1524         fputs("[-f archive] [-o options] ... \n", stderr);
1525         fputs("    [-p string] ... [-s replstr] ... ", stderr);
1526         fputs("[-U user] ... [-G group] ...\n      ", stderr);
1527         fputs("[-T [from_date][,to_date]] ... ", stderr);
1528         fputs(" [pattern ...]\n", stderr);
1529         fputs("       pax -w [-dituvzHLPX] [-b blocksize] ", stderr);
1530         fputs("[ [-a] [-f archive] ] [-x format] \n", stderr);
1531         fputs("    [-B bytes] [-s replstr] ... ", stderr);
1532         fputs("[-o options] ... [-U user] ...", stderr);
1533         fputs("\n          [-G group] ... ", stderr);
1534         fputs("[-T [from_date][,to_date][/[c][m]]] ... ", stderr);
1535         fputs("[file ...]\n", stderr);
1536         fputs("       pax -r -w [-diklntuvDHLPXYZ] ", stderr);
1537         fputs("[-p string] ... [-s replstr] ...", stderr);
1538         fputs("\n          [-U user] ... [-G group] ... ", stderr);
1539         fputs("[-T [from_date][,to_date][/[c][m]]] ... ", stderr);
1540         fputs("\n          [file ...] directory\n", stderr);
1541         exit(1);
1542 }
1543
1544 /*
1545  * tar_usage()
1546  *      print the usage summary to the user
1547  */
1548
1549 void
1550 tar_usage(void)
1551 {
1552         fputs("usage: tar [-]{crtux}[-befhjmopqsvwyzHLOPXZ014578] [blocksize] ",
1553                  stderr);
1554         fputs("[archive] [replstr] [-C directory] [-I file] [file ...]\n",
1555             stderr);
1556         exit(1);
1557 }
1558
1559 /*
1560  * cpio_usage()
1561  *      print the usage summary to the user
1562  */
1563
1564 void
1565 cpio_usage(void)
1566 {
1567         fputs("usage: cpio -o [-aABcLvVzZ] [-C bytes] [-H format] [-O archive]\n", stderr);
1568         fputs("               [-F archive] < name-list [> archive]\n", stderr);
1569         fputs("       cpio -i [-bBcdfmnrsStuvVzZ6] [-C bytes] [-E file] [-H format]\n", stderr);
1570         fputs("               [-I archive] [-F archive] [pattern...] [< archive]\n", stderr);
1571         fputs("       cpio -p [-adlLmuvV] destination-directory < name-list\n", stderr);
1572         exit(1);
1573 }