![[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 / src / sbbs3|
Return to zmodem.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* zmodem.c */
2:
3: /* Synchronet ZMODEM Functions */
4:
5: /* $Id: zmodem.c,v 1.71 2006/09/07 00:43:59 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: /*
23: * zmodem primitives and other code common to zmtx and zmrx
24: */
25:
26: #include <stdio.h>
27: #include <string.h>
28: #include <stdarg.h> /* va_list */
29: #include <sys/stat.h> /* struct stat */
30:
31: #include "genwrap.h"
32: #include "dirwrap.h" /* getfname() */
33: #include "filewrap.h" /* filelength() */
34:
35: #include "zmodem.h"
36: #include "crc16.h"
37: #include "crc32.h"
38:
39: #include "sexyz.h"
40: #include "telnet.h"
41:
42: #define ENDOFFRAME 2
43: #define FRAMEOK 1
44: #define TIMEOUT -1 /* rx routine did not receive a character within timeout */
45: #define INVHDR -2 /* invalid header received; but within timeout */
46: #define ZDLEESC 0x8000 /* one of ZCRCE; ZCRCG; ZCRCQ or ZCRCW was received; ZDLE escaped */
47:
48: #define BADSUBPKT 0x80
49:
50: #define HDRLEN 5 /* size of a zmodem header */
51:
52: static int lprintf(zmodem_t* zm, int level, const char *fmt, ...)
53: {
54: va_list argptr;
55: char sbuf[1024];
56:
57: if(zm->lputs==NULL)
58: return(-1);
59:
60: va_start(argptr,fmt);
61: vsnprintf(sbuf,sizeof(sbuf),fmt,argptr);
62: sbuf[sizeof(sbuf)-1]=0;
63: va_end(argptr);
64: return(zm->lputs(zm->cbdata,level,sbuf));
65: }
66:
67: static BOOL is_connected(zmodem_t* zm)
68: {
69: if(zm->is_connected!=NULL)
70: return(zm->is_connected(zm->cbdata));
71: return(TRUE);
72: }
73:
74: static BOOL is_cancelled(zmodem_t* zm)
75: {
76: if(zm->is_cancelled!=NULL)
77: return(zm->cancelled=zm->is_cancelled(zm->cbdata));
78: return(zm->cancelled);
79: }
80: int zmodem_data_waiting(zmodem_t* zm, unsigned timeout)
81: {
82: if(zm->data_waiting)
83: return(zm->data_waiting(zm->cbdata, timeout));
84: return(FALSE);
85: }
86:
87: static char *chr(int ch)
88: {
89: static char str[25];
90:
91: switch(ch) {
92: case TIMEOUT: return("TIMEOUT");
93: case ZRQINIT: return("ZRQINIT");
94: case ZRINIT: return("ZRINIT");
95: case ZSINIT: return("ZSINIT");
96: case ZACK: return("ZACK");
97: case ZFILE: return("ZFILE");
98: case ZSKIP: return("ZSKIP");
99: case ZCRC: return("ZCRC");
100: case ZNAK: return("ZNAK");
101: case ZABORT: return("ZABORT");
102: case ZFIN: return("ZFIN");
103: case ZRPOS: return("ZRPOS");
104: case ZDATA: return("ZDATA");
105: case ZEOF: return("ZEOF");
106: case ZPAD: return("ZPAD");
107: case ZCAN: return("ZCAN");
108: case ZDLE: return("ZDLE");
109: case ZDLEE: return("ZDLEE");
110: case ZBIN: return("ZBIN");
111: case ZHEX: return("ZHEX");
112: case ZBIN32: return("ZBIN32");
113: case ZRESC: return("ZRESC");
114: case ZCRCE: return("ZCRCE");
115: case ZCRCG: return("ZCRCG");
116: case ZCRCQ: return("ZCRCQ");
117: case ZCRCW: return("ZCRCW");
118:
119: }
120: if(ch>=' ' && ch<='~')
121: sprintf(str,"'%c' (%02Xh)",(uchar)ch,(uchar)ch);
122: else
123: sprintf(str,"%u (%02Xh)",(uchar)ch,(uchar)ch);
124: return(str);
125: }
126:
127: static char* frame_desc(int frame)
128: {
129: static char str[25];
130:
131: if(frame==TIMEOUT)
132: return("TIMEOUT");
133:
134: if(frame==INVHDR)
135: return("Invalid Header");
136:
137: if(frame&BADSUBPKT)
138: strcpy(str,"BAD ");
139: else
140: str[0]=0;
141:
142: switch(frame&~BADSUBPKT) {
143: case ZRQINIT: strcat(str,"ZRQINIT"); break;
144: case ZRINIT: strcat(str,"ZRINIT"); break;
145: case ZSINIT: strcat(str,"ZSINIT"); break;
146: case ZACK: strcat(str,"ZACK"); break;
147: case ZFILE: strcat(str,"ZFILE"); break;
148: case ZSKIP: strcat(str,"ZSKIP"); break;
149: case ZNAK: strcat(str,"ZNAK"); break;
150: case ZABORT: strcat(str,"ZABORT"); break;
151: case ZFIN: strcat(str,"ZFIN"); break;
152: case ZRPOS: strcat(str,"ZRPOS"); break;
153: case ZDATA: strcat(str,"ZDATA"); break;
154: case ZEOF: strcat(str,"ZEOF"); break;
155: case ZFERR: strcat(str,"ZFERR"); break;
156: case ZCRC: strcat(str,"ZCRC"); break;
157: case ZCHALLENGE: strcat(str,"ZCHALLENGE"); break;
158: case ZCOMPL: strcat(str,"ZCOMPL"); break;
159: case ZCAN: strcat(str,"ZCAN"); break;
160: case ZFREECNT: strcat(str,"ZFREECNT"); break;
161: case ZCOMMAND: strcat(str,"ZCOMMAND"); break;
162: case ZSTDERR: strcat(str,"ZSTDERR"); break;
163: default:
164: sprintf(str,"Unknown (%08X)", frame);
165: break;
166: }
167: return(str);
168: }
169:
170:
171: /*
172: * read bytes as long as rdchk indicates that
173: * more data is available.
174: */
175:
176: void zmodem_recv_purge(zmodem_t* zm)
177: {
178: while(zm->recv_byte(zm->cbdata,0)>=0);
179: }
180:
181: /*
182: * transmit a character.
183: * this is the raw modem interface
184: */
185:
186: int zmodem_send_raw(zmodem_t* zm, unsigned char ch)
187: {
188: int result;
189:
190: if((result=zm->send_byte(zm->cbdata,ch,zm->send_timeout))!=0)
191: lprintf(zm,LOG_ERR,"send_raw SEND ERROR: %d",result);
192:
193: zm->last_sent = ch;
194:
195: return result;
196: }
197:
198: /*
199: * transmit a character ZDLE escaped
200: */
201:
202: int zmodem_send_esc(zmodem_t* zm, unsigned char c)
203: {
204: int result;
205:
206: if((result=zmodem_send_raw(zm, ZDLE))!=0)
207: return(result);
208: /*
209: * exclusive or; not an or so ZDLE becomes ZDLEE
210: */
211: return zmodem_send_raw(zm, (uchar)(c ^ 0x40));
212: }
213:
214: /*
215: * transmit a character; ZDLE escaping if appropriate
216: */
217:
218: int zmodem_tx(zmodem_t* zm, unsigned char c)
219: {
220: int result;
221:
222: switch (c) {
223: case DLE:
224: case DLE|0x80: /* even if high-bit set */
225: case XON:
226: case XON|0x80:
227: case XOFF:
228: case XOFF|0x80:
229: case ZDLE:
230: return zmodem_send_esc(zm, c);
231: case CR:
232: case CR|0x80:
233: if(zm->escape_ctrl_chars && (zm->last_sent&0x7f) == '@')
234: return zmodem_send_esc(zm, c);
235: break;
236: case TELNET_IAC:
237: if(zm->escape_telnet_iac) {
238: if((result=zmodem_send_raw(zm, ZDLE))!=0)
239: return(result);
240: return zmodem_send_raw(zm, ZRUB1);
241: }
242: break;
243: default:
244: if(zm->escape_ctrl_chars && (c&0x60)==0)
245: return zmodem_send_esc(zm, c);
246: break;
247: }
248: /*
249: * anything that ends here is so normal we might as well transmit it.
250: */
251: return zmodem_send_raw(zm, c);
252: }
253:
254: /**********************************************/
255: /* Output single byte as two hex ASCII digits */
256: /**********************************************/
257: int zmodem_send_hex(zmodem_t* zm, uchar val)
258: {
259: char* xdigit="0123456789abcdef";
260: int result;
261:
262: lprintf(zm,LOG_DEBUG,"send_hex: %02X ",val);
263:
264: if((result=zmodem_send_raw(zm, xdigit[val>>4]))!=0)
265: return result;
266: return zmodem_send_raw(zm, xdigit[val&0xf]);
267: }
268:
269: int zmodem_send_padded_zdle(zmodem_t* zm)
270: {
271: int result;
272:
273: if((result=zmodem_send_raw(zm, ZPAD))!=0)
274: return result;
275: if((result=zmodem_send_raw(zm, ZPAD))!=0)
276: return result;
277: return zmodem_send_raw(zm, ZDLE);
278: }
279:
280: /*
281: * transmit a hex header.
282: * these routines use tx_raw because we're sure that all the
283: * characters are not to be escaped.
284: */
285: int zmodem_send_hex_header(zmodem_t* zm, unsigned char * p)
286: {
287: int i;
288: int result;
289: uchar type=*p;
290: unsigned short int crc;
291:
292: lprintf(zm,LOG_DEBUG,"send_hex_header: %s", chr(type));
293:
294: if((result=zmodem_send_padded_zdle(zm))!=0)
295: return result;
296:
297: if((result=zmodem_send_raw(zm, ZHEX))!=0)
298: return result;
299:
300: /*
301: * initialise the crc
302: */
303:
304: crc = 0;
305:
306: /*
307: * transmit the header
308: */
309:
310: for(i=0;i<HDRLEN;i++) {
311: if((result=zmodem_send_hex(zm, *p))!=0)
312: return result;
313: crc = ucrc16(*p, crc);
314: p++;
315: }
316:
317: /*
318: * update the crc as though it were zero
319: */
320:
321: /*
322: * transmit the crc
323: */
324:
325: if((result=zmodem_send_hex(zm, (uchar)(crc>>8)))!=0)
326: return result;
327: if((result=zmodem_send_hex(zm, (uchar)(crc&0xff)))!=0)
328: return result;
329:
330: /*
331: * end of line sequence
332: */
333:
334: if((result=zmodem_send_raw(zm, '\r'))!=0)
335: return result;
336: if((result=zmodem_send_raw(zm, '\n'))!=0) /* FDSZ sends 0x8a instead of 0x0a */
337: return result;
338:
339: if(type!=ZACK && type!=ZFIN)
340: result=zmodem_send_raw(zm, XON);
341:
342: return(result);
343: }
344:
345: /*
346: * Send ZMODEM binary header hdr
347: */
348:
349: int zmodem_send_bin32_header(zmodem_t* zm, unsigned char * p)
350: {
351: int i;
352: int result;
353: unsigned long crc;
354:
355: lprintf(zm,LOG_DEBUG,"send_bin32_header: %s", chr(*p));
356:
357: if((result=zmodem_send_padded_zdle(zm))!=0)
358: return result;
359:
360: if((result=zmodem_send_raw(zm, ZBIN32))!=0)
361: return result;
362:
363: crc = 0xffffffffL;
364:
365: for(i=0;i<HDRLEN;i++) {
366: crc = ucrc32(*p,crc);
367: if((result=zmodem_tx(zm, *p++))!=0)
368: return result;
369: }
370:
371: crc = ~crc;
372:
373: if((result= zmodem_tx(zm, (uchar)((crc ) & 0xff)))!=0)
374: return result;
375: if((result= zmodem_tx(zm, (uchar)((crc >> 8) & 0xff)))!=0)
376: return result;
377: if((result= zmodem_tx(zm, (uchar)((crc >> 16) & 0xff)))!=0)
378: return result;
379: return zmodem_tx(zm, (uchar)((crc >> 24) & 0xff));
380: }
381:
382: int zmodem_send_bin16_header(zmodem_t* zm, unsigned char * p)
383: {
384: int i;
385: int result;
386: unsigned int crc;
387:
388: lprintf(zm,LOG_DEBUG,"send_bin16_header: %s", chr(*p));
389:
390: if((result=zmodem_send_padded_zdle(zm))!=0)
391: return result;
392:
393: if((result=zmodem_send_raw(zm, ZBIN))!=0)
394: return result;
395:
396: crc = 0;
397:
398: for(i=0;i<HDRLEN;i++) {
399: crc = ucrc16(*p,crc);
400: if((result=zmodem_tx(zm, *p++))!=0)
401: return result;
402: }
403:
404: if((result= zmodem_tx(zm, (uchar)(crc >> 8)))!=0)
405: return result;
406: return zmodem_tx(zm, (uchar)(crc&0xff));
407: }
408:
409:
410: /*
411: * transmit a header using either hex 16 bit crc or binary 32 bit crc
412: * depending on the receivers capabilities
413: * we dont bother with variable length headers. I dont really see their
414: * advantage and they would clutter the code unneccesarily
415: */
416:
417: int zmodem_send_bin_header(zmodem_t* zm, unsigned char * p)
418: {
419: if(zm->can_fcs_32 && !zm->want_fcs_16)
420: return zmodem_send_bin32_header(zm, p);
421: return zmodem_send_bin16_header(zm, p);
422: }
423:
424: /*
425: * data subpacket transmission
426: */
427:
428: int zmodem_send_data32(zmodem_t* zm, uchar subpkt_type, unsigned char * p, size_t l)
429: {
430: int result;
431: unsigned long crc;
432:
433: lprintf(zm,LOG_DEBUG,"send_data32: %s (%u bytes)", chr(subpkt_type), l);
434:
435: crc = 0xffffffffl;
436:
437: while(l > 0) {
438: crc = ucrc32(*p,crc);
439: if((result=zmodem_tx(zm, *p++))!=0)
440: return result;
441: l--;
442: }
443:
444: crc = ucrc32(subpkt_type, crc);
445:
446: if((result=zmodem_send_raw(zm, ZDLE))!=0)
447: return result;
448: if((result=zmodem_send_raw(zm, subpkt_type))!=0)
449: return result;
450:
451: crc = ~crc;
452:
453: if((result= zmodem_tx(zm, (uchar) ((crc ) & 0xff)))!=0)
454: return result;
455: if((result= zmodem_tx(zm, (uchar) ((crc >> 8 ) & 0xff)))!=0)
456: return result;
457: if((result= zmodem_tx(zm, (uchar) ((crc >> 16) & 0xff)))!=0)
458: return result;
459: return zmodem_tx(zm, (uchar) ((crc >> 24) & 0xff));
460: }
461:
462: int zmodem_send_data16(zmodem_t* zm, uchar subpkt_type,unsigned char * p, size_t l)
463: {
464: int result;
465: unsigned short crc;
466:
467: lprintf(zm,LOG_DEBUG,"send_data16: %s (%u bytes)", chr(subpkt_type), l);
468:
469: crc = 0;
470:
471: while(l > 0) {
472: crc = ucrc16(*p,crc);
473: if((result=zmodem_tx(zm, *p++))!=0)
474: return result;
475: l--;
476: }
477:
478: crc = ucrc16(subpkt_type,crc);
479:
480: if((result=zmodem_send_raw(zm, ZDLE))!=0)
481: return result;
482: if((result=zmodem_send_raw(zm, subpkt_type))!=0)
483: return result;
484:
485: if((result= zmodem_tx(zm, (uchar)(crc >> 8)))!=0)
486: return result;
487: return zmodem_tx(zm, (uchar)(crc&0xff));
488: }
489:
490: /*
491: * send a data subpacket using crc 16 or crc 32 as desired by the receiver
492: */
493:
494: int zmodem_send_data(zmodem_t* zm, uchar subpkt_type, unsigned char * p, size_t l)
495: {
496: int result;
497:
498: if(!zm->want_fcs_16 && zm->can_fcs_32) {
499: if((result=zmodem_send_data32(zm, subpkt_type,p,l))!=0)
500: return result;
501: }
502: else {
503: if((result=zmodem_send_data16(zm, subpkt_type,p,l))!=0)
504: return result;
505: }
506:
507: if(subpkt_type == ZCRCW)
508: result=zmodem_send_raw(zm, XON);
509:
510: return result;
511: }
512:
513: int zmodem_send_pos_header(zmodem_t* zm, int type, long pos, BOOL hex)
514: {
515: uchar header[5];
516:
517: header[0] = type;
518: header[ZP0] = (uchar) (pos & 0xff);
519: header[ZP1] = (uchar)((pos >> 8) & 0xff);
520: header[ZP2] = (uchar)((pos >> 16) & 0xff);
521: header[ZP3] = (uchar)((pos >> 24) & 0xff);
522:
523: if(hex)
524: return zmodem_send_hex_header(zm, header);
525: else
526: return zmodem_send_bin_header(zm, header);
527: }
528:
529: int zmodem_send_ack(zmodem_t* zm, long pos)
530: {
531: return zmodem_send_pos_header(zm, ZACK, pos, /* Hex? */ TRUE);
532: }
533:
534: int zmodem_send_nak(zmodem_t* zm)
535: {
536: return zmodem_send_pos_header(zm, ZNAK, 0, /* Hex? */ TRUE);
537: }
538:
539: int zmodem_send_zfin(zmodem_t* zm)
540: {
541: unsigned char zfin_header[] = { ZFIN, 0, 0, 0, 0 };
542:
543: return zmodem_send_hex_header(zm,zfin_header);
544: }
545:
546: int zmodem_abort_receive(zmodem_t* zm)
547: {
548: lprintf(zm,LOG_WARNING,"Aborting receive");
549: return zmodem_send_pos_header(zm, ZABORT, 0, /* Hex? */ TRUE);
550: }
551:
552: int zmodem_send_znak(zmodem_t* zm)
553: {
554: return zmodem_send_pos_header(zm, ZNAK, zm->ack_file_pos, /* Hex? */ TRUE);
555: }
556:
557: int zmodem_send_zskip(zmodem_t* zm)
558: {
559: return zmodem_send_pos_header(zm, ZSKIP, 0L, /* Hex? */ TRUE);
560: }
561:
562: int zmodem_send_zeof(zmodem_t* zm)
563: {
564: return zmodem_send_pos_header(zm, ZEOF, zm->current_file_size, /* Hex? */ TRUE);
565: }
566:
567:
568: /*
569: * rx_raw ; receive a single byte from the line.
570: * reads as many are available and then processes them one at a time
571: * check the data stream for 5 consecutive CAN characters;
572: * and if you see them abort. this saves a lot of clutter in
573: * the rest of the code; even though it is a very strange place
574: * for an exit. (but that was wat session abort was all about.)
575: */
576:
577: int zmodem_recv_raw(zmodem_t* zm)
578: {
579: int c;
580:
581: if((c=zm->recv_byte(zm->cbdata,zm->recv_timeout)) < 0)
582: return(TIMEOUT);
583:
584: if(c == CAN) {
585: zm->n_cans++;
586: if(zm->n_cans == 5) {
587: zm->cancelled=TRUE;
588: lprintf(zm,LOG_WARNING,"recv_raw: Cancelled remotely");
589: /* return(TIMEOUT); removed June-12-2005 */
590: }
591: }
592: else {
593: zm->n_cans = 0;
594: }
595:
596: return c;
597: }
598:
599: /*
600: * rx; receive a single byte undoing any escaping at the
601: * sending site. this bit looks like a mess. sorry for that
602: * but there seems to be no other way without incurring a lot
603: * of overhead. at least like this the path for a normal character
604: * is relatively short.
605: */
606:
607: int zmodem_rx(zmodem_t* zm)
608: {
609: int c;
610:
611: /*
612: * outer loop for ever so for sure something valid
613: * will come in; a timeout will occur or a session abort
614: * will be received.
615: */
616:
617: while(is_connected(zm)) {
618:
619: while(TRUE) {
620: if((c = zmodem_recv_raw(zm)) < 0)
621: return(c);
622:
623: switch (c) {
624: case ZDLE:
625: break;
626: case XON:
627: case XON|0x80:
628: case XOFF:
629: case XOFF|0x80:
630: continue;
631: default:
632: /*
633: * if all control characters should be escaped and
634: * this one wasnt then its spurious and should be dropped.
635: */
636: if(zm->escape_ctrl_chars && (c & 0x60) == 0) {
637: continue;
638: }
639: /*
640: * normal character; return it.
641: */
642: return c;
643: }
644: break;
645: }
646:
647: /*
648: * ZDLE encoded sequence or session abort.
649: * (or something illegal; then back to the top)
650: */
651:
652: while(TRUE) {
653: if((c = zmodem_recv_raw(zm)) < 0)
654: return(c);
655:
656: if(c == XON || c == (XON|0x80) || c == XOFF || c == (XOFF|0x80) || c == ZDLE) {
657: /*
658: * these can be dropped.
659: */
660: continue;
661: }
662:
663: switch (c) {
664: /*
665: * these four are really nasty.
666: * for convenience we just change them into
667: * special characters by setting a bit outside the
668: * first 8. that way they can be recognized and still
669: * be processed as characters by the rest of the code.
670: */
671: case ZCRCE:
672: case ZCRCG:
673: case ZCRCQ:
674: case ZCRCW:
675: lprintf(zm,LOG_DEBUG,"rx: encoding data subpacket type: %s"
676: ,chr(c));
677: return (c | ZDLEESC);
678: case ZRUB0:
679: return 0x7f;
680: case ZRUB1:
681: return 0xff;
682: default:
683: if(zm->escape_ctrl_chars && (c & 0x60) == 0) {
684: /*
685: * a not escaped control character; probably
686: * something from a network. just drop it.
687: */
688: continue;
689: }
690: /*
691: * legitimate escape sequence.
692: * rebuild the orignal and return it.
693: */
694: if((c & 0x60) == 0x40) {
695: return c ^ 0x40;
696: }
697: lprintf(zm,LOG_WARNING,"rx: illegal sequence: ZDLE %s"
698: ,chr(c));
699: break;
700: }
701: break;
702: }
703: }
704:
705: /*
706: * not reached.
707: */
708:
709: return 0;
710: }
711:
712: /*
713: * receive a data subpacket as dictated by the last received header.
714: * return 2 with correct packet and end of frame
715: * return 1 with correct packet frame continues
716: * return 0 with incorrect frame.
717: * return TIMEOUT with a timeout
718: * if an acknowledgement is requested it is generated automatically
719: * here.
720: */
721:
722: /*
723: * data subpacket reception
724: */
725:
726: int zmodem_recv_data32(zmodem_t* zm, unsigned char * p, unsigned maxlen, unsigned* l)
727: {
728: int c;
729: unsigned long rxd_crc;
730: unsigned long crc;
731: int subpkt_type;
732:
733: lprintf(zm,LOG_DEBUG,"recv_data32");
734:
735: crc = 0xffffffffl;
736:
737: do {
738: c = zmodem_rx(zm);
739:
740: if(c == TIMEOUT) {
741: return TIMEOUT;
742: }
743: if(c < 0x100 && *l < maxlen) {
744: crc = ucrc32(c,crc);
745: *p++ = c;
746: (*l)++;
747: continue;
748: }
749: } while(c < 0x100);
750:
751: subpkt_type = c & 0xff;
752:
753: crc = ucrc32(subpkt_type, crc);
754:
755: crc = ~crc;
756:
757: rxd_crc = zmodem_rx(zm);
758: rxd_crc |= zmodem_rx(zm) << 8;
759: rxd_crc |= zmodem_rx(zm) << 16;
760: rxd_crc |= zmodem_rx(zm) << 24;
761:
762: if(rxd_crc != crc) {
763: lprintf(zm,LOG_WARNING,"CRC32 ERROR (%08lX, expected: %08lX) Bytes=%u, subpacket-type=%s"
764: ,rxd_crc, crc, *l, chr(subpkt_type));
765: return FALSE;
766: }
767: lprintf(zm,LOG_DEBUG,"GOOD CRC32: %08lX (Bytes=%u, subpacket-type=%s)"
768: ,crc, *l, chr(subpkt_type));
769:
770: zm->ack_file_pos += *l;
771:
772: return subpkt_type;
773: }
774:
775: int zmodem_recv_data16(zmodem_t* zm, register unsigned char* p, unsigned maxlen, unsigned* l)
776: {
777: int c;
778: int subpkt_type;
779: unsigned short crc;
780: unsigned short rxd_crc;
781:
782: lprintf(zm,LOG_DEBUG,"recv_data16");
783:
784: crc = 0;
785:
786: do {
787: c = zmodem_rx(zm);
788:
789: if(c == TIMEOUT) {
790: return TIMEOUT;
791: }
792: if(c < 0x100 && *l < maxlen) {
793: crc = ucrc16(c,crc);
794: *p++ = c;
795: (*l)++;
796: }
797: } while(c < 0x100);
798:
799: subpkt_type = c & 0xff;
800:
801: crc = ucrc16(subpkt_type,crc);
802:
803: rxd_crc = zmodem_rx(zm) << 8;
804: rxd_crc |= zmodem_rx(zm);
805:
806: if(rxd_crc != crc) {
807: lprintf(zm,LOG_WARNING,"CRC16 ERROR (%04hX, expected: %04hX) Bytes=%d"
808: ,rxd_crc, crc, *l);
809: return FALSE;
810: }
811: lprintf(zm,LOG_DEBUG,"GOOD CRC16: %04hX (Bytes=%d)", crc, *l);
812:
813: zm->ack_file_pos += *l;
814:
815: return subpkt_type;
816: }
817:
818: int zmodem_recv_data(zmodem_t* zm, unsigned char* p, size_t maxlen, unsigned* l, BOOL ack)
819: {
820: int subpkt_type;
821: unsigned n=0;
822:
823: if(l==NULL)
824: l=&n;
825:
826: lprintf(zm,LOG_DEBUG,"recv_data (%u-bit)", zm->receive_32bit_data ? 32:16);
827:
828: /*
829: * receive the right type of frame
830: */
831:
832: *l = 0;
833:
834: if(zm->receive_32bit_data) {
835: subpkt_type = zmodem_recv_data32(zm, p, maxlen, l);
836: }
837: else {
838: subpkt_type = zmodem_recv_data16(zm, p, maxlen, l);
839: }
840:
841: if(subpkt_type==FALSE)
842: return(FALSE);
843:
844: if(subpkt_type==TIMEOUT)
845: return(TIMEOUT);
846:
847: lprintf(zm,LOG_DEBUG,"recv_data received subpacket-type: %s"
848: ,chr(subpkt_type));
849:
850: switch (subpkt_type) {
851: /*
852: * frame continues non-stop
853: */
854: case ZCRCG:
855: return FRAMEOK;
856: /*
857: * frame ends
858: */
859: case ZCRCE:
860: return ENDOFFRAME;
861: /*
862: * frame continues; ZACK expected
863: */
864: case ZCRCQ:
865: if(ack)
866: zmodem_send_ack(zm, zm->ack_file_pos);
867: return FRAMEOK;
868: /*
869: * frame ends; ZACK expected
870: */
871: case ZCRCW:
872: if(ack)
873: zmodem_send_ack(zm, zm->ack_file_pos);
874: return ENDOFFRAME;
875: }
876:
877: lprintf(zm,LOG_WARNING,"Invalid subpacket-type: %s",chr(subpkt_type));
878:
879: return FALSE;
880: }
881:
882: BOOL zmodem_recv_subpacket(zmodem_t* zm, BOOL ack)
883: {
884: int type;
885:
886: type=zmodem_recv_data(zm,zm->rx_data_subpacket,sizeof(zm->rx_data_subpacket),NULL,ack);
887: if(type!=FRAMEOK && type!=ENDOFFRAME) {
888: zmodem_send_nak(zm);
889: return(FALSE);
890: }
891:
892: return(TRUE);
893: }
894:
895: int zmodem_recv_nibble(zmodem_t* zm)
896: {
897: int c;
898:
899: c = zmodem_rx(zm);
900:
901: if(c == TIMEOUT) {
902: return c;
903: }
904:
905: if(c > '9') {
906: if(c < 'a' || c > 'f') {
907: /*
908: * illegal hex; different than expected.
909: * we might as well time out.
910: */
911: return TIMEOUT;
912: }
913:
914: c -= 'a' - 10;
915: }
916: else {
917: if(c < '0') {
918: /*
919: * illegal hex; different than expected.
920: * we might as well time out.
921: */
922: return TIMEOUT;
923: }
924: c -= '0';
925: }
926:
927: return c;
928: }
929:
930: int zmodem_recv_hex(zmodem_t* zm)
931: {
932: int n1;
933: int n0;
934: int ret;
935:
936: n1 = zmodem_recv_nibble(zm);
937:
938: if(n1 == TIMEOUT) {
939: return n1;
940: }
941:
942: n0 = zmodem_recv_nibble(zm);
943:
944: if(n0 == TIMEOUT) {
945: return n0;
946: }
947:
948: ret = (n1 << 4) | n0;
949:
950: lprintf(zm,LOG_DEBUG,"recv_hex returning: 0x%02X", ret);
951:
952: return ret;
953: }
954:
955: /*
956: * receive routines for each of the six different styles of header.
957: * each of these leaves zm->rxd_header_len set to 0 if the end result is
958: * not a valid header.
959: */
960:
961: BOOL zmodem_recv_bin16_header(zmodem_t* zm)
962: {
963: int c;
964: int n;
965: unsigned short int crc;
966: unsigned short int rxd_crc;
967:
968: lprintf(zm,LOG_DEBUG,"recv_bin16_header");
969:
970: crc = 0;
971:
972: for(n=0;n<HDRLEN;n++) {
973: c = zmodem_rx(zm);
974: if(c == TIMEOUT) {
975: lprintf(zm,LOG_WARNING,"recv_bin16_header: timeout");
976: return(FALSE);
977: }
978: crc = ucrc16(c,crc);
979: zm->rxd_header[n] = c;
980: }
981:
982: rxd_crc = zmodem_rx(zm) << 8;
983: rxd_crc |= zmodem_rx(zm);
984:
985: if(rxd_crc != crc) {
986: lprintf(zm,LOG_WARNING,"CRC16 ERROR: 0x%hX, expected: 0x%hX", rxd_crc, crc);
987: return(FALSE);
988: }
989: lprintf(zm,LOG_DEBUG,"GOOD CRC16: %04hX", crc);
990:
991: zm->rxd_header_len = 5;
992:
993: return(TRUE);
994: }
995:
996: void zmodem_recv_hex_header(zmodem_t* zm)
997: {
998: int c;
999: int i;
1000: unsigned short int crc = 0;
1001: unsigned short int rxd_crc;
1002:
1003: lprintf(zm,LOG_DEBUG,"recv_hex_header");
1004:
1005: for(i=0;i<HDRLEN;i++) {
1006: c = zmodem_recv_hex(zm);
1007: if(c == TIMEOUT) {
1008: return;
1009: }
1010: crc = ucrc16(c,crc);
1011:
1012: zm->rxd_header[i] = c;
1013: }
1014:
1015: /*
1016: * receive the crc
1017: */
1018:
1019: c = zmodem_recv_hex(zm);
1020:
1021: if(c == TIMEOUT) {
1022: return;
1023: }
1024:
1025: rxd_crc = c << 8;
1026:
1027: c = zmodem_recv_hex(zm);
1028:
1029: if(c == TIMEOUT) {
1030: return;
1031: }
1032:
1033: rxd_crc |= c;
1034:
1035: if(rxd_crc == crc) {
1036: lprintf(zm,LOG_DEBUG,"GOOD CRC16: %04hX", crc);
1037: zm->rxd_header_len = 5;
1038: }
1039: else {
1040: lprintf(zm,LOG_WARNING,"CRC16 ERROR: 0x%hX, expected: 0x%hX", rxd_crc, crc);
1041: }
1042:
1043: /*
1044: * drop the end of line sequence after a hex header
1045: */
1046: c = zmodem_rx(zm);
1047: if(c == '\r') {
1048: /*
1049: * both are expected with CR
1050: */
1051: zmodem_rx(zm); /* drop LF */
1052: }
1053: }
1054:
1055: BOOL zmodem_recv_bin32_header(zmodem_t* zm)
1056: {
1057: int c;
1058: int n;
1059: unsigned long crc;
1060: unsigned long rxd_crc;
1061:
1062: lprintf(zm,LOG_DEBUG,"recv_bin32_header");
1063:
1064: crc = 0xffffffffL;
1065:
1066: for(n=0;n<HDRLEN;n++) {
1067: c = zmodem_rx(zm);
1068: if(c == TIMEOUT) {
1069: return(TRUE);
1070: }
1071: crc = ucrc32(c,crc);
1072: zm->rxd_header[n] = c;
1073: }
1074:
1075: crc = ~crc;
1076:
1077: rxd_crc = zmodem_rx(zm);
1078: rxd_crc |= zmodem_rx(zm) << 8;
1079: rxd_crc |= zmodem_rx(zm) << 16;
1080: rxd_crc |= zmodem_rx(zm) << 24;
1081:
1082: if(rxd_crc != crc) {
1083: lprintf(zm,LOG_WARNING,"CRC32 ERROR (%08lX, expected: %08lX)"
1084: ,rxd_crc, crc);
1085: return(FALSE);
1086: }
1087: lprintf(zm,LOG_DEBUG,"GOOD CRC32: %08lX", crc);
1088:
1089: zm->rxd_header_len = 5;
1090: return(TRUE);
1091: }
1092:
1093: /*
1094: * receive any style header
1095: * if the errors flag is set than whenever an invalid header packet is
1096: * received INVHDR will be returned. otherwise we wait for a good header
1097: * also; a flag (receive_32bit_data) will be set to indicate whether data
1098: * packets following this header will have 16 or 32 bit data attached.
1099: * variable headers are not implemented.
1100: */
1101:
1102: int zmodem_recv_header_raw(zmodem_t* zm, int errors)
1103: {
1104: int c;
1105: int frame_type;
1106:
1107: lprintf(zm,LOG_DEBUG,"recv_header_raw");
1108:
1109: zm->rxd_header_len = 0;
1110:
1111: do {
1112: do {
1113: if((c = zmodem_recv_raw(zm)) < 0)
1114: return(c);
1115: if(is_cancelled(zm))
1116: return(ZCAN);
1117: } while(c != ZPAD);
1118:
1119: if((c = zmodem_recv_raw(zm)) < 0)
1120: return(c);
1121:
1122: if(c == ZPAD) {
1123: if((c = zmodem_recv_raw(zm)) < 0)
1124: return(c);
1125: }
1126:
1127: /*
1128: * spurious ZPAD check
1129: */
1130:
1131: if(c != ZDLE) {
1132: lprintf(zm,LOG_WARNING,"recv_header_raw: Expected ZDLE, received: %s"
1133: ,chr(c));
1134: continue;
1135: }
1136:
1137: /*
1138: * now read the header style
1139: */
1140:
1141: c = zmodem_rx(zm);
1142:
1143: if(c == TIMEOUT) {
1144: lprintf(zm,LOG_WARNING,"recv_header_raw: TIMEOUT");
1145: return c;
1146: }
1147:
1148: switch (c) {
1149: case ZBIN:
1150: zmodem_recv_bin16_header(zm);
1151: zm->receive_32bit_data = FALSE;
1152: break;
1153: case ZHEX:
1154: zmodem_recv_hex_header(zm);
1155: zm->receive_32bit_data = FALSE;
1156: break;
1157: case ZBIN32:
1158: zmodem_recv_bin32_header(zm);
1159: zm->receive_32bit_data = TRUE;
1160: break;
1161: default:
1162: /*
1163: * unrecognized header style
1164: */
1165: lprintf(zm,LOG_ERR,"recv_header_raw: UNRECOGNIZED header style: %s"
1166: ,chr(c));
1167: if(errors) {
1168: return INVHDR;
1169: }
1170:
1171: continue;
1172: }
1173: if(errors && zm->rxd_header_len == 0) {
1174: return INVHDR;
1175: }
1176:
1177: } while(zm->rxd_header_len == 0 && !is_cancelled(zm));
1178:
1179: if(is_cancelled(zm))
1180: return(ZCAN);
1181:
1182: /*
1183: * this appears to have been a valid header.
1184: * return its type.
1185: */
1186:
1187: frame_type = zm->rxd_header[0];
1188:
1189: zm->rxd_header_pos = zm->rxd_header[ZP0] | (zm->rxd_header[ZP1] << 8) |
1190: (zm->rxd_header[ZP2] << 16) | (zm->rxd_header[ZP3] << 24);
1191:
1192: switch(frame_type) {
1193: case ZCRC:
1194: zm->crc_request = zm->rxd_header_pos;
1195: break;
1196: case ZDATA:
1197: zm->ack_file_pos = zm->rxd_header_pos;
1198: break;
1199: case ZFILE:
1200: zm->ack_file_pos = 0l;
1201: if(!zmodem_recv_subpacket(zm,/* ack? */FALSE))
1202: frame_type |= BADSUBPKT;
1203: break;
1204: case ZSINIT:
1205: case ZCOMMAND:
1206: if(!zmodem_recv_subpacket(zm,/* ack? */TRUE))
1207: frame_type |= BADSUBPKT;
1208: break;
1209: case ZFREECNT:
1210: zmodem_send_pos_header(zm, ZACK, getfreediskspace(".",1), /* Hex? */ TRUE);
1211: break;
1212: }
1213:
1214: #if 0 /*def _DEBUG */
1215: lprintf(zm,LOG_DEBUG,"recv_header_raw received header type: %s"
1216: ,frame_desc(frame_type));
1217: #endif
1218:
1219: return frame_type;
1220: }
1221:
1222: int zmodem_recv_header(zmodem_t* zm)
1223: {
1224: int ret;
1225:
1226: ret = zmodem_recv_header_raw(zm, FALSE);
1227:
1228: if(ret == TIMEOUT)
1229: lprintf(zm,LOG_WARNING,"recv_header TIMEOUT");
1230: else if(ret == INVHDR)
1231: lprintf(zm,LOG_WARNING,"recv_header detected an invalid header");
1232: else
1233: lprintf(zm,LOG_DEBUG,"recv_header returning: %s (pos=%ld)"
1234: ,frame_desc(ret), zm->rxd_header_pos);
1235:
1236: if(ret==ZCAN)
1237: zm->cancelled=TRUE;
1238:
1239: return ret;
1240: }
1241:
1242: int zmodem_recv_header_and_check(zmodem_t* zm)
1243: {
1244: int type;
1245:
1246: while(is_connected(zm)) {
1247: type = zmodem_recv_header_raw(zm,TRUE);
1248:
1249: if(type != INVHDR && (type&BADSUBPKT) == 0) {
1250: break;
1251: }
1252:
1253: zmodem_send_znak(zm);
1254: }
1255:
1256: return type;
1257: }
1258:
1259: BOOL zmodem_get_crc(zmodem_t* zm, long length, ulong* crc)
1260: {
1261: zmodem_send_pos_header(zm,ZCRC,length,TRUE);
1262: if(!zmodem_data_waiting(zm,zm->crc_timeout*1000))
1263: return(FALSE);
1264: if(zmodem_recv_header(zm)!=ZCRC)
1265: return(FALSE);
1266: if(crc!=NULL)
1267: *crc = zm->crc_request;
1268: return(TRUE);
1269: }
1270:
1271: void zmodem_parse_zrinit(zmodem_t* zm)
1272: {
1273: zm->can_full_duplex = INT_TO_BOOL(zm->rxd_header[ZF0] & ZF0_CANFDX);
1274: zm->can_overlap_io = INT_TO_BOOL(zm->rxd_header[ZF0] & ZF0_CANOVIO);
1275: zm->can_break = INT_TO_BOOL(zm->rxd_header[ZF0] & ZF0_CANBRK);
1276: zm->can_fcs_32 = INT_TO_BOOL(zm->rxd_header[ZF0] & ZF0_CANFC32);
1277: zm->escape_ctrl_chars = INT_TO_BOOL(zm->rxd_header[ZF0] & ZF0_ESCCTL);
1278: zm->escape_8th_bit = INT_TO_BOOL(zm->rxd_header[ZF0] & ZF0_ESC8);
1279:
1280: lprintf(zm,LOG_INFO,"Receiver requested mode (0x%02X):\r\n"
1281: "%s-duplex, %s overlap I/O, CRC-%u, Escape: %s"
1282: ,zm->rxd_header[ZF0]
1283: ,zm->can_full_duplex ? "Full" : "Half"
1284: ,zm->can_overlap_io ? "Can" : "Cannot"
1285: ,zm->can_fcs_32 ? 32 : 16
1286: ,zm->escape_ctrl_chars ? "ALL" : "Normal"
1287: );
1288:
1289: if((zm->recv_bufsize = (zm->rxd_header[ZP0] | zm->rxd_header[ZP1]<<8)) != 0)
1290: lprintf(zm,LOG_INFO,"Receiver specified buffer size of: %u", zm->recv_bufsize);
1291: }
1292:
1293: int zmodem_get_zrinit(zmodem_t* zm)
1294: {
1295: unsigned char zrqinit_header[] = { ZRQINIT, /* ZF3: */0, 0, 0, /* ZF0: */0 };
1296: /* Note: sz/dsz/fdsz sends 0x80 in ZF3 because it supports var-length headers. */
1297: /* We do not, so we send 0x00, resulting in a CRC-16 value of 0x0000 as well. */
1298:
1299: zmodem_send_raw(zm,'r');
1300: zmodem_send_raw(zm,'z');
1301: zmodem_send_raw(zm,'\r');
1302: zmodem_send_hex_header(zm,zrqinit_header);
1303:
1304: if(!zmodem_data_waiting(zm,zm->init_timeout*1000))
1305: return(TIMEOUT);
1306: return zmodem_recv_header(zm);
1307: }
1308:
1309: int zmodem_send_zrinit(zmodem_t* zm)
1310: {
1311: unsigned char zrinit_header[] = { ZRINIT, 0, 0, 0, 0 };
1312:
1313: zrinit_header[ZF0] = ZF0_CANFDX;
1314:
1315: if(!zm->no_streaming)
1316: zrinit_header[ZF0] |= ZF0_CANOVIO;
1317:
1318: if(zm->can_break)
1319: zrinit_header[ZF0] |= ZF0_CANBRK;
1320:
1321: if(!zm->want_fcs_16)
1322: zrinit_header[ZF0] |= ZF0_CANFC32;
1323:
1324: if(zm->escape_ctrl_chars)
1325: zrinit_header[ZF0] |= ZF0_ESCCTL;
1326:
1327: if(zm->escape_8th_bit)
1328: zrinit_header[ZF0] |= ZF0_ESC8;
1329:
1330: if(zm->no_streaming && zm->recv_bufsize==0)
1331: zm->recv_bufsize = sizeof(zm->rx_data_subpacket);
1332:
1333: zrinit_header[ZP0] = zm->recv_bufsize & 0xff;
1334: zrinit_header[ZP1] = zm->recv_bufsize >> 8;
1335:
1336: return zmodem_send_hex_header(zm, zrinit_header);
1337: }
1338:
1339: int zmodem_get_zfin(zmodem_t* zm)
1340: {
1341: int type;
1342:
1343: zmodem_send_zfin(zm);
1344: do {
1345: type = zmodem_recv_header(zm);
1346: } while(type != ZFIN && type != TIMEOUT && is_connected(zm));
1347:
1348: /*
1349: * these Os are formally required; but they don't do a thing
1350: * unfortunately many programs require them to exit
1351: * (both programs already sent a ZFIN so why bother ?)
1352: */
1353:
1354: if(type != TIMEOUT) {
1355: zmodem_send_raw(zm,'O');
1356: zmodem_send_raw(zm,'O');
1357: }
1358:
1359: return 0;
1360: }
1361:
1362:
1363: /*
1364: * send from the current position in the file
1365: * all the way to end of file or until something goes wrong.
1366: * (ZNAK or ZRPOS received)
1367: * the name is only used to show progress
1368: */
1369:
1370: int zmodem_send_from(zmodem_t* zm, FILE* fp, ulong pos, ulong* sent)
1371: {
1372: size_t n;
1373: uchar type;
1374: unsigned buf_sent=0;
1375:
1376: if(sent!=NULL)
1377: *sent=0;
1378:
1379: fseek(fp,pos,SEEK_SET);
1380:
1381: zmodem_send_pos_header(zm, ZDATA, pos, /* Hex? */ FALSE);
1382:
1383: /*
1384: * send the data in the file
1385: */
1386:
1387: while(is_connected(zm)) {
1388:
1389: /*
1390: * read a block from the file
1391: */
1392:
1393: n = fread(zm->tx_data_subpacket,sizeof(BYTE),zm->block_size,fp);
1394:
1395: if(zm->progress!=NULL)
1396: zm->progress(zm->cbdata, ftell(fp));
1397:
1398: type = ZCRCG;
1399:
1400: /** ZMODEM.DOC:
1401: ZCRCW data subpackets expect a response before the next frame is sent.
1402: If the receiver does not indicate overlapped I/O capability with the
1403: CANOVIO bit, or sets a buffer size, the sender uses the ZCRCW to allow
1404: the receiver to write its buffer before sending more data.
1405: ***/
1406: if(!zm->can_overlap_io || zm->no_streaming
1407: || (zm->recv_bufsize && buf_sent+n>=zm->recv_bufsize)) {
1408: type=ZCRCW;
1409: buf_sent=0;
1410: }
1411:
1412: if((ulong)ftell(fp) >= zm->current_file_size || n==0) /* can't use feof() here! */
1413: type = ZCRCE;
1414:
1415: if(zmodem_send_data(zm, type, zm->tx_data_subpacket, n)!=0)
1416: return(TIMEOUT);
1417:
1418: if(type == ZCRCW || type == ZCRCE) {
1419: int ack;
1420: lprintf(zm,LOG_DEBUG,"Sent end-of-frame (%s sub-packet)", chr(type));
1421:
1422: if(type==ZCRCW) { /* ZACK expected */
1423:
1424: lprintf(zm,LOG_DEBUG,"Waiting for ZACK");
1425: while(is_connected(zm)) {
1426: if((ack = zmodem_recv_header(zm)) != ZACK)
1427: return(ack);
1428:
1429: if(is_cancelled(zm))
1430: return(ZCAN);
1431:
1432: if(zm->rxd_header_pos == (ulong)ftell(fp))
1433: break;
1434: lprintf(zm,LOG_WARNING,"ZACK for incorrect offset (%lu vs %lu)"
1435: ,zm->rxd_header_pos, ftell(fp));
1436: }
1437:
1438: }
1439: }
1440:
1441: if(sent!=NULL)
1442: *sent+=n;
1443:
1444: buf_sent+=n;
1445:
1446: if((ulong)ftell(fp) >= zm->current_file_size) {
1447: lprintf(zm,LOG_DEBUG,"send_from: end of file (%ld)", zm->current_file_size );
1448: return ZACK;
1449: }
1450: if(n==0) {
1451: lprintf(zm,LOG_ERR,"send_from: read error %d at offset %lu"
1452: ,ferror(fp), ftell(fp) );
1453: return ZACK;
1454: }
1455:
1456: /*
1457: * characters from the other side
1458: * check out that header
1459: */
1460:
1461: while(zmodem_data_waiting(zm, zm->consecutive_errors ? 1000:0)
1462: && !is_cancelled(zm) && is_connected(zm)) {
1463: int type;
1464: int c;
1465: lprintf(zm,LOG_DEBUG,"Back-channel traffic detected:");
1466: if((c = zmodem_recv_raw(zm)) < 0)
1467: return(c);
1468: if(c == ZPAD) {
1469: type = zmodem_recv_header(zm);
1470: if(type != TIMEOUT && type != ZACK) {
1471: return type;
1472: }
1473: } else
1474: lprintf(zm,LOG_DEBUG,"Received: %s",chr(c));
1475: }
1476: if(is_cancelled(zm))
1477: return(ZCAN);
1478:
1479: zm->consecutive_errors = 0;
1480:
1481: if(zm->block_size < zm->max_block_size) {
1482: zm->block_size*=2;
1483: if(zm->block_size > zm->max_block_size)
1484: zm->block_size = zm->max_block_size;
1485: }
1486:
1487: if(type == ZCRCW || type == ZCRCE) /* end-of-frame */
1488: zmodem_send_pos_header(zm, ZDATA, ftell(fp), /* Hex? */ FALSE);
1489: }
1490:
1491: lprintf(zm,LOG_DEBUG,"send_from: returning unexpectedly!");
1492:
1493: /*
1494: * end of file reached.
1495: * should receive something... so fake ZACK
1496: */
1497:
1498: return ZACK;
1499: }
1500:
1501: /*
1502: * send a file; returns true when session is aborted.
1503: * (using ZABORT frame)
1504: */
1505:
1506: BOOL zmodem_send_file(zmodem_t* zm, char* fname, FILE* fp, BOOL request_init, time_t* start, ulong* sent)
1507: {
1508: BOOL success=FALSE;
1509: ulong pos=0;
1510: ulong sent_bytes;
1511: struct stat s;
1512: unsigned char * p;
1513: uchar zfile_frame[] = { ZFILE, 0, 0, 0, 0 };
1514: int type;
1515: int i;
1516: unsigned attempts;
1517:
1518: if(zm->block_size == 0)
1519: zm->block_size = ZBLOCKLEN;
1520:
1521: if(zm->block_size < 128)
1522: zm->block_size = 128;
1523:
1524: if(zm->block_size > sizeof(zm->tx_data_subpacket))
1525: zm->block_size = sizeof(zm->tx_data_subpacket);
1526:
1527: if(zm->max_block_size < zm->block_size)
1528: zm->max_block_size = zm->block_size;
1529:
1530: if(zm->max_block_size > sizeof(zm->rx_data_subpacket))
1531: zm->max_block_size = sizeof(zm->rx_data_subpacket);
1532:
1533: if(sent!=NULL)
1534: *sent=0;
1535:
1536: if(start!=NULL)
1537: *start=time(NULL);
1538:
1539: zm->file_skipped=FALSE;
1540:
1541: if(zm->no_streaming)
1542: lprintf(zm,LOG_WARNING,"Streaming disabled");
1543:
1544: if(request_init) {
1545: for(zm->errors=0; zm->errors<=zm->max_errors && !is_cancelled(zm) && is_connected(zm); zm->errors++) {
1546: lprintf(zm,LOG_INFO,"Sending ZRQINIT (%u of %u)"
1547: ,zm->errors+1,zm->max_errors+1);
1548: i = zmodem_get_zrinit(zm);
1549: if(i == ZRINIT) {
1550: zmodem_parse_zrinit(zm);
1551: break;
1552: }
1553: lprintf(zm,LOG_WARNING,"send_file: received header type %s"
1554: ,frame_desc(i));
1555: }
1556: if(zm->errors>=zm->max_errors || is_cancelled(zm))
1557: return(FALSE);
1558: }
1559:
1560: fstat(fileno(fp),&s);
1561: zm->current_file_size = s.st_size;
1562: SAFECOPY(zm->current_file_name, getfname(fname));
1563:
1564: /*
1565: * the file exists. now build the ZFILE frame
1566: */
1567:
1568: /*
1569: * set conversion option
1570: * (not used; always binary)
1571: */
1572:
1573: zfile_frame[ZF0] = ZF0_ZCBIN;
1574:
1575: /*
1576: * management option
1577: */
1578:
1579: if(zm->management_protect) {
1580: zfile_frame[ZF1] = ZF1_ZMPROT;
1581: lprintf(zm,LOG_DEBUG,"send_file: protecting destination");
1582: }
1583: else if(zm->management_clobber) {
1584: zfile_frame[ZF1] = ZF1_ZMCLOB;
1585: lprintf(zm,LOG_DEBUG,"send_file: overwriting destination");
1586: }
1587: else if(zm->management_newer) {
1588: zfile_frame[ZF1] = ZF1_ZMNEW;
1589: lprintf(zm,LOG_DEBUG,"send_file: overwriting destination if newer");
1590: }
1591: else
1592: zfile_frame[ZF1] = ZF1_ZMCRC;
1593:
1594: /*
1595: * transport options
1596: * (just plain normal transfer)
1597: */
1598:
1599: zfile_frame[ZF2] = ZF2_ZTNOR;
1600:
1601: /*
1602: * extended options
1603: */
1604:
1605: zfile_frame[ZF3] = 0;
1606:
1607: /*
1608: * now build the data subpacket with the file name and lots of other
1609: * useful information.
1610: */
1611:
1612: /*
1613: * first enter the name and a 0
1614: */
1615:
1616: p = zm->tx_data_subpacket;
1617:
1618: strcpy(p,getfname(fname));
1619:
1620: p += strlen(p) + 1;
1621:
1622: sprintf(p,"%lu %lo %lo %d %u %lu %d"
1623: ,zm->current_file_size
1624: ,s.st_mtime
1625: ,0 /* file mode */
1626: ,0 /* serial number */
1627: ,zm->files_remaining
1628: ,zm->bytes_remaining
1629: ,0 /* file type */
1630: );
1631:
1632: p += strlen(p) + 1;
1633:
1634: do {
1635: /*
1636: * send the header and the data
1637: */
1638:
1639: lprintf(zm,LOG_DEBUG,"Sending ZFILE header block: '%s'"
1640: ,zm->tx_data_subpacket+strlen(zm->tx_data_subpacket)+1);
1641:
1642: zmodem_send_bin_header(zm,zfile_frame);
1643: zmodem_send_data(zm,ZCRCW,zm->tx_data_subpacket,p - zm->tx_data_subpacket);
1644:
1645: /*
1646: * wait for anything but an ZACK packet
1647: */
1648:
1649: do {
1650: type = zmodem_recv_header(zm);
1651: if(is_cancelled(zm))
1652: return(FALSE);
1653: } while(type == ZACK && is_connected(zm));
1654:
1655: if(!is_connected(zm))
1656: return(FALSE);
1657:
1658: #if 0
1659: lprintf(zm,LOG_INFO,"type : %d",type);
1660: #endif
1661:
1662: if(type == ZSKIP) {
1663: zm->file_skipped=TRUE;
1664: lprintf(zm,LOG_WARNING,"File skipped by receiver");
1665: return(FALSE);
1666: }
1667:
1668: if(type == ZCRC) {
1669: if(zm->crc_request==0)
1670: lprintf(zm,LOG_NOTICE,"Receiver requested CRC of entire file");
1671: else
1672: lprintf(zm,LOG_NOTICE,"Receiver requested CRC of first %lu bytes"
1673: ,zm->crc_request);
1674: zmodem_send_pos_header(zm,ZCRC,fcrc32(fp,zm->crc_request),TRUE);
1675: type = zmodem_recv_header(zm);
1676: }
1677:
1678: } while(type != ZRPOS);
1679:
1680: zm->transfer_start_time = time(NULL);
1681: zm->transfer_start_pos = 0;
1682: if(zm->rxd_header_pos && zm->rxd_header_pos <= zm->current_file_size) {
1683: pos = zm->transfer_start_pos = zm->rxd_header_pos;
1684: lprintf(zm,LOG_INFO,"Starting transfer at offset: %lu (resume)", pos);
1685: }
1686:
1687: if(start!=NULL)
1688: *start=zm->transfer_start_time;
1689:
1690: rewind(fp);
1691: zm->errors = 0;
1692: zm->consecutive_errors = 0;
1693: do {
1694: /*
1695: * and start sending
1696: */
1697:
1698: type = zmodem_send_from(zm, fp, pos, &sent_bytes);
1699:
1700: if(!is_connected(zm))
1701: return(FALSE);
1702:
1703: if(type == ZFERR || type == ZABORT || is_cancelled(zm))
1704: return(FALSE);
1705:
1706: if(sent != NULL)
1707: *sent += sent_bytes;
1708:
1709: pos += sent_bytes;
1710:
1711: if(type == ZACK) /* success */
1712: break;
1713:
1714: lprintf(zm,LOG_ERR,"%s at offset: %lu", chr(type), pos);
1715:
1716: if(zm->block_size == zm->max_block_size && zm->max_block_size > ZBLOCKLEN)
1717: zm->max_block_size /= 2;
1718:
1719: if(zm->block_size > 128)
1720: zm->block_size /= 2;
1721:
1722: zm->errors++;
1723: if(++zm->consecutive_errors > zm->max_errors)
1724: return(FALSE);
1725:
1726: /*
1727: * fetch pos from the ZRPOS header
1728: */
1729:
1730: if(type == ZRPOS) {
1731: if(zm->rxd_header_pos <= zm->current_file_size) {
1732: if(pos != zm->rxd_header_pos) {
1733: pos = zm->rxd_header_pos;
1734: lprintf(zm,LOG_INFO,"Resuming transfer from offset: %lu", pos);
1735: }
1736: } else
1737: lprintf(zm,LOG_WARNING,"Invalid ZRPOS offset: %lu", zm->rxd_header_pos);
1738: }
1739:
1740: } while(type == ZRPOS || type == ZNAK || type==TIMEOUT);
1741:
1742:
1743: lprintf(zm,LOG_INFO,"Finishing transfer on receipt of header: %s", chr(type));
1744: if(sent!=NULL)
1745: lprintf(zm,LOG_DEBUG,"Sent %lu total bytes", *sent);
1746:
1747: if(type==ZACK) {
1748: /*
1749: * file sent. send end of file frame
1750: * and wait for zrinit. if it doesnt come then try again
1751: */
1752:
1753: for(attempts=0;attempts<=zm->max_errors && !is_cancelled(zm) && is_connected(zm);attempts++) {
1754: lprintf(zm,LOG_INFO,"Sending End-of-File (ZEOF) frame (%u of %u)"
1755: ,attempts+1, zm->max_errors+1);
1756: zmodem_send_zeof(zm);
1757: if(zmodem_recv_header(zm)==ZRINIT) {
1758: success=TRUE;
1759: break;
1760: }
1761: }
1762: }
1763: return(success);
1764: }
1765:
1766: int zmodem_recv_files(zmodem_t* zm, const char* download_dir, ulong* bytes_received)
1767: {
1768: char fpath[MAX_PATH+1];
1769: FILE* fp;
1770: long l;
1771: BOOL skip;
1772: ulong b;
1773: ulong crc;
1774: ulong rcrc;
1775: ulong bytes;
1776: ulong kbytes;
1777: ulong start_bytes;
1778: unsigned files_received=0;
1779: time_t t;
1780: unsigned cps;
1781: unsigned timeout;
1782: unsigned errors;
1783:
1784: if(bytes_received!=NULL)
1785: *bytes_received=0;
1786: zm->current_file_num=1;
1787: while(zmodem_recv_init(zm)==ZFILE) {
1788: bytes=zm->current_file_size;
1789: kbytes=bytes/1024;
1790: if(kbytes<1) kbytes=0;
1791: lprintf(zm,LOG_INFO,"Downloading %s (%lu KBytes) via Zmodem", zm->current_file_name, kbytes);
1792:
1793: do { /* try */
1794: skip=TRUE;
1795:
1796: sprintf(fpath,"%s/%s",download_dir,zm->current_file_name);
1797: lprintf(zm,LOG_DEBUG,"fpath=%s",fpath);
1798: if(fexist(fpath)) {
1799: l=flength(fpath);
1800: lprintf(zm,LOG_WARNING,"%s already exists (%lu bytes)",fpath,l);
1801: if(l>=(long)bytes) {
1802: lprintf(zm,LOG_WARNING,"Local file size >= remote file size (%ld)"
1803: ,bytes);
1804: break;
1805: }
1806: if((fp=fopen(fpath,"rb"))==NULL) {
1807: lprintf(zm,LOG_ERR,"Error %d opening %s", errno, fpath);
1808: break;
1809: }
1810: setvbuf(fp,NULL,_IOFBF,0x10000);
1811:
1812: lprintf(zm,LOG_INFO,"Calculating CRC of: %s", fpath);
1813: crc=fcrc32(fp,l);
1814: fclose(fp);
1815: lprintf(zm,LOG_INFO,"CRC of %s (%lu bytes): %08lX"
1816: ,getfname(fpath), l, crc);
1817: lprintf(zm,LOG_INFO,"Requesting CRC of remote file: %s", zm->current_file_name);
1818: if(!zmodem_get_crc(zm,l,&rcrc)) {
1819: lprintf(zm,LOG_ERR,"Failed to get CRC of remote file");
1820: break;
1821: }
1822: if(crc!=rcrc) {
1823: lprintf(zm,LOG_WARNING,"Remote file has different CRC value: %08lX", rcrc);
1824: break;
1825: }
1826: lprintf(zm,LOG_INFO,"Resuming download of %s",fpath);
1827: }
1828:
1829: if((fp=fopen(fpath,"ab"))==NULL) {
1830: lprintf(zm,LOG_ERR,"Error %d opening/creating/appending %s",errno,fpath);
1831: break;
1832: }
1833: start_bytes=filelength(fileno(fp));
1834:
1835: skip=FALSE;
1836: errors=zmodem_recv_file_data(zm,fp,flength(fpath));
1837:
1838: for(;errors<=zm->max_errors && !is_cancelled(zm); errors++) {
1839: if(zmodem_recv_header_and_check(zm))
1840: break;
1841: }
1842: fclose(fp);
1843: l=flength(fpath);
1844: if(errors && l==0) { /* aborted/failed download */
1845: if(remove(fpath)) /* don't save 0-byte file */
1846: lprintf(zm,LOG_ERR,"Error %d removing %s",errno,fpath);
1847: else
1848: lprintf(zm,LOG_INFO,"Deleted 0-byte file %s",fpath);
1849: }
1850: else {
1851: if(l!=(long)bytes) {
1852: lprintf(zm,LOG_WARNING,"Incomplete download (%ld bytes received, expected %lu)"
1853: ,l,bytes);
1854: } else {
1855: if((t=time(NULL)-zm->transfer_start_time)<=0)
1856: t=1;
1857: b=l-start_bytes;
1858: if((cps=b/t)==0)
1859: cps=1;
1860: lprintf(zm,LOG_INFO,"Received %lu bytes successfully (%u CPS)",b,cps);
1861: files_received++;
1862: if(bytes_received!=NULL)
1863: *bytes_received+=b;
1864: }
1865: if(zm->current_file_time)
1866: setfdate(fpath,zm->current_file_time);
1867: }
1868:
1869: } while(0);
1870: /* finally */
1871:
1872: if(skip) {
1873: lprintf(zm,LOG_WARNING,"Skipping file");
1874: zmodem_send_zskip(zm);
1875: }
1876: zm->current_file_num++;
1877: }
1878: if(zm->local_abort)
1879: zmodem_abort_receive(zm);
1880:
1881: /* wait for "over-and-out" */
1882: timeout=zm->recv_timeout;
1883: zm->recv_timeout=2;
1884: if(zmodem_rx(zm)=='O')
1885: zmodem_rx(zm);
1886: zm->recv_timeout=timeout;
1887:
1888: return(files_received);
1889: }
1890:
1891: int zmodem_recv_init(zmodem_t* zm)
1892: {
1893: int type=CAN;
1894: unsigned errors;
1895:
1896: lprintf(zm,LOG_DEBUG,"recv_init");
1897:
1898: #if 0
1899: while(is_connected(zm) && !is_cancelled(zm) && (ch=zm->recv_byte(zm,0))!=NOINP)
1900: lprintf(zm,LOG_DEBUG,"Throwing out received: %s",chr((uchar)ch));
1901: #endif
1902:
1903: for(errors=0; errors<=zm->max_errors && !is_cancelled(zm) && is_connected(zm); errors++) {
1904: lprintf(zm,LOG_DEBUG,"Sending ZRINIT (%u of %u)"
1905: ,errors+1, zm->max_errors+1);
1906: zmodem_send_zrinit(zm);
1907:
1908: type = zmodem_recv_header(zm);
1909:
1910: if(type==TIMEOUT)
1911: continue;
1912:
1913: lprintf(zm,LOG_DEBUG,"Received header: %s",chr(type));
1914:
1915: if(type==ZFILE) {
1916: zmodem_parse_zfile_subpacket(zm);
1917: return(type);
1918: }
1919:
1920: if(type==ZFIN) {
1921: zmodem_send_zfin(zm); /* ACK */
1922: return(type);
1923: }
1924:
1925: lprintf(zm,LOG_WARNING,"Received frame: %s, expected ZFILE or ZFIN"
1926: ,frame_desc(type));
1927: lprintf(zm,LOG_DEBUG,"ZF0=%02X ZF1=%02X ZF2=%02X ZF3=%02X"
1928: ,zm->rxd_header[ZF0],zm->rxd_header[ZF1],zm->rxd_header[ZF2],zm->rxd_header[ZF3]);
1929: }
1930:
1931: return(type);
1932: }
1933:
1934: void zmodem_parse_zfile_subpacket(zmodem_t* zm)
1935: {
1936: int i;
1937: long mode=0;
1938: long serial=-1;
1939:
1940: SAFECOPY(zm->current_file_name,getfname(zm->rx_data_subpacket));
1941:
1942: zm->current_file_size = 0;
1943: zm->current_file_time = 0;
1944: zm->files_remaining = 0;
1945: zm->bytes_remaining = 0;
1946:
1947: i=sscanf(zm->rx_data_subpacket+strlen(zm->rx_data_subpacket)+1,"%lu %lo %lo %lo %lu %lu"
1948: ,&zm->current_file_size /* file size (decimal) */
1949: ,&zm->current_file_time /* file time (octal unix format) */
1950: ,&mode /* file mode */
1951: ,&serial /* program serial number */
1952: ,&zm->files_remaining /* remaining files to be sent */
1953: ,&zm->bytes_remaining /* remaining bytes to be sent */
1954: );
1955:
1956: lprintf(zm,LOG_DEBUG,"Zmodem header (%u fields): %s"
1957: ,i, zm->rx_data_subpacket+strlen(zm->rx_data_subpacket)+1);
1958:
1959: if(!zm->files_remaining)
1960: zm->files_remaining = 1;
1961: if(!zm->bytes_remaining)
1962: zm->bytes_remaining = zm->current_file_size;
1963:
1964: if(!zm->total_files)
1965: zm->total_files = zm->files_remaining;
1966: if(!zm->total_bytes)
1967: zm->total_bytes = zm->bytes_remaining;
1968: }
1969:
1970: /*
1971: * receive file data until the end of the file or until something goes wrong.
1972: * the name is only used to show progress
1973: */
1974:
1975: unsigned zmodem_recv_file_data(zmodem_t* zm, FILE* fp, ulong offset)
1976: {
1977: int i=0;
1978: unsigned errors=0;
1979:
1980: zm->transfer_start_pos=offset;
1981: zm->transfer_start_time=time(NULL);
1982:
1983: fseek(fp,offset,SEEK_SET);
1984:
1985: while(errors<=zm->max_errors && is_connected(zm)
1986: && (ulong)ftell(fp) < zm->current_file_size && !is_cancelled(zm)) {
1987:
1988: if(i!=ENDOFFRAME)
1989: zmodem_send_pos_header(zm, ZRPOS, ftell(fp), /* Hex? */ TRUE);
1990:
1991: if((i = zmodem_recv_file_frame(zm,fp)) == ZEOF)
1992: break;
1993: if(i!=ENDOFFRAME) {
1994: if(i>0)
1995: lprintf(zm,LOG_ERR,"%s at offset: %lu", chr(i), ftell(fp));
1996: errors++;
1997: }
1998: }
1999: return(errors);
2000: }
2001:
2002:
2003: int zmodem_recv_file_frame(zmodem_t* zm, FILE* fp)
2004: {
2005: unsigned n;
2006: int type;
2007:
2008: /*
2009: * wait for a ZDATA header with the right file offset
2010: * or a timeout or a ZFIN
2011: */
2012:
2013: do {
2014: do {
2015: type = zmodem_recv_header(zm);
2016: if (type == TIMEOUT) {
2017: return TIMEOUT;
2018: }
2019: if(is_cancelled(zm))
2020: return(ZCAN);
2021:
2022: } while(type != ZDATA);
2023:
2024: if(zm->rxd_header_pos==(ulong)ftell(fp))
2025: break;
2026: lprintf(zm,LOG_WARNING,"Wrong ZDATA block (%lu vs %lu)", zm->rxd_header_pos, ftell(fp));
2027:
2028: } while(!is_cancelled(zm) && is_connected(zm));
2029:
2030: do {
2031: type = zmodem_recv_data(zm,zm->rx_data_subpacket,sizeof(zm->rx_data_subpacket),&n,TRUE);
2032:
2033: /* fprintf(stderr,"packet len %d type %d\n",n,type);
2034: */
2035: if (type == ENDOFFRAME || type == FRAMEOK) {
2036: fwrite(zm->rx_data_subpacket,1,n,fp);
2037: }
2038:
2039: if(type==FRAMEOK)
2040: zm->block_size = n;
2041:
2042: if(zm->progress!=NULL)
2043: zm->progress(zm->cbdata,ftell(fp));
2044:
2045: if(is_cancelled(zm))
2046: return(ZCAN);
2047:
2048: } while(type == FRAMEOK);
2049:
2050: return type;
2051: }
2052:
2053: const char* zmodem_source(void)
2054: {
2055: return(__FILE__);
2056: }
2057:
2058: char* zmodem_ver(char *buf)
2059: {
2060: sscanf("$Revision: 1.71 $", "%*s %s", buf);
2061:
2062: return(buf);
2063: }
2064:
2065: void zmodem_init(zmodem_t* zm, void* cbdata
2066: ,int (*lputs)(void*, int level, const char* str)
2067: ,void (*progress)(void* unused, ulong)
2068: ,int (*send_byte)(void*, uchar ch, unsigned timeout)
2069: ,int (*recv_byte)(void*, unsigned timeout)
2070: ,BOOL (*is_connected)(void*)
2071: ,BOOL (*is_cancelled)(void*)
2072: ,BOOL (*data_waiting)(void*, unsigned timeout))
2073: {
2074: memset(zm,0,sizeof(zmodem_t));
2075:
2076: /* Use sane default values */
2077: zm->init_timeout=10; /* seconds */
2078: zm->send_timeout=15; /* seconds */
2079: zm->recv_timeout=20; /* seconds */
2080: zm->crc_timeout=60; /* seconds */
2081: #if 0
2082: zm->byte_timeout=3; /* seconds */
2083: zm->ack_timeout=10; /* seconds */
2084: #endif
2085: zm->block_size=ZBLOCKLEN;
2086: zm->max_block_size=ZBLOCKLEN;
2087: zm->max_errors=9;
2088:
2089: zm->cbdata=cbdata;
2090: zm->lputs=lputs;
2091: zm->progress=progress;
2092: zm->send_byte=send_byte;
2093: zm->recv_byte=recv_byte;
2094: zm->is_connected=is_connected;
2095: zm->is_cancelled=is_cancelled;
2096: zm->data_waiting=data_waiting;
2097: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.