home *** CD-ROM | disk | FTP | other *** search
/ Frostbyte's 1980s DOS Shareware Collection / floppyshareware.zip / floppyshareware / BOUT / BT2404SC.ZIP / MISC.C < prev    next >
C/C++ Source or Header  |  1990-07-28  |  38KB  |  1,650 lines
  1. /*
  2. ** Henry Clark 1:124/6120 made changes here 7/28/90
  3. */
  4. /*--------------------------------------------------------------------------*/
  5. /*                                                                          */
  6. /*                                                                          */
  7. /*      ------------         Bit-Bucket Software, Co.                       */
  8. /*      \ 10001101 /         Writers and Distributors of                    */
  9. /*       \ 011110 /          Freely Available<tm> Software.                 */
  10. /*        \ 1011 /                                                          */
  11. /*         ------                                                           */
  12. /*                                                                          */
  13. /*  (C) Copyright 1987-90, Bit Bucket Software Co., a Delaware Corporation. */
  14. /*                                                                          */
  15. /*                                                                          */
  16. /*                This module was written by Vince Perriello                */
  17. /*                     with code from several authors                       */
  18. /*                                                                          */
  19. /*                                                                          */
  20. /*                Miscellaneous routines used by BinkleyTerm                */
  21. /*                                                                          */
  22. /*                                                                          */
  23. /*    For complete  details  of the licensing restrictions, please refer    */
  24. /*    to the License  agreement,  which  is published in its entirety in    */
  25. /*    the MAKEFILE and BT.C, and also contained in the file LICENSE.240.    */
  26. /*                                                                          */
  27. /*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  28. /*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  29. /*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
  30. /*    NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
  31. /*    SOFTWARE CO.  AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
  32. /*    SHOULD YOU  PROCEED TO USE THIS FILE  WITHOUT HAVING  ACCEPTED THE    */
  33. /*    TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
  34. /*    AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.      */
  35. /*                                                                          */
  36. /*                                                                          */
  37. /* You can contact Bit Bucket Software Co. at any one of the following      */
  38. /* addresses:                                                               */
  39. /*                                                                          */
  40. /* Bit Bucket Software Co.        FidoNet  1:104/501, 1:132/491, 1:141/491  */
  41. /* P.O. Box 460398                AlterNet 7:491/0                          */
  42. /* Aurora, CO 80046               BBS-Net  86:2030/1                        */
  43. /*                                Internet f491.n132.z1.fidonet.org         */
  44. /*                                                                          */
  45. /* Please feel free to contact us at any time to share your comments about  */
  46. /* our software and/or licensing policies.                                  */
  47. /*                                                                          */
  48. /*--------------------------------------------------------------------------*/
  49.  
  50. #include <dos.h>
  51. #include <time.h>
  52. #include <ctype.h>
  53. #include <stdio.h>
  54. #include <stdarg.h>
  55. #include <string.h>
  56. #include <conio.h>
  57. #include <process.h>
  58. #include <io.h>
  59. #include <stdlib.h>
  60. #include <fcntl.h>
  61.  
  62. #ifdef OS_2
  63. #define  INCL_DOSPROCESS
  64. #endif
  65.  
  66. #ifdef __TURBOC__
  67. #include "tc_utime.h"
  68. #include <mem.h>
  69. #else
  70. #include <sys/utime.h>
  71. #include <memory.h>
  72. #endif
  73.  
  74. #include "com.h"
  75. #include "xfer.h"
  76. #include "zmodem.h"
  77. #include "keybd.h"
  78. #include "sbuf.h"
  79. #include "sched.h"
  80. #include "vfossil.h"
  81. #include "externs.h"
  82. #include "prototyp.h"
  83. #include "defines.h"
  84.  
  85. #ifdef OS_2
  86. #ifdef Snoop
  87. #include "snserver.h"
  88. static HSNOOP hsnoop=(HSNOOP)NULL;
  89. #endif /* Snoop */
  90. #endif /* OS_2  */
  91.  
  92. static char newstring[200];
  93. static void fill_in_status (void);
  94. static int find_addr (char *, ADDR *, char *);
  95.  
  96.  
  97. int dexists (filename)
  98. char *filename;
  99. {
  100.    struct FILEINFO dta;
  101.  
  102.    return (!dfind (&dta, filename, 0));
  103. }
  104.  
  105. int dfind (dta, name, times)
  106. struct FILEINFO *dta;
  107. char *name;
  108. int times;
  109. {
  110. #ifndef OS_2
  111.    union REGS r;
  112.  
  113.    r.x.dx = (unsigned int) dta;
  114.    r.h.ah = 0x1a;
  115.    (void) intdos (&r, &r);
  116.    r.x.bx = 0;
  117.    r.x.cx = ~0x08;
  118.    r.x.dx = (unsigned int) name;
  119.    r.x.si = 0;
  120.    r.x.di = 0;
  121.    if (times == 0)
  122.       {
  123.       r.h.ah = 0x4e;
  124.       (void) intdos (&r, &r);
  125.       dta->nill = '\0';
  126.       if (r.x.cflag != 0)
  127.          {
  128.          dta->name[0] = '\0';
  129.          return (1);
  130.          }
  131.       return (0);
  132.       }
  133.    else
  134.       {
  135.       r.h.ah = 0x4f;
  136.       (void) intdos (&r, &r);
  137.       dta->nill = '\0';
  138.       if (r.x.cflag != 0)
  139.          {
  140.          dta->name[0] = '\0';
  141.          return (1);
  142.          }
  143.       return (0);
  144.       }
  145. #else
  146.    int retval;
  147.  
  148.    if (times == 0)
  149.    {
  150.       retval = dir_findfirst(name, 0x37, dta);
  151. /*    dta->nill = '\0'; */
  152.       if (retval)
  153.       {
  154. /*       dta->name[0] = '\0'; */
  155.          return (1);
  156.       }
  157.       else
  158.          return (0);
  159.    }
  160.    else
  161.    {
  162.       retval = dir_findnext(dta);
  163. /*    dta->nill = '\0'; */
  164.       if (retval)
  165.       {
  166. /*       dta->name[0] = '\0'; */
  167.          return (1);
  168.       }
  169.       else
  170.          return (0);
  171.    }
  172. #endif
  173. }
  174.  
  175. int set_baud (baudrate, log)
  176. unsigned baudrate;
  177. int log;
  178. {
  179.    register int i;
  180.  
  181.    if (baudrate > max_baud.rate_value)
  182.       baudrate = max_baud.rate_value;
  183.  
  184.    for (i = 0; btypes[i].rate_value; i++)
  185.       {
  186.       if (btypes[i].rate_value == baudrate)
  187.          {
  188.          if (baud != i)                          /* same as what we have?     */
  189.             {
  190.             if (log && !un_attended)
  191.                status_line (msgtxt[M_SETTING_BAUD], baudrate);
  192.             baud = i;                            /* need this for ALT-B       */
  193.             MDM_ENABLE (lock_baud && (btypes[baud].rate_value >= lock_baud) ? max_baud.rate_mask : btypes[baud].rate_mask);
  194.             cur_baud = baudrate;
  195.             }
  196.  
  197.  
  198.          if (un_attended && fullscreen)
  199.             {
  200.             sb_move (settingswin, SET_PORT_ROW, SET_COL);
  201.             (void) sprintf (junk, "%-5u Com%d", baudrate, port_ptr + 1);
  202.             sb_puts (settingswin, (unsigned char *) junk);
  203.             sb_show ();
  204.             }
  205.          return (1);
  206.          }
  207.       }
  208.    return (0);
  209. }
  210.  
  211. static char *specifiers = "!*+:# >";
  212. static struct tm *tp;
  213. static time_t ltime;
  214.  
  215. /*
  216. ** Henry Clark 1:124/6120 made changes here 7/28/90
  217. */
  218. void _cdecl status_line (char *fmt,...)
  219. {
  220.    va_list arg_ptr;
  221.  
  222. #ifdef Snoop
  223.    char tmp[255];
  224. #define e_input tmp
  225. #endif /* Snoop */
  226.  
  227.    va_start (arg_ptr, fmt);
  228.    (void) vsprintf (e_input, fmt, arg_ptr);
  229.    (void) time (<ime);
  230.    tp = localtime (<ime);
  231.    if ((!fullscreen) || (!un_attended))
  232.       {
  233.       if ((e_input[0] != '>') || debugging_log)
  234.          {
  235.          (void) printf ("\n%c %02i %03s %02i:%02i:%02i BINK %s", e_input[0],
  236.              tp->tm_mday, mtext[tp->tm_mon], tp->tm_hour, tp->tm_min, tp->tm_sec,
  237.                   &e_input[1]);
  238.          }
  239.       }
  240.    else
  241.       {
  242.       if ((e_input[0] != '>') || debugging_log)
  243.          {
  244.          (void) sprintf (stat_line, stat_str, e_input[0],
  245.                   tp->tm_hour, tp->tm_min, tp->tm_sec, &e_input[1]);
  246.  
  247.          fill_in_status ();
  248.  
  249. #ifdef OS_2
  250. #ifdef Snoop
  251.          if(hsnoop)
  252.             SnoopWrite(hsnoop, stat_line);
  253. #endif /* Snoop */
  254. #endif /* OS_2  */
  255.          }
  256.       }
  257.    if ((status_log != NULL) &&
  258.        ((strchr (specifiers, e_input[0]) - strchr (specifiers, '!')) <= loglevel))
  259.       {
  260.       (void) fprintf (status_log, "%c %02i %s %02i:%02i:%02i BINK %s\n", e_input[0],
  261.           tp->tm_mday, mtext[tp->tm_mon], tp->tm_hour, tp->tm_min, tp->tm_sec,
  262.                &e_input[1]);
  263.       if (immed_update)
  264.          {
  265.          (void) fflush (status_log);
  266.          (void) real_flush (fileno (status_log));
  267.          need_update = 0;
  268.          }
  269.       else
  270.          {
  271.          need_update = 1;
  272.          }
  273.       }
  274.    va_end (arg_ptr);
  275. }
  276.  
  277. /*--------------------------------------------------------------------------*/
  278. /* THROUGHPUT                                                               */
  279. /* Print throughput message at end of transfer                              */
  280. /*--------------------------------------------------------------------------*/
  281. void throughput (opt, bytes)
  282. int opt;
  283. unsigned long bytes;
  284.  
  285. {
  286.    static long started = 0L;
  287.    static long elapsed;
  288.    static long cps;
  289.  
  290.    if (!opt)
  291.       started = time (NULL);
  292.    else if (started)
  293.       {
  294.       elapsed = time (NULL);
  295.       /* The next line tests for day wrap without the date rolling over */
  296.       if (elapsed < started)
  297.          elapsed += 86400L;
  298.       elapsed -= started;
  299.       if (elapsed == 0L)
  300.          elapsed = 1L;
  301.       cps = (long) (bytes / (unsigned long) elapsed);
  302.       started = (cps * 1000L) / ((long) cur_baud);
  303.       status_line ((char *) msgtxt[M_CPS_MESSAGE], cps, bytes, started);
  304.       }
  305. }                                                /* throughput */
  306.  
  307. static void fill_in_status ()
  308. {
  309.  
  310.    (void) time (<ime);
  311.    tp = localtime (<ime);
  312.    if (fullscreen)
  313.       {
  314.       sb_scrl (callwin, 1);
  315.       sb_move (callwin, SB_ROWS - 15, 2);
  316.       sb_puts (callwin, (unsigned char *) stat_line);
  317.       sb_move (settingswin, SET_TIME_ROW, SET_TIME_COL);
  318.       (void) sprintf (junk, "%s %s %02d @ %02d:%02d",
  319.                wkday[tp->tm_wday], mtext[tp->tm_mon], tp->tm_mday,
  320.                tp->tm_hour, tp->tm_min);
  321.       sb_puts (settingswin, (unsigned char *) junk);
  322.       sb_show ();
  323.       }
  324. }
  325.  
  326. void clear_statusline ()
  327. {
  328.    if (fullscreen)
  329.       sb_fillc (callwin, ' ');
  330. }
  331.  
  332. int got_error (string1, string2)
  333. char *string1, *string2;
  334. {
  335.  
  336. #ifdef __TURBOC__
  337. /*    Since TurboC doesn't handle errno correctly, zero it and ignore. */
  338.     errno = 0;
  339.    status_line ("%s, %s %s %s", msgtxt[M_ERROR], msgtxt[M_CANT], string1, string2);
  340. #else
  341.    if (errno == 0x18)
  342.       errno = 0;
  343.    if (errno != 0)
  344.       {
  345.       status_line ("%s %d, %s %s %s", msgtxt[M_ERROR], errno, msgtxt[M_CANT], string1, string2);
  346.       errno = 0;
  347.       return (1);
  348.       }
  349. #endif
  350.    return (0);
  351. }
  352.  
  353. void set_xy (string)
  354. char *string;
  355. {
  356.    WRITE_ANSI ('\r');
  357.    WRITE_ANSI ('\n');
  358.    scr_printf (string);
  359.    locate_x = wherex ();
  360.    locate_y = wherey ();
  361. }
  362.  
  363. void message (string)
  364. char *string;
  365. {
  366.    if (string != NULL)
  367.       {
  368.       status_line (" %s", string);
  369.       }
  370. }
  371.  
  372. /*
  373. ** Henry Clark 1:124/6120 made changes here 7/28/90
  374. */
  375. void _cdecl time_release ()
  376. {
  377.    if (need_update)
  378.       {
  379.       (void) fflush (status_log);
  380.       (void) real_flush (fileno (status_log));
  381.       need_update = 0;
  382.       }
  383.  
  384. #ifdef OS_2
  385.  
  386.    DosSleep (1L);
  387.  
  388. #else
  389.  
  390.    dos_break_off ();                            /* Turn off ^C trapping */
  391.  
  392.    if (have_dv)
  393.       {
  394.       dv_pause ();
  395.       }
  396.     else if (have_mos)
  397.         {
  398.         mos_pause ();
  399.         }
  400.    else if (have_ddos)
  401.       {
  402.       ddos_pause ();
  403.       }
  404.    else if (have_tv)
  405.       {
  406.       tv_pause ();
  407.       }
  408.    else if (have_ml)
  409.       {
  410.       ml_pause ();
  411.       }
  412.     else
  413.         {
  414.         /* The idea for this code came from Holger Schurig */
  415.         msdos_pause ();
  416.         }
  417.  
  418. #endif /* OS_2 */
  419. }
  420.  
  421. char *fancy_str (string)
  422. char *string;
  423. {
  424.    register int flag = 0;
  425.    char *s;
  426.  
  427.    s = string;
  428.  
  429.    while (*string)
  430.       {
  431.       if (isalpha (*string))                     /* If alphabetic,     */
  432.          {
  433.          if (flag)                               /* already saw one?   */
  434.             *string = tolower (*string);         /* Yes, lowercase it  */
  435.          else
  436.             {
  437.             flag = 1;                            /* first one, flag it */
  438.             *string = toupper (*string);         /* Uppercase it       */
  439.             }
  440.          }
  441.       else /* if not alphabetic  */ flag = 0;    /* reset alpha flag   */
  442.       string++;
  443.       }
  444.  
  445.    return (s);
  446. }
  447. void timer (interval)
  448. int interval;
  449. {
  450.    long timeout, timerset ();
  451.  
  452.    timeout = timerset ((unsigned int) (interval * 10));
  453.    while (!timeup (timeout))
  454.       time_release ();
  455. }
  456.  
  457. void big_pause (secs)
  458. int secs;
  459. {
  460.    long timeout, timerset ();
  461.  
  462.    timeout = timerset ((unsigned int) (secs * 100));
  463.    while (!timeup (timeout))
  464.       {
  465.       if (CHAR_AVAIL ())
  466.          break;
  467.       time_release ();
  468.       }
  469. }
  470.  
  471. int com_getc (t)
  472. int t;
  473. {
  474.    long t1;
  475.    extern long timerset ();
  476.  
  477.    if (!CHAR_AVAIL ())
  478.       {
  479.       t1 = timerset ((unsigned int) (t * 100));
  480.       while (!CHAR_AVAIL ())
  481.          {
  482.          if (timeup (t1))
  483.             {
  484.             return (EOF);
  485.             }
  486.  
  487.          /*
  488.           * This should work because we only do TIMED_READ when we have
  489.           * carrier
  490.           */
  491.          if (!CARRIER)
  492.             {
  493.             return (EOF);
  494.             }
  495.          time_release ();
  496.          }
  497.       }
  498.    return ((unsigned int)(MODEM_IN ()) & 0x00ff);
  499. }
  500.  
  501. /* Z F R E E -- Return total number of free bytes on drive specified */
  502. #ifdef OS_2
  503. long zfree (char *path)
  504. {
  505.    int drive;
  506.    FSALLOCATE dt;
  507.  
  508.    if (!path || !*path)
  509.       drive = 0;
  510.    else
  511.       drive = tolower (*path) - 'a' + 1;
  512.    DosQFSInfo (drive, 1, (char far *) &dt, sizeof (FSALLOCATE));
  513.    return ( dt.cSectorUnit * dt.cUnitAvail * dt.cbSector);
  514. }
  515.  
  516. #else /* OS_2 */
  517.  
  518. long zfree (drive)
  519. char *drive;
  520. {
  521.    union REGS r;
  522.  
  523.    unsigned char driveno;
  524.    long stat;
  525.  
  526.    if (drive[0] != '\0' && drive[1] == ':')
  527.       {
  528.       driveno = (unsigned char) (islower (*drive) ? toupper (*drive) : *drive);
  529.       driveno = (unsigned char) (driveno - 'A' + 1);
  530.       }
  531.    else driveno = 0;                             /* Default drive    */
  532.  
  533.    r.x.ax = 0x3600;                              /* get free space   */
  534.    r.h.dl = driveno;                             /* on this drive    */
  535.    (void) int86 (0x21, &r, &r);                         /* go do it      */
  536.  
  537.    if (r.x.ax == 0xffff)                         /* error return??   */
  538.       return (0);
  539.  
  540.    stat = (long) r.x.bx                          /* bx = clusters avail  */
  541.       * (long) r.x.ax                            /* ax = sectors/clust   */
  542.       * (long) r.x.cx;                           /* cx = bytes/sector    */
  543.  
  544.    return (stat);
  545.  
  546. }
  547.  
  548. #endif /* OS_2 */
  549.  
  550. void scr_printf (string)
  551. char *string;
  552. {
  553.    if (string != NULL)
  554. #ifdef OS_2
  555.       VioWrtTTY (string, (USHORT) strlen (string), (HVIO) 0L);
  556. #else
  557.       while (*string != 0)
  558.          WRITE_ANSI (*string++);
  559. #endif
  560. }
  561.  
  562. void send_can ()
  563. {
  564.    int i;
  565.  
  566.    CLEAR_OUTBOUND ();
  567.    CLEAR_INBOUND ();
  568.  
  569.    for (i = 0; i < 10; i++)
  570.       SENDBYTE (CAN);
  571.    for (i = 0; i < 10; i++)
  572.       SENDBYTE (BS);
  573. }
  574.  
  575. void invent_pkt_name (string)
  576. char string[];
  577.  
  578. {
  579.    struct tm *tp;
  580.    time_t ltime;
  581.  
  582.    (void) time (<ime);
  583.    tp = localtime (<ime);
  584.    (void) sprintf (string, "%02i%02i%02i%02i.pkt",
  585.             tp->tm_mday, tp->tm_hour, tp->tm_min, tp->tm_sec);
  586. }
  587.  
  588. static char *suffixes[8] = {
  589.                             "SU", "MO", "TU", "WE", "TH", "FR", "SA", NULL
  590. };
  591.  
  592. int is_user (p)
  593. char *p;
  594. {
  595.    char *q, *r;
  596.    int i, j;
  597.  
  598.    if (cur_event < 0)
  599.       return (0);
  600.  
  601.    q = strchr (p, '.');
  602.    if (q != NULL)
  603.       {
  604.       ++q;
  605.       for (i = 0; i < 6; i++)
  606.          {
  607.          r = &(e_ptrs[cur_event]->err_extent[i][0]);
  608.          for (j = 0; j < 3; j++)
  609.             {
  610.             if ((tolower (q[j]) != tolower (r[j])) && (q[j] != '?'))
  611.                break;
  612.             }
  613.          if (j == 3)
  614.             user_exits[i] = 1;
  615.          }
  616.       }
  617.  
  618.    return (0);
  619. }
  620.  
  621. int is_arcmail (p, n)
  622. char *p;
  623. int n;
  624. {
  625.    int i;
  626.    char c[128];
  627.  
  628.    if (!isdigit (p[n]))
  629.       {
  630.       return (is_user (p));
  631.       }
  632.  
  633.    (void) strcpy (c, p);
  634.    (void) strupr (c);
  635.  
  636.    for (i = n - 11; i < n - 3; i++)
  637.       {
  638.       if ((!isdigit (c[i])) && ((c[i] > 'F') || (c[i] < 'A')))
  639.          return (is_user (p));
  640.       }
  641.  
  642.    for (i = 0; i < 7; i++)
  643.       {
  644.       if (strnicmp (&c[n - 2], suffixes[i], 2) == 0)
  645.          break;
  646.       }
  647.  
  648.    if (i >= 7)
  649.       {
  650.       return (is_user (p));
  651.       }
  652.  
  653.    got_arcmail = 1;
  654.    return (1);
  655. }
  656.  
  657. int get_number (target)
  658. char *target;
  659. {
  660.    ADDR gaddr;
  661.    int k;
  662.  
  663.    (void) fgets (target, 100, stdin);
  664.    k = (int) strlen (target);
  665.    if (k == 1)
  666.       return (0);
  667.    target[--k] = '\0';                           /* no '\n' */
  668.    if (!isdigit (target[0]) && target[0] != '\"')
  669.       {
  670.       fidouser (target, &gaddr);
  671.       if ((gaddr.Net != -1) && (gaddr.Node != -1) && (gaddr.Zone != -1))
  672.          {
  673.          sprintf (target, "%s", Full_Addr_Str (&gaddr));
  674.          }
  675.       else return (0);                           /* Gotta have addr */
  676.       }
  677.    return (1);
  678. }
  679.  
  680. void gong ()
  681. {
  682.    long t, timerset ();
  683.    int i;
  684.  
  685.    if (!gong_allowed)
  686.       return;
  687.  
  688.    for (i = 0; i < 15; i++)
  689.       {
  690.       WRITE_ANSI ('\07');                        /* Bell code       */
  691.       t = timerset (100);                        /* 1 second        */
  692.       while (!timeup (t))
  693.          {
  694.          if (KEYPRESS ())                        /* If key pressed, */
  695.             {
  696.             (void) READKB ();                           /* Throw it away   */
  697.             return;                              /* And get out     */
  698.             }
  699.          }
  700.       }
  701. }
  702.  
  703. char *skip_blanks (string)
  704. char *string;
  705. {
  706.    while (*string && isspace (*string))
  707.       ++string;
  708.    return (string);
  709. }
  710.  
  711. char *skip_to_blank (string)
  712. char *string;
  713. {
  714.    while (*string && (!isspace (*string)))
  715.       ++string;
  716.    return (string);
  717. }
  718.  
  719. #ifdef DEBUG
  720. void show_debug_name (string)
  721. char *string;
  722. {
  723.    int x, y;
  724.    static char *filler = "                           ";
  725.  
  726.    x = wherex ();
  727.    y = wherey ();
  728.    gotoxy (40, 0);
  729.    scr_printf (string);
  730.    scr_printf (&filler[strlen (string)]);
  731.    gotoxy (x, y);
  732. }
  733. #endif
  734.  
  735. int parse (input, list)
  736. char *input;
  737. struct parse_list list[];
  738.  
  739. {
  740.    int i;
  741.  
  742.    for (i = 0; list[i].p_length; i++)
  743.       {
  744.       if (strnicmp (input, list[i].p_string, (unsigned int) list[i].p_length) == 0)
  745.          return (++i);
  746.       }
  747.    return (-1);
  748. }
  749.  
  750. void change_prompt ()
  751. {
  752.    char *s;
  753.  
  754.    if (newstring[0])
  755.       {
  756.       (void) putenv (newstring);
  757.       return;
  758.       }
  759.  
  760.    (void) strcpy (newstring, "PROMPT=[");
  761.    (void) strcat (newstring, xfer_id);
  762. #ifdef OVERLAYS
  763.    (void) strcat (newstring, "-Overlay");
  764. #endif
  765.    (void) strcat (newstring, " Shell]$_");
  766.    s = getenv ("PROMPT");
  767.    if (s)
  768.       {
  769.       (void) strcat (newstring, s);
  770.       }
  771.    else
  772.       {
  773.       (void) strcat (newstring, "$P$G");
  774.       }
  775.  
  776.    (void) putenv (newstring);
  777. }
  778.  
  779. void update_files (t)
  780. int t;
  781. {
  782.    char s[10];
  783.  
  784.    if (un_attended && fullscreen)
  785.       {
  786.       if (t)
  787.          {
  788.          ++hist.files_out;
  789.          }
  790.       else
  791.          {
  792.          ++hist.files_in;
  793.          }
  794.  
  795.       sb_move (historywin, HIST_FILE_ROW, HIST_COL);
  796.       (void) sprintf (s, "%d/%d", hist.files_in, hist.files_out);
  797.       sb_puts (historywin, (unsigned char *) s);
  798.       sb_show ();
  799.       }
  800. }
  801.  
  802. static char *last_str[] = {
  803.                            "     None    ",
  804.                            "     WaZOO   ",
  805.                            "     FTS-0001",
  806.                            "     BBS     ",
  807.                            "     Ext Mail"
  808. };
  809.  
  810. void last_type (n, taddr)
  811. int n;
  812. ADDR *taddr;
  813. {
  814.    int i;
  815.    char *p;
  816.    char j[20];
  817.  
  818.    if (fullscreen)
  819.       sb_move (historywin, HIST_LAST_ROW, HIST_COL2);
  820.  
  821.    if ((n == 1) || (n == 2))
  822.       {
  823.       if ((taddr->Zone != -1000) && (taddr->Net > 0))
  824.          {
  825.          (void) sprintf (j, "%s", Full_Addr_Str (taddr));
  826. if ((p = strchr (j, '@')) != NULL)
  827. *p = '\0';
  828.          for (i = (int) strlen (j); i < 13; i++)
  829.             j[i] = ' ';
  830.          j[i] = '\0';
  831.          hist.last_zone = taddr->Zone;
  832.          hist.last_net = taddr->Net;
  833.          hist.last_node = taddr->Node;
  834.          }
  835.       else
  836.          {
  837.          (void) strcpy (j, "     FTS-0001");
  838.          }
  839.       if (fullscreen)
  840.          sb_puts (historywin, (unsigned char *) j);
  841.       }
  842.    else
  843.       {
  844.       if ((n < 0) || (n > 4))
  845.          n = 0;
  846.  
  847.       if (fullscreen)
  848.          sb_puts (historywin, (unsigned char *) last_str[n]);
  849.       }
  850.  
  851.    hist.last_caller = n;
  852. }
  853.  
  854.  
  855. /*--------------------------------------------------------------------------*/
  856. /* CHECK_NETFILE -- find out if the file we've got is a netfile.            */
  857. /*--------------------------------------------------------------------------*/
  858.  
  859. char *check_netfile (fname)
  860. char *fname;
  861. {
  862.    register char *p;
  863.    register int n;
  864.  
  865.    p = fname;
  866.    n = (int) strlen (p) - 1;
  867.  
  868.    if ((p[n] == 't') && (p[n - 1] == 'k') && (p[n - 2] == 'p') && (p[n - 3] == '.'))
  869.       {
  870.       got_packet = 1;
  871.       got_mail = 1;
  872.       p = msgtxt[M_MAIL_PACKET];
  873.       }
  874.    else if (is_arcmail (p, n))
  875.       {
  876.       got_mail = 1;
  877.       p = msgtxt[M_COMPRESSED_MAIL];
  878.       }
  879.    else
  880.       {
  881.       /* Don't set 'got_mail' if it's a .REQ file */
  882.       if ((p[n] != 'q') || (p[n - 1] != 'e') || (p[n - 2] != 'r') || (p[n - 3] != '.'))
  883.          got_mail = 1;
  884.       p = msgtxt[M_NET_FILE];
  885.       }
  886.  
  887.    return (p);
  888. }
  889.  
  890. /*--------------------------------------------------------------------------*/
  891. /* UNIQUE_NAME                                                              */
  892. /* Increments the suffix of a filename as necessary to make the name unique */
  893. /*--------------------------------------------------------------------------*/
  894. void unique_name (fname)
  895. char *fname;
  896. {
  897.    static char suffix[] = ".001";
  898.    register char *p;
  899.    register int n;
  900.  
  901.    if (dexists (fname))
  902.       {                                          /* If file already exists...      */
  903.       p = fname;
  904.       while (*p && *p != '.')
  905.          p++;                                    /* ...find the extension, if
  906.                                                   * any  */
  907.       for (n = 0; n < 4; n++)                    /* ...fill it out if
  908.                                                   * neccessary   */
  909.          if (!*p)
  910.             {
  911.             *p = suffix[n];
  912.             *(++p) = '\0';
  913.             }
  914.          else p++;
  915.  
  916.       while (dexists (fname))                    /* ...If 'file.ext' exists
  917.                                                   * suffix++ */
  918.          {
  919.          p = fname + strlen (fname) - 1;
  920.          for (n = 3; n--;)
  921.             {
  922.             if (!isdigit (*p))
  923.                *p = '0';
  924.             if (++(*p) <= '9')
  925.                break;
  926.             else *p-- = '0';
  927.             }                                    /* for */
  928.          }                                       /* while */
  929.       }                                          /* if exist */
  930. }                                                /* unique_name */
  931.  
  932. int got_ESC ()
  933. {
  934.    while (KEYPRESS ())
  935.       {
  936.       screen_blank = 0;
  937.       if (fullscreen && un_attended)
  938.          sb_show ();
  939.       if (READKB () == 27)     /* ESC pressed?        */
  940.          {
  941.          while (KEYPRESS ())
  942.             (void) READKB ();
  943.          return (1);
  944.          }
  945.       }
  946.    return (0);
  947. }
  948.  
  949. long cost_of_call (s, e)
  950. long s, e;
  951. {
  952.    long a;
  953.  
  954.    a = e - s;
  955.    a = (a + 59) / 60;
  956.    return (a * newnodedes.RealCost);
  957. }
  958.  
  959. void screen_clear ()
  960. {
  961.    register int r;
  962.    unsigned int far *q;
  963.  
  964.    if (!vfossil_installed)
  965.       scr_printf ("\033[H\033[2J");
  966.    else
  967.       {
  968.       for (r = 0; r <= SB_ROWS; r++)
  969.          {
  970.          q = (unsigned int far *) blanks;
  971. #ifndef OS_2
  972.          (void) VioWrtCellStr (q, SB_COLS * 2, r, 0, 0);
  973. #else
  974.          (void) VioWrtCellStr ((PCH) q, (USHORT) (SB_COLS * 2), (USHORT) r, (USHORT) 0, (HVIO) 0L);
  975. #endif
  976.          }
  977.  
  978.       gotoxy (0, 0);
  979.       }
  980. }
  981.  
  982. void clear_eol ()
  983. {
  984.    int x, y;
  985.    unsigned int far *q;
  986.    if (!vfossil_installed)
  987.       (void) printf ("\033[K");
  988.    else
  989.       {
  990.       x = wherex();
  991.       y = wherey();
  992.  
  993.       q = (unsigned int far *) blanks;
  994. #ifndef OS_2
  995.       (void) VioWrtCellStr (q, (SB_COLS - (unsigned) x) * 2, y, x, 0);
  996. #else
  997.       (void) VioWrtCellStr ((PCH) q, (USHORT) ((SB_COLS - x) * 2), (USHORT) y, (USHORT) x, (HVIO) 0L);
  998. #endif
  999.       }
  1000. }
  1001.  
  1002. void log_product (product, version, subversion)
  1003. int product;
  1004. int version;
  1005. int subversion;
  1006. {
  1007.    switch (product)
  1008.       {
  1009.       case isBITBRAIN :
  1010.       case isFIDO     :
  1011.       case isSPARK    :
  1012.       case isSEA      :
  1013.       case isSlick    :
  1014.       case isHENK     :
  1015.       case isTABBIE   :
  1016.       case isWOLF     :
  1017.       case isQMM      :
  1018.       case isFD       :
  1019.       case isGSPOINT  :
  1020.       case isBGMAIL   :
  1021.       case isCROSSBOW :
  1022.       case isDBRIDGE  :
  1023.       case isDAISY    :
  1024.       case isPOLAR    :
  1025.       case isTHEBOX   :
  1026.       case isWARLOCK  :
  1027.       case isTCOMM    :
  1028.       case isBANANNA  :
  1029.       case isAPPLE    :
  1030.       case isCHAMELEON:
  1031.       case isMAJIK    :
  1032.       case isDOMAIN   :
  1033.       case isLESROBOT :
  1034.       case isROSE     :
  1035.       case isPARAGON  :
  1036.       case isBINKST   :
  1037.       case isSTARNET  :
  1038.       case isQUICKBBS :
  1039.       case isPBBS     :
  1040.       case isTRAPDOOR :
  1041.       case isWELMAT   :
  1042.       case isTIMS     :
  1043.       case isISIS     :
  1044.          status_line ("%s %s %s %d.%02d", msgtxt[M_REMOTE_USES],
  1045.              prodcode[product], msgtxt[M_VERSION], version, subversion);
  1046.          break;
  1047.  
  1048.       case isOPUS:
  1049.          status_line ("%s Opus %s %d.%02d", msgtxt[M_REMOTE_USES],
  1050.                       msgtxt[M_VERSION], version,
  1051.                       (subversion == 48) ? 0 : subversion);
  1052.          break;
  1053.  
  1054.       default:
  1055.          status_line ("%s %s '%02x' %s %d.%02d", msgtxt[M_REMOTE_USES],
  1056.                       msgtxt[M_PROGRAM], product,
  1057.                       msgtxt[M_VERSION], version, subversion);
  1058.          break;
  1059.       }
  1060. return;
  1061. }
  1062.  
  1063. int next_minute ()
  1064. {
  1065.    int hours, mins, secs, ths;
  1066.  
  1067.    /* Get the DOS time */
  1068.    dostime (&hours, &mins, &secs, &ths);
  1069.  
  1070.    return ((60 - (secs % 60)) * 100 + 1);
  1071. }
  1072.  
  1073. void can_Janus (p)
  1074. char *p;
  1075. {
  1076.    J_TYPESP j;
  1077.  
  1078.    janus_OK = 0;
  1079.    for (j = j_top; j != NULL; j = j->next)
  1080.       {
  1081.       if (strnicmp (p, j->j_match, strlen (j->j_match)) == 0)
  1082.          {
  1083.          janus_OK = 1;
  1084.          break;
  1085.          }
  1086.       }
  1087. }
  1088.  
  1089. int check_failed (fname, theirname, info, ourname)
  1090. char *fname, *theirname, *info, *ourname;
  1091. {
  1092.    FILE *abortlog;
  1093.    char linebuf[64];
  1094.     char *p, *badname;
  1095.     int ret;
  1096.  
  1097.     ret = 0;
  1098.    if ((abortlog = fopen (fname, read_ascii)) == NULL)
  1099.       {
  1100.       (void) got_error (msgtxt[M_OPEN_MSG], fname);
  1101.       }
  1102.    else
  1103.       {
  1104.       while (!feof (abortlog))
  1105.          {
  1106.          linebuf[0] = '\0';
  1107.          if (!fgets ((p = linebuf), 64, abortlog))
  1108.             break;
  1109.          while (*p >= ' ')
  1110.             ++p;
  1111.          *p = '\0';
  1112.          p = strchr (linebuf, ' ');
  1113.          *p = '\0';
  1114.          if (!stricmp (linebuf, theirname))
  1115.             {
  1116.             p = strchr ((badname = ++p), ' ');
  1117.             *p = '\0';
  1118.             if (!stricmp (++p, info))
  1119.                {
  1120.                strcpy (ourname, badname);
  1121.                     ret = 1;
  1122.                break;
  1123.                }
  1124.             }
  1125.          }
  1126.       fclose (abortlog);
  1127.       }
  1128.  
  1129.     return (ret);
  1130. }
  1131.  
  1132. void add_abort (fname, rname, cname, cpath, info)
  1133. char *fname, *rname, *cname, *cpath, *info;
  1134. {
  1135.     FILE *abortlog;
  1136.     char namebuf[100];
  1137.  
  1138.    strcpy (namebuf, cpath);
  1139.    strcat (namebuf, "BadWaZOO.001");
  1140.    unique_name (namebuf);
  1141.    rename (cname, namebuf);
  1142.    if ((abortlog = fopen (fname, "at")) == NULL)
  1143.       {
  1144.       (void) got_error (msgtxt[M_OPEN_MSG], fname);
  1145.       unlink (namebuf);
  1146.       }
  1147.    else
  1148.       {
  1149.       fprintf (abortlog, "%s %s %s\n", rname, namebuf + strlen (cpath), info);
  1150.       fclose (abortlog);
  1151.       }
  1152. }
  1153.  
  1154. void remove_abort (fname, rname)
  1155. char *fname, *rname;
  1156. {
  1157.     FILE *abortlog, *newlog;
  1158.     char namebuf[100];
  1159.     char linebuf[100];
  1160.     char *p;
  1161.     int c;
  1162.  
  1163.     if (!dexists (fname))
  1164.         return;
  1165.  
  1166.    if ((abortlog = fopen (fname, read_ascii)) == NULL)
  1167.       {
  1168.       (void) got_error (msgtxt[M_OPEN_MSG], fname);
  1169.       }
  1170.    else
  1171.       {
  1172.       strcpy (namebuf, fname);
  1173.       strcpy (namebuf + strlen (namebuf) - 1, "TMP");
  1174.       c = 0;
  1175.       if ((newlog = fopen (namebuf, write_ascii)) == NULL)
  1176.          {
  1177.          (void) got_error (msgtxt[M_OPEN_MSG], namebuf);
  1178.          fclose (abortlog);
  1179.          }
  1180.       else
  1181.          {
  1182.          while (!feof (abortlog))
  1183.             {
  1184.             linebuf[0] = '\0';
  1185.             if (!fgets (linebuf, 64, abortlog))
  1186.                break;
  1187.             p = linebuf;
  1188.             while (*p > ' ')
  1189.                ++p;
  1190.             *p = '\0';
  1191.             if (stricmp (linebuf, rname))
  1192.                {
  1193.                *p = ' ';
  1194.                fputs (linebuf, newlog);
  1195.                ++c;
  1196.                }
  1197.             }
  1198.          fclose (abortlog);
  1199.          fclose (newlog);
  1200.          unlink (fname);
  1201.          if (c)
  1202.             rename (namebuf, fname);
  1203.          else unlink (namebuf);
  1204.          }
  1205.       }
  1206. }
  1207.  
  1208. /*
  1209.  * The next routine is used in the count down timer during file
  1210.  * transfers, and were provided by Jon Sabol, along with the other code that
  1211.  * calls these routines.
  1212.  */
  1213.  
  1214. void elapse_time ()
  1215. {
  1216.    time_t ltime;
  1217.    long eh;
  1218.    long em;
  1219.    long es;
  1220.  
  1221.  
  1222.    if (fullscreen && (un_attended || doing_poll))
  1223.       {
  1224.       time (<ime);
  1225.  
  1226.       if (ltime < etm)
  1227.          ltime += 86400L;
  1228.  
  1229.       eh = (ltime - etm) / 3600L;
  1230.       em = ((ltime - etm) / 60L) - (eh * 60L);
  1231.       es = (ltime - etm) - (eh * 3600L) - (em * 60L);
  1232.  
  1233.       sb_move (settingswin, SET_TASK_ROW, SET_TIME_COL);
  1234.       sprintf (junk, "%s:  %02ld:%02ld:%02ld", msgtxt[M_ELAPSED], eh, em, es);
  1235.       sb_puts (settingswin, junk);
  1236.       sb_show ();
  1237.       }
  1238. }
  1239.  
  1240. static int find_addr (node, addr, d)
  1241. char *node;
  1242. ADDR *addr;
  1243. char *d;
  1244. {
  1245.    int ret;
  1246.  
  1247.     ret = 1;
  1248.    if (alias[0].Node == -1)
  1249.       addr->Zone = 0;
  1250.    else
  1251.       addr->Zone = alias[0].Zone;
  1252.    addr->Net = 0;
  1253.    addr->Node = 0;
  1254.    addr->Point = 0;
  1255.    addr->Domain = NULL;
  1256.    d[0] = '\0';
  1257.    if ((ret = sscanf (node, "%d:%d/%d.%d@%s",
  1258.       &(addr->Zone), &(addr->Net), &(addr->Node), &(addr->Point), d)) < 3)
  1259.       {
  1260.       if (alias[0].Node == -1)
  1261.          addr->Zone = 0;
  1262.       else
  1263.          addr->Zone = alias[0].Zone;
  1264.       if ((ret = sscanf (node, "%d/%d.%d@%s",
  1265.          &(addr->Net), &(addr->Node), &(addr->Point), d)) < 2)
  1266.          {
  1267.          addr->Net = alias[0].Net;
  1268.          if (sscanf (node, "%d.%d@%s",
  1269.             &(addr->Node), &(addr->Point), d) < 1)
  1270.             {
  1271.             ret = 0;
  1272.             }
  1273.          else if (ret == 1)
  1274.             {
  1275.             (void) sscanf (node, "%d@%s",
  1276.                &(addr->Node), d);
  1277.             }
  1278.          }
  1279.       else if (ret == 2)
  1280.          {
  1281.          (void) sscanf (node, "%d/%d@%s",
  1282.             &(addr->Net), &(addr->Node), d);
  1283.          }
  1284.       }
  1285.    else if (ret == 3)
  1286.       {
  1287.       (void) sscanf (node, "%d:%d/%d@%s",
  1288.          &(addr->Zone), &(addr->Net), &(addr->Node), d);
  1289.       }
  1290.  
  1291.    return (ret);
  1292. }
  1293.  
  1294. int parse_address (node, addr)
  1295. char *node;
  1296. ADDR *addr;
  1297. {
  1298.     int ret;
  1299.    char d[100];
  1300.  
  1301.    ret = find_addr (node, addr, d);
  1302.  
  1303.    if (d[0] != '\0')
  1304.       {
  1305.       addr->Domain = add_domain (d);
  1306.       }
  1307.  
  1308.     return (ret);
  1309. }
  1310.  
  1311. int find_address (node, addr)
  1312. char *node;
  1313. ADDR *addr;
  1314. {
  1315.    int ret;
  1316.    char d[100];
  1317.    char *p;
  1318.  
  1319.    d[0] = '\0';
  1320.    p = skip_blanks (node);
  1321.    if (!isdigit (*p))
  1322.       {
  1323.       fidouser (p, addr);
  1324.       if ((addr->Net == -1) || (addr->Node == -1) || (addr->Zone == -1))
  1325.          {
  1326.          ret = 0;
  1327.          }
  1328.       else
  1329.          {
  1330.          ret = 1;
  1331.          }
  1332.       }
  1333.    else
  1334.       {
  1335.       ret = find_addr (p, addr, d);
  1336.       }
  1337.  
  1338.    if (d[0] != '\0')
  1339.       {
  1340.       addr->Domain = find_domain (d);
  1341.       }
  1342.  
  1343.    return (ret);
  1344. }
  1345.  
  1346. char *add_domain (d)
  1347. char *d;
  1348. {
  1349.    char *p;
  1350.    int i;
  1351.  
  1352.    for (i = 0; (p = domain_name[i]) != NULL; i++)
  1353.       {
  1354.       if (strnicmp (d, p, strlen (p)) == 0)
  1355.          return (p);
  1356.       }
  1357.  
  1358.    if (i >= 49)
  1359.       return (NULL);
  1360.  
  1361.    domain_name[i] = strdup (d);
  1362.    return (domain_name[i]);
  1363. }
  1364.  
  1365. char *find_domain (d)
  1366. char *d;
  1367. {
  1368.    char *p, *q, *s;
  1369.    char c;
  1370.    int i, j, k;
  1371.  
  1372.    j = strlen (d);
  1373.    /* First see if we can find the whole domain name at the right */
  1374.    for (i = 0; (p = domain_name[i]) != NULL; i++)
  1375.       {
  1376.       k = strlen (p);
  1377.       if (k > j)
  1378.          continue;
  1379.  
  1380.       q = &(d[j - k]);
  1381.       if (strnicmp (q, p, k) == 0)
  1382.          {
  1383.          return (p);
  1384.          }
  1385.       }
  1386.  
  1387.    /* Ok, now see if we can find the abbreviated name at the right */
  1388.    for (i = 0; (p = domain_abbrev[i]) != NULL; i++)
  1389.       {
  1390.       k = strlen (p);
  1391.       if (k > j)
  1392.          continue;
  1393.  
  1394.       q = &(d[j - k]);
  1395.       if (strnicmp (q, p, k) == 0)
  1396.          {
  1397.          return (domain_name[i]);
  1398.          }
  1399.       }
  1400.  
  1401.    /* If there is a period in it, see if we can match the abbreviated name
  1402.       just before the period */
  1403.    if ((s = strrchr (d, '.')) != NULL)
  1404.       {
  1405.       c = *s;
  1406.       *s = '\0';
  1407.       j = strlen (d);
  1408.       for (i = 0; (p = domain_abbrev[i]) != NULL; i++)
  1409.          {
  1410.          k = strlen (p);
  1411.          if (k > j)
  1412.             continue;
  1413.  
  1414.          q = &(d[j - k]);
  1415.          if (strnicmp (q, p, k) == 0)
  1416.             {
  1417.             *s = c;
  1418.             return (domain_name[i]);
  1419.             }
  1420.          }
  1421.       *s = c;
  1422.       }
  1423.  
  1424.    return (NULL);
  1425. }
  1426.  
  1427. char addr_str[100];
  1428.  
  1429. char *Hex_Addr_Str (a)
  1430. ADDR *a;
  1431. {
  1432.    sprintf (addr_str, "%04x%04x", a->Net, a->Node);
  1433.    return (addr_str);
  1434. }
  1435.  
  1436. char *Full_Addr_Str (a)
  1437. ADDR *a;
  1438. {
  1439.    char t1[10];
  1440.    char t2[30];
  1441.    char t3[10];
  1442.    char t4[50];
  1443.  
  1444.    if (a->Zone && !no_zones)
  1445.       sprintf (t1, "%u:", a->Zone);
  1446.    else
  1447.       t1[0] = '\0';
  1448.  
  1449.    sprintf (t2, "%u/%u", a->Net, a->Node);
  1450.  
  1451.    if (a->Point)
  1452.       sprintf (t3, ".%u", a->Point);
  1453.    else
  1454.       t3[0] = '\0';
  1455.  
  1456.    if (a->Domain != NULL)
  1457.       sprintf (t4, "@%s", a->Domain);
  1458.    else
  1459.       t4[0] = '\0';
  1460.  
  1461.    strcpy (addr_str, t1);
  1462.    strcat (addr_str, t2);
  1463.    strcat (addr_str, t3);
  1464.    strcat (addr_str, t4);
  1465.    return (addr_str);
  1466. }
  1467.  
  1468. unsigned int crc_block(ptr, count)
  1469. unsigned char *ptr;
  1470. int count;
  1471. {
  1472.     unsigned int crc;
  1473.     int i;
  1474.  
  1475.    for (crc = 0, i = 0; i < count; i++, ptr++)
  1476.       {
  1477.       crc = xcrc (crc, (byte) *ptr);
  1478.         }
  1479.     return (crc & 0xFFFF);
  1480.     }
  1481.  
  1482. void Data_Check (xtmp, mode)
  1483. XMDATAP xtmp;
  1484. int mode;
  1485. {
  1486.     int i;
  1487.     unsigned char cs;
  1488.     unsigned char *cp;
  1489.     unsigned int cs1;
  1490.  
  1491.     /* If we are in checksum mode, just do it */
  1492.     if (mode == CHECKSUM)
  1493.         {
  1494.         cp = xtmp->data_bytes;
  1495.         cs = 0;
  1496.         for (i = 0; i < 128; i++)
  1497.             {
  1498.             cs += *cp++;
  1499.             }
  1500.         xtmp->data_check[0] = cs;
  1501.         }
  1502.     /* If we are in CRC mode, run the characters through the CRC calculator */
  1503.     else
  1504.         {
  1505.         cs1 = crc_block (xtmp->data_bytes, 128);
  1506.         xtmp->data_check[0] = (unsigned char) (cs1 >> 8);
  1507.         xtmp->data_check[1] = (unsigned char) (cs1 & 0xff);
  1508.         }
  1509.     }
  1510.  
  1511. static int buff_bytes = 0;
  1512.  
  1513. FILE *buff_fopen (fname, fmode)
  1514. char *fname;
  1515. char *fmode;
  1516. {
  1517.     buff_bytes = 0;
  1518.     return (fopen (fname, fmode));
  1519. }
  1520.  
  1521. int buff_fwrite (buff, size1, size2, fp)
  1522. char *buff;
  1523. int size1;
  1524. int size2;
  1525. FILE *fp;
  1526. {
  1527.     if ((buff_bytes + (size1 * size2)) > WAZOOMAX)
  1528.         {
  1529.         (void) fwrite (Secbuf, 1, buff_bytes, fp);
  1530.         buff_bytes = 0;
  1531.         }
  1532.  
  1533.     memcpy (Secbuf + buff_bytes, buff, size1 * size2);
  1534.     buff_bytes += size1 * size2;
  1535.     return (size1 * size2);
  1536. }
  1537.  
  1538. int buff_fclose (fp)
  1539. FILE *fp;
  1540. {
  1541.     (void) fwrite (Secbuf, 1, buff_bytes, fp);
  1542.     buff_bytes = 0;
  1543.     return (fclose (fp));
  1544. }
  1545.  
  1546. long buff_fseek (fp, a, b)
  1547. FILE *fp;
  1548. long a;
  1549. int b;
  1550. {
  1551.     (void) fwrite (Secbuf, 1, buff_bytes, fp);
  1552.     buff_bytes = 0;
  1553.     return (fseek (fp, a, b));
  1554. }
  1555.  
  1556. #ifdef OS_2
  1557. void set_prior (int pclass)
  1558. {
  1559.     char *s;
  1560.     static USHORT regular = 0;
  1561.     static USHORT janus = 0;
  1562.     static USHORT modem = 0;
  1563.     USHORT priority;
  1564.  
  1565.     switch (pclass)
  1566.         {
  1567.         case 2:
  1568.             if (regular)
  1569.                priority = regular;
  1570.             else
  1571.                {
  1572.                s = getenv("REGULARPRIORITY");
  1573.                if (s)
  1574.                   priority = regular = atoi(s);
  1575.                else
  1576.                   priority = regular = 2;
  1577.                }
  1578.            break;
  1579.  
  1580.         case 3:
  1581.             if (janus)
  1582.                priority = janus;
  1583.             else
  1584.                {
  1585.                s = getenv("JANUSPRIORITY");
  1586.                if (s)
  1587.                   priority = janus = atoi(s);
  1588.                else
  1589.                   priority = janus = 3;
  1590.                }
  1591.            break;
  1592.  
  1593.         case 4:
  1594.             if (modem)
  1595.                priority = modem;
  1596.             else
  1597.                {
  1598.                s = getenv("MODEMPRIORITY");
  1599.                if (s)
  1600.                   priority = modem = atoi(s);
  1601.                else
  1602.                   priority = modem = 4;
  1603.                }
  1604.             break;
  1605.  
  1606.         default:
  1607.             priority = 2;
  1608.             break;
  1609.         }
  1610.  
  1611.    (void) DosSetPrty ((USHORT) 1, priority, (SHORT) 31, (USHORT) 0);
  1612. }
  1613.  
  1614. #ifdef Snoop
  1615. #pragma check_stack(off)
  1616. static int far pascal _loadds mesgfunc(int error, char far *mesg)
  1617. {
  1618.     if(!error)
  1619.         status_line(":%Fs", mesg);
  1620.     else
  1621.         status_line("!SYS%04u : %Fs", error, mesg);
  1622.     return(0);
  1623. }
  1624. #pragma check_stack()
  1625.  
  1626. void snoop_open(char *pipename)
  1627. {
  1628.    static char *pipe = NULL;
  1629.    if(pipe)
  1630.       free(pipe);
  1631.    if(pipename)
  1632.       pipe = strdup(pipename);
  1633.    SnoopOpen(pipe, &hsnoop, xfer_id, (PFNSN)mesgfunc);
  1634. }
  1635.  
  1636. void snoop_close(void)
  1637. {
  1638.     if(hsnoop)
  1639.         SnoopClose(hsnoop);
  1640.     hsnoop = (HSNOOP)NULL;
  1641. }
  1642. #endif /* Snoop */
  1643. #else /* OS_2 */
  1644. void set_prior (int pclass)
  1645. {
  1646.    return;
  1647.    pclass = 5;
  1648. }
  1649. #endif /* OS_2 */
  1650.