![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to connect.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 connect.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: connect.c ! 8: ! 9: Abstract: ! 10: ! 11: This module contains code which performs the following TDI services: ! 12: ! 13: o TdiAccept ! 14: o TdiListen ! 15: o TdiConnect ! 16: o TdiDisconnect ! 17: o TdiAssociateAddress ! 18: o TdiDisassociateAddress ! 19: o OpenConnection ! 20: o CloseConnection ! 21: ! 22: Environment: ! 23: ! 24: Kernel mode ! 25: ! 26: Revision History: ! 27: ! 28: --*/ ! 29: ! 30: #include "st.h" ! 31: ! 32: ! 33: NTSTATUS ! 34: StTdiAccept( ! 35: IN PIRP Irp ! 36: ) ! 37: ! 38: /*++ ! 39: ! 40: Routine Description: ! 41: ! 42: This routine performs the TdiAccept request for the transport provider. ! 43: ! 44: Arguments: ! 45: ! 46: Irp - Pointer to the I/O Request Packet for this request. ! 47: ! 48: Return Value: ! 49: ! 50: NTSTATUS - status of operation. ! 51: ! 52: --*/ ! 53: ! 54: { ! 55: PTP_CONNECTION connection; ! 56: PIO_STACK_LOCATION irpSp; ! 57: KIRQL oldirql; ! 58: NTSTATUS status; ! 59: ! 60: // ! 61: // Get the connection this is associated with; if there is none, get out. ! 62: // ! 63: ! 64: irpSp = IoGetCurrentIrpStackLocation (Irp); ! 65: ! 66: connection = irpSp->FileObject->FsContext; ! 67: ! 68: // ! 69: // This adds a connection reference if successful. ! 70: // ! 71: ! 72: status = StVerifyConnectionObject (connection); ! 73: ! 74: if (!NT_SUCCESS (status)) { ! 75: return status; ! 76: } ! 77: ! 78: // ! 79: // just set the connection flags to allow reads and writes to proceed. ! 80: // ! 81: ! 82: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql); ! 83: ! 84: // ! 85: // Turn off the stopping flag for this connection. ! 86: // ! 87: ! 88: connection->Flags &= ~CONNECTION_FLAGS_STOPPING; ! 89: connection->Status = STATUS_PENDING; ! 90: ! 91: connection->Flags2 |= CONNECTION_FLAGS2_ACCEPTED; ! 92: ! 93: ! 94: if (connection->AddressFile->ConnectIndicationInProgress) { ! 95: connection->Flags2 |= CONNECTION_FLAGS2_INDICATING; ! 96: } ! 97: ! 98: if ((connection->Flags2 & CONNECTION_FLAGS2_WAIT_ACCEPT) != 0) { ! 99: ! 100: // ! 101: // We previously completed a listen, now the user is ! 102: // coming back with an accept, Set this flag to allow ! 103: // the connection to proceed. ! 104: // ! 105: ! 106: connection->Flags |= CONNECTION_FLAGS_READY; ! 107: ! 108: INCREMENT_COUNTER (connection->Provider, OpenConnections); ! 109: ! 110: // ! 111: // Set this flag to enable disconnect indications; once ! 112: // the client has accepted he expects those. ! 113: // ! 114: ! 115: connection->Flags2 &= ~CONNECTION_FLAGS2_WAIT_ACCEPT; ! 116: connection->Flags2 |= CONNECTION_FLAGS2_REQ_COMPLETED; ! 117: ! 118: StReferenceConnection("Pended listen completed", connection); ! 119: ! 120: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 121: ! 122: } else { ! 123: ! 124: // ! 125: // This accept is being called at some point before ! 126: // the link is up; directly from the connection handler ! 127: // or at some point slightly later. ! 128: // ! 129: ! 130: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 131: ! 132: } ! 133: ! 134: StDereferenceConnection ("Temp TdiAccept", connection); ! 135: ! 136: return STATUS_SUCCESS; ! 137: ! 138: } /* StTdiAccept */ ! 139: ! 140: ! 141: NTSTATUS ! 142: StTdiAssociateAddress( ! 143: IN PIRP Irp ! 144: ) ! 145: ! 146: /*++ ! 147: ! 148: Routine Description: ! 149: ! 150: This routine performs the association of the connection and the address for ! 151: the user. ! 152: ! 153: Arguments: ! 154: ! 155: Irp - Pointer to the I/O Request Packet for this request. ! 156: ! 157: Return Value: ! 158: ! 159: NTSTATUS - status of operation. ! 160: ! 161: --*/ ! 162: ! 163: { ! 164: NTSTATUS status; ! 165: PFILE_OBJECT fileObject; ! 166: PTP_ADDRESS_FILE addressFile; ! 167: PTP_ADDRESS oldAddress; ! 168: PTP_CONNECTION connection; ! 169: PIO_STACK_LOCATION irpSp; ! 170: PTDI_REQUEST_KERNEL_ASSOCIATE parameters; ! 171: PDEVICE_CONTEXT deviceContext; ! 172: ! 173: KIRQL oldirql, oldirql2; ! 174: ! 175: irpSp = IoGetCurrentIrpStackLocation (Irp); ! 176: ! 177: // ! 178: // verify that the operation is taking place on a connection. At the same ! 179: // time we do this, we reference the connection. This ensures it does not ! 180: // get removed out from under us. Note also that we do the connection ! 181: // lookup within a try/except clause, thus protecting ourselves against ! 182: // really bogus handles ! 183: // ! 184: ! 185: connection = irpSp->FileObject->FsContext; ! 186: status = StVerifyConnectionObject (connection); ! 187: if (!NT_SUCCESS (status)) { ! 188: return status; ! 189: } ! 190: ! 191: ! 192: // ! 193: // Make sure this connection is ready to be associated. ! 194: // ! 195: ! 196: oldAddress = (PTP_ADDRESS)NULL; ! 197: ! 198: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql2); ! 199: ! 200: if ((connection->Flags2 & CONNECTION_FLAGS2_ASSOCIATED) && ! 201: ((connection->Flags2 & CONNECTION_FLAGS2_DISASSOCIATED) == 0)) { ! 202: ! 203: // ! 204: // The connection is already associated with ! 205: // an active connection...bad! ! 206: // ! 207: ! 208: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql2); ! 209: StDereferenceConnection ("Temp Ref Associate", connection); ! 210: ! 211: return STATUS_INVALID_CONNECTION; ! 212: ! 213: } else { ! 214: ! 215: // ! 216: // See if there is an old association hanging around... ! 217: // this happens if the connection has been disassociated, ! 218: // but not closed. ! 219: // ! 220: ! 221: if (connection->Flags2 & CONNECTION_FLAGS2_DISASSOCIATED) { ! 222: ! 223: // ! 224: // Save this; since it is non-null this address ! 225: // will be dereferenced after the connection ! 226: // spinlock is released. ! 227: // ! 228: ! 229: oldAddress = connection->AddressFile->Address; ! 230: ! 231: // ! 232: // Remove the old association. ! 233: // ! 234: ! 235: connection->Flags2 &= ~CONNECTION_FLAGS2_ASSOCIATED; ! 236: RemoveEntryList (&connection->AddressList); ! 237: RemoveEntryList (&connection->AddressFileList); ! 238: InitializeListHead (&connection->AddressList); ! 239: InitializeListHead (&connection->AddressFileList); ! 240: connection->AddressFile = NULL; ! 241: ! 242: } ! 243: ! 244: } ! 245: ! 246: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql2); ! 247: ! 248: // ! 249: // If we removed an old association, dereference the ! 250: // address. ! 251: // ! 252: ! 253: if (oldAddress != (PTP_ADDRESS)NULL) { ! 254: ! 255: StDereferenceAddress("Removed old association", oldAddress); ! 256: ! 257: } ! 258: ! 259: ! 260: deviceContext = connection->Provider; ! 261: ! 262: parameters = (PTDI_REQUEST_KERNEL_ASSOCIATE)&irpSp->Parameters; ! 263: ! 264: // ! 265: // get a pointer to the address File Object, which points us to the ! 266: // transport's address object, which is where we want to put the ! 267: // connection. ! 268: // ! 269: ! 270: status = ObReferenceObjectByHandle ( ! 271: parameters->AddressHandle, ! 272: 0L, ! 273: 0, ! 274: KernelMode, ! 275: (PVOID *) &fileObject, ! 276: NULL); ! 277: ! 278: if (NT_SUCCESS(status)) { ! 279: ! 280: // ! 281: // we might have one of our address objects; verify that. ! 282: // ! 283: ! 284: addressFile = fileObject->FsContext; ! 285: ! 286: if (NT_SUCCESS (StVerifyAddressObject (addressFile))) { ! 287: ! 288: // ! 289: // have an address and connection object. Add the connection to the ! 290: // address object database. Also add the connection to the address ! 291: // file object db (used primarily for cleaning up). Reference the ! 292: // address to account for one more reason for it staying open. ! 293: // ! 294: ! 295: ACQUIRE_SPIN_LOCK (&addressFile->Address->SpinLock, &oldirql); ! 296: if ((addressFile->Address->Flags & ADDRESS_FLAGS_STOPPING) == 0) { ! 297: ! 298: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql2); ! 299: ! 300: if ((connection->Flags2 & CONNECTION_FLAGS2_CLOSING) == 0) { ! 301: ! 302: StReferenceAddress ( ! 303: "Connection associated", ! 304: addressFile->Address); ! 305: ! 306: InsertTailList ( ! 307: &addressFile->Address->ConnectionDatabase, ! 308: &connection->AddressList); ! 309: ! 310: InsertTailList ( ! 311: &addressFile->ConnectionDatabase, ! 312: &connection->AddressFileList); ! 313: ! 314: connection->AddressFile = addressFile; ! 315: connection->Flags2 |= CONNECTION_FLAGS2_ASSOCIATED; ! 316: connection->Flags2 &= ~CONNECTION_FLAGS2_DISASSOCIATED; ! 317: ! 318: if (addressFile->ConnectIndicationInProgress) { ! 319: connection->Flags2 |= CONNECTION_FLAGS2_INDICATING; ! 320: } ! 321: ! 322: status = STATUS_SUCCESS; ! 323: ! 324: } else { ! 325: ! 326: // ! 327: // The connection is closing, stop the ! 328: // association. ! 329: // ! 330: ! 331: status = STATUS_INVALID_CONNECTION; ! 332: ! 333: } ! 334: ! 335: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql2); ! 336: ! 337: } else { ! 338: ! 339: status = STATUS_INVALID_HANDLE; ! 340: } ! 341: ! 342: RELEASE_SPIN_LOCK (&addressFile->Address->SpinLock, oldirql); ! 343: ! 344: StDereferenceAddress ("Temp associate", addressFile->Address); ! 345: ! 346: } else { ! 347: ! 348: status = STATUS_INVALID_HANDLE; ! 349: } ! 350: ! 351: // ! 352: // Note that we don't keep a reference to this file object around. ! 353: // That's because the IO subsystem manages the object for us; we simply ! 354: // want to keep the association. We only use this association when the ! 355: // IO subsystem has asked us to close one of the file object, and then ! 356: // we simply remove the association. ! 357: // ! 358: ! 359: ObDereferenceObject (fileObject); ! 360: ! 361: } else { ! 362: status = STATUS_INVALID_HANDLE; ! 363: } ! 364: ! 365: StDereferenceConnection ("Temp Ref Associate", connection); ! 366: ! 367: return status; ! 368: ! 369: } /* TdiAssociateAddress */ ! 370: ! 371: ! 372: NTSTATUS ! 373: StTdiDisassociateAddress( ! 374: IN PIRP Irp ! 375: ) ! 376: /*++ ! 377: ! 378: Routine Description: ! 379: ! 380: This routine performs the disassociation of the connection and the address ! 381: for the user. If the connection has not been stopped, it will be stopped ! 382: here. ! 383: ! 384: Arguments: ! 385: ! 386: Irp - Pointer to the I/O Request Packet for this request. ! 387: ! 388: Return Value: ! 389: ! 390: NTSTATUS - status of operation. ! 391: ! 392: --*/ ! 393: ! 394: { ! 395: ! 396: KIRQL oldirql; ! 397: PIO_STACK_LOCATION irpSp; ! 398: PTP_CONNECTION connection; ! 399: NTSTATUS status; ! 400: ! 401: irpSp = IoGetCurrentIrpStackLocation (Irp); ! 402: ! 403: connection = irpSp->FileObject->FsContext; ! 404: ! 405: // ! 406: // If successful this adds a reference. ! 407: // ! 408: ! 409: status = StVerifyConnectionObject (connection); ! 410: ! 411: if (!NT_SUCCESS (status)) { ! 412: return status; ! 413: } ! 414: ! 415: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql); ! 416: if ((connection->Flags & CONNECTION_FLAGS_STOPPING) == 0) { ! 417: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 418: StStopConnection (connection, STATUS_LOCAL_DISCONNECT); ! 419: ! 420: } else { ! 421: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 422: } ! 423: ! 424: // ! 425: // and now we disassociate the address. This only removes ! 426: // the appropriate reference for the connection, the ! 427: // actually disassociation will be done later. ! 428: // ! 429: // The DISASSOCIATED flag is used to make sure that ! 430: // only one person removes this reference. ! 431: // ! 432: ! 433: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql); ! 434: if ((connection->Flags2 & CONNECTION_FLAGS2_ASSOCIATED) && ! 435: ((connection->Flags2 & CONNECTION_FLAGS2_DISASSOCIATED) == 0)) { ! 436: connection->Flags2 |= CONNECTION_FLAGS2_DISASSOCIATED; ! 437: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 438: } else { ! 439: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 440: } ! 441: ! 442: StDereferenceConnection ("Temp use in Associate", connection); ! 443: ! 444: return STATUS_SUCCESS; ! 445: ! 446: } /* TdiDisassociateAddress */ ! 447: ! 448: ! 449: NTSTATUS ! 450: StTdiConnect( ! 451: IN PIRP Irp ! 452: ) ! 453: ! 454: /*++ ! 455: ! 456: Routine Description: ! 457: ! 458: This routine performs the TdiConnect request for the transport provider. ! 459: ! 460: Arguments: ! 461: ! 462: Irp - Pointer to the I/O Request Packet for this request. ! 463: ! 464: Return Value: ! 465: ! 466: NTSTATUS - status of operation. ! 467: ! 468: --*/ ! 469: ! 470: { ! 471: NTSTATUS status; ! 472: PTP_CONNECTION connection; ! 473: PSTRING GeneralBroadcastSourceRoute = NULL; // BUGBUG: define this later. ! 474: LARGE_INTEGER timeout = {0,0}; ! 475: KIRQL oldirql, cancelirql; ! 476: PTP_REQUEST tpRequest; ! 477: PIO_STACK_LOCATION irpSp; ! 478: PTDI_REQUEST_KERNEL parameters; ! 479: PTA_NETBIOS_ADDRESS RemoteAddress; ! 480: ULONG RemoteAddressLength; ! 481: ! 482: // ! 483: // is the file object a connection? ! 484: // ! 485: ! 486: irpSp = IoGetCurrentIrpStackLocation (Irp); ! 487: connection = irpSp->FileObject->FsContext; ! 488: ! 489: // ! 490: // If successful this adds a reference. ! 491: // ! 492: ! 493: status = StVerifyConnectionObject (connection); ! 494: ! 495: if (!NT_SUCCESS (status)) { ! 496: return status; ! 497: } ! 498: ! 499: parameters = (PTDI_REQUEST_KERNEL)(&irpSp->Parameters); ! 500: ! 501: // ! 502: // fix up the timeout if required; no connect request should take more ! 503: // than 15 seconds if there is someone out there. We'll assume that's ! 504: // what the user wanted if they specify -1 as the timer length. ! 505: // ! 506: ! 507: if (parameters->RequestSpecific != NULL) { ! 508: if ((((PLARGE_INTEGER)(parameters->RequestSpecific))->LowPart == -1) && ! 509: (((PLARGE_INTEGER)(parameters->RequestSpecific))->HighPart == -1)) { ! 510: ! 511: timeout.LowPart = (ULONG)(-TDI_TIMEOUT_CONNECT * 10000000L); // n * 10 ** 7 => 100ns units ! 512: if (timeout.LowPart != 0) { ! 513: timeout.HighPart = -1L; ! 514: } else { ! 515: timeout.HighPart = 0; ! 516: } ! 517: ! 518: } else { ! 519: ! 520: timeout.LowPart = ((PLARGE_INTEGER)(parameters->RequestSpecific))->LowPart; ! 521: timeout.HighPart = ((PLARGE_INTEGER)(parameters->RequestSpecific))->HighPart; ! 522: } ! 523: } ! 524: ! 525: // ! 526: // Check that the remote is a Netbios address. ! 527: // ! 528: ! 529: RemoteAddress = (PTA_NETBIOS_ADDRESS) ! 530: (parameters->RequestConnectionInformation->RemoteAddress); ! 531: ! 532: if (RemoteAddress->Address[0].AddressType != TDI_ADDRESS_TYPE_NETBIOS) { ! 533: ! 534: StDereferenceConnection ("Not Netbios", connection); ! 535: return STATUS_BAD_NETWORK_PATH; // don't even try to find it. ! 536: ! 537: } ! 538: ! 539: // ! 540: // copy the called address someplace we can use it. ! 541: // ! 542: ! 543: RemoteAddressLength = parameters->RequestConnectionInformation->RemoteAddressLength; ! 544: ! 545: if (RemoteAddressLength > sizeof(TA_NETBIOS_ADDRESS)) { ! 546: RemoteAddressLength = sizeof(TA_NETBIOS_ADDRESS); ! 547: } ! 548: ! 549: RtlCopyMemory( ! 550: connection->CalledAddress.NetbiosName, ! 551: RemoteAddress->Address[0].Address[0].NetbiosName, ! 552: 16); ! 553: ! 554: // ! 555: // We need a request object to keep track of this TDI request. ! 556: // Attach this request to the new connection object. ! 557: // ! 558: ! 559: status = StCreateRequest ( ! 560: Irp, // IRP for this request. ! 561: connection, // context. ! 562: REQUEST_FLAGS_CONNECTION, // partial flags. ! 563: NULL, ! 564: 0, ! 565: timeout, ! 566: &tpRequest); ! 567: ! 568: if (!NT_SUCCESS (status)) { // couldn't make the request. ! 569: StDereferenceConnection ("Throw away", connection); ! 570: return status; // return with failure. ! 571: } else { ! 572: ! 573: // Reference the connection since StDestroyRequest derefs it. ! 574: ! 575: StReferenceConnection("For connect request", connection); ! 576: ! 577: tpRequest->Owner = ConnectionType; ! 578: IoAcquireCancelSpinLock (&cancelirql); ! 579: ACQUIRE_SPIN_LOCK (&connection->SpinLock,&oldirql); ! 580: if ((connection->Flags & CONNECTION_FLAGS_STOPPING) != 0) { ! 581: RELEASE_SPIN_LOCK (&connection->SpinLock,oldirql); ! 582: IoReleaseCancelSpinLock (cancelirql); ! 583: StCompleteRequest ( ! 584: tpRequest, ! 585: connection->Status, ! 586: 0); ! 587: StDereferenceConnection("Temporary Use 1", connection); ! 588: return STATUS_PENDING; ! 589: } else { ! 590: InsertTailList (&connection->InProgressRequest,&tpRequest->Linkage); ! 591: ! 592: connection->Flags |= CONNECTION_FLAGS_CONNECTOR; // we're the initiator. ! 593: ! 594: connection->Flags &= ~CONNECTION_FLAGS_STOPPING; ! 595: connection->Status = STATUS_PENDING; ! 596: ! 597: connection->Flags2 &= ~CONNECTION_FLAGS2_INDICATING; ! 598: RELEASE_SPIN_LOCK (&connection->SpinLock,oldirql); ! 599: ! 600: // ! 601: // Check if the IRP has been cancelled. ! 602: // ! 603: ! 604: if (Irp->Cancel) { ! 605: Irp->CancelIrql = cancelirql; ! 606: StCancelConnection((PDEVICE_OBJECT)(connection->Provider), Irp); ! 607: StDereferenceConnection ("IRP cancelled", connection); // release lookup hold. ! 608: return STATUS_PENDING; ! 609: } ! 610: ! 611: Irp->CancelRoutine = StCancelConnection; ! 612: IoReleaseCancelSpinLock(cancelirql); ! 613: ! 614: } ! 615: } ! 616: ! 617: status = StSendConnect ( ! 618: connection); ! 619: ! 620: if (!NT_SUCCESS(status)) { // can't send the name request ! 621: StStopConnection (connection, status); ! 622: StDereferenceConnection("Temporary Use 2", connection); ! 623: ! 624: // ! 625: // Note that this return status isn't really a lie. We are waiting ! 626: // for the connection to run down. ! 627: // ! 628: ! 629: return STATUS_PENDING; ! 630: } ! 631: ! 632: ! 633: StDereferenceConnection("Temporary Use 3", connection); ! 634: ! 635: return STATUS_PENDING; // things are started. ! 636: ! 637: } /* TdiConnect */ ! 638: ! 639: ! 640: NTSTATUS ! 641: StTdiDisconnect( ! 642: IN PIRP Irp ! 643: ) ! 644: ! 645: /*++ ! 646: ! 647: Routine Description: ! 648: ! 649: This routine performs the TdiDisconnect request for the transport provider. ! 650: ! 651: Arguments: ! 652: ! 653: Irp - Pointer to the I/O Request Packet for this request. ! 654: ! 655: Return Value: ! 656: ! 657: NTSTATUS - status of operation. ! 658: ! 659: --*/ ! 660: ! 661: { ! 662: PTP_CONNECTION connection; ! 663: LARGE_INTEGER timeout; ! 664: PIO_STACK_LOCATION irpSp; ! 665: PTDI_REQUEST_KERNEL parameters; ! 666: KIRQL oldirql; ! 667: NTSTATUS status; ! 668: ! 669: ! 670: irpSp = IoGetCurrentIrpStackLocation (Irp); ! 671: ! 672: connection = irpSp->FileObject->FsContext; ! 673: ! 674: // ! 675: // If successful this adds a reference. ! 676: // ! 677: ! 678: status = StVerifyConnectionObject (connection); ! 679: if (!NT_SUCCESS (status)) { ! 680: return status; ! 681: } ! 682: ! 683: ! 684: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql); ! 685: ! 686: // ! 687: // if the connection is currently stopping, there's no reason to blow ! 688: // it away... ! 689: // ! 690: ! 691: if ((connection->Flags & CONNECTION_FLAGS_STOPPING) != 0) { ! 692: ! 693: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 694: StDereferenceConnection ("Ignoring disconnect", connection); // release our lookup reference. ! 695: return connection->Status; ! 696: ! 697: } else { ! 698: connection->Flags2 &= ~ (CONNECTION_FLAGS2_ACCEPTED | ! 699: CONNECTION_FLAGS2_PRE_ACCEPT | ! 700: CONNECTION_FLAGS2_WAIT_ACCEPT); ! 701: connection->Flags2 |= CONNECTION_FLAGS2_DISCONNECT; ! 702: ! 703: // ! 704: // Set this flag so the disconnect IRP is completed. ! 705: // ! 706: // BUGBUG: If the connection goes down before we can ! 707: // call StStopConnection with STATUS_LOCAL_DISCONNECT, ! 708: // the disconnect IRP won't get completed. ! 709: // ! 710: ! 711: connection->Flags2 |= CONNECTION_FLAGS2_REQ_COMPLETED; ! 712: ! 713: connection->DisconnectIrp = Irp; ! 714: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 715: } ! 716: ! 717: // ! 718: // fix up the timeout if required; no disconnect request should take very ! 719: // long. However, the user can cause the timeout to not happen if they ! 720: // desire that. ! 721: // ! 722: ! 723: parameters = (PTDI_REQUEST_KERNEL)(&irpSp->Parameters); ! 724: ! 725: // ! 726: // fix up the timeout if required; no disconnect request should take more ! 727: // than 15 seconds. We'll assume that's what the user wanted if they ! 728: // specify -1 as the timer. ! 729: // ! 730: ! 731: if (parameters->RequestSpecific != NULL) { ! 732: if ((((PLARGE_INTEGER)(parameters->RequestSpecific))->LowPart == -1) && ! 733: (((PLARGE_INTEGER)(parameters->RequestSpecific))->HighPart == -1)) { ! 734: ! 735: timeout.LowPart = (ULONG)(-TDI_TIMEOUT_DISCONNECT * 10000000L); // n * 10 ** 7 => 100ns units ! 736: if (timeout.LowPart != 0) { ! 737: timeout.HighPart = -1L; ! 738: } else { ! 739: timeout.HighPart = 0; ! 740: } ! 741: ! 742: } else { ! 743: timeout.LowPart = ((PLARGE_INTEGER)(parameters->RequestSpecific))->LowPart; ! 744: timeout.HighPart = ((PLARGE_INTEGER)(parameters->RequestSpecific))->HighPart; ! 745: } ! 746: } ! 747: ! 748: // ! 749: // Now the reason for the disconnect ! 750: // ! 751: ! 752: if ((ULONG)(parameters->RequestFlags) & (ULONG)TDI_DISCONNECT_RELEASE) { ! 753: connection->Flags |= CONNECTION_FLAGS_DESTROY; ! 754: } else if ((ULONG)(parameters->RequestFlags) & (ULONG)TDI_DISCONNECT_ABORT) { ! 755: connection->Flags |= CONNECTION_FLAGS_ABORT; ! 756: } else if ((ULONG)(parameters->RequestFlags) & (ULONG)TDI_DISCONNECT_WAIT) { ! 757: connection->Flags |= CONNECTION_FLAGS_ORDREL; ! 758: } ! 759: ! 760: // ! 761: // This will get passed to IoCompleteRequest during TdiDestroyConnection ! 762: // ! 763: ! 764: StStopConnection (connection, STATUS_LOCAL_DISCONNECT); // starts the abort sequence. ! 765: StDereferenceConnection ("Disconnecting", connection); // release our lookup reference. ! 766: ! 767: // ! 768: // This request will be completed by TdiDestroyConnection once ! 769: // the connection reference count drops to 0. ! 770: // ! 771: ! 772: return STATUS_PENDING; ! 773: } /* TdiDisconnect */ ! 774: ! 775: ! 776: NTSTATUS ! 777: StTdiListen( ! 778: IN PIRP Irp ! 779: ) ! 780: ! 781: /*++ ! 782: ! 783: Routine Description: ! 784: ! 785: This routine performs the TdiListen request for the transport provider. ! 786: ! 787: Arguments: ! 788: ! 789: Irp - Pointer to the I/O Request Packet for this request. ! 790: ! 791: Return Value: ! 792: ! 793: NTSTATUS - status of operation. ! 794: ! 795: --*/ ! 796: ! 797: { ! 798: NTSTATUS status; ! 799: PTP_CONNECTION connection; ! 800: LARGE_INTEGER timeout = {0,0}; ! 801: KIRQL oldirql, cancelirql; ! 802: PTP_REQUEST tpRequest; ! 803: PIO_STACK_LOCATION irpSp; ! 804: PTDI_REQUEST_KERNEL_LISTEN parameters; ! 805: ! 806: // ! 807: // validate this connection ! 808: ! 809: irpSp = IoGetCurrentIrpStackLocation (Irp); ! 810: ! 811: connection = irpSp->FileObject->FsContext; ! 812: ! 813: // ! 814: // If successful this adds a reference. ! 815: // ! 816: ! 817: status = StVerifyConnectionObject (connection); ! 818: ! 819: if (!NT_SUCCESS (status)) { ! 820: return status; ! 821: } ! 822: ! 823: parameters = (PTDI_REQUEST_KERNEL_LISTEN)&irpSp->Parameters; ! 824: ! 825: // ! 826: // We need a request object to keep track of this TDI request. ! 827: // Attach this request to the new connection object. ! 828: // ! 829: ! 830: status = StCreateRequest ( ! 831: Irp, // IRP for this request. ! 832: connection, // context. ! 833: REQUEST_FLAGS_CONNECTION, // partial flags. ! 834: NULL, ! 835: 0, ! 836: timeout, // timeout value (can be 0). ! 837: &tpRequest); ! 838: ! 839: ! 840: if (!NT_SUCCESS (status)) { // couldn't make the request. ! 841: ! 842: StDereferenceConnection ("For create", connection); ! 843: return status; // return with failure. ! 844: } ! 845: ! 846: // Reference the connection since StDestroyRequest derefs it. ! 847: ! 848: IoAcquireCancelSpinLock (&cancelirql); ! 849: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql); ! 850: tpRequest->Owner = ConnectionType; ! 851: ! 852: StReferenceConnection("For listen request", connection); ! 853: ! 854: if ((connection->Flags & CONNECTION_FLAGS_STOPPING) != 0) { ! 855: ! 856: RELEASE_SPIN_LOCK (&connection->SpinLock,oldirql); ! 857: IoReleaseCancelSpinLock(cancelirql); ! 858: ! 859: StCompleteRequest ( ! 860: tpRequest, ! 861: connection->Status, ! 862: 0); ! 863: StDereferenceConnection("Temp create", connection); ! 864: return STATUS_PENDING; ! 865: ! 866: } else { ! 867: ! 868: InsertTailList (&connection->InProgressRequest,&tpRequest->Linkage); ! 869: connection->Flags |= CONNECTION_FLAGS_LISTENER | // we're the passive one. ! 870: CONNECTION_FLAGS_WAIT_LISTEN; // waiting for a connect ! 871: connection->Flags2 &= ~CONNECTION_FLAGS2_INDICATING; ! 872: connection->Flags &= ~CONNECTION_FLAGS_STOPPING; ! 873: connection->Status = STATUS_PENDING; ! 874: ! 875: // ! 876: // If TDI_QUERY_ACCEPT is not set, then we set PRE_ACCEPT to ! 877: // indicate that when the listen completes we do not have to ! 878: // wait for a TDI_ACCEPT to continue. ! 879: // ! 880: ! 881: if ((parameters->RequestFlags & TDI_QUERY_ACCEPT) == 0) { ! 882: connection->Flags2 |= CONNECTION_FLAGS2_PRE_ACCEPT; ! 883: } ! 884: ! 885: RELEASE_SPIN_LOCK (&connection->SpinLock,oldirql); ! 886: ! 887: // ! 888: // Check if the IRP has been cancelled. ! 889: // ! 890: ! 891: if (Irp->Cancel) { ! 892: Irp->CancelIrql = cancelirql; ! 893: StCancelConnection((PDEVICE_OBJECT)(connection->Provider), Irp); ! 894: StDereferenceConnection ("IRP cancelled", connection); // release lookup hold. ! 895: return STATUS_PENDING; ! 896: } ! 897: ! 898: Irp->CancelRoutine = StCancelConnection; ! 899: IoReleaseCancelSpinLock(cancelirql); ! 900: ! 901: } ! 902: ! 903: // ! 904: // Wait for an incoming NAME_QUERY frame. The remainder of the ! 905: // connectionless protocol to set up a connection is processed ! 906: // in the NAME_QUERY frame handler. ! 907: // ! 908: ! 909: StDereferenceConnection("Temp create", connection); ! 910: ! 911: return STATUS_PENDING; // things are started. ! 912: } /* TdiListen */ ! 913: ! 914: ! 915: NTSTATUS ! 916: StOpenConnection ( ! 917: IN PDEVICE_OBJECT DeviceObject, ! 918: IN PIRP Irp, ! 919: IN PIO_STACK_LOCATION IrpSp ! 920: ) ! 921: ! 922: /*++ ! 923: ! 924: Routine Description: ! 925: ! 926: This routine is called to open a connection. Note that the connection that ! 927: is open is of little use until associated with an address; until then, ! 928: the only thing that can be done with it is close it. ! 929: ! 930: Arguments: ! 931: ! 932: DeviceObject - Pointer to the device object for this driver. ! 933: ! 934: Irp - Pointer to the request packet representing the I/O request. ! 935: ! 936: IrpSp - Pointer to current IRP stack frame. ! 937: ! 938: Return Value: ! 939: ! 940: The function value is the status of the operation. ! 941: ! 942: --*/ ! 943: ! 944: { ! 945: PDEVICE_CONTEXT DeviceContext; ! 946: NTSTATUS status; ! 947: PTP_CONNECTION connection; ! 948: PFILE_FULL_EA_INFORMATION ea; ! 949: ! 950: UNREFERENCED_PARAMETER (Irp); ! 951: ! 952: DeviceContext = (PDEVICE_CONTEXT)DeviceObject; ! 953: ! 954: // ! 955: // First, try to make a connection object to represent this pending ! 956: // connection. Then fill in the relevant fields. ! 957: // In addition to the creation, if successful StCreateConnection ! 958: // will create a second reference which is removed once the request ! 959: // references the connection, or if the function exits before that. ! 960: ! 961: status = StCreateConnection (DeviceContext, &connection); ! 962: if (!NT_SUCCESS (status)) { ! 963: return status; // sorry, we couldn't make one. ! 964: } ! 965: ! 966: // ! 967: // set the connection context so we can connect the user to this data ! 968: // structure ! 969: // ! 970: ! 971: ea = (PFILE_FULL_EA_INFORMATION)Irp->AssociatedIrp.SystemBuffer; ! 972: RtlCopyMemory ( ! 973: &connection->Context, ! 974: &ea->EaName[ea->EaNameLength+1], ! 975: sizeof (PVOID)); ! 976: ! 977: // ! 978: // let file object point at connection and connection at file object ! 979: // ! 980: ! 981: IrpSp->FileObject->FsContext = (PVOID)connection; ! 982: IrpSp->FileObject->FsContext2 = (PVOID)TDI_CONNECTION_FILE; ! 983: connection->FileObject = IrpSp->FileObject; ! 984: ! 985: return status; ! 986: ! 987: } /* StOpenConnection */ ! 988: ! 989: ! 990: NTSTATUS ! 991: StCloseConnection ( ! 992: IN PDEVICE_OBJECT DeviceObject, ! 993: IN PIRP Irp, ! 994: IN PIO_STACK_LOCATION IrpSp ! 995: ) ! 996: ! 997: /*++ ! 998: ! 999: Routine Description: ! 1000: ! 1001: This routine is called to close a connection. There may be actions in ! 1002: progress on this connection, so we note the closing IRP, mark the ! 1003: connection as closing, and complete it somewhere down the road (when all ! 1004: references have been removed). ! 1005: ! 1006: Arguments: ! 1007: ! 1008: DeviceObject - Pointer to the device object for this driver. ! 1009: ! 1010: Irp - Pointer to the request packet representing the I/O request. ! 1011: ! 1012: IrpSp - Pointer to current IRP stack frame. ! 1013: ! 1014: Return Value: ! 1015: ! 1016: The function value is the status of the operation. ! 1017: ! 1018: --*/ ! 1019: ! 1020: { ! 1021: NTSTATUS status; ! 1022: KIRQL oldirql; ! 1023: PTP_CONNECTION connection; ! 1024: ! 1025: UNREFERENCED_PARAMETER (DeviceObject); ! 1026: UNREFERENCED_PARAMETER (Irp); ! 1027: ! 1028: // ! 1029: // is the file object a connection? ! 1030: // ! 1031: ! 1032: connection = IrpSp->FileObject->FsContext; ! 1033: ! 1034: ! 1035: // ! 1036: // We duplicate the code from VerifyConnectionObject, ! 1037: // although we don't actually call that since it does ! 1038: // a reference, which we don't want (to avoid bouncing ! 1039: // the reference count up from 0 if this is a dead ! 1040: // link). ! 1041: // ! 1042: ! 1043: try { ! 1044: ! 1045: if ((connection->Size == sizeof (TP_CONNECTION)) && ! 1046: (connection->Type == ST_CONNECTION_SIGNATURE)) { ! 1047: ! 1048: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql); ! 1049: ! 1050: if ((connection->Flags2 & CONNECTION_FLAGS2_CLOSING) == 0) { ! 1051: ! 1052: status = STATUS_SUCCESS; ! 1053: ! 1054: } else { ! 1055: ! 1056: status = STATUS_INVALID_CONNECTION; ! 1057: } ! 1058: ! 1059: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 1060: ! 1061: } else { ! 1062: ! 1063: status = STATUS_INVALID_CONNECTION; ! 1064: } ! 1065: ! 1066: } except(EXCEPTION_EXECUTE_HANDLER) { ! 1067: ! 1068: return GetExceptionCode(); ! 1069: } ! 1070: ! 1071: if (!NT_SUCCESS (status)) { ! 1072: return status; ! 1073: } ! 1074: ! 1075: // ! 1076: // We recognize it; is it closing already? ! 1077: // ! 1078: ! 1079: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql); ! 1080: ! 1081: if ((connection->Flags2 & CONNECTION_FLAGS2_CLOSING) != 0) { ! 1082: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 1083: StDereferenceConnection("Temp Close", connection); ! 1084: return STATUS_INVALID_CONNECTION; ! 1085: } ! 1086: ! 1087: connection->Flags2 |= CONNECTION_FLAGS2_CLOSING; ! 1088: ! 1089: // ! 1090: // if there is activity on the connection, tear it down. ! 1091: // ! 1092: ! 1093: if ((connection->Flags & CONNECTION_FLAGS_STOPPING) == 0) { ! 1094: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 1095: StStopConnection (connection, STATUS_LOCAL_DISCONNECT); ! 1096: ACQUIRE_SPIN_LOCK (&connection->SpinLock, &oldirql); ! 1097: } ! 1098: ! 1099: // ! 1100: // If the connection is still associated, disassociate it. ! 1101: // ! 1102: ! 1103: if ((connection->Flags2 & CONNECTION_FLAGS2_ASSOCIATED) && ! 1104: ((connection->Flags2 & CONNECTION_FLAGS2_DISASSOCIATED) == 0)) { ! 1105: connection->Flags2 |= CONNECTION_FLAGS2_DISASSOCIATED; ! 1106: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 1107: } else { ! 1108: RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql); ! 1109: } ! 1110: ! 1111: ! 1112: // ! 1113: // Save this to complete the IRP later. ! 1114: // ! 1115: ! 1116: connection->CloseIrp = Irp; ! 1117: ! 1118: // ! 1119: // make it impossible to use this connection from the file object ! 1120: // ! 1121: ! 1122: IrpSp->FileObject->FsContext = NULL; ! 1123: IrpSp->FileObject->FsContext2 = NULL; ! 1124: connection->FileObject = NULL; ! 1125: ! 1126: // ! 1127: // dereference for the creation. Note that this dereference ! 1128: // here won't have any effect until the regular reference count ! 1129: // hits zero. ! 1130: // ! 1131: ! 1132: StDereferenceConnectionSpecial (" Closing Connection", connection); ! 1133: ! 1134: return STATUS_PENDING; ! 1135: ! 1136: } /* StCloseConnection */ ! 1137:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.