home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / MISC / OS2 / BSRCP240.ZIP / JANUS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-08-22  |  59.7 KB  |  1,799 lines
  1. /*--------------------------------------------------------------------------*/
  2. /*                                                                            */
  3. /*                                                                            */
  4. /*        ------------         Bit-Bucket Software, Co.                        */
  5. /*        \ 10001101 /         Writers and Distributors of                    */
  6. /*         \ 011110 /          Freely Available<tm> Software.                 */
  7. /*          \ 1011 /                                                            */
  8. /*           ------                                                            */
  9. /*                                                                            */
  10. /*    (C) Copyright 1987-90, Bit Bucket Software Co., a Delaware Corporation. */
  11. /*                                                                            */
  12. /*                                                                            */
  13. /*                    BinkleyTerm Janus revision 0.31, 11- 2-89                */
  14. /*                     Full-duplex WaZOO file transfer protocol                */
  15. /*                                                                            */
  16. /*                                                                            */
  17. /*      For complete    details  of the licensing restrictions, please refer    */
  18. /*      to the License  agreement,  which  is published in its entirety in    */
  19. /*      the MAKEFILE and BT.C, and also contained in the file LICENSE.240.    */
  20. /*                                                                            */
  21. /*      USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  22. /*      BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  23. /*      THIS    AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,    OR IF YOU DO    */
  24. /*      NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
  25. /*      SOFTWARE CO.    AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
  26. /*      SHOULD YOU  PROCEED TO USE THIS FILE    WITHOUT HAVING    ACCEPTED THE    */
  27. /*      TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
  28. /*      AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.        */
  29. /*                                                                            */
  30. /*                                                                            */
  31. /* You can contact Bit Bucket Software Co. at any one of the following        */
  32. /* addresses:                                                                */
  33. /*                                                                            */
  34. /* Bit Bucket Software Co.          FidoNet  1:104/501, 1:132/491, 1:141/491    */
  35. /* P.O. Box 460398                  AlterNet 7:491/0                            */
  36. /* Aurora, CO 80046               BBS-Net  86:2030/1                        */
  37. /*                                  Internet f491.n132.z1.fidonet.org         */
  38. /*                                                                            */
  39. /* Please feel free to contact us at any time to share your comments about    */
  40. /* our software and/or licensing policies.                                    */
  41. /*                                                                            */
  42. /*--------------------------------------------------------------------------*/
  43.  
  44. #define  WAZOO_SECTION
  45. #include <sys\types.h>
  46. #include <sys\stat.h>
  47. #include <stdio.h>
  48. #include <stdarg.h>
  49. #include <fcntl.h>
  50. #include <ctype.h>
  51. #include <string.h>
  52. #include <time.h>
  53. #include <io.h>
  54. #include <conio.h>
  55. #include <stdlib.h>
  56.  
  57. #ifdef __TURBOC__
  58. #include "tc_utime.h"
  59. #include <alloc.h>
  60. #else
  61. #include <sys/utime.h>
  62. #include <malloc.h>
  63. #endif
  64.  
  65. #ifndef IBM_C
  66. extern int _fmode;
  67. #endif
  68.  
  69. #include "com.h"
  70. #include "xfer.h"
  71. #include "zmodem.h"
  72. #include "keybd.h"
  73. #include "sbuf.h"
  74. #include "sched.h"
  75. #include "externs.h"
  76. #include "prototyp.h"
  77. #include "defines.h"
  78. #include "janus.h"
  79.  
  80.  
  81. /* Private routines */
  82. static void getfname(word);
  83. static void sendpkt(byte *,int,int);
  84. static void sendpkt32(byte *,int,int);
  85. static void txbyte(byte);
  86. static long procfname(void);
  87. static byte rcvpkt(void);
  88. static void rxclose(word);
  89. static void endbatch(void);
  90. static void j_message(word,char *,...);
  91. static void j_status(char *,...);
  92. static int j_error(byte *,byte *);
  93. static void update_y(void);
  94. static void long_set_timer(long *,word);
  95. static int long_time_gone(long *);
  96. static int rcvrawbyte(void);
  97. static int rxbyte(void);
  98. static void xfer_summary(char *,char *,long *,int);
  99. static void update_status(long *,long *,long,int *,int);
  100. static void through(long *,long *);
  101. static int get_filereq(byte);
  102. static int record_reqfile(char *);
  103. static byte get_reqname(byte);
  104. static void mark_done(char *);
  105.  
  106.  
  107.  
  108. /* Private data. I know, proper software design says you shouldn't make data */
  109. /* global unless you really need to.  In this case speed and code size make  */
  110. /* it more important to avoid constantly pushing & popping arguments.         */
  111.  
  112. static byte *GenericError = "!%s";
  113. static byte *ReqTmp = "JANUSREQ.TMP";
  114. #ifdef OS_2
  115. static byte Upload_path[PATHLEN];    /* Dest. path of file being
  116.                                      * received   */
  117. #endif
  118. static char *Rxbuf;       /* Address of packet reception buffer              */
  119. static char *Txfname;      /* Full path of file we're sending                 */
  120. static char *Rxfname;      /* Full path of file we're receiving               */
  121. static byte *Rxbufptr;      /* Current position within packet reception buffer */
  122. static byte *Rxbufmax;      /* Upper bound of packet reception buffer          */
  123. static byte Do_after;      /* What to do with file being sent when we're done */
  124. static byte WaitFlag;      /* Tells rcvrawbyte() whether or not to wait         */
  125. static byte SharedCap;      /* Capability bits both sides have in common         */
  126. static int Txfile;          /* File handle of file we're sending               */
  127. static int Rxfile;          /* File handle of file we're receiving             */
  128. static int ReqRecorded;   /* Number of files obtained by this request         */
  129. static word TimeoutSecs;  /* How long to wait for various things             */
  130. static word Rxblklen;      /* Length of data in last data block packet recvd  */
  131. static word Next_y;       /* Number of next available line on screen         */
  132. static word Tx_y;          /* Line number of file transmission status display */
  133. static word Rx_y;          /* Line number of file reception status display     */
  134. static long Txlen;          /* Total length of file we're sending              */
  135. static long Rxlen;          /* Total length of file we're receiving            */
  136. static long Rxfiletime;   /* Timestamp of file we're receiving               */
  137. static long Diskavail;      /* Bytes available in upload directory             */
  138. static long TotalBytes;   /* Total bytes xferred in this session             */
  139. static long Txsttime;      /* Time at which we started sending current file     */
  140. static long Rxsttime;      /* Time at which we started receiving current file */
  141.  
  142.  
  143. /*****************************************************************************/
  144. /* Super-duper neato-whizbang full-duplex streaming ACKless batch file         */
  145. /* transfer protocol for use in WaZOO mail sessions                          */
  146. /*****************************************************************************/
  147. void Janus(void) {
  148.    byte xstate;           /* Current file transmission state                 */
  149.    byte rstate;           /* Current file reception state                     */
  150.    byte pkttype;          /* Type of packet last received                     */
  151.    byte tx_inhibit;       /* Flag to wait and send after done receiving      */
  152.    byte *holdname;          /* Name of hold area                                 */
  153. #ifdef OS_2
  154.    byte *p;               /* Temporary pointer                                 */
  155. #endif
  156.    byte fsent;              /* Did we manage to send anything this session?     */
  157.    byte sending_req;      /* Are we currently sending requested files?         */
  158.    byte attempting_req;   /* Are we waiting for the sender to start our req? */
  159.    byte req_started;      /* Has the sender started servicing our request?     */
  160.    int txoldeta;          /* Last transmission ETA displayed                 */
  161.    int rxoldeta;          /* Last reception ETA displayed                     */
  162.    word blklen;           /* Length of last data block sent                  */
  163.    word txblklen;          /* Size of data block to try to send this time     */
  164.    word txblkmax;          /* Max size of data block to send at this speed     */
  165.    word goodneeded;       /* # good bytes to send before upping txblklen     */
  166.    word goodbytes;          /* Number of good bytes sent at this block size     */
  167.    word rpos_count;       /* Number of RPOS packets sent at this position     */
  168.    long xmit_retry;       /* Time to retransmit lost FNAMEPKT or EOF packet  */
  169.    long txpos;              /* Current position within file we're sending      */
  170.    long lasttx;           /* Position within file of last data block we sent */
  171.    long starttime;          /* Time at which we started this Janus session     */
  172.    long txstpos;          /* Initial data position of file we're sending     */
  173.    long rxstpos;          /* Initial data position of file we're receiving   */
  174.    long txoldpos;          /* Last transmission file position displayed         */
  175.    long rxoldpos;          /* Last reception file position displayed          */
  176.    long rpos_retry;       /* Time at which to retry RPOS packet              */
  177.    long brain_dead;       /* Time at which to give up on other computer      */
  178.    long rpos_sttime;      /* Time at which we started current RPOS sequence  */
  179.    long last_rpostime;      /* Timetag of last RPOS which we performed         */
  180.    long last_blkpos;      /* File position of last out-of-sequence BLKPKT     */
  181.    FILE *reqfile;          /* File handle for .REQ file                         */
  182.  
  183.  
  184.    set_prior(3);          /* Time Critical                                     */
  185.    XON_DISABLE();
  186.    if (un_attended && fullscreen) {
  187.       clear_filetransfer();
  188.       sb_show();
  189.    } else {
  190.       set_xy(NULL);
  191.       Next_y = locate_y;
  192.    }
  193.    Tx_y = Rx_y = 0;
  194.    SharedCap = 0;
  195.    TotalBytes = 0;
  196.    time(&starttime);
  197.  
  198.    /*------------------------------------------------------------------------*/
  199.    /* Allocate memory                                                         */
  200.    /*------------------------------------------------------------------------*/
  201.    Rxbuf = Txbuf + 4096 + 8;
  202.    Txfname = Rxfname = NULL;
  203.    if (!(Txfname = malloc(PATHLEN)) || !(Rxfname = malloc(PATHLEN))) {
  204.       status_line(msgtxt[M_MEM_ERROR]);
  205.       mdm_hangup();
  206.       goto freemem;
  207.    }
  208.    Rxbufmax = Rxbuf + BUFMAX + 8;
  209.  
  210.    /*------------------------------------------------------------------------*/
  211.    /* Initialize file transmission variables                                 */
  212.    /*------------------------------------------------------------------------*/
  213.    tx_inhibit = FALSE;
  214.    last_rpostime = xmit_retry = 0L;
  215.    TimeoutSecs = (unsigned int)(40960 / cur_baud);
  216.    if (TimeoutSecs < 10)
  217.       TimeoutSecs = 10;
  218.    long_set_timer(&brain_dead,120);
  219.    txblkmax = cur_baud/300 * 128;
  220.    if (txblkmax > BUFMAX)
  221.       txblkmax = BUFMAX;
  222.    txblklen = txblkmax;
  223.    goodbytes = goodneeded = 0;
  224.    Txfile = -1;
  225.    sending_req = fsent = FALSE;
  226.    xstate = XSENDFNAME;
  227.    getfname(INITIAL_XFER);
  228.  
  229.    /*------------------------------------------------------------------------*/
  230.    /* Initialize file reception variables                                     */
  231.    /*------------------------------------------------------------------------*/
  232.    holdname = HoldAreaNameMunge(&called_addr);
  233.    sprintf(Abortlog_name,"%s%s.Z\0",holdname,Hex_Addr_Str(&called_addr));
  234.  
  235. /* Sorry, this don't cut in OS/2's zfree */
  236. #ifdef OS_2
  237.    p = strchr(strcpy (Upload_path, CurrentNetFiles),'\0') - 1;
  238.    while (p >= Upload_path && *p != '\\')
  239.       --p;
  240.    *(++p) = '\0';
  241.    if ((Diskavail = zfree(Upload_path)) <= 0L)
  242.       Diskavail = 0x7FFFFFF;
  243. #else
  244.    Diskavail = (CurrentNetFiles[1] == ':') ? zfree(CurrentNetFiles) : 0x7FFFFFFF;
  245. #endif
  246.    Rxbufptr = NULL;
  247.    rpos_retry = rpos_count = 0;
  248.    attempting_req = req_started = FALSE;
  249.    rstate = RRCVFNAME;
  250.  
  251.    /*------------------------------------------------------------------------*/
  252.    /* Send and/or receive stuff until we're done with both                   */
  253.    /*------------------------------------------------------------------------*/
  254.    do {                                          /* while (xstate || rstate) */
  255.  
  256.       /*---------------------------------------------------------------------*/
  257.       /* If nothing useful (i.e. sending or receiving good data block) has     */
  258.       /* happened within the last 2 minutes, give up in disgust              */
  259.       /*---------------------------------------------------------------------*/
  260.       if (long_time_gone(&brain_dead)) {
  261.          j_status(msgtxt[M_OTHER_DIED]);           /* "He's dead, Jim." */
  262.          goto giveup;
  263.       }
  264.  
  265.       /*---------------------------------------------------------------------*/
  266.       /* If we're tired of waiting for an ACK, try again                     */
  267.       /*---------------------------------------------------------------------*/
  268.       if (xmit_retry) {
  269.          if (long_time_gone(&xmit_retry)) {
  270.             j_message(Tx_y,msgtxt[M_TIMEOUT]);
  271.             xmit_retry = 0L;
  272.  
  273.             switch (xstate) {
  274.                case XRCVFNACK:
  275.                   xstate = XSENDFNAME;
  276.                   break;
  277.                case XRCVFRNAKACK:
  278.                   xstate = XSENDFREQNAK;
  279.                   break;
  280.                case XRCVEOFACK:
  281.                   errno = 0;
  282.                   lseek(Txfile, txpos=lasttx, SEEK_SET);
  283.                   if (j_error(msgtxt[M_SEEK_MSG],Txfname))
  284.                      goto giveup;
  285.                   xstate = XSENDBLK;
  286.                   break;
  287.             }
  288.          }
  289.       }
  290.  
  291.       /*---------------------------------------------------------------------*/
  292.       /* Transmit next part of file, if any                                  */
  293.       /*---------------------------------------------------------------------*/
  294.       switch (xstate) {
  295.          case XSENDBLK:
  296.             if (tx_inhibit)
  297.                break;
  298.             *((long *)Txbuf) = lasttx = txpos;
  299.             errno = 0;
  300.             blklen = read(Txfile, Txbuf+sizeof(txpos), txblklen);
  301.             if (j_error(msgtxt[M_READ_MSG],Txfname))
  302.                goto giveup;
  303.             txpos += blklen;
  304.             sendpkt(Txbuf, sizeof(txpos)+blklen, BLKPKT);
  305.             update_status(&txpos,&txoldpos,Txlen-txpos,&txoldeta,Tx_y);
  306.             fsent = TRUE;
  307.             if (txpos >= Txlen || blklen < txblklen) {
  308.                long_set_timer(&xmit_retry,TimeoutSecs);
  309.                xstate = XRCVEOFACK;
  310.             } else
  311.                long_set_timer(&brain_dead,120);
  312.  
  313.             if (txblklen < txblkmax && (goodbytes+=txblklen) >= goodneeded) {
  314.                txblklen <<= 1;
  315.                goodbytes = 0;
  316.             }
  317.             break;
  318.  
  319.          case XSENDFNAME:
  320.             blklen = strchr( strchr(Txbuf,'\0')+1, '\0') - Txbuf + 1;
  321.             Txbuf[blklen++] = OURCAP;
  322.             sendpkt(Txbuf,blklen,FNAMEPKT);
  323.             txoldpos = txoldeta = -1;
  324.             long_set_timer(&xmit_retry,TimeoutSecs);
  325.             xstate = XRCVFNACK;
  326.             break;
  327.  
  328.          case XSENDFREQNAK:
  329.             sendpkt(NULL,0,FREQNAKPKT);
  330.             long_set_timer(&xmit_retry,TimeoutSecs);
  331.             xstate = XRCVFRNAKACK;
  332.             break;
  333.       }
  334.  
  335.       /*---------------------------------------------------------------------*/
  336.       /* Catch up on our reading; receive and handle all outstanding packets */
  337.       /*---------------------------------------------------------------------*/
  338.       while (pkttype = rcvpkt()) {
  339.          if (pkttype != BADPKT)
  340.             long_set_timer(&brain_dead,120);
  341.          switch (pkttype) {
  342.  
  343.             /*---------------------------------------------------------------*/
  344.             /* File data block or munged block                                 */
  345.             /*---------------------------------------------------------------*/
  346.             case BADPKT:
  347.             case BLKPKT:
  348.                if (rstate == RRCVBLK) {
  349.                   if (pkttype == BADPKT || *((long *)Rxbuf) != Rxpos) {
  350.                      if (pkttype == BLKPKT) {
  351.                         if (*((long *)Rxbuf) < last_blkpos)
  352.                            rpos_retry = rpos_count = 0;
  353.                         last_blkpos = *((long *)Rxbuf);
  354.                      }
  355.                      if (long_time_gone(&rpos_retry)) {
  356.                         /* If we're the called machine, and we're trying
  357.                            to send stuff, and it seems to be screwing up
  358.                            our ability to receive stuff, maybe this
  359.                            connection just can't hack full-duplex.  Try
  360.                            waiting till the sending system finishes before
  361.                            sending our stuff to it */
  362.                         if (rpos_count > 4) {
  363.                            if (xstate && !isOriginator && !tx_inhibit) {
  364.                               tx_inhibit = TRUE;
  365.                               j_status(msgtxt[M_GOING_ONE_WAY]);
  366.                            }
  367.                            rpos_count = 0;
  368.                         }
  369.                         if (++rpos_count == 1)
  370.                            time(&rpos_sttime);
  371.                         j_message(Rx_y,msgtxt[M_J_BAD_PACKET],Rxpos);
  372.                         *((long *)Rxbuf) = Rxpos;
  373.                         *((long *)(Rxbuf + sizeof(Rxpos))) = rpos_sttime;
  374.                         sendpkt(Rxbuf, sizeof(Rxpos)+sizeof(rpos_sttime), RPOSPKT);
  375.                         long_set_timer(&rpos_retry,TimeoutSecs/2);
  376.                      }
  377.                   } else {
  378.                      last_blkpos = Rxpos;
  379.                      rpos_retry = rpos_count = 0;
  380.                      errno = 0;
  381.                      write(Rxfile, Rxbuf+sizeof(Rxpos), Rxblklen -= sizeof(Rxpos));
  382.                      if (j_error(msgtxt[M_WRITE_MSG],Rxfname))
  383.                         goto giveup;
  384.                      Diskavail -= Rxblklen;
  385.                      Rxpos += Rxblklen;
  386.                      update_status(&Rxpos,&rxoldpos,Rxlen-Rxpos,&rxoldeta,Rx_y);
  387.                      if (Rxpos >= Rxlen) {
  388.                         rxclose(GOOD_XFER);
  389.                         Rxlen -= rxstpos;
  390.                         through(&Rxlen,&Rxsttime);
  391.                         j_status("%s-J%s %s",msgtxt[M_FILE_RECEIVED], (SharedCap&CANCRC32)?"/32":" ",Rxfname);
  392.                         update_files(0);
  393.                         rstate = RRCVFNAME;
  394.                      }
  395.                   }
  396.                }
  397.                if (rstate == RRCVFNAME)
  398.                   sendpkt(NULL,0,EOFACKPKT);
  399.                break;
  400.  
  401.             /*---------------------------------------------------------------*/
  402.             /* Name and other data for next file to receive                  */
  403.             /*---------------------------------------------------------------*/
  404.             case FNAMEPKT:
  405.                if (rstate == RRCVFNAME)
  406.                   Rxpos = rxstpos = procfname();
  407.                if (!Rxfname[0] && get_filereq(req_started)) {
  408.                   sendpkt(Rxbuf,strlen(Rxbuf)+2,FREQPKT);
  409.                   attempting_req = TRUE;
  410.                   req_started = FALSE;
  411.                } else {
  412.                   if (attempting_req) {
  413.                      attempting_req = FALSE;
  414.                      req_started = TRUE;
  415.                   }
  416.                   *((long *)Rxbuf) = Rxpos;
  417.                   Rxbuf[sizeof(Rxpos)] = SharedCap;
  418.                   sendpkt(Rxbuf,sizeof(Rxpos)+1,FNACKPKT);
  419.                   rxoldpos = rxoldeta = -1;
  420.                   if (Rxpos > -1)
  421.                      rstate = (byte)((Rxfname[0]) ? RRCVBLK : RDONE);
  422.                   else
  423.                      j_status(msgtxt[M_REFUSING],Rxfname);
  424.                   if (!rstate)
  425.                      tx_inhibit = FALSE;
  426.                   if (!(xstate || rstate))
  427.                      goto breakout;
  428.                }
  429.                break;
  430.  
  431.             /*---------------------------------------------------------------*/
  432.             /* ACK to filename packet we just sent                             */
  433.             /*---------------------------------------------------------------*/
  434.             case FNACKPKT:
  435.                if (xstate == XRCVFNACK) {
  436.                   xmit_retry = 0L;
  437.                   if (Txfname[0]) {
  438.                      SharedCap = (Rxblklen > sizeof(long)) ? Rxbuf[sizeof(long)] : 0;
  439.                      if ((txpos = *((long *)Rxbuf)) > -1L) {
  440.                         if (txpos)
  441.                            status_line(msgtxt[M_SYNCHRONIZING],txpos);
  442.                         errno = 0;
  443.                         lseek(Txfile, txstpos = txpos, SEEK_SET);
  444.                         if (j_error(msgtxt[M_SEEK_MSG],Txfname))
  445.                            goto giveup;
  446.                         xstate = XSENDBLK;
  447.                      } else {
  448.                         j_status(msgtxt[M_REMOTE_REFUSED],Txfname);
  449.                         if (sending_req) {
  450.                            if (!(sending_req = get_reqname(FALSE)))
  451.                               getfname(GOOD_XFER);
  452.                         } else {
  453.                            Do_after = NOTHING_AFTER;
  454.                            getfname(GOOD_XFER);
  455.                         }
  456.                         xstate = XSENDFNAME;
  457.                      }
  458.                   } else {
  459.                      sent_mail = 1;
  460.                      xstate = XDONE;
  461.                   }
  462.                }
  463.                if (!(xstate || rstate))
  464.                   goto breakout;
  465.                break;
  466.  
  467.             /*---------------------------------------------------------------*/
  468.             /* Request to send more stuff rather than end batch just yet     */
  469.             /*---------------------------------------------------------------*/
  470.             case FREQPKT:
  471.                if (xstate == XRCVFNACK) {
  472.                   xmit_retry = 0L;
  473.                   SharedCap = *(strchr(Rxbuf,'\0')+1);
  474.                   if (CurrentReqLim > 0) {
  475.                      sprintf(Txbuf,request_template,CurrentNetFiles,
  476.                         Hex_Addr_Str (&(alias[0])));
  477.                      errno = 0;
  478.                      reqfile = fopen(Txbuf,"wt");
  479.                      j_error(msgtxt[M_OPEN_MSG],Txbuf);
  480.                      fputs(Rxbuf,reqfile);
  481.                      fputs("\n",reqfile);
  482.                      fclose(reqfile);
  483.                      unlink(ReqTmp);
  484.                      ReqRecorded = 0;  /* counted by record_reqfile */
  485.                      respond_to_file_requests(0,record_reqfile);
  486.                      CurrentReqLim -= ReqRecorded;
  487.                      if (sending_req = get_reqname(TRUE))
  488.                         xstate = XSENDFNAME;
  489.                      else
  490.                         xstate = XSENDFREQNAK;
  491.                   } else
  492.                      xstate = XSENDFREQNAK;
  493.                }
  494.                break;
  495.  
  496.             /*---------------------------------------------------------------*/
  497.             /* Our last file request didn't match anything; move on to next  */
  498.             /*---------------------------------------------------------------*/
  499.             case FREQNAKPKT:
  500.                attempting_req = FALSE;
  501.                req_started = TRUE;
  502.                sendpkt(NULL,0,FRNAKACKPKT);
  503.                break;
  504.  
  505.             /*---------------------------------------------------------------*/
  506.             /* ACK to no matching files for request error; try to end again  */
  507.             /*---------------------------------------------------------------*/
  508.             case FRNAKACKPKT:
  509.                if (xstate == XRCVFRNAKACK) {
  510.                   xmit_retry = 0L;
  511.                   getfname(GOOD_XFER);
  512.                   xstate = XSENDFNAME;
  513.                }
  514.                break;
  515.  
  516.             /*---------------------------------------------------------------*/
  517.             /* ACK to last data block in file                                 */
  518.             /*---------------------------------------------------------------*/
  519.             case EOFACKPKT:
  520.                if (xstate == XRCVEOFACK || xstate == XRCVFNACK) {
  521.                   xmit_retry = 0L;
  522.                   if (xstate == XRCVEOFACK) {
  523.                      Txlen -= txstpos;
  524.                      through(&Txlen,&Txsttime);
  525.                      j_status("%s-J%s %s",msgtxt[M_FILE_SENT],(SharedCap&CANCRC32)?"/32":" ",Txfname);
  526.                      update_files(1);
  527.                      if (sending_req) {
  528.                         if (!(sending_req = get_reqname(FALSE)))
  529.                            getfname(GOOD_XFER);
  530.                      } else
  531.                         getfname(GOOD_XFER);
  532.                   }
  533.                   xstate = XSENDFNAME;
  534.                }
  535.                break;
  536.  
  537.             /*---------------------------------------------------------------*/
  538.             /* Receiver says "let's try that again."                         */
  539.             /*---------------------------------------------------------------*/
  540.             case RPOSPKT:
  541.                if (xstate == XSENDBLK || xstate == XRCVEOFACK) {
  542.                   if (*((long *)(Rxbuf+sizeof(txpos))) != last_rpostime) {
  543.                      last_rpostime = *((long *)(Rxbuf+sizeof(txpos)));
  544.                      xmit_retry = 0L;
  545.                      CLEAR_OUTBOUND();
  546.                      errno = 0;
  547.                      lseek(Txfile, txpos = lasttx = *((long *)Rxbuf), SEEK_SET);
  548.                      if (j_error(msgtxt[M_SEEK_MSG],Txfname))
  549.                         goto giveup;
  550.                      j_message(Tx_y,msgtxt[M_SYNCHRONIZING],txpos);
  551.                      txblklen >>= 2;
  552.                      if (txblklen < 64)
  553.                         txblklen = 64;
  554.                      goodbytes = 0;
  555.                      goodneeded += 1024;
  556.                      if (goodneeded > 8192)
  557.                         goodneeded = 8192;
  558.                      xstate = XSENDBLK;
  559.                   }
  560.                }
  561.                break;
  562.  
  563.             /*---------------------------------------------------------------*/
  564.             /* Debris from end of previous Janus session; ignore it          */
  565.             /*---------------------------------------------------------------*/
  566.             case HALTACKPKT:
  567.                break;
  568.  
  569.             /*---------------------------------------------------------------*/
  570.             /* Abort the transfer and quit                                     */
  571.             /*---------------------------------------------------------------*/
  572.             default:
  573.                j_status(msgtxt[M_UNKNOWN_PACKET],pkttype);
  574.                /* fallthrough */
  575.             case HALTPKT:
  576. giveup:        j_status(msgtxt[M_SESSION_ABORT]);
  577.                if (Txfname[0])
  578.                   getfname(ABORT_XFER);
  579.                if (rstate == RRCVBLK) {
  580.                   TotalBytes += (Rxpos-rxstpos);
  581.                   rxclose(FAILED_XFER);
  582.                }
  583.                goto abortxfer;
  584.  
  585.          }                                      /* switch (pkttype)  */
  586.       }                                       /* while (pkttype)  */
  587.    } while (xstate || rstate);
  588.  
  589.    /*------------------------------------------------------------------------*/
  590.    /* All done; make sure other end is also finished (one way or another)     */
  591.    /*------------------------------------------------------------------------*/
  592. breakout:
  593.    if (!fsent) j_status(msgtxt[M_NOTHING_TO_SEND], Full_Addr_Str (&called_addr));
  594. abortxfer:
  595.    through(&TotalBytes,&starttime);
  596.    endbatch();
  597.  
  598.    /*------------------------------------------------------------------------*/
  599.    /* Release allocated memory                                                 */
  600.    /*------------------------------------------------------------------------*/
  601. freemem:
  602.    if (Txfname)
  603.       free(Txfname);
  604.    if (Rxfname)
  605.       free(Rxfname);
  606.    flag_file (CLEAR_FLAG, &called_addr, 1);
  607.    set_prior(4);          /* Always High                                     */
  608. }
  609.  
  610.  
  611.  
  612. /*****************************************************************************/
  613. /* Get name and info for next file to be transmitted, if any, and build      */
  614. /* FNAMEPKT.  Packet contents as per ZModem filename info packet, to allow     */
  615. /* use of same method of aborted-transfer recovery.  If there are no more     */
  616. /* files to be sent, build FNAMEPKT with null filename.  Also open file and  */
  617. /* set up for transmission.  Set Txfname, Txfile, Txlen.  Txbuf must not be  */
  618. /* modified until FNACKPKT is received.                                      */
  619. /*****************************************************************************/
  620. static void getfname(word xfer_flag) {
  621.    static byte floflag, bad_xfers, outboundname[PATHLEN];
  622.    static long floname_pos;
  623.    static FILE *flofile;
  624.    static int have_lock;
  625.    char *holdname;
  626.  
  627.    register char *p;
  628.    int i;
  629.    long curr_pos;
  630.    struct stat f;
  631.  
  632.    /*------------------------------------------------------------------------*/
  633.    /* Initialize static variables on first call of the batch                 */
  634.    /*------------------------------------------------------------------------*/
  635.    if (xfer_flag == INITIAL_XFER) {
  636.       floflag = outboundname[0] = '\0';
  637.       flofile = NULL;
  638.       have_lock = flag_file (TEST_AND_SET, &called_addr, 1);
  639.  
  640.    /*------------------------------------------------------------------------*/
  641.    /* If we were already sending a file, close it and clean up                 */
  642.    /*------------------------------------------------------------------------*/
  643.    } else if (Txfile != -1) {
  644.       errno = 0;
  645.       close(Txfile);
  646.       j_error(msgtxt[M_CLOSE_MSG],Txfname);
  647.       Txfile = -1;
  648.       /*---------------------------------------------------------------------*/
  649.       /* If xfer completed, do post-xfer cleanup                             */
  650.       /*---------------------------------------------------------------------*/
  651.       if (xfer_flag == GOOD_XFER) {
  652.          /*------------------------------------------------------------------*/
  653.          /* Perform post-xfer file massaging if neccessary                     */
  654.          /*------------------------------------------------------------------*/
  655.          switch (Do_after) {
  656.             case DELETE_AFTER:
  657.             case SHOW_DELETE_AFTER:
  658.                j_status(msgtxt[M_UNLINKING_MSG],Txfname);
  659.                unlink(Txfname);
  660.                j_error(msgtxt[M_UNLINK_MSG],Txfname);
  661.                break;
  662.             case TRUNC_AFTER:
  663.                j_status(msgtxt[M_TRUNC_MSG],Txfname);
  664.                Txfile = open(Txfname,O_TRUNC|O_RDWR,S_IREAD|S_IWRITE);
  665.                if (Txfile != -1)
  666.                   errno = 0;
  667.                j_error(msgtxt[M_TRUNC_MSG],Txfname);
  668.                close(Txfile);
  669.                Txfile = -1;
  670.          }
  671.          /*------------------------------------------------------------------*/
  672.          /* If processing .?LO file, flag filename as sent (name[0] = '~')   */
  673.          /*------------------------------------------------------------------*/
  674. skipname:
  675.          if (floflag) {
  676.             curr_pos = ftell(flofile);
  677.             j_error(msgtxt[M_SEEK_MSG],outboundname);
  678.             fseek(flofile,floname_pos,SEEK_SET);
  679.             j_error(msgtxt[M_SEEK_MSG],outboundname);
  680.             fputc(Txfname[0] = '~',flofile);
  681.             j_error(msgtxt[M_WRITE_MSG],outboundname);
  682.             fseek(flofile,curr_pos,SEEK_SET);
  683.             j_error(msgtxt[M_SEEK_MSG],outboundname);
  684.          }
  685.       } else {
  686. abort:
  687.          ++bad_xfers;
  688.       }
  689.    }
  690.  
  691.    /*------------------------------------------------------------------------*/
  692.    /* Find next file to be sent and build FNAMEPKT.  If reading .FLO-type     */
  693.    /* file get next entry from it; otherwise check for next .OUT/.FLO file     */
  694.    /*------------------------------------------------------------------------*/
  695.    if (have_lock)
  696.       goto end_send;
  697.  
  698.    holdname = HoldAreaNameMunge(&called_addr);
  699.    if (!floflag) {
  700.       /*---------------------------------------------------------------------*/
  701.       /* If first getfname() for this batch, init filename to .OUT             */
  702.       /*---------------------------------------------------------------------*/
  703.       if (!outboundname[0]) {
  704.          sprintf(outboundname,"%s%s.OUT",holdname,Hex_Addr_Str(&called_addr));
  705.          *ext_flags = 'O';
  706.       /*---------------------------------------------------------------------*/
  707.       /* Increment outbound filename until match found or all checked         */
  708.       /* .OUT->.DUT->.CUT->.HUT->.FLO->.DLO->.CLO->.HLO->null name             */
  709.       /*---------------------------------------------------------------------*/
  710.       } else {
  711. nxtout:
  712.          p = strchr(outboundname,'\0') - 3;
  713.          for (i = 0; i < NUM_FLAGS; ++i)
  714.             if (ext_flags[i] == *p)
  715.                break;
  716.          if (i < NUM_FLAGS - 1) {
  717.             *p = ext_flags[i+1];
  718. #ifndef JACK_DECKER
  719.             if (isOriginator && *p == 'H')
  720.                goto nxtout;
  721. #endif
  722.          } else {
  723.             /*---------------------------------------------------------------*/
  724.             /* Finished ?,D,C,H sequence; wrap .OUT->.FLO, or .FLO->done     */
  725.             /*---------------------------------------------------------------*/
  726.             if (!floflag) {
  727.                *p++ = *ext_flags = 'F';
  728.                *p++ = 'L';
  729.                *p = 'O';
  730.                ++floflag;
  731.             } else
  732. end_send:
  733.                outboundname[0] = Txfname[0] = Txbuf[0] = Txbuf[1] = floflag = '\0';
  734.          }
  735.       }
  736.       /*---------------------------------------------------------------------*/
  737.       /* Check potential outbound name; if file doesn't exist keep looking   */
  738.       /*---------------------------------------------------------------------*/
  739.       if (outboundname[0]) {
  740.          if (!dexists(outboundname))
  741.             goto nxtout;
  742.          if (floflag)
  743.             goto rdflo;
  744.          strcpy(Txfname,outboundname);
  745.          /*------------------------------------------------------------------*/
  746.          /* Start FNAMEPKT using .PKT alias                                  */
  747.          /*------------------------------------------------------------------*/
  748.          invent_pkt_name(Txbuf);
  749.          Do_after = DELETE_AFTER;
  750.       }
  751.    /*------------------------------------------------------------------------*/
  752.    /* Read and process next entry from .?LO-type file                         */
  753.    /*------------------------------------------------------------------------*/
  754.    } else {
  755. rdflo:
  756.       /*---------------------------------------------------------------------*/
  757.       /* Open .?LO file for processing if neccessary                         */
  758.       /*---------------------------------------------------------------------*/
  759.       if (!flofile) {
  760.          bad_xfers = 0;
  761.          errno = 0;
  762.          flofile = fopen(outboundname,"rb+");
  763.          if (j_error(msgtxt[M_OPEN_MSG],outboundname))
  764.             goto nxtout;
  765.       }
  766.       errno = 0;
  767.       floname_pos = ftell(flofile);
  768.       j_error(msgtxt[M_SEEK_MSG],outboundname);
  769.       if (fgets(p = Txfname, PATHLEN, flofile)) {
  770.          /*------------------------------------------------------------------*/
  771.          /* Got an attached file name; check for handling flags, fix up name */
  772.          /*------------------------------------------------------------------*/
  773.          while (*p > ' ')
  774.             ++p;
  775.          *p = '\0';
  776.          switch (Txfname[0]) {
  777.             case '\0':
  778.             case '~':
  779.             case ';':
  780.                goto rdflo;
  781.             case TRUNC_AFTER:
  782.             case DELETE_AFTER:
  783.             case SHOW_DELETE_AFTER:
  784.                Do_after = Txfname[0];
  785.                strcpy(Txfname,Txfname+1);
  786.                break;
  787.             default:
  788.                Do_after = NOTHING_AFTER;
  789.                break;
  790.          }
  791.          /*------------------------------------------------------------------*/
  792.          /* Start FNAMEPKT with simple filename                              */
  793.          /*------------------------------------------------------------------*/
  794.          while (p >= Txfname && *p != '\\' && *p != ':')
  795.             --p;
  796.          strcpy(Txbuf,++p);
  797.       } else {
  798.          /*------------------------------------------------------------------*/
  799.          /* Finished reading this .?LO file; clean up and look for another     */
  800.          /*------------------------------------------------------------------*/
  801.          errno = 0;
  802.          fclose(flofile);
  803.          j_error(msgtxt[M_CLOSE_MSG],outboundname);
  804.          flofile = NULL;
  805.          if (!bad_xfers) {
  806.             unlink(outboundname);
  807.             j_error(msgtxt[M_UNLINK_MSG],outboundname);
  808.          }
  809.          goto nxtout;
  810.       }
  811.    }
  812.  
  813.    /*------------------------------------------------------------------------*/
  814.    /* If we managed to find a valid file to transmit, open it, finish         */
  815.    /* FNAMEPKT, and print nice message for the sysop.                         */
  816.    /*------------------------------------------------------------------------*/
  817.    if (Txfname[0]) {
  818.       if (xfer_flag == ABORT_XFER)
  819.          goto abort;
  820.       j_status(msgtxt[M_SENDING],Txfname);
  821.       errno = 0;
  822.       Txfile = open(Txfname,O_RDONLY|O_BINARY);
  823.       if (Txfile != -1)
  824.          errno = 0;
  825.       if (j_error(msgtxt[M_OPEN_MSG],Txfname))
  826.          goto skipname;
  827.  
  828.       stat(Txfname,&f);
  829.       sprintf(strchr(Txbuf,'\0')+1,"%lu %lo %o",Txlen = f.st_size,f.st_mtime,f.st_mode);
  830.  
  831.       p = strchr(Txfname,'\0');
  832.       while (p >= Txfname && *p != ':' && *p != '\\')
  833.          --p;
  834.       if (!un_attended || !fullscreen)
  835.          Tx_y = Next_y;
  836.       else
  837.          Tx_y = 1;
  838.       xfer_summary(msgtxt[M_SEND],++p,&Txlen,Tx_y);
  839.  
  840.       time(&Txsttime);
  841.    }
  842. }
  843.  
  844.  
  845. /*****************************************************************************/
  846. /* Build and send a packet of any type.                                      */
  847. /* Packet structure is: PKTSTRT,contents,packet_type,PKTEND,crc              */
  848. /* CRC is computed from contents and packet_type only; if PKTSTRT or PKTEND  */
  849. /* get munged we'll never even find the CRC.                                 */
  850. /*****************************************************************************/
  851. static void sendpkt(register byte *buf,int len,int type) {
  852.    register word crc;
  853.  
  854.    if ((SharedCap & CANCRC32) && type != FNAMEPKT)
  855.       sendpkt32(buf,len,type);
  856.    else {
  857.       BUFFER_BYTE(DLE);
  858.       BUFFER_BYTE(PKTSTRTCHR ^ 0x40);
  859.  
  860.       crc = 0;
  861.       while (--len >= 0) {
  862.          txbyte(*buf);
  863.          crc = xcrc(crc, ((word)(*buf++)) );
  864.       }
  865.  
  866.       BUFFER_BYTE((byte)type);
  867.       crc = xcrc(crc,type);
  868.  
  869.       BUFFER_BYTE(DLE);
  870.       BUFFER_BYTE(PKTENDCHR ^ 0x40);
  871.  
  872.       txbyte((byte)(crc >> 8));
  873.       txbyte((byte)(crc & 0xFF));
  874.  
  875.       UNBUFFER_BYTES();
  876.    }
  877. }
  878.  
  879.  
  880. /*****************************************************************************/
  881. /* Build and send a packet using 32-bit CRC; same as sendpkt in other ways     */
  882. /*****************************************************************************/
  883. static void sendpkt32(register byte *buf,register int len,int type) {
  884.    unsigned long crc32;
  885.  
  886.    BUFFER_BYTE(DLE);
  887.    BUFFER_BYTE(PKTSTRTCHR32 ^ 0x40);
  888.  
  889.    crc32 = 0xFFFFFFFF;
  890.    while (--len >= 0) {
  891.       txbyte(*buf);
  892.       crc32 = Z_32UpdateCRC(((word)*buf),crc32);
  893.       ++buf;
  894.    }
  895.  
  896.    BUFFER_BYTE((byte)type);
  897.    crc32 = Z_32UpdateCRC(type,crc32);
  898.  
  899.    BUFFER_BYTE(DLE);
  900.    BUFFER_BYTE(PKTENDCHR ^ 0x40);
  901.  
  902.    txbyte((byte)(crc32 >> 24));
  903.    txbyte((byte)((crc32 >> 16) & 0xFF));
  904.    txbyte((byte)((crc32 >> 8) & 0xFF));
  905.    txbyte((byte)(crc32 & 0xFF));
  906.  
  907.    UNBUFFER_BYTES();
  908. }
  909.  
  910.  
  911.  
  912. /*****************************************************************************/
  913. /* Transmit cooked escaped byte(s) corresponding to raw input byte.  Escape  */
  914. /* DLE, XON, and XOFF using DLE prefix byte and ^ 0x40. Also escape          */
  915. /* CR-after-'@' to avoid Telenet/PC-Pursuit problems.                        */
  916. /*****************************************************************************/
  917. static void txbyte(register byte c) {
  918.    static byte lastsent;
  919.  
  920.    switch (c) {
  921.       case CR:
  922.          if (lastsent != '@')
  923.             goto sendit;
  924.          /* fallthrough */
  925.       case DLE:
  926.       case XON:
  927.       case XOFF:
  928.          BUFFER_BYTE(DLE);
  929.          c ^= 0x40;
  930.          /* fallthrough */
  931.       default:
  932. sendit:  BUFFER_BYTE(lastsent = c);
  933.    }
  934. }
  935.  
  936.  
  937. /*****************************************************************************/
  938. /* Process FNAMEPKT of file to be received.  Check for aborted-transfer      */
  939. /* recovery and solve filename collisions.      Check for enough disk space.     */
  940. /* Return initial file data position to start receiving at, or -1 if error     */
  941. /* detected to abort file reception.  Set Rxfname, Rxlen, Rxfile.             */
  942. /*****************************************************************************/
  943. static long procfname(void) {
  944.    register byte *p;
  945.    char linebuf[128], *fileinfo, *badfname;
  946.    long filestart, bytes;
  947.    FILE *abortlog;
  948.    struct stat f;
  949.    int i;
  950.  
  951.    /*------------------------------------------------------------------------*/
  952.    /* Initialize for file reception                                          */
  953.    /*------------------------------------------------------------------------*/
  954.    Rxfname[0] = Resume_WaZOO = 0;
  955.  
  956.    /*------------------------------------------------------------------------*/
  957.    /* Save info on WaZOO transfer in case of abort                             */
  958.    /*------------------------------------------------------------------------*/
  959.    strcpy(Resume_name,fancy_str(Rxbuf));
  960.    fileinfo = strchr(Rxbuf,'\0') + 1;
  961.    p = strchr(fileinfo,'\0') + 1;
  962.    SharedCap = (Rxblklen > p-Rxbuf) ? *p & OURCAP : 0;
  963.  
  964.    /*------------------------------------------------------------------------*/
  965.    /* If this is a null FNAMEPKT, return OK immediately                      */
  966.    /*------------------------------------------------------------------------*/
  967.    if (!Rxbuf[0])
  968.       return 0L;
  969.  
  970.    strcpy(linebuf,Rxbuf);
  971.    strlwr(linebuf);
  972.    p = check_netfile(linebuf);
  973.    j_status("#%s %s %s",msgtxt[M_RECEIVING],(p) ? p : " ",Rxbuf);
  974.  
  975.    /*------------------------------------------------------------------------*/
  976.    /* Extract and validate filesize                                          */
  977.    /*------------------------------------------------------------------------*/
  978.    Rxlen = -1;
  979.    Rxfiletime = 0;
  980.    if (sscanf(fileinfo,"%ld %lo",&Rxlen,&Rxfiletime) < 1 || Rxlen < 0) {
  981.       j_status(msgtxt[M_NO_LENGTH]);
  982.       return -1L;
  983.    }
  984.    sprintf(Resume_info,"%ld %lo",Rxlen,Rxfiletime);
  985.  
  986.    /*------------------------------------------------------------------------*/
  987.    /* Check if this is a failed WaZOO transfer which should be resumed         */
  988.    /*------------------------------------------------------------------------*/
  989.    if (dexists(Abortlog_name)) {
  990.       errno = 0;
  991.       abortlog = fopen(Abortlog_name,read_ascii);
  992.       if (!j_error(msgtxt[M_OPEN_MSG],Abortlog_name)) {
  993.          while (!feof(abortlog)) {
  994.             linebuf[0] = '\0';
  995.             if (!fgets(p = linebuf,sizeof(linebuf),abortlog))
  996.                break;
  997.             while (*p >= ' ')
  998.                ++p;
  999.             *p = '\0';
  1000.             p = strchr(linebuf,' ');
  1001.             *p = '\0';
  1002.             if (!stricmp(linebuf,Resume_name)) {
  1003.                p = strchr( (badfname = ++p), ' ');
  1004.                *p = '\0';
  1005.                if (!stricmp(++p,Resume_info)) {
  1006.                   ++Resume_WaZOO;
  1007.                   break;
  1008.                }
  1009.             }
  1010.          }
  1011.          errno = 0;
  1012.          fclose(abortlog);
  1013.          j_error(msgtxt[M_CLOSE_MSG],Abortlog_name);
  1014.       }
  1015.    }
  1016.  
  1017.    /*------------------------------------------------------------------------*/
  1018.    /* Open either the old or a new file, as appropriate                      */
  1019.    /*------------------------------------------------------------------------*/
  1020.    p = strchr(strcpy(Rxfname,CurrentNetFiles),'\0');
  1021.    errno = 0;
  1022.    if (Resume_WaZOO) {
  1023.       strcpy(p,badfname);
  1024.       Rxfile = open(Rxfname,O_CREAT|O_RDWR|O_BINARY,S_IREAD|S_IWRITE);
  1025.    } else {
  1026.       strcpy(p,Rxbuf);
  1027.       /*---------------------------------------------------------------------*/
  1028.       /* If the file already exists:                                         */
  1029.       /* 1) And the new file has the same time and size, skip it             */
  1030.       /* 2) And OVERWRITE is turned on, delete the old copy                  */
  1031.       /* 3) Else create a unique file name in which to store new data         */
  1032.       /*---------------------------------------------------------------------*/
  1033.       if (dexists(Rxfname)) {
  1034.          stat(Rxfname,&f);
  1035.          if (Rxlen == f.st_size && Rxfiletime == f.st_mtime) {
  1036.             j_status(msgtxt[M_ALREADY_HAVE],Rxfname);
  1037.             return -1L;
  1038.          }
  1039.          i = strlen(Rxfname) - 1;
  1040.          if ((!overwrite) || (is_arcmail(Rxfname,i))) {
  1041.             unique_name(Rxfname);
  1042.             j_status(msgtxt[M_RENAME_MSG],Rxfname);
  1043.          } else {
  1044.             unlink(Rxfname);
  1045.             j_error(msgtxt[M_UNLINK_MSG],Rxfname);
  1046.          }
  1047.       }
  1048.       Rxfile = open(Rxfname,O_CREAT|O_EXCL|O_RDWR|O_BINARY,S_IREAD|S_IWRITE);
  1049.    }
  1050.    if (Rxfile != -1)
  1051.       errno = 0;
  1052.    if (j_error(msgtxt[M_OPEN_MSG],Rxfname))
  1053.       return -1L;
  1054.  
  1055.    /*------------------------------------------------------------------------*/
  1056.    /* Determine initial file data position                                     */
  1057.    /*------------------------------------------------------------------------*/
  1058.    if (Resume_WaZOO) {
  1059.       stat(Rxfname,&f);
  1060.       j_status(msgtxt[M_SYNCHRONIZING_OFFSET],filestart = f.st_size);
  1061.       p = Rxbuf;
  1062.       errno = 0;
  1063.       lseek(Rxfile,filestart,SEEK_SET);
  1064.       if (j_error(msgtxt[M_SEEK_MSG],Rxfname)) {
  1065.          close(Rxfile);
  1066.          return -1L;
  1067.       }
  1068.    } else
  1069.       filestart = 0L;
  1070.  
  1071.    /*------------------------------------------------------------------------*/
  1072.    /* Check for enough disk space                                             */
  1073.    /*------------------------------------------------------------------------*/
  1074.    bytes = Rxlen - filestart + 10240;
  1075.    if (bytes > Diskavail) {
  1076.       j_status(msgtxt[M_OUT_OF_DISK_SPACE]);
  1077.       close(Rxfile);
  1078.       return -1L;
  1079.    }
  1080.  
  1081.    /*------------------------------------------------------------------------*/
  1082.    /* Print status message for the sysop                                     */
  1083.    /*------------------------------------------------------------------------*/
  1084.    if (!un_attended || !fullscreen)
  1085.       Rx_y = Next_y;
  1086.    else
  1087.       Rx_y = 2;
  1088.    xfer_summary(msgtxt[M_RECV],p,&Rxlen,Rx_y);
  1089.  
  1090.    time(&Rxsttime);
  1091.  
  1092.    return filestart;
  1093. }
  1094.  
  1095.  
  1096. /*****************************************************************************/
  1097. /* Receive, validate, and extract a packet if available.  If a complete      */
  1098. /* packet hasn't been received yet, receive and store as much of the next    */
  1099. /* packet as possible.      Each call to rcvpkt() will continue accumulating a */
  1100. /* packet until a complete packet has been received or an error is detected. */
  1101. /* Rxbuf must not be modified between calls to rcvpkt() if NOPKT is returned.*/
  1102. /* Returns type of packet received, NOPKT, or BADPKT.  Sets Rxblklen.         */
  1103. /*****************************************************************************/
  1104. static byte rcvpkt() {
  1105.    static byte rxcrc32;
  1106.    static word crc;
  1107.    static unsigned long crc32;
  1108.    register byte *p;
  1109.    register int c;
  1110.    int i;
  1111.    unsigned long pktcrc;
  1112.  
  1113.    /*------------------------------------------------------------------------*/
  1114.    /* Abort transfer if operator pressed ESC                                 */
  1115.    /*------------------------------------------------------------------------*/
  1116.  
  1117.    if (got_ESC()) {
  1118.       j_status(GenericError,msgtxt[M_KBD_MSG]);
  1119.       return HALTPKT;
  1120.    }
  1121.  
  1122.    /*------------------------------------------------------------------------*/
  1123.    /* If not accumulating packet yet, find start of next packet              */
  1124.    /*------------------------------------------------------------------------*/
  1125.    WaitFlag = FALSE;
  1126.    if (!(p = Rxbufptr)) {
  1127.       do
  1128.          c = rxbyte();
  1129.       while (c >= 0 || c == PKTEND);
  1130.  
  1131.       switch (c) {
  1132.          case PKTSTRT:
  1133.             rxcrc32 = FALSE;
  1134.             p = Rxbuf;
  1135.             crc = 0;
  1136.             break;
  1137.          case PKTSTRT32:
  1138.             rxcrc32 = TRUE;
  1139.             p = Rxbuf;
  1140.             crc32 = 0xFFFFFFFF;
  1141.             break;
  1142.          case NOCARRIER:
  1143.             j_status(GenericError,&(msgtxt[M_NO_CARRIER][1]));
  1144.             return HALTPKT;
  1145.          default:
  1146.             return NOPKT;
  1147.       }
  1148.    }
  1149.  
  1150.    /*------------------------------------------------------------------------*/
  1151.    /* Accumulate packet data until we empty buffer or find packet delimiter  */
  1152.    /*------------------------------------------------------------------------*/
  1153.    if (rxcrc32) {
  1154.       while ((c = rxbyte()) >= 0 && p < Rxbufmax) {
  1155.          *p++ = (byte)c;
  1156.          crc32 = Z_32UpdateCRC(c,crc32);
  1157.       }
  1158.    } else {
  1159.       while ((c = rxbyte()) >= 0 && p < Rxbufmax) {
  1160.          *p++ = (byte)c;
  1161.          crc = xcrc(crc,c);
  1162.       }
  1163.    }
  1164.  
  1165.    /*------------------------------------------------------------------------*/
  1166.    /* Handle whichever end-of-packet condition occurred                      */
  1167.    /*------------------------------------------------------------------------*/
  1168.    switch (c) {
  1169.       /*---------------------------------------------------------------------*/
  1170.       /* PKTEND found; verify valid CRC                                      */
  1171.       /*---------------------------------------------------------------------*/
  1172.       case PKTEND:
  1173.          WaitFlag = TRUE;
  1174.          pktcrc = 0;
  1175.          for (i = (rxcrc32) ? 4 : 2; i; --i) {
  1176.             if ((c = rxbyte()) < 0)
  1177.                break;
  1178.             pktcrc = (pktcrc << 8) | c;
  1179.          }
  1180.          if (!i) {
  1181.             if ((rxcrc32 && pktcrc == crc32) || pktcrc == crc) {
  1182.                /*------------------------------------------------------------*/
  1183.                /* Good packet verified; compute packet data length and         */
  1184.                /* return packet type                                         */
  1185.                /*------------------------------------------------------------*/
  1186.                Rxbufptr = NULL;
  1187.                Rxblklen = --p - Rxbuf;
  1188.                return *p;
  1189.             }
  1190.          }
  1191.          /* fallthrough */
  1192.  
  1193.       /*---------------------------------------------------------------------*/
  1194.       /* Bad CRC, carrier lost, or buffer overflow from munged PKTEND         */
  1195.       /*---------------------------------------------------------------------*/
  1196.       default:
  1197.          if (c == NOCARRIER) {
  1198.             j_status(GenericError,&(msgtxt[M_NO_CARRIER][1]));
  1199.             return HALTPKT;
  1200.          } else {
  1201.             Rxbufptr = NULL;
  1202.             return BADPKT;
  1203.          }
  1204.  
  1205.       /*---------------------------------------------------------------------*/
  1206.       /* Emptied buffer; save partial packet and let sender do something     */
  1207.       /*---------------------------------------------------------------------*/
  1208.       case BUFEMPTY:
  1209.          Rxbufptr = p;
  1210.          return NOPKT;
  1211.  
  1212.       /*---------------------------------------------------------------------*/
  1213.       /* PKTEND was trashed; discard partial packet and prep for next one     */
  1214.       /*---------------------------------------------------------------------*/
  1215.       case PKTSTRT:
  1216.          rxcrc32 = FALSE;
  1217.          Rxbufptr = Rxbuf;
  1218.          crc = 0;
  1219.          return BADPKT;
  1220.  
  1221.       case PKTSTRT32:
  1222.          rxcrc32 = TRUE;
  1223.          Rxbufptr = Rxbuf;
  1224.          crc32 = 0xFFFFFFFF;
  1225.          return BADPKT;
  1226.    }
  1227. }
  1228.  
  1229.  
  1230.  
  1231. /*****************************************************************************/
  1232. /* Close file being received and perform post-reception aborted-transfer     */
  1233. /* recovery cleanup if neccessary.                                             */
  1234. /*****************************************************************************/
  1235. static void rxclose(word xfer_flag) {
  1236.    register byte *p;
  1237.    byte namebuf[PATHLEN], linebuf[128], c;
  1238.    FILE *abortlog, *newlog;
  1239.    struct utimbuf utimes;
  1240.  
  1241.    /*------------------------------------------------------------------------*/
  1242.    /* Close file we've been receiving                                        */
  1243.    /*------------------------------------------------------------------------*/
  1244.    errno = 0;
  1245.    close(Rxfile);
  1246.    j_error(msgtxt[M_CLOSE_MSG],Rxfname);
  1247.    if (Rxfiletime) {
  1248.       utimes.actime = Rxfiletime;
  1249.       utimes.modtime = Rxfiletime;
  1250.       utime(Rxfname,&utimes);
  1251.    }
  1252.  
  1253.    /*------------------------------------------------------------------------*/
  1254.    /* If we completed a previously-aborted transfer, kill log entry & rename */
  1255.    /*------------------------------------------------------------------------*/
  1256.    if (xfer_flag == GOOD_XFER && Resume_WaZOO) {
  1257.       abortlog = fopen(Abortlog_name,read_ascii);
  1258.       if (!j_error(msgtxt[M_OPEN_MSG],Abortlog_name)) {
  1259.          c = 0;
  1260.          strcpy(strchr(strcpy(namebuf,Abortlog_name),'\0')-1,"TMP");
  1261.          newlog = fopen(namebuf,write_ascii);
  1262.          if (!j_error(msgtxt[M_OPEN_MSG],namebuf)) {
  1263.             while (!feof(abortlog)) {
  1264.                linebuf[0] = '\0';
  1265.                if (!fgets(p = linebuf,sizeof(linebuf),abortlog))
  1266.                   break;
  1267.                while (*p > ' ')
  1268.                   ++p;
  1269.                *p = '\0';
  1270.                if (stricmp(linebuf,Resume_name)) {
  1271.                   *p = ' ';
  1272.                   fputs(linebuf,newlog);
  1273.                   if (j_error(msgtxt[M_WRITE_MSG],namebuf))
  1274.                      break;
  1275.                   ++c;
  1276.                }
  1277.             }
  1278.             errno = 0;
  1279.             fclose(abortlog);
  1280.             j_error(msgtxt[M_CLOSE_MSG],Abortlog_name);
  1281.             fclose(newlog);
  1282.             j_error(msgtxt[M_CLOSE_MSG],namebuf);
  1283.             unlink(Abortlog_name);
  1284.             j_error(msgtxt[M_UNLINK_MSG],Abortlog_name);
  1285.             if (c) {
  1286.                if (!rename(namebuf,Abortlog_name))
  1287.                   errno = 0;
  1288.                j_error(msgtxt[M_RENAME_MSG],namebuf);
  1289.             } else {
  1290.                unlink(namebuf);
  1291.                j_error(msgtxt[M_UNLINK_MSG],namebuf);
  1292.             }
  1293.          } else {
  1294.             fclose(abortlog);
  1295.             j_error(msgtxt[M_CLOSE_MSG],Abortlog_name);
  1296.          }
  1297.       }
  1298.       j_status(msgtxt[M_FINISHED_PART],Resume_name);
  1299.       unique_name(strcat(strcpy(namebuf,CurrentNetFiles),Resume_name));
  1300.       if (!rename(Rxfname,namebuf)) {
  1301.          errno = 0;
  1302.          strcpy(Rxfname,namebuf);
  1303.       } else
  1304.          j_error(msgtxt[M_RENAME_MSG],Rxfname);
  1305.    /*------------------------------------------------------------------------*/
  1306.    /* If transfer failed and was not an attempted resumption, log for later  */
  1307.    /*------------------------------------------------------------------------*/
  1308.    } else if (xfer_flag == FAILED_XFER && !Resume_WaZOO) {
  1309.       j_status(msgtxt[M_SAVING_PART],Rxfname);
  1310.       unique_name(strcat(strcpy(namebuf,CurrentNetFiles),"BadWaZOO.001"));
  1311.       if (!rename(Rxfname,namebuf))
  1312.          errno = 0;
  1313.       j_error(msgtxt[M_RENAME_MSG],Rxfname);
  1314.  
  1315.       abortlog = fopen(Abortlog_name,"at");
  1316.       if (!j_error(msgtxt[M_OPEN_MSG],Abortlog_name)) {
  1317.          fprintf(abortlog,"%s %s %s\n",Resume_name,namebuf+strlen(CurrentNetFiles),Resume_info);
  1318.          j_error(msgtxt[M_WRITE_MSG],Abortlog_name);
  1319.          fclose(abortlog);
  1320.          j_error(msgtxt[M_CLOSE_MSG],Abortlog_name);
  1321.       } else {
  1322.          unlink(namebuf);
  1323.          j_error(msgtxt[M_UNLINK_MSG],namebuf);
  1324.       }
  1325.    }
  1326. }
  1327.  
  1328.  
  1329. /*****************************************************************************/
  1330. /* Try REAL HARD to disengage batch session cleanly                          */
  1331. /*****************************************************************************/
  1332. static void endbatch(void) {
  1333.    register int done, timeouts;
  1334.    long timeval, brain_dead;
  1335.  
  1336.    /*------------------------------------------------------------------------*/
  1337.    /* Tell the other end to halt if it hasn't already                        */
  1338.    /*------------------------------------------------------------------------*/
  1339.    done = timeouts = 0;
  1340.    long_set_timer(&brain_dead,120);
  1341.    goto reject;
  1342.  
  1343.    /*------------------------------------------------------------------------*/
  1344.    /* Wait for the other end to acknowledge that it's halting                */
  1345.    /*------------------------------------------------------------------------*/
  1346.    while (!done) {
  1347.       if (long_time_gone(&brain_dead))
  1348.          break;
  1349.  
  1350.       switch (rcvpkt()) {
  1351.          case NOPKT:
  1352.          case BADPKT:
  1353.             if (long_time_gone(&timeval)) {
  1354.                if (++timeouts > 2)
  1355.                   ++done;
  1356.                else
  1357.                   goto reject;
  1358.             }
  1359.             break;
  1360.  
  1361.          case HALTPKT:
  1362.          case HALTACKPKT:
  1363.             ++done;
  1364.             break;
  1365.  
  1366.          default:
  1367.             timeouts = 0;
  1368. reject:     sendpkt(NULL,0,HALTPKT);
  1369.             long_set_timer(&timeval,TimeoutSecs);
  1370.             break;
  1371.       }
  1372.    }
  1373.  
  1374.    /*------------------------------------------------------------------------*/
  1375.    /* Announce quite insistently that we're done now                         */
  1376.    /*------------------------------------------------------------------------*/
  1377.    for (done = 0; done < 10; ++done)
  1378.       sendpkt(NULL,0,HALTACKPKT);
  1379.  
  1380.    wait_for_clear();
  1381. }
  1382.  
  1383.  
  1384. /*****************************************************************************/
  1385. /* Print a message in the message field of a transfer status line             */
  1386. /*****************************************************************************/
  1387. static void j_message(word pos,char *va_alist,...)
  1388. {
  1389.    va_list arg_ptr;
  1390.    int y, l;
  1391.  
  1392.    char buf[128];
  1393.    y = pos;
  1394.    va_start(arg_ptr, va_alist);
  1395.  
  1396.    if (!un_attended || !fullscreen)
  1397.       gotoxy(MSG_X,y);
  1398.    else
  1399.       sb_move(filewin,y,MSG_X);
  1400.  
  1401.  
  1402.    (void) vsprintf(buf,va_alist,arg_ptr);
  1403.  
  1404.    for (l = 25-strlen(buf); l > 0; --l)
  1405.       strcat(buf," ");
  1406.  
  1407.    if (!un_attended || !fullscreen) {
  1408.       cputs(buf);
  1409.    } else {
  1410.       sb_puts(filewin,buf);
  1411.       sb_show();
  1412.    }
  1413.  
  1414.    va_end(arg_ptr);
  1415. }
  1416.  
  1417.  
  1418. /*****************************************************************************/
  1419. /* Print & log status message without messing up display                     */
  1420. /*****************************************************************************/
  1421. static void j_status(char *va_alist,...)
  1422. {
  1423.    va_list arg_ptr;
  1424.  
  1425.    char buf[128];
  1426.    va_start(arg_ptr, va_alist);
  1427.  
  1428.    if (!un_attended || !fullscreen)
  1429.       gotoxy(1,Next_y-1);
  1430.  
  1431.    (void) vsprintf(buf,va_alist,arg_ptr);
  1432.  
  1433.    status_line(buf);
  1434.  
  1435.    if (!un_attended || !fullscreen)
  1436.       update_y();
  1437.  
  1438.    va_end(arg_ptr);
  1439. }
  1440.  
  1441.  
  1442. /*****************************************************************************/
  1443. /* Print & log error message without messing up display                      */
  1444. /*****************************************************************************/
  1445. static int j_error(byte *msg,byte *fname) {
  1446.    register int e;
  1447.  
  1448.    if (e = errno) {
  1449.       if (!un_attended || !fullscreen)
  1450.          gotoxy(1,Next_y-1);
  1451.  
  1452.       got_error(msg,fname);
  1453.  
  1454.       if (!un_attended || !fullscreen)
  1455.          update_y();
  1456.    }
  1457.    return e;
  1458. }
  1459.  
  1460.  
  1461. /*****************************************************************************/
  1462. /* Update screen position variables after printing a message                 */
  1463. /*****************************************************************************/
  1464. static void update_y() {
  1465.    set_xy(NULL);               /* Bump cursor to next line after printing     */
  1466.    if (locate_y == Next_y) {   /* If we didn't go anywhere, screen scrolled; */
  1467.       if (Tx_y > 1)            /* so decrement status line numbers             */
  1468.          --Tx_y;
  1469.       if (Rx_y > 1)
  1470.          --Rx_y;
  1471.    } else Next_y = locate_y;
  1472. }
  1473.  
  1474.  
  1475. /*****************************************************************************/
  1476. /* Compute future timehack for later reference                                 */
  1477. /*****************************************************************************/
  1478. static void long_set_timer(long *Buffer,word Duration) {
  1479.    time(Buffer);
  1480.    *Buffer += (long)Duration;
  1481. }
  1482.  
  1483.  
  1484. /*****************************************************************************/
  1485. /* Return TRUE if timehack has been passed, FALSE if not                     */
  1486. /*****************************************************************************/
  1487. static int long_time_gone(long *TimePtr) {
  1488.    return (time(NULL) > *TimePtr);
  1489. }
  1490.  
  1491.  
  1492. /*****************************************************************************/
  1493. /* Receive cooked escaped byte translated to avoid various problems.         */
  1494. /* Returns raw byte, BUFEMPTY, PKTSTRT, PKTEND, or NOCARRIER.                 */
  1495. /*****************************************************************************/
  1496. static int rxbyte(void) {
  1497.    register int c, w;
  1498.  
  1499.    if ((c = rcvrawbyte()) == DLE) {
  1500.       w = WaitFlag++;
  1501.       if ((c = rcvrawbyte()) >= 0) {
  1502.          switch (c ^= 0x40) {
  1503.             case PKTSTRTCHR:
  1504.                c = PKTSTRT;
  1505.                break;
  1506.             case PKTSTRTCHR32:
  1507.                c = PKTSTRT32;
  1508.                break;
  1509.             case PKTENDCHR:
  1510.                c = PKTEND;
  1511.                break;
  1512.          }
  1513.       }
  1514.       WaitFlag = (byte)w;
  1515.    }
  1516.    return c;
  1517. }
  1518.  
  1519.  
  1520. /*****************************************************************************/
  1521. /* Receive raw non-escaped byte.  Returns byte, BUFEMPTY, or NOCARRIER.      */
  1522. /* If waitflag is true, will wait for a byte for Timeoutsecs; otherwise      */
  1523. /* will return BUFEMPTY if a byte isn't ready and waiting in inbound buffer. */
  1524. /*****************************************************************************/
  1525. static int rcvrawbyte(void) {
  1526.    register int c;
  1527.    long timeval;
  1528.  
  1529.    if ((c = PEEKBYTE()) >= 0)
  1530.       return MODEM_IN();
  1531.  
  1532.    if (!CARRIER)
  1533.       return NOCARRIER;
  1534.    if (!WaitFlag)
  1535.       return BUFEMPTY;
  1536.  
  1537.    timeval = time(NULL) + TimeoutSecs;
  1538.  
  1539.    while ((c = PEEKBYTE()) < 0) {
  1540.       if (!CARRIER)
  1541.          return NOCARRIER;
  1542.       if (time(NULL) > timeval)
  1543.          return BUFEMPTY;
  1544.       time_release();
  1545.    }
  1546.  
  1547.    return MODEM_IN();
  1548. }
  1549.  
  1550.  
  1551. /*****************************************************************************/
  1552. /* Display start-of-transfer summary info                                     */
  1553. /*****************************************************************************/
  1554. static void xfer_summary(char *xfertype,char *fname,long *len,int y) {
  1555.    char buf[128];
  1556.  
  1557.    if (!un_attended || !fullscreen)
  1558.       gotoxy(2,y);
  1559.    else
  1560.       sb_move(filewin,y,2);
  1561.  
  1562.    sprintf(buf,"%s %12.12s;        0/%8ldb,%4d min.                       ",
  1563.       xfertype, fname, *len, (int)((*len*10/cur_baud*100/JANUS_EFFICIENCY+59)/60));
  1564.  
  1565.    if (!un_attended || !fullscreen) {
  1566.       cputs(buf);
  1567.       cputs(local_CEOL);
  1568.       update_y();
  1569.    } else {
  1570.       sb_puts(filewin,buf);
  1571.       sb_show();
  1572.    }
  1573. }
  1574.  
  1575.  
  1576. /*****************************************************************************/
  1577. /* Update any status line values which have changed                          */
  1578. /*****************************************************************************/
  1579. static void update_status(long *pos,long *oldpos,long left,int *oldeta,int y) {
  1580.   char buf[16];
  1581.   register int eta;
  1582.  
  1583.   elapse_time();
  1584.  
  1585.   if (*pos != *oldpos) {
  1586.      sprintf(buf,"%8ld",*oldpos = *pos);
  1587.      if (!un_attended || !fullscreen) {
  1588.         gotoxy(POS_X,y);
  1589.         cputs(buf);
  1590.      } else {
  1591.         sb_move(filewin,y,POS_X);
  1592.         sb_puts(filewin,buf);
  1593.      }
  1594.   }
  1595.  
  1596.   eta = (int)((left*10/cur_baud*100/JANUS_EFFICIENCY+59)/60);
  1597.   if (eta != *oldeta) {
  1598.      sprintf(buf,"%4d",*oldeta = eta);
  1599.      if (!un_attended || !fullscreen) {
  1600.         gotoxy(ETA_X,y);
  1601.         cputs(buf);
  1602.      } else {
  1603.         sb_move(filewin,y,ETA_X);
  1604.         sb_puts(filewin,buf);
  1605.      }
  1606.   }
  1607.  
  1608.   if (un_attended && fullscreen)
  1609.      sb_show();
  1610. }
  1611.  
  1612. /*****************************************************************************/
  1613. /* Compute and print throughput                                              */
  1614. /*****************************************************************************/
  1615. static void through(long *bytes,long *started) {
  1616.    static byte *scrn = "+CPS: %u (%lu bytes)  Efficiency: %lu%%%%";
  1617.    unsigned long elapsed;
  1618.    register word cps;
  1619.  
  1620.    elapsed = time(NULL) - *started;
  1621.    cps = (elapsed) ? (word)(*bytes/elapsed) : 0;
  1622.    j_status(scrn, cps, *bytes, cps*1000L/cur_baud);
  1623.    TotalBytes += *bytes;
  1624. }
  1625.  
  1626.  
  1627. /*****************************************************************************/
  1628. /* Get next file to request, if any                                          */
  1629. /*****************************************************************************/
  1630. static int get_filereq(byte req_started) {
  1631.    byte reqname[PATHLEN], linebuf[128];
  1632.    register byte *p;
  1633.    int gotone = FALSE;
  1634.    FILE *reqfile;
  1635.  
  1636.    if (flag_file (TEST_AND_SET, &called_addr, 1))
  1637.       return FALSE;
  1638.  
  1639.    strcpy(reqname,Abortlog_name);
  1640.    strcpy(strchr(reqname,'Z'),"REQ");
  1641.  
  1642.    if (req_started)
  1643.       mark_done(reqname);
  1644.  
  1645.    if (dexists(reqname)) {
  1646.       if (!(remote_capabilities & WZ_FREQ))
  1647.          j_status(msgtxt[M_FREQ_DECLINED]);
  1648.       else if (!(SharedCap & CANFREQ))
  1649.          j_status(msgtxt[M_REMOTE_CANT_FREQ]);
  1650.       else {
  1651.          errno = 0;
  1652.          reqfile = fopen(reqname,read_ascii);
  1653.          if (!j_error(msgtxt[M_OPEN_MSG],reqname)) {
  1654.             while (!feof(reqfile)) {
  1655.                linebuf[0] = '\0';
  1656.                if (!fgets(p = linebuf,sizeof(linebuf),reqfile))
  1657.                   break;
  1658.                while (*p >= ' ')
  1659.                   ++p;
  1660.                *p = '\0';
  1661.                if (linebuf[0] != ';') {
  1662.                   strcpy(Rxbuf,linebuf);
  1663.                   *(strchr(Rxbuf,'\0')+1) = SharedCap;
  1664.                   gotone = TRUE;
  1665.                   break;
  1666.                }
  1667.             }
  1668.             fclose(reqfile);
  1669.             j_error(msgtxt[M_CLOSE_MSG],reqname);
  1670.             if (!gotone) {
  1671.                unlink(reqname);
  1672.                j_error(msgtxt[M_UNLINK_MSG],reqname);
  1673.             }
  1674.          }
  1675.       }
  1676.    }
  1677.  
  1678.    return gotone;
  1679. }
  1680.  
  1681.  
  1682. /*****************************************************************************/
  1683. /* Record names of files to send in response to file request; callback         */
  1684. /* routine for respond_to_file_requests()                                     */
  1685. /*****************************************************************************/
  1686. static int record_reqfile(char *fname) {
  1687.    FILE *tmpfile;
  1688.  
  1689.    errno = 0;
  1690.    tmpfile = fopen(ReqTmp,"at");
  1691.    if (!j_error(msgtxt[M_OPEN_MSG],ReqTmp)) {
  1692.       fputs(fname,tmpfile);
  1693.       j_error(msgtxt[M_WRITE_MSG],ReqTmp);
  1694.       fputs("\n",tmpfile);
  1695.       j_error(msgtxt[M_WRITE_MSG],ReqTmp);
  1696.       fclose(tmpfile);
  1697.       j_error(msgtxt[M_CLOSE_MSG],ReqTmp);
  1698.       ++ReqRecorded;
  1699.       return TRUE;
  1700.    }
  1701.    return FALSE;
  1702. }
  1703.  
  1704.  
  1705. /*****************************************************************************/
  1706. /* Get next file which was requested, if any                                 */
  1707. /*****************************************************************************/
  1708. static byte get_reqname(byte first_req) {
  1709.    register byte *p;
  1710.    byte gotone = FALSE;
  1711.    FILE *tmpfile;
  1712.    struct stat f;
  1713.  
  1714.    if (!first_req) {
  1715.       errno = 0;
  1716.       close(Txfile);
  1717.       j_error(msgtxt[M_CLOSE_MSG],Txfname);
  1718.       Txfile = -1;
  1719.       mark_done(ReqTmp);
  1720.    }
  1721.  
  1722.    if (dexists(ReqTmp)) {
  1723.       errno = 0;
  1724.       tmpfile = fopen(ReqTmp,read_ascii);
  1725.       if (!j_error(msgtxt[M_OPEN_MSG],ReqTmp)) {
  1726.          while (!feof(tmpfile)) {
  1727.             Txfname[0] = '\0';
  1728.             if (!fgets(p = Txfname,PATHLEN,tmpfile))
  1729.                break;
  1730.             while (*p >= ' ')
  1731.                ++p;
  1732.             *p = '\0';
  1733.             if (Txfname[0] != ';') {
  1734.                j_status(msgtxt[M_SENDING],Txfname);
  1735.                errno = 0;
  1736.                Txfile = open(Txfname,O_RDONLY|O_BINARY);
  1737.                if (Txfile != -1)
  1738.                   errno = 0;
  1739.                if (j_error(msgtxt[M_OPEN_MSG],Txfname))
  1740.                   continue;
  1741.                while (p >= Txfname && *p != '\\' && *p != ':')
  1742.                   --p;
  1743.                strcpy(Txbuf,++p);
  1744.                stat(Txfname,&f);
  1745.                sprintf(strchr(Txbuf,'\0')+1,"%lu %lo %o",Txlen = f.st_size,f.st_mtime,f.st_mode);
  1746.                if (!un_attended || !fullscreen)
  1747.                   Tx_y = Next_y;
  1748.                else
  1749.                   Tx_y = 1;
  1750.                xfer_summary(msgtxt[M_SEND],p,&Txlen,Tx_y);
  1751.                time(&Txsttime);
  1752.                gotone = TRUE;
  1753.                break;
  1754.             }
  1755.          }
  1756.          fclose(tmpfile);
  1757.          j_error(msgtxt[M_CLOSE_MSG],ReqTmp);
  1758.          if (!gotone) {
  1759.             unlink(ReqTmp);
  1760.             j_error(msgtxt[M_UNLINK_MSG],ReqTmp);
  1761.          }
  1762.       }
  1763.    }
  1764.  
  1765.    return gotone;
  1766. }
  1767.  
  1768.  
  1769. /*****************************************************************************/
  1770. /* Mark first unmarked line of file as done (comment it out)                 */
  1771. /*****************************************************************************/
  1772. static void mark_done(char *fname) {
  1773.    byte linebuf[128];
  1774.    FILE *fh;
  1775.    long pos;
  1776.  
  1777.    if (dexists(fname)) {
  1778.       errno = 0;
  1779.       fh = fopen(fname,"rb+");
  1780.       if (!j_error(msgtxt[M_OPEN_MSG],fname)) {
  1781.          while (!feof(fh)) {
  1782.             pos = ftell(fh);
  1783.             j_error(msgtxt[M_SEEK_MSG],fname);
  1784.             if (!fgets(linebuf,sizeof(linebuf),fh))
  1785.                break;
  1786.             if (linebuf[0] != ';') {
  1787.                fseek(fh,pos,SEEK_SET);
  1788.                j_error(msgtxt[M_SEEK_MSG],fname);
  1789.                fputc(';',fh);
  1790.                j_error(msgtxt[M_WRITE_MSG],fname);
  1791.                break;
  1792.             }
  1793.          }
  1794.          fclose(fh);
  1795.          j_error(msgtxt[M_CLOSE_MSG],fname);
  1796.       }
  1797.    }
  1798. }
  1799.