nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * Copyright (c) 1993,1994
3 * Texas A&M University. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Texas A&M University
16 * and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * Developers:
34 * David K. Hess, Douglas Lee Schales, David R. Safford
35 *
36 * Heavily modified for Metaware HighC + GNU C 2.8+
37 * Gisle Vanem 1998
38 */
39  
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <dos.h>
43 #include <io.h>
44 #include <fcntl.h>
45 #include <malloc.h>
46 #include <string.h>
47  
48 #include "pcap-dos.h"
49 #include "pcap-int.h"
50 #include "msdos/ndis2.h"
51  
52 #if defined(USE_NDIS2)
53  
54 /*
55 * Packet buffer handling
56 */
57 extern int FreePktBuf (PktBuf *buf);
58 extern int EnquePktBuf (PktBuf *buf);
59 extern PktBuf* AllocPktBuf (void);
60  
61 /*
62 * Various defines
63 */
64 #define MAX_NUM_DEBUG_STRINGS 90
65 #define DEBUG_STRING_LENGTH 80
66 #define STACK_POOL_SIZE 6
67 #define STACK_SIZE 256
68  
69 #define MEDIA_FDDI 1
70 #define MEDIA_ETHERNET 2
71 #define MEDIA_TOKEN 3
72  
73 static int startDebug = 0;
74 static int stopDebug = 0;
75  
76 static DWORD droppedPackets = 0L;
77 static WORD frameSize = 0;
78 static WORD headerSize = 0;
79 static int mediaType = 0;
80 static char *lastErr = NULL;
81  
82 static BYTE debugStrings [MAX_NUM_DEBUG_STRINGS][DEBUG_STRING_LENGTH];
83 static BYTE *freeStacks [STACK_POOL_SIZE];
84 static int freeStackPtr = STACK_POOL_SIZE - 1;
85  
86 static ProtMan protManEntry = NULL;
87 static WORD protManDS = 0;
88 static volatile int xmitPending;
89  
90 static struct _PktBuf *txBufPending;
91 static struct _CardHandle *handle;
92 static struct _CommonChars common;
93 static struct _ProtocolChars protChars;
94 static struct _ProtDispatch lowerTable;
95  
96 static struct _FailingModules failingModules;
97 static struct _BindingsList bindings;
98  
99 static struct {
100 WORD err_num;
101 char *err_text;
102 } ndis_errlist[] = {
103  
104 { ERR_SUCCESS,
105 "The function completed successfully.\n" },
106  
107 { ERR_WAIT_FOR_RELEASE,
108 "The ReceiveChain completed successfully but the protocol has\n"
109 "retained control of the buffer.\n" },
110  
111 { ERR_REQUEST_QUEUED,
112 "The current request has been queued.\n" },
113  
114 { ERR_FRAME_NOT_RECOGNIZED,
115 "Frame not recognized.\n" },
116  
117 { ERR_FRAME_REJECTED,
118 "Frame was discarded.\n" },
119  
120 { ERR_FORWARD_FRAME,
121 "Protocol wishes to forward frame to another protocol.\n" },
122  
123 { ERR_OUT_OF_RESOURCE,
124 "Out of resource.\n" },
125  
126 { ERR_INVALID_PARAMETER,
127 "Invalid parameter.\n" },
128  
129 { ERR_INVALID_FUNCTION,
130 "Invalid function.\n" },
131  
132 { ERR_NOT_SUPPORTED,
133 "Not supported.\n" },
134  
135 { ERR_HARDWARE_ERROR,
136 "Hardware error.\n" },
137  
138 { ERR_TRANSMIT_ERROR,
139 "The packet was not transmitted due to an error.\n" },
140  
141 { ERR_NO_SUCH_DESTINATION,
142 "Token ring packet was not recognized when transmitted.\n" },
143  
144 { ERR_BUFFER_TOO_SMALL,
145 "Provided buffer was too small.\n" },
146  
147 { ERR_ALREADY_STARTED,
148 "Network drivers already started.\n" },
149  
150 { ERR_INCOMPLETE_BINDING,
151 "Protocol driver could not complete its bindings.\n" },
152  
153 { ERR_DRIVER_NOT_INITIALIZED,
154 "MAC did not initialize properly.\n" },
155  
156 { ERR_HARDWARE_NOT_FOUND,
157 "Hardware not found.\n" },
158  
159 { ERR_HARDWARE_FAILURE,
160 "Hardware failure.\n" },
161  
162 { ERR_CONFIGURATION_FAILURE,
163 "Configuration failure.\n" },
164  
165 { ERR_INTERRUPT_CONFLICT,
166 "Interrupt conflict.\n" },
167  
168 { ERR_INCOMPATIBLE_MAC,
169 "The MAC is not compatible with the protocol.\n" },
170  
171 { ERR_INITIALIZATION_FAILED,
172 "Initialization failed.\n" },
173  
174 { ERR_NO_BINDING,
175 "Binding did not occur.\n" },
176  
177 { ERR_NETWORK_MAY_NOT_BE_CONNECTED,
178 "The network may not be connected to the adapter.\n" },
179  
180 { ERR_INCOMPATIBLE_OS_VERSION,
181 "The version of the operating system is incompatible with the protocol.\n" },
182  
183 { ERR_ALREADY_REGISTERED,
184 "The protocol is already registered.\n" },
185  
186 { ERR_PATH_NOT_FOUND,
187 "PROTMAN.EXE could not be found.\n" },
188  
189 { ERR_INSUFFICIENT_MEMORY,
190 "Insufficient memory.\n" },
191  
192 { ERR_INFO_NOT_FOUND,
193 "Protocol Mananger info structure is lost or corrupted.\n" },
194  
195 { ERR_GENERAL_FAILURE,
196 "General failure.\n" }
197 };
198  
199 /*
200 * Some handy macros
201 */
202 #define PERROR(str) printf("%s (%d): %s\n", __FILE__,__LINE__,str)
203 #define DEBUG_RING() (debugStrings[stopDebug+1 == MAX_NUM_DEBUG_STRINGS ? \
204 stopDebug = 0 : ++stopDebug])
205  
206 /*
207 * needs rewrite for DOSX
208 */
209 #define MAC_DISPATCH(hnd) ((struct _MacUpperDispatch*)(hnd)->common->upperDispatchTable)
210 #define MAC_STATUS(hnd) ((struct _MacStatusTable*) (hnd)->common->serviceStatus)
211 #define MAC_CHAR(hnd) ((struct _MacChars*) (hnd)->common->serviceChars)
212  
213 #ifdef NDIS_DEBUG
214 #define DEBUG0(str) printf (str)
215 #define DEBUG1(fmt,a) printf (fmt,a)
216 #define DEBUG2(fmt,a,b) printf (fmt,a,b)
217 #define TRACE0(str) sprintf (DEBUG_RING(),str)
218 #define TRACE1(fmt,a) sprintf (DEBUG_RING(),fmt,a)
219 #else
220 #define DEBUG0(str) ((void)0)
221 #define DEBUG1(fmt,a) ((void)0)
222 #define DEBUG2(fmt,a,b) ((void)0)
223 #define TRACE0(str) ((void)0)
224 #define TRACE1(fmt,a) ((void)0)
225 #endif
226  
227 /*
228 * This routine is called from both threads
229 */
230 void NdisFreeStack (BYTE *aStack)
231 {
232 GUARD();
233  
234 if (freeStackPtr == STACK_POOL_SIZE - 1)
235 PERROR ("tried to free too many stacks");
236  
237 freeStacks[++freeStackPtr] = aStack;
238  
239 if (freeStackPtr == 0)
240 TRACE0 ("freeStackPtr went positive\n");
241  
242 UNGUARD();
243 }
244  
245 /*
246 * This routine is called from callbacks to allocate local data
247 */
248 BYTE *NdisAllocStack (void)
249 {
250 BYTE *stack;
251  
252 GUARD();
253  
254 if (freeStackPtr < 0)
255 {
256 /* Ran out of stack buffers. Return NULL which will start
257 * dropping packets
258 */
259 TRACE0 ("freeStackPtr went negative\n");
260 stack = 0;
261 }
262 else
263 stack = freeStacks[freeStackPtr--];
264  
265 UNGUARD();
266 return (stack);
267 }
268  
269 CALLBACK (NdisSystemRequest (DWORD param1, DWORD param2, WORD param3,
270 WORD opcode, WORD targetDS))
271 {
272 static int bindEntry = 0;
273 struct _CommonChars *macCommon;
274 volatile WORD result;
275  
276 switch (opcode)
277 {
278 case REQ_INITIATE_BIND:
279 macCommon = (struct _CommonChars*) param2;
280 if (macCommon == NULL)
281 {
282 printf ("There is an NDIS misconfiguration.\n");
283 result = ERR_GENERAL_FAILURE;
284 break;
285 }
286 DEBUG2 ("module name %s\n"
287 "module type %s\n",
288 macCommon->moduleName,
289 ((MacChars*) macCommon->serviceChars)->macName);
290  
291 /* Binding to the MAC */
292 result = macCommon->systemRequest ((DWORD)&common, (DWORD)&macCommon,
293 0, REQ_BIND,
294 macCommon->moduleDS);
295  
296 if (!strcmp(bindings.moduleName[bindEntry], handle->moduleName))
297 handle->common = macCommon;
298 else PERROR ("unknown module");
299 ++bindEntry;
300 break;
301  
302 case REQ_INITIATE_UNBIND:
303 macCommon = (struct _CommonChars*) param2;
304 result = macCommon->systemRequest ((DWORD)&common, 0,
305 0, REQ_UNBIND,
306 macCommon->moduleDS);
307 break;
308  
309 default:
310 result = ERR_GENERAL_FAILURE;
311 break;
312 }
313 ARGSUSED (param1);
314 ARGSUSED (param3);
315 ARGSUSED (targetDS);
316 return (result);
317 }
318  
319 CALLBACK (NdisRequestConfirm (WORD protId, WORD macId, WORD reqHandle,
320 WORD status, WORD request, WORD protDS))
321 {
322 ARGSUSED (protId); ARGSUSED (macId);
323 ARGSUSED (reqHandle); ARGSUSED (status);
324 ARGSUSED (request); ARGSUSED (protDS);
325 return (ERR_SUCCESS);
326 }
327  
328 CALLBACK (NdisTransmitConfirm (WORD protId, WORD macId, WORD reqHandle,
329 WORD status, WORD protDS))
330 {
331 xmitPending--;
332 FreePktBuf (txBufPending); /* Add passed ECB back to the free list */
333  
334 ARGSUSED (reqHandle);
335 ARGSUSED (status);
336 ARGSUSED (protDS);
337 return (ERR_SUCCESS);
338 }
339  
340  
341 /*
342 * The primary function for receiving packets
343 */
344 CALLBACK (NdisReceiveLookahead (WORD macId, WORD frameSize,
345 WORD bytesAvail, BYTE *buffer,
346 BYTE *indicate, WORD protDS))
347 {
348 int result;
349 PktBuf *pktBuf;
350 WORD bytesCopied;
351 struct _TDBufDescr tDBufDescr;
352  
353 #if 0
354 TRACE1 ("lookahead length = %d, ", bytesAvail);
355 TRACE1 ("ecb = %08lX, ", *ecb);
356 TRACE1 ("count = %08lX\n", count);
357 TRACE1 ("offset = %08lX, ", offset);
358 TRACE1 ("timesAllowed = %d, ", timesAllowed);
359 TRACE1 ("packet size = %d\n", look->dataLookAheadLen);
360 #endif
361  
362 /* Allocate a buffer for the packet
363 */
364 if ((pktBuf = AllocPktBuf()) == NULL)
365 {
366 droppedPackets++;
367 return (ERR_FRAME_REJECTED);
368 }
369  
370 /*
371 * Now kludge things. Note we will have to undo this later. This will
372 * make the packet contiguous after the MLID has done the requested copy.
373 */
374  
375 tDBufDescr.tDDataCount = 1;
376 tDBufDescr.tDBufDescrRec[0].tDPtrType = NDIS_PTR_PHYSICAL;
377 tDBufDescr.tDBufDescrRec[0].tDDataPtr = pktBuf->buffer;
378 tDBufDescr.tDBufDescrRec[0].tDDataLen = pktBuf->length;
379 tDBufDescr.tDBufDescrRec[0].dummy = 0;
380  
381 result = MAC_DISPATCH(handle)->transferData (&bytesCopied, 0, &tDBufDescr,
382 handle->common->moduleDS);
383 pktBuf->packetLength = bytesCopied;
384  
385 if (result == ERR_SUCCESS)
386 EnquePktBuf(pktBuf);
387 else FreePktBuf (pktBuf);
388  
389 ARGSUSED (frameSize);
390 ARGSUSED (bytesAvail);
391 ARGSUSED (indicate);
392 ARGSUSED (protDS);
393  
394 return (ERR_SUCCESS);
395 }
396  
397 CALLBACK (NdisIndicationComplete (WORD macId, WORD protDS))
398 {
399 ARGSUSED (macId);
400 ARGSUSED (protDS);
401  
402 /* We don't give a hoot about these. Just return
403 */
404 return (ERR_SUCCESS);
405 }
406  
407 /*
408 * This is the OTHER way we may receive packets
409 */
410 CALLBACK (NdisReceiveChain (WORD macId, WORD frameSize, WORD reqHandle,
411 struct _RxBufDescr *rxBufDescr,
412 BYTE *indicate, WORD protDS))
413 {
414 struct _PktBuf *pktBuf;
415 int i;
416  
417 /*
418 * For now we copy the entire packet over to a PktBuf structure. This may be
419 * a performance hit but this routine probably isn't called very much, and
420 * it is a lot of work to do it otherwise. Also if it is a filter protocol
421 * packet we could end up sucking up MAC buffes.
422 */
423  
424 if ((pktBuf = AllocPktBuf()) == NULL)
425 {
426 droppedPackets++;
427 return (ERR_FRAME_REJECTED);
428 }
429 pktBuf->packetLength = 0;
430  
431 /* Copy the packet to the buffer
432 */
433 for (i = 0; i < rxBufDescr->rxDataCount; ++i)
434 {
435 struct _RxBufDescrRec *rxDescr = &rxBufDescr->rxBufDescrRec[i];
436  
437 memcpy (pktBuf->buffer + pktBuf->packetLength,
438 rxDescr->rxDataPtr, rxDescr->rxDataLen);
439 pktBuf->packetLength += rxDescr->rxDataLen;
440 }
441  
442 EnquePktBuf (pktBuf);
443  
444 ARGSUSED (frameSize);
445 ARGSUSED (reqHandle);
446 ARGSUSED (indicate);
447 ARGSUSED (protDS);
448  
449 /* This frees up the buffer for the MAC to use
450 */
451 return (ERR_SUCCESS);
452 }
453  
454 CALLBACK (NdisStatusProc (WORD macId, WORD param1, BYTE *indicate,
455 WORD opcode, WORD protDS))
456 {
457 switch (opcode)
458 {
459 case STATUS_RING_STATUS:
460 break;
461 case STATUS_ADAPTER_CHECK:
462 break;
463 case STATUS_START_RESET:
464 break;
465 case STATUS_INTERRUPT:
466 break;
467 case STATUS_END_RESET:
468 break;
469 default:
470 break;
471 }
472 ARGSUSED (macId);
473 ARGSUSED (param1);
474 ARGSUSED (indicate);
475 ARGSUSED (opcode);
476 ARGSUSED (protDS);
477  
478 /* We don't need to do anything about this stuff yet
479 */
480 return (ERR_SUCCESS);
481 }
482  
483 /*
484 * Tell the NDIS driver to start the delivery of the packet
485 */
486 int NdisSendPacket (struct _PktBuf *pktBuf, int macId)
487 {
488 struct _TxBufDescr txBufDescr;
489 int result;
490  
491 xmitPending++;
492 txBufPending = pktBuf; /* we only have 1 pending Tx at a time */
493  
494 txBufDescr.txImmedLen = 0;
495 txBufDescr.txImmedPtr = NULL;
496 txBufDescr.txDataCount = 1;
497 txBufDescr.txBufDescrRec[0].txPtrType = NDIS_PTR_PHYSICAL;
498 txBufDescr.txBufDescrRec[0].dummy = 0;
499 txBufDescr.txBufDescrRec[0].txDataLen = pktBuf->packetLength;
500 txBufDescr.txBufDescrRec[0].txDataPtr = pktBuf->buffer;
501  
502 result = MAC_DISPATCH(handle)->transmitChain (common.moduleId,
503 pktBuf->handle,
504 &txBufDescr,
505 handle->common->moduleDS);
506 switch (result)
507 {
508 case ERR_OUT_OF_RESOURCE:
509 /* Note that this should not happen but if it does there is not
510 * much we can do about it
511 */
512 printf ("ERROR: transmit queue overflowed\n");
513 return (0);
514  
515 case ERR_SUCCESS:
516 /* Everything was hunky dory and synchronous. Free up the
517 * packet buffer
518 */
519 xmitPending--;
520 FreePktBuf (pktBuf);
521 return (1);
522  
523 case ERR_REQUEST_QUEUED:
524 /* Everything was hunky dory and asynchronous. Do nothing
525 */
526 return (1);
527  
528 default:
529 printf ("Tx fail, code = %04X\n", result);
530 return (0);
531 }
532 }
533  
534  
535  
536 static int ndis_nerr = sizeof(ndis_errlist) / sizeof(ndis_errlist[0]);
537  
538 static char *Ndis_strerror (WORD errorCode)
539 {
540 static char buf[30];
541 int i;
542  
543 for (i = 0; i < ndis_nerr; i++)
544 if (errorCode == ndis_errlist[i].err_num)
545 return (ndis_errlist[i].err_text);
546  
547 sprintf (buf,"unknown error %d",errorCode);
548 return (buf);
549 }
550  
551  
552 char *NdisLastError (void)
553 {
554 char *errStr = lastErr;
555 lastErr = NULL;
556 return (errStr);
557 }
558  
559 int NdisOpen (void)
560 {
561 struct _ReqBlock reqBlock;
562 int result;
563 int ndisFd = open (NDIS_PATH, O_RDONLY);
564  
565 if (ndisFd < 0)
566 {
567 printf ("Could not open NDIS Protocol Manager device.\n");
568 return (0);
569 }
570  
571 memset (&reqBlock, 0, sizeof(ReqBlock));
572  
573 reqBlock.opcode = PM_GET_PROTOCOL_MANAGER_LINKAGE;
574  
575 result = NdisGetLinkage (ndisFd, (char*)&reqBlock, sizeof(ReqBlock));
576 if (result != 0)
577 {
578 printf ("Could not get Protocol Manager linkage.\n");
579 close (ndisFd);
580 return (0);
581 }
582  
583 close (ndisFd);
584 protManEntry = (ProtMan) reqBlock.pointer1;
585 protManDS = reqBlock.word1;
586  
587 DEBUG2 ("Entry Point = %04X:%04X\n", FP_SEG(protManEntry),FP_OFF(protManEntry));
588 DEBUG1 ("ProtMan DS = %04X\n", protManDS);
589 return (1);
590 }
591  
592  
593 int NdisRegisterAndBind (int promis)
594 {
595 struct _ReqBlock reqBlock;
596 WORD result;
597  
598 memset (&common,0,sizeof(common));
599  
600 common.tableSize = sizeof (common);
601  
602 common.majorNdisVersion = 2;
603 common.minorNdisVersion = 0;
604 common.majorModuleVersion = 2;
605 common.minorModuleVersion = 0;
606  
607 /* Indicates binding from below and dynamically loaded
608 */
609 common.moduleFlags = 0x00000006L;
610  
611 strcpy (common.moduleName, "PCAP");
612  
613 common.protocolLevelUpper = 0xFF;
614 common.protocolLevelLower = 1;
615 common.interfaceLower = 1;
616 #ifdef __DJGPP__
617 common.moduleDS = _dos_ds; /* the callback data segment */
618 #else
619 common.moduleDS = _DS;
620 #endif
621  
622 common.systemRequest = (SystemRequest) systemRequestGlue;
623 common.serviceChars = (BYTE*) &protChars;
624 common.serviceStatus = NULL;
625 common.upperDispatchTable = NULL;
626 common.lowerDispatchTable = (BYTE*) &lowerTable;
627  
628 protChars.length = sizeof (protChars);
629 protChars.name[0] = 0;
630 protChars.type = 0;
631  
632 lowerTable.backPointer = &common;
633 lowerTable.requestConfirm = requestConfirmGlue;
634 lowerTable.transmitConfirm = transmitConfirmGlue;
635 lowerTable.receiveLookahead = receiveLookaheadGlue;
636 lowerTable.indicationComplete = indicationCompleteGlue;
637 lowerTable.receiveChain = receiveChainGlue;
638 lowerTable.status = statusGlue;
639 lowerTable.flags = 3;
640 if (promis)
641 lowerTable.flags |= 4; /* promiscous mode (receive everything) */
642  
643 bindings.numBindings = 1;
644 strcpy (bindings.moduleName[0], handle->moduleName);
645  
646 /* Register ourselves with NDIS
647 */
648 reqBlock.opcode = PM_REGISTER_MODULE;
649 reqBlock.pointer1 = (BYTE FAR*) &common;
650 reqBlock.pointer2 = (BYTE FAR*) &bindings;
651  
652 result = (*protManEntry) (&reqBlock, protManDS);
653 if (result)
654 {
655 printf ("Protman registering failed: %s\n", Ndis_strerror(result));
656 return (0);
657 }
658  
659 /* Start the binding process
660 */
661 reqBlock.opcode = PM_BIND_AND_START;
662 reqBlock.pointer1 = (BYTE FAR*) &failingModules;
663  
664 result = (*protManEntry) (&reqBlock, protManDS);
665 if (result)
666 {
667 printf ("Start binding failed: %s\n", Ndis_strerror(result));
668 return (0);
669 }
670 return (1);
671 }
672  
673 static int CheckMacFeatures (CardHandle *card)
674 {
675 DWORD serviceFlags;
676 BYTE _far *mediaString;
677 BYTE _far *mac_addr;
678  
679 DEBUG2 ("checking card features\n"
680 "common table address = %08lX, macId = %d\n",
681 card->common, card->common->moduleId);
682  
683 serviceFlags = MAC_CHAR (handle)->serviceFlags;
684  
685 if ((serviceFlags & SF_PROMISCUOUS) == 0)
686 {
687 printf ("The MAC %s does not support promiscuous mode.\n",
688 card->moduleName);
689 return (0);
690 }
691  
692 mediaString = MAC_CHAR (handle)->macName;
693  
694 DEBUG1 ("media type = %s\n",mediaString);
695  
696 /* Get the media type. And set the header size
697 */
698 if (!strncmp(mediaString,"802.3",5) ||
699 !strncmp(mediaString,"DIX",3) ||
700 !strncmp(mediaString,"DIX+802.3",9))
701 headerSize = sizeof (EthernetIIHeader);
702  
703 else if (!strncmp(mediaString,"FDDI",4))
704 headerSize = sizeof (FddiHeader) +
705 sizeof (Ieee802Dot2SnapHeader);
706 else
707 {
708 printf ("Unsupported MAC type: `%s'\n", mediaString);
709 return (0);
710 }
711  
712 frameSize = MAC_CHAR (handle)->maxFrameSize;
713 mac_addr = MAC_CHAR (handle)->currentAddress;
714  
715 printf ("Hardware address: %02X:%02X:%02X:%02X:%02X:%02X\n",
716 mac_addr[0], mac_addr[1], mac_addr[2],
717 mac_addr[3], mac_addr[4], mac_addr[5]);
718 return (1);
719 }
720  
721 static int NdisStartMac (CardHandle *card)
722 {
723 WORD result;
724  
725 /* Set the lookahead length
726 */
727 result = MAC_DISPATCH(handle)->request (common.moduleId, 0,
728 headerSize, 0,
729 REQ_SET_LOOKAHEAD,
730 card->common->moduleDS);
731  
732 /* We assume that if we got INVALID PARAMETER then either this
733 * is not supported or will work anyway. NE2000 does this.
734 */
735 if (result != ERR_SUCCESS && result != ERR_INVALID_PARAMETER)
736 {
737 DEBUG1 ("Set lookahead failed: %s\n", Ndis_strerror(result));
738 return (0);
739 }
740  
741 /* Set the packet filter. Note that for some medias and drivers we
742 * must specify all three flags or the card(s) will not operate correctly.
743 */
744 result = MAC_DISPATCH(handle)->request (common.moduleId, 0,
745 /* all packets */ FILTER_PROMISCUOUS |
746 /* packets to us */ FILTER_DIRECTED |
747 /* broadcasts */ FILTER_BROADCAST,
748 0, REQ_SET_PACKET_FILTER,
749 card->common->moduleDS);
750 if (result != ERR_SUCCESS)
751 {
752 DEBUG1 ("Set packet filter failed: %s\n", Ndis_strerror(result));
753 return (0);
754 }
755  
756 /* If OPEN/CLOSE supported then open the adapter
757 */
758 if (MAC_CHAR(handle)->serviceFlags & SF_OPEN_CLOSE)
759 {
760 result = MAC_DISPATCH(handle)->request (common.moduleId, 0, 0, NULL,
761 REQ_OPEN_ADAPTER,
762 card->common->moduleDS);
763 if (result != ERR_SUCCESS)
764 {
765 DEBUG1 ("Opening the MAC failed: %s\n", Ndis_strerror(result));
766 return (0);
767 }
768 }
769 return (1);
770 }
771  
772 void NdisShutdown (void)
773 {
774 struct _ReqBlock reqBlock;
775 int result, i;
776  
777 if (!handle)
778 return;
779  
780 /* If the adapters support open and are open then close them
781 */
782 if ((MAC_CHAR(handle)->serviceFlags & SF_OPEN_CLOSE) &&
783 (MAC_STATUS(handle)->macStatus & MAC_OPEN))
784 {
785 result = MAC_DISPATCH(handle)->request (common.moduleId, 0, 0, 0,
786 REQ_CLOSE_ADAPTER,
787 handle->common->moduleDS);
788 if (result != ERR_SUCCESS)
789 {
790 printf ("Closing the MAC failed: %s\n", Ndis_strerror(result));
791 return;
792 }
793 }
794  
795 /* Tell the Protocol Manager to unbind and stop
796 */
797 reqBlock.opcode = PM_UNBIND_AND_STOP;
798 reqBlock.pointer1 = (BYTE FAR*) &failingModules;
799 reqBlock.pointer2 = NULL;
800  
801 result = (*protManEntry) (&reqBlock, protManDS);
802 if (result)
803 printf ("Unbind failed: %s\n", Ndis_strerror(result));
804  
805 for (i = 0; i < STACK_POOL_SIZE; ++i)
806 free (freeStacks[i] - STACK_SIZE);
807  
808 handle = NULL;
809 }
810  
811 int NdisInit (int promis)
812 {
813 int i, result;
814  
815 /* Allocate the real mode stacks used for NDIS callbacks
816 */
817 for (i = 0; i < STACK_POOL_SIZE; ++i)
818 {
819 freeStacks[i] = malloc (STACK_SIZE);
820 if (!freeStacks[i])
821 return (0);
822 freeStacks[i] += STACK_SIZE;
823 }
824  
825 if (!NdisOpen())
826 return (0);
827  
828 if (!NdisRegisterAndBind(promis))
829 return (0);
830  
831 DEBUG1 ("My module id: %d\n", common.moduleId);
832 DEBUG1 ("Handle id; %d\n", handle->common->moduleId);
833 DEBUG1 ("MAC card: %-16s - ", handle->moduleName);
834  
835 atexit (NdisShutdown);
836  
837 if (!CheckMacFeatures(&handle))
838 return (0);
839  
840 switch (mediaType)
841 {
842 case MEDIA_FDDI:
843 DEBUG0 ("Media type: FDDI");
844 break;
845 case MEDIA_ETHERNET:
846 DEBUG0 ("Media type: ETHERNET");
847 break;
848 default:
849 DEBUG0 ("Unsupported media.\n");
850 return (0);
851 }
852  
853 DEBUG1 (" - Frame size: %d\n", frameSize);
854  
855 if (!NdisStartMac(&handle))
856 return (0);
857 return (1);
858 }
859 #endif /* USE_NDIS2 */
860