![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uframes.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / tdi|
Return to uframes.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / tdi |
1.1 root 1: /*++
2:
3: Copyright (c) 1989-1993 Microsoft Corporation
4:
5: Module Name:
6:
7: uframes.c
8:
9: Abstract:
10:
11: This module contains a routine called StProcessConnectionless,
12: that gets control from routines in IND.C when a connectionless
13: frame is received.
14:
15: Environment:
16:
17: Kernel mode, DISPATCH_LEVEL.
18:
19: Revision History:
20:
21: --*/
22:
23: #include "st.h"
24:
25:
26:
27: NTSTATUS
28: StIndicateDatagram(
29: IN PDEVICE_CONTEXT DeviceContext,
30: IN PTP_ADDRESS Address,
31: IN PUCHAR Header,
32: IN ULONG Length
33: )
34:
35: /*++
36:
37: Routine Description:
38:
39: This routine processes an incoming DATAGRAM or DATAGRAM_BROADCAST frame.
40: BROADCAST and normal datagrams have the same receive logic, except
41: for broadcast datagrams Address will be the broadcast address.
42:
43: When we return STATUS_MORE_PROCESSING_REQUIRED, the caller of
44: this routine will continue to call us for each address for the device
45: context. When we return STATUS_SUCCESS, the caller will switch to the
46: next address. When we return any other status code, including
47: STATUS_ABANDONED, the caller will stop distributing the frame.
48:
49: Arguments:
50:
51: DeviceContext - Pointer to our device context.
52:
53: Address - Pointer to the transport address object.
54:
55: StHeader - Pointer to a buffer that contains the receive datagram.
56: The first byte of information is the ST header.
57:
58: Length - The length of the MDL pointed to by StHeader.
59:
60: Return Value:
61:
62: NTSTATUS - status of operation.
63:
64: --*/
65:
66: {
67: NTSTATUS status;
68: PLIST_ENTRY p, q;
69: PIRP irp;
70: PIO_STACK_LOCATION irpSp;
71: PTP_REQUEST Request;
72: ULONG IndicateBytesCopied, MdlBytesCopied;
73: KIRQL oldirql;
74: TA_NETBIOS_ADDRESS SourceName;
75: TA_NETBIOS_ADDRESS DestinationName;
76: PTDI_CONNECTION_INFORMATION remoteInformation;
77: ULONG returnLength;
78: PTP_ADDRESS_FILE addressFile, prevaddressFile;
79: PST_HEADER StHeader;
80:
81: //
82: // If this datagram wasn't big enough for a transport header, then don't
83: // let the caller look at any data.
84: //
85:
86: if (Length < sizeof(ST_HEADER)) {
87: return STATUS_ABANDONED;
88: }
89:
90: //
91: // Update our statistics.
92: //
93:
94: ++DeviceContext->DatagramsReceived;
95: ADD_TO_LARGE_INTEGER(
96: &DeviceContext->DatagramBytesReceived,
97: Length - sizeof(ST_HEADER),
98: &DeviceContext->StatisticsSpinLock);
99:
100:
101: //
102: // Call the client's ReceiveDatagram indication handler. He may
103: // want to accept the datagram that way.
104: //
105:
106: StHeader = (PST_HEADER)Header;
107:
108: TdiBuildNetbiosAddress (StHeader->Source, FALSE, &SourceName);
109: TdiBuildNetbiosAddress (StHeader->Destination, FALSE, &DestinationName);
110:
111:
112: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
113:
114: //
115: // Find the first open address file in the list.
116: //
117:
118: p = Address->AddressFileDatabase.Flink;
119: while (p != &Address->AddressFileDatabase) {
120: addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
121: if (addressFile->State != ADDRESSFILE_STATE_OPEN) {
122: p = p->Flink;
123: continue;
124: }
125: StReferenceAddressFile(addressFile);
126: break;
127: }
128:
129: while (p != &Address->AddressFileDatabase) {
130:
131: //
132: // do we have a datagram receive request outstanding? If so, we will
133: // satisfy it first.
134: //
135: // NOTE: We should check if this receive dataframs is for
136: // a specific address.
137: //
138:
139: q = RemoveHeadList (&addressFile->ReceiveDatagramQueue);
140: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
141:
142: if (q != &addressFile->ReceiveDatagramQueue) {
143:
144: Request = CONTAINING_RECORD (q, TP_REQUEST, Linkage);
145:
146: //
147: // Copy the actual user data.
148: //
149:
150: MdlBytesCopied = 0;
151:
152: status = TdiCopyBufferToMdl (
153: StHeader,
154: sizeof(ST_HEADER), // offset
155: Length - sizeof(ST_HEADER), // length
156: Request->IoRequestPacket->MdlAddress,
157: 0,
158: &MdlBytesCopied);
159:
160: irpSp = IoGetCurrentIrpStackLocation (Request->IoRequestPacket);
161: remoteInformation =
162: ((PTDI_REQUEST_KERNEL_RECEIVEDG)(&irpSp->Parameters))->
163: ReturnDatagramInformation;
164: if (remoteInformation != NULL) {
165: try {
166: if (remoteInformation->RemoteAddressLength != 0) {
167: if (remoteInformation->RemoteAddressLength >=
168: sizeof (TA_NETBIOS_ADDRESS)) {
169:
170: RtlCopyMemory (
171: (PTA_NETBIOS_ADDRESS)remoteInformation->RemoteAddress,
172: &SourceName,
173: sizeof (TA_NETBIOS_ADDRESS));
174:
175: returnLength = sizeof(TA_NETBIOS_ADDRESS);
176: remoteInformation->RemoteAddressLength = returnLength;
177:
178: } else {
179:
180: RtlCopyMemory (
181: (PTA_NETBIOS_ADDRESS)remoteInformation->RemoteAddress,
182: &SourceName,
183: remoteInformation->RemoteAddressLength);
184:
185: returnLength = remoteInformation->RemoteAddressLength;
186: remoteInformation->RemoteAddressLength = returnLength;
187:
188: }
189:
190: } else {
191:
192: returnLength = 0;
193: }
194:
195: status = STATUS_SUCCESS;
196:
197: } except (EXCEPTION_EXECUTE_HANDLER) {
198:
199: returnLength = 0;
200: status = GetExceptionCode ();
201:
202: }
203:
204: }
205:
206: StCompleteRequest (Request, STATUS_SUCCESS, MdlBytesCopied);
207:
208: } else {
209:
210: //
211: // no receive datagram requests; is there a kernel client?
212: //
213:
214: if (addressFile->RegisteredReceiveDatagramHandler) {
215:
216: IndicateBytesCopied = 0;
217:
218: //
219: // Note that we can always set the COPY_LOOKAHEAD
220: // flag because we are indicating from our own
221: // buffer, not directly from a lookahead indication.
222: //
223:
224: status = (*addressFile->ReceiveDatagramHandler)(
225: addressFile->ReceiveDatagramHandlerContext,
226: sizeof (TA_NETBIOS_ADDRESS),
227: &SourceName,
228: 0,
229: NULL,
230: TDI_RECEIVE_COPY_LOOKAHEAD,
231: Length - sizeof(ST_HEADER), // indicated
232: Length - sizeof(ST_HEADER), // available
233: &IndicateBytesCopied,
234: Header + sizeof(ST_HEADER),
235: &irp);
236:
237: if (status == STATUS_SUCCESS) {
238:
239: //
240: // The client accepted the datagram and so we're done.
241: //
242:
243: } else if (status == STATUS_DATA_NOT_ACCEPTED) {
244:
245: //
246: // The client did not accept the datagram and we need to satisfy
247: // a TdiReceiveDatagram, if possible.
248: //
249:
250: status = STATUS_MORE_PROCESSING_REQUIRED;
251:
252: } else if (status == STATUS_MORE_PROCESSING_REQUIRED) {
253:
254: //
255: // The client returned an IRP that we should queue up to the
256: // address to satisfy the request.
257: //
258:
259: irp->IoStatus.Status = STATUS_PENDING; // init status information.
260: irp->IoStatus.Information = 0;
261: irpSp = IoGetCurrentIrpStackLocation (irp); // get current stack loctn.
262: if ((irpSp->MajorFunction != IRP_MJ_INTERNAL_DEVICE_CONTROL) ||
263: (irpSp->MinorFunction != TDI_RECEIVE_DATAGRAM)) {
264: irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
265: return status;
266: }
267:
268: //
269: // Now copy the actual user data.
270: //
271:
272: MdlBytesCopied = 0;
273:
274: status = TdiCopyBufferToMdl (
275: StHeader,
276: sizeof(ST_HEADER) + IndicateBytesCopied,
277: Length - sizeof(ST_HEADER) - IndicateBytesCopied,
278: irp->MdlAddress,
279: 0,
280: &MdlBytesCopied);
281:
282: irp->IoStatus.Information = MdlBytesCopied;
283: irp->IoStatus.Status = status;
284: IoCompleteRequest (irp, IO_NETWORK_INCREMENT);
285: }
286: }
287: }
288:
289: //
290: // Save this to dereference it later.
291: //
292:
293: prevaddressFile = addressFile;
294:
295: //
296: // Reference the next address file on the list, so it
297: // stays around.
298: //
299:
300: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
301:
302: p = p->Flink;
303: while (p != &Address->AddressFileDatabase) {
304: addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
305: if (addressFile->State != ADDRESSFILE_STATE_OPEN) {
306: p = p->Flink;
307: continue;
308: }
309: StReferenceAddressFile(addressFile);
310: break;
311: }
312:
313: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
314:
315: //
316: // Now dereference the previous address file with
317: // the lock released.
318: //
319:
320: StDereferenceAddressFile (prevaddressFile);
321:
322: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
323:
324: } // end of while loop
325:
326: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
327:
328: return status; // to dispatcher.
329: } /* StIndicateDatagram */
330:
331:
332: NTSTATUS
333: StProcessConnect(
334: IN PDEVICE_CONTEXT DeviceContext,
335: IN PTP_ADDRESS Address,
336: IN PST_HEADER Header,
337: IN PHARDWARE_ADDRESS SourceAddress,
338: IN PUCHAR SourceRouting,
339: IN UINT SourceRoutingLength
340: )
341:
342: /*++
343:
344: Routine Description:
345:
346: This routine processes an incoming connect frame. It scans for
347: posted listens, otherwise it indicates to connect handlers
348: on this address if they are registered.
349:
350: Arguments:
351:
352: DeviceContext - Pointer to our device context.
353:
354: Address - Pointer to the transport address object.
355:
356: Header - Pointer to the ST header of the frame.
357:
358: SourceAddress - Pointer to the source hardware address in the received
359: frame.
360:
361: SourceRouting - Pointer to the source routing information in
362: the frame.
363:
364: SourceRoutingLength - Length of the source routing information.
365:
366: Return Value:
367:
368: NTSTATUS - status of operation.
369:
370: --*/
371:
372: {
373: KIRQL oldirql, oldirql1, cancelirql;
374: NTSTATUS status;
375: PTP_CONNECTION Connection;
376: BOOLEAN ConnectIndicationBlocked = FALSE;
377: PLIST_ENTRY p;
378: BOOLEAN UsedListeningConnection = FALSE;
379: PTP_ADDRESS_FILE addressFile, prevaddressFile;
380:
381: PTP_REQUEST request;
382: PIO_STACK_LOCATION irpSp;
383: ULONG returnLength;
384: PTDI_CONNECTION_INFORMATION remoteInformation;
385: TA_NETBIOS_ADDRESS TempAddress;
386: PIRP acceptIrp;
387:
388: CONNECTION_CONTEXT connectionContext;
389:
390: //
391: // If we are just registering or deregistering this address, then don't
392: // allow state changes. Just throw the packet away, and let the frame
393: // distributor try the next address.
394: //
395:
396: if (Address->Flags & (ADDRESS_FLAGS_REGISTERING | ADDRESS_FLAGS_DEREGISTERING)) {
397: return STATUS_SUCCESS;
398: }
399:
400: //
401: // This is an incoming connection request. If we have a listening
402: // connection on this address, then continue with the connection setup.
403: // If there is no outstanding listen, then indicate any kernel mode
404: // clients that want to know about this frame. If a listen was posted,
405: // then a connection has already been set up for it.
406: //
407:
408: //
409: // First, check if we already have an active connection with
410: // this remote on this address. If so, we ignore this
411: // (NOTE: This is not the correct behaviour for a real
412: // transport).
413: //
414:
415: //
416: // If successful this adds a reference.
417: //
418:
419: if (Connection = StLookupRemoteName(Address, Header->Source)) {
420:
421: StDereferenceConnection ("Lookup done", Connection);
422: return STATUS_ABANDONED;
423:
424: }
425:
426: // If successful, this adds a reference which is removed before
427: // this function returns.
428:
429: Connection = StLookupListeningConnection (Address);
430: if (Connection == NULL) {
431:
432: //
433: // not having a listening connection is not reason to bail out here.
434: // we need to indicate to the user that a connect attempt occurred,
435: // and see if there is a desire to use this connection. We
436: // indicate in order to all address files that are
437: // using this address.
438: //
439: // If we already have an indication pending on this address,
440: // we ignore this frame (the NAME_QUERY may have come from
441: // a different address, but we can't know that). Also, if
442: // there is already an active connection on this remote
443: // name, then we ignore the frame.
444: //
445:
446:
447: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
448:
449: p = Address->AddressFileDatabase.Flink;
450: while (p != &Address->AddressFileDatabase) {
451: addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
452: if (addressFile->State != ADDRESSFILE_STATE_OPEN) {
453: p = p->Flink;
454: continue;
455: }
456: StReferenceAddressFile(addressFile);
457: break;
458: }
459:
460: while (p != &Address->AddressFileDatabase) {
461:
462: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
463:
464: if ((addressFile->RegisteredConnectionHandler == TRUE) &&
465: (!addressFile->ConnectIndicationInProgress)) {
466:
467:
468: TdiBuildNetbiosAddress (
469: Header->Source,
470: FALSE,
471: &TempAddress);
472:
473: addressFile->ConnectIndicationInProgress = TRUE;
474:
475: //
476: // we have a connection handler, now indicate that a connection
477: // attempt occurred.
478: //
479:
480: status = (addressFile->ConnectionHandler)(
481: addressFile->ConnectionHandlerContext,
482: sizeof (TDI_ADDRESS_NETBIOS),
483: &TempAddress,
484: 0,
485: NULL,
486: 0,
487: NULL,
488: &connectionContext,
489: &acceptIrp);
490:
491: if (status == STATUS_MORE_PROCESSING_REQUIRED) {
492:
493: // the user has connected a currently open connection, but
494: // we have to figure out which one it is.
495: //
496:
497: //
498: // If successful this adds a reference of type LISTENING
499: // (the same what StLookupListeningConnection adds).
500: //
501:
502: Connection = StLookupConnectionByContext (
503: Address,
504: connectionContext);
505:
506: if (Connection == NULL) {
507:
508: //
509: // BUGBUG: We have to tell the client that
510: // his connection is bogus (or has this
511: // already happened??).
512: //
513:
514: StPrint0("MORE_PROCESSING_REQUIRED, connection not found\n");
515: addressFile->ConnectIndicationInProgress = FALSE;
516: acceptIrp->IoStatus.Status = STATUS_INVALID_CONNECTION;
517: IoCompleteRequest (acceptIrp, IO_NETWORK_INCREMENT);
518:
519: goto whileend; // try next address file
520:
521: } else {
522:
523: if (Connection->AddressFile->Address != Address) {
524: addressFile->ConnectIndicationInProgress = FALSE;
525:
526: StPrint0("MORE_PROCESSING_REQUIRED, address wrong\n");
527: StStopConnection (Connection, STATUS_INVALID_ADDRESS);
528: StDereferenceConnection("Bad Address", Connection);
529: Connection = NULL;
530: acceptIrp->IoStatus.Status = STATUS_INVALID_CONNECTION;
531: IoCompleteRequest (acceptIrp, IO_NETWORK_INCREMENT);
532:
533: goto whileend; // try next address file
534: }
535:
536: //
537: // OK, we have a valid connection. If the response to
538: // this connection was disconnect, we need to reject
539: // the connection request and return. If it was accept
540: // or not specified (to be done later), we simply
541: // fall through and continue processing on the U Frame.
542: //
543:
544: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql1);
545: if ((Connection->Flags2 & CONNECTION_FLAGS2_DISCONNECT) != 0) {
546:
547: Connection->Flags2 &= ~CONNECTION_FLAGS2_DISCONNECT;
548: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql1);
549: StPrint0("MORE_PROCESSING_REQUIRED, disconnect\n");
550: addressFile->ConnectIndicationInProgress = FALSE;
551: StDereferenceConnection("Disconnecting", Connection);
552: Connection = NULL;
553: acceptIrp->IoStatus.Status = STATUS_INVALID_CONNECTION;
554: IoCompleteRequest (acceptIrp, IO_NETWORK_INCREMENT);
555:
556: goto whileend; // try next address file
557: }
558:
559: }
560:
561: //
562: // This connection is ready.
563: //
564:
565: Connection->Flags &= ~CONNECTION_FLAGS_STOPPING;
566: Connection->Status = STATUS_PENDING;
567: Connection->Flags2 |= CONNECTION_FLAGS2_ACCEPTED;
568:
569: Connection->Flags |= CONNECTION_FLAGS_READY;
570: INCREMENT_COUNTER (Connection->Provider, OpenConnections);
571:
572: Connection->Flags2 |= CONNECTION_FLAGS2_REQ_COMPLETED;
573:
574: StReferenceConnection("Indication completed", Connection);
575:
576: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql1);
577:
578: //
579: // Make a note that we have to set
580: // addressFile->ConnectIndicationInProgress to
581: // FALSE once the address is safely stored
582: // in the connection.
583: //
584:
585: ConnectIndicationBlocked = TRUE;
586: StDereferenceAddressFile (addressFile);
587: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
588: break; // exit the while
589:
590: } else if (status == STATUS_INSUFFICIENT_RESOURCES) {
591:
592: //
593: // we know the address, but can't create a connection to
594: // use on it. This gets passed to the network as a response
595: // saying I'm here, but can't help.
596: //
597:
598: addressFile->ConnectIndicationInProgress = FALSE;
599:
600: StDereferenceAddressFile (addressFile);
601: return STATUS_ABANDONED;
602:
603: } else {
604:
605: addressFile->ConnectIndicationInProgress = FALSE;
606: goto whileend; // try next address file
607:
608: } // end status ifs
609:
610: } else {
611:
612: goto whileend; // try next address file
613:
614: } // end no indication handler
615:
616: whileend:
617: //
618: // Jumping here is like a continue, except that the
619: // addressFile pointer is advanced correctly.
620: //
621:
622: //
623: // Save this to dereference it later.
624: //
625:
626: prevaddressFile = addressFile;
627:
628: //
629: // Reference the next address file on the list, so it
630: // stays around.
631: //
632:
633: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
634:
635: p = p->Flink;
636: while (p != &Address->AddressFileDatabase) {
637: addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
638: if (addressFile->State != ADDRESSFILE_STATE_OPEN) {
639: p = p->Flink;
640: continue;
641: }
642: StReferenceAddressFile(addressFile);
643: break;
644: }
645:
646: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
647:
648: //
649: // Now dereference the previous address file with
650: // the lock released.
651: //
652:
653: StDereferenceAddressFile (prevaddressFile);
654:
655: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
656:
657: } // end of loop through the address files.
658:
659: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
660:
661: if (Connection == NULL) {
662:
663: //
664: // We used to return MORE_PROCESSING_REQUIRED, but
665: // since we matched with this address, no other
666: // address is going to match, so abandon it.
667: //
668:
669: return STATUS_ABANDONED;
670:
671: }
672:
673: } else { // end connection == null
674:
675: UsedListeningConnection = TRUE;
676:
677: IoAcquireCancelSpinLock (&cancelirql);
678: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql);
679:
680: p = RemoveHeadList (&Connection->InProgressRequest);
681: if (p == &Connection->InProgressRequest) {
682:
683: Connection->IndicationInProgress = FALSE;
684: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
685: IoReleaseCancelSpinLock (cancelirql);
686: return STATUS_SUCCESS;
687:
688: }
689:
690: //
691: // If this listen indicated that we should wait for a
692: // TdiAccept, then do that, otherwise the connection is
693: // ready.
694: //
695:
696: if ((Connection->Flags2 & CONNECTION_FLAGS2_PRE_ACCEPT) == 0) {
697:
698: Connection->Flags2 |= CONNECTION_FLAGS2_WAIT_ACCEPT;
699:
700: } else {
701:
702: Connection->Flags |= CONNECTION_FLAGS_READY;
703: INCREMENT_COUNTER (Connection->Provider, OpenConnections);
704:
705: Connection->Flags2 |= CONNECTION_FLAGS2_REQ_COMPLETED;
706:
707: StReferenceConnection("Listen completed", Connection);
708:
709: }
710:
711: //
712: // We have a completed connection with a queued listen. Complete
713: // the listen and let the user do an accept at some time down the
714: // road.
715: //
716:
717: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
718:
719: request = CONTAINING_RECORD (p, TP_REQUEST, Linkage);
720: request->IoRequestPacket->CancelRoutine = (PDRIVER_CANCEL)NULL;
721: IoReleaseCancelSpinLock (cancelirql);
722:
723: irpSp = IoGetCurrentIrpStackLocation (request->IoRequestPacket);
724: remoteInformation =
725: ((PTDI_REQUEST_KERNEL)(&irpSp->Parameters))->ReturnConnectionInformation;
726: if (remoteInformation != NULL) {
727: try {
728: if (remoteInformation->RemoteAddressLength != 0) {
729:
730: //
731: // Build a temporary TA_NETBIOS_ADDRESS, then
732: // copy over as many bytes as fit.
733: //
734:
735: TdiBuildNetbiosAddress(
736: Connection->CalledAddress.NetbiosName,
737: (BOOLEAN)(Connection->CalledAddress.NetbiosNameType ==
738: TDI_ADDRESS_NETBIOS_TYPE_GROUP),
739: &TempAddress);
740:
741: if (remoteInformation->RemoteAddressLength >=
742: sizeof (TA_NETBIOS_ADDRESS)) {
743:
744: returnLength = sizeof(TA_NETBIOS_ADDRESS);
745: remoteInformation->RemoteAddressLength = returnLength;
746:
747: } else {
748:
749: returnLength = remoteInformation->RemoteAddressLength;
750:
751: }
752:
753: RtlCopyMemory(
754: (PTA_NETBIOS_ADDRESS)remoteInformation->RemoteAddress,
755: &TempAddress,
756: returnLength);
757:
758: } else {
759:
760: returnLength = 0;
761: }
762:
763: status = STATUS_SUCCESS;
764:
765: } except (EXCEPTION_EXECUTE_HANDLER) {
766:
767: returnLength = 0;
768: status = GetExceptionCode ();
769:
770: }
771:
772: } else {
773:
774: status = STATUS_SUCCESS;
775: returnLength = 0;
776:
777: }
778:
779: //
780: // Don't clear this until now, so that the connection is all
781: // set up before we allow more indications.
782: //
783:
784: Connection->IndicationInProgress = FALSE;
785:
786: StCompleteRequest (request, status, 0);
787:
788: }
789:
790:
791: //
792: // Before we continue, store the remote guy's transport address
793: // into the TdiListen's TRANSPORT_CONNECTION buffer. This allows
794: // the client to determine who called him.
795: //
796:
797: Connection->CalledAddress.NetbiosNameType = TDI_ADDRESS_NETBIOS_TYPE_UNIQUE;
798: NdisMoveFromMappedMemory(
799: Connection->CalledAddress.NetbiosName,
800: Header->Source,
801: 16);
802:
803: NdisMoveFromMappedMemory(
804: Connection->RemoteName,
805: Header->Source,
806: 16);
807:
808: Connection->Flags2 |= CONNECTION_FLAGS2_REMOTE_VALID;
809:
810: if (ConnectIndicationBlocked) {
811: addressFile->ConnectIndicationInProgress = FALSE;
812: }
813:
814: StDereferenceConnection("ProcessNameQuery done", Connection);
815:
816: return STATUS_ABANDONED;
817:
818: } /* StProcessConnect */
819:
820:
821: NTSTATUS
822: StProcessConnectionless(
823: IN PDEVICE_CONTEXT DeviceContext,
824: IN PHARDWARE_ADDRESS SourceAddress,
825: IN PST_HEADER StHeader,
826: IN ULONG StLength,
827: IN PUCHAR SourceRouting,
828: IN UINT SourceRoutingLength,
829: OUT PTP_ADDRESS * DatagramAddress
830: )
831:
832: /*++
833:
834: Routine Description:
835:
836: This routine receives control from the data link provider as an
837: indication that a connectionless frame has been received on the data link.
838: Here we dispatch to the correct handler.
839:
840: Arguments:
841:
842: DeviceContext - Pointer to our device context.
843:
844: SourceAddress - Pointer to the source hardware address in the received
845: frame.
846:
847: StHeader - Points to the ST header of the incoming packet.
848:
849: StLength - Actual length in bytes of the packet, starting at the
850: StHeader.
851:
852: SourceRouting - Source routing information in the MAC header.
853:
854: SourceRoutingLength - The length of SourceRouting.
855:
856: DatagramAddress - If this function returns STATUS_MORE_PROCESSING_
857: REQUIRED, this will be the address the datagram should be
858: indicated to.
859:
860: Return Value:
861:
862: NTSTATUS - status of operation.
863:
864: --*/
865:
866: {
867: PTP_ADDRESS Address;
868: KIRQL oldirql;
869: NTSTATUS status;
870: PLIST_ENTRY Flink;
871: BOOLEAN MatchedAddress;
872: PUCHAR MatchName;
873:
874: //
875: // Verify that this frame is long enough to examine.
876: //
877:
878: if (StLength < sizeof(ST_HEADER)) {
879: return STATUS_ABANDONED; // frame too small.
880: }
881:
882: //
883: // We have a valid connectionless protocol frame that's not a
884: // datagram, so deliver it to every address which matches the
885: // destination name in the frame.
886: //
887:
888: MatchedAddress = FALSE;
889:
890: //
891: // Search for the address; for broadcast datagrams we
892: // search for the special "broadcast" address.
893: //
894:
895: if ((StHeader->Command == ST_CMD_DATAGRAM) &&
896: (StHeader->Flags & ST_FLAGS_BROADCAST)) {
897:
898: MatchName = NULL;
899:
900: } else {
901:
902: MatchName = StHeader->Destination;
903:
904: }
905:
906: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql);
907:
908: for (Flink = DeviceContext->AddressDatabase.Flink;
909: Flink != &DeviceContext->AddressDatabase;
910: Flink = Flink->Flink) {
911:
912: Address = CONTAINING_RECORD (
913: Flink,
914: TP_ADDRESS,
915: Linkage);
916:
917: if ((Address->Flags & ADDRESS_FLAGS_STOPPING) != 0) {
918: continue;
919: }
920:
921: if (StMatchNetbiosAddress (Address, MatchName)) {
922:
923: StReferenceAddress ("UI Frame", Address); // prevent address from being destroyed.
924: MatchedAddress = TRUE;
925: break;
926:
927: }
928: }
929:
930: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
931:
932: if (MatchedAddress) {
933:
934: //
935: // Deliver the frame to the current address.
936: //
937:
938: switch (StHeader->Command) {
939:
940: case ST_CMD_CONNECT:
941:
942: status = StProcessConnect (
943: DeviceContext,
944: Address,
945: StHeader,
946: SourceAddress,
947: SourceRouting,
948: SourceRoutingLength);
949:
950: break;
951:
952: case ST_CMD_DATAGRAM:
953:
954: //
955: // Reference the datagram so it sticks around until the
956: // ReceiveComplete, when it is processed.
957: //
958:
959: StReferenceAddress ("Datagram indicated", Address);
960: *DatagramAddress = Address;
961: status = STATUS_MORE_PROCESSING_REQUIRED;
962: break;
963:
964: default:
965:
966: ASSERT(FALSE);
967:
968: } /* switch on frame command code */
969:
970: StDereferenceAddress ("Done", Address); // done with previous address.
971:
972: } else {
973:
974: status = STATUS_ABANDONED;
975:
976: }
977:
978: return status;
979:
980: } /* StProcessConnectionless */
981:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.