![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sexyz.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 sexyz.c CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 ! root 1: /* sexyz.c */ ! 2: ! 3: /* Synchronet External X/Y/ZMODEM Transfer Protocols */ ! 4: ! 5: /* $Id: sexyz.c,v 1.77 2006/12/28 22:25:36 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: /* ! 39: * ZMODEM code based on zmtx/zmrx v1.02 (C) Mattheij Computer Service 1994 ! 40: * by Jacques Mattheij <[email protected]> ! 41: */ ! 42: ! 43: #include <time.h> ! 44: #include <stdio.h> ! 45: #include <errno.h> ! 46: #include <string.h> ! 47: #include <stdlib.h> ! 48: #include <stdarg.h> ! 49: #include <ctype.h> /* isdigit */ ! 50: #include <sys/stat.h> ! 51: ! 52: #ifdef __unix__ ! 53: #include <termios.h> ! 54: #include <signal.h> ! 55: #endif ! 56: ! 57: /* xpdev */ ! 58: #include "conwrap.h" ! 59: #include "genwrap.h" ! 60: #include "semwrap.h" ! 61: #include "dirwrap.h" ! 62: #include "filewrap.h" ! 63: #include "sockwrap.h" ! 64: #include "str_list.h" ! 65: #include "ini_file.h" ! 66: #include "eventwrap.h" ! 67: #include "threadwrap.h" ! 68: ! 69: /* sbbs */ ! 70: #include "ringbuf.h" ! 71: #include "telnet.h" ! 72: #include "nopen.h" ! 73: ! 74: /* sexyz */ ! 75: #include "sexyz.h" ! 76: ! 77: #define SINGLE_THREADED FALSE ! 78: #define MIN_OUTBUF_SIZE 1024 ! 79: #define MAX_OUTBUF_SIZE (64*1024) ! 80: ! 81: /***************/ ! 82: /* Global Vars */ ! 83: /***************/ ! 84: long mode=0; /* Program mode */ ! 85: long zmode=0L; /* Zmodem mode */ ! 86: uchar block[1024]; /* Block buffer */ ! 87: ulong block_num; /* Block number */ ! 88: char* dszlog; ! 89: BOOL dszlog_path=TRUE; /* Log complete path to filename */ ! 90: BOOL dszlog_short=FALSE; /* Log Micros~1 short filename */ ! 91: BOOL dszlog_quotes=FALSE; /* Quote filenames in DSZLOG */ ! 92: int log_level=LOG_INFO; ! 93: ! 94: xmodem_t xm; ! 95: zmodem_t zm; ! 96: ! 97: FILE* errfp; ! 98: FILE* statfp; ! 99: FILE* logfp=NULL; ! 100: ! 101: char revision[16]; ! 102: ! 103: SOCKET sock=INVALID_SOCKET; ! 104: ! 105: BOOL telnet=TRUE; ! 106: #ifdef __unix__ ! 107: BOOL stdio=FALSE; ! 108: struct termios origterm; ! 109: #endif ! 110: BOOL aborted=FALSE; ! 111: BOOL terminate=FALSE; ! 112: BOOL debug_tx=FALSE; ! 113: BOOL debug_rx=FALSE; ! 114: BOOL debug_telnet=FALSE; ! 115: BOOL pause_on_exit=FALSE; ! 116: BOOL pause_on_abend=FALSE; ! 117: BOOL newline=TRUE; ! 118: ! 119: time_t progress_interval; ! 120: ! 121: RingBuf outbuf; ! 122: #if defined(RINGBUF_EVENT) ! 123: #define outbuf_empty outbuf.empty_event ! 124: #else ! 125: xpevent_t outbuf_empty; ! 126: #endif ! 127: unsigned outbuf_drain_timeout; ! 128: long outbuf_size; ! 129: ! 130: unsigned flows=0; ! 131: unsigned select_errors=0; ! 132: ! 133: #ifdef __unix__ ! 134: void resetterm(void) ! 135: { ! 136: tcsetattr(STDOUT_FILENO, TCSADRAIN, &origterm); ! 137: } ! 138: #endif ! 139: ! 140: #ifdef _WINSOCKAPI_ ! 141: ! 142: /* Note: Don't call WSACleanup() or TCP session will close! */ ! 143: WSADATA WSAData; ! 144: ! 145: static BOOL winsock_startup(void) ! 146: { ! 147: int status; /* Status Code */ ! 148: ! 149: if((status = WSAStartup(MAKEWORD(1,1), &WSAData))==0) { ! 150: fprintf(statfp,"%s %s\n",WSAData.szDescription, WSAData.szSystemStatus); ! 151: return(TRUE); ! 152: } ! 153: ! 154: fprintf(errfp,"!WinSock startup ERROR %d\n", status); ! 155: return(FALSE); ! 156: } ! 157: ! 158: #else /* No WINSOCK */ ! 159: ! 160: #define winsock_startup() (TRUE) ! 161: ! 162: #endif ! 163: ! 164: static int lputs(void* unused, int level, const char* str) ! 165: { ! 166: FILE* fp=statfp; ! 167: ! 168: #if defined(_WIN32) && defined(_DEBUG) ! 169: if(log_level==LOG_DEBUG) ! 170: OutputDebugString(str); ! 171: #endif ! 172: ! 173: if(level>log_level) ! 174: return 0; ! 175: ! 176: if(level<LOG_NOTICE) ! 177: fp=errfp; ! 178: ! 179: if(!newline) { ! 180: fprintf(fp,"\n"); ! 181: newline=TRUE; ! 182: } ! 183: if(level<LOG_NOTICE) ! 184: return fprintf(fp,"!%s\n",str); ! 185: else ! 186: return fprintf(fp,"%s\n",str); ! 187: } ! 188: ! 189: static int lprintf(int level, const char *fmt, ...) ! 190: { ! 191: char sbuf[1024]; ! 192: va_list argptr; ! 193: ! 194: va_start(argptr,fmt); ! 195: vsnprintf(sbuf,sizeof(sbuf),fmt,argptr); ! 196: sbuf[sizeof(sbuf)-1]=0; ! 197: va_end(argptr); ! 198: return(lputs(NULL,level,sbuf)); ! 199: } ! 200: ! 201: void break_handler(int type) ! 202: { ! 203: lprintf(LOG_NOTICE,"-> Aborted Locally (signal: %d)",type); ! 204: ! 205: /* Flag to indicate local (as opposed to remote) abort */ ! 206: aborted=TRUE; ! 207: ! 208: /* Stop any transfers in progress immediately */ ! 209: xm.cancelled=TRUE; ! 210: zm.cancelled=TRUE; ! 211: } ! 212: ! 213: #if defined(_WIN32) ! 214: BOOL WINAPI ControlHandler(DWORD CtrlType) ! 215: { ! 216: break_handler((int)CtrlType); ! 217: return TRUE; ! 218: } ! 219: #endif ! 220: ! 221: char* dszlog_filename(char* str) ! 222: { ! 223: char* p=str; ! 224: static char path[MAX_PATH+1]; ! 225: ! 226: #ifdef _WIN32 ! 227: char sfpath[MAX_PATH+1]; ! 228: if(dszlog_short) { ! 229: SAFECOPY(sfpath,str); ! 230: GetShortPathName(str,sfpath,sizeof(sfpath)); ! 231: p=sfpath; ! 232: } ! 233: #endif ! 234: ! 235: if(!dszlog_path) ! 236: p=getfname(p); ! 237: ! 238: if(!dszlog_quotes) ! 239: return(p); ! 240: ! 241: SAFEPRINTF(path,"\"%s\"",p); ! 242: return(path); ! 243: } ! 244: ! 245: static char *chr(uchar ch) ! 246: { ! 247: static char str[25]; ! 248: ! 249: if(mode&ZMODEM) { ! 250: switch(ch) { ! 251: case ZRQINIT: return("ZRQINIT"); ! 252: case ZRINIT: return("ZRINIT"); ! 253: case ZSINIT: return("ZSINIT"); ! 254: case ZACK: return("ZACK"); ! 255: case ZFILE: return("ZFILE"); ! 256: case ZSKIP: return("ZSKIP"); ! 257: case ZNAK: return("ZNAK"); ! 258: case ZABORT: return("ZABORT"); ! 259: case ZFIN: return("ZFIN"); ! 260: case ZRPOS: return("ZRPOS"); ! 261: case ZDATA: return("ZDATA"); ! 262: case ZEOF: return("ZEOF"); ! 263: case ZPAD: return("ZPAD"); ! 264: case ZDLE: return("ZDLE"); ! 265: case ZDLEE: return("ZDLEE"); ! 266: case ZBIN: return("ZBIN"); ! 267: case ZHEX: return("ZHEX"); ! 268: case ZBIN32: return("ZBIN32"); ! 269: case ZRESC: return("ZRESC"); ! 270: case ZCRCE: return("ZCRCE"); ! 271: case ZCRCG: return("ZCRCG"); ! 272: case ZCRCQ: return("ZCRCQ"); ! 273: case ZCRCW: return("ZCRCW"); ! 274: } ! 275: } else { ! 276: switch(ch) { ! 277: case SOH: return("SOH"); ! 278: case STX: return("STX"); ! 279: case ETX: return("ETX"); ! 280: case EOT: return("EOT"); ! 281: case ACK: return("ACK"); ! 282: case NAK: return("NAK"); ! 283: case CAN: return("CAN"); ! 284: } ! 285: } ! 286: if(ch>=' ' && ch<='~') ! 287: sprintf(str,"'%c' (%02Xh)",ch,ch); ! 288: else ! 289: sprintf(str,"%u (%02Xh)",ch,ch); ! 290: return(str); ! 291: } ! 292: ! 293: void dump(BYTE* buf, int len) ! 294: { ! 295: char str[128]; ! 296: int i,j; ! 297: size_t slen=0; ! 298: ! 299: slen=sprintf(str,"TX: "); ! 300: for(i=0;i<len;i+=j) { ! 301: for(j=0;i+j<len && j<32;j++) ! 302: slen+=sprintf(str+slen,"%02X ",buf[i+j]); ! 303: lprintf(LOG_DEBUG,"%s",str); ! 304: slen=sprintf(str,"TX: "); ! 305: } ! 306: } ! 307: ! 308: void send_telnet_cmd(SOCKET sock, uchar cmd, uchar opt) ! 309: { ! 310: uchar buf[3]; ! 311: ! 312: buf[0]=TELNET_IAC; ! 313: buf[1]=cmd; ! 314: buf[2]=opt; ! 315: ! 316: if(debug_telnet) ! 317: lprintf(LOG_DEBUG,"Sending telnet command: %s %s" ! 318: ,telnet_cmd_desc(buf[1]),telnet_opt_desc(buf[2])); ! 319: ! 320: if(sendsocket(sock,buf,sizeof(buf))!=sizeof(buf) && debug_telnet) ! 321: lprintf(LOG_ERR,"FAILED"); ! 322: } ! 323: ! 324: #define DEBUG_TELNET FALSE ! 325: ! 326: /****************************************************************************/ ! 327: /* Receive a byte from remote (single-threaded version) */ ! 328: /****************************************************************************/ ! 329: int recv_byte(void* unused, unsigned timeout) ! 330: { ! 331: int i; ! 332: long t; ! 333: uchar ch; ! 334: fd_set socket_set; ! 335: time_t end; ! 336: struct timeval tv; ! 337: static uchar telnet_cmd; ! 338: static int telnet_cmdlen; ! 339: ! 340: end=msclock()+(timeout*MSCLOCKS_PER_SEC); ! 341: while(!terminate) { ! 342: ! 343: FD_ZERO(&socket_set); ! 344: #ifdef __unix__ ! 345: if(stdio) ! 346: FD_SET(STDIN_FILENO,&socket_set); ! 347: else ! 348: #endif ! 349: FD_SET(sock,&socket_set); ! 350: if((t=end-msclock())<0) t=0; ! 351: tv.tv_sec=t/MSCLOCKS_PER_SEC; ! 352: tv.tv_usec=0; ! 353: ! 354: if((i=select(sock+1,&socket_set,NULL,NULL,&tv))<1) { ! 355: if(i==SOCKET_ERROR) { ! 356: lprintf(LOG_ERR,"ERROR %d selecting socket", ERROR_VALUE); ! 357: } ! 358: if(timeout) ! 359: lprintf(LOG_WARNING,"Receive timeout (%u seconds)", timeout); ! 360: return(NOINP); ! 361: } ! 362: ! 363: #ifdef __unix__ ! 364: if(stdio) ! 365: i=read(STDIN_FILENO,&ch,sizeof(ch)); ! 366: else ! 367: #endif ! 368: i=recv(sock,&ch,sizeof(ch),0); ! 369: ! 370: if(i!=sizeof(ch)) { ! 371: if(i==0) { ! 372: lprintf(LOG_WARNING,"Socket Disconnected"); ! 373: } else ! 374: lprintf(LOG_ERR,"recv error %d (%d)",i,ERROR_VALUE); ! 375: return(NOINP); ! 376: } ! 377: ! 378: if(telnet) { ! 379: if(ch==TELNET_IAC) { ! 380: #if DEBUG_TELNET ! 381: lprintf(LOG_DEBUG,"T<%s> ",telnet_cmd_desc(ch)); ! 382: #endif ! 383: if(telnet_cmdlen==0) { ! 384: telnet_cmdlen=1; ! 385: continue; ! 386: } ! 387: if(telnet_cmdlen==1) { ! 388: telnet_cmdlen=0; ! 389: if(debug_rx) ! 390: lprintf(LOG_DEBUG,"RX: %s",chr(TELNET_IAC)); ! 391: return(TELNET_IAC); ! 392: } ! 393: } ! 394: if(telnet_cmdlen) { ! 395: telnet_cmdlen++; ! 396: #if DEBUG_TELNET ! 397: if(telnet_cmdlen==2) ! 398: lprintf(LOG_DEBUG,"T<%s> ",telnet_cmd_desc(ch)); ! 399: else ! 400: lprintf(LOG_DEBUG,"T<%s> ",telnet_opt_desc(ch)); ! 401: #endif ! 402: if(debug_telnet && telnet_cmdlen==3) ! 403: lprintf(LOG_DEBUG,"Received telnet command: %s %s" ! 404: ,telnet_cmd_desc(telnet_cmd),telnet_opt_desc(ch)); ! 405: if(telnet_cmdlen==3 && telnet_cmd==TELNET_DO) ! 406: send_telnet_cmd(sock, TELNET_WILL,ch); ! 407: /* ! 408: else if(telnet_cmdlen==3 && telnet_cmd==TELNET_WILL) ! 409: send_telnet_cmd(sock, TELNET_DO,ch); ! 410: */ ! 411: telnet_cmd=ch; ! 412: if((telnet_cmdlen==2 && ch<TELNET_WILL) || telnet_cmdlen>2) { ! 413: telnet_cmdlen=0; ! 414: /* Code disabled. Why? ToDo */ ! 415: /* break; */ ! 416: } ! 417: continue; ! 418: } ! 419: } ! 420: if(debug_rx) ! 421: lprintf(LOG_DEBUG,"RX: %s",chr(ch)); ! 422: return(ch); ! 423: } ! 424: ! 425: return(NOINP); ! 426: } ! 427: ! 428: #if !SINGLE_THREADED ! 429: /*************************/ ! 430: /* Send a byte to remote */ ! 431: /*************************/ ! 432: int send_byte(void* unused, uchar ch, unsigned timeout) ! 433: { ! 434: uchar buf[2] = { TELNET_IAC, TELNET_IAC }; ! 435: unsigned len=1; ! 436: DWORD result; ! 437: ! 438: if(telnet && ch==TELNET_IAC) /* escape IAC char */ ! 439: len=2; ! 440: else ! 441: buf[0]=ch; ! 442: ! 443: if(RingBufFree(&outbuf)<len) { ! 444: fprintf(statfp,"FLOW"); ! 445: flows++; ! 446: result=WaitForEvent(outbuf_empty,timeout*1000); ! 447: fprintf(statfp,"\b\b\b\b \b\b\b\b"); ! 448: if(result!=WAIT_OBJECT_0) { ! 449: fprintf(statfp ! 450: ,"\n!TIMEOUT (%d) waiting for output buffer to flush (%u seconds, %u bytes)\n" ! 451: ,result, timeout, RingBufFull(&outbuf)); ! 452: newline=TRUE; ! 453: if(RingBufFree(&outbuf)<len) ! 454: return(-1); ! 455: } ! 456: } ! 457: ! 458: RingBufWrite(&outbuf,buf,len); ! 459: #if !defined(RINGBUF_EVENT) ! 460: ResetEvent(outbuf_empty); ! 461: #endif ! 462: ! 463: #if 0 ! 464: if(debug_tx) ! 465: lprintf(LOG_DEBUG,"TX: %s",chr(ch)); ! 466: #endif ! 467: return(0); ! 468: } ! 469: ! 470: #else ! 471: ! 472: /*************************/ ! 473: /* Send a byte to remote */ ! 474: /*************************/ ! 475: int send_byte(void* unused, uchar ch, unsigned timeout) ! 476: { ! 477: uchar buf[2] = { TELNET_IAC, TELNET_IAC }; ! 478: int len=1; ! 479: int i; ! 480: fd_set socket_set; ! 481: struct timeval tv; ! 482: ! 483: FD_ZERO(&socket_set); ! 484: #ifdef __unix__ ! 485: if(stdio) ! 486: FD_SET(STDOUT_FILENO,&socket_set); ! 487: else ! 488: #endif ! 489: FD_SET(sock,&socket_set); ! 490: tv.tv_sec=timeout; ! 491: tv.tv_usec=0; ! 492: ! 493: if(select(sock+1,NULL,&socket_set,NULL,&tv)<1) ! 494: return(ERROR_VALUE); ! 495: ! 496: if(telnet && ch==TELNET_IAC) /* escape IAC char */ ! 497: len=2; ! 498: else ! 499: buf[0]=ch; ! 500: ! 501: #ifdef __unix__ ! 502: if(stdio) ! 503: i=write(STDOUT_FILENO,buf,len); ! 504: else ! 505: #endif ! 506: i=sendsocket(sock,buf,len); ! 507: ! 508: if(i==len) { ! 509: if(debug_tx) ! 510: lprintf(LOG_DEBUG,"TX: %s",chr(ch)); ! 511: return(0); ! 512: } ! 513: ! 514: return(-1); ! 515: } ! 516: #endif ! 517: ! 518: static void output_thread(void* arg) ! 519: { ! 520: char stats[128]; ! 521: BYTE buf[MAX_OUTBUF_SIZE]; ! 522: int i; ! 523: ulong avail; ! 524: ulong total_sent=0; ! 525: ulong total_pkts=0; ! 526: ulong short_sends=0; ! 527: ulong bufbot=0; ! 528: ulong buftop=0; ! 529: fd_set socket_set; ! 530: struct timeval tv; ! 531: ! 532: #if 0 /* def _DEBUG */ ! 533: fprintf(statfp,"output thread started\n"); ! 534: #endif ! 535: ! 536: while(sock!=INVALID_SOCKET && !terminate) { ! 537: ! 538: if(bufbot==buftop) ! 539: avail=RingBufFull(&outbuf); ! 540: else ! 541: avail=buftop-bufbot; ! 542: ! 543: if(!avail) { ! 544: #if !defined(RINGBUF_EVENT) ! 545: SetEvent(outbuf_empty); ! 546: #endif ! 547: sem_wait(&outbuf.sem); ! 548: if(outbuf.highwater_mark) ! 549: sem_trywait_block(&outbuf.highwater_sem,outbuf_drain_timeout); ! 550: continue; ! 551: } ! 552: ! 553: /* Check socket for writability (using select) */ ! 554: tv.tv_sec=0; ! 555: tv.tv_usec=1000; ! 556: ! 557: FD_ZERO(&socket_set); ! 558: #ifdef __unix__ ! 559: if(stdio) ! 560: FD_SET(STDOUT_FILENO,&socket_set); ! 561: else ! 562: #endif ! 563: FD_SET(sock,&socket_set); ! 564: ! 565: i=select(sock+1,NULL,&socket_set,NULL,&tv); ! 566: if(i==SOCKET_ERROR) { ! 567: lprintf(LOG_ERR,"ERROR %d selecting socket %u for send" ! 568: ,ERROR_VALUE,sock); ! 569: break; ! 570: } ! 571: if(i<1) { ! 572: select_errors++; ! 573: continue; ! 574: } ! 575: ! 576: if(bufbot==buftop) { /* linear buf empty, read from ring buf */ ! 577: if(avail>sizeof(buf)) { ! 578: lprintf(LOG_ERR,"Insufficient linear output buffer (%lu > %lu)" ! 579: ,avail, sizeof(buf)); ! 580: avail=sizeof(buf); ! 581: } ! 582: buftop=RingBufRead(&outbuf, buf, avail); ! 583: bufbot=0; ! 584: } ! 585: #ifdef __unix__ ! 586: if(stdio) ! 587: i=write(STDOUT_FILENO, (char*)buf+bufbot, buftop-bufbot); ! 588: else ! 589: #endif ! 590: i=sendsocket(sock, (char*)buf+bufbot, buftop-bufbot); ! 591: if(i==SOCKET_ERROR) { ! 592: if(ERROR_VALUE == ENOTSOCK) ! 593: lprintf(LOG_ERR,"client socket closed on send"); ! 594: else if(ERROR_VALUE==ECONNRESET) ! 595: lprintf(LOG_ERR,"connection reset by peer on send"); ! 596: else if(ERROR_VALUE==ECONNABORTED) ! 597: lprintf(LOG_ERR,"connection aborted by peer on send"); ! 598: else ! 599: lprintf(LOG_ERR,"ERROR %d sending on socket %d" ! 600: ,ERROR_VALUE, sock); ! 601: break; ! 602: } ! 603: ! 604: if(debug_tx) ! 605: dump(buf+bufbot,i); ! 606: ! 607: if(i!=(int)(buftop-bufbot)) { ! 608: lprintf(LOG_ERR,"Short socket send (%u instead of %u)" ! 609: ,i ,buftop-bufbot); ! 610: short_sends++; ! 611: } ! 612: bufbot+=i; ! 613: total_sent+=i; ! 614: total_pkts++; ! 615: } ! 616: ! 617: if(total_sent) ! 618: sprintf(stats,"(sent %lu bytes in %lu blocks, %lu average, %lu short, %lu errors)" ! 619: ,total_sent, total_pkts, total_sent/total_pkts, short_sends, select_errors); ! 620: else ! 621: stats[0]=0; ! 622: ! 623: lprintf(LOG_DEBUG,"output thread terminated\n%s", stats); ! 624: } ! 625: ! 626: BOOL is_connected(void* unused) ! 627: { ! 628: return socket_check(sock,NULL,NULL,0); ! 629: } ! 630: ! 631: BOOL data_waiting(void* unused, unsigned timeout) ! 632: { ! 633: BOOL rd; ! 634: ! 635: if(!socket_check(sock,&rd,NULL,timeout)) ! 636: return(FALSE); ! 637: return(rd); ! 638: } ! 639: ! 640: /****************************************************************************/ ! 641: /* Returns the number of blocks required to send len bytes */ ! 642: /****************************************************************************/ ! 643: unsigned num_blocks(ulong len, unsigned block_size) ! 644: { ! 645: ulong blocks; ! 646: ! 647: blocks=len/block_size; ! 648: if(len%block_size) ! 649: blocks++; ! 650: return(blocks); ! 651: } ! 652: ! 653: /************************************************/ ! 654: /* Dump the current block contents - for debug */ ! 655: /************************************************/ ! 656: void dump_block(long block_size) ! 657: { ! 658: long l; ! 659: ! 660: for(l=0;l<block_size;l++) ! 661: fprintf(statfp,"%02X ",block[l]); ! 662: fprintf(statfp,"\n"); ! 663: } ! 664: ! 665: void xmodem_progress(void* unused, unsigned block_num, ulong offset, ulong fsize, time_t start) ! 666: { ! 667: unsigned cps; ! 668: unsigned total_blocks; ! 669: long l; ! 670: long t; ! 671: time_t now; ! 672: static time_t last_progress; ! 673: ! 674: now=time(NULL); ! 675: if(now-last_progress>=progress_interval || offset >= fsize || newline) { ! 676: t=now-start; ! 677: if(t<=0) ! 678: t=1; ! 679: if((cps=offset/t)==0) ! 680: cps=1; /* cps so far */ ! 681: l=fsize/cps; /* total transfer est time */ ! 682: l-=t; /* now, it's est time left */ ! 683: if(l<0) l=0; ! 684: if(mode&SEND) { ! 685: total_blocks=num_blocks(fsize,xm.block_size); ! 686: fprintf(statfp,"\rBlock (%lu%s): %lu/%lu Byte: %lu " ! 687: "Time: %lu:%02lu/%lu:%02lu %u cps %lu%% " ! 688: ,xm.block_size%1024L ? xm.block_size: xm.block_size/1024L ! 689: ,xm.block_size%1024L ? "" : "K" ! 690: ,block_num ! 691: ,total_blocks ! 692: ,offset ! 693: ,t/60L ! 694: ,t%60L ! 695: ,l/60L ! 696: ,l%60L ! 697: ,cps ! 698: ,(long)(((float)offset/(float)fsize)*100.0) ! 699: ); ! 700: } else if(mode&YMODEM) { ! 701: fprintf(statfp,"\rBlock (%lu%s): %lu Byte: %lu " ! 702: "Time: %lu:%02lu/%lu:%02lu %u cps %lu%% " ! 703: ,xm.block_size%1024L ? xm.block_size: xm.block_size/1024L ! 704: ,xm.block_size%1024L ? "" : "K" ! 705: ,block_num ! 706: ,offset ! 707: ,t/60L ! 708: ,t%60L ! 709: ,l/60L ! 710: ,l%60L ! 711: ,cps ! 712: ,(long)(((float)offset/(float)fsize)*100.0) ! 713: ); ! 714: } else { /* XModem receive */ ! 715: fprintf(statfp,"\rBlock (%lu%s): %lu Byte: %lu " ! 716: "Time: %lu:%02lu %u cps " ! 717: ,xm.block_size%1024L ? xm.block_size: xm.block_size/1024L ! 718: ,xm.block_size%1024L ? "" : "K" ! 719: ,block_num ! 720: ,offset ! 721: ,t/60L ! 722: ,t%60L ! 723: ,cps ! 724: ); ! 725: } ! 726: newline=FALSE; ! 727: last_progress=now; ! 728: } ! 729: } ! 730: ! 731: /* ! 732: * show the progress of the transfer like this: ! 733: * zmtx: sending file "garbage" 4096 bytes ( 20%) ! 734: */ ! 735: void zmodem_progress(void* cbdata, ulong current_pos) ! 736: { ! 737: unsigned cps; ! 738: long l; ! 739: long t; ! 740: time_t now; ! 741: static time_t last_progress; ! 742: ! 743: now=time(NULL); ! 744: if(now-last_progress>=progress_interval || current_pos >= zm.current_file_size || newline) { ! 745: t=now-zm.transfer_start_time; ! 746: if(t<=0) ! 747: t=1; ! 748: if(zm.transfer_start_pos>current_pos) ! 749: zm.transfer_start_pos=0; ! 750: if((cps=(current_pos-zm.transfer_start_pos)/t)==0) ! 751: cps=1; /* cps so far */ ! 752: l=zm.current_file_size/cps; /* total transfer est time */ ! 753: l-=t; /* now, it's est time left */ ! 754: if(l<0) l=0; ! 755: fprintf(statfp,"\rKByte: %lu/%lu %u/CRC-%u " ! 756: "Time: %lu:%02lu/%lu:%02lu %u cps %lu%% " ! 757: ,current_pos/1024 ! 758: ,zm.current_file_size/1024 ! 759: ,zm.block_size ! 760: ,mode&RECV ? (zm.receive_32bit_data ? 32:16) : ! 761: (zm.can_fcs_32 && !zm.want_fcs_16) ? 32:16 ! 762: ,t/60L ! 763: ,t%60L ! 764: ,l/60L ! 765: ,l%60L ! 766: ,cps ! 767: ,(long)(((float)current_pos/(float)zm.current_file_size)*100.0) ! 768: ); ! 769: newline=FALSE; ! 770: last_progress=now; ! 771: } ! 772: } ! 773: ! 774: static int send_files(char** fname, uint fnames) ! 775: { ! 776: char path[MAX_PATH+1]; ! 777: int i; ! 778: uint errors; ! 779: uint fnum; ! 780: uint cps; ! 781: glob_t g; ! 782: int gi; ! 783: BOOL success=TRUE; ! 784: long fsize; ! 785: ulong sent_bytes; ! 786: ulong total_bytes=0; ! 787: time_t t,startfile; ! 788: time_t startall; ! 789: FILE* fp; ! 790: ! 791: startall=time(NULL); ! 792: ! 793: /****************************************************/ ! 794: /* Search through all to find total files and bytes */ ! 795: /****************************************************/ ! 796: for(fnum=0;fnum<fnames;fnum++) { ! 797: if(glob(fname[fnum],0,NULL,&g)) { ! 798: lprintf(LOG_WARNING,"%s not found",fname[fnum]); ! 799: continue; ! 800: } ! 801: for(i=0;i<(int)g.gl_pathc;i++) { ! 802: if(isdir(g.gl_pathv[i])) ! 803: continue; ! 804: xm.total_files++; ! 805: xm.total_bytes+=flength(g.gl_pathv[i]); ! 806: } ! 807: globfree(&g); ! 808: } ! 809: ! 810: if(xm.total_files<1) { ! 811: lprintf(LOG_ERR,"No files to send"); ! 812: return(-1); ! 813: } ! 814: if(xm.total_files>1) ! 815: lprintf(LOG_INFO,"Sending %u files (%lu KB total)" ! 816: ,xm.total_files,xm.total_bytes/1024); ! 817: ! 818: zm.files_remaining = xm.total_files; ! 819: zm.bytes_remaining = xm.total_bytes; ! 820: ! 821: /***********************************************/ ! 822: /* Send every file matching names or filespecs */ ! 823: /***********************************************/ ! 824: for(fnum=0;fnum<fnames;fnum++) { ! 825: if(glob(fname[fnum],0,NULL,&g)) { ! 826: lprintf(LOG_WARNING,"%s not found",fname[fnum]); ! 827: continue; ! 828: } ! 829: for(gi=0;gi<(int)g.gl_pathc;gi++) { ! 830: SAFECOPY(path,g.gl_pathv[gi]); ! 831: if(isdir(path)) ! 832: continue; ! 833: ! 834: if((fp=fnopen(NULL,path,O_RDONLY|O_BINARY))==NULL ! 835: && (fp=fopen(path,"rb"))==NULL) { ! 836: lprintf(LOG_ERR,"Error %d opening %s for read",errno,path); ! 837: continue; ! 838: } ! 839: setvbuf(fp,NULL,_IOFBF,0x10000); ! 840: ! 841: fsize=filelength(fileno(fp)); ! 842: ! 843: errors=0; ! 844: success=FALSE; ! 845: startfile=time(NULL); ! 846: ! 847: lprintf(LOG_INFO,"Sending %s (%lu KB) via %s" ! 848: ,path,fsize/1024 ! 849: ,mode&XMODEM ? "Xmodem" : mode&YMODEM ? "Ymodem" : "Zmodem"); ! 850: ! 851: if(mode&ZMODEM) ! 852: success=zmodem_send_file(&zm, path, fp, /* ZRQINIT? */fnum==0, &startfile, &sent_bytes); ! 853: else /* X/Ymodem */ ! 854: success=xmodem_send_file(&xm, path, fp, &startfile, &sent_bytes); ! 855: ! 856: fclose(fp); ! 857: ! 858: if((t=time(NULL)-startfile)<=0) ! 859: t=1; ! 860: if((cps=sent_bytes/t)==0) ! 861: cps=1; ! 862: if(success) { ! 863: xm.sent_files++; ! 864: xm.sent_bytes+=fsize; ! 865: lprintf(LOG_INFO,"Successful - Time: %lu:%02lu CPS: %lu" ! 866: ,t/60,t%60,cps); ! 867: ! 868: if(xm.total_files-xm.sent_files) ! 869: lprintf(LOG_INFO,"Remaining - Time: %lu:%02lu Files: %u KBytes: %lu" ! 870: ,((xm.total_bytes-xm.sent_bytes)/cps)/60 ! 871: ,((xm.total_bytes-xm.sent_bytes)/cps)%60 ! 872: ,xm.total_files-xm.sent_files ! 873: ,(xm.total_bytes-xm.sent_bytes)/1024 ! 874: ); ! 875: } else ! 876: lprintf(LOG_WARNING,"File Transfer %s", aborted ? "Aborted" : "Failure"); ! 877: ! 878: /* DSZLOG entry */ ! 879: if(logfp) { ! 880: lprintf(LOG_DEBUG,"Updating DSZLOG: %s", dszlog); ! 881: fprintf(logfp,"%c %7lu %5u bps %6lu cps %3u errors %5u %4u " ! 882: "%s -1\n" ! 883: ,success ? (mode&ZMODEM ? 'z':'S') ! 884: : (mode&ZMODEM && zm.file_skipped) ? 's' ! 885: : 'E' ! 886: ,sent_bytes ! 887: ,115200 /* baud */ ! 888: ,cps ! 889: ,mode&ZMODEM ? zm.errors : xm.errors ! 890: ,flows ! 891: ,mode&ZMODEM ? zm.block_size : xm.block_size ! 892: ,dszlog_filename(path)); ! 893: fflush(logfp); ! 894: } ! 895: total_bytes += sent_bytes; ! 896: ! 897: if(aborted) { ! 898: xm.cancelled=FALSE; ! 899: xmodem_cancel(&xm); ! 900: break; ! 901: } ! 902: ! 903: if(xm.cancelled || zm.cancelled) ! 904: break; ! 905: ! 906: } /* while(gi<(int)g.gl_pathc) */ ! 907: ! 908: if(gi<(int)g.gl_pathc)/* error occurred */ ! 909: break; ! 910: } ! 911: ! 912: if(mode&ZMODEM && !zm.cancelled && is_connected(NULL)) ! 913: zmodem_get_zfin(&zm); ! 914: ! 915: if(fnum<fnames) /* error occurred */ ! 916: return(-1); ! 917: ! 918: if(!success) ! 919: return(-1); ! 920: ! 921: if(mode&XMODEM) ! 922: return(0); ! 923: if(mode&YMODEM) { ! 924: ! 925: if(xmodem_get_mode(&xm)) { ! 926: ! 927: lprintf(LOG_INFO,"Sending Ymodem termination block"); ! 928: ! 929: memset(block,0,128); /* send short block for terminator */ ! 930: xmodem_put_block(&xm, block, 128 /* block_size */, 0 /* block_num */); ! 931: if(!xmodem_get_ack(&xm,6,0)) { ! 932: lprintf(LOG_WARNING,"Failed to receive ACK after terminating block"); ! 933: } ! 934: } ! 935: } ! 936: if(xm.total_files>1) { ! 937: t=time(NULL)-startall; ! 938: if(!t) t=1; ! 939: lprintf(LOG_INFO,"Overall - Time %02lu:%02lu KBytes: %lu CPS: %lu" ! 940: ,t/60,t%60,total_bytes/1024,total_bytes/t); ! 941: } ! 942: return(0); /* success */ ! 943: } ! 944: ! 945: static int receive_files(char** fname_list, int fnames) ! 946: { ! 947: char str[MAX_PATH+1]; ! 948: char fname[MAX_PATH+1]; ! 949: int i; ! 950: int fnum=0; ! 951: uint errors; ! 952: uint total_files=0; ! 953: uint cps; ! 954: uint wr; ! 955: BOOL success=FALSE; ! 956: long fmode; ! 957: long serial_num=-1; ! 958: ulong file_bytes=0,file_bytes_left=0; ! 959: ulong total_bytes=0; ! 960: FILE* fp; ! 961: time_t t,startfile,ftime; ! 962: ! 963: if(fnames>1) ! 964: lprintf(LOG_INFO,"Receiving %u files",fnames); ! 965: ! 966: outbuf.highwater_mark=0; /* don't delay ACK/NAK transmits */ ! 967: ! 968: /* Purge input buffer */ ! 969: while(is_connected(NULL) && (i=recv_byte(NULL,0))!=NOINP) ! 970: lprintf(LOG_WARNING,"Throwing out received: %s",chr((uchar)i)); ! 971: ! 972: while(is_connected(NULL)) { ! 973: if(mode&XMODEM) { ! 974: SAFECOPY(str,fname_list[0]); /* we'll have at least one fname */ ! 975: file_bytes=file_bytes_left=0x7fffffff; ! 976: } ! 977: ! 978: else { ! 979: if(mode&YMODEM) { ! 980: lprintf(LOG_INFO,"Fetching Ymodem header block"); ! 981: for(errors=0;errors<=xm.max_errors && !xm.cancelled;errors++) { ! 982: if(errors>(xm.max_errors/2) && mode&CRC && !(mode&GMODE)) ! 983: mode&=~CRC; ! 984: xmodem_put_nak(&xm, /* expected_block: */ 0); ! 985: if(xmodem_get_block(&xm, block, /* expected_block: */ 0) == 0) { ! 986: send_byte(NULL,ACK,10); ! 987: break; ! 988: } ! 989: } ! 990: if(errors>=xm.max_errors || xm.cancelled) { ! 991: lprintf(LOG_ERR,"Error fetching Ymodem header block"); ! 992: xmodem_cancel(&xm); ! 993: return(1); ! 994: } ! 995: if(!block[0]) { ! 996: lprintf(LOG_INFO,"Received Ymodem termination block"); ! 997: return(0); ! 998: } ! 999: file_bytes=ftime=total_files=total_bytes=0; ! 1000: i=sscanf(block+strlen(block)+1,"%ld %lo %lo %lo %d %ld" ! 1001: ,&file_bytes /* file size (decimal) */ ! 1002: ,&ftime /* file time (octal unix format) */ ! 1003: ,&fmode /* file mode (not used) */ ! 1004: ,&serial_num /* program serial number */ ! 1005: ,&total_files /* remaining files to be sent */ ! 1006: ,&total_bytes /* remaining bytes to be sent */ ! 1007: ); ! 1008: lprintf(LOG_DEBUG,"Ymodem header (%u fields): %s", i, block+strlen(block)+1); ! 1009: SAFECOPY(fname,block); ! 1010: ! 1011: } else { /* Zmodem */ ! 1012: lprintf(LOG_INFO,"Waiting for Zmodem sender..."); ! 1013: ! 1014: i=zmodem_recv_init(&zm); ! 1015: ! 1016: if(zm.cancelled) ! 1017: return(1); ! 1018: if(i<0) ! 1019: return(-1); ! 1020: switch(i) { ! 1021: case ZFILE: ! 1022: SAFECOPY(fname,zm.current_file_name); ! 1023: file_bytes = zm.current_file_size; ! 1024: ftime = zm.current_file_time; ! 1025: total_files = zm.files_remaining; ! 1026: total_bytes = zm.bytes_remaining; ! 1027: break; ! 1028: case ZFIN: ! 1029: case ZCOMPL: ! 1030: return(!success); ! 1031: default: ! 1032: return(-1); ! 1033: } ! 1034: } ! 1035: ! 1036: if(!file_bytes) ! 1037: file_bytes=0x7fffffff; ! 1038: file_bytes_left=file_bytes; ! 1039: if(!total_files) ! 1040: total_files=fnames-fnum; ! 1041: if(!total_files) ! 1042: total_files=1; ! 1043: if(total_bytes<file_bytes) ! 1044: total_bytes=file_bytes; ! 1045: ! 1046: lprintf(LOG_DEBUG,"Incoming filename: %.64s ",fname); ! 1047: ! 1048: if(mode&RECVDIR) ! 1049: sprintf(str,"%s%s",fname_list[0],getfname(fname)); ! 1050: else { ! 1051: SAFECOPY(str,getfname(fname)); ! 1052: for(i=0;i<fnames;i++) { ! 1053: if(!fname_list[i][0]) /* name blank or already used */ ! 1054: continue; ! 1055: if(!stricmp(getfname(fname_list[i]),str)) { ! 1056: SAFECOPY(str,fname_list[i]); ! 1057: fname_list[i][0]=0; ! 1058: break; ! 1059: } ! 1060: } ! 1061: if(i==fnames) { /* Not found in list */ ! 1062: if(fnames) ! 1063: fprintf(statfp," - Not in receive list!"); ! 1064: if(!fnames || fnum>=fnames || !fname_list[fnum][0]) ! 1065: SAFECOPY(str,getfname(fname)); /* worst case */ ! 1066: else { ! 1067: SAFECOPY(str,fname_list[fnum]); ! 1068: fname_list[fnum][0]=0; ! 1069: } ! 1070: } ! 1071: } ! 1072: fprintf(statfp,"File size: %lu bytes\n", file_bytes); ! 1073: if(total_files>1) ! 1074: fprintf(statfp,"Remaining: %lu bytes in %u files\n", total_bytes, total_files); ! 1075: } ! 1076: ! 1077: lprintf(LOG_DEBUG,"Receiving: %.64s ",str); ! 1078: ! 1079: fnum++; ! 1080: ! 1081: if(!(mode&RECVDIR) && fnames && fnum>fnames) { ! 1082: lprintf(LOG_WARNING,"Attempt to send more files than specified"); ! 1083: xmodem_cancel(&xm); ! 1084: break; ! 1085: } ! 1086: ! 1087: if(fexistcase(str) && !(mode&OVERWRITE)) { ! 1088: lprintf(LOG_WARNING,"%s already exists",str); ! 1089: if(mode&ZMODEM) { ! 1090: zmodem_send_zskip(&zm); ! 1091: continue; ! 1092: } ! 1093: xmodem_cancel(&xm); ! 1094: return(1); ! 1095: } ! 1096: if((fp=fnopen(NULL,str,O_WRONLY|O_CREAT|O_TRUNC|O_BINARY))==NULL ! 1097: && (fp=fopen(str,"wb"))==NULL) { ! 1098: lprintf(LOG_ERR,"Error %d creating %s",errno,str); ! 1099: if(mode&ZMODEM) { ! 1100: zmodem_send_zskip(&zm); ! 1101: continue; ! 1102: } ! 1103: xmodem_cancel(&xm); ! 1104: return(1); ! 1105: } ! 1106: ! 1107: if(mode&XMODEM) ! 1108: lprintf(LOG_INFO,"Receiving %s via Xmodem %s" ! 1109: ,str ! 1110: ,mode&CRC ? "CRC-16":"Checksum"); ! 1111: else ! 1112: lprintf(LOG_INFO,"Receiving %s (%lu KB) via %s %s" ! 1113: ,str ! 1114: ,file_bytes/1024 ! 1115: ,mode&YMODEM ? mode&GMODE ? "Ymodem-G" : "Ymodem" :"Zmodem" ! 1116: ,mode&ZMODEM ? "" : (mode&CRC ? "CRC-16" : "Checksum")); ! 1117: ! 1118: startfile=time(NULL); ! 1119: success=FALSE; ! 1120: if(mode&ZMODEM) { ! 1121: ! 1122: errors=zmodem_recv_file_data(&zm,fp,0); ! 1123: ! 1124: /* ! 1125: * wait for the eof header ! 1126: */ ! 1127: ! 1128: for(;errors<=zm.max_errors && !success && !zm.cancelled; errors++) { ! 1129: if(zmodem_recv_header_and_check(&zm)) ! 1130: success=TRUE; ! 1131: } ! 1132: ! 1133: } else { ! 1134: errors=0; ! 1135: block_num=1; ! 1136: xmodem_put_nak(&xm, block_num); ! 1137: while(is_connected(NULL)) { ! 1138: xmodem_progress(NULL,block_num,ftell(fp),file_bytes,startfile); ! 1139: i=xmodem_get_block(&xm, block, block_num); ! 1140: ! 1141: if(i!=0) { ! 1142: if(i==EOT) { /* end of transfer */ ! 1143: success=TRUE; ! 1144: xmodem_put_ack(&xm); ! 1145: break; ! 1146: } ! 1147: if(i==CAN) { /* Cancel */ ! 1148: xm.cancelled=TRUE; ! 1149: break; ! 1150: } ! 1151: ! 1152: if(mode&GMODE) ! 1153: return(-1); ! 1154: ! 1155: if(++errors>=xm.max_errors) { ! 1156: lprintf(LOG_ERR,"Too many errors (%u)",errors); ! 1157: xmodem_cancel(&xm); ! 1158: break; ! 1159: } ! 1160: if(block_num==1 && errors>(xm.max_errors/2) && mode&CRC && !(mode&GMODE)) ! 1161: mode&=~CRC; ! 1162: xmodem_put_nak(&xm, block_num); ! 1163: continue; ! 1164: } ! 1165: if(!(mode&GMODE)) ! 1166: send_byte(NULL,ACK,10); ! 1167: if(file_bytes_left<=0L) { /* No more bytes to send */ ! 1168: lprintf(LOG_WARNING,"Attempt to send more byte specified in header"); ! 1169: break; ! 1170: } ! 1171: wr=xm.block_size; ! 1172: if(wr>file_bytes_left) ! 1173: wr=file_bytes_left; ! 1174: if(fwrite(block,1,wr,fp)!=wr) { ! 1175: lprintf(LOG_ERR,"Error writing %u bytes to file at offset %lu" ! 1176: ,wr,ftell(fp)); ! 1177: xmodem_cancel(&xm); ! 1178: return(1); ! 1179: } ! 1180: file_bytes_left-=wr; ! 1181: block_num++; ! 1182: } ! 1183: } ! 1184: ! 1185: /* Use correct file size */ ! 1186: fflush(fp); ! 1187: if(file_bytes < (ulong)filelength(fileno(fp))) { ! 1188: lprintf(LOG_INFO,"Truncating file to %lu bytes", file_bytes); ! 1189: chsize(fileno(fp),file_bytes); ! 1190: } else ! 1191: file_bytes = filelength(fileno(fp)); ! 1192: fclose(fp); ! 1193: ! 1194: t=time(NULL)-startfile; ! 1195: if(!t) t=1; ! 1196: if(success) ! 1197: lprintf(LOG_INFO,"Successful - Time: %lu:%02lu CPS: %lu" ! 1198: ,t/60,t%60,file_bytes/t); ! 1199: else ! 1200: lprintf(LOG_ERR,"File Transfer %s", aborted ? "Aborted":"Failure"); ! 1201: ! 1202: if(!(mode&XMODEM) && ftime) ! 1203: setfdate(str,ftime); ! 1204: ! 1205: if(logfp) { ! 1206: lprintf(LOG_DEBUG,"Updating DSZLOG: %s", dszlog); ! 1207: fprintf(logfp,"%c %6lu %5u bps %4lu cps %3u errors %5u %4u " ! 1208: "%s %d\n" ! 1209: ,success ? (mode&ZMODEM ? 'Z' : 'R') : 'E' ! 1210: ,file_bytes ! 1211: ,115200 /* baud */ ! 1212: ,file_bytes/t ! 1213: ,errors ! 1214: ,flows ! 1215: ,mode&ZMODEM ? zm.block_size : xm.block_size ! 1216: ,dszlog_filename(str) ! 1217: ,serial_num); ! 1218: fflush(logfp); ! 1219: } ! 1220: ! 1221: if(aborted) { ! 1222: lprintf(LOG_DEBUG,"Locally aborted, sending cancel to remote"); ! 1223: if(mode&ZMODEM) ! 1224: zmodem_abort_receive(&zm); ! 1225: xm.cancelled=FALSE; ! 1226: xmodem_cancel(&xm); ! 1227: break; ! 1228: } ! 1229: ! 1230: if(mode&XMODEM) /* maximum of one file */ ! 1231: break; ! 1232: if((cps=file_bytes/t)==0) ! 1233: cps=1; ! 1234: total_files--; ! 1235: total_bytes-=file_bytes; ! 1236: if(total_files>1 && total_bytes) ! 1237: lprintf(LOG_INFO,"Remaining - Time: %lu:%02lu Files: %u KBytes: %lu" ! 1238: ,(total_bytes/cps)/60 ! 1239: ,(total_bytes/cps)%60 ! 1240: ,total_files ! 1241: ,total_bytes/1024 ! 1242: ); ! 1243: } ! 1244: return(!success); /* 0=success */ ! 1245: } ! 1246: ! 1247: void bail(int code) ! 1248: { ! 1249: if(logfp!=NULL) ! 1250: fclose(logfp); ! 1251: if(pause_on_exit || (pause_on_abend && code!=0)) { ! 1252: printf("Hit enter to continue..."); ! 1253: getchar(); ! 1254: } ! 1255: exit(code); ! 1256: } ! 1257: ! 1258: static const char* usage= ! 1259: "usage: sexyz <socket> [-opts] <cmd> [file | path | @list]\n" ! 1260: "\n" ! 1261: #ifdef __unix__ ! 1262: "socket = TCP socket descriptor (leave blank for stdio mode)\n" ! 1263: #else ! 1264: "socket = TCP socket descriptor\n" ! 1265: #endif ! 1266: "\n" ! 1267: "opts = -y to overwrite files when receiving\n" ! 1268: " -o disable Zmodem CRC-32 mode (use CRC-16)\n" ! 1269: " -s disable Zmodem streaming (Slow Zmodem)\n" ! 1270: " -2 set maximum Zmodem block size to 2K\n" ! 1271: " -4 set maximum Zmodem block size to 4K\n" ! 1272: " -8 set maximum Zmodem block size to 8K (ZedZap)\n" ! 1273: " -! to pause after abnormal exit (error)\n" ! 1274: " -telnet to enable Telnet mode (the default)\n" ! 1275: " -rlogin or -ssh or -raw to disable Telnet mode\n" ! 1276: "\n" ! 1277: "cmd = v to display detailed version information\n" ! 1278: " sx to send Xmodem rx to recv Xmodem\n" ! 1279: " sX to send Xmodem-1K rc to recv Xmodem-CRC\n" ! 1280: " sy to send Ymodem ry to recv Ymodem\n" ! 1281: " sY to send Ymodem-1K rg to recv Ymodem-G\n" ! 1282: " sz to send Zmodem rz to recv Zmodem\n" ! 1283: "\n" ! 1284: "file = filename to send or receive\n" ! 1285: "path = directory to receive files into\n" ! 1286: "list = name of text file with list of filenames to send or receive\n"; ! 1287: ! 1288: /***************/ ! 1289: /* Entry Point */ ! 1290: /***************/ ! 1291: int main(int argc, char **argv) ! 1292: { ! 1293: char str[MAX_PATH+1]; ! 1294: char fname[MAX_PATH+1]; ! 1295: char ini_fname[MAX_PATH+1]; ! 1296: char* p; ! 1297: char* arg; ! 1298: int i; ! 1299: int retval; ! 1300: uint fnames=0; ! 1301: FILE* fp; ! 1302: BOOL tcp_nodelay; ! 1303: char compiler[32]; ! 1304: str_list_t fname_list; ! 1305: ! 1306: fname_list=strListInit(); ! 1307: ! 1308: DESCRIBE_COMPILER(compiler); ! 1309: ! 1310: errfp=stderr; ! 1311: #ifdef __unix__ ! 1312: statfp=stderr; ! 1313: #else ! 1314: statfp=stdout; ! 1315: #endif ! 1316: ! 1317: sscanf("$Revision: 1.77 $", "%*s %s", revision); ! 1318: ! 1319: fprintf(statfp,"\nSynchronet External X/Y/Zmodem v%s-%s" ! 1320: " Copyright %s Rob Swindell\n\n" ! 1321: ,revision ! 1322: ,PLATFORM_DESC ! 1323: ,__DATE__+7 ! 1324: ); ! 1325: ! 1326: xmodem_init(&xm,NULL,&mode,lputs,xmodem_progress,send_byte,recv_byte,is_connected,NULL); ! 1327: zmodem_init(&zm,NULL,lputs,zmodem_progress,send_byte,recv_byte,is_connected,NULL,data_waiting); ! 1328: ! 1329: /* Generate path/sexyz[.host].ini from path/sexyz[.exe] */ ! 1330: SAFECOPY(str,argv[0]); ! 1331: p=getfname(str); ! 1332: SAFECOPY(fname,p); ! 1333: *p=0; ! 1334: if((p=getfext(fname))!=NULL) ! 1335: *p=0; ! 1336: strcat(fname,".ini"); ! 1337: ! 1338: iniFileName(ini_fname,sizeof(ini_fname),str,fname); ! 1339: if((fp=fopen(ini_fname,"r"))!=NULL) ! 1340: fprintf(statfp,"Reading %s\n",ini_fname); ! 1341: ! 1342: tcp_nodelay =iniReadBool(fp,ROOT_SECTION,"TCP_NODELAY",TRUE); ! 1343: ! 1344: telnet =iniReadBool(fp,ROOT_SECTION,"Telnet",TRUE); ! 1345: debug_tx =iniReadBool(fp,ROOT_SECTION,"DebugTx",FALSE); ! 1346: debug_rx =iniReadBool(fp,ROOT_SECTION,"DebugRx",FALSE); ! 1347: debug_telnet =iniReadBool(fp,ROOT_SECTION,"DebugTelnet",FALSE); ! 1348: ! 1349: pause_on_exit =iniReadBool(fp,ROOT_SECTION,"PauseOnExit",FALSE); ! 1350: pause_on_abend =iniReadBool(fp,ROOT_SECTION,"PauseOnAbend",FALSE); ! 1351: ! 1352: log_level =iniReadLogLevel(fp,ROOT_SECTION,"LogLevel",log_level); ! 1353: ! 1354: outbuf.highwater_mark =iniReadInteger(fp,ROOT_SECTION,"OutbufHighwaterMark",1100); ! 1355: outbuf_drain_timeout =iniReadInteger(fp,ROOT_SECTION,"OutbufDrainTimeout",10); ! 1356: outbuf_size =iniReadInteger(fp,ROOT_SECTION,"OutbufSize",16*1024); ! 1357: ! 1358: progress_interval =iniReadInteger(fp,ROOT_SECTION,"ProgressInterval",1); ! 1359: ! 1360: if(iniReadBool(fp,ROOT_SECTION,"Debug",FALSE)) ! 1361: log_level=LOG_DEBUG; ! 1362: ! 1363: xm.send_timeout =iniReadInteger(fp,"Xmodem","SendTimeout",xm.send_timeout); /* seconds */ ! 1364: xm.recv_timeout =iniReadInteger(fp,"Xmodem","RecvTimeout",xm.recv_timeout); /* seconds */ ! 1365: xm.byte_timeout =iniReadInteger(fp,"Xmodem","ByteTimeout",xm.byte_timeout); /* seconds */ ! 1366: xm.ack_timeout =iniReadInteger(fp,"Xmodem","AckTimeout",xm.ack_timeout); /* seconds */ ! 1367: xm.block_size =iniReadInteger(fp,"Xmodem","BlockSize",xm.block_size); /* 128 or 1024 */ ! 1368: xm.max_errors =iniReadInteger(fp,"Xmodem","MaxErrors",xm.max_errors); ! 1369: xm.g_delay =iniReadInteger(fp,"Xmodem","G_Delay",xm.g_delay); ! 1370: ! 1371: zm.init_timeout =iniReadInteger(fp,"Zmodem","InitTimeout",zm.init_timeout); /* seconds */ ! 1372: zm.send_timeout =iniReadInteger(fp,"Zmodem","SendTimeout",zm.send_timeout); /* seconds */ ! 1373: zm.recv_timeout =iniReadInteger(fp,"Zmodem","RecvTimeout",zm.recv_timeout); /* seconds */ ! 1374: zm.crc_timeout =iniReadInteger(fp,"Zmodem","CrcTimeout",zm.crc_timeout); /* seconds */ ! 1375: zm.block_size =iniReadInteger(fp,"Zmodem","BlockSize",zm.block_size); /* 1024 */ ! 1376: zm.max_block_size =iniReadInteger(fp,"Zmodem","MaxBlockSize",zm.max_block_size); /* 1024 or 8192 */ ! 1377: zm.max_errors =iniReadInteger(fp,"Zmodem","MaxErrors",zm.max_errors); ! 1378: zm.recv_bufsize =iniReadInteger(fp,"Zmodem","RecvBufSize",0); ! 1379: zm.no_streaming =!iniReadBool(fp,"Zmodem","Streaming",TRUE); ! 1380: zm.want_fcs_16 =!iniReadBool(fp,"Zmodem","CRC32",TRUE); ! 1381: zm.escape_telnet_iac =iniReadBool(fp,"Zmodem","EscapeTelnetIAC",TRUE); ! 1382: zm.escape_8th_bit =iniReadBool(fp,"Zmodem","Escape8thBit",FALSE); ! 1383: zm.escape_ctrl_chars =iniReadBool(fp,"Zmodem","EscapeCtrlChars",FALSE); ! 1384: ! 1385: dszlog_path =iniReadBool(fp,"DSZLOG","Path",TRUE); ! 1386: dszlog_short =iniReadBool(fp,"DSZLOG","Short",FALSE); ! 1387: dszlog_quotes =iniReadBool(fp,"DSZLOG","Quotes",FALSE); ! 1388: ! 1389: if(fp!=NULL) ! 1390: fclose(fp); ! 1391: ! 1392: if(zm.recv_bufsize > 0xffff) ! 1393: zm.recv_bufsize = 0xffff; ! 1394: ! 1395: if(outbuf_size < MIN_OUTBUF_SIZE) ! 1396: outbuf_size = MIN_OUTBUF_SIZE; ! 1397: else if(outbuf_size > MAX_OUTBUF_SIZE) ! 1398: outbuf_size = MAX_OUTBUF_SIZE; ! 1399: ! 1400: fprintf(statfp,"Output buffer size: %u\n", outbuf_size); ! 1401: RingBufInit(&outbuf, outbuf_size); ! 1402: ! 1403: #if !defined(RINGBUF_EVENT) ! 1404: outbuf_empty=CreateEvent(NULL,/* ManualReset */TRUE, /*InitialState */TRUE,NULL); ! 1405: #endif ! 1406: ! 1407: #if 0 ! 1408: if(argc>1) { ! 1409: fprintf(statfp,"Command line: "); ! 1410: for(i=1;i<argc;i++) ! 1411: fprintf(statfp,"%s ",argv[i]); ! 1412: fprintf(statfp,"\n",statfp); ! 1413: } ! 1414: #endif ! 1415: ! 1416: ! 1417: for(i=1;i<argc;i++) { ! 1418: ! 1419: if(sock==INVALID_SOCKET && isdigit(argv[i][0])) { ! 1420: sock=atoi(argv[i]); ! 1421: continue; ! 1422: } ! 1423: ! 1424: if(!(mode&(SEND|RECV))) { ! 1425: if(toupper(argv[i][0])=='S' || toupper(argv[i][0])=='R') { /* cmd */ ! 1426: if(toupper(argv[i][0])=='R') ! 1427: mode|=RECV; ! 1428: else ! 1429: mode|=SEND; ! 1430: ! 1431: switch(argv[i][1]) { ! 1432: case 'c': ! 1433: case 'C': ! 1434: mode|=XMODEM|CRC; ! 1435: break; ! 1436: case 'x': ! 1437: xm.block_size=128; ! 1438: case 'X': ! 1439: mode|=XMODEM; ! 1440: break; ! 1441: case 'b': /* sz/rz compatible */ ! 1442: case 'B': ! 1443: case 'y': ! 1444: xm.block_size=128; ! 1445: case 'Y': ! 1446: mode|=(YMODEM|CRC); ! 1447: break; ! 1448: case 'g': ! 1449: case 'G': ! 1450: mode|=(YMODEM|CRC|GMODE); ! 1451: break; ! 1452: case 'z': ! 1453: case 'Z': ! 1454: mode|=(ZMODEM|CRC); ! 1455: break; ! 1456: default: ! 1457: fprintf(statfp,"Unrecognized command '%s'\n\n",argv[i]); ! 1458: fprintf(statfp,usage); ! 1459: bail(1); ! 1460: } ! 1461: continue; ! 1462: } ! 1463: ! 1464: if(toupper(argv[i][0])=='V') { ! 1465: ! 1466: fprintf(statfp,"%-8s %s\n",getfname(__FILE__) ,revision); ! 1467: fprintf(statfp,"%-8s %s\n",getfname(xmodem_source()),xmodem_ver(str)); ! 1468: fprintf(statfp,"%-8s %s\n",getfname(zmodem_source()),zmodem_ver(str)); ! 1469: #ifdef _DEBUG ! 1470: fprintf(statfp,"Debug\n"); ! 1471: #endif ! 1472: fprintf(statfp,"Compiled %s %.5s with %s\n",__DATE__,__TIME__,compiler); ! 1473: fprintf(statfp,"%s\n",os_version(str)); ! 1474: bail(0); ! 1475: } ! 1476: ! 1477: arg=argv[i]; ! 1478: if(*arg=='-') { ! 1479: while(*arg=='-') ! 1480: arg++; ! 1481: if(stricmp(arg,"telnet")==0) { ! 1482: telnet=TRUE; ! 1483: continue; ! 1484: } ! 1485: if(stricmp(arg,"rlogin")==0 || stricmp(arg,"ssh")==0 || stricmp(arg,"raw")==0) { ! 1486: telnet=FALSE; ! 1487: continue; ! 1488: } ! 1489: if(stricmp(arg,"debug")==0) { ! 1490: log_level=LOG_DEBUG; ! 1491: continue; ! 1492: } ! 1493: if(stricmp(arg,"quotes")==0) { ! 1494: dszlog_quotes=TRUE; ! 1495: continue; ! 1496: } ! 1497: switch(toupper(*arg)) { ! 1498: case 'K': /* sz/rz compatible */ ! 1499: xm.block_size=1024; ! 1500: break; ! 1501: case 'C': /* sz/rz compatible */ ! 1502: mode|=CRC; ! 1503: break; ! 1504: case '2': ! 1505: zm.max_block_size=2048; ! 1506: break; ! 1507: case '4': ! 1508: zm.max_block_size=4096; ! 1509: break; ! 1510: case '8': /* ZedZap */ ! 1511: zm.max_block_size=8192; ! 1512: break; ! 1513: case 'O': /* disable Zmodem CRC-32 */ ! 1514: zm.want_fcs_16=TRUE; ! 1515: break; ! 1516: case 'S': /* disable Zmodem streaming */ ! 1517: zm.no_streaming=TRUE; ! 1518: break; ! 1519: case 'G': /* Ymodem-G */ ! 1520: mode|=GMODE; ! 1521: break; ! 1522: case 'Y': ! 1523: mode|=OVERWRITE; ! 1524: break; ! 1525: case '!': ! 1526: pause_on_abend=TRUE; ! 1527: break; ! 1528: } ! 1529: } ! 1530: } ! 1531: ! 1532: else if((argv[i][0]=='+' || argv[i][0]=='@') && fexist(argv[i]+1)) { ! 1533: if(mode&RECVDIR) { ! 1534: fprintf(statfp,"!Cannot specify both directory and filename\n"); ! 1535: bail(1); ! 1536: } ! 1537: sprintf(str,"%s",argv[i]+1); ! 1538: if((fp=fopen(str,"r"))==NULL) { ! 1539: fprintf(statfp,"!Error %d opening filelist: %s\n",errno,str); ! 1540: bail(1); ! 1541: } ! 1542: while(!feof(fp) && !ferror(fp)) { ! 1543: if(!fgets(str,sizeof(str),fp)) ! 1544: break; ! 1545: truncsp(str); ! 1546: strListAppend(&fname_list,strdup(str),fnames++); ! 1547: } ! 1548: fclose(fp); ! 1549: } ! 1550: ! 1551: else if(mode&(SEND|RECV)){ ! 1552: if(isdir(argv[i])) { /* is a directory */ ! 1553: if(mode&RECVDIR) { ! 1554: fprintf(statfp,"!Only one directory can be specified\n"); ! 1555: bail(1); ! 1556: } ! 1557: if(fnames) { ! 1558: fprintf(statfp,"!Cannot specify both directory and filename\n"); ! 1559: bail(1); ! 1560: } ! 1561: if(mode&SEND) { ! 1562: fprintf(statfp,"!Cannot send directory '%s'\n",argv[i]); ! 1563: bail(1); ! 1564: } ! 1565: mode|=RECVDIR; ! 1566: } ! 1567: strListAppend(&fname_list,argv[i],fnames++); ! 1568: } ! 1569: } ! 1570: ! 1571: if(!telnet) ! 1572: zm.escape_telnet_iac = FALSE; ! 1573: ! 1574: if(sock==INVALID_SOCKET || sock<1) { ! 1575: #ifdef __unix__ ! 1576: if(STDOUT_FILENO > STDIN_FILENO) ! 1577: sock=STDOUT_FILENO; ! 1578: else ! 1579: sock=STDIN_FILENO; ! 1580: stdio=TRUE; ! 1581: ! 1582: fprintf(statfp,"No socket descriptor specified, using STDIO\n"); ! 1583: telnet=FALSE; ! 1584: #else ! 1585: fprintf(statfp,"!No socket descriptor specified\n\n"); ! 1586: fprintf(errfp,usage); ! 1587: bail(1); ! 1588: #endif ! 1589: } ! 1590: #ifdef __unix__ ! 1591: else ! 1592: statfp=stdout; ! 1593: #endif ! 1594: ! 1595: if(!(mode&(SEND|RECV))) { ! 1596: fprintf(statfp,"!No command specified\n\n"); ! 1597: fprintf(statfp,usage); ! 1598: bail(1); ! 1599: } ! 1600: ! 1601: if(mode&(SEND|XMODEM) && !fnames) { /* Sending with any or recv w/Xmodem */ ! 1602: fprintf(statfp,"!Must specify filename or filelist\n\n"); ! 1603: fprintf(statfp,usage); ! 1604: bail(1); ! 1605: } ! 1606: ! 1607: #ifdef __unix__ ! 1608: if(stdio) { ! 1609: struct termios term; ! 1610: memset(&term,0,sizeof(term)); ! 1611: cfsetispeed(&term,B19200); ! 1612: cfsetospeed(&term,B19200); ! 1613: term.c_iflag &= ~(IMAXBEL|IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON); ! 1614: term.c_oflag &= ~OPOST; ! 1615: term.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN); ! 1616: term.c_cflag &= ~(CSIZE|PARENB); ! 1617: term.c_cflag |= CS8; ! 1618: atexit(resetterm); ! 1619: tcgetattr(STDOUT_FILENO, &origterm); ! 1620: tcsetattr(STDOUT_FILENO, TCSADRAIN, &term); ! 1621: } ! 1622: #endif ! 1623: ! 1624: /* Code disabled. Why? ToDo */ ! 1625: /* if(mode&RECVDIR) ! 1626: backslash(fname[0]); */ ! 1627: ! 1628: if(!winsock_startup()) ! 1629: bail(-1); ! 1630: ! 1631: /* Enable the Nagle Algorithm */ ! 1632: #ifdef __unix__ ! 1633: if(!stdio) { ! 1634: #endif ! 1635: lprintf(LOG_DEBUG,"Setting TCP_NODELAY to %d",tcp_nodelay); ! 1636: setsockopt(sock,IPPROTO_TCP,TCP_NODELAY,(char*)&tcp_nodelay,sizeof(tcp_nodelay)); ! 1637: #ifdef __unix__ ! 1638: } ! 1639: #endif ! 1640: ! 1641: if(!socket_check(sock, NULL, NULL, 0)) { ! 1642: lprintf(LOG_WARNING,"No socket connection"); ! 1643: bail(-1); ! 1644: } ! 1645: ! 1646: if((dszlog=getenv("DSZLOG"))!=NULL) { ! 1647: if((logfp=fopen(dszlog,"w"))==NULL) { ! 1648: lprintf(LOG_WARNING,"Error %d opening DSZLOG file: %s",errno,dszlog); ! 1649: bail(-1); ! 1650: } ! 1651: } ! 1652: ! 1653: /* Install Ctrl-C/Break signal handler here */ ! 1654: #if defined(_WIN32) ! 1655: SetConsoleCtrlHandler(ControlHandler, TRUE /* Add */); ! 1656: #elif defined(__unix__) ! 1657: signal(SIGQUIT,break_handler); ! 1658: signal(SIGINT,break_handler); ! 1659: signal(SIGTERM,break_handler); ! 1660: ! 1661: signal(SIGHUP,SIG_IGN); ! 1662: ! 1663: /* Don't die on SIGPIPE */ ! 1664: signal(SIGPIPE,SIG_IGN); ! 1665: #endif ! 1666: ! 1667: #if !SINGLE_THREADED ! 1668: _beginthread(output_thread,0,NULL); ! 1669: #endif ! 1670: ! 1671: if(mode&RECV) ! 1672: retval=receive_files(fname_list, fnames); ! 1673: else ! 1674: retval=send_files(fname_list, fnames); ! 1675: ! 1676: #if !SINGLE_THREADED ! 1677: lprintf(LOG_DEBUG,"Waiting for output buffer to empty... "); ! 1678: if(WaitForEvent(outbuf_empty,5000)!=WAIT_OBJECT_0) ! 1679: lprintf(LOG_DEBUG,"FAILURE"); ! 1680: #endif ! 1681: ! 1682: terminate=TRUE; /* stop output thread */ ! 1683: /* Code disabled. Why? ToDo */ ! 1684: /* sem_post(outbuf.sem); ! 1685: sem_post(outbuf.highwater_sem); */ ! 1686: ! 1687: fprintf(statfp,"Exiting - Error level: %d, flows: %u, select_errors=%u" ! 1688: ,retval, flows, select_errors); ! 1689: fprintf(statfp,"\n"); ! 1690: ! 1691: bail(retval); ! 1692: } ! 1693:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.