home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / BBS / MISC / BSRC_250.ZIP / XMSEND.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-15  |  21.9 KB  |  818 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-91, Bit Bucket Software Co., a Delaware Corporation. */
  11. /*                                                                          */
  12. /*                                                                          */
  13. /*                  This module was written by Bob Hartman                  */
  14. /*                                                                          */
  15. /*                                                                          */
  16. /*                 BinkleyTerm Xmodem Sender State Machine                  */
  17. /*                                                                          */
  18. /*                                                                          */
  19. /*    For complete  details  of the licensing restrictions, please refer    */
  20. /*    to the License  agreement,  which  is published in its entirety in    */
  21. /*    the MAKEFILE and BT.C, and also contained in the file LICENSE.250.    */
  22. /*                                                                          */
  23. /*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  24. /*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  25. /*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
  26. /*    NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
  27. /*    SOFTWARE CO.  AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
  28. /*    SHOULD YOU  PROCEED TO USE THIS FILE  WITHOUT HAVING  ACCEPTED THE    */
  29. /*    TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
  30. /*    AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.      */
  31. /*                                                                          */
  32. /*                                                                          */
  33. /* You can contact Bit Bucket Software Co. at any one of the following      */
  34. /* addresses:                                                               */
  35. /*                                                                          */
  36. /* Bit Bucket Software Co.        FidoNet  1:104/501, 1:343/491             */
  37. /* P.O. Box 460398                AlterNet 7:491/0                          */
  38. /* Aurora, CO 80046               BBS-Net  86:2030/1                        */
  39. /*                                Internet f491.n343.z1.fidonet.org         */
  40. /*                                                                          */
  41. /* Please feel free to contact us at any time to share your comments about  */
  42. /* our software and/or licensing policies.                                  */
  43. /*                                                                          */
  44. /*--------------------------------------------------------------------------*/
  45.  
  46. /* Include this file before any other includes or defines! */
  47.  
  48. #include "includes.h"
  49.  
  50. void Build_Header_Block (XMARGSP args, char type)
  51. {
  52.     struct FILEINFO dta;
  53.     SEADATAP ttmp;
  54.  
  55.     (void) dfind (&dta, args->filename, 0);
  56.     args->save_header = type;
  57.     ttmp = (SEADATAP) &(args->header);
  58.  
  59.     (void) memset (ttmp, 0, sizeof (XMDATA));
  60.     ttmp->header = type;
  61.     ttmp->block_num = 0;
  62.     ttmp->block_num_comp = 0xff;
  63.     ttmp->filelength = args->filelen;
  64.     (void) strncpy (ttmp->sendingprog, xfer_id, 14);
  65.     if (type == SYN)
  66.         {
  67.         (void) memset (ttmp->filename, ' ', 16);
  68.         ttmp->timedate = dta.time;
  69.         /* This is the CRC bit in the TeLink header */
  70.         ttmp->Resync = 1;
  71.         }
  72.     else
  73.         {
  74.         ttmp->timedate = args->save_filetime.oneword.timedate;
  75.         ttmp->SLO = (unsigned char) (((cur_baud.rate_value >= 9600) && !no_overdrive)? 1 : 0);
  76.         ttmp->Resync = (unsigned char) (no_resync ? 0 : 1);
  77.         ttmp->MACFLOW = 1;
  78.         }
  79.     if (args->temp_name != NULL)
  80.         (void) strncpy (ttmp->filename, args->temp_name, strlen (args->temp_name));
  81.     else
  82.         (void) strncpy (ttmp->filename, (char *) (dta.name), strlen (dta.name));
  83. }
  84.  
  85. void XSSetVars (XMARGSP);
  86. int XSInit (XMARGSP, int);
  87. int XSEnd (XMARGSP, int);
  88. int XSXmtStart (XMARGSP);
  89. int XSXmTeStrt (XMARGSP);
  90. int XSCheckACK (XMARGSP);
  91. int XSSendBlk (XMARGSP);
  92. int XSWaitEnd (XMARGSP);
  93.  
  94. STATES Xmodem_Sender[] = {
  95.    { "XSInit", XSInit },
  96.    { "XSEnd",  XSEnd },
  97.    { "XS0",    XSXmtStart },
  98.    { "XS0T",   XSXmTeStrt },
  99.    { "XS1",    XSCheckACK },
  100.    { "XS2",    XSSendBlk },
  101.    { "XS3",    XSWaitEnd }
  102. };
  103.  
  104. int XSInit (XMARGSP args, int start_state)
  105. {
  106.     struct stat st;
  107.     char junkbuff[100];
  108.  
  109.     /* Get the file information */
  110.     if (stat (args->filename, &st))
  111.         {
  112.         /* Print error message */
  113.         return (OPEN_ERR);
  114.         }
  115.  
  116.     if ((args->file_pointer = share_fopen (args->filename, "rb", DENY_WRITE)) == NULL)
  117.         {
  118.         /* Print error message */
  119.         return (OPEN_ERR);
  120.         }
  121.  
  122.     /* Get important information out of it */
  123.     args->filelen = st.st_size;
  124.     args->LastBlk = (st.st_size + 127) / 128;
  125.     args->save_filetime.oneword.timedate = st.st_atime;
  126.     args->prev_bytes = 0L;
  127.     args->tot_errs = 0;
  128.  
  129.     (void) sprintf (junkbuff, MSG_TXT(M_SEND_MSG), args->LastBlk, args->filename, st.st_size);
  130.     if (un_attended && fullscreen)
  131.         {
  132.         clear_filetransfer ();
  133.         sb_move (file_hWnd, 1, 2);
  134.         FlLnModeSet( FILE_LN_2, 1 );
  135.         sb_puts( GetDlgItem( file_hWnd, FILE_LN_1 ), junkbuff );
  136.         elapse_time ();
  137.         sb_show ();
  138.         }
  139.     else
  140.        {
  141.        status_line ("+%s", junkbuff);
  142.        (void) printf ("\n");
  143.        }
  144.  
  145.     locate_y = wherey ();
  146.     locate_x = wherex ();
  147.  
  148.     /* Start the throughput calculations */
  149.     throughput (0, 0L);
  150.     return (start_state);
  151. }
  152.  
  153. int XSEnd (XMARGSP args, int cur_state)
  154. {
  155.     args->result = cur_state;
  156.  
  157.     /* Close file */
  158.     (void) fclose (args->file_pointer);
  159.  
  160.     if (args->tot_errs > 3)
  161.         status_line (MSG_TXT(M_CORRECTED_ERRORS), args->tot_errs, args->LastBlk);
  162.  
  163.     /* Log that we sent it */
  164.     if (cur_state == SUCCESS)
  165.         {
  166.         throughput (1, (unsigned long) (args->filelen - args->prev_bytes));
  167.         status_line ("%s: %s", MSG_TXT(M_FILE_SENT), args->filename);
  168.         update_files (1);
  169.         }
  170.  
  171.     return (cur_state);
  172. }
  173.  
  174. void XSSetVars (XMARGSP args)
  175. {
  176.     if (no_sealink)
  177.         {
  178.         args->options.SLO = 0;
  179.         args->options.Resync = 0;
  180.         }
  181.     else
  182.         {
  183.         args->options.SLO = ((cur_baud.rate_value >= 9600) && !no_overdrive) ? 1 : 0;
  184.         args->options.Resync = (~no_resync) & 1;
  185.         }
  186.  
  187.     args->options.SEAlink = 0;
  188.     args->SendBLK = 1;
  189.     args->curr_byte = 0L;
  190.     args->NextBLK = 1;
  191.     args->ACKST = 0;
  192.     args->ACKBLK = -1L;
  193.     args->Window = 1;
  194.     args->ACKsRcvd = 0;
  195.     args->NumNAK = 0;
  196.     args->T1 = timerset (3000);
  197. }
  198.  
  199. int XSXmtStart (XMARGSP args)
  200. {
  201.     XSSetVars (args);
  202.     Build_Header_Block (args, SOH);
  203.     return (XS1);
  204. }
  205.  
  206. int XSXmTeStrt (XMARGSP args)
  207. {
  208.     XSSetVars (args);
  209.     Build_Header_Block (args, SYN);
  210.     return (XS1);
  211. }
  212.  
  213. int XSCheckACK (XMARGSP args)
  214. {
  215.     Check_ACKNAK (args);
  216.     return (XS2);
  217. }
  218.  
  219. int XSSendBlk (XMARGSP args)
  220. {
  221.     if (!CARRIER)
  222.         return (CARRIER_ERR);
  223.  
  224.     if (got_ESC ())
  225.         {
  226.         status_line (MSG_TXT(M_KBD_MSG));
  227.         return (KBD_ERR);
  228.         }
  229.  
  230.     if ((args->NumNAK > 4) && (args->SendBLK == 0))
  231.         {
  232.         if (args->save_header == SOH)
  233.             return (XS0T);
  234.         else
  235.             {
  236.             args->NumNAK = 0;
  237.             ++(args->ACKBLK);
  238.             ++(args->SendBLK);
  239.             return (XS2);
  240.             }
  241.         }
  242.  
  243.     if (args->NumNAK > 10)
  244.         {
  245.         /* Too Many Errors */
  246.         return (SEND_RETRY_ERR);
  247.         }
  248.  
  249.     if (timeup (args->T1))
  250.         {
  251.         /* Fatal Timeout */
  252.         return (SEND_TIMEOUT);
  253.         }
  254.  
  255.     if (args->SendBLK > (args->LastBlk + 1))
  256.         return (XS3);
  257.  
  258.     if (args->SendBLK > (args->ACKBLK + args->Window))
  259.         {
  260.         time_release ();
  261.         return (XS1);
  262.         }
  263.  
  264.     if (args->SendBLK == (args->LastBlk + 1))
  265.         {
  266.         SENDBYTE (EOT);
  267.         ++(args->SendBLK);
  268.         args->T1 = timerset (3000);
  269.         show_sending_blocks (args);
  270.         time_release ();
  271.         return (XS1);
  272.         }
  273.  
  274.     /*
  275.         Increment the block count before sending because we read the next
  276.         block immediately after sending this block.  On error free connects
  277.         we have a big net win because we never do a seek, and while we are
  278.         sending one block, we read the next.  If we do get errors, then we
  279.         have to seek back to the previous block, and that will be a bother.
  280.         With today's phone lines and modems, we'll assume error free is more
  281.         often than not, and take our chances.
  282.     */
  283.     if (args->options.SLO && args->options.SEAlink)
  284.         {
  285.         args->ACKBLK = args->SendBLK;
  286.         }
  287.  
  288.     ++(args->SendBLK);
  289.     args->curr_byte += 128L;
  290.     Send_Block (args);
  291.     args->T1 = timerset (6000);
  292.     return (XS1);
  293. }
  294.  
  295. int XSWaitEnd (XMARGSP args)
  296. {
  297.     show_sending_blocks (args);
  298.  
  299.     if (args->ACKBLK < (args->LastBlk + 1))
  300.         {
  301.         time_release ();
  302.         return (XS1);
  303.         }
  304.  
  305.     if (!CARRIER)
  306.         return (CARRIER_ERR);
  307.  
  308.     return (SUCCESS);
  309. }
  310.  
  311. int SEAlink_Send_File (char *filename, char *sendname)
  312. {
  313.     XMARGS xm;
  314.  
  315.     xm.filename = filename;
  316.     xm.temp_name = sendname;
  317.     return (state_machine (Xmodem_Sender, &xm, XS0));
  318. }
  319.  
  320. int Xmodem_Send_File (char *filename, char *sendname)
  321. {
  322.     return (SEAlink_Send_File (filename, sendname));
  323. }
  324.  
  325. int Telink_Send_File (char *filename, char *sendname)
  326. {
  327.     XMARGS xm;
  328.  
  329.     xm.filename = filename;
  330.     xm.temp_name = sendname;
  331.     return (state_machine (Xmodem_Sender, &xm, XS0T));
  332. }
  333.  
  334. void Get_Block (XMARGSP args)
  335. {
  336.     XMDATAP xtmp;
  337.  
  338.     if (args->SendBLK == 0)
  339.         {
  340.         Build_Header_Block (args, args->save_header);
  341.         args->NextBLK = -1L;
  342.         return;
  343.         }
  344.  
  345.     xtmp = (XMDATAP) &(args->header);
  346.  
  347.     /* Set up buffer as all ^Zs for EOF */
  348.     (void) memset (xtmp, SUB, sizeof (XMDATA));
  349.  
  350.     /* Now set up the header stuff */
  351.     xtmp->header = SOH;
  352.     xtmp->block_num = (unsigned char) (args->SendBLK & 0xff);
  353.     xtmp->block_num_comp = (unsigned char)~xtmp->block_num;
  354.  
  355.     if (args->NextBLK != args->SendBLK)
  356.         {
  357.         (void) fseek (args->file_pointer, (args->SendBLK - 1) * 128, SEEK_SET);
  358.         }
  359.  
  360.     args->NextBLK = args->SendBLK + 1;
  361.  
  362.     /* Can we read any data? */
  363.     if (fread ((char *) xtmp->data_bytes, 1, 128, args->file_pointer) <= 0)
  364.         return;
  365.  
  366.     /* Looks good */
  367.     return;
  368. }
  369.  
  370. void Send_Block (XMARGSP args)
  371. {
  372.     if (args->header == SYN)
  373.         {
  374.         Data_Check ((XMDATAP) &(args->header), CHECKSUM);
  375.         }
  376.     else
  377.         {
  378.         Data_Check ((XMDATAP) &(args->header), args->options.do_CRC ? CRC : CHECKSUM);
  379.         }
  380.  
  381.     if ((!(args->options.do_CRC)) || (args->header == SYN))
  382.         {
  383.         SENDCHARS ((char *) &(args->header), sizeof (XMDATA) - 1, 1);
  384.         }
  385.     else
  386.         {
  387.         SENDCHARS ((char *) &(args->header), sizeof (XMDATA), 1);
  388.         }
  389.  
  390.     UNBUFFER_BYTES ();
  391.  
  392.     show_sending_blocks (args);
  393.  
  394.     Get_Block (args);
  395. }
  396.  
  397. char *show_num (XMARGSP args, long b)
  398. {
  399.     char               *Rtn;
  400.  
  401.     Rtn = "EOT";
  402.     if (b > args->LastBlk)
  403.         {
  404.         if (!(fullscreen && un_attended))
  405.             (void) cputs (Rtn);
  406.         }
  407.     else if (b >= 0L)
  408.         {
  409.         Rtn = ultoa (((unsigned long) b), e_input, 10);
  410.         if (!(fullscreen && un_attended))
  411.             (void) cputs (Rtn);
  412.         }
  413.     return Rtn;
  414. }
  415.  
  416. void show_sending_blocks (XMARGSP args)
  417. {
  418.     char *TmpPtr = (char *)&happy_compiler;
  419.     char j[100];
  420.     int i;
  421.     long k;
  422.  
  423.     k = args->filelen - args->curr_byte;
  424.     if (k < 0L)
  425.         k = 0L;
  426.  
  427.     i = (int) ((k * 10 / cur_baud.rate_value * 100 /
  428.         ((args->save_header == SOH) ? 94 : 70) + 59) / 60);
  429.     (void) sprintf (j, "%3d min", i);
  430.  
  431.     if (args->options.SLO)
  432.         {
  433.         if ((!((args->SendBLK - 1) & 0x1f)) || ((args->SendBLK - 1) > args->LastBlk))
  434.             {
  435.             if (fullscreen && un_attended)
  436.                 {
  437.                 elapse_time();
  438.                 sb_move (file_hWnd, 2, 2);
  439.                 TmpPtr = show_num (args, args->SendBLK - 1);
  440.                 sb_puts( GetDlgItem( file_hWnd, FILE_LN_2 + GD_TOTAL ), 
  441.                          TmpPtr );
  442. #ifndef MILQ
  443.                 (void) sb_putc (file_hWnd, ':');
  444. #endif
  445.                 TmpPtr = show_num (args, args->ACKBLK);
  446.                 sb_puts( GetDlgItem( file_hWnd, FILE_LN_2 + GD_SIZE ),
  447.                          TmpPtr );
  448.                 sb_puts( GetDlgItem( file_hWnd, FILE_LN_2 + GD_STATUS ),
  449.                          " *Overdrive*  ");
  450.                 sb_move (file_hWnd, 2, 69);
  451.                 sb_puts( GetDlgItem( file_hWnd, FILE_LN_2 + GD_DTTM ), j );
  452.                 sb_show ();
  453.                 }
  454.             else
  455.                 {
  456.                 gotoxy (locate_x, locate_y);
  457.                 (void) show_num (args, args->SendBLK - 1);
  458.                 (void) cputs (":");
  459.                 (void) show_num (args, args->ACKBLK);
  460.                 (void) cputs (" *Overdrive*  ");
  461.                 }
  462.             }
  463.         }
  464.     else
  465.         {
  466.         if (fullscreen && un_attended)
  467.             {
  468.             elapse_time();
  469.  
  470.             sb_move (file_hWnd, 2, 2);
  471.             TmpPtr = show_num (args, args->SendBLK - 1);
  472.             sb_puts( GetDlgItem( file_hWnd, FILE_LN_2 + GD_TOTAL ),
  473.                      TmpPtr );
  474. #ifndef MILQ
  475.             (void) sb_putc (file_hWnd, ':');
  476. #endif
  477.             TmpPtr = show_num (args, args->ACKBLK);
  478.             sb_puts( GetDlgItem( file_hWnd, FILE_LN_2 + GD_SIZE ),
  479.                      TmpPtr );
  480.  
  481. #ifndef MILQ
  482.             sb_puts (file_hWnd, "              ");
  483. #endif
  484.             sb_move (file_hWnd, 2, 69);
  485.             sb_puts( GetDlgItem( file_hWnd, FILE_LN_2 + GD_DTTM ), j );
  486.             sb_show ();
  487.             }
  488.         else
  489.             {
  490.             gotoxy (locate_x, locate_y);
  491.             (void) show_num (args, args->SendBLK - 1);
  492.             (void) cputs (":");
  493.             (void) show_num (args, args->ACKBLK);
  494.             (void) cputs ("              ");
  495.             }
  496.         }
  497.    happy_compiler = * (int *) TmpPtr; /* Makes the compiler happy! */
  498. }
  499.  
  500. int ACInit (XMARGSP, int);
  501. int ACEnd (XMARGSP, int);
  502. int ACChkRcvd (XMARGSP);
  503. int ACSLCheck (XMARGSP);
  504. int ACSLVerify (XMARGSP);
  505. int ACSLACKNAK (XMARGSP);
  506. int ACXMCheck (XMARGSP);
  507. int ACSLOCheck (XMARGSP);
  508. int ACSL1Check (XMARGSP);
  509. int ACACKNAK (XMARGSP);
  510. int ACXMACK (XMARGSP);
  511. int ACXMNAK (XMARGSP);
  512. int ACRESYNC (XMARGSP);
  513.  
  514. STATES ACKNAK_Check[] = {
  515.    { "ACInit", ACInit },
  516.    { "ACEnd",  ACEnd },
  517.    { "AC0",    ACChkRcvd },
  518.    { "AC1",    ACSLCheck },
  519.    { "AC2",    ACSLVerify },
  520.    { "AC3",    ACSLACKNAK },
  521.    { "AC4",    ACXMCheck },
  522.    { "AC5",    ACSLOCheck },
  523.    { "AC6",    ACSL1Check },
  524.    { "AC7",    ACACKNAK },
  525.    { "AC8",    ACXMACK },
  526.    { "AC9",    ACXMNAK },
  527.    { "AC10",   ACRESYNC }
  528. };
  529.  
  530. int ACInit (XMARGSP args, int start_state)
  531. {
  532.     args->result = 0;
  533.     return (start_state);
  534. }
  535.  
  536. int ACEnd (XMARGSP args, int cur_state)
  537. {
  538.     args->result = cur_state;
  539.     return (cur_state);
  540. }
  541.  
  542. int ACChkRcvd (XMARGSP args)
  543. {
  544.     if (PEEKBYTE () >= 0)
  545.         {
  546.         args->CHR = TIMED_READ (0);
  547.         return (AC1);
  548.         }
  549.  
  550.     return (SUCCESS);
  551. }
  552.  
  553. int ACSLCheck (XMARGSP args)
  554. {
  555.     if (args->ACKST > 2)
  556.         return (AC2);
  557.  
  558.     return (AC6);
  559. }
  560.  
  561. int ACSLVerify (XMARGSP args)
  562. {
  563.     if (args->ARBLK8 == (unsigned char) ((~args->CHR) & 0xff))
  564.         {
  565.         args->ARBLK = args->SendBLK - ((args->SendBLK - args->ARBLK8) & 0xff);
  566.         return (AC3);
  567.         }
  568.  
  569.     args->options.SEAlink = 0;
  570.     args->Window = 1;
  571.     args->ACKST = 0;
  572.     return (AC6);
  573. }
  574.  
  575. int ACSLACKNAK (XMARGSP args)
  576. {
  577.     if ((args->ARBLK < 0)
  578.     ||  (args->ARBLK > args->SendBLK)
  579.     ||  (args->ARBLK <= (args->SendBLK - 128)))
  580.         {
  581.         return (AC0);
  582.         }
  583.  
  584.     if (args->ACKST == 3)
  585.         {
  586.         args->options.SEAlink = (~no_sealink) & 1;
  587.         args->Window = calc_window ();
  588.         args->ACKBLK = args->ARBLK;
  589.         ++(args->ACKsRcvd);
  590.         args->ACKST = 0;
  591.         return (AC5);
  592.         }
  593.  
  594.     args->SendBLK = args->ARBLK;
  595.     args->curr_byte = (args->SendBLK - 1) * 128L;
  596.     if (args->curr_byte < 0L)
  597.         args->curr_byte = 0L;
  598.  
  599.     if (args->SendBLK > 0)
  600.         ++(args->tot_errs);
  601.  
  602.     Get_Block (args);
  603.     args->ACKST = 0;
  604.  
  605.     return (AC4);
  606. }
  607.  
  608. int ACXMCheck (XMARGSP args)
  609. {
  610.     if (args->NumNAK < 4)
  611.         {
  612.         args->options.SEAlink = (~no_sealink) & 1;
  613.         args->Window = calc_window ();
  614.         }
  615.     else
  616.         {
  617.         args->options.SEAlink = 0;
  618.         args->Window = 1;
  619.         }
  620.     return (SUCCESS);
  621. }
  622.  
  623. int ACSLOCheck (XMARGSP args)
  624. {
  625.     if ((args->options.SLO == 0) || (args->ACKsRcvd < 10))
  626.         return (SUCCESS);
  627.  
  628.     args->options.SLO = 0;
  629.     return (SUCCESS);
  630. }
  631.  
  632. int ACSL1Check (XMARGSP args)
  633. {
  634.     if ((args->ACKST == 1) || (args->ACKST == 2))
  635.         {
  636.         args->ARBLK8 = (unsigned char) args->CHR;
  637.         args->ACKST += 2;
  638.         return (AC6);
  639.         }
  640.  
  641.     if ((args->options.SEAlink == 0) || (args->ACKST == 0))
  642.         return (AC7);
  643.  
  644.     return (AC0);
  645. }
  646.  
  647. int ACACKNAK (XMARGSP args)
  648. {
  649.     long mac_timer;
  650.  
  651.     switch (args->CHR)
  652.         {
  653.         case ACK:
  654.             args->ACKST = 1;
  655.             args->NumNAK = 0;
  656.             return (AC8);
  657.  
  658.         case WANTCRC:
  659.             args->options.do_CRC = 1;
  660.             /* Fallthrough */
  661.  
  662.         case NAK:
  663.             args->ACKST = 2;
  664.             ++(args->NumNAK);
  665.             CLEAR_OUTBOUND ();
  666.             timer (6);
  667.             return (AC9);
  668.  
  669.         case SYN:
  670.             CLEAR_OUTBOUND ();
  671.             if (!no_resync)
  672.                 {
  673.                 args->result = Receive_Resync (&(args->resync_block));
  674.                 args->ACKST = 0;
  675.                 return (AC10);
  676.                 }
  677.             else
  678.                 {
  679.                 return (AC0);
  680.                 }
  681.  
  682.         case DC3: /* ^S */
  683.             if (args->options.SEAlink && (args->ACKST == 0))
  684.                 {
  685.                 mac_timer = timerset (1000);
  686.                 while (CARRIER && !timeup (mac_timer))
  687.                     {
  688.                     if (TIMED_READ (0) == DC1)
  689.                         break;
  690.  
  691.                     time_release ();
  692.                     }
  693.                 return (AC0);
  694.                 }
  695.  
  696.             /* Otherwise, fallthrough */
  697.  
  698.         default:
  699.             break;
  700.         }
  701.    return (AC0);
  702. }
  703.  
  704. int ACXMACK (XMARGSP args)
  705. {
  706.     if (!args->options.SEAlink)
  707.         ++(args->ACKBLK);
  708.  
  709.     return (AC0);
  710. }
  711.  
  712. int ACXMNAK (XMARGSP args)
  713. {
  714.     if (!args->options.SEAlink)
  715.         {
  716.         args->SendBLK = args->ACKBLK + 1;
  717.         args->curr_byte = (args->SendBLK - 1) * 128L;
  718.         if (args->curr_byte < 0L)
  719.             args->curr_byte = 0L;
  720.  
  721.         if (args->SendBLK > 0)
  722.             ++(args->tot_errs);
  723.  
  724.         Get_Block (args);
  725.         }
  726.  
  727.     return (AC0);
  728. }
  729.  
  730. int ACRESYNC (XMARGSP args)
  731. {
  732.     CLEAR_OUTBOUND ();
  733.     if (args->result != SUCCESS)
  734.         {
  735.         SENDBYTE (NAK);
  736.         return (SUCCESS);
  737.         }
  738.  
  739.     if (args->SendBLK == 1)
  740.         {
  741.         args->prev_bytes = (args->resync_block - 1) * 128;
  742.         if (args->prev_bytes > args->filelen)
  743.             args->prev_bytes = args->filelen;
  744.         status_line (MSG_TXT(M_SYNCHRONIZING), args->prev_bytes);
  745.         }
  746.     else
  747.         {
  748.         ++(args->tot_errs);
  749.         }
  750.  
  751.     args->options.SEAlink = 1;
  752.     args->Window = calc_window ();
  753.     args->SendBLK = args->resync_block;
  754.     args->curr_byte = (args->SendBLK - 1) * 128L;
  755.     if (args->curr_byte < 0L)
  756.         args->curr_byte = 0L;
  757.  
  758.     Get_Block (args);
  759.     args->ACKBLK = args->SendBLK - 1;
  760.     SENDBYTE (ACK);
  761.     return (SUCCESS);
  762. }
  763.  
  764.  
  765. void Check_ACKNAK (XMARGSP args)
  766. {
  767.     (void) state_machine (ACKNAK_Check, args, AC0);
  768. }
  769.  
  770. int Receive_Resync (long *resync_block)
  771. {
  772.     unsigned char resyncit[30];
  773.     unsigned char *p;
  774.     unsigned char a, b;
  775.     unsigned int nak_crc, his_crc;
  776.  
  777.     p = resyncit;
  778.  
  779.     while ((*p = (unsigned char) TIMED_READ(1)) != ETX)
  780.         {
  781.         if ((*p < '0') || (*p > '9'))
  782.             {
  783.             status_line (">SEAlink Send: Resync bad byte '%02x'", *p);
  784.             return (RESYNC_ERR);
  785.             }
  786.         ++p;
  787.         }
  788.     *p = '\0';
  789.     nak_crc = crc_block ((unsigned char *) resyncit, (int) strlen ((char *) resyncit));
  790.     a = (unsigned char) TIMED_READ (1);
  791.     b = (unsigned char) TIMED_READ (1);
  792.     his_crc = (b << 8) | a;
  793.  
  794.     if (nak_crc != his_crc)
  795.         {
  796.         status_line (">SEAlink Send: Resync bad crc %04x/%04x", nak_crc, his_crc);
  797.         return (CRC_ERR);
  798.         }
  799.  
  800.     *resync_block = atol ((char *) resyncit);
  801.  
  802.     status_line (">SEAlink Send: Resync to %ld", *resync_block);
  803.     return (SUCCESS);
  804. }
  805.  
  806. int calc_window ()
  807. {
  808.     int window;
  809.  
  810.     window = (int) (cur_baud.rate_value / 400);
  811.     if (window <= 0)
  812.         window = 2;
  813.     if (small_window)
  814.         window = (window > 6) ? 6 : window;
  815.  
  816.     return (window);
  817. }
  818.