windows-server-2003/net/irda/winsock/wshirda.c

/*++

Copyright (c) 1996 Microsoft Corporation

Module Name:

    WshIrDA.c

Abstract:

    This module contains necessary routines for the IrDA Windows Sockets
    Helper DLL.  This DLL provides the transport-specific support necessary
    for the Windows Sockets DLL to use IrDA as a transport.

Author:

    Zed (mikezin)               28-Aug-1996
    mbert                       Sept 97

--*/

#define UNICODE
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>


#include <windows.h>
#include <stdio.h>
#include <ctype.h>
#include <wchar.h>
#include <tdi.h>

#include <winsock2.h>
#include <wsahelp.h>

#include <tdistat.h>
#include <tdiinfo.h>
#include <llinfo.h>


typedef unsigned long   ulong;
typedef unsigned short  ushort;
typedef unsigned int    uint;
typedef unsigned char   uchar;

#define NT  /* for tdiinfo.h */
#include <tdiinfo.h>


#include <basetyps.h>
#include <nspapi.h>
#include <nspapip.h>

#include <af_irda.h>
#include <irioctl.h>
#include <irdatdi.h>

#define MIN_SOCKADDR_LEN    8
#define MAX_SOCKADDR_LEN    sizeof(SOCKADDR_IRDA)

#ifdef _NOT_DBG
//#ifdef DBG
#define DEBUGMSG(s)   DbgPrint s
#else
#define DEBUGMSG(s)
#endif

typedef struct WshIrdaIasAttrib
{
    HANDLE                  AttribHandle;
    struct WshIrdaIasAttrib *pNext;
} WSHIRDA_IAS_ATTRIBUTE, *PWSHIRDA_IAS_ATTRIBUTE;

typedef struct _WSHIRDA_SOCKET_CONTEXT
{
    PWSHIRDA_IAS_ATTRIBUTE          pIasAttribs;
    // all fields copied from parent to child (at accept) must follow    
    // (see SetSocketInformation SO_CONTEXT)
    INT                             AddressFamily;
    INT                             SocketType;
    INT                             Protocol;
    DWORD                           Options;
    HANDLE                          LazyDscvDevHandle;
} WSHIRDA_SOCKET_CONTEXT, *PWSHIRDA_SOCKET_CONTEXT;

typedef struct
{
    DWORD Rows;
    DWORD Columns;
    struct {
        DWORD AddressFamily;
        DWORD SocketType;
        DWORD Protocol;
    } Mapping[3];
} IRDA_WINSOCK_MAPPING;

const IRDA_WINSOCK_MAPPING IrDAMapping =
  { 3, 3,
    AF_IRDA, SOCK_STREAM, IRDA_PROTO_SOCK_STREAM,
    AF_IRDA, SOCK_STREAM, 0,
    AF_IRDA, 0,           IRDA_PROTO_SOCK_STREAM };
    
WSAPROTOCOL_INFOW Winsock2Protocols[] =
    {
        {
            XP1_GUARANTEED_DELIVERY                 // dwServiceFlags1
                | XP1_GUARANTEED_ORDER
                | XP1_IFS_HANDLES,                
            0,                                      // dwServiceFlags2
            0,                                      // dwServiceFlags3
            0,                                      // dwServiceFlags4
            PFL_MATCHES_PROTOCOL_ZERO,              // dwProviderFlags
            {                                       // gProviderId
                0, 0, 0,
                { 0, 0, 0, 0, 0, 0, 0, 0 }
            },
            0,                                      // dwCatalogEntryId
            {                                       // ProtocolChain
                BASE_PROTOCOL,                      // ChainLen
                { 0, 0, 0, 0, 0, 0, 0 }              // ChainEntries
            },
            2,                                      // iVersion
            AF_IRDA,                                // iAddressFamily
            
            // winsock doesn't seem to use min and max here,
            // it gets it from inf and is stored
            // in CCS\services\irda\parameters\winsock
            sizeof(SOCKADDR_IRDA),                  // iMaxSockAddr
            8,                                      // iMinSockAddr
            
            SOCK_STREAM,                            // iSocketType
            IRDA_PROTO_SOCK_STREAM,                 // iProtocol
            0,                                      // iProtocolMaxOffset
            BIGENDIAN,                              // iNetworkByteOrder
            SECURITY_PROTOCOL_NONE,                 // iSecurityScheme
            0,                                      // dwMessageSize
            0,                                      // dwProviderReserved
            L"MSAFD Irda [IrDA]"                    // szProtocol
        }
    };
        
GUID IrdaProviderGuid = { /* 3972523d-2af1-11d1-b655-00805f3642cc */
    0x3972523d,
    0x2af1,
    0x11d1,
    {0xb6, 0x55, 0x00, 0x80, 0x5f, 0x36, 0x42, 0xcc}
    };    

VOID
DeleteSocketAttribs(PWSHIRDA_SOCKET_CONTEXT pSocket);

// globals
CRITICAL_SECTION        IrdaCs;

BOOLEAN
DllInitialize(
    IN PVOID DllHandle,
    IN ULONG Reason,
    IN PVOID Context OPTIONAL)
{
    switch(Reason)
    {
        case DLL_PROCESS_ATTACH:
        
            // We don't need to receive thread attach and detach
            // notifications, so disable them to help application
            // performance.
            DisableThreadLibraryCalls(DllHandle);
            
            try 
            { 
                InitializeCriticalSection(&IrdaCs);
            }
            except (STATUS_NO_MEMORY == GetExceptionCode())
            {
                return FALSE;
            }        
            return TRUE;

        case DLL_THREAD_ATTACH:
            break;

        case DLL_PROCESS_DETACH:
            DeleteCriticalSection(&IrdaCs);
            break;

        case DLL_THREAD_DETACH:
            break;
    }

    return TRUE;
}

INT
IoStatusToWs(NTSTATUS Status)
{
  switch (Status)
  {
    case STATUS_SUCCESS: 
        return NO_ERROR;
        
    case STATUS_PENDING:
        return ERROR_IO_PENDING;

    case STATUS_INVALID_HANDLE:
    case STATUS_OBJECT_TYPE_MISMATCH:
        return WSAENOTSOCK;

    case STATUS_INVALID_PARAMETER:
    case STATUS_ADDRESS_CLOSED:
    case STATUS_CONNECTION_INVALID:
    case STATUS_ADDRESS_ALREADY_ASSOCIATED:
    case STATUS_ADDRESS_NOT_ASSOCIATED:
    case STATUS_CONNECTION_ACTIVE:
    case STATUS_INVALID_DEVICE_STATE:
    case STATUS_INVALID_DEVICE_REQUEST:
        return WSAEINVAL;

    case STATUS_INSUFFICIENT_RESOURCES:
    case STATUS_PAGEFILE_QUOTA:
    case STATUS_COMMITMENT_LIMIT:
    case STATUS_WORKING_SET_QUOTA:
    case STATUS_NO_MEMORY:
    case STATUS_CONFLICTING_ADDRESSES:
    case STATUS_QUOTA_EXCEEDED:
    case STATUS_TOO_MANY_PAGING_FILES:
    case STATUS_REMOTE_RESOURCES:
    case STATUS_TOO_MANY_ADDRESSES:
        return WSAENOBUFS;

    case STATUS_SHARING_VIOLATION:
    case STATUS_ADDRESS_ALREADY_EXISTS:
        return WSAEADDRINUSE;

    case STATUS_LINK_TIMEOUT:
    case STATUS_IO_TIMEOUT:
    case STATUS_TIMEOUT:
        return WSAETIMEDOUT;

    case STATUS_GRACEFUL_DISCONNECT:
        return WSAEDISCON;

    case STATUS_REMOTE_DISCONNECT:
    case STATUS_CONNECTION_RESET:
    case STATUS_LINK_FAILED:
    case STATUS_CONNECTION_DISCONNECTED:
        return WSAECONNRESET;

    case STATUS_LOCAL_DISCONNECT:
    case STATUS_TRANSACTION_ABORTED:
    case STATUS_CONNECTION_ABORTED:
        return WSAECONNRESET; // WSAECONNABORTED; Make HAPI happy

    case STATUS_INVALID_NETWORK_RESPONSE:
        return WSAENETDOWN;

    case STATUS_BAD_NETWORK_PATH:
    case STATUS_NETWORK_UNREACHABLE:
    case STATUS_PROTOCOL_UNREACHABLE:
        return WSAENETUNREACH;

    case STATUS_HOST_UNREACHABLE:
        return WSAEHOSTUNREACH;

    case STATUS_CANCELLED:
    case STATUS_REQUEST_ABORTED:
        return WSAEINTR;

    case STATUS_BUFFER_OVERFLOW:
    case STATUS_INVALID_BUFFER_SIZE:
        return WSAEMSGSIZE;

    case STATUS_BUFFER_TOO_SMALL:
    case STATUS_ACCESS_VIOLATION:
        return WSAEFAULT;

    case STATUS_DEVICE_NOT_READY:
    case STATUS_REQUEST_NOT_ACCEPTED:
        return WSAEWOULDBLOCK;

    case STATUS_NETWORK_BUSY:
    case STATUS_NO_SUCH_DEVICE:
    case STATUS_NO_SUCH_FILE:
    case STATUS_OBJECT_PATH_NOT_FOUND:
    case STATUS_UNEXPECTED_NETWORK_ERROR:
        return WSAENETDOWN;

    case STATUS_INVALID_CONNECTION:
        return WSAENOTCONN;

    case STATUS_REMOTE_NOT_LISTENING:
    case STATUS_CONNECTION_REFUSED:
        return WSAECONNREFUSED;

    case STATUS_PIPE_DISCONNECTED:
        return WSAESHUTDOWN;

    case STATUS_INVALID_ADDRESS:
    case STATUS_INVALID_ADDRESS_COMPONENT:
        return WSAEADDRNOTAVAIL;

    case STATUS_NOT_SUPPORTED:
    case STATUS_NOT_IMPLEMENTED:
        return WSAEOPNOTSUPP;

    case STATUS_PORT_UNREACHABLE:
        return WSAEREMOTE;

    case STATUS_UNSUCCESSFUL:
        return WSAEINVAL;

    case STATUS_ACCESS_DENIED:
        return WSAEACCES;
        
    default:
        DEBUGMSG(("Didn't map NT status %X, returning WSAEINVAL\n", Status));
        return WSAEINVAL;
  }
}        

INT
WSHGetSockaddrType(
    IN  PSOCKADDR       Sockaddr,
    IN  DWORD           SockaddrLength,
    OUT PSOCKADDR_INFO  SockaddrInfo)
{
    UNALIGNED SOCKADDR *pSockaddr = (PSOCKADDR) Sockaddr;

    if (SockaddrLength < sizeof(SOCKADDR_IRDA))
    {
        DEBUGMSG(("WSHGetSockaddrType(irda): SockaddrLength(%d) < sizeof(SOCKADDR_IRDA)%d ret WSAEFAULT\n",
                    SockaddrLength, sizeof(SOCKADDR_IRDA)));
        return WSAEFAULT;
    }    

    if (pSockaddr->sa_family != AF_IRDA)
    {
        DEBUGMSG(("WSHGetSockaddrType(irda): pSockaddr->sa_family != AF_IRDA ret WSAEAFNOSUPPORT\n"));        
        return WSAEAFNOSUPPORT;
    }    

    if (((SOCKADDR_IRDA *) pSockaddr)->irdaServiceName[0] == 0)
    {
        SockaddrInfo->AddressInfo  = SockaddrAddressInfoWildcard;
        SockaddrInfo->EndpointInfo = SockaddrEndpointInfoWildcard;
    }
    else
    {
        SockaddrInfo->AddressInfo  = SockaddrAddressInfoNormal;
        SockaddrInfo->EndpointInfo = SockaddrEndpointInfoNormal;
    }

    DEBUGMSG(("WSHGetSockaddrType(irda): returning no error\n"));
    return NO_ERROR;
}

INT
ControlIoctl(
    ULONG       IoctlCode,
    OUT PCHAR   OptionValue,
    OUT PINT    OptionLength,
    OUT HANDLE  *pDevHandle)
{
    NTSTATUS            Status;
    OBJECT_ATTRIBUTES   ObjAttr;
    UNICODE_STRING      DeviceName;
    HANDLE              DeviceHandle;
    IO_STATUS_BLOCK     IoStatusBlock;
      
    RtlInitUnicodeString(&DeviceName, IRDA_DEVICE_NAME);

    if (pDevHandle)
    {    
        *pDevHandle = INVALID_HANDLE_VALUE;
    }    
      
    InitializeObjectAttributes(
        &ObjAttr,
        &DeviceName,
        OBJ_CASE_INSENSITIVE,
        NULL,
        NULL);
        
    Status = NtCreateFile(
                &DeviceHandle,                  // PHANDLE FileHandle
                SYNCHRONIZE | GENERIC_EXECUTE,  // ACCESS_MASK DesiredAccess
                &ObjAttr,                       // POBJECT_ATTRIBUTES ObjAttr
                &IoStatusBlock,                 // PIO_STATUS_BLOCK IoStatusBlock
                NULL,                           // PLARGE_INTEGER AllocationSize
                FILE_ATTRIBUTE_NORMAL,          // ULONG FileAttributes
                FILE_SHARE_READ |
                FILE_SHARE_WRITE,               // ULONG ShareAccess
                FILE_OPEN_IF,                   // ULONG CreateDisposition
                FILE_SYNCHRONOUS_IO_NONALERT,   // ULONG CreateOptions
                NULL,                           // PVOID EaBuffer
                0);                             // ULONG EaLength

    if (!NT_SUCCESS(Status))
    {
        return WSAEINVAL;
    }

    Status = NtDeviceIoControlFile(
                DeviceHandle,    // HANDLE FileHandle
                NULL,            // HANDLE Event OPTIONAL
                NULL,            // PIO_APC_ROUTINE ApcRoutine
                NULL,            // PVOID ApcContext
                &IoStatusBlock,  // PIO_STATUS_BLOCK IoStatusBlock
                IoctlCode,       // ULONG IoControlCode
                OptionValue,     // PVOID InputBuffer
                *OptionLength,   // ULONG InputBufferLength
                OptionValue,     // PVOID OutputBuffer
                *OptionLength);  // ULONG OutputBufferLength

    DEBUGMSG(("IoControlFile returned %x\n", Status));
    
    if (Status == STATUS_SUCCESS)
    {
        *OptionLength = (INT) IoStatusBlock.Information;    
    }
    
    if (pDevHandle && Status == STATUS_SUCCESS)
    {
        *pDevHandle = DeviceHandle;
    }
    else
    {    
        NtClose(DeviceHandle);
    }    
    
    return IoStatusToWs(Status);
}

INT
WSHGetSocketInformation(
    IN  PVOID   HelperDllSocketContext,
    IN  SOCKET  SocketHandle,
    IN  HANDLE  TdiAddressObjectHandle,
    IN  HANDLE  TdiConnectionObjectHandle,
    IN  INT     Level,
    IN  INT     OptionName,
    OUT PCHAR   OptionValue,
    OUT PINT    OptionLength)
{
    PWSHIRDA_SOCKET_CONTEXT pContext = HelperDllSocketContext;

    UNREFERENCED_PARAMETER( SocketHandle );
    UNREFERENCED_PARAMETER( TdiAddressObjectHandle );
    UNREFERENCED_PARAMETER( TdiConnectionObjectHandle );

    DEBUGMSG(("WSHGetSocketInformation\n"));
    
    if (Level == SOL_INTERNAL && OptionName == SO_CONTEXT)
    {
        if (OptionValue != NULL)
        {
            if (*OptionLength < sizeof(WSHIRDA_SOCKET_CONTEXT))
            {
                return WSAEFAULT;
            }
            
            RtlCopyMemory(OptionValue, pContext,
                          sizeof(WSHIRDA_SOCKET_CONTEXT));
        }

        *OptionLength = sizeof(WSHIRDA_SOCKET_CONTEXT);

        return NO_ERROR;
    }
    
    if (Level == SOL_IRLMP)
    {
        switch (OptionName)
        {
            case IRLMP_ENUMDEVICES:
                // need remove for at least 1 device
                if (*OptionLength < (sizeof(DWORD) + 
                        sizeof(IRDA_DEVICE_INFO)))
                {
                    return WSAEFAULT;
                }
                return ControlIoctl(IOCTL_IRDA_GET_INFO_ENUM_DEV,
                                    OptionValue, OptionLength, NULL);
                
            case IRLMP_IAS_QUERY:
                if (*OptionLength < sizeof(IAS_QUERY))
                {
                    return WSAEFAULT;
                }
                return ControlIoctl(IOCTL_IRDA_QUERY_IAS,
                                    OptionValue, OptionLength, NULL);
                
            case IRLMP_SEND_PDU_LEN:
            {
                NTSTATUS            Status;
                IO_STATUS_BLOCK     IoStatusBlock;
                
                Status = NtDeviceIoControlFile(
                    TdiConnectionObjectHandle,
                    NULL,                      // HANDLE Event OPTIONAL
                    NULL,                      // PIO_APC_ROUTINE ApcRoutine
                    NULL,                      // PVOID ApcContext
                    &IoStatusBlock,            // PIO_STATUS_BLOCK IoStatusBlock
                    IOCTL_IRDA_GET_SEND_PDU_LEN,// ULONG IoControlCode
                    NULL,                      // PVOID InputBuffer
                    0,                         // ULONG InputBufferLength
                    OptionValue,               // PVOID OutputBuffer
                    sizeof(DWORD));            // ULONG OutputBufferLength
        
                return IoStatusToWs(Status);        
            }
        }        
    }

    return WSAEINVAL;
}

INT
WSHSetSocketInformation(
    IN PVOID    HelperDllSocketContext,
    IN SOCKET   SocketHandle,
    IN HANDLE   TdiAddressObjectHandle,
    IN HANDLE   TdiConnectionObjectHandle,
    IN INT      Level,
    IN INT      OptionName,
    IN PCHAR    OptionValue,
    IN INT      OptionLength)
{
    PWSHIRDA_SOCKET_CONTEXT pSocketContext = 
        (PWSHIRDA_SOCKET_CONTEXT) HelperDllSocketContext;

    DEBUGMSG(("WSHSetSocketInformation\n"));

    if (Level == SOL_INTERNAL && OptionName == SO_CONTEXT)
    {
        int CopyOffset;
        
        if (OptionLength < sizeof(WSHIRDA_SOCKET_CONTEXT))
            return WSAEINVAL;
        
        if (HelperDllSocketContext == NULL)
        {
            // Socket was inherited or duped, create a new context.
            if ((pSocketContext =
                 RtlAllocateHeap(RtlProcessHeap(), 0,
                                 sizeof(WSHIRDA_SOCKET_CONTEXT)))
                == NULL)
            {
                return WSAENOBUFS;
            }   

            // Copy the parent's context into the child's context.
            RtlCopyMemory(pSocketContext, OptionValue,
                          sizeof(WSHIRDA_SOCKET_CONTEXT));

            pSocketContext->pIasAttribs = NULL;
    
            // Return the address of the new context in pOptionVal.
            *(PWSHIRDA_SOCKET_CONTEXT *) OptionValue = pSocketContext;

            return NO_ERROR;
        }
        
        // The socket was accept()'ed and it needs to have the same 
        // properties as it's parent.  The OptionValue buffer
        // contains the context information of this socket's parent.
        CopyOffset = FIELD_OFFSET(WSHIRDA_SOCKET_CONTEXT, AddressFamily);
        RtlCopyMemory((char *) pSocketContext + CopyOffset,
                      OptionValue + CopyOffset,
                      sizeof(WSHIRDA_SOCKET_CONTEXT) - CopyOffset);

        return NO_ERROR;
    }
    
    if (Level == SOL_IRLMP)
    {
        switch (OptionName)
        {
            case IRLMP_IRLPT_MODE:
                DEBUGMSG(("Set options for %x\n", pSocketContext)); 
                pSocketContext->Options |= OPT_IRLPT_MODE;
                return NO_ERROR;
                
            case IRLMP_9WIRE_MODE:
                pSocketContext->Options |= OPT_9WIRE_MODE;
                return NO_ERROR;
          
            case IRLMP_IAS_SET:
            {
                INT                     rc;
                PWSHIRDA_IAS_ATTRIBUTE  pIasAttrib;
                INT                     OptLen;
                PWSHIRDA_SOCKET_CONTEXT SockContext = (PWSHIRDA_SOCKET_CONTEXT) HelperDllSocketContext;
                HANDLE                  AttribHandle;
	            
                rc = ControlIoctl(IOCTL_IRDA_SET_IAS,
                                  OptionValue, &OptionLength, &AttribHandle);
                
                if (rc == NO_ERROR)
                {
                    pIasAttrib = RtlAllocateHeap(RtlProcessHeap(), 0, sizeof(*pIasAttrib));

                    if (pIasAttrib  == NULL)
                    {
                        rc = WSAENOBUFS;
                    }
                    else
                    {
                        pIasAttrib->AttribHandle = AttribHandle;
                                        
                        EnterCriticalSection(&IrdaCs);
                    
                        DEBUGMSG(("Added attrib %x to socket %x\n",
                                AttribHandle, SockContext));
                                
                        pIasAttrib->pNext = SockContext->pIasAttribs;
                        SockContext->pIasAttribs = pIasAttrib;

                        LeaveCriticalSection(&IrdaCs);
                    }    
                }   
                
                if (rc != NO_ERROR && AttribHandle != INVALID_HANDLE_VALUE)
                {
                    CloseHandle(AttribHandle);
                }    
                
                return rc;
            }
        }
    }

    return WSAEINVAL;
}

INT
WSHGetWildcardSockaddr(
    IN  PVOID       HelperDllSocketContext,
    OUT PSOCKADDR   Sockaddr,
    OUT PINT        SockaddrLength)
{
    
    DEBUGMSG(("WSHGetWildcarSockaddr\n"));

    if (*SockaddrLength < sizeof(SOCKADDR_IRDA))
    {
        return WSAEFAULT;
    }

    *SockaddrLength = sizeof(SOCKADDR_IRDA);

    RtlZeroMemory(Sockaddr, sizeof(SOCKADDR_IRDA));

    Sockaddr->sa_family = AF_IRDA;

    return NO_ERROR;
}

DWORD
WSHGetWinsockMapping(
    OUT PWINSOCK_MAPPING    Mapping,
    IN  DWORD               MappingLength)
{

    DEBUGMSG(("WSHGetWinsockMapping\n"));
    
    if (MappingLength >= sizeof(IrDAMapping))
        RtlMoveMemory(Mapping, &IrDAMapping, sizeof(IRDA_WINSOCK_MAPPING));

    return(sizeof(IRDA_WINSOCK_MAPPING));
}

//****************************************************************************
//
//
INT
WSHOpenSocket(
    IN OUT  PINT            AddressFamily,
    IN OUT  PINT            SocketType,
    IN OUT  PINT            Protocol,
    OUT     PUNICODE_STRING TransportDeviceName,
    OUT     PVOID          *HelperDllSocketContext,
    OUT     PDWORD          NotificationEvents)
{
    PWSHIRDA_SOCKET_CONTEXT pSocket;
    
    if (*AddressFamily != (int) IrDAMapping.Mapping[0].AddressFamily)
        return WSAEINVAL;

    ASSERT(IrDAMapping.Rows == 3);

    if (! ((*SocketType == (int) IrDAMapping.Mapping[0].SocketType  &&
            *Protocol   == (int) IrDAMapping.Mapping[0].Protocol)   ||
           (*SocketType == (int) IrDAMapping.Mapping[1].SocketType  &&
            *Protocol   == (int) IrDAMapping.Mapping[1].Protocol)   ||   
           (*SocketType == (int) IrDAMapping.Mapping[2].SocketType  &&
            *Protocol   == (int) IrDAMapping.Mapping[2].Protocol)))
    {
        DEBUGMSG(("WSHOpenSocket failed! WSAEINVAL\n"));    
        return WSAEINVAL;
    }

    RtlInitUnicodeString(TransportDeviceName, IRDA_DEVICE_NAME);

    if ((pSocket = RtlAllocateHeap(RtlProcessHeap(), 
            0, sizeof(WSHIRDA_SOCKET_CONTEXT))) == NULL)
    {
        DEBUGMSG(("WSHOpenSocket failed! WSAENOBUFS\n"));
        return WSAENOBUFS;
    }
    
    *HelperDllSocketContext = pSocket;
    
    pSocket->AddressFamily = AF_IRDA;
    pSocket->SocketType = SOCK_STREAM;
    pSocket->Protocol = IRDA_PROTO_SOCK_STREAM;
    pSocket->Options = 0;
    pSocket->pIasAttribs = NULL;
    pSocket->LazyDscvDevHandle = NULL;
    
    *NotificationEvents = WSH_NOTIFY_CLOSE | WSH_NOTIFY_BIND;

    DEBUGMSG(("WSHOpenSocket %X\n", pSocket));

    return NO_ERROR;
}    

VOID
DeleteSocketAttribs(PWSHIRDA_SOCKET_CONTEXT pSocket)
{
    PWSHIRDA_IAS_ATTRIBUTE pIasAttrib;

    // Assumes IrdaCs is held
    
    DEBUGMSG(("Delete attribs for socket %X\n", pSocket));
    
    while (pSocket->pIasAttribs)
    {
        pIasAttrib = pSocket->pIasAttribs;
                
        pSocket->pIasAttribs = pIasAttrib->pNext;
                
        DEBUGMSG(("Delete attrib %x socket %x\n", 
                pIasAttrib->AttribHandle, pSocket));
                
        CloseHandle(pIasAttrib->AttribHandle);                

        RtlFreeHeap(RtlProcessHeap(), 0, pIasAttrib);
    }
}

INT
WSHNotify(
    IN PVOID    HelperDllSocketContext,
    IN SOCKET   SocketHandle,
    IN HANDLE   TdiAddressObjectHandle,
    IN HANDLE   TdiConnectionObjectHandle,
    IN DWORD    NotifyEvent)
{
    PWSHIRDA_SOCKET_CONTEXT pSocket = HelperDllSocketContext;
    
    DEBUGMSG(("WSHNotify\n"));

    switch (NotifyEvent)
    {
        case WSH_NOTIFY_CLOSE:
            DEBUGMSG(("WSH_NOTIFY_CLOSE %x\n", pSocket));
            
            EnterCriticalSection(&IrdaCs);
            
            DeleteSocketAttribs(pSocket);
         
            LeaveCriticalSection(&IrdaCs);
            
            if (pSocket->LazyDscvDevHandle != NULL)
            {
                NtClose(pSocket->LazyDscvDevHandle);
            }    
            
            RtlFreeHeap(RtlProcessHeap(), 0, pSocket);
            
            break;

        case WSH_NOTIFY_CONNECT:
            DEBUGMSG(("WSH_NOTIFY_CONNECT\n"));
            break;            
 
        case WSH_NOTIFY_BIND:
            DEBUGMSG(("WSH_NOTIFY_BIND AddrObj:%x, ConnObj:%x Context %x Options %d\n",
                        TdiAddressObjectHandle, TdiConnectionObjectHandle,
                        pSocket, pSocket->Options));
                        
            if (pSocket->Options != 0)
            {
                NTSTATUS            Status;
                IO_STATUS_BLOCK     IoStatusBlock;
                
                Status = NtDeviceIoControlFile(
                            TdiAddressObjectHandle,
                            NULL,                      // HANDLE Event OPTIONAL
                            NULL,                      // PIO_APC_ROUTINE ApcRoutine
                            NULL,                      // PVOID ApcContext
                            &IoStatusBlock,            // PIO_STATUS_BLOCK IoStatusBlock
                            IOCTL_IRDA_SET_OPTIONS,    // ULONG IoControlCode
                            (char *) &pSocket->Options, // PVOID InputBuffer
                            sizeof(DWORD),             // ULONG InputBufferLength
                            NULL,                      // PVOID OutputBuffer
                            0);                        // ULONG OutputBufferLength
                            
                DEBUGMSG(("IOCTL_IRDA_SET_OPTIONS rc %x\n", Status));                            
                
            }                
            break;            
            
        case WSH_NOTIFY_LISTEN:
            DEBUGMSG(("WSH_NOTIFY_LISTEN\n"));
            break;            
            
        case WSH_NOTIFY_ACCEPT:
            DEBUGMSG(("WSH_NOTIFY_ACCEPT\n"));
            break;            
            
        default:
            DEBUGMSG(("WSHNotify unknown event %d\n", NotifyEvent));
            
    }        
            
    return NO_ERROR;

}



INT
WSHEnumProtocols(
    IN      LPINT   lpiProtocols,
    IN      LPWSTR  lpTransportKeyName,
    IN OUT  LPVOID  lpProtocolBuffer,
    IN OUT  LPDWORD lpdwBufferLength)
{
    BOOL            UseIrDA = FALSE;        
    PPROTOCOL_INFO  pIrDAProtocolInfo;    
    DWORD           BytesRequired;
    DWORD           i;

    lpTransportKeyName; // Avoid compiler warnings.

    DEBUGMSG(("WSHEnumProtocols\n"));

    if (ARGUMENT_PRESENT(lpiProtocols))
    {
        for (i = 0; lpiProtocols[i] != 0; i++) 
        {
            if (lpiProtocols[i] == IRDA_PROTO_SOCK_STREAM) 
            {
                UseIrDA = TRUE;
            }
        }
    }
    else 
    {
        UseIrDA = TRUE;
    }    

    if (! UseIrDA)
    {
        *lpdwBufferLength = 0;
        return 0;
    }

    BytesRequired = sizeof(PROTOCOL_INFO) +
        ((wcslen(IRDA_NAME) + 1) * sizeof(WCHAR));

    if (BytesRequired > *lpdwBufferLength)
    {
        *lpdwBufferLength = BytesRequired;
        return -1;
    }

    pIrDAProtocolInfo = lpProtocolBuffer;

    pIrDAProtocolInfo->dwServiceFlags   =
        XP_GUARANTEED_DELIVERY |
        XP_GUARANTEED_ORDER;
    pIrDAProtocolInfo->iAddressFamily   = AF_IRDA;
    pIrDAProtocolInfo->iMaxSockAddr     = MIN_SOCKADDR_LEN;
    pIrDAProtocolInfo->iMinSockAddr     = MAX_SOCKADDR_LEN;
    pIrDAProtocolInfo->iSocketType      = SOCK_STREAM;
    pIrDAProtocolInfo->iProtocol        = IRDA_PROTO_SOCK_STREAM;
    pIrDAProtocolInfo->dwMessageSize    = 0;
    pIrDAProtocolInfo->lpProtocol       = (LPWSTR)
        ((PBYTE) lpProtocolBuffer + *lpdwBufferLength -
         ((wcslen(IRDA_NAME) + 1) * sizeof(WCHAR)));   

    wcscpy(pIrDAProtocolInfo->lpProtocol, IRDA_NAME );

    *lpdwBufferLength = BytesRequired;

    return (1);
}

INT
WINAPI
WSHGetWSAProtocolInfo (
    IN LPWSTR ProviderName,
    OUT LPWSAPROTOCOL_INFOW * ProtocolInfo,
    OUT LPDWORD ProtocolInfoEntries
    )

/*++

Routine Description:

    Retrieves a pointer to the WSAPROTOCOL_INFOW structure(s) describing
    the protocol(s) supported by this helper.

Arguments:

    ProviderName - Contains the name of the provider, such as "TcpIp".

    ProtocolInfo - Receives a pointer to the WSAPROTOCOL_INFOW array.

    ProtocolInfoEntries - Receives the number of entries in the array.

Return Value:

    INT - 0 if successful, WinSock error code if not.

--*/

{

    DEBUGMSG(("WSHGetWSAProtocolInfo\n"));

    if( ProviderName == NULL ||
        ProtocolInfo == NULL ||
        ProtocolInfoEntries == NULL ) {

        return WSAEFAULT;

    }

    if( _wcsicmp( ProviderName, L"IrDA" ) == 0 ) {

        *ProtocolInfo = Winsock2Protocols;
        *ProtocolInfoEntries = 1;

        return NO_ERROR;

    }

    return WSAEINVAL;

} // WSHGetWSAProtocolInfo

INT
WINAPI
WSHGetProviderGuid (
    IN LPWSTR ProviderName,
    OUT LPGUID ProviderGuid
    )

/*++

Routine Description:

    Returns the GUID identifying the protocols supported by this helper.

Arguments:

    ProviderName - Contains the name of the provider, such as "TcpIp".

    ProviderGuid - Points to a buffer that receives the provider's GUID.

Return Value:

    INT - 0 if successful, WinSock error code if not.

--*/

{

    if( ProviderName == NULL ||
        ProviderGuid == NULL ) {

        return WSAEFAULT;

    }

    if( _wcsicmp( ProviderName, L"irda" ) == 0 ) {

        RtlCopyMemory(
            ProviderGuid,
            &IrdaProviderGuid,
            sizeof(GUID)
            );

        return NO_ERROR;

    }

    return WSAEINVAL;

} // WSHGetProviderGuid

VOID
WINAPI
IoctlCompletionRoutine (
    PVOID ApcContext,
    PIO_STATUS_BLOCK IoStatusBlock,
    DWORD Reserved
    )
{
    LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine;
    LPWSAOVERLAPPED     lpOverlapped;
    DWORD               dwErrorCode = 0;
    DWORD               dwNumberOfBytesTransfered;
    DWORD               dwFlags = 0;

    DEBUGMSG(("IoctlCompletionRoutine\n"));
    
    if (NT_ERROR(IoStatusBlock->Status))
    {
        if (IoStatusBlock->Status != STATUS_CANCELLED) 
        {
            dwErrorCode = IoStatusToWs(IoStatusBlock->Status);
        } 
        else
        {
            dwErrorCode = WSA_OPERATION_ABORTED;
        }

        dwNumberOfBytesTransfered = 0;
    } 
    else 
    {
        dwErrorCode = 0;
        dwNumberOfBytesTransfered = (ULONG) IoStatusBlock->Information;
    }    

    CompletionRoutine = (LPWSAOVERLAPPED_COMPLETION_ROUTINE)ApcContext;
    lpOverlapped = (LPWSAOVERLAPPED)CONTAINING_RECORD(IoStatusBlock,WSAOVERLAPPED,Internal);
    
    (CompletionRoutine)(
        dwErrorCode,
        dwNumberOfBytesTransfered,
        lpOverlapped,
        dwFlags);
}

INT
WSHIoctl(
    IN PVOID HelperDllSocketContext,
    IN SOCKET SocketHandle,
    IN HANDLE TdiAddressObjectHandle,
    IN HANDLE TdiConnectionObjectHandle,
    IN DWORD IoControlCode,
    IN LPVOID InputBuffer,
    IN DWORD InputBufferLength,
    IN LPVOID OutputBuffer,
    IN DWORD OutputBufferLength,
    OUT LPDWORD NumberOfBytesReturned,
    IN LPWSAOVERLAPPED Overlapped,
    IN LPWSAOVERLAPPED_COMPLETION_ROUTINE CallerCompletionRoutine,
    OUT LPBOOL NeedsCompletion)
{
    NTSTATUS                Status;
    OBJECT_ATTRIBUTES       ObjAttr;
    UNICODE_STRING          DeviceName;
    HANDLE                  DeviceHandle;
    IO_STATUS_BLOCK         IoStatusBlock;
    BOOL                    Result;   
    PWSHIRDA_SOCKET_CONTEXT pSocket = HelperDllSocketContext;
    PIO_APC_ROUTINE apcRoutine;
    
    DEBUGMSG(("WSHIoctl: Sock %d, AddrObj %X, ConnObj %X\n", SocketHandle,
             TdiAddressObjectHandle, TdiConnectionObjectHandle));
             
    if (HelperDllSocketContext == NULL ||
        SocketHandle == INVALID_SOCKET ||
        NumberOfBytesReturned == NULL ||
        NeedsCompletion == NULL ||
        IoControlCode != SIO_LAZY_DISCOVERY ||
        (CallerCompletionRoutine != NULL && Overlapped == NULL) ||
            // I am using the Overlapped for the IoStatusBlock
            // for the completion routine so if a CallerCompletionRoutine
            // is specified, an Overlapped must be passed in as well
        OutputBufferLength < (sizeof(DWORD) + sizeof(IRDA_DEVICE_INFO))) 
    {
        return WSAEINVAL;

    }
    
    *NeedsCompletion = FALSE;
    
    *NumberOfBytesReturned = OutputBufferLength;

    if (pSocket->LazyDscvDevHandle == NULL)
    {
        RtlInitUnicodeString(&DeviceName, IRDA_DEVICE_NAME);
      
        InitializeObjectAttributes(
            &ObjAttr,
            &DeviceName,
            OBJ_INHERIT | OBJ_CASE_INSENSITIVE,
            NULL,
            NULL);


        Status = NtCreateFile(
                &pSocket->LazyDscvDevHandle,    // PHANDLE FileHandle
                GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,//SYNCHRONIZE | GENERIC_EXECUTE,  // ACCESS_MASK DesiredAccess
                &ObjAttr,                       // POBJECT_ATTRIBUTES ObjAttr
                &IoStatusBlock,                 // PIO_STATUS_BLOCK IoStatusBlock
                NULL,                           // PLARGE_INTEGER AllocationSize
                0,                              // ULONG FileAttributes
                FILE_SHARE_READ |
                FILE_SHARE_WRITE,               // ULONG ShareAccess
                FILE_OPEN_IF,                   // ULONG CreateDisposition
                0,                              // ULONG CreateOptions
                NULL,                           // PVOID EaBuffer
                0);                             // ULONG EaLength

        if (!NT_SUCCESS(Status))
        {
            return WSAEINVAL;
        }
    }    

    Status = STATUS_SUCCESS;
    
    if (CallerCompletionRoutine == NULL)
    {
        // let Win32 do the dirty work
        
        DEBUGMSG(("No CallerCompletionRoutine, using DeviceIoControl()\n"));
        Result = DeviceIoControl(pSocket->LazyDscvDevHandle,
                             IOCTL_IRDA_LAZY_DISCOVERY,
                             NULL, 0, OutputBuffer, OutputBufferLength,
                             NumberOfBytesReturned, Overlapped);

        if (Result == FALSE)
        {
            Status = GetLastError();
        
            if (Status == ERROR_IO_PENDING)
            {
                Status = STATUS_PENDING;
            }
        }
    }                             
    else
    {
        DEBUGMSG(("Using NtDeviceIoControlFile\n"));    
        
        Status = NtDeviceIoControlFile(
                    pSocket->LazyDscvDevHandle,
                    NULL,
                    IoctlCompletionRoutine,
                    CallerCompletionRoutine,
                    (PIO_STATUS_BLOCK)&Overlapped->Internal,
                    IOCTL_IRDA_LAZY_DISCOVERY,
                    NULL,
                    0,
                    OutputBuffer,
                    OutputBufferLength);
                    
        if (Status == STATUS_SUCCESS)
        {
            *NumberOfBytesReturned = (DWORD) IoStatusBlock.Information;
        }
    }
    
    DEBUGMSG(("IoControlFile returned %x\n", Status));
    
    return IoStatusToWs(Status);
}