home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / packetdrivers.tar.gz / pd.tar / src / pktdrvr.c < prev    next >
C/C++ Source or Header  |  1995-06-25  |  4KB  |  197 lines
  1. /* Turbo C Driver for FTP Software's packet driver interface.
  2.  * Graciously donated to the public domain by Phil Karn.
  3.  */
  4. #include <stdio.h>
  5. #include <dos.h>
  6. #include <string.h>
  7. #include "pktdrvr.h"
  8.  
  9. int Derr;
  10. static char Pkt_sig[] = "PKT DRVR";    /* Packet driver signature */
  11.  
  12. /* Test for the presence of a packet driver at an interrupt number.
  13.  * Return 0 if no packet driver.
  14.  */
  15. int
  16. test_for_pd(intno)
  17. int intno;
  18. {
  19.     long drvvec;
  20.     char sig[8];    /* Copy of driver signature "PKT DRVR" */
  21.  
  22.     /* Verify that there's really a packet driver there, so we don't
  23.      * go off into the ozone (if there's any left)
  24.      */
  25.     drvvec = (long)getvect(intno);
  26.     _fmemcpy(sig, MK_FP(FP_SEG(drvvec),FP_OFF(drvvec)+3),
  27.         strlen(Pkt_sig));
  28.     return !strncmp(sig,Pkt_sig,strlen(Pkt_sig));
  29. }
  30.  
  31. int
  32. access_type(intno,if_class,if_type,if_number,type,typelen,receiver)
  33. int intno;
  34. int if_class;
  35. int if_type;
  36. int if_number;
  37. char *type;
  38. unsigned typelen;
  39. int interrupt (*receiver)();
  40. {
  41.     union REGS regs;
  42.     struct SREGS sregs;
  43.  
  44.     segread(&sregs);
  45.     regs.h.dl = if_number;        /* Number */
  46.     sregs.ds = FP_SEG(type);    /* Packet type template */
  47.     regs.x.si = FP_OFF(type);
  48.     regs.x.cx = typelen;        /* Length of type */
  49.     sregs.es = FP_SEG(receiver);    /* Address of receive handler */
  50.     regs.x.di = FP_OFF(receiver);
  51.     regs.x.bx = if_type;        /* Type */
  52.     regs.h.ah = ACCESS_TYPE;    /* Access_type() function */
  53.     regs.h.al = if_class;        /* Class */
  54.     int86x(intno,®s,®s,&sregs);
  55.     if(regs.x.cflag){
  56.         Derr = regs.h.dh;
  57.         return -1;
  58.     } else
  59.         return regs.x.ax;
  60. }
  61. int
  62. release_type(intno,handle)
  63. int intno;
  64. int handle;
  65. {
  66.     union REGS regs;
  67.  
  68.     regs.x.bx = handle;
  69.     regs.h.ah = RELEASE_TYPE;
  70.     int86(intno,®s,®s);
  71.     if(regs.x.cflag){
  72.         Derr = regs.h.dh;
  73.         return -1;
  74.     } else
  75.         return 0;
  76. }
  77. int
  78. send_pkt(intno,buffer,length)
  79. int intno;
  80. char *buffer;
  81. unsigned length;
  82. {
  83.     union REGS regs;
  84.     struct SREGS sregs;
  85.  
  86.     segread(&sregs);
  87.     sregs.ds = FP_SEG(buffer);
  88.     sregs.es = FP_SEG(buffer); /* for buggy univation pkt driver - CDY */
  89.     regs.x.si = FP_OFF(buffer);
  90.     regs.x.cx = length;
  91.     regs.h.ah = SEND_PKT;
  92.     int86x(intno,®s,®s,&sregs);
  93.     if(regs.x.cflag){
  94.         Derr = regs.h.dh;
  95.         return -1;
  96.     } else
  97.         return 0;
  98. }
  99. int
  100. driver_info(intno,handle,version,class,type,number,basic)
  101. int intno;
  102. int handle;
  103. int *version,*class,*type,*number,*basic;
  104. {
  105.     union REGS regs;
  106.  
  107.     regs.x.bx = handle;
  108.     regs.h.ah = DRIVER_INFO;
  109.     regs.h.al = 0xff;
  110.     int86(intno,®s,®s);
  111.     if(regs.x.cflag){
  112.         Derr = regs.h.dh;
  113.         return -1;
  114.     }
  115.     if(version != NULL)
  116.         *version = regs.x.bx;
  117.     if(class != NULL)
  118.         *class = regs.h.ch;
  119.     if(type != NULL)
  120.         *type = regs.x.dx;
  121.     if(number != NULL)
  122.         *number = regs.h.cl;
  123.     if(basic != NULL)
  124.         *basic = regs.h.al;
  125.     return 0;
  126. }
  127. int
  128. get_mtu(intno)
  129. int intno;
  130. {
  131.     union REGS regs;
  132.     struct SREGS sregs;
  133.     char far *param;
  134.  
  135.     regs.h.ah = GET_PARAMETERS;
  136.     int86x(intno,®s,®s,&sregs);
  137.     if(regs.x.cflag){
  138.         Derr = regs.h.dh;
  139.         return -1;
  140.     }
  141.     param = MK_FP(sregs.es, regs.x.di);
  142.     return ((unsigned char)param[4]) + 256 * ((unsigned char)param[5]);
  143. }
  144. int
  145. get_address(intno,handle,buf,len)
  146. int intno;
  147. int handle;
  148. char *buf;
  149. int len;
  150. {
  151.     union REGS regs;
  152.     struct SREGS sregs;
  153.  
  154.     segread(&sregs);
  155.     sregs.es = FP_SEG(buf);
  156.     regs.x.di = FP_OFF(buf);
  157.     regs.x.cx = len;
  158.     regs.x.bx = handle;
  159.     regs.h.ah = GET_ADDRESS;
  160.     int86x(intno,®s,®s,&sregs);
  161.     if(regs.x.cflag){
  162.         Derr = regs.h.dh;
  163.         return -1;
  164.     }
  165.     return 0;
  166. }
  167. /* set the mode -- returns the old mode or -1 if error. */
  168. int
  169. set_mode(intno, handle, mode)
  170. int intno;
  171. int handle;
  172. int mode;
  173. {
  174.     union REGS regs;
  175.     char far *param;
  176.     int oldmode;
  177.  
  178.     regs.h.ah = GET_RCV_MODE;
  179.     regs.x.bx = handle;
  180.     int86(intno,®s,®s);
  181.     if(regs.x.cflag){
  182.         Derr = regs.h.dh;
  183.         return -1;
  184.     }
  185.     oldmode = regs.x.ax;
  186.  
  187.     regs.h.ah = SET_RCV_MODE;
  188.     regs.x.cx = mode;
  189.     regs.x.bx = handle;
  190.     int86(intno,®s,®s);
  191.     if(regs.x.cflag){
  192.         Derr = regs.h.dh;
  193.         return -1;
  194.     }
  195.     return oldmode;
  196. }
  197.