home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 5 / DATAFILE_PDCD5.iso / internet / netlite2 / DCI / c / MBUF < prev    next >
Encoding:
Text File  |  1993-04-29  |  5.7 KB  |  259 lines
  1. #include <stdlib.h>
  2. #include <string.h>
  3. #include "kernel.h"
  4. #include "global.h"
  5.  
  6. static struct packet packet_list[MAXPACKET];
  7.  
  8. void initialise_packet(void)
  9. {
  10.         register int i;
  11.  
  12.         for (i = 0; i < MAXPACKET; i++)
  13.                 packet_list[i].status = PACKET_FREE;
  14. }
  15.  
  16. int initialise_rx_mbuf(int n)
  17. {
  18.         struct mbuf *nbp, *fbp, *pbp;
  19.         register int i;
  20.  
  21.         for (i = 0; i < n; i++)
  22.         {
  23.                 if ((nbp = (struct mbuf *)malloc(sizeof(struct mbuf))) == NULLMBUF)
  24.                         return(FALSE);
  25.  
  26.                 nbp->m_next  = NULLMBUF;
  27.                 nbp->m_off   = MMINOFF;
  28.                 nbp->m_len   = 0;
  29.                 nbp->m_type  = MT_FREE;
  30.                 nbp->m_indir = FALSE;
  31.                 nbp->m_act   = NULLMBUF;
  32.  
  33.                 if (i > 0)
  34.                         pbp->m_next = nbp;
  35.                 else
  36.                         fbp = nbp;
  37.  
  38.                 pbp = nbp;
  39.         }
  40.  
  41.         rxfreeq_first = fbp;
  42.         rxfreeq_last  = pbp;
  43.  
  44.         return(TRUE);
  45. }
  46.  
  47. int initialise_tx_mbuf(int n)
  48. {
  49.         struct mbuf *nbp, *fbp, *pbp;
  50.         register int i;
  51.  
  52.         for (i = 0; i < n; i++)
  53.         {
  54.                 if ((nbp = (struct mbuf *)malloc(sizeof(struct mbuf))) == NULLMBUF)
  55.                         return(FALSE);
  56.  
  57.                 nbp->m_next  = NULLMBUF;
  58.                 nbp->m_off   = MMINOFF;
  59.                 nbp->m_len   = 0;
  60.                 nbp->m_type  = MT_FREE;
  61.                 nbp->m_indir = FALSE;
  62.                 nbp->m_act   = NULLMBUF;
  63.  
  64.                 if (i > 0)
  65.                         pbp->m_next = nbp;
  66.                 else
  67.                         fbp = nbp;
  68.  
  69.                 pbp = nbp;
  70.         }
  71.  
  72.         txfreeq_first = fbp;
  73.         txfreeq_last  = pbp;
  74.  
  75.         return(TRUE);
  76. }
  77.  
  78. struct packet *alloc_packet(void)
  79. {
  80.         register int i;
  81.         int state;
  82.  
  83.         state = ensure_irqs_off();
  84.  
  85.         for (i = 0; i < MAXPACKET; i++)
  86.         {
  87.                 if (packet_list[i].status == PACKET_FREE)
  88.                 {
  89.                         packet_list[i].status = PACKET_USED;
  90.                         restore_irqs(state); 
  91.                         return(packet_list + i);
  92.                 }
  93.         }
  94.  
  95.         restore_irqs(state);
  96.  
  97.         return(NULLPACKET);
  98. }
  99.  
  100. void free_packet(struct packet *p)
  101. {
  102.         p->status = PACKET_FREE;
  103. }
  104.  
  105. struct mbuf *alloc_tx_mbuf(register unsigned int n)
  106. {
  107.         struct mbuf *nbp, *fbp, *pbp;
  108.         int state;
  109.  
  110.         if (n == 0) return(NULLMBUF);
  111.  
  112.         state = ensure_irqs_off();
  113.  
  114.         for (fbp = nbp = txfreeq_first;
  115.              n > 0 && nbp != NULLMBUF;
  116.              nbp = nbp->m_next, n--)
  117.         {
  118.                 nbp->m_off   = MMINOFF;
  119.                 nbp->m_len   = 0;
  120.                 nbp->m_type  = MT_FREE;
  121.                 nbp->m_indir = FALSE;
  122.                 nbp->m_act   = NULLMBUF;
  123.  
  124.                 pbp = nbp;
  125.         }
  126.  
  127.         txfreeq_first = pbp->m_next;
  128.  
  129.         pbp->m_next = NULLMBUF;
  130.  
  131.         restore_irqs(state);
  132.  
  133.         return(fbp);
  134. }
  135.  
  136. void free_tx_mbuf(register struct mbuf *bp)
  137. {
  138.         register struct mbuf *nbp, *pbp;
  139.         int state;
  140.  
  141.         if (bp == NULLMBUF) return;
  142.  
  143.         for (nbp = bp; nbp != NULLMBUF; nbp = nbp->m_next)
  144.         {
  145.                 nbp->m_off   = MMINOFF;
  146.                 nbp->m_len   = 0;
  147.                 nbp->m_type  = MT_FREE;
  148.                 nbp->m_indir = FALSE;
  149.                 nbp->m_act   = NULLMBUF;
  150.  
  151.                 pbp = nbp;
  152.         }
  153.  
  154.         state = ensure_irqs_off();
  155.  
  156.         txfreeq_last->m_next = bp;
  157.         txfreeq_last         = pbp;
  158.  
  159.         restore_irqs(state);
  160. }
  161.  
  162. void free_rx_mbuf(register struct mbuf *bp)
  163. {
  164.         register struct mbuf *nbp, *pbp;
  165.         int state;
  166.  
  167.         if (bp == NULLMBUF) return;
  168.  
  169.         for (nbp = bp; nbp != NULLMBUF; nbp = nbp->m_next)
  170.         {
  171.                 nbp->m_off   = MMINOFF;
  172.                 nbp->m_len   = 0;
  173.                 nbp->m_type  = MT_FREE;
  174.                 nbp->m_indir = FALSE;
  175.                 nbp->m_act   = NULLMBUF;
  176.  
  177.                 pbp = nbp;
  178.         }
  179.  
  180.         state = ensure_irqs_off();
  181.  
  182.         rxfreeq_last->m_next = bp;
  183.         rxfreeq_last         = pbp;
  184.  
  185.         restore_irqs(state);
  186. }
  187.  
  188. int len_mbuf(register struct mbuf *bp)
  189. {
  190.         register int size;
  191.  
  192.         for (size = 0; bp != NULLMBUF; size += bp->m_len, bp = bp->m_next);
  193.  
  194.         return(size);
  195. }
  196.  
  197. struct mbuf *qdata(int size, register char *data)
  198. {
  199.         register struct mbuf *bp, *tbp;
  200.         register int length;
  201.         register char *s;
  202.  
  203.         if ((bp = alloc_tx_mbuf(size / MLEN + 2)) == NULLMBUF)
  204.                  return(NULLMBUF);
  205.  
  206.         for (tbp = bp; size > 0; tbp = tbp->m_next)
  207.         {
  208.                  length = (size > MLEN) ? MLEN : size;
  209.  
  210.                  size -= length;
  211.                  tbp->m_len = length;
  212.  
  213.                  s = tbp->m_dat;
  214.  
  215.                  while (length-- > 0)
  216.                        *s++ = *data++;
  217.  
  218.                  tbp->m_off   = MMINOFF;
  219.                  tbp->m_type  = MT_DATA;
  220.                  tbp->m_indir = FALSE;
  221.                  tbp->m_act   = NULLMBUF;
  222.         }
  223.  
  224.         return(bp);
  225. }
  226.  
  227. int dqdata(struct mbuf *bp, int size, register char *data)
  228. {
  229.         register struct mbuf *tbp;
  230.         register int length;
  231.         register char *s;
  232.         int n = 0;
  233.  
  234.         /* The first mbuf contains control information */
  235.         for (tbp = bp->m_next; tbp != NULLMBUF && size > 0; tbp = tbp->m_next)
  236.         {
  237.                  length = tbp->m_len;
  238.  
  239.                  n    += length;
  240.                  size -= length;
  241.  
  242.                  s = tbp->m_dat + tbp->m_off - MMINOFF;
  243.  
  244.                  while (length-- > 0)
  245.                         *data++ = *s++;
  246.         }
  247.  
  248.         return(n);
  249. }
  250.  
  251. int len_q(register struct packet *p)
  252. {
  253.         register int n;
  254.  
  255.         for (n = 0; p != NULLPACKET; n++, p = p->next);
  256.  
  257.         return(n);
  258. }
  259.