home *** CD-ROM | disk | FTP | other *** search
/ Programmer Power Tools / Programmer Power Tools.iso / opus / fvsrc620.arc / FOSCOM.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-25  |  16.1 KB  |  556 lines
  1. /*--------------------------------------------------------------------------*/
  2. /*                                                                          */
  3. /* Copyright 1989, Doug Boone   FidoNet 119/5                               */
  4. /* Copyright 1989, John Valentyn FidoNet 114/18                             */
  5. /*                                                                          */
  6. /*                              (916) 893-9019 Data                         */
  7. /*                              (916) 891-0748 voice                        */
  8. /*                              P.O. Box 5108, Chico, CA. 95928             */
  9. /*                                                                          */
  10. /* Originally by John Vallentyn (FidoNet 114/15), so you'll need his        */
  11. /* permission too.                                                          */
  12. /*                                                                          */
  13. /* This program is not for sale. It is for the free use with Opus systems.  */
  14. /* You may not sell it in ANY way. If you have an access charge to your     */
  15. /* Bulletin Board, consider this to be like Opus, you can ONLY make it      */
  16. /* available for download in an open area, where non-members can get access */
  17. /*                                                                          */
  18. /* If you need to modify this source code, please send me a copy of the     */
  19. /* changes you've made so that everyone can share in the updates.           */
  20. /*                                                                          */
  21. /* "Don't rip me off!" -- Tom Jennings, FidoNet's founder                   */
  22. /*                                                                          */
  23. /*--------------------------------------------------------------------------*/
  24.  
  25. #include     <stdio.h>
  26. #include     <ctype.h>
  27. #include     <time.h>
  28. #include    <dos.h>
  29. #include    <conio.h>
  30. #include    <stdarg.h>
  31. #include    <stdlib.h>
  32. #ifdef TURBOC
  33. #include    <alloc.h>
  34. #include <sys\timeb.h>
  35. #else
  36. #include    <malloc.h>
  37. #endif
  38. #include    "archdr.h"
  39.  
  40. extern    int        baud;
  41. extern    int        port;
  42. extern    int        flags;
  43. extern    int        line;
  44. extern    int        screen;
  45. extern    int        ctrl_err;
  46. extern  long    quit_time;
  47.  
  48. extern    int  (cdecl * cdecl sdisplay)(char *);    /* ptr to display function */
  49. extern    int  (cdecl * cdecl get_a_char)(void);    /* instead of getch()    */
  50. extern    int  (cdecl * cdecl chk_keyboard)(void);    /* instead of kbhit()    */
  51.  
  52. int        GetDriverInfo(void);
  53. int        CkFossilCD(void);
  54. int     Com_(unsigned,unsigned);
  55. int     Comm_Set_Baud(int,int,int,int);
  56. void     Comm_transmit(int);
  57. int     Comm_Receive(void);
  58. int     Get_Comm_Status(void);
  59. int     Comm_Char_Avail(void);
  60. int     Comm_Init(int,int,int,int);
  61. void     Comm_De_Init(void);
  62. void     Comm_Dtr(int);
  63. void     Comm_flush_out(void);
  64. void     Comm_Purge_out(void);
  65. void     Comm_Purge_in(void);
  66. void     Comm_Watch(int);
  67. char     Comm_Peek(void);
  68. int     Comm_CD(void);
  69. int     locputs(register char *);
  70. int     fosputs(register char *);
  71. int     play(const char *,...);
  72. void     sendbyte(byte);
  73. void    ask_more(void);
  74.  
  75. extern  void    terminate(int);
  76.  
  77. struct fos_info {    /* info avail via 0x1B function           */
  78.    int    info_size;    /* Offset 0 (word) = Structure size       */
  79.    char    fos_spec;    /*        2 (byte) = FOSSIL spec version  */
  80.    char    drvr_rev;    /*        3 (byte) = Driver rev level     */
  81.    char far *fos_id;    /*        4 (dwrd) = Pointer to ASCII ID  */
  82.    int    ibuf_sz;    /*        8 (word) = Input buffer size    */
  83.    int    ibuf_free;    /*       0A (word) = Bytes avail (input)  */
  84.    int    obuf_sz;    /*       0C (word) = Output buffer size   */
  85.    int    obuf_free;    /*       0E (word) = Bytes avail (output) */
  86.    char    scrn_width;    /*       10 (byte) = Screen width, chars  */
  87.    char    scrn_height;    /*       11 (byte) = Screen height, chars */
  88.    char    baud_msk;    /*       12 (byte) = Baud rate mask       */
  89. } fossil_info =
  90.    { 0, 0, 0, 0L, 0, 0, 0, 0, 0, 0, 0 };
  91.  
  92.  
  93. /* ====================================================================
  94.  * Fill in the fossil information block
  95.  * ====================================================================
  96.  */
  97. int GetDriverInfo(void)
  98. {
  99.     union REGS regs;
  100.     struct SREGS segregs;
  101.     int result;
  102.     char far *p;
  103.  
  104.     p = (char far *) &fossil_info;
  105.     regs.h.al = 0;
  106.     regs.h.ah = 0x1B;            /* function = get driver info */
  107.     regs.x.cx = sizeof(struct fos_info);
  108.     regs.x.di = FP_OFF (p);
  109.     segregs.es = segregs.ds = FP_SEG (p);
  110.     regs.x.dx = port;
  111.     result=int86x(FOSSIL_INT, ®s, ®s, &segregs);
  112.     return(result);
  113. }
  114.  
  115. /* ====================================================================
  116.  *  CkFossilCD() -- Check if Fossil initiallized and CD on
  117.  * ====================================================================
  118.  */
  119. int CkFossilCD(void)
  120. {
  121.     union REGS regs;
  122.     long far *INTword;
  123.     int far *IDword;
  124.  
  125.     INTword = (long far *) 0x50;      /* get interrupt pointer for INT 14h function */
  126.     IDword  = (int far *) *INTword+3; /* point to sig word 1954 and add offset */
  127.     if(*IDword != 0x1954) {           /* if FOSSIL not installed */
  128.         printf("FOSSIL not installed...\n");
  129.         return(FALSE);
  130.         }
  131.     regs.h.al = 0;
  132.     regs.h.ah = 0x04;    /* function = initialize driver */
  133.     regs.x.dx = port;
  134.     regs.x.bx = 0;        /* no ^C */
  135.     int86(FOSSIL_INT, ®s, ®s);
  136.     if(regs.x.ax != 0x1954)
  137.         return(FALSE);        /* unable to initialize fossil */
  138.     if (flags & FOSSIL) {
  139.         Comm_Dtr(1);        /* insure that DTR is on */
  140.         return(Get_Comm_Status() & DCD);    /* return DCD */
  141.         }
  142.     else
  143.         return(TRUE);
  144. }
  145.  
  146. /* ====================================================================
  147.  * General purpose comm function
  148.  * ====================================================================
  149.  */
  150. int Com_(unsigned funct,unsigned chr)
  151. {
  152.     union REGS regs;
  153.     int result;
  154.  
  155.     regs.h.al = (byte)chr;
  156.     regs.h.ah = (byte)funct;
  157.     regs.x.dx = port;
  158.     result=int86(FOSSIL_INT, ®s, ®s);
  159.     return(result);
  160. }
  161.  
  162. /* ====================================================================
  163.  * fossil function 0 = Set baud rate
  164.  * ====================================================================
  165.  */
  166. int Comm_Set_Baud(int BaudRate,
  167.           int DataBits,
  168.           int StopBits,
  169.           int Parity)
  170. { 
  171.     union REGS regs;
  172.     register int value;
  173.  
  174.     switch(BaudRate/300) {
  175.         case 1:   value = 0x40;    break;
  176.         case 2:   value = 0x60;    break;
  177.         case 4:   value = 0x80;    break;
  178.         case 8:   value = 0xA0;    break;
  179.         case 16:  value = 0xC0;    break;
  180.         case 32:  value = 0xE0;    break;
  181.         case 64:  value = 0;    break;
  182.         default: return(FALSE);
  183.         }
  184.     switch (Parity) {
  185.         case 0: break;
  186.         case 1: value |= 0x8; break;
  187.         case 2: value |= 0xA; break;
  188.         default: return(FALSE);
  189.         }
  190.     switch(StopBits-1) {
  191.         case 0: break;
  192.         case 1: value |= 0x4; break;
  193.         default: return(FALSE);
  194.         }
  195.     switch (DataBits-7)    {
  196.         case 0: value |= 0x2; break;
  197.         case 1: value |= 0x3; break;
  198.         default: return(FALSE);
  199.         }
  200.     regs.h.ah = 0x00;
  201.     regs.h.al = (byte)value;
  202.     regs.x.dx = port;
  203.     int86(FOSSIL_INT, ®s, ®s);
  204.     return(TRUE);
  205. } 
  206.  
  207. /* ====================================================================
  208.  * fossil function 1 - transmit character with wait
  209.  * ====================================================================
  210.  */
  211. void Comm_transmit(int chr)
  212. {
  213.     union REGS regs;
  214.  
  215.     regs.h.ah = 0x01;
  216.     regs.h.al = (byte)chr;
  217.     regs.x.dx = port;
  218.     int86(FOSSIL_INT, ®s, ®s);
  219.     return;
  220. } 
  221.  
  222. /* ====================================================================
  223.  * fossil function 2 - receive character with wait
  224.  * ====================================================================
  225.  */
  226. int Comm_Receive(void)
  227. {
  228.     union REGS regs;
  229.  
  230.     do {        /* Watch carrier while waiting for next charatcher */
  231.         if (Comm_CD() == FALSE)
  232.             terminate(3);
  233.         if (kbhit())         /* Allows local keyboard over-ride */
  234.             return(getch());
  235.         } while (Comm_Peek() == 0xff);
  236.   
  237.     regs.h.ah = 0x02; 
  238.     regs.h.al = 0x00;
  239.     regs.x.dx = port;
  240.     int86(FOSSIL_INT, ®s, ®s);
  241.     regs.h.ah = 0x00;
  242.     return(regs.x.ax); 
  243. } 
  244.  
  245. /* ====================================================================
  246.  * get status of comm port
  247.  * ====================================================================
  248.  */
  249. int Get_Comm_Status(void)
  250. {
  251.     union REGS regs;
  252.  
  253.     regs.h.ah = 0x03;    /* function = request status */
  254.     regs.h.al = 0x00; 
  255.     regs.x.dx = port;
  256.     int86(FOSSIL_INT, ®s, ®s);
  257.  
  258.     if (!(regs.x.ax & DCD) && flags & FOSSIL)
  259.         terminate(3);
  260.  
  261.     if (regs.x.ax == 0xffff)        /* Hangs sometimes clear buffer */
  262.         Comm_Purge_out();
  263.  
  264.     return(regs.x.ax);
  265. } 
  266.  
  267. /* ====================================================================
  268.  * check if character available in input buffer
  269.  * ====================================================================
  270.  */
  271. int Comm_Char_Avail(void)
  272. {
  273.     union REGS regs;
  274.  
  275.     regs.h.ah = 0x03;    /* function = request status */
  276.     regs.h.al = 0x00;
  277.     regs.x.dx = port;
  278.     int86(FOSSIL_INT, ®s, ®s); 
  279.     regs.x.ax = regs.x.ax & 0x0100;    /* check input data avail, ah bit 0 */
  280.     if (regs.x.ax == 0)
  281.         return(FALSE);
  282.     return(TRUE);
  283. }
  284.  
  285. /* ====================================================================
  286.  * function 4 - initialize driver
  287.  * ==================================================================== */
  288. int Comm_Init(int BaudRate,
  289.       int DataBits,
  290.       int StopBits,
  291.       int Parity)
  292. {
  293.     union REGS regs;
  294.  
  295.     regs.h.ah = 0x04;
  296.     regs.h.al = (byte)(BaudRate | DataBits | StopBits | Parity);
  297.     regs.x.dx = port;
  298.     regs.x.bx = 0;    /* no ^C code */ 
  299.     int86(FOSSIL_INT, ®s, ®s);
  300.     return(regs.x.ax);
  301. }
  302.  
  303. /* ====================================================================
  304.  * function 5 - deinitialize driver
  305.  * ====================================================================
  306.  */
  307. void Comm_De_Init(void)
  308. {
  309.     union REGS regs;
  310.  
  311.     regs.h.ah = 0x05;
  312.     regs.h.al = 0;
  313.     regs.x.dx = port;
  314.     int86(FOSSIL_INT, ®s, ®s);
  315.     return;
  316. } 
  317.  
  318. /* ====================================================================
  319.  * function 6 - Raise/Lower DTR
  320.  * ====================================================================
  321.  */
  322. void Comm_Dtr(int flag)
  323. {
  324.     union REGS regs;
  325.  
  326.     regs.h.ah = 0x06;
  327.     regs.h.al = (byte)flag;    /* 01h=Raise 00h=Lower */
  328.     regs.x.dx = port;
  329.     int86(FOSSIL_INT, ®s, ®s);
  330.     return;
  331. }
  332.  
  333. /* ====================================================================
  334.  * function 8 - flush output buffer
  335.  * ====================================================================
  336.  */
  337. void Comm_flush_out(void)
  338. {
  339.     union REGS regs;
  340.  
  341.     regs.h.ah = 0x08;
  342.     regs.h.al = 0x00;
  343.     regs.x.dx = port; 
  344.     int86(FOSSIL_INT, ®s, ®s);
  345.     return;
  346. } 
  347.  
  348. /* ====================================================================
  349.  * function 9 - purge output buffer
  350.  * ====================================================================
  351.  */
  352. void Comm_Purge_out(void)
  353. {
  354.     union REGS regs;
  355.  
  356.     regs.h.ah = 0x09;
  357.     regs.h.al = 0x00;
  358.     regs.x.dx = port;
  359.     int86(FOSSIL_INT, ®s, ®s);
  360.     return;
  361. }
  362.  
  363. /* ====================================================================
  364.  * function 10 (0Ah) - purge input buffer
  365.  * ====================================================================
  366.  */
  367. void Comm_Purge_in(void)
  368. {
  369.     union REGS regs;
  370.  
  371.     regs.h.ah = 0x0A;
  372.     regs.h.al = 0x00;
  373.     regs.x.dx = port;
  374.     int86(FOSSIL_INT, ®s, ®s);
  375.     return;
  376. }
  377.  
  378. /* ====================================================================
  379.  * function 14 - Watchdog On/Off
  380.  * ====================================================================
  381.  */
  382. void Comm_Watch(int flag)
  383. {
  384.     union REGS regs;
  385.  
  386.     regs.h.ah = 0x14;
  387.     regs.h.al = (byte)flag;    /* 01h=Watchdog on 00h=Watchdog off */
  388.     regs.x.dx = port;
  389.     int86(FOSSIL_INT, ®s, ®s);
  390.     return;
  391. }
  392. /*--------------------------------------------------------------------------*/
  393. /* Look ahead at input buffer, primarily to check for ^C                    */
  394. /*--------------------------------------------------------------------------*/
  395. char Comm_Peek(void)
  396. {
  397.     union REGS regs;
  398.  
  399.     regs.h.ah = 0x0C;
  400.     regs.x.dx = port;
  401.     int86(FOSSIL_INT, ®s,®s);
  402.     return(regs.h.al);
  403. }
  404.  
  405. /* ====================================================================
  406.  *  Check for carrier detect returns TRUE (1) while carrier is high
  407.  * ====================================================================
  408.  */
  409. int Comm_CD(void)
  410. {
  411.     union REGS regs;
  412.  
  413.     regs.h.ah = 0x03;
  414.     regs.x.dx = port;
  415.     int86(FOSSIL_INT, ®s,®s);
  416.     if (regs.h.al & DCD)
  417.         return(TRUE);
  418.     else
  419.         return(FALSE);
  420. }
  421.  
  422.  
  423. /* ====================================================================
  424.  *  Local display function - access via display()
  425.  * ====================================================================
  426.  */
  427. int locputs(register char *str)
  428. {
  429.     register int c;
  430.  
  431.     while (*str && ctrl_err) {
  432.         c = *str++;
  433.         putchar(c);
  434.         if (c == '\n')
  435.             line++;
  436.         if (line > (screen-2) && flags & MORE)
  437.             ask_more();
  438.         }
  439.     return(0);
  440. }
  441.  
  442. /* ====================================================================
  443.  *  Fossil display function - access via display()
  444.  * ====================================================================
  445.  */
  446. int fosputs(register char *str)
  447. {
  448.     register int c;
  449.  
  450.     while (*str && ctrl_err) {
  451.         c = *str++;
  452.         putchar(c);        /* So what's going on will display locally!! */
  453.         if(c == '\n') {
  454.             Comm_transmit('\r');
  455.             line++;
  456.             if (Comm_Peek() == 0x13) {
  457.                 Comm_Purge_in();
  458.                 while (Comm_Peek() == 0xff);
  459.                 Comm_Purge_in();
  460.                 }
  461.             else if (Comm_Peek() == 0x03) {
  462.                 Comm_Purge_in();
  463.                 Comm_Purge_out();
  464.                 ctrl_err = 0;
  465.                 }
  466.             }
  467.         Comm_transmit(c);
  468.         if (line > (screen-2) && flags & MORE)
  469.             ask_more();
  470.         }
  471.     while(!(Get_Comm_Status() & TSRE));    /* wait for output buffer to empty */
  472.     return(0);
  473. }
  474.  
  475. /* ====================================================================
  476.  * display is a printf function to either the console or the comm port
  477.  * note that the argument is variable (therefore must be cdecl convention)
  478.  * ====================================================================
  479.  */
  480. int play(const char *fmt,...)
  481. {
  482.     char pbuf[BUFSIZ];
  483.     va_list arg_ptr;
  484.  
  485.     va_start(arg_ptr, fmt);
  486.     vsprintf(pbuf, fmt, arg_ptr);
  487.     va_end(arg_ptr);
  488.     sdisplay(pbuf);
  489.     return(0);
  490. }
  491.  
  492. /* ====================================================================
  493.  * sendbyte outputs a character to either the console or the comm port
  494.  * ====================================================================
  495.  */
  496. void sendbyte(byte ch)
  497. {
  498.  
  499.     if(flags & FOSSIL) {
  500.         if(ch == '\n') {
  501.             Comm_transmit('\r');
  502.             line++;
  503.             if (!(Comm_CD()))
  504.                 terminate(3);
  505.             }
  506.         Comm_transmit(ch);
  507.         putchar(ch);
  508.         while(!(Get_Comm_Status() & TSRE));    /* wait for output buffer to empty */
  509.         return;
  510.         }
  511.     else
  512.         putchar(ch);
  513.     return;
  514. }
  515. /*--------------------------------------------------------------------------*/
  516. /* If user has More? on in their user record                                */
  517. /*--------------------------------------------------------------------------*/
  518.  
  519. void    ask_more(void)
  520. {
  521.     char    ch;
  522.  
  523.     line = 0;
  524.  
  525.     if (quit_time < time(NULL))        /* Check the time */
  526.         ctrl_err = 0;
  527.  
  528.     if (flags & FOSSIL) {        /* Check carrier, exit(3) if lost */
  529.         if (!(Comm_CD()))
  530.             terminate(3);
  531.  
  532.     if (Comm_Peek() == 0x03) {        /* Check for ^C inbound buffer */
  533.             ctrl_err = 0;
  534.             Comm_Purge_in();        /* Clear all buffers */
  535.             Comm_Purge_out();
  536.             }
  537.         }
  538.     sdisplay("More [Y,n,=]?  ");
  539.     ch = (char) get_a_char();
  540.     sdisplay("\n");
  541.     switch(ch) {
  542.  
  543.         case '\03':
  544.         case 'n':
  545.         case 'N':     ctrl_err = 0;
  546.                     return;
  547.  
  548.         case '=':
  549.         case '+':     flags &= ~MORE;
  550.                     break;
  551.  
  552.         default:    break;
  553.         }
  554.     return;
  555. }
  556.