![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rbsb.sh CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / spitbol / cint|
Return to rbsb.sh CVS log | Up to [Research Unix] / researchv10no / cmd / spitbol / cint |
1.1 root 1: # This is a shell archive.
2: # Remove everything above and including the cut line.
3: # Then run the rest of the file through sh.
4: -----cut here-----cut here-----cut here-----cut here-----
5: #!/bin/sh
6: # shar: Shell Archiver
7: # Run the following text with /bin/sh to create:
8: # rb.1
9: # rb.c
10: # rbsb.c
11: # sb.1
12: # sb.c
13: # undos.1
14: # undos.c
15: # This archive created: Fri Jan 10 12:33:41 1986
16: cat << \SHAR_EOF > rb.1
17: '\" Revision Level
18: '\" Last Delta 12-16-85
19: .TH RB 1 OMEN
20: .SH NAME
21: rb \- YMODEM batch file receive
22: .SH SYNOPSIS
23: .B rb
24: [
25: .B \-bquv
26: ]
27: .PP
28: .B rb
29: [
30: .B \-bcquv
31: ]
32: .B file
33: .PP
34: .B [-][v]rbCOMMAND
35: .SH DESCRIPTION
36: .B Rb
37: receives 0 or more files in batch mode.
38: Iff
39: .B file
40: is speficied,
41: a single file is received in XMODEM single file mode.
42:
43: Normally, the file contents are converted to
44: .SM Unix
45: conventions by stripping carriage returns and all characters
46: beginning with Control Z (CP/M end of file).
47: If the raw pathname ends in
48: ".A",
49: ".ARC",
50: ".CCC",
51: ".CL",
52: ".CMD",
53: ".COM",
54: ".CRL",
55: ".DAT",
56: ".DIR",
57: ".EXE",
58: ".O",
59: ".OBJ",
60: ".OVL",
61: ".PAG",
62: ".REL",
63: ".SAV",
64: ".SUB",
65: ".SWP",
66: ".SYS",
67: ".TAR",
68: ".UTL",
69: ".a",
70: ".o",
71: ".tar",
72: or if the first sector contains
73: data that suggest a binary file
74: (parity bits or characters in the range 000 to 006 before the first ^Z),
75: or if the file mode is transmitted and the 0100000 bit is set,
76: that file will be received in binary mode anyway.
77:
78: Otherwise,
79: if the raw pathname ends in .MSG, or .TXT, any existing file will
80: be appended to rather than replaced.
81:
82: Normally, each file name is converted to lower case
83: unless it contains one or more lower case letters.
84:
85: Rb works with either standard 128 byte sectors or
86: 1024 byte sectors
87: (YAM
88: .B k
89: option).
90: The user should determine experimentally
91: the conditions under which use of 1k blocks
92: actually improves throughput without causing
93: problems.
94:
95: If extended file information (file length, etc.)
96: is received,
97: the file length controls the number of bytes written to
98: the output dataset,
99: and the modify time and file mode
100: (iff non zero)
101: are set accordingly.
102:
103: If no extended file information is received,
104: slashes in the pathname are changed to underscore,
105: and any trailing period in the pathname is eliminated.
106:
107: If rb is invoked with stdout and stderr to different datasets,
108: Verbose is set to 2, causing frame by frame progress reports
109: to stderr.
110: This may be disabled with the
111: .B q
112: option.
113:
114: If the SHELL environment variable includes
115: .I "rsh"
116: or
117: .I "rksh"
118: (restricted shell),
119: rb will not accept pathnames containing referenced to absolute paths
120: or to a parent directory, will not receive to an existing file, and
121: removes any files received in error.
122:
123: .PP
124: The meanings of the available options are:
125: .PP
126: .PD 0
127: .TP
128: .B b
129: transfer all files in binary
130: (tell it like it is)
131: mode.
132: This option disables any append mode special processing.
133: .TP
134: .B c
135: Request 16 bit cyclic redundancy check
136: (8 bit checksum default).
137: .TP
138: .B q
139: Quiet suppresses verbosity.
140: .TP
141: .B v
142: .IR Verbose
143: causes a list of file
144: names to be appended to
145: /tmp/rblog .
146: More v's generate more output.
147: .TP
148: .B u
149: Retain upper case letters in file names unconditionally.
150: .PD
151: .SH EXAMPLES
152: (
153: .SM Unix
154: command)
155: .RS
156: $rb
157: .br
158: rb: ready C
159: .br
160: .RE
161: (Pro-YAM command)
162: .RS
163: <F1>
164: .br
165: >>>c: sbt *.h *.c
166: .br
167: .RE
168: .SH SEE ALSO
169: YMODEM.DOC,
170: IMP(CP/M),
171: ncu(1),
172: Professional-YAM manual,
173: sb(omen),
174: usq(omen),
175: undos(omen)
176:
177: Compile time options for various operating systems are described in the
178: program source file.
179: .SH NOTES
180: If rb is invoked as
181: .B rbCOMMAND
182: (with an optional leading \- as generated by login(1)),
183: rb will pipe each received file to ``COMMAND filename''
184: (filename is the name of the transmitted file)
185: with the file contents as standard input.
186: A typical usage for this form is rbrmail which calls rmail
187: to post mail.
188: On some
189: .SM Unix
190: systems, the login directory must contain
191: COMMAND as login sets SHELL=rsh which disallows absolute
192: pathnames.
193: If invoked with a leading ``v'' rb will report progress to LOGFILE.
194: The following entry works for
195: .SM Unix
196: 3.0.
197: rbrmail::5:1::/bin:/usr/local/rbrmail
198: .PP
199: The following (in a shell script)
200: may be used to fetch file(s) from a remote computer connected to /dev/tty7
201: once sb has been started on the remote.
202: rb -v >/dev/tty7 </dev/tty7
203: .SH BUGS
204: Pathnames are restricted to 127 characters.
205:
206: In XMODEM single file mode, the pathname given on the command line
207: is still processed as described above.
208:
209: The CR/LF to NL translation merely deletes CR\'s;
210: undos(omen) performs a more intelligent translation.
211: .SH "VMS VERSION"
212: Some of the #includes with file names enclosed with angle brackets <>
213: may need to have the angle brackets removed, or vice versa.
214:
215: The VMS version does not set binary mode according to the incoming
216: file type.
217: Non binary file processing consists of stripping all characters beginning
218: with CPMEOF (^Z).
219:
220: The VMS version does not set the file time.
221:
222: VMS occaisonally loses incoming characters, resulting in retries
223: and degradation of throughput.
224:
225: There may be unknown interactions between the VMS C standard i/o
226: package and RMS.
227:
228: The VMS version does not support invocation as
229: .B rbCOMMAND .
230: SHAR_EOF
231: cat << \SHAR_EOF > rb.c
232: #define VERSION "2.17 12-07-85"
233: #define PUBDIR "/usr/spool/uucppublic"
234:
235: /*% cc -DUSG -DNFGVMIN -O -K % -o rb
236: *
237: * rb.c By Chuck Forsberg
238: *
239: * USG UNIX (3.0) ioctl conventions courtesy Jeff Martin
240: * cc -O -DV7 rb.c -o rb Unix V7, BSD 2.8 - 4.2
241: * cc -O -DUSG rb.c -o rb USG (3.0) Unix
242: * cc -o rb.c Regulus
243: * (Don't try this on Unix, you'll clobber the source!)
244: * Unix is a trademark of Western Electric Company
245: *
246: * Regulus conventions 1-10-83 CAF
247: *
248: * Some systems (Venix, Coherent, Regulus) do not support tty raw mode
249: * read(2) the same way as Unix. ONEREAD must be defined to force one
250: * character reads for these systems. Added 7-01-84 CAF
251: *
252: * Alarm signal handling changed to work with 4.2 BSD 7-15-84 CAF
253: *
254: * NFGVMIN Added 1-13-85 CAF for PC-AT Xenix systems where c_cc[VMIN]
255: * doesn't seem to work (even though it compiles without error!).
256: *
257: * A program for Unix which can receive
258: * files from computers running YAM or MODEM.
259: * rb uses Unix System III buffered input to reduce CPU time.
260: * If no filename is given, YAM batch mode is assumed.
261: *
262: * Iff the program is invoked by rbCOMMAND, output is piped to
263: * "COMMAND filename"
264: *
265: * Supports the CRC option or regular checksum.
266: * Received pathnames containing no lowercase letters will be changed to lower
267: * case unless -u option is given.
268: *
269: * Unless the -b (binary) option is given, \r is discarded and
270: * ^Z (which is also discarded) acts as end of file.
271: *
272: * Any slashes in the pathname are changed to underscore.
273: * If the raw pathname ends in .MSG or .TXT, any existing file will
274: * be appended to rather than replaced. Trailing periods are eliminated.
275: *
276: * If the raw pathname ends in any of the extensions in Extensions,
277: * or .?Q* (squeezed file), or if the first sector contains binary-like
278: * data (parity bits or characters in the range 0 to 6 before ^Z is seen),
279: * or if the transmitted file mode has the 0100000 but set,
280: * that file will be received in binary mode anyway.
281: *
282: *
283: * A log of activities is appended to LOGFILE with the -v option
284: * If stdout and stderr refer to different devices, progress is displayed to
285: * stderr.
286: *
287: * rb is derived from yam2.c and sb.c
288: */
289: #define LOGFILE "/tmp/rblog"
290:
291: #include <stdio.h>
292: #include <signal.h>
293: #include <setjmp.h>
294: #include <ctype.h>
295: FILE *popen();
296:
297: #define OK 0
298: #define FALSE 0
299: #define TRUE 1
300: #define ERROR (-1)
301:
302: #define HOWMANY 133
303: #include "rbsb.c" /* most of the system dependent stuff here */
304:
305: char *substr();
306: FILE *fout;
307:
308: char *Extensions[] = {
309: ".A",
310: ".ARC",
311: ".CCC",
312: ".CL",
313: ".CMD",
314: ".COM",
315: ".CRL",
316: ".DAT",
317: ".DIR",
318: ".EXE",
319: ".O",
320: ".OBJ",
321: ".OVL",
322: ".PAG",
323: ".REL",
324: ".SAV",
325: ".SUB",
326: ".SWP",
327: ".SYS",
328: ".TAR",
329: ".UTL",
330: ".a",
331: ".o",
332: ".tar",
333: ""
334: };
335:
336: /* Ward Christensen / CP/M parameters - Don't change these! */
337: #define ENQ 005
338: #define CAN ('X'&037)
339: #define XOFF ('s'&037)
340: #define XON ('q'&037)
341: #define SOH 1
342: #define STX 2
343: #define EOT 4
344: #define ACK 6
345: #define NAK 025
346: #define CPMEOF 032
347: #define WANTCRC 0103 /* send C not NAK to get crc not checksum */
348: #define TIMEOUT (-2)
349: #define ERRORMAX 5
350: #define RETRYMAX 5
351: #define WCEOT (-10)
352: #define SECSIZ 128 /* cp/m's Magic Number record size */
353: #define PATHLEN 257 /* ready for 4.2 bsd ? */
354: #define KSIZE 1024 /* record size with k option */
355: #define UNIXFILE 0x8000 /* happens to the the S_IFREG file mask bit for stat */
356:
357: int Lastrx;
358: int Crcflg;
359: int Firstsec;
360: int Eofseen; /* indicates cpm eof (^Z) has been received */
361: int totblocks; /* total number of blocks received */
362: int errors;
363: int Restricted=0; /* restricted; no /.. or ../ in filenames */
364:
365: #define DEFBYTL 2000000000L /* default rx file size */
366: long Bytesleft; /* number of bytes of incoming file left */
367: long Modtime; /* Unix style mod time for incoming file */
368: short Filemode; /* Unix style mode for incoming file */
369: char Pathname[PATHLEN];
370: char *Progname; /* the name by which we were called */
371:
372: int Batch=0;
373: int Wcsmask=0377;
374: int Topipe=0;
375: int MakeLCPathname=TRUE; /* make received pathname lower case */
376: int Verbose=0;
377: int Quiet=0; /* overrides logic that would otherwise set verbose */
378: int Rxbinary=FALSE; /* receive all files in bin mode */
379: int Thisbinary; /* current file is to be received in bin mode */
380: int Blklen; /* record length of received packets */
381: char secbuf[KSIZE];
382: char linbuf[KSIZE];
383: int Lleft=0; /* number of characters in linbuf */
384:
385: jmp_buf tohere; /* For the interrupt on RX timeout */
386:
387: unsigned short updcrc();
388:
389: alrm()
390: {
391: longjmp(tohere, -1);
392: }
393:
394: /* called by signal interrupt or terminate to clean things up */
395: bibi(n)
396: {
397: canit(); mode(0);
398: fprintf(stderr, "sb: caught signal %d; exiting", n);
399: exit(128+n);
400: }
401:
402: main(argc, argv)
403: char *argv[];
404: {
405: register char *cp;
406: register npats;
407: char *virgin, **patts;
408: char *getenv();
409: int exitcode;
410:
411: setbuf(stderr, NULL);
412: if ((cp=getenv("SHELL")) && (substr(cp, "rsh") || substr(cp, "rsh")))
413: Restricted=TRUE;
414:
415: chkinvok(virgin=argv[0]); /* if called as [-]rbCOMMAND set flag */
416: npats = 0;
417: while (--argc) {
418: cp = *++argv;
419: if (*cp == '-') {
420: while( *++cp) {
421: switch(*cp) {
422: case '1':
423: iofd = 1; break;
424: case '7':
425: Wcsmask = 0177;
426: case 'b':
427: Rxbinary=TRUE; break;
428: case 'k':
429: case 'c':
430: Crcflg=TRUE; break;
431: case 'q':
432: Quiet=TRUE; Verbose=0; break;
433: case 'u':
434: MakeLCPathname=FALSE; break;
435: case 'v':
436: ++Verbose; break;
437: default:
438: usage();
439: }
440: }
441: }
442: else if ( !npats && argc>0) {
443: if (argv[0][0]) {
444: npats=argc;
445: patts=argv;
446: }
447: }
448: }
449: if (npats > 1)
450: usage();
451: if (Verbose) {
452: if (freopen(LOGFILE, "a", stderr)==NULL) {
453: printf("Can't open log file %s\n",LOGFILE);
454: exit(0200);
455: }
456: setbuf(stderr, NULL);
457: fprintf(stderr, "argv[0]=%s Progname=%s\n", virgin, Progname);
458: }
459: if (fromcu() && !Quiet) {
460: if (Verbose == 0)
461: Verbose = 2;
462: }
463: mode(1);
464: if (signal(SIGINT, bibi) == SIG_IGN) {
465: signal(SIGINT, SIG_IGN); signal(SIGKILL, SIG_IGN);
466: }
467: else {
468: signal(SIGINT, bibi); signal(SIGKILL, bibi);
469: }
470: if (wcreceive(npats, patts)==ERROR) {
471: exitcode=0200;
472: canit();
473: }
474: mode(0);
475: if (exitcode != 0) /* bellow again with all thy might. */
476: canit();
477: #ifdef REGULUS
478: else
479: printf("\6\6\6\6\6\n"); /* Regulus doesn't wait ... */
480: #endif
481: exit(exitcode);
482: }
483:
484:
485: usage()
486: {
487: fprintf(stderr,"%s %s by Chuck Forsberg\n", Progname, VERSION);
488: fprintf(stderr,"Usage: rb [-17buv]\n\tor rb [-1bcuv] file\n");
489: exit(1);
490: }
491:
492: wcreceive(argc, argp)
493: char **argp;
494: {
495: if (Batch || argc==0) {
496: Crcflg=(Wcsmask==0377);
497: fprintf(stderr, "rb: ready ");
498: for (;;) {
499: totblocks=0;
500: if (wcrxpn(secbuf)== ERROR)
501: goto fubar;
502: if (secbuf[0]==0)
503: return OK;
504: if (procheader(secbuf) == ERROR)
505: goto fubar;
506: if (wcrx()==ERROR)
507: goto fubar;
508: }
509: } else {
510: totblocks=0; Bytesleft = DEFBYTL; Filemode = 0; Modtime = 0L;
511:
512: strcpy(Pathname, *argp);
513: checkpath(Pathname);
514: fprintf(stderr, "\nrb: ready to receive %s ", Pathname);
515: if ((fout=fopen(Pathname, "w")) == NULL)
516: return ERROR;
517: if (wcrx()==ERROR)
518: goto fubar;
519: }
520: return OK;
521: fubar:
522: canit();
523: if (Topipe && fout) {
524: pclose(fout); return ERROR;
525: }
526: if (fout)
527: fclose(fout);
528: if (Restricted) {
529: unlink(Pathname);
530: fprintf(stderr, "\r\nrb: %s removed.\r\n", Pathname);
531: }
532: return ERROR;
533: }
534:
535:
536: /*
537: * Fetch a pathname from the other end as a C ctyle ASCIZ string.
538: * Length is indeterminate as long as less than Blklen
539: * a null string represents no more files
540: */
541: wcrxpn(rpn)
542: char *rpn; /* receive a pathname */
543: {
544: register c;
545:
546: #ifdef NFGVMIN
547: readline(1);
548: #else
549: purgeline();
550: #endif
551:
552: et_tu:
553: Firstsec=TRUE;
554: sendline(Crcflg?WANTCRC:NAK);
555: while ((c = wcgetsec(rpn, 100)) != 0) {
556: log( "Pathname fetch returned %d\n", c);
557: if (c == WCEOT) {
558: sendline(ACK); readline(1); goto et_tu;
559: }
560: return ERROR;
561: }
562: sendline(ACK);
563: return OK;
564: }
565:
566: /*
567: * Adapted from CMODEM13.C, written by
568: * Jack M. Wierda and Roderick W. Hart
569: */
570:
571: wcrx()
572: {
573: register int sectnum, sectcurr;
574: register char sendchar;
575: register char *p;
576: int cblklen; /* bytes to dump this block */
577: time_t timep[2];
578:
579: Firstsec=TRUE;sectnum=0; Eofseen=FALSE;
580: sendchar=Crcflg?WANTCRC:NAK;
581:
582: for (;;) {
583: sendline(sendchar); /* send it now, we're ready! */
584: sectcurr=wcgetsec(secbuf, (sectnum&0177)?50:130);
585: report(sectcurr);
586: if (sectcurr==(sectnum+1 &Wcsmask)) {
587:
588: if (sectnum==0 && !Thisbinary)
589: for (p=secbuf,sectcurr=Blklen;
590: *p != 032 && --sectcurr>=0; ++p)
591: if (*p < 07 || (*p & 0200)) {
592: Thisbinary++;
593: if (Verbose)
594: fprintf(stderr, "Changed to BIN\n");
595: break;
596: }
597: sectnum++;
598: cblklen = Bytesleft>Blklen ? Blklen:Bytesleft;
599: if (putsec(secbuf, cblklen)==ERROR)
600: return ERROR;
601: if ((Bytesleft-=cblklen) < 0)
602: Bytesleft = 0;
603: sendchar=ACK;
604: }
605: else if (sectcurr==(sectnum&Wcsmask)) {
606: log( "Received dup Sector\n");
607: sendchar=ACK;
608: }
609: else if (sectcurr==WCEOT) {
610: if (Topipe) {
611: if (pclose(fout)!=ERROR) {
612: sendline(ACK);
613: return OK;
614: }
615: canit(); return ERROR;
616: }
617: if (fclose(fout)==ERROR) {
618: canit();
619: fprintf(stderr, "file close ERROR\n");
620: return ERROR;
621: }
622: if (Modtime) {
623: timep[0] = time(NULL);
624: timep[1] = Modtime;
625: utime(Pathname, timep);
626: }
627: if (Filemode)
628: chmod(Pathname, (07777 & Filemode));
629: sendline(ACK);
630: return OK;
631: }
632: else if (sectcurr==ERROR)
633: return ERROR;
634: else {
635: log( "Sync Error\n");
636: return ERROR;
637: }
638: }
639: }
640:
641: /*
642: * wcgetsec fetches a Ward Christensen type sector.
643: * Returns sector number encountered or ERROR if valid sector not received,
644: * or CAN CAN received
645: * or WCEOT if eot sector
646: * time is timeout for first char, set to 4 seconds thereafter
647: ***************** NO ACK IS SENT IF SECTOR IS RECEIVED OK **************
648: * (Caller must do that when he is good and ready to get next sector)
649: */
650:
651: wcgetsec(rxbuf, maxtime)
652: char *rxbuf;
653: int maxtime;
654: {
655: register checksum, wcj, firstch;
656: register unsigned short oldcrc;
657: register char *p;
658: int sectcurr;
659:
660: for (Lastrx=errors=0; errors<RETRYMAX; errors++) {
661:
662: if ((firstch=readline(maxtime))==STX) {
663: Blklen=KSIZE; goto get2;
664: }
665: if (firstch==SOH) {
666: Blklen=SECSIZ;
667: get2:
668: sectcurr=readline(1);
669: if ((sectcurr+(oldcrc=readline(1)))==Wcsmask) {
670: oldcrc=checksum=0;
671: for (p=rxbuf,wcj=Blklen; --wcj>=0; ) {
672: if ((firstch=readline(1)) < 0)
673: goto bilge;
674: oldcrc=updcrc(firstch, oldcrc);
675: checksum += (*p++ = firstch);
676: }
677: if ((firstch=readline(1)) < 0)
678: goto bilge;
679: if (Crcflg) {
680: oldcrc=updcrc(firstch, oldcrc);
681: if ((firstch=readline(1)) < 0)
682: goto bilge;
683: oldcrc=updcrc(firstch, oldcrc);
684: if (oldcrc)
685: log("CRC=0%o\n", oldcrc);
686: else {
687: Firstsec=FALSE;
688: return sectcurr;
689: }
690: }
691: else if (((checksum-firstch)&Wcsmask)==0) {
692: Firstsec=FALSE;
693: return sectcurr;
694: }
695: else
696: log( "Checksum Error\n");
697: }
698: else
699: log("Sector number garbled 0%o 0%o\n",
700: sectcurr, oldcrc);
701: }
702: /* make sure eot really is eot and not just mixmash */
703: #ifdef NFGVMIN
704: else if (firstch==EOT && readline(1)==TIMEOUT)
705: return WCEOT;
706: #else
707: else if (firstch==EOT && Lleft==0)
708: return WCEOT;
709: #endif
710: else if (firstch==CAN) {
711: if (Lastrx==CAN) {
712: log( "Sender CANcelled\n");
713: return ERROR;
714: } else {
715: Lastrx=CAN;
716: continue;
717: }
718: }
719: else if (firstch==TIMEOUT) {
720: if (Firstsec)
721: goto humbug;
722: bilge:
723: log( "Timeout\n");
724: }
725: else
726: log( "Got 0%o sector header\n", firstch);
727:
728: humbug:
729: Lastrx=0;
730: while(readline(1)!=TIMEOUT)
731: ;
732: if (Firstsec)
733: sendline(Crcflg?WANTCRC:NAK);
734: else {
735: maxtime=40; sendline(NAK);
736: }
737: }
738: /* try to stop the bubble machine. */
739: canit();
740: return ERROR;
741: }
742:
743: /*
744: * This version of readline is reasoably well suited for
745: * reading many characters.
746: * (except, currently, for the Regulus version!)
747: *
748: * timeout is in tenths of seconds
749: */
750: readline(timeout)
751: int timeout;
752: {
753: register n;
754: static char *cdq; /* pointer for removing chars from linbuf */
755:
756: if (--Lleft >= 0) {
757: if (Verbose > 8) {
758: fprintf(stderr, "%02x ", *cdq&0377);
759: }
760: return (*cdq++ & Wcsmask);
761: }
762: n = timeout/10;
763: if (n < 2)
764: n = 3;
765: if (Verbose > 3)
766: fprintf(stderr, "Calling read: n=%d ", n);
767: if (setjmp(tohere)) {
768: #ifdef TIOCFLUSH
769: /* ioctl(iofd, TIOCFLUSH, 0); */
770: #endif
771: Lleft = 0;
772: if (Verbose>1)
773: fprintf(stderr, "Readline:TIMEOUT\n");
774: return TIMEOUT;
775: }
776: signal(SIGALRM, alrm); alarm(n);
777: #ifdef ONEREAD
778: /* Sorry, Regulus and some others don't work right in raw mode! */
779: Lleft=read(iofd, cdq=linbuf, 1);
780: #else
781: Lleft=read(iofd, cdq=linbuf, KSIZE);
782: #endif
783: alarm(0);
784: if (Verbose > 3) {
785: fprintf(stderr, "Read returned %d bytes\n", Lleft);
786: }
787: if (Lleft < 1)
788: return TIMEOUT;
789: --Lleft;
790: if (Verbose > 8) {
791: fprintf(stderr, "%02x ", *cdq&0377);
792: }
793: return (*cdq++ & Wcsmask);
794: }
795:
796:
797:
798:
799: purgeline()
800: {
801: Lleft = 0;
802: #ifdef USG
803: ioctl(iofd, TCFLSH, 0);
804: #else
805: lseek(iofd, 0L, 2);
806: #endif
807: }
808:
809: /* update CRC */
810: unsigned short
811: updcrc(c, crc)
812: register c;
813: register unsigned crc;
814: {
815: register count;
816:
817: for (count=8; --count>=0;) {
818: if (crc & 0x8000) {
819: crc <<= 1;
820: crc += (((c<<=1) & 0400) != 0);
821: crc ^= 0x1021;
822: }
823: else {
824: crc <<= 1;
825: crc += (((c<<=1) & 0400) != 0);
826: }
827: }
828: return crc;
829: }
830:
831: /*
832: * process incoming header
833: */
834: procheader(name)
835: char *name;
836: {
837: register char *openmode, *p, **pp;
838:
839: /* set default parameters */
840: openmode = "w"; Thisbinary=Rxbinary;
841: Bytesleft = DEFBYTL; Filemode = 0; Modtime = 0L;
842:
843: p = name + 1 + strlen(name);
844: if (*p) { /* file coming from Unix or DOS system */
845: sscanf(p, "%ld%lo%o", &Bytesleft, &Modtime, &Filemode);
846: if (Filemode & UNIXFILE)
847: ++Thisbinary;
848: if (Verbose) {
849: fprintf(stderr, "Incoming: %s %ld %lo %o\n",
850: name, Bytesleft, Modtime, Filemode);
851: }
852: }
853: else { /* File coming from CP/M system */
854: for (p=name; *p; ++p) /* change / to _ */
855: if ( *p == '/')
856: *p = '_';
857:
858: if ( *--p == '.') /* zap trailing period */
859: *p = 0;
860: }
861:
862: /* scan for extensions that signify a binary file */
863: if (p=substr(name, "."))
864: for (pp=Extensions; **pp; ++pp)
865: if (strcmp(p, *pp)==0) {
866: Thisbinary=TRUE; break;
867: }
868:
869: /* scan for files which should be appended */
870: if ( !Thisbinary
871: && (substr(name, ".TXT")
872: || substr(name, ".txt")
873: || substr(name, ".MSG")))
874: openmode = "a";
875: if (MakeLCPathname && !IsAnyLower(name))
876: uncaps(name);
877: if (Topipe) {
878: sprintf(Pathname, "%s %s", Progname+2, name);
879: if (Verbose)
880: fprintf(stderr, "Topipe: %s %s\n",
881: Pathname, Thisbinary?"BIN":"ASCII");
882: if ((fout=popen(Pathname, "w")) == NULL)
883: return ERROR;
884: } else {
885: strcpy(Pathname, name);
886: if (Verbose) {
887: fprintf(stderr, "Receiving %s %s %s\n",
888: name, Thisbinary?"BIN":"ASCII", openmode);
889: }
890: checkpath(name);
891: if ((fout=fopen(name, openmode)) == NULL)
892: return ERROR;
893: }
894: return OK;
895: }
896:
897: /* make string s lower case */
898: uncaps(s)
899: register char *s;
900: {
901: for ( ; *s; ++s)
902: if (isupper(*s))
903: *s = tolower(*s);
904: }
905:
906:
907: /*
908: * IsAnyLower returns TRUE if string s has lower case letters.
909: */
910: IsAnyLower(s)
911: register char *s;
912: {
913: for ( ; *s; ++s)
914: if (islower(*s))
915: return TRUE;
916: return FALSE;
917: }
918: /*
919: * putsec writes the n characters of buf to receive file fout.
920: * If not in binary mode, carriage returns, and all characters
921: * starting with CPMEOF are discarded.
922: */
923: putsec(buf, n)
924: char *buf;
925: register n;
926: {
927: register char *p;
928:
929: ++totblocks;
930: if (Thisbinary)
931: {
932: for (p=buf; --n>=0; )
933: putc( *p++, fout);
934: }
935: else {
936: if (Eofseen)
937: return OK;
938: for (p=buf; --n>=0; ++p ) {
939: if ( *p == '\r')
940: continue;
941: if (*p == CPMEOF) {
942: Eofseen=TRUE; return OK;
943: }
944: putc(*p ,fout);
945: }
946: }
947: return OK;
948: }
949: sendline(c)
950: {
951: char d;
952:
953: d = c;
954: if (Verbose>2)
955: fprintf(stderr, "Sendline: %x\n", c);
956: write(1, &d, 1);
957: Lleft=0; /* Do read next time ... */
958: }
959:
960:
961: /*
962: * substr(string, token) searches for token in string s
963: * returns pointer to token within string if found, NULL otherwise
964: */
965: char *
966: substr(s, t)
967: register char *s,*t;
968: {
969: register char *ss,*tt;
970: /* search for first char of token */
971: for (ss=s; *s; s++)
972: if (*s == *t)
973: /* compare token with substring */
974: for (ss=s,tt=t; ;) {
975: if (*tt == 0)
976: return s;
977: if (*ss++ != *tt++)
978: break;
979: }
980: return NULL;
981: }
982:
983: /*VARARGS1*/
984: log(s,p,u)
985: char *s, *p, *u;
986: {
987: if (!Verbose)
988: return;
989: fprintf(stderr, "error %d: ", errors);
990: fprintf(stderr, s, p, u);
991: }
992:
993: /* send 10 CAN's to try to get the other end to shut up */
994: canit()
995: {
996: register n;
997: for (n=10; --n>=0; )
998: sendline(CAN);
999: }
1000:
1001: #ifdef REGULUS
1002: /*
1003: * copies count bytes from s to d
1004: * (No structure assignment in Regulus C compiler)
1005: */
1006:
1007: movmem(s, d, count)
1008: register char *s, *d;
1009: register count;
1010: {
1011: while (--count >= 0)
1012: *d++ = *s++;
1013: }
1014: #endif
1015:
1016: /*
1017: * return 1 iff stdout and stderr are different devices
1018: * indicating this program operating with a modem on a
1019: * different line
1020: */
1021: fromcu()
1022: {
1023: struct stat a, b;
1024: fstat(1, &a); fstat(2, &b);
1025: return (a.st_rdev != b.st_rdev);
1026: }
1027:
1028: report(sct)
1029: int sct;
1030: {
1031: if (Verbose>1)
1032: fprintf(stderr,"%03d%c",sct,sct%10? ' ' : '\r');
1033: }
1034:
1035: /*
1036: * if called as [-][dir/../]vrbCOMMAND set Verbose to 1
1037: * if called as [-][dir/../]rbCOMMAND set the pipe flag
1038: */
1039: chkinvok(s)
1040: char *s;
1041: {
1042: register char *p;
1043:
1044: p = s;
1045: while (*p == '-')
1046: s = ++p;
1047: while (*p)
1048: if (*p++ == '/')
1049: s = p;
1050: if (*s == 'v') {
1051: Verbose=1; ++s;
1052: }
1053: Progname = s;
1054: if (s[2] && s[0]=='r' && s[1]=='b')
1055: Topipe=TRUE;
1056: }
1057:
1058: checkpath(name)
1059: char *name;
1060: {
1061: if (Restricted) {
1062: if (fopen(name, "r") != NULL) {
1063: canit();
1064: fprintf(stderr, "\r\nrb: %s exists\n", name);
1065: bibi();
1066: }
1067: /* restrict pathnames to current tree or uucppublic */
1068: if ( substr(name, "../")
1069: || (name[0]== '/' && strncmp(name, PUBDIR, strlen(PUBDIR))) ) {
1070: canit();
1071: fprintf(stderr,"\r\nrb:\tSecurity Violation\r\n");
1072: bibi();
1073: }
1074: }
1075: }
1076:
1077: SHAR_EOF
1078: cat << \SHAR_EOF > rbsb.c
1079: /* -rev 09-13-85
1080: * mode function and most of the rest of the system dependent
1081: * stuff for rb.c and sb.c This file is #included so the includer
1082: * can set parameters such as HOWMANY.
1083: */
1084:
1085: #ifdef USG
1086: #include <sys/types.h>
1087: #include <sys/stat.h>
1088: #include <termio.h>
1089: #include <sys/ioctl.h>
1090: #define OS "USG"
1091: #endif
1092:
1093: #ifdef V7
1094: #include <sys/types.h>
1095: #include <sys/stat.h>
1096: #include <sgtty.h>
1097: #define OS "V7"
1098: #endif
1099:
1100: #ifndef OS
1101: #include <termio.h>
1102: #include <sys/ioctl.h>
1103: #include <stat.h>
1104: #define REGULUS
1105: #define ONEREAD
1106: #define OS "REGULUS"
1107: #define void int
1108: #define time_t long
1109: #endif
1110:
1111:
1112: #ifdef ICANON
1113: struct termio oldtty, tty;
1114: #else
1115: struct sgttyb oldtty, tty;
1116: struct tchars oldtch, tch;
1117: #endif
1118:
1119: int iofd = 0; /* File descriptor for ioctls & reads */
1120:
1121: /*
1122: * mode(n)
1123: * 2: set a cbreak, XON/XOFF control mode if using Pro-YAM's -g option
1124: * 1: save old tty stat, set raw mode
1125: * 0: restore original tty mode
1126: */
1127: mode(n)
1128: {
1129: static did0 = FALSE;
1130:
1131: switch(n) {
1132: #ifdef USG
1133: case 2: /* Cbreak mode used by sb when -g detected */
1134: if(!did0)
1135: (void) ioctl(iofd, TCGETA, &oldtty);
1136: tty = oldtty;
1137:
1138: tty.c_iflag = BRKINT|IXON;
1139:
1140: tty.c_oflag = 0; /* Transparent output */
1141:
1142: tty.c_cflag &= ~PARENB; /* Disable parity */
1143: tty.c_cflag |= CS8; /* Set character size = 8 */
1144:
1145: #ifdef XCLUDE
1146: tty.c_lflag = XCLUDE | ISIG;
1147: #else
1148: tty.c_lflag = ISIG;
1149: #endif
1150:
1151: tty.c_cc[VINTR] = 030; /* Interrupt on CANCEL */
1152: tty.c_cc[VMIN] = 1;
1153:
1154: (void) ioctl(iofd, TCSETAW, &tty);
1155: did0 = TRUE;
1156: return OK;
1157: case 1:
1158: if(!did0)
1159: (void) ioctl(iofd, TCGETA, &oldtty);
1160: tty = oldtty;
1161:
1162: tty.c_iflag = IGNBRK;
1163:
1164: /* No echo, crlf mapping, INTR, QUIT, delays, no erase/kill */
1165: tty.c_lflag &= ~(ECHO | ICANON | ISIG);
1166: #ifdef XCLUDE
1167: tty.c_lflag |= XCLUDE;
1168: #endif
1169:
1170: tty.c_oflag = 0; /* Transparent output */
1171:
1172: tty.c_cflag &= ~PARENB; /* Leave baud rate alone, disable parity */
1173: tty.c_cflag |= CS8; /* Set character size = 8 */
1174: tty.c_cc[VMIN] = HOWMANY; /* Satisfy reads when this many chars in */
1175: tty.c_cc[VTIME] = 1; /* ... or in this many tenths of seconds */
1176: (void) ioctl(iofd, TCSETAW, &tty);
1177: did0 = TRUE;
1178: return OK;
1179: #endif
1180: #ifdef V7
1181: case 2:
1182: if(!did0) {
1183: ioctl(iofd, TIOCEXCL, 0);
1184: ioctl(iofd, TIOCGETP, &oldtty);
1185: ioctl(iofd, TIOCGETC, &oldtch);
1186: }
1187: tty = oldtty;
1188: tch = oldtch;
1189: tch.t_intrc = 030;
1190: tty.sg_flags |= CBREAK;
1191: tty.sg_flags &= ~ECHO;
1192: ioctl(iofd, TIOCSETP, &tty);
1193: ioctl(iofd, TIOCSETC, &tch);
1194: did0 = TRUE;
1195: return OK;
1196: case 1:
1197: if(!did0) {
1198: ioctl(iofd, TIOCEXCL, 0);
1199: ioctl(iofd, TIOCGETP, &oldtty);
1200: ioctl(iofd, TIOCGETC, &oldtch);
1201: }
1202: tty = oldtty;
1203: tty.sg_flags |= RAW;
1204: tty.sg_flags &= ~ECHO;
1205: ioctl(iofd, TIOCSETP, &tty);
1206: did0 = TRUE;
1207: return OK;
1208: #endif
1209: #ifdef REGULUS
1210: case 2:
1211: return ERROR;
1212: case 1:
1213: if(!did0) {
1214: ioctl(iofd, TCGETA, &oldtty);
1215: }
1216: tty = oldtty;
1217:
1218: tty.c_lflag = 0;
1219: tty.c_iflag = IGNBRK;
1220: tty.c_oflag = 0; /* Transparent output */
1221:
1222: tty.c_cflag &= ~PARENB; /* Leave baud rate alone, disable parity */
1223: tty.c_cflag |= CS8; /* Set character size = 8 */
1224: tty.c_cc[VMIN] = HOWMANY; /* Satisfy reads when this many chars in */
1225: tty.c_cc[VTIME] = 1; /* ... or in this many tenths of seconds */
1226: ioctl(iofd, TCSETA, &tty);
1227: did0 = TRUE;
1228: return OK;
1229: #endif
1230: #ifdef REGULUS10
1231: if(!did0) {
1232: ioctl(iofd, TIOCGETP, &oldtty);
1233: }
1234: /* Sorry, No structure assignment in Regulus C */
1235: movmem( (char *)&oldtty, (char *)&tty, sizeof(tty));
1236: tty.sg_flags |= (EIGHTBIT|RAW);
1237: tty.sg_flags &= ~ECHO;
1238: tty.sg_ledit &= ~LEDIT;
1239: ioctl(iofd, TIOCSETP, &tty);
1240: did0 = TRUE;
1241: return OK;
1242: #endif
1243: case 0:
1244: if(!did0)
1245: return ERROR;
1246: #ifdef USG
1247: (void) ioctl(iofd, TCSBRK, 1); /* Wait for output to drain */
1248: (void) ioctl(iofd, TCFLSH, 1); /* Flush input queue */
1249: (void) ioctl(iofd, TCSETAW, &oldtty); /* Restore original modes */
1250: (void) ioctl(iofd, TCXONC,1); /* Restart output */
1251: #endif
1252: #ifdef V7
1253: ioctl(iofd, TIOCSETP, &oldtty);
1254: ioctl(iofd, TIOCSETC, &oldtch);
1255: ioctl(iofd, TIOCNXCL, 0);
1256: #endif
1257: #ifdef REGULUS
1258: ioctl(iofd, TCSETAW, &oldtty); /* Restore original modes */
1259: #endif
1260: #ifdef REGULUS10
1261: ioctl(iofd, TIOCSETP, &oldtty);
1262: #endif
1263: return OK;
1264: default:
1265: return ERROR;
1266: }
1267: }
1268:
1269: SHAR_EOF
1270: cat << \SHAR_EOF > sb.1
1271: '\" Revision Level
1272: '\" Last Delta 12-07-85
1273: .TH SB 1 OMEN
1274: .SH NAME
1275: sb \- send files in batch mode
1276: .SH SYNOPSIS
1277: .B sb
1278: [
1279: .B \-1dfkquv
1280: ]
1281: .B file ...
1282: .br
1283: .B "sb -X"
1284: [
1285: .B \-1kquv
1286: ]
1287: .B file
1288: .SH DESCRIPTION
1289: .B Sb
1290: sends one or more files with YMODEM batch protocol.
1291: Normally, only the file name part of the pathname is transmitted.
1292: On
1293: .SM Unix
1294: systems, additional information about the file is transmitted.
1295: If the receiving program uses this information,
1296: the transmitted file length controls the exact number of bytes written to
1297: the output dataset,
1298: and the modify time and file mode
1299: are set accordingly.
1300:
1301: With the
1302: .B -X
1303: flag,
1304: .B sb
1305: sends a single file using XMODEM protocol.
1306: The received file name must be supplied by the user.
1307:
1308: If sb is invoked with stdout and stderr to different datasets,
1309: Verbose is set to 2, causing frame by frame progress reports
1310: to stderr.
1311: This may be disabled with the
1312: .B q
1313: option.
1314:
1315: Iff sb is invoked with $SHELL set and iff that variable contains the
1316: string
1317: .I "rsh"
1318: or
1319: .I "rksh"
1320: (restricted shell), sb operates in restricted mode.
1321: Restricted mode restricts pathnames to the current directory and
1322: PUBDIR (conventionally, /usr/spool/uucppublic) and/or subdirectories
1323: thereof.
1324:
1325: Sb supports YMODEM
1326: .B g
1327: mode by switching to "cbreak" tty mode with XON/XOFF folow control
1328: and the interrupt character set to CAN.
1329: The YMODEM
1330: .B g
1331: mode
1332: (Pro-YAM
1333: .B g
1334: option)
1335: increases throughput over error free channels
1336: (direct connection, X.PC, etc.)
1337: by not acknowledging each transmitted sector.
1338: .PP
1339: The meanings of the available options are:
1340: .PP
1341: .PD 0
1342: .TP
1343: .B 1
1344: Use file descriptor 1 for ioctls and reads.
1345: By default, file descriptor 0 is used.
1346: .TP
1347: .B X
1348: (XMODEM protocol)
1349: Send a single file without the filename packet.
1350: .TP
1351: .B d
1352: Change all instances of "." to "/" in the transmitted pathname.
1353: Thus, C.omenB0000 (which is unacceptable to MSDOS or CP/M)
1354: is transmitted as C/omenB0000.
1355: If the resultant filename has more than 8 characters in the stem,
1356: a "." in inserted to allow a total of eleven.
1357: .TP
1358: .B f
1359: Send Full pathnname.
1360: Normally directory prefices are stripped from the transmitted
1361: filename.
1362: .TP
1363: .B k
1364: Send files using 1024 byte blocks
1365: rather than the default 128 byte blocks.
1366: The user should determine experimentally
1367: the conditions under which use of 1k blocks
1368: actually improves throughput without causing
1369: problems.
1370: .TP
1371: .B q
1372: Quiet suppresses verbosity.
1373: .TP
1374: .B u
1375: Unlink the file after successful transmission.
1376: .TP
1377: .B v
1378: .IR Verbose
1379: causes a list of file
1380: names to be appended to
1381: /tmp/sblog .
1382: More v's generate more output.
1383: .PD
1384: .SH EXAMPLES
1385: (Unix command)
1386: .RS
1387: sb -k *.c
1388: .br
1389: .RE
1390: (Pro-YAM command)
1391: .RS
1392: <F3>
1393: .br
1394: .RE
1395: (8-bit YAM Commands)
1396: .br
1397: .RS
1398: ^E
1399: .br
1400: >>>c: rt -y
1401: .br
1402: .RE
1403: .SH SEE ALSO
1404: rb(omen),
1405: YMODEM.DOC,
1406: Professional-YAM manual,
1407: IMP(CP/M),
1408: ncu(1),
1409: sq(omen),
1410: todos(omen),
1411: tocpm(omen),
1412: tomac(omen)
1413:
1414: Compile time options for various operating systems are described in the
1415: program source file.
1416: .SH BUGS
1417: On VMS,
1418: some of the #includes with file names enclosed with angle brackets <>
1419: may need to have the angle brackets removed, or vice versa.
1420:
1421: The VMS version does not transmit the file date.
1422:
1423: The VMS version does not recognize Pro-YAM\'s
1424: .B g
1425: option (YMODEM-g protocol).
1426:
1427: The VMS version calculates the file length by counting the bytes therin.
1428:
1429: When VMS is lightly loaded, the response time may be too quick for MODEM7
1430: unless the MODEM7
1431: .B "q"
1432: modifier is used.
1433:
1434: There may be unknown interactions between the VMS C standard i/o
1435: package and RMS.
1436: SHAR_EOF
1437: cat << \SHAR_EOF > sb.c
1438: #define VERSION "sb 2.24 01-04-86"
1439: #define PUBDIR "/usr/spool/uucppublic"
1440:
1441: /*% cc -K -O -DUSG sb.c -o sb
1442:
1443: * sb.c By Chuck Forsberg
1444: *
1445: * USG UNIX (3.0) ioctl conventions courtesy Jeff Martin
1446: * cc -O -DV7 sb.c -o sb Unix version 7, 2.8 - 4.3 BSD
1447: * cc -O -DUSG sb.c -o sb USG (3.0) Unix
1448: * ******* Some systems (Venix, Coherent, Regulus) do not *******
1449: * ******* support tty raw mode read(2) identically to *******
1450: * ******* Unix. ONEREAD must be defined to force one *******
1451: * ******* character reads for these systems. *******
1452: *
1453: * A small program for Unix which can send 1 or more
1454: * files in Batch mode to computers running YAM. (Use "rb" in YAM.)
1455: * Supports the CRC option or regular checksum.
1456: * Exit status is 0 for all transfers completed successfully,
1457: * 1 for 1 or more unreadable files or'd with 200 for incomplete file xfer.
1458: *
1459: * accepts -k option for 1kb record length.
1460: *
1461: * sb is derived from yam2.c
1462: * Uses buffered i/o to reduce the CPU time compared to UMODEM.
1463: */
1464:
1465: #define LOGFILE "/tmp/sblog"
1466:
1467: #include <stdio.h>
1468: #include <signal.h>
1469: #include <setjmp.h>
1470: #include <ctype.h>
1471:
1472: #define PATHLEN 256
1473: #define OK 0
1474: #define FALSE 0
1475: #define TRUE 1
1476: #define ERROR (-1)
1477:
1478: #define HOWMANY 2
1479: #include "rbsb.c" /* most of the system dependent stuff here */
1480:
1481: FILE *in;
1482:
1483: /* Ward Christensen / CP/M parameters - Don't change these! */
1484: #define ENQ 005
1485: #define CAN ('X'&037)
1486: #define XOFF ('s'&037)
1487: #define XON ('q'&037)
1488: #define SOH 1
1489: #define STX 2
1490: #define EOT 4
1491: #define ACK 6
1492: #define NAK 025
1493: #define CPMEOF 032
1494: #define WANTCRC 0103 /* send C not NAK to get crc not checksum */
1495: #define WANTG 0107 /* Send G not NAK to get nonstop batch xmsn */
1496: #define TIMEOUT (-2)
1497: #define RETRYMAX 10
1498: #define SECSIZ 128 /* cp/m's Magic Number record size */
1499: #define KSIZE 1024
1500:
1501: char Lastrx;
1502: char Crcflg;
1503: int Wcsmask=0377;
1504: int Verbose=0;
1505: int Modem=0; /* MODEM - don't send pathnames */
1506: int Restricted=0; /* restricted; no /.. or ../ in filenames */
1507: int Quiet=0; /* overrides logic that would otherwise set verbose */
1508: int Fullname=0; /* transmit full pathname */
1509: int Unlinkafter=0; /* Unlink file after it is sent */
1510: int Dottoslash=0; /* Change foo.bar.baz to foo/bar/baz */
1511: int firstsec;
1512: int errcnt=0; /* number of files unreadable */
1513: int blklen=SECSIZ; /* length of transmitted records */
1514: int Optiong; /* Let it rip no wait for sector ACK's */
1515: int Noeofseen;
1516: int Totsecs; /* total number of sectors this file */
1517: char txbuf[KSIZE];
1518: int Filcnt=0; /* count of number of files opened */
1519:
1520: jmp_buf tohere; /* For the interrupt on RX timeout */
1521:
1522: unsigned updcrc();
1523: char *substr(), *getenv();
1524:
1525: /* called by signal interrupt or terminate to clean things up */
1526: bibi(n)
1527: {
1528: canit(); fflush(stdout); mode(0);
1529: fprintf(stderr, "sb: caught signal %d; exiting\n", n);
1530: if (n == SIGQUIT)
1531: abort();
1532: exit(128+n);
1533: }
1534:
1535: #ifdef REGULUS
1536: sendline(c)
1537: {
1538: static char d[2];
1539:
1540: d[0] = c&Wcsmask;
1541: write(1, d, 1);
1542: }
1543: #else
1544: #define sendline(c) putchar(c & Wcsmask)
1545: #endif
1546:
1547: main(argc, argv)
1548: char *argv[];
1549: {
1550: register char *cp;
1551: register npats;
1552: int agcnt; char **agcv;
1553: char **patts;
1554: int exitcode;
1555: #ifndef REGULUS
1556: static char xXbuf[BUFSIZ];
1557: #endif
1558:
1559: if ((cp=getenv("SHELL")) && (substr(cp, "rsh") || substr(cp, "rsh")))
1560: Restricted=TRUE;
1561:
1562: npats=0;
1563: if (argc<2)
1564: usage();
1565: #ifndef REGULUS
1566: setbuf(stdout, xXbuf);
1567: #endif
1568: while (--argc) {
1569: cp = *++argv;
1570: if (*cp++ == '-' && *cp) {
1571: while ( *cp) {
1572: switch(*cp++) {
1573: case '1':
1574: iofd = 1; break;
1575: case '7':
1576: Wcsmask=0177; break;
1577: case 'd':
1578: ++Dottoslash;
1579: /* **** FALL THROUGH TO **** */
1580: case 'f':
1581: Fullname=TRUE; break;
1582: case 'k':
1583: blklen=KSIZE; break;
1584: case 'q':
1585: Quiet=TRUE; Verbose=0; break;
1586: case 'u':
1587: ++Unlinkafter; break;
1588: case 'v':
1589: ++Verbose; break;
1590: case 'X':
1591: ++Modem; break;
1592: default:
1593: usage();
1594: }
1595: }
1596: }
1597: else if ( !npats && argc>0) {
1598: if (argv[0][0]) {
1599: npats=argc;
1600: patts=argv;
1601: if ( !strcmp(*patts, "-"))
1602: iofd = 1;
1603: }
1604: }
1605: }
1606: if (npats < 1)
1607: usage();
1608: if (Verbose) {
1609: if (freopen(LOGFILE, "a", stderr)==NULL) {
1610: printf("Can't open log file %s\n",LOGFILE);
1611: exit(0200);
1612: }
1613: setbuf(stderr, NULL);
1614: }
1615: if (fromcu() && !Quiet) {
1616: if (Verbose == 0)
1617: Verbose = 2;
1618: }
1619: if (Verbose != 1) {
1620: fprintf(stderr, "sb: %d file%s requested:\r\n",
1621: npats, npats>1?"s":"");
1622: for ( agcnt=npats, agcv=patts; --agcnt>=0; ) {
1623: fprintf(stderr, "%s ", *agcv++);
1624: }
1625: }
1626:
1627: mode(1);
1628: if (signal(SIGINT, bibi) == SIG_IGN) {
1629: signal(SIGINT, SIG_IGN); signal(SIGKILL, SIG_IGN);
1630: }
1631: else {
1632: signal(SIGINT, bibi); signal(SIGKILL, bibi);
1633: signal(SIGQUIT, bibi);
1634: }
1635:
1636: if (wcsend(npats, patts)==ERROR) {
1637: exitcode=0200;
1638: canit();
1639: }
1640: fflush(stdout);
1641: mode(0);
1642: exit((errcnt != 0) | exitcode);
1643: }
1644:
1645: wcsend(argc, argp)
1646: char *argp[];
1647: {
1648: register n;
1649:
1650: Crcflg=FALSE;
1651: firstsec=TRUE;
1652: for (n=0; n<argc; ++n) {
1653: Totsecs = 0;
1654: if (wcs(argp[n])==ERROR)
1655: goto fubar;
1656: }
1657: Totsecs = 0;
1658: if (Filcnt==0) { /* bitch if we couldn't open ANY files */
1659: fprintf(stderr,"\r\nCan't open any requested files.\n");
1660: return ERROR;
1661: }
1662: else if (wctxpn("")==ERROR)
1663: goto fubar;
1664: return OK;
1665: fubar:
1666: canit(); return ERROR;
1667: }
1668:
1669: wcs(oname)
1670: char *oname;
1671: {
1672: register c;
1673: register char *p;
1674: struct stat f;
1675: char name[PATHLEN];
1676:
1677: strcpy(name, oname);
1678:
1679: if (Restricted) {
1680: /* restrict pathnames to current tree or uucppublic */
1681: if ( substr(name, "../")
1682: || (name[0]== '/' && strncmp(name, PUBDIR, strlen(PUBDIR))) ) {
1683: canit();
1684: fprintf(stderr,"\r\nsb:\tSecurity Violation\r\n");
1685: return ERROR;
1686: }
1687: }
1688:
1689: if ( !strcmp(oname, "-")) {
1690: sprintf(name, "s%d.sb", getpid());
1691: in = stdin;
1692: }
1693: else if ((in=fopen(oname, "r"))==NULL) {
1694: ++errcnt;
1695: return OK; /* pass over it, there may be others */
1696: }
1697: ++Noeofseen;
1698: /* Check for directory or block special files */
1699: #ifndef REGULUS /* This doesn't seem to work on Regulus */
1700: fstat(fileno(in), &f);
1701: c = f.st_mode & S_IFMT;
1702: if (c == S_IFDIR || c == S_IFBLK) {
1703: fclose(in);
1704: return OK;
1705: }
1706: #endif
1707: ++Filcnt;
1708: if (wctxpn(name)== ERROR)
1709: return ERROR;
1710: if (wctx()==ERROR)
1711: return ERROR;
1712: if (Unlinkafter)
1713: unlink(oname);
1714: return 0;
1715: }
1716:
1717: /*
1718: * generate and transmit pathname block consisting of
1719: * pathname (null terminated),
1720: * file length, mode time and file mode in octal
1721: * as provided by the Unix fstat call.
1722: * N.B.: modifies the passed name, may extend it!
1723: */
1724: wctxpn(name)
1725: char *name;
1726: {
1727: register firstch;
1728: register char *p, *q;
1729: char name2[PATHLEN];
1730: struct stat f;
1731:
1732: if (Modem)
1733: return OK;
1734: logent("\r\nAwaiting pathname nak for %s\r\n", *name?name:"<END>");
1735: if (getnak())
1736: return ERROR;
1737:
1738: q = (char *) 0;
1739: if (Dottoslash) { /* change . to . */
1740: for (p=name; *p; ++p) {
1741: if (*p == '/')
1742: q = p;
1743: else if (*p == '.')
1744: *(q=p) = '/';
1745: }
1746: if (q && strlen(++q) > 8) { /* If name>8 chars */
1747: q += 8; /* make it .ext */
1748: strcpy(name2, q); /* save excess of name */
1749: *q = '.';
1750: strcpy(++q, name2); /* add it back */
1751: }
1752: }
1753:
1754: for (p=name, q=txbuf ; *p; )
1755: if ((*q++ = *p++) == '/' && !Fullname)
1756: q = txbuf;
1757: *q++ = 0;
1758: p=q;
1759: while (q < (txbuf + KSIZE))
1760: *q++ = 0;
1761: if (in == stdin)
1762: strcpy(p, "1999999999");
1763: #ifndef REGULUS /* This doesn't seem to work on Regulus */
1764: else if (*name && fstat(fileno(in), &f)!= -1)
1765: sprintf(p, "%lu %lo %o", f.st_size, f.st_mtime, f.st_mode);
1766: #endif
1767: /* force 1k blocks if name won't fit in 128 byte block */
1768: if (txbuf[125])
1769: blklen=KSIZE;
1770: else { /* A little goodie for IMP/KMD */
1771: txbuf[127] = f.st_size >>7;
1772: txbuf[126] = f.st_size >>15;
1773: }
1774: if (wcputsec(txbuf, 0, SECSIZ)==ERROR)
1775: return ERROR;
1776: return OK;
1777: }
1778:
1779: getnak()
1780: {
1781: register firstch;
1782:
1783: Lastrx = 0;
1784: for (;;) {
1785: switch (firstch = readock(800,2)) {
1786: case TIMEOUT:
1787: logent("Timeout on pathname\n");
1788: return TRUE;
1789: case WANTG:
1790: mode(2); /* Set cbreak, XON/XOFF, etc. */
1791: Optiong = TRUE;
1792: blklen=KSIZE;
1793: case WANTCRC:
1794: Crcflg = TRUE;
1795: case NAK:
1796: return FALSE;
1797: case CAN:
1798: if (Lastrx == CAN)
1799: return TRUE;
1800: default:
1801: break;
1802: }
1803: Lastrx = firstch;
1804: }
1805: }
1806:
1807:
1808: wctx()
1809: {
1810: register int sectnum, attempts, firstch;
1811:
1812: firstsec=TRUE;
1813:
1814: while ((firstch=readock(400, 2))!=NAK && firstch != WANTCRC
1815: && firstch != WANTG && firstch!=TIMEOUT && firstch!=CAN)
1816: ;
1817: if (firstch==CAN) {
1818: logent("Receiver CANcelled\n");
1819: return ERROR;
1820: }
1821: if (firstch==WANTCRC)
1822: Crcflg=TRUE;
1823: if (firstch==WANTG)
1824: Crcflg=TRUE;
1825: sectnum=1;
1826: while (filbuf(txbuf, blklen)) {
1827: if (wcputsec(txbuf, sectnum, blklen)==ERROR) {
1828: return ERROR;
1829: } else
1830: sectnum++;
1831: }
1832: if (Verbose>1)
1833: fprintf(stderr, " Closing ");
1834: fclose(in);
1835: attempts=0;
1836: do {
1837: logent(" EOT ");
1838: purgeline();
1839: sendline(EOT);
1840: fflush(stdout);
1841: ++attempts;
1842: }
1843: while ((firstch=(readock(100, 2)) != ACK) && attempts < RETRYMAX);
1844: if (attempts == RETRYMAX) {
1845: logent("No ACK on EOT\n");
1846: return ERROR;
1847: }
1848: else
1849: return OK;
1850: }
1851:
1852: wcputsec(buf, sectnum, cseclen)
1853: char *buf;
1854: int sectnum;
1855: int cseclen; /* data length of this sector to send */
1856: {
1857: register checksum, wcj;
1858: register char *cp;
1859: unsigned oldcrc;
1860: int firstch;
1861: int attempts;
1862:
1863: firstch=0; /* part of logic to detect CAN CAN */
1864:
1865: if (Verbose>1)
1866: fprintf(stderr, "\rSector %3d %2dk ", Totsecs, Totsecs/8 );
1867: for (attempts=0; attempts <= RETRYMAX; attempts++) {
1868: Lastrx= firstch;
1869: sendline(cseclen==KSIZE?STX:SOH);
1870: sendline(sectnum);
1871: sendline(-sectnum -1);
1872: oldcrc=checksum=0;
1873: for (wcj=cseclen,cp=buf; --wcj>=0; ) {
1874: sendline(*cp);
1875: oldcrc=updcrc(*cp, oldcrc);
1876: checksum += *cp++;
1877: }
1878: if (Crcflg) {
1879: oldcrc=updcrc(0,updcrc(0,oldcrc));
1880: sendline((int)oldcrc>>8);
1881: sendline((int)oldcrc);
1882: }
1883: else
1884: sendline(checksum);
1885:
1886: if (Optiong) {
1887: firstsec = FALSE; return OK;
1888: }
1889: firstch = readock(400, (Noeofseen&§num) ? 2:1);
1890: gotnak:
1891: switch (firstch) {
1892: case CAN:
1893: if(Lastrx == CAN) {
1894: cancan:
1895: logent("Cancelled\n"); return ERROR;
1896: }
1897: break;
1898: case TIMEOUT:
1899: logent("Timeout on sector ACK\n"); continue;
1900: case WANTCRC:
1901: if (firstsec)
1902: Crcflg = TRUE;
1903: case NAK:
1904: logent("NAK on sector\n"); continue;
1905: case ACK:
1906: firstsec=FALSE;
1907: Totsecs += (cseclen>>7);
1908: return OK;
1909: case ERROR:
1910: logent("Got burst for sector ACK\n"); break;
1911: default:
1912: logent("Got %02x for sector ACK\n", firstch); break;
1913: }
1914: for (;;) {
1915: Lastrx = firstch;
1916: if ((firstch = readock(400, 2)) == TIMEOUT)
1917: break;
1918: if (firstch == NAK || firstch == WANTCRC)
1919: goto gotnak;
1920: if (firstch == CAN && Lastrx == CAN)
1921: goto cancan;
1922: }
1923: }
1924: logent("Retry Count Exceeded\n");
1925: return ERROR;
1926: }
1927:
1928:
1929: /* fill buf with count chars padding with ^Z for CPM */
1930: filbuf(buf, count)
1931: register char *buf;
1932: {
1933: register c, m;
1934: static lfseen=0;
1935:
1936: m=count;
1937: while ((c=getc(in))!=EOF) {
1938: *buf++ =c;
1939: if (--m == 0)
1940: break;
1941: }
1942: if (m==count)
1943: return (Noeofseen=0);
1944: else
1945: while (--m>=0)
1946: *buf++ = CPMEOF;
1947: return count;
1948: }
1949:
1950:
1951: alrm()
1952: {
1953: longjmp(tohere, -1);
1954: }
1955:
1956:
1957: /*
1958: * readock(timeout, count) reads character(s) from file descriptor 0
1959: * (1 <= count <= 3)
1960: * it attempts to read count characters. If it gets more than one,
1961: * it is an error unless all are CAN
1962: * (otherwise, only normal response is ACK, CAN, or C)
1963: * Only looks for one if Optiong, which signifies cbreak, not raw input
1964: *
1965: * timeout is in tenths of seconds
1966: */
1967: readock(timeout, count)
1968: {
1969: register int c;
1970: static char byt[5];
1971:
1972: if (Optiong)
1973: count = 1; /* Special hack for cbreak */
1974:
1975: fflush(stdout);
1976: if (setjmp(tohere)) {
1977: logent("TIMEOUT\n");
1978: return TIMEOUT;
1979: }
1980: c = timeout/10;
1981: if (c<2)
1982: c=2;
1983: if (Verbose>3) {
1984: fprintf(stderr, "Timeout=%d Calling alarm(%d) ", timeout, c);
1985: byt[1] = 0;
1986: }
1987: signal(SIGALRM, alrm); alarm(c);
1988: #ifdef ONEREAD
1989: c=read(iofd, byt, 1); /* regulus raw read is unique */
1990: #else
1991: c=read(iofd, byt, count);
1992: #endif
1993: alarm(0);
1994: if (Verbose>5)
1995: fprintf(stderr, "ret cnt=%d %x %x\n", c, byt[0], byt[1]);
1996: if (c<1)
1997: return TIMEOUT;
1998: if (c==1)
1999: return (byt[0]&0377);
2000: else
2001: while (c)
2002: if (byt[--c] != CAN)
2003: return ERROR;
2004: return CAN;
2005: }
2006:
2007: purgeline()
2008: {
2009: #ifdef USG
2010: ioctl(iofd, TCFLSH, 0);
2011: #else
2012: lseek(iofd, 0L, 2);
2013: #endif
2014: }
2015:
2016: /* update CRC */
2017: unsigned updcrc(c, crc)
2018: register c;
2019: register unsigned crc;
2020: {
2021: register count;
2022:
2023: for (count=8; --count>=0;) {
2024: if (crc & 0x8000) {
2025: crc <<= 1;
2026: crc += (((c<<=1) & 0400) != 0);
2027: crc ^= 0x1021;
2028: }
2029: else {
2030: crc <<= 1;
2031: crc += (((c<<=1) & 0400) != 0);
2032: }
2033: }
2034: return crc;
2035: }
2036:
2037: /* send 10 CAN's to try to get the other end to shut up */
2038: canit()
2039: {
2040: register n;
2041: for (n=10; --n>=0; )
2042: sendline(CAN);
2043: }
2044:
2045: #ifdef REGULUS
2046: /*
2047: * copies count bytes from s to d
2048: * (No structure assignment in Regulus C compiler)
2049: */
2050: movmem(s, d, count)
2051: register char *s, *d;
2052: register count;
2053: {
2054: while (--count >= 0)
2055: *d++ = *s++;
2056: }
2057: #endif
2058:
2059: /*VARARGS1*/
2060: logent(a, b, c)
2061: char *a, *b, *c;
2062: {
2063: if(Verbose)
2064: fprintf(stderr, a, b, c);
2065: }
2066:
2067: /*
2068: * return 1 iff stdout and stderr are different devices
2069: * indicating this program operating with a modem on a
2070: * different line
2071: */
2072: fromcu()
2073: {
2074: struct stat a, b;
2075: fstat(1, &a); fstat(2, &b);
2076: return (a.st_rdev != b.st_rdev);
2077: }
2078:
2079: /*
2080: * substr(string, token) searches for token in string s
2081: * returns pointer to token within string if found, NULL otherwise
2082: */
2083: char *
2084: substr(s, t)
2085: register char *s,*t;
2086: {
2087: register char *ss,*tt;
2088: /* search for first char of token */
2089: for (ss=s; *s; s++)
2090: if (*s == *t)
2091: /* compare token with substring */
2092: for (ss=s,tt=t; ;) {
2093: if (*tt == 0)
2094: return s;
2095: if (*ss++ != *tt++)
2096: break;
2097: }
2098: return NULL;
2099: }
2100:
2101: usage()
2102: {
2103: fprintf(stderr,"%s by Chuck Forsberg\n", VERSION);
2104: fprintf(stderr,"Usage: sb [-17dfkquvX] [-] file ...\n");
2105: fprintf(stderr," 1 Use stdout for all modem i/o\n");
2106: fprintf(stderr," 7 Use 7 bits only\n");
2107: fprintf(stderr," d Change '.' to '/' in pathnames\n");
2108: fprintf(stderr," f Send full pathname\n");
2109: fprintf(stderr," k Send 1024 byte packets\n");
2110: fprintf(stderr," q Quiet (no progress reports)\n");
2111: fprintf(stderr," u Unlink file after transmission\n");
2112: fprintf(stderr," v Verbose - give more information\n");
2113: fprintf(stderr," X XMODEM protocol - send no pathnames\n");
2114: fprintf(stderr,"- as pathname sends standard input, filename=sPID.sb, requires -1 flag\n");
2115: exit(1);
2116: }
2117: SHAR_EOF
2118: cat << \SHAR_EOF > undos.1
2119: .TH UNDOS 1 OMEN
2120: .SH NAME
2121: undos,tounix,todos,tocpm,tomac,unmac \- Change file format for target operating system
2122: .SH SYNOPSIS
2123: .B undos
2124: [
2125: .B -s
2126: ]
2127: file ...
2128: .br
2129: .B tounix
2130: [
2131: .B -s
2132: ]
2133: file ...
2134: .br
2135: .B todos
2136: [
2137: .B -s
2138: ]
2139: file ...
2140: .br
2141: .B tocpm
2142: [
2143: .B -s
2144: ]
2145: file ...
2146: .br
2147: .B unmac
2148: [
2149: .B -s
2150: ]
2151: file ...
2152: .br
2153: .B tomac
2154: [
2155: .B -s
2156: ]
2157: file ...
2158: .SH DESCRIPTION
2159: .B Undos
2160: and
2161: .B tounix
2162: convert DOS or CP/M format source files to Unix format by deleting
2163: carriage returns preceding linefeeds and eliminating characters
2164: starting with CPMEOF (^Z).
2165: .PP
2166: .B Todos
2167: converts Unix format source files to DOS format by adding a carriage return
2168: (if not already present) before each linefeed,
2169: and eliminates characters
2170: starting with CPMEOF (^Z).
2171: .B Tocpm
2172: additionally appends CPMEOF (^Z) characters to the resulting file
2173: to make the file length a multiple of the 128 byte CP/M record length.
2174:
2175: Any combination of
2176: .B undos, todos,
2177: or
2178: .B tocpm
2179: (without flags)
2180: may be applied to a proper ASCII
2181: file without destroying information.
2182: Lone carriage returns used to force overprinting are not translated
2183: to CR/LF pairs.
2184:
2185: .B Unmac
2186: converts files with lines terminated only by carriage return
2187: to Unix format.
2188: .B Unmac
2189: should only be used to translate files whose lines are terminated
2190: by lone carriage returns.
2191:
2192: .B Tomac
2193: converts Unix format files to Macintosh format
2194: (lines terminated by carriage return only).
2195:
2196: The optional flag
2197: .B -s
2198: Strips the parity bit on all characters
2199: and discards all resulting characters with values less than 7.
2200:
2201: The access and modification times of the modified files are set
2202: to those of the original files.
2203: .SH DIAGNOSTICS
2204: Refuses to translate files in which "binary" characters (less than 7
2205: or greater than 127) are seen before CPMEOF.
2206: Refuses to translate files
2207: with ultra long lines.
2208: Refuses to translate special files.
2209: .SH NOTES
2210: Should be executed with the current directory in the same filesystem
2211: as the target files for minimum disk i/o.
2212: .SH BUGS
2213: Does not detect short files without linefeeds.
2214: .B Unmac
2215: and
2216: .B tomac
2217: cannot handle files with CR-only overprinting.
2218: (Files whose lines end with CR only violate the ASCII code!).
2219: .SH SEE ALSO
2220: lar(1), yam(1), sq(1), usq(1), rb(omen), sb(omen)
2221: SHAR_EOF
2222: cat << \SHAR_EOF > undos.c
2223: /*% cc -O -K % -o undos
2224: *
2225: * Undos - change DOS format files to Unix, etc.
2226: */
2227: char ID[] =
2228: "Undos Rev 12-07-85 (C)Copyright Omen Technology Inc All Rights Reserved\n";
2229: /*
2230: * This program and documentation may be copied, used, or modified
2231: * by Professional-YAM and POWERCOMM licensees provided these notices are
2232: * not removed. Others may use this program for non-profit purposes only.
2233: */
2234:
2235: #include <stdio.h>
2236: #include <sys/types.h>
2237: #include <sys/stat.h>
2238:
2239: #define LL 1024
2240: #define SUB 032
2241:
2242: char Lbuf[LL];
2243: char *Progname;
2244: int Todos = 0;
2245: int Tocpm = 0;
2246: int Tomac = 0;
2247: int Unmac = 0;
2248: int Strip = 0;
2249:
2250: main(argc, argv)
2251: char **argv;
2252: {
2253: Progname = *argv;
2254: if (! strcmp(Progname, "tocpm"))
2255: Todos = Tocpm = 1;
2256: if (! strcmp(Progname, "todos"))
2257: Todos = 1;
2258: if (! strcmp(Progname, "unmac"))
2259: Unmac = 1;
2260: if (! strcmp(Progname, "tomac"))
2261: Tomac = 1;
2262:
2263: if (! strcmp(argv[1], "-s")) {
2264: ++Strip; --argc; ++argv;
2265: }
2266:
2267:
2268: if (argc<2 || *argv[1]== '-')
2269: usage();
2270: while (--argc >= 1)
2271: chngfmt(*++argv);
2272: exit(0);
2273: }
2274: usage()
2275: {
2276: fprintf(stderr, ID);
2277: fprintf(stderr, "Usage: {undos|tounix|todos|tocpm|unmac} [-s] file ...\n");
2278: fprintf(stderr, " -s Strip parity bit, ignore bytes < 007\n");
2279: exit(1);
2280: }
2281:
2282:
2283: chngfmt(name)
2284: char *name;
2285: {
2286: register c;
2287: register char *p;
2288: register n;
2289: register long fpos;
2290: struct stat st;
2291: FILE *fin, *fout;
2292: int linno = 0;
2293: long ftell();
2294: char *mktemp();
2295: char outnam[64];
2296:
2297: if (stat(name, &st)) {
2298: xperror(name); return;
2299: }
2300: if ((st.st_mode & S_IFMT) != S_IFREG) {
2301: fprintf(stderr, "%s: %s is not a regular file\n", Progname, name);
2302: return;
2303: }
2304: if ((fin = fopen(name, "r")) == NULL) {
2305: xperror(name); return;
2306: }
2307: strcpy(outnam, "undosXXXXXX");
2308: mktemp(outnam);
2309: if ((fout = fopen(outnam, "w")) == NULL) {
2310: xperror(outnam); exit(1);
2311: }
2312:
2313: for (;;) {
2314: ++linno;
2315: for (p=Lbuf, n=LL; --n>0; ) {
2316: ignore:
2317: if ((c = getc(fin)) == EOF)
2318: break;
2319: if ( !c)
2320: goto ignore;
2321: if (c < '\7' || (c & 0200)) {
2322: if (Strip) {
2323: if ((c &= 0177) < 7)
2324: goto ignore;
2325: } else
2326: goto thisbin;
2327: }
2328: if (c == SUB)
2329: break;
2330: if (c == '\r' && Unmac)
2331: c = '\n';
2332: *p++ = c;
2333: if (c == '\n')
2334: break;
2335: }
2336: *p = '\0';
2337:
2338: if (n == 0) {
2339: thisbin:
2340: if (n) {
2341: fprintf(stderr, "%s: %s is a binary file", Progname, name);
2342: fprintf(stderr, " line=%d char =%2X\n", linno, c);
2343: } else
2344: fprintf(stderr, "%s: %s has no linefeeds: try unmac?\n", Progname, name);
2345: fclose(fout);
2346: unlink(outnam);
2347: return;
2348: }
2349:
2350: if (Todos) {
2351: if (*--p == '\n' && p[-1] != '\r') {
2352: *p++ = '\r'; *p++ = '\n'; *p = 0;
2353: }
2354: } else if (Tomac) {
2355: if (*--p == '\n') {
2356: if (p[-1] == '\r')
2357: --p;
2358: *p++ = '\r'; *p = 0;
2359: }
2360: } else {
2361: if (*--p == '\n' && *--p == '\r') {
2362: *p++ = '\n'; *p = 0;
2363: }
2364: }
2365: if (fputs(Lbuf, fout) == EOF) {
2366: xperror(outnam); exit(1);
2367: }
2368: switch (c) {
2369: case EOF:
2370: if (ferror(fin)) {
2371: xperror(name); exit(0200);
2372: }
2373: case SUB:
2374: if (Tocpm) {
2375: fpos = ftell(fout);
2376: do {
2377: putc(SUB, fout);
2378: } while (++fpos & 127);
2379: }
2380: fclose(fout); fclose(fin);
2381: if (st.st_nlink > 1)
2382: sprintf(Lbuf, "cp %s %s", outnam, name);
2383: else
2384: sprintf(Lbuf, "mv %s %s", outnam, name);
2385: system(Lbuf);
2386: utime(name, (struct utimbuf *) &st.st_atime);
2387: if (st.st_nlink > 1)
2388: unlink(outnam);
2389: return;
2390: }
2391: }
2392: }
2393:
2394: xperror(s)
2395: char *s;
2396: {
2397: register char *p;
2398: extern int sys_nerr;
2399: extern char *sys_errlist[];
2400: extern errno;
2401:
2402: if (errno >= sys_nerr)
2403: p = "Gloryovsky: a New Error!";
2404: else
2405: p = sys_errlist[errno];
2406: fprintf(stderr, "%s: %s: %s\n", Progname, s, p);
2407: }
2408: SHAR_EOF
2409: # End of shell archive
2410: exit 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.