![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to zmodem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs3|
Return to zmodem.c CVS log | Up to [Synchronet] / sbbs / sbbs3 |
1.1 root 1: /* zmodem.c */
2:
3: /* Synchronet ZMODEM Functions */
4:
5: /* $Id: zmodem.c,v 1.4 2003/09/18 03:43:44 rswindell Exp $ */
6:
7: /******************************************************************************/
8: /* Project : Unite! File : zmodem general Version : 1.02 */
9: /* */
10: /* (C) Mattheij Computer Service 1994 */
11: /* */
12: /* contact us through (in order of preference) */
13: /* */
14: /* email: [email protected] */
15: /* mail: MCS */
16: /* Prinses Beatrixlaan 535 */
17: /* 2284 AT RIJSWIJK */
18: /* The Netherlands */
19: /* voice phone: 31+070-3936926 */
20: /******************************************************************************/
21:
22: #if 0
23:
24: /****************************************/
25: /* Zmodem specific functions start here */
26: /****************************************/
27:
28:
29: /***********************/
30: /* Output a hex header */
31: /***********************/
32: void putzhhdr(char type)
33: {
34: uint i;
35: ushort crc=0;
36:
37: putcom(ZPAD);
38: putcom(ZPAD);
39: putcom(ZDLE);
40: if(zmode&VAR_HDRS) {
41: putcom(ZVHEX);
42: putzhex(4);
43: }
44: else
45: putcom(ZHEX);
46: putzhex(type);
47: // crc=ucrc16(type,crc);
48: for(i=0;i<4;i++) {
49: putzhex(Txhdr[i]);
50: crc=ucrc16(Txhdr[i],crc);
51: }
52: // crc=ucrc16(0,crc);
53: // crc=ucrc16(0,crc);
54: putzhex(crc>>8);
55: putzhex(crc&0xff);
56: putcom(CR);
57: putcom(LF); /* Chuck's RZ.C sends LF|0x80 for some unknown reason */
58: if(type!=ZFIN && type!=ZACK)
59: putcom(XON);
60: }
61:
62: /****************************************************************************/
63: /* Stores a long in the Zmodem transmit header (usually position offset) */
64: /****************************************************************************/
65: void ltohdr(long l)
66: {
67:
68: Txhdr[ZP0] = l;
69: Txhdr[ZP1] = l>>8;
70: Txhdr[ZP2] = l>>16;
71: Txhdr[ZP3] = l>>24;
72: }
73:
74: /*
75: * Read a byte, checking for ZMODEM escape encoding
76: * including CAN*5 which represents a quick abort
77: */
78: int getzcom()
79: {
80: int i;
81:
82: while(1) {
83: /* Quick check for non control characters */
84: if((i=getcom(Rxtimeout))&0x60)
85: return(i);
86: if(i==ZDLE)
87: break;
88: if((i&0x7f)==XOFF || (i&0x7f)==XON)
89: continue;
90: if(zmode&CTRL_ESC && !(i&0x60))
91: continue;
92: return(i);
93: }
94:
95: while(1) { /* Escaped characters */
96: if((i=getcom(Rxtimeout))<0)
97: return(i);
98: if(i==CAN && (i=getcom(Rxtimeout))<0)
99: return(i);
100: if(i==CAN && (i=getcom(Rxtimeout))<0)
101: return(i);
102: if(i==CAN && (i=getcom(Rxtimeout))<0)
103: return(i);
104: switch (i) {
105: case CAN:
106: return(GOTCAN);
107: case ZCRCE:
108: case ZCRCG:
109: case ZCRCQ:
110: case ZCRCW:
111: return(i|GOTOR);
112: case ZRUB0:
113: return(0x7f);
114: case ZRUB1:
115: return(0xff);
116: case XON:
117: case XON|0x80:
118: case XOFF:
119: case XOFF|0x80:
120: continue;
121: default:
122: if (zmode&CTRL_ESC && !(i&0x60))
123: continue;
124: if ((i&0x60)==0x40)
125: return(i^0x40);
126: break;
127: }
128: break;
129: }
130: return(ERROR);
131: }
132:
133:
134:
135: /*
136: * Read a character from the modem line with timeout.
137: * Eat parity, XON and XOFF characters.
138: */
139: int getcom7()
140: {
141: int i;
142:
143: while(1) {
144: i=getcom(10);
145: switch(i) {
146: case XON:
147: case XOFF:
148: continue;
149: case CR:
150: case LF:
151: case NOINP:
152: case ZDLE:
153: return(i);
154: default:
155: if(!(i&0x60) && zmode&CTRL_ESC)
156: continue;
157: return(i);
158: }
159: }
160: }
161:
162: #endif
163:
164: /*
165: * zmodem primitives and other code common to zmtx and zmrx
166: */
167:
168: #include <stdio.h>
169: #include <sys/stat.h> /* struct stat */
170:
171: #include "sexyz.h"
172: #include "genwrap.h"
173: #include "sockwrap.h"
174:
175: #include "zmodem.h"
176: #include "crc16.h"
177: #include "crc32.h"
178:
179: #define ENDOFFRAME 2
180: #define FRAMEOK 1
181: #define TIMEOUT -1 /* rx routine did not receive a character within timeout */
182: #define INVHDR -2 /* invalid header received; but within timeout */
183: #define INVDATA -3 /* invalid data subpacket received */
184: #define ZDLEESC 0x8000 /* one of ZCRCE; ZCRCG; ZCRCQ or ZCRCW was received; ZDLE escaped */
185:
186: #define HDRLEN 5 /* size of a zmodem header */
187:
188:
189: int opt_v = TRUE; /* show progress output */
190: int opt_d = TRUE; /* show debug output */
191:
192: /*
193: * read bytes as long as rdchk indicates that
194: * more data is available.
195: */
196:
197: void
198: zmodem_rx_purge(zmodem_t* zm)
199: {
200: while(recv_byte(zm->sock,0,zm->mode)<=0xff);
201: }
202:
203: /*
204: * transmit a character.
205: * this is the raw modem interface
206: */
207:
208: void
209: zmodem_tx_raw(zmodem_t* zm, unsigned char ch)
210: {
211:
212: #if 0 /* def _DEBUG */
213: if (zm->raw_trace) {
214: fprintf(zm->statfp,"%02x ",ch);
215: }
216: #endif
217:
218: if(send_byte(zm->sock,ch,10,zm->mode))
219: fprintf(zm->errfp,"!Send error: %u\n",ERROR_VALUE);
220:
221: zm->last_sent = ch;
222: }
223:
224: /*
225: * transmit a character ZDLE escaped
226: */
227:
228: void
229: zmodem_tx_esc(zmodem_t* zm, unsigned char c)
230: {
231: zmodem_tx_raw(zm, ZDLE);
232: /*
233: * exclusive or; not an or so ZDLE becomes ZDLEE
234: */
235: zmodem_tx_raw(zm, (uchar)(c ^ 0x40));
236: }
237:
238: /*
239: * transmit a character; ZDLE escaping if appropriate
240: */
241:
242: #if 0
243: /****************************************************************************/
244: /* Outputs single Zmodem character, escaping with ZDLE when appropriate */
245: /****************************************************************************/
246: void putzcom(uchar ch)
247: {
248: static lastsent;
249:
250: if(ch&0x60) /* not a control char */
251: putcom(lastsent=ch);
252: else
253: switch(ch) {
254: case DLE:
255: case DLE|0x80: /* even if high-bit set */
256: case XON:
257: case XON|0x80:
258: case XOFF:
259: case XOFF|0x80:
260: case ZDLE:
261: putcom(ZDLE);
262: ch^=0x40;
263: putcom(lastsent=ch);
264: break;
265: case CR:
266: case CR|0x80:
267: if(!(zmode&CTRL_ESC) && (lastsent&0x7f)!='@')
268: putcom(lastsent=ch);
269: else {
270: putcom(ZDLE);
271: ch^=0x40;
272: putcom(lastsent=ch);
273: }
274: break;
275: default:
276: if(zmode&CTRL_ESC && !(ch&0x60)) { /* it's a ctrl char */
277: putcom(ZDLE);
278: ch^=0x40;
279: }
280: putcom(lastsent=ch);
281: break;
282: }
283: }
284: #endif
285:
286: void
287: zmodem_tx(zmodem_t* zm, unsigned char c)
288: {
289: switch (c) {
290: case DLE:
291: case DLE|0x80: /* even if high-bit set */
292: case XON:
293: case XON|0x80:
294: case XOFF:
295: case XOFF|0x80:
296: case ZDLE:
297: zmodem_tx_esc(zm, c);
298: return;
299: case CR:
300: case CR|0x80:
301: if (zm->escape_all_control_characters && (zm->last_sent&0x7f) == '@') {
302: zmodem_tx_esc(zm, c);
303: return;
304: }
305: break;
306: default:
307: if (zm->escape_all_control_characters && (c&0x60)==0) {
308: zmodem_tx_esc(zm, c);
309: return;
310: }
311: break;
312: }
313: /*
314: * anything that ends here is so normal we might as well transmit it.
315: */
316: zmodem_tx_raw(zm, c);
317: }
318:
319: /**********************************************/
320: /* Output single byte as two hex ASCII digits */
321: /**********************************************/
322: void
323: zmodem_tx_hex(zmodem_t* zm, char val)
324: {
325: char* xdigit="0123456789abcdef";
326:
327: zmodem_tx_raw(zm, xdigit[val>>4]);
328: zmodem_tx_raw(zm, xdigit[val&0xf]);
329: }
330:
331: /*
332: * transmit a hex header.
333: * these routines use tx_raw because we're sure that all the
334: * characters are not to be escaped.
335: */
336: void
337: zmodem_tx_hex_header(zmodem_t* zm, unsigned char * p)
338: {
339: int i;
340: unsigned short int crc;
341:
342: #if 0 /* def _DEBUG */
343: fprintf(zm->statfp,"tx_hheader : ");
344: #endif
345:
346: zmodem_tx_raw(zm, ZPAD);
347: zmodem_tx_raw(zm, ZPAD);
348: zmodem_tx_raw(zm, ZDLE);
349:
350: if (zm->use_variable_headers) {
351: zmodem_tx_raw(zm, ZVHEX);
352: zmodem_tx_hex(zm, HDRLEN);
353: }
354: else {
355: zmodem_tx_raw(zm, ZHEX);
356: }
357:
358: /*
359: * initialise the crc
360: */
361:
362: crc = 0;
363:
364: /*
365: * transmit the header
366: */
367:
368: for (i=0;i<HDRLEN;i++) {
369: zmodem_tx_hex(zm, *p);
370: crc = ucrc16(*p, crc);
371: p++;
372: }
373:
374: /*
375: * update the crc as though it were zero
376: */
377:
378: // crc = ucrc16(0,crc);
379: // crc = ucrc16(0,crc);
380:
381: /*
382: * transmit the crc
383: */
384:
385: zmodem_tx_hex(zm, (char)(crc>>8));
386: zmodem_tx_hex(zm, (char)(crc&0xff));
387:
388: /*
389: * end of line sequence
390: */
391:
392: zmodem_tx_raw(zm, '\r');
393: zmodem_tx_raw(zm, '\n');
394:
395: zmodem_tx_raw(zm, XON);
396:
397:
398: #if 0 /* def _DEBUG */
399: fprintf(zm->statfp,"\n");
400: #endif
401: }
402:
403: /*
404: * Send ZMODEM binary header hdr
405: */
406:
407: void
408: zmodem_tx_bin32_header(zmodem_t* zm, unsigned char * p)
409: {
410: int i;
411: unsigned long crc;
412:
413: #if 0 /* def _DEBUG */
414: fprintf(zm->statfp,"tx binary header 32 bits crc\n");
415: // zm->raw_trace = 1;
416: #endif
417:
418: zmodem_tx_raw(zm, ZPAD);
419: zmodem_tx_raw(zm, ZPAD);
420: zmodem_tx_raw(zm, ZDLE);
421:
422: if (zm->use_variable_headers) {
423: zmodem_tx_raw(zm, ZVBIN32);
424: zmodem_tx(zm, HDRLEN);
425: }
426: else {
427: zmodem_tx_raw(zm, ZBIN32);
428: }
429:
430: crc = 0xffffffffL;
431:
432: for (i=0;i<HDRLEN;i++) {
433: crc = ucrc32(*p,crc);
434: zmodem_tx(zm, *p++);
435: }
436:
437: crc = ~crc;
438:
439: zmodem_tx(zm, (uchar)((crc ) & 0xff));
440: zmodem_tx(zm, (uchar)((crc >> 8) & 0xff));
441: zmodem_tx(zm, (uchar)((crc >> 16) & 0xff));
442: zmodem_tx(zm, (uchar)((crc >> 24) & 0xff));
443: }
444:
445: void
446: zmodem_tx_bin16_header(zmodem_t* zm, unsigned char * p)
447: {
448: int i;
449: unsigned int crc;
450:
451: #if 0 /* def _DEBUG */
452: fprintf(zm->statfp,"tx binary header 16 bits crc\n");
453: #endif
454:
455: zmodem_tx_raw(zm, ZPAD);
456: zmodem_tx_raw(zm, ZPAD);
457: zmodem_tx_raw(zm, ZDLE);
458:
459: if (zm->use_variable_headers) {
460: zmodem_tx_raw(zm, ZVBIN);
461: zmodem_tx(zm, HDRLEN);
462: }
463: else {
464: zmodem_tx_raw(zm, ZBIN);
465: }
466:
467: crc = 0;
468:
469: for (i=0;i<HDRLEN;i++) {
470: crc = ucrc16(*p,crc);
471: zmodem_tx(zm, *p++);
472: }
473:
474: // crc = ucrc16(0,crc);
475: // crc = ucrc16(0,crc);
476:
477: zmodem_tx(zm, (uchar)(crc >> 8));
478: zmodem_tx(zm, (uchar)(crc&0xff));
479: }
480:
481:
482: /*
483: * transmit a header using either hex 16 bit crc or binary 32 bit crc
484: * depending on the receivers capabilities
485: * we dont bother with variable length headers. I dont really see their
486: * advantage and they would clutter the code unneccesarily
487: */
488:
489: void
490: zmodem_tx_header(zmodem_t* zm, unsigned char * p)
491: {
492: if (zm->can_fcs_32) {
493: if (!zm->want_fcs_16) {
494: zmodem_tx_bin32_header(zm, p);
495: }
496: else {
497: zmodem_tx_bin16_header(zm, p);
498: }
499: }
500: else {
501: zmodem_tx_hex_header(zm, p);
502: }
503: }
504:
505: /*
506: * data subpacket transmission
507: */
508:
509: void
510: zmodem_tx_32_data(zmodem_t* zm, uchar sub_frame_type, unsigned char * p, int l)
511: {
512: unsigned long crc;
513:
514: #if 0 /* def _DEBUG */
515: fprintf(zm->statfp,"tx_32_data\n");
516: #endif
517:
518: crc = 0xffffffffl;
519:
520: while (l > 0) {
521: crc = ucrc32(*p,crc);
522: zmodem_tx(zm, *p++);
523: l--;
524: }
525:
526: crc = ucrc32(sub_frame_type, crc);
527:
528: zmodem_tx_raw(zm, ZDLE);
529: zmodem_tx_raw(zm, sub_frame_type);
530:
531: crc = ~crc;
532:
533: zmodem_tx(zm, (uchar) ((crc ) & 0xff));
534: zmodem_tx(zm, (uchar) ((crc >> 8 ) & 0xff));
535: zmodem_tx(zm, (uchar) ((crc >> 16) & 0xff));
536: zmodem_tx(zm, (uchar) ((crc >> 24) & 0xff));
537: }
538:
539: void
540: zmodem_tx_16_data(zmodem_t* zm, uchar sub_frame_type,unsigned char * p,int l)
541: {
542: unsigned short crc;
543:
544: #if 0 /* def _DEBUG */
545: fprintf(zm->statfp,"tx_16_data\n");
546: #endif
547:
548: crc = 0;
549:
550: while (l > 0) {
551: crc = ucrc16(*p,crc);
552: zmodem_tx(zm, *p++);
553: l--;
554: }
555:
556: crc = ucrc16(sub_frame_type,crc);
557:
558: zmodem_tx_raw(zm, ZDLE);
559: zmodem_tx_raw(zm, sub_frame_type);
560:
561: // crc = ucrc16(0,crc);
562: // crc = ucrc16(0,crc);
563:
564: zmodem_tx(zm, (uchar)(crc >> 8));
565: zmodem_tx(zm, (uchar)(crc&0xff));
566: }
567:
568: /*
569: * send a data subpacket using crc 16 or crc 32 as desired by the receiver
570: */
571:
572: void
573: zmodem_tx_data(zmodem_t* zm, uchar sub_frame_type,unsigned char * p, int l)
574: {
575: if (!zm->want_fcs_16 && zm->can_fcs_32) {
576: zmodem_tx_32_data(zm, sub_frame_type,p,l);
577: }
578: else {
579: zmodem_tx_16_data(zm, sub_frame_type,p,l);
580: }
581:
582: if (sub_frame_type == ZCRCW) {
583: zmodem_tx_raw(zm, XON);
584: }
585:
586: }
587:
588: void
589: zmodem_tx_pos_header(zmodem_t* zm, int type,long pos)
590: {
591: char header[5];
592:
593: header[0] = type;
594: header[ZP0] = pos & 0xff;
595: header[ZP1] = (pos >> 8) & 0xff;
596: header[ZP2] = (pos >> 16) & 0xff;
597: header[ZP3] = (pos >> 24) & 0xff;
598:
599: zmodem_tx_hex_header(zm, header);
600: }
601:
602: void
603: zmodem_tx_znak(zmodem_t* zm)
604: {
605: fprintf(zm->statfp,"tx_znak\n");
606:
607: zmodem_tx_pos_header(zm, ZNAK, zm->ack_file_pos);
608: }
609:
610: void
611: zmodem_tx_zskip(zmodem_t* zm)
612: {
613: zmodem_tx_pos_header(zm, ZSKIP, 0L);
614: }
615:
616: /*
617: * receive any style header within timeout milliseconds
618: */
619:
620: int
621: zmodem_rx_poll(zmodem_t* zm)
622: {
623: int rd=0;
624:
625: socket_check(zm->sock,&rd,NULL,0);
626:
627: return(rd);
628: }
629:
630: /*
631: * rx_raw ; receive a single byte from the line.
632: * reads as many are available and then processes them one at a time
633: * check the data stream for 5 consecutive CAN characters;
634: * and if you see them abort. this saves a lot of clutter in
635: * the rest of the code; even though it is a very strange place
636: * for an exit. (but that was wat session abort was all about.)
637: */
638:
639: int
640: zmodem_rx_raw(zmodem_t* zm, int to)
641: {
642: int c;
643:
644: if((c=recv_byte(zm->sock,to,zm->mode)) > 0xff)
645: return TIMEOUT;
646:
647: // fprintf(zm->statfp,"%02X ",c);
648:
649: if (c == CAN) {
650: zm->n_cans++;
651: if (zm->n_cans == 5) {
652: fprintf(zm->statfp,"\nCancelled Remotely\n");
653: bail(CAN);
654: }
655: }
656: else {
657: zm->n_cans = 0;
658: }
659:
660: return c;
661: }
662:
663: /*
664: * rx; receive a single byte undoing any escaping at the
665: * sending site. this bit looks like a mess. sorry for that
666: * but there seems to be no other way without incurring a lot
667: * of overhead. at least like this the path for a normal character
668: * is relatively short.
669: */
670:
671:
672: int
673: zmodem_rx(zmodem_t* zm, int to)
674: {
675: int c;
676:
677: /*
678: * outer loop for ever so for sure something valid
679: * will come in; a timeout will occur or a session abort
680: * will be received.
681: */
682:
683: while (TRUE) {
684:
685: /*
686: * fake do loop so we may continue
687: * in case a character should be dropped.
688: */
689:
690: do {
691: c = zmodem_rx_raw(zm, to);
692: if (c == TIMEOUT) {
693: return c;
694: }
695:
696: switch (c) {
697: case ZDLE:
698: break;
699: case XON:
700: case XON|0x80:
701: case XOFF:
702: case XOFF|0x80:
703: continue;
704: default:
705: /*
706: * if all control characters should be escaped and
707: * this one wasnt then its spurious and should be dropped.
708: */
709: if (zm->escape_all_control_characters && (c & 0x60) == 0) {
710: continue;
711: }
712: /*
713: * normal character; return it.
714: */
715: return c;
716: }
717: } while (FALSE);
718:
719: /*
720: * ZDLE encoded sequence or session abort.
721: * (or something illegal; then back to the top)
722: */
723:
724: do {
725: c = zmodem_rx_raw(zm, to);
726:
727: if (c == XON || c == (XON|0x80) || c == XOFF || c == (XOFF|0x80) || c == ZDLE) {
728: /*
729: * these can be dropped.
730: */
731: continue;
732: }
733:
734: switch (c) {
735: /*
736: * these four are really nasty.
737: * for convenience we just change them into
738: * special characters by setting a bit outside the
739: * first 8. that way they can be recognized and still
740: * be processed as characters by the rest of the code.
741: */
742: case ZCRCE:
743: case ZCRCG:
744: case ZCRCQ:
745: case ZCRCW:
746: return (c | ZDLEESC);
747: case ZRUB0:
748: return 0x7f;
749: case ZRUB1:
750: return 0xff;
751: default:
752: if (zm->escape_all_control_characters && (c & 0x60) == 0) {
753: /*
754: * a not escaped control character; probably
755: * something from a network. just drop it.
756: */
757: continue;
758: }
759: /*
760: * legitimate escape sequence.
761: * rebuild the orignal and return it.
762: */
763: if ((c & 0x60) == 0x40) {
764: return c ^ 0x40;
765: }
766: break;
767: }
768: } while (FALSE);
769: }
770:
771: /*
772: * not reached.
773: */
774:
775: return 0;
776: }
777:
778: /*
779: * receive a data subpacket as dictated by the last received header.
780: * return 2 with correct packet and end of frame
781: * return 1 with correct packet frame continues
782: * return 0 with incorrect frame.
783: * return TIMEOUT with a timeout
784: * if an acknowledgement is requested it is generated automatically
785: * here.
786: */
787:
788: /*
789: * data subpacket reception
790: */
791:
792: int
793: zmodem_rx_32_data(zmodem_t* zm, unsigned char * p,int * l)
794: {
795: int c;
796: unsigned long rxd_crc;
797: unsigned long crc;
798: int sub_frame_type;
799:
800: #if 0 /* def _DEBUG */
801: fprintf(zm->statfp,"rx_32_data\n");
802: #endif
803:
804: crc = 0xffffffffl;
805:
806: do {
807: c = zmodem_rx(zm, 1);
808:
809: if (c == TIMEOUT) {
810: return TIMEOUT;
811: }
812: if (c < 0x100) {
813: crc = ucrc32(c,crc);
814: *p++ = c;
815: (*l)++;
816: continue;
817: }
818: } while (c < 0x100);
819:
820: sub_frame_type = c & 0xff;
821:
822: crc = ucrc32(sub_frame_type, crc);
823:
824: crc = ~crc;
825:
826: rxd_crc = zmodem_rx(zm, 1);
827: rxd_crc |= zmodem_rx(zm, 1) << 8;
828: rxd_crc |= zmodem_rx(zm, 1) << 16;
829: rxd_crc |= zmodem_rx(zm, 1) << 24;
830:
831: if (rxd_crc != crc) {
832: return FALSE;
833: }
834:
835: zm->ack_file_pos += *l;
836:
837: return sub_frame_type;
838: }
839:
840: int
841: zmodem_rx_16_data(zmodem_t* zm, register unsigned char * p,int * l)
842: {
843: register int c;
844: int sub_frame_type;
845: register unsigned short crc;
846: unsigned short rxd_crc;
847:
848: #if 0 /* def _DEBUG */
849: fprintf(zm->statfp,"rx_16_data\n");
850: #endif
851:
852: crc = 0;
853:
854: do {
855: c = zmodem_rx(zm, 5);
856:
857: if (c == TIMEOUT) {
858: return TIMEOUT;
859: }
860: if (c < 0x100) {
861: crc = ucrc16(c,crc);
862: *p++ = c;
863: (*l)++;
864: }
865: } while (c < 0x100);
866:
867: sub_frame_type = c & 0xff;
868:
869: crc = ucrc16(sub_frame_type,crc);
870:
871: // crc = ucrc16(0,crc);
872: // crc = ucrc16(0,crc);
873:
874: rxd_crc = zmodem_rx(zm, 1) << 8;
875: rxd_crc |= zmodem_rx(zm, 1);
876:
877: if (rxd_crc != crc) {
878: return FALSE;
879: }
880:
881: zm->ack_file_pos += *l;
882:
883: return sub_frame_type;
884: }
885:
886: int
887: zmodem_rx_data(zmodem_t* zm, unsigned char * p, int * l)
888: {
889: unsigned char zack_header[] = { ZACK, 0, 0, 0, 0 };
890: int sub_frame_type;
891: long pos;
892:
893: /*
894: * fill in the file pointer in case acknowledgement is requested.
895: * the ack file pointer will be updated in the subpacket read routine;
896: * so we need to get it now
897: */
898:
899: pos = zm->ack_file_pos;
900:
901: /*
902: * receive the right type of frame
903: */
904:
905: *l = 0;
906:
907: if (zm->receive_32_bit_data) {
908: sub_frame_type = zmodem_rx_32_data(zm, p,l);
909: }
910: else {
911: sub_frame_type = zmodem_rx_16_data(zm, p,l);
912: }
913:
914: switch (sub_frame_type) {
915: case TIMEOUT:
916: return TIMEOUT;
917: /*
918: * frame continues non-stop
919: */
920: case ZCRCG:
921: return FRAMEOK;
922: /*
923: * frame ends
924: */
925: case ZCRCE:
926: return ENDOFFRAME;
927: /*
928: * frame continues; ZACK expected
929: */
930: case ZCRCQ:
931: zmodem_tx_pos_header(zm, ZACK, pos);
932: return FRAMEOK;
933: /*
934: * frame ends; ZACK expected
935: */
936: case ZCRCW:
937: zmodem_tx_pos_header(zm, ZACK, pos);
938: return ENDOFFRAME;
939: }
940:
941: return FALSE;
942: }
943:
944: int
945: zmodem_rx_nibble(zmodem_t* zm, int to)
946: {
947: int c;
948:
949: c = zmodem_rx(zm, to);
950:
951: if (c == TIMEOUT) {
952: return c;
953: }
954:
955: if (c > '9') {
956: if (c < 'a' || c > 'f') {
957: /*
958: * illegal hex; different than expected.
959: * we might as well time out.
960: */
961: return TIMEOUT;
962: }
963:
964: c -= 'a' - 10;
965: }
966: else {
967: if (c < '0') {
968: /*
969: * illegal hex; different than expected.
970: * we might as well time out.
971: */
972: return TIMEOUT;
973: }
974: c -= '0';
975: }
976:
977: return c;
978: }
979:
980: int
981: zmodem_rx_hex(zmodem_t* zm, int to)
982: {
983: int n1;
984: int n0;
985:
986: n1 = zmodem_rx_nibble(zm, to);
987:
988: if (n1 == TIMEOUT) {
989: return n1;
990: }
991:
992: n0 = zmodem_rx_nibble(zm, to);
993:
994: if (n0 == TIMEOUT) {
995: return n0;
996: }
997:
998: return (n1 << 4) | n0;
999: }
1000:
1001: /*
1002: * receive routines for each of the six different styles of header.
1003: * each of these leaves zm->rxd_header_len set to 0 if the end result is
1004: * not a valid header.
1005: */
1006:
1007: void
1008: zmodem_rx_bin16_header(zmodem_t* zm, int to)
1009: {
1010: int c;
1011: int n;
1012: unsigned short int crc;
1013: unsigned short int rxd_crc;
1014:
1015: #if 0 /* def _DEBUG */
1016: fprintf(zm->statfp,"rx binary header 16 bits crc\n");
1017: #endif
1018:
1019: crc = 0;
1020:
1021: for (n=0;n<5;n++) {
1022: c = zmodem_rx(zm, to);
1023: if (c == TIMEOUT) {
1024: fprintf(zm->errfp,"timeout\n");
1025: return;
1026: }
1027: crc = ucrc16(c,crc);
1028: zm->rxd_header[n] = c;
1029: }
1030:
1031: // crc = ucrc16(0,crc);
1032: // crc = ucrc16(0,crc);
1033:
1034: rxd_crc = zmodem_rx(zm, 1) << 8;
1035: rxd_crc |= zmodem_rx(zm, 1);
1036:
1037: if (rxd_crc != crc) {
1038: fprintf(zm->errfp,"bad crc %4.4x %4.4x\n",rxd_crc,crc);
1039: return;
1040: }
1041:
1042: zm->rxd_header_len = 5;
1043: }
1044:
1045: void
1046: zmodem_rx_hex_header(zmodem_t* zm, int to)
1047: {
1048: int c;
1049: int i;
1050: unsigned short int crc = 0;
1051: unsigned short int rxd_crc;
1052:
1053: #if 0 /* def _DEBUG */
1054: fprintf(zm->statfp,"rx_hex_header : ");
1055: #endif
1056: for (i=0;i<5;i++) {
1057: c = zmodem_rx_hex(zm, to);
1058: if (c == TIMEOUT) {
1059: return;
1060: }
1061: crc = ucrc16(c,crc);
1062:
1063: zm->rxd_header[i] = c;
1064: }
1065:
1066: // crc = ucrc16(0,crc);
1067: // crc = ucrc16(0,crc);
1068:
1069: /*
1070: * receive the crc
1071: */
1072:
1073: c = zmodem_rx_hex(zm, to);
1074:
1075: if (c == TIMEOUT) {
1076: return;
1077: }
1078:
1079: rxd_crc = c << 8;
1080:
1081: c = zmodem_rx_hex(zm, to);
1082:
1083: if (c == TIMEOUT) {
1084: return;
1085: }
1086:
1087: rxd_crc |= c;
1088:
1089: if (rxd_crc == crc) {
1090: zm->rxd_header_len = 5;
1091: }
1092: else {
1093: fprintf(zm->errfp,"\n!BAD CRC-16: 0x%hX, expected: 0x%hX\n", rxd_crc, crc);
1094: }
1095:
1096: /*
1097: * drop the end of line sequence after a hex header
1098: */
1099: c = zmodem_rx(zm, to);
1100: if (c == CR) {
1101: /*
1102: * both are expected with CR
1103: */
1104: zmodem_rx(zm, to); /* drop LF */
1105: }
1106: }
1107:
1108: void
1109: zmodem_rx_bin32_header(zmodem_t* zm, int to)
1110: {
1111: int c;
1112: int n;
1113: unsigned long crc;
1114: unsigned long rxd_crc;
1115:
1116: #if 0 /* def _DEBUG */
1117: fprintf(zm->statfp,"rx binary header 32 bits crc\n");
1118: #endif
1119:
1120: crc = 0xffffffffL;
1121:
1122: for (n=0;n<to;n++) {
1123: c = zmodem_rx(zm, 1);
1124: if (c == TIMEOUT) {
1125: return;
1126: }
1127: crc = ucrc32(c,crc);
1128: zm->rxd_header[n] = c;
1129: }
1130:
1131: crc = ~crc;
1132:
1133: rxd_crc = zmodem_rx(zm, 1);
1134: rxd_crc |= zmodem_rx(zm, 1) << 8;
1135: rxd_crc |= zmodem_rx(zm, 1) << 16;
1136: rxd_crc |= zmodem_rx(zm, 1) << 24;
1137:
1138: if (rxd_crc != crc) {
1139: return;
1140: }
1141:
1142: zm->rxd_header_len = 5;
1143: }
1144:
1145: /*
1146: * receive any style header
1147: * if the errors flag is set than whenever an invalid header packet is
1148: * received INVHDR will be returned. otherwise we wait for a good header
1149: * also; a flag (receive_32_bit_data) will be set to indicate whether data
1150: * packets following this header will have 16 or 32 bit data attached.
1151: * variable headers are not implemented.
1152: */
1153:
1154: int
1155: zmodem_rx_header_raw(zmodem_t* zm, int to,int errors)
1156: {
1157: int c;
1158:
1159: #if 0 /* def _DEBUG */
1160: fprintf(zm->statfp,"rx header : ");
1161: #endif
1162: zm->rxd_header_len = 0;
1163:
1164: do {
1165: do {
1166: c = zmodem_rx_raw(zm, to);
1167: if (c == TIMEOUT) {
1168: fprintf(zm->statfp,"\n%s %d\n",__FILE__,__LINE__);
1169: return c;
1170: }
1171: } while (c != ZPAD);
1172:
1173: c = zmodem_rx_raw(zm, to);
1174: if (c == TIMEOUT) {
1175: fprintf(zm->statfp,"\n%s %d\n",__FILE__,__LINE__);
1176: return c;
1177: }
1178:
1179: if (c == ZPAD) {
1180: c = zmodem_rx_raw(zm, to);
1181: if (c == TIMEOUT) {
1182: fprintf(zm->statfp,"\n%s %d\n",__FILE__,__LINE__);
1183: return c;
1184: }
1185: }
1186:
1187: /*
1188: * spurious ZPAD check
1189: */
1190:
1191: if (c != ZDLE) {
1192: fprintf(zm->errfp,"expected ZDLE; got %c\n",c);
1193: continue;
1194: }
1195:
1196: /*
1197: * now read the header style
1198: */
1199:
1200: c = zmodem_rx(zm, to);
1201:
1202: if (c == TIMEOUT) {
1203: fprintf(zm->errfp,"\n!TIMEOUT %s %d\n",__FILE__,__LINE__);
1204: return c;
1205: }
1206:
1207: #if 0 /* def _DEBUG */
1208: fprintf(zm->statfp,"\n");
1209: #endif
1210: switch (c) {
1211: case ZBIN:
1212: zmodem_rx_bin16_header(zm, to);
1213: zm->receive_32_bit_data = FALSE;
1214: break;
1215: case ZHEX:
1216: zmodem_rx_hex_header(zm, to);
1217: zm->receive_32_bit_data = FALSE;
1218: break;
1219: case ZBIN32:
1220: zmodem_rx_bin32_header(zm, to);
1221: zm->receive_32_bit_data = TRUE;
1222: break;
1223: default:
1224: /*
1225: * unrecognized header style
1226: */
1227: fprintf(zm->errfp,"unrecognized header style %c\n",c);
1228: if (errors) {
1229: return INVHDR;
1230: }
1231:
1232: continue;
1233: }
1234: if (errors && zm->rxd_header_len == 0) {
1235: return INVHDR;
1236: }
1237:
1238: } while (zm->rxd_header_len == 0);
1239:
1240: /*
1241: * this appears to have been a valid header.
1242: * return its type.
1243: */
1244:
1245: if (zm->rxd_header[0] == ZDATA) {
1246: zm->ack_file_pos = zm->rxd_header[ZP0] | (zm->rxd_header[ZP1] << 8) |
1247: (zm->rxd_header[ZP2] << 16) | (zm->rxd_header[ZP3] << 24);
1248: }
1249:
1250: if (zm->rxd_header[0] == ZFILE) {
1251: zm->ack_file_pos = 0l;
1252: }
1253:
1254: #if 0 /* def _DEBUG */
1255: fprintf(zm->statfp,"type %d\n",zm->rxd_header[0]);
1256: #endif
1257:
1258: return zm->rxd_header[0];
1259: }
1260:
1261: int
1262: zmodem_rx_header(zmodem_t* zm, int timeout)
1263: {
1264: return zmodem_rx_header_raw(zm, timeout, FALSE);
1265: }
1266:
1267: int
1268: zmodem_rx_header_and_check(zmodem_t* zm, int timeout)
1269: {
1270: int type;
1271: while (TRUE) {
1272: type = zmodem_rx_header_raw(zm, timeout,TRUE);
1273:
1274: if (type != INVHDR) {
1275: break;
1276: }
1277:
1278: zmodem_tx_znak(zm);
1279: }
1280:
1281: return type;
1282: }
1283:
1284: void zmodem_parse_zrinit(zmodem_t* zm)
1285: {
1286: zm->can_full_duplex = (zm->rxd_header[ZF0] & ZF0_CANFDX) != 0;
1287: zm->can_overlap_io = (zm->rxd_header[ZF0] & ZF0_CANOVIO) != 0;
1288: zm->can_break = (zm->rxd_header[ZF0] & ZF0_CANBRK) != 0;
1289: zm->can_fcs_32 = (zm->rxd_header[ZF0] & ZF0_CANFC32) != 0;
1290: zm->escape_all_control_characters = (zm->rxd_header[ZF0] & ZF0_ESCCTL) != 0;
1291: zm->escape_8th_bit = (zm->rxd_header[ZF0] & ZF0_ESC8) != 0;
1292:
1293: zm->use_variable_headers = (zm->rxd_header[ZF1] & ZF1_CANVHDR) != 0;
1294: }
1295:
1296: int zmodem_get_zrinit(zmodem_t* zm)
1297: {
1298: unsigned char zrqinit_header[] = { ZRQINIT, 0, 0, 0, 0 };
1299:
1300: zmodem_tx_raw(zm,'r');
1301: zmodem_tx_raw(zm,'z');
1302: zmodem_tx_raw(zm,'\r');
1303: zmodem_tx_hex_header(zm,zrqinit_header);
1304:
1305: return zmodem_rx_header(zm,7);
1306: }
1307:
1308: int zmodem_send_zfin(zmodem_t* zm)
1309: {
1310: int type;
1311: unsigned char zfin_header[] = { ZFIN, 0, 0, 0, 0 };
1312:
1313: zmodem_tx_hex_header(zm,zfin_header);
1314: do {
1315: type = zmodem_rx_header(zm,10);
1316: } while (type != ZFIN && type != TIMEOUT);
1317:
1318: /*
1319: * these Os are formally required; but they don't do a thing
1320: * unfortunately many programs require them to exit
1321: * (both programs already sent a ZFIN so why bother ?)
1322: */
1323:
1324: if (type != TIMEOUT) {
1325: zmodem_tx_raw(zm,'O');
1326: zmodem_tx_raw(zm,'O');
1327: }
1328:
1329: return 0;
1330: }
1331:
1332: /*
1333: * show the progress of the transfer like this:
1334: * zmtx: sending file "garbage" 4096 bytes ( 20%)
1335: */
1336:
1337: void
1338: show_progress(zmodem_t* zm, ulong offset)
1339: {
1340: time_t t;
1341: long l;
1342: uint cps;
1343:
1344: t=time(NULL)-zm->transfer_start;
1345: if(!t) t=1; /* t is time so far */
1346:
1347: cps=offset/t; /* cps so far */
1348: if(!cps) cps=1;
1349: l=zm->current_file_size/cps; /* total transfer est time */
1350: l-=t; /* now, it's est time left */
1351:
1352: fprintf(zm->statfp,"\rByte: %lu/%lu "
1353: "Time: %lu:%02lu/%lu:%02lu CPS: %u %lu%% "
1354: ,offset
1355: ,zm->current_file_size
1356: ,t/60L
1357: ,t%60L
1358: ,l/60L
1359: ,l%60L
1360: ,cps
1361: ,(long)(((float)offset/(float)zm->current_file_size)*100.0)
1362: );
1363:
1364: }
1365:
1366: /*
1367: * send from the current position in the file
1368: * all the way to end of file or until something goes wrong.
1369: * (ZNAK or ZRPOS received)
1370: * the name is only used to show progress
1371: */
1372:
1373: int
1374: send_from(zmodem_t* zm, FILE * fp)
1375: {
1376: int n;
1377: long pos;
1378: uchar type = ZCRCG;
1379: char zdata_frame[] = { ZDATA, 0, 0, 0, 0 };
1380:
1381: /*
1382: * put the file position in the ZDATA frame
1383: */
1384:
1385: pos = ftell(fp);
1386: zdata_frame[ZP0] = pos & 0xff;
1387: zdata_frame[ZP1] = (pos >> 8) & 0xff;
1388: zdata_frame[ZP2] = (pos >> 16) & 0xff;
1389: zdata_frame[ZP3] = (pos >> 24) & 0xff;
1390:
1391: zmodem_tx_header(zm, zdata_frame);
1392: /*
1393: * send the data in the file
1394: */
1395:
1396: while (!feof(fp)) {
1397:
1398: show_progress(zm, ftell(fp));
1399:
1400: /*
1401: * read a block from the file
1402: */
1403: n = fread(zm->tx_data_subpacket,1,sizeof(zm->tx_data_subpacket),fp);
1404:
1405: if (n == 0) {
1406: /*
1407: * nothing to send ?
1408: */
1409: break;
1410: }
1411:
1412: /*
1413: * at end of file wait for an ACK
1414: */
1415: if (ftell(fp) == zm->current_file_size) {
1416: type = ZCRCW;
1417: }
1418:
1419: zmodem_tx_data(zm, type, zm->tx_data_subpacket, n);
1420:
1421: if (type == ZCRCW) {
1422: int type;
1423: do {
1424: type = zmodem_rx_header(zm, 10);
1425: if (type == ZNAK || type == ZRPOS) {
1426: return type;
1427: }
1428: } while (type != ZACK);
1429:
1430: if (ftell(fp) == zm->current_file_size) {
1431: if (opt_d) {
1432: fprintf(zm->statfp,"end of file\n");
1433: }
1434: return ZACK;
1435: }
1436: }
1437:
1438: /*
1439: * characters from the other side
1440: * check out that header
1441: */
1442:
1443: while (zmodem_rx_poll(zm)) {
1444: int type;
1445: int c;
1446: c = zmodem_rx_raw(zm, 1);
1447: if (c == ZPAD) {
1448: type = zmodem_rx_header(zm, 1);
1449: if (type != TIMEOUT && type != ACK) {
1450: return type;
1451: }
1452: }
1453: }
1454:
1455: }
1456:
1457: /*
1458: * end of file reached.
1459: * should receive something... so fake ZACK
1460: */
1461:
1462: return ZACK;
1463: }
1464:
1465: /*
1466: * send a file; returns true when session is aborted.
1467: * (using ZABORT frame)
1468: */
1469:
1470: int
1471: zmodem_send_file(zmodem_t* zm, char* name, FILE* fp)
1472: {
1473: long pos;
1474: struct stat s;
1475: unsigned char * p;
1476: char zfile_frame[] = { ZFILE, 0, 0, 0, 0 };
1477: char zeof_frame[] = { ZEOF, 0, 0, 0, 0 };
1478: int type;
1479:
1480: fstat(fileno(fp),&s);
1481: zm->current_file_size = s.st_size;
1482:
1483: /*
1484: * the file exists. now build the ZFILE frame
1485: */
1486:
1487: /*
1488: * set conversion option
1489: * (not used; always binary)
1490: */
1491:
1492: zfile_frame[ZF0] = ZF0_ZCBIN;
1493:
1494: /*
1495: * management option
1496: */
1497:
1498: if (zm->management_protect) {
1499: zfile_frame[ZF1] = ZF1_ZMPROT;
1500: if (opt_d) {
1501: fprintf(zm->statfp,"zmtx: protecting destination\n");
1502: }
1503: }
1504:
1505: if (zm->management_clobber) {
1506: zfile_frame[ZF1] = ZF1_ZMCLOB;
1507: if (opt_d) {
1508: fprintf(zm->statfp,"zmtx: overwriting destination\n");
1509: }
1510: }
1511:
1512: if (zm->management_newer) {
1513: zfile_frame[ZF1] = ZF1_ZMNEW;
1514: if (opt_d) {
1515: fprintf(zm->statfp,"zmtx: overwriting destination if newer\n");
1516: }
1517: }
1518:
1519: /*
1520: * transport options
1521: * (just plain normal transfer)
1522: */
1523:
1524: zfile_frame[ZF2] = ZF2_ZTNOR;
1525:
1526: /*
1527: * extended options
1528: */
1529:
1530: zfile_frame[ZF3] = 0;
1531:
1532: /*
1533: * now build the data subpacket with the file name and lots of other
1534: * useful information.
1535: */
1536:
1537: /*
1538: * first enter the name and a 0
1539: */
1540:
1541: p = zm->tx_data_subpacket;
1542:
1543: strcpy(p,name);
1544:
1545: p += strlen(p) + 1;
1546:
1547: sprintf(p,"%lu %lo %lo %d %u %lu %d"
1548: ,s.st_size
1549: ,s.st_mtime
1550: ,0 /* file mode */
1551: ,0 /* serial number */
1552: ,zm->n_files_remaining
1553: ,zm->n_bytes_remaining
1554: ,0 /* file type */
1555: );
1556:
1557: p += strlen(p) + 1;
1558:
1559: do {
1560: /*
1561: * send the header and the data
1562: */
1563:
1564: zmodem_tx_header(zm,zfile_frame);
1565: zmodem_tx_data(zm,ZCRCW,zm->tx_data_subpacket,p - zm->tx_data_subpacket);
1566:
1567: /*
1568: * wait for anything but an ZACK packet
1569: */
1570:
1571: do {
1572: type = zmodem_rx_header(zm,10);
1573: } while (type == ZACK);
1574:
1575: #if 0
1576: fprintf(zm->statfp,"type : %d\n",type);
1577: #endif
1578:
1579: if (type == ZSKIP) {
1580: fclose(fp);
1581: if (opt_v) {
1582: fprintf(zm->statfp,"zmtx: skipped file \"%s\" \n",name);
1583: }
1584: return -1;
1585: }
1586:
1587: } while (type != ZRPOS);
1588:
1589: zm->transfer_start = time(NULL);
1590:
1591: do {
1592: /*
1593: * fetch pos from the ZRPOS header
1594: */
1595:
1596: if (type == ZRPOS) {
1597: pos = zm->rxd_header[ZP0] | (zm->rxd_header[ZP1] << 8) | (zm->rxd_header[ZP2] << 16) | (zm->rxd_header[ZP3] << 24);
1598: }
1599:
1600: /*
1601: * seek to the right place in the file
1602: */
1603: fseek(fp,pos,SEEK_SET);
1604:
1605: /*
1606: * and start sending
1607: */
1608:
1609: type = send_from(zm,fp);
1610:
1611: if (type == ZFERR || type == ZABORT) {
1612: fclose(fp);
1613: return -1;
1614: }
1615:
1616: } while (type == ZRPOS || type == ZNAK);
1617:
1618: /*
1619: * file sent. send end of file frame
1620: * and wait for zrinit. if it doesnt come then try again
1621: */
1622:
1623: zeof_frame[ZP0] = s.st_size & 0xff;
1624: zeof_frame[ZP1] = (s.st_size >> 8) & 0xff;
1625: zeof_frame[ZP2] = (s.st_size >> 16) & 0xff;
1626: zeof_frame[ZP3] = (s.st_size >> 24) & 0xff;
1627:
1628: do {
1629: zmodem_tx_hex_header(zm,zeof_frame);
1630: type = zmodem_rx_header(zm,10);
1631: } while (type != ZRINIT);
1632:
1633: /*
1634: * and close the input file
1635: */
1636:
1637: if (opt_v) {
1638: fprintf(zm->statfp,"zmtx: sent file \"%s\" \n",name);
1639: }
1640:
1641: fclose(fp);
1642:
1643: return 0;
1644: }
1645:
1646: #if 0
1647:
1648: zmodem_send_files(char** fname, int total_files)
1649: {
1650: int i;
1651: int fnum;
1652: char * s;
1653:
1654: /*
1655: * clear the input queue from any possible garbage
1656: * this also clears a possible ZRINIT from an already started
1657: * zmodem receiver. this doesn't harm because we reinvite to
1658: * receive again below and it may be that the receiver whose
1659: * ZRINIT we are about to wipe has already died.
1660: */
1661:
1662: zmodem_rx_purge();
1663:
1664: /*
1665: * establish contact with the receiver
1666: */
1667:
1668: if (opt_v) {
1669: fprintf(zm->statfp,"zmtx: establishing contact with receiver\n");
1670: }
1671:
1672: i = 0;
1673: do {
1674: unsigned char zrqinit_header[] = { ZRQINIT, 0, 0, 0, 0 };
1675: i++;
1676: if (i > 10) {
1677: fprintf(zm->statfp,"zmtx: can't establish contact with receiver\n");
1678: bail(3);
1679: }
1680:
1681: zmodem_tx_raw('r');
1682: zmodem_tx_raw('z');
1683: zmodem_tx_raw('\r');
1684: zmodem_tx_hex_header(zrqinit_header);
1685: } while (zmodem_rx_header(7) != ZRINIT);
1686:
1687: if (opt_v) {
1688: fprintf(zm->statfp,"zmtx: contact established\n");
1689: fprintf(zm->statfp,"zmtx: starting file transfer\n");
1690: }
1691:
1692: /*
1693: * decode receiver capability flags
1694: * forget about encryption and compression.
1695: */
1696:
1697: zmodem_can_full_duplex = (zm->rxd_header[ZF0] & ZF0_CANFDX) != 0;
1698: zmodem_can_overlap_io = (zm->rxd_header[ZF0] & ZF0_CANOVIO) != 0;
1699: zmodem_can_break = (zm->rxd_header[ZF0] & ZF0_CANBRK) != 0;
1700: zmodem_can_fcs_32 = (zm->rxd_header[ZF0] & ZF0_CANFC32) != 0;
1701: zmodem_escape_all_control_characters = (zm->rxd_header[ZF0] & ZF0_ESCCTL) != 0;
1702: zmodem_escape_8th_bit = (zm->rxd_header[ZF0] & ZF0_ESC8) != 0;
1703:
1704: zm->use_variable_headers = (zm->rxd_header[ZF1] & ZF1_CANVHDR) != 0;
1705:
1706: if (opt_d) {
1707: fprintf(zm->statfp,"receiver %s full duplex\n" ,zmodem_can_full_duplex ? "can" : "can't");
1708: fprintf(zm->statfp,"receiver %s overlap io\n" ,zmodem_can_overlap_io ? "can" : "can't");
1709: fprintf(zm->statfp,"receiver %s break\n" ,zmodem_can_break ? "can" : "can't");
1710: fprintf(zm->statfp,"receiver %s fcs 32\n" ,zmodem_can_fcs_32 ? "can" : "can't");
1711: fprintf(zm->statfp,"receiver %s escaped control chars\n",zmodem_escape_all_control_characters ? "requests" : "doesn't request");
1712: fprintf(zm->statfp,"receiver %s escaped 8th bit\n" ,zmodem_escape_8th_bit ? "requests" : "doesn't request");
1713: fprintf(zm->statfp,"receiver %s use variable headers\n" ,zm->use_variable_headers ? "can" : "can't");
1714: }
1715:
1716: /*
1717: * and send each file in turn
1718: */
1719:
1720: n_files_remaining = total_files;
1721:
1722: for(fnum=0;fnum<total_files;fnum++) {
1723: if(send_file(fname[fnum])) {
1724: if (opt_v) {
1725: fprintf(zm->statfp,"zmtx: remote aborted.\n");
1726: }
1727: break;
1728: }
1729: n_files_remaining--;
1730: }
1731:
1732: /*
1733: * close the session
1734: */
1735:
1736: if (opt_v) {
1737: fprintf(zm->statfp,"zmtx: closing the session\n");
1738: }
1739:
1740: {
1741: int type;
1742: unsigned char zfin_header[] = { ZFIN, 0, 0, 0, 0 };
1743:
1744: zmodem_tx_hex_header(zfin_header);
1745: do {
1746: type = zmodem_rx_header(10);
1747: } while (type != ZFIN && type != TIMEOUT);
1748:
1749: /*
1750: * these Os are formally required; but they don't do a thing
1751: * unfortunately many programs require them to exit
1752: * (both programs already sent a ZFIN so why bother ?)
1753: */
1754:
1755: if (type != TIMEOUT) {
1756: zmodem_tx_raw('O');
1757: zmodem_tx_raw('O');
1758: }
1759: }
1760:
1761: /*
1762: * c'est fini
1763: */
1764:
1765: if (opt_d) {
1766: fprintf(zm->statfp,"zmtx: cleanup and exit\n");
1767: }
1768:
1769: return 0;
1770: }
1771:
1772: #endif
1773:
1774: const char* zmodem_source(void)
1775: {
1776: return(__FILE__);
1777: }
1778:
1779: char* zmodem_ver(char *buf)
1780: {
1781: sscanf("$Revision: 1.4 $", "%*s %s", buf);
1782:
1783: return(buf);
1784: }
1785:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.