home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / bts314b4 / sendbark.c < prev    next >
C/C++ Source or Header  |  1994-01-08  |  10KB  |  372 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. /*                 This module was written by Bob Hartman                   */
  14. /*                                                                          */
  15. /*                BinkleyTerm SEAdog Mail Session Routines                  */
  16. /*                                                                          */
  17. /*                                                                          */
  18. /*    For complete  details  of the licensing restrictions, please refer    */
  19. /*    to the License  agreement,  which  is published in its entirety in    */
  20. /*    the MAKEFILE and BT.C, and also contained in the file LICENSE.240.    */
  21. /*                                                                          */
  22. /*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  23. /*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  24. /*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
  25. /*    NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
  26. /*    SOFTWARE CO.  AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
  27. /*    SHOULD YOU  PROCEED TO USE THIS FILE  WITHOUT HAVING  ACCEPTED THE    */
  28. /*    TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
  29. /*    AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.      */
  30. /*                                                                          */
  31. /*                                                                          */
  32. /* You can contact Bit Bucket Software Co. at any one of the following      */
  33. /* addresses:                                                               */
  34. /*                                                                          */
  35. /* Bit Bucket Software Co.        FidoNet  1:104/501, 1:132/491, 1:141/491  */
  36. /* P.O. Box 460398                AlterNet 7:491/0                          */
  37. /* Aurora, CO 80046               BBS-Net  86:2030/1                        */
  38. /*                                Internet f491.n132.z1.fidonet.org         */
  39. /*                                                                          */
  40. /* Please feel free to contact us at any time to share your comments about  */
  41. /* our software and/or licensing policies.                                  */
  42. /*                                                                          */
  43. /*--------------------------------------------------------------------------*/
  44.  
  45. #ifdef __TOS__
  46. /* #pragma warn -sus */
  47. #endif
  48. #include <stdio.h>
  49. #include <signal.h>
  50. #include <ctype.h>
  51. #include <conio.h>
  52. #include <time.h>
  53. #include <string.h>
  54. #include <stdlib.h>
  55.  
  56. #include "bink.h"
  57. #include "msgs.h"
  58. #include "com.h"
  59. #include "ascii.h"
  60. #include "defines.h"
  61.  
  62. void SEA_sendreq( void )
  63. {
  64.        char fname[80];
  65.        char reqf[80];
  66.        char *reqtime = " 0";
  67.        char *p, *name, *pw;
  68.        char *updtime;
  69.        FILE *fp;
  70.        char *HoldName;
  71. #ifdef IOS
  72.     BOOLEAN flag;
  73. #endif
  74.  
  75.        HoldName = HoldAreaNameMunge(&called_addr);
  76.        sprintf (fname, "%s%s.REQ", HoldName, Hex_Addr_Str (&called_addr));
  77. #ifdef IOS
  78.     if((flag = dexists(fname)) == 0)
  79.     {
  80.         char *ext = "HOC";
  81.         while(*ext)
  82.         {
  83.             sprintf (fname, "%s%s.%cRT", HoldName, Addr36(&called_addr), *ext);
  84.             if((flag = dexists(fname)) != 0 )
  85.                 break;
  86.             ext++;
  87.         }
  88.     }
  89.     if(!flag)
  90. #else
  91.        /* If we have file requests, then do them */
  92.        if (!dexists (fname))
  93. #endif
  94.           status_line (msgtxt[M_NO_OUT_REQUESTS]);
  95.    else
  96.       {
  97.       status_line (msgtxt[M_OUT_REQUESTS]);
  98.       /* Open the .REQ file */
  99.       if ((fp = fopen (fname, read_ascii)) == NULL)
  100.          {
  101.          Bark_Request (CurrentNetFiles, NULL, NULL, NULL);
  102.          return;
  103.          }
  104.  
  105.       /* As long as we do not have EOF, read the request */
  106.       while ((fgets (reqf, 79, fp) != NULL) && (CARRIER))
  107.          {
  108.          /* Properly format the request */
  109.  
  110.          /* First get rid of the trailing junk */
  111.  
  112.          p = reqf + strlen (reqf) - 1;
  113.          while ((p >= reqf) && *p && (isspace (*p)))
  114.             *p-- = '\0';
  115.  
  116.          /* Now get rid of the beginning junk */
  117.  
  118.          p = reqf;
  119.          while ((*p) && (isspace (*p)))
  120.             p++;
  121.  
  122.          /* This is where the name starts */
  123.          name = p;
  124.  
  125.          /* If the first char is ; then ignore the line */
  126.          if (*name == ';')
  127.             continue;
  128.  
  129.          /* Now get to where the name ends */
  130.          while ((*p) && (!isspace (*p)))
  131.             p++;
  132.  
  133.          updtime = reqtime;             /* Default to request        */
  134.          pw = p;                        /* This is or will be a null */
  135. req_scan:
  136.          if (*p)
  137.             {
  138.             *p++ = '\0';
  139.  
  140.             while ((*p) && (*p != '!') && (*p != '-') && (*p != '+'))
  141.                p++;
  142.  
  143.             /* Check for a password */
  144.  
  145.             if (*p == '!')
  146.                {
  147.                *p = ' ';
  148.                pw = p++;
  149.  
  150.                /* Now get to where the password ends */
  151.  
  152.                while ((*p) && (!isspace (*p)))
  153.                   p++;
  154.                goto req_scan;
  155.                }
  156.  
  157.             /* Try for an update request */
  158.  
  159.             if (*p == '+')
  160.                {
  161.                *p = ' ';
  162.                updtime = p++;
  163.  
  164.                /* Now get to where the update time ends */
  165.  
  166.                while ((*p) && (!isspace (*p)))
  167.                   p++;
  168.  
  169.                *p = '\0';
  170.  
  171.                /* Request time is last thing we care about on line, so
  172.                   we just drop out of the loop after finding it.
  173.                 */
  174.                }
  175.  
  176.             /* Note: since SEAdog doesn't do "backdate" requests, all we
  177.                have to do if we see a '-' is to do a full request. Hence
  178.                we only process a '+' here.
  179.              */
  180.  
  181.             }
  182.  
  183.          if (Bark_Request (CurrentNetFiles, name, pw, updtime))
  184.             continue;
  185.          }
  186.       (void) fclose (fp);
  187.       (void) unlink (fname);
  188.       status_line (msgtxt[M_END_OUT_REQUESTS]);
  189.       }
  190.  
  191.    /* Finish the file requests off */
  192.    Bark_Request (CurrentNetFiles, NULL, NULL, NULL);
  193.  
  194. }
  195.  
  196. int cdecl SBInit (BARKARGSP, int);
  197. int cdecl SBEnd (BARKARGSP, int);
  198. int cdecl SBSendBark (BARKARGSP);
  199. int cdecl SBAskFile (BARKARGSP);
  200. int cdecl SBRcvFile (BARKARGSP);
  201. int cdecl SBNxtFile (BARKARGSP);
  202.  
  203. STATES Bark_Sender[] = {
  204.    { "SBInit", ( void *)SBInit },
  205.    { "SBEnd", ( void *)SBEnd },
  206.    { "SB0", ( void *)SBSendBark },
  207.    { "SB1", ( void *)SBAskFile },
  208.    { "SB2", ( void *)SBRcvFile },
  209.    { "SB3", ( void *)SBNxtFile },
  210. };
  211.  
  212. void Build_Bark_Packet( BARKARGSP args )
  213. {
  214.    char *p, *q;
  215.    unsigned int crc;
  216.  
  217.    p = args->barkpacket;
  218.    *p++ = ACK;
  219.    crc = 0;
  220.    q = args->filename;
  221.    while (*q)
  222.       {
  223.       *p++ = *q;
  224.       crc = xcrc (crc, (byte) (*q));
  225.       ++q;
  226.       }
  227.    q = args->barktime;
  228.    while (*q)
  229.       {
  230.       *p++ = *q;
  231.       crc = xcrc (crc, (byte) (*q));
  232.       ++q;
  233.       }
  234.    q = args->barkpw;
  235.    while (*q)
  236.       {
  237.       *p++ = *q;
  238.       crc = xcrc (crc, (byte) (*q));
  239.       ++q;
  240.       }
  241.  
  242.    *p++ = ETX;
  243.    *p++ = (char) (crc & 0xff);
  244.    *p++ = (char) (crc >> 8);
  245.  
  246.    args->barklen = (size_t) (p - args->barkpacket);
  247. }
  248.  
  249. int cdecl SBInit( BARKARGSP args, int start_state )
  250. {
  251.    if ( args )
  252.    {
  253.    }
  254.    
  255.    XON_DISABLE ();
  256.    return (start_state);
  257.    /* args; */
  258. }
  259.  
  260. int cdecl SBEnd( BARKARGSP args, int cur_state )
  261. {
  262.    if ( args )
  263.    {
  264.    }
  265.    
  266.    return (cur_state);
  267.    /* args; */
  268. }
  269.  
  270. int cdecl SBSendBark( BARKARGSP args )
  271. {
  272.    if ((args->filename != NULL) && (args->filename[0] != '\0'))
  273.       {
  274.       status_line ("%s '%s' %s%s", msgtxt[M_MAKING_FREQ], args->filename, (*(args->barkpw)) ? "with password" : "", args->barkpw);
  275.       args->tries = 0;
  276.       Build_Bark_Packet (args);
  277.       return (SB1);
  278.       }
  279.    else
  280.       {
  281.       SENDBYTE (ETB);
  282.  
  283.       /* Delay one second */
  284.       big_pause (1);
  285.  
  286.       return (SUCCESS);
  287.       }
  288. }
  289.  
  290. int cdecl SBAskFile( BARKARGSP args )
  291. {
  292.    SENDCHARS (args->barkpacket, args->barklen, 1);
  293.    return (SB2);
  294. }
  295.  
  296. int cdecl SBRcvFile( BARKARGSP args )
  297. {
  298.    int c;
  299.    int ret;
  300.  
  301.    ret = SB2;
  302.    while (CARRIER && (ret == SB2))
  303.       {
  304.       c = TIMED_READ (10);
  305.  
  306.       if (c == ACK)
  307.          {
  308.          Batch_Receive (args->inbound);
  309.          ret = SB3;
  310.          break;
  311.          }
  312.  
  313.       if (args->tries > 5)
  314.          {
  315. /* Report transfer failed */
  316.          SENDBYTE (ETB);
  317.          ret = SENDBLOCK_ERR;
  318.          break;
  319.          }
  320.  
  321.       CLEAR_INBOUND ();
  322.       ++(args->tries);
  323.       ret = SB1;
  324.       }
  325.  
  326.    if (!CARRIER)
  327.       return (CARRIER_ERR);
  328.    else
  329.       return (ret);
  330. }
  331.  
  332. int cdecl SBNxtFile( BARKARGSP args )
  333. {
  334.    int c;
  335.    long SB3Timer;
  336.  
  337.    SB3Timer = timerset (4500);
  338.  
  339.    if ( args )
  340.    {
  341.    }
  342.    
  343.    while (CARRIER && !timeup (SB3Timer))
  344.       {
  345.       if ((c = TIMED_READ (5)) == -1)
  346.          {
  347.          SENDBYTE (SUB);
  348.          continue;
  349.          }
  350.  
  351.       if (c == ENQ)
  352.          return (SUCCESS);
  353.       }
  354.  
  355.    if (CARRIER)
  356.       return (CARRIER_ERR);
  357.    else
  358.       return (TIME_ERR);
  359.    /* args; */
  360. }
  361.  
  362. int Bark_Request( char *where, char *filename, char *pw, char *updtime )
  363. {
  364.    BARKARGS bark;
  365.  
  366.    bark.inbound = where;
  367.    bark.filename = filename;
  368.    bark.barkpw = pw;
  369.    bark.barktime = updtime;
  370.    return (state_machine (Bark_Sender, &bark, SB0));
  371. }
  372.