home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c019 / 4.ddi / UNZIP42 / SHIP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-03  |  37.6 KB  |  1,288 lines
  1. /* ship.c -- Not copyrighted 1991 Mark Adler */
  2.  
  3. #define SHIPVER "ship version 1.1  November 4, 1991  Mark Adler"
  4.  
  5. /* Command for mailing (-m): the %s's are, in order, the subject prefix,
  6.    the part number (always of the form "partnnnn"), the subject suffix
  7.    (empty or " (last)" if the last part), the mailing address, and the
  8.    name of the temporary file begin mailed.  The command "Mail" is for BSD
  9.    systems.  You may need to change it to "mailx" for System V Unix, using
  10.    the compile option "-DMAILX".  Also, on Sperry (Unisys?) SysV.3 systems,
  11.    you might try the command name "v6mail". */
  12.  
  13. #ifdef DIRENT           /* If compiled with zip, DIRENT implies System V */
  14. #  define MAILX
  15. #endif /* DIRENT */
  16.  
  17. #ifdef sun              /* Except Sun's use DIRENT, but have Mail */
  18. #  ifdef MAILX
  19. #    undef MAILX
  20. #  endif /* MAILX */
  21. #endif /* sun */
  22.  
  23. #ifdef sgi              /* Silicon Graphics that way too */
  24. #  ifdef MAILX
  25. #    undef MAILX
  26. #  endif /* MAILX */
  27. #endif /* sgi */
  28.  
  29. #ifdef VMS
  30. #  define TMPNAME "_SXXXXXX."
  31. #  define MAILCMD "mail %s /subj=\"%s %s%s\" \"%s\""
  32. #  define PATHCUT ']'
  33. #else /* !VMS */
  34. #  define TMPNAME "_SXXXXXX"
  35. #  ifdef MAILX
  36. #    define MAILCMD "mailx -s \"%s %s%s\" \"%s\" < %s"
  37. #  else /* !MAILX */
  38. #    ifdef M_XENIX
  39. #      define MAILCMD "mail -s \"%s %s%s\" \"%s\" < %s"
  40. #    else /* !M_XENIX */
  41. #      define MAILCMD "Mail -s \"%s %s%s\" \"%s\" < %s"
  42. #    endif /* ?M_XENIX */
  43. #  endif /* ?MAILX */
  44. #  ifdef MSDOS
  45. #    define PATHCUT '\\'
  46. #  else /* !MSDOS */
  47. #    define PATHCUT '/'
  48. #  endif /* ?MSDOS */
  49. #endif /* ?VMS */
  50.  
  51. /*
  52.  
  53. SHIP -
  54.  
  55.   Ship is a program for sending binary files through email.  It is designed
  56.   to supplant uuencode and uudecode.  Ship encodes approximately 6.32 bits
  57.   per character mailed, compared to uuencode's 5.81 bits per character.
  58.  
  59.   Ship also has these features: a 32-bit CRC check on each file; automatic
  60.   splitting of the ship output into multiple, smaller files for speedier
  61.   mailing; automatic mailing of ship's output, with subject lines for
  62.   multiple parts; and a check on the sequence of parts when unshipping.
  63.  
  64.   Usage:
  65.  
  66.        ship [-nnn] [-m address] [-s subject] file ...
  67.  
  68.   where nnn is the maximum number of K bytes for each output file, address
  69.   is the address to send mail to, subject is a Subject" line prefix, and
  70.   file ... is a list of files to ship.  If no options are given, ship
  71.   outputs to stdout.  The simplest use is:
  72.  
  73.        ship foo > x
  74.  
  75.   where foo is converted into the mailable file, x.
  76.  
  77.   When -nnn is specified, but -m is not, ship writes to the files
  78.   part0001, part0002, etc., where each file has nnn or less K bytes.  For
  79.   example:
  80.  
  81.        ship -25 bigfoo
  82.  
  83.   will write however many 25K byte or less ship files is needed to contain
  84.   bigfoo.  If, say, six files are needed, then the files part0001 to part0006
  85.   will be written.
  86.  
  87.   When using -m, nothing is written, either to files or to stdout; rather,
  88.   the output is mailed to the specified address.  If -nnn is also specified,
  89.   then the parts are mailed separately with the subject lines part0001, etc.
  90.   If -nnn is not specified, then only one part (the whole thing) is mailed
  91.   with the subject line "part0001".  For example:
  92.  
  93.        ship -25 -m fred bigfoo
  94.  
  95.   will mail the six parts of bigfoo to fred.
  96.  
  97.   Any number of files can be shipped at once.  They become part of one long
  98.   ship stream, so if, for example -25 is specified, all but the last part
  99.   will have about 25K bytes.  For example:
  100.  
  101.        ship -25 -m fred fee fi fo fum
  102.  
  103.   will send the files fee, fi, fo, and fum to fred.
  104.  
  105.   Fred will get several mail messages with the subject lines part0001, etc.
  106.   He can then save those messages as the files, say, p1, p2, p3, ...
  107.   Then he can use the command:
  108.  
  109.        ship -u p?
  110.  
  111.   to recreate bigfoo, or fee fi fo and fum, depending on what he was sent.
  112.   If Fred saved the wrong numbers, ship will detect this and report a
  113.   sequence error.
  114.  
  115.   Note: there is enough information in the shipped parts to determine the
  116.   correct sequence.  A future version of ship will prescan the files to
  117.   determine the sequence, and then process them in the correct order.
  118.  
  119.   If a file being received already exists, ship -u will report an error
  120.   and exit.  The -o option avoids this and allows ship to overwrite existing
  121.   files.  The -o option must follow the -u option:
  122.  
  123.        ship -u -o p?
  124.  
  125.   In addition to the -u option, ship will unship if it sees that its name is
  126.   unship.  On Unix systems, this can be done simply by linking the executable
  127.   to unship:
  128.  
  129.        ln ship unship 
  130.  
  131.   Ship can also be used as a filter.  The special file name "-" means stdin.
  132.   For example:
  133.  
  134.        tar covf - foodir | compress | ship -25 -m fred -
  135.  
  136.   will tar the directory foodir, compress it, and ship it to fred in 25K byte
  137.   pieces.  Then, after Fred saves the files as p01, etc. at the other, end,
  138.   he can:
  139.  
  140.        ship -u p? | zcat | tar xovf -
  141.  
  142.   which will recreate the directory foobar and its contents.  ship -u knows
  143.   to write to stdout, since the original ship put the special file name "-"
  144.   in the first part.
  145.  
  146.   Ship uses a base 85 coding that needs 32-bit multiplication and division.
  147.   This can be slow on 16-bit machines, so ship provides a fast encoding
  148.   method by specifying the -f option.  This method is somewhat faster even
  149.   on 32-bit machines, and has approximately a 1% penalty in the size of the
  150.   encoded result (-f gives 6.26 bits per character, on the average).  The -f
  151.   option need only be used when shipping--unshipping (ship -u) automatically
  152.   detects the encoding used.  For example:
  153.  
  154.        ship -f -25 -m fred foo
  155.  
  156.   will send foo to fred in 25K byte pieces using the fast encoding method.
  157.   You don't need to tell Fred, since ship -u will figure that out for him.
  158.  
  159.   The fast encoding method is probabilistic, so it's possible for the size
  160.   penalty to be worse than 1%, and it's also possible for the fast encoding
  161.   to produce a smaller result than base 85 encoding would, all depending on
  162.   the data.
  163.  
  164.   The -q option can be used with either ship or unship (ship -u) for quiet
  165.   operation--informational messages are inhibited.
  166.  
  167.   You can find out the version of ship and get the command usage by using
  168.   "ship -h" or "ship -?".  The version number and date and help will be
  169.   printed, and ship will exit (the rest of the command line is ignored).
  170.  
  171.   Acknowledgements:
  172.  
  173.   The hard-arithmetic coding algorithm was blatantly stolen from Peter
  174.   Gutmann's pgencode/pgdecode programs posted on comp.compression, with
  175.   modifications to use 86 instead of 94 characters, and to make zeros encode
  176.   better than, rather than worse than other bytes.  (As Stravinsky once said:
  177.   "Mediocre composers plagiarize.  Great composers steal.")
  178.  
  179. */
  180.  
  181. /* tailor.h -- Not copyrighted 1991 Mark Adler */
  182.  
  183. /* const's are inconsistently used across ANSI libraries--kill for all
  184.    header files. */
  185. #define const
  186.  
  187.  
  188. /* Use prototypes and ANSI libraries if __STDC__ */
  189. #ifdef __STDC__
  190. #  ifndef PROTO
  191. #    define PROTO
  192. #  endif /* !PROTO */
  193. #  define MODERN
  194. #endif /* __STDC__ */
  195.  
  196.  
  197. /* Use prototypes and ANSI libraries if Silicon Graphics */
  198. #ifdef sgi
  199. #  ifndef PROTO
  200. #    define PROTO
  201. #  endif /* !PROTO */
  202. #  define MODERN
  203. #endif /* sgi */
  204.  
  205.  
  206. /* Define MSDOS for Turbo C as well as Microsoft C */
  207. #ifdef __POWERC                 /* For Power C too */
  208. #  define __TURBOC__
  209. #endif /* __POWERC */
  210. #ifdef __TURBOC__
  211. #  ifndef MSDOS
  212. #    define MSDOS
  213. #  endif /* !MSDOS */
  214. #endif /* __TURBOC__ */
  215.  
  216.  
  217. /* Use prototypes and ANSI libraries if Microsoft or Borland C */
  218. #ifdef MSDOS
  219. #  ifndef PROTO
  220. #    define PROTO
  221. #  endif /* !PROTO */
  222. #  define MODERN
  223. #endif /* MSDOS */
  224.  
  225.  
  226. /* Turn off prototypes if requested */
  227. #ifdef NOPROTO
  228. #  ifdef PROTO
  229. #    undef PROTO
  230. #  endif /* PROTO */
  231. #endif /* NOPROT */
  232.  
  233.  
  234. /* Used to remove arguments in function prototypes for non-ANSI C */
  235. #ifdef PROTO
  236. #  define OF(a) a
  237. #else /* !PROTO */
  238. #  define OF(a) ()
  239. #endif /* ?PROTO */
  240.  
  241.  
  242. /* Allow far and huge allocation for small model (Microsoft C or Turbo C) */
  243. #ifdef MSDOS
  244. #  ifdef __TURBOC__
  245. #    include <alloc.h>
  246. #  else /* !__TURBOC__ */
  247. #    include <malloc.h>
  248. #    define farmalloc _fmalloc
  249. #    define farfree   _ffree
  250. #  endif /* ?__TURBOC__ */
  251. #else /* !MSDOS */
  252. #  define huge
  253. #  define far
  254. #  define near
  255. #  define farmalloc malloc
  256. #  define farfree   free
  257. #endif /* ?MSDOS */
  258.  
  259.  
  260. /* Define MSVMS if either MSDOS or VMS defined */
  261. #ifdef MSDOS
  262. #  define MSVMS
  263. #else /* !MSDOS */
  264. #  ifdef VMS
  265. #    define MSVMS
  266. #  endif /* VMS */
  267. #endif /* ?MSDOS */
  268.  
  269.  
  270. /* Define void, voidp, and extent (size_t) */
  271. #include <stdio.h>
  272. #ifdef MODERN
  273. #  if !defined(M_XENIX) && !(defined(__GNUC__) && defined(sun))
  274. #    include <stddef.h>
  275. #  endif
  276. #  include <stdlib.h>
  277.    typedef size_t extent;
  278.    typedef void voidp;
  279. #else /* !MODERN */
  280.    typedef unsigned int extent;
  281. #  define void int
  282.    typedef char voidp;
  283. #endif /* ?MODERN */
  284.  
  285. /* Get types and stat */
  286. #ifdef VMS
  287. #  include <types.h>
  288. #  include <stat.h>
  289. #else /* !VMS */
  290. #  include <sys/types.h>
  291. #  include <sys/stat.h>
  292. #endif /* ?VMS */
  293.  
  294.  
  295. /* Cheap fix for unlink on VMS */
  296. #ifdef VMS
  297. #  define unlink delete
  298. #endif /* VMS */
  299.  
  300.  
  301. /* For Pyramid */
  302. #ifdef pyr
  303. #  define strrchr rindex
  304. #  define ZMEM
  305. #endif /* pyr */
  306.  
  307.  
  308. /* File operations--use "b" for binary if allowed */
  309. #ifdef MODERN
  310. #  define FOPR "rb"
  311. #  define FOPM "r+b"
  312. #  define FOPW "w+b"
  313. #else /* !MODERN */
  314. #  define FOPR "r"
  315. #  define FOPM "r+"
  316. #  define FOPW "w+"
  317. #endif /* ?MODERN */
  318.  
  319.  
  320. /* Fine tuning */
  321. #ifndef MSDOS
  322. #   define BSZ 8192   /* Buffer size for files */
  323. #else /* !MSDOS */
  324. #   define BSZ 4096   /* Keep precious NEAR space */
  325.     /* BSZ can't be 8192 even for compact model because of 64K limitation
  326.      * in im_lmat.c. If you run out of memory when processing a large number
  327.      * files, use the compact model and reduce BSZ to 2048 here and in
  328.      * im_lm.asm.
  329.      */
  330. #endif /* ?MSDOS */
  331.  
  332. /* end of tailor.h */
  333.  
  334. #ifdef MODERN
  335. #  include <string.h>
  336. #else /* !MODERN */
  337.    voidp *malloc();
  338.    long atol();
  339.    char *strcpy();
  340.    char *strrchr();
  341. #endif /* ?MODERN */
  342.  
  343. /* Library functions not in (most) header files */
  344. char *mktemp OF((char *));
  345. int unlink OF((char *));
  346.  
  347. #ifdef MSDOS            /* Use binary mode for binary files */
  348. #  include <io.h>
  349. #  include <fcntl.h>
  350. #endif /* MSDOS */
  351.  
  352.  
  353. #define LNSZ 1025       /* size of line buffer */
  354.  
  355. typedef unsigned long ulg;      /* 32-bit unsigned integer */
  356.  
  357. typedef struct {        /* associates a CRC with a file */
  358.   FILE *f;              /* pointer to associated file stream */
  359.   ulg c;                /* CRC register */
  360.   ulg b;                /* four byte buffer */
  361.   int n;                /* buffer count */
  362. } cfile;
  363.  
  364.  
  365. /* Function prototypes */
  366. #ifdef MODERN
  367.    void err(int, char *);
  368.    cfile *chook(FILE *);
  369.    char *nopath(char *);
  370.    void newship(void);
  371.    void endship(int);
  372.    void newline(char *);
  373.    void ship(char *, FILE *);
  374.    void mkinv(void);
  375.    void decode(unsigned char *, cfile *);
  376.    void unship(char **, int, int);
  377.    void help(void);
  378.    void main(int, char **);
  379. #endif /* MODERN */
  380.  
  381.  
  382.  
  383. /* Globals for ship() */
  384. char sname[9];          /* current ship file name */
  385. FILE *sfile;            /* current ship file */
  386. ulg slns;               /* number of lines written to ship file */
  387. ulg slmax;              /* maximum number of lines per ship file */
  388. int fast;               /* true for arithmetic coding, else base 85 */
  389. int mail;               /* true if mailing */
  390. char mpspc[9];          /* prealloced space for prefix */
  391. char *mprefix = mpspc;  /* identification for this mailing */
  392. char *mdest;            /* mail destination */
  393. char mname[10];         /* temporary file name if mailing */
  394. ulg ccnt;               /* count of bytes read or written */
  395. int noisy = 1;          /* false to inhibit informational messages */
  396.  
  397.  
  398.  
  399. /* Errors */
  400. #define SE_ARG 1
  401. #define SE_FIND 2
  402. #define SE_NONE 3
  403. #define SE_PART 4
  404. #define SE_FORM 5
  405. #define SE_CONT 6
  406. #define SE_CRC 7
  407. #define SE_MAIL 8
  408. #define SE_OVER 9
  409. #define SE_FULL 10
  410. #define SE_MANY 11
  411. #define SE_MEM 12
  412. char *errors[] = {
  413.   /* 1 */ "invalid argument ",
  414.   /* 2 */ "could not find ",
  415.   /* 3 */ "no files received",
  416.   /* 4 */ "unfinished file ",
  417.   /* 5 */ "invalid ship format in ",
  418.   /* 6 */ "wrong sequence for ",
  419.   /* 7 */ "CRC check failed on ",
  420.   /* 8 */ "mail command failed: ",
  421.   /* 9 */ "attempted to overwrite ",
  422.   /* 10 */ "could not write to ",
  423.   /* 11 */ "too many output files!",
  424.   /* 12 */ "out of memory"
  425. };
  426.  
  427.  
  428. /* Set of 86 characters used for the base 85 digits (last one not used), and
  429.    the 86 character arithmetic coding.  Selected to be part of both the ASCII
  430.    printable characters, and the common EBCDIC printable characters whose
  431.    ASCII translations are universal. */
  432. unsigned char safe[] = {
  433.         '{','"','#','$','%','&','\'','(',')','*','+',',','-','.','/',
  434.         '0','1','2','3','4','5','6','7','8','9',':',';','<','=','>','?','@',
  435.         'A','B','C','D','E','F','G','H','I','J','K','L','M',
  436.         'N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_',
  437.         'a','b','c','d','e','f','g','h','i','j','k','l','m',
  438.         'n','o','p','q','r','s','t','u','v','w','x','y','z','}'};
  439.  
  440. #define LOWSZ (sizeof(safe)-64)         /* low set size for fast coding */
  441.  
  442. /* Special replacement pairs--if first of each pair is received, it is
  443.    treated like the second member of the pair.  You're probably
  444.    wondering why.  The first pair is for compatibility with an
  445.    earlier version of ship that used ! for the base 85 zero digit.
  446.    However, there exist ASCII-EBCDIC translation tables that don't
  447.    know about exclamation marks.  The second set has mysterious
  448.    historical origins that are best left unspoken ... */
  449. unsigned char aliases[] = {'!','{','|','+',0};
  450.  
  451. /* Inverse of safe[], filled in by mkinv() */
  452. unsigned char invsafe[256];
  453.  
  454. /* Table of CRC-32's of all single byte values (made by makecrc.c) */
  455. ulg crctab[] = {
  456.   0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
  457.   0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
  458.   0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
  459.   0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
  460.   0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
  461.   0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
  462.   0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
  463.   0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
  464.   0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
  465.   0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
  466.   0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
  467.   0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
  468.   0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
  469.   0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
  470.   0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
  471.   0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
  472.   0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
  473.   0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
  474.   0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
  475.   0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
  476.   0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
  477.   0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
  478.   0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
  479.   0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
  480.   0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
  481.   0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
  482.   0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
  483.   0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
  484.   0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
  485.   0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
  486.   0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
  487.   0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
  488.   0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
  489.   0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
  490.   0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
  491.   0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
  492.   0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
  493.   0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
  494.   0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
  495.   0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
  496.   0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
  497.   0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
  498.   0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
  499.   0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
  500.   0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
  501.   0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
  502.   0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
  503.   0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
  504.   0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
  505.   0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
  506.   0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
  507.   0x2d02ef8dL
  508. };
  509.  
  510. /* Macro to update the CRC shift register one byte at a time */
  511. #define CRC(c,b) (crctab[((int)(c)^(int)(b))&0xff]^((c)>>8))
  512.  
  513.  
  514. char *errname = "ship error";
  515. char *warname = "ship warning";
  516.  
  517. void err(n, m)
  518. int n;                  /* error number */
  519. char *m;                /* additional error information */
  520. {
  521.   if (n == SE_FIND || n == SE_FULL)
  522.     perror(errname);
  523.   fputs(errname, stderr);
  524.   fputs(": ", stderr);
  525.   fputs(errors[n - 1], stderr);
  526.   fputs(m, stderr);
  527.   putc('\n', stderr);
  528.   if (*mname)
  529.     unlink(mname);
  530. #ifdef VMS
  531.   exit(0);
  532. #else /* !VMS */
  533.   exit(n);
  534. #endif /* ?VMS */
  535. }
  536.  
  537.  
  538. cfile *chook(f)
  539. FILE *f;                /* file stream */
  540. /* Inherit the file stream structure and add a CRC and buffer for appending
  541.    a CRC on reads and checking the CRC on writes.  Return a pointer to the
  542.    cfile structure, or NULL if the malloc() failed.  Also, if MSDOS, set the
  543.    file mode to binary to avoid LF<->CRLF conversions. */
  544. {
  545.   cfile *c;             /* allocated cfile structure */
  546.  
  547. #ifdef MSDOS
  548.   /* Set file mode to binary for MSDOS systems */
  549.   setmode(fileno(f), O_BINARY);
  550. #endif /* MSDOS */
  551.  
  552.   /* Allocate and fill structure */
  553.   if ((c = (cfile *)malloc(sizeof(cfile))) != NULL)
  554.   {
  555.     c->f = f;                           /* file stream */
  556.     c->b = 0;                           /* empty fifo (for output) */
  557.     c->c = 0xffffffffL;                 /* preload CRC register */
  558.     c->n = 0;                           /* fifo is empty (output) or */
  559.   }                                     /*  no CRC bytes given (input) */
  560.   return c;
  561. }
  562.  
  563.  
  564.  
  565. /* cgetc(x)--like getc(f), but appends a 32-bit CRC to the end of the stream.
  566.    Return the byte read (the last four of which will be the CRC) or EOF. */
  567. #define cgete(x) (x->n==4?EOF:(x->c=x->n++?x->c>>8:~x->c,(int)x->c&0xff))
  568. #define cgetc(x) (x->n==0&&(b=getc(x->f))!=EOF?(ccnt++,x->c=CRC(x->c,b),b):cgete(c))
  569.  
  570.  
  571. /* cputc(d,x)--like putc(d,f), but delays four bytes and computes a CRC.
  572.    x is a cfile *, and d is expected to be an ulg. */
  573. #define cputf(x) (int)(x->c=CRC(x->c,x->b),putc((int)x->b&0xff,x->f),ccnt++)
  574. #define cputc(d,x) (x->n!=4?x->n++:cputf(x),x->b=(x->b>>8)+((ulg)(d)<<24))
  575.  
  576.  
  577. char *nopath(p)
  578. char *p;                /* full file name */
  579. /* Extract just the name of file--remove and subdirectories or devices */
  580. {
  581. #ifdef MSDOS
  582.   char *q = "/\\:";     /* MSDOS delimiters */
  583. #else /* !MSDOS */
  584. #ifdef VMS
  585.   char *q = "]:";       /* VMS delimiters */
  586. #else /* !VMS */
  587.   char *q = "/";        /* Unix delimiter */
  588. #endif /* ?VMS */
  589. #endif /* ?MSDOS */
  590.   char *r;              /* result of strrchr() */
  591.  
  592.   while (*q)
  593.     if ((r = strrchr(p, *q++)) != NULL)
  594.       p = r + 1;
  595.   return p;
  596. }
  597.  
  598.  
  599. void newship()
  600. /* Open up a new ship file to write to */
  601. {
  602.   int i;                /* scans down name to increment */
  603.  
  604.   for (i = 7; i > 3; i--)
  605.     if (++sname[i] > '9')
  606.       sname[i] = '0';
  607.     else
  608.       break;
  609.   if (i == 3)
  610.     err(SE_MANY, "");
  611.   if ((sfile = fopen(mail ? mktemp(strcpy(mname, TMPNAME)) : sname,
  612.                      "w")) == NULL)
  613.     err(SE_FULL, mail ? mname : sname);
  614.   slns = 0;
  615. }
  616.  
  617.  
  618. void endship(e)
  619. int e;          /* true if ending the last ship file */
  620. /* Finish off current ship file */
  621. {
  622.   char *s;              /* malloc'd space for mail command */
  623.  
  624.   if (ferror(sfile) || fclose(sfile))
  625.     err(SE_FULL, mail ? mname : sname);
  626.   if (mail)
  627.   {
  628.     if ((s = malloc(strlen(MAILCMD)- 5*2 + strlen(mprefix) + strlen(sname) +
  629.                     (e ? 7 : 0) + strlen(mdest) + strlen(mname) + 1)) == NULL)
  630.       err(SE_MEM, "");
  631. #ifdef VMS
  632.     sprintf(s, MAILCMD, mname, mprefix, sname, e ? " (last)" : "", mdest);
  633.     if (!system(s))             /* this string fits on one line */
  634.       err(SE_MAIL, "system() call is not supported on this machine");
  635. #else /* !VMS */
  636.     sprintf(s, MAILCMD, mprefix, sname, e ? " (last)" : "", mdest, mname);
  637.     if (system(s))
  638.       err(SE_MAIL, s);
  639. #endif /* ?VMS */
  640.     free((voidp *)s);
  641.     unlink(mname);
  642.     *mname = 0;
  643.   }
  644. }
  645.  
  646.  
  647. void newline(p)
  648. char *p;                /* name of the input file */
  649. /* Add a new line inside a ship file, possibly cut the file */
  650. {
  651.   putc('\n', sfile);
  652.   slns++;
  653.   if (slmax && slns >= slmax - 2)
  654.   {
  655.     putc('$', sfile);
  656.     if (fast)
  657.       fputs(" f", sfile);
  658.     fputs("\nmore\n", sfile);
  659.     endship(0);
  660.     newship();
  661.     fprintf(sfile, "$%s\ncont %lu %s\n", fast ? " f" : "", ccnt, nopath(p));
  662.     slns += 2;
  663.   }
  664. }
  665.  
  666.  
  667. /* Macro to avoid leading dots.  It assumes i==0 at the beginning of a line
  668.    and that b is an available int.  c is only evaluated once. */
  669. #define sputc(c,f) (i==0?((b=(c))=='.'?putc(' ',f):0,putc(b,f)):putc(c,f))
  670.  
  671.  
  672. void ship(p, f)
  673. char *p;                /* name of the input file */
  674. FILE *f;                /* input file */
  675. /* Encode the binary file f. */
  676. {
  677.   int b;                /* character just read */
  678.   cfile *c;             /* checked file stream */
  679.   int i;                /* how much is written on line so far */
  680.   int j;                /* how much is in bit buffer */
  681.  
  682.   /* Set up output file if needed */
  683.   if ((mail || slmax) && sfile == stdout)
  684.   {
  685.     strcpy(sname, "part0000");
  686.     newship();
  687.   }
  688.  
  689.   /* Write header */
  690.   if ((c = chook(f)) == NULL)
  691.     err(SE_MEM, "");
  692.   ccnt = 0;
  693.   if (slmax && slns >= slmax - 5) 
  694.   {
  695.     endship(0);
  696.     newship();
  697.   }
  698.   fprintf(sfile, "$%s\nship %s\n", fast ? " f" : "", nopath(p));
  699.   slns += 2;
  700.  
  701.   /* Encode the file, writing to sfile */
  702.   if (fast)
  703.   {
  704.     int d;              /* accumulates bits (never more than 14) */
  705.  
  706.     d = j = i = 0;
  707.     while ((b = cgetc(c)) != EOF)
  708.     {
  709.       d |= b << j;
  710.       j += 8;
  711.       if ((d & 0x3f) >= LOWSZ)
  712.       {
  713.         sputc((int)(safe[(d & 0x3f) + LOWSZ]), sfile);
  714.         d >>= 6;
  715.         j -= 6;
  716.       }
  717.       else
  718.       {
  719.         sputc((int)(safe[(d & 0x3f) + (d & 0x40 ? LOWSZ : 0)]), sfile);
  720.         d >>= 7;
  721.         j -= 7;
  722.       }
  723.       if (++i == 79)
  724.       {
  725.         newline(p);
  726.         i = 0;
  727.       }
  728.       if (j >= 6 && (d & 0x3f) >= LOWSZ)
  729.       {
  730.         sputc((int)(safe[(d & 0x3f) + LOWSZ]), sfile);
  731.         d >>= 6;
  732.         j -= 6;
  733.         if (++i == 79)
  734.         {
  735.           newline(p);
  736.           i = 0;
  737.         }
  738.       }
  739.       else if (j >= 7)
  740.       {
  741.         sputc((int)(safe[(d & 0x3f) + (d & 0x40 ? LOWSZ : 0)]), sfile);
  742.         d >>= 7;
  743.         j -= 7;
  744.         if (++i == 79)
  745.         {
  746.           newline(p);
  747.           i = 0;
  748.         }
  749.       }
  750.     }
  751.     free((voidp *)c);
  752.  
  753.     /* Write leftover bits */
  754.     if (j)
  755.     {
  756.       sputc((int)(safe[d + (d < LOWSZ ? 0 : LOWSZ)]), sfile);
  757.       putc('\n', sfile);
  758.       slns++;
  759.     }
  760.     else if (i)
  761.     {
  762.       putc('\n', sfile);
  763.       slns++;
  764.     }
  765.   }
  766.   else
  767.   {
  768.     ulg d;              /* accumulates bytes */
  769.  
  770.     d = j = i = 0;
  771.     while ((b = cgetc(c)) != EOF)
  772.     {
  773.       d += ((ulg)b) << j;
  774.       if ((j += 8) == 32)
  775.       {
  776.         sputc((int)(safe[(int)(d % 85)]), sfile);  d /= 85;
  777.         putc((int)(safe[(int)(d % 85)]), sfile);  d /= 85;
  778.         putc((int)(safe[(int)(d % 85)]), sfile);  d /= 85;
  779.         putc((int)(safe[(int)(d % 85)]), sfile);  d /= 85;
  780.         putc((int)(safe[(int)d]), sfile);
  781.         if (++i == 15)                  /* each line is <= 75 characters */
  782.         {
  783.           newline(p);
  784.           i = 0;
  785.         }
  786.         d = j = 0;
  787.       }
  788.     }
  789.     free((voidp *)c);
  790.   
  791.     /* Write leftover data */
  792.     if (j)
  793.     {
  794.       j >>= 3;
  795.       sputc((int)(safe[(int)(d % 85)]), sfile);
  796.       while (j--)
  797.       {
  798.         d /= 85;
  799.         putc((int)(safe[(int)(d % 85)]), sfile);
  800.       }
  801.       putc('\n', sfile);
  802.       slns++;
  803.     }
  804.     else if (i)
  805.     {
  806.       putc('\n', sfile);
  807.       slns++;
  808.     }
  809.   }
  810.   putc('$', sfile);
  811.   if (fast)
  812.     fputs(" f", sfile);
  813.   fputs("\nend\n", sfile);
  814.   slns += 2;
  815.   if (ferror(sfile) || fflush(sfile))
  816.     err(SE_FULL, mail ? mname : sname);
  817.   if (noisy)
  818.     fprintf(stderr, "%s shipped\n", p);
  819. }
  820.  
  821.  
  822. void mkinv()
  823. /* Build invsafe[], the inverse of safe[]. */
  824. {
  825.   int i;
  826.  
  827.   for (i = 0; i < 256; i++)
  828.     invsafe[i] = 127;
  829.   for (i = 0; i < sizeof(safe); i++)
  830.     invsafe[safe[i]] = (char)i;
  831.   for (i = 0; aliases[i]; i += 2)
  832.     invsafe[aliases[i]] = invsafe[aliases[i + 1]];
  833. }
  834.  
  835.  
  836. unsigned int decb;      /* bit buffer for decode */
  837. unsigned int decn;      /* number of bits in decb */
  838.  
  839. void decode(s, c)
  840. unsigned char *s;       /* data to decode */
  841. cfile *c;               /* binary output file */
  842. /* Decode s, a string of base 85 digits or, if fast is true, a string of safe
  843.    characters generated arithmetically, into its binary equivalent, writing
  844.    the result to c, using cputc(). */
  845. {
  846.   int b;                /* state of line loop, next character */
  847.   int k;                /* counts bits or digits read */
  848.   /* powers of 85 table for decoding */
  849.   static ulg m[] = {1L,85L,85L*85L,85L*85L*85L,85L*85L*85L*85L};
  850.  
  851.   if (fast)
  852.   {
  853.     unsigned int d;     /* disperses bits */
  854.  
  855.     d = decb;
  856.     k = decn;
  857.     while ((b = *s++) != 0)
  858.       if ((b = invsafe[b]) < sizeof(safe))
  859.       {
  860.         if (b < LOWSZ)
  861.         {
  862.           d |= b << k;
  863.           k += 7;
  864.         }
  865.         else if ((b -= LOWSZ) < LOWSZ)
  866.         {
  867.           d |= (b + 0x40) << k;
  868.           k += 7;
  869.         }
  870.         else
  871.         {
  872.           d |= b << k;
  873.           k += 6;
  874.         }
  875.         if (k >= 8)
  876.         {
  877.           cputc(d, c);
  878.           d >>= 8;
  879.           k -= 8;
  880.         }
  881.       }
  882.     decb = d;
  883.     decn = k;
  884.   }
  885.   else
  886.   {
  887.     ulg d;              /* disperses bytes */
  888.  
  889.     d = k = 0;
  890.     while ((b = *s++) != 0)
  891.       if ((b = invsafe[b]) < 85)
  892.       {
  893.         d += m[k] * b;
  894.         if (++k == 5)
  895.         {
  896.           cputc(d, c);  d >>= 8;
  897.           cputc(d, c);  d >>= 8;
  898.           cputc(d, c);  d >>= 8;
  899.           cputc(d, c);
  900.           d = k = 0;
  901.         }
  902.       }
  903.     if (--k > 0)
  904.     {
  905.       while (--k)
  906.       {
  907.         cputc(d, c);
  908.         d >>= 8;
  909.       }
  910.       cputc(d, c);
  911.     }
  912.   }
  913. }
  914.  
  915.  
  916. void unship(v, g, o)
  917. char **v;               /* arguments */
  918. int g;                  /* number of arguments */
  919. int o;                  /* overwrite flag */
  920. /* Extract from the files named in the arguments the files that were
  921.    encoded by ship.  If an argument is "-", then stdin is read. */
  922. {
  923.   int b;                /* state of line loop */
  924.   cfile *c;             /* output binary file */
  925.   FILE *f;              /* output file */
  926.   char *h;              /* name of current ship file */
  927.   char l[LNSZ];         /* line buffer on input */
  928.   int n;                /* next argument to use for input */
  929.   char *p;              /* modifies line buffer */
  930.   char *q;              /* scans continuation line */
  931.   char *r;              /* name of output binary file */
  932.   FILE *s;              /* current ship file */
  933.   int z;                /* true if zero files received */
  934.  
  935.   /* Build inverse table */
  936.   mkinv();
  937.  
  938.   /* No input or output files initially */
  939.   s = NULL;
  940.   c = NULL;
  941.   h = r = NULL;
  942.  
  943.   /* Loop on input files' lines */
  944.   z = 1;                                /* none received yet */
  945.   n = 0;                                /* start with file zero */
  946.   b = 2;                                /* not in body yet */
  947.   while (1)                             /* return on end of last file */
  948.   {
  949.     /* Get next line from list of files */
  950.     while (s == NULL || fgets(l, LNSZ, s) == NULL)
  951.     {
  952.       if (s != NULL)
  953.         fclose(s);
  954.       if (n >= g)
  955.       {
  956.         if (c != NULL)
  957.           err(SE_PART, r);
  958.         else if (z)
  959.           err(SE_NONE, "");
  960.         return;
  961.       }
  962.       if (v[n][0] == '-')
  963.         if (v[n][1])
  964.           err(SE_ARG, v[n]);
  965.         else
  966.         {
  967.           h = "stream stdin";
  968.           s = stdin;
  969.         }
  970.       else
  971.       {
  972.         h = v[n];
  973.         if ((s = fopen(h, "r")) == NULL)
  974.           err(SE_FIND, h);
  975.       }
  976.       n++;
  977.       b &= ~1;                          /* not in middle of line */
  978.     }
  979.  
  980.     /* Strip control characters and leading blank space, if any */
  981.     for (q = l; *q && *q <= ' ' && *q != '\n'; q++)
  982.       ;
  983.     for (p = l; *q; q++)
  984.       if (*q >= ' ' || *q == '\n')
  985.         *p++ = *q;
  986.     *p = 0;
  987.  
  988.     /* Based on current state, end or start on terminator.  States are:
  989.          b == 0:  at start of body or body terminator line
  990.          b == 1:  in middle of body line
  991.          b == 2:  at start of non-body line
  992.          b == 3:  in middle of non-body line
  993.          b == 4:  at information line
  994.     */
  995.     switch (b)
  996.     {
  997.     case 0:
  998.       if ((!fast && strcmp(l, "$\n") == 0) ||
  999.           (fast && strcmp(l, "$ f\n") == 0))
  1000.       {
  1001.         b = 4;
  1002.         break;
  1003.       }
  1004.       /* fall through to case 1 */
  1005.     case 1:
  1006.       decode((unsigned char *)l, c);
  1007.       b = l[strlen(l) - 1] != '\n';
  1008.       break;
  1009.     case 2:
  1010.       if (strcmp(l, "$\n") == 0 || strcmp(l, "$ f\n") == 0)
  1011.       {
  1012.         fast = l[1] == ' ';
  1013.         b = 4;
  1014.         break;
  1015.       }
  1016.       /* fall through to case 3 */
  1017.     case 3:
  1018.       b = l[strlen(l)-1] == '\n' ? 2 : 3;
  1019.       break;
  1020.     case 4:
  1021.       /* Possible information lines are ship, more, cont, and end */
  1022.       if (l[b = strlen(l) - 1] != '\n')
  1023.         err(SE_FORM, h);
  1024.       l[b] = 0;
  1025.       if (strncmp(l, "ship ", 5) == 0)
  1026.       {
  1027.         /* get name, open new output file */
  1028.         if (c != NULL)
  1029.           err(SE_FORM, h);
  1030.         if ((r = malloc(b - 4)) == NULL)
  1031.           err(SE_MEM, "");
  1032.         strcpy(r, l + 5);
  1033.         if (strcmp(r, "-") == 0)
  1034.           f = stdout;
  1035. #ifndef VMS     /* shouldn't have explicit version #, so VMS won't overwrite */
  1036.         else if (!o && (f = fopen(r, "r")) != NULL)
  1037.         {
  1038.           fclose(f);
  1039.           err(SE_OVER, r);
  1040.         }
  1041. #endif /* !VMS */
  1042.         else if ((f = fopen(r, "w")) == NULL)
  1043.           err(SE_FULL, r);
  1044.         if ((c = chook(f)) == NULL)
  1045.           err(SE_MEM, "");
  1046.         b = decb = decn = 0;
  1047.         ccnt = 0;
  1048.       }
  1049.       else if (strcmp(l, "more") == 0)
  1050.       {
  1051.         /* check if currently writing */
  1052.         if (c == NULL)
  1053.           err(SE_FORM, h);
  1054.         b = 2;
  1055.       }
  1056.       else if (strncmp(l, "cont ", 5) == 0)
  1057.       {
  1058.         /* check name and file offset */
  1059.         if (c == NULL)
  1060.           err(SE_FORM, h);
  1061.         for (q = l + 5; *q && *q != ' '; q++)
  1062.           ;
  1063.         if (*q == 0 || atol(l + 5) != ccnt + 4 + (decn != 0) ||
  1064.             strcmp(q + 1, r))
  1065.           err(SE_CONT, r);
  1066.         b = 0;
  1067.       }
  1068.       else if (strcmp(l, "end") == 0)
  1069.       {
  1070.         /* check crc, close output file */
  1071.         if (c == NULL)
  1072.           err(SE_FORM, h);
  1073.         if (c->n != 4 || c->b != ~c->c)
  1074.           err(SE_CRC, r);
  1075.         if (ferror(c->f) || fclose(c->f))
  1076.           err(SE_FULL, r);
  1077.         if (noisy)
  1078.           fprintf(stderr, "%s received\n", r);
  1079.         z = 0;
  1080.         free((voidp *)c);
  1081.         c = NULL;
  1082.         b = 2;
  1083.       }
  1084.       else
  1085.       {
  1086.         for (q = l; *q && *q != ' '; q++)
  1087.           ;
  1088.         *q = 0;
  1089.         fprintf(stderr, "%s: unsupported keyword '%s' ignored\n", warname, l);
  1090.         b = 4;
  1091.       }
  1092.       break;
  1093.     }
  1094.   }
  1095. }
  1096.  
  1097.  
  1098. void help()
  1099. {
  1100.   int i;
  1101.   static char *text[] = {
  1102. "Usage:",
  1103. "   ship [-f] [-q] [-nnn] [-m address] [-s subject] files...",
  1104. "",
  1105. "   ships the files to stdout.  -m sends the output via the mailer to",
  1106. "   address.  -nnn splits the output into pieces of nnnK bytes or less.",
  1107. "   if -nnn is used without -m, the output goes to the files partxxxx,",
  1108. "   where xxxx is 0001, 0002, etc.  If -0 is specified, the output goes",
  1109. "   entirely to the file part0001.  -f uses a fast method with slightly",
  1110. "   less performance.  If no files are given, stdin is used.  The special",
  1111. "   filename '-' also takes input from stdin.  Files shipped from stdin",
  1112. "   are unshipped to stdout.  This can be used to document a shipment.",
  1113. "   When mailing, -s gives a subject line prefix.  -q inhibits messages.",
  1114. "",
  1115. "   ship -u [-o] [-q] files...",
  1116. "   unship  [-o] [-q] files...",
  1117. "",
  1118. "   extracts the contents of the mail messages in files...  -o allows",
  1119. "   existing files to be overwritten.  -u is implied if the name of the",
  1120. "   executable is unship.  If no files are given, the input is from",
  1121. "   stdin.  If any of the files were shipped from stdin, then they are",
  1122. "   extracted to stdout."
  1123.   };
  1124.  
  1125.   puts(SHIPVER);
  1126.   for (i = 0; i < sizeof(text)/sizeof(char *); i++)
  1127.   {
  1128.     printf(text[i]);
  1129.     putchar('\n');
  1130.   }
  1131.   exit(0);
  1132. }
  1133.  
  1134.  
  1135. void main(argc, argv)
  1136. int argc;               /* number of arguments */
  1137. char **argv;            /* table of argument strings */
  1138. {
  1139.   FILE *f;              /* input file */
  1140.   ulg k;                /* number of k requested per part */
  1141.   char *p;              /* temporary variable */
  1142.   int o;                /* overwrite flag */
  1143.   int r;                /* temporary variable */
  1144.   int s;                /* true if no names given */
  1145.  
  1146.   /* No temporary file yet (for err()) */
  1147.   *mname = 0;
  1148.  
  1149.   /* No subject prefix yet */
  1150.   *mprefix = 0;
  1151.  
  1152.   /* See if help requested */
  1153.   if (argc > 1 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-?") == 0))
  1154.     help();
  1155.  
  1156.   /* Unship */
  1157.   if ((p = strrchr(argv[0], PATHCUT)) == NULL)
  1158.     p = argv[0];
  1159.   else
  1160.     p++;
  1161.   r = 0;                                /* (make some compilers happier) */
  1162.   if ((r = strncmp(p, "unship", 6)) == 0 ||
  1163.       (r = strncmp(p, "UNSHIP", 6)) == 0 ||
  1164.       (argc > 1 && strcmp(argv[1], "-u") == 0))
  1165.   {
  1166.     errname = "unship error";
  1167.     warname = "unship warning";
  1168.     r = r ? 2 : 1;                      /* next arg */
  1169.     o = 0;                              /* disallow overwriting */
  1170.     if (r < argc && strcmp(argv[r], "-o") == 0)
  1171.     {
  1172.       r++;
  1173.       o = 1;                            /* allow overwriting */
  1174.     }
  1175.     if (r < argc && strcmp(argv[r], "-q") == 0)
  1176.     {
  1177.       r++;
  1178.       noisy = 0;                        /* inhibit messages */
  1179.     }
  1180.     if (r < argc)
  1181.       unship(argv + r, argc - r, o);    /* unship files in args */
  1182.     else
  1183.     {
  1184.       char *a[1];       /* short list of names (one) */
  1185.  
  1186.       a[0] = "-";
  1187.       unship(a, 1, o);                  /* no args--do stdin */
  1188.     }
  1189.   }
  1190.  
  1191.   /* Ship */
  1192.   else
  1193.   {
  1194.     mail = 0;                           /* not mailing */
  1195.     fast = 0;                           /* use base 85 encoding */
  1196.     s = 1;                              /* no names given yet */
  1197.     strcpy(sname, "-");                 /* output to stdout */
  1198.     sfile = stdout;
  1199.     slns = slmax = k = 0;
  1200.     for (r = 1; r < argc; r++)          /* go through args */
  1201.       if (argv[r][0] == '-')            /* option or stdin */
  1202.         if (argv[r][1])                 /* option */
  1203.         {
  1204.           if (argv[r][1] == 'm')        /* mail output */
  1205.           {
  1206.             mail = 1;
  1207.             mdest = NULL;               /* next arg is mail address */
  1208.           }
  1209.           else if (argv[r][1] == 's')   /* next arg is subject prefix */
  1210.             mprefix = NULL;
  1211.           else if (argv[r][1] == 'f')   /* fast arithmetic encoding */
  1212.           {
  1213.             fast = 1;
  1214.             if (k)                      /* recompute slmax if needed */
  1215.               slmax = 4 + (k * 1024L) / 81;
  1216.           }
  1217.           else if (argv[r][1] == 'q')   /* quiet operation */
  1218.             noisy = 0;
  1219.           else                          /* option is number of lines */
  1220.           {
  1221.             /* Check numeric option */
  1222.             for (p = argv[r] + 1; *p; p++)
  1223.               if (*p < '0' || *p > '9')
  1224.                 break;
  1225.             if (*p || slmax)
  1226.               err(SE_ARG, argv[r]);
  1227.   
  1228.             /* Zero means infinity, else convert */
  1229.             if ((k = atol(argv[r] + 1)) == 0)
  1230.               slmax = -1L;
  1231.             else
  1232.               slmax = 4 + (k * 1024L) / (fast ? 81 : 77);
  1233.           }
  1234.         }
  1235.         else                            /* input file is stdin */
  1236.         {
  1237.           if (mail && mdest == NULL)
  1238.             err(SE_ARG, "- (no mail destination given)");
  1239.           s = 0;
  1240.           if (mail && !*mprefix)
  1241.             strcpy(mprefix, "(stdin)");
  1242.           ship("-", stdin);
  1243.         }
  1244.       else                              /* not option or stdin */
  1245.         if (mail && mdest == NULL)      /* arg is mail address */
  1246.           mdest = argv[r];
  1247.         else if (mprefix == NULL)       /* arg is subject prefix */
  1248.           mprefix = argv[r];
  1249.         else                            /* arg is file to ship */
  1250.         {
  1251.           s = 0;
  1252.           if ((f = fopen(argv[r], "r")) == NULL)
  1253.             err(SE_FIND, argv[r]);
  1254.           if (mail && !*mprefix)
  1255.           {
  1256.             int i;
  1257.  
  1258.             for (i = 0, p = nopath(argv[r]); i < 8 && *p; p++)
  1259.               if ((*p >= '0' && *p <= '9') || (*p >= 'A' && *p <= 'Z') ||
  1260.                   (*p >= 'a' && *p <= 'z') || *p == '.' || *p == '_')
  1261.                 mprefix[i++] = *p;
  1262.             mprefix[i] = 0;
  1263.           }
  1264.           ship(argv[r], f);
  1265.           fclose(f);
  1266.         }
  1267.     if (s)                              /* no names--act as filter */
  1268.       if (mail && mdest == NULL)
  1269.         err(SE_ARG, "-m (no mail destination given)");
  1270.       else if (mprefix == NULL)
  1271.         err(SE_ARG, "-s (no subject prefix given)");
  1272.       else
  1273.       {
  1274.         if (mail && !*mprefix)
  1275.           strcpy(mprefix, "(stdin)");
  1276.         ship("-", stdin);
  1277.       }
  1278.     endship(1);                         /* clean up */
  1279.     if (noisy && (mail || slmax))
  1280.       fprintf(stderr, "file%s%s %s\n",
  1281.               strcmp("part0001", sname) ? "s part0001.." : " ", sname,
  1282.               mail ? "mailed" : "written");
  1283.   }
  1284.  
  1285.   /* Done */
  1286.   exit(0);
  1287. }
  1288.