![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to address.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 address.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: address.c
8:
9: Abstract:
10:
11: This module contains code which implements the TP_ADDRESS object.
12: Routines are provided to create, destroy, reference, and dereference,
13: transport address objects.
14:
15: Environment:
16:
17: Kernel mode
18:
19: Revision History:
20:
21: --*/
22:
23: #include "st.h"
24:
25:
26: //
27: // Map all generic accesses to the same one.
28: //
29:
30: STATIC GENERIC_MAPPING AddressGenericMapping =
31: { READ_CONTROL, READ_CONTROL, READ_CONTROL, READ_CONTROL };
32:
33:
34: NTSTATUS
35: StOpenAddress(
36: IN PDEVICE_OBJECT DeviceObject,
37: IN PIRP Irp,
38: IN PIO_STACK_LOCATION IrpSp
39: )
40:
41: /*++
42:
43: Routine Description:
44:
45: This routine opens a file that points to an existing address object, or, if
46: the object doesn't exist, creates it (note that creation of the address
47: object includes registering the address, and may take many seconds to
48: complete, depending upon system configuration).
49:
50: If the address already exists, and it has an ACL associated with it, the
51: ACL is checked for access rights before allowing creation of the address.
52:
53: Arguments:
54:
55: DeviceObject - pointer to the device object describing the ST transport.
56:
57: Irp - a pointer to the Irp used for the creation of the address.
58:
59: IrpSp - a pointer to the Irp stack location.
60:
61: Return Value:
62:
63: NTSTATUS - status of operation.
64:
65: --*/
66:
67: {
68: PDEVICE_CONTEXT DeviceContext;
69: NTSTATUS status;
70: PTP_ADDRESS address;
71: PTP_ADDRESS_FILE addressFile;
72: PST_NETBIOS_ADDRESS networkName; // Network name string.
73: PFILE_FULL_EA_INFORMATION ea;
74: TRANSPORT_ADDRESS UNALIGNED *name;
75: TA_ADDRESS UNALIGNED *addressName;
76: TDI_ADDRESS_NETBIOS UNALIGNED *netbiosName;
77: ULONG DesiredShareAccess;
78: KIRQL oldirql;
79: PACCESS_STATE AccessState;
80: ACCESS_MASK GrantedAccess;
81: BOOLEAN AccessAllowed;
82: int i;
83: BOOLEAN found = FALSE;
84:
85: DeviceContext = (PDEVICE_CONTEXT)DeviceObject;
86:
87: //
88: // The network name is in the EA, passed in AssociatedIrp.SystemBuffer
89: //
90:
91: ea = (PFILE_FULL_EA_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
92: if (ea == NULL) {
93: StPrint1("OpenAddress: IRP %lx has no EA\n", Irp);
94: return STATUS_NONEXISTENT_EA_ENTRY;
95: }
96:
97: //
98: // this may be a valid name; parse the name from the EA and use it if OK.
99: //
100:
101: name = (PTRANSPORT_ADDRESS)&ea->EaName[ea->EaNameLength+1];
102: addressName = (PTA_ADDRESS)&name->Address[0];
103:
104: //
105: // The name can be passed with multiple entries; we'll take and use only
106: // the first one.
107: //
108:
109: for (i=0;i<name->TAAddressCount;i++) {
110: if (addressName->AddressType == TDI_ADDRESS_TYPE_NETBIOS) {
111: if (addressName->AddressLength != 0) {
112: netbiosName = (PTDI_ADDRESS_NETBIOS)&addressName->Address[0];
113: networkName = (PST_NETBIOS_ADDRESS)ExAllocatePool (
114: NonPagedPool,
115: sizeof (ST_NETBIOS_ADDRESS));
116: if (networkName == NULL) {
117: PANIC ("StOpenAddress: PANIC! could not allocate networkName!\n");
118: StWriteResourceErrorLog (DeviceContext, sizeof(TA_NETBIOS_ADDRESS), 1);
119: return STATUS_INSUFFICIENT_RESOURCES;
120: }
121:
122: //
123: // get the name to local storage
124: //
125:
126: if ((netbiosName->NetbiosNameType == TDI_ADDRESS_NETBIOS_TYPE_GROUP) ||
127: (netbiosName->NetbiosNameType == TDI_ADDRESS_NETBIOS_TYPE_QUICK_GROUP)) {
128: networkName->NetbiosNameType = TDI_ADDRESS_NETBIOS_TYPE_GROUP;
129: } else {
130: networkName->NetbiosNameType = TDI_ADDRESS_NETBIOS_TYPE_UNIQUE;
131: }
132: RtlCopyMemory (networkName->NetbiosName, netbiosName->NetbiosName, 16);
133:
134: found = TRUE;
135: } else {
136: networkName = NULL;
137: found = TRUE;
138: }
139:
140: break;
141:
142: } else {
143:
144: addressName = (PTA_ADDRESS)(addressName->Address +
145: addressName->AddressLength);
146:
147: }
148:
149: }
150:
151: if (!found) {
152: StPrint1("OpenAddress: IRP %lx has no NETBIOS address\n", Irp);
153: return STATUS_NONEXISTENT_EA_ENTRY;
154: }
155:
156: //
157: // get an address file structure to represent this address.
158: //
159:
160: status = StCreateAddressFile (DeviceContext, &addressFile);
161:
162: if (!NT_SUCCESS (status)) {
163: return status;
164: }
165:
166: //
167: // See if this address is already established. This call automatically
168: // increments the reference count on the address so that it won't disappear
169: // from underneath us after this call but before we have a chance to use it.
170: //
171: // To ensure that we don't create two address objects for the
172: // same address, we hold the device context AddressResource until
173: // we have found the address or created a new one.
174: //
175:
176: ExAcquireResourceExclusive (&DeviceContext->AddressResource, TRUE);
177:
178: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql);
179:
180: address = StLookupAddress (DeviceContext, networkName);
181:
182: if (address == NULL) {
183:
184: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
185:
186: //
187: // This address doesn't exist. Create it, and start the process of
188: // registering it.
189: //
190:
191: status = StCreateAddress (
192: DeviceContext,
193: networkName,
194: &address);
195:
196: if (NT_SUCCESS (status)) {
197:
198: //
199: // Initialize the shared access now. We use read access
200: // to control all access.
201: //
202:
203: DesiredShareAccess = (ULONG)
204: (((IrpSp->Parameters.Create.ShareAccess & FILE_SHARE_READ) ||
205: (IrpSp->Parameters.Create.ShareAccess & FILE_SHARE_WRITE)) ?
206: FILE_SHARE_READ : 0);
207:
208: IoSetShareAccess(
209: FILE_READ_DATA,
210: DesiredShareAccess,
211: IrpSp->FileObject,
212: &address->ShareAccess);
213:
214:
215: //
216: // Assign the security descriptor (need to do this with
217: // the spinlock released because the descriptor is not
218: // mapped. BUGBUG: Need to synchronize Assign and Access).
219: //
220:
221: AccessState = IrpSp->Parameters.Create.SecurityContext->AccessState;
222:
223: status = SeAssignSecurity(
224: NULL, // parent descriptor
225: AccessState->SecurityDescriptor,
226: &address->SecurityDescriptor,
227: FALSE, // is directory
228: &AccessState->SubjectSecurityContext,
229: &AddressGenericMapping,
230: NonPagedPool);
231:
232: if (!NT_SUCCESS(status)) {
233:
234: //
235: // Error, return status.
236: //
237:
238: IoRemoveShareAccess (IrpSp->FileObject, &address->ShareAccess);
239: ExReleaseResource (&DeviceContext->AddressResource);
240: StDereferenceAddress ("Device context stopping", address);
241: StDereferenceAddressFile (addressFile);
242: return status;
243:
244: }
245:
246: ExReleaseResource (&DeviceContext->AddressResource);
247:
248: //
249: // if the adapter isn't ready, we can't do any of this; get out
250: //
251:
252: if (DeviceContext->State == DEVICECONTEXT_STATE_STOPPING) {
253: StDereferenceAddress ("Device context stopping", address);
254: StDereferenceAddressFile (addressFile);
255: status = STATUS_DEVICE_NOT_READY;
256:
257: } else {
258:
259: IrpSp->FileObject->FsContext = (PVOID)addressFile;
260: IrpSp->FileObject->FsContext2 =
261: (PVOID)TDI_TRANSPORT_ADDRESS_FILE;
262: addressFile->FileObject = IrpSp->FileObject;
263: addressFile->Irp = Irp;
264: addressFile->Address = address;
265:
266: ACQUIRE_SPIN_LOCK (&address->SpinLock, &oldirql);
267: InsertTailList (&address->AddressFileDatabase, &addressFile->Linkage);
268: RELEASE_SPIN_LOCK (&address->SpinLock, oldirql);
269:
270:
271: //
272: // Begin address registration unless this is the broadcast
273: // address (which is a "fake" address with no corresponding
274: // Netbios address) or the reserved address, which we know
275: // is unique since it is based on the adapter address.
276: //
277:
278: if ((networkName != NULL) &&
279: (RtlCompareMemory (networkName->NetbiosName,
280: DeviceContext->ReservedNetBIOSAddress,
281: NETBIOS_NAME_LENGTH) < NETBIOS_NAME_LENGTH)) {
282:
283: StRegisterAddress (address); // begin address registration.
284: status = STATUS_PENDING;
285:
286: } else {
287:
288: address->Flags &= ~ADDRESS_FLAGS_NEEDS_REG;
289: addressFile->Irp = NULL;
290: addressFile->State = ADDRESSFILE_STATE_OPEN;
291: status = STATUS_SUCCESS;
292:
293: }
294:
295: }
296:
297: } else {
298:
299: ExReleaseResource (&DeviceContext->AddressResource);
300:
301: //
302: // If the address could not be created, and is not in the process of
303: // being created, then we can't open up an address.
304: //
305:
306: if (networkName != NULL) {
307: ExFreePool (networkName);
308: }
309:
310: StDereferenceAddressFile (addressFile);
311:
312: }
313:
314: } else {
315:
316: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
317:
318: //
319: // The address already exists. Check the ACL and see if we
320: // can access it. If so, simply use this address as our address.
321: //
322:
323: AccessState = IrpSp->Parameters.Create.SecurityContext->AccessState;
324:
325: AccessAllowed = SeAccessCheck(
326: address->SecurityDescriptor,
327: &AccessState->SubjectSecurityContext,
328: FALSE, // tokens locked
329: IrpSp->Parameters.Create.SecurityContext->DesiredAccess,
330: (ACCESS_MASK)0, // previously granted
331: NULL, // privileges
332: &AddressGenericMapping,
333: Irp->RequestorMode,
334: &GrantedAccess,
335: &status);
336:
337: if (AccessAllowed) {
338:
339: //
340: // Access was successful, make sure Status is right.
341: //
342:
343: status = STATUS_SUCCESS;
344:
345: //
346: // Check that the name is of the correct type (unique vs. group)
347: // We don't need to check this for the broadcast address.
348: //
349:
350: if (networkName != NULL) {
351: if (address->NetworkName->NetbiosNameType !=
352: networkName->NetbiosNameType) {
353:
354: status = STATUS_DUPLICATE_NAME;
355:
356: }
357: }
358:
359: }
360:
361:
362: if (!NT_SUCCESS (status)) {
363:
364: ExReleaseResource (&DeviceContext->AddressResource);
365:
366: StDereferenceAddressFile (addressFile);
367:
368: } else {
369:
370: //
371: // Now check that we can obtain the desired share
372: // access. We use read access to control all access.
373: //
374:
375: DesiredShareAccess = (ULONG)
376: (((IrpSp->Parameters.Create.ShareAccess & FILE_SHARE_READ) ||
377: (IrpSp->Parameters.Create.ShareAccess & FILE_SHARE_WRITE)) ?
378: FILE_SHARE_READ : 0);
379:
380: status = IoCheckShareAccess(
381: FILE_READ_DATA,
382: DesiredShareAccess,
383: IrpSp->FileObject,
384: &address->ShareAccess,
385: TRUE);
386:
387: if (!NT_SUCCESS (status)) {
388:
389: ExReleaseResource (&DeviceContext->AddressResource);
390:
391: StDereferenceAddressFile (addressFile);
392:
393: } else {
394:
395: ExReleaseResource (&DeviceContext->AddressResource);
396:
397: ACQUIRE_SPIN_LOCK (&address->SpinLock, &oldirql);
398:
399: //
400: // now, if the address registered, we simply return success after
401: // pointing the file object at the address file (which points to
402: // the address). If the address registration is pending, we mark
403: // the registration pending and let the registration completion
404: // routine complete the open. If the address is bad, we simply
405: // fail the open.
406: //
407:
408: if ((address->Flags &
409: (ADDRESS_FLAGS_CONFLICT |
410: ADDRESS_FLAGS_REGISTERING |
411: ADDRESS_FLAGS_DEREGISTERING |
412: ADDRESS_FLAGS_DUPLICATE_NAME |
413: ADDRESS_FLAGS_NEEDS_REG |
414: ADDRESS_FLAGS_STOPPING |
415: ADDRESS_FLAGS_BAD_ADDRESS |
416: ADDRESS_FLAGS_CLOSED)) == 0) {
417:
418: InsertTailList (
419: &address->AddressFileDatabase,
420: &addressFile->Linkage);
421:
422: addressFile->Irp = NULL;
423: addressFile->Address = address;
424: addressFile->FileObject = IrpSp->FileObject;
425: addressFile->State = ADDRESSFILE_STATE_OPEN;
426:
427: StReferenceAddress("open ready", address);
428:
429: IrpSp->FileObject->FsContext = (PVOID)addressFile;
430: IrpSp->FileObject->FsContext2 =
431: (PVOID)TDI_TRANSPORT_ADDRESS_FILE;
432:
433: RELEASE_SPIN_LOCK (&address->SpinLock, oldirql);
434:
435: status = STATUS_SUCCESS;
436:
437: } else {
438:
439: //
440: // if the address is still registering, make the open pending.
441: //
442:
443: if ((address->Flags & (ADDRESS_FLAGS_REGISTERING | ADDRESS_FLAGS_NEEDS_REG)) != 0) {
444:
445: InsertTailList (
446: &address->AddressFileDatabase,
447: &addressFile->Linkage);
448:
449: addressFile->Irp = Irp;
450: addressFile->Address = address;
451: addressFile->FileObject = IrpSp->FileObject;
452:
453: StReferenceAddress("open registering", address);
454:
455: IrpSp->FileObject->FsContext = (PVOID)addressFile;
456: IrpSp->FileObject->FsContext2 =
457: (PVOID)TDI_TRANSPORT_ADDRESS_FILE;
458:
459: RELEASE_SPIN_LOCK (&address->SpinLock, oldirql);
460:
461: status = STATUS_PENDING;
462:
463: } else {
464:
465: RELEASE_SPIN_LOCK (&address->SpinLock, oldirql);
466:
467: StDereferenceAddressFile (addressFile);
468:
469: status = STATUS_DRIVER_INTERNAL_ERROR;
470:
471: }
472: }
473: }
474: }
475:
476: //
477: // Remove the reference from StLookupAddress.
478: //
479:
480: StDereferenceAddress ("Done opening", address);
481: }
482:
483: return status;
484: } /* StOpenAddress */
485:
486:
487: VOID
488: StAllocateAddress(
489: IN PDEVICE_CONTEXT DeviceContext,
490: OUT PTP_ADDRESS *TransportAddress
491: )
492:
493: /*++
494:
495: Routine Description:
496:
497: This routine allocates storage for a transport address. Some minimal
498: initialization is done on the address.
499:
500: NOTE: This routine is called with the device context spinlock
501: held, or at such a time as synchronization is unnecessary.
502:
503: Arguments:
504:
505: DeviceContext - Pointer to the device context (which is really just
506: the device object with its extension) to be associated with the
507: address.
508:
509: Address - Pointer to a place where this routine will return a pointer
510: to a transport address structure. Returns NULL if no storage
511: can be allocated.
512:
513: Return Value:
514:
515: None.
516:
517: --*/
518:
519: {
520: PTP_ADDRESS Address;
521: PSEND_PACKET_TAG SendTag;
522:
523: if ((DeviceContext->MemoryLimit != 0) &&
524: ((DeviceContext->MemoryUsage + sizeof(TP_ADDRESS)) >
525: DeviceContext->MemoryLimit)) {
526: PANIC("ST: Could not allocate address: limit\n");
527: StWriteResourceErrorLog (DeviceContext, sizeof(TP_ADDRESS), 101);
528: *TransportAddress = NULL;
529: return;
530: }
531:
532: Address = (PTP_ADDRESS)ExAllocatePool (NonPagedPool, sizeof (TP_ADDRESS));
533: if (Address == NULL) {
534: PANIC("ST: Could not allocate address: no pool\n");
535: StWriteResourceErrorLog (DeviceContext, sizeof(TP_ADDRESS), 201);
536: *TransportAddress = NULL;
537: return;
538: }
539: RtlZeroMemory (Address, sizeof(TP_ADDRESS));
540:
541: DeviceContext->MemoryUsage += sizeof(TP_ADDRESS);
542: ++DeviceContext->AddressAllocated;
543:
544: StAllocateSendPacket (DeviceContext, &(Address->Packet));
545: if (Address->Packet == NULL) {
546: ExFreePool (Address);
547: *TransportAddress = NULL;
548: return;
549: }
550: --DeviceContext->PacketAllocated; // AllocatePacket added one
551:
552: //
553: // Need to modify the address packets to belong to
554: // the address, not the device context.
555: //
556:
557: SendTag = (PSEND_PACKET_TAG)(Address->Packet->NdisPacket->ProtocolReserved);
558: SendTag->Type = TYPE_G_FRAME;
559: SendTag->Packet = Address->Packet;
560: SendTag->Owner = (PVOID)Address;
561:
562:
563: Address->Type = ST_ADDRESS_SIGNATURE;
564: Address->Size = sizeof (TP_ADDRESS);
565:
566: Address->Provider = DeviceContext;
567: KeInitializeSpinLock (&Address->SpinLock);
568:
569: InitializeListHead (&Address->ConnectionDatabase);
570: InitializeListHead (&Address->AddressFileDatabase);
571: InitializeListHead (&Address->SendDatagramQueue);
572:
573: //
574: // For each address, allocate a receive packet, a receive buffer,
575: // and a UI frame.
576: //
577:
578: StAddReceivePacket (DeviceContext);
579: StAddReceiveBuffer (DeviceContext);
580:
581: *TransportAddress = Address;
582:
583: } /* StAllocateAddress */
584:
585:
586: VOID
587: StDeallocateAddress(
588: IN PDEVICE_CONTEXT DeviceContext,
589: IN PTP_ADDRESS TransportAddress
590: )
591:
592: /*++
593:
594: Routine Description:
595:
596: This routine frees storage for a transport address.
597:
598: NOTE: This routine is called with the device context spinlock
599: held, or at such a time as synchronization is unnecessary.
600:
601: Arguments:
602:
603: DeviceContext - Pointer to the device context (which is really just
604: the device object with its extension) to be associated with the
605: address.
606:
607: Address - Pointer to a transport address structure.
608:
609: Return Value:
610:
611: None.
612:
613: --*/
614:
615: {
616:
617: if (TransportAddress->NetworkName != NULL) {
618: ExFreePool (TransportAddress->NetworkName);
619: }
620: StDeallocateSendPacket (DeviceContext, TransportAddress->Packet);
621: ++DeviceContext->PacketAllocated;
622:
623: ExFreePool (TransportAddress);
624: --DeviceContext->AddressAllocated;
625: DeviceContext->MemoryUsage -= sizeof(TP_ADDRESS);
626:
627: //
628: // Remove the resources which allocating this caused.
629: //
630:
631: StRemoveReceivePacket (DeviceContext);
632: StRemoveReceiveBuffer (DeviceContext);
633:
634: } /* StDeallocateAddress */
635:
636:
637: NTSTATUS
638: StCreateAddress(
639: IN PDEVICE_CONTEXT DeviceContext,
640: IN PST_NETBIOS_ADDRESS NetworkName,
641: OUT PTP_ADDRESS *Address
642: )
643:
644: /*++
645:
646: Routine Description:
647:
648: This routine creates a transport address and associates it with
649: the specified transport device context. The reference count in the
650: address is automatically set to 1, and the reference count of the
651: device context is incremented.
652:
653: NOTE: This routine must be called with the DeviceContext
654: spinlock held.
655:
656: Arguments:
657:
658: DeviceContext - Pointer to the device context (which is really just
659: the device object with its extension) to be associated with the
660: address.
661:
662: NetworkName - Pointer to an ST_NETBIOS_ADDRESS type containing the network
663: name to be associated with this address, if any.
664:
665: Address - Pointer to a place where this routine will return a pointer
666: to a transport address structure.
667:
668: Return Value:
669:
670: NTSTATUS - status of operation.
671:
672: --*/
673:
674: {
675: PTP_ADDRESS pAddress;
676: PLIST_ENTRY p;
677:
678:
679: p = RemoveHeadList (&DeviceContext->AddressPool);
680: if (p == &DeviceContext->AddressPool) {
681:
682: if ((DeviceContext->AddressMaxAllocated == 0) ||
683: (DeviceContext->AddressAllocated < DeviceContext->AddressMaxAllocated)) {
684:
685: StAllocateAddress (DeviceContext, &pAddress);
686:
687: } else {
688:
689: StWriteResourceErrorLog (DeviceContext, sizeof(TP_ADDRESS), 401);
690: pAddress = NULL;
691:
692: }
693:
694: if (pAddress == NULL) {
695: ++DeviceContext->AddressExhausted;
696: PANIC ("StCreateConnection: Could not allocate address object!\n");
697: return STATUS_INSUFFICIENT_RESOURCES;
698: }
699:
700: } else {
701:
702: pAddress = CONTAINING_RECORD (p, TP_ADDRESS, Linkage);
703:
704: }
705:
706: ++DeviceContext->AddressInUse;
707: if (DeviceContext->AddressInUse > DeviceContext->AddressMaxInUse) {
708: ++DeviceContext->AddressMaxInUse;
709: }
710:
711: DeviceContext->AddressTotal += DeviceContext->AddressInUse;
712: ++DeviceContext->AddressSamples;
713:
714:
715: //
716: // Initialize all of the static data for this address.
717: //
718:
719: pAddress->ReferenceCount = 1;
720:
721: pAddress->Flags = ADDRESS_FLAGS_NEEDS_REG;
722: InitializeListHead (&pAddress->AddressFileDatabase);
723:
724: pAddress->NetworkName = NetworkName;
725: if ((NetworkName != (PST_NETBIOS_ADDRESS)NULL) &&
726: (NetworkName->NetbiosNameType ==
727: TDI_ADDRESS_NETBIOS_TYPE_GROUP)) {
728:
729: pAddress->Flags |= ADDRESS_FLAGS_GROUP;
730:
731: }
732:
733: //
734: // Now link this address into the specified device context's
735: // address database. To do this, we need to acquire the spin lock
736: // on the device context.
737: //
738:
739: InsertTailList (&DeviceContext->AddressDatabase, &pAddress->Linkage);
740: pAddress->Provider = DeviceContext;
741: StReferenceDeviceContext ("Create Address", DeviceContext); // count refs to the device context.
742:
743: *Address = pAddress; // return the address.
744: return STATUS_SUCCESS; // not finished yet.
745: } /* StCreateAddress */
746:
747:
748: VOID
749: StRegisterAddress(
750: PTP_ADDRESS Address
751: )
752:
753: /*++
754:
755: Routine Description:
756:
757: This routine starts the registration process of the transport address
758: specified, if it has not already been started.
759:
760: Arguments:
761:
762: Address - Pointer to a transport address object to begin registering
763: on the network.
764:
765: Return Value:
766:
767: NTSTATUS - status of operation.
768:
769: --*/
770:
771: {
772: KIRQL oldirql;
773: PLIST_ENTRY p;
774: PIRP irp;
775: PTP_ADDRESS_FILE addressFile;
776:
777: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
778: if (!(Address->Flags & ADDRESS_FLAGS_NEEDS_REG)) {
779: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
780:
781: return;
782: }
783:
784: Address->Flags &= ~ADDRESS_FLAGS_NEEDS_REG;
785: Address->Flags |= ADDRESS_FLAGS_REGISTERING;
786:
787: //
788: // Keep a reference on this address until the registration process
789: // completes or is aborted. It will be aborted in UFRAMES.C, in
790: // either the NAME_IN_CONFLICT or ADD_NAME_RESPONSE frame handlers.
791: //
792:
793: StReferenceAddress ("start registration", Address);
794: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
795:
796: //
797: // Normally we would add the name on the network, then
798: // do the following in our timeout logic, but for ST
799: // we assume that all names are OK.
800: //
801:
802: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
803: Address->Flags &= ~ADDRESS_FLAGS_REGISTERING;
804:
805: p = Address->AddressFileDatabase.Flink;
806:
807: while (p != &Address->AddressFileDatabase) {
808: addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
809: p = p->Flink;
810:
811: if (addressFile->Irp != NULL) {
812: irp = addressFile->Irp;
813: addressFile->Irp = NULL;
814: addressFile->State = ADDRESSFILE_STATE_OPEN;
815: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
816: irp->IoStatus.Information = 0;
817: irp->IoStatus.Status = STATUS_SUCCESS;
818:
819: IoCompleteRequest (irp, IO_NETWORK_INCREMENT);
820:
821: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
822: }
823:
824: }
825:
826: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
827:
828: //
829: // Dereference the address if we're all done.
830: //
831:
832: StDereferenceAddress ("Timer, registered", Address);
833:
834: } /* StRegisterAddress */
835:
836:
837: NTSTATUS
838: StVerifyAddressObject (
839: IN PTP_ADDRESS_FILE AddressFile
840: )
841:
842: /*++
843:
844: Routine Description:
845:
846: This routine is called to verify that the pointer given us in a file
847: object is in fact a valid address file object. We also verify that the
848: address object pointed to by it is a valid address object, and reference
849: it to keep it from disappearing while we use it.
850:
851: Arguments:
852:
853: AddressFile - potential pointer to a TP_ADDRESS_FILE object
854:
855: Return Value:
856:
857: STATUS_SUCCESS if all is well; STATUS_INVALID_ADDRESS otherwise
858:
859: --*/
860:
861: {
862: KIRQL oldirql;
863: NTSTATUS status = STATUS_SUCCESS;
864: PTP_ADDRESS address;
865:
866: //
867: // try to verify the address file signature. If the signature is valid,
868: // verify the address pointed to by it and get the address spinlock.
869: // check the address's state, and increment the reference count if it's
870: // ok to use it. Note that the only time we return an error for state is
871: // if the address is closing.
872: //
873:
874: try {
875:
876: if ((AddressFile->Size == sizeof (TP_ADDRESS_FILE)) &&
877: (AddressFile->Type == ST_ADDRESSFILE_SIGNATURE) ) {
878: // (AddressFile->State != ADDRESSFILE_STATE_CLOSING) ) {
879:
880: address = AddressFile->Address;
881:
882: if ((address->Size == sizeof (TP_ADDRESS)) &&
883: (address->Type == ST_ADDRESS_SIGNATURE) ) {
884:
885: ACQUIRE_SPIN_LOCK (&address->SpinLock, &oldirql);
886:
887: if ((address->Flags & ADDRESS_FLAGS_STOPPING) == 0) {
888:
889: StReferenceAddress ("verify", address);
890:
891: } else {
892:
893: StPrint1("StVerifyAddress: A %lx closing\n", address);
894: status = STATUS_INVALID_ADDRESS;
895: }
896:
897: RELEASE_SPIN_LOCK (&address->SpinLock, oldirql);
898:
899: } else {
900:
901: StPrint1("StVerifyAddress: A %lx bad signature\n", address);
902: status = STATUS_INVALID_ADDRESS;
903: }
904:
905: } else {
906:
907: StPrint1("StVerifyAddress: AF %lx bad signature\n", AddressFile);
908: status = STATUS_INVALID_ADDRESS;
909: }
910:
911: } except(EXCEPTION_EXECUTE_HANDLER) {
912:
913: StPrint1("StVerifyAddress: AF %lx exception\n", address);
914: return GetExceptionCode();
915: }
916:
917: return status;
918:
919: }
920:
921: NTSTATUS
922: StDestroyAddress(
923: IN PTP_ADDRESS Address
924: )
925:
926: /*++
927:
928: Routine Description:
929:
930: This routine destroys a transport address and removes all references
931: made by it to other objects in the transport. The address structure
932: is returned to nonpaged system pool or our lookaside list. It is assumed
933: that the caller has already removed all addressfile structures associated
934: with this address.
935:
936: This routine is only called by StDerefAddress. The reason for
937: this is that there may be multiple streams of execution which are
938: simultaneously referencing the same address object, and it should
939: not be deleted out from under an interested stream of execution.
940:
941: Arguments:
942:
943: Address - Pointer to a transport address structure to be destroyed.
944:
945: Return Value:
946:
947: NTSTATUS - status of operation.
948:
949: --*/
950:
951: {
952: KIRQL oldirql;
953: PDEVICE_CONTEXT DeviceContext;
954:
955: DeviceContext = Address->Provider;
956:
957: SeDeassignSecurity (&Address->SecurityDescriptor);
958:
959: //
960: // Delink this address from its associated device context's address
961: // database. To do this we must spin lock on the device context object,
962: // not on the address.
963: //
964:
965: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql);
966:
967: RemoveEntryList (&Address->Linkage);
968:
969: //
970: // Now we can deallocate the transport address object.
971: //
972:
973: DeviceContext->AddressTotal += DeviceContext->AddressInUse;
974: ++DeviceContext->AddressSamples;
975: --DeviceContext->AddressInUse;
976:
977: if ((DeviceContext->AddressAllocated - DeviceContext->AddressInUse) >
978: DeviceContext->AddressInitAllocated) {
979: StDeallocateAddress (DeviceContext, Address);
980: } else {
981: InsertTailList (&DeviceContext->AddressPool, &Address->Linkage);
982: }
983:
984: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
985: StDereferenceDeviceContext ("Destroy Address", DeviceContext); // just housekeeping.
986:
987: return STATUS_SUCCESS;
988: } /* StDestroyAddress */
989:
990:
991: VOID
992: StRefAddress(
993: IN PTP_ADDRESS Address
994: )
995:
996: /*++
997:
998: Routine Description:
999:
1000: This routine increments the reference count on a transport address.
1001:
1002: Arguments:
1003:
1004: Address - Pointer to a transport address object.
1005:
1006: Return Value:
1007:
1008: none.
1009:
1010: --*/
1011:
1012: {
1013:
1014: ASSERT (Address->ReferenceCount > 0); // not perfect, but...
1015:
1016: (VOID)ExInterlockedIncrementLong (
1017: &Address->ReferenceCount,
1018: &Address->Provider->Interlock);
1019:
1020: } /* StRefAddress */
1021:
1022:
1023: VOID
1024: StDerefAddress(
1025: IN PTP_ADDRESS Address
1026: )
1027:
1028: /*++
1029:
1030: Routine Description:
1031:
1032: This routine dereferences a transport address by decrementing the
1033: reference count contained in the structure. If, after being
1034: decremented, the reference count is zero, then this routine calls
1035: StDestroyAddress to remove it from the system.
1036:
1037: Arguments:
1038:
1039: Address - Pointer to a transport address object.
1040:
1041: Return Value:
1042:
1043: none.
1044:
1045: --*/
1046:
1047: {
1048: INTERLOCKED_RESULT result;
1049:
1050: result = ExInterlockedDecrementLong (
1051: &Address->ReferenceCount,
1052: &Address->Provider->Interlock);
1053:
1054: //
1055: // If we have deleted all references to this address, then we can
1056: // destroy the object. It is okay to have already released the spin
1057: // lock at this point because there is no possible way that another
1058: // stream of execution has access to the address any longer.
1059: //
1060:
1061: ASSERT (result != ResultNegative);
1062:
1063: if (result == ResultZero) {
1064: StDestroyAddress (Address);
1065: }
1066: } /* StDerefAddress */
1067:
1068:
1069:
1070: VOID
1071: StAllocateAddressFile(
1072: IN PDEVICE_CONTEXT DeviceContext,
1073: OUT PTP_ADDRESS_FILE *TransportAddressFile
1074: )
1075:
1076: /*++
1077:
1078: Routine Description:
1079:
1080: This routine allocates storage for an address file. Some
1081: minimal initialization is done on the object.
1082:
1083: NOTE: This routine is called with the device context spinlock
1084: held, or at such a time as synchronization is unnecessary.
1085:
1086: Arguments:
1087:
1088: DeviceContext - Pointer to the device context (which is really just
1089: the device object with its extension) to be associated with the
1090: address.
1091:
1092: TransportAddressFile - Pointer to a place where this routine will return
1093: a pointer to a transport address file structure. It returns NULL if no
1094: storage can be allocated.
1095:
1096: Return Value:
1097:
1098: None.
1099:
1100: --*/
1101:
1102: {
1103:
1104: PTP_ADDRESS_FILE AddressFile;
1105:
1106: if ((DeviceContext->MemoryLimit != 0) &&
1107: ((DeviceContext->MemoryUsage + sizeof(TP_ADDRESS_FILE)) >
1108: DeviceContext->MemoryLimit)) {
1109: PANIC("ST: Could not allocate address file: limit\n");
1110: StWriteResourceErrorLog (DeviceContext, sizeof(TP_ADDRESS_FILE), 102);
1111: *TransportAddressFile = NULL;
1112: return;
1113: }
1114:
1115: AddressFile = (PTP_ADDRESS_FILE)ExAllocatePool (NonPagedPool, sizeof (TP_ADDRESS_FILE));
1116: if (AddressFile == NULL) {
1117: PANIC("ST: Could not allocate address file: no pool\n");
1118: StWriteResourceErrorLog (DeviceContext, sizeof(TP_ADDRESS_FILE), 202);
1119: *TransportAddressFile = NULL;
1120: return;
1121: }
1122: RtlZeroMemory (AddressFile, sizeof(TP_ADDRESS_FILE));
1123:
1124: DeviceContext->MemoryUsage += sizeof(TP_ADDRESS_FILE);
1125: ++DeviceContext->AddressFileAllocated;
1126:
1127: AddressFile->Type = ST_ADDRESSFILE_SIGNATURE;
1128: AddressFile->Size = sizeof (TP_ADDRESS_FILE);
1129:
1130: InitializeListHead (&AddressFile->ReceiveDatagramQueue);
1131: InitializeListHead (&AddressFile->ConnectionDatabase);
1132:
1133: *TransportAddressFile = AddressFile;
1134:
1135: } /* StAllocateAddressFile */
1136:
1137:
1138: VOID
1139: StDeallocateAddressFile(
1140: IN PDEVICE_CONTEXT DeviceContext,
1141: IN PTP_ADDRESS_FILE TransportAddressFile
1142: )
1143:
1144: /*++
1145:
1146: Routine Description:
1147:
1148: This routine frees storage for an address file.
1149:
1150: NOTE: This routine is called with the device context spinlock
1151: held, or at such a time as synchronization is unnecessary.
1152:
1153: Arguments:
1154:
1155: DeviceContext - Pointer to the device context (which is really just
1156: the device object with its extension) to be associated with the
1157: address.
1158:
1159: TransportAddressFile - Pointer to a transport address file structure.
1160:
1161: Return Value:
1162:
1163: None.
1164:
1165: --*/
1166:
1167: {
1168:
1169: ExFreePool (TransportAddressFile);
1170: --DeviceContext->AddressFileAllocated;
1171: DeviceContext->MemoryUsage -= sizeof(TP_ADDRESS_FILE);
1172:
1173: } /* StDeallocateAddressFile */
1174:
1175:
1176: NTSTATUS
1177: StCreateAddressFile(
1178: IN PDEVICE_CONTEXT DeviceContext,
1179: OUT PTP_ADDRESS_FILE * AddressFile
1180: )
1181:
1182: /*++
1183:
1184: Routine Description:
1185:
1186: This routine creates an address file from the pool of ther
1187: specified device context. The reference count in the
1188: address is automatically set to 1.
1189:
1190: Arguments:
1191:
1192: DeviceContext - Pointer to the device context (which is really just
1193: the device object with its extension) to be associated with the
1194: address.
1195:
1196: AddressFile - Pointer to a place where this routine will return a pointer
1197: to a transport address file structure.
1198:
1199: Return Value:
1200:
1201: NTSTATUS - status of operation.
1202:
1203: --*/
1204:
1205: {
1206: KIRQL oldirql;
1207: PLIST_ENTRY p;
1208: PTP_ADDRESS_FILE addressFile;
1209:
1210: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql);
1211:
1212: p = RemoveHeadList (&DeviceContext->AddressFilePool);
1213: if (p == &DeviceContext->AddressFilePool) {
1214:
1215: if ((DeviceContext->AddressFileMaxAllocated == 0) ||
1216: (DeviceContext->AddressFileAllocated < DeviceContext->AddressFileMaxAllocated)) {
1217:
1218: StAllocateAddressFile (DeviceContext, &addressFile);
1219: } else {
1220:
1221: StWriteResourceErrorLog (DeviceContext, sizeof(TP_ADDRESS_FILE), 402);
1222: addressFile = NULL;
1223:
1224: }
1225:
1226: if (addressFile == NULL) {
1227: ++DeviceContext->AddressFileExhausted;
1228: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
1229: PANIC ("StCreateConnection: Could not allocate address file object!\n");
1230: return STATUS_INSUFFICIENT_RESOURCES;
1231: }
1232:
1233: } else {
1234:
1235: addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
1236:
1237: }
1238:
1239: ++DeviceContext->AddressFileInUse;
1240: if (DeviceContext->AddressFileInUse > DeviceContext->AddressFileMaxInUse) {
1241: ++DeviceContext->AddressFileMaxInUse;
1242: }
1243:
1244: DeviceContext->AddressFileTotal += DeviceContext->AddressFileInUse;
1245: ++DeviceContext->AddressFileSamples;
1246:
1247: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
1248:
1249:
1250: InitializeListHead (&addressFile->ConnectionDatabase);
1251: addressFile->Address = NULL;
1252: addressFile->FileObject = NULL;
1253: addressFile->Provider = DeviceContext;
1254: addressFile->State = ADDRESSFILE_STATE_OPENING;
1255: addressFile->ConnectIndicationInProgress = FALSE;
1256: addressFile->ReferenceCount = 1;
1257: addressFile->CloseIrp = (PIRP)NULL;
1258:
1259: //
1260: // Initialize the request handlers.
1261: //
1262:
1263: addressFile->RegisteredConnectionHandler = FALSE;
1264: addressFile->ConnectionHandler = TdiDefaultConnectHandler;
1265: addressFile->ConnectionHandlerContext = NULL;
1266: addressFile->RegisteredDisconnectHandler = FALSE;
1267: addressFile->DisconnectHandler = TdiDefaultDisconnectHandler;
1268: addressFile->DisconnectHandlerContext = NULL;
1269: addressFile->RegisteredReceiveHandler = FALSE;
1270: addressFile->ReceiveHandler = TdiDefaultReceiveHandler;
1271: addressFile->ReceiveHandlerContext = NULL;
1272: addressFile->RegisteredReceiveDatagramHandler = FALSE;
1273: addressFile->ReceiveDatagramHandler = TdiDefaultRcvDatagramHandler;
1274: addressFile->ReceiveDatagramHandlerContext = NULL;
1275: addressFile->RegisteredExpeditedDataHandler = FALSE;
1276: addressFile->ExpeditedDataHandler = TdiDefaultRcvExpeditedHandler;
1277: addressFile->ExpeditedDataHandlerContext = NULL;
1278: addressFile->RegisteredErrorHandler = FALSE;
1279: addressFile->ErrorHandler = TdiDefaultErrorHandler;
1280: addressFile->ErrorHandlerContext = NULL;
1281:
1282:
1283: *AddressFile = addressFile;
1284: return STATUS_SUCCESS;
1285:
1286: } /* StCreateAddress */
1287:
1288:
1289: NTSTATUS
1290: StDestroyAddressFile(
1291: IN PTP_ADDRESS_FILE AddressFile
1292: )
1293:
1294: /*++
1295:
1296: Routine Description:
1297:
1298: This routine destroys an address file and removes all references
1299: made by it to other objects in the transport.
1300:
1301: This routine is only called by StDereferenceAddressFile. The reason
1302: for this is that there may be multiple streams of execution which are
1303: simultaneously referencing the same address file object, and it should
1304: not be deleted out from under an interested stream of execution.
1305:
1306: Arguments:
1307:
1308: AddressFile Pointer to a transport address file structure to be destroyed.
1309:
1310: Return Value:
1311:
1312: NTSTATUS - status of operation.
1313:
1314: --*/
1315:
1316: {
1317: KIRQL oldirql, oldirql1;
1318: PTP_ADDRESS address;
1319: PDEVICE_CONTEXT DeviceContext;
1320: PIRP CloseIrp;
1321:
1322:
1323: address = AddressFile->Address;
1324: DeviceContext = AddressFile->Provider;
1325:
1326: if (address) {
1327:
1328: //
1329: // This addressfile was associated with an address.
1330: //
1331:
1332: ACQUIRE_SPIN_LOCK (&address->SpinLock, &oldirql);
1333:
1334: //
1335: // remove this addressfile from the address list and disassociate it from
1336: // the file handle.
1337: //
1338:
1339: RemoveEntryList (&AddressFile->Linkage);
1340: InitializeListHead (&AddressFile->Linkage);
1341:
1342: if (address->AddressFileDatabase.Flink == &address->AddressFileDatabase) {
1343:
1344: //
1345: // This is the last open of this address, it will close
1346: // due to normal dereferencing but we have to set the
1347: // CLOSING flag too to stop further references.
1348: //
1349:
1350: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql1);
1351: address->Flags |= ADDRESS_FLAGS_STOPPING;
1352: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql1);
1353:
1354: }
1355:
1356: AddressFile->Address = NULL;
1357:
1358: AddressFile->FileObject->FsContext = NULL;
1359: AddressFile->FileObject->FsContext2 = NULL;
1360:
1361: RELEASE_SPIN_LOCK (&address->SpinLock, oldirql);
1362:
1363: //
1364: // We will already have been removed from the ShareAccess
1365: // of the owning address.
1366: //
1367:
1368: //
1369: // Now dereference the owning address.
1370: //
1371:
1372: StDereferenceAddress ("Close", address); // remove the creation hold
1373:
1374: }
1375:
1376: //
1377: // Save this for later completion.
1378: //
1379:
1380: CloseIrp = AddressFile->CloseIrp;
1381:
1382: //
1383: // return the addressFile to the pool of address files
1384: //
1385:
1386: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql);
1387:
1388: DeviceContext->AddressFileTotal += DeviceContext->AddressFileInUse;
1389: ++DeviceContext->AddressFileSamples;
1390: --DeviceContext->AddressFileInUse;
1391:
1392: if ((DeviceContext->AddressFileAllocated - DeviceContext->AddressFileInUse) >
1393: DeviceContext->AddressFileInitAllocated) {
1394: StDeallocateAddressFile (DeviceContext, AddressFile);
1395: } else {
1396: InsertTailList (&DeviceContext->AddressFilePool, &AddressFile->Linkage);
1397: }
1398:
1399: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
1400:
1401:
1402: if (CloseIrp != (PIRP)NULL) {
1403: CloseIrp->IoStatus.Information = 0;
1404: CloseIrp->IoStatus.Status = STATUS_SUCCESS;
1405: IoCompleteRequest (CloseIrp, IO_NETWORK_INCREMENT);
1406: }
1407:
1408: return STATUS_SUCCESS;
1409:
1410: } /* StDestroyAddress */
1411:
1412:
1413: VOID
1414: StReferenceAddressFile(
1415: IN PTP_ADDRESS_FILE AddressFile
1416: )
1417:
1418: /*++
1419:
1420: Routine Description:
1421:
1422: This routine increments the reference count on an address file.
1423:
1424: Arguments:
1425:
1426: AddressFile - Pointer to a transport address file object.
1427:
1428: Return Value:
1429:
1430: none.
1431:
1432: --*/
1433:
1434: {
1435:
1436: ASSERT (AddressFile->ReferenceCount > 0); // not perfect, but...
1437:
1438: (VOID)ExInterlockedIncrementLong (
1439: &AddressFile->ReferenceCount,
1440: &AddressFile->Provider->Interlock);
1441:
1442: } /* StReferenceAddressFile */
1443:
1444:
1445: VOID
1446: StDereferenceAddressFile(
1447: IN PTP_ADDRESS_FILE AddressFile
1448: )
1449:
1450: /*++
1451:
1452: Routine Description:
1453:
1454: This routine dereferences an address file by decrementing the
1455: reference count contained in the structure. If, after being
1456: decremented, the reference count is zero, then this routine calls
1457: StDestroyAddressFile to remove it from the system.
1458:
1459: Arguments:
1460:
1461: AddressFile - Pointer to a transport address file object.
1462:
1463: Return Value:
1464:
1465: none.
1466:
1467: --*/
1468:
1469: {
1470: INTERLOCKED_RESULT result;
1471:
1472: result = ExInterlockedDecrementLong (
1473: &AddressFile->ReferenceCount,
1474: &AddressFile->Provider->Interlock);
1475:
1476: //
1477: // If we have deleted all references to this address file, then we can
1478: // destroy the object. It is okay to have already released the spin
1479: // lock at this point because there is no possible way that another
1480: // stream of execution has access to the address any longer.
1481: //
1482:
1483: ASSERT (result != ResultNegative);
1484:
1485: if (result == ResultZero) {
1486: StDestroyAddressFile (AddressFile);
1487: }
1488: } /* StDerefAddressFile */
1489:
1490:
1491: PTP_ADDRESS
1492: StLookupAddress(
1493: IN PDEVICE_CONTEXT DeviceContext,
1494: IN PST_NETBIOS_ADDRESS NetworkName
1495: )
1496:
1497: /*++
1498:
1499: Routine Description:
1500:
1501: This routine scans the transport addresses defined for the given
1502: device context and compares them with the specified NETWORK
1503: NAME values. If an exact match is found, then a pointer to the
1504: TP_ADDRESS object is returned, and as a side effect, the reference
1505: count to the address object is incremented. If the address is not
1506: found, then NULL is returned.
1507:
1508: NOTE: This routine must be called with the DeviceContext
1509: spinlock held.
1510:
1511: Arguments:
1512:
1513: DeviceContext - Pointer to the device object and its extension.
1514: NetworkName - Pointer to an ST_NETBIOS_ADDRESS structure containing the
1515: network name.
1516:
1517: Return Value:
1518:
1519: Pointer to the TP_ADDRESS object found, or NULL if not found.
1520:
1521: --*/
1522:
1523: {
1524: PTP_ADDRESS address;
1525: PLIST_ENTRY p;
1526: ULONG i;
1527:
1528:
1529: p = DeviceContext->AddressDatabase.Flink;
1530:
1531: for (p = DeviceContext->AddressDatabase.Flink;
1532: p != &DeviceContext->AddressDatabase;
1533: p = p->Flink) {
1534:
1535: address = CONTAINING_RECORD (p, TP_ADDRESS, Linkage);
1536:
1537: if ((address->Flags & ADDRESS_FLAGS_STOPPING) != 0) {
1538: continue;
1539: }
1540:
1541: //
1542: // If the network name is specified and the network names don't match,
1543: // then the addresses don't match.
1544: //
1545:
1546: i = NETBIOS_NAME_LENGTH; // length of a Netbios name
1547:
1548: if (address->NetworkName != NULL) {
1549: if (NetworkName != NULL) {
1550: if (RtlCompareMemory (
1551: address->NetworkName->NetbiosName,
1552: NetworkName->NetbiosName,
1553: i) < i) {
1554: continue;
1555: }
1556: } else {
1557: continue;
1558: }
1559:
1560: } else {
1561: if (NetworkName != NULL) {
1562: continue;
1563: }
1564: }
1565:
1566: //
1567: // We found the match. Bump the reference count on the address, and
1568: // return a pointer to the address object for the caller to use.
1569: //
1570:
1571: StReferenceAddress ("lookup", address);
1572: return address;
1573:
1574: } /* for */
1575:
1576: //
1577: // The specified address was not found.
1578: //
1579:
1580: return NULL;
1581:
1582: } /* StLookupAddress */
1583:
1584:
1585: PTP_CONNECTION
1586: StLookupRemoteName(
1587: IN PTP_ADDRESS Address,
1588: IN PUCHAR RemoteName
1589: )
1590:
1591: /*++
1592:
1593: Routine Description:
1594:
1595: This routine scans the connections associated with an
1596: address, and determines if there is an connection
1597: associated with the specific remote address.
1598:
1599: Arguments:
1600:
1601: Address - Pointer to the address.
1602:
1603: RemoteName - The 16-character Netbios name of the remote.
1604:
1605: Return Value:
1606:
1607: The connection if one is found, NULL otherwise.
1608:
1609: --*/
1610:
1611: {
1612: KIRQL oldirql, oldirql1;
1613: PLIST_ENTRY p;
1614: PTP_CONNECTION connection;
1615:
1616:
1617: //
1618: // Hold the spinlock so the connection database doesn't
1619: // change.
1620: //
1621:
1622: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
1623:
1624: for (p=Address->ConnectionDatabase.Flink;
1625: p != &Address->ConnectionDatabase;
1626: p=p->Flink) {
1627:
1628: connection = CONTAINING_RECORD (p, TP_CONNECTION, AddressList);
1629:
1630: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql1);
1631:
1632: if (((connection->Flags2 & CONNECTION_FLAGS2_REMOTE_VALID) != 0) &&
1633: ((connection->Flags & CONNECTION_FLAGS_READY) != 0)) {
1634:
1635: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql1);
1636:
1637: //
1638: // If the remote names match, then return the
1639: // connection.
1640: //
1641:
1642: if (RtlCompareMemory(RemoteName, connection->RemoteName, NETBIOS_NAME_LENGTH) ==
1643: NETBIOS_NAME_LENGTH) {
1644:
1645: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
1646: StReferenceConnection ("Lookup found", connection);
1647: return connection;
1648:
1649: }
1650:
1651: } else {
1652:
1653: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql1);
1654:
1655: }
1656:
1657: }
1658:
1659: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
1660:
1661: return (PTP_CONNECTION)NULL;
1662:
1663: }
1664:
1665:
1666: BOOLEAN
1667: StMatchNetbiosAddress(
1668: IN PTP_ADDRESS Address,
1669: IN PUCHAR NetBIOSName
1670: )
1671:
1672: /*++
1673:
1674: Routine Description:
1675:
1676: This routine is called to compare the addressing information in a
1677: TP_ADDRESS object with the 16-byte NetBIOS name in a frame header.
1678: If they match, then this routine returns TRUE, else it returns FALSE.
1679:
1680: Arguments:
1681:
1682: Address - Pointer to a TP_ADDRESS object.
1683:
1684: NetBIOSName - Pointer to a 16-byte character string (non-terminated),
1685: or NULL if this is a received broadcast address.
1686:
1687: Return Value:
1688:
1689: BOOLEAN, TRUE if match, FALSE if not.
1690:
1691: --*/
1692:
1693: {
1694:
1695: PULONG AddressNamePointer;
1696: ULONG UNALIGNED * NetbiosNamePointer;
1697:
1698: //
1699: // If this is address is the Netbios broadcast address, the comparison
1700: // succeeds only if the passed in address is also NULL.
1701: //
1702:
1703: if (Address->NetworkName == NULL) {
1704:
1705: if (NetBIOSName == NULL) {
1706: return TRUE;
1707: } else {
1708: return FALSE;
1709: }
1710:
1711: } else if (NetBIOSName == NULL) {
1712:
1713: return FALSE;
1714:
1715: }
1716:
1717: //
1718: // Do a quick check of the first character in the names.
1719: //
1720:
1721: if (Address->NetworkName->NetbiosName[0] != NetBIOSName[0]) {
1722: return FALSE;
1723: }
1724:
1725: //
1726: // Now compare the 16-character Netbios names as ULONGs
1727: // for speed. We know the one stored in the address
1728: // structure is aligned.
1729: //
1730:
1731: AddressNamePointer = (PULONG)(Address->NetworkName->NetbiosName);
1732: NetbiosNamePointer = (ULONG UNALIGNED *)NetBIOSName;
1733:
1734: if ((AddressNamePointer[0] == NetbiosNamePointer[0]) &&
1735: (AddressNamePointer[1] == NetbiosNamePointer[1]) &&
1736: (AddressNamePointer[2] == NetbiosNamePointer[2]) &&
1737: (AddressNamePointer[3] == NetbiosNamePointer[3])) {
1738: return TRUE;
1739: } else {
1740: return FALSE;
1741: }
1742:
1743: } /* StMatchNetbiosAddress */
1744:
1745:
1746: VOID
1747: StStopAddress(
1748: IN PTP_ADDRESS Address
1749: )
1750:
1751: /*++
1752:
1753: Routine Description:
1754:
1755: This routine is called to terminate all activity on an address and
1756: destroy the object. This is done in a graceful manner; i.e., all
1757: outstanding addressfiles are removed from the addressfile database, and
1758: all their activities are shut down.
1759:
1760: Arguments:
1761:
1762: Address - Pointer to a TP_ADDRESS object.
1763:
1764: Return Value:
1765:
1766: none.
1767:
1768: --*/
1769:
1770: {
1771: KIRQL oldirql, oldirql1;
1772: PTP_ADDRESS_FILE addressFile;
1773: PLIST_ENTRY p;
1774: PDEVICE_CONTEXT DeviceContext;
1775:
1776: DeviceContext = Address->Provider;
1777:
1778: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
1779:
1780: //
1781: // If we're already stopping this address, then don't try to do it again.
1782: //
1783:
1784: if (!(Address->Flags & ADDRESS_FLAGS_STOPPING)) {
1785:
1786: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql1);
1787: Address->Flags |= ADDRESS_FLAGS_STOPPING;
1788: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql1);
1789:
1790: //
1791: // Run down all addressfiles on this address. This
1792: // will leave the address with no references
1793: // potentially, but we don't need a temp one
1794: // because every place that calls StStopAddress
1795: // already has a temp reference.
1796: //
1797:
1798: while (!IsListEmpty (&Address->AddressFileDatabase)) {
1799: p = RemoveHeadList (&Address->AddressFileDatabase);
1800: addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
1801:
1802: addressFile->Address = NULL;
1803: addressFile->FileObject->FsContext = NULL;
1804: addressFile->FileObject->FsContext2 = NULL;
1805:
1806: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
1807:
1808: //
1809: // Run-down this addressFile without the lock on.
1810: // We don't care about removing ourselves from
1811: // the address' ShareAccess because we are
1812: // tearing it down.
1813: //
1814:
1815: StStopAddressFile (addressFile, Address);
1816:
1817: //
1818: // return the addressFile to the pool of address files
1819: //
1820:
1821: StDereferenceAddressFile (addressFile);
1822:
1823: StDereferenceAddress ("stop address", Address);
1824:
1825: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
1826: }
1827:
1828: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
1829: return;
1830:
1831: }
1832:
1833: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
1834: } /* StStopAddress */
1835:
1836:
1837: NTSTATUS
1838: StStopAddressFile(
1839: IN PTP_ADDRESS_FILE AddressFile,
1840: IN PTP_ADDRESS Address
1841: )
1842:
1843: /*++
1844:
1845: Routine Description:
1846:
1847: This routine is called to terminate all activity on an AddressFile and
1848: destroy the object. We remove every connection and datagram associated
1849: with this addressfile from the address database and terminate their
1850: activity. Then, if there are no other outstanding addressfiles open on
1851: this address, the address will go away.
1852:
1853: Arguments:
1854:
1855: AddressFile - pointer to the addressFile to be stopped
1856:
1857: Address - the owning address for this addressFile (we do not depend upon
1858: the pointer in the addressFile because we want this routine to be safe)
1859:
1860: Return Value:
1861:
1862: STATUS_SUCCESS if all is well, STATUS_INVALID_HANDLE if the Irp does not
1863: point to a real address.
1864:
1865: --*/
1866:
1867: {
1868: KIRQL oldirql, oldirql1;
1869: LIST_ENTRY localList;
1870: PLIST_ENTRY p, pFlink;
1871: PTP_REQUEST request;
1872: PTP_CONNECTION connection;
1873:
1874:
1875: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
1876:
1877: if (AddressFile->State == ADDRESSFILE_STATE_CLOSING) {
1878: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
1879: return STATUS_SUCCESS;
1880: }
1881:
1882:
1883: AddressFile->State = ADDRESSFILE_STATE_CLOSING;
1884: InitializeListHead (&localList);
1885:
1886: //
1887: // Run down all connections on this addressfile, and
1888: // preform the equivalent of StDestroyAssociation
1889: // on them.
1890: //
1891:
1892: while (!IsListEmpty (&AddressFile->ConnectionDatabase)) {
1893: p = RemoveHeadList (&AddressFile->ConnectionDatabase);
1894: connection = CONTAINING_RECORD (p, TP_CONNECTION, AddressFileList);
1895:
1896: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql1);
1897:
1898: if ((connection->Flags2 & CONNECTION_FLAGS2_ASSOCIATED) == 0) {
1899:
1900: //
1901: // It is in the process of being disassociated already.
1902: //
1903:
1904: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql1);
1905: continue;
1906: }
1907:
1908: connection->Flags2 &= ~CONNECTION_FLAGS2_ASSOCIATED;
1909: connection->Flags |= CONNECTION_FLAGS_DESTROY; // BUGBUG: Is this needed?
1910: RemoveEntryList (&connection->AddressList);
1911: InitializeListHead (&connection->AddressList);
1912: InitializeListHead (&connection->AddressFileList);
1913: connection->AddressFile = NULL;
1914:
1915: StReferenceConnection ("Close AddressFile", connection);
1916: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql1);
1917:
1918: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
1919:
1920: StStopConnection (connection, STATUS_LOCAL_DISCONNECT);
1921: StDereferenceConnection ("Close AddressFile", connection);
1922:
1923: StDereferenceAddress ("Destroy association", Address);
1924:
1925: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
1926: }
1927:
1928: //
1929: // now remove all of the datagrams owned by this addressfile
1930: //
1931:
1932: for (p = Address->SendDatagramQueue.Flink;
1933: p != &Address->SendDatagramQueue;
1934: p = pFlink ) {
1935:
1936: pFlink = p->Flink;
1937: request = CONTAINING_RECORD (p, TP_REQUEST, Linkage);
1938: if ((PTP_ADDRESS_FILE)(request->Owner) == AddressFile) {
1939: RemoveEntryList (p);
1940: InitializeListHead (p);
1941: InsertTailList (&localList, p);
1942: }
1943:
1944: }
1945:
1946: for (p = AddressFile->ReceiveDatagramQueue.Flink;
1947: p != &AddressFile->ReceiveDatagramQueue;
1948: p = pFlink ) {
1949:
1950: pFlink = p->Flink;
1951: RemoveEntryList (p);
1952: InitializeListHead (p);
1953: InsertTailList (&localList, p);
1954: }
1955:
1956: //
1957: // and finally, signal failure if the address file was waiting for a
1958: // registration to complete (Irp is set to NULL when this succeeds).
1959: //
1960:
1961: if (AddressFile->Irp != NULL) {
1962: PIRP irp=AddressFile->Irp;
1963: AddressFile->Irp = NULL;
1964: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
1965: irp->IoStatus.Information = 0;
1966: irp->IoStatus.Status = STATUS_DUPLICATE_NAME;
1967:
1968: IoCompleteRequest (irp, IO_NETWORK_INCREMENT);
1969:
1970: } else {
1971:
1972: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
1973: }
1974:
1975: //
1976: // cancel all the datagrams on this address file
1977: //
1978:
1979: while (!IsListEmpty (&localList)) {
1980:
1981: p = RemoveHeadList (&localList);
1982: request = CONTAINING_RECORD (p, TP_REQUEST, Linkage);
1983:
1984: StCompleteRequest (request, STATUS_NETWORK_NAME_DELETED, 0);
1985:
1986: }
1987:
1988:
1989: } /* StStopAddressFile */
1990:
1991:
1992: NTSTATUS
1993: StCloseAddress(
1994: IN PDEVICE_OBJECT DeviceObject,
1995: IN PIRP Irp,
1996: IN PIO_STACK_LOCATION IrpSp
1997: )
1998:
1999: /*++
2000:
2001: Routine Description:
2002:
2003: This routine is called to close the addressfile pointed to by a file
2004: object. If there is any activity to be run down, we will run it down
2005: before we terminate the addressfile. We remove every connection and
2006: datagram associated with this addressfile from the address database
2007: and terminate their activity. Then, if there are no other outstanding
2008: addressfiles open on this address, the address will go away.
2009:
2010: Arguments:
2011:
2012: Irp - the Irp Address - Pointer to a TP_ADDRESS object.
2013:
2014: Return Value:
2015:
2016: STATUS_SUCCESS if all is well, STATUS_INVALID_HANDLE if the Irp does not
2017: point to a real address.
2018:
2019: --*/
2020:
2021: {
2022: PTP_ADDRESS address;
2023: PTP_ADDRESS_FILE addressFile;
2024:
2025: addressFile = IrpSp->FileObject->FsContext;
2026: addressFile->CloseIrp = Irp;
2027:
2028: //
2029: // We assume that addressFile has already been verified
2030: // at this point.
2031: //
2032:
2033: address = addressFile->Address;
2034: ASSERT (address);
2035:
2036: //
2037: // Remove us from the access info for this address.
2038: //
2039:
2040: ExAcquireResourceExclusive (&addressFile->Provider->AddressResource, TRUE);
2041: IoRemoveShareAccess (addressFile->FileObject, &address->ShareAccess);
2042: ExReleaseResource (&addressFile->Provider->AddressResource);
2043:
2044:
2045: StStopAddressFile (addressFile, address);
2046: StDereferenceAddressFile (addressFile);
2047:
2048: //
2049: // This removes a reference added by our caller.
2050: //
2051:
2052: StDereferenceAddress ("IRP_MJ_CLOSE", address);
2053:
2054: return STATUS_PENDING;
2055:
2056: } /* StCloseAddress */
2057:
2058:
2059: NTSTATUS
2060: StSendDatagramsOnAddress(
2061: PTP_ADDRESS Address
2062: )
2063:
2064: /*++
2065:
2066: Routine Description:
2067:
2068: This routine attempts to acquire a hold on the SendDatagramQueue of
2069: the specified address, prepare the next datagram for shipment, and
2070: call StSendUIMdlFrame to actually do the work. When StSendUIMdlFrame
2071: is finished, it will cause an I/O completion routine in UFRAMES.C to
2072: be called, at which time this routine is called again to handle the
2073: next datagram in the pipeline.
2074:
2075: Arguments:
2076:
2077: Address - a pointer to the address object to send the datagram on.
2078:
2079: Return Value:
2080:
2081: NTSTATUS - status of operation.
2082:
2083: --*/
2084:
2085: {
2086: KIRQL oldirql;
2087: PLIST_ENTRY p;
2088: PTP_REQUEST request;
2089: PTA_NETBIOS_ADDRESS remoteTA;
2090: PIO_STACK_LOCATION irpSp;
2091: PDEVICE_CONTEXT DeviceContext;
2092: PUCHAR SourceRouting;
2093: UINT SourceRoutingLength;
2094: UINT HeaderLength;
2095: PST_HEADER StHeader;
2096: PSEND_PACKET_TAG SendTag;
2097:
2098: DeviceContext = Address->Provider;
2099:
2100: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
2101: StReferenceAddress ("Send datagram", Address); // keep it around
2102:
2103: if (!(Address->Flags & ADDRESS_FLAGS_SEND_IN_PROGRESS)) {
2104:
2105: //
2106: // If the queue is empty, don't do anything.
2107: //
2108:
2109: if (IsListEmpty (&Address->SendDatagramQueue)) {
2110: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
2111: StDereferenceAddress ("Queue empty", Address);
2112: return STATUS_SUCCESS;
2113: }
2114:
2115: //
2116: // Mark the address's send datagram queue as held so that the
2117: // MDL and ST header will not be used for two requests at the
2118: // same time.
2119: //
2120:
2121: Address->Flags |= ADDRESS_FLAGS_SEND_IN_PROGRESS;
2122:
2123: //
2124: // We own the hold, and we've released the spinlock. So pick off the
2125: // next datagram to be sent, and ship it.
2126: //
2127:
2128: p = Address->SendDatagramQueue.Flink;
2129: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
2130:
2131: request = CONTAINING_RECORD (p, TP_REQUEST, Linkage);
2132:
2133: //
2134: // If there is no remote Address specified (the Address specified has
2135: // length 0), this is a broadcast datagram. If anything is specified, it
2136: // will be used as a netbios address.
2137: //
2138:
2139: irpSp = IoGetCurrentIrpStackLocation (request->IoRequestPacket);
2140:
2141: remoteTA = ((PTDI_REQUEST_KERNEL_SENDDG)(&irpSp->Parameters))->
2142: SendDatagramInformation->RemoteAddress;
2143:
2144: //
2145: // Build the MAC header. DATAGRAM frames go out as
2146: // single-route source routing.
2147: //
2148:
2149: MacReturnSingleRouteSR(
2150: &DeviceContext->MacInfo,
2151: &SourceRouting,
2152: &SourceRoutingLength);
2153:
2154: MacConstructHeader (
2155: &DeviceContext->MacInfo,
2156: Address->Packet->Header,
2157: DeviceContext->MulticastAddress.Address,
2158: DeviceContext->LocalAddress.Address,
2159: sizeof(ST_HEADER) + request->Buffer2Length,
2160: SourceRouting,
2161: SourceRoutingLength,
2162: &HeaderLength);
2163:
2164: //
2165: // Build the header: 'G', dest, source
2166: //
2167:
2168: StHeader = (PST_HEADER)(&Address->Packet->Header[HeaderLength]);
2169:
2170: StHeader->Signature = ST_SIGNATURE;
2171: StHeader->Command = ST_CMD_DATAGRAM;
2172: StHeader->Flags = 0;
2173:
2174: RtlCopyMemory (StHeader->Source, Address->NetworkName->NetbiosName, 16);
2175:
2176: if (remoteTA->Address[0].AddressLength == 0) {
2177:
2178: //
2179: // A broadcast datagram
2180: //
2181:
2182: RtlZeroMemory (StHeader->Destination, 16);
2183: StHeader->Flags |= ST_FLAGS_BROADCAST;
2184:
2185: } else {
2186:
2187: RtlCopyMemory (StHeader->Destination, remoteTA->Address[0].Address[0].NetbiosName, 16);
2188:
2189: }
2190:
2191: HeaderLength += sizeof(ST_HEADER);
2192:
2193: SendTag = (PSEND_PACKET_TAG)(Address->Packet->NdisPacket->ProtocolReserved);
2194: SendTag->Type = TYPE_G_FRAME;
2195: SendTag->Packet = Address->Packet;
2196: SendTag->Owner = (PVOID)Address;
2197:
2198: //
2199: // Update our statistics for this datagram.
2200: //
2201:
2202: ++DeviceContext->DatagramsSent;
2203: ADD_TO_LARGE_INTEGER(
2204: &DeviceContext->DatagramBytesSent,
2205: request->Buffer2Length,
2206: &DeviceContext->StatisticsSpinLock);
2207:
2208:
2209: //
2210: // Munge the packet length, append the data, and send it.
2211: //
2212:
2213: StSetNdisPacketLength(Address->Packet->NdisPacket, HeaderLength);
2214:
2215: if (request->Buffer2) {
2216: NdisChainBufferAtBack (Address->Packet->NdisPacket, (PNDIS_BUFFER)request->Buffer2);
2217: }
2218:
2219: (VOID)StSendAddressFrame (
2220: Address);
2221:
2222:
2223: //
2224: // The hold will be released in the I/O completion handler.
2225: // At that time, if there is another outstanding datagram
2226: // to send, it will reset the hold and call this routine again.
2227: //
2228:
2229:
2230: } else {
2231:
2232: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
2233: }
2234:
2235: StDereferenceAddress ("Sent datagram", Address); // all done
2236:
2237: return STATUS_SUCCESS;
2238:
2239: } /* StSendDatagramsOnAddress */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.