1 files changed, 980 insertions, 0 deletions

diff --git a/private/ntos/tdi/st/uframes.c b/private/ntos/tdi/st/uframes.c
new file mode 100644
index 000000000..c05f6eaa6
--- /dev/null
+++ b/private/ntos/tdi/st/uframes.c
@@ -0,0 +1,980 @@
+/*++
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    uframes.c
+
+Abstract:
+
+    This module contains a routine called StProcessConnectionless,
+    that gets control from routines in IND.C when a connectionless
+    frame is received.
+
+Environment:
+
+    Kernel mode, DISPATCH_LEVEL.
+
+Revision History:
+
+--*/
+
+#include "st.h"
+
+
+
+NTSTATUS
+StIndicateDatagram(
+    IN PDEVICE_CONTEXT DeviceContext,
+    IN PTP_ADDRESS Address,
+    IN PUCHAR Header,
+    IN ULONG Length
+    )
+
+/*++
+
+Routine Description:
+
+    This routine processes an incoming DATAGRAM or DATAGRAM_BROADCAST frame.
+    BROADCAST and normal datagrams have the same receive logic, except
+    for broadcast datagrams Address will be the broadcast address.
+
+    When we return STATUS_MORE_PROCESSING_REQUIRED, the caller of
+    this routine will continue to call us for each address for the device
+    context.  When we return STATUS_SUCCESS, the caller will switch to the
+    next address.  When we return any other status code, including
+    STATUS_ABANDONED, the caller will stop distributing the frame.
+
+Arguments:
+
+    DeviceContext - Pointer to our device context.
+
+    Address - Pointer to the transport address object.
+
+    StHeader - Pointer to a buffer that contains the receive datagram.
+        The first byte of information is the ST header.
+
+    Length - The length of the MDL pointed to by StHeader.
+
+Return Value:
+
+    NTSTATUS - status of operation.
+
+--*/
+
+{
+    NTSTATUS status;
+    PLIST_ENTRY p, q;
+    PIRP irp;
+    PIO_STACK_LOCATION irpSp;
+    PTP_REQUEST Request;
+    ULONG IndicateBytesCopied, MdlBytesCopied;
+    KIRQL oldirql;
+    TA_NETBIOS_ADDRESS SourceName;
+    TA_NETBIOS_ADDRESS DestinationName;
+    PTDI_CONNECTION_INFORMATION remoteInformation;
+    ULONG returnLength;
+    PTP_ADDRESS_FILE addressFile, prevaddressFile;
+    PST_HEADER StHeader;
+
+    //
+    // If this datagram wasn't big enough for a transport header, then don't
+    // let the caller look at any data.
+    //
+
+    if (Length < sizeof(ST_HEADER)) {
+        return STATUS_ABANDONED;
+    }
+
+    //
+    // Update our statistics.
+    //
+
+    ++DeviceContext->DatagramsReceived;
+    ADD_TO_LARGE_INTEGER(
+        &DeviceContext->DatagramBytesReceived,
+        Length - sizeof(ST_HEADER));
+
+
+    //
+    // Call the client's ReceiveDatagram indication handler.  He may
+    // want to accept the datagram that way.
+    //
+
+    StHeader = (PST_HEADER)Header;
+
+    TdiBuildNetbiosAddress (StHeader->Source, FALSE, &SourceName);
+    TdiBuildNetbiosAddress (StHeader->Destination, FALSE, &DestinationName);
+
+
+    ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
+
+    //
+    // Find the first open address file in the list.
+    //
+
+    p = Address->AddressFileDatabase.Flink;
+    while (p != &Address->AddressFileDatabase) {
+        addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
+        if (addressFile->State != ADDRESSFILE_STATE_OPEN) {
+            p = p->Flink;
+            continue;
+        }
+        StReferenceAddressFile(addressFile);
+        break;
+    }
+
+    while (p != &Address->AddressFileDatabase) {
+
+        //
+        // do we have a datagram receive request outstanding? If so, we will
+        // satisfy it first.
+        //
+        // NOTE: We should check if this receive dataframs is for
+        // a specific address.
+        //
+
+        q = RemoveHeadList (&addressFile->ReceiveDatagramQueue);
+        RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
+
+        if (q != &addressFile->ReceiveDatagramQueue) {
+
+            Request = CONTAINING_RECORD (q, TP_REQUEST, Linkage);
+
+            //
+            // Copy the actual user data.
+            //
+
+            MdlBytesCopied = 0;
+
+            status = TdiCopyBufferToMdl (
+                         StHeader,
+                         sizeof(ST_HEADER),           // offset
+                         Length - sizeof(ST_HEADER),  // length
+                         Request->IoRequestPacket->MdlAddress,
+                         0,
+                         &MdlBytesCopied);
+
+            irpSp = IoGetCurrentIrpStackLocation (Request->IoRequestPacket);
+            remoteInformation =
+                ((PTDI_REQUEST_KERNEL_RECEIVEDG)(&irpSp->Parameters))->
+                                                        ReturnDatagramInformation;
+            if (remoteInformation != NULL) {
+                try {
+                    if (remoteInformation->RemoteAddressLength != 0) {
+                        if (remoteInformation->RemoteAddressLength >=
+                                               sizeof (TA_NETBIOS_ADDRESS)) {
+
+                            RtlCopyMemory (
+                             (PTA_NETBIOS_ADDRESS)remoteInformation->RemoteAddress,
+                             &SourceName,
+                             sizeof (TA_NETBIOS_ADDRESS));
+
+                            returnLength = sizeof(TA_NETBIOS_ADDRESS);
+                            remoteInformation->RemoteAddressLength = returnLength;
+
+                        } else {
+
+                            RtlCopyMemory (
+                             (PTA_NETBIOS_ADDRESS)remoteInformation->RemoteAddress,
+                             &SourceName,
+                             remoteInformation->RemoteAddressLength);
+
+                            returnLength = remoteInformation->RemoteAddressLength;
+                            remoteInformation->RemoteAddressLength = returnLength;
+
+                        }
+
+                    } else {
+
+                        returnLength = 0;
+                    }
+
+                    status = STATUS_SUCCESS;
+
+                } except (EXCEPTION_EXECUTE_HANDLER) {
+
+                    returnLength = 0;
+                    status = GetExceptionCode ();
+
+                }
+
+            }
+
+            StCompleteRequest (Request, STATUS_SUCCESS, MdlBytesCopied);
+
+        } else {
+
+            //
+            // no receive datagram requests; is there a kernel client?
+            //
+
+            if (addressFile->RegisteredReceiveDatagramHandler) {
+
+                IndicateBytesCopied = 0;
+
+                //
+                // Note that we can always set the COPY_LOOKAHEAD
+                // flag because we are indicating from our own
+                // buffer, not directly from a lookahead indication.
+                //
+
+                status = (*addressFile->ReceiveDatagramHandler)(
+                             addressFile->ReceiveDatagramHandlerContext,
+                             sizeof (TA_NETBIOS_ADDRESS),
+                             &SourceName,
+                             0,
+                             NULL,
+                             TDI_RECEIVE_COPY_LOOKAHEAD,
+                             Length - sizeof(ST_HEADER),  // indicated
+                             Length - sizeof(ST_HEADER),  // available
+                             &IndicateBytesCopied,
+                             Header + sizeof(ST_HEADER),
+                             &irp);
+
+                if (status == STATUS_SUCCESS) {
+
+                    //
+                    // The client accepted the datagram and so we're done.
+                    //
+
+                } else if (status == STATUS_DATA_NOT_ACCEPTED) {
+
+                    //
+                    // The client did not accept the datagram and we need to satisfy
+                    // a TdiReceiveDatagram, if possible.
+                    //
+
+                    status = STATUS_MORE_PROCESSING_REQUIRED;
+
+                } else if (status == STATUS_MORE_PROCESSING_REQUIRED) {
+
+                    //
+                    // The client returned an IRP that we should queue up to the
+                    // address to satisfy the request.
+                    //
+
+                    irp->IoStatus.Status = STATUS_PENDING;  // init status information.
+                    irp->IoStatus.Information = 0;
+                    irpSp = IoGetCurrentIrpStackLocation (irp); // get current stack loctn.
+                    if ((irpSp->MajorFunction != IRP_MJ_INTERNAL_DEVICE_CONTROL) ||
+                        (irpSp->MinorFunction != TDI_RECEIVE_DATAGRAM)) {
+                        irp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
+                        return status;
+                    }
+
+                    //
+                    // Now copy the actual user data.
+                    //
+
+                    MdlBytesCopied = 0;
+
+                    status = TdiCopyBufferToMdl (
+                                 StHeader,
+                                 sizeof(ST_HEADER) + IndicateBytesCopied,
+                                 Length - sizeof(ST_HEADER) - IndicateBytesCopied,
+                                 irp->MdlAddress,
+                                 0,
+                                 &MdlBytesCopied);
+
+                    irp->IoStatus.Information = MdlBytesCopied;
+                    irp->IoStatus.Status = status;
+                    IoCompleteRequest (irp, IO_NETWORK_INCREMENT);
+                }
+            }
+        }
+
+        //
+        // Save this to dereference it later.
+        //
+
+        prevaddressFile = addressFile;
+
+        //
+        // Reference the next address file on the list, so it
+        // stays around.
+        //
+
+        ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
+
+        p = p->Flink;
+        while (p != &Address->AddressFileDatabase) {
+            addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
+            if (addressFile->State != ADDRESSFILE_STATE_OPEN) {
+                p = p->Flink;
+                continue;
+            }
+            StReferenceAddressFile(addressFile);
+            break;
+        }
+
+        RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
+
+        //
+        // Now dereference the previous address file with
+        // the lock released.
+        //
+
+        StDereferenceAddressFile (prevaddressFile);
+
+        ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
+
+    }    // end of while loop
+
+    RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
+
+    return status;                      // to dispatcher.
+} /* StIndicateDatagram */
+
+
+NTSTATUS
+StProcessConnect(
+    IN PDEVICE_CONTEXT DeviceContext,
+    IN PTP_ADDRESS Address,
+    IN PST_HEADER Header,
+    IN PHARDWARE_ADDRESS SourceAddress,
+    IN PUCHAR SourceRouting,
+    IN UINT SourceRoutingLength
+    )
+
+/*++
+
+Routine Description:
+
+    This routine processes an incoming connect frame. It scans for
+    posted listens, otherwise it indicates to connect handlers
+    on this address if they are registered.
+
+Arguments:
+
+    DeviceContext - Pointer to our device context.
+
+    Address - Pointer to the transport address object.
+
+    Header - Pointer to the ST header of the frame.
+
+    SourceAddress - Pointer to the source hardware address in the received
+        frame.
+
+    SourceRouting - Pointer to the source routing information in
+        the frame.
+
+    SourceRoutingLength - Length of the source routing information.
+
+Return Value:
+
+    NTSTATUS - status of operation.
+
+--*/
+
+{
+    KIRQL oldirql, oldirql1, cancelirql;
+    NTSTATUS status;
+    PTP_CONNECTION Connection;
+    BOOLEAN ConnectIndicationBlocked = FALSE;
+    PLIST_ENTRY p;
+    BOOLEAN UsedListeningConnection = FALSE;
+    PTP_ADDRESS_FILE addressFile, prevaddressFile;
+
+    PTP_REQUEST request;
+    PIO_STACK_LOCATION irpSp;
+    ULONG returnLength;
+    PTDI_CONNECTION_INFORMATION remoteInformation;
+    TA_NETBIOS_ADDRESS TempAddress;
+    PIRP acceptIrp;
+
+    CONNECTION_CONTEXT connectionContext;
+
+    //
+    // If we are just registering or deregistering this address, then don't
+    // allow state changes.  Just throw the packet away, and let the frame
+    // distributor try the next address.
+    //
+
+    if (Address->Flags & (ADDRESS_FLAGS_REGISTERING | ADDRESS_FLAGS_DEREGISTERING)) {
+        return STATUS_SUCCESS;
+    }
+
+    //
+    // This is an incoming connection request.  If we have a listening
+    // connection on this address, then continue with the connection setup.
+    // If there is no outstanding listen, then indicate any kernel mode
+    // clients that want to know about this frame. If a listen was posted,
+    // then a connection has already been set up for it.
+    //
+
+    //
+    // First, check if we already have an active connection with
+    // this remote on this address. If so, we ignore this
+    // (NOTE: This is not the correct behaviour for a real
+    // transport).
+    //
+
+    //
+    // If successful this adds a reference.
+    //
+
+    if (Connection = StLookupRemoteName(Address, Header->Source)) {
+
+        StDereferenceConnection ("Lookup done", Connection);
+        return STATUS_ABANDONED;
+
+    }
+
+    // If successful, this adds a reference which is removed before
+    // this function returns.
+
+    Connection = StLookupListeningConnection (Address);
+    if (Connection == NULL) {
+
+        //
+        // not having a listening connection is not reason to bail out here.
+        // we need to indicate to the user that a connect attempt occurred,
+        // and see if there is a desire to use this connection. We
+        // indicate in order to all address files that are
+        // using this address.
+        //
+        // If we already have an indication pending on this address,
+        // we ignore this frame (the NAME_QUERY may have come from
+        // a different address, but we can't know that). Also, if
+        // there is already an active connection on this remote
+        // name, then we ignore the frame.
+        //
+
+
+        ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
+
+        p = Address->AddressFileDatabase.Flink;
+        while (p != &Address->AddressFileDatabase) {
+            addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
+            if (addressFile->State != ADDRESSFILE_STATE_OPEN) {
+                p = p->Flink;
+                continue;
+            }
+            StReferenceAddressFile(addressFile);
+            break;
+        }
+
+        while (p != &Address->AddressFileDatabase) {
+
+            RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
+
+            if ((addressFile->RegisteredConnectionHandler == TRUE) &&
+                (!addressFile->ConnectIndicationInProgress)) {
+
+
+                TdiBuildNetbiosAddress (
+                    Header->Source,
+                    FALSE,
+                    &TempAddress);
+
+                addressFile->ConnectIndicationInProgress = TRUE;
+
+                //
+                // we have a connection handler, now indicate that a connection
+                // attempt occurred.
+                //
+
+                status = (addressFile->ConnectionHandler)(
+                             addressFile->ConnectionHandlerContext,
+                             sizeof (TDI_ADDRESS_NETBIOS),
+                             &TempAddress,
+                             0,
+                             NULL,
+                             0,
+                             NULL,
+                             &connectionContext,
+                             &acceptIrp);
+
+                if (status == STATUS_MORE_PROCESSING_REQUIRED) {
+
+                    // the user has connected a currently open connection, but
+                    // we have to figure out which one it is.
+                    //
+
+                    //
+                    // If successful this adds a reference of type LISTENING
+                    // (the same what StLookupListeningConnection adds).
+                    //
+
+                    Connection = StLookupConnectionByContext (
+                                    Address,
+                                    connectionContext);
+
+                    if (Connection == NULL) {
+
+                        //
+                        // BUGBUG: We have to tell the client that
+                        // his connection is bogus (or has this
+                        // already happened??).
+                        //
+
+                        StPrint0("MORE_PROCESSING_REQUIRED, connection not found\n");
+                        addressFile->ConnectIndicationInProgress = FALSE;
+                        acceptIrp->IoStatus.Status = STATUS_INVALID_CONNECTION;
+                        IoCompleteRequest (acceptIrp, IO_NETWORK_INCREMENT);
+
+                        goto whileend;    // try next address file
+
+                    } else {
+
+                        if (Connection->AddressFile->Address != Address) {
+                            addressFile->ConnectIndicationInProgress = FALSE;
+
+                            StPrint0("MORE_PROCESSING_REQUIRED, address wrong\n");
+                            StStopConnection (Connection, STATUS_INVALID_ADDRESS);
+                            StDereferenceConnection("Bad Address", Connection);
+                            Connection = NULL;
+                            acceptIrp->IoStatus.Status = STATUS_INVALID_CONNECTION;
+                            IoCompleteRequest (acceptIrp, IO_NETWORK_INCREMENT);
+
+                            goto whileend;    // try next address file
+                        }
+
+                        //
+                        // OK, we have a valid connection. If the response to
+                        // this connection was disconnect, we need to reject
+                        // the connection request and return. If it was accept
+                        // or not specified (to be done later), we simply
+                        // fall through and continue processing on the U Frame.
+                        //
+
+                        ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql1);
+                        if ((Connection->Flags2 & CONNECTION_FLAGS2_DISCONNECT) != 0) {
+
+                            Connection->Flags2 &= ~CONNECTION_FLAGS2_DISCONNECT;
+                            RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql1);
+                            StPrint0("MORE_PROCESSING_REQUIRED, disconnect\n");
+                            addressFile->ConnectIndicationInProgress = FALSE;
+                            StDereferenceConnection("Disconnecting", Connection);
+                            Connection = NULL;
+                            acceptIrp->IoStatus.Status = STATUS_INVALID_CONNECTION;
+                            IoCompleteRequest (acceptIrp, IO_NETWORK_INCREMENT);
+
+                            goto whileend;    // try next address file
+                        }
+
+                    }
+
+                    //
+                    // This connection is ready.
+                    //
+
+                    Connection->Flags &= ~CONNECTION_FLAGS_STOPPING;
+                    Connection->Status = STATUS_PENDING;
+                    Connection->Flags2 |= CONNECTION_FLAGS2_ACCEPTED;
+
+                    Connection->Flags |= CONNECTION_FLAGS_READY;
+                    INCREMENT_COUNTER (Connection->Provider, OpenConnections);
+
+                    Connection->Flags2 |= CONNECTION_FLAGS2_REQ_COMPLETED;
+
+                    StReferenceConnection("Indication completed", Connection);
+
+                    RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql1);
+
+                    //
+                    // Make a note that we have to set
+                    // addressFile->ConnectIndicationInProgress to
+                    // FALSE once the address is safely stored
+                    // in the connection.
+                    //
+
+                    ConnectIndicationBlocked = TRUE;
+                    StDereferenceAddressFile (addressFile);
+                    ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
+                    break;    // exit the while
+
+                } else if (status == STATUS_INSUFFICIENT_RESOURCES) {
+
+                    //
+                    // we know the address, but can't create a connection to
+                    // use on it. This gets passed to the network as a response
+                    // saying I'm here, but can't help.
+                    //
+
+                    addressFile->ConnectIndicationInProgress = FALSE;
+
+                    StDereferenceAddressFile (addressFile);
+                    return STATUS_ABANDONED;
+
+                } else {
+
+                    addressFile->ConnectIndicationInProgress = FALSE;
+                    goto whileend;    // try next address file
+
+                } // end status ifs
+
+            } else {
+
+                goto whileend;     // try next address file
+
+            } // end no indication handler
+
+whileend:
+            //
+            // Jumping here is like a continue, except that the
+            // addressFile pointer is advanced correctly.
+            //
+
+            //
+            // Save this to dereference it later.
+            //
+
+            prevaddressFile = addressFile;
+
+            //
+            // Reference the next address file on the list, so it
+            // stays around.
+            //
+
+            ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
+
+            p = p->Flink;
+            while (p != &Address->AddressFileDatabase) {
+                addressFile = CONTAINING_RECORD (p, TP_ADDRESS_FILE, Linkage);
+                if (addressFile->State != ADDRESSFILE_STATE_OPEN) {
+                    p = p->Flink;
+                    continue;
+                }
+                StReferenceAddressFile(addressFile);
+                break;
+            }
+
+            RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
+
+            //
+            // Now dereference the previous address file with
+            // the lock released.
+            //
+
+            StDereferenceAddressFile (prevaddressFile);
+
+            ACQUIRE_SPIN_LOCK (&Address->SpinLock, &oldirql);
+
+        } // end of loop through the address files.
+
+        RELEASE_SPIN_LOCK (&Address->SpinLock, oldirql);
+
+        if (Connection == NULL) {
+
+            //
+            // We used to return MORE_PROCESSING_REQUIRED, but
+            // since we matched with this address, no other
+            // address is going to match, so abandon it.
+            //
+
+            return STATUS_ABANDONED;
+
+        }
+
+    } else { // end connection == null
+
+        UsedListeningConnection = TRUE;
+
+        IoAcquireCancelSpinLock (&cancelirql);
+        ACQUIRE_SPIN_LOCK (&Connection->SpinLock, &oldirql);
+
+        p = RemoveHeadList (&Connection->InProgressRequest);
+        if (p == &Connection->InProgressRequest) {
+
+            Connection->IndicationInProgress = FALSE;
+            RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
+            IoReleaseCancelSpinLock (cancelirql);
+            return STATUS_SUCCESS;
+
+        }
+
+        //
+        // If this listen indicated that we should wait for a
+        // TdiAccept, then do that, otherwise the connection is
+        // ready.
+        //
+
+        if ((Connection->Flags2 & CONNECTION_FLAGS2_PRE_ACCEPT) == 0) {
+
+            Connection->Flags2 |= CONNECTION_FLAGS2_WAIT_ACCEPT;
+
+        } else {
+
+            Connection->Flags |= CONNECTION_FLAGS_READY;
+            INCREMENT_COUNTER (Connection->Provider, OpenConnections);
+
+            Connection->Flags2 |= CONNECTION_FLAGS2_REQ_COMPLETED;
+
+            StReferenceConnection("Listen completed", Connection);
+
+        }
+
+        //
+        // We have a completed connection with a queued listen. Complete
+        // the listen and let the user do an accept at some time down the
+        // road.
+        //
+
+        RELEASE_SPIN_LOCK (&Connection->SpinLock, oldirql);
+
+        request = CONTAINING_RECORD (p, TP_REQUEST, Linkage);
+        request->IoRequestPacket->CancelRoutine = (PDRIVER_CANCEL)NULL;
+        IoReleaseCancelSpinLock (cancelirql);
+
+        irpSp = IoGetCurrentIrpStackLocation (request->IoRequestPacket);
+        remoteInformation =
+            ((PTDI_REQUEST_KERNEL)(&irpSp->Parameters))->ReturnConnectionInformation;
+        if (remoteInformation != NULL) {
+            try {
+                if (remoteInformation->RemoteAddressLength != 0) {
+
+                    //
+                    // Build a temporary TA_NETBIOS_ADDRESS, then
+                    // copy over as many bytes as fit.
+                    //
+
+                    TdiBuildNetbiosAddress(
+                        Connection->CalledAddress.NetbiosName,
+                        (BOOLEAN)(Connection->CalledAddress.NetbiosNameType ==
+                            TDI_ADDRESS_NETBIOS_TYPE_GROUP),
+                        &TempAddress);
+
+                    if (remoteInformation->RemoteAddressLength >=
+                                           sizeof (TA_NETBIOS_ADDRESS)) {
+
+                        returnLength = sizeof(TA_NETBIOS_ADDRESS);
+                        remoteInformation->RemoteAddressLength = returnLength;
+
+                    } else {
+
+                        returnLength = remoteInformation->RemoteAddressLength;
+
+                    }
+
+                    RtlCopyMemory(
+                        (PTA_NETBIOS_ADDRESS)remoteInformation->RemoteAddress,
+                        &TempAddress,
+                        returnLength);
+
+                } else {
+
+                    returnLength = 0;
+                }
+
+                status = STATUS_SUCCESS;
+
+            } except (EXCEPTION_EXECUTE_HANDLER) {
+
+                returnLength = 0;
+                status = GetExceptionCode ();
+
+            }
+
+        } else {
+
+            status = STATUS_SUCCESS;
+            returnLength = 0;
+
+        }
+
+        //
+        // Don't clear this until now, so that the connection is all
+        // set up before we allow more indications.
+        //
+
+        Connection->IndicationInProgress = FALSE;
+
+        StCompleteRequest (request, status, 0);
+
+    }
+
+
+    //
+    // Before we continue, store the remote guy's transport address
+    // into the TdiListen's TRANSPORT_CONNECTION buffer.  This allows
+    // the client to determine who called him.
+    //
+
+    Connection->CalledAddress.NetbiosNameType = TDI_ADDRESS_NETBIOS_TYPE_UNIQUE;
+    NdisMoveFromMappedMemory(
+        Connection->CalledAddress.NetbiosName,
+        Header->Source,
+        16);
+
+    NdisMoveFromMappedMemory(
+        Connection->RemoteName,
+        Header->Source,
+        16);
+
+    Connection->Flags2 |= CONNECTION_FLAGS2_REMOTE_VALID;
+
+    if (ConnectIndicationBlocked) {
+        addressFile->ConnectIndicationInProgress = FALSE;
+    }
+
+    StDereferenceConnection("ProcessNameQuery done", Connection);
+
+    return STATUS_ABANDONED;
+
+}   /* StProcessConnect */
+
+
+NTSTATUS
+StProcessConnectionless(
+    IN PDEVICE_CONTEXT DeviceContext,
+    IN PHARDWARE_ADDRESS SourceAddress,
+    IN PST_HEADER StHeader,
+    IN ULONG StLength,
+    IN PUCHAR SourceRouting,
+    IN UINT SourceRoutingLength,
+    OUT PTP_ADDRESS * DatagramAddress
+    )
+
+/*++
+
+Routine Description:
+
+    This routine receives control from the data link provider as an
+    indication that a connectionless frame has been received on the data link.
+    Here we dispatch to the correct handler.
+
+Arguments:
+
+    DeviceContext - Pointer to our device context.
+
+    SourceAddress - Pointer to the source hardware address in the received
+        frame.
+
+    StHeader - Points to the ST header of the incoming packet.
+
+    StLength - Actual length in bytes of the packet, starting at the
+        StHeader.
+
+    SourceRouting - Source routing information in the MAC header.
+
+    SourceRoutingLength - The length of SourceRouting.
+
+    DatagramAddress - If this function returns STATUS_MORE_PROCESSING_
+        REQUIRED, this will be the address the datagram should be
+        indicated to.
+
+Return Value:
+
+    NTSTATUS - status of operation.
+
+--*/
+
+{
+    PTP_ADDRESS Address;
+    KIRQL oldirql;
+    NTSTATUS status;
+    PLIST_ENTRY Flink;
+    BOOLEAN MatchedAddress;
+    PUCHAR MatchName;
+
+    //
+    // Verify that this frame is long enough to examine.
+    //
+
+    if (StLength < sizeof(ST_HEADER)) {
+        return STATUS_ABANDONED;        // frame too small.
+    }
+
+    //
+    // We have a valid connectionless protocol frame that's not a
+    // datagram, so deliver it to every address which matches the
+    // destination name in the frame.
+    //
+
+    MatchedAddress = FALSE;
+
+    //
+    // Search for the address; for broadcast datagrams we
+    // search for the special "broadcast" address.
+    //
+
+    if ((StHeader->Command == ST_CMD_DATAGRAM) &&
+        (StHeader->Flags & ST_FLAGS_BROADCAST)) {
+
+        MatchName = NULL;
+
+    } else {
+
+        MatchName = StHeader->Destination;
+
+    }
+
+    ACQUIRE_SPIN_LOCK (&DeviceContext->SpinLock, &oldirql);
+
+    for (Flink = DeviceContext->AddressDatabase.Flink;
+         Flink != &DeviceContext->AddressDatabase;
+         Flink = Flink->Flink) {
+
+        Address = CONTAINING_RECORD (
+                    Flink,
+                    TP_ADDRESS,
+                    Linkage);
+
+        if ((Address->Flags & ADDRESS_FLAGS_STOPPING) != 0) {
+            continue;
+        }
+
+        if (StMatchNetbiosAddress (Address, MatchName)) {
+
+            StReferenceAddress ("UI Frame", Address);   // prevent address from being destroyed.
+            MatchedAddress = TRUE;
+            break;
+
+        }
+    }
+
+    RELEASE_SPIN_LOCK (&DeviceContext->SpinLock, oldirql);
+
+    if (MatchedAddress) {
+
+        //
+        // Deliver the frame to the current address.
+        //
+
+        switch (StHeader->Command) {
+
+        case ST_CMD_CONNECT:
+
+            status = StProcessConnect (
+                         DeviceContext,
+                         Address,
+                         StHeader,
+                         SourceAddress,
+                         SourceRouting,
+                         SourceRoutingLength);
+
+            break;
+
+        case ST_CMD_DATAGRAM:
+
+            //
+            // Reference the datagram so it sticks around until the
+            // ReceiveComplete, when it is processed.
+            //
+
+            StReferenceAddress ("Datagram indicated", Address);
+            *DatagramAddress = Address;
+            status = STATUS_MORE_PROCESSING_REQUIRED;
+            break;
+
+        default:
+
+            ASSERT(FALSE);
+
+        } /* switch on frame command code */
+
+        StDereferenceAddress ("Done", Address);     // done with previous address.
+
+    } else {
+
+        status = STATUS_ABANDONED;
+
+    }
+
+    return status;
+
+} /* StProcessConnectionless */
+