/*

 *  File.........: pktdrvr.c

 *

 *  Responsible..: Gisle Vanem,  giva@bgnett.no

 *

 *  Created......: 26.Sept 1995

 *

 *  Description..: Packet-driver interface for 16/32-bit C :

 *                 Borland C/C++ 3.0+ small/large model

 *                 Watcom C/C++ 11+, DOS4GW flat model

 *                 Metaware HighC 3.1+ and PharLap 386|DosX

 *                 GNU C/C++ 2.7+ and djgpp 2.x extender

 *

 *  References...: PC/TCP Packet driver Specification. rev 1.09

 *                 FTP Software Inc.

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <dos.h>

#include "pcap-dos.h"

#include "pcap-int.h"

#include "msdos/pktdrvr.h"

#if (DOSX)

#define NUM_RX_BUF  32      /* # of buffers in Rx FIFO queue */

#else

#define NUM_RX_BUF  10

#endif

#define DIM(x)   (sizeof((x)) / sizeof(x[0]))

#define PUTS(s)  do {                                           \

                   if (!pktInfo.quiet)                          \

                      pktInfo.error ?                           \

                        printf ("%s: %s\n", s, pktInfo.error) : \

                        printf ("%s\n", pktInfo.error = s);     \

                 } while (0)

#if defined(__HIGHC__)

  extern UINT _mwenv;

#elif defined(__DJGPP__)

  #include <stddef.h>

  #include <dpmi.h>

  #include <go32.h>

  #include <pc.h>

  #include <sys/farptr.h>

#elif defined(__WATCOMC__)

  #include <i86.h>

  #include <stddef.h>

  extern char _Extender;

#else

  extern void far PktReceiver (void);

#endif

#if (DOSX & (DJGPP|DOS4GW))

  #include <sys/pack_on.h>

  struct DPMI_regs {

         DWORD  r_di;

         DWORD  r_si;

         DWORD  r_bp;

         DWORD  reserved;

         DWORD  r_bx;

         DWORD  r_dx;

         DWORD  r_cx;

         DWORD  r_ax;

         WORD   r_flags;

         WORD   r_es, r_ds, r_fs, r_gs;

         WORD   r_ip, r_cs, r_sp, r_ss;

       };

  /* Data located in a real-mode segment. This becomes far at runtime

   */

  typedef struct  {          /* must match data/code in pkt_rx1.s */

          WORD       _rxOutOfs;

          WORD       _rxInOfs;

          DWORD      _pktDrop;

          BYTE       _pktTemp [20];

          TX_ELEMENT _pktTxBuf[1];

          RX_ELEMENT _pktRxBuf[NUM_RX_BUF];

          WORD       _dummy[2];        /* screenSeg,newInOffset */

          BYTE       _fanChars[4];

          WORD       _fanIndex;

          BYTE       _PktReceiver[15]; /* starts on a paragraph (16byte) */

        } PktRealStub;

  #include <sys/pack_off.h>

  static BYTE real_stub_array [] = {

         #include "pkt_stub.inc"       /* generated opcode array */

       };

  #define rxOutOfs      offsetof (PktRealStub,_rxOutOfs)

  #define rxInOfs       offsetof (PktRealStub,_rxInOfs)

  #define PktReceiver   offsetof (PktRealStub,_PktReceiver [para_skip])

  #define pktDrop       offsetof (PktRealStub,_pktDrop)

  #define pktTemp       offsetof (PktRealStub,_pktTemp)

  #define pktTxBuf      offsetof (PktRealStub,_pktTxBuf)

  #define FIRST_RX_BUF  offsetof (PktRealStub,_pktRxBuf [0])

  #define LAST_RX_BUF   offsetof (PktRealStub,_pktRxBuf [NUM_RX_BUF-1])

#else

  extern WORD       rxOutOfs;    /* offsets into pktRxBuf FIFO queue   */

  extern WORD       rxInOfs;

  extern DWORD      pktDrop;     /* # packets dropped in PktReceiver() */

  extern BYTE       pktRxEnd;    /* marks the end of r-mode code/data  */

  extern RX_ELEMENT pktRxBuf [NUM_RX_BUF];       /* PktDrvr Rx buffers */

  extern TX_ELEMENT pktTxBuf;                    /* PktDrvr Tx buffer  */

  extern char       pktTemp[20];                 /* PktDrvr temp area  */

  #define FIRST_RX_BUF (WORD) &pktRxBuf [0]

  #define LAST_RX_BUF  (WORD) &pktRxBuf [NUM_RX_BUF-1]

#endif

#ifdef __BORLANDC__           /* Use Borland's inline functions */

  #define memcpy  __memcpy__

  #define memcmp  __memcmp__

  #define memset  __memset__

#endif

#if (DOSX & PHARLAP)

  extern void PktReceiver (void);     /* in pkt_rx0.asm */

  static int  RealCopy    (ULONG, ULONG, REALPTR*, FARPTR*, USHORT*);

  #undef  FP_SEG

  #undef  FP_OFF

  #define FP_OFF(x)     ((WORD)(x))

  #define FP_SEG(x)     ((WORD)(realBase >> 16))

  #define DOS_ADDR(s,o) (((DWORD)(s) << 16) + (WORD)(o))

  #define r_ax          eax

  #define r_bx          ebx

  #define r_dx          edx

  #define r_cx          ecx

  #define r_si          esi

  #define r_di          edi

  #define r_ds          ds

  #define r_es          es

  LOCAL FARPTR          protBase;

  LOCAL REALPTR         realBase;

  LOCAL WORD            realSeg;   /* DOS para-address of allocated area */

  LOCAL SWI_REGS        reg;

  static WORD _far *rxOutOfsFp, *rxInOfsFp;

#elif (DOSX & DJGPP)

  static _go32_dpmi_seginfo rm_mem;

  static __dpmi_regs        reg;

  static DWORD              realBase;

  static int                para_skip = 0;

  #define DOS_ADDR(s,o)     (((WORD)(s) << 4) + (o))

  #define r_ax              x.ax

  #define r_bx              x.bx

  #define r_dx              x.dx

  #define r_cx              x.cx

  #define r_si              x.si

  #define r_di              x.di

  #define r_ds              x.ds

  #define r_es              x.es

#elif (DOSX & DOS4GW)

  LOCAL struct DPMI_regs    reg;

  LOCAL WORD                rm_base_seg, rm_base_sel;

  LOCAL DWORD               realBase;

  LOCAL int                 para_skip = 0;

  LOCAL DWORD dpmi_get_real_vector (int intr);

  LOCAL WORD  dpmi_real_malloc     (int size, WORD *selector);

  LOCAL void  dpmi_real_free       (WORD selector);

  #define DOS_ADDR(s,o) (((DWORD)(s) << 4) + (WORD)(o))

#else              /* real-mode Borland etc. */

  static struct  {

         WORD r_ax, r_bx, r_cx, r_dx, r_bp;

         WORD r_si, r_di, r_ds, r_es, r_flags;

       } reg;

#endif

#ifdef __HIGHC__

  #pragma Alias (pktDrop,    "_pktDrop")

  #pragma Alias (pktRxBuf,   "_pktRxBuf")

  #pragma Alias (pktTxBuf,   "_pktTxBuf")

  #pragma Alias (pktTemp,    "_pktTemp")

  #pragma Alias (rxOutOfs,   "_rxOutOfs")

  #pragma Alias (rxInOfs,    "_rxInOfs")

  #pragma Alias (pktRxEnd,   "_pktRxEnd")

  #pragma Alias (PktReceiver,"_PktReceiver")

#endif

PUBLIC PKT_STAT    pktStat;    /* statistics for packets    */

PUBLIC PKT_INFO    pktInfo;    /* packet-driver information */

PUBLIC PKT_RX_MODE receiveMode  = PDRX_DIRECT;

PUBLIC ETHER       myAddress    = {   0,  0,  0,  0,  0,  0 };

PUBLIC ETHER       ethBroadcast = { 255,255,255,255,255,255 };

LOCAL  struct {             /* internal statistics */

       DWORD  tooSmall;     /* size < ETH_MIN */

       DWORD  tooLarge;     /* size > ETH_MAX */

       DWORD  badSync;      /* count_1 != count_2 */

       DWORD  wrongHandle;  /* upcall to wrong handle */

     } intStat;

/***************************************************************************/

PUBLIC const char *PktGetErrorStr (int errNum)

{

  static const char *errStr[] = {

                    "",

                    "Invalid handle number",

                    "No interfaces of specified class found",

                    "No interfaces of specified type found",

                    "No interfaces of specified number found",

                    "Bad packet type specified",

                    "Interface does not support multicast",

                    "Packet driver cannot terminate",

                    "Invalid receiver mode specified",

                    "Insufficient memory space",

                    "Type previously accessed, and not released",

                    "Command out of range, or not implemented",

                    "Cannot send packet (usually hardware error)",

                    "Cannot change hardware address ( > 1 handle open)",

                    "Hardware address has bad length or format",

                    "Cannot reset interface (more than 1 handle open)",

                    "Bad Check-sum",

                    "Bad size",

                    "Bad sync" ,

                    "Source hit"

                  };

  if (errNum < 0 || errNum >= DIM(errStr))

     return ("Unknown driver error.");

  return (errStr [errNum]);

}

/**************************************************************************/

PUBLIC const char *PktGetClassName (WORD class)

{

  switch (class)

  {

    case PD_ETHER:

         return ("DIX-Ether");

    case PD_PRONET10:

         return ("ProNET-10");

    case PD_IEEE8025:

         return ("IEEE 802.5");

    case PD_OMNINET:

         return ("OmniNet");

    case PD_APPLETALK:

         return ("AppleTalk");

    case PD_SLIP:

         return ("SLIP");

    case PD_STARTLAN:

         return ("StartLAN");

    case PD_ARCNET:

         return ("ArcNet");

    case PD_AX25:

         return ("AX.25");

    case PD_KISS:

         return ("KISS");

    case PD_IEEE8023_2:

         return ("IEEE 802.3 w/802.2 hdr");

    case PD_FDDI8022:

         return ("FDDI w/802.2 hdr");

    case PD_X25:

         return ("X.25");

    case PD_LANstar:

         return ("LANstar");

    case PD_PPP:

         return ("PPP");

    default:

         return ("unknown");

  }

}

/**************************************************************************/

PUBLIC char const *PktRXmodeStr (PKT_RX_MODE mode)

{

  static const char *modeStr [] = {

                    "Receiver turned off",

                    "Receive only directly addressed packets",

                    "Receive direct & broadcast packets",

                    "Receive direct,broadcast and limited multicast packets",

                    "Receive direct,broadcast and all multicast packets",

                    "Receive all packets (promiscuouos mode)"

                  };

  if (mode > DIM(modeStr))

     return ("??");

  return (modeStr [mode-1]);

}

/**************************************************************************/

LOCAL __inline BOOL PktInterrupt (void)

{

  BOOL okay;

#if (DOSX & PHARLAP)

  _dx_real_int ((UINT)pktInfo.intr, ®);

  okay = ((reg.flags & 1) == 0);  /* OK if carry clear */

#elif (DOSX & DJGPP)

  __dpmi_int ((int)pktInfo.intr, ®);

  okay = ((reg.x.flags & 1) == 0);

#elif (DOSX & DOS4GW)

  union  REGS  r;

  struct SREGS s;

  memset (&r, 0, sizeof(r));

  segread (&s);

  r.w.ax  = 0x300;

  r.x.ebx = pktInfo.intr;

  r.w.cx  = 0;

  s.es    = FP_SEG (®);

  r.x.edi = FP_OFF (®);

  reg.r_flags = 0;

  reg.r_ss = reg.r_sp = 0;     /* DPMI host provides stack */

  int386x (0x31, &r, &r, &s);

  okay = (!r.w.cflag);

#else

  reg.r_flags = 0;

  intr (pktInfo.intr, (struct REGPACK*)®);

  okay = ((reg.r_flags & 1) == 0);

#endif

  if (okay)

       pktInfo.error = NULL;

  else pktInfo.error = PktGetErrorStr (reg.r_dx >> 8);

  return (okay);

}

/**************************************************************************/

/*

 * Search for packet driver at interrupt 60h through 80h. If ASCIIZ

 * string "PKT DRVR" found at offset 3 in the interrupt handler, return

 * interrupt number, else return zero in pktInfo.intr

 */

PUBLIC BOOL PktSearchDriver (void)

{

  BYTE intr  = 0x20;

  BOOL found = FALSE;

  while (!found && intr < 0xFF)

  {

    static char str[12];                 /* 3 + strlen("PKT DRVR") */

    static char pktStr[9] = "PKT DRVR";  /* ASCIIZ string at ofs 3 */

    DWORD  rp;                           /* in interrupt  routine  */

#if (DOSX & PHARLAP)

    _dx_rmiv_get (intr, &rp);

    ReadRealMem (&str, (REALPTR)rp, sizeof(str));

#elif (DOSX & DJGPP)

    __dpmi_raddr realAdr;

    __dpmi_get_real_mode_interrupt_vector (intr, &realAdr);

    rp = (realAdr.segment << 4) + realAdr.offset16;

    dosmemget (rp, sizeof(str), &str);

#elif (DOSX & DOS4GW)

    rp = dpmi_get_real_vector (intr);

    memcpy (&str, (void*)rp, sizeof(str));

#else

    _fmemcpy (&str, getvect(intr), sizeof(str));

#endif

    found = memcmp (&str[3],&pktStr,sizeof(pktStr)) == 0;

    intr++;

  }

  pktInfo.intr = (found ? intr-1 : 0);

  return (found);

}

/**************************************************************************/

static BOOL PktSetAccess (void)

{

  reg.r_ax = 0x0200 + pktInfo.class;

  reg.r_bx = 0xFFFF;

  reg.r_dx = 0;

  reg.r_cx = 0;

#if (DOSX & PHARLAP)

  reg.ds  = 0;

  reg.esi = 0;

  reg.es  = RP_SEG (realBase);

  reg.edi = (WORD) &PktReceiver;

#elif (DOSX & DJGPP)

  reg.x.ds = 0;

  reg.x.si = 0;

  reg.x.es = rm_mem.rm_segment;

  reg.x.di = PktReceiver;

#elif (DOSX & DOS4GW)

  reg.r_ds = 0;

  reg.r_si = 0;

  reg.r_es = rm_base_seg;

  reg.r_di = PktReceiver;

#else

  reg.r_ds = 0;

  reg.r_si = 0;

  reg.r_es = FP_SEG (&PktReceiver);

  reg.r_di = FP_OFF (&PktReceiver);

#endif

  if (!PktInterrupt())

     return (FALSE);

  pktInfo.handle = reg.r_ax;

  return (TRUE);

}

/**************************************************************************/

PUBLIC BOOL PktReleaseHandle (WORD handle)

{

  reg.r_ax = 0x0300;

  reg.r_bx = handle;

  return PktInterrupt();

}

/**************************************************************************/

PUBLIC BOOL PktTransmit (const void *eth, int len)

{

  if (len > ETH_MTU)

     return (FALSE);

  reg.r_ax = 0x0400;             /* Function 4, send pkt */

  reg.r_cx = len;                /* total size of frame  */

#if (DOSX & DJGPP)

  dosmemput (eth, len, realBase+pktTxBuf);

  reg.x.ds = rm_mem.rm_segment;  /* DOS data segment and */

  reg.x.si = pktTxBuf;           /* DOS offset to buffer */

#elif (DOSX & DOS4GW)

  memcpy ((void*)(realBase+pktTxBuf), eth, len);

  reg.r_ds = rm_base_seg;

  reg.r_si = pktTxBuf;

#elif (DOSX & PHARLAP)

  memcpy (&pktTxBuf, eth, len);

  reg.r_ds = FP_SEG (&pktTxBuf);

  reg.r_si = FP_OFF (&pktTxBuf);

#else

  reg.r_ds = FP_SEG (eth);

  reg.r_si = FP_OFF (eth);

#endif

  return PktInterrupt();

}

/**************************************************************************/

#if (DOSX & (DJGPP|DOS4GW))

LOCAL __inline BOOL CheckElement (RX_ELEMENT *rx)

#else

LOCAL __inline BOOL CheckElement (RX_ELEMENT _far *rx)

#endif

{

  WORD count_1, count_2;

  /*

   * We got an upcall to the same RMCB with wrong handle.

   * This can happen if we failed to release handle at program exit

   */

  if (rx->handle != pktInfo.handle)

  {

    pktInfo.error = "Wrong handle";

    intStat.wrongHandle++;

    PktReleaseHandle (rx->handle);

    return (FALSE);

  }

  count_1 = rx->firstCount;

  count_2 = rx->secondCount;

  if (count_1 != count_2)

  {

    pktInfo.error = "Bad sync";

    intStat.badSync++;

    return (FALSE);

  }

  if (count_1 > ETH_MAX)

  {

    pktInfo.error = "Large esize";

    intStat.tooLarge++;

    return (FALSE);

  }

#if 0

  if (count_1 < ETH_MIN)

  {

    pktInfo.error = "Small esize";

    intStat.tooSmall++;

    return (FALSE);

  }

#endif

  return (TRUE);

}

/**************************************************************************/

PUBLIC BOOL PktTerminHandle (WORD handle)

{

  reg.r_ax = 0x0500;

  reg.r_bx = handle;

  return PktInterrupt();

}

/**************************************************************************/

PUBLIC BOOL PktResetInterface (WORD handle)

{

  reg.r_ax = 0x0700;

  reg.r_bx = handle;

  return PktInterrupt();

}

/**************************************************************************/

PUBLIC BOOL PktSetReceiverMode (PKT_RX_MODE mode)

{

  if (pktInfo.class == PD_SLIP || pktInfo.class == PD_PPP)

     return (TRUE);

  reg.r_ax = 0x1400;

  reg.r_bx = pktInfo.handle;

  reg.r_cx = (WORD)mode;

  if (!PktInterrupt())

     return (FALSE);

  receiveMode = mode;

  return (TRUE);

}

/**************************************************************************/

PUBLIC BOOL PktGetReceiverMode (PKT_RX_MODE *mode)

{

  reg.r_ax = 0x1500;

  reg.r_bx = pktInfo.handle;

  if (!PktInterrupt())

     return (FALSE);

  *mode = reg.r_ax;

  return (TRUE);

}

/**************************************************************************/

static PKT_STAT initialStat;         /* statistics at startup */

static BOOL     resetStat = FALSE;   /* statistics reset ? */

PUBLIC BOOL PktGetStatistics (WORD handle)

{

  reg.r_ax = 0x1800;

  reg.r_bx = handle;

  if (!PktInterrupt())

     return (FALSE);

#if (DOSX & PHARLAP)

  ReadRealMem (&pktStat, DOS_ADDR(reg.ds,reg.esi), sizeof(pktStat));

#elif (DOSX & DJGPP)

  dosmemget (DOS_ADDR(reg.x.ds,reg.x.si), sizeof(pktStat), &pktStat);

#elif (DOSX & DOS4GW)

  memcpy (&pktStat, (void*)DOS_ADDR(reg.r_ds,reg.r_si), sizeof(pktStat));

#else

  _fmemcpy (&pktStat, MK_FP(reg.r_ds,reg.r_si), sizeof(pktStat));

#endif

  return (TRUE);

}

/**************************************************************************/

PUBLIC BOOL PktSessStatistics (WORD handle)

{

  if (!PktGetStatistics(pktInfo.handle))

     return (FALSE);

  if (resetStat)

  {

    pktStat.inPackets  -= initialStat.inPackets;

    pktStat.outPackets -= initialStat.outPackets;

    pktStat.inBytes    -= initialStat.inBytes;

    pktStat.outBytes   -= initialStat.outBytes;

    pktStat.inErrors   -= initialStat.inErrors;

    pktStat.outErrors  -= initialStat.outErrors;

    pktStat.outErrors  -= initialStat.outErrors;

    pktStat.lost       -= initialStat.lost;

  }

  return (TRUE);

}

/**************************************************************************/

PUBLIC BOOL PktResetStatistics (WORD handle)

{

  if (!PktGetStatistics(pktInfo.handle))

     return (FALSE);

  memcpy (&initialStat, &pktStat, sizeof(initialStat));

  resetStat = TRUE;

  return (TRUE);

}

/**************************************************************************/

PUBLIC BOOL PktGetAddress (ETHER *addr)

{

  reg.r_ax = 0x0600;

  reg.r_bx = pktInfo.handle;

  reg.r_cx = sizeof (*addr);

#if (DOSX & DJGPP)

  reg.x.es = rm_mem.rm_segment;

  reg.x.di = pktTemp;

#elif (DOSX & DOS4GW)

  reg.r_es = rm_base_seg;

  reg.r_di = pktTemp;

#else

  reg.r_es = FP_SEG (&pktTemp);

  reg.r_di = FP_OFF (&pktTemp);  /* ES:DI = address for result */

#endif

  if (!PktInterrupt())

     return (FALSE);

#if (DOSX & PHARLAP)

  ReadRealMem (addr, realBase + (WORD)&pktTemp, sizeof(*addr));

#elif (DOSX & DJGPP)

  dosmemget (realBase+pktTemp, sizeof(*addr), addr);

#elif (DOSX & DOS4GW)

  memcpy (addr, (void*)(realBase+pktTemp), sizeof(*addr));

#else

  memcpy ((void*)addr, &pktTemp, sizeof(*addr));

#endif

  return (TRUE);

}

/**************************************************************************/

PUBLIC BOOL PktSetAddress (const ETHER *addr)

{

  /* copy addr to real-mode scrath area */

#if (DOSX & PHARLAP)

  WriteRealMem (realBase + (WORD)&pktTemp, (void*)addr, sizeof(*addr));

#elif (DOSX & DJGPP)

  dosmemput (addr, sizeof(*addr), realBase+pktTemp);

#elif (DOSX & DOS4GW)

  memcpy ((void*)(realBase+pktTemp), addr, sizeof(*addr));

#else

  memcpy (&pktTemp, (void*)addr, sizeof(*addr));

#endif

  reg.r_ax = 0x1900;

  reg.r_cx = sizeof (*addr);      /* address length       */

#if (DOSX & DJGPP)

  reg.x.es = rm_mem.rm_segment;   /* DOS offset to param  */

  reg.x.di = pktTemp;             /* DOS segment to param */

#elif (DOSX & DOS4GW)

  reg.r_es = rm_base_seg;

  reg.r_di = pktTemp;

#else

  reg.r_es = FP_SEG (&pktTemp);

  reg.r_di = FP_OFF (&pktTemp);

#endif

  return PktInterrupt();

}

/**************************************************************************/

PUBLIC BOOL PktGetDriverInfo (void)

{

  pktInfo.majVer = 0;

  pktInfo.minVer = 0;

  memset (&pktInfo.name, 0, sizeof(pktInfo.name));

  reg.r_ax = 0x01FF;

  reg.r_bx = 0;

  if (!PktInterrupt())

     return (FALSE);

  pktInfo.number = reg.r_cx & 0xFF;

  pktInfo.class  = reg.r_cx >> 8;

#if 0

  pktInfo.minVer = reg.r_bx % 10;

  pktInfo.majVer = reg.r_bx / 10;

#else

  pktInfo.majVer = reg.r_bx;  // !!

#endif

  pktInfo.funcs  = reg.r_ax & 0xFF;

  pktInfo.type   = reg.r_dx & 0xFF;

#if (DOSX & PHARLAP)

  ReadRealMem (&pktInfo.name, DOS_ADDR(reg.ds,reg.esi), sizeof(pktInfo.name));

#elif (DOSX & DJGPP)

  dosmemget (DOS_ADDR(reg.x.ds,reg.x.si), sizeof(pktInfo.name), &pktInfo.name);

#elif (DOSX & DOS4GW)

  memcpy (&pktInfo.name, (void*)DOS_ADDR(reg.r_ds,reg.r_si), sizeof(pktInfo.name));

#else

  _fmemcpy (&pktInfo.name, MK_FP(reg.r_ds,reg.r_si), sizeof(pktInfo.name));

#endif

  return (TRUE);

}

/**************************************************************************/

PUBLIC BOOL PktGetDriverParam (void)

{

  reg.r_ax = 0x0A00;

  if (!PktInterrupt())

     return (FALSE);

#if (DOSX & PHARLAP)

  ReadRealMem (&pktInfo.majVer, DOS_ADDR(reg.es,reg.edi), PKT_PARAM_SIZE);

#elif (DOSX & DJGPP)

  dosmemget (DOS_ADDR(reg.x.es,reg.x.di), PKT_PARAM_SIZE, &pktInfo.majVer);

#elif (DOSX & DOS4GW)

  memcpy (&pktInfo.majVer, (void*)DOS_ADDR(reg.r_es,reg.r_di), PKT_PARAM_SIZE);

#else

  _fmemcpy (&pktInfo.majVer, MK_FP(reg.r_es,reg.r_di), PKT_PARAM_SIZE);

#endif

  return (TRUE);

}

/**************************************************************************/

#if (DOSX & PHARLAP)

  PUBLIC int PktReceive (BYTE *buf, int max)

  {

    WORD inOfs  = *rxInOfsFp;

    WORD outOfs = *rxOutOfsFp;

    if (outOfs != inOfs)

    {

      RX_ELEMENT _far *head = (RX_ELEMENT _far*)(protBase+outOfs);

      int size, len = max;

      if (CheckElement(head))

      {

        size = min (head->firstCount, sizeof(RX_ELEMENT));

        len  = min (size, max);

        _fmemcpy (buf, &head->destin, len);

      }

      else

        size = -1;

      outOfs += sizeof (RX_ELEMENT);

      if (outOfs > LAST_RX_BUF)

          outOfs = FIRST_RX_BUF;

      *rxOutOfsFp = outOfs;

      return (size);

    }

    return (0);

  }

  PUBLIC void PktQueueBusy (BOOL busy)

  {

    *rxOutOfsFp = busy ? (*rxInOfsFp + sizeof(RX_ELEMENT)) : *rxInOfsFp;

    if (*rxOutOfsFp > LAST_RX_BUF)

        *rxOutOfsFp = FIRST_RX_BUF;

    *(DWORD _far*)(protBase + (WORD)&pktDrop) = 0;

  }

  PUBLIC WORD PktBuffersUsed (void)

  {

    WORD inOfs  = *rxInOfsFp;

    WORD outOfs = *rxOutOfsFp;

    if (inOfs >= outOfs)

       return (inOfs - outOfs) / sizeof(RX_ELEMENT);

    return (NUM_RX_BUF - (outOfs - inOfs) / sizeof(RX_ELEMENT));

  }

  PUBLIC DWORD PktRxDropped (void)

  {

    return (*(DWORD _far*)(protBase + (WORD)&pktDrop));

  }

#elif (DOSX & DJGPP)

  PUBLIC int PktReceive (BYTE *buf, int max)

  {

    WORD ofs = _farpeekw (_dos_ds, realBase+rxOutOfs);

    if (ofs != _farpeekw (_dos_ds, realBase+rxInOfs))

    {

      RX_ELEMENT head;

      int  size, len = max;

      head.firstCount  = _farpeekw (_dos_ds, realBase+ofs);

      head.secondCount = _farpeekw (_dos_ds, realBase+ofs+2);

      head.handle      = _farpeekw (_dos_ds, realBase+ofs+4);

      if (CheckElement(&head))

      {

        size = min (head.firstCount, sizeof(RX_ELEMENT));

        len  = min (size, max);

        dosmemget (realBase+ofs+6, len, buf);

      }

      else

        size = -1;

      ofs += sizeof (RX_ELEMENT);

      if (ofs > LAST_RX_BUF)

           _farpokew (_dos_ds, realBase+rxOutOfs, FIRST_RX_BUF);

      else _farpokew (_dos_ds, realBase+rxOutOfs, ofs);

      return (size);

    }

    return (0);

  }

  PUBLIC void PktQueueBusy (BOOL busy)

  {

    WORD ofs;

    disable();

    ofs = _farpeekw (_dos_ds, realBase+rxInOfs);

    if (busy)

       ofs += sizeof (RX_ELEMENT);

    if (ofs > LAST_RX_BUF)

         _farpokew (_dos_ds, realBase+rxOutOfs, FIRST_RX_BUF);

    else _farpokew (_dos_ds, realBase+rxOutOfs, ofs);

    _farpokel (_dos_ds, realBase+pktDrop, 0UL);

    enable();

  }

  PUBLIC WORD PktBuffersUsed (void)

  {

    WORD inOfs, outOfs;

    disable();

    inOfs  = _farpeekw (_dos_ds, realBase+rxInOfs);

    outOfs = _farpeekw (_dos_ds, realBase+rxOutOfs);

    enable();