![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xmodem.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 xmodem.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 ! root 1: /* xmodem.c */ ! 2: ! 3: /* Synchronet X/YMODEM Functions */ ! 4: ! 5: /* $Id: xmodem.c,v 1.26 2006/02/24 09:50:50 rswindell Exp $ */ ! 6: ! 7: /**************************************************************************** ! 8: * @format.tab-size 4 (Plain Text/Source Code File Header) * ! 9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) * ! 10: * * ! 11: * Copyright 2006 Rob Swindell - http://www.synchro.net/copyright.html * ! 12: * * ! 13: * This program is free software; you can redistribute it and/or * ! 14: * modify it under the terms of the GNU General Public License * ! 15: * as published by the Free Software Foundation; either version 2 * ! 16: * of the License, or (at your option) any later version. * ! 17: * See the GNU General Public License for more details: gpl.txt or * ! 18: * http://www.fsf.org/copyleft/gpl.html * ! 19: * * ! 20: * Anonymous FTP access to the most recent released source is available at * ! 21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net * ! 22: * * ! 23: * Anonymous CVS access to the development source and modification history * ! 24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: * ! 25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login * ! 26: * (just hit return, no password is necessary) * ! 27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src * ! 28: * * ! 29: * For Synchronet coding style and modification guidelines, see * ! 30: * http://www.synchro.net/source.html * ! 31: * * ! 32: * You are encouraged to submit any modifications (preferably in Unix diff * ! 33: * format) via e-mail to [email protected] * ! 34: * * ! 35: * Note: If this box doesn't appear square, then you need to fix your tabs. * ! 36: ****************************************************************************/ ! 37: ! 38: /* Standard headers */ ! 39: #include <stdio.h> ! 40: #include <sys/stat.h> /* struct stat */ ! 41: #include <stdarg.h> /* va_list */ ! 42: ! 43: /* smblib */ ! 44: #include "crc16.h" ! 45: ! 46: /* xpdev */ ! 47: #include "genwrap.h" /* YIELD */ ! 48: #include "dirwrap.h" /* getfname */ ! 49: ! 50: /* sexyz */ ! 51: #include "sexyz.h" ! 52: ! 53: #define getcom(t) xm->recv_byte(xm->cbdata,t) ! 54: #define putcom(ch) xm->send_byte(xm->cbdata,ch,xm->send_timeout) ! 55: ! 56: static int lprintf(xmodem_t* xm, int level, const char *fmt, ...) ! 57: { ! 58: va_list argptr; ! 59: char sbuf[1024]; ! 60: ! 61: if(xm->lputs==NULL) ! 62: return(-1); ! 63: ! 64: va_start(argptr,fmt); ! 65: vsnprintf(sbuf,sizeof(sbuf),fmt,argptr); ! 66: sbuf[sizeof(sbuf)-1]=0; ! 67: va_end(argptr); ! 68: return(xm->lputs(xm->cbdata,level,sbuf)); ! 69: } ! 70: ! 71: static BOOL is_connected(xmodem_t* xm) ! 72: { ! 73: if(xm->is_connected!=NULL) ! 74: return(xm->is_connected(xm->cbdata)); ! 75: return(TRUE); ! 76: } ! 77: ! 78: static BOOL is_cancelled(xmodem_t* xm) ! 79: { ! 80: if(xm->is_cancelled!=NULL) ! 81: return(xm->cancelled=xm->is_cancelled(xm->cbdata)); ! 82: return(xm->cancelled); ! 83: } ! 84: ! 85: static char *chr(uchar ch) ! 86: { ! 87: static char str[25]; ! 88: ! 89: switch(ch) { ! 90: case SOH: return("SOH"); ! 91: case STX: return("STX"); ! 92: case ETX: return("ETX"); ! 93: case EOT: return("EOT"); ! 94: case ACK: return("ACK"); ! 95: case NAK: return("NAK"); ! 96: case CAN: return("CAN"); ! 97: } ! 98: if(ch>=' ' && ch<='~') ! 99: sprintf(str,"'%c' (%02Xh)",ch,ch); ! 100: else ! 101: sprintf(str,"%u (%02Xh)",ch,ch); ! 102: return(str); ! 103: } ! 104: ! 105: ! 106: int xmodem_put_ack(xmodem_t* xm) ! 107: { ! 108: while(getcom(0)!=NOINP && is_connected(xm)) ! 109: ; /* wait for any trailing data */ ! 110: return putcom(ACK); ! 111: } ! 112: ! 113: int xmodem_put_nak(xmodem_t* xm, unsigned block_num) ! 114: { ! 115: while(getcom(0)!=NOINP && is_connected(xm)) ! 116: ; /* wait for any trailing data */ ! 117: ! 118: if(block_num<=1) { ! 119: if(*(xm->mode)&GMODE) { /* G for Ymodem-G */ ! 120: lprintf(xm,LOG_INFO,"Requesting mode: Streaming, 16-bit CRC"); ! 121: return putcom('G'); ! 122: } else if(*(xm->mode)&CRC) { /* C for CRC */ ! 123: lprintf(xm,LOG_INFO,"Requesting mode: 16-bit CRC"); ! 124: return putcom('C'); ! 125: } else { /* NAK for checksum */ ! 126: lprintf(xm,LOG_INFO,"Requesting mode: 8-bit Checksum"); ! 127: return putcom(NAK); ! 128: } ! 129: } ! 130: return putcom(NAK); ! 131: } ! 132: ! 133: int xmodem_cancel(xmodem_t* xm) ! 134: { ! 135: int i; ! 136: int result; ! 137: ! 138: if(!is_cancelled(xm) && is_connected(xm)) { ! 139: for(i=0;i<8 && is_connected(xm);i++) ! 140: if((result=putcom(CAN))!=0) ! 141: return result; ! 142: for(i=0;i<10 && is_connected(xm);i++) ! 143: if((result=putcom('\b'))!=0) ! 144: return result; ! 145: xm->cancelled=TRUE; ! 146: } ! 147: ! 148: return 0; ! 149: } ! 150: ! 151: /****************************************************************************/ ! 152: /* Return 0 on success */ ! 153: /****************************************************************************/ ! 154: int xmodem_get_block(xmodem_t* xm, uchar* block, unsigned expected_block_num) ! 155: { ! 156: uchar block_num; /* Block number received in header */ ! 157: uchar block_inv; ! 158: uchar chksum,calc_chksum; ! 159: int i,eot=0,can=0; ! 160: uint b,errors; ! 161: ushort crc,calc_crc; ! 162: ! 163: for(errors=0;errors<=xm->max_errors && is_connected(xm);errors++) { ! 164: ! 165: i=getcom(expected_block_num<=1 ? 5 : 10); ! 166: if(eot && i!=EOT && i!=NOINP) ! 167: eot=0; ! 168: if(can && i!=CAN) ! 169: can=0; ! 170: switch(i) { ! 171: case SOH: /* 128 byte blocks */ ! 172: xm->block_size=128; ! 173: break; ! 174: case STX: /* 1024 byte blocks */ ! 175: xm->block_size=1024; ! 176: break; ! 177: case EOT: ! 178: lprintf(xm,LOG_DEBUG,"EOT"); ! 179: if(/*((*xm->mode)&(YMODEM|GMODE))==YMODEM &&*/ !eot) { ! 180: lprintf(xm,LOG_INFO,"NAKing first EOT"); ! 181: eot=1; ! 182: xmodem_put_nak(xm,expected_block_num); /* chuck's double EOT trick */ ! 183: continue; ! 184: } ! 185: return(EOT); ! 186: case CAN: ! 187: if(!can) { /* must get two CANs in a row */ ! 188: can=1; ! 189: lprintf(xm,LOG_WARNING,"Received CAN Expected SOH, STX, or EOT"); ! 190: continue; ! 191: } ! 192: lprintf(xm,LOG_WARNING,"Cancelled remotely"); ! 193: return(CAN); ! 194: default: ! 195: lprintf(xm,LOG_WARNING,"Received %s Expected SOH, STX, or EOT",chr((uchar)i)); ! 196: case NOINP: /* Nothing came in */ ! 197: if(eot) ! 198: return(EOT); ! 199: return(NOINP); ! 200: } ! 201: if((i=getcom(xm->byte_timeout))==NOINP) ! 202: break; ! 203: block_num=i; ! 204: if((i=getcom(xm->byte_timeout))==NOINP) ! 205: break; ! 206: block_inv=i; ! 207: calc_crc=calc_chksum=0; ! 208: for(b=0;b<xm->block_size && is_connected(xm);b++) { ! 209: if((i=getcom(xm->byte_timeout))==NOINP) ! 210: break; ! 211: block[b]=i; ! 212: if((*xm->mode)&CRC) ! 213: calc_crc=ucrc16(block[b],calc_crc); ! 214: else ! 215: calc_chksum+=block[b]; ! 216: } ! 217: ! 218: if(b<xm->block_size) ! 219: break; ! 220: ! 221: if((*xm->mode)&CRC) { ! 222: crc=getcom(xm->byte_timeout)<<8; ! 223: crc|=getcom(xm->byte_timeout); ! 224: } ! 225: else ! 226: chksum=getcom(xm->byte_timeout); ! 227: ! 228: if(block_num!=(uchar)~block_inv) { ! 229: lprintf(xm,LOG_WARNING,"Block number bit error (0x%02X vs 0x%02x)" ! 230: ,block_num,(uchar)~block_inv); ! 231: break; ! 232: } ! 233: ! 234: if(block_num!=(uchar)(expected_block_num&0xff)) { ! 235: lprintf(xm,LOG_WARNING,"Block number error (%u received, expected %u)" ! 236: ,block_num,expected_block_num&0xff); ! 237: if(expected_block_num && block_num==(uchar)((expected_block_num-1)&0xff)) ! 238: continue; /* silently discard repeated packets (ymodem.doc 7.3.2) */ ! 239: break; ! 240: } ! 241: ! 242: if((*xm->mode)&CRC) { ! 243: if(crc!=calc_crc) { ! 244: lprintf(xm,LOG_WARNING,"Block %u: CRC ERROR", expected_block_num); ! 245: break; ! 246: } ! 247: } ! 248: else /* CHKSUM */ ! 249: { ! 250: if(chksum!=calc_chksum) { ! 251: lprintf(xm,LOG_WARNING,"Block %u: CHECKSUM ERROR", expected_block_num); ! 252: break; ! 253: } ! 254: } ! 255: return(0); /* Success */ ! 256: } ! 257: ! 258: return(-2); /* Failure */ ! 259: } ! 260: ! 261: /*****************/ ! 262: /* Sends a block */ ! 263: /*****************/ ! 264: int xmodem_put_block(xmodem_t* xm, uchar* block, unsigned block_size, unsigned block_num) ! 265: { ! 266: int result; ! 267: uchar ch,chksum; ! 268: uint i; ! 269: ushort crc; ! 270: ! 271: if(block_size==128) ! 272: result=putcom(SOH); ! 273: else /* 1024 */ ! 274: result=putcom(STX); ! 275: if(result!=0) ! 276: return(result); ! 277: ch=(uchar)(block_num&0xff); ! 278: if((result=putcom(ch))!=0) ! 279: return result; ! 280: if((result=putcom((uchar)~ch))!=0) ! 281: return result; ! 282: chksum=0; ! 283: crc=0; ! 284: for(i=0;i<block_size && is_connected(xm);i++) { ! 285: if((result=putcom(block[i]))!=0) ! 286: return result; ! 287: if((*xm->mode)&CRC) ! 288: crc=ucrc16(block[i],crc); ! 289: else ! 290: chksum+=block[i]; ! 291: } ! 292: ! 293: if((*xm->mode)&CRC) { ! 294: if((result= putcom((uchar)(crc >> 8)))!=0) ! 295: return result; ! 296: return putcom((uchar)(crc&0xff)); ! 297: } ! 298: return putcom(chksum); ! 299: } ! 300: ! 301: /************************************************************/ ! 302: /* Gets an acknowledgement - usually after sending a block */ ! 303: /* Returns 1 if ack received, 0 otherwise. */ ! 304: /************************************************************/ ! 305: BOOL xmodem_get_ack(xmodem_t* xm, unsigned tries, unsigned block_num) ! 306: { ! 307: int i,can=0; ! 308: unsigned errors; ! 309: ! 310: for(errors=0;errors<tries && is_connected(xm);errors++) { ! 311: ! 312: if((*xm->mode)&GMODE) { /* Don't wait for ACK on Ymodem-G */ ! 313: SLEEP(xm->g_delay); ! 314: if(getcom(0)==CAN) { ! 315: lprintf(xm,LOG_WARNING,"Block %u: !Cancelled remotely", block_num); ! 316: xmodem_cancel(xm); ! 317: return(FALSE); ! 318: } ! 319: return(TRUE); ! 320: } ! 321: ! 322: i=getcom(xm->ack_timeout); ! 323: if(can && i!=CAN) ! 324: can=0; ! 325: if(i==ACK) ! 326: return(TRUE); ! 327: if(i==CAN) { ! 328: if(can) { ! 329: lprintf(xm,LOG_WARNING,"Block %u: !Cancelled remotely", block_num); ! 330: xmodem_cancel(xm); ! 331: return(FALSE); ! 332: } ! 333: can=1; ! 334: } ! 335: if(i!=NOINP) { ! 336: lprintf(xm,LOG_WARNING,"Block %u: !Received %s Expected ACK" ! 337: ,block_num, chr((uchar)i)); ! 338: if(i!=CAN) ! 339: return(FALSE); ! 340: } ! 341: } ! 342: ! 343: return(FALSE); ! 344: } ! 345: ! 346: BOOL xmodem_get_mode(xmodem_t* xm) ! 347: { ! 348: int i; ! 349: unsigned errors; ! 350: unsigned can; ! 351: ! 352: lprintf(xm,LOG_INFO,"Waiting for transfer mode request..."); ! 353: ! 354: *(xm->mode)&=~(GMODE|CRC); ! 355: for(errors=can=0;errors<=xm->max_errors && is_connected(xm);errors++) { ! 356: i=getcom(xm->recv_timeout); ! 357: if(can && i!=CAN) ! 358: can=0; ! 359: switch(i) { ! 360: case NAK: /* checksum */ ! 361: lprintf(xm,LOG_INFO,"Receiver requested mode: 8-bit Checksum"); ! 362: return(TRUE); ! 363: case 'C': ! 364: lprintf(xm,LOG_INFO,"Receiver requested mode: 16-bit CRC"); ! 365: *(xm->mode)|=CRC; ! 366: return(TRUE); ! 367: case 'G': ! 368: lprintf(xm,LOG_INFO,"Receiver requested mode: Streaming, 16-bit CRC"); ! 369: *(xm->mode)|=(GMODE|CRC); ! 370: return(TRUE); ! 371: case CAN: ! 372: if(can) { ! 373: lprintf(xm,LOG_WARNING,"Cancelled remotely"); ! 374: return(FALSE); ! 375: } ! 376: can=1; ! 377: break; ! 378: case NOINP: ! 379: break; ! 380: default: ! 381: lprintf(xm,LOG_WARNING,"Received %s Expected NAK, C, or G" ! 382: ,chr((uchar)i)); ! 383: break; ! 384: } ! 385: } ! 386: ! 387: lprintf(xm,LOG_ERR,"Failed to get transfer mode request from receiver"); ! 388: return(FALSE); ! 389: } ! 390: ! 391: BOOL xmodem_put_eot(xmodem_t* xm) ! 392: { ! 393: int ch; ! 394: unsigned errors; ! 395: unsigned cans=0; ! 396: ! 397: for(errors=0;errors<=xm->max_errors && is_connected(xm);errors++) { ! 398: ! 399: lprintf(xm,LOG_INFO,"Sending End-of-Text (EOT) indicator (%d)",errors+1); ! 400: ! 401: while((ch=getcom(0))!=NOINP && is_connected(xm)) ! 402: lprintf(xm,LOG_INFO,"Throwing out received: %s",chr((uchar)ch)); ! 403: ! 404: putcom(EOT); ! 405: if((ch=getcom(xm->recv_timeout))==NOINP) ! 406: continue; ! 407: lprintf(xm,LOG_INFO,"Received %s",chr((uchar)ch)); ! 408: if(ch==ACK) ! 409: return(TRUE); ! 410: if(ch==CAN && ++cans>1) ! 411: break; ! 412: if(ch==NAK && errors==0 && (*(xm->mode)&(YMODEM|GMODE))==YMODEM) { ! 413: continue; /* chuck's double EOT trick so don't complain */ ! 414: } ! 415: lprintf(xm,LOG_WARNING,"Expected ACK"); ! 416: } ! 417: return(FALSE); ! 418: } ! 419: ! 420: BOOL xmodem_send_file(xmodem_t* xm, const char* fname, FILE* fp, time_t* start, ulong* sent) ! 421: { ! 422: BOOL success=FALSE; ! 423: ulong sent_bytes=0; ! 424: char block[1024]; ! 425: size_t block_len; ! 426: unsigned block_num; ! 427: size_t i; ! 428: size_t rd; ! 429: time_t startfile; ! 430: struct stat st; ! 431: ! 432: if(sent!=NULL) ! 433: *sent=0; ! 434: ! 435: if(start!=NULL) ! 436: *start=time(NULL); ! 437: ! 438: fstat(fileno(fp),&st); ! 439: ! 440: if(xm->total_files==0) ! 441: xm->total_files=1; ! 442: ! 443: if(xm->total_bytes==0) ! 444: xm->total_bytes=st.st_size; ! 445: ! 446: do { ! 447: /* try */ ! 448: if(*(xm->mode)&YMODEM) { ! 449: ! 450: if(!xmodem_get_mode(xm)) ! 451: break; ! 452: ! 453: memset(block,0,sizeof(block)); ! 454: SAFECOPY(block,getfname(fname)); ! 455: i=sprintf(block+strlen(block)+1,"%lu %lo 0 0 %d %ld" ! 456: ,(ulong)st.st_size ! 457: ,st.st_mtime ! 458: ,xm->total_files-xm->sent_files ! 459: ,xm->total_bytes-xm->sent_bytes); ! 460: ! 461: lprintf(xm,LOG_INFO,"Sending Ymodem header block: '%s'",block+strlen(block)+1); ! 462: ! 463: block_len=strlen(block)+1+i; ! 464: for(xm->errors=0;xm->errors<=xm->max_errors && !is_cancelled(xm) && is_connected(xm);xm->errors++) { ! 465: xmodem_put_block(xm, block, block_len <=128 ? 128:1024, 0 /* block_num */); ! 466: if(xmodem_get_ack(xm,1,0)) ! 467: break; ! 468: } ! 469: if(xm->errors>=xm->max_errors || is_cancelled(xm)) { ! 470: lprintf(xm,LOG_ERR,"Failed to send header block"); ! 471: break; ! 472: } ! 473: } ! 474: ! 475: if(!xmodem_get_mode(xm)) ! 476: break; ! 477: ! 478: startfile=time(NULL); /* reset time, don't count header block */ ! 479: if(start!=NULL) ! 480: *start=startfile; ! 481: ! 482: block_num=1; ! 483: xm->errors=0; ! 484: while(sent_bytes < (ulong)st.st_size && xm->errors<=xm->max_errors && !is_cancelled(xm) ! 485: && is_connected(xm)) { ! 486: fseek(fp,sent_bytes,SEEK_SET); ! 487: memset(block,CPMEOF,xm->block_size); ! 488: if((rd=fread(block,1,xm->block_size,fp))!=xm->block_size ! 489: && (long)(block_num*xm->block_size) < st.st_size) { ! 490: lprintf(xm,LOG_ERR,"READ ERROR %d instead of %d at offset %lu" ! 491: ,rd,xm->block_size,(block_num-1)*(long)xm->block_size); ! 492: xm->errors++; ! 493: continue; ! 494: } ! 495: if(xm->progress!=NULL) ! 496: xm->progress(xm->cbdata,block_num,ftell(fp),st.st_size,startfile); ! 497: xmodem_put_block(xm, block, xm->block_size, block_num); ! 498: if(!xmodem_get_ack(xm,5,block_num)) { ! 499: xm->errors++; ! 500: lprintf(xm,LOG_WARNING,"Error #%d at offset %ld" ! 501: ,xm->errors,ftell(fp)-xm->block_size); ! 502: } else { ! 503: block_num++; ! 504: sent_bytes+=rd; ! 505: } ! 506: } ! 507: if(sent_bytes >= (ulong)st.st_size && !is_cancelled(xm) && is_connected(xm)) { ! 508: ! 509: #if 0 /* !SINGLE_THREADED */ ! 510: lprintf(LOG_DEBUG,"Waiting for output buffer to empty... "); ! 511: if(WaitForEvent(outbuf_empty,5000)!=WAIT_OBJECT_0) ! 512: lprintf(xm,LOG_WARNING,"FAILURE"); ! 513: #endif ! 514: if(xmodem_put_eot(xm)) /* end-of-text, wait for ACK */ ! 515: success=TRUE; ! 516: } ! 517: } while(0); ! 518: /* finally */ ! 519: ! 520: if(!success) ! 521: xmodem_cancel(xm); ! 522: ! 523: if(sent!=NULL) ! 524: *sent=sent_bytes; ! 525: ! 526: return(success); ! 527: } ! 528: ! 529: ! 530: const char* xmodem_source(void) ! 531: { ! 532: return(__FILE__); ! 533: } ! 534: ! 535: char* xmodem_ver(char *buf) ! 536: { ! 537: sscanf("$Revision: 1.26 $", "%*s %s", buf); ! 538: ! 539: return(buf); ! 540: } ! 541: ! 542: void xmodem_init(xmodem_t* xm, void* cbdata, long* mode ! 543: ,int (*lputs)(void*, int level, const char* str) ! 544: ,void (*progress)(void* unused, unsigned block_num, ulong offset, ulong fsize, time_t t) ! 545: ,int (*send_byte)(void*, uchar ch, unsigned timeout) ! 546: ,int (*recv_byte)(void*, unsigned timeout) ! 547: ,BOOL (*is_connected)(void*) ! 548: ,BOOL (*is_cancelled)(void*)) ! 549: { ! 550: memset(xm,0,sizeof(xmodem_t)); ! 551: ! 552: /* Use sane default values */ ! 553: xm->send_timeout=10; /* seconds */ ! 554: xm->recv_timeout=10; /* seconds */ ! 555: xm->byte_timeout=3; /* seconds */ ! 556: xm->ack_timeout=10; /* seconds */ ! 557: ! 558: xm->block_size=1024; ! 559: xm->max_errors=9; ! 560: xm->g_delay=1; ! 561: ! 562: xm->cbdata=cbdata; ! 563: xm->mode=mode; ! 564: xm->lputs=lputs; ! 565: xm->progress=progress; ! 566: xm->send_byte=send_byte; ! 567: xm->recv_byte=recv_byte; ! 568: xm->is_connected=is_connected; ! 569: xm->is_cancelled=is_cancelled; ! 570: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.