ReactOS 0.4.17-dev-966-gf06eace
Classes | Macros | Typedefs | Functions | Variables
afd.h File Reference
#include <ntifs.h>
#include <ndk/obtypes.h>
#include <tdi.h>
#include <tcpioctl.h>
#include <windef.h>
#include <winsock2.h>
#include <afd/shared.h>
#include <pseh/pseh2.h>
#include "tdi_proto.h"
#include "tdiconn.h"
#include "debug.h"
Include dependency graph for afd.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  IPADDR_ENTRY
 
struct  _AFD_MAPBUF
 
struct  _AFD_DEVICE_EXTENSION
 
struct  _AFD_ACTIVE_POLL
 
struct  _IRP_LIST
 
struct  _AFD_TDI_OBJECT
 
struct  _AFD_TDI_OBJECT_QELT
 
struct  _AFD_IN_FLIGHT_REQUEST
 
struct  _AFD_DATA_WINDOW
 
struct  _AFD_STORED_DATAGRAM
 
struct  _AFD_FCB
 

Macros

#define _WINBASE_
 
#define _WINDOWS_H
 
#define _INC_WINDOWS
 
#define MIN(x, y)   (((x)<(y))?(x):(y))
 
#define TL_INSTANCE   0
 
#define IP_MIB_STATS_ID   1
 
#define IP_MIB_ADDRTABLE_ENTRY_ID   0x102
 
#define TAG_AFD_DATA_BUFFER   'BdfA'
 
#define TAG_AFD_TRANSPORT_ADDRESS   'tdfA'
 
#define TAG_AFD_SOCKET_CONTEXT   'XdfA'
 
#define TAG_AFD_CONNECT_DATA   'cdfA'
 
#define TAG_AFD_DISCONNECT_DATA   'ddfA'
 
#define TAG_AFD_CONNECT_OPTIONS   'ocfA'
 
#define TAG_AFD_DISCONNECT_OPTIONS   'odfA'
 
#define TAG_AFD_SUPER_CONNECT_BUFFER   'sdfA'
 
#define TAG_AFD_ACCEPT_QUEUE   'qafA'
 
#define TAG_AFD_POLL_HANDLE   'hpfA'
 
#define TAG_AFD_FCB   'cffA'
 
#define TAG_AFD_ACTIVE_POLL   'pafA'
 
#define TAG_AFD_EA_INFO   'aefA'
 
#define TAG_AFD_STORED_DATAGRAM   'gsfA'
 
#define TAG_AFD_SNMP_ADDRESS_INFO   'asfA'
 
#define TAG_AFD_TDI_CONNECTION_INFORMATION   'cTfA'
 
#define TAG_AFD_WSA_BUFFER   'bWfA'
 
#define DN2H(dw)
 
#define SOCKET_STATE_INVALID_TRANSITION   ((DWORD)-1)
 
#define SOCKET_STATE_CREATED   0
 
#define SOCKET_STATE_BOUND   1
 
#define SOCKET_STATE_CONNECTING   2
 
#define SOCKET_STATE_CONNECTED   3
 
#define SOCKET_STATE_LISTENING   4
 
#define SOCKET_STATE_MASK   0x0000ffff
 
#define SOCKET_STATE_EOF_READ   0x20000000
 
#define SOCKET_STATE_LOCKED   0x40000000
 
#define SOCKET_STATE_NEW   0x80000000
 
#define SOCKET_STATE_CLOSED   0x00000100
 
#define FUNCTION_CONNECT   0
 
#define FUNCTION_RECV   1
 
#define FUNCTION_SEND   2
 
#define FUNCTION_PREACCEPT   3
 
#define FUNCTION_ACCEPT   4
 
#define FUNCTION_DISCONNECT   5
 
#define FUNCTION_CLOSE   6
 
#define FUNCTION_CONNECTEX   7
 
#define MAX_FUNCTIONS   8
 
#define IN_FLIGHT_REQUESTS   5
 
#define EXTRA_LOCK_BUFFERS
 
#define AFD_HANDLES(x)   ((PAFD_HANDLE)(x)->Exclusive)
 
#define SET_AFD_HANDLES(x, y)   (((x)->Exclusive) = (ULONG_PTR)(y))
 

Typedefs

typedef struct IPADDR_ENTRY IPADDR_ENTRY
 
typedef struct IPADDR_ENTRY * PIPADDR_ENTRY
 
typedef struct _AFD_MAPBUF AFD_MAPBUF
 
typedef struct _AFD_MAPBUF * PAFD_MAPBUF
 
typedef struct _AFD_DEVICE_EXTENSION AFD_DEVICE_EXTENSION
 
typedef struct _AFD_DEVICE_EXTENSION * PAFD_DEVICE_EXTENSION
 
typedef struct _AFD_ACTIVE_POLL AFD_ACTIVE_POLL
 
typedef struct _AFD_ACTIVE_POLL * PAFD_ACTIVE_POLL
 
typedef struct _IRP_LIST IRP_LIST
 
typedef struct _IRP_LIST * PIRP_LIST
 
typedef struct _AFD_TDI_OBJECT AFD_TDI_OBJECT
 
typedef struct _AFD_TDI_OBJECT * PAFD_TDI_OBJECT
 
typedef struct _AFD_TDI_OBJECT_QELT AFD_TDI_OBJECT_QELT
 
typedef struct _AFD_TDI_OBJECT_QELT * PAFD_TDI_OBJECT_QELT
 
typedef struct _AFD_IN_FLIGHT_REQUEST AFD_IN_FLIGHT_REQUEST
 
typedef struct _AFD_IN_FLIGHT_REQUEST * PAFD_IN_FLIGHT_REQUEST
 
typedef struct _AFD_DATA_WINDOW AFD_DATA_WINDOW
 
typedef struct _AFD_DATA_WINDOW * PAFD_DATA_WINDOW
 
typedef struct _AFD_STORED_DATAGRAM AFD_STORED_DATAGRAM
 
typedef struct _AFD_STORED_DATAGRAM * PAFD_STORED_DATAGRAM
 
typedef struct _AFD_FCB AFD_FCB
 
typedef struct _AFD_FCB * PAFD_FCB
 

Functions

NTSTATUS WarmSocketForBind (PAFD_FCB FCB, ULONG ShareType)
 
NTSTATUS NTAPI AfdBindSocket (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS MakeSocketIntoConnection (PAFD_FCB FCB, BOOL Receive)
 
NTSTATUS WarmSocketForConnection (PAFD_FCB FCB)
 
NTSTATUS NTAPI AfdStreamSocketConnect (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdStreamSocketSuperConnect (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdGetConnectData (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdSetConnectData (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdSetConnectDataSize (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdGetConnectOptions (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdSetConnectOptions (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdSetConnectOptionsSize (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdGetContext (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdGetContextSize (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdSetContext (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdGetInfo (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdSetInfo (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdGetSockName (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdGetPeerName (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS AfdWaitForListen (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS AfdListenSocket (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS AfdAccept (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS AfdSuperAccept (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
PAFD_WSABUF LockBuffers (PAFD_WSABUF Buf, UINT Count, PVOID AddressBuf, PINT AddressLen, BOOLEAN Write, BOOLEAN LockAddress, KPROCESSOR_MODE LockMode)
 
VOID UnlockBuffers (PAFD_WSABUF Buf, UINT Count, BOOL Address)
 
BOOLEAN SocketAcquireStateLock (PAFD_FCB FCB)
 
NTSTATUS NTAPI UnlockAndMaybeComplete (PAFD_FCB FCB, NTSTATUS Status, PIRP Irp, UINT Information)
 
VOID SocketStateUnlock (PAFD_FCB FCB)
 
NTSTATUS LostSocket (PIRP Irp)
 
PAFD_HANDLE LockHandles (PAFD_HANDLE HandleArray, UINT HandleCount)
 
VOID UnlockHandles (PAFD_HANDLE HandleArray, UINT HandleCount)
 
PVOID LockRequest (PIRP Irp, PIO_STACK_LOCATION IrpSp, BOOLEAN Output, KPROCESSOR_MODE *LockMode)
 
VOID UnlockRequest (PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
PVOID GetLockedData (PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS LeaveIrpUntilLater (PAFD_FCB FCB, PIRP Irp, UINT Function)
 
NTSTATUS QueueUserModeIrp (PAFD_FCB FCB, PIRP Irp, UINT Function)
 
VOID OskitDumpBuffer (PCHAR Buffer, UINT Len)
 
VOID DestroySocket (PAFD_FCB FCB)
 
VOID RetryDisconnectCompletion (PAFD_FCB FCB)
 
BOOLEAN CheckUnlockExtraBuffers (PAFD_FCB FCB, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdConnectedSocketReadData (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp, BOOLEAN Short)
 
NTSTATUS NTAPI AfdPacketSocketReadData (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdSelect (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdEventSelect (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
NTSTATUS NTAPI AfdEnumEvents (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 
VOID PollReeval (PAFD_DEVICE_EXTENSION DeviceObject, PFILE_OBJECT FileObject)
 
VOID KillSelectsForFCB (PAFD_DEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, BOOLEAN ExclusiveOnly)
 
VOID ZeroEvents (PAFD_HANDLE HandleArray, UINT HandleCount)
 
VOID SignalSocket (PAFD_ACTIVE_POLL Poll OPTIONAL, PIRP _Irp OPTIONAL, PAFD_POLL_INFO PollReq, NTSTATUS Status)
 
NTSTATUS NTAPI AfdConnectedSocketWriteData (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp, BOOLEAN Short)
 
NTSTATUS NTAPI AfdPacketSocketWriteData (PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
 

Variables

DRIVER_CANCEL AfdCancelHandler
 
IO_COMPLETION_ROUTINE AcceptExReceiveComplete
 
IO_COMPLETION_ROUTINE ReceiveComplete
 
IO_COMPLETION_ROUTINE PacketSocketRecvComplete
 

Macro Definition Documentation

◆ _INC_WINDOWS

#define _INC_WINDOWS

Definition at line 20 of file afd.h.

◆ _WINBASE_

#define _WINBASE_

Definition at line 18 of file afd.h.

◆ _WINDOWS_H

#define _WINDOWS_H

Definition at line 19 of file afd.h.

◆ AFD_HANDLES

#define AFD_HANDLES (   x)    ((PAFD_HANDLE)(x)->Exclusive)

Definition at line 102 of file afd.h.

◆ DN2H

#define DN2H (   dw)
Value:
((((dw) & 0xFF000000L) >> 24) | \
(((dw) & 0x00FF0000L) >> 8) | \
(((dw) & 0x0000FF00L) << 8) | \
(((dw) & 0x000000FFL) << 24))
dw
REFIID LPVOID DWORD_PTR dw
Definition: atlbase.h:40

Definition at line 67 of file afd.h.

◆ EXTRA_LOCK_BUFFERS

#define EXTRA_LOCK_BUFFERS
Value:
2 /* Number of extra buffers needed
* for ancillary data on packet
* requests. */

Definition at line 97 of file afd.h.

◆ FUNCTION_ACCEPT

#define FUNCTION_ACCEPT   4

Definition at line 89 of file afd.h.

◆ FUNCTION_CLOSE

#define FUNCTION_CLOSE   6

Definition at line 91 of file afd.h.

◆ FUNCTION_CONNECT

#define FUNCTION_CONNECT   0

Definition at line 85 of file afd.h.

◆ FUNCTION_CONNECTEX

#define FUNCTION_CONNECTEX   7

Definition at line 92 of file afd.h.

◆ FUNCTION_DISCONNECT

#define FUNCTION_DISCONNECT   5

Definition at line 90 of file afd.h.

◆ FUNCTION_PREACCEPT

#define FUNCTION_PREACCEPT   3

Definition at line 88 of file afd.h.

◆ FUNCTION_RECV

#define FUNCTION_RECV   1

Definition at line 86 of file afd.h.

◆ FUNCTION_SEND

#define FUNCTION_SEND   2

Definition at line 87 of file afd.h.

◆ IN_FLIGHT_REQUESTS

#define IN_FLIGHT_REQUESTS   5

Definition at line 95 of file afd.h.

◆ IP_MIB_ADDRTABLE_ENTRY_ID

#define IP_MIB_ADDRTABLE_ENTRY_ID   0x102

Definition at line 36 of file afd.h.

◆ IP_MIB_STATS_ID

#define IP_MIB_STATS_ID   1

Definition at line 35 of file afd.h.

◆ MAX_FUNCTIONS

#define MAX_FUNCTIONS   8

Definition at line 93 of file afd.h.

◆ MIN

#define MIN (   x,
  y 
)    (((x)<(y))?(x):(y))

Definition at line 31 of file afd.h.

◆ SET_AFD_HANDLES

#define SET_AFD_HANDLES (   x,
  y 
)    (((x)->Exclusive) = (ULONG_PTR)(y))

Definition at line 103 of file afd.h.

◆ SOCKET_STATE_BOUND

#define SOCKET_STATE_BOUND   1

Definition at line 75 of file afd.h.

◆ SOCKET_STATE_CLOSED

#define SOCKET_STATE_CLOSED   0x00000100

Definition at line 83 of file afd.h.

◆ SOCKET_STATE_CONNECTED

#define SOCKET_STATE_CONNECTED   3

Definition at line 77 of file afd.h.

◆ SOCKET_STATE_CONNECTING

#define SOCKET_STATE_CONNECTING   2

Definition at line 76 of file afd.h.

◆ SOCKET_STATE_CREATED

#define SOCKET_STATE_CREATED   0

Definition at line 74 of file afd.h.

◆ SOCKET_STATE_EOF_READ

#define SOCKET_STATE_EOF_READ   0x20000000

Definition at line 80 of file afd.h.

◆ SOCKET_STATE_INVALID_TRANSITION

#define SOCKET_STATE_INVALID_TRANSITION   ((DWORD)-1)

Definition at line 73 of file afd.h.

◆ SOCKET_STATE_LISTENING

#define SOCKET_STATE_LISTENING   4

Definition at line 78 of file afd.h.

◆ SOCKET_STATE_LOCKED

#define SOCKET_STATE_LOCKED   0x40000000

Definition at line 81 of file afd.h.

◆ SOCKET_STATE_MASK

#define SOCKET_STATE_MASK   0x0000ffff

Definition at line 79 of file afd.h.

◆ SOCKET_STATE_NEW

#define SOCKET_STATE_NEW   0x80000000

Definition at line 82 of file afd.h.

◆ TAG_AFD_ACCEPT_QUEUE

#define TAG_AFD_ACCEPT_QUEUE   'qafA'

Definition at line 47 of file afd.h.

◆ TAG_AFD_ACTIVE_POLL

#define TAG_AFD_ACTIVE_POLL   'pafA'

Definition at line 50 of file afd.h.

◆ TAG_AFD_CONNECT_DATA

#define TAG_AFD_CONNECT_DATA   'cdfA'

Definition at line 41 of file afd.h.

◆ TAG_AFD_CONNECT_OPTIONS

#define TAG_AFD_CONNECT_OPTIONS   'ocfA'

Definition at line 44 of file afd.h.

◆ TAG_AFD_DATA_BUFFER

#define TAG_AFD_DATA_BUFFER   'BdfA'

Definition at line 38 of file afd.h.

◆ TAG_AFD_DISCONNECT_DATA

#define TAG_AFD_DISCONNECT_DATA   'ddfA'

Definition at line 42 of file afd.h.

◆ TAG_AFD_DISCONNECT_OPTIONS

#define TAG_AFD_DISCONNECT_OPTIONS   'odfA'

Definition at line 45 of file afd.h.

◆ TAG_AFD_EA_INFO

#define TAG_AFD_EA_INFO   'aefA'

Definition at line 51 of file afd.h.

◆ TAG_AFD_FCB

#define TAG_AFD_FCB   'cffA'

Definition at line 49 of file afd.h.

◆ TAG_AFD_POLL_HANDLE

#define TAG_AFD_POLL_HANDLE   'hpfA'

Definition at line 48 of file afd.h.

◆ TAG_AFD_SNMP_ADDRESS_INFO

#define TAG_AFD_SNMP_ADDRESS_INFO   'asfA'

Definition at line 53 of file afd.h.

◆ TAG_AFD_SOCKET_CONTEXT

#define TAG_AFD_SOCKET_CONTEXT   'XdfA'

Definition at line 40 of file afd.h.

◆ TAG_AFD_STORED_DATAGRAM

#define TAG_AFD_STORED_DATAGRAM   'gsfA'

Definition at line 52 of file afd.h.

◆ TAG_AFD_SUPER_CONNECT_BUFFER

#define TAG_AFD_SUPER_CONNECT_BUFFER   'sdfA'

Definition at line 46 of file afd.h.

◆ TAG_AFD_TDI_CONNECTION_INFORMATION

#define TAG_AFD_TDI_CONNECTION_INFORMATION   'cTfA'

Definition at line 54 of file afd.h.

◆ TAG_AFD_TRANSPORT_ADDRESS

#define TAG_AFD_TRANSPORT_ADDRESS   'tdfA'

Definition at line 39 of file afd.h.

◆ TAG_AFD_WSA_BUFFER

#define TAG_AFD_WSA_BUFFER   'bWfA'

Definition at line 55 of file afd.h.

◆ TL_INSTANCE

#define TL_INSTANCE   0

Definition at line 34 of file afd.h.

Typedef Documentation

◆ AFD_ACTIVE_POLL

typedef struct _AFD_ACTIVE_POLL AFD_ACTIVE_POLL

◆ AFD_DATA_WINDOW

typedef struct _AFD_DATA_WINDOW AFD_DATA_WINDOW

◆ AFD_DEVICE_EXTENSION

typedef struct _AFD_DEVICE_EXTENSION AFD_DEVICE_EXTENSION

◆ AFD_FCB

typedef struct _AFD_FCB AFD_FCB

◆ AFD_IN_FLIGHT_REQUEST

typedef struct _AFD_IN_FLIGHT_REQUEST AFD_IN_FLIGHT_REQUEST

◆ AFD_MAPBUF

typedef struct _AFD_MAPBUF AFD_MAPBUF

◆ AFD_STORED_DATAGRAM

typedef struct _AFD_STORED_DATAGRAM AFD_STORED_DATAGRAM

◆ AFD_TDI_OBJECT

typedef struct _AFD_TDI_OBJECT AFD_TDI_OBJECT

◆ AFD_TDI_OBJECT_QELT

typedef struct _AFD_TDI_OBJECT_QELT AFD_TDI_OBJECT_QELT

◆ IPADDR_ENTRY

typedef struct IPADDR_ENTRY IPADDR_ENTRY

◆ IRP_LIST

typedef struct _IRP_LIST IRP_LIST

◆ PAFD_ACTIVE_POLL

typedef struct _AFD_ACTIVE_POLL * PAFD_ACTIVE_POLL

◆ PAFD_DATA_WINDOW

typedef struct _AFD_DATA_WINDOW * PAFD_DATA_WINDOW

◆ PAFD_DEVICE_EXTENSION

typedef struct _AFD_DEVICE_EXTENSION * PAFD_DEVICE_EXTENSION

◆ PAFD_FCB

typedef struct _AFD_FCB * PAFD_FCB

◆ PAFD_IN_FLIGHT_REQUEST

typedef struct _AFD_IN_FLIGHT_REQUEST * PAFD_IN_FLIGHT_REQUEST

◆ PAFD_MAPBUF

typedef struct _AFD_MAPBUF * PAFD_MAPBUF

◆ PAFD_STORED_DATAGRAM

typedef struct _AFD_STORED_DATAGRAM * PAFD_STORED_DATAGRAM

◆ PAFD_TDI_OBJECT

typedef struct _AFD_TDI_OBJECT * PAFD_TDI_OBJECT

◆ PAFD_TDI_OBJECT_QELT

typedef struct _AFD_TDI_OBJECT_QELT * PAFD_TDI_OBJECT_QELT

◆ PIPADDR_ENTRY

typedef struct IPADDR_ENTRY * PIPADDR_ENTRY

◆ PIRP_LIST

typedef struct _IRP_LIST * PIRP_LIST

Function Documentation

◆ AfdAccept()

NTSTATUS AfdAccept ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 470 of file listen.c.

471 {
472 NTSTATUS Status = STATUS_SUCCESS;
473 PFILE_OBJECT FileObject = IrpSp->FileObject;
474 PAFD_DEVICE_EXTENSION DeviceExt =
475 (PAFD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
476 PAFD_FCB FCB = FileObject->FsContext;
477 PAFD_ACCEPT_DATA AcceptData = Irp->AssociatedIrp.SystemBuffer;
478 PLIST_ENTRY PendingConn;
479
480 AFD_DbgPrint(MID_TRACE,("Called\n"));
481
482 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
483
484 FCB->EventSelectDisabled &= ~AFD_EVENT_ACCEPT;
485
486 for( PendingConn = FCB->PendingConnections.Flink;
487 PendingConn != &FCB->PendingConnections;
488 PendingConn = PendingConn->Flink ) {
489 PAFD_TDI_OBJECT_QELT PendingConnObj =
490 CONTAINING_RECORD( PendingConn, AFD_TDI_OBJECT_QELT, ListEntry );
491
492 AFD_DbgPrint(MID_TRACE,("Comparing Seq %u to Q %u\n",
493 AcceptData->SequenceNumber,
494 PendingConnObj->Seq));
495
496 if( PendingConnObj->Seq == AcceptData->SequenceNumber ) {
497 PFILE_OBJECT NewFileObject = NULL;
498
499 RemoveEntryList( PendingConn );
500
501 Status = ObReferenceObjectByHandle
502 ( AcceptData->ListenHandle,
503 FILE_ALL_ACCESS,
504 NULL,
505 KernelMode,
506 (PVOID *)&NewFileObject,
507 NULL );
508
509 if( !NT_SUCCESS(Status) ) return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
510
511 ASSERT(NewFileObject != FileObject);
512 ASSERT(NewFileObject->FsContext != FCB);
513
514 /* We have a pending connection ... complete this irp right away */
515 Status = SatisfyAccept( DeviceExt, Irp, NewFileObject, PendingConnObj, FALSE );
516
517 ObDereferenceObject( NewFileObject );
518
519 AFD_DbgPrint(MID_TRACE,("Completed a wait for accept\n"));
520
521 ExFreePoolWithTag(PendingConnObj, TAG_AFD_ACCEPT_QUEUE);
522
523 if( !IsListEmpty( &FCB->PendingConnections ) )
524 {
525 FCB->PollState |= AFD_EVENT_ACCEPT;
526 FCB->PollStatus[FD_ACCEPT_BIT] = STATUS_SUCCESS;
527 PollReeval( FCB->DeviceExt, FCB->FileObject );
528 } else
529 FCB->PollState &= ~AFD_EVENT_ACCEPT;
530
531 SocketStateUnlock( FCB );
532 return Status;
533 }
534 }
535
536 AFD_DbgPrint(MIN_TRACE,("No connection waiting\n"));
537
538 return UnlockAndMaybeComplete( FCB, STATUS_UNSUCCESSFUL, Irp, 0 );
539}
TAG_AFD_ACCEPT_QUEUE
#define TAG_AFD_ACCEPT_QUEUE
Definition: afd.h:47
PAFD_DEVICE_EXTENSION
struct _AFD_DEVICE_EXTENSION * PAFD_DEVICE_EXTENSION
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
MIN_TRACE
#define MIN_TRACE
Definition: debug.h:14
MID_TRACE
#define MID_TRACE
Definition: debug.h:15
Irp
_In_ PIRP Irp
Definition: csq.h:116
NULL
#define NULL
Definition: types.h:112
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
IrpSp
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4138
SatisfyAccept
static NTSTATUS SatisfyAccept(PAFD_DEVICE_EXTENSION DeviceExt, PIRP Irp, PFILE_OBJECT NewFileObject, PAFD_TDI_OBJECT_QELT Qelt, BOOL SuperAccept)
Definition: listen.c:14
LostSocket
NTSTATUS LostSocket(PIRP Irp)
Definition: lock.c:387
UnlockAndMaybeComplete
NTSTATUS NTAPI UnlockAndMaybeComplete(PAFD_FCB FCB, NTSTATUS Status, PIRP Irp, UINT Information)
Definition: lock.c:375
SocketStateUnlock
VOID SocketStateUnlock(PAFD_FCB FCB)
Definition: lock.c:370
SocketAcquireStateLock
BOOLEAN SocketAcquireStateLock(PAFD_FCB FCB)
Definition: lock.c:360
PollReeval
VOID PollReeval(PAFD_DEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject)
Definition: select.c:407
AFD_DbgPrint
#define AFD_DbgPrint(_t_, _x_)
Definition: debug.h:60
RemoveEntryList
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
IsListEmpty
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
NewFileObject
_Must_inspect_result_ _In_ PFILE_OBJECT NewFileObject
Definition: fsrtlfuncs.h:1357
Status
Status
Definition: gdiplustypes.h:24
ASSERT
#define ASSERT(a)
Definition: mode.c:44
ExFreePoolWithTag
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
KernelMode
#define KernelMode
Definition: asm.h:38
FILE_ALL_ACCESS
#define FILE_ALL_ACCESS
Definition: nt_native.h:651
ObReferenceObjectByHandle
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:493
AFD_EVENT_ACCEPT
#define AFD_EVENT_ACCEPT
Definition: shared.h:226
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
_AFD_ACCEPT_DATA
Definition: shared.h:62
_AFD_DEVICE_EXTENSION
Definition: afd.h:110
_AFD_FCB
Definition: afd.h:161
_AFD_TDI_OBJECT_QELT
Definition: afd.h:136
_AFD_TDI_OBJECT_QELT::Seq
UINT Seq
Definition: afd.h:138
_FCB
Definition: cdstruc.h:902
_FCB::FileObject
PFILE_OBJECT FileObject
Definition: ntfs.h:520
_IO_STACK_LOCATION::FileObject
PFILE_OBJECT FileObject
Definition: iotypes.h:3171
_LIST_ENTRY
Definition: typedefs.h:120
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
STATUS_UNSUCCESSFUL
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2061
FileObject
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550
FD_ACCEPT_BIT
#define FD_ACCEPT_BIT
Definition: winsock2.h:293
PFILE_OBJECT
* PFILE_OBJECT
Definition: iotypes.h:1998
ObDereferenceObject
#define ObDereferenceObject
Definition: obfuncs.h:203

Referenced by AfdDispatch().

◆ AfdBindSocket()

NTSTATUS NTAPI AfdBindSocket ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 76 of file bind.c.

77 {
78 NTSTATUS Status = STATUS_SUCCESS;
79 PFILE_OBJECT FileObject = IrpSp->FileObject;
80 PAFD_FCB FCB = FileObject->FsContext;
81 PAFD_BIND_DATA BindReq;
82 HANDLE UserHandle = NULL;
83
84 UNREFERENCED_PARAMETER(DeviceObject);
85
86 AFD_DbgPrint(MID_TRACE,("Called\n"));
87
88 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
89 if( !(BindReq = LockRequest( Irp, IrpSp, FALSE, NULL )) )
90 return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
91 Irp, 0 );
92
93 if (FCB->SharedData.State != SOCKET_STATE_CREATED)
94 return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
95
96 if (FCB->LocalAddress)
97 {
98 ExFreePoolWithTag(FCB->LocalAddress, TAG_AFD_TRANSPORT_ADDRESS);
99 }
100
101 FCB->LocalAddress = TaCopyTransportAddress( &BindReq->Address );
102
103 if( FCB->LocalAddress )
104 Status = TdiBuildConnectionInfo( &FCB->AddressFrom,
105 FCB->LocalAddress );
106
107 if( NT_SUCCESS(Status) )
108 Status = WarmSocketForBind( FCB, BindReq->ShareType );
109 AFD_DbgPrint(MID_TRACE,("FCB->Flags %x\n", FCB->Flags));
110
111 if (NT_SUCCESS(Status))
112 {
113 Status = ObOpenObjectByPointer(FCB->AddressFile.Object,
114 0,
115 NULL,
116 MAXIMUM_ALLOWED,
117 *IoFileObjectType,
118 Irp->RequestorMode,
119 &UserHandle);
120 if (NT_SUCCESS(Status))
121 FCB->SharedData.State = SOCKET_STATE_BOUND;
122 }
123
124 /* MSAFD relies on us returning the address file handle in the IOSB */
125 return UnlockAndMaybeComplete( FCB, Status, Irp,
126 (ULONG_PTR)UserHandle);
127}
SOCKET_STATE_CREATED
#define SOCKET_STATE_CREATED
Definition: afd.h:74
SOCKET_STATE_BOUND
#define SOCKET_STATE_BOUND
Definition: afd.h:75
TAG_AFD_TRANSPORT_ADDRESS
#define TAG_AFD_TRANSPORT_ADDRESS
Definition: afd.h:39
STATUS_NO_MEMORY
#define STATUS_NO_MEMORY
Definition: d3dkmdt.h:51
WarmSocketForBind
NTSTATUS WarmSocketForBind(PAFD_FCB FCB, ULONG ShareType)
Definition: bind.c:13
LockRequest
PVOID LockRequest(PIRP Irp, PIO_STACK_LOCATION IrpSp, BOOLEAN Output, KPROCESSOR_MODE *LockMode)
Definition: lock.c:24
IoFileObjectType
POBJECT_TYPE IoFileObjectType
Definition: iomgr.c:36
MAXIMUM_ALLOWED
#define MAXIMUM_ALLOWED
Definition: nt_native.h:83
UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:329
ObOpenObjectByPointer
NTSTATUS NTAPI ObOpenObjectByPointer(IN PVOID Object, IN ULONG HandleAttributes, IN PACCESS_STATE PassedAccessState, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PHANDLE Handle)
Definition: obhandle.c:2764
_AFD_BIND_DATA
Definition: shared.h:38
_AFD_BIND_DATA::ShareType
ULONG ShareType
Definition: shared.h:39
_AFD_BIND_DATA::Address
TRANSPORT_ADDRESS Address
Definition: shared.h:40
_FCB::Flags
ULONG Flags
Definition: ntfs.h:536
TdiBuildConnectionInfo
NTSTATUS TdiBuildConnectionInfo(PTDI_CONNECTION_INFORMATION *ConnectionInfo, PTRANSPORT_ADDRESS Name)
Definition: tdiconn.c:247
TaCopyTransportAddress
PTRANSPORT_ADDRESS TaCopyTransportAddress(PTRANSPORT_ADDRESS OtherAddress)
Definition: tdiconn.c:90
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

Referenced by AfdDispatch().

◆ AfdConnectedSocketReadData()

NTSTATUS NTAPI AfdConnectedSocketReadData ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp,
BOOLEAN  Short 
)

Definition at line 446 of file read.c.

447 {
448 NTSTATUS Status = STATUS_INVALID_PARAMETER;
449 PFILE_OBJECT FileObject = IrpSp->FileObject;
450 PAFD_FCB FCB = FileObject->FsContext;
451 PAFD_RECV_INFO RecvReq;
452 UINT TotalBytesCopied = 0;
453 PAFD_STORED_DATAGRAM DatagramRecv;
454 PLIST_ENTRY ListEntry;
455 KPROCESSOR_MODE LockMode;
456
457 UNREFERENCED_PARAMETER(DeviceObject);
458 UNREFERENCED_PARAMETER(Short);
459
460 AFD_DbgPrint(MID_TRACE,("Called on %p\n", FCB));
461
462 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
463
464 FCB->EventSelectDisabled &= ~AFD_EVENT_RECEIVE;
465
466 if( !(FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS) &&
467 FCB->SharedData.State != SOCKET_STATE_CONNECTED &&
468 FCB->SharedData.State != SOCKET_STATE_CONNECTING ) {
469 AFD_DbgPrint(MIN_TRACE,("Called recv on wrong kind of socket (s%x)\n",
470 FCB->SharedData.State));
471 return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER,
472 Irp, 0 );
473 }
474
475 if( !(RecvReq = LockRequest( Irp, IrpSp, FALSE, &LockMode )) )
476 return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
477 Irp, 0 );
478
479 AFD_DbgPrint(MID_TRACE,("Recv flags %x\n", RecvReq->AfdFlags));
480
481 RecvReq->BufferArray = LockBuffers( RecvReq->BufferArray,
482 RecvReq->BufferCount,
483 NULL, NULL,
484 TRUE, FALSE, LockMode );
485
486 if( !RecvReq->BufferArray ) {
487 return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
488 Irp, 0 );
489 }
490
491 if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS )
492 {
493 if (!IsListEmpty(&FCB->DatagramList))
494 {
495 ListEntry = RemoveHeadList(&FCB->DatagramList);
496 DatagramRecv = CONTAINING_RECORD(ListEntry, AFD_STORED_DATAGRAM, ListEntry);
497 Status = SatisfyPacketRecvRequest(FCB, Irp, DatagramRecv,
498 (PUINT)&Irp->IoStatus.Information);
499
500 if (RecvReq->TdiFlags & TDI_RECEIVE_PEEK)
501 {
502 InsertHeadList(&FCB->DatagramList,
503 &DatagramRecv->ListEntry);
504 }
505
506 if (!IsListEmpty(&FCB->DatagramList))
507 {
508 FCB->PollState |= AFD_EVENT_RECEIVE;
509 FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
510 PollReeval( FCB->DeviceExt, FCB->FileObject );
511 }
512 else
513 FCB->PollState &= ~AFD_EVENT_RECEIVE;
514
515 UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE);
516
517 return UnlockAndMaybeComplete(FCB, Status, Irp, Irp->IoStatus.Information);
518 }
519 else if (!(RecvReq->AfdFlags & AFD_OVERLAPPED) &&
520 ((RecvReq->AfdFlags & AFD_IMMEDIATE) || (FCB->NonBlocking)))
521 {
522 AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
523 Status = STATUS_CANT_WAIT;
524 FCB->PollState &= ~AFD_EVENT_RECEIVE;
525 UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, FALSE );
526 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
527 }
528 else
529 {
530 FCB->PollState &= ~AFD_EVENT_RECEIVE;
531 return LeaveIrpUntilLater( FCB, Irp, FUNCTION_RECV );
532 }
533 }
534
535 Irp->IoStatus.Status = STATUS_PENDING;
536 Irp->IoStatus.Information = 0;
537
538 InsertTailList( &FCB->PendingIrpList[FUNCTION_RECV],
539 &Irp->Tail.Overlay.ListEntry );
540
541 /************ From this point, the IRP is not ours ************/
542
543 Status = ReceiveActivity( FCB, Irp );
544
545 if( Status == STATUS_PENDING &&
546 !(RecvReq->AfdFlags & AFD_OVERLAPPED) &&
547 ((RecvReq->AfdFlags & AFD_IMMEDIATE) || (FCB->NonBlocking))) {
548 AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
549 Status = STATUS_CANT_WAIT;
550 TotalBytesCopied = 0;
551 RemoveEntryList( &Irp->Tail.Overlay.ListEntry );
552 UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, FALSE );
553 return UnlockAndMaybeComplete( FCB, Status, Irp,
554 TotalBytesCopied );
555 } else if( Status == STATUS_PENDING ) {
556 AFD_DbgPrint(MID_TRACE,("Leaving read irp\n"));
557 IoMarkIrpPending( Irp );
558 (void)IoSetCancelRoutine(Irp, AfdCancelHandler);
559 } else {
560 AFD_DbgPrint(MID_TRACE,("Completed with status %x\n", Status));
561 }
562
563 SocketStateUnlock( FCB );
564 return Status;
565}
SOCKET_STATE_CONNECTED
#define SOCKET_STATE_CONNECTED
Definition: afd.h:77
FUNCTION_RECV
#define FUNCTION_RECV
Definition: afd.h:86
AfdCancelHandler
DRIVER_CANCEL AfdCancelHandler
Definition: afd.h:313
SOCKET_STATE_CONNECTING
#define SOCKET_STATE_CONNECTING
Definition: afd.h:76
TRUE
#define TRUE
Definition: types.h:120
UnlockBuffers
VOID UnlockBuffers(PAFD_WSABUF Buf, UINT Count, BOOL Address)
Definition: lock.c:289
LockBuffers
PAFD_WSABUF LockBuffers(PAFD_WSABUF Buf, UINT Count, PVOID AddressBuf, PINT AddressLen, BOOLEAN Write, BOOLEAN LockAddress, KPROCESSOR_MODE LockMode)
Definition: lock.c:205
LeaveIrpUntilLater
NTSTATUS LeaveIrpUntilLater(PAFD_FCB FCB, PIRP Irp, UINT Function)
Definition: lock.c:433
LockMode
ULONG LockMode
Definition: env_spec_w32.cpp:8
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
InsertHeadList
#define InsertHeadList(ListHead, Entry)
Definition: env_spec_w32.h:1022
RemoveHeadList
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: fpEnumPrinters.c:23
Short
short Short
Definition: ftraster.c:309
UINT
unsigned int UINT
Definition: sysinfo.c:13
IoMarkIrpPending
IoMarkIrpPending(Irp)
IoSetCancelRoutine
IoSetCancelRoutine(Irp, CancelRoutine)
PUINT
unsigned int * PUINT
Definition: ndis.h:50
SatisfyPacketRecvRequest
static NTSTATUS NTAPI SatisfyPacketRecvRequest(PAFD_FCB FCB, PIRP Irp, PAFD_STORED_DATAGRAM DatagramRecv, PUINT TotalBytesCopied)
Definition: read.c:345
ReceiveActivity
static NTSTATUS ReceiveActivity(PAFD_FCB FCB, PIRP Irp)
Definition: read.c:151
STATUS_CANT_WAIT
#define STATUS_CANT_WAIT
Definition: ntstatus.h:546
AFD_IMMEDIATE
#define AFD_IMMEDIATE
Definition: shared.h:236
AFD_OVERLAPPED
#define AFD_OVERLAPPED
Definition: shared.h:235
AFD_EVENT_RECEIVE
#define AFD_EVENT_RECEIVE
Definition: shared.h:219
AFD_ENDPOINT_CONNECTIONLESS
#define AFD_ENDPOINT_CONNECTIONLESS
Definition: shared.h:169
_AFD_RECV_INFO
Definition: shared.h:94
_AFD_RECV_INFO::BufferCount
ULONG BufferCount
Definition: shared.h:96
_AFD_RECV_INFO::TdiFlags
ULONG TdiFlags
Definition: shared.h:98
_AFD_RECV_INFO::AfdFlags
ULONG AfdFlags
Definition: shared.h:97
_AFD_RECV_INFO::BufferArray
PAFD_WSABUF BufferArray
Definition: shared.h:95
_AFD_STORED_DATAGRAM
Definition: afd.h:154
_AFD_STORED_DATAGRAM::ListEntry
LIST_ENTRY ListEntry
Definition: afd.h:155
TDI_RECEIVE_PEEK
#define TDI_RECEIVE_PEEK
Definition: tdi.h:124
STATUS_PENDING
#define STATUS_PENDING
Definition: telnetd.h:14
FD_READ_BIT
#define FD_READ_BIT
Definition: winsock2.h:287
KPROCESSOR_MODE
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7

Referenced by AfdDispatch().

◆ AfdConnectedSocketWriteData()

NTSTATUS NTAPI AfdConnectedSocketWriteData ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp,
BOOLEAN  Short 
)

Definition at line 329 of file write.c.

330 {
331 NTSTATUS Status = STATUS_SUCCESS;
332 PFILE_OBJECT FileObject = IrpSp->FileObject;
333 PAFD_FCB FCB = FileObject->FsContext;
334 PAFD_SEND_INFO SendReq;
335 UINT TotalBytesCopied = 0, i, SpaceAvail = 0, BytesCopied, SendLength;
336 KPROCESSOR_MODE LockMode;
337
338 UNREFERENCED_PARAMETER(DeviceObject);
339 UNREFERENCED_PARAMETER(Short);
340
341 AFD_DbgPrint(MID_TRACE,("Called on %p\n", FCB));
342
343 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
344
345 FCB->EventSelectDisabled &= ~AFD_EVENT_SEND;
346
347 if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS )
348 {
349 PAFD_SEND_INFO_UDP SendReq;
350 PTDI_CONNECTION_INFORMATION TargetAddress;
351
352 /* Check that the socket is bound */
353 if( FCB->SharedData.State != SOCKET_STATE_BOUND || !FCB->RemoteAddress )
354 {
355 AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
356 return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp,
357 0 );
358 }
359
360 if( !(SendReq = LockRequest( Irp, IrpSp, FALSE, &LockMode )) )
361 return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
362
363 /* Must lock buffers before handing off user data */
364 SendReq->BufferArray = LockBuffers( SendReq->BufferArray,
365 SendReq->BufferCount,
366 NULL, NULL,
367 FALSE, FALSE, LockMode );
368
369 if( !SendReq->BufferArray ) {
370 return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
371 Irp, 0 );
372 }
373
374 Status = TdiBuildConnectionInfo( &TargetAddress, FCB->RemoteAddress );
375
376 if( NT_SUCCESS(Status) ) {
377 FCB->PollState &= ~AFD_EVENT_SEND;
378
379 Status = QueueUserModeIrp(FCB, Irp, FUNCTION_SEND);
380 if (Status == STATUS_PENDING)
381 {
382 if (SendReq->BufferCount > 1)
383 {
384 AFD_DbgPrint(MIN_TRACE,("WARN: More than one buffer %ld\n", SendReq->BufferCount));
385 }
386 Status = TdiSendDatagram(&FCB->SendIrp.InFlightRequest,
387 FCB->AddressFile.Object,
388 SendReq->BufferArray[0].buf,
389 SendReq->BufferArray[0].len,
390 TargetAddress,
391 PacketSocketSendComplete,
392 FCB);
393 if (Status != STATUS_PENDING)
394 {
395 NT_VERIFY(RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]) == &Irp->Tail.Overlay.ListEntry);
396 Irp->IoStatus.Status = Status;
397 Irp->IoStatus.Information = ((Status == STATUS_SUCCESS) ? SendReq->BufferArray[0].len : 0);
398 (void)IoSetCancelRoutine(Irp, NULL);
399 UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
400 UnlockRequest(Irp, IoGetCurrentIrpStackLocation(Irp));
401 IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
402 }
403 }
404
405 ExFreePoolWithTag(TargetAddress, TAG_AFD_TDI_CONNECTION_INFORMATION);
406
407 SocketStateUnlock(FCB);
408
409 return STATUS_PENDING;
410 }
411 else
412 {
413 UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
414 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
415 }
416 }
417
418 if (FCB->PollState & AFD_EVENT_CLOSE)
419 {
420 AFD_DbgPrint(MIN_TRACE,("Connection reset by remote peer\n"));
421
422 /* This is an unexpected remote disconnect */
423 return UnlockAndMaybeComplete(FCB, FCB->PollStatus[FD_CLOSE_BIT], Irp, 0);
424 }
425
426 if (FCB->PollState & AFD_EVENT_ABORT)
427 {
428 AFD_DbgPrint(MIN_TRACE,("Connection aborted\n"));
429
430 /* This is an abortive socket closure on our side */
431 return UnlockAndMaybeComplete(FCB, FCB->PollStatus[FD_CLOSE_BIT], Irp, 0);
432 }
433
434 if (FCB->SendClosed)
435 {
436 AFD_DbgPrint(MIN_TRACE,("No more sends\n"));
437
438 /* This is a graceful send closure */
439 return UnlockAndMaybeComplete(FCB, STATUS_FILE_CLOSED, Irp, 0);
440 }
441
442 if( !(SendReq = LockRequest( Irp, IrpSp, FALSE, &LockMode )) )
443 return UnlockAndMaybeComplete
444 ( FCB, STATUS_NO_MEMORY, Irp, 0 );
445
446 SendReq->BufferArray = LockBuffers( SendReq->BufferArray,
447 SendReq->BufferCount,
448 NULL, NULL,
449 FALSE, FALSE, LockMode );
450
451 if( !SendReq->BufferArray ) {
452 return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
453 Irp, 0 );
454 }
455
456 AFD_DbgPrint(MID_TRACE,("Socket state %u\n", FCB->SharedData.State));
457
458 if( FCB->SharedData.State != SOCKET_STATE_CONNECTED ) {
459 AFD_DbgPrint(MID_TRACE,("Socket not connected\n"));
460 UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
461 return UnlockAndMaybeComplete( FCB, STATUS_INVALID_CONNECTION, Irp, 0 );
462 }
463
464 AFD_DbgPrint(MID_TRACE,("FCB->Send.BytesUsed = %u\n",
465 FCB->Send.BytesUsed));
466
467 SpaceAvail = FCB->Send.Size - FCB->Send.BytesUsed;
468
469 AFD_DbgPrint(MID_TRACE,("We can accept %u bytes\n",
470 SpaceAvail));
471
472 /* Count the total transfer size */
473 SendLength = 0;
474 for (i = 0; i < SendReq->BufferCount; i++)
475 {
476 SendLength += SendReq->BufferArray[i].len;
477 }
478
479 /* Make sure we've got the space */
480 if (SendLength > SpaceAvail)
481 {
482 /* Blocking sockets have to wait here */
483 if (SendLength <= FCB->Send.Size && !((SendReq->AfdFlags & AFD_IMMEDIATE) || (FCB->NonBlocking)))
484 {
485 FCB->PollState &= ~AFD_EVENT_SEND;
486 return LeaveIrpUntilLater(FCB, Irp, FUNCTION_SEND);
487 }
488
489 /* Check if we can send anything */
490 if (SpaceAvail == 0)
491 {
492 FCB->PollState &= ~AFD_EVENT_SEND;
493
494 /* Non-overlapped sockets will fail if we can send nothing */
495 if (!(SendReq->AfdFlags & AFD_OVERLAPPED))
496 {
497 UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
498 return UnlockAndMaybeComplete( FCB, STATUS_CANT_WAIT, Irp, 0 );
499 }
500 else
501 {
502 /* Overlapped sockets just pend */
503 return LeaveIrpUntilLater(FCB, Irp, FUNCTION_SEND);
504 }
505 }
506 }
507
508 for ( i = 0; SpaceAvail > 0 && i < SendReq->BufferCount; i++ )
509 {
510 BytesCopied = MIN(SendReq->BufferArray[i].len, SpaceAvail);
511
512 AFD_DbgPrint(MID_TRACE,("Copying Buffer %u, %p:%u to %p\n",
513 i,
514 SendReq->BufferArray[i].buf,
515 BytesCopied,
516 FCB->Send.Window + FCB->Send.BytesUsed));
517
518 RtlCopyMemory(FCB->Send.Window + FCB->Send.BytesUsed,
519 SendReq->BufferArray[i].buf,
520 BytesCopied);
521
522 TotalBytesCopied += BytesCopied;
523 SpaceAvail -= BytesCopied;
524 FCB->Send.BytesUsed += BytesCopied;
525 }
526
527 Irp->IoStatus.Information = TotalBytesCopied;
528
529 if( TotalBytesCopied == 0 ) {
530 AFD_DbgPrint(MID_TRACE,("Empty send\n"));
531 UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
532 return UnlockAndMaybeComplete
533 ( FCB, STATUS_SUCCESS, Irp, TotalBytesCopied );
534 }
535
536 if (SpaceAvail)
537 {
538 FCB->PollState |= AFD_EVENT_SEND;
539 FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
540 PollReeval( FCB->DeviceExt, FCB->FileObject );
541 }
542 else
543 {
544 FCB->PollState &= ~AFD_EVENT_SEND;
545 }
546
547 /* We use the IRP tail for some temporary storage here */
548 Irp->Tail.Overlay.DriverContext[3] = (PVOID)Irp->IoStatus.Information;
549
550 Status = QueueUserModeIrp(FCB, Irp, FUNCTION_SEND);
551 if (Status == STATUS_PENDING && !FCB->SendIrp.InFlightRequest)
552 {
553 TdiSend(&FCB->SendIrp.InFlightRequest,
554 FCB->Connection.Object,
555 0,
556 FCB->Send.Window,
557 FCB->Send.BytesUsed,
558 SendComplete,
559 FCB);
560 }
561
562 SocketStateUnlock(FCB);
563
564 return STATUS_PENDING;
565}
IoGetCurrentIrpStackLocation
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
Definition: Bus_PDO_EvalMethod.c:152
TAG_AFD_TDI_CONNECTION_INFORMATION
#define TAG_AFD_TDI_CONNECTION_INFORMATION
Definition: afd.h:54
FUNCTION_SEND
#define FUNCTION_SEND
Definition: afd.h:87
MIN
#define MIN(x, y)
Definition: rdesktop.h:171
UnlockRequest
VOID UnlockRequest(PIRP Irp, PIO_STACK_LOCATION IrpSp)
Definition: lock.c:180
QueueUserModeIrp
NTSTATUS QueueUserModeIrp(PAFD_FCB FCB, PIRP Irp, UINT Function)
Definition: lock.c:397
SendComplete
static IO_COMPLETION_ROUTINE SendComplete
Definition: write.c:13
PacketSocketSendComplete
static IO_COMPLETION_ROUTINE PacketSocketSendComplete
Definition: write.c:260
IO_NETWORK_INCREMENT
#define IO_NETWORK_INCREMENT
Definition: tcpip.h:43
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
BytesCopied
_In_ UINT _In_ UINT _In_ PNDIS_PACKET _In_ UINT _Out_ PUINT BytesCopied
Definition: ndis.h:3171
IoCompleteRequest
#define IoCompleteRequest
Definition: irp.c:1272
STATUS_FILE_CLOSED
#define STATUS_FILE_CLOSED
Definition: ntstatus.h:626
STATUS_INVALID_CONNECTION
#define STATUS_INVALID_CONNECTION
Definition: ntstatus.h:650
AFD_EVENT_SEND
#define AFD_EVENT_SEND
Definition: shared.h:221
AFD_EVENT_ABORT
#define AFD_EVENT_ABORT
Definition: shared.h:223
AFD_EVENT_CLOSE
#define AFD_EVENT_CLOSE
Definition: shared.h:224
_AFD_SEND_INFO_UDP
Definition: shared.h:117
_AFD_SEND_INFO_UDP::BufferCount
ULONG BufferCount
Definition: shared.h:119
_AFD_SEND_INFO_UDP::AfdFlags
ULONG AfdFlags
Definition: shared.h:120
_AFD_SEND_INFO_UDP::BufferArray
PAFD_WSABUF BufferArray
Definition: shared.h:118
_AFD_SEND_INFO
Definition: shared.h:110
_AFD_WSABUF::buf
PCHAR buf
Definition: shared.h:18
_AFD_WSABUF::len
UINT len
Definition: shared.h:17
_TDI_CONNECTION_INFORMATION
Definition: tdi.h:39
TdiSendDatagram
NTSTATUS TdiSendDatagram(PIRP *Irp, PFILE_OBJECT TransportObject, PCHAR Buffer, UINT BufferLength, PTDI_CONNECTION_INFORMATION To, PIO_COMPLETION_ROUTINE CompletionRoutine, PVOID CompletionContext)
Sends a datagram.
Definition: tdi.c:1166
TdiSend
NTSTATUS TdiSend(PIRP *Irp, PFILE_OBJECT ConnectionObject, USHORT Flags, PCHAR Buffer, UINT BufferLength, PIO_COMPLETION_ROUTINE CompletionRoutine, PVOID CompletionContext)
Definition: tdi.c:921
PVOID
void * PVOID
Definition: typedefs.h:50
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
FD_CLOSE_BIT
#define FD_CLOSE_BIT
Definition: winsock2.h:297
FD_WRITE_BIT
#define FD_WRITE_BIT
Definition: winsock2.h:289
TargetAddress
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _Inout_ PLARGE_INTEGER _Outptr_ PVOID * TargetAddress
Definition: iotypes.h:1037
NT_VERIFY
#define NT_VERIFY(exp)
Definition: rtlfuncs.h:3311

Referenced by AfdDispatch(), and StreamSocketConnectComplete().

◆ AfdEnumEvents()

NTSTATUS NTAPI AfdEnumEvents ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 328 of file select.c.

329 {
330 PFILE_OBJECT FileObject = IrpSp->FileObject;
331 PAFD_ENUM_NETWORK_EVENTS_INFO EnumReq =
332 (PAFD_ENUM_NETWORK_EVENTS_INFO)LockRequest( Irp, IrpSp, TRUE, NULL );
333 PAFD_FCB FCB = FileObject->FsContext;
334 PKEVENT UserEvent;
335 NTSTATUS Status;
336
337 UNREFERENCED_PARAMETER(DeviceObject);
338
339 AFD_DbgPrint(MID_TRACE,("Called (FCB %p)\n", FCB));
340
341 if( !SocketAcquireStateLock( FCB ) ) {
342 return LostSocket( Irp );
343 }
344
345 if ( !EnumReq ) {
346 return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
347 }
348
349 /* An event may optionally be provided for us to clear */
350 if (EnumReq->Event != NULL)
351 {
352 Status = ObReferenceObjectByHandle(EnumReq->Event,
353 EVENT_ALL_ACCESS,
354 *ExEventObjectType,
355 UserMode,
356 (PVOID *)&UserEvent,
357 NULL);
358 if (!NT_SUCCESS(Status))
359 {
360 AFD_DbgPrint(MIN_TRACE,("Unable to reference event %x\n", Status));
361 return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
362 }
363
364 /* Clear the event */
365 KeClearEvent(UserEvent);
366 ObDereferenceObject(UserEvent);
367 }
368
369 /* Copy the poll state, masking out disabled events */
370 EnumReq->PollEvents = (FCB->PollState & ~FCB->EventSelectDisabled);
371 RtlCopyMemory( EnumReq->EventStatus,
372 FCB->PollStatus,
373 sizeof(EnumReq->EventStatus) );
374
375 /* Disable the events that triggered the select until the reenabling function is called */
376 FCB->EventSelectDisabled |= (FCB->PollState & FCB->EventSelectTriggers);
377
378 return UnlockAndMaybeComplete( FCB, STATUS_SUCCESS, Irp, 0 );
379}
KeClearEvent
VOID NTAPI KeClearEvent(IN PKEVENT Event)
Definition: eventobj.c:22
EVENT_ALL_ACCESS
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
UserMode
#define UserMode
Definition: asm.h:39
ExEventObjectType
POBJECT_TYPE ExEventObjectType
Definition: event.c:18
PAFD_ENUM_NETWORK_EVENTS_INFO
struct _AFD_ENUM_NETWORK_EVENTS_INFO * PAFD_ENUM_NETWORK_EVENTS_INFO
_AFD_ENUM_NETWORK_EVENTS_INFO
Definition: shared.h:145
_AFD_ENUM_NETWORK_EVENTS_INFO::Event
HANDLE Event
Definition: shared.h:146
_AFD_ENUM_NETWORK_EVENTS_INFO::EventStatus
NTSTATUS EventStatus[AFD_MAX_EVENTS]
Definition: shared.h:148
_AFD_ENUM_NETWORK_EVENTS_INFO::PollEvents
ULONG PollEvents
Definition: shared.h:147
_KEVENT
Definition: ketypes.h:879

Referenced by AfdDispatch().

◆ AfdEventSelect()

NTSTATUS NTAPI AfdEventSelect ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 265 of file select.c.

266 {
267 PFILE_OBJECT FileObject = IrpSp->FileObject;
268 NTSTATUS Status = STATUS_NO_MEMORY;
269 PAFD_EVENT_SELECT_INFO EventSelectInfo =
270 (PAFD_EVENT_SELECT_INFO)LockRequest( Irp, IrpSp, FALSE, NULL );
271 PAFD_FCB FCB = FileObject->FsContext;
272
273 UNREFERENCED_PARAMETER(DeviceObject);
274
275 if( !SocketAcquireStateLock( FCB ) ) {
276 return LostSocket( Irp );
277 }
278
279 if ( !EventSelectInfo ) {
280 return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp,
281 0 );
282 }
283 AFD_DbgPrint(MID_TRACE,("Called (Event %p Triggers %u)\n",
284 EventSelectInfo->EventObject,
285 EventSelectInfo->Events));
286
287 if( FCB->EventSelect ) ObDereferenceObject( FCB->EventSelect );
288 FCB->EventSelect = NULL;
289
290 if( EventSelectInfo->EventObject && EventSelectInfo->Events ) {
291 Status = ObReferenceObjectByHandle( (PVOID)EventSelectInfo->
292 EventObject,
293 EVENT_ALL_ACCESS,
294 *ExEventObjectType,
295 UserMode,
296 (PVOID *)&FCB->EventSelect,
297 NULL );
298
299 if( !NT_SUCCESS(Status) )
300 {
301 AFD_DbgPrint(MIN_TRACE,("Failed reference event (0x%x)\n", Status));
302 FCB->EventSelect = NULL;
303 }
304 else
305 FCB->EventSelectTriggers = EventSelectInfo->Events;
306 } else {
307 FCB->EventSelect = NULL;
308 FCB->EventSelectTriggers = 0;
309 Status = STATUS_SUCCESS;
310 }
311
312 if((FCB->EventSelect) &&
313 (FCB->PollState & (FCB->EventSelectTriggers & ~FCB->EventSelectDisabled)))
314 {
315 AFD_DbgPrint(MID_TRACE,("Setting event %p\n", FCB->EventSelect));
316
317 /* Set the application's event */
318 KeSetEvent( FCB->EventSelect, IO_NETWORK_INCREMENT, FALSE );
319 }
320
321 AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
322
323 return UnlockAndMaybeComplete( FCB, Status, Irp,
324 0 );
325}
KeSetEvent
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
PAFD_EVENT_SELECT_INFO
struct _AFD_EVENT_SELECT_INFO * PAFD_EVENT_SELECT_INFO
_AFD_EVENT_SELECT_INFO
Definition: shared.h:140
_AFD_EVENT_SELECT_INFO::EventObject
HANDLE EventObject
Definition: shared.h:141
_AFD_EVENT_SELECT_INFO::Events
ULONG Events
Definition: shared.h:142

Referenced by AfdDispatch().

◆ AfdGetConnectData()

NTSTATUS NTAPI AfdGetConnectData ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 127 of file connect.c.

129{
130 PFILE_OBJECT FileObject = IrpSp->FileObject;
131 PAFD_FCB FCB = FileObject->FsContext;
132 UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
133
134 UNREFERENCED_PARAMETER(DeviceObject);
135
136 if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
137
138 if (FCB->ConnectDataSize == 0)
139 {
140 AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
141 return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
142 }
143
144 ASSERT(FCB->ConnectData);
145
146 if (FCB->FilledConnectData < BufferSize) BufferSize = FCB->FilledConnectData;
147
148 RtlCopyMemory(Irp->UserBuffer,
149 FCB->ConnectData,
150 BufferSize);
151
152 return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, BufferSize);
153}
BufferSize
_In_ ULONG BufferSize
Definition: dispmprt.h:490
_IO_STACK_LOCATION::Parameters
union _IO_STACK_LOCATION::@1803 Parameters
_IO_STACK_LOCATION::DeviceIoControl
struct _IO_STACK_LOCATION::@1803::@1804 DeviceIoControl

Referenced by AfdDispatch().

◆ AfdGetConnectOptions()

NTSTATUS NTAPI AfdGetConnectOptions ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 15 of file connect.c.

17{
18 PFILE_OBJECT FileObject = IrpSp->FileObject;
19 PAFD_FCB FCB = FileObject->FsContext;
20 UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
21
22 UNREFERENCED_PARAMETER(DeviceObject);
23
24 if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
25
26 if (FCB->ConnectOptionsSize == 0)
27 {
28 AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
29 return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
30 }
31
32 ASSERT(FCB->ConnectOptions);
33
34 if (FCB->FilledConnectOptions < BufferSize) BufferSize = FCB->FilledConnectOptions;
35
36 RtlCopyMemory(Irp->UserBuffer,
37 FCB->ConnectOptions,
38 BufferSize);
39
40 return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, BufferSize);
41}

Referenced by AfdDispatch().

◆ AfdGetContext()

NTSTATUS NTAPI AfdGetContext ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 14 of file context.c.

15 {
16 NTSTATUS Status = STATUS_INVALID_PARAMETER;
17 PFILE_OBJECT FileObject = IrpSp->FileObject;
18 PAFD_FCB FCB = FileObject->FsContext;
19 UINT ContextSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
20
21 UNREFERENCED_PARAMETER(DeviceObject);
22
23 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
24
25 if (ContextSize == sizeof(FCB->SharedData))
26 {
27 RtlCopyMemory(Irp->UserBuffer,
28 &FCB->SharedData,
29 ContextSize);
30 Status = STATUS_SUCCESS;
31 }
32 else if (FCB->Context)
33 {
34 ContextSize = min(ContextSize, FCB->ContextSize);
35 RtlCopyMemory( Irp->UserBuffer,
36 FCB->Context,
37 ContextSize );
38 Status = STATUS_SUCCESS;
39 }
40
41 AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
42
43 return UnlockAndMaybeComplete( FCB, Status, Irp, ContextSize );
44}
ContextSize
_Must_inspect_result_ _In_ FLT_CONTEXT_TYPE _In_ SIZE_T ContextSize
Definition: fltkernel.h:1444
min
#define min(a, b)
Definition: monoChain.cc:55

Referenced by AfdDispatch().

◆ AfdGetContextSize()

NTSTATUS NTAPI AfdGetContextSize ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 47 of file context.c.

49{
50 PFILE_OBJECT FileObject = IrpSp->FileObject;
51 PAFD_FCB FCB = FileObject->FsContext;
52
53 UNREFERENCED_PARAMETER(DeviceObject);
54
55 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
56
57 if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
58 {
59 AFD_DbgPrint(MIN_TRACE,("Buffer too small\n"));
60 return UnlockAndMaybeComplete(FCB, STATUS_BUFFER_TOO_SMALL, Irp, sizeof(ULONG));
61 }
62
63 RtlCopyMemory(Irp->UserBuffer,
64 &FCB->ContextSize,
65 sizeof(ULONG));
66
67 return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, sizeof(ULONG));
68}
STATUS_BUFFER_TOO_SMALL
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
ULONG
uint32_t ULONG
Definition: typedefs.h:59

Referenced by AfdDispatch().

◆ AfdGetInfo()

NTSTATUS NTAPI AfdGetInfo ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 14 of file info.c.

15 {
16 NTSTATUS Status = STATUS_SUCCESS;
17 PAFD_INFO InfoReq = LockRequest(Irp, IrpSp, TRUE, NULL);
18 PFILE_OBJECT FileObject = IrpSp->FileObject;
19 PAFD_FCB FCB = FileObject->FsContext;
20 PLIST_ENTRY CurrentEntry;
21
22 UNREFERENCED_PARAMETER(DeviceObject);
23
24 AFD_DbgPrint(MID_TRACE,("Called %p %x\n", InfoReq,
25 InfoReq ? InfoReq->InformationClass : 0));
26
27 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
28
29 if (!InfoReq)
30 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
31
32 _SEH2_TRY {
33 switch( InfoReq->InformationClass ) {
34 case AFD_INFO_RECEIVE_WINDOW_SIZE:
35 InfoReq->Information.Ulong = FCB->Recv.Size;
36 break;
37
38 case AFD_INFO_SEND_WINDOW_SIZE:
39 InfoReq->Information.Ulong = FCB->Send.Size;
40 AFD_DbgPrint(MID_TRACE,("Send window size %u\n", FCB->Send.Size));
41 break;
42
43 case AFD_INFO_GROUP_ID_TYPE:
44 InfoReq->Information.LargeInteger.u.HighPart = FCB->GroupType;
45 InfoReq->Information.LargeInteger.u.LowPart = FCB->GroupID;
46 AFD_DbgPrint(MID_TRACE, ("Group ID: %u Group Type: %u\n", FCB->GroupID, FCB->GroupType));
47 break;
48
49 case AFD_INFO_BLOCKING_MODE:
50 InfoReq->Information.Boolean = FCB->NonBlocking;
51 break;
52
53 case AFD_INFO_INLINING_MODE:
54 InfoReq->Information.Boolean = FCB->OobInline;
55 break;
56
57 case AFD_INFO_RECEIVE_CONTENT_SIZE:
58 InfoReq->Information.Ulong = FCB->Recv.Content - FCB->Recv.BytesUsed;
59 break;
60
61 case AFD_INFO_SENDS_IN_PROGRESS:
62 InfoReq->Information.Ulong = 0;
63
64 /* Count the queued sends */
65 CurrentEntry = FCB->PendingIrpList[FUNCTION_SEND].Flink;
66 while (CurrentEntry != &FCB->PendingIrpList[FUNCTION_SEND])
67 {
68 InfoReq->Information.Ulong++;
69 CurrentEntry = CurrentEntry->Flink;
70 }
71
72 /* This needs to count too because when this is dispatched
73 * the user-mode IRP has already been completed and therefore
74 * will NOT be in our pending IRP list. We count this as one send
75 * outstanding although it could be multiple since we batch sends
76 * when waiting for the in flight request to return, so this number
77 * may not be accurate but it really doesn't matter that much since
78 * it's more or less a zero/non-zero comparison to determine whether
79 * we can shutdown the socket
80 */
81 if (FCB->SendIrp.InFlightRequest)
82 InfoReq->Information.Ulong++;
83 break;
84
85 default:
86 AFD_DbgPrint(MIN_TRACE,("Unknown info id %x\n",
87 InfoReq->InformationClass));
88 Status = STATUS_INVALID_PARAMETER;
89 break;
90 }
91 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
92 AFD_DbgPrint(MIN_TRACE,("Exception executing GetInfo\n"));
93 Status = STATUS_INVALID_PARAMETER;
94 } _SEH2_END;
95
96 AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
97
98 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
99}
EXCEPTION_EXECUTE_HANDLER
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
_SEH2_EXCEPT
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:104
_SEH2_END
#define _SEH2_END
Definition: pseh2_64.h:194
_SEH2_TRY
#define _SEH2_TRY
Definition: pseh2_64.h:93
AFD_INFO_SEND_WINDOW_SIZE
#define AFD_INFO_SEND_WINDOW_SIZE
Definition: shared.h:202
AFD_INFO_RECEIVE_WINDOW_SIZE
#define AFD_INFO_RECEIVE_WINDOW_SIZE
Definition: shared.h:201
AFD_INFO_RECEIVE_CONTENT_SIZE
#define AFD_INFO_RECEIVE_CONTENT_SIZE
Definition: shared.h:204
AFD_INFO_BLOCKING_MODE
#define AFD_INFO_BLOCKING_MODE
Definition: shared.h:199
AFD_INFO_SENDS_IN_PROGRESS
#define AFD_INFO_SENDS_IN_PROGRESS
Definition: shared.h:200
AFD_INFO_INLINING_MODE
#define AFD_INFO_INLINING_MODE
Definition: shared.h:198
AFD_INFO_GROUP_ID_TYPE
#define AFD_INFO_GROUP_ID_TYPE
Definition: shared.h:203
_AFD_INFO
Definition: shared.h:28
_AFD_INFO::InformationClass
ULONG InformationClass
Definition: shared.h:29
_AFD_INFO::Ulong
ULONG Ulong
Definition: shared.h:31
_AFD_INFO::Information
union _AFD_INFO::@4118 Information
_AFD_INFO::Boolean
BOOLEAN Boolean
Definition: shared.h:33
_AFD_INFO::LargeInteger
LARGE_INTEGER LargeInteger
Definition: shared.h:32
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_LARGE_INTEGER::u
struct _LARGE_INTEGER::@2736 u

Referenced by AfdDispatch().

◆ AfdGetPeerName()

NTSTATUS NTAPI AfdGetPeerName ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 281 of file info.c.

282 {
283 NTSTATUS Status;
284 PFILE_OBJECT FileObject = IrpSp->FileObject;
285 PAFD_FCB FCB = FileObject->FsContext;
286
287 UNREFERENCED_PARAMETER(DeviceObject);
288
289 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
290
291 if (FCB->RemoteAddress == NULL) {
292 AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
293 return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
294 }
295
296 if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength >= TaLengthOfTransportAddress(FCB->RemoteAddress))
297 {
298 RtlCopyMemory(Irp->UserBuffer, FCB->RemoteAddress, TaLengthOfTransportAddress(FCB->RemoteAddress));
299 Status = STATUS_SUCCESS;
300 }
301 else
302 {
303 AFD_DbgPrint(MIN_TRACE,("Buffer too small\n"));
304 Status = STATUS_BUFFER_TOO_SMALL;
305 }
306
307 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
308}
TaLengthOfTransportAddress
UINT TaLengthOfTransportAddress(PTRANSPORT_ADDRESS Addr)
Definition: tdiconn.c:56

Referenced by AfdDispatch().

◆ AfdGetSockName()

NTSTATUS NTAPI AfdGetSockName ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 232 of file info.c.

233 {
234 NTSTATUS Status = STATUS_SUCCESS;
235 PFILE_OBJECT FileObject = IrpSp->FileObject;
236 PAFD_FCB FCB = FileObject->FsContext;
237 PMDL Mdl = NULL;
238
239 UNREFERENCED_PARAMETER(DeviceObject);
240 ASSERT(Irp->MdlAddress == NULL);
241
242 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
243
244 if( FCB->AddressFile.Object == NULL && FCB->Connection.Object == NULL ) {
245 return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
246 }
247
248 Mdl = IoAllocateMdl( Irp->UserBuffer,
249 IrpSp->Parameters.DeviceIoControl.OutputBufferLength,
250 FALSE,
251 FALSE,
252 NULL );
253
254 if( Mdl != NULL ) {
255 _SEH2_TRY {
256 MmProbeAndLockPages( Mdl, Irp->RequestorMode, IoModifyAccess );
257 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
258 AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
259 Status = _SEH2_GetExceptionCode();
260 } _SEH2_END;
261
262 if( NT_SUCCESS(Status) ) {
263 Status = TdiQueryInformation( FCB->Connection.Object
264 ? FCB->Connection.Object
265 : FCB->AddressFile.Object,
266 TDI_QUERY_ADDRESS_INFO,
267 Mdl );
268 }
269
270 /* Check if MmProbeAndLockPages or TdiQueryInformation failed and
271 * clean up Mdl */
272 if (!NT_SUCCESS(Status) && Irp->MdlAddress != Mdl)
273 IoFreeMdl(Mdl);
274 } else
275 Status = STATUS_INSUFFICIENT_RESOURCES;
276
277 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
278}
IoFreeMdl
#define IoFreeMdl
Definition: fxmdl.h:89
IoAllocateMdl
#define IoAllocateMdl
Definition: fxmdl.h:88
MmProbeAndLockPages
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:931
_SEH2_GetExceptionCode
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:204
TDI_QUERY_ADDRESS_INFO
#define TDI_QUERY_ADDRESS_INFO
Definition: tdi.h:181
TdiQueryInformation
NTSTATUS TdiQueryInformation(PFILE_OBJECT FileObject, LONG QueryType, PMDL MdlBuffer)
Query for information.
Definition: tdi.c:691
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
Mdl
_In_ WDFDEVICE _In_ PVOID _In_opt_ PMDL Mdl
Definition: wdfdmatransaction.h:89
IoModifyAccess
@ IoModifyAccess
Definition: ketypes.h:933

Referenced by AfdDispatch().

◆ AfdListenSocket()

NTSTATUS AfdListenSocket ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 358 of file listen.c.

359 {
360 NTSTATUS Status = STATUS_SUCCESS;
361 PFILE_OBJECT FileObject = IrpSp->FileObject;
362 PAFD_FCB FCB = FileObject->FsContext;
363 PAFD_LISTEN_DATA ListenReq;
364
365 UNREFERENCED_PARAMETER(DeviceObject);
366
367 AFD_DbgPrint(MID_TRACE,("Called on %p\n", FCB));
368
369 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
370
371 if( !(ListenReq = LockRequest( Irp, IrpSp, FALSE, NULL )) )
372 return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp,
373 0 );
374
375 if( FCB->SharedData.State != SOCKET_STATE_BOUND ) {
376 Status = STATUS_INVALID_PARAMETER;
377 AFD_DbgPrint(MIN_TRACE,("Could not listen an unbound socket\n"));
378 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
379 }
380
381 FCB->DelayedAccept = ListenReq->UseDelayedAcceptance;
382
383 AFD_DbgPrint(MID_TRACE,("ADDRESSFILE: %p\n", FCB->AddressFile.Handle));
384
385 Status = WarmSocketForConnection( FCB );
386
387 AFD_DbgPrint(MID_TRACE,("Status from warmsocket %x\n", Status));
388
389 if( !NT_SUCCESS(Status) ) return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
390
391 Status = TdiBuildNullConnectionInfo
392 ( &FCB->ListenIrp.ConnectionCallInfo,
393 FCB->LocalAddress->Address[0].AddressType );
394
395 if (!NT_SUCCESS(Status)) return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
396
397 Status = TdiBuildNullConnectionInfo
398 ( &FCB->ListenIrp.ConnectionReturnInfo,
399 FCB->LocalAddress->Address[0].AddressType );
400
401 if (!NT_SUCCESS(Status))
402 {
403 ExFreePoolWithTag(FCB->ListenIrp.ConnectionCallInfo,
404 TAG_AFD_TDI_CONNECTION_INFORMATION);
405
406 FCB->ListenIrp.ConnectionCallInfo = NULL;
407 return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
408 }
409
410 FCB->SharedData.State = SOCKET_STATE_LISTENING;
411
412 Status = TdiListen( &FCB->ListenIrp.InFlightRequest,
413 FCB->Connection.Object,
414 &FCB->ListenIrp.ConnectionCallInfo,
415 &FCB->ListenIrp.ConnectionReturnInfo,
416 ListenComplete,
417 FCB );
418
419 if( Status == STATUS_PENDING )
420 Status = STATUS_SUCCESS;
421
422 AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
423 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
424}
SOCKET_STATE_LISTENING
#define SOCKET_STATE_LISTENING
Definition: afd.h:78
WarmSocketForConnection
NTSTATUS WarmSocketForConnection(PAFD_FCB FCB)
Definition: connect.c:238
ListenComplete
static IO_COMPLETION_ROUTINE ListenComplete
Definition: listen.c:216
_AFD_LISTEN_DATA
Definition: shared.h:43
_AFD_LISTEN_DATA::UseDelayedAcceptance
BOOLEAN UseDelayedAcceptance
Definition: shared.h:46
TdiBuildNullConnectionInfo
NTSTATUS TdiBuildNullConnectionInfo(PTDI_CONNECTION_INFORMATION *ConnectionInfo, ULONG Type)
Builds a NULL TDI connection information structure.
Definition: tdiconn.c:181
TdiListen
NTSTATUS TdiListen(PIRP *Irp, PFILE_OBJECT ConnectionObject, PTDI_CONNECTION_INFORMATION *RequestConnectionInfo, PTDI_CONNECTION_INFORMATION *ReturnConnectionInfo, PIO_COMPLETION_ROUTINE CompletionRoutine, PVOID CompletionContext)
Listen on a connection endpoint for a connection request from a remote peer.
Definition: tdi.c:461

Referenced by AfdDispatch().

◆ AfdPacketSocketReadData()

NTSTATUS NTAPI AfdPacketSocketReadData ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 727 of file read.c.

728 {
729 NTSTATUS Status = STATUS_SUCCESS;
730 PFILE_OBJECT FileObject = IrpSp->FileObject;
731 PAFD_FCB FCB = FileObject->FsContext;
732 PAFD_RECV_INFO_UDP RecvReq;
733 PLIST_ENTRY ListEntry;
734 PAFD_STORED_DATAGRAM DatagramRecv;
735 KPROCESSOR_MODE LockMode;
736
737 UNREFERENCED_PARAMETER(DeviceObject);
738
739 AFD_DbgPrint(MID_TRACE,("Called on %p\n", FCB));
740
741 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
742
743 FCB->EventSelectDisabled &= ~AFD_EVENT_RECEIVE;
744
745 /* Check that the socket is bound */
746 if( FCB->SharedData.State != SOCKET_STATE_BOUND )
747 {
748 AFD_DbgPrint(MIN_TRACE,("Invalid socket state\n"));
749 return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
750 }
751
752 if (FCB->TdiReceiveClosed)
753 {
754 AFD_DbgPrint(MIN_TRACE,("Receive closed\n"));
755 return UnlockAndMaybeComplete(FCB, STATUS_FILE_CLOSED, Irp, 0);
756 }
757
758 if( !(RecvReq = LockRequest( Irp, IrpSp, FALSE, &LockMode )) )
759 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
760
761 AFD_DbgPrint(MID_TRACE,("Recv flags %x\n", RecvReq->AfdFlags));
762
763 RecvReq->BufferArray = LockBuffers( RecvReq->BufferArray,
764 RecvReq->BufferCount,
765 RecvReq->Address,
766 RecvReq->AddressLength,
767 TRUE, TRUE, LockMode );
768
769 if( !RecvReq->BufferArray ) { /* access violation in userspace */
770 return UnlockAndMaybeComplete(FCB, STATUS_ACCESS_VIOLATION, Irp, 0);
771 }
772
773 if (!IsListEmpty(&FCB->DatagramList))
774 {
775 ListEntry = RemoveHeadList(&FCB->DatagramList);
776 DatagramRecv = CONTAINING_RECORD(ListEntry, AFD_STORED_DATAGRAM, ListEntry);
777 Status = SatisfyPacketRecvRequest(FCB, Irp, DatagramRecv,
778 (PUINT)&Irp->IoStatus.Information);
779
780 if (RecvReq->TdiFlags & TDI_RECEIVE_PEEK)
781 {
782 InsertHeadList(&FCB->DatagramList,
783 &DatagramRecv->ListEntry);
784 }
785
786 if (!IsListEmpty(&FCB->DatagramList))
787 {
788 FCB->PollState |= AFD_EVENT_RECEIVE;
789 FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
790 PollReeval( FCB->DeviceExt, FCB->FileObject );
791 }
792 else
793 FCB->PollState &= ~AFD_EVENT_RECEIVE;
794
795 UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, TRUE);
796
797 return UnlockAndMaybeComplete(FCB, Status, Irp, Irp->IoStatus.Information);
798 }
799 else if (!(RecvReq->AfdFlags & AFD_OVERLAPPED) &&
800 ((RecvReq->AfdFlags & AFD_IMMEDIATE) || (FCB->NonBlocking)))
801 {
802 AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
803 Status = STATUS_CANT_WAIT;
804 FCB->PollState &= ~AFD_EVENT_RECEIVE;
805 UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, TRUE );
806 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
807 }
808 else
809 {
810 FCB->PollState &= ~AFD_EVENT_RECEIVE;
811 return LeaveIrpUntilLater( FCB, Irp, FUNCTION_RECV );
812 }
813}
_AFD_RECV_INFO_UDP
Definition: shared.h:101
_AFD_RECV_INFO_UDP::AfdFlags
ULONG AfdFlags
Definition: shared.h:104
_AFD_RECV_INFO_UDP::AddressLength
PINT AddressLength
Definition: shared.h:107
_AFD_RECV_INFO_UDP::BufferCount
ULONG BufferCount
Definition: shared.h:103
_AFD_RECV_INFO_UDP::Address
PVOID Address
Definition: shared.h:106
_AFD_RECV_INFO_UDP::TdiFlags
ULONG TdiFlags
Definition: shared.h:105
_AFD_RECV_INFO_UDP::BufferArray
PAFD_WSABUF BufferArray
Definition: shared.h:102

Referenced by AfdDispatch().

◆ AfdPacketSocketWriteData()

NTSTATUS NTAPI AfdPacketSocketWriteData ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 568 of file write.c.

569 {
570 NTSTATUS Status = STATUS_SUCCESS;
571 PTDI_CONNECTION_INFORMATION TargetAddress;
572 PFILE_OBJECT FileObject = IrpSp->FileObject;
573 PAFD_FCB FCB = FileObject->FsContext;
574 PAFD_SEND_INFO_UDP SendReq;
575 KPROCESSOR_MODE LockMode;
576
577 UNREFERENCED_PARAMETER(DeviceObject);
578
579 AFD_DbgPrint(MID_TRACE,("Called on %p\n", FCB));
580
581 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
582
583 FCB->EventSelectDisabled &= ~AFD_EVENT_SEND;
584
585 /* Check that the socket is bound */
586 if( FCB->SharedData.State != SOCKET_STATE_BOUND &&
587 FCB->SharedData.State != SOCKET_STATE_CREATED)
588 {
589 AFD_DbgPrint(MIN_TRACE,("Invalid socket state\n"));
590 return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
591 }
592
593 if (FCB->SendClosed)
594 {
595 AFD_DbgPrint(MIN_TRACE,("No more sends\n"));
596 return UnlockAndMaybeComplete(FCB, STATUS_FILE_CLOSED, Irp, 0);
597 }
598
599 if( !(SendReq = LockRequest( Irp, IrpSp, FALSE, &LockMode )) )
600 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
601
602 if (FCB->SharedData.State == SOCKET_STATE_CREATED)
603 {
604 if (FCB->LocalAddress)
605 {
606 ExFreePoolWithTag(FCB->LocalAddress, TAG_AFD_TRANSPORT_ADDRESS);
607 }
608
609 FCB->LocalAddress =
610 TaBuildNullTransportAddress( ((PTRANSPORT_ADDRESS)SendReq->TdiConnection.RemoteAddress)->
611 Address[0].AddressType );
612
613 if( FCB->LocalAddress ) {
614 Status = WarmSocketForBind( FCB, AFD_SHARE_WILDCARD );
615
616 if( NT_SUCCESS(Status) )
617 FCB->SharedData.State = SOCKET_STATE_BOUND;
618 else
619 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
620 } else
621 return UnlockAndMaybeComplete
622 ( FCB, STATUS_NO_MEMORY, Irp, 0 );
623 }
624
625 SendReq->BufferArray = LockBuffers( SendReq->BufferArray,
626 SendReq->BufferCount,
627 NULL, NULL,
628 FALSE, FALSE, LockMode );
629
630 if( !SendReq->BufferArray )
631 return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
632 Irp, 0 );
633
634 AFD_DbgPrint
635 (MID_TRACE,("RemoteAddress #%d Type %u\n",
636 ((PTRANSPORT_ADDRESS)SendReq->TdiConnection.RemoteAddress)->
637 TAAddressCount,
638 ((PTRANSPORT_ADDRESS)SendReq->TdiConnection.RemoteAddress)->
639 Address[0].AddressType));
640
641 Status = TdiBuildConnectionInfo( &TargetAddress,
642 ((PTRANSPORT_ADDRESS)SendReq->TdiConnection.RemoteAddress) );
643
644 /* Check the size of the Address given ... */
645
646 if( NT_SUCCESS(Status) ) {
647 FCB->PollState &= ~AFD_EVENT_SEND;
648
649 Status = QueueUserModeIrp(FCB, Irp, FUNCTION_SEND);
650 if (Status == STATUS_PENDING)
651 {
652 if (SendReq->BufferCount > 1)
653 {
654 AFD_DbgPrint(MIN_TRACE,("WARN: More than one buffer %ld\n", SendReq->BufferCount));
655 }
656 Status = TdiSendDatagram(&FCB->SendIrp.InFlightRequest,
657 FCB->AddressFile.Object,
658 SendReq->BufferArray[0].buf,
659 SendReq->BufferArray[0].len,
660 TargetAddress,
661 PacketSocketSendComplete,
662 FCB);
663 if (Status != STATUS_PENDING)
664 {
665 NT_VERIFY(RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]) == &Irp->Tail.Overlay.ListEntry);
666 Irp->IoStatus.Status = Status;
667 Irp->IoStatus.Information = ((Status == STATUS_SUCCESS) ? SendReq->BufferArray[0].len : 0);
668 (void)IoSetCancelRoutine(Irp, NULL);
669 UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
670 UnlockRequest(Irp, IoGetCurrentIrpStackLocation(Irp));
671 IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
672 }
673 }
674
675 ExFreePoolWithTag(TargetAddress, TAG_AFD_TDI_CONNECTION_INFORMATION);
676
677 SocketStateUnlock(FCB);
678
679 return STATUS_PENDING;
680 }
681 else
682 {
683 UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
684 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
685 }
686}
AFD_SHARE_WILDCARD
#define AFD_SHARE_WILDCARD
Definition: netio.c:69
Address
static WCHAR Address[46]
Definition: ping.c:68
_AFD_SEND_INFO_UDP::TdiConnection
TDI_CONNECTION_INFORMATION TdiConnection
Definition: shared.h:122
_TDI_CONNECTION_INFORMATION::RemoteAddress
PVOID RemoteAddress
Definition: tdi.h:45
_TRANSPORT_ADDRESS
Definition: tdi.h:375
TaBuildNullTransportAddress
PTRANSPORT_ADDRESS TaBuildNullTransportAddress(UINT AddressType)
Definition: tdiconn.c:123

Referenced by AfdDispatch().

◆ AfdSelect()

NTSTATUS NTAPI AfdSelect ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 165 of file select.c.

166 {
167 NTSTATUS Status = STATUS_NO_MEMORY;
168 PAFD_FCB FCB;
169 PFILE_OBJECT FileObject;
170 PAFD_POLL_INFO PollReq = Irp->AssociatedIrp.SystemBuffer;
171 PAFD_DEVICE_EXTENSION DeviceExt = DeviceObject->DeviceExtension;
172 KIRQL OldIrql;
173 UINT i, Signalled = 0;
174 ULONG Exclusive = PollReq->Exclusive;
175
176 UNREFERENCED_PARAMETER(IrpSp);
177
178 AFD_DbgPrint(MID_TRACE,("Called (HandleCount %u Timeout %d)\n",
179 PollReq->HandleCount,
180 (INT)(PollReq->Timeout.QuadPart)));
181
182 SET_AFD_HANDLES(PollReq,
183 LockHandles( PollReq->Handles, PollReq->HandleCount ));
184
185 if( !AFD_HANDLES(PollReq) ) {
186 Irp->IoStatus.Status = STATUS_NO_MEMORY;
187 Irp->IoStatus.Information = 0;
188 IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
189 return STATUS_NO_MEMORY;
190 }
191
192 if( Exclusive ) {
193 for( i = 0; i < PollReq->HandleCount; i++ ) {
194 if( !AFD_HANDLES(PollReq)[i].Handle ) continue;
195
196 KillSelectsForFCB( DeviceExt,
197 (PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle,
198 TRUE );
199 }
200 }
201
202 KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
203
204 for( i = 0; i < PollReq->HandleCount; i++ ) {
205 if( !AFD_HANDLES(PollReq)[i].Handle ) continue;
206
207 FileObject = (PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle;
208 FCB = FileObject->FsContext;
209
210 AFD_DbgPrint(MID_TRACE, ("AFD: Select Events: "));
211 PrintEvents( PollReq->Handles[i].Events );
212 AFD_DbgPrint(MID_TRACE,("\n"));
213
214 PollReq->Handles[i].Status =
215 PollReq->Handles[i].Events & FCB->PollState;
216 if( PollReq->Handles[i].Status ) {
217 AFD_DbgPrint(MID_TRACE,("Signalling %p with %x\n",
218 FCB, FCB->PollState));
219 Signalled++;
220 }
221 }
222
223 if( Signalled ) {
224 Status = STATUS_SUCCESS;
225 Irp->IoStatus.Status = Status;
226 SignalSocket( NULL, Irp, PollReq, Status );
227 } else {
228
229 PAFD_ACTIVE_POLL Poll = NULL;
230
231 Poll = ExAllocatePoolWithTag(NonPagedPool,
232 sizeof(AFD_ACTIVE_POLL),
233 TAG_AFD_ACTIVE_POLL);
234
235 if (Poll){
236 Poll->Irp = Irp;
237 Poll->DeviceExt = DeviceExt;
238 Poll->Exclusive = Exclusive;
239
240 KeInitializeTimerEx( &Poll->Timer, NotificationTimer );
241
242 KeInitializeDpc( (PRKDPC)&Poll->TimeoutDpc, SelectTimeout, Poll );
243
244 InsertTailList( &DeviceExt->Polls, &Poll->ListEntry );
245
246 KeSetTimer( &Poll->Timer, PollReq->Timeout, &Poll->TimeoutDpc );
247
248 Status = STATUS_PENDING;
249 IoMarkIrpPending( Irp );
250 (void)IoSetCancelRoutine(Irp, AfdCancelHandler);
251 } else {
252 AFD_DbgPrint(MAX_TRACE, ("FIXME: do something with the IRP!\n"));
253 Status = STATUS_NO_MEMORY;
254 }
255 }
256
257 KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
258
259 AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
260
261 return Status;
262}
SET_AFD_HANDLES
#define SET_AFD_HANDLES(x, y)
Definition: afd.h:103
AFD_HANDLES
#define AFD_HANDLES(x)
Definition: afd.h:102
TAG_AFD_ACTIVE_POLL
#define TAG_AFD_ACTIVE_POLL
Definition: afd.h:50
MAX_TRACE
#define MAX_TRACE
Definition: debug.h:16
FCB
struct _FCB FCB
KeInitializeDpc
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
Definition: dpc.c:712
LockHandles
PAFD_HANDLE LockHandles(PAFD_HANDLE HandleArray, UINT HandleCount)
Definition: lock.c:310
KillSelectsForFCB
VOID KillSelectsForFCB(PAFD_DEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject, BOOLEAN OnlyExclusive)
Definition: select.c:125
SelectTimeout
static KDEFERRED_ROUTINE SelectTimeout
Definition: select.c:95
SignalSocket
VOID SignalSocket(PAFD_ACTIVE_POLL Poll OPTIONAL, PIRP _Irp OPTIONAL, PAFD_POLL_INFO PollReq, NTSTATUS Status)
Definition: select.c:56
PrintEvents
static VOID PrintEvents(ULONG Events)
Definition: select.c:13
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
KIRQL
UCHAR KIRQL
Definition: env_spec_w32.h:591
KeReleaseSpinLock
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
KeAcquireSpinLock
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
NonPagedPool
#define NonPagedPool
Definition: env_spec_w32.h:307
Exclusive
__in PWDFDEVICE_INIT __in BOOLEAN Exclusive
Definition: fxdeviceinitapi.cpp:226
Handle
ULONG Handle
Definition: gdb_input.c:15
NotificationTimer
@ NotificationTimer
Definition: ntdef.template.h:370
_AFD_ACTIVE_POLL
Definition: afd.h:116
_AFD_ACTIVE_POLL::Irp
PIRP Irp
Definition: afd.h:118
_AFD_ACTIVE_POLL::TimeoutDpc
KDPC TimeoutDpc
Definition: afd.h:120
_AFD_ACTIVE_POLL::ListEntry
LIST_ENTRY ListEntry
Definition: afd.h:117
_AFD_ACTIVE_POLL::Timer
KTIMER Timer
Definition: afd.h:121
_AFD_ACTIVE_POLL::DeviceExt
PAFD_DEVICE_EXTENSION DeviceExt
Definition: afd.h:119
_AFD_ACTIVE_POLL::Exclusive
BOOLEAN Exclusive
Definition: afd.h:123
_AFD_DEVICE_EXTENSION::Polls
LIST_ENTRY Polls
Definition: afd.h:112
_AFD_DEVICE_EXTENSION::Lock
KSPIN_LOCK Lock
Definition: afd.h:113
_AFD_HANDLE_::Events
ULONG Events
Definition: shared.h:51
_AFD_HANDLE_::Status
NTSTATUS Status
Definition: shared.h:52
_AFD_POLL_INFO
Definition: shared.h:55
_AFD_POLL_INFO::Timeout
LARGE_INTEGER Timeout
Definition: shared.h:56
_AFD_POLL_INFO::HandleCount
ULONG HandleCount
Definition: shared.h:57
_AFD_POLL_INFO::Handles
AFD_HANDLE Handles[1]
Definition: shared.h:59
_AFD_POLL_INFO::Exclusive
ULONG_PTR Exclusive
Definition: shared.h:58
_KDPC
Definition: ketypes.h:767
KeSetTimer
BOOLEAN NTAPI KeSetTimer(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:282
KeInitializeTimerEx
VOID NTAPI KeInitializeTimerEx(OUT PKTIMER Timer, IN TIMER_TYPE Type)
Definition: timerobj.c:244
INT
int32_t INT
Definition: typedefs.h:58
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114
OldIrql
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778

Referenced by AfdDispatch().

◆ AfdSetConnectData()

NTSTATUS NTAPI AfdSetConnectData ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 157 of file connect.c.

159{
160 PFILE_OBJECT FileObject = IrpSp->FileObject;
161 PAFD_FCB FCB = FileObject->FsContext;
162 PVOID ConnectData = LockRequest(Irp, IrpSp, FALSE, NULL);
163 UINT ConnectDataSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
164
165 UNREFERENCED_PARAMETER(DeviceObject);
166
167 if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
168
169 if (!ConnectData)
170 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
171
172 if (FCB->ConnectData)
173 {
174 ExFreePoolWithTag(FCB->ConnectData, TAG_AFD_CONNECT_DATA);
175 FCB->ConnectData = NULL;
176 FCB->ConnectDataSize = 0;
177 FCB->FilledConnectData = 0;
178 }
179
180 FCB->ConnectData = ExAllocatePoolWithTag(PagedPool,
181 ConnectDataSize,
182 TAG_AFD_CONNECT_DATA);
183
184 if (!FCB->ConnectData) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
185
186 RtlCopyMemory(FCB->ConnectData,
187 ConnectData,
188 ConnectDataSize);
189
190 FCB->ConnectDataSize = ConnectDataSize;
191
192 return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
193}
TAG_AFD_CONNECT_DATA
#define TAG_AFD_CONNECT_DATA
Definition: afd.h:41
PagedPool
#define PagedPool
Definition: env_spec_w32.h:308

Referenced by AfdDispatch().

◆ AfdSetConnectDataSize()

NTSTATUS NTAPI AfdSetConnectDataSize ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 197 of file connect.c.

199{
200 PFILE_OBJECT FileObject = IrpSp->FileObject;
201 PAFD_FCB FCB = FileObject->FsContext;
202 PUINT ConnectDataSize = LockRequest(Irp, IrpSp, FALSE, NULL);
203 UINT BufferSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
204
205 UNREFERENCED_PARAMETER(DeviceObject);
206
207 if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
208
209 if (!ConnectDataSize)
210 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
211
212 if (BufferSize < sizeof(UINT))
213 {
214 AFD_DbgPrint(MIN_TRACE,("Buffer too small\n"));
215 return UnlockAndMaybeComplete(FCB, STATUS_BUFFER_TOO_SMALL, Irp, 0);
216 }
217
218 if (FCB->ConnectData)
219 {
220 ExFreePoolWithTag(FCB->ConnectData, TAG_AFD_CONNECT_DATA);
221 FCB->ConnectDataSize = 0;
222 FCB->FilledConnectData = 0;
223 }
224
225 FCB->ConnectData = ExAllocatePoolWithTag(PagedPool,
226 *ConnectDataSize,
227 TAG_AFD_CONNECT_DATA);
228
229 if (!FCB->ConnectData) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
230
231 FCB->ConnectDataSize = *ConnectDataSize;
232
233 return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
234}

Referenced by AfdDispatch().

◆ AfdSetConnectOptions()

NTSTATUS NTAPI AfdSetConnectOptions ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 45 of file connect.c.

47{
48 PFILE_OBJECT FileObject = IrpSp->FileObject;
49 PAFD_FCB FCB = FileObject->FsContext;
50 PVOID ConnectOptions = LockRequest(Irp, IrpSp, FALSE, NULL);
51 UINT ConnectOptionsSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
52
53 UNREFERENCED_PARAMETER(DeviceObject);
54
55 if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
56
57 if (!ConnectOptions)
58 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
59
60 if (FCB->ConnectOptions)
61 {
62 ExFreePoolWithTag(FCB->ConnectOptions, TAG_AFD_CONNECT_OPTIONS);
63 FCB->ConnectOptions = NULL;
64 FCB->ConnectOptionsSize = 0;
65 FCB->FilledConnectOptions = 0;
66 }
67
68 FCB->ConnectOptions = ExAllocatePoolWithTag(PagedPool,
69 ConnectOptionsSize,
70 TAG_AFD_CONNECT_OPTIONS);
71
72 if (!FCB->ConnectOptions)
73 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
74
75 RtlCopyMemory(FCB->ConnectOptions,
76 ConnectOptions,
77 ConnectOptionsSize);
78
79 FCB->ConnectOptionsSize = ConnectOptionsSize;
80
81 return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
82}
TAG_AFD_CONNECT_OPTIONS
#define TAG_AFD_CONNECT_OPTIONS
Definition: afd.h:44

Referenced by AfdDispatch().

◆ AfdSetConnectOptionsSize()

NTSTATUS NTAPI AfdSetConnectOptionsSize ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 86 of file connect.c.

88{
89 PFILE_OBJECT FileObject = IrpSp->FileObject;
90 PAFD_FCB FCB = FileObject->FsContext;
91 PUINT ConnectOptionsSize = LockRequest(Irp, IrpSp, FALSE, NULL);
92 UINT BufferSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
93
94 UNREFERENCED_PARAMETER(DeviceObject);
95
96 if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
97
98 if (!ConnectOptionsSize)
99 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
100
101 if (BufferSize < sizeof(UINT))
102 {
103 AFD_DbgPrint(MIN_TRACE,("Buffer too small\n"));
104 return UnlockAndMaybeComplete(FCB, STATUS_BUFFER_TOO_SMALL, Irp, 0);
105 }
106
107 if (FCB->ConnectOptions)
108 {
109 ExFreePoolWithTag(FCB->ConnectOptions, TAG_AFD_CONNECT_OPTIONS);
110 FCB->ConnectOptionsSize = 0;
111 FCB->FilledConnectOptions = 0;
112 }
113
114 FCB->ConnectOptions = ExAllocatePoolWithTag(PagedPool,
115 *ConnectOptionsSize,
116 TAG_AFD_CONNECT_OPTIONS);
117
118 if (!FCB->ConnectOptions) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
119
120 FCB->ConnectOptionsSize = *ConnectOptionsSize;
121
122 return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
123}

Referenced by AfdDispatch().

◆ AfdSetContext()

NTSTATUS NTAPI AfdSetContext ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 71 of file context.c.

72 {
73 PFILE_OBJECT FileObject = IrpSp->FileObject;
74 PAFD_FCB FCB = FileObject->FsContext;
75 PVOID Context = LockRequest(Irp, IrpSp, FALSE, NULL);
76
77 UNREFERENCED_PARAMETER(DeviceObject);
78
79 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
80
81 if (!Context)
82 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
83
84 if( FCB->Context ) {
85 ExFreePoolWithTag(FCB->Context, TAG_AFD_SOCKET_CONTEXT);
86 FCB->ContextSize = 0;
87 }
88
89 FCB->Context = ExAllocatePoolWithTag(PagedPool,
90 IrpSp->Parameters.DeviceIoControl.InputBufferLength,
91 TAG_AFD_SOCKET_CONTEXT);
92
93 if( !FCB->Context ) return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
94
95 FCB->ContextSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
96
97 RtlCopyMemory( FCB->Context,
98 Context,
99 FCB->ContextSize );
100
101 return UnlockAndMaybeComplete( FCB, STATUS_SUCCESS, Irp, 0 );
102}
TAG_AFD_SOCKET_CONTEXT
#define TAG_AFD_SOCKET_CONTEXT
Definition: afd.h:40
Context
_In_ PVOID Context
Definition: storport.h:2269

Referenced by AfdDispatch().

◆ AfdSetInfo()

NTSTATUS NTAPI AfdSetInfo ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 102 of file info.c.

103 {
104 NTSTATUS Status = STATUS_SUCCESS;
105 PAFD_INFO InfoReq = LockRequest(Irp, IrpSp, FALSE, NULL);
106 PFILE_OBJECT FileObject = IrpSp->FileObject;
107 PAFD_FCB FCB = FileObject->FsContext;
108 PCHAR NewBuffer;
109
110 UNREFERENCED_PARAMETER(DeviceObject);
111
112 if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
113
114 if (!InfoReq)
115 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
116
117 _SEH2_TRY {
118 switch (InfoReq->InformationClass) {
119 case AFD_INFO_BLOCKING_MODE:
120 AFD_DbgPrint(MID_TRACE,("Blocking mode set to %u\n", InfoReq->Information.Boolean));
121 FCB->NonBlocking = InfoReq->Information.Boolean;
122 break;
123 case AFD_INFO_INLINING_MODE:
124 FCB->OobInline = InfoReq->Information.Boolean;
125 break;
126 case AFD_INFO_RECEIVE_WINDOW_SIZE:
127 if (FCB->SharedData.State == SOCKET_STATE_CONNECTED ||
128 FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
129 {
130 /* FIXME: likely not right, check tcpip.sys for TDI_QUERY_MAX_DATAGRAM_INFO */
131 if (InfoReq->Information.Ulong > 0 && InfoReq->Information.Ulong < 0xFFFF &&
132 InfoReq->Information.Ulong != FCB->Recv.Size)
133 {
134 NewBuffer = ExAllocatePoolWithTag(PagedPool,
135 InfoReq->Information.Ulong,
136 TAG_AFD_DATA_BUFFER);
137
138 if (NewBuffer)
139 {
140 if (FCB->Recv.Content > InfoReq->Information.Ulong)
141 FCB->Recv.Content = InfoReq->Information.Ulong;
142
143 if (FCB->Recv.Window)
144 {
145 RtlCopyMemory(NewBuffer,
146 FCB->Recv.Window,
147 FCB->Recv.Content);
148
149 ExFreePoolWithTag(FCB->Recv.Window, TAG_AFD_DATA_BUFFER);
150 }
151
152 FCB->Recv.Size = InfoReq->Information.Ulong;
153 FCB->Recv.Window = NewBuffer;
154
155 Status = STATUS_SUCCESS;
156 }
157 else
158 {
159 Status = STATUS_NO_MEMORY;
160 }
161 }
162 else
163 {
164 Status = STATUS_SUCCESS;
165 }
166 }
167 else
168 {
169 Status = STATUS_INVALID_PARAMETER;
170 }
171 break;
172 case AFD_INFO_SEND_WINDOW_SIZE:
173 if (FCB->SharedData.State == SOCKET_STATE_CONNECTED ||
174 FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
175 {
176 if (InfoReq->Information.Ulong > 0 && InfoReq->Information.Ulong < 0xFFFF &&
177 InfoReq->Information.Ulong != FCB->Send.Size)
178 {
179 NewBuffer = ExAllocatePoolWithTag(PagedPool,
180 InfoReq->Information.Ulong,
181 TAG_AFD_DATA_BUFFER);
182
183 if (NewBuffer)
184 {
185 if (FCB->Send.BytesUsed > InfoReq->Information.Ulong)
186 FCB->Send.BytesUsed = InfoReq->Information.Ulong;
187
188 if (FCB->Send.Window)
189 {
190 RtlCopyMemory(NewBuffer,
191 FCB->Send.Window,
192 FCB->Send.BytesUsed);
193
194 ExFreePoolWithTag(FCB->Send.Window, TAG_AFD_DATA_BUFFER);
195 }
196
197 FCB->Send.Size = InfoReq->Information.Ulong;
198 FCB->Send.Window = NewBuffer;
199
200 Status = STATUS_SUCCESS;
201 }
202 else
203 {
204 Status = STATUS_NO_MEMORY;
205 }
206 }
207 else
208 {
209 Status = STATUS_SUCCESS;
210 }
211 }
212 else
213 {
214 Status = STATUS_INVALID_PARAMETER;
215 }
216 break;
217 default:
218 AFD_DbgPrint(MIN_TRACE,("Unknown request %u\n", InfoReq->InformationClass));
219 break;
220 }
221 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
222 AFD_DbgPrint(MIN_TRACE,("Exception executing SetInfo\n"));
223 Status = STATUS_INVALID_PARAMETER;
224 } _SEH2_END;
225
226 AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
227
228 return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
229}
TAG_AFD_DATA_BUFFER
#define TAG_AFD_DATA_BUFFER
Definition: afd.h:38
PCHAR
char * PCHAR
Definition: typedefs.h:51

Referenced by AfdDispatch().

◆ AfdStreamSocketConnect()

NTSTATUS NTAPI AfdStreamSocketConnect ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 523 of file connect.c.

524 {
525 NTSTATUS Status = STATUS_INVALID_PARAMETER;
526 PFILE_OBJECT FileObject = IrpSp->FileObject;
527 PAFD_FCB FCB = FileObject->FsContext;
528 PAFD_CONNECT_INFO ConnectReq;
529 AFD_DbgPrint(MID_TRACE,("Called on %p\n", FCB));
530
531 UNREFERENCED_PARAMETER(DeviceObject);
532
533 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
534 if( !(ConnectReq = LockRequest( Irp, IrpSp, FALSE, NULL )) )
535 return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp,
536 0 );
537
538 AFD_DbgPrint(MID_TRACE,("Connect request:\n"));
539#if 0
540 OskitDumpBuffer
541 ( (PCHAR)ConnectReq,
542 IrpSp->Parameters.DeviceIoControl.InputBufferLength );
543#endif
544
545 if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS )
546 {
547 if (FCB->RemoteAddress)
548 {
549 ExFreePoolWithTag(FCB->RemoteAddress, TAG_AFD_TRANSPORT_ADDRESS);
550 }
551
552 FCB->RemoteAddress =
553 TaCopyTransportAddress( &ConnectReq->RemoteAddress );
554
555 if( !FCB->RemoteAddress )
556 Status = STATUS_NO_MEMORY;
557 else
558 Status = STATUS_SUCCESS;
559
560 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
561 }
562
563 switch(FCB->SharedData.State)
564 {
565 case SOCKET_STATE_CONNECTED:
566 Status = STATUS_INVALID_PARAMETER;
567 break;
568
569 case SOCKET_STATE_CONNECTING:
570 return LeaveIrpUntilLater( FCB, Irp, FUNCTION_CONNECT );
571
572 case SOCKET_STATE_CREATED:
573 if (FCB->LocalAddress)
574 {
575 ExFreePoolWithTag(FCB->LocalAddress, TAG_AFD_TRANSPORT_ADDRESS);
576 }
577
578 FCB->LocalAddress =
579 TaBuildNullTransportAddress( ConnectReq->RemoteAddress.Address[0].AddressType );
580
581 if( FCB->LocalAddress ) {
582 Status = WarmSocketForBind( FCB, AFD_SHARE_WILDCARD );
583
584 if( NT_SUCCESS(Status) )
585 FCB->SharedData.State = SOCKET_STATE_BOUND;
586 else
587 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
588 } else
589 return UnlockAndMaybeComplete
590 ( FCB, STATUS_NO_MEMORY, Irp, 0 );
591
592 /* Drop through to SOCKET_STATE_BOUND */
593
594 case SOCKET_STATE_BOUND:
595 if (FCB->RemoteAddress)
596 {
597 ExFreePoolWithTag(FCB->RemoteAddress, TAG_AFD_TRANSPORT_ADDRESS);
598 }
599
600 FCB->RemoteAddress =
601 TaCopyTransportAddress( &ConnectReq->RemoteAddress );
602
603 if( !FCB->RemoteAddress ) {
604 Status = STATUS_NO_MEMORY;
605 break;
606 }
607
608 Status = WarmSocketForConnection( FCB );
609
610 if( !NT_SUCCESS(Status) )
611 break;
612
613 if (FCB->ConnectReturnInfo)
614 {
615 ExFreePoolWithTag(FCB->ConnectReturnInfo, TAG_AFD_TDI_CONNECTION_INFORMATION);
616 }
617
618 Status = TdiBuildConnectionInfo
619 ( &FCB->ConnectReturnInfo,
620 &ConnectReq->RemoteAddress );
621
622 if( NT_SUCCESS(Status) )
623 {
624 if (FCB->ConnectCallInfo)
625 {
626 ExFreePoolWithTag(FCB->ConnectCallInfo, TAG_AFD_TDI_CONNECTION_INFORMATION);
627 }
628
629 Status = TdiBuildConnectionInfo(&FCB->ConnectCallInfo,
630 &ConnectReq->RemoteAddress);
631 }
632 else break;
633
634
635 if( NT_SUCCESS(Status) ) {
636 FCB->ConnectCallInfo->UserData = FCB->ConnectData;
637 FCB->ConnectCallInfo->UserDataLength = FCB->ConnectDataSize;
638 FCB->ConnectCallInfo->Options = FCB->ConnectOptions;
639 FCB->ConnectCallInfo->OptionsLength = FCB->ConnectOptionsSize;
640
641 FCB->SharedData.State = SOCKET_STATE_CONNECTING;
642
643 AFD_DbgPrint(MID_TRACE,("Queueing IRP %p\n", Irp));
644 Status = QueueUserModeIrp(FCB, Irp, FUNCTION_CONNECT);
645 if (Status == STATUS_PENDING)
646 {
647 Status = TdiConnect(&FCB->ConnectIrp.InFlightRequest,
648 FCB->Connection.Object,
649 FCB->ConnectCallInfo,
650 FCB->ConnectReturnInfo,
651 StreamSocketConnectComplete,
652 FCB);
653 }
654
655 if (Status != STATUS_PENDING)
656 FCB->SharedData.State = SOCKET_STATE_BOUND;
657
658 SocketStateUnlock(FCB);
659
660 return Status;
661 }
662 break;
663
664 default:
665 AFD_DbgPrint(MIN_TRACE,("Inappropriate socket state %u for connect\n",
666 FCB->SharedData.State));
667 break;
668 }
669
670 return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
671}
FUNCTION_CONNECT
#define FUNCTION_CONNECT
Definition: afd.h:85
StreamSocketConnectComplete
static IO_COMPLETION_ROUTINE StreamSocketConnectComplete
Definition: connect.c:370
OskitDumpBuffer
void OskitDumpBuffer(PCHAR Data, UINT Len)
Definition: main.c:30
_AFD_CONNECT_INFO
Definition: shared.h:127
_AFD_CONNECT_INFO::RemoteAddress
TRANSPORT_ADDRESS RemoteAddress
Definition: shared.h:131
_TA_ADDRESS::AddressType
USHORT AddressType
Definition: tdi.h:339
_TRANSPORT_ADDRESS::Address
TA_ADDRESS Address[1]
Definition: tdi.h:377
TdiConnect
NTSTATUS TdiConnect(PIRP *PendingIrp, PFILE_OBJECT ConnectionObject, PTDI_CONNECTION_INFORMATION ConnectionCallInfo, PTDI_CONNECTION_INFORMATION ConnectionReturnInfo, PIO_COMPLETION_ROUTINE CompletionRoutine, PVOID CompletionContext)
Connect a connection endpoint to a remote peer.
Definition: tdi.c:311

Referenced by AfdDispatch().

◆ AfdStreamSocketSuperConnect()

NTSTATUS NTAPI AfdStreamSocketSuperConnect ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 676 of file connect.c.

680{
681 NTSTATUS Status = STATUS_INVALID_PARAMETER;
682 PFILE_OBJECT FileObject = IrpSp->FileObject;
683 PAFD_FCB FCB = FileObject->FsContext;
684 PAFD_SUPER_CONNECT_INFO ConnectReq;
685 KPROCESSOR_MODE LockMode;
686 UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
687 AFD_DbgPrint(MID_TRACE,("Called on %p\n", FCB));
688
689 UNREFERENCED_PARAMETER(DeviceObject);
690
691 if (!SocketAcquireStateLock(FCB))
692 return LostSocket(Irp);
693
694 ConnectReq = LockRequest(Irp, IrpSp, FALSE, &LockMode);
695 if (!ConnectReq)
696 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
697
698 AFD_DbgPrint(MID_TRACE,("Connect request:\n"));
699#if DBG
700 OskitDumpBuffer((PCHAR)ConnectReq,
701 IrpSp->Parameters.DeviceIoControl.InputBufferLength);
702#endif
703
704 if (FCB->OnConnectSendBuffer)
705 {
706 ExFreePoolWithTag(FCB->OnConnectSendBuffer, TAG_AFD_SUPER_CONNECT_BUFFER);
707 FCB->OnConnectSendBuffer = NULL;
708 FCB->OnConnectSendBufferSize = 0;
709 }
710
711 if (Irp->UserBuffer)
712 {
713 FCB->OnConnectSendBufferSize = BufferSize;
714 FCB->OnConnectSendBuffer = ExAllocatePoolWithTag(PagedPool,
715 BufferSize,
716 TAG_AFD_SUPER_CONNECT_BUFFER);
717
718 if (!FCB->OnConnectSendBuffer)
719 return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
720
721 RtlCopyMemory(FCB->OnConnectSendBuffer, Irp->UserBuffer, BufferSize);
722 }
723
724 if (FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
725 {
726 AFD_DbgPrint(MIN_TRACE,("Cannot call IOCTL_CONNECTEX on connectionless socket\n",
727 FCB->SharedData.State));
728 if (FCB->RemoteAddress)
729 {
730 ExFreePoolWithTag(FCB->RemoteAddress, TAG_AFD_TRANSPORT_ADDRESS);
731 }
732
733 FCB->RemoteAddress =
734 TaCopyTransportAddress(&ConnectReq->RemoteAddress);
735
736 if(!FCB->RemoteAddress)
737 Status = STATUS_NO_MEMORY;
738 else
739 Status = STATUS_SUCCESS;
740
741 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
742 }
743
744 switch (FCB->SharedData.State)
745 {
746 case SOCKET_STATE_CONNECTED:
747 Status = STATUS_SUCCESS;
748 break;
749
750 case SOCKET_STATE_CONNECTING:
751 return LeaveIrpUntilLater( FCB, Irp, FUNCTION_CONNECTEX );
752
753 case SOCKET_STATE_BOUND:
754 if (FCB->RemoteAddress)
755 {
756 ExFreePoolWithTag(FCB->RemoteAddress, TAG_AFD_TRANSPORT_ADDRESS);
757 }
758
759 FCB->RemoteAddress =
760 TaCopyTransportAddress(&ConnectReq->RemoteAddress);
761 if (!FCB->RemoteAddress)
762 {
763 Status = STATUS_NO_MEMORY;
764 break;
765 }
766
767 Status = WarmSocketForConnection(FCB);
768 if (!NT_SUCCESS(Status))
769 break;
770
771 if (FCB->ConnectReturnInfo)
772 {
773 ExFreePoolWithTag(FCB->ConnectReturnInfo, TAG_AFD_TDI_CONNECTION_INFORMATION);
774 }
775
776 Status = TdiBuildConnectionInfo(&FCB->ConnectReturnInfo,
777 &ConnectReq->RemoteAddress);
778 if (!NT_SUCCESS(Status))
779 break;
780
781 if (FCB->ConnectCallInfo)
782 {
783 ExFreePoolWithTag(FCB->ConnectCallInfo, TAG_AFD_TDI_CONNECTION_INFORMATION);
784 }
785
786 Status = TdiBuildConnectionInfo(&FCB->ConnectCallInfo,
787 &ConnectReq->RemoteAddress);
788
789
790 if (!NT_SUCCESS(Status))
791 break;
792
793 FCB->ConnectCallInfo->UserData = FCB->ConnectData ? FCB->ConnectData : FCB->OnConnectSendBuffer;
794 FCB->ConnectCallInfo->UserDataLength = FCB->ConnectData ? FCB->ConnectDataSize : FCB->OnConnectSendBufferSize;
795 FCB->ConnectCallInfo->Options = FCB->ConnectOptions;
796 FCB->ConnectCallInfo->OptionsLength = FCB->ConnectOptionsSize;
797 FCB->SharedData.State = SOCKET_STATE_CONNECTING;
798
799 AFD_DbgPrint(MID_TRACE,("Queueing IRP %p\n", Irp));
800 Status = QueueUserModeIrp( FCB, Irp, FUNCTION_CONNECTEX );
801 if (Status == STATUS_PENDING)
802 {
803 Status = TdiConnect(&FCB->ConnectIrp.InFlightRequest,
804 FCB->Connection.Object,
805 FCB->ConnectCallInfo,
806 FCB->ConnectReturnInfo,
807 StreamSocketConnectComplete,
808 FCB );
809 }
810
811 if (Status != STATUS_PENDING)
812 FCB->SharedData.State = SOCKET_STATE_BOUND;
813
814 SocketStateUnlock(FCB);
815
816 return Status;
817
818 default:
819 AFD_DbgPrint(MIN_TRACE,("Inappropriate socket state %u for connect\n",
820 FCB->SharedData.State));
821 break;
822 }
823
824 return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
825}
TAG_AFD_SUPER_CONNECT_BUFFER
#define TAG_AFD_SUPER_CONNECT_BUFFER
Definition: afd.h:46
FUNCTION_CONNECTEX
#define FUNCTION_CONNECTEX
Definition: afd.h:92
BufferSize
#define BufferSize
Definition: mmc.h:75
_AFD_SUPER_CONNECT_INFO
Definition: shared.h:135
_AFD_SUPER_CONNECT_INFO::RemoteAddress
TRANSPORT_ADDRESS RemoteAddress
Definition: shared.h:137

Referenced by AfdDispatch().

◆ AfdSuperAccept()

NTSTATUS AfdSuperAccept ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 541 of file listen.c.

542 {
543 NTSTATUS Status = STATUS_SUCCESS;
544 PFILE_OBJECT FileObject = IrpSp->FileObject;
545 PAFD_FCB Fcb = FileObject->FsContext;
546 PAFD_SUPER_ACCEPT_INFO AcceptRequest;
547
548 PFILE_OBJECT NewFileObject = NULL;
549
550 AFD_DbgPrint(MID_TRACE,("Called\n"));
551
552 if( !SocketAcquireStateLock( Fcb ) ) return LostSocket( Irp );
553
554 if( !(AcceptRequest = LockRequest( Irp, IrpSp, FALSE, NULL )) )
555 return UnlockAndMaybeComplete( Fcb, STATUS_NO_MEMORY, Irp,
556 0 );
557
558 Fcb->EventSelectDisabled &= ~AFD_EVENT_ACCEPT;
559
560 /* Allow the IRP to access UserBuffer later */
561 Irp->Tail.Overlay.DriverContext[3] = IoAllocateMdl(Irp->UserBuffer, IrpSp->Parameters.DeviceIoControl.OutputBufferLength, FALSE, FALSE, NULL);
562 _SEH2_TRY
563 {
564 MmProbeAndLockPages((PMDL)Irp->Tail.Overlay.DriverContext[3], Irp->RequestorMode, IoWriteAccess);
565 }
566 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
567 {
568 Status = _SEH2_GetExceptionCode();
569 return UnlockAndMaybeComplete(Fcb, Status, Irp, 0);
570 }
571 _SEH2_END;
572
573 /* Validate that accepting socket is valid, and has not been bound or connected */
574 Status = ObReferenceObjectByHandle(
575 AcceptRequest->AcceptHandle, FILE_ALL_ACCESS, NULL, KernelMode, (PVOID *)&NewFileObject, NULL);
576 if (!NT_SUCCESS(Status))
577 {
578 IoFreeMdl((PMDL)Irp->Tail.Overlay.DriverContext[3]);
579 Irp->Tail.Overlay.DriverContext[3] = NULL;
580 return UnlockAndMaybeComplete(Fcb, Status, Irp, 0);
581 }
582
583 PAFD_FCB Fcb2 = NewFileObject->FsContext;
584
585 if (!SocketAcquireStateLock(Fcb2))
586 {
587 ObDereferenceObject(NewFileObject);
588 return LostSocket(Irp);
589 }
590
591 /* Verify that the acceptor socket has not been already binded/connected or that it has been used by AcceptEx */
592 if (Fcb2->SharedData.State != SOCKET_STATE_CREATED)
593 {
594 IoFreeMdl((PMDL)Irp->Tail.Overlay.DriverContext[3]);
595 Irp->Tail.Overlay.DriverContext[3] = NULL;
596 SocketStateUnlock(Fcb2);
597 ObDereferenceObject(NewFileObject);
598 return UnlockAndMaybeComplete(Fcb, STATUS_INVALID_PARAMETER, Irp, 0);
599 }
600 Fcb2->SharedData.State = SOCKET_STATE_CONNECTING;
601
602 Irp->Tail.Overlay.DriverContext[2] = NewFileObject;
603
604 /* Proceed later in SatisfyAcceptEx */
605 SocketStateUnlock(Fcb2);
606
607 return LeaveIrpUntilLater(Fcb, Irp, FUNCTION_PREACCEPT);
608}
FUNCTION_PREACCEPT
#define FUNCTION_PREACCEPT
Definition: afd.h:88
Fcb
_In_ PFCB Fcb
Definition: cdprocs.h:159
_AFD_FCB::SharedData
SOCK_SHARED_INFO SharedData
Definition: afd.h:162
_AFD_SUPER_ACCEPT_INFO
Definition: shared.h:69
_AFD_SUPER_ACCEPT_INFO::AcceptHandle
HANDLE AcceptHandle
Definition: shared.h:72
_SOCK_SHARED_INFO::State
SOCKET_STATE State
Definition: shared.h:383
IoWriteAccess
@ IoWriteAccess
Definition: ketypes.h:932

Referenced by AfdDispatch().

◆ AfdWaitForListen()

NTSTATUS AfdWaitForListen ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 426 of file listen.c.

427 {
428 PFILE_OBJECT FileObject = IrpSp->FileObject;
429 PAFD_FCB FCB = FileObject->FsContext;
430 NTSTATUS Status;
431
432 UNREFERENCED_PARAMETER(DeviceObject);
433
434 AFD_DbgPrint(MID_TRACE,("Called\n"));
435
436 if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
437
438 if( !IsListEmpty( &FCB->PendingConnections ) ) {
439 PLIST_ENTRY PendingConn = FCB->PendingConnections.Flink;
440
441 /* We have a pending connection ... complete this irp right away */
442 Status = SatisfyPreAccept
443 ( Irp,
444 CONTAINING_RECORD
445 ( PendingConn, AFD_TDI_OBJECT_QELT, ListEntry ) );
446
447 AFD_DbgPrint(MID_TRACE,("Completed a wait for accept\n"));
448
449 if ( !IsListEmpty( &FCB->PendingConnections ) )
450 {
451 FCB->PollState |= AFD_EVENT_ACCEPT;
452 FCB->PollStatus[FD_ACCEPT_BIT] = STATUS_SUCCESS;
453 PollReeval( FCB->DeviceExt, FCB->FileObject );
454 } else
455 FCB->PollState &= ~AFD_EVENT_ACCEPT;
456
457 SocketStateUnlock( FCB );
458 return Status;
459 } else if (FCB->NonBlocking) {
460 AFD_DbgPrint(MIN_TRACE,("No connection ready on a non-blocking socket\n"));
461
462 return UnlockAndMaybeComplete(FCB, STATUS_CANT_WAIT, Irp, 0);
463 } else {
464 AFD_DbgPrint(MID_TRACE,("Holding\n"));
465
466 return LeaveIrpUntilLater( FCB, Irp, FUNCTION_PREACCEPT );
467 }
468}
SatisfyPreAccept
static NTSTATUS SatisfyPreAccept(PIRP Irp, PAFD_TDI_OBJECT_QELT Qelt)
Definition: listen.c:61

Referenced by AfdDispatch().

◆ CheckUnlockExtraBuffers()

BOOLEAN CheckUnlockExtraBuffers ( PAFD_FCB  FCB,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 1100 of file main.c.

1101{
1102 if (FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
1103 {
1104 if (IrpSp->MajorFunction == IRP_MJ_READ || IrpSp->MajorFunction == IRP_MJ_WRITE)
1105 {
1106 /* read()/write() call - no extra buffers */
1107 return FALSE;
1108 }
1109 else if (IrpSp->MajorFunction == IRP_MJ_DEVICE_CONTROL)
1110 {
1111 if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_RECV_DATAGRAM)
1112 {
1113 /* recvfrom() call - extra buffers */
1114 return TRUE;
1115 }
1116 else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_RECV)
1117 {
1118 /* recv() call - no extra buffers */
1119 return FALSE;
1120 }
1121 else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SEND ||
1122 IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SEND_DATAGRAM)
1123 {
1124 /* send()/sendto() call - no extra buffers */
1125 return FALSE;
1126 }
1127 else
1128 {
1129 /* Unknown IOCTL */
1130 ASSERT(FALSE);
1131 return FALSE;
1132 }
1133 }
1134 else
1135 {
1136 /* Unknown IRP_MJ code */
1137 ASSERT(FALSE);
1138 return FALSE;
1139 }
1140 }
1141 else
1142 {
1143 /* Connection-oriented never has extra buffers */
1144 return FALSE;
1145 }
1146}
IRP_MJ_READ
#define IRP_MJ_READ
Definition: rdpdr.c:46
IRP_MJ_DEVICE_CONTROL
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
IRP_MJ_WRITE
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
IOCTL_AFD_RECV
#define IOCTL_AFD_RECV
Definition: shared.h:295
IOCTL_AFD_SEND_DATAGRAM
#define IOCTL_AFD_SEND_DATAGRAM
Definition: shared.h:301
IOCTL_AFD_RECV_DATAGRAM
#define IOCTL_AFD_RECV_DATAGRAM
Definition: shared.h:297
IOCTL_AFD_SEND
#define IOCTL_AFD_SEND
Definition: shared.h:299
_IO_STACK_LOCATION::MajorFunction
UCHAR MajorFunction
Definition: iotypes.h:3113

Referenced by CleanupPendingIrp(), PacketSocketRecvComplete(), and SatisfyPacketRecvRequest().

◆ DestroySocket()

VOID DestroySocket ( PAFD_FCB  FCB)

◆ GetLockedData()

PVOID GetLockedData ( PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 13 of file lock.c.

14{
15 ASSERT(Irp->MdlAddress);
16 ASSERT(Irp->Tail.Overlay.DriverContext[0]);
17
18 UNREFERENCED_PARAMETER(IrpSp);
19
20 return Irp->Tail.Overlay.DriverContext[0];
21}

Referenced by CleanupPendingIrp(), LockRequest(), PacketSocketRecvComplete(), PacketSocketSendComplete(), ReceiveActivity(), ReceiveComplete(), SatisfyPacketRecvRequest(), and SendComplete().

◆ KillSelectsForFCB()

VOID KillSelectsForFCB ( PAFD_DEVICE_EXTENSION  DeviceExt,
PFILE_OBJECT  FileObject,
BOOLEAN  ExclusiveOnly 
)

Definition at line 125 of file select.c.

127 {
128 KIRQL OldIrql;
129 PLIST_ENTRY ListEntry;
130 PAFD_ACTIVE_POLL Poll;
131 PIRP Irp;
132 PAFD_POLL_INFO PollReq;
133 PAFD_HANDLE HandleArray;
134 UINT i;
135
136 AFD_DbgPrint(MID_TRACE,("Killing selects that refer to %p\n", FileObject));
137
138 KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
139
140 ListEntry = DeviceExt->Polls.Flink;
141 while ( ListEntry != &DeviceExt->Polls ) {
142 Poll = CONTAINING_RECORD(ListEntry, AFD_ACTIVE_POLL, ListEntry);
143 ListEntry = ListEntry->Flink;
144 Irp = Poll->Irp;
145 PollReq = Irp->AssociatedIrp.SystemBuffer;
146 HandleArray = AFD_HANDLES(PollReq);
147
148 for( i = 0; i < PollReq->HandleCount; i++ ) {
149 AFD_DbgPrint(MAX_TRACE,("Req: %u, This %p\n",
150 HandleArray[i].Handle, FileObject));
151 if( (PVOID)HandleArray[i].Handle == FileObject &&
152 (!OnlyExclusive || (OnlyExclusive && Poll->Exclusive)) ) {
153 ZeroEvents( PollReq->Handles, PollReq->HandleCount );
154 SignalSocket( Poll, NULL, PollReq, STATUS_CANCELLED );
155 }
156 }
157 }
158
159 KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
160
161 AFD_DbgPrint(MID_TRACE,("Done\n"));
162}
ZeroEvents
VOID ZeroEvents(PAFD_HANDLE HandleArray, UINT HandleCount)
Definition: select.c:44
_AFD_HANDLE_
Definition: shared.h:49
_IRP
Definition: Bus_PDO_EvalMethod.c:107
STATUS_CANCELLED
#define STATUS_CANCELLED
Definition: udferr_usr.h:170

Referenced by AfdCleanupSocket(), AfdCloseSocket(), and AfdSelect().

◆ LeaveIrpUntilLater()

NTSTATUS LeaveIrpUntilLater ( PAFD_FCB  FCB,
PIRP  Irp,
UINT  Function 
)

Definition at line 433 of file lock.c.

433 {
434 NTSTATUS Status;
435
436 Status = QueueUserModeIrp(FCB, Irp, Function);
437
438 SocketStateUnlock( FCB );
439
440 return Status;
441}
Function
_In_ CDROM_SCAN_FOR_SPECIAL_INFO _In_ PCDROM_SCAN_FOR_SPECIAL_HANDLER Function
Definition: cdrom.h:1156

Referenced by AfdConnectedSocketReadData(), AfdConnectedSocketWriteData(), AfdPacketSocketReadData(), AfdStreamSocketConnect(), AfdStreamSocketSuperConnect(), AfdSuperAccept(), and AfdWaitForListen().

◆ LockBuffers()

PAFD_WSABUF LockBuffers ( PAFD_WSABUF  Buf,
UINT  Count,
PVOID  AddressBuf,
PINT  AddressLen,
BOOLEAN  Write,
BOOLEAN  LockAddress,
KPROCESSOR_MODE  LockMode 
)

Definition at line 205 of file lock.c.

208 {
209 UINT i;
210 /* Copy the buffer array so we don't lose it */
211 UINT Lock = LockAddress ? 2 : 0;
212 UINT Size = (sizeof(AFD_WSABUF) + sizeof(AFD_MAPBUF)) * (Count + Lock);
213 PAFD_WSABUF NewBuf = ExAllocatePoolWithTag(PagedPool, Size, TAG_AFD_WSA_BUFFER);
214 BOOLEAN LockFailed = FALSE;
215 PAFD_MAPBUF MapBuf;
216
217 AFD_DbgPrint(MID_TRACE,("Called(%p)\n", NewBuf));
218
219 if( NewBuf ) {
220 RtlZeroMemory(NewBuf, Size);
221
222 MapBuf = (PAFD_MAPBUF)(NewBuf + Count + Lock);
223
224 _SEH2_TRY {
225 RtlCopyMemory( NewBuf, Buf, sizeof(AFD_WSABUF) * Count );
226 if( LockAddress ) {
227 if (AddressBuf && AddressLen) {
228 NewBuf[Count].buf = AddressBuf;
229 NewBuf[Count].len = *AddressLen;
230 NewBuf[Count + 1].buf = (PVOID)AddressLen;
231 NewBuf[Count + 1].len = sizeof(*AddressLen);
232 }
233 Count += 2;
234 }
235 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
236 AFD_DbgPrint(MIN_TRACE,("Access violation copying buffer info "
237 "from userland (%p %p)\n",
238 Buf, AddressLen));
239 ExFreePoolWithTag(NewBuf, TAG_AFD_WSA_BUFFER);
240 _SEH2_YIELD(return NULL);
241 } _SEH2_END;
242
243 for( i = 0; i < Count; i++ ) {
244 AFD_DbgPrint(MID_TRACE,("Locking buffer %u (%p:%u)\n",
245 i, NewBuf[i].buf, NewBuf[i].len));
246
247 if( NewBuf[i].buf && NewBuf[i].len ) {
248 MapBuf[i].Mdl = IoAllocateMdl( NewBuf[i].buf,
249 NewBuf[i].len,
250 FALSE,
251 FALSE,
252 NULL );
253 } else {
254 MapBuf[i].Mdl = NULL;
255 continue;
256 }
257
258 AFD_DbgPrint(MID_TRACE,("NewMdl @ %p\n", MapBuf[i].Mdl));
259
260 if( MapBuf[i].Mdl ) {
261 AFD_DbgPrint(MID_TRACE,("Probe and lock pages\n"));
262 _SEH2_TRY {
263 MmProbeAndLockPages( MapBuf[i].Mdl, LockMode,
264 Write ? IoModifyAccess : IoReadAccess );
265 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
266 LockFailed = TRUE;
267 } _SEH2_END;
268 AFD_DbgPrint(MID_TRACE,("MmProbeAndLock finished\n"));
269
270 if( LockFailed ) {
271 AFD_DbgPrint(MIN_TRACE,("Failed to lock pages\n"));
272 IoFreeMdl( MapBuf[i].Mdl );
273 MapBuf[i].Mdl = NULL;
274 ExFreePoolWithTag(NewBuf, TAG_AFD_WSA_BUFFER);
275 return NULL;
276 }
277 } else {
278 ExFreePoolWithTag(NewBuf, TAG_AFD_WSA_BUFFER);
279 return NULL;
280 }
281 }
282 }
283
284 AFD_DbgPrint(MID_TRACE,("Leaving %p\n", NewBuf));
285
286 return NewBuf;
287}
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
PAFD_MAPBUF
struct _AFD_MAPBUF * PAFD_MAPBUF
TAG_AFD_WSA_BUFFER
#define TAG_AFD_WSA_BUFFER
Definition: afd.h:55
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
len
GLenum GLsizei len
Definition: glext.h:6722
Count
int Count
Definition: noreturn.cpp:7
_SEH2_YIELD
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:207
AFD_WSABUF
struct _AFD_WSABUF AFD_WSABUF
_AFD_MAPBUF
Definition: afd.h:105
_AFD_MAPBUF::Mdl
PMDL Mdl
Definition: afd.h:107
_AFD_WSABUF
Definition: shared.h:16
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
Write
static BOOL Write(PBYTE Address, PBYTE Data, SIZE_T Size)
Definition: vmhorizon.c:15
Size
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4539
Lock
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:127
IoReadAccess
@ IoReadAccess
Definition: ketypes.h:931

Referenced by AfdConnectedSocketReadData(), AfdConnectedSocketWriteData(), AfdPacketSocketReadData(), and AfdPacketSocketWriteData().

◆ LockHandles()

PAFD_HANDLE LockHandles ( PAFD_HANDLE  HandleArray,
UINT  HandleCount 
)

Definition at line 310 of file lock.c.

310 {
311 UINT i;
312 NTSTATUS Status = STATUS_SUCCESS;
313
314 PAFD_HANDLE FileObjects = ExAllocatePoolWithTag(NonPagedPool,
315 HandleCount * sizeof(AFD_HANDLE),
316 TAG_AFD_POLL_HANDLE);
317
318 for( i = 0; FileObjects && i < HandleCount; i++ ) {
319 FileObjects[i].Status = 0;
320 FileObjects[i].Events = HandleArray[i].Events;
321 FileObjects[i].Handle = 0;
322 if( !HandleArray[i].Handle ) continue;
323 if( NT_SUCCESS(Status) ) {
324 Status = ObReferenceObjectByHandle
325 ( (PVOID)HandleArray[i].Handle,
326 FILE_ALL_ACCESS,
327 NULL,
328 KernelMode,
329 (PVOID*)&FileObjects[i].Handle,
330 NULL );
331 }
332
333 if( !NT_SUCCESS(Status) )
334 {
335 AFD_DbgPrint(MIN_TRACE,("Failed to reference handles (0x%x)\n", Status));
336 FileObjects[i].Handle = 0;
337 }
338 }
339
340 if( !NT_SUCCESS(Status) ) {
341 UnlockHandles( FileObjects, HandleCount );
342 return NULL;
343 }
344
345 return FileObjects;
346}
TAG_AFD_POLL_HANDLE
#define TAG_AFD_POLL_HANDLE
Definition: afd.h:48
UnlockHandles
VOID UnlockHandles(PAFD_HANDLE HandleArray, UINT HandleCount)
Definition: lock.c:348
_AFD_HANDLE_::Handle
SOCKET Handle
Definition: shared.h:50
HandleCount
static ULONG HandleCount
Definition: uefidisk.c:67

Referenced by AfdSelect().

◆ LockRequest()

PVOID LockRequest ( PIRP  Irp,
PIO_STACK_LOCATION  IrpSp,
BOOLEAN  Output,
KPROCESSOR_MODE *  LockMode 
)

Definition at line 24 of file lock.c.

27 {
28 BOOLEAN LockFailed = FALSE;
29
30 ASSERT(!Irp->MdlAddress);
31
32 switch (IrpSp->MajorFunction)
33 {
34 case IRP_MJ_DEVICE_CONTROL:
35 case IRP_MJ_INTERNAL_DEVICE_CONTROL:
36 ASSERT(IrpSp->Parameters.DeviceIoControl.Type3InputBuffer);
37 ASSERT(IrpSp->Parameters.DeviceIoControl.InputBufferLength);
38
39
40 Irp->MdlAddress =
41 IoAllocateMdl( IrpSp->Parameters.DeviceIoControl.Type3InputBuffer,
42 IrpSp->Parameters.DeviceIoControl.InputBufferLength,
43 FALSE,
44 FALSE,
45 NULL );
46 if( Irp->MdlAddress ) {
47 _SEH2_TRY {
48 MmProbeAndLockPages( Irp->MdlAddress, Irp->RequestorMode, IoModifyAccess );
49 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
50 LockFailed = TRUE;
51 } _SEH2_END;
52
53 if( LockFailed ) {
54 AFD_DbgPrint(MIN_TRACE,("Failed to lock pages\n"));
55 IoFreeMdl( Irp->MdlAddress );
56 Irp->MdlAddress = NULL;
57 return NULL;
58 }
59
60 /* The mapped address goes in index 1 */
61 Irp->Tail.Overlay.DriverContext[1] = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
62 if (!Irp->Tail.Overlay.DriverContext[1])
63 {
64 AFD_DbgPrint(MIN_TRACE,("Failed to get mapped address\n"));
65 MmUnlockPages(Irp->MdlAddress);
66 IoFreeMdl( Irp->MdlAddress );
67 Irp->MdlAddress = NULL;
68 return NULL;
69 }
70
71 /* The allocated address goes in index 0 */
72 Irp->Tail.Overlay.DriverContext[0] = ExAllocatePoolWithTag(NonPagedPool,
73 MmGetMdlByteCount(Irp->MdlAddress),
74 TAG_AFD_DATA_BUFFER);
75
76 if (!Irp->Tail.Overlay.DriverContext[0])
77 {
78 AFD_DbgPrint(MIN_TRACE,("Failed to allocate memory\n"));
79 MmUnlockPages(Irp->MdlAddress);
80 IoFreeMdl( Irp->MdlAddress );
81 Irp->MdlAddress = NULL;
82 return NULL;
83 }
84
85 RtlCopyMemory(Irp->Tail.Overlay.DriverContext[0],
86 Irp->Tail.Overlay.DriverContext[1],
87 MmGetMdlByteCount(Irp->MdlAddress));
88
89 /* If we don't want a copy back, we zero the mapped address pointer */
90 if (!Output)
91 {
92 Irp->Tail.Overlay.DriverContext[1] = NULL;
93 }
94
95 /* We're using a user-mode buffer directly */
96 if (LockMode != NULL)
97 {
98 *LockMode = UserMode;
99 }
100 }
101 else return NULL;
102 break;
103
104 case IRP_MJ_READ:
105 case IRP_MJ_WRITE:
106 ASSERT(Irp->UserBuffer);
107
108 Irp->MdlAddress =
109 IoAllocateMdl(Irp->UserBuffer,
110 (IrpSp->MajorFunction == IRP_MJ_READ) ?
111 IrpSp->Parameters.Read.Length : IrpSp->Parameters.Write.Length,
112 FALSE,
113 FALSE,
114 NULL );
115 if( Irp->MdlAddress ) {
116 PAFD_RECV_INFO AfdInfo;
117
118 _SEH2_TRY {
119 MmProbeAndLockPages( Irp->MdlAddress, Irp->RequestorMode, IoModifyAccess );
120 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
121 LockFailed = TRUE;
122 } _SEH2_END;
123
124 if( LockFailed ) {
125 AFD_DbgPrint(MIN_TRACE,("Failed to lock pages\n"));
126 IoFreeMdl( Irp->MdlAddress );
127 Irp->MdlAddress = NULL;
128 return NULL;
129 }
130
131 /* We need to create the info struct that AFD expects for all send/recv requests */
132 AfdInfo = ExAllocatePoolWithTag(NonPagedPool,
133 sizeof(AFD_RECV_INFO) + sizeof(AFD_WSABUF),
134 TAG_AFD_DATA_BUFFER);
135
136 if (!AfdInfo)
137 {
138 AFD_DbgPrint(MIN_TRACE,("Failed to allocate memory\n"));
139 MmUnlockPages(Irp->MdlAddress);
140 IoFreeMdl( Irp->MdlAddress );
141 Irp->MdlAddress = NULL;
142 return NULL;
143 }
144
145 /* We'll append the buffer array to this struct */
146 AfdInfo->BufferArray = (PAFD_WSABUF)(AfdInfo + 1);
147 AfdInfo->BufferCount = 1;
148
149 /* Setup the default flags values */
150 AfdInfo->AfdFlags = 0;
151 AfdInfo->TdiFlags = 0;
152
153 /* Now build the buffer array */
154 AfdInfo->BufferArray[0].buf = MmGetSystemAddressForMdl(Irp->MdlAddress);
155 AfdInfo->BufferArray[0].len = MmGetMdlByteCount(Irp->MdlAddress);
156
157 /* Store the struct where AFD expects */
158 Irp->Tail.Overlay.DriverContext[0] = AfdInfo;
159
160 /* Don't copy anything out */
161 Irp->Tail.Overlay.DriverContext[1] = NULL;
162
163 /* We're using a placeholder buffer that we allocated */
164 if (LockMode != NULL)
165 {
166 *LockMode = KernelMode;
167 }
168 }
169 else return NULL;
170 break;
171
172 default:
173 ASSERT(FALSE);
174 return NULL;
175 }
176
177 return GetLockedData(Irp, IrpSp);
178}
GetLockedData
PVOID GetLockedData(PIRP Irp, PIO_STACK_LOCATION IrpSp)
Definition: lock.c:13
MmUnlockPages
VOID NTAPI MmUnlockPages(IN PMDL Mdl)
Definition: mdlsup.c:1435
NormalPagePriority
@ NormalPagePriority
Definition: imports.h:54
Output
@ Output
Definition: arc.h:94
PAFD_WSABUF
struct _AFD_WSABUF * PAFD_WSABUF
_IO_STACK_LOCATION::Read
struct _IO_STACK_LOCATION::@4925::@4929 Read
_IO_STACK_LOCATION::Write
struct _IO_STACK_LOCATION::@4925::@4930 Write
IRP_MJ_INTERNAL_DEVICE_CONTROL
#define IRP_MJ_INTERNAL_DEVICE_CONTROL
MmGetMdlByteCount
#define MmGetMdlByteCount(_Mdl)
MmGetSystemAddressForMdl
#define MmGetSystemAddressForMdl(Mdl)
MmGetSystemAddressForMdlSafe
#define MmGetSystemAddressForMdlSafe(_Mdl, _Priority)

Referenced by AfdBindSocket(), AfdConnectedSocketReadData(), AfdConnectedSocketWriteData(), AfdDisconnect(), AfdEnumEvents(), AfdEventSelect(), AfdGetInfo(), AfdGetTdiHandles(), AfdListenSocket(), AfdPacketSocketReadData(), AfdPacketSocketWriteData(), AfdSetConnectData(), AfdSetConnectDataSize(), AfdSetConnectOptions(), AfdSetConnectOptionsSize(), AfdSetContext(), AfdSetDisconnectData(), AfdSetDisconnectDataSize(), AfdSetDisconnectOptions(), AfdSetDisconnectOptionsSize(), AfdSetInfo(), AfdStreamSocketConnect(), AfdStreamSocketSuperConnect(), AfdSuperAccept(), MimeProtocol_LockRequest(), PersistMoniker_Load(), Protocol_Continue(), Protocol_LockRequest(), Protocol_Start(), ProtocolEmul_LockRequest(), ProtocolSink_ReportData(), test_binding(), test_BindToStorage(), test_download(), test_submit(), and thread_proc().

◆ LostSocket()

NTSTATUS LostSocket ( PIRP  Irp)

Definition at line 387 of file lock.c.

387 {
388 NTSTATUS Status = STATUS_FILE_CLOSED;
389 AFD_DbgPrint(MIN_TRACE,("Called.\n"));
390 Irp->IoStatus.Information = 0;
391 Irp->IoStatus.Status = Status;
392 if ( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
393 IoCompleteRequest( Irp, IO_NO_INCREMENT );
394 return Status;
395}
IO_NO_INCREMENT
#define IO_NO_INCREMENT
Definition: iotypes.h:598

Referenced by AfdAccept(), AfdBindSocket(), AfdCleanupSocket(), AfdConnectedSocketReadData(), AfdConnectedSocketWriteData(), AfdDisconnect(), AfdEnumEvents(), AfdEventSelect(), AfdGetConnectData(), AfdGetConnectOptions(), AfdGetContext(), AfdGetContextSize(), AfdGetDisconnectData(), AfdGetDisconnectOptions(), AfdGetInfo(), AfdGetPeerName(), AfdGetSockName(), AfdGetTdiHandles(), AfdListenSocket(), AfdPacketSocketReadData(), AfdPacketSocketWriteData(), AfdSetConnectData(), AfdSetConnectDataSize(), AfdSetConnectOptions(), AfdSetConnectOptionsSize(), AfdSetContext(), AfdSetDisconnectData(), AfdSetDisconnectDataSize(), AfdSetDisconnectOptions(), AfdSetDisconnectOptionsSize(), AfdSetInfo(), AfdStreamSocketConnect(), AfdStreamSocketSuperConnect(), AfdSuperAccept(), AfdWaitForListen(), and SatisfyAccept().

◆ MakeSocketIntoConnection()

NTSTATUS MakeSocketIntoConnection ( PAFD_FCB  FCB,
BOOL  Receive 
)

Definition at line 259 of file connect.c.

259 {
260 NTSTATUS Status = STATUS_SUCCESS;
261
262 ASSERT(!FCB->Recv.Window);
263 ASSERT(!FCB->Send.Window);
264
265 if (!FCB->Recv.Size)
266 {
267 Status = TdiQueryMaxDatagramLength(FCB->Connection.Object,
268 &FCB->Recv.Size);
269 if (!NT_SUCCESS(Status))
270 return Status;
271 }
272
273 if (!FCB->Send.Size)
274 {
275 Status = TdiQueryMaxDatagramLength(FCB->Connection.Object,
276 &FCB->Send.Size);
277 if (!NT_SUCCESS(Status))
278 return Status;
279 }
280
281 /* Allocate the receive area and start receiving */
282 if (!FCB->Recv.Window)
283 {
284 FCB->Recv.Window = ExAllocatePoolWithTag(PagedPool,
285 FCB->Recv.Size,
286 TAG_AFD_DATA_BUFFER);
287
288 if( !FCB->Recv.Window ) return STATUS_NO_MEMORY;
289 }
290
291 if (!FCB->Send.Window)
292 {
293 FCB->Send.Window = ExAllocatePoolWithTag(PagedPool,
294 FCB->Send.Size,
295 TAG_AFD_DATA_BUFFER);
296
297 if( !FCB->Send.Window ) return STATUS_NO_MEMORY;
298 }
299
300 FCB->SharedData.State = SOCKET_STATE_CONNECTED;
301 FCB->SharedData.ConnectTime = 0; // Not used
302
303 if (Receive)
304 {
305 Status = TdiReceive( &FCB->ReceiveIrp.InFlightRequest,
306 FCB->Connection.Object,
307 TDI_RECEIVE_NORMAL,
308 FCB->Recv.Window,
309 FCB->Recv.Size,
310 ReceiveComplete,
311 FCB );
312
313 if( Status == STATUS_PENDING ) Status = STATUS_SUCCESS;
314 }
315
316 FCB->PollState |= AFD_EVENT_CONNECT | AFD_EVENT_SEND;
317 FCB->PollStatus[FD_CONNECT_BIT] = STATUS_SUCCESS;
318 FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
319 PollReeval( FCB->DeviceExt, FCB->FileObject );
320
321 return Status;
322}
ReceiveComplete
IO_COMPLETION_ROUTINE ReceiveComplete
Definition: afd.h:321
AFD_EVENT_CONNECT
#define AFD_EVENT_CONNECT
Definition: shared.h:225
TDI_RECEIVE_NORMAL
#define TDI_RECEIVE_NORMAL
Definition: tdi.h:122
TdiQueryMaxDatagramLength
NTSTATUS TdiQueryMaxDatagramLength(PFILE_OBJECT FileObject, PUINT MaxDatagramLength)
Definition: tdi.c:203
TdiReceive
NTSTATUS TdiReceive(PIRP *Irp, PFILE_OBJECT ConnectionObject, USHORT Flags, PCHAR Buffer, UINT BufferLength, PIO_COMPLETION_ROUTINE CompletionRoutine, PVOID CompletionContext)
Definition: tdi.c:995
FD_CONNECT_BIT
#define FD_CONNECT_BIT
Definition: winsock2.h:295

Referenced by SatisfyAccept(), and StreamSocketConnectComplete().

◆ OskitDumpBuffer()

VOID OskitDumpBuffer ( PCHAR  Buffer,
UINT  Len 
)

Definition at line 30 of file main.c.

30 {
31 unsigned int i;
32
33 for( i = 0; i < Len; i++ ) {
34 if( i && !(i & 0xf) ) DbgPrint( "\n" );
35 if( !(i & 0xf) ) DbgPrint( "%p: ", (Data + i) );
36 DbgPrint( " %02x", Data[i] & 0xff );
37 }
38 DbgPrint("\n");
39}
Len
#define Len
Definition: deflate.h:82
DbgPrint
#define DbgPrint
Definition: hal.h:12

Referenced by AfdStreamSocketConnect(), and AfdStreamSocketSuperConnect().

◆ PollReeval()

VOID PollReeval ( PAFD_DEVICE_EXTENSION  DeviceObject,
PFILE_OBJECT  FileObject 
)

Definition at line 407 of file select.c.

407 {
408 PAFD_ACTIVE_POLL Poll = NULL;
409 PLIST_ENTRY ThePollEnt = NULL;
410 PAFD_FCB FCB;
411 KIRQL OldIrql;
412 PAFD_POLL_INFO PollReq;
413
414 AFD_DbgPrint(MID_TRACE,("Called: DeviceExt %p FileObject %p\n",
415 DeviceExt, FileObject));
416
417 KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
418
419 /* Take care of any event select signalling */
420 FCB = (PAFD_FCB)FileObject->FsContext;
421
422 if( !FCB ) {
423 KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
424 return;
425 }
426
427 /* Now signal normal select irps */
428 ThePollEnt = DeviceExt->Polls.Flink;
429
430 while( ThePollEnt != &DeviceExt->Polls ) {
431 Poll = CONTAINING_RECORD( ThePollEnt, AFD_ACTIVE_POLL, ListEntry );
432 PollReq = Poll->Irp->AssociatedIrp.SystemBuffer;
433 AFD_DbgPrint(MID_TRACE,("Checking poll %p\n", Poll));
434
435 if( UpdatePollWithFCB( Poll, FileObject ) ) {
436 ThePollEnt = ThePollEnt->Flink;
437 AFD_DbgPrint(MID_TRACE,("Signalling socket\n"));
438 SignalSocket( Poll, NULL, PollReq, STATUS_SUCCESS );
439 } else
440 ThePollEnt = ThePollEnt->Flink;
441 }
442
443 KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
444
445 if((FCB->EventSelect) &&
446 (FCB->PollState & (FCB->EventSelectTriggers & ~FCB->EventSelectDisabled)))
447 {
448 AFD_DbgPrint(MID_TRACE,("Setting event %p\n", FCB->EventSelect));
449
450 /* Set the application's event */
451 KeSetEvent( FCB->EventSelect, IO_NETWORK_INCREMENT, FALSE );
452 }
453
454 AFD_DbgPrint(MID_TRACE,("Leaving\n"));
455}
PAFD_FCB
struct _AFD_FCB * PAFD_FCB
UpdatePollWithFCB
static BOOLEAN UpdatePollWithFCB(PAFD_ACTIVE_POLL Poll, PFILE_OBJECT FileObject)
Definition: select.c:382
_IRP::SystemBuffer
PVOID SystemBuffer
Definition: Bus_PDO_EvalMethod.c:110
_IRP::AssociatedIrp
union _IRP::@1805 AssociatedIrp

Referenced by AfdAccept(), AfdConnectedSocketReadData(), AfdConnectedSocketWriteData(), AfdCreateSocket(), AfdPacketSocketReadData(), AfdWaitForListen(), DisconnectComplete(), ListenComplete(), MakeSocketIntoConnection(), PacketSocketRecvComplete(), PacketSocketSendComplete(), ReceiveActivity(), SendComplete(), and StreamSocketConnectComplete().

◆ QueueUserModeIrp()

NTSTATUS QueueUserModeIrp ( PAFD_FCB  FCB,
PIRP  Irp,
UINT  Function 
)

Definition at line 397 of file lock.c.

398{
399 NTSTATUS Status;
400
401 /* Add the IRP to the queue in all cases (so AfdCancelHandler will work properly) */
402 InsertTailList( &FCB->PendingIrpList[Function],
403 &Irp->Tail.Overlay.ListEntry );
404
405 /* Acquire the cancel spin lock and check the cancel bit */
406 IoAcquireCancelSpinLock(&Irp->CancelIrql);
407 if (!Irp->Cancel)
408 {
409 /* We are not cancelled; we're good to go so
410 * set the cancel routine, release the cancel spin lock,
411 * mark the IRP as pending, and
412 * return STATUS_PENDING to the caller
413 */
414 (void)IoSetCancelRoutine(Irp, AfdCancelHandler);
415 IoReleaseCancelSpinLock(Irp->CancelIrql);
416 IoMarkIrpPending(Irp);
417 Status = STATUS_PENDING;
418 }
419 else
420 {
421 /* We were already cancelled before we were able to register our cancel routine
422 * so we are to call the cancel routine ourselves right here to cancel the IRP
423 * (which handles all the stuff we do above) and return STATUS_CANCELLED to the caller
424 */
425 AfdCancelHandler(IoGetCurrentIrpStackLocation(Irp)->DeviceObject,
426 Irp);
427 Status = STATUS_CANCELLED;
428 }
429
430 return Status;
431}
IoReleaseCancelSpinLock
VOID NTAPI IoReleaseCancelSpinLock(IN KIRQL Irql)
Definition: util.c:150
IoAcquireCancelSpinLock
VOID NTAPI IoAcquireCancelSpinLock(OUT PKIRQL Irql)
Definition: util.c:56

Referenced by AfdConnectedSocketWriteData(), AfdDisconnect(), AfdPacketSocketWriteData(), AfdStreamSocketConnect(), AfdStreamSocketSuperConnect(), and LeaveIrpUntilLater().

◆ RetryDisconnectCompletion()

VOID RetryDisconnectCompletion ( PAFD_FCB  FCB)

Definition at line 708 of file main.c.

709{
710 ASSERT(FCB->RemoteAddress);
711
712 if (IsListEmpty(&FCB->PendingIrpList[FUNCTION_SEND]) && !FCB->SendIrp.InFlightRequest && FCB->DisconnectPending)
713 {
714 /* Sends are done; fire off a TDI_DISCONNECT request */
715 DoDisconnect(FCB);
716 }
717}
DoDisconnect
static NTSTATUS DoDisconnect(PAFD_FCB FCB)
Definition: main.c:673

Referenced by SendComplete().

◆ SignalSocket()

VOID SignalSocket ( PAFD_ACTIVE_POLL Poll  OPTIONAL,
PIRP _Irp  OPTIONAL,
PAFD_POLL_INFO  PollReq,
NTSTATUS  Status 
)

Definition at line 56 of file select.c.

62{
63 UINT i;
64 PIRP Irp = _Irp ? _Irp : Poll->Irp;
65 AFD_DbgPrint(MID_TRACE,("Called (Status %x)\n", Status));
66
67 if (Poll)
68 {
69 KeCancelTimer( &Poll->Timer );
70 RemoveEntryList( &Poll->ListEntry );
71 ExFreePoolWithTag(Poll, TAG_AFD_ACTIVE_POLL);
72 }
73
74 Irp->IoStatus.Status = Status;
75 Irp->IoStatus.Information =
76 FIELD_OFFSET(AFD_POLL_INFO, Handles) + sizeof(AFD_HANDLE) * PollReq->HandleCount;
77 CopyBackStatus( PollReq->Handles,
78 PollReq->HandleCount );
79 for( i = 0; i < PollReq->HandleCount; i++ ) {
80 AFD_DbgPrint
81 (MAX_TRACE,
82 ("Handle(%x): Got %x,%x\n",
83 PollReq->Handles[i].Handle,
84 PollReq->Handles[i].Events,
85 PollReq->Handles[i].Status));
86 }
87 UnlockHandles( AFD_HANDLES(PollReq), PollReq->HandleCount );
88 if( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
89 AFD_DbgPrint(MID_TRACE,("Completing\n"));
90 (void)IoSetCancelRoutine(Irp, NULL);
91 IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
92 AFD_DbgPrint(MID_TRACE,("Done\n"));
93}
CopyBackStatus
static VOID CopyBackStatus(PAFD_HANDLE HandleArray, UINT HandleCount)
Definition: select.c:34
AFD_HANDLE
struct _AFD_HANDLE_ AFD_HANDLE
KeCancelTimer
BOOLEAN NTAPI KeCancelTimer(IN OUT PKTIMER Timer)
Definition: timerobj.c:206
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255

Referenced by AfdSelect(), CleanupPendingIrp(), KillSelectsForFCB(), PollReeval(), and SelectTimeout().

◆ SocketAcquireStateLock()

BOOLEAN SocketAcquireStateLock ( PAFD_FCB  FCB)

Definition at line 360 of file lock.c.

360 {
361 if( !FCB ) return FALSE;
362
363 return !KeWaitForMutexObject(&FCB->Mutex,
364 Executive,
365 KernelMode,
366 FALSE,
367 NULL);
368}
KeWaitForMutexObject
#define KeWaitForMutexObject
Definition: kefuncs.h:543
Executive
@ Executive
Definition: ketypes.h:467

Referenced by AcceptExReceiveComplete(), AfdAccept(), AfdBindSocket(), AfdCancelHandler(), AfdCleanupSocket(), AfdCloseSocket(), AfdConnectedSocketReadData(), AfdConnectedSocketWriteData(), AfdDisconnect(), AfdEnumEvents(), AfdEventSelect(), AfdGetConnectData(), AfdGetConnectOptions(), AfdGetContext(), AfdGetContextSize(), AfdGetDisconnectData(), AfdGetDisconnectOptions(), AfdGetInfo(), AfdGetPeerName(), AfdGetSockName(), AfdGetTdiHandles(), AfdListenSocket(), AfdPacketSocketReadData(), AfdPacketSocketWriteData(), AfdSetConnectData(), AfdSetConnectDataSize(), AfdSetConnectOptions(), AfdSetConnectOptionsSize(), AfdSetContext(), AfdSetDisconnectData(), AfdSetDisconnectDataSize(), AfdSetDisconnectOptions(), AfdSetDisconnectOptionsSize(), AfdSetInfo(), AfdStreamSocketConnect(), AfdStreamSocketSuperConnect(), AfdSuperAccept(), AfdWaitForListen(), DisconnectComplete(), ListenComplete(), PacketSocketRecvComplete(), PacketSocketSendComplete(), ReceiveComplete(), SatisfyAccept(), SendComplete(), StreamSocketConnectComplete(), and StreamSocketConnectSendComplete().

◆ SocketStateUnlock()

VOID SocketStateUnlock ( PAFD_FCB  FCB)

Definition at line 370 of file lock.c.

370 {
371 KeReleaseMutex(&FCB->Mutex, FALSE);
372}
KeReleaseMutex
LONG NTAPI KeReleaseMutex(IN PKMUTEX Mutex, IN BOOLEAN Wait)
Definition: mutex.c:189

Referenced by AcceptExReceiveComplete(), AfdAccept(), AfdCancelHandler(), AfdCloseSocket(), AfdConnectedSocketReadData(), AfdConnectedSocketWriteData(), AfdDisconnect(), AfdPacketSocketWriteData(), AfdStreamSocketConnect(), AfdStreamSocketSuperConnect(), AfdSuperAccept(), AfdWaitForListen(), DisconnectComplete(), LeaveIrpUntilLater(), ListenComplete(), PacketSocketRecvComplete(), PacketSocketSendComplete(), ReceiveComplete(), SatisfyAccept(), SendComplete(), StreamSocketConnectComplete(), StreamSocketConnectSendComplete(), and UnlockAndMaybeComplete().

◆ UnlockAndMaybeComplete()

NTSTATUS NTAPI UnlockAndMaybeComplete ( PAFD_FCB  FCB,
NTSTATUS  Status,
PIRP  Irp,
UINT  Information 
)

Definition at line 374 of file lock.c.

376 {
377 Irp->IoStatus.Status = Status;
378 Irp->IoStatus.Information = Information;
379 if ( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
380 (void)IoSetCancelRoutine(Irp, NULL);
381 SocketStateUnlock( FCB );
382 IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
383 return Status;
384}
Information
_In_ WDFREQUEST _In_ NTSTATUS _In_ ULONG_PTR Information
Definition: wdfrequest.h:1049

Referenced by AfdAccept(), AfdBindSocket(), AfdCancelHandler(), AfdCleanupSocket(), AfdConnectedSocketReadData(), AfdConnectedSocketWriteData(), AfdDisconnect(), AfdEnumEvents(), AfdEventSelect(), AfdGetConnectData(), AfdGetConnectOptions(), AfdGetContext(), AfdGetContextSize(), AfdGetDisconnectData(), AfdGetDisconnectOptions(), AfdGetInfo(), AfdGetPeerName(), AfdGetSockName(), AfdGetTdiHandles(), AfdListenSocket(), AfdPacketSocketReadData(), AfdPacketSocketWriteData(), AfdSetConnectData(), AfdSetConnectDataSize(), AfdSetConnectOptions(), AfdSetConnectOptionsSize(), AfdSetContext(), AfdSetDisconnectData(), AfdSetDisconnectDataSize(), AfdSetDisconnectOptions(), AfdSetDisconnectOptionsSize(), AfdSetInfo(), AfdStreamSocketConnect(), AfdStreamSocketSuperConnect(), AfdSuperAccept(), AfdWaitForListen(), and SatisfyAccept().

◆ UnlockBuffers()

VOID UnlockBuffers ( PAFD_WSABUF  Buf,
UINT  Count,
BOOL  Address 
)

Definition at line 289 of file lock.c.

289 {
290 UINT Lock = Address ? 2 : 0;
291 PAFD_MAPBUF Map = (PAFD_MAPBUF)(Buf + Count + Lock);
292 UINT i;
293
294 if( !Buf ) return;
295
296 for( i = 0; i < Count + Lock; i++ ) {
297 if( Map[i].Mdl ) {
298 MmUnlockPages( Map[i].Mdl );
299 IoFreeMdl( Map[i].Mdl );
300 Map[i].Mdl = NULL;
301 }
302 }
303
304 ExFreePoolWithTag(Buf, TAG_AFD_WSA_BUFFER);
305 Buf = NULL;
306}

Referenced by AfdConnectedSocketReadData(), AfdConnectedSocketWriteData(), AfdPacketSocketReadData(), AfdPacketSocketWriteData(), CleanupPendingIrp(), PacketSocketRecvComplete(), PacketSocketSendComplete(), ReceiveActivity(), ReceiveComplete(), and SendComplete().

◆ UnlockHandles()

VOID UnlockHandles ( PAFD_HANDLE  HandleArray,
UINT  HandleCount 
)

Definition at line 348 of file lock.c.

348 {
349 UINT i;
350
351 for( i = 0; i < HandleCount; i++ ) {
352 if( HandleArray[i].Handle )
353 ObDereferenceObject( (PVOID)HandleArray[i].Handle );
354 }
355
356 ExFreePoolWithTag(HandleArray, TAG_AFD_POLL_HANDLE);
357 HandleArray = NULL;
358}

Referenced by LockHandles(), and SignalSocket().

◆ UnlockRequest()

VOID UnlockRequest ( PIRP  Irp,
PIO_STACK_LOCATION  IrpSp 
)

Definition at line 180 of file lock.c.

181{
182 ASSERT(Irp->MdlAddress);
183 ASSERT(Irp->Tail.Overlay.DriverContext[0]);
184
185 UNREFERENCED_PARAMETER(IrpSp);
186
187 /* Check if we need to copy stuff back */
188 if (Irp->Tail.Overlay.DriverContext[1] != NULL)
189 {
190 RtlCopyMemory(Irp->Tail.Overlay.DriverContext[1],
191 Irp->Tail.Overlay.DriverContext[0],
192 MmGetMdlByteCount(Irp->MdlAddress));
193 }
194
195 ExFreePoolWithTag(Irp->Tail.Overlay.DriverContext[0], TAG_AFD_DATA_BUFFER);
196 MmUnlockPages( Irp->MdlAddress );
197 IoFreeMdl( Irp->MdlAddress );
198 Irp->MdlAddress = NULL;
199}

Referenced by AcceptExReceiveComplete(), AfdConnectedSocketWriteData(), AfdDisconnect(), AfdPacketSocketWriteData(), DisconnectComplete(), ListenComplete(), LostSocket(), MimeProtocol_UnlockRequest(), PacketSocketRecvComplete(), PacketSocketSendComplete(), Protocol_UnlockRequest(), ProtocolEmul_UnlockRequest(), ReceiveActivity(), ReceiveComplete(), SatisfyPreAccept(), SatisfySuperAccept(), SendComplete(), SignalSocket(), StreamSocketConnectComplete(), StreamSocketConnectSendComplete(), test_binding(), test_BindToObject(), test_BindToStorage(), test_download(), test_submit(), test_URLDownloadToFile(), and UnlockAndMaybeComplete().

◆ WarmSocketForBind()

NTSTATUS WarmSocketForBind ( PAFD_FCB  FCB,
ULONG  ShareType 
)

Definition at line 13 of file bind.c.

13 {
14 NTSTATUS Status;
15
16 AFD_DbgPrint(MID_TRACE,("Called (AF %u)\n",
17 FCB->LocalAddress->Address[0].AddressType));
18
19 if( !FCB->TdiDeviceName.Length || !FCB->TdiDeviceName.Buffer ) {
20 AFD_DbgPrint(MIN_TRACE,("Null Device\n"));
21 return STATUS_NO_SUCH_DEVICE;
22 }
23 if( !FCB->LocalAddress ) {
24 AFD_DbgPrint(MIN_TRACE,("No local address\n"));
25 return STATUS_INVALID_PARAMETER;
26 }
27
28 Status = TdiOpenAddressFile(&FCB->TdiDeviceName,
29 FCB->LocalAddress,
30 ShareType,
31 &FCB->AddressFile.Handle,
32 &FCB->AddressFile.Object );
33 if (!NT_SUCCESS(Status))
34 return Status;
35
36 if (FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
37 {
38 if (!FCB->Recv.Size)
39 {
40 Status = TdiQueryMaxDatagramLength(FCB->AddressFile.Object,
41 &FCB->Recv.Size);
42 }
43
44 if (NT_SUCCESS(Status) && !FCB->Recv.Window)
45 {
46 FCB->Recv.Window = ExAllocatePoolWithTag(PagedPool,
47 FCB->Recv.Size,
48 TAG_AFD_DATA_BUFFER);
49
50 if (!FCB->Recv.Window)
51 Status = STATUS_NO_MEMORY;
52 }
53
54 if (NT_SUCCESS(Status) && FCB->Recv.Content < FCB->Recv.Size)
55 {
56 Status = TdiReceiveDatagram(&FCB->ReceiveIrp.InFlightRequest,
57 FCB->AddressFile.Object,
58 0,
59 FCB->Recv.Window,
60 FCB->Recv.Size,
61 FCB->AddressFrom,
62 PacketSocketRecvComplete,
63 FCB);
64
65 /* We don't want to wait for this read to complete. */
66 if( Status == STATUS_PENDING ) Status = STATUS_SUCCESS;
67 }
68 }
69
70 AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
71
72 return Status;
73}
PacketSocketRecvComplete
IO_COMPLETION_ROUTINE PacketSocketRecvComplete
Definition: afd.h:323
TdiReceiveDatagram
NTSTATUS TdiReceiveDatagram(PIRP *Irp, PFILE_OBJECT TransportObject, USHORT Flags, PCHAR Buffer, UINT BufferLength, PTDI_CONNECTION_INFORMATION From, PIO_COMPLETION_ROUTINE CompletionRoutine, PVOID CompletionContext)
Receives a datagram.
Definition: tdi.c:1075
TdiOpenAddressFile
NTSTATUS TdiOpenAddressFile(PUNICODE_STRING DeviceName, PTRANSPORT_ADDRESS Name, ULONG ShareType, PHANDLE AddressHandle, PFILE_OBJECT *AddressObject)
Opens an IPv4 address file object.
Definition: tdi.c:148
STATUS_NO_SUCH_DEVICE
#define STATUS_NO_SUCH_DEVICE
Definition: udferr_usr.h:136

Referenced by AfdBindSocket(), AfdPacketSocketWriteData(), and AfdStreamSocketConnect().

◆ WarmSocketForConnection()

NTSTATUS WarmSocketForConnection ( PAFD_FCB  FCB)

Definition at line 238 of file connect.c.

238 {
239 NTSTATUS Status;
240
241 if( !FCB->TdiDeviceName.Length || !FCB->TdiDeviceName.Buffer ) {
242 AFD_DbgPrint(MIN_TRACE,("Null Device\n"));
243 return STATUS_NO_SUCH_DEVICE;
244 }
245
246 Status = TdiOpenConnectionEndpointFile(&FCB->TdiDeviceName,
247 &FCB->Connection.Handle,
248 &FCB->Connection.Object );
249
250 if( NT_SUCCESS(Status) ) {
251 Status = TdiAssociateAddressFile( FCB->AddressFile.Handle,
252 FCB->Connection.Object );
253 }
254
255 return Status;
256}
TdiOpenConnectionEndpointFile
NTSTATUS TdiOpenConnectionEndpointFile(PUNICODE_STRING DeviceName, PHANDLE ConnectionHandle, PFILE_OBJECT *ConnectionObject)
Opens a connection endpoint file object.
Definition: tdi.c:258
TdiAssociateAddressFile
NTSTATUS TdiAssociateAddressFile(HANDLE AddressHandle, PFILE_OBJECT ConnectionObject)
Associates a connection endpoint to an address file object.
Definition: tdi.c:364

Referenced by AfdListenSocket(), AfdStreamSocketConnect(), AfdStreamSocketSuperConnect(), and ListenComplete().

◆ ZeroEvents()

VOID ZeroEvents ( PAFD_HANDLE  HandleArray,
UINT  HandleCount 
)

Definition at line 44 of file select.c.

45 {
46 UINT i;
47
48 for( i = 0; i < HandleCount; i++ ) {
49 HandleArray[i].Status = 0;
50 HandleArray[i].Events = 0;
51 }
52}

Referenced by CleanupPendingIrp(), KillSelectsForFCB(), and SelectTimeout().

Variable Documentation

◆ AcceptExReceiveComplete

IO_COMPLETION_ROUTINE AcceptExReceiveComplete

Definition at line 319 of file afd.h.

Referenced by SatisfySuperAccept().

◆ AfdCancelHandler

DRIVER_CANCEL AfdCancelHandler

Definition at line 313 of file afd.h.

Referenced by AfdConnectedSocketReadData(), AfdSelect(), and QueueUserModeIrp().

◆ PacketSocketRecvComplete

IO_COMPLETION_ROUTINE PacketSocketRecvComplete

Definition at line 323 of file afd.h.

Referenced by PacketSocketRecvComplete(), and WarmSocketForBind().

◆ ReceiveComplete

IO_COMPLETION_ROUTINE ReceiveComplete

Definition at line 321 of file afd.h.

Referenced by MakeSocketIntoConnection(), RefillSocketBuffer(), and SatisfySuperAccept().