sndrcv.c

winNT技术操作系统,国外开放的原代码和LIUX一样

/*
 * COPYRIGHT:   See COPYING in the top level directory
 * PROJECT:     ReactOS Ancillary Function Driver DLL
 * FILE:        misc/sndrcv.c
 * PURPOSE:     Send/receive routines
 * PROGRAMMERS: Casper S. Hornstrup ([e-mail])
 *				Alex Ionescu ([e-mail])
 * REVISIONS:
 *   CSH 01/09-2000 Created
 *	 Alex 16/07/2004 - Complete Rewrite
 */

#include <msafd.h>

#include <debug.h>

INT
WSPAPI
WSPAsyncSelect(
    IN  SOCKET Handle, 
    IN  HWND hWnd, 
    IN  UINT wMsg, 
    IN  LONG lEvent, 
    OUT LPINT lpErrno)
{
	PSOCKET_INFORMATION Socket = NULL;
	PASYNC_DATA AsyncData;
	NTSTATUS Status;
	ULONG BlockMode;

	/* Get the Socket Structure associated to this Socket */
	Socket = GetSocketStructure(Handle);

	/* Allocate the Async Data Structure to pass on to the Thread later */
	AsyncData = HeapAlloc(GetProcessHeap(), 0, sizeof(*AsyncData));

	/* Change the Socket to Non Blocking */
	BlockMode = 1;
	SetSocketInformation(Socket, AFD_INFO_BLOCKING_MODE, &BlockMode, NULL);
	Socket->SharedData.NonBlocking = TRUE;

	/* Deactive WSPEventSelect */
	if (Socket->SharedData.AsyncEvents) {
		WSPEventSelect(Handle, NULL, 0, NULL);
	}

	/* Create the Asynch Thread if Needed */  
	SockCreateOrReferenceAsyncThread();
	
	/* Open a Handle to AFD's Async Helper */
	SockGetAsyncSelectHelperAfdHandle();

	/* Store Socket Data */
	Socket->SharedData.hWnd = hWnd;
	Socket->SharedData.wMsg = wMsg;
	Socket->SharedData.AsyncEvents = lEvent;
	Socket->SharedData.AsyncDisabledEvents = 0;
	Socket->SharedData.SequenceNumber++;

    /* Return if there are no more Events */
	if ((Socket->SharedData.AsyncEvents & (~Socket->SharedData.AsyncDisabledEvents)) == 0) {
		HeapFree(GetProcessHeap(), 0, AsyncData);
		return 0;
	}

	/* Set up the Async Data */
	AsyncData->ParentSocket = Socket;
	AsyncData->SequenceNumber = Socket->SharedData.SequenceNumber;

	/* Begin Async Select by using I/O Completion */
	Status = NtSetIoCompletion(SockAsyncCompletionPort,
				  (PVOID)&SockProcessQueuedAsyncSelect,
				  AsyncData,
				  0,
				  0);

	/* Return */
	return ERROR_SUCCESS;
}


int 
WSPAPI
WSPRecv(
	SOCKET Handle, 
	LPWSABUF lpBuffers, 
	DWORD dwBufferCount, 
	LPDWORD lpNumberOfBytesRead, 
	LPDWORD ReceiveFlags, 
	LPWSAOVERLAPPED lpOverlapped, 
	LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, 
	LPWSATHREADID lpThreadId, 
	LPINT lpErrno)
{
	PIO_STATUS_BLOCK			IOSB;
	IO_STATUS_BLOCK				DummyIOSB;
	AFD_RECV_INFO				RecvInfo;
	NTSTATUS					Status;
	PVOID						APCContext;
	PVOID						APCFunction;
	HANDLE						Event;
	HANDLE                                  SockEvent;
	PSOCKET_INFORMATION			Socket;

	AFD_DbgPrint(MID_TRACE,("Called (%x)\n", Handle));

	/* Get the Socket Structure associate to this Socket*/
	Socket = GetSocketStructure(Handle);

	Status = NtCreateEvent( &SockEvent, GENERIC_READ | GENERIC_WRITE,
				NULL, 1, FALSE );

	if( !NT_SUCCESS(Status) ) return -1;

    /* Set up the Receive Structure */
    RecvInfo.BufferArray = (PAFD_WSABUF)lpBuffers;
    RecvInfo.BufferCount = dwBufferCount;
	RecvInfo.TdiFlags = 0;
	RecvInfo.AfdFlags = Socket->SharedData.NonBlocking ? AFD_IMMEDIATE : 0;

	/* Set the TDI Flags */
	if (*ReceiveFlags == 0) {
		RecvInfo.TdiFlags |= TDI_RECEIVE_NORMAL;
	
	} else {
	
		if (*ReceiveFlags & MSG_OOB) {
			RecvInfo.TdiFlags |= TDI_RECEIVE_EXPEDITED;
		} else {
			RecvInfo.TdiFlags |= TDI_RECEIVE_NORMAL;
		}

		if (*ReceiveFlags & MSG_PEEK) {
			RecvInfo.TdiFlags |= TDI_RECEIVE_PEEK;
		}

		if (*ReceiveFlags & MSG_PARTIAL) {
			RecvInfo.TdiFlags |= TDI_RECEIVE_NORMAL;
		}
	}

	/* Verifiy if we should use APC */

	if (lpOverlapped == NULL) {

		/* Not using Overlapped structure, so use normal blocking on event */
		APCContext = NULL;
		APCFunction = NULL;
		Event = SockEvent;
		IOSB = &DummyIOSB;

	} else {

		if (lpCompletionRoutine == NULL) {

			/* Using Overlapped Structure, but no Completition Routine, so no need for APC */
			APCContext = lpOverlapped;
			APCFunction = NULL;
			Event = lpOverlapped->hEvent;
		
		} else {

			/* Using Overlapped Structure and a Completition Routine, so use an APC */
			APCFunction = NULL; // should be a private io completition function inside us
			APCContext = lpCompletionRoutine;
			RecvInfo.AfdFlags = AFD_SKIP_FIO;
		}

		IOSB = (PIO_STATUS_BLOCK)&lpOverlapped->Internal;
		RecvInfo.AfdFlags |= AFD_OVERLAPPED;
	}

	IOSB->Status = STATUS_PENDING;

	/* Send IOCTL */
	Status = NtDeviceIoControlFile((HANDLE)Handle,
					SockEvent,
					APCFunction,
					APCContext,
					IOSB,
					IOCTL_AFD_RECV,
					&RecvInfo,
					sizeof(RecvInfo),
					NULL,
					0);

	/* Wait for completition of not overlapped */
	if (Status == STATUS_PENDING && lpOverlapped == NULL) {
	    /* It's up to the protocol to time out recv.  We must wait
	     * until the protocol decides it's had enough. */
	    WaitForSingleObject(SockEvent, INFINITE);
	    Status = IOSB->Status;
	}

    NtClose( SockEvent );

    AFD_DbgPrint(MID_TRACE,("Status %x Information %d\n", 
			    Status, IOSB->Information));

    /* Return the Flags */
    *ReceiveFlags = 0;

    switch (Status) {
    case STATUS_RECEIVE_EXPEDITED: *ReceiveFlags = MSG_OOB; break;
    case STATUS_RECEIVE_PARTIAL_EXPEDITED: 
	*ReceiveFlags = MSG_PARTIAL | MSG_OOB; break;
    case STATUS_RECEIVE_PARTIAL: *ReceiveFlags = MSG_PARTIAL; break;
    }
    
    /* Re-enable Async Event */
    if (*ReceiveFlags == MSG_OOB) {
        SockReenableAsyncSelectEvent(Socket, FD_OOB);
    } else {
        SockReenableAsyncSelectEvent(Socket, FD_READ);
    }

    return MsafdReturnWithErrno
	( Status, lpErrno, IOSB->Information, lpNumberOfBytesRead );
}

int 
WSPAPI 
WSPRecvFrom(
	SOCKET Handle, 
	LPWSABUF lpBuffers, 
	DWORD dwBufferCount, 
	LPDWORD lpNumberOfBytesRead, 
	LPDWORD ReceiveFlags, 
	struct sockaddr *SocketAddress, 
	int *SocketAddressLength, 
	LPWSAOVERLAPPED lpOverlapped, 
	LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, 
	LPWSATHREADID lpThreadId, 
	LPINT lpErrno)
{
	PIO_STATUS_BLOCK			IOSB;
	IO_STATUS_BLOCK				DummyIOSB;
	AFD_RECV_INFO_UDP			RecvInfo;
	NTSTATUS					Status;
	PVOID						APCContext;
	PVOID						APCFunction;
	HANDLE						Event;
	HANDLE                                  SockEvent;
	PSOCKET_INFORMATION			Socket;

	/* Get the Socket Structure associate to this Socket*/
	Socket = GetSocketStructure(Handle);

	Status = NtCreateEvent( &SockEvent, GENERIC_READ | GENERIC_WRITE,
				NULL, 1, FALSE );

	if( !NT_SUCCESS(Status) ) return -1;

    /* Set up the Receive Structure */
    RecvInfo.BufferArray = (PAFD_WSABUF)lpBuffers;
    RecvInfo.BufferCount = dwBufferCount;
	RecvInfo.TdiFlags = 0;
	RecvInfo.AfdFlags = Socket->SharedData.NonBlocking ? AFD_IMMEDIATE : 0;
	RecvInfo.AddressLength = SocketAddressLength;
	RecvInfo.Address = SocketAddress;

	/* Set the TDI Flags */
	if (*ReceiveFlags == 0) {
		RecvInfo.TdiFlags |= TDI_RECEIVE_NORMAL;
	
	} else {
	
		if (*ReceiveFlags & MSG_OOB) {
			RecvInfo.TdiFlags |= TDI_RECEIVE_EXPEDITED;
		} else {
			RecvInfo.TdiFlags |= TDI_RECEIVE_NORMAL;
		}

		if (*ReceiveFlags & MSG_PEEK) {
			RecvInfo.TdiFlags |= TDI_RECEIVE_PEEK;
		}

		if (*ReceiveFlags & MSG_PARTIAL) {
			RecvInfo.TdiFlags |= TDI_RECEIVE_NORMAL;
		}
	}

	/* Verifiy if we should use APC */

	if (lpOverlapped == NULL) {

		/* Not using Overlapped structure, so use normal blocking on event */
		APCContext = NULL;
		APCFunction = NULL;
		Event = SockEvent;
		IOSB = &DummyIOSB;

	} else {

		if (lpCompletionRoutine == NULL) {

			/* Using Overlapped Structure, but no Completition Routine, so no need for APC */
			APCContext = lpOverlapped;
			APCFunction = NULL;
			Event = lpOverlapped->hEvent;
		
		} else {

			/* Using Overlapped Structure and a Completition Routine, so use an APC */
			APCFunction = NULL; // should be a private io completition function inside us
			APCContext = lpCompletionRoutine;
			RecvInfo.AfdFlags = AFD_SKIP_FIO;
		}

		IOSB = (PIO_STATUS_BLOCK)&lpOverlapped->Internal;
		RecvInfo.AfdFlags |= AFD_OVERLAPPED;