![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to connobj.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 connobj.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: connobj.c ! 8: ! 9: Abstract: ! 10: ! 11: This module contains code which implements the TP_CONNECTION object. ! 12: Routines are provided to create, destroy, reference, and dereference, ! 13: transport connection objects. ! 14: ! 15: Environment: ! 16: ! 17: Kernel mode ! 18: ! 19: Revision History: ! 20: ! 21: --*/ ! 22: ! 23: #include "st.h" ! 24: ! 25: ! 26: ! 27: VOID ! 28: StAllocateConnection( ! 29: IN PDEVICE_CONTEXT DeviceContext, ! 30: OUT PTP_CONNECTION *TransportConnection ! 31: ) ! 32: ! 33: /*++ ! 34: ! 35: Routine Description: ! 36: ! 37: This routine allocates storage for a transport connection. Some ! 38: minimal initialization is done. ! 39: ! 40: NOTE: This routine is called with the device context spinlock ! 41: held, or at such a time as synchronization is unnecessary. ! 42: ! 43: Arguments: ! 44: ! 45: DeviceContext - the device context for this connection to be ! 46: associated with. ! 47: ! 48: TransportConnection - Pointer to a place where this routine will ! 49: return a pointer to a transport connection structure. Returns ! 50: NULL if the storage cannot be allocated. ! 51: ! 52: Return Value: ! 53: ! 54: None. ! 55: ! 56: --*/ ! 57: ! 58: { ! 59: ! 60: PTP_CONNECTION Connection; ! 61: ! 62: if ((DeviceContext->MemoryLimit != 0) && ! 63: ((DeviceContext->MemoryUsage + sizeof(TP_CONNECTION)) > ! 64: DeviceContext->MemoryLimit)) { ! 65: PANIC("ST: Could not allocate connection: limit\n"); ! 66: StWriteResourceErrorLog (DeviceContext, sizeof(TP_CONNECTION), 103); ! 67: *TransportConnection = NULL; ! 68: return; ! 69: } ! 70: ! 71: Connection = (PTP_CONNECTION)ExAllocatePool (NonPagedPool, ! 72: sizeof (TP_CONNECTION)); ! 73: if (Connection == NULL) { ! 74: PANIC("ST: Could not allocate connection: no pool\n"); ! 75: StWriteResourceErrorLog (DeviceContext, sizeof(TP_CONNECTION), 203); ! 76: *TransportConnection = NULL; ! 77: return; ! 78: } ! 79: RtlZeroMemory (Connection, sizeof(TP_CONNECTION)); ! 80: ! 81: DeviceContext->MemoryUsage += sizeof(TP_CONNECTION); ! 82: ++DeviceContext->ConnectionAllocated; ! 83: ! 84: Connection->Type = ST_CONNECTION_SIGNATURE; ! 85: Connection->Size = sizeof (TP_CONNECTION); ! 86: ! 87: Connection->Provider = DeviceContext; ! 88: Connection->ProviderInterlock = &DeviceContext->Interlock; ! 89: KeInitializeSpinLock (&Connection->SpinLock); ! 90: ! 91: InitializeListHead (&Connection->LinkList); ! 92: InitializeListHead (&Connection->AddressFileList); ! 93: InitializeListHead (&Connection->AddressList); ! 94: InitializeListHead (&Connection->PacketWaitLinkage); ! 95: InitializeListHead (&Connection->PacketizeLinkage); ! 96: InitializeListHead (&Connection->SendQueue); ! 97: InitializeListHead (&Connection->ReceiveQueue); ! 98: InitializeListHead (&Connection->InProgressRequest); ! 99: ! 100: StAddSendPacket (DeviceContext); ! 101: ! 102: *TransportConnection = Connection; ! 103: ! 104: } /* StAllocateConnection */ ! 105: ! 106: ! 107: VOID ! 108: StDeallocateConnection( ! 109: IN PDEVICE_CONTEXT DeviceContext, ! 110: IN PTP_CONNECTION TransportConnection ! 111: ) ! 112: ! 113: /*++ ! 114: ! 115: Routine Description: ! 116: ! 117: This routine frees storage for a transport connection. ! 118: ! 119: NOTE: This routine is called with the device context spinlock ! 120: held, or at such a time as synchronization is unnecessary. ! 121: ! 122: Arguments: ! 123: ! 124: DeviceContext - the device context for this connection to be ! 125: associated with. ! 126: ! 127: TransportConnection - Pointer to a transport connection structure. ! 128: ! 129: Return Value: ! 130: ! 131: None. ! 132: ! 133: --*/ ! 134: ! 135: { ! 136: ! 137: ExFreePool (TransportConnection); ! 138: --DeviceContext->ConnectionAllocated; ! 139: DeviceContext->MemoryUsage -= sizeof(TP_CONNECTION); ! 140: ! 141: StRemoveSendPacket (DeviceContext); ! 142: ! 143: } /* StDeallocateConnection */ ! 144: ! 145: ! 146: NTSTATUS ! 147: StCreateConnection( ! 148: IN PDEVICE_CONTEXT DeviceContext, ! 149: OUT PTP_CONNECTION *TransportConnection ! 150: ) ! 151: ! 152: /*++ ! 153: ! 154: Routine Description: ! 155: ! 156: This routine creates a transport connection. The reference count in the ! 157: connection is automatically set to 1, and the reference count in the ! 158: DeviceContext is incremented. ! 159: ! 160: Arguments: ! 161: ! 162: Address - the address for this connection to be associated with. ! 163: ! 164: TransportConnection - Pointer to a place where this routine will ! 165: return a pointer to a transport connection structure. ! 166: ! 167: Return Value: ! 168: ! 169: NTSTATUS - status of operation. ! 170: ! 171: --*/ ! 172: ! 173: { ! 174: PTP_CONNECTION Connection; ! 175: KIRQL oldirql; ! 176: PLIST_ENTRY p; ! 177: UINT TempDataLen; ! 178: ! 179: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql); ! 180: ! 181: p = RemoveHeadList (&DeviceContext->ConnectionPool); ! 182: if (p == &DeviceContext->ConnectionPool) { ! 183: ! 184: if ((DeviceContext->ConnectionMaxAllocated == 0) || ! 185: (DeviceContext->ConnectionAllocated < DeviceContext->ConnectionMaxAllocated)) { ! 186: ! 187: StAllocateConnection (DeviceContext, &Connection); ! 188: ! 189: } else { ! 190: ! 191: StWriteResourceErrorLog (DeviceContext, sizeof(TP_CONNECTION), 403); ! 192: Connection = NULL; ! 193: ! 194: } ! 195: ! 196: if (Connection == NULL) { ! 197: ++DeviceContext->ConnectionExhausted; ! 198: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql); ! 199: PANIC ("StCreateConnection: Could not allocate connection object!\n"); ! 200: return STATUS_INSUFFICIENT_RESOURCES; ! 201: } ! 202: ! 203: } else { ! 204: ! 205: Connection = CONTAINING_RECORD (p, TP_CONNECTION, LinkList); ! 206: ! 207: } ! 208: ! 209: ++DeviceContext->ConnectionInUse; ! 210: if (DeviceContext->ConnectionInUse > DeviceContext->ConnectionMaxInUse) { ! 211: ++DeviceContext->ConnectionMaxInUse; ! 212: } ! 213: ! 214: DeviceContext->ConnectionTotal += DeviceContext->ConnectionInUse; ! 215: ++DeviceContext->ConnectionSamples; ! 216: ! 217: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql); ! 218: ! 219: ! 220: // ! 221: // We have two references; one is for creation, and the ! 222: // other is a temporary one so that the connection won't ! 223: // go away before the creator has a chance to access it. ! 224: // ! 225: ! 226: Connection->SpecialRefCount = 1; ! 227: Connection->ReferenceCount = -1; // this is -1 based ! 228: ! 229: // ! 230: // Initialize the request queues & components of this connection. ! 231: // ! 232: ! 233: InitializeListHead (&Connection->SendQueue); ! 234: InitializeListHead (&Connection->ReceiveQueue); ! 235: InitializeListHead (&Connection->InProgressRequest); ! 236: InitializeListHead (&Connection->AddressList); ! 237: InitializeListHead (&Connection->AddressFileList); ! 238: Connection->SpecialReceiveIrp = (PIRP)NULL; ! 239: Connection->Flags = 0; ! 240: Connection->Flags2 = 0; ! 241: Connection->MessageBytesReceived = (USHORT)0; // no data yet ! 242: Connection->MessageBytesAcked = (USHORT)0; ! 243: Connection->Context = NULL; // no context yet. ! 244: Connection->Status = STATUS_PENDING; // default StStopConnection status. ! 245: Connection->SendState = CONNECTION_SENDSTATE_IDLE; ! 246: Connection->CurrentReceiveRequest = (PTP_REQUEST)NULL; ! 247: Connection->DisconnectIrp = (PIRP)NULL; ! 248: Connection->CloseIrp = (PIRP)NULL; ! 249: Connection->AddressFile = NULL; ! 250: Connection->IndicationInProgress = FALSE; ! 251: ! 252: MacReturnMaxDataSize( ! 253: &DeviceContext->MacInfo, ! 254: NULL, ! 255: 0, ! 256: DeviceContext->MaxSendPacketSize, ! 257: &TempDataLen); ! 258: Connection->MaximumDataSize = TempDataLen - sizeof(ST_HEADER); ! 259: ! 260: StReferenceDeviceContext ("Create Connection", DeviceContext); ! 261: ! 262: *TransportConnection = Connection; // return the connection. ! 263: ! 264: return STATUS_SUCCESS; ! 265: } /* StCreateConnection */ ! 266: ! 267: ! 268: NTSTATUS ! 269: StVerifyConnectionObject ( ! 270: IN PTP_CONNECTION Connection ! 271: ) ! 272: ! 273: /*++ ! 274: ! 275: Routine Description: ! 276: ! 277: This routine is called to verify that the pointer given us in a file ! 278: object is in fact a valid connection object. ! 279: ! 280: Arguments: ! 281: ! 282: Connection - potential pointer to a TP_CONNECTION object. ! 283: ! 284: Return Value: ! 285: ! 286: STATUS_SUCCESS if all is well; STATUS_INVALID_CONNECTION otherwise ! 287: ! 288: --*/ ! 289: ! 290: { ! 291: KIRQL oldirql; ! 292: NTSTATUS status = STATUS_SUCCESS; ! 293: ! 294: // ! 295: // try to verify the connection signature. If the signature is valid, ! 296: // get the connection spinlock, check its state, and increment the ! 297: // reference count if it's ok to use it. Note that being in the stopping ! 298: // state is an OK place to be and reference the connection; we can ! 299: // disassociate the address while running down. ! 300: // ! 301: ! 302: try { ! 303: ! 304: if ((Connection->Size == sizeof (TP_CONNECTION)) && ! 305: (Connection->Type == ST_CONNECTION_SIGNATURE)) { ! 306: ! 307: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql); ! 308: ! 309: if ((Connection->Flags2 & CONNECTION_FLAGS2_CLOSING) == 0) { ! 310: ! 311: StReferenceConnection ("Verify Temp Use", Connection); ! 312: ! 313: } else { ! 314: ! 315: status = STATUS_INVALID_CONNECTION; ! 316: } ! 317: ! 318: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql); ! 319: ! 320: } else { ! 321: ! 322: status = STATUS_INVALID_CONNECTION; ! 323: } ! 324: ! 325: } except(EXCEPTION_EXECUTE_HANDLER) { ! 326: ! 327: return GetExceptionCode(); ! 328: } ! 329: ! 330: return status; ! 331: ! 332: } ! 333: ! 334: ! 335: NTSTATUS ! 336: StDestroyAssociation( ! 337: IN PTP_CONNECTION TransportConnection ! 338: ) ! 339: ! 340: /*++ ! 341: ! 342: Routine Description: ! 343: ! 344: This routine destroys the association between a transport connection and ! 345: the address it was formerly associated with. The only action taken is ! 346: to disassociate the address and remove the connection from all address ! 347: queues. ! 348: ! 349: This routine is only called by StDereferenceConnection. The reason for ! 350: this is that there may be multiple streams of execution which are ! 351: simultaneously referencing the same connection object, and it should ! 352: not be deleted out from under an interested stream of execution. ! 353: ! 354: Arguments: ! 355: ! 356: TransportConnection - Pointer to a transport connection structure to ! 357: be destroyed. ! 358: ! 359: Return Value: ! 360: ! 361: NTSTATUS - status of operation. ! 362: ! 363: --*/ ! 364: ! 365: { ! 366: KIRQL oldirql, oldirql2; ! 367: PTP_ADDRESS_FILE addressFile; ! 368: ! 369: ! 370: ACQUIRE_SPIN_LOCK (&TransportConnection->SpinLock, &oldirql2); ! 371: if ((TransportConnection->Flags2 & CONNECTION_FLAGS2_ASSOCIATED) == 0) { ! 372: RELEASE_SPIN_LOCK (&TransportConnection->SpinLock, oldirql2); ! 373: return STATUS_SUCCESS; ! 374: } else { ! 375: TransportConnection->Flags2 &= ~CONNECTION_FLAGS2_ASSOCIATED; ! 376: RELEASE_SPIN_LOCK (&TransportConnection->SpinLock, oldirql2); ! 377: } ! 378: ! 379: addressFile = TransportConnection->AddressFile; ! 380: ! 381: // ! 382: // Delink this connection from its associated address connection ! 383: // database. To do this we must spin lock on the address object as ! 384: // well as on the connection, ! 385: // ! 386: ! 387: ACQUIRE_SPIN_LOCK (&addressFile->Address->SpinLock, &oldirql); ! 388: ACQUIRE_SPIN_LOCK (&TransportConnection->SpinLock, &oldirql2); ! 389: RemoveEntryList (&TransportConnection->AddressFileList); ! 390: RemoveEntryList (&TransportConnection->AddressList); ! 391: ! 392: InitializeListHead (&TransportConnection->AddressList); ! 393: InitializeListHead (&TransportConnection->AddressFileList); ! 394: ! 395: // ! 396: // remove the association between the address and the connection. ! 397: // ! 398: ! 399: TransportConnection->AddressFile = NULL; ! 400: ! 401: RELEASE_SPIN_LOCK (&TransportConnection->SpinLock, oldirql2); ! 402: RELEASE_SPIN_LOCK (&addressFile->Address->SpinLock, oldirql); ! 403: ! 404: // ! 405: // and remove a reference to the address ! 406: // ! 407: ! 408: StDereferenceAddress ("Destroy association", addressFile->Address); ! 409: ! 410: ! 411: return STATUS_SUCCESS; ! 412: ! 413: } /* StDestroyAssociation */ ! 414: ! 415: ! 416: NTSTATUS ! 417: StIndicateDisconnect( ! 418: IN PTP_CONNECTION TransportConnection ! 419: ) ! 420: ! 421: /*++ ! 422: ! 423: Routine Description: ! 424: ! 425: This routine indicates a remote disconnection on this connection if it ! 426: is necessary to do so. No other action is taken here. ! 427: ! 428: This routine is only called by StDereferenceConnection. The reason for ! 429: this is that there may be multiple streams of execution which are ! 430: simultaneously referencing the same connection object, and it should ! 431: not be deleted out from under an interested stream of execution. ! 432: ! 433: Arguments: ! 434: ! 435: TransportConnection - Pointer to a transport connection structure to ! 436: be destroyed. ! 437: ! 438: Return Value: ! 439: ! 440: NTSTATUS - status of operation. ! 441: ! 442: --*/ ! 443: ! 444: { ! 445: PTP_ADDRESS_FILE addressFile; ! 446: PDEVICE_CONTEXT DeviceContext; ! 447: ULONG DisconnectReason; ! 448: PIRP DisconnectIrp; ! 449: KIRQL oldirql; ! 450: ! 451: ACQUIRE_SPIN_LOCK (&TransportConnection->SpinLock, &oldirql); ! 452: ! 453: if (((TransportConnection->Flags2 & CONNECTION_FLAGS2_REQ_COMPLETED) != 0)) { ! 454: ! 455: // ! 456: // Turn off all but the still-relevant bits in the flags. ! 457: // ! 458: ! 459: ASSERT (TransportConnection->Flags & CONNECTION_FLAGS_STOPPING); ! 460: ! 461: TransportConnection->Flags = CONNECTION_FLAGS_STOPPING; ! 462: TransportConnection->Flags2 &= ! 463: (CONNECTION_FLAGS2_ASSOCIATED | ! 464: CONNECTION_FLAGS2_DISASSOCIATED | ! 465: CONNECTION_FLAGS2_CLOSING); ! 466: ! 467: // ! 468: // Clean up other stuff -- basically everything gets ! 469: // done here except for the flags and the status, since ! 470: // they are used to block other requests. When the connection ! 471: // is given back to us (in Accept, Connect, or Listen) ! 472: // they are cleared. ! 473: // ! 474: ! 475: TransportConnection->MessageBytesReceived = (USHORT)0; // no data yet ! 476: TransportConnection->MessageBytesAcked = (USHORT)0; ! 477: ! 478: TransportConnection->CurrentReceiveRequest = (PTP_REQUEST)NULL; ! 479: ! 480: DisconnectIrp = TransportConnection->DisconnectIrp; ! 481: TransportConnection->DisconnectIrp = (PIRP)NULL; ! 482: ! 483: RELEASE_SPIN_LOCK (&TransportConnection->SpinLock, oldirql); ! 484: ! 485: ! 486: DeviceContext = TransportConnection->Provider; ! 487: addressFile = TransportConnection->AddressFile; ! 488: ! 489: ! 490: // ! 491: // If this connection was stopped by a call to TdiDisconnect, ! 492: // we have to complete that. We save the Irp so we can return ! 493: // the connection to the pool before we complete the request. ! 494: // ! 495: ! 496: ! 497: if (DisconnectIrp != (PIRP)NULL) { ! 498: ! 499: // ! 500: // Now complete the IRP if needed. This will be non-null ! 501: // only if TdiDisconnect was called, and we have not ! 502: // yet completed it. ! 503: // ! 504: ! 505: DisconnectIrp->IoStatus.Information = 0; ! 506: DisconnectIrp->IoStatus.Status = STATUS_SUCCESS; ! 507: IoCompleteRequest (DisconnectIrp, IO_NETWORK_INCREMENT); ! 508: ! 509: } else if ((TransportConnection->Status != STATUS_LOCAL_DISCONNECT) && ! 510: (addressFile->RegisteredDisconnectHandler == TRUE)) { ! 511: ! 512: // ! 513: // This was a remotely spawned disconnect, so indicate that ! 514: // to our client. Note that in the comparison above we ! 515: // check the status first, since if it is LOCAL_DISCONNECT ! 516: // addressFile may be NULL (BUGBUG: This is sort of a hack ! 517: // for PDK2, we should really indicate the disconnect inside ! 518: // StStopConnection, where we know addressFile is valid). ! 519: // ! 520: ! 521: // ! 522: // if the disconnection was remotely spawned, then indicate ! 523: // disconnect. In the case that a disconnect was issued at ! 524: // the same time as the connection went down remotely, we ! 525: // won't do this because DisconnectIrp will be non-NULL. ! 526: // ! 527: ! 528: // ! 529: // Invoke the user's disconnection event handler, if any. We do this here ! 530: // so that any outstanding sends will complete before we tear down the ! 531: // connection. ! 532: // ! 533: ! 534: DisconnectReason = 0; ! 535: if (TransportConnection->Flags & CONNECTION_FLAGS_ABORT) { ! 536: DisconnectReason |= TDI_DISCONNECT_ABORT; ! 537: } ! 538: if (TransportConnection->Flags & CONNECTION_FLAGS_DESTROY) { ! 539: DisconnectReason |= TDI_DISCONNECT_RELEASE; ! 540: } ! 541: ! 542: (*addressFile->DisconnectHandler)( ! 543: addressFile->DisconnectHandlerContext, ! 544: TransportConnection->Context, ! 545: 0, ! 546: NULL, ! 547: 0, ! 548: NULL, ! 549: DisconnectReason); ! 550: ! 551: } ! 552: ! 553: } else { ! 554: ! 555: // ! 556: // The client does not yet think that this connection ! 557: // is up...generally this happens due to request count ! 558: // fluctuation during connection setup. ! 559: // ! 560: ! 561: RELEASE_SPIN_LOCK (&TransportConnection->SpinLock, oldirql); ! 562: ! 563: } ! 564: ! 565: ! 566: return STATUS_SUCCESS; ! 567: ! 568: } /* StIndicateDisconnect */ ! 569: ! 570: ! 571: NTSTATUS ! 572: StDestroyConnection( ! 573: IN PTP_CONNECTION TransportConnection ! 574: ) ! 575: ! 576: /*++ ! 577: ! 578: Routine Description: ! 579: ! 580: This routine destroys a transport connection and removes all references ! 581: made by it to other objects in the transport. The connection structure ! 582: is returned to our lookaside list. It is assumed that the caller ! 583: has removed all IRPs from the connections's queues first. ! 584: ! 585: This routine is only called by StDereferenceConnection. The reason for ! 586: this is that there may be multiple streams of execution which are ! 587: simultaneously referencing the same connection object, and it should ! 588: not be deleted out from under an interested stream of execution. ! 589: ! 590: Arguments: ! 591: ! 592: TransportConnection - Pointer to a transport connection structure to ! 593: be destroyed. ! 594: ! 595: Return Value: ! 596: ! 597: NTSTATUS - status of operation. ! 598: ! 599: --*/ ! 600: ! 601: { ! 602: KIRQL oldirql; ! 603: PDEVICE_CONTEXT DeviceContext; ! 604: PIRP CloseIrp; ! 605: ! 606: ! 607: DeviceContext = TransportConnection->Provider; ! 608: ! 609: // ! 610: // Destroy any association that this connection has. ! 611: // ! 612: ! 613: StDestroyAssociation (TransportConnection); ! 614: ! 615: // ! 616: // Clear out any associated nasties hanging around the connection. Note ! 617: // that the current flags are set to STOPPING; this way anyone that may ! 618: // maliciously try to use the connection after it's dead and gone will ! 619: // just get ignored. ! 620: // ! 621: ! 622: TransportConnection->Flags = CONNECTION_FLAGS_STOPPING; ! 623: TransportConnection->Flags2 = CONNECTION_FLAGS2_CLOSING; ! 624: TransportConnection->MessageBytesReceived = (USHORT)0; // no data yet ! 625: TransportConnection->MessageBytesAcked = (USHORT)0; ! 626: ! 627: ! 628: // ! 629: // Now complete the close IRP. This will be set to non-null ! 630: // when CloseConnection was called. ! 631: // ! 632: ! 633: CloseIrp = TransportConnection->CloseIrp; ! 634: ! 635: if (CloseIrp != (PIRP)NULL) { ! 636: ! 637: TransportConnection->CloseIrp = (PIRP)NULL; ! 638: CloseIrp->IoStatus.Information = 0; ! 639: CloseIrp->IoStatus.Status = STATUS_SUCCESS; ! 640: IoCompleteRequest (CloseIrp, IO_NETWORK_INCREMENT); ! 641: ! 642: } ! 643: ! 644: // ! 645: // Return the connection to the provider's pool. ! 646: // ! 647: ! 648: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql); ! 649: ! 650: DeviceContext->ConnectionTotal += DeviceContext->ConnectionInUse; ! 651: ++DeviceContext->ConnectionSamples; ! 652: --DeviceContext->ConnectionInUse; ! 653: ! 654: if ((DeviceContext->ConnectionAllocated - DeviceContext->ConnectionInUse) > ! 655: DeviceContext->ConnectionInitAllocated) { ! 656: StDeallocateConnection (DeviceContext, TransportConnection); ! 657: } else { ! 658: InsertTailList (&DeviceContext->ConnectionPool, &TransportConnection->LinkList); ! 659: } ! 660: ! 661: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql); ! 662: ! 663: StDereferenceDeviceContext ("Destroy Connection", DeviceContext); ! 664: ! 665: return STATUS_SUCCESS; ! 666: ! 667: } /* StDestroyConnection */ ! 668: ! 669: ! 670: VOID ! 671: StRefConnection( ! 672: IN PTP_CONNECTION TransportConnection ! 673: ) ! 674: ! 675: /*++ ! 676: ! 677: Routine Description: ! 678: ! 679: This routine increments the reference count on a transport connection. ! 680: ! 681: Arguments: ! 682: ! 683: TransportConnection - Pointer to a transport connection object. ! 684: ! 685: Return Value: ! 686: ! 687: none. ! 688: ! 689: --*/ ! 690: ! 691: { ! 692: INTERLOCKED_RESULT result; ! 693: ! 694: result = ExInterlockedIncrementLong ( ! 695: &TransportConnection->ReferenceCount, ! 696: TransportConnection->ProviderInterlock); ! 697: ! 698: if (result == ResultZero) { ! 699: ! 700: // ! 701: // The first increment causes us to increment the ! 702: // "ref count is not zero" special ref. ! 703: // ! 704: ! 705: ExInterlockedAddUlong( ! 706: (PULONG)(&TransportConnection->SpecialRefCount), ! 707: 1, ! 708: TransportConnection->ProviderInterlock); ! 709: ! 710: } ! 711: ! 712: ASSERT (result != ResultNegative); ! 713: ! 714: } /* StRefConnection */ ! 715: ! 716: ! 717: VOID ! 718: StDerefConnection( ! 719: IN PTP_CONNECTION TransportConnection ! 720: ) ! 721: ! 722: /*++ ! 723: ! 724: Routine Description: ! 725: ! 726: This routine dereferences a transport connection by decrementing the ! 727: reference count contained in the structure. If, after being ! 728: decremented, the reference count is zero, then this routine calls ! 729: StDestroyConnection to remove it from the system. ! 730: ! 731: Arguments: ! 732: ! 733: TransportConnection - Pointer to a transport connection object. ! 734: ! 735: Return Value: ! 736: ! 737: none. ! 738: ! 739: --*/ ! 740: ! 741: { ! 742: INTERLOCKED_RESULT result; ! 743: ! 744: result = ExInterlockedDecrementLong ( ! 745: &TransportConnection->ReferenceCount, ! 746: TransportConnection->ProviderInterlock); ! 747: ! 748: // ! 749: // If all the normal references to this connection are gone, then ! 750: // we can remove the special reference that stood for ! 751: // "the regular ref count is non-zero". ! 752: // ! 753: ! 754: if (result == ResultNegative) { ! 755: ! 756: // ! 757: // If the refcount is -1, then we need to indicate ! 758: // disconnect. However, we need to ! 759: // do this before we actually do the special deref, since ! 760: // otherwise the connection might go away while we ! 761: // are doing that. ! 762: // ! 763: ! 764: StIndicateDisconnect (TransportConnection); ! 765: ! 766: // ! 767: // Now it is OK to let the connection go away. ! 768: // ! 769: ! 770: StDereferenceConnectionSpecial ("Regular ref gone", TransportConnection); ! 771: ! 772: } ! 773: ! 774: } /* StDerefConnection */ ! 775: ! 776: ! 777: VOID ! 778: StDerefConnectionSpecial( ! 779: IN PTP_CONNECTION TransportConnection ! 780: ) ! 781: ! 782: /*++ ! 783: ! 784: Routine Description: ! 785: ! 786: This routines completes the dereferencing of a connection. ! 787: It may be called any time, but it does not do its work until ! 788: the regular reference count is also 0. ! 789: ! 790: Arguments: ! 791: ! 792: TransportConnection - Pointer to a transport connection object. ! 793: ! 794: Return Value: ! 795: ! 796: none. ! 797: ! 798: --*/ ! 799: ! 800: { ! 801: KIRQL oldirql; ! 802: ! 803: ACQUIRE_SPIN_LOCK (TransportConnection->ProviderInterlock, &oldirql); ! 804: ! 805: --TransportConnection->SpecialRefCount; ! 806: ! 807: if ((TransportConnection->SpecialRefCount == 0) && ! 808: (TransportConnection->ReferenceCount == -1)) { ! 809: ! 810: // ! 811: // If we have deleted all references to this connection, then we can ! 812: // destroy the object. It is okay to have already released the spin ! 813: // lock at this point because there is no possible way that another ! 814: // stream of execution has access to the connection any longer. ! 815: // ! 816: ! 817: RELEASE_SPIN_LOCK (TransportConnection->ProviderInterlock, oldirql); ! 818: ! 819: StDestroyConnection (TransportConnection); ! 820: ! 821: } else { ! 822: ! 823: RELEASE_SPIN_LOCK (TransportConnection->ProviderInterlock, oldirql); ! 824: ! 825: } ! 826: ! 827: } /* StDerefConnectionSpecial */ ! 828: ! 829: ! 830: PTP_CONNECTION ! 831: StFindConnection( ! 832: IN PDEVICE_CONTEXT DeviceContext, ! 833: IN PUCHAR LocalName, ! 834: IN PUCHAR RemoteName ! 835: ) ! 836: ! 837: /*++ ! 838: ! 839: Routine Description: ! 840: ! 841: This routine scans the connections associated with a ! 842: device context, and determines if there is an connection ! 843: associated with the specific remote address on the ! 844: specific local address. ! 845: ! 846: Arguments: ! 847: ! 848: DeviceContext - Pointer to the device context. ! 849: ! 850: LocalName - The 16-character Netbios name of the local address. ! 851: ! 852: RemoteName - The 16-character Netbios name of the remote. ! 853: ! 854: Return Value: ! 855: ! 856: The connection if one is found, NULL otherwise. ! 857: ! 858: --*/ ! 859: ! 860: { ! 861: KIRQL oldirql; ! 862: PLIST_ENTRY Flink; ! 863: PTP_ADDRESS Address; ! 864: BOOLEAN MatchedAddress = FALSE; ! 865: PTP_CONNECTION Connection; ! 866: ! 867: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql); ! 868: ! 869: for (Flink = DeviceContext->AddressDatabase.Flink; ! 870: Flink != &DeviceContext->AddressDatabase; ! 871: Flink = Flink->Flink) { ! 872: ! 873: Address = CONTAINING_RECORD ( ! 874: Flink, ! 875: TP_ADDRESS, ! 876: Linkage); ! 877: ! 878: if ((Address->Flags & ADDRESS_FLAGS_STOPPING) != 0) { ! 879: continue; ! 880: } ! 881: ! 882: if (StMatchNetbiosAddress (Address, LocalName)) { ! 883: ! 884: StReferenceAddress ("Looking for connection", Address); // prevent address from being destroyed. ! 885: MatchedAddress = TRUE; ! 886: break; ! 887: ! 888: } ! 889: } ! 890: ! 891: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql); ! 892: ! 893: if (!MatchedAddress) { ! 894: return NULL; ! 895: } ! 896: ! 897: Connection = StLookupRemoteName (Address, RemoteName); ! 898: ! 899: StDereferenceAddress ("Looking for connection", Address); ! 900: ! 901: return Connection; ! 902: ! 903: } ! 904: ! 905: ! 906: PTP_CONNECTION ! 907: StLookupConnectionByContext( ! 908: IN PTP_ADDRESS Address, ! 909: IN CONNECTION_CONTEXT ConnectionContext ! 910: ) ! 911: ! 912: /*++ ! 913: ! 914: Routine Description: ! 915: ! 916: This routine accepts a connection identifier and an address and ! 917: returns a pointer to the connection object, TP_CONNECTION. If the ! 918: connection identifier is not found on the address, then NULL is returned. ! 919: This routine automatically increments the reference count of the ! 920: TP_CONNECTION structure if it is found. It is assumed that the ! 921: TP_ADDRESS structure is already held with a reference count. ! 922: ! 923: BUGBUG: Should the ConnectionDatabase go in the address file? ! 924: ! 925: Arguments: ! 926: ! 927: Address - Pointer to a transport address object. ! 928: ! 929: ConnectionContext - Connection Context for this address. ! 930: ! 931: Return Value: ! 932: ! 933: A pointer to the connection we found ! 934: ! 935: --*/ ! 936: ! 937: { ! 938: KIRQL oldirql, oldirql1; ! 939: PLIST_ENTRY p; ! 940: PTP_CONNECTION Connection; ! 941: ! 942: // ! 943: // Currently, this implementation is inefficient, but brute force so ! 944: // that a system can get up and running. Later, a cache of the mappings ! 945: // of popular connection id's and pointers to their TP_CONNECTION structures ! 946: // will be searched first. ! 947: // ! 948: ! 949: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql); ! 950: ! 951: for (p=Address->ConnectionDatabase.Flink; ! 952: p != &Address->ConnectionDatabase; ! 953: p=p->Flink) { ! 954: ! 955: ! 956: Connection = CONTAINING_RECORD (p, TP_CONNECTION, AddressList); ! 957: ! 958: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql1); ! 959: ! 960: if ((Connection->Context == ConnectionContext) && ! 961: ((Connection->Flags2 & CONNECTION_FLAGS2_CLOSING) == 0)) { ! 962: // This reference is removed by the calling function ! 963: StReferenceConnection ("Lookup up for request", Connection); ! 964: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql1); ! 965: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql); ! 966: ! 967: return Connection; ! 968: } ! 969: ! 970: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql1); ! 971: ! 972: } ! 973: ! 974: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql); ! 975: ! 976: return NULL; ! 977: ! 978: } /* StLookupConnectionByContext */ ! 979: ! 980: ! 981: PTP_CONNECTION ! 982: StLookupListeningConnection( ! 983: IN PTP_ADDRESS Address ! 984: ) ! 985: ! 986: /*++ ! 987: ! 988: Routine Description: ! 989: ! 990: This routine scans the connection database on an address to find ! 991: a TP_CONNECTION object which has CONNECTION_FLAGS_WAIT_NQ ! 992: flag set. It returns a pointer to the found connection object (and ! 993: simultaneously resets the flag) or NULL if it could not be found. ! 994: The reference count is also incremented atomically on the connection. ! 995: ! 996: Arguments: ! 997: ! 998: Address - Pointer to a transport address object. ! 999: ! 1000: Return Value: ! 1001: ! 1002: NTSTATUS - status of operation. ! 1003: ! 1004: --*/ ! 1005: ! 1006: { ! 1007: KIRQL oldirql, oldirql1; ! 1008: PTP_CONNECTION Connection; ! 1009: PLIST_ENTRY p; ! 1010: ! 1011: ! 1012: ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql); ! 1013: ! 1014: for (p=Address->ConnectionDatabase.Flink; ! 1015: p != &Address->ConnectionDatabase; ! 1016: p=p->Flink) { ! 1017: ! 1018: ! 1019: Connection = CONTAINING_RECORD (p, TP_CONNECTION, AddressList); ! 1020: if (Connection->Flags & CONNECTION_FLAGS_WAIT_LISTEN) { ! 1021: ! 1022: // This reference is removed by the calling function ! 1023: StReferenceConnection ("Found Listening", Connection); ! 1024: ! 1025: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql1); ! 1026: Connection->Flags &= ~CONNECTION_FLAGS_WAIT_LISTEN; ! 1027: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql1); ! 1028: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql); ! 1029: ! 1030: return Connection; ! 1031: } ! 1032: ! 1033: } ! 1034: ! 1035: RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql); ! 1036: ! 1037: return NULL; ! 1038: ! 1039: } /* StLookupListeningConnection */ ! 1040: ! 1041: ! 1042: VOID ! 1043: StStopConnection( ! 1044: IN PTP_CONNECTION Connection, ! 1045: IN NTSTATUS Status ! 1046: ) ! 1047: ! 1048: /*++ ! 1049: ! 1050: Routine Description: ! 1051: ! 1052: This routine is called to terminate all activity on a connection and ! 1053: destroy the object. This is done in a graceful manner; i.e., all ! 1054: outstanding requests are terminated by cancelling them, etc. It is ! 1055: assumed that the caller has a reference to this connection object, ! 1056: but this routine will do the dereference for the one issued at creation ! 1057: time. ! 1058: ! 1059: Orderly release is a function of this routine, but it is not a provided ! 1060: service of this transport provider, so there is no code to do it here. ! 1061: ! 1062: Arguments: ! 1063: ! 1064: Connection - Pointer to a TP_CONNECTION object. ! 1065: ! 1066: Status - The status that caused us to stop the connection. This ! 1067: will determine what status pending requests are aborted with, ! 1068: and also how we proceed during the stop (whether to send a ! 1069: session end, and whether to indicate disconnect). ! 1070: ! 1071: Return Value: ! 1072: ! 1073: none. ! 1074: ! 1075: --*/ ! 1076: ! 1077: { ! 1078: KIRQL oldirql, oldirql1, cancelirql; ! 1079: PLIST_ENTRY p; ! 1080: PIRP Irp; ! 1081: PTP_REQUEST Request; ! 1082: ULONG DisconnectReason; ! 1083: PULONG StopCounter; ! 1084: PDEVICE_CONTEXT DeviceContext; ! 1085: BOOLEAN WasConnected; ! 1086: ! 1087: ! 1088: DeviceContext = Connection->Provider; ! 1089: ! 1090: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql); ! 1091: if (!(Connection->Flags & CONNECTION_FLAGS_STOPPING)) { ! 1092: ! 1093: // ! 1094: // We are stopping the connection, record statistics ! 1095: // about it. ! 1096: // ! 1097: ! 1098: if (Connection->Flags & CONNECTION_FLAGS_READY) { ! 1099: ! 1100: DECREMENT_COUNTER (DeviceContext, OpenConnections); ! 1101: WasConnected = TRUE; ! 1102: ! 1103: } else { ! 1104: ! 1105: WasConnected = FALSE; ! 1106: ! 1107: } ! 1108: ! 1109: Connection->Flags &= ~CONNECTION_FLAGS_READY; // no longer open for business ! 1110: Connection->Flags |= CONNECTION_FLAGS_STOPPING; ! 1111: Connection->Flags2 &= ~CONNECTION_FLAGS2_REMOTE_VALID; ! 1112: Connection->SendState = CONNECTION_SENDSTATE_IDLE; ! 1113: Connection->Status = Status; ! 1114: ! 1115: // ! 1116: // If this connection is waiting to packetize, ! 1117: // remove it from the device context queue it is on. ! 1118: // ! 1119: // NOTE: If the connection is currently in the ! 1120: // packetize queue, it will eventually go to get ! 1121: // packetized and at that point it will get ! 1122: // removed. ! 1123: // ! 1124: ! 1125: if (Connection->Flags & CONNECTION_FLAGS_SUSPENDED) { ! 1126: ! 1127: ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql1); ! 1128: RemoveEntryList (&Connection->PacketWaitLinkage); ! 1129: RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql1); ! 1130: } ! 1131: ! 1132: ! 1133: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql); ! 1134: ! 1135: IoAcquireCancelSpinLock(&cancelirql); ! 1136: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql); ! 1137: ! 1138: ! 1139: // ! 1140: // Run down all TdiSend requests on this connection. ! 1141: // ! 1142: ! 1143: while (TRUE) { ! 1144: p = RemoveHeadList (&Connection->SendQueue); ! 1145: if (p == &Connection->SendQueue) { ! 1146: break; ! 1147: } ! 1148: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql); ! 1149: Irp = CONTAINING_RECORD (p, IRP, Tail.Overlay.ListEntry); ! 1150: Irp->CancelRoutine = (PDRIVER_CANCEL)NULL; ! 1151: IoReleaseCancelSpinLock(cancelirql); ! 1152: StCompleteSendIrp (Irp, Connection->Status, 0); ! 1153: IoAcquireCancelSpinLock(&cancelirql); ! 1154: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql); ! 1155: } ! 1156: ! 1157: // ! 1158: // NOTE: We hold the connection spinlock AND the ! 1159: // cancel spinlock here. ! 1160: // ! 1161: ! 1162: Connection->Flags &= ~CONNECTION_FLAGS_ACTIVE_RECEIVE; ! 1163: ! 1164: // ! 1165: // Run down all TdiReceive requests on this connection. ! 1166: // ! 1167: ! 1168: while (TRUE) { ! 1169: p = RemoveHeadList (&Connection->ReceiveQueue); ! 1170: if (p == &Connection->ReceiveQueue) { ! 1171: break; ! 1172: } ! 1173: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql); ! 1174: Request = CONTAINING_RECORD (p, TP_REQUEST, Linkage); ! 1175: Request->IoRequestPacket->CancelRoutine = (PDRIVER_CANCEL)NULL; ! 1176: IoReleaseCancelSpinLock(cancelirql); ! 1177: ! 1178: StCompleteRequest (Request, Connection->Status, 0); ! 1179: IoAcquireCancelSpinLock(&cancelirql); ! 1180: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql); ! 1181: } ! 1182: ! 1183: ! 1184: // ! 1185: // NOTE: We hold the connection spinlock AND the ! 1186: // cancel spinlock here. ! 1187: // ! 1188: ! 1189: // ! 1190: // Run down all TdiConnect/TdiDisconnect/TdiListen requests. ! 1191: // ! 1192: ! 1193: while (TRUE) { ! 1194: p = RemoveHeadList (&Connection->InProgressRequest); ! 1195: if (p == &Connection->InProgressRequest) { ! 1196: break; ! 1197: } ! 1198: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql); ! 1199: Request = CONTAINING_RECORD (p, TP_REQUEST, Linkage); ! 1200: Request->IoRequestPacket->CancelRoutine = (PDRIVER_CANCEL)NULL; ! 1201: IoReleaseCancelSpinLock(cancelirql); ! 1202: ! 1203: StCompleteRequest (Request, Connection->Status, 0); ! 1204: ! 1205: IoAcquireCancelSpinLock(&cancelirql); ! 1206: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql); ! 1207: } ! 1208: ! 1209: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql); ! 1210: IoReleaseCancelSpinLock(cancelirql); ! 1211: ! 1212: // ! 1213: // If we aren't DESTROYing the link, then send a SESSION_END frame ! 1214: // to the remote side. When the SESSION_END frame is acknowleged, ! 1215: // we will decrement the connection's reference count by one, removing ! 1216: // its creation reference. This will cause the connection object to ! 1217: // be disposed of, and will begin running down the link. ! 1218: // DGB: add logic to avoid blowing away link if one doesn't exist yet. ! 1219: // ! 1220: ! 1221: DisconnectReason = 0; ! 1222: if (Connection->Flags & CONNECTION_FLAGS_ABORT) { ! 1223: DisconnectReason |= TDI_DISCONNECT_ABORT; ! 1224: } ! 1225: if (Connection->Flags & CONNECTION_FLAGS_DESTROY) { ! 1226: DisconnectReason |= TDI_DISCONNECT_RELEASE; ! 1227: } ! 1228: ! 1229: // ! 1230: // When this completes we will dereference the connection. ! 1231: // ! 1232: ! 1233: if (WasConnected) { ! 1234: StSendDisconnect (Connection); ! 1235: } ! 1236: ! 1237: ! 1238: switch (Status) { ! 1239: ! 1240: case STATUS_LOCAL_DISCONNECT: ! 1241: StopCounter = &DeviceContext->LocalDisconnects; ! 1242: break; ! 1243: case STATUS_REMOTE_DISCONNECT: ! 1244: StopCounter = &DeviceContext->RemoteDisconnects; ! 1245: break; ! 1246: case STATUS_LINK_FAILED: ! 1247: StopCounter = &DeviceContext->LinkFailures; ! 1248: break; ! 1249: case STATUS_IO_TIMEOUT: ! 1250: StopCounter = &DeviceContext->SessionTimeouts; ! 1251: break; ! 1252: case STATUS_CANCELLED: ! 1253: StopCounter = &DeviceContext->CancelledConnections; ! 1254: break; ! 1255: case STATUS_REMOTE_RESOURCES: ! 1256: StopCounter = &DeviceContext->RemoteResourceFailures; ! 1257: break; ! 1258: case STATUS_INSUFFICIENT_RESOURCES: ! 1259: StopCounter = &DeviceContext->LocalResourceFailures; ! 1260: break; ! 1261: case STATUS_BAD_NETWORK_PATH: ! 1262: StopCounter = &DeviceContext->NotFoundFailures; ! 1263: break; ! 1264: case STATUS_REMOTE_NOT_LISTENING: ! 1265: StopCounter = &DeviceContext->NoListenFailures; ! 1266: break; ! 1267: ! 1268: default: ! 1269: StopCounter = NULL; ! 1270: break; ! 1271: ! 1272: } ! 1273: ! 1274: if (StopCounter != NULL) { ! 1275: ! 1276: ExInterlockedIncrementLong( ! 1277: (PLONG)StopCounter, ! 1278: &DeviceContext->StatisticsInterlock); ! 1279: ! 1280: } ! 1281: ! 1282: ! 1283: // ! 1284: // Note that we've blocked all new requests being queued during the ! 1285: // time we have been in this teardown code; StDestroyConnection also ! 1286: // sets the connection flags to STOPPING when returning the ! 1287: // connection to the queue. This avoids lingerers using non-existent ! 1288: // connections. ! 1289: // ! 1290: ! 1291: } else { ! 1292: ! 1293: // ! 1294: // The connection was already stopping. ! 1295: // ! 1296: ! 1297: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql); ! 1298: ! 1299: } ! 1300: ! 1301: } /* StStopConnection */ ! 1302: ! 1303: ! 1304: VOID ! 1305: StCancelConnection( ! 1306: IN PDEVICE_OBJECT DeviceObject, ! 1307: IN PIRP Irp ! 1308: ) ! 1309: ! 1310: /*++ ! 1311: ! 1312: Routine Description: ! 1313: ! 1314: This routine is called by the I/O system to cancel a connect ! 1315: or a listen. It is simple since there can only be one of these ! 1316: active on a connection; we just stop the connection, the IRP ! 1317: will get completed as part of normal session teardown. ! 1318: ! 1319: NOTE: This routine is called with the CancelSpinLock held and ! 1320: is responsible for releasing it. ! 1321: ! 1322: Arguments: ! 1323: ! 1324: DeviceObject - Pointer to the device object for this driver. ! 1325: ! 1326: Irp - Pointer to the request packet representing the I/O request. ! 1327: ! 1328: Return Value: ! 1329: ! 1330: none. ! 1331: ! 1332: --*/ ! 1333: ! 1334: { ! 1335: KIRQL oldirql; ! 1336: PIO_STACK_LOCATION IrpSp; ! 1337: PTP_CONNECTION Connection; ! 1338: PTP_REQUEST Request; ! 1339: PLIST_ENTRY p; ! 1340: ! 1341: UNREFERENCED_PARAMETER (DeviceObject); ! 1342: ! 1343: // ! 1344: // Get a pointer to the current stack location in the IRP. This is where ! 1345: // the function codes and parameters are stored. ! 1346: // ! 1347: ! 1348: IrpSp = IoGetCurrentIrpStackLocation (Irp); ! 1349: ! 1350: ASSERT ((IrpSp->MajorFunction == IRP_MJ_INTERNAL_DEVICE_CONTROL) && ! 1351: (IrpSp->MinorFunction == TDI_CONNECT || IrpSp->MinorFunction == TDI_LISTEN)); ! 1352: ! 1353: Connection = IrpSp->FileObject->FsContext; ! 1354: ! 1355: // ! 1356: // Since this IRP is still in the cancellable state, we know ! 1357: // that the connection is still around (although it may be in ! 1358: // the process of being torn down). ! 1359: // ! 1360: ! 1361: ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql); ! 1362: StReferenceConnection ("Cancelling Send", Connection); ! 1363: ! 1364: p = RemoveHeadList (&Connection->InProgressRequest); ! 1365: ASSERT (p != &Connection->InProgressRequest); ! 1366: ! 1367: RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql); ! 1368: ! 1369: Request = CONTAINING_RECORD (p, TP_REQUEST, Linkage); ! 1370: ASSERT (Request->IoRequestPacket == Irp); ! 1371: Request->IoRequestPacket->CancelRoutine = (PDRIVER_CANCEL)NULL; ! 1372: ! 1373: IoReleaseCancelSpinLock(Irp->CancelIrql); ! 1374: ! 1375: StCompleteRequest (Request, STATUS_CANCELLED, 0); ! 1376: StStopConnection (Connection, STATUS_CANCELLED); ! 1377: ! 1378: StDereferenceConnection ("Cancel done", Connection); ! 1379: ! 1380: } ! 1381:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.