// Zmodlib.cpp // Zmodem library functions #include "stdafx.h" #include "Rzsz.h" #include "Crctab.h" // Global variables FILE *in; FILE *fout; FILE *popen(); char Pathname[PATHLEN]; char *Progname; /* the name by which we were called */ char *qbf="The quick brown fox jumped over the lazy dog's back 1234567890\r\n"; char *substr(); int Cmdtries = 11; int Rxtimeout = 100; int Wantfcs32 = TRUE; /* want to send 32 bit FCS */ int Zmodem=0; /* ZMODEM protocol requested */ int Lastrx; int Crcflg; int Firstsec; int Eofseen; /* indicates cpm eof (^Z) has been received */ int errors; int Restricted=0; /* restricted; no /.. or ../ in filenames */ int Readnum = HOWMANY; long Bytesleft; /* number of bytes of incoming file left */ long Modtime; /* Unix style mod time for incoming file */ int Filemode; /* Unix style mode for incoming file */ int Batch=0; int Topipe=0; int MakeLCPathname=TRUE; /* make received pathname lower case */ int Verbose=0; int Quiet=0; /* overrides logic that would otherwise set verbose */ int Nflag = 0; /* Don't really transfer files */ int Rxclob=FALSE; /* Clobber existing file */ int Rxbinary=FALSE; /* receive all files in bin mode */ int Rxascii=FALSE; /* receive files in ascii (translate) mode */ int Thisbinary; /* current file is to be received in bin mode */ int Blklen = 1024; /* record length of received packets */ int Ascii; char secbuf[1025]; char linbuf[HOWMANY]; int Lleft=0; /* number of characters in linbuf */ time_t timep[2]; char Lzmanag; /* Local file management request */ char zconv; /* ZMODEM file conversion request */ char zmanag; /* ZMODEM file management request */ char ztrans; /* ZMODEM file transport request */ int Zctlesc; /* Encode control characters */ int Zrwindow = 1400; /* RX window size (controls garbage count) */ int tryzhdrtype=ZRINIT; /* Header type to send corresponding to Last rx close */ unsigned Txwindow; /* Control the size of the transmitted window */ unsigned Txwspac; /* Spacing between zcrcq requests */ unsigned Txwcnt; /* Counter used to space ack requests */ long Lrxpos; /* Receiver's last reported offset */ char *substr(), *getenv(); int Filesleft; long Totalleft; char txbuf[1024]; long vpos = 0; /* Number of bytes read from file */ int Optiong; /* Let it rip no wait for sector ACK's */ int Totsecs; /* total number of sectors this file */ int Filcnt=0; /* count of number of files opened */ int Lfseen=0; unsigned Rxbuflen = 16384; /* Receiver's max buffer length */ int Tframlen = 0; /* Override for tx frame length */ long bytcnt; char Lzconv; /* Local ZMODEM file conversion request */ int Lskipnocor; char Lztrans; int Command; /* Send a command, then exit. */ char *Cmdstr; /* Pointer to the command string */ int Cmdack1; /* Rx ACKs command, then do it */ int Exitcode; int Test; /* 1= Force receiver to send Attn, etc with qbf. */ /* 2= Character transparency test */ long Lastsync; /* Last offset to which we got a ZRPOS */ int Beenhereb4; /* How many times we've been ZRPOS'd same place */ /* Globals used by ZMODEM functions */ int Rxflags = 0; int Rxframeind; /* ZBIN ZBIN32, or ZHEX type of frame received */ int Rxtype; /* Type of header received */ int Rxcount; /* Count of data bytes received */ char Rxhdr[4]; /* Received header */ char Txhdr[4]; /* Transmitted header */ long Rxpos; /* Received file position */ long Txpos; /* Transmitted file position */ int Txfcs32 = TRUE; /* TRUE means send binary frames with 32 bit FCS */ int Crc32t; /* Display flag indicating 32 bit CRC being sent */ int Crc32; /* Display flag indicating 32 bit CRC being received */ int Znulls; /* Number of nulls to send at beginning of ZDATA hdr */ char Attn[ZATTNLEN+1]; /* Attention string rx sends to tx on err */ static lastsent; /* Last char we sent */ static Not8bit; /* Seven bits seen on header */ static char *frametypes[] = { "Carrier Lost", /* -3 */ "TIMEOUT", /* -2 */ "ERROR", /* -1 */ #define FTOFFSET 3 "ZRQINIT", "ZRINIT", "ZSINIT", "ZACK", "ZFILE", "ZSKIP", "ZNAK", "ZABORT", "ZFIN", "ZRPOS", "ZDATA", "ZEOF", "ZFERR", "ZCRC", "ZCHALLENGE", "ZCOMPL", "ZCAN", "ZFREECNT", "ZCOMMAND", "ZSTDERR", "xxxxx" #define FRTYPES 22 /* Total number of frame types in this array */ /* not including psuedo negative entries */ }; static char badcrc[] = "Bad CRC"; /* * rz.c By Chuck Forsberg * Copyright 2001 Omen Technology INC All Rights Reserved * Part of the ZMODEM Developer's Collection * VERSION "2.05a 06-27-2001" */ /* * Initialize for Zmodem receive attempt, try to activate Zmodem sender * Handles ZSINIT frame * Return ZFILE if Zmodem filename received, -1 on error, * ZCOMPL if transaction finished, else 0 */ int tryz(void) { int c, n, cmdzack1flg; for (n=Zmodem?15:5; --n>=0; ) { /* Set buffer length (0) and capability flags */ stohdr(0L); Txhdr[ZF0] = CANFC32|CANFDX|CANOVIO; if (Zctlesc) Txhdr[ZF0] |= TESCCTL; zshhdr(tryzhdrtype, Txhdr); if (tryzhdrtype == ZSKIP) /* Don't skip too far */ tryzhdrtype = ZRINIT; /* CAF 8-21-87 */ again: switch (zgethdr(Rxhdr, 0)) { case ZRQINIT: continue; case ZEOF: continue; case TIMEOUT: continue; case ZFILE: zconv = Rxhdr[ZF0]; zmanag = Rxhdr[ZF1]; ztrans = Rxhdr[ZF2]; tryzhdrtype = ZRINIT; c = zrdata(secbuf, 1024); // mode(3); if (c == GOTCRCW) return ZFILE; zshhdr(ZNAK, Txhdr); goto again; case ZSINIT: Zctlesc = TESCCTL & Rxhdr[ZF0]; if (zrdata(Attn, ZATTNLEN) == GOTCRCW) { stohdr(1L); zshhdr(ZACK, Txhdr); goto again; } zshhdr(ZNAK, Txhdr); goto again; case ZFREECNT: // stohdr(getfree()); zshhdr(ZACK, Txhdr); goto again; case ZCOMMAND: cmdzack1flg = Rxhdr[ZF0]; if (zrdata(secbuf, 1024) == GOTCRCW) { if (cmdzack1flg & ZCACK1) stohdr(0L); else // stohdr((long)sys2(secbuf)); // purgeline(); /* dump impatient questions */ do { zshhdr(ZCOMPL, Txhdr); } while (++errors<20 && zgethdr(Rxhdr,1) != ZFIN); ackbibi(); // if (cmdzack1flg & ZCACK1) // exec2(secbuf); return ZCOMPL; } zshhdr(ZNAK, Txhdr); goto again; case ZCOMPL: goto again; default: continue; case ZFIN: ackbibi(); return ZCOMPL; case ZCAN: return ZERR; } } return 0; } /*******************************************************/ /* * Receive 1 or more files with ZMODEM protocol */ int rzfiles(void) { register c; for (;;) { switch (c = rzfile()) { case ZEOF: case ZSKIP: case ZFERR: switch (tryz()) { case ZCOMPL: return OK; default: return ZERR; case ZFILE: break; } continue; default: return c; case ERROR: return ZERR; } } } /********************************************************/ /* * Receive a file with ZMODEM protocol * Assumes file name frame is in secbuf */ int rzfile(void) { register c, n; long rxbytes; Eofseen=FALSE; if (procheader(secbuf) == ZERR) { return (tryzhdrtype = ZSKIP); } n = 20; rxbytes = 0l; for (;;) { #ifdef SEGMENTS chinseg = 0; #endif stohdr(rxbytes); zshhdr(ZRPOS, Txhdr); nxthdr: switch (c = zgethdr(Rxhdr, 0)) { default: // vfile("rzfile: zgethdr returned %d", c); return ZERR; case ZNAK: case TIMEOUT: #ifdef SEGMENTS putsec(secbuf, chinseg); chinseg = 0; #endif if ( --n < 0) { // vfile("rzfile: zgethdr returned %d", c); return ZERR; } continue; case ZFILE: zrdata(secbuf, 1024); continue; case ZEOF: #ifdef SEGMENTS putsec(secbuf, chinseg); chinseg = 0; #endif if (rclhdr(Rxhdr) != rxbytes) { /* * Ignore eof if it's at wrong place - force * a timeout because the eof might have gone * out before we sent our zrpos. */ errors = 0; goto nxthdr; } if (closeit()) { tryzhdrtype = ZFERR; // vfile("rzfile: closeit returned <> 0"); return ZERR; } // vfile("rzfile: normal EOF"); return c; case ZERR: /* Too much garbage in header search error */ #ifdef SEGMENTS putsec(secbuf, chinseg); chinseg = 0; #endif if ( --n < 0) { // vfile("rzfile: zgethdr returned %d", c); return ZERR; } zmputs(Attn); continue; case ZSKIP: #ifdef SEGMENTS putsec(secbuf, chinseg); chinseg = 0; #endif closeit(); // vfile("rzfile: Sender SKIPPED file"); return c; case ZDATA: if (rclhdr(Rxhdr) != rxbytes) { if ( --n < 0) { return ZERR; } #ifdef SEGMENTS putsec(secbuf, chinseg); chinseg = 0; #endif zmputs(Attn); continue; } moredata: if (Verbose>1) fprintf(stderr, "\r%7ld ZMODEM%s ", rxbytes, Crc32?" CRC-32":""); #ifdef SEGMENTS if (chinseg >= (1024 * SEGMENTS)) { putsec(secbuf, chinseg); chinseg = 0; } switch (c = zrdata(secbuf+chinseg, 1024)) #else switch (c = zrdata(secbuf, 1024)) #endif { case ZCAN: #ifdef SEGMENTS putsec(secbuf, chinseg); chinseg = 0; #endif // vfile("rzfile: zgethdr returned %d", c); return ZERR; case ERROR: /* CRC error */ #ifdef SEGMENTS putsec(secbuf, chinseg); chinseg = 0; #endif if ( --n < 0) { // vfile("rzfile: zgethdr returned %d", c); return ZERR; } zmputs(Attn); continue; case TIMEOUT: #ifdef SEGMENTS putsec(secbuf, chinseg); chinseg = 0; #endif if ( --n < 0) { // vfile("rzfile: zgethdr returned %d", c); return ZERR; } continue; case GOTCRCW: n = 20; #ifdef SEGMENTS chinseg += Rxcount; putsec(secbuf, chinseg); chinseg = 0; #else putsec(secbuf, Rxcount); #endif rxbytes += Rxcount; stohdr(rxbytes); zshhdr(ZACK, Txhdr); sendline(XON); goto nxthdr; case GOTCRCQ: n = 20; #ifdef SEGMENTS chinseg += Rxcount; #else putsec(secbuf, Rxcount); #endif rxbytes += Rxcount; stohdr(rxbytes); zshhdr(ZACK, Txhdr); goto moredata; case GOTCRCG: n = 20; #ifdef SEGMENTS chinseg += Rxcount; #else putsec(secbuf, Rxcount); #endif rxbytes += Rxcount; goto moredata; case GOTCRCE: n = 20; #ifdef SEGMENTS chinseg += Rxcount; #else putsec(secbuf, Rxcount); #endif rxbytes += Rxcount; goto nxthdr; } } } } /* * This version of readline is reasoably well suited for * reading many characters. * (except, currently, for the Regulus version!) * * timeout is in tenths of seconds */ readline(int timeout) { register n; static char *cdq; /* pointer for removing chars from linbuf */ if (--Lleft >= 0) { if (Verbose > 8) { fprintf(stderr, "%02x ", *cdq&0377); } return (*cdq++ & 0377); } n = timeout/10; if (n < 2) n = 3; if (Verbose > 5) fprintf(stderr, "Calling read: alarm=%d Readnum=%d ", n, Readnum); if (Verbose > 5) { fprintf(stderr, "Read returned %d bytes\n", Lleft); } if (Lleft < 1) return TIMEOUT; --Lleft; if (Verbose > 8) { fprintf(stderr, "%02x ", *cdq&0377); } return (*cdq++ & 0377); } /* * Process incoming file information header */ int procheader(char *name) { char *openmode, *p; /* set default parameters and overrides */ openmode = "w"; Thisbinary = (!Rxascii) || Rxbinary; if (Lzmanag) zmanag = Lzmanag; /* * Process ZMODEM remote file management requests */ if (!Rxbinary && zconv == ZCNL) /* Remote ASCII override */ Thisbinary = 0; if (zconv == ZCBIN) /* Remote Binary override */ Thisbinary = TRUE; else if (zmanag == ZMAPND) openmode = "a"; Bytesleft = DEFBYTL; Filemode = 0; Modtime = 0L; p = name + 1 + strlen(name); if (*p) { /* file coming from Unix or DOS system */ sscanf(p, "%ld%lo%o", &Bytesleft, &Modtime, &Filemode); /* Remove this if not running on a Unix like system */ if (Filemode & UNIXFILE) ++Thisbinary; if (Verbose) { fprintf(stderr, "Incoming: %s %ld %lo %o\n", name, Bytesleft, Modtime, Filemode); } } else { /* File coming from CP/M system */ for (p=name; *p; ++p) /* change / to _ */ if ( *p == '/') *p = '_'; if ( *--p == '.') /* zap trailing period */ *p = 0; } if (Topipe > 0) { sprintf(Pathname, "%s %s", Progname+2, name); if (Verbose) fprintf(stderr, "Topipe: %s %s\n", Pathname, Thisbinary?"BIN":"ASCII"); } else { strcpy(Pathname, name); if (Verbose) { fprintf(stderr, "Receiving %s %s %s\n", name, Thisbinary?"BIN":"ASCII", openmode); } fout = fopen(name, openmode); if ( !fout) { tryzhdrtype = ZFERR; return ZERR; } } return OK; } /*****************************************************/ /* void sendline(char c) { char d; d = c; if (Verbose>6) fprintf(stderr, "Sendline: %x\n", c); write(1, &d, 1); } */ /* * substr(string, token) searches for token in string s * returns pointer to token within string if found, NULL otherwise */ char *substr(char *s, char *t) { char *ss,*tt; /* search for first char of token */ for (ss=s; *s; s++) if (*s == *t) /* compare token with substring */ for (ss=s,tt=t; ;) { if (*tt == 0) return s; if (*ss++ != *tt++) break; } return NULL; } /********************************************************************/ /* * Send a string to the modem, processing for \336 (sleep 1 sec) * and \335 (break signal) */ void zmputs(char *s) { register c; while (*s) { switch (c = *s++) { case '\336': sleep(1); continue; case '\335': // sendbrk(); continue; default: sendline(c); } } } /*********************************************************/ /* * Close the receive dataset, return OK or ZERR */ int closeit(void) { time_t time(); /* if (Topipe) { if (pclose(fout)) { return ZERR; } return OK; } */ if (fclose(fout)==ERROR) { fprintf(stderr, "file close ERROR\n"); return ZERR; } /* if (Modtime) { timep[0] = time(NULL); timep[1] = Modtime; utime(Pathname, timep); } if ((Filemode&S_IFMT) == S_IFREG) chmod(Pathname, (07777 & Filemode)); */ return OK; } /*********************************************************/ /* * Ack a ZFIN packet, let byegones be byegones */ void ackbibi(void) { int n; // vfile("ackbibi:"); Readnum = 1; stohdr(0L); for (n=3; --n>=0; ) { // purgeline(); zshhdr(ZFIN, Txhdr); switch (readline(100)) { case 'O': readline(1); /* Discard 2nd 'O' */ // vfile("ackbibi complete"); return; case RCDO: return; case TIMEOUT: default: break; } } } /* * Putsec writes the n characters of buf to receive file fout. * If not in binary mode, carriage returns, and all characters * starting with CPMEOF are discarded. * This routine is specific to Unix like systems!!! */ int putsec(char *buf, int n) { register char *p; if (n == 0) return OK; if (Thisbinary) { for (p=buf; --n>=0; ) putc( *p++, fout); } else { if (Eofseen) return OK; for (p=buf; --n>=0; ++p ) { if ( *p == '\r') continue; if (*p == CPMEOF) { Eofseen=TRUE; return OK; } putc(*p ,fout); } } return OK; } /******************************************************/ /* * Strip leading ! if present, do shell escape. */ int sys2(char *s) { if (*s == '!') ++s; return system(s); } /* End of rz.c */ /**************************************************************************** * * sz.c By Chuck Forsberg, Omen Technology INC * Copyright 2001 Omen Technology INC All Rights Reserved * Part of the ZMODEM Developer's Collection * VERSION "sz 2.17b 07-31-2002" ****************************************************************************/ /* called by signal interrupt or terminate to clean things up */ void bibi(int n) { canit(); fflush(stdout); fprintf(stderr, "sz: caught signal %d; exiting\n", n); // cucheck(); exit(128+n); } /* Called when ZMODEM gets an interrupt (^X) */ void onintr(void) { // signal(SIGINT, SIG_IGN); // longjmp(intrjmp, -1); } /*******************************************************/ int wcs(char *oname) { char name[PATHLEN]; strcpy(name, oname); if ((in=fopen(oname, "r"))==NULL) { return ZERR; } switch (wctxpn(name)) { case ZSKIP: case ZFERR: return OK; case OK: break; default: return ZERR; } return 0; } /* * generate and transmit pathname block consisting of * pathname (null terminated), * file length, mode time and file mode in octal * as provided by the Unix fstat call. * N.B.: modifies the passed name, may extend it! */ int wctxpn(char *name) { char *p; zsendfile(txbuf, ((int)1+strlen(p)+(p-txbuf))); return OK; } /***************************************************************/ getnak() { register firstch; Lastrx = 0; for (;;) { switch (firstch = readline(800)) { case ZPAD: if (getzrxinit()) return ZERR; Ascii = 0; /* Receiver does the conversion */ return FALSE; case TIMEOUT: // zperr("Timeout on pathname"); return TRUE; case WANTG: #ifdef MODE2OK mode(2); /* Set cbreak, XON/XOFF, etc. */ #endif Optiong = TRUE; Blklen=1024; case WANTCRC: Crcflg = TRUE; case NAK: return FALSE; case CAN: if ((firstch = readline(20)) == CAN && Lastrx == CAN) return TRUE; default: break; } Lastrx = firstch; } } /**************************************************************/ wctx(long flen) { register int thisblklen; register int sectnum, attempts, firstch; long charssent; charssent = 0; Firstsec=TRUE; thisblklen = Blklen; // vfile("wctx:file length=%ld", flen); while ((firstch=readline(Rxtimeout))!=NAK && firstch != WANTCRC && firstch != WANTG && firstch!=TIMEOUT && firstch!=CAN) ; if (firstch==CAN) { // zperr("Receiver CANcelled"); return ZERR; } if (firstch==WANTCRC) Crcflg=TRUE; if (firstch==WANTG) Crcflg=TRUE; sectnum=0; for (;;) { if (flen <= (charssent + 896L)) thisblklen = 128; // if ( !filbuf(txbuf, thisblklen)) // break; if (wcputsec(txbuf, ++sectnum, thisblklen)==ERROR) return ZERR; charssent += thisblklen; } fclose(in); attempts=0; do { // purgeline(); sendline(EOT); fflush(stdout); ++attempts; } while ((firstch=(readline(Rxtimeout)) != ACK) && attempts < RETRYMAX); if (attempts == RETRYMAX) { // zperr("No ACK on EOT"); return ZERR; } else return OK; } int wcputsec(char *buf, int sectnum, int cseclen) { register checksum, wcj; register char *cp; unsigned oldcrc; int firstch; int attempts; firstch=0; /* part of logic to detect CAN CAN */ if (Verbose>2) fprintf(stderr, "Sector %3d %2dk\n", Totsecs, Totsecs/8 ); else if (Verbose>1) fprintf(stderr, "\rSector %3d %2dk ", Totsecs, Totsecs/8 ); for (attempts=0; attempts <= RETRYMAX; attempts++) { Lastrx= firstch; sendline(cseclen==1024?STX:SOH); sendline(sectnum); sendline(-sectnum -1); oldcrc=checksum=0; for (wcj=cseclen,cp=buf; --wcj>=0; ) { sendline(*cp); oldcrc=updcrc((0377& *cp), oldcrc); checksum += *cp++; } if (Crcflg) { oldcrc=updcrc(0,updcrc(0,oldcrc)); sendline((int)oldcrc>>8); sendline((int)oldcrc); } else sendline(checksum); if (Optiong) { Firstsec = FALSE; return OK; } firstch = readline(Rxtimeout); gotnak: switch (firstch) { case CAN: if(Lastrx == CAN) { cancan: printf("Cancelled"); return ZERR; } break; case TIMEOUT: zperr("Timeout on sector ACK"); continue; case WANTCRC: if (Firstsec) Crcflg = TRUE; case NAK: zperr("NAK on sector"); continue; case ACK: Firstsec=FALSE; Totsecs += (cseclen>>7); return OK; case ERROR: zperr("Got burst for sector ACK"); break; default: zperr("Got %02x for sector ACK"); break; } for (;;) { Lastrx = firstch; if ((firstch = readline(Rxtimeout)) == TIMEOUT) break; if (firstch == NAK || firstch == WANTCRC) goto gotnak; if (firstch == CAN && Lastrx == CAN) goto cancan; } } // zperr("Retry Count Exceeded"); return ZERR; } /* Fill buffer with blklen chars */ int zfilbuf(void) { int n; n = fread(txbuf, 1, Blklen, in); if (n < Blklen) Eofseen = 1; return n; } /**************************************************************/ /* send cancel string to get the other end to shut up */ void canit(void) { static char canistr[] = { 24,24,24,24,24,24,24,24,24,24,8,8,8,8,8,8,8,8,8,8,0 }; printf(canistr); fflush(stdout); } /* * Get the receiver's init parameters */ int getzrxinit(void) { register n; for (n=10; --n>=0; ) { switch (zgethdr(Rxhdr, 1)) { case ZCHALLENGE: /* Echo receiver's challenge numbr */ stohdr(Rxpos); zshhdr(ZACK, Txhdr); continue; case ZCOMMAND: /* They didn't see out ZRQINIT */ stohdr(0L); zshhdr(ZRQINIT, Txhdr); continue; case ZRINIT: Rxflags = 0377 & Rxhdr[ZF0]; Txfcs32 = (Wantfcs32 && (Rxflags & CANFC32)); Zctlesc |= Rxflags & TESCCTL; Rxbuflen = (0377 & Rxhdr[ZP0])+((0377 & Rxhdr[ZP1])<<8); if ( !(Rxflags & CANFDX)) Txwindow = 0; // vfile("Rxbuflen=%d Tframlen=%d", Rxbuflen, Tframlen); // if ( !Fromcu) // signal(SIGINT, SIG_IGN); /* Override to force shorter frame length */ if (Rxbuflen && (Rxbuflen>Tframlen) && (Tframlen>=32)) Rxbuflen = Tframlen; if ( !Rxbuflen && (Tframlen>=32) && (Tframlen<=1024)) Rxbuflen = Tframlen; // vfile("Rxbuflen=%d", Rxbuflen); case ZCAN: case TIMEOUT: return ZERR; case ZRQINIT: if (Rxhdr[ZF0] == ZCOMMAND) continue; default: zshhdr(ZNAK, Txhdr); continue; } } return ZERR; } /* Send send-init information */ sendzsinit() { register c; // if (Myattn[0] == '\0' && (!Zctlesc || (Rxflags & TESCCTL))) // return OK; errors = 0; for (;;) { stohdr(0L); if (Zctlesc) { Txhdr[ZF0] |= TESCCTL; zshhdr(ZSINIT, Txhdr); } else zsbhdr(ZSINIT, Txhdr); // zsdata(Myattn, 1+strlen(Myattn), ZCRCW); c = zgethdr(Rxhdr, 1); switch (c) { case ZCAN: return ZERR; case ZACK: return OK; default: if (++errors > 19) return ZERR; continue; } } } /**********************************************************/ /* Send file name and related info */ int zsendfile(char *buf, int blen) { int c; long crc; for (;;) { Txhdr[ZF0] = Lzconv; /* file conversion request */ Txhdr[ZF1] = Lzmanag; /* file management request */ if (Lskipnocor) Txhdr[ZF1] |= ZMSKNOLOC; Txhdr[ZF2] = Lztrans; /* file transport request */ Txhdr[ZF3] = 0; zsbhdr(ZFILE, Txhdr); zsdata(buf, blen, ZCRCW); again: c = zgethdr(Rxhdr, 1); switch (c) { case ZRINIT: while ((c = readline(50)) > 0) if (c == ZPAD) { goto again; } continue; default: case ZCAN: case TIMEOUT: case ZABORT: case ZFIN: return ZERR; case ZCRC: crc = 0xFFFFFFFFL; while (((c = getc(in)) != EOF) && --Rxpos) crc = UPDC32(c, crc); crc = ~crc; clearerr(in); /* Clear EOF */ fseek(in, 0L, 0); stohdr(crc); zsbhdr(ZCRC, Txhdr); goto again; case ZSKIP: case ZFERR: fclose(in); return c; case ZRPOS: /* * Suppress zcrcw request otherwise triggered by * lastyunc==bytcnt */ if (Rxpos && fseek(in, Rxpos, 0)) return ZERR; Lastsync = (bytcnt = Txpos = Rxpos) -1; return zsendfdata(); } } } /* Send the data in the file */ int zsendfdata(void) { register c, e, n; register newcnt; register long tcount = 0; int junkcount; /* Counts garbage chars received by TX */ static int tleft = 6; /* Counter for test mode */ Lrxpos = 0; junkcount = 0; Beenhereb4 = FALSE; somemore: if (0) { waitack: junkcount = 0; c = getinsync(0); gotack: switch (c) { default: case ZCAN: fclose(in); return ZERR; case ZSKIP: fclose(in); return c; case ZACK: case ZRPOS: break; case ZRINIT: fclose(in); return OK; } #ifdef READCHECK /* * If the reverse channel can be tested for data, * this logic may be used to detect error packets * sent by the receiver, in place of setjmp/longjmp * rdchk(fdes) returns non 0 if a character is available */ while (rdchk(0)) { #ifdef SV switch (checked) #else switch (readline(1)) #endif { case CAN: case ZPAD: c = getinsync(1); goto gotack; case XOFF: /* Wait a while for an XON */ case XOFF|0200: readline(100); } } #endif } // if ( !Fromcu) // signal(SIGINT, onintr); newcnt = Rxbuflen; Txwcnt = 0; stohdr(Txpos); zsbhdr(ZDATA, Txhdr); /* * Special testing mode. This should force receiver to Attn,ZRPOS * many times. Each time the signal should be caught, causing the * file to be started over from the beginning. */ if (Test) { if ( --tleft) while (tcount < 20000) { printf(qbf); fflush(stdout); tcount += strlen(qbf); #ifdef READCHECK while (rdchk(0)) { #ifdef SV switch (checked) #else switch (readline(1)) #endif { case CAN: case ZPAD: #ifdef TCFLSH ioctl(0, TCFLSH, 1); #endif goto waitack; case XOFF: /* Wait for XON */ case XOFF|0200: readline(100); } } #endif } // signal(SIGINT, SIG_IGN); canit(); // sleep(3); purgeline(); mode(0); printf("\nsz: Tcount = %ld\n", tcount); if (tleft) { printf("ERROR: Interrupts Not Caught\n"); exit(1); } exit(0); } do { n = zfilbuf(); if (Eofseen) e = ZCRCE; else if (junkcount > 3) e = ZCRCW; else if (bytcnt == Lastsync) e = ZCRCW; else if (Rxbuflen && (newcnt -= n) <= 0) e = ZCRCW; else if (Txwindow && (Txwcnt += n) >= Txwspac) { Txwcnt = 0; e = ZCRCQ; } else e = ZCRCG; if (Verbose>1) fprintf(stderr, "\r%7ld ZMODEM%s ", Txpos, Crc32t?" CRC-32":""); zsdata(txbuf, n, e); bytcnt = Txpos += n; if (e == ZCRCW) goto waitack; #ifdef READCHECK /* * If the reverse channel can be tested for data, * this logic may be used to detect error packets * sent by the receiver, in place of setjmp/longjmp * rdchk(fdes) returns non 0 if a character is available */ fflush(stdout); while (rdchk(0)) { #ifdef SV switch (checked) #else switch (readline(1)) #endif { case CAN: case ZPAD: c = getinsync(1); if (c == ZACK) break; #ifdef TCFLSH ioctl(0, TCFLSH, 1); #endif /* zcrce - dinna wanna starta ping-pong game */ zsdata(txbuf, 0, ZCRCE); goto gotack; case XOFF: /* Wait a while for an XON */ case XOFF|0200: readline(100); default: ++junkcount; } } #endif /* READCHECK */ if (Txwindow) { while ((tcount = Txpos - Lrxpos) >= Txwindow) { // vfile("%ld window >= %u", tcount, Txwindow); if (e != ZCRCQ) zsdata(txbuf, 0, e = ZCRCQ); c = getinsync(1); if (c != ZACK) { #ifdef TCFLSH ioctl(0, TCFLSH, 1); #endif zsdata(txbuf, 0, ZCRCE); goto gotack; } } // vfile("window = %ld", tcount); } } while (!Eofseen); // if ( !Fromcu) // signal(SIGINT, SIG_IGN); for (;;) { stohdr(Txpos); zsbhdr(ZEOF, Txhdr); egotack: switch (getinsync(0)) { case ZACK: goto egotack; case ZRPOS: goto somemore; case ZRINIT: fclose(in); return OK; case ZSKIP: fclose(in); return ZSKIP; default: fclose(in); return ZERR; } } } /* * Respond to receiver's complaint, get back in sync with receiver */ int getinsync(int flag) { int c; for (;;) { if (Test) { printf("\r\n\n\n***** Signal Caught *****\r\n"); Rxpos = 0; c = ZRPOS; } else c = zgethdr(Rxhdr, 0); switch (c) { case ZCAN: case ZABORT: case ZFIN: case TIMEOUT: return ZERR; case ZRPOS: /* ************************************* */ /* If sending to a buffered modem, you */ /* might send a break at this point to */ /* dump the modem's buffer. */ clearerr(in); /* In case file EOF seen */ if (fseek(in, Rxpos, 0)) return ZERR; Eofseen = 0; bytcnt = Lrxpos = Txpos = Rxpos; if (Lastsync == Rxpos) { if (++Beenhereb4 > 4) if (Blklen > 32) Blklen /= 2; } Lastsync = Rxpos; return c; case ZACK: Lrxpos = Rxpos; if (flag || Txpos == Rxpos) return ZACK; continue; case ZRINIT: case ZSKIP: fclose(in); return c; case ERROR: default: zsbhdr(ZNAK, Txhdr); continue; } } } /* Say "bibi" to the receiver, try to do it cleanly */ void saybibi(void) { for (;;) { stohdr(0L); /* CAF Was zsbhdr - minor change */ zshhdr(ZFIN, Txhdr); /* to make debugging easier */ switch (zgethdr(Rxhdr, 0)) { case ZFIN: sendline('O'); sendline('O'); case ZCAN: case TIMEOUT: return; } } } /* Send command and related info */ int zsendcmd(char *buf, int blen) { register c; long cmdnum; // cmdnum = getpid(); errors = 0; for (;;) { stohdr(cmdnum); Txhdr[ZF0] = Cmdack1; zsbhdr(ZCOMMAND, Txhdr); zsdata(buf, blen, ZCRCW); listen: Rxtimeout = 100; /* Ten second wait for resp. */ c = zgethdr(Rxhdr, 1); switch (c) { case ZRINIT: goto listen; /* CAF 8-21-87 */ // case ERROR: case TIMEOUT: if (++errors > Cmdtries) return ZERR; continue; case ZCAN: case ZABORT: case ZFIN: case ZSKIP: case ZRPOS: return ZERR; default: if (++errors > 20) return ZERR; continue; case ZCOMPL: Exitcode = Rxpos; saybibi(); return OK; case ZRQINIT: // vfile("******** RZ *******"); // system("rz"); // vfile("******** SZ *******"); goto listen; } } } void chartest(int m) { int n; printf("\r\n\nCharacter Transparency Test Mode %d\r\n", m); printf("If Pro-YAM/ZCOMM is not displaying ^M hit ALT-V NOW.\r\n"); printf("Hit Enter.\021"); fflush(stdout); readline(500); for (n = 0; n < 256; ++n) { if (!(n%8)) printf("\r\n"); printf("%02x ", n); fflush(stdout); sendline(n); printf(" "); fflush(stdout); if (n == 127) { printf("Hit Enter.\021"); fflush(stdout); readline(500); printf("\r\n"); fflush(stdout); } } printf("\021\r\nEnter Characters, echo is in hex.\r\n"); printf("Hit SPACE or pause 40 seconds for exit.\r\n"); while (n != TIMEOUT && n != ' ') { n = readline(400); printf("%02x\r\n", n); fflush(stdout); } printf("\r\nMode %d character transparency test ends.\r\n", m); fflush(stdout); } /* End of sz.c */ /********************************************************************** * Z M . C * ZMODEM protocol primitives * 05-09-88 Chuck Forsberg Omen Technology Inc * Copyright 1993 Omen Technology INC All Rights Reserved * Part of the ZMODEM Developer's Collection * * Entry point Functions: * zsbhdr(type, hdr) send binary header * zshhdr(type, hdr) send hex header * zgethdr(hdr, eflag) receive header - binary or hex * zsdata(buf, len, frameend) send data * zrdata(buf, len) receive data * stohdr(pos) store position data in Txhdr * long rclhdr(hdr) recover position offset from header ***********************************************************************/ /* Send ZMODEM binary header hdr of type type */ void zsbhdr(int type, char *hdr) { int n; unsigned short crc; if (type == ZDATA) for (n = Znulls; --n >=0; ) xsendline(0); xsendline(ZPAD); xsendline(ZDLE); if (Crc32t=Txfcs32) zsbh32(hdr, type); else { xsendline(ZBIN); zsendline(type); crc = updcrc(type, 0); for (n=4; --n >= 0; ++hdr) { zsendline(*hdr); crc = updcrc((0377& *hdr), crc); } crc = updcrc(0,updcrc(0,crc)); zsendline(crc>>8); zsendline(crc); } // if (type != ZDATA) // flushmo(); } /* Send ZMODEM binary header hdr of type type */ void zsbh32(char *hdr, int type) { int n; long crc; xsendline(ZBIN32); zsendline(type); crc = 0xFFFFFFFFL; crc = UPDC32(type, crc); for (n=4; --n >= 0; ++hdr) { crc = UPDC32((0377 & *hdr), crc); zsendline(*hdr); } crc = ~crc; for (n=4; --n >= 0;) { zsendline((int)crc); crc >>= 8; } } /* Send ZMODEM HEX header hdr of type type */ void zshhdr(int type, char *hdr) { int n; unsigned short crc; // vfile("zshhdr: %s %lx", frametypes[type+FTOFFSET], rclhdr(hdr)); sendline(ZPAD); sendline(ZPAD); sendline(ZDLE); sendline(ZHEX); zputhex(type); Crc32t = 0; crc = updcrc(type, 0); for (n=4; --n >= 0; ++hdr) { zputhex(*hdr); crc = updcrc((0377 & *hdr), crc); } crc = updcrc(0,updcrc(0,crc)); zputhex(crc>>8); zputhex(crc); /* Make it printable on remote machine */ sendline(015); sendline(0212); /* * Uncork the remote in case a fake XOFF has stopped data flow */ if (type != ZFIN && type != ZACK) sendline(021); // flushmo(); } /***************************************************************/ /* * Send binary array buf of length length, with ending ZDLE sequence frameend */ static char *Zendnames[] = { "ZCRCE", "ZCRCG", "ZCRCQ", "ZCRCW"}; void zsdata(char *buf, int length, int frameend) { register unsigned short crc; // vfile("zsdata: %d %s", length, Zendnames[frameend-ZCRCE&3]); if (Crc32t) zsda32(buf, length, frameend); else { crc = 0; for (;--length >= 0; ++buf) { zsendline(*buf); crc = updcrc((0377 & *buf), crc); } xsendline(ZDLE); xsendline(frameend); crc = updcrc(frameend, crc); crc = updcrc(0,updcrc(0,crc)); zsendline(crc>>8); zsendline(crc); } if (frameend == ZCRCW) xsendline(XON); if (frameend != ZCRCG) flushmo(); } /**************************************************/ void zsda32(char *buf, int length, int frameend) { int c; long crc; crc = 0xFFFFFFFFL; for (;--length >= 0; ++buf) { c = *buf & 0377; if (c & 0140) xsendline(lastsent = c); else zsendline(c); crc = UPDC32(c, crc); } xsendline(ZDLE); xsendline(frameend); crc = UPDC32(frameend, crc); crc = ~crc; for (length=4; --length >= 0;) { zsendline((int)crc); crc >>= 8; } } /* * Receive array buf of max length with ending ZDLE sequence * and CRC. Returns the ending character or error code. * NB: On errors may store length+1 bytes! */ int zrdata(char *buf, int length) { register int c; register unsigned short crc; register char *end; register int d; if (Rxframeind == ZBIN32) return zrdat32(buf, length); crc = Rxcount = 0; end = buf + length; while (buf <= end) { if ((c = zdlread()) & ~0377) { crcfoo: switch (c) { case GOTCRCE: case GOTCRCG: case GOTCRCQ: case GOTCRCW: crc = updcrc((d=c)&0377, crc); if ((c = zdlread()) & ~0377) goto crcfoo; crc = updcrc(c, crc); if ((c = zdlread()) & ~0377) goto crcfoo; crc = updcrc(c, crc); if (crc & 0xFFFF) { zperr(badcrc); return ZERR; } Rxcount = length - (end - buf); // vfile("zrdata: %d %s", Rxcount, // Zendnames[d-GOTCRCE&3]); return d; case GOTCAN: zperr("Sender Canceled"); return ZCAN; case TIMEOUT: zperr("TIMEOUT"); return c; default: zperr("Bad data subpacket"); return c; } } *buf++ = c; crc = updcrc(c, crc); } zperr("Data subpacket too long"); return ZERR; } /***********************************************************/ int zrdat32(char *buf, int length) { int c; long crc; char *end; int d; crc = 0xFFFFFFFFL; Rxcount = 0; end = buf + length; while (buf <= end) { if ((c = zdlread()) & ~0377) { crcfoo: switch (c) { case GOTCRCE: case GOTCRCG: case GOTCRCQ: case GOTCRCW: d = c; c &= 0377; crc = UPDC32(c, crc); if ((c = zdlread()) & ~0377) goto crcfoo; crc = UPDC32(c, crc); if ((c = zdlread()) & ~0377) goto crcfoo; crc = UPDC32(c, crc); if ((c = zdlread()) & ~0377) goto crcfoo; crc = UPDC32(c, crc); if ((c = zdlread()) & ~0377) goto crcfoo; crc = UPDC32(c, crc); if (crc != 0xDEBB20E3) { zperr(badcrc); return ZERR; } Rxcount = length - (end - buf); // vfile("zrdat32: %d %s", Rxcount, // Zendnames[d-GOTCRCE&3]); return d; case GOTCAN: zperr("Sender Canceled"); return ZCAN; case TIMEOUT: zperr("TIMEOUT"); return c; default: zperr("Bad data subpacket"); return c; } } *buf++ = c; crc = UPDC32(c, crc); } zperr("Data subpacket too long"); return ZERR; } /* * Read a ZMODEM header to hdr, either binary or hex. * eflag controls local display of non zmodem characters: * 0: no display * 1: display printing characters only * 2: display all non ZMODEM characters * On success, set Zmodem to 1, set Rxpos and return type of header. * Otherwise return negative on error. * Return ERROR instantly if ZCRCW sequence, for fast error recovery. */ int zgethdr(char *hdr, int eflag) { register int c, n, cancount; n = Zrwindow; /* Max bytes before start of frame */ Rxframeind = Rxtype = 0; startover: cancount = 5; again: /* Return immediate ERROR if ZCRCW sequence seen */ switch (c = readline(Rxtimeout)) { case RCDO: case TIMEOUT: goto fifi; case CAN: gotcan: if (--cancount <= 0) { c = ZCAN; goto fifi; } switch (c = readline(1)) { case TIMEOUT: goto again; case ZCRCW: c = ERROR; /* **** FALL THRU TO **** */ case RCDO: goto fifi; default: break; case CAN: if (--cancount <= 0) { c = ZCAN; goto fifi; } goto again; } /* **** FALL THRU TO **** */ default: agn2: if ( --n == 0) { zperr("Garbage count exceeded"); return(ERROR); } if (eflag && ((c &= 0177) & 0140)) putchar(c); else if (eflag > 1) putchar(c); #ifdef UNIX fflush(stderr); #endif goto startover; case ZPAD|0200: /* This is what we want. */ Not8bit = c; case ZPAD: /* This is what we want. */ break; } cancount = 5; splat: switch (c = noxrd7()) { case ZPAD: goto splat; case RCDO: case TIMEOUT: goto fifi; default: goto agn2; case ZDLE: /* This is what we want. */ break; } switch (c = noxrd7()) { case RCDO: case TIMEOUT: goto fifi; case ZBIN: Rxframeind = ZBIN; Crc32 = FALSE; c = zrbhdr(hdr); break; case ZBIN32: Crc32 = Rxframeind = ZBIN32; c = zrbhdr32(hdr); break; case ZHEX: Rxframeind = ZHEX; Crc32 = FALSE; c = zrhhdr(hdr); break; case CAN: goto gotcan; default: goto agn2; } Rxpos = hdr[ZP3] & 0377; Rxpos = (Rxpos<<8) + (hdr[ZP2] & 0377); Rxpos = (Rxpos<<8) + (hdr[ZP1] & 0377); Rxpos = (Rxpos<<8) + (hdr[ZP0] & 0377); fifi: switch (c) { case GOTCAN: c = ZCAN; /* **** FALL THRU TO **** */ case ZNAK: case ZCAN: case ERROR: case TIMEOUT: case RCDO: zperr("Got RCDO"); /* **** FALL THRU TO **** */ default: if (c >= -3 && c <= FRTYPES) printf("zgethdr: %s %lx", frametypes[c+FTOFFSET], Rxpos); else printf("zgethdr: %d %lx", c, Rxpos); } return c; } /*************************************************************/ /* * Read a character from the modem line with timeout. * Eat parity, XON and XOFF characters. */ int noxrd7(void) { int c; for (;;) { if ((c = readline(Rxtimeout)) < 0) return c; switch (c &= 0177) { case XON: case XOFF: continue; default: if (Zctlesc && !(c & 0140)) continue; case '\r': case '\n': case ZDLE: return c; } } } /*******************************************************/ /* Store long integer pos in Txhdr */ void stohdr(long pos) { Txhdr[ZP0] = pos; Txhdr[ZP1] = pos>>8; Txhdr[ZP2] = pos>>16; Txhdr[ZP3] = pos>>24; } /****************************************************/ /* Recover a long integer from a header */ long rclhdr(char *hdr) { register long l; l = (hdr[ZP3] & 0377); l = (l << 8) | (hdr[ZP2] & 0377); l = (l << 8) | (hdr[ZP1] & 0377); l = (l << 8) | (hdr[ZP0] & 0377); return l; } /*****************************************************************/ void sendline(char c) { c = c & 0377; WriteSerPort(&c, 1); } /*******************************************************************/ void xsendline(char c) { WriteSerPort(&c, 1); } /*******************************************************************/ /* * Send character c with ZMODEM escape sequence encoding. * Escape XON, XOFF. Escape CR following @ (Telenet net escape) */ void zsendline(int c) { /* Quick check for non control characters */ if (c & 0140) xsendline(lastsent = c); else { switch (c &= 0377) { case ZDLE: xsendline(ZDLE); xsendline (lastsent = (c ^= 0100)); break; case 015: case 0215: if (!Zctlesc && (lastsent & 0177) != '@') goto sendit; /* **** FALL THRU TO **** */ case 020: case 021: case 023: case 0220: case 0221: case 0223: xsendline(ZDLE); c ^= 0100; sendit: xsendline(lastsent = c); break; default: if (Zctlesc && ! (c & 0140)) { xsendline(ZDLE); c ^= 0100; } xsendline(lastsent = c); } } } /***************************************************/ void zperr(char *s) { printf("\n%s", s); } /****************************************************/ /* Send a byte as two hex digits */ void zputhex(int c) { static char digits[] = "0123456789abcdef"; if (Verbose>8) // vfile("zputhex: %02X", c); sendline(digits[(c&0xF0)>>4]); sendline(digits[(c)&0xF]); } /**********************************************************/ /* * Read a byte, checking for ZMODEM escape encoding * including CAN*5 which represents a quick abort */ int zdlread(void) { register int c; again: /* Quick check for non control characters */ if ((c = readline(Rxtimeout)) & 0140) return c; switch (c) { case ZDLE: break; case 023: case 0223: case 021: case 0221: goto again; default: if (Zctlesc && !(c & 0140)) { goto again; } return c; } again2: if ((c = readline(Rxtimeout)) < 0) return c; if (c == CAN && (c = readline(Rxtimeout)) < 0) return c; if (c == CAN && (c = readline(Rxtimeout)) < 0) return c; if (c == CAN && (c = readline(Rxtimeout)) < 0) return c; switch (c) { case CAN: return GOTCAN; case ZCRCE: case ZCRCG: case ZCRCQ: case ZCRCW: return (c | GOTOR); /* DO NOT REMOVE THIS ENTRY!!! */ case ZRUB0: return 0177; /* DO NOT REMOVE THIS ENTRY!!! (used for telnet) */ case ZRUB1: return 0377; case 023: case 0223: case 021: case 0221: goto again2; default: if (Zctlesc && ! (c & 0140)) { goto again2; } if ((c & 0140) == 0100) return (c ^ 0100); break; } if (Verbose>1) zperr("Bad escape sequence"); return ZERR; } /******************************************************************/ /* Receive a hex style header (type and position) */ int zrhhdr(char *hdr) { register int c; register unsigned short crc; register int n; if ((c = zgethex()) < 0) return c; Rxtype = c; crc = updcrc(c, 0); for (n=4; --n >= 0; ++hdr) { if ((c = zgethex()) < 0) return c; crc = updcrc(c, crc); *hdr = c; } if ((c = zgethex()) < 0) return c; crc = updcrc(c, crc); if ((c = zgethex()) < 0) return c; crc = updcrc(c, crc); if (crc & 0xFFFF) { zperr(badcrc); return ZERR; } switch ( c = readline(1)) { case 0215: Not8bit = c; /* **** FALL THRU TO **** */ case 015: /* Throw away possible cr/lf */ switch (c = readline(1)) { case 012: Not8bit |= c; } } #ifdef ZMODEM Protocol = ZMODEM; #endif Zmodem = 1; return Rxtype; } /******************************************************/ /* Receive a binary style header (type and position) */ int zrbhdr(char *hdr) { int c, n; unsigned short crc; if ((c = zdlread()) & ~0377) return c; Rxtype = c; crc = updcrc(c, 0); for (n=4; --n >= 0; ++hdr) { if ((c = zdlread()) & ~0377) return c; crc = updcrc(c, crc); *hdr = c; } if ((c = zdlread()) & ~0377) return c; crc = updcrc(c, crc); if ((c = zdlread()) & ~0377) return c; crc = updcrc(c, crc); if (crc & 0xFFFF) { zperr(badcrc); return ZERR; } #ifdef ZMODEM Protocol = ZMODEM; #endif Zmodem = 1; return Rxtype; } /*************************************************************************/ /* Receive a binary style header (type and position) with 32 bit FCS */ int zrbhdr32(char *hdr) { int c, n; long crc; if ((c = zdlread()) & ~0377) return c; Rxtype = c; crc = 0xFFFFFFFFL; crc = UPDC32(c, crc); #ifdef DEBUGZ vfile("zrbhdr32 c=%X crc=%lX", c, crc); #endif for (n=4; --n >= 0; ++hdr) { if ((c = zdlread()) & ~0377) return c; crc = UPDC32(c, crc); *hdr = c; #ifdef DEBUGZ vfile("zrbhdr32 c=%X crc=%lX", c, crc); #endif } for (n=4; --n >= 0;) { if ((c = zdlread()) & ~0377) return c; crc = UPDC32(c, crc); #ifdef DEBUGZ vfile("zrbhdr32 c=%X crc=%lX", c, crc); #endif } if (crc != 0xDEBB20E3) { zperr(badcrc); return ZERR; } #ifdef ZMODEM Protocol = ZMODEM; #endif Zmodem = 1; return Rxtype; } /********************************************************/ /* Decode two lower case hex digits into an 8 bit byte value */ int zgethex(void) { int c; c = zgeth1(); // if (Verbose>8) // vfile("zgethex: %02X", c); return c; } /***********************************************************/ int zgeth1(void) { register int c, n; if ((c = noxrd7()) < 0) return c; n = c - '0'; if (n > 9) n -= ('a' - ':'); if (n & ~0xF) return ZERR; if ((c = noxrd7()) < 0) return c; c -= '0'; if (c > 9) c -= ('a' - ':'); if (c & ~0xF) return ZERR; c += (n<<4); return c; } /**************************************************/ void flushmo(void) { fflush(stdout); }