1 /*
2  *  File.........: pktdrvr.c
3  *
4  *  Responsible..: Gisle Vanem,  giva@bgnett.no
5  *
6  *  Created......: 26.Sept 1995
7  *
8  *  Description..: Packet-driver interface for 16/32-bit C :
9  *                 Borland C/C++ 3.0+ small/large model
10  *                 Watcom C/C++ 11+, DOS4GW flat model
11  *                 Metaware HighC 3.1+ and PharLap 386|DosX
12  *                 GNU C/C++ 2.7+ and djgpp 2.x extender
13  *
14  *  References...: PC/TCP Packet driver Specification. rev 1.09
15  *                 FTP Software Inc.
16  *
17  */
18 
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <dos.h>
23 
24 #include "pcap-dos.h"
25 #include "pcap-int.h"
26 #include "msdos/pktdrvr.h"
27 
28 #if (DOSX)
29 #define NUM_RX_BUF  32      /* # of buffers in Rx FIFO queue */
30 #else
31 #define NUM_RX_BUF  10
32 #endif
33 
34 #define DIM(x)   (sizeof((x)) / sizeof(x[0]))
35 #define PUTS(s)  do {                                           \
36                    if (!pktInfo.quiet)                          \
37                       pktInfo.error ?                           \
38                         printf ("%s: %s\n", s, pktInfo.error) : \
39                         printf ("%s\n", pktInfo.error = s);     \
40                  } while (0)
41 
42 #if defined(__HIGHC__)
43   extern UINT _mwenv;
44 
45 #elif defined(__DJGPP__)
46   #include <stddef.h>
47   #include <dpmi.h>
48   #include <go32.h>
49   #include <pc.h>
50   #include <sys/farptr.h>
51 
52 #elif defined(__WATCOMC__)
53   #include <i86.h>
54   #include <stddef.h>
55   extern char _Extender;
56 
57 #else
58   extern void far PktReceiver (void);
59 #endif
60 
61 
62 #if (DOSX & (DJGPP|DOS4GW))
63   #include <sys/pack_on.h>
64 
65   struct DPMI_regs {
66          DWORD  r_di;
67          DWORD  r_si;
68          DWORD  r_bp;
69          DWORD  reserved;
70          DWORD  r_bx;
71          DWORD  r_dx;
72          DWORD  r_cx;
73          DWORD  r_ax;
74          WORD   r_flags;
75          WORD   r_es, r_ds, r_fs, r_gs;
76          WORD   r_ip, r_cs, r_sp, r_ss;
77        };
78 
79   /* Data located in a real-mode segment. This becomes far at runtime
80    */
81   typedef struct  {          /* must match data/code in pkt_rx1.s */
82           WORD       _rxOutOfs;
83           WORD       _rxInOfs;
84           DWORD      _pktDrop;
85           BYTE       _pktTemp [20];
86           TX_ELEMENT _pktTxBuf[1];
87           RX_ELEMENT _pktRxBuf[NUM_RX_BUF];
88           WORD       _dummy[2];        /* screenSeg,newInOffset */
89           BYTE       _fanChars[4];
90           WORD       _fanIndex;
91           BYTE       _PktReceiver[15]; /* starts on a paragraph (16byte) */
92         } PktRealStub;
93   #include <sys/pack_off.h>
94 
95   static BYTE real_stub_array [] = {
96          #include "pkt_stub.inc"       /* generated opcode array */
97        };
98 
99   #define rxOutOfs      offsetof (PktRealStub,_rxOutOfs)
100   #define rxInOfs       offsetof (PktRealStub,_rxInOfs)
101   #define PktReceiver   offsetof (PktRealStub,_PktReceiver [para_skip])
102   #define pktDrop       offsetof (PktRealStub,_pktDrop)
103   #define pktTemp       offsetof (PktRealStub,_pktTemp)
104   #define pktTxBuf      offsetof (PktRealStub,_pktTxBuf)
105   #define FIRST_RX_BUF  offsetof (PktRealStub,_pktRxBuf [0])
106   #define LAST_RX_BUF   offsetof (PktRealStub,_pktRxBuf [NUM_RX_BUF-1])
107 
108 #else
109   extern WORD       rxOutOfs;    /* offsets into pktRxBuf FIFO queue   */
110   extern WORD       rxInOfs;
111   extern DWORD      pktDrop;     /* # packets dropped in PktReceiver() */
112   extern BYTE       pktRxEnd;    /* marks the end of r-mode code/data  */
113 
114   extern RX_ELEMENT pktRxBuf [NUM_RX_BUF];       /* PktDrvr Rx buffers */
115   extern TX_ELEMENT pktTxBuf;                    /* PktDrvr Tx buffer  */
116   extern char       pktTemp[20];                 /* PktDrvr temp area  */
117 
118   #define FIRST_RX_BUF (WORD) &pktRxBuf [0]
119   #define LAST_RX_BUF  (WORD) &pktRxBuf [NUM_RX_BUF-1]
120 #endif
121 
122 
123 #ifdef __BORLANDC__           /* Use Borland's inline functions */
124   #define memcpy  __memcpy__
125   #define memcmp  __memcmp__
126   #define memset  __memset__
127 #endif
128 
129 
130 #if (DOSX & PHARLAP)
131   extern void PktReceiver (void);     /* in pkt_rx0.asm */
132   static int  RealCopy    (ULONG, ULONG, REALPTR*, FARPTR*, USHORT*);
133 
134   #undef  FP_SEG
135   #undef  FP_OFF
136   #define FP_OFF(x)     ((WORD)(x))
137   #define FP_SEG(x)     ((WORD)(realBase >> 16))
138   #define DOS_ADDR(s,o) (((DWORD)(s) << 16) + (WORD)(o))
139   #define r_ax          eax
140   #define r_bx          ebx
141   #define r_dx          edx
142   #define r_cx          ecx
143   #define r_si          esi
144   #define r_di          edi
145   #define r_ds          ds
146   #define r_es          es
147   LOCAL FARPTR          protBase;
148   LOCAL REALPTR         realBase;
149   LOCAL WORD            realSeg;   /* DOS para-address of allocated area */
150   LOCAL SWI_REGS        reg;
151 
152   static WORD _far *rxOutOfsFp, *rxInOfsFp;
153 
154 #elif (DOSX & DJGPP)
155   static _go32_dpmi_seginfo rm_mem;
156   static __dpmi_regs        reg;
157   static DWORD              realBase;
158   static int                para_skip = 0;
159 
160   #define DOS_ADDR(s,o)     (((WORD)(s) << 4) + (o))
161   #define r_ax              x.ax
162   #define r_bx              x.bx
163   #define r_dx              x.dx
164   #define r_cx              x.cx
165   #define r_si              x.si
166   #define r_di              x.di
167   #define r_ds              x.ds
168   #define r_es              x.es
169 
170 #elif (DOSX & DOS4GW)
171   LOCAL struct DPMI_regs    reg;
172   LOCAL WORD                rm_base_seg, rm_base_sel;
173   LOCAL DWORD               realBase;
174   LOCAL int                 para_skip = 0;
175 
176   LOCAL DWORD dpmi_get_real_vector (int intr);
177   LOCAL WORD  dpmi_real_malloc     (int size, WORD *selector);
178   LOCAL void  dpmi_real_free       (WORD selector);
179   #define DOS_ADDR(s,o) (((DWORD)(s) << 4) + (WORD)(o))
180 
181 #else              /* real-mode Borland etc. */
182   static struct  {
183          WORD r_ax, r_bx, r_cx, r_dx, r_bp;
184          WORD r_si, r_di, r_ds, r_es, r_flags;
185        } reg;
186 #endif
187 
188 #ifdef __HIGHC__
189   #pragma Alias (pktDrop,    "_pktDrop")
190   #pragma Alias (pktRxBuf,   "_pktRxBuf")
191   #pragma Alias (pktTxBuf,   "_pktTxBuf")
192   #pragma Alias (pktTemp,    "_pktTemp")
193   #pragma Alias (rxOutOfs,   "_rxOutOfs")
194   #pragma Alias (rxInOfs,    "_rxInOfs")
195   #pragma Alias (pktRxEnd,   "_pktRxEnd")
196   #pragma Alias (PktReceiver,"_PktReceiver")
197 #endif
198 
199 
200 PUBLIC PKT_STAT    pktStat;    /* statistics for packets    */
201 PUBLIC PKT_INFO    pktInfo;    /* packet-driver information */
202 
203 PUBLIC PKT_RX_MODE receiveMode  = PDRX_DIRECT;
204 PUBLIC ETHER       myAddress    = {   0,  0,  0,  0,  0,  0 };
205 PUBLIC ETHER       ethBroadcast = { 255,255,255,255,255,255 };
206 
207 LOCAL  struct {             /* internal statistics */
208        DWORD  tooSmall;     /* size < ETH_MIN */
209        DWORD  tooLarge;     /* size > ETH_MAX */
210        DWORD  badSync;      /* count_1 != count_2 */
211        DWORD  wrongHandle;  /* upcall to wrong handle */
212      } intStat;
213 
214 /***************************************************************************/
215 
PktGetErrorStr(int errNum)216 PUBLIC const char *PktGetErrorStr (int errNum)
217 {
218   static const char *errStr[] = {
219                     "",
220                     "Invalid handle number",
221                     "No interfaces of specified class found",
222                     "No interfaces of specified type found",
223                     "No interfaces of specified number found",
224                     "Bad packet type specified",
225                     "Interface does not support multicast",
226                     "Packet driver cannot terminate",
227                     "Invalid receiver mode specified",
228                     "Insufficient memory space",
229                     "Type previously accessed, and not released",
230                     "Command out of range, or not implemented",
231                     "Cannot send packet (usually hardware error)",
232                     "Cannot change hardware address ( > 1 handle open)",
233                     "Hardware address has bad length or format",
234                     "Cannot reset interface (more than 1 handle open)",
235                     "Bad Check-sum",
236                     "Bad size",
237                     "Bad sync" ,
238                     "Source hit"
239                   };
240 
241   if (errNum < 0 || errNum >= DIM(errStr))
242      return ("Unknown driver error.");
243   return (errStr [errNum]);
244 }
245 
246 /**************************************************************************/
247 
PktGetClassName(WORD class)248 PUBLIC const char *PktGetClassName (WORD class)
249 {
250   switch (class)
251   {
252     case PD_ETHER:
253          return ("DIX-Ether");
254     case PD_PRONET10:
255          return ("ProNET-10");
256     case PD_IEEE8025:
257          return ("IEEE 802.5");
258     case PD_OMNINET:
259          return ("OmniNet");
260     case PD_APPLETALK:
261          return ("AppleTalk");
262     case PD_SLIP:
263          return ("SLIP");
264     case PD_STARTLAN:
265          return ("StartLAN");
266     case PD_ARCNET:
267          return ("ArcNet");
268     case PD_AX25:
269          return ("AX.25");
270     case PD_KISS:
271          return ("KISS");
272     case PD_IEEE8023_2:
273          return ("IEEE 802.3 w/802.2 hdr");
274     case PD_FDDI8022:
275          return ("FDDI w/802.2 hdr");
276     case PD_X25:
277          return ("X.25");
278     case PD_LANstar:
279          return ("LANstar");
280     case PD_PPP:
281          return ("PPP");
282     default:
283          return ("unknown");
284   }
285 }
286 
287 /**************************************************************************/
288 
PktRXmodeStr(PKT_RX_MODE mode)289 PUBLIC char const *PktRXmodeStr (PKT_RX_MODE mode)
290 {
291   static const char *modeStr [] = {
292                     "Receiver turned off",
293                     "Receive only directly addressed packets",
294                     "Receive direct & broadcast packets",
295                     "Receive direct,broadcast and limited multicast packets",
296                     "Receive direct,broadcast and all multicast packets",
297                     "Receive all packets (promiscuouos mode)"
298                   };
299 
300   if (mode > DIM(modeStr))
301      return ("??");
302   return (modeStr [mode-1]);
303 }
304 
305 /**************************************************************************/
306 
PktInterrupt(void)307 LOCAL __inline BOOL PktInterrupt (void)
308 {
309   BOOL okay;
310 
311 #if (DOSX & PHARLAP)
312   _dx_real_int ((UINT)pktInfo.intr, &reg);
313   okay = ((reg.flags & 1) == 0);  /* OK if carry clear */
314 
315 #elif (DOSX & DJGPP)
316   __dpmi_int ((int)pktInfo.intr, &reg);
317   okay = ((reg.x.flags & 1) == 0);
318 
319 #elif (DOSX & DOS4GW)
320   union  REGS  r;
321   struct SREGS s;
322 
323   memset (&r, 0, sizeof(r));
324   segread (&s);
325   r.w.ax  = 0x300;
326   r.x.ebx = pktInfo.intr;
327   r.w.cx  = 0;
328   s.es    = FP_SEG (&reg);
329   r.x.edi = FP_OFF (&reg);
330   reg.r_flags = 0;
331   reg.r_ss = reg.r_sp = 0;     /* DPMI host provides stack */
332 
333   int386x (0x31, &r, &r, &s);
334   okay = (!r.w.cflag);
335 
336 #else
337   reg.r_flags = 0;
338   intr (pktInfo.intr, (struct REGPACK*)&reg);
339   okay = ((reg.r_flags & 1) == 0);
340 #endif
341 
342   if (okay)
343        pktInfo.error = NULL;
344   else pktInfo.error = PktGetErrorStr (reg.r_dx >> 8);
345   return (okay);
346 }
347 
348 /**************************************************************************/
349 
350 /*
351  * Search for packet driver at interrupt 60h through 80h. If ASCIIZ
352  * string "PKT DRVR" found at offset 3 in the interrupt handler, return
353  * interrupt number, else return zero in pktInfo.intr
354  */
PktSearchDriver(void)355 PUBLIC BOOL PktSearchDriver (void)
356 {
357   BYTE intr  = 0x20;
358   BOOL found = FALSE;
359 
360   while (!found && intr < 0xFF)
361   {
362     static char str[12];                 /* 3 + strlen("PKT DRVR") */
363     static char pktStr[9] = "PKT DRVR";  /* ASCIIZ string at ofs 3 */
364     DWORD  rp;                           /* in interrupt  routine  */
365 
366 #if (DOSX & PHARLAP)
367     _dx_rmiv_get (intr, &rp);
368     ReadRealMem (&str, (REALPTR)rp, sizeof(str));
369 
370 #elif (DOSX & DJGPP)
371     __dpmi_raddr realAdr;
372     __dpmi_get_real_mode_interrupt_vector (intr, &realAdr);
373     rp = (realAdr.segment << 4) + realAdr.offset16;
374     dosmemget (rp, sizeof(str), &str);
375 
376 #elif (DOSX & DOS4GW)
377     rp = dpmi_get_real_vector (intr);
378     memcpy (&str, (void*)rp, sizeof(str));
379 
380 #else
381     _fmemcpy (&str, getvect(intr), sizeof(str));
382 #endif
383 
384     found = memcmp (&str[3],&pktStr,sizeof(pktStr)) == 0;
385     intr++;
386   }
387   pktInfo.intr = (found ? intr-1 : 0);
388   return (found);
389 }
390 
391 
392 /**************************************************************************/
393 
PktSetAccess(void)394 static BOOL PktSetAccess (void)
395 {
396   reg.r_ax = 0x0200 + pktInfo.class;
397   reg.r_bx = 0xFFFF;
398   reg.r_dx = 0;
399   reg.r_cx = 0;
400 
401 #if (DOSX & PHARLAP)
402   reg.ds  = 0;
403   reg.esi = 0;
404   reg.es  = RP_SEG (realBase);
405   reg.edi = (WORD) &PktReceiver;
406 
407 #elif (DOSX & DJGPP)
408   reg.x.ds = 0;
409   reg.x.si = 0;
410   reg.x.es = rm_mem.rm_segment;
411   reg.x.di = PktReceiver;
412 
413 #elif (DOSX & DOS4GW)
414   reg.r_ds = 0;
415   reg.r_si = 0;
416   reg.r_es = rm_base_seg;
417   reg.r_di = PktReceiver;
418 
419 #else
420   reg.r_ds = 0;
421   reg.r_si = 0;
422   reg.r_es = FP_SEG (&PktReceiver);
423   reg.r_di = FP_OFF (&PktReceiver);
424 #endif
425 
426   if (!PktInterrupt())
427      return (FALSE);
428 
429   pktInfo.handle = reg.r_ax;
430   return (TRUE);
431 }
432 
433 /**************************************************************************/
434 
PktReleaseHandle(WORD handle)435 PUBLIC BOOL PktReleaseHandle (WORD handle)
436 {
437   reg.r_ax = 0x0300;
438   reg.r_bx = handle;
439   return PktInterrupt();
440 }
441 
442 /**************************************************************************/
443 
PktTransmit(const void * eth,int len)444 PUBLIC BOOL PktTransmit (const void *eth, int len)
445 {
446   if (len > ETH_MTU)
447      return (FALSE);
448 
449   reg.r_ax = 0x0400;             /* Function 4, send pkt */
450   reg.r_cx = len;                /* total size of frame  */
451 
452 #if (DOSX & DJGPP)
453   dosmemput (eth, len, realBase+pktTxBuf);
454   reg.x.ds = rm_mem.rm_segment;  /* DOS data segment and */
455   reg.x.si = pktTxBuf;           /* DOS offset to buffer */
456 
457 #elif (DOSX & DOS4GW)
458   memcpy ((void*)(realBase+pktTxBuf), eth, len);
459   reg.r_ds = rm_base_seg;
460   reg.r_si = pktTxBuf;
461 
462 #elif (DOSX & PHARLAP)
463   memcpy (&pktTxBuf, eth, len);
464   reg.r_ds = FP_SEG (&pktTxBuf);
465   reg.r_si = FP_OFF (&pktTxBuf);
466 
467 #else
468   reg.r_ds = FP_SEG (eth);
469   reg.r_si = FP_OFF (eth);
470 #endif
471 
472   return PktInterrupt();
473 }
474 
475 /**************************************************************************/
476 
477 #if (DOSX & (DJGPP|DOS4GW))
CheckElement(RX_ELEMENT * rx)478 LOCAL __inline BOOL CheckElement (RX_ELEMENT *rx)
479 #else
480 LOCAL __inline BOOL CheckElement (RX_ELEMENT _far *rx)
481 #endif
482 {
483   WORD count_1, count_2;
484 
485   /*
486    * We got an upcall to the same RMCB with wrong handle.
487    * This can happen if we failed to release handle at program exit
488    */
489   if (rx->handle != pktInfo.handle)
490   {
491     pktInfo.error = "Wrong handle";
492     intStat.wrongHandle++;
493     PktReleaseHandle (rx->handle);
494     return (FALSE);
495   }
496   count_1 = rx->firstCount;
497   count_2 = rx->secondCount;
498 
499   if (count_1 != count_2)
500   {
501     pktInfo.error = "Bad sync";
502     intStat.badSync++;
503     return (FALSE);
504   }
505   if (count_1 > ETH_MAX)
506   {
507     pktInfo.error = "Large esize";
508     intStat.tooLarge++;
509     return (FALSE);
510   }
511 #if 0
512   if (count_1 < ETH_MIN)
513   {
514     pktInfo.error = "Small esize";
515     intStat.tooSmall++;
516     return (FALSE);
517   }
518 #endif
519   return (TRUE);
520 }
521 
522 /**************************************************************************/
523 
PktTerminHandle(WORD handle)524 PUBLIC BOOL PktTerminHandle (WORD handle)
525 {
526   reg.r_ax = 0x0500;
527   reg.r_bx = handle;
528   return PktInterrupt();
529 }
530 
531 /**************************************************************************/
532 
PktResetInterface(WORD handle)533 PUBLIC BOOL PktResetInterface (WORD handle)
534 {
535   reg.r_ax = 0x0700;
536   reg.r_bx = handle;
537   return PktInterrupt();
538 }
539 
540 /**************************************************************************/
541 
PktSetReceiverMode(PKT_RX_MODE mode)542 PUBLIC BOOL PktSetReceiverMode (PKT_RX_MODE mode)
543 {
544   if (pktInfo.class == PD_SLIP || pktInfo.class == PD_PPP)
545      return (TRUE);
546 
547   reg.r_ax = 0x1400;
548   reg.r_bx = pktInfo.handle;
549   reg.r_cx = (WORD)mode;
550 
551   if (!PktInterrupt())
552      return (FALSE);
553 
554   receiveMode = mode;
555   return (TRUE);
556 }
557 
558 /**************************************************************************/
559 
PktGetReceiverMode(PKT_RX_MODE * mode)560 PUBLIC BOOL PktGetReceiverMode (PKT_RX_MODE *mode)
561 {
562   reg.r_ax = 0x1500;
563   reg.r_bx = pktInfo.handle;
564 
565   if (!PktInterrupt())
566      return (FALSE);
567 
568   *mode = reg.r_ax;
569   return (TRUE);
570 }
571 
572 /**************************************************************************/
573 
574 static PKT_STAT initialStat;         /* statistics at startup */
575 static BOOL     resetStat = FALSE;   /* statistics reset ? */
576 
PktGetStatistics(WORD handle)577 PUBLIC BOOL PktGetStatistics (WORD handle)
578 {
579   reg.r_ax = 0x1800;
580   reg.r_bx = handle;
581 
582   if (!PktInterrupt())
583      return (FALSE);
584 
585 #if (DOSX & PHARLAP)
586   ReadRealMem (&pktStat, DOS_ADDR(reg.ds,reg.esi), sizeof(pktStat));
587 
588 #elif (DOSX & DJGPP)
589   dosmemget (DOS_ADDR(reg.x.ds,reg.x.si), sizeof(pktStat), &pktStat);
590 
591 #elif (DOSX & DOS4GW)
592   memcpy (&pktStat, (void*)DOS_ADDR(reg.r_ds,reg.r_si), sizeof(pktStat));
593 
594 #else
595   _fmemcpy (&pktStat, MK_FP(reg.r_ds,reg.r_si), sizeof(pktStat));
596 #endif
597 
598   return (TRUE);
599 }
600 
601 /**************************************************************************/
602 
PktSessStatistics(WORD handle)603 PUBLIC BOOL PktSessStatistics (WORD handle)
604 {
605   if (!PktGetStatistics(pktInfo.handle))
606      return (FALSE);
607 
608   if (resetStat)
609   {
610     pktStat.inPackets  -= initialStat.inPackets;
611     pktStat.outPackets -= initialStat.outPackets;
612     pktStat.inBytes    -= initialStat.inBytes;
613     pktStat.outBytes   -= initialStat.outBytes;
614     pktStat.inErrors   -= initialStat.inErrors;
615     pktStat.outErrors  -= initialStat.outErrors;
616     pktStat.outErrors  -= initialStat.outErrors;
617     pktStat.lost       -= initialStat.lost;
618   }
619   return (TRUE);
620 }
621 
622 /**************************************************************************/
623 
PktResetStatistics(WORD handle)624 PUBLIC BOOL PktResetStatistics (WORD handle)
625 {
626   if (!PktGetStatistics(pktInfo.handle))
627      return (FALSE);
628 
629   memcpy (&initialStat, &pktStat, sizeof(initialStat));
630   resetStat = TRUE;
631   return (TRUE);
632 }
633 
634 /**************************************************************************/
635 
PktGetAddress(ETHER * addr)636 PUBLIC BOOL PktGetAddress (ETHER *addr)
637 {
638   reg.r_ax = 0x0600;
639   reg.r_bx = pktInfo.handle;
640   reg.r_cx = sizeof (*addr);
641 
642 #if (DOSX & DJGPP)
643   reg.x.es = rm_mem.rm_segment;
644   reg.x.di = pktTemp;
645 #elif (DOSX & DOS4GW)
646   reg.r_es = rm_base_seg;
647   reg.r_di = pktTemp;
648 #else
649   reg.r_es = FP_SEG (&pktTemp);
650   reg.r_di = FP_OFF (&pktTemp);  /* ES:DI = address for result */
651 #endif
652 
653   if (!PktInterrupt())
654      return (FALSE);
655 
656 #if (DOSX & PHARLAP)
657   ReadRealMem (addr, realBase + (WORD)&pktTemp, sizeof(*addr));
658 
659 #elif (DOSX & DJGPP)
660   dosmemget (realBase+pktTemp, sizeof(*addr), addr);
661 
662 #elif (DOSX & DOS4GW)
663   memcpy (addr, (void*)(realBase+pktTemp), sizeof(*addr));
664 
665 #else
666   memcpy ((void*)addr, &pktTemp, sizeof(*addr));
667 #endif
668 
669   return (TRUE);
670 }
671 
672 /**************************************************************************/
673 
PktSetAddress(const ETHER * addr)674 PUBLIC BOOL PktSetAddress (const ETHER *addr)
675 {
676   /* copy addr to real-mode scrath area */
677 
678 #if (DOSX & PHARLAP)
679   WriteRealMem (realBase + (WORD)&pktTemp, (void*)addr, sizeof(*addr));
680 
681 #elif (DOSX & DJGPP)
682   dosmemput (addr, sizeof(*addr), realBase+pktTemp);
683 
684 #elif (DOSX & DOS4GW)
685   memcpy ((void*)(realBase+pktTemp), addr, sizeof(*addr));
686 
687 #else
688   memcpy (&pktTemp, (void*)addr, sizeof(*addr));
689 #endif
690 
691   reg.r_ax = 0x1900;
692   reg.r_cx = sizeof (*addr);      /* address length       */
693 
694 #if (DOSX & DJGPP)
695   reg.x.es = rm_mem.rm_segment;   /* DOS offset to param  */
696   reg.x.di = pktTemp;             /* DOS segment to param */
697 #elif (DOSX & DOS4GW)
698   reg.r_es = rm_base_seg;
699   reg.r_di = pktTemp;
700 #else
701   reg.r_es = FP_SEG (&pktTemp);
702   reg.r_di = FP_OFF (&pktTemp);
703 #endif
704 
705   return PktInterrupt();
706 }
707 
708 /**************************************************************************/
709 
PktGetDriverInfo(void)710 PUBLIC BOOL PktGetDriverInfo (void)
711 {
712   pktInfo.majVer = 0;
713   pktInfo.minVer = 0;
714   memset (&pktInfo.name, 0, sizeof(pktInfo.name));
715   reg.r_ax = 0x01FF;
716   reg.r_bx = 0;
717 
718   if (!PktInterrupt())
719      return (FALSE);
720 
721   pktInfo.number = reg.r_cx & 0xFF;
722   pktInfo.class  = reg.r_cx >> 8;
723 #if 0
724   pktInfo.minVer = reg.r_bx % 10;
725   pktInfo.majVer = reg.r_bx / 10;
726 #else
727   pktInfo.majVer = reg.r_bx;  // !!
728 #endif
729   pktInfo.funcs  = reg.r_ax & 0xFF;
730   pktInfo.type   = reg.r_dx & 0xFF;
731 
732 #if (DOSX & PHARLAP)
733   ReadRealMem (&pktInfo.name, DOS_ADDR(reg.ds,reg.esi), sizeof(pktInfo.name));
734 
735 #elif (DOSX & DJGPP)
736   dosmemget (DOS_ADDR(reg.x.ds,reg.x.si), sizeof(pktInfo.name), &pktInfo.name);
737 
738 #elif (DOSX & DOS4GW)
739   memcpy (&pktInfo.name, (void*)DOS_ADDR(reg.r_ds,reg.r_si), sizeof(pktInfo.name));
740 
741 #else
742   _fmemcpy (&pktInfo.name, MK_FP(reg.r_ds,reg.r_si), sizeof(pktInfo.name));
743 #endif
744   return (TRUE);
745 }
746 
747 /**************************************************************************/
748 
PktGetDriverParam(void)749 PUBLIC BOOL PktGetDriverParam (void)
750 {
751   reg.r_ax = 0x0A00;
752 
753   if (!PktInterrupt())
754      return (FALSE);
755 
756 #if (DOSX & PHARLAP)
757   ReadRealMem (&pktInfo.majVer, DOS_ADDR(reg.es,reg.edi), PKT_PARAM_SIZE);
758 
759 #elif (DOSX & DJGPP)
760   dosmemget (DOS_ADDR(reg.x.es,reg.x.di), PKT_PARAM_SIZE, &pktInfo.majVer);
761 
762 #elif (DOSX & DOS4GW)
763   memcpy (&pktInfo.majVer, (void*)DOS_ADDR(reg.r_es,reg.r_di), PKT_PARAM_SIZE);
764 
765 #else
766   _fmemcpy (&pktInfo.majVer, MK_FP(reg.r_es,reg.r_di), PKT_PARAM_SIZE);
767 #endif
768   return (TRUE);
769 }
770 
771 /**************************************************************************/
772 
773 #if (DOSX & PHARLAP)
PktReceive(BYTE * buf,int max)774   PUBLIC int PktReceive (BYTE *buf, int max)
775   {
776     WORD inOfs  = *rxInOfsFp;
777     WORD outOfs = *rxOutOfsFp;
778 
779     if (outOfs != inOfs)
780     {
781       RX_ELEMENT _far *head = (RX_ELEMENT _far*)(protBase+outOfs);
782       int size, len = max;
783 
784       if (CheckElement(head))
785       {
786         size = min (head->firstCount, sizeof(RX_ELEMENT));
787         len  = min (size, max);
788         _fmemcpy (buf, &head->destin, len);
789       }
790       else
791         size = -1;
792 
793       outOfs += sizeof (RX_ELEMENT);
794       if (outOfs > LAST_RX_BUF)
795           outOfs = FIRST_RX_BUF;
796       *rxOutOfsFp = outOfs;
797       return (size);
798     }
799     return (0);
800   }
801 
PktQueueBusy(BOOL busy)802   PUBLIC void PktQueueBusy (BOOL busy)
803   {
804     *rxOutOfsFp = busy ? (*rxInOfsFp + sizeof(RX_ELEMENT)) : *rxInOfsFp;
805     if (*rxOutOfsFp > LAST_RX_BUF)
806         *rxOutOfsFp = FIRST_RX_BUF;
807     *(DWORD _far*)(protBase + (WORD)&pktDrop) = 0;
808   }
809 
PktBuffersUsed(void)810   PUBLIC WORD PktBuffersUsed (void)
811   {
812     WORD inOfs  = *rxInOfsFp;
813     WORD outOfs = *rxOutOfsFp;
814 
815     if (inOfs >= outOfs)
816        return (inOfs - outOfs) / sizeof(RX_ELEMENT);
817     return (NUM_RX_BUF - (outOfs - inOfs) / sizeof(RX_ELEMENT));
818   }
819 
PktRxDropped(void)820   PUBLIC DWORD PktRxDropped (void)
821   {
822     return (*(DWORD _far*)(protBase + (WORD)&pktDrop));
823   }
824 
825 #elif (DOSX & DJGPP)
PktReceive(BYTE * buf,int max)826   PUBLIC int PktReceive (BYTE *buf, int max)
827   {
828     WORD ofs = _farpeekw (_dos_ds, realBase+rxOutOfs);
829 
830     if (ofs != _farpeekw (_dos_ds, realBase+rxInOfs))
831     {
832       RX_ELEMENT head;
833       int  size, len = max;
834 
835       head.firstCount  = _farpeekw (_dos_ds, realBase+ofs);
836       head.secondCount = _farpeekw (_dos_ds, realBase+ofs+2);
837       head.handle      = _farpeekw (_dos_ds, realBase+ofs+4);
838 
839       if (CheckElement(&head))
840       {
841         size = min (head.firstCount, sizeof(RX_ELEMENT));
842         len  = min (size, max);
843         dosmemget (realBase+ofs+6, len, buf);
844       }
845       else
846         size = -1;
847 
848       ofs += sizeof (RX_ELEMENT);
849       if (ofs > LAST_RX_BUF)
850            _farpokew (_dos_ds, realBase+rxOutOfs, FIRST_RX_BUF);
851       else _farpokew (_dos_ds, realBase+rxOutOfs, ofs);
852       return (size);
853     }
854     return (0);
855   }
856 
PktQueueBusy(BOOL busy)857   PUBLIC void PktQueueBusy (BOOL busy)
858   {
859     WORD ofs;
860 
861     disable();
862     ofs = _farpeekw (_dos_ds, realBase+rxInOfs);
863     if (busy)
864        ofs += sizeof (RX_ELEMENT);
865 
866     if (ofs > LAST_RX_BUF)
867          _farpokew (_dos_ds, realBase+rxOutOfs, FIRST_RX_BUF);
868     else _farpokew (_dos_ds, realBase+rxOutOfs, ofs);
869     _farpokel (_dos_ds, realBase+pktDrop, 0UL);
870     enable();
871   }
872 
PktBuffersUsed(void)873   PUBLIC WORD PktBuffersUsed (void)
874   {
875     WORD inOfs, outOfs;
876 
877     disable();
878     inOfs  = _farpeekw (_dos_ds, realBase+rxInOfs);
879     outOfs = _farpeekw (_dos_ds, realBase+rxOutOfs);
880     enable();
881     if (inOfs >= outOfs)
882        return (inOfs - outOfs) / sizeof(RX_ELEMENT);
883     return (NUM_RX_BUF - (outOfs - inOfs) / sizeof(RX_ELEMENT));
884   }
885 
PktRxDropped(void)886   PUBLIC DWORD PktRxDropped (void)
887   {
888     return _farpeekl (_dos_ds, realBase+pktDrop);
889   }
890 
891 #elif (DOSX & DOS4GW)
PktReceive(BYTE * buf,int max)892   PUBLIC int PktReceive (BYTE *buf, int max)
893   {
894     WORD ofs = *(WORD*) (realBase+rxOutOfs);
895 
896     if (ofs != *(WORD*) (realBase+rxInOfs))
897     {
898       RX_ELEMENT head;
899       int  size, len = max;
900 
901       head.firstCount  = *(WORD*) (realBase+ofs);
902       head.secondCount = *(WORD*) (realBase+ofs+2);
903       head.handle      = *(WORD*) (realBase+ofs+4);
904 
905       if (CheckElement(&head))
906       {
907         size = min (head.firstCount, sizeof(RX_ELEMENT));
908         len  = min (size, max);
909         memcpy (buf, (const void*)(realBase+ofs+6), len);
910       }
911       else
912         size = -1;
913 
914       ofs += sizeof (RX_ELEMENT);
915       if (ofs > LAST_RX_BUF)
916            *(WORD*) (realBase+rxOutOfs) = FIRST_RX_BUF;
917       else *(WORD*) (realBase+rxOutOfs) = ofs;
918       return (size);
919     }
920     return (0);
921   }
922 
PktQueueBusy(BOOL busy)923   PUBLIC void PktQueueBusy (BOOL busy)
924   {
925     WORD ofs;
926 
927     _disable();
928     ofs = *(WORD*) (realBase+rxInOfs);
929     if (busy)
930        ofs += sizeof (RX_ELEMENT);
931 
932     if (ofs > LAST_RX_BUF)
933          *(WORD*) (realBase+rxOutOfs) = FIRST_RX_BUF;
934     else *(WORD*) (realBase+rxOutOfs) = ofs;
935     *(DWORD*) (realBase+pktDrop) = 0UL;
936     _enable();
937   }
938 
PktBuffersUsed(void)939   PUBLIC WORD PktBuffersUsed (void)
940   {
941     WORD inOfs, outOfs;
942 
943     _disable();
944     inOfs  = *(WORD*) (realBase+rxInOfs);
945     outOfs = *(WORD*) (realBase+rxOutOfs);
946     _enable();
947     if (inOfs >= outOfs)
948        return (inOfs - outOfs) / sizeof(RX_ELEMENT);
949     return (NUM_RX_BUF - (outOfs - inOfs) / sizeof(RX_ELEMENT));
950   }
951 
PktRxDropped(void)952   PUBLIC DWORD PktRxDropped (void)
953   {
954     return *(DWORD*) (realBase+pktDrop);
955   }
956 
957 #else     /* real-mode small/large model */
958 
PktReceive(BYTE * buf,int max)959   PUBLIC int PktReceive (BYTE *buf, int max)
960   {
961     if (rxOutOfs != rxInOfs)
962     {
963       RX_ELEMENT far *head = (RX_ELEMENT far*) MK_FP (_DS,rxOutOfs);
964       int  size, len = max;
965 
966       if (CheckElement(head))
967       {
968         size = min (head->firstCount, sizeof(RX_ELEMENT));
969         len  = min (size, max);
970         _fmemcpy (buf, &head->destin, len);
971       }
972       else
973         size = -1;
974 
975       rxOutOfs += sizeof (RX_ELEMENT);
976       if (rxOutOfs > LAST_RX_BUF)
977           rxOutOfs = FIRST_RX_BUF;
978       return (size);
979     }
980     return (0);
981   }
982 
PktQueueBusy(BOOL busy)983   PUBLIC void PktQueueBusy (BOOL busy)
984   {
985     rxOutOfs = busy ? (rxInOfs + sizeof(RX_ELEMENT)) : rxInOfs;
986     if (rxOutOfs > LAST_RX_BUF)
987         rxOutOfs = FIRST_RX_BUF;
988     pktDrop = 0L;
989   }
990 
PktBuffersUsed(void)991   PUBLIC WORD PktBuffersUsed (void)
992   {
993     WORD inOfs  = rxInOfs;
994     WORD outOfs = rxOutOfs;
995 
996     if (inOfs >= outOfs)
997        return ((inOfs - outOfs) / sizeof(RX_ELEMENT));
998     return (NUM_RX_BUF - (outOfs - inOfs) / sizeof(RX_ELEMENT));
999   }
1000 
PktRxDropped(void)1001   PUBLIC DWORD PktRxDropped (void)
1002   {
1003     return (pktDrop);
1004   }
1005 #endif
1006 
1007 /**************************************************************************/
1008 
PktFreeMem(void)1009 LOCAL __inline void PktFreeMem (void)
1010 {
1011 #if (DOSX & PHARLAP)
1012   if (realSeg)
1013   {
1014     _dx_real_free (realSeg);
1015     realSeg = 0;
1016   }
1017 #elif (DOSX & DJGPP)
1018   if (rm_mem.rm_segment)
1019   {
1020     unsigned ofs;  /* clear the DOS-mem to prevent further upcalls */
1021 
1022     for (ofs = 0; ofs < 16 * rm_mem.size / 4; ofs += 4)
1023        _farpokel (_dos_ds, realBase + ofs, 0);
1024     _go32_dpmi_free_dos_memory (&rm_mem);
1025     rm_mem.rm_segment = 0;
1026   }
1027 #elif (DOSX & DOS4GW)
1028   if (rm_base_sel)
1029   {
1030     dpmi_real_free (rm_base_sel);
1031     rm_base_sel = 0;
1032   }
1033 #endif
1034 }
1035 
1036 /**************************************************************************/
1037 
PktExitDriver(void)1038 PUBLIC BOOL PktExitDriver (void)
1039 {
1040   if (pktInfo.handle)
1041   {
1042     if (!PktSetReceiverMode(PDRX_BROADCAST))
1043        PUTS ("Error restoring receiver mode.");
1044 
1045     if (!PktReleaseHandle(pktInfo.handle))
1046        PUTS ("Error releasing PKT-DRVR handle.");
1047 
1048     PktFreeMem();
1049     pktInfo.handle = 0;
1050   }
1051 
1052   if (pcap_pkt_debug >= 1)
1053      printf ("Internal stats: too-small %lu, too-large %lu, bad-sync %lu, "
1054              "wrong-handle %lu\n",
1055              intStat.tooSmall, intStat.tooLarge,
1056              intStat.badSync, intStat.wrongHandle);
1057   return (TRUE);
1058 }
1059 
1060 #if (DOSX & (DJGPP|DOS4GW))
dump_pkt_stub(void)1061 static void dump_pkt_stub (void)
1062 {
1063   int i;
1064 
1065   fprintf (stderr, "PktReceiver %lu, pkt_stub[PktReceiver] =\n",
1066            PktReceiver);
1067   for (i = 0; i < 15; i++)
1068       fprintf (stderr, "%02X, ", real_stub_array[i+PktReceiver]);
1069   fputs ("\n", stderr);
1070 }
1071 #endif
1072 
1073 /*
1074  * Front end initialization routine
1075  */
PktInitDriver(PKT_RX_MODE mode)1076 PUBLIC BOOL PktInitDriver (PKT_RX_MODE mode)
1077 {
1078   PKT_RX_MODE rxMode;
1079   BOOL   writeInfo = (pcap_pkt_debug >= 3);
1080 
1081   pktInfo.quiet = (pcap_pkt_debug < 3);
1082 
1083 #if (DOSX & PHARLAP) && defined(__HIGHC__)
1084   if (_mwenv != 2)
1085   {
1086     fprintf (stderr, "Only Pharlap DOS extender supported.\n");
1087     return (FALSE);
1088   }
1089 #endif
1090 
1091 #if (DOSX & PHARLAP) && defined(__WATCOMC__)
1092   if (_Extender != 1)
1093   {
1094     fprintf (stderr, "Only DOS4GW style extenders supported.\n");
1095     return (FALSE);
1096   }
1097 #endif
1098 
1099   if (!PktSearchDriver())
1100   {
1101     PUTS ("Packet driver not found.");
1102     PktFreeMem();
1103     return (FALSE);
1104   }
1105 
1106   if (!PktGetDriverInfo())
1107   {
1108     PUTS ("Error getting pkt-drvr information.");
1109     PktFreeMem();
1110     return (FALSE);
1111   }
1112 
1113 #if (DOSX & PHARLAP)
1114   if (RealCopy((ULONG)&rxOutOfs, (ULONG)&pktRxEnd,
1115                &realBase, &protBase, (USHORT*)&realSeg))
1116   {
1117     rxOutOfsFp  = (WORD _far *) (protBase + (WORD) &rxOutOfs);
1118     rxInOfsFp   = (WORD _far *) (protBase + (WORD) &rxInOfs);
1119     *rxOutOfsFp = FIRST_RX_BUF;
1120     *rxInOfsFp  = FIRST_RX_BUF;
1121   }
1122   else
1123   {
1124     PUTS ("Cannot allocate real-mode stub.");
1125     return (FALSE);
1126   }
1127 
1128 #elif (DOSX & (DJGPP|DOS4GW))
1129   if (sizeof(real_stub_array) > 0xFFFF)
1130   {
1131     fprintf (stderr, "`real_stub_array[]' too big.\n");
1132     return (FALSE);
1133   }
1134 #if (DOSX & DJGPP)
1135   rm_mem.size = (sizeof(real_stub_array) + 15) / 16;
1136 
1137   if (_go32_dpmi_allocate_dos_memory(&rm_mem) || rm_mem.rm_offset != 0)
1138   {
1139     PUTS ("real-mode init failed.");
1140     return (FALSE);
1141   }
1142   realBase = (rm_mem.rm_segment << 4);
1143   dosmemput (&real_stub_array, sizeof(real_stub_array), realBase);
1144   _farpokel (_dos_ds, realBase+rxOutOfs, FIRST_RX_BUF);
1145   _farpokel (_dos_ds, realBase+rxInOfs,  FIRST_RX_BUF);
1146 
1147 #elif (DOSX & DOS4GW)
1148   rm_base_seg = dpmi_real_malloc (sizeof(real_stub_array), &rm_base_sel);
1149   if (!rm_base_seg)
1150   {
1151     PUTS ("real-mode init failed.");
1152     return (FALSE);
1153   }
1154   realBase = (rm_base_seg << 4);
1155   memcpy ((void*)realBase, &real_stub_array, sizeof(real_stub_array));
1156   *(WORD*) (realBase+rxOutOfs) = FIRST_RX_BUF;
1157   *(WORD*) (realBase+rxInOfs)  = FIRST_RX_BUF;
1158 
1159 #endif
1160   {
1161     int pushf = PktReceiver;
1162 
1163     while (real_stub_array[pushf++] != 0x9C &&    /* pushf */
1164            real_stub_array[pushf]   != 0xFA)      /* cli   */
1165     {
1166       if (++para_skip > 16)
1167       {
1168         fprintf (stderr, "Something wrong with `pkt_stub.inc'.\n");
1169         para_skip = 0;
1170         dump_pkt_stub();
1171         return (FALSE);
1172       }
1173     }
1174     if (*(WORD*)(real_stub_array + offsetof(PktRealStub,_dummy)) != 0xB800)
1175     {
1176       fprintf (stderr, "`real_stub_array[]' is misaligned.\n");
1177       return (FALSE);
1178     }
1179   }
1180 
1181   if (pcap_pkt_debug > 2)
1182       dump_pkt_stub();
1183 
1184 #else
1185   rxOutOfs = FIRST_RX_BUF;
1186   rxInOfs  = FIRST_RX_BUF;
1187 #endif
1188 
1189   if (!PktSetAccess())
1190   {
1191     PUTS ("Error setting pkt-drvr access.");
1192     PktFreeMem();
1193     return (FALSE);
1194   }
1195 
1196   if (!PktGetAddress(&myAddress))
1197   {
1198     PUTS ("Error fetching adapter address.");
1199     PktFreeMem();
1200     return (FALSE);
1201   }
1202 
1203   if (!PktSetReceiverMode(mode))
1204   {
1205     PUTS ("Error setting receiver mode.");
1206     PktFreeMem();
1207     return (FALSE);
1208   }
1209 
1210   if (!PktGetReceiverMode(&rxMode))
1211   {
1212     PUTS ("Error getting receiver mode.");
1213     PktFreeMem();
1214     return (FALSE);
1215   }
1216 
1217   if (writeInfo)
1218      printf ("Pkt-driver information:\n"
1219              "  Version  : %d.%d\n"
1220              "  Name     : %.15s\n"
1221              "  Class    : %u (%s)\n"
1222              "  Type     : %u\n"
1223              "  Number   : %u\n"
1224              "  Funcs    : %u\n"
1225              "  Intr     : %Xh\n"
1226              "  Handle   : %u\n"
1227              "  Extended : %s\n"
1228              "  Hi-perf  : %s\n"
1229              "  RX mode  : %s\n"
1230              "  Eth-addr : %02X:%02X:%02X:%02X:%02X:%02X\n",
1231 
1232              pktInfo.majVer, pktInfo.minVer, pktInfo.name,
1233              pktInfo.class,  PktGetClassName(pktInfo.class),
1234              pktInfo.type,   pktInfo.number,
1235              pktInfo.funcs,  pktInfo.intr,   pktInfo.handle,
1236              pktInfo.funcs == 2 || pktInfo.funcs == 6 ? "Yes" : "No",
1237              pktInfo.funcs == 5 || pktInfo.funcs == 6 ? "Yes" : "No",
1238              PktRXmodeStr(rxMode),
1239              myAddress[0], myAddress[1], myAddress[2],
1240              myAddress[3], myAddress[4], myAddress[5]);
1241 
1242 #if defined(DEBUG) && (DOSX & PHARLAP)
1243   if (writeInfo)
1244   {
1245     DWORD    rAdr = realBase + (WORD)&PktReceiver;
1246     unsigned sel, ofs;
1247 
1248     printf ("\nReceiver at   %04X:%04X\n", RP_SEG(rAdr),    RP_OFF(rAdr));
1249     printf ("Realbase    = %04X:%04X\n",   RP_SEG(realBase),RP_OFF(realBase));
1250 
1251     sel = _FP_SEG (protBase);
1252     ofs = _FP_OFF (protBase);
1253     printf ("Protbase    = %04X:%08X\n", sel,ofs);
1254     printf ("RealSeg     = %04X\n", realSeg);
1255 
1256     sel = _FP_SEG (rxOutOfsFp);
1257     ofs = _FP_OFF (rxOutOfsFp);
1258     printf ("rxOutOfsFp  = %04X:%08X\n", sel,ofs);
1259 
1260     sel = _FP_SEG (rxInOfsFp);
1261     ofs = _FP_OFF (rxInOfsFp);
1262     printf ("rxInOfsFp   = %04X:%08X\n", sel,ofs);
1263 
1264     printf ("Ready: *rxOutOfsFp = %04X *rxInOfsFp = %04X\n",
1265             *rxOutOfsFp, *rxInOfsFp);
1266 
1267     PktQueueBusy (TRUE);
1268     printf ("Busy:  *rxOutOfsFp = %04X *rxInOfsFp = %04X\n",
1269             *rxOutOfsFp, *rxInOfsFp);
1270   }
1271 #endif
1272 
1273   memset (&pktStat, 0, sizeof(pktStat));  /* clear statistics */
1274   PktQueueBusy (TRUE);
1275   return (TRUE);
1276 }
1277 
1278 
1279 /*
1280  * DPMI functions only for Watcom + DOS4GW extenders
1281  */
1282 #if (DOSX & DOS4GW)
dpmi_get_real_vector(int intr)1283 LOCAL DWORD dpmi_get_real_vector (int intr)
1284 {
1285   union REGS r;
1286 
1287   r.x.eax = 0x200;
1288   r.x.ebx = (DWORD) intr;
1289   int386 (0x31, &r, &r);
1290   return ((r.w.cx << 4) + r.w.dx);
1291 }
1292 
dpmi_real_malloc(int size,WORD * selector)1293 LOCAL WORD dpmi_real_malloc (int size, WORD *selector)
1294 {
1295   union REGS r;
1296 
1297   r.x.eax = 0x0100;             /* DPMI allocate DOS memory */
1298   r.x.ebx = (size + 15) / 16;   /* Number of paragraphs requested */
1299   int386 (0x31, &r, &r);
1300   if (r.w.cflag & 1)
1301      return (0);
1302 
1303   *selector = r.w.dx;
1304   return (r.w.ax);              /* Return segment address */
1305 }
1306 
dpmi_real_free(WORD selector)1307 LOCAL void dpmi_real_free (WORD selector)
1308 {
1309   union REGS r;
1310 
1311   r.x.eax = 0x101;              /* DPMI free DOS memory */
1312   r.x.ebx = selector;           /* Selector to free */
1313   int386 (0x31, &r, &r);
1314 }
1315 #endif
1316 
1317 
1318 #if defined(DOSX) && (DOSX & PHARLAP)
1319 /*
1320  * Description:
1321  *     This routine allocates conventional memory for the specified block
1322  *     of code (which must be within the first 64K of the protected mode
1323  *     program segment) and copies the code to it.
1324  *
1325  *     The caller should free up the conventional memory block when it
1326  *     is done with the conventional memory.
1327  *
1328  *     NOTE THIS ROUTINE REQUIRES 386|DOS-EXTENDER 3.0 OR LATER.
1329  *
1330  * Calling arguments:
1331  *     start_offs      start of real mode code in program segment
1332  *     end_offs        1 byte past end of real mode code in program segment
1333  *     real_basep      returned;  real mode ptr to use as a base for the
1334  *                        real mode code (eg, to get the real mode FAR
1335  *                        addr of a function foo(), take
1336  *                        real_basep + (ULONG) foo).
1337  *                        This pointer is constructed such that
1338  *                        offsets within the real mode segment are
1339  *                        the same as the link-time offsets in the
1340  *                        protected mode program segment
1341  *     prot_basep      returned;  prot mode ptr to use as a base for getting
1342  *                        to the conventional memory, also constructed
1343  *                        so that adding the prot mode offset of a
1344  *                        function or variable to the base gets you a
1345  *                        ptr to the function or variable in the
1346  *                        conventional memory block.
1347  *     rmem_adrp       returned;  real mode para addr of allocated
1348  *                        conventional memory block, to be used to free
1349  *                        up the conventional memory when done.  DO NOT
1350  *                        USE THIS TO CONSTRUCT A REAL MODE PTR, USE
1351  *                        REAL_BASEP INSTEAD SO THAT OFFSETS WORK OUT
1352  *                        CORRECTLY.
1353  *
1354  * Returned values:
1355  *     0      if error
1356  *     1      if success
1357  */
RealCopy(ULONG start_offs,ULONG end_offs,REALPTR * real_basep,FARPTR * prot_basep,USHORT * rmem_adrp)1358 int RealCopy (ULONG    start_offs,
1359               ULONG    end_offs,
1360               REALPTR *real_basep,
1361               FARPTR  *prot_basep,
1362               USHORT  *rmem_adrp)
1363 {
1364   ULONG   rm_base;    /* base real mode para addr for accessing */
1365                       /* allocated conventional memory          */
1366   UCHAR  *source;     /* source pointer for copy                */
1367   FARPTR  destin;     /* destination pointer for copy           */
1368   ULONG   len;        /* number of bytes to copy                */
1369   ULONG   temp;
1370   USHORT  stemp;
1371 
1372   /* First check for valid inputs
1373    */
1374   if (start_offs >= end_offs || end_offs > 0x10000)
1375      return (FALSE);
1376 
1377   /* Round start_offs down to a paragraph (16-byte) boundary so we can set up
1378    * the real mode pointer easily. Round up end_offs to make sure we allocate
1379    * enough paragraphs
1380    */
1381   start_offs &= ~15;
1382   end_offs = (15 + (end_offs << 4)) >> 4;
1383 
1384   /* Allocate the conventional memory for our real mode code.  Remember to
1385    * round byte count UP to 16-byte paragraph size.  We alloc it
1386    * above the DOS data buffer so both the DOS data buffer and the appl
1387    * conventional mem block can still be resized.
1388    *
1389    * First just try to alloc it;  if we can't get it, shrink the appl mem
1390    * block down to the minimum, try to alloc the memory again, then grow the
1391    * appl mem block back to the maximum.  (Don't try to shrink the DOS data
1392    * buffer to free conventional memory;  it wouldn't be good for this routine
1393    * to have the possible side effect of making file I/O run slower.)
1394    */
1395   len = ((end_offs - start_offs) + 15) >> 4;
1396   if (_dx_real_above(len, rmem_adrp, &stemp) != _DOSE_NONE)
1397   {
1398     if (_dx_cmem_usage(0, 0, &temp, &temp) != _DOSE_NONE)
1399        return (FALSE);
1400 
1401     if (_dx_real_above(len, rmem_adrp, &stemp) != _DOSE_NONE)
1402        *rmem_adrp = 0;
1403 
1404     if (_dx_cmem_usage(0, 1, &temp, &temp) != _DOSE_NONE)
1405     {
1406       if (*rmem_adrp != 0)
1407          _dx_real_free (*rmem_adrp);
1408       return (FALSE);
1409     }
1410 
1411     if (*rmem_adrp == 0)
1412        return (FALSE);
1413   }
1414 
1415   /* Construct real mode & protected mode pointers to access the allocated
1416    * memory.  Note we know start_offs is aligned on a paragraph (16-byte)
1417    * boundary, because we rounded it down.
1418    *
1419    * We make the offsets come out rights by backing off the real mode selector
1420    * by start_offs.
1421    */
1422   rm_base = ((ULONG) *rmem_adrp) - (start_offs >> 4);
1423   RP_SET (*real_basep, 0, rm_base);
1424   FP_SET (*prot_basep, rm_base << 4, SS_DOSMEM);
1425 
1426   /* Copy the real mode code/data to the allocated memory
1427    */
1428   source = (UCHAR *) start_offs;
1429   destin = *prot_basep;
1430   FP_SET (destin, FP_OFF(*prot_basep) + start_offs, FP_SEL(*prot_basep));
1431   len = end_offs - start_offs;
1432   WriteFarMem (destin, source, len);
1433 
1434   return (TRUE);
1435 }
1436 #endif /* DOSX && (DOSX & PHARLAP) */
1437