home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / msvp98b1.lzh / MSNPKT.C < prev    next >
Text File  |  1993-05-14  |  6KB  |  202 lines
  1. /* File MSNPKT.C
  2.  * Packet Driver interface
  3.  *
  4.  * Copyright (C) 1985, 1992, Trustees of Columbia University in the 
  5.  * City of New York.  Permission is granted to any individual or institution
  6.  * to use this software as long as it is not sold for profit.  This copyright
  7.  * notice must be retained.  This software may not be included in commercial
  8.  * products without written permission of Columbia University.
  9.  *
  10.  * Written for MS-DOS Kermit by Joe R. Doupnik, 
  11.  *  Utah State University, jrd@cc.usu.edu, jrd@usu.Bitnet
  12.  *
  13.  * Last edit
  14.  * 25 May 1992
  15.  */
  16. #include "msntcp.h"
  17. #include "msnlib.h"
  18.  
  19. #define BUFSIZE    3000            /* size of pkt receive buffer */
  20.  
  21. word    pkt_ip_type = 0x0008;        /* these are little endian values */
  22. word    pkt_arp_type = 0x0608;
  23. word    pkt_rarp_type = 0x3580;
  24.  
  25. word    pkt_ip_handle = -1;        /* -1 means invalid handle */
  26. word    pkt_arp_handle = -1;
  27. word    pkt_rarp_handle = -1;
  28.  
  29. int    pdversion, pdtype, pdnum, pdfunct;
  30. extern    word pktdevclass;
  31. extern    int pdinit(), pdinfo(), pdaccess(), pdclose();
  32. extern    eth_address eth_addr;
  33.  
  34. byte pktbuf[BUFSIZE] = {0};    /* linked list packet receive buffer */
  35. static byte * pktbuf_read = pktbuf;
  36. byte pktwnum = 0;        /* seq number for packets written to buffer */
  37. byte pktrnum = 0;        /* seq number for packets read from buffer */
  38. byte * pktbuf_wrote = &pktbuf[BUFSIZE - 4];
  39.  
  40. int
  41. pkt_eth_init()
  42. {
  43.     
  44.         pkt_buf_wipe();        /* clean out and init receiver buffer */
  45.     if (pdinit(pktbuf, eth_addr) == 0)
  46.             {
  47.         outs("\r\nCannot attach to an Ethernet Packet Driver");
  48.         outs(" or a Novell ODI driver.");
  49.         return( 0 );
  50.         }
  51.     pkt_buf_wipe();
  52.                     /* lets find out about the driver */
  53.     if ((pdinfo(&pdversion, &pktdevclass, &pdtype, &pdnum, &pdfunct))
  54.         == 0)
  55.         {
  56.         outs("\r\nCannot obtain Packet Driver or ODI information");
  57.         return (0);
  58.         }
  59.     if (pdaccess(&pkt_ip_type, 
  60.     (pktdevclass == PD_SLIP)? 0: sizeof(pkt_ip_handle), &pkt_ip_handle)
  61.         == 0)
  62.          {
  63.         outs("\r\n\7Cannot access IP type packets");
  64.         return (0);
  65.         }
  66.     if (pktdevclass == PD_SLIP)        /* SLIP uses only IP */
  67.         return (1);
  68.  
  69.     if (pdaccess(&pkt_arp_type, sizeof(pkt_arp_handle), &pkt_arp_handle)
  70.         == 0)
  71.          {
  72.         outs("\r\n\7Cannot access ARP type packets");
  73.         return (0);
  74.         }
  75.     return (1);                /* say success */
  76. }
  77.  
  78. int
  79. pkt_rarp_init()                /* access PD for RARP */
  80. {
  81.     if (pkt_rarp_handle != -1)
  82.         return (1);        /* have handle already */
  83.  
  84.     if (pdaccess(&pkt_rarp_type, sizeof(pkt_rarp_handle), &pkt_rarp_handle)
  85.         == 0)
  86.          {
  87.         outs("\r\n\7Cannot access RARP type packets");
  88.         return (0);
  89.         }
  90.     return (1);                /* say success */
  91. }
  92.  
  93. int
  94. pkt_release()
  95. {
  96.     register int status = 1;            /* assume success */
  97.  
  98.     if (pkt_ip_handle != -1)
  99.         if (pdclose(pkt_ip_handle) == 0)
  100.             {
  101.             outs("\r\nERROR releasing Packet Driver for IP");
  102.             status = 0;
  103.             }
  104.         else pkt_ip_handle = -1;    /* handle is out of service */
  105.  
  106.     if ( pktdevclass == PD_SLIP ) return (0);
  107.  
  108.         if (pkt_arp_handle != -1)
  109.         if (pdclose(pkt_arp_handle) == 0)
  110.             {
  111.             outs("\r\nERROR releasing Packet Driver for ARP");
  112.             status = 0;
  113.             }
  114.         else pkt_arp_handle = -1;    /* handle is out of service */
  115.  
  116.     if (pkt_rarp_handle != -1)
  117.         if (pdclose(pkt_rarp_handle) == 0)
  118.             {
  119.             outs("\r\nERROR releasing Packet Driver for RARP");
  120.             status = 0;
  121.             }
  122.         else pkt_rarp_handle = -1;    /* handle is out of service */
  123.     return (status);
  124. }
  125.  
  126. /* Deliver pointer to start of packet (destination address) or NULL.
  127.  * Simple linked list: byte flag, byte pkt seq number, int count, 
  128.  * byte data[count] and so on.
  129.  * Status on the link flag byte is
  130.  * 0 = end of buffer (count has size to point to start of buffer)
  131.  * 1 = this slot is free (unused)
  132.  * 2 = this slot has an unread packet
  133.  * 4 = this slot is allocated for a packet, packet not yet loaded into it
  134.  * 8 = this slot has a packet which has been read once
  135.  * A two byte count value follows the flag byte, for number of bytes in 
  136.  * this slot. Pktbuf_read remembers the pointer to the last-read slot.
  137. */
  138.  
  139. void * pkt_received()
  140. {
  141.     register byte * p;
  142.     register int i;
  143.  
  144.     p = pktbuf_read;            /* start with last read */
  145.     for (i = 0; i < 2 * (BUFSIZE / (60 + 4)); i++)    /* 2 * max pkts */
  146.         {
  147.         if (*p == 2 && *(p+1) == pktrnum) /* 2 == ready to be read */
  148.             {            /* if this is the next pkt */
  149.              pktbuf_read = p;    /* where we have read */
  150.             *p = 8;            /* mark as have read */
  151.             pktrnum++;        /* next one to read */
  152.             return (p + 4);        /* return ptr to pkt*/
  153.             }
  154. /* if link is:    end of buf    free     ready      allocated   have read */
  155.         if (*p == 0 || *p == 1 || *p == 2 || *p == 4 || *p == 8)
  156.             {
  157.             p += 4 + *(word *)(p+2);   /* point at next link */
  158.             continue;
  159.             }
  160.         else                /* bad link information */
  161.             {
  162.             pkt_buf_wipe();        /* emergency treatment */
  163.             break;
  164.             }
  165.         if (p == pktbuf_read) break;    /* where we came in */
  166.         }
  167.     return (NULL);
  168. }
  169.     
  170. void
  171. pkt_buf_release(byte *p)    /* return a buffer to the pool */
  172. {
  173.     disable();        /* disallow interrupts here */
  174.     if (pktdevclass == PD_SLIP)
  175.         p -= 4;            /* just link info */
  176.     else
  177.         p -= 4 + 6 + 6 + 2;    /* link info and MAC header */
  178.  
  179.     if (*p == 8)        /* if packet has been read */
  180.         *p = 1;        /* mark link as freed */
  181.     enable();
  182. }
  183.  
  184. void
  185. pkt_buf_wipe()                    /* clear all buffers */
  186. {
  187.     disable();
  188.     pktbuf[0] = 1;                /* flag first link as free */
  189.     pktbuf[1] = 0;
  190.     *(word *)&pktbuf[2] = BUFSIZE - 8; /* free space, size - two links */
  191.  
  192.     pktbuf[BUFSIZE - 4] = 0;        /* flag as end of buffer */
  193.     pktbuf[BUFSIZE - 3] = 0;        /* pkt buffer seq number */
  194.                 /* count below points to start of buffer */
  195.     *(word *)&pktbuf[BUFSIZE - 2] = - BUFSIZE; 
  196.     pktbuf_read = pktbuf;                /* where last read */
  197.     pktbuf_wrote = &pktbuf[BUFSIZE - 4];        /* where last wrote*/
  198.     pktwnum = pktrnum = 0;        /* reset buffer sequence numbers */
  199.     enable();
  200. }
  201.  
  202.