OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
master
Windows-Server-2003/net/irda/sys/irda.c

5191 lines
146 KiB
C
Raw Permalink Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
irda.c
Abstract:
TDI interface portion of irda.sys
Author:
mbert 9-97
--*/
#define UNICODE
#include <irda.h>
#include <tdi.h>
#include <tdikrnl.h>
#include <tdistat.h>
#include <tdiinfo.h>
#include <irioctl.h>
#include <irlap.h>
#include <irlmp.h>
#include <irdap.h>
#undef offsetof
#include "irda.tmh"
static LARGE_INTEGER Magic10000 = {0xe219652c, 0xd1b71758};
#if 0
#if DBG
int DbgSettings =
DBG_TDI |
// DBG_NDIS |
// DBG_TDI_IRP |
DBG_IRLMP |
// DBG_IRLMP_CONN |
// DBG_IRLMP_IAS |
// DBG_IRLMP_CRED |
// DBG_IRLAPLOG |
DBG_IRLAP |
// DBG_TXFRAME |
// DBG_RXFRAME |
// DBG_DISCOVERY |
DBG_ERROR |
DBG_WARN |
1;
int DbgOutput = /*DBG_OUTPUT_DEBUGGER |*/ DBG_OUTPUT_BUFFER;
#endif
#endif
PDRIVER_OBJECT pIrDADriverObject;
PDEVICE_OBJECT pIrDADeviceObject;
PVOID IrdaMsgPool;
PVOID RecvBufPool;
PIRDA_ADDR_OBJ AddrObjList;
LIST_ENTRY DscvIrpList;
LIST_ENTRY IasIrpList;
LIST_ENTRY ConnIrpList;
LIST_ENTRY StatusIrpList;
LIST_ENTRY IasAttribList;
CTEEvent PendingIasEvent;
IRLINK_STATUS LinkStatus;
BOOLEAN LinkStatusUpdated;
LONG ConnectionCount;
BOOLEAN ConnectionInterrupted;
CTELock IrdaLock;
char IasBuf[sizeof(IAS_QUERY) + IAS_MAX_OCTET_STRING];
IAS_QUERY *pvIasQuery = (IAS_QUERY *) IasBuf;
PIRP pIasIrp;
LIST_ENTRY LazyDscvIrpList;
IRDA_TIMER LazyDscvTimer;
BOOLEAN LazyDscvTimerRunning;
UINT LazyDscvInterval;
UINT LazyDscvMacAddrs;
UINT RandSeed;
int gNextLsapSel;
VOID (*CloseRasIrdaAddresses)();
NTSTATUS
DriverEntry(
PDRIVER_OBJECT pDriverObject,
PUNICODE_STRING pRegistryPath);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, DriverEntry)
#endif
PIRP
GetIrpOnConnIrpList(PIRDA_CONN_OBJ pConn);
NTSTATUS
DriverEntry(
PDRIVER_OBJECT pDriverObject,
PUNICODE_STRING pRegistryPath)
{
NTSTATUS Status;
UNICODE_STRING DeviceName;
UNICODE_STRING ProtocolName;
int i;
LARGE_INTEGER li;
WPP_INIT_TRACING(pDriverObject,pRegistryPath);
#if 0
DbgMsgInit();
#endif
DEBUGMSG(DBG_TDI, ("IRDA: DriverEntry(), %ws.\n",
pRegistryPath->Buffer));
pIrDADriverObject = pDriverObject;
RtlInitUnicodeString(&DeviceName, IRDA_DEVICE_NAME);
RtlInitUnicodeString(&ProtocolName, IRDA_NAME);
Status = IoCreateDevice(
pDriverObject, // DriverObject
0, // DeviceExtensionSize
&DeviceName, // DeviceName
FILE_DEVICE_NETWORK, // DeviceType
FILE_DEVICE_SECURE_OPEN,// DeviceCharacteristics
FALSE, // Exclusive?
&pIrDADeviceObject); // DeviceObject pointer returned
if (! NT_SUCCESS(Status))
{
/* wmz
CTELogEvent(
pDriverObject,
EVENT_IRDA_CREATE_DEVICE_FAILED,
1,
1,
&DeviceName.Buffer,
0,
NULL);
*/
DEBUGMSG(DBG_ERROR, ("IRDA: IoCreateDevice() failed, 0x%1x.\n",
Status));
return Status;
}
// Initialize the driver object.
pDriverObject->DriverUnload = DriverUnload;
pDriverObject->FastIoDispatch = NULL;
for (i=0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
{
pDriverObject->MajorFunction[i] = IrDADispatch;
}
// Internal Device Controls are hot paths for kernel-mode clients.
pDriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] =
IrDADispatchInternalDeviceControl;
// Intialize the device objects.
pIrDADeviceObject->Flags |= DO_DIRECT_IO;
CTEInitLock(&IrdaLock);
CTEInitEvent(&PendingIasEvent, PendingIasRequestCallback);
InitializeListHead(&DscvIrpList);
InitializeListHead(&IasIrpList);
InitializeListHead(&ConnIrpList);
InitializeListHead(&LazyDscvIrpList);
InitializeListHead(&StatusIrpList);
InitializeListHead(&IasAttribList);
pIasIrp = NULL;
gNextLsapSel = IRDA_MIN_LSAP_SEL;
if ((IrdaMsgPool = CreateIrdaBufPool(IRDA_MSG_DATA_SIZE_INTERNAL,
MT_IMSG_POOL)) == NULL)
{
IoDeleteDevice(pIrDADeviceObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
if ((RecvBufPool = CreateIrdaBufPool(sizeof(IRDA_RECV_BUF),
MT_RXBUF_POOL)) == NULL)
{
DeleteIrdaBufPool(IrdaMsgPool);
IoDeleteDevice(pIrDADeviceObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
if ((Status = IrdaInitialize(&ProtocolName, pRegistryPath,
&LazyDscvInterval)) != STATUS_SUCCESS)
{
DEBUGMSG(DBG_ERROR, ("IRDA: IrdaInitialize() failed.\n"));
IoDeleteDevice(pIrDADeviceObject);
DeleteIrdaBufPool(IrdaMsgPool);
DeleteIrdaBufPool(RecvBufPool);
return Status;
}
if (LazyDscvInterval == 0)
LazyDscvInterval = DEFAULT_LAZY_DSCV_INTERVAL;
#if DBG
LazyDscvTimer.pName = "LazyDscv";
#endif
IrdaTimerInitialize(&LazyDscvTimer,
LazyDscvTimerExp,
LazyDscvInterval*1000,
NULL, NULL);
KeQuerySystemTime(&li);
RandSeed = li.LowPart;
return STATUS_SUCCESS;
}
VOID
DriverUnload(
PDRIVER_OBJECT pDriverObject)
{
DEBUGMSG(DBG_TDI, ("IRDA: DriverUnload\n"));
IrdaTimerStop(&LazyDscvTimer);
IrdaShutdown();
DeleteIrdaBufPool(IrdaMsgPool);
DeleteIrdaBufPool(RecvBufPool);
IoDeleteDevice(pIrDADeviceObject);
WPP_CLEANUP(pDriverObject);
}
NTSTATUS
IrDADispatch(
PDEVICE_OBJECT pDeviceObject,
PIRP pIrp)
{
NTSTATUS Status;
PIO_STACK_LOCATION pIrpSp;
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
/*
DEBUGMSG(DBG_TDI_IRP, ("IRDA: IrDADispatch(), Irp:%X %s.\n",
pIrp,
IrpMJTxt(pIrpSp)));
*/
CTEAssert(pIrpSp->MajorFunction != IRP_MJ_INTERNAL_DEVICE_CONTROL);
switch (pIrpSp->MajorFunction)
{
case IRP_MJ_CREATE:
Status = IrDACreate(pDeviceObject, pIrp, pIrpSp);
break;
case IRP_MJ_CLEANUP:
Status = IrDACleanup(pDeviceObject, pIrp, pIrpSp);
break;
case IRP_MJ_CLOSE:
Status = IrDAClose(pIrp, pIrpSp);
break;
case IRP_MJ_DEVICE_CONTROL:
Status = TdiMapUserRequest(pDeviceObject, pIrp, pIrpSp);
if (Status == STATUS_SUCCESS)
{
/*
IrDA will not support TdiMapUserRequest as it is not safe.
return IrDADispatchInternalDeviceControl(pDeviceObject, pIrp);
*/
Status = STATUS_INVALID_DEVICE_REQUEST;
ASSERT(0);
}
else
{
return IrDADispatchDeviceControl(pIrp, IoGetCurrentIrpStackLocation(pIrp));
}
case IRP_MJ_QUERY_SECURITY:
case IRP_MJ_WRITE:
case IRP_MJ_READ:
default:
DEBUGMSG(DBG_ERROR, ("IRDA: Irp:0x%p, Unsupported %s.\n",
pIrp,
IrpMJTxt(pIrpSp)));
Status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
CTEAssert(Status != TDI_PENDING);
DEBUGMSG(DBG_TDI_IRP,
("IRDA: Completing Irp:%p, Status %x.\n",
pIrp,
Status));
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return Status;
}
NTSTATUS
IrDACreate(
PDEVICE_OBJECT pDeviceObject,
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
NTSTATUS Status;
FILE_FULL_EA_INFORMATION *pEAs;
FILE_FULL_EA_INFORMATION UNALIGNED *pEA;
pEAs = (PFILE_FULL_EA_INFORMATION) pIrp->AssociatedIrp.SystemBuffer;
// Open a control channel
if (pEAs == NULL)
{
pIrpSp->FileObject->FsContext = (PVOID) 1; // no context here
pIrpSp->FileObject->FsContext2 = (PVOID) TDI_CONTROL_CHANNEL_FILE;
DEBUGMSG(DBG_TDI, ("IRDA: IrdaCreate() new control channel (fo:%p)\n",
pIrpSp->FileObject));
return STATUS_SUCCESS;
}
// Address Object open?
pEA = FindEA(pEAs,TdiTransportAddress,TDI_TRANSPORT_ADDRESS_LENGTH);
if (pEA != NULL)
{
PIRDA_ADDR_OBJ pAddr;
Status = TdiOpenAddress(&pAddr, (TRANSPORT_ADDRESS UNALIGNED *)
&(pEA->EaName[pEA->EaNameLength + 1]),
pEA->EaValueLength);
CTEAssert(Status != TDI_PENDING);
if (NT_SUCCESS(Status))
{
pIrpSp->FileObject->FsContext = pAddr;
pIrpSp->FileObject->FsContext2 = (PVOID) TDI_TRANSPORT_ADDRESS_FILE;
DEBUGMSG(DBG_TDI,
("IRDA: IrdaCreate() new AddrObj:%p (fo:%p)\n",
pAddr, pIrpSp->FileObject));
}
else
{
DEBUGMSG(DBG_ERROR,
("IRDA: TdiOpenAddress() failed, 0x%1x.\n", Status));
if (Status == STATUS_ADDRESS_ALREADY_EXISTS)
{
Status = STATUS_SHARING_VIOLATION;
}
}
return Status;
}
// Connection Object open?
pEA = FindEA(
pEAs,
TdiConnectionContext,
TDI_CONNECTION_CONTEXT_LENGTH);
if (pEA != NULL)
{
PIRDA_CONN_OBJ pConn;
Status = TdiOpenConnection(&pConn,
*((CONNECTION_CONTEXT UNALIGNED *)
&(pEA->EaName[pEA->EaNameLength + 1])),
pEA->EaValueLength);
CTEAssert(Status != TDI_PENDING);
if (NT_SUCCESS(Status))
{
pIrpSp->FileObject->FsContext = pConn;
pIrpSp->FileObject->FsContext2 = (PVOID) TDI_CONNECTION_FILE;
DEBUGMSG(DBG_TDI,
("IRDA: IrdaCreate() new ConnObj:%p (fo:%p)\n",
pConn, pIrpSp->FileObject));
}
else
{
DEBUGMSG(DBG_ERROR,
("IRDA: TdiOpenConnection() failed, 0x%1x.\n", Status));
}
return Status;
}
DEBUGMSG(DBG_ERROR, ("IRDA: Unsupported EA.\n"));
Status = STATUS_INVALID_EA_NAME;
return Status;
}
FILE_FULL_EA_INFORMATION UNALIGNED *
FindEA(
PFILE_FULL_EA_INFORMATION pStartEA,
CHAR *pTargetName,
USHORT TargetNameLength)
{
FILE_FULL_EA_INFORMATION UNALIGNED *pCurrentEA;
BOOLEAN Found;
USHORT i;
do
{
Found = TRUE;
pCurrentEA = pStartEA;
(PCHAR) pStartEA += pCurrentEA->NextEntryOffset;
if (pCurrentEA->EaNameLength != TargetNameLength)
{
continue;
}
for (i=0; i < pCurrentEA->EaNameLength; i++)
{
if (pCurrentEA->EaName[i] == pTargetName[i])
{
continue;
}
Found = FALSE;
break;
}
if (Found)
{
return pCurrentEA;
}
} while (pCurrentEA->NextEntryOffset != 0);
return NULL;
}
VOID
CancelCtrlChannelIrpsOnList(
PLIST_ENTRY pIrpList,
PFILE_OBJECT pFileObject)
{
PIRP pIrp;
PLIST_ENTRY pListEntry, pListEntryNext;
PIO_STACK_LOCATION pIrpSp;
for (pListEntry = LazyDscvIrpList.Flink;
pListEntry != &LazyDscvIrpList;
pListEntry = pListEntryNext)
{
pListEntryNext = pListEntry->Flink;
pIrp = CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
if (pIrpSp->FileObject == pFileObject)
{
RemoveEntryList(pListEntry);
if (IoSetCancelRoutine(pIrp, NULL) == NULL)
{
// Cancel routine is going to run. Indicate to the
// cancel routine that the Irp has already been removed
// from the list by setting Flink to NULL
pIrp->Tail.Overlay.ListEntry.Flink = NULL;
}
else
{
DEBUGMSG(DBG_TDI_IRP, ("IRDA: cancelled irp %p\n", pIrp));
pIrp->IoStatus.Status = STATUS_CANCELLED;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
}
}
}
NTSTATUS
IrDACleanup(
PDEVICE_OBJECT pDeviceObject,
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
NTSTATUS Status;
KIRQL OldIrql;
switch((UINT_PTR)pIrpSp->FileObject->FsContext2)
{
case TDI_TRANSPORT_ADDRESS_FILE:
DEBUGMSG(DBG_TDI_IRP, ("IRDA: Cleanup AddrObj:%p\n",
pIrpSp->FileObject->FsContext));
break;
case TDI_CONNECTION_FILE:
DEBUGMSG(DBG_TDI_IRP, ("IRDA: Cleanup ConnObj:%p\n",
pIrpSp->FileObject->FsContext));
break;
case TDI_CONTROL_CHANNEL_FILE:
{
CTELockHandle hLock;
DEBUGMSG(DBG_TDI_IRP, ("IRDA: Cleanup control channel (fo:%p)\n",
pIrpSp->FileObject));
CTEGetLock(&IrdaLock, &hLock);
// Cleanup any Irps that may have been placed on
// a list by this control channel
CancelCtrlChannelIrpsOnList(&LazyDscvIrpList, pIrpSp->FileObject);
CancelCtrlChannelIrpsOnList(&DscvIrpList, pIrpSp->FileObject);
CancelCtrlChannelIrpsOnList(&StatusIrpList, pIrpSp->FileObject);
CTEFreeLock(&IrdaLock, hLock);
break;
}
}
// Search for IAS entries that have been added on this
// control channel and delete them
{
PIRDA_IAS_ATTRIB pIasAttrib, pIasAttribNext;
CTELockHandle hLock;
IRDA_MSG IMsg;
CTEGetLock(&IrdaLock, &hLock);
for (pIasAttrib = (PIRDA_IAS_ATTRIB) IasAttribList.Flink;
pIasAttrib != (PIRDA_IAS_ATTRIB) &IasAttribList;
pIasAttrib = pIasAttribNext)
{
pIasAttribNext = (PIRDA_IAS_ATTRIB) pIasAttrib->Linkage.Flink;
DEBUGMSG(DBG_TDI_IRP, ("IRDA IAS cleanup compare fs-%p fs-%p\n",
pIasAttrib->pFileObject, pIrpSp->FileObject));
if (pIasAttrib->pFileObject == pIrpSp->FileObject)
{
IMsg.Prim = IRLMP_DELATTRIBUTE_REQ;
IMsg.IRDA_MSG_AttribHandle = pIasAttrib->AttribHandle;
RemoveEntryList(&pIasAttrib->Linkage);
CTEFreeLock(&IrdaLock, hLock);
IrlmpDown(NULL, &IMsg);
CTEGetLock(&IrdaLock, &hLock);
IRDA_FREE_MEM(pIasAttrib);
}
}
CTEFreeLock(&IrdaLock, hLock);
}
return STATUS_SUCCESS;
}
NTSTATUS
IrDAClose(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
NTSTATUS Status;
KIRQL OldIrql;
switch((UINT_PTR) pIrpSp->FileObject->FsContext2)
{
case TDI_TRANSPORT_ADDRESS_FILE:
TdiCloseAddress((PIRDA_ADDR_OBJ) pIrpSp->FileObject->FsContext);
break;
case TDI_CONNECTION_FILE:
TdiCloseConnection((PIRDA_CONN_OBJ) pIrpSp->FileObject->FsContext);
break;
case TDI_CONTROL_CHANNEL_FILE:
DEBUGMSG(DBG_TDI, ("IRDA: Close control channel (fo:%p)\n",
pIrpSp->FileObject));
break;
}
return STATUS_SUCCESS;
}
NTSTATUS
IrDADispatchInternalDeviceControl(
PDEVICE_OBJECT pDeviceObject,
PIRP pIrp)
{
NTSTATUS Status;
PIO_STACK_LOCATION pIrpSp;
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
DEBUGMSG(DBG_TDI_IRP,
("IRDA: IrDADispatch(), Irp:0x%p %s %s FileObj:0x%p %s:0x%p.\n",
pIrp,
IrpMJTxt(pIrpSp),
IrpTdiTxt(pIrpSp),
pIrpSp->FileObject,
IrpTdiObjTypeTxt(pIrpSp),
pIrpSp->FileObject->FsContext));
if (((UINT_PTR) pIrpSp->FileObject->FsContext2) == TDI_CONNECTION_FILE)
{
switch (pIrpSp->MinorFunction)
{
case TDI_ASSOCIATE_ADDRESS:
return TdiAssociateAddress(pIrp, pIrpSp);
case TDI_DISASSOCIATE_ADDRESS:
return TdiDisassociateAddress(pIrp, pIrpSp);
case TDI_CONNECT:
return TdiConnect(pIrp, pIrpSp);
case TDI_DISCONNECT:
return TdiDisconnect(pIrp, pIrpSp, NULL);
case TDI_SEND:
return TdiSend(pIrp, pIrpSp);
case TDI_RECEIVE:
return TdiReceive(pIrp, pIrpSp);
case TDI_QUERY_INFORMATION:
case TDI_SET_INFORMATION:
break;
default:
DEBUGMSG(DBG_ERROR, ("IRDA: minor function %X not supportedon\n",
pIrpSp->MinorFunction));
CTEAssert(FALSE);
Status = STATUS_NOT_IMPLEMENTED;
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return Status;
}
}
else if (((UINT_PTR) pIrpSp->FileObject->FsContext2) ==
TDI_TRANSPORT_ADDRESS_FILE)
{
if (pIrpSp->MinorFunction == TDI_SET_EVENT_HANDLER)
{
PTDI_REQUEST_KERNEL_SET_EVENT pTdiParmsSetEvent;
pTdiParmsSetEvent = (PTDI_REQUEST_KERNEL_SET_EVENT)
&(pIrpSp->Parameters);
Status = TdiSetEvent(
(PIRDA_ADDR_OBJ) pIrpSp->FileObject->FsContext,
pTdiParmsSetEvent->EventType,
pTdiParmsSetEvent->EventHandler,
pTdiParmsSetEvent->EventContext);
CTEAssert(Status != TDI_PENDING);
DEBUGMSG(DBG_TDI_IRP,
("IRDA: Completing Irp:0x%p %s %s FileObj:0x%p %s:0x%p, Status 0x%lx.\n",
pIrp,
IrpMJTxt(pIrpSp),
IrpTdiTxt(pIrpSp),
pIrpSp->FileObject,
IrpTdiObjTypeTxt(pIrpSp),
pIrpSp->FileObject->FsContext,
Status));
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return Status;
}
}
CTEAssert(
(((UINT_PTR)pIrpSp->FileObject->FsContext2)
== TDI_TRANSPORT_ADDRESS_FILE) ||
(((UINT_PTR)pIrpSp->FileObject->FsContext2)
== TDI_CONNECTION_FILE) ||
(((UINT_PTR)pIrpSp->FileObject->FsContext2)
== TDI_CONTROL_CHANNEL_FILE));
switch(pIrpSp->MinorFunction)
{
case TDI_QUERY_INFORMATION:
return TdiQueryInformation(pIrp, pIrpSp);
case TDI_SET_INFORMATION:
return TdiSetInformation(pIrp, pIrpSp);
case TDI_ACTION:
Status = STATUS_NOT_IMPLEMENTED;
break;
default:
Status = STATUS_INVALID_DEVICE_REQUEST;
}
CTEAssert(Status != TDI_PENDING);
DEBUGMSG(DBG_TDI_IRP,
("IRDA: Completing Irp:0x%p %s %s FileObj:0x%p %s:0x%p, Status 0x%lx.\n",
pIrp,
IrpMJTxt(pIrpSp),
IrpTdiTxt(pIrpSp),
pIrpSp->FileObject,
IrpTdiObjTypeTxt(pIrpSp),
pIrpSp->FileObject->FsContext,
Status));
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return Status;
}
BOOLEAN
ValidConnectObject(
PIRDA_CONN_OBJ pConnCheck)
{
CTELockHandle hLock;
PIRDA_ADDR_OBJ pAddr;
PIRDA_CONN_OBJ pConn;
BOOLEAN Valid = FALSE;
CTEGetLock(&IrdaLock, &hLock);
for (pAddr = AddrObjList; pAddr != NULL; pAddr = pAddr->pNext)
{
for (pConn = pAddr->ConnObjList; pConn != NULL; pConn = pConn->pNext)
{
if (pConn == pConnCheck)
{
Valid = TRUE;
break;
}
}
}
CTEFreeLock(&IrdaLock, hLock);
return Valid;
}
BOOLEAN
ValidAddrObject(
PIRDA_ADDR_OBJ pAddrCheck)
{
CTELockHandle hLock;
PIRDA_ADDR_OBJ pAddr;
BOOLEAN Valid = FALSE;
CTEGetLock(&IrdaLock, &hLock);
for (pAddr = AddrObjList; pAddr != NULL; pAddr = pAddr->pNext)
{
if (pAddr == pAddrCheck)
{
Valid = TRUE;
break;
}
}
CTEFreeLock(&IrdaLock, hLock);
return Valid;
}
NTSTATUS
IrDADispatchDeviceControl(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
NTSTATUS Status;
CTELockHandle hLock;
#if DBG
if (pIrpSp->Parameters.DeviceIoControl.IoControlCode != IOCTL_IRDA_GET_DBG_MSGS)
DEBUGMSG(DBG_TDI_IRP,
("IRDA: IrDADispatchDeviceControl(), Irp:%p %s FileObj:%p %s:%p IoControlCode %X.\n",
pIrp,
IrpTdiTxt(pIrpSp),
pIrpSp->FileObject,
IrpTdiObjTypeTxt(pIrpSp),
pIrpSp->FileObject->FsContext,
pIrpSp->Parameters.DeviceIoControl.IoControlCode));
#endif
pIrp->IoStatus.Information = 0;
switch(pIrpSp->Parameters.DeviceIoControl.IoControlCode)
{
IRDA_MSG IMsg;
case IOCTL_IRDA_GET_INFO_ENUM_DEV:
PendIrp(
&DscvIrpList,
pIrp,
NULL,
FALSE
);
Status=STATUS_PENDING;
#if DBG
pIrp=NULL;
#endif
IMsg.Prim = IRLMP_DISCOVERY_REQ;
IMsg.IRDA_MSG_SenseMedia = TRUE;
IrlmpDown(NULL, &IMsg);
break;
case IOCTL_IRDA_LAZY_DISCOVERY:
{
CTEGetLock(&IrdaLock, &hLock);
PendIrp(
&LazyDscvIrpList,
pIrp,
NULL,
TRUE
);
Status=STATUS_PENDING;
#if DBG
pIrp=NULL;
#endif
if (LazyDscvTimerRunning == FALSE) {
LazyDscvTimerRunning = TRUE;
IrdaTimerStart(&LazyDscvTimer);
}
CTEFreeLock(&IrdaLock, hLock);
break;
}
case IOCTL_IRDA_FLUSH_DISCOVERY_CACHE:
{
IMsg.Prim = IRLMP_FLUSHDSCV_REQ;
IrlmpDown(NULL, &IMsg);
LazyDscvMacAddrs = 0;
Status = STATUS_SUCCESS;
// also reset LinkStatusUpated flag so that irmon will get
// latest status if it was restarted
LinkStatusUpdated = TRUE;
break;
}
case IOCTL_IRDA_SET_OPTIONS:
{
PIRDA_ADDR_OBJ pAddr = pIrpSp->FileObject->FsContext;
int *pOptions;
DEBUGMSG(DBG_TDI, ("IRDA: IOCTL_IRDA_SET_OPTIONS\n"));
if (!ValidAddrObject(pAddr))
{
Status = STATUS_INVALID_HANDLE;
break;
}
CTEAssert(IS_VALID_ADDR(pAddr));
if (pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(int))
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
pOptions = pIrp->AssociatedIrp.SystemBuffer;
if (*pOptions & OPT_IRLPT_MODE)
{
DEBUGMSG(DBG_TDI, ("IRDA: AddrObj:%p use IrLPT mode\n", pAddr));
pAddr->UseIrlptMode = IRLPT_MODE1;
}
if (*pOptions & OPT_9WIRE_MODE)
{
DEBUGMSG(DBG_TDI, ("IRDA: AddrObj:%p use 9-wire mode\n", pAddr));
pAddr->Use9WireMode = TRUE;
}
Status = STATUS_SUCCESS;
break;
}
case IOCTL_IRDA_GET_SEND_PDU_LEN:
{
PIRDA_CONN_OBJ pConn = pIrpSp->FileObject->FsContext;
// protect ourselves from malicious hackers by verifying
// this is a valid connObject
if (!ValidConnectObject(pConn))
{
Status = STATUS_INVALID_HANDLE;
break;
}
CTEAssert(IS_VALID_CONN(pConn));
if (pIrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(UINT))
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
*(UINT *) pIrp->AssociatedIrp.SystemBuffer = pConn->SendMaxPDU;
DEBUGMSG(DBG_TDI, ("IRDA: GET_SEND_PDU_LEN Conn:%p, Len %d\n",
pConn, *(UINT *) pIrp->AssociatedIrp.SystemBuffer));
pIrp->IoStatus.Information = sizeof(UINT);
Status = STATUS_SUCCESS;
break;
}
case IOCTL_IRDA_QUERY_IAS:
Status = InitiateIasQuery(pIrp, pIrpSp, NULL);
if (Status == STATUS_PENDING)
{
return STATUS_PENDING;
}
break;
case IOCTL_IRDA_SET_IAS:
{
PVOID AttribHandle;
PIRDA_IAS_ATTRIB pIasAttrib;
if (pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(IAS_SET) ||
pIrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(PVOID))
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
IMsg.Prim = IRLMP_ADDATTRIBUTE_REQ;
IMsg.IRDA_MSG_pIasSet = (IAS_SET *) pIrp->AssociatedIrp.SystemBuffer;
IMsg.IRDA_MSG_pAttribHandle = &AttribHandle;
IrlmpDown(NULL, &IMsg);
Status = STATUS_INSUFFICIENT_RESOURCES;
if (AttribHandle)
{
IRDA_ALLOC_MEM(pIasAttrib, sizeof(IRDA_IAS_ATTRIB), MT_TDI_IAS);
if (!pIasAttrib)
{
IMsg.Prim = IRLMP_DELATTRIBUTE_REQ;
IMsg.IRDA_MSG_AttribHandle = AttribHandle;
IrlmpDown(NULL, &IMsg);
}
else
{
pIasAttrib->pFileObject = pIrpSp->FileObject;
pIasAttrib->AttribHandle = AttribHandle;
CTEGetLock(&IrdaLock, &hLock);
InsertTailList(&IasAttribList, &pIasAttrib->Linkage);
CTEFreeLock(&IrdaLock, hLock);
pIrp->IoStatus.Information = sizeof(PVOID);
*(PVOID *) pIrp->AssociatedIrp.SystemBuffer = AttribHandle;
Status = STATUS_SUCCESS;
DEBUGMSG(DBG_TDI, ("IRDA: IAS entry added, fo:%p ah:%p\n",
pIrpSp->FileObject, AttribHandle));
}
}
break;
}
case IOCTL_IRDA_DEL_IAS_ATTRIB:
{
PVOID *pAttribHandle = (PVOID *) pIrp->AssociatedIrp.SystemBuffer;
if (pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(PVOID))
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
IMsg.Prim = IRLMP_DELATTRIBUTE_REQ;
IMsg.IRDA_MSG_AttribHandle = *pAttribHandle;
IrlmpDown(NULL, &IMsg);
pIrp->IoStatus.Information = 0;
Status = STATUS_SUCCESS;
break;
}
case IOCTL_IRDA_LINK_STATUS_NB:
{
PIRLINK_STATUS pLinkStatus = (PIRLINK_STATUS) pIrp->AssociatedIrp.SystemBuffer;
if (pIrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(IRLINK_STATUS))
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
CTEGetLock(&IrdaLock, &hLock);
CTEMemCopy(pLinkStatus, &LinkStatus, sizeof(IRLINK_STATUS));
CTEFreeLock(&IrdaLock, hLock);
pIrp->IoStatus.Information = sizeof(IRLINK_STATUS);
Status = STATUS_SUCCESS;
break;
}
case IOCTL_IRDA_LINK_STATUS:
{
PIRLINK_STATUS pLinkStatus = (PIRLINK_STATUS) pIrp->AssociatedIrp.SystemBuffer;
if (pIrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(IRLINK_STATUS))
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
CTEGetLock(&IrdaLock, &hLock);
if (LinkStatusUpdated)
{
LinkStatusUpdated = FALSE;
CTEMemCopy(pLinkStatus, &LinkStatus, sizeof(IRLINK_STATUS));
pIrp->IoStatus.Information = sizeof(IRLINK_STATUS);
Status = STATUS_SUCCESS;
}
else
{
PendIrp(&StatusIrpList, pIrp, NULL, TRUE);
Status = STATUS_PENDING;
}
CTEFreeLock(&IrdaLock, hLock);
break;
}
#if 0 //DBG
case IOCTL_IRDA_GET_DBG_MSGS:
Status = DbgMsgIrp(pIrp, pIrpSp);
break;
case IOCTL_IRDA_GET_DBG_SETTINGS:
{
UINT *Settings = pIrp->AssociatedIrp.SystemBuffer;
if (pIrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(UINT)*2)
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
Settings[0] = DbgSettings;
Settings[1] = DbgOutput;
pIrp->IoStatus.Information = sizeof(UINT)*2;
Status = STATUS_SUCCESS;
break;
}
case IOCTL_IRDA_SET_DBG_SETTINGS:
{
UINT *Settings = pIrp->AssociatedIrp.SystemBuffer;
if (pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(UINT)*2)
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
}
DbgSettings = Settings[0];
DbgOutput = Settings[1];
pIrp->IoStatus.Information = 0;
Status = STATUS_SUCCESS;
break;
}
#endif
default:
Status = STATUS_NOT_IMPLEMENTED;
break;
}
if (Status != STATUS_PENDING)
{
pIrp->IoStatus.Status = Status;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
}
return Status;
}
NTSTATUS
TdiQueryInformation(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
NTSTATUS Status = STATUS_SUCCESS;
PIRDA_CONN_OBJ pConn;
PIRDA_ADDR_OBJ pAddr;
CTELockHandle hLock;
int InfoSize = 0;
int BytesCopied;
int DataLen = GetMdlChainByteCount(pIrp->MdlAddress);
PTDI_REQUEST_KERNEL_QUERY_INFORMATION pTdiParmsQueryInfo;
//
// This is large enough for TDI_QUERY_ADDRESS_INFO because
// of the inclusion of TDI_PROVIDER_STATISTICS.
//
union
{
TDI_CONNECTION_INFO ConnInfo;
TDI_ADDRESS_INFO AddrInfo;
TDI_PROVIDER_INFO ProviderInfo;
TDI_PROVIDER_STATISTICS ProviderStats;
} InfoBuf;
pTdiParmsQueryInfo = (PTDI_REQUEST_KERNEL_QUERY_INFORMATION)
&(pIrpSp->Parameters);
switch(pTdiParmsQueryInfo->QueryType)
{
case TDI_QUERY_PROVIDER_INFO:
InfoSize = sizeof(TDI_PROVIDER_INFO);
InfoBuf.ProviderInfo.Version = 0x0100;
InfoBuf.ProviderInfo.MaxSendSize = 2048;//IRDA_MAX_DATA_SIZE;
InfoBuf.ProviderInfo.MaxConnectionUserData = 0;
InfoBuf.ProviderInfo.MaxDatagramSize = 0;
InfoBuf.ProviderInfo.ServiceFlags =
TDI_SERVICE_CONNECTION_MODE |
TDI_SERVICE_FORCE_ACCESS_CHECK/* |
TDI_SERVICE_ORDERLY_RELEASE*/;
InfoBuf.ProviderInfo.MinimumLookaheadData = 0;
InfoBuf.ProviderInfo.MaximumLookaheadData = 0;
InfoBuf.ProviderInfo.NumberOfResources = 0;
InfoBuf.ProviderInfo.StartTime.LowPart =
CTESystemUpTime();
InfoBuf.ProviderInfo.StartTime.HighPart = 0;
break;
case TDI_QUERY_ADDRESS_INFO:
//
// typedef struct _TA_ADDRESS
// {
// USHORT AddressLength;
// USHORT AddressType;
// UCHAR Address[1];
// } TA_ADDRESS, *PTA_ADDRESS;
//
// typedef struct _TRANSPORT_ADDRESS
// {
// LONG TAAddressCount;
// TA_ADDRESS Address[1];
// } TRANSPORT_ADDRESS, *PTRANSPORT_ADDRESS;
//
// typedef struct _TDI_ADDRESS_IRDA
// {
// UCHAR irdaDeviceID[4];
// CHAR irdaServiceName[26];
// } TDI_ADDRESS_IRDA, *PTDI_ADDRESS_IRDA;
//
// IrDA assumes one TA_ADDRESS containing a TDI_ADDRESS_IRDA.
//
// typedef struct _TDI_ADDRESS_INFO
// {
// ULONG ActivityCount;
// TRANSPORT_ADDRESS Address;
// } TDI_ADDRESS_INFO, *PTDI_ADDRESS_INFO;
InfoSize =
offsetof(TDI_ADDRESS_INFO, Address.Address[0].Address[0]) +
sizeof(TDI_ADDRESS_IRDA);
InfoBuf.AddrInfo.ActivityCount = 1; // What is this?
InfoBuf.AddrInfo.Address.TAAddressCount = 1;
InfoBuf.AddrInfo.Address.Address[0].AddressLength =
sizeof(TDI_ADDRESS_IRDA);
InfoBuf.AddrInfo.Address.Address[0].AddressType =
TDI_ADDRESS_TYPE_IRDA;
if ((UINT_PTR) pIrpSp->FileObject->FsContext2 == TDI_CONNECTION_FILE)
{
// Extract the local address from the Connection
pConn = (PIRDA_CONN_OBJ) pIrpSp->FileObject->FsContext;
CTEAssert(IS_VALID_CONN(pConn));
GET_CONN_LOCK(pConn, &hLock);
CTEMemCopy(
&InfoBuf.AddrInfo.Address.Address[0].Address[0],
&pConn->LocalAddr,
sizeof(TDI_ADDRESS_IRDA));
FREE_CONN_LOCK(pConn, hLock);
DEBUGMSG(DBG_TDI,
("IRDA: TdiQueryInformation(), From ConnObj:%p, %d %02X%02X%02X%02X \"%s\".\n",
pConn,
InfoBuf.AddrInfo.Address.Address[0].AddressType,
InfoBuf.AddrInfo.Address.Address[0].Address[0],
InfoBuf.AddrInfo.Address.Address[0].Address[1],
InfoBuf.AddrInfo.Address.Address[0].Address[2],
InfoBuf.AddrInfo.Address.Address[0].Address[3],
(char *) &InfoBuf.AddrInfo.Address.Address[0].Address[4]));
}
else // Extract the local address from the Address Object
{
pAddr = (PIRDA_ADDR_OBJ) pIrpSp->FileObject->FsContext;
CTEAssert(IS_VALID_ADDR(pAddr));
GET_ADDR_LOCK(pAddr, &hLock);
CTEMemCopy(
&InfoBuf.AddrInfo.Address.Address[0].Address[0],
&pAddr->LocalAddr,
sizeof(TDI_ADDRESS_IRDA));
FREE_ADDR_LOCK(pAddr, hLock);
DEBUGMSG(DBG_TDI,
("IRDA: TdiQueryInformation(), From AddrObj:%p, %d %02X%02X%02X%02X \"%s\".\n",
pAddr,
InfoBuf.AddrInfo.Address.Address[0].AddressType,
InfoBuf.AddrInfo.Address.Address[0].Address[0],
InfoBuf.AddrInfo.Address.Address[0].Address[1],
InfoBuf.AddrInfo.Address.Address[0].Address[2],
InfoBuf.AddrInfo.Address.Address[0].Address[3],
(char *) &InfoBuf.AddrInfo.Address.Address[0].Address[4]));
}
break;
case TDI_QUERY_CONNECTION_INFO:
CTEAssert(FALSE);
break;
case TDI_QUERY_PROVIDER_STATISTICS:
CTEAssert(FALSE);
/*
InfoSize = sizeof(TDI_PROVIDER_STATISTICS);
CTEMemSet(&InfoBuf.ProviderStats, 0, sizeof(TDI_PROVIDER_STATISTICS));
InfoBuf.ProviderStats.Version = 0x100;
*/
break;
case TDI_QUERY_BROADCAST_ADDRESS:
default:
Status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
BytesCopied=0;
if (Status == STATUS_SUCCESS)
{
if (DataLen < InfoSize)
{
DEBUGMSG(DBG_ERROR, ("IRDA: Buffer overflow in TdiQueryInformation\n"));
Status = STATUS_BUFFER_OVERFLOW;
}
else
{
//
// could fail to get the system address for the mdl
//
Status=TdiCopyBufferToMdl(&InfoBuf, 0, InfoSize, pIrp->MdlAddress, 0, &BytesCopied);
}
}
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = BytesCopied;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return Status;
}
NTSTATUS
TdiSetInformation(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
DEBUGMSG(DBG_TDI, ("IRDA: TdiSetInformation()\n"));
//(PVOID) CloseRasIrdaAddresses = pIrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
pIrp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
TdiSetEvent(
PIRDA_ADDR_OBJ pAddr,
int Type,
PVOID pHandler,
PVOID pContext)
{
TDI_STATUS Status;
CTELockHandle hLock;
DEBUGMSG(DBG_TDI, ("IRDA: TdiSetEvent(), %s for AddrObj:%p, Handler:%p, Context:%p \n",
TdiEventTxt(Type), pAddr, pHandler, pContext));
CTEAssert(IS_VALID_ADDR(pAddr));
Status = STATUS_SUCCESS;
GET_ADDR_LOCK(pAddr, &hLock);
switch (Type)
{
case TDI_EVENT_CONNECT:
pAddr->pEventConnect = pHandler;
pAddr->pEventConnectContext = pContext;
break;
case TDI_EVENT_DISCONNECT:
pAddr->pEventDisconnect = pHandler;
pAddr->pEventDisconnectContext = pContext;
break;
case TDI_EVENT_RECEIVE:
pAddr->pEventReceive = pHandler;
pAddr->pEventReceiveContext = pContext;
break;
case TDI_EVENT_ERROR:
break;
case TDI_EVENT_RECEIVE_DATAGRAM:
case TDI_EVENT_RECEIVE_EXPEDITED:
default:
Status = STATUS_INVALID_PARAMETER;//TDI_BAD_EVENT_TYPE;
break;
}
FREE_ADDR_LOCK(pAddr, hLock);
return Status;
}
int
GetLsapSelServiceName(CHAR *ServiceName)
{
int LsapSel = 0;
int i;
CHAR *Digits;
// Is the service name of the form "LSAP-SELxxx"?
// If yes then return xxx if it is a number else -1.
// If not "LSAP-SELxxx" return 0.
if (RtlCompareMemory(LSAPSEL_TXT, ServiceName, LSAPSEL_TXTLEN)
== LSAPSEL_TXTLEN)
{
Digits = ServiceName + LSAPSEL_TXTLEN;
for (i = 0; i< 3; i++)
{
if (Digits[i] == 0)
break;
if (Digits[i] < '0' || Digits[i] > '9')
{
LsapSel = -1;
break;
}
LsapSel = (LsapSel*10) + (Digits[i] - '0');
}
if (Digits[i] != 0) // LSAP-SELxxx should be null terminated
{
LsapSel = -1;
}
}
if (LsapSel > 127) {
//
// lsapsel's are only 7 bits
//
LsapSel=-1;
}
return LsapSel;
}
NTSTATUS
TdiOpenAddress(
PIRDA_ADDR_OBJ *ppNewAddrObj,
TRANSPORT_ADDRESS UNALIGNED *pAddrList,
USHORT AddrListLen)
{
TDI_STATUS Status = TDI_SUCCESS;
PIRDA_ADDR_OBJ pAddr;
CTELockHandle hLock;
int NewLsapSel;
int i;
PTDI_ADDRESS_IRDA pIrdaAddr = (PTDI_ADDRESS_IRDA) pAddrList->Address[0].Address;
BOOLEAN AddIasServiceName = TRUE;
//
// typedef struct _TA_ADDRESS
// {
// USHORT AddressLength;
// USHORT AddressType;
// UCHAR Address[1];
// } TA_ADDRESS, *PTA_ADDRESS;
//
// typedef struct _TRANSPORT_ADDRESS
// {
// LONG TAAddressCount;
// TA_ADDRESS Address[1];
// } TRANSPORT_ADDRESS, *PTRANSPORT_ADDRESS;
//
// typedef struct _TDI_ADDRESS_IRDA
// {
// UCHAR irdaDeviceID[4];
// CHAR irdaServiceName[26];
// } TDI_ADDRESS_IRDA, *PTDI_ADDRESS_IRDA;
//
// IrDA assumes one TA_ADDRESS containing a TDI_ADDRESS_IRDA.
//
// typedef struct _TDI_ADDRESS_INFO
// {
// ULONG ActivityCount;
// TRANSPORT_ADDRESS Address;
// } TDI_ADDRESS_INFO, *PTDI_ADDRESS_INFO;
//
if (AddrListLen < sizeof(TRANSPORT_ADDRESS) + sizeof(TDI_ADDRESS_IRDA) - 1)
{
return STATUS_EA_LIST_INCONSISTENT;
}
DEBUGMSG(DBG_TDI,
("IRDA: TdiOpenAddress(), Type:%d Addr:%02X%02X%02X%02X \"%s\".\n",
pAddrList->Address[0].AddressType,
pAddrList->Address[0].Address[0],
pAddrList->Address[0].Address[1],
pAddrList->Address[0].Address[2],
pAddrList->Address[0].Address[3],
(char *) &pAddrList->Address[0].Address[4]));
if (pAddrList->TAAddressCount != 1 ||
pAddrList->Address[0].AddressLength != sizeof(TDI_ADDRESS_IRDA) ||
pAddrList->Address[0].AddressType != TDI_ADDRESS_TYPE_IRDA)
{
DEBUGMSG(DBG_ERROR, ("IRDA: TdiOpenAddress(), Bad Address. Count=%d, AddrLen:%d!=%d Type:%d!=%d\n",
pAddrList->TAAddressCount, pAddrList->Address[0].AddressLength,
sizeof(TDI_ADDRESS_IRDA), pAddrList->Address[0].AddressType,
TDI_ADDRESS_TYPE_IRDA));
return STATUS_INVALID_ADDRESS_COMPONENT; //TDI_BAD_ADDR;
}
CTEGetLock(&IrdaLock, &hLock);
// Service name supplied. Ensure that an address object with the same
// name does not exist
if (pIrdaAddr->irdaServiceName[0] != 0)
{
for (pAddr = AddrObjList; pAddr != NULL; pAddr = pAddr->pNext)
{
if (MyStrEqual(pIrdaAddr->irdaServiceName,
pAddr->LocalAddr.irdaServiceName,
sizeof(pIrdaAddr->irdaServiceName)))
{
DEBUGMSG(DBG_ERROR, ("IRDA: TdiOpenAddress(), Duplicate irdaServiceName.\n"));
Status = STATUS_ADDRESS_ALREADY_EXISTS;//TDI_ADDR_IN_USE;
CTEFreeLock(&IrdaLock, hLock);
goto done;
}
}
}
NewLsapSel = GetLsapSelServiceName(pIrdaAddr->irdaServiceName);
if (NewLsapSel == -1)
{
// Service name was of the form "LSAP-SELxxx" but xxx was invalid
Status = STATUS_INVALID_ADDRESS_COMPONENT;
CTEFreeLock(&IrdaLock, hLock);
goto done;
}
if (NewLsapSel)
{
// Service name was of the form "LSAP-SELxxx"
// NewLsapSel = xxx
AddIasServiceName = FALSE;
}
else if ((NewLsapSel = GetUnusedLsapSel()) == -1)
{
DEBUGMSG(DBG_ERROR, ("IRDA: TdiOpenAddress(), No LSAP-SELs.\n"));
Status = STATUS_TOO_MANY_ADDRESSES;//TDI_NO_FREE_ADDR;
CTEFreeLock(&IrdaLock, hLock);
goto done;
}
IRDA_ALLOC_MEM(pAddr, sizeof(IRDA_ADDR_OBJ), MT_TDI_ADDROBJ);
if (pAddr == NULL)
{
DEBUGMSG(DBG_ERROR, ("IRDA: AllocMem(IRDA_ADDR_OBJ) failed.\n"));
Status = STATUS_INSUFFICIENT_RESOURCES;//TDI_NO_RESOURCES;
CTEFreeLock(&IrdaLock, hLock);
goto done;
}
CTEMemSet(pAddr, 0, sizeof(IRDA_ADDR_OBJ));
CTEInitLock(&pAddr->Lock);
pAddr->ConnObjList = NULL;
pAddr->pEventConnect = NULL;
pAddr->pEventConnectContext = NULL;
pAddr->pEventDisconnect = NULL;
pAddr->pEventDisconnectContext = NULL;
pAddr->pEventReceive = NULL;
pAddr->pEventReceiveContext = NULL;
pAddr->LocalLsapSel = NewLsapSel;
pAddr->UseIrlptMode = 0;
pAddr->Use9WireMode = FALSE;
pAddr->pNext = AddrObjList;
AddrObjList = pAddr;
#if DBG
pAddr->Sig = ADDR_OBJ_SIG;
#endif
CTEFreeLock(&IrdaLock, hLock);
// A server
if (pIrdaAddr->irdaServiceName[0] != 0)
{
IRDA_MSG IMsg;
IAS_SET IasSet;
RtlCopyMemory(&pAddr->LocalAddr,
pIrdaAddr, sizeof(TDI_ADDRESS_IRDA));
pAddr->IsServer = TRUE;
// register LSAP-SEL
IMsg.Prim = IRLMP_REGISTERLSAP_REQ;
IMsg.IRDA_MSG_LocalLsapSel = NewLsapSel;
IMsg.IRDA_MSG_UseTtp = TRUE;
IrlmpDown(NULL, &IMsg);
// and IAS LsapSel attribute
if (AddIasServiceName)
{
i = 0;
while (pAddr->LocalAddr.irdaServiceName[i] && i < 60)
{
IasSet.irdaClassName[i] = pAddr->LocalAddr.irdaServiceName[i];
i++;
}
IasSet.irdaClassName[i] = 0;
i = 0;
while (IasAttribName_TTPLsapSel[i])
{
IasSet.irdaAttribName[i] = IasAttribName_TTPLsapSel[i];
i++;
}
IasSet.irdaAttribName[i] = 0;
IasSet.irdaAttribType = IAS_ATTRIB_INT;
IasSet.irdaAttribute.irdaAttribInt = NewLsapSel;
IMsg.Prim = IRLMP_ADDATTRIBUTE_REQ;
IMsg.IRDA_MSG_pIasSet = &IasSet;
IMsg.IRDA_MSG_pAttribHandle = &pAddr->IasAttribHandle;
IrlmpDown(NULL, &IMsg);
}
}
// A client
else
{
pAddr->IsServer = FALSE;
SetLsapSelAddr(NewLsapSel, pAddr->LocalAddr.irdaServiceName);
}
*ppNewAddrObj = pAddr;
DEBUGMSG(DBG_TDI,
("IRDA: TdiOpenAddress(), Assigned local LSAP-SEL %d, Service:\"%s\".\n",
pAddr->LocalLsapSel, pAddr->LocalAddr.irdaServiceName));
done:
return Status;
}
NTSTATUS
TdiOpenConnection(
PIRDA_CONN_OBJ *ppNewConnObj,
PVOID pContext,
USHORT ContextLen)
{
PIRDA_CONN_OBJ pNewConnObj;
*ppNewConnObj=NULL;
if (ContextLen < sizeof(CONNECTION_CONTEXT))
{
return STATUS_EA_LIST_INCONSISTENT;
}
IRDA_ALLOC_MEM(pNewConnObj, sizeof(IRDA_CONN_OBJ), MT_TDI_CONNOBJ);
if (pNewConnObj == NULL)
{
DEBUGMSG(DBG_ERROR, ("IRDA: AllocMem(IRDA_CONN_OBJ) failed.\n"));
return STATUS_INSUFFICIENT_RESOURCES;//TDI_NO_RESOURCES;
}
CTEMemSet(pNewConnObj, 0, sizeof(IRDA_CONN_OBJ));
CTEInitLock(&pNewConnObj->Lock);
pNewConnObj->ClientContext = pContext;
pNewConnObj->ConnState = IRDA_CONN_CREATED;
InitializeListHead(&pNewConnObj->RecvBufList);
InitializeListHead(&pNewConnObj->RecvIrpList);
InitializeListHead(&pNewConnObj->SendIrpList);
InitializeListHead(&pNewConnObj->SendIrpPassiveList);
IrdaTimerInitialize(&pNewConnObj->RetryConnTimer,
RetryConnTimerExp,
BUSY_LINK_CONN_RETRY_WAIT,
pNewConnObj, NULL);
ReferenceInit(&pNewConnObj->RefCnt, pNewConnObj, FreeConnObject);
REFADD(&pNewConnObj->RefCnt, ' TS1');
CTEInitEvent(&pNewConnObj->SendEvent, TdiSendAtPassiveCallback);
#if DBG
pNewConnObj->Sig = CONN_OBJ_SIG;
pNewConnObj->RetryConnTimer.pName = "RetryConn";
#endif
*ppNewConnObj = pNewConnObj;
return STATUS_SUCCESS;
}
NTSTATUS
TdiCloseAddress(PIRDA_ADDR_OBJ pAddr)
{
PIRDA_ADDR_OBJ pPrevAddrObj;
CTELockHandle hLock;
DEBUGMSG(DBG_TDI, ("IRDA: TdiCloseAddress() AddrObj:%p\n",
pAddr));
CTEAssert(IS_VALID_ADDR(pAddr));
CTEAssert(pAddr->ConnObjList == NULL);
CTEGetLock(&IrdaLock, &hLock);
// if pAddr is first in the list, remove it from the list
if (AddrObjList == pAddr)
AddrObjList = pAddr->pNext;
else
{
// find the previous IRDA_ADDR_OBJ
pPrevAddrObj = AddrObjList;
while (pPrevAddrObj->pNext != pAddr)
pPrevAddrObj = pPrevAddrObj->pNext;
// remove pAddr from the list
pPrevAddrObj->pNext = pAddr->pNext;
}
CTEFreeLock(&IrdaLock, hLock);
if (pAddr->IsServer)
{
IRDA_MSG IMsg;
IMsg.Prim = IRLMP_DEREGISTERLSAP_REQ;
IMsg.IRDA_MSG_LocalLsapSel = pAddr->LocalLsapSel;
IrlmpDown(NULL, &IMsg);
IMsg.Prim = IRLMP_DELATTRIBUTE_REQ;
IMsg.IRDA_MSG_AttribHandle = pAddr->IasAttribHandle;
IrlmpDown(NULL, &IMsg);
}
#if DBG
pAddr->Sig = ' DAB';
#endif
IRDA_FREE_MEM(pAddr);
return STATUS_SUCCESS;
}
VOID
ConnectionStatusChange(
PIRDA_CONN_OBJ pConn,
IRDA_CONNECTION_STATUS ConnStatus)
{
PLIST_ENTRY pListEntry;
PIRP pIrp;
CTELockHandle hLock;
if (ConnStatus == CONNECTION_UP)
{
IRDA_MSG IMsg;
if (!ConnectionCount)
{
return;
}
ConnectionInterrupted = FALSE;
if (pConn)
{
// Query Irlap for the connected speed and
// the MAC address of the peer so Irmon
// can display the name of the connected device
IMsg.Prim = IRLAP_STATUS_REQ;
IMsg.IRDA_MSG_pLinkStatus = &LinkStatus;
IrlmpDown(pConn->IrlmpContext, &IMsg);
}
}
CTEGetLock(&IrdaLock, &hLock);
LinkStatusUpdated = TRUE;
switch (ConnStatus)
{
case CONNECTION_UP:
LinkStatus.Flags = LF_CONNECTED;
break;
case CONNECTION_DOWN:
LinkStatus.Flags = 0;
break;
case CONNECTION_INTERRUPTED:
if (ConnectionInterrupted || !ConnectionCount)
{
CTEFreeLock(&IrdaLock, hLock);
return;
}
LinkStatus.Flags = LF_INTERRUPTED;
ConnectionInterrupted = TRUE;
break;
}
while (!IsListEmpty(&StatusIrpList)) {
pListEntry = RemoveHeadList(&StatusIrpList);
pIrp = CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
if (IoSetCancelRoutine(pIrp, NULL) == NULL) {
// Cancel routine is going to run. Mark Irp so cancel
// routine won't attempt to remove it from the list
pIrp->Tail.Overlay.ListEntry.Flink = NULL;
} else {
CTEMemCopy(pIrp->AssociatedIrp.SystemBuffer,
&LinkStatus, sizeof(IRLINK_STATUS));
CTEFreeLock(&IrdaLock, hLock);
pIrp->IoStatus.Information = sizeof(IRLINK_STATUS);
pIrp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
CTEGetLock(&IrdaLock, &hLock);
LinkStatusUpdated = FALSE;
}
}
CTEFreeLock(&IrdaLock, hLock);
return;
}
VOID
ConnectionUp(
PIRDA_CONN_OBJ pConn,
BOOLEAN ConnectionUp)
{
if (ConnectionUp)
{
if (pConn->ConnectionUp)
{
return;
}
pConn->ConnectionUp = TRUE;
CTEInterlockedIncrementLong(&ConnectionCount);
if (ConnectionCount == 1)
{
ConnectionStatusChange(pConn, CONNECTION_UP);
}
}
else
{
if (!pConn->ConnectionUp)
{
return;
}
pConn->ConnectionUp = FALSE;
ASSERT(ConnectionCount);
CTEInterlockedDecrementLong(&ConnectionCount);
if (ConnectionCount == 0)
{
ConnectionStatusChange(pConn, CONNECTION_DOWN);
}
}
}
VOID
IrdaDisconnectIrlmp(PIRDA_CONN_OBJ pConn)
{
IRDA_MSG IMsg;
if (pConn->IrlmpContext)
{
IMsg.Prim = IRLMP_DISCONNECT_REQ;
IMsg.IRDA_MSG_pDiscData = NULL;
IMsg.IRDA_MSG_DiscDataLen = 0;
IMsg.IRDA_MSG_pDiscContext = pConn;
IrlmpDown(pConn->IrlmpContext, &IMsg);
DEBUGMSG(DBG_TDI, ("IRDA: IrdaDisconnectIrlmp co:%p\n", pConn));
}
else
{
DEBUGMSG(DBG_TDI, ("IRDA: IrdaDisconnectIrlmp co %p, IrlmpContext == NULL\n",
pConn));
}
}
VOID
FreeConnObject(PIRDA_CONN_OBJ pConn)
{
IRDA_FREE_MEM(pConn);
}
NTSTATUS
TdiCloseConnection(PIRDA_CONN_OBJ pConn)
{
PIRDA_ADDR_OBJ pAddr=NULL;
CTELockHandle hLock;
DEBUGMSG(DBG_TDI, ("IRDA: TdiCloseConnecion() ConnObj:%p\n",
pConn));
CTEAssert(IS_VALID_CONN(pConn));
if (pConn->ConnState != IRDA_CONN_CREATED)
{
TdiDisconnect(NULL, NULL, pConn);
}
GET_CONN_LOCK(pConn, &hLock);
pAddr=pConn->pAddr;
pConn->pAddr=NULL;
if (pAddr != NULL) {
PIRDA_CONN_OBJ pPrevConnObj;
CTELockHandle hAddrLock;
GET_ADDR_LOCK(pAddr, &hAddrLock);
//
// if pConn is first in the list, remove it from the list
//
if (pAddr->ConnObjList == pConn) {
pAddr->ConnObjList = pConn->pNext;
} else {
//
// find the previous IRDA_CONN_OBJ
//
pPrevConnObj = pAddr->ConnObjList;
while ((pPrevConnObj != NULL) && (pPrevConnObj->pNext != pConn)) {
pPrevConnObj = pPrevConnObj->pNext;
}
//
// since the connection has a pointer to the address object,
// the connection should really be in the address objects connection list.
//
ASSERT(pPrevConnObj != NULL);
//
// remove pConn from the list
//
if (pPrevConnObj != NULL) {
pPrevConnObj->pNext = pConn->pNext;
}
}
DumpObjects();
FREE_ADDR_LOCK(pAddr, hAddrLock);
//
// done with this address object
//
ObDereferenceObject(pConn->AddressFileObject);
}
FREE_CONN_LOCK(pConn, hLock);
if (pConn->IrlmpContext)
{
IRDA_MSG IMsg;
IMsg.Prim = IRLMP_CLOSELSAP_REQ;
IrlmpDown(pConn->IrlmpContext, &IMsg);
}
#if DBG
pConn->Sig = ' DAB';
#endif
CTEAssert(IsListEmpty(&pConn->RecvBufList));
CTEAssert(IsListEmpty(&pConn->SendIrpList));
REFDEL(&pConn->RefCnt, ' TS1');
return STATUS_SUCCESS;
}
NTSTATUS
TdiAssociateAddress(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
NTSTATUS Status;
PTDI_REQUEST_KERNEL_ASSOCIATE pTdiParmsAssoc;
PFILE_OBJECT AddressFileObject;
CTEAssert(((UINT_PTR) pIrpSp->FileObject->FsContext2) == TDI_CONNECTION_FILE);
pTdiParmsAssoc = (PTDI_REQUEST_KERNEL_ASSOCIATE) &(pIrpSp->Parameters);
Status = ObReferenceObjectByHandle(
pTdiParmsAssoc->AddressHandle,
0,
*IoFileObjectType,
pIrp->RequestorMode,
&AddressFileObject,
NULL);
if (!NT_SUCCESS(Status))
{
DEBUGMSG(DBG_ERROR,
("IRDA: TdiAssociateAddress(), ObReferenceObjectByHandle() for %p failed, %X.\n",
pTdiParmsAssoc->AddressHandle,
Status));
}
else if (AddressFileObject->DeviceObject != pIrDADeviceObject ||
((UINT_PTR) AddressFileObject->FsContext2) != TDI_TRANSPORT_ADDRESS_FILE)
{
DEBUGMSG(DBG_ERROR,("IRDA: TdiAssociateAddress(), Bad handle %p.\n",
pTdiParmsAssoc->AddressHandle));
ObDereferenceObject(AddressFileObject);
Status = STATUS_INVALID_HANDLE;
}
else
{
PIRDA_CONN_OBJ pConn;
PIRDA_ADDR_OBJ pAddr;
CTELockHandle hAddrLock;
CTELockHandle hLock;
pConn = (PIRDA_CONN_OBJ) pIrpSp->FileObject->FsContext;
CTEAssert(IS_VALID_CONN(pConn));
pAddr = (PIRDA_ADDR_OBJ) AddressFileObject->FsContext;
CTEAssert(IS_VALID_ADDR(pAddr));
DEBUGMSG(DBG_TDI, ("IRDA: TdiAssociateAddress AddrObj:%p ConnObj:%p\n",
pAddr, pConn));
GET_CONN_LOCK(pConn, &hLock);
GET_ADDR_LOCK(pAddr, &hAddrLock);
if (pConn->pAddr != NULL) {
ObDereferenceObject(AddressFileObject);
Status = STATUS_ADDRESS_ALREADY_ASSOCIATED;
ASSERT(0);
} else {
//
// don't want the address file object going away while we have a connection object pointing to it
//
pConn->AddressFileObject=AddressFileObject;
// Link IRDA_CONN_OBJ to IRDA_ADDR_OBJ.
pConn->pAddr = pAddr;
// Add IRDA_CONN_OBJ to ConnObjList anchored on IRDA_ADDR_OBJ.
pConn->pNext = pAddr->ConnObjList;
pAddr->ConnObjList = pConn;
CTEMemCopy(&pConn->LocalAddr,&pAddr->LocalAddr, sizeof(TDI_ADDRESS_IRDA));
pConn->IsServer = pAddr->IsServer;
pConn->LocalLsapSel = pAddr->LocalLsapSel;
DumpObjects();
Status = STATUS_SUCCESS;
}
FREE_ADDR_LOCK(pAddr, hAddrLock);
FREE_CONN_LOCK(pConn, hLock);
}
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return Status;
}
NTSTATUS
TdiDisassociateAddress(PIRP pIrp, PIO_STACK_LOCATION pIrpSp)
{
PIRDA_CONN_OBJ pConn, pPrevConnObj;
PIRDA_ADDR_OBJ pAddr;
CTELockHandle hLock;
CTELockHandle hAddrLock;
NTSTATUS Status = STATUS_SUCCESS;
pConn = (PIRDA_CONN_OBJ) pIrpSp->FileObject->FsContext;
CTEAssert(IS_VALID_CONN(pConn));
if (pConn->pAddr == NULL)
{
CTEAssert(pConn->pAddr != NULL);
Status = STATUS_INVALID_ADDRESS_COMPONENT; //TDI_BAD_ADDR;
goto done;
}
// normally when the peer disconnects I indicate the
// disconnect to AFD and go to IRDA_CONN_CLOSING state.
// AFD then calls TdiDisconnect and I go into IRDA_CONN_CREATED.
// AFD then disassociates the address. In some cases however,
// AFD does not call TdiDisconnect before it disassociates so
// I'll do it.
if (pConn->ConnState != IRDA_CONN_CREATED)
{
TdiDisconnect(NULL, NULL, pConn);
}
CTEAssert(pConn->ConnState == IRDA_CONN_CREATED);
GET_CONN_LOCK(pConn, &hLock);
pAddr = pConn->pAddr;
CTEAssert(IS_VALID_ADDR(pAddr));
DEBUGMSG(DBG_TDI, ("IRDA: TdiDisassociateAddress() AddrObj:%p ConnObj:%p\n",
pAddr, pConn));
GET_ADDR_LOCK(pAddr, &hAddrLock);
// if pConn is first in the list, remove it from the list
if (pAddr->ConnObjList == pConn)
pAddr->ConnObjList = pConn->pNext;
else
{
// find the previous IRDA_CONN_OBJ
pPrevConnObj = pAddr->ConnObjList;
while (pPrevConnObj && pPrevConnObj->pNext != pConn)
{
pPrevConnObj = pPrevConnObj->pNext;
}
// remove pConn from the list
if (pPrevConnObj)
{
pPrevConnObj->pNext = pConn->pNext;
}
}
DumpObjects();
pConn->pAddr=NULL;
//
// done with this address object
//
ObDereferenceObject(pConn->AddressFileObject);
FREE_ADDR_LOCK(pAddr, hAddrLock);
FREE_CONN_LOCK(pConn, hLock);
done:
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return Status;
}
NTSTATUS
ConnectRcToNtStatus(UINT IrlmpRc)
{
switch (IrlmpRc)
{
case IRLMP_LSAP_SEL_IN_USE:
case IRLMP_IN_EXCLUSIVE_MODE:
return STATUS_ADDRESS_ALREADY_EXISTS;
case IRLMP_LINK_IN_USE:
return STATUS_ACCESS_DENIED;
case IRLMP_IAS_QUERY_IN_PROGRESS:
// I've serialized IAS requests, should never happen
CTEAssert(0);
return STATUS_CONNECTION_RESET; //STATUS_CONNECTION_ABORTED;
case IRLMP_BAD_DEV_ADDR:
return STATUS_INVALID_ADDRESS_COMPONENT;
}
return STATUS_CONNECTION_RESET; //STATUS_CONNECTION_ABORTED;
}
NTSTATUS
InitiateConnection(PIRDA_CONN_OBJ pConn, PIRP pIrp)
{
IRDA_MSG IMsg;
UINT rc;
DEBUGMSG(DBG_TDI, ("IRDA: Initiate connection to Dev:%02X%02X%02X%02X\n",
pConn->RemoteAddr.irdaDeviceID[0],
pConn->RemoteAddr.irdaDeviceID[1],
pConn->RemoteAddr.irdaDeviceID[2],
pConn->RemoteAddr.irdaDeviceID[3]
));
DEBUGMSG(DBG_TDI, (" LocalLsapSel:%d, RemoteLsapSel:%d\n",
pConn->LocalLsapSel, pConn->RemoteLsapSel));
IMsg.Prim = IRLMP_CONNECT_REQ;
RtlCopyMemory(IMsg.IRDA_MSG_RemoteDevAddr,
pConn->RemoteAddr.irdaDeviceID,
IRDA_DEV_ADDR_LEN);
IMsg.IRDA_MSG_RemoteLsapSel = pConn->RemoteLsapSel;
IMsg.IRDA_MSG_pQos = NULL;
IMsg.IRDA_MSG_pConnData = NULL;
IMsg.IRDA_MSG_ConnDataLen = 0;
IMsg.IRDA_MSG_LocalLsapSel = pConn->LocalLsapSel;
IMsg.IRDA_MSG_pContext = pConn;
IMsg.IRDA_MSG_UseTtp = pConn->pAddr->UseIrlptMode ? FALSE:TRUE;
IMsg.IRDA_MSG_TtpCredits = TTP_RECV_CREDITS;
IMsg.IRDA_MSG_MaxSDUSize = TTP_RECV_MAX_SDU;
#if DBG
pConn->CreditsExtended += TTP_RECV_CREDITS;
#endif
pConn->TtpRecvCreditsLeft = TTP_RECV_CREDITS;
#if DBG
pIrp->IoStatus.Information=1;
#endif
//
// pend the irp, now incase the confermation happened quickly
//
PendIrp(&ConnIrpList, pIrp, NULL, FALSE);
rc = IrlmpDown(NULL, &IMsg);
pIrp=NULL;
switch (rc)
{
case SUCCESS:
//
// TDI needed the IrlmpContext immediately so it is
// now returned in the request message
pConn->IrlmpContext = IMsg.IRDA_MSG_pContext;
break;
case IRLAP_REMOTE_DISCOVERY_IN_PROGRESS_ERR:
//
// failed, get the irp back off the queue if possible
//
pIrp=GetIrpOnConnIrpList(pConn);
if (pIrp != NULL) {
//
// we got it back, attempt to retry the connection
//
RetryConnection(pConn, pIrp);
}
break;
default:
DEBUGMSG(DBG_ERROR, ("IRDA: IRLMP_CONNECT_REQ failed %d\n", rc));
//
// failed, get the irp back off the queue if possible
//
pIrp=GetIrpOnConnIrpList(pConn);
if (pIrp != NULL) {
pIrp->IoStatus.Status=ConnectRcToNtStatus(rc);
IoCompleteRequest(pIrp,IO_NO_INCREMENT);
}
break;
}
return STATUS_PENDING;
}
UINT
SendIasQuery(PIRP pIrp, PIO_STACK_LOCATION pIrpSp)
{
IRDA_MSG IMsg;
if ((UINT_PTR) pIrpSp->FileObject->FsContext2 == TDI_CONNECTION_FILE)
{
// connection object querying remote IAS for LsapSel
PTDI_CONNECTION_INFORMATION pReqConnInfo;
PTDI_REQUEST_KERNEL_CONNECT pTdiParmsConn;
PTRANSPORT_ADDRESS pTranAddr;
PTDI_ADDRESS_IRDA pIrdaAddr;
PIRDA_CONN_OBJ pConn = pIrpSp->FileObject->FsContext;
if (!ValidConnectObject(pConn))
{
return 1;
}
CTEAssert(IS_VALID_CONN(pConn));
pTdiParmsConn = (PTDI_REQUEST_KERNEL_CONNECT) &(pIrpSp->Parameters);
pReqConnInfo = pTdiParmsConn->RequestConnectionInformation;
pTranAddr = (PTRANSPORT_ADDRESS) pReqConnInfo->RemoteAddress;
pIrdaAddr = (PTDI_ADDRESS_IRDA) pTranAddr->Address[0].Address;
RtlCopyMemory(pvIasQuery->irdaDeviceID,
pIrdaAddr->irdaDeviceID,
IRDA_DEV_ADDR_LEN);
strcpy(pvIasQuery->irdaClassName, pIrdaAddr->irdaServiceName);
if (pConn->pAddr->UseIrlptMode)
{
// I can't beleive this crap
if (pConn->pAddr->UseIrlptMode == IRLPT_MODE1)
{
strcpy(pvIasQuery->irdaAttribName, IasAttribName_IrLMPLsapSel);
pConn->pAddr->UseIrlptMode = IRLPT_MODE2;
}
else
{
strcpy(pvIasQuery->irdaAttribName, IasAttribName_IrLMPLsapSel2);
pConn->pAddr->UseIrlptMode = IRLPT_MODE1;
}
}
else
{
strcpy(pvIasQuery->irdaAttribName, IasAttribName_TTPLsapSel);
}
pvIasQuery->irdaAttribType = 0; // development purposes only
}
else
{
// A getsockopt(IRLMP_IAS_QUERY)
IAS_QUERY *pIasQuery = pIrp->AssociatedIrp.SystemBuffer;
CTEAssert(pIrpSp->FileObject->FsContext2 == (PVOID) TDI_CONTROL_CHANNEL_FILE);
if (pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(IAS_QUERY))
{
return 1;
}
RtlCopyMemory(pvIasQuery->irdaDeviceID,
pIasQuery->irdaDeviceID,
IRDA_DEV_ADDR_LEN);
strncpy(pvIasQuery->irdaClassName, pIasQuery->irdaClassName, IAS_MAX_CLASSNAME);
strncpy(pvIasQuery->irdaAttribName, pIasQuery->irdaAttribName, IAS_MAX_ATTRIBNAME);
}
IMsg.Prim = IRLMP_GETVALUEBYCLASS_REQ;
IMsg.IRDA_MSG_pIasQuery = pvIasQuery;
IMsg.IRDA_MSG_AttribLen = sizeof(IasBuf) - sizeof(IAS_QUERY);
return IrlmpDown(NULL, &IMsg);
}
VOID
PendingIasRequestCallback(
struct CTEEvent *Event,
PVOID Arg)
{
CTELockHandle hLock;
UINT rc;
CTEGetLock(&IrdaLock, &hLock);
if (pIasIrp != NULL) // Is there an Ias query in progress?
{
CTEFreeLock(&IrdaLock, hLock);
return;
}
while (!IsListEmpty(&IasIrpList)) {
LIST_ENTRY *pListEntry;
PIRP Irp;
PVOID OldCancelRoutine;
pListEntry = RemoveHeadList(&IasIrpList);
Irp=CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
Irp->Tail.Overlay.ListEntry.Blink=NULL;
OldCancelRoutine=IoSetCancelRoutine(Irp,NULL);
if (OldCancelRoutine == NULL) {
//
// the irp is in the process of being canceled
//
Irp=NULL;
continue;
}
pIasIrp = Irp;
break;
}
if (pIasIrp == NULL) {
CTEFreeLock(&IrdaLock, hLock);
return;
}
CTEFreeLock(&IrdaLock, hLock);
rc = SendIasQuery(pIasIrp, IoGetCurrentIrpStackLocation(pIasIrp));
if (rc != SUCCESS)
{
IRDA_MSG IMsg;
// Make a fake GetValueByClass confirm
IMsg.Prim = IRLMP_GETVALUEBYCLASS_CONF;
IMsg.IRDA_MSG_IASStatus = IRLMP_IAS_FAILED;
IrlmpGetValueByClassConf(&IMsg);
}
}
NTSTATUS
InitiateIasQuery(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp,
PIRDA_CONN_OBJ pConn)
{
NTSTATUS Status;
CTELockHandle hLock;
UINT rc;
DEBUGMSG(DBG_TDI, ("IRDA: InitiateIasQuery() \n"));
CTEGetLock(&IrdaLock, &hLock);
// only can send 1 IAS query at a time
if (pIasIrp != NULL) {
PendIrp(&IasIrpList, pIrp, NULL, TRUE);
CTEFreeLock(&IrdaLock, hLock);
} else {
//
// now a current IAS irp
//
pIasIrp = pIrp;
IoMarkIrpPending(pIrp);
CTEFreeLock(&IrdaLock, hLock);
rc = SendIasQuery(pIrp, pIrpSp);
if (rc != SUCCESS) {
//
// failed,
//
Status = ConnectRcToNtStatus(rc);
DEBUGMSG(DBG_ERROR,
("IRDA: IRLMP_GETVALUEBYCLASS_REQ failed, rc %d\n",
rc));
CTEGetLock(&IrdaLock, &hLock);
if ((pIasIrp != NULL) && (pIasIrp == pIrp)) {
pIasIrp = NULL;
// Retry the the connection if this query is for a
// connection setup and the query failed because
// the peer was discovering us
if (!pConn) {
//
// not a connection attempt
//
CTEFreeLock(&IrdaLock, hLock);
pIrp->IoStatus.Status=Status;
IoCompleteRequest(pIrp,IO_NO_INCREMENT);
#if DBG
pIrp=NULL;
#endif
CTEGetLock(&IrdaLock, &hLock);
} else {
if (rc == IRLAP_REMOTE_DISCOVERY_IN_PROGRESS_ERR) {
//
// retry, the irp will either be put on a queue for later processing or
// complete if the retry count has been exceeded
//
CTEFreeLock(&IrdaLock, hLock);
RetryConnection(pConn, pIrp);
} else {
//
// failed for some other reason, just complete
//
CTEFreeLock(&IrdaLock, hLock);
pIrp->IoStatus.Status=Status;
IoCompleteRequest(pIrp,IO_NO_INCREMENT);
#if DBG
pIrp=NULL;
#endif
CTEGetLock(&IrdaLock, &hLock);
}
}
} else {
ASSERT(0);
}
if (!IsListEmpty(&IasIrpList))
{
if (CTEScheduleEvent(&PendingIasEvent, NULL) == FALSE)
{
CTEAssert(0);
}
}
CTEFreeLock(&IrdaLock, hLock);
}
}
return STATUS_PENDING;
}
VOID
IndicateDisconnect(
PIRDA_CONN_OBJ pConn,
ULONG DisconnectFlags)
{
if (pConn->pAddr->pEventDisconnect != NULL) {
if (pConn->pAddr->pEventDisconnect(
pConn->pAddr->pEventDisconnectContext,
pConn->ClientContext, 0, NULL, 0, NULL,
DisconnectFlags) != STATUS_SUCCESS)
{
DEBUGMSG(DBG_ERROR, (" EventDisconnect() failed\r\n"));
ASSERT(0);
}
}
if (DisconnectFlags == TDI_DISCONNECT_ABORT)
{
DEBUGMSG(DBG_TDI, ("IRDA: pConn:%p, indicated abortive disconnect to client %p\n",
pConn, pConn->ClientContext));
TdiDisconnect(NULL, NULL, pConn);
}
else
{
DEBUGMSG(DBG_TDI, ("IRDA: pConn:%p, indicated graceful disconnect to client %p\n",
pConn, pConn->ClientContext));
}
}
NTSTATUS
TdiConnect(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
PTDI_CONNECTION_INFORMATION pReqConnInfo, pRetConnInfo;
PTDI_REQUEST_KERNEL_CONNECT pTdiParmsConn;
PIRDA_CONN_OBJ pConn = pIrpSp->FileObject->FsContext;
PTRANSPORT_ADDRESS pTranAddr;
PTDI_ADDRESS_IRDA pIrdaAddr;
NTSTATUS Status;
int RemLsapSel;
CTEAssert((UINT_PTR) pIrpSp->FileObject->FsContext2 == TDI_CONNECTION_FILE);
CTEAssert(IS_VALID_CONN(pConn));
CTEAssert(pConn->ConnState == IRDA_CONN_CREATED ||
pConn->ConnState == IRDA_CONN_OPENING);
pTdiParmsConn = (PTDI_REQUEST_KERNEL_CONNECT) &(pIrpSp->Parameters);
pReqConnInfo = pTdiParmsConn->RequestConnectionInformation;
pTranAddr = (PTRANSPORT_ADDRESS) pReqConnInfo->RemoteAddress;
pIrdaAddr = (PTDI_ADDRESS_IRDA) pTranAddr->Address[0].Address;
CTEAssert(pTranAddr->TAAddressCount == 1);
// Will either complete the Irp now with one of the following errors:
// (see InitiateConnection/InitiateIasQuery)
//
// LsapSel already in use or link in exclusive mode:
// WSAEADDRINUSE - STATUS_ADDRESS_ALREADY_EXISTS
// Link in use:
// WSAEACCESS - STATUS_ACCESS_DENIED
// Unspecified error:
// WSAECONNABORTED - STATUS_CONNECTION_ABORTED
// Request to device that is not in Irlmp's discovery list
// WSAEADDRNOTAVAIL - STATUS_INVALID_ADDRESS_COMPONENT
// Blank service name:
// WASEAFAULT - STATUS_ACCESS_VIOLATION
//
// or pend the irp and complete with (see CompleteConnection):
//
// Connect request to disconnected LSAP:
// WSAECONNREFUSED - STATUS_CONNECTION_REFUSED
// Mac media busy or remote discovery in progress &
// Remote Lsap respsonse timeout:
// WSAETIMEDOUT
// Unspecified error:
// WSAECONNABORTED - STATUS_CONNECTION_ABORTED
DEBUGMSG(DBG_TDI, ("IRDA: TdiConnect(retry:%d) ConnObj:%p to Dev:%02X%02X%02X%02X Service:%s\n",
pConn->RetryConnCount, pConn,
pIrdaAddr->irdaDeviceID[0],
pIrdaAddr->irdaDeviceID[1],
pIrdaAddr->irdaDeviceID[2],
pIrdaAddr->irdaDeviceID[3],
pIrdaAddr->irdaServiceName));
// Two ways to connect to remote:
// 1. Directly to remote LsapSel - remote address is of the form
// "LSAP-SELx" where x is the remote LsapSel. Initiate an
// IrLMP connection and pend the Irp on the ConnIrpList
// 2. To a remote service. Query the remote IAS database for the
// LsapSel of the given service. Pend the Irp on the IasIrpList.
// When the Ias query completes, initiate an IrLMP connection and
// pend the Irp on the ConnIrpList.
pConn->RetryConnCount += 1;
RtlCopyMemory(pConn->RemoteAddr.irdaDeviceID,
pIrdaAddr->irdaDeviceID, IRDA_DEV_ADDR_LEN);
strcpy(pConn->RemoteAddr.irdaServiceName,
pIrdaAddr->irdaServiceName);
pConn->ConnState = IRDA_CONN_OPENING;
if (pIrdaAddr->irdaServiceName[0] == 0)
{
Status = STATUS_ACCESS_VIOLATION;
}
else if (pConn->IsServer)
{
Status = STATUS_INVALID_DEVICE_REQUEST;
}
else if ((RemLsapSel =
GetLsapSelServiceName(pIrdaAddr->irdaServiceName)) != 0)
{
if (RemLsapSel == -1)
{
DEBUGMSG(DBG_TDI, ("IRDA: TdiConnect() failed, bad LsapSel in service name\n"));
Status = STATUS_INVALID_ADDRESS_COMPONENT;
}
else
{
pConn->RemoteLsapSel = RemLsapSel;
Status = InitiateConnection(pConn, pIrp);
}
}
else
{
Status = InitiateIasQuery(pIrp, pIrpSp, pConn);
}
if (Status != STATUS_PENDING)
{
pConn->ConnState = IRDA_CONN_CREATED;
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
}
return Status;
}
//*************************************************************************
//
// Irda's disconnect handler. If passed a connection object, then this is
// a disconnect generated internally by the stack. Otherwise called by
// client to disconnect peer.
// This isolates the cleanup code.
NTSTATUS
TdiDisconnect(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp,
PIRDA_CONN_OBJ pConn)
{
CTELockHandle hLock;
PTDI_REQUEST_KERNEL_DISCONNECT pReqDisc = NULL;
if (!pConn)
{
// AFD initated, connection object in the Irp
CTEAssert(pIrp);
pConn = pIrpSp->FileObject->FsContext;
pReqDisc = (PTDI_REQUEST_KERNEL_DISCONNECT) &pIrpSp->Parameters;
}
DEBUGMSG(DBG_TDI, ("IRDA: TdiDisconnect(%s) ConnObj:%p State %d Irlmp:%p\n",
pIrp ? "external":"internal", pConn, pConn->ConnState, pConn->IrlmpContext));
CTEAssert(IS_VALID_CONN(pConn));
GET_CONN_LOCK(pConn, &hLock);
ConnectionUp(pConn, FALSE);
while (!IsListEmpty(&pConn->RecvBufList))
{
LIST_ENTRY *pListEntry;
PIRDA_RECV_BUF pRecvBuf;
pListEntry = RemoveHeadList(&pConn->RecvBufList);
ASSERT(pListEntry);
pRecvBuf = CONTAINING_RECORD(pListEntry, IRDA_RECV_BUF, Linkage);
FreeIrdaBuf(RecvBufPool, pRecvBuf);
}
pConn->ConnState = IRDA_CONN_CREATED;
FREE_CONN_LOCK(pConn, hLock);
IrdaDisconnectIrlmp(pConn);
if (pIrp)
{
// Indicate the disconnect back to the client
// This is because we don't support half close.
// so AFD may hang the app if the app has done
// a shutdown(SD_SEND). Really, AFD should handle
// this correctly because I don't support
// TDI_SERVICE_ORDERLY_RELEASE. Vadim admits that
// AFD should handle this but he doesn't want to
// break legacy transports.
if (pConn->pAddr->pEventDisconnect != NULL) {
pConn->pAddr->pEventDisconnect(
pConn->pAddr->pEventDisconnectContext,
pConn->ClientContext, 0, NULL, 0, NULL,
TDI_DISCONNECT_ABORT);
}
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
}
return STATUS_SUCCESS;
}
NTSTATUS
TdiSend(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
PIRDA_CONN_OBJ pConn = pIrpSp->FileObject->FsContext;
CTELockHandle hLock;
NTSTATUS Status;
CTEAssert(((UINT_PTR) pIrpSp->FileObject->FsContext2) == TDI_CONNECTION_FILE);
CTEAssert(IS_VALID_CONN(pConn));
// IrLMP likes passive level only
if (KeGetCurrentIrql() >= DISPATCH_LEVEL)
{
DEBUGMSG(DBG_TDI, ("IRDA: TdiSend() at DISPATCH_LEVEL\n"));
GET_CONN_LOCK(pConn, &hLock);
PendIrp(&pConn->SendIrpPassiveList, pIrp, pConn, TRUE);
#if DBG
pIrp=NULL;
#endif
Status=STATUS_PENDING;
if (CTEScheduleEvent(&pConn->SendEvent, pConn) == FALSE) {
LIST_ENTRY *pListEntry;
pListEntry = RemoveHeadList(&pConn->SendIrpPassiveList);
pIrp = CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
if (IoSetCancelRoutine(pIrp, NULL) == NULL) {
//
// Cancel routine is going to run. Mark Irp so cancel
// routine won't attempt to remove it from the list
//
pIrp->Tail.Overlay.ListEntry.Flink = NULL;
} else {
pIrp->IoStatus.Status=STATUS_UNEXPECTED_NETWORK_ERROR;
FREE_CONN_LOCK(pConn, hLock);
IoCompleteRequest(pIrp,IO_NO_INCREMENT);
#if DBG
pIrp=NULL;
#endif
GET_CONN_LOCK(pConn, &hLock);
}
ASSERT(0);
}
FREE_CONN_LOCK(pConn, hLock);
if (Status != STATUS_PENDING)
{
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = Status;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
}
return Status;
}
else
{
return TdiSendAtPassive(pIrp, pIrpSp);
}
}
VOID
TdiSendAtPassiveCallback(struct CTEEvent *Event, PVOID Arg)
{
PIRDA_CONN_OBJ pConn = Arg;
CTELockHandle hLock;
LIST_ENTRY *pListEntry;
PIRP pIrp;
CTEAssert(IS_VALID_CONN(pConn));
GET_CONN_LOCK(pConn, &hLock);
while (!IsListEmpty(&pConn->SendIrpPassiveList))
{
pListEntry = RemoveHeadList(&pConn->SendIrpPassiveList);
ASSERT(pListEntry);
pIrp = CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
if (IoSetCancelRoutine(pIrp, NULL) == NULL)
{
// Cancel routine is going to run. Mark Irp so cancel
// routine won't attempt to remove it from the list
pIrp->Tail.Overlay.ListEntry.Flink = NULL;
CTEFreeLock(&IrdaLock, hLock);
continue;
}
FREE_CONN_LOCK(pConn, hLock);
TdiSendAtPassive(pIrp, IoGetCurrentIrpStackLocation(pIrp));
GET_CONN_LOCK(pConn, &hLock);
}
FREE_CONN_LOCK(pConn, hLock);
}
NTSTATUS
TdiSendAtPassive(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
PTDI_REQUEST_KERNEL_SEND pSendParms = (PTDI_REQUEST_KERNEL_SEND) &pIrpSp->Parameters;
PIRDA_CONN_OBJ pConn = pIrpSp->FileObject->FsContext;
NTSTATUS Status;
IRDA_MSG *pMsg;
CTEAssert(((UINT_PTR) pIrpSp->FileObject->FsContext2) == TDI_CONNECTION_FILE);
CTEAssert(IS_VALID_CONN(pConn));
if (pConn->pAddr->UseIrlptMode &&
pSendParms->SendLength > (ULONG)pConn->SendMaxSDU)
{
DEBUGMSG(DBG_ERROR, ("IRDA: TdiSend() error buffer overflow, max %d\n",
pConn->SendMaxSDU));
Status = STATUS_BUFFER_OVERFLOW;
}
else if (!pSendParms->SendLength)
{
DEBUGMSG(DBG_ERROR, ("IRDA: TdiSend() length of 0\n"));
Status = STATUS_SUCCESS;
}
else if (pConn->ConnState != IRDA_CONN_OPEN)
{
DEBUGMSG(DBG_TDI, ("IRDA: TdiSend() ConnObj:%p error conn reset\n",
pConn));
Status = STATUS_CONNECTION_RESET; //STATUS_CONNECTION_ABORTED;
if (pConn->ConnState == IRDA_CONN_CLOSING)
{
DEBUGMSG(DBG_ERROR, ("IRDA: Send after indicated disconnect, indicate abortive disconnect\n"));
// We've indicated a graceful disconnect to AFD, but AFD
// was in the middle of sending. Because Irda doesn't support
// graceful closes, we have to now indicate an abortive
// disconnect to AFD.
IndicateDisconnect(pConn, TDI_DISCONNECT_ABORT);
}
}
else if ((pMsg = AllocIrdaBuf(IrdaMsgPool)) == NULL)
{
DEBUGMSG(DBG_TDI, ("IRDA: TdiSend() ConnObj:%p returning STATUS_INSUFFICIENT_RESOURCES\n",
pConn));
Status = STATUS_INSUFFICIENT_RESOURCES;
}
else
{
UINT rc;
CTELockHandle hLock;
// We can't allow the cancelling of send IRPs because
// the stack may have passed ownership of the MDL contained
// in this IRP to the NDIS driver.
GET_CONN_LOCK(pConn, &hLock);
InsertTailList(&pConn->SendIrpList, &pIrp->Tail.Overlay.ListEntry);
IoMarkIrpPending(pIrp);
FREE_CONN_LOCK(pConn, hLock);
Status = STATUS_PENDING;
pIrp->IoStatus.Information = pSendParms->SendLength;
DEBUGMSG(DBG_TDI, ("IRDA: TdiSend() ConnObj:%p %d bytes, pend Irp:%p\n",
pConn, pSendParms->SendLength, pIrp));
pMsg->Prim = IRLMP_DATA_REQ;
pMsg->DataContext = pIrp->MdlAddress;
pMsg->IRDA_MSG_pTdiSendCompCnxt = pIrp;
pMsg->IRDA_MSG_IrCOMM_9Wire = pConn->pAddr->Use9WireMode;
if ((rc = IrlmpDown(pConn->IrlmpContext, pMsg)) != SUCCESS)
{
DEBUGMSG(DBG_ERROR, ("IRDA: IRLMP_DATA_REQ failed %d\n", rc));
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = STATUS_CONNECTION_RESET;
GET_CONN_LOCK(pConn, &hLock);
RemoveEntryList(&pIrp->Tail.Overlay.ListEntry);
FREE_CONN_LOCK(pConn, hLock);
//
// complete it now
//
IoCompleteRequest(pIrp,IO_NO_INCREMENT);
pIrp=NULL;
FreeIrdaBuf(IrdaMsgPool, pMsg);
}
return STATUS_PENDING;
}
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = Status;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
return Status;
}
//*************************************************************************
//
// Irda's receive handler. Called to resume receiving of data after AFD
// or client has stopped taking indicated data (see IrlmpDataInd).
// Data will have been buffered on the connection's RecvBufList.
//
NTSTATUS
TdiReceive(
PIRP pIrp,
PIO_STACK_LOCATION pIrpSp)
{
PTDI_REQUEST_KERNEL_RECEIVE pRecvReq;
PIRDA_CONN_OBJ pConn = pIrpSp->FileObject->FsContext;
ULONG BytesTaken = 0;
CTELockHandle hLock;
PIRDA_RECV_BUF pRecvBuf;
LIST_ENTRY *pListEntry, *pListEntryNext;
NTSTATUS Status= STATUS_SUCCESS;
PIRDA_ADDR_OBJ pAddr;
DEBUGMSG(DBG_TDI, ("IRDA: TdiReceive() ConnObj:%p. credits=%d\n", pConn, pConn->TtpRecvCreditsLeft));
CTEAssert(IS_VALID_CONN(pConn));
pAddr = pConn->pAddr;
CTEAssert(IS_VALID_ADDR(pAddr));
GET_CONN_LOCK(pConn, &hLock);
pRecvReq = (PTDI_REQUEST_KERNEL_RECEIVE) &(pIrpSp->Parameters);
if (!IsListEmpty(&pConn->RecvBufList)) {
//
// the list is not empty
//
pListEntry = RemoveHeadList(&pConn->RecvBufList);
pRecvBuf = CONTAINING_RECORD(pListEntry, IRDA_RECV_BUF, Linkage);
//
// copy what we can
//
Status=TdiCopyBufferToMdl(&pRecvBuf->Data[0],
pRecvBuf->Offset,
pRecvBuf->Len,
pIrp->MdlAddress,
0,
&BytesTaken
);
if (Status != STATUS_SUCCESS) {
//
// some sort of problem
//
if (Status == STATUS_BUFFER_OVERFLOW) {
//
// the irp could no hold all the data, need to adjust the recvbuf
// values to indace what is left
//
pRecvBuf->Len -= BytesTaken;
pRecvBuf->Offset += BytesTaken;
//
// need to put it back on the list
//
InsertHeadList(&pConn->RecvBufList, pListEntry);
DEBUGMSG(DBG_TDI, (" RecvBuf copied only %d of %d\n",
BytesTaken, pRecvBuf->Len));
} else {
//
// could not get a system address for the mdl, just return the status
//
InsertHeadList(&pConn->RecvBufList, pListEntry);
BytesTaken=0;
DEBUGMSG(DBG_TDI, (" RecvBuf could not map MDL\n"));
}
} else {
//
// copied it all
//
DEBUGMSG(DBG_TDI, (" RecvBuf %p copied all %d\n", pRecvBuf, BytesTaken));
}
FREE_CONN_LOCK(pConn, hLock);
pIrp->IoStatus.Information = BytesTaken;
pIrp->IoStatus.Status = Status;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
pIrp=NULL;
GET_CONN_LOCK(pConn, &hLock);
}
else
{
DEBUGMSG(DBG_ERROR, ("IRDA: Pending TDI_RECEIVE Irp %p\n", pIrp));
PendIrp(&pConn->RecvIrpList, pIrp, pConn, TRUE);
pIrp=NULL;
Status=STATUS_PENDING;
FREE_CONN_LOCK(pConn, hLock);
return Status;
}
// Still more buffered data, indicate to client through EventReceive handler
while (!(IsListEmpty(&pConn->RecvBufList)) && Status != STATUS_DATA_NOT_ACCEPTED)
{
pListEntry = RemoveHeadList(&pConn->RecvBufList);
FREE_CONN_LOCK(pConn, hLock);
pRecvBuf = CONTAINING_RECORD(pListEntry, IRDA_RECV_BUF, Linkage);
Status = pAddr->pEventReceive(
pAddr->pEventReceiveContext,
pConn->ClientContext,
TDI_RECEIVE_NORMAL | \
(pRecvBuf->FinalSeg ? TDI_RECEIVE_ENTIRE_MESSAGE : 0),
pRecvBuf->Len,
pRecvBuf->Len,
&BytesTaken,
&pRecvBuf->Data[pRecvBuf->Offset],
&pIrp);
DEBUGMSG(DBG_TDI, (" Next RecvBuf %p, indicated %d\n",
pRecvBuf, pRecvBuf->Len));
switch (Status)
{
case STATUS_MORE_PROCESSING_REQUIRED:
CTEAssert(BytesTaken == 0);
CTEAssert(pIrp);
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
pRecvReq = (PTDI_REQUEST_KERNEL_RECEIVE) &pIrpSp->Parameters;
CTEAssert(pRecvReq->ReceiveLength >= pRecvBuf->Len);
TdiCopyBufferToMdl(
&pRecvBuf->Data[pRecvBuf->Offset],
0,
pRecvBuf->Len,
pIrp->MdlAddress,
0,
&BytesTaken);
pIrp->IoStatus.Status = STATUS_SUCCESS;
pIrp->IoStatus.Information = BytesTaken;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
// fall through
case STATUS_SUCCESS:
CTEAssert(BytesTaken == pRecvBuf->Len);
FreeIrdaBuf(RecvBufPool, pRecvBuf);
DEBUGMSG(DBG_TDI, (" RecvBuf copied %d\n", BytesTaken));
break;
case STATUS_DATA_NOT_ACCEPTED:
CTEAssert(BytesTaken == 0);
DEBUGMSG(DBG_TDI, (" No bytes taken\n"));
GET_CONN_LOCK(pConn, &hLock);
InsertHeadList(&pConn->RecvBufList, pListEntry);
FREE_CONN_LOCK(pConn, hLock);
break;
default:
CTEAssert(0);
}
GET_CONN_LOCK(pConn, &hLock);
}
// Has the client taken all buffered data?
if (IsListEmpty(&pConn->RecvBufList))
{
CTEAssert(pConn->RecvBusy)
pConn->RecvBusy = FALSE;
if (pConn->ConnState == IRDA_CONN_OPEN)
{
// Start up peer again
if (pConn->TtpRecvCreditsLeft <= TTP_CREDIT_ADVANCE_THRESH)
{
IRDA_MSG IMsg;
int CreditsLeft;
CreditsLeft = pConn->TtpRecvCreditsLeft;
pConn->TtpRecvCreditsLeft = TTP_RECV_CREDITS;
FREE_CONN_LOCK(pConn, hLock);
IMsg.Prim = IRLMP_MORECREDIT_REQ;
IMsg.IRDA_MSG_TtpCredits = TTP_RECV_CREDITS - CreditsLeft;
#if DBG
pConn->CreditsExtended += (TTP_RECV_CREDITS - CreditsLeft);
#endif
IrlmpDown(pConn->IrlmpContext, &IMsg);
return STATUS_SUCCESS;
}
}
else if (pConn->ConnState == IRDA_CONN_CLOSING)
{
ULONG DiscFlags = TDI_DISCONNECT_RELEASE;
if (!IsListEmpty(&pConn->SendIrpList))
{
DEBUGMSG(DBG_TDI, (" SendIrpList not empty, indicate abortive disconnect\n"));
DiscFlags = TDI_DISCONNECT_ABORT;
}
FREE_CONN_LOCK(pConn, hLock);
// all buffer data has been delivered for the connection
// that has was previously disconnected by the peer. Notify client
// of the disconnect
IndicateDisconnect(pConn, DiscFlags);
return STATUS_SUCCESS;
}
}
FREE_CONN_LOCK(pConn, hLock);
return STATUS_SUCCESS;
}
ULONG
GetMdlChainByteCount(
PMDL pMdl)
{
ULONG Count = 0;
while (pMdl != NULL)
{
Count += MmGetMdlByteCount(pMdl);
pMdl = pMdl->Next;
}
return(Count);
}
//*************************************************************************
//
// Copy discovered device information from internal buffer to
// user buffer in Winsock format (extracting hints and characters
// set)
//
VOID
CopyDevToDevInfo(PIRDA_DEVICE_INFO pDevInfo, IRDA_DEVICE *pDevice)
{
BOOLEAN GotHint1 = FALSE;
BOOLEAN GotHint2 = FALSE;
BOOLEAN GotChar = FALSE;
BOOLEAN MoreHints = FALSE;
int i, j;
RtlCopyMemory(pDevInfo->irdaDeviceID,pDevice->DevAddr, IRDA_DEV_ADDR_LEN);
CTEMemSet(pDevInfo->irdaDeviceName, 0, sizeof(pDevInfo->irdaDeviceName));
pDevInfo->irdaDeviceHints1 = 0;
pDevInfo->irdaDeviceHints2 = 0;
pDevInfo->irdaCharSet = 0;
j = 0;
for (i = 0; i < pDevice->DscvInfoLen; i++)
{
if (GotHint1 == FALSE)
{
GotHint1 = TRUE;
pDevInfo->irdaDeviceHints1 = pDevice->DscvInfo[i];
if ((pDevInfo->irdaDeviceHints1) & 0x80)
MoreHints = TRUE;
continue;
}
if (GotHint2 == FALSE && MoreHints)
{
GotHint2 = TRUE;
pDevInfo->irdaDeviceHints2 = pDevice->DscvInfo[i];
if ((pDevInfo->irdaDeviceHints2) & 0x80)
MoreHints = TRUE;
else
MoreHints = FALSE;
continue;
}
if (MoreHints)
{
if ((pDevice->DscvInfo[i]) & 0x80)
MoreHints = TRUE;
else
MoreHints = FALSE;
continue;
}
if (GotChar == FALSE)
{
GotChar = TRUE;
pDevInfo->irdaCharSet = pDevice->DscvInfo[i];
continue;
}
pDevInfo->irdaDeviceName[j++] = pDevice->DscvInfo[i];
if (j > sizeof(pDevInfo->irdaDeviceName))
break;
}
}
//*************************************************************************
//
// Run through the ConnIrpList and find the Irp associated with the
// given connection object
//
PIRP
GetIrpOnConnIrpList(PIRDA_CONN_OBJ pConn)
{
PIRDA_CONN_OBJ pConnOnList;
CTELockHandle hLock;
PIO_STACK_LOCATION pIrpSp;
LIST_ENTRY *pListEntry;
PIRP pIrp = NULL;
CTEGetLock(&IrdaLock, &hLock);
// Remove the connect irp from the ConnIrpList
for (pListEntry = ConnIrpList.Flink;
pListEntry != &ConnIrpList;
pListEntry = pListEntry->Flink)
{
pIrp = CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
pConnOnList = (PIRDA_CONN_OBJ) pIrpSp->FileObject->FsContext;
if (pConnOnList == pConn) {
break;
}
pIrp = NULL;
}
if (pIrp != NULL) {
//
// we got a irp
//
#if DBG
pIrp->IoStatus.Information=0;
#endif
if (IoSetCancelRoutine(pIrp, NULL) == NULL) {
// It was already cancelled or is in the process
DEBUGMSG(DBG_TDI, ("IRDA: Connect Irp not on list, must have been cancelled\n"));
pIrp=NULL;
} else {
RemoveEntryList(&pIrp->Tail.Overlay.ListEntry);
}
}
CTEFreeLock(&IrdaLock, hLock);
return pIrp;
}
//*************************************************************************
//
// TimerExpiration routine to retry a connection attempt do to
// remote discovery in progress
//
VOID
RetryConnTimerExp(PVOID Context)
{
PIRDA_CONN_OBJ pConn = Context;
PIRP pIrp;
DEBUGMSG(DBG_TDI, ("IRDA: RetryConnect timer expired\n"));
if (pIrp = GetIrpOnConnIrpList(pConn))
{
TdiConnect(pIrp, IoGetCurrentIrpStackLocation(pIrp));
}
REFDEL(&pConn->RefCnt, 'RMIT');
}
//************************************************************************
//
// RetryConnection if remote discovery in progress.
// Returns:
// STATUS_PENDING - a retry will be attempted. The Irp is placed on the
// ConnIrpList.
// STATUS_CANCELLED - the Irp could not be pended because it was cancelled
// STATUS_IO_TIMEOUT - no more retries left.
//
VOID
RetryConnection(PIRDA_CONN_OBJ pConn, PIRP pIrp)
{
CTELockHandle hLock;
NTSTATUS Status = STATUS_IO_TIMEOUT;
IoMarkIrpPending(pIrp);
if (pConn->RetryConnCount <= BUSY_LINK_CONN_RETRIES)
{
DEBUGMSG(DBG_TDI, ("IRDA: Media busy or remote dscv in progress, retry(%d) connection\n",
pConn->RetryConnCount));
IrdaDisconnectIrlmp(pConn);
#if DBG
pIrp->IoStatus.Information=2;
#endif
PendIrp(&ConnIrpList, pIrp, NULL, FALSE);
Status=STATUS_PENDING;
pConn->RetryConnTimer.Context = pConn;
REFADD(&pConn->RefCnt, 'RMIT');
IrdaTimerStart(&pConn->RetryConnTimer);
} else {
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
}
return;
}
//*************************************************************************
//
// Asyncronous completetion of a client connection request.
// This routine also completes a failed connection.
//
VOID
CompleteConnection(PIRDA_CONN_OBJ pConn, IRDA_MSG *pMsg)
{
PIRP pIrp;
BOOLEAN RetryConn = FALSE;
if ((pIrp = GetIrpOnConnIrpList(pConn)) == NULL)
{
DbgPrint("IRDA: CompleteConnection: could not find irp\n");
ASSERT(pIrp);
}
else
{
if (pMsg->Prim == IRLMP_DISCONNECT_IND)
{
pConn->ConnState = IRDA_CONN_CREATED;
switch (pMsg->IRDA_MSG_DiscReason)
{
case IRLMP_DISC_LSAP:
// WSAECONNREFUSED
pIrp->IoStatus.Status = STATUS_CONNECTION_REFUSED;
break;
case IRLMP_IRLAP_REMOTE_DISCOVERY_IN_PROGRESS:
case IRLMP_MAC_MEDIA_BUSY:
RetryConn = TRUE;
case IRLMP_IRLAP_CONN_FAILED:
case IRLMP_NO_RESPONSE_LSAP:
// WASETIMEDOUT
pIrp->IoStatus.Status = STATUS_IO_TIMEOUT;
break;
default:
// WSECONNABORTED
pIrp->IoStatus.Status = STATUS_CONNECTION_RESET; //STATUS_CONNECTION_ABORTED;
}
if (RetryConn) {
//
// the irp will be queued or complete, by this function
//
RetryConnection(pConn, pIrp);
return;
}
}
else // IRLMP_CONNECT_CONF
{
pConn->SendMaxSDU = pMsg->IRDA_MSG_MaxSDUSize;
pConn->SendMaxPDU = pMsg->IRDA_MSG_MaxPDUSize;
pConn->ConnState = IRDA_CONN_OPEN;
pIrp->IoStatus.Status = STATUS_SUCCESS;
DEBUGMSG(DBG_TDI, ("IRDA: Completing TdiConnect co:%p\n", pConn));
ConnectionUp(pConn, TRUE);
}
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
}
}
//*************************************************************************
//
//
//
VOID
CompleteDscvIrpList(LIST_ENTRY *pIrpList, IRDA_MSG *pMsg)
{
PIO_STACK_LOCATION pIrpSp;
PDEVICELIST pDevList;
PIRP pIrp;
LIST_ENTRY *pListEntry;
ULONG BytesWritten;
ULONG BufLen;
IRDA_DEVICE *pDevice;
ULONG DevCnt;
NTSTATUS Status;
CTELockHandle hLock;
CTEGetLock(&IrdaLock, &hLock);
while (!IsListEmpty(pIrpList)) {
pListEntry = RemoveHeadList(pIrpList);
pIrp = CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
if (IoSetCancelRoutine(pIrp, NULL) == NULL) {
//
// Cancel routine is going to run. Mark Irp so cancel
// routine won't attempt to remove it from the list
//
pIrp->Tail.Overlay.ListEntry.Flink = NULL;
} else {
//
// not canceled
//
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
pDevList = pIrp->AssociatedIrp.SystemBuffer;
BufLen = pIrpSp->Parameters.DeviceIoControl.OutputBufferLength;
if (BufLen < sizeof(IRDA_DEVICE_INFO))
{
DEBUGMSG(DBG_DISCOVERY, ("IRDA: IRLMP_DISCOVERY_REQ failed, buf too small\n"));
BytesWritten = 0;
Status = STATUS_BUFFER_TOO_SMALL;
}
else if (pMsg->IRDA_MSG_DscvStatus != IRLAP_DISCOVERY_COMPLETED)
{
DEBUGMSG(DBG_DISCOVERY, ("IRDA: IRLMP_DISCOVERY_REQ failed\n"));
BytesWritten = 0;
Status = STATUS_UNEXPECTED_NETWORK_ERROR;
}
else
{
//
// start with the device count at the begining of the list
//
BytesWritten = sizeof(pDevList->numDevice);
DevCnt = 0;
if (pMsg->IRDA_MSG_pDevList != NULL)
{
for (pDevice = (IRDA_DEVICE * ) pMsg->IRDA_MSG_pDevList->Flink;
(LIST_ENTRY *) pDevice != pMsg->IRDA_MSG_pDevList;
pDevice = (IRDA_DEVICE *) pDevice->Linkage.Flink)
{
if (BufLen < (BytesWritten + sizeof(IRDA_DEVICE_INFO)))
{
DEBUGMSG(DBG_ERROR, ("IRDA: Found more devices, but user buffer too small.\n"));
break;
}
CopyDevToDevInfo(&pDevList->Device[DevCnt], pDevice);
BytesWritten += sizeof(IRDA_DEVICE_INFO);
DevCnt++;
}
}
pDevList->numDevice = DevCnt;
Status = STATUS_SUCCESS;
}
CTEFreeLock(&IrdaLock, hLock);
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = BytesWritten;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
CTEGetLock(&IrdaLock, &hLock);
}
}
CTEFreeLock(&IrdaLock, hLock);
}
//*************************************************************************
//
// Process IRMLP_DISCOVERY_CONFIRM - Completes client discovery
// request Irp stored on DscvIrpList
//
VOID
IrlmpDiscoveryConf(IRDA_MSG *pMsg)
{
CTELockHandle hLock;
DEBUGMSG(DBG_DISCOVERY, ("IRDA: IRLMP_DISCOVERY_CONF\n"));
// Complete regular discovery Irp list
CompleteDscvIrpList(&DscvIrpList, pMsg);
CTEGetLock(&IrdaLock, &hLock);
// Complete lazy discoveries if device list has changed
if (!IsListEmpty(&LazyDscvIrpList))
{
IRDA_DEVICE *pDevice;
UINT CurrLazyDscvMacAddrs = 0;
// Lazy discovery Irps are completed if the newly discovered
// device list has changed since the last discovery.
// We determine that the device list has changed by storing
// the value of the Mac addresses added together from the
// last discovery
if (pMsg->IRDA_MSG_DscvStatus == IRLAP_DISCOVERY_COMPLETED)
{
for (pDevice = (IRDA_DEVICE * ) pMsg->IRDA_MSG_pDevList->Flink;
(LIST_ENTRY *) pDevice != pMsg->IRDA_MSG_pDevList;
pDevice = (IRDA_DEVICE *) pDevice->Linkage.Flink)
{
CurrLazyDscvMacAddrs += *(UINT*)pDevice->DevAddr;
}
if (CurrLazyDscvMacAddrs == LazyDscvMacAddrs)
{
CTEFreeLock(&IrdaLock, hLock);
return;
}
LazyDscvMacAddrs = CurrLazyDscvMacAddrs;
}
LazyDscvTimerRunning = FALSE;
CTEFreeLock(&IrdaLock, hLock);
IrdaTimerStop(&LazyDscvTimer);
CompleteDscvIrpList(&LazyDscvIrpList, pMsg);
CTEGetLock(&IrdaLock, &hLock);
}
CTEFreeLock(&IrdaLock, hLock);
}
//*************************************************************************
//
// Process IRLMP_CONNECT_IND. Call client connect handler if we find
// matching address object
//
VOID
IrlmpConnectInd(IRDA_MSG *pMsg)
{
PIRDA_ADDR_OBJ pAddr;
CTELockHandle hLock;
IRDA_MSG IMsg;
PIRDA_CONN_OBJ pConn;
BOOLEAN AcceptConnection = FALSE;
PIRP pAcceptIrp = NULL;
DEBUGMSG(DBG_TDI, ("IRDA: IRLMP_CONNECT_IND\n"));
// Get the LinkStatus immediately so we'll have the link speed
// when we indicate the incoming connection to RasIrda which
// immediately requests link speed through an ioctl.
IMsg.Prim = IRLAP_STATUS_REQ;
IMsg.IRDA_MSG_pLinkStatus = &LinkStatus;
IrlmpDown(pMsg->IRDA_MSG_pContext, &IMsg);
CTEGetLock(&IrdaLock, &hLock);
// Find the address object with LocalLsapSel that matches
// the one in the CONNECT_IND
for (pAddr = AddrObjList; pAddr != NULL; pAddr = pAddr->pNext)
{
if (pAddr->LocalLsapSel == pMsg->IRDA_MSG_LocalLsapSel)
break;
}
CTEFreeLock(&IrdaLock, hLock);
if (pAddr && pAddr->pEventConnect)
{
UCHAR RemAddrBuf[sizeof(TRANSPORT_ADDRESS) + sizeof(TDI_ADDRESS_IRDA)-1];
PTRANSPORT_ADDRESS pRemAddr = (PTRANSPORT_ADDRESS) RemAddrBuf;
PTDI_ADDRESS_IRDA pIrdaAddr = (PTDI_ADDRESS_IRDA) pRemAddr->Address[0].Address;
NTSTATUS Status;
CONNECTION_CONTEXT ClientContext;
pRemAddr->TAAddressCount = 1;
pRemAddr->Address[0].AddressLength = sizeof(SOCKADDR_IRDA) - 2;
pRemAddr->Address[0].AddressType = AF_IRDA;
RtlCopyMemory(pIrdaAddr->irdaDeviceID,
pMsg->IRDA_MSG_RemoteDevAddr,
IRDA_DEV_ADDR_LEN);
SetLsapSelAddr(pMsg->IRDA_MSG_RemoteLsapSel,
pIrdaAddr->irdaServiceName);
Status = pAddr->pEventConnect(
pAddr->pEventConnectContext,
sizeof(RemAddrBuf),
pRemAddr,
0, NULL, 0, NULL,
&ClientContext,
&pAcceptIrp);
if (Status != STATUS_MORE_PROCESSING_REQUIRED)
{
DEBUGMSG(DBG_ERROR, ("IRDA: EventConnect failed %X\n", Status));
}
else
{
ASSERT(pAcceptIrp);
CTEGetLock(&IrdaLock, &hLock);
for (pConn = pAddr->ConnObjList;
pConn != NULL;
pConn = pConn->pNext)
{
if (pConn->ClientContext == ClientContext)
break;
}
if (!pConn)
{
CTEAssert(0);
pAcceptIrp->IoStatus.Status = STATUS_INVALID_ADDRESS_COMPONENT;
CTEFreeLock(&IrdaLock, hLock);
IoCompleteRequest (pAcceptIrp, IO_NETWORK_INCREMENT);
}
else
{
ASSERT(pConn->ConnState == IRDA_CONN_CREATED);
pConn->ConnState = IRDA_CONN_OPEN;
pConn->RemoteLsapSel = pMsg->IRDA_MSG_RemoteLsapSel;
pConn->SendMaxSDU = pMsg->IRDA_MSG_MaxSDUSize;
pConn->SendMaxPDU = pMsg->IRDA_MSG_MaxPDUSize;
pConn->IrlmpContext = pMsg->IRDA_MSG_pContext;
pConn->TtpRecvCreditsLeft = TTP_RECV_CREDITS;
/* IRDA_MSG_pQOS ignored */
RtlCopyMemory(&pConn->RemoteAddr,
pIrdaAddr, sizeof(TDI_ADDRESS_IRDA));
pAcceptIrp->IoStatus.Status = STATUS_SUCCESS;
CTEFreeLock(&IrdaLock, hLock);
IoCompleteRequest (pAcceptIrp, IO_NETWORK_INCREMENT);
DEBUGMSG(DBG_TDI, (" ConnObj:%p connected, Loc:%s,%d Rem:%s,%d\n",
pConn,
pConn->LocalAddr.irdaServiceName,
pConn->LocalLsapSel,
pConn->RemoteAddr.irdaServiceName,
pConn->RemoteLsapSel));
AcceptConnection = TRUE;
}
}
}
if (AcceptConnection)
{
IMsg.Prim = IRLMP_CONNECT_RESP;
IMsg.IRDA_MSG_pConnData = NULL;
IMsg.IRDA_MSG_ConnDataLen = 0;
IMsg.IRDA_MSG_pContext = pConn;
IMsg.IRDA_MSG_MaxSDUSize = TTP_RECV_MAX_SDU;
IMsg.IRDA_MSG_TtpCredits = TTP_RECV_CREDITS;
#if DBG
pConn->CreditsExtended += TTP_RECV_CREDITS;
#endif
ConnectionUp(pConn, TRUE);
}
else
{
DEBUGMSG(DBG_TDI, (" declining connection\n"));
IMsg.Prim = IRLMP_DISCONNECT_REQ;
IMsg.IRDA_MSG_pDiscData = NULL;
IMsg.IRDA_MSG_DiscDataLen = 0;
}
IrlmpDown(pMsg->IRDA_MSG_pContext, &IMsg);
}
VOID
IrlmpDisconnectInd(PIRDA_CONN_OBJ pConn, IRDA_MSG *pMsg)
{
CTELockHandle hLock;
DEBUGMSG(DBG_TDI, ("IRDA: IRLMP_DISCONNECT_IND ConnObj:%p (Irlmp:%p)\n", pConn,
pConn->IrlmpContext));
switch (pConn->ConnState)
{
case IRDA_CONN_CLOSING:
case IRDA_CONN_CREATED:
break;
case IRDA_CONN_OPENING:
{
CompleteConnection(pConn, pMsg);
break;
}
case IRDA_CONN_OPEN:
{
ULONG DiscFlags;
if (pMsg->IRDA_MSG_DiscReason == IRLMP_USER_REQUEST)
{
DEBUGMSG(DBG_TDI, (" ConnObj:%p graceful disconnect\n",
pConn));
DiscFlags = TDI_DISCONNECT_RELEASE;
}
else
{
DEBUGMSG(DBG_TDI, (" ConnObj:%p abortive disconnect\n",
pConn));
DiscFlags = TDI_DISCONNECT_ABORT;
}
GET_CONN_LOCK(pConn, &hLock);
pConn->ConnState = IRDA_CONN_CLOSING;
if (IsListEmpty(&pConn->RecvBufList) ||
DiscFlags == TDI_DISCONNECT_ABORT)
{
if (!IsListEmpty(&pConn->SendIrpList))
{
DEBUGMSG(DBG_TDI, (" SendIrpList not empty, indicate abortive disconnect\n"));
DiscFlags = TDI_DISCONNECT_ABORT;
}
FREE_CONN_LOCK(pConn, hLock);
IndicateDisconnect(pConn, DiscFlags);
}
else
{
DEBUGMSG(DBG_TDI, (" receive data has been buffered, not indicating disconnect to client\n"));
FREE_CONN_LOCK(pConn, hLock);
}
break;
}
default:
CTEAssert(0);
}
}
VOID
IrlmpConnectConf(PIRDA_CONN_OBJ pConn, IRDA_MSG *pMsg)
{
DEBUGMSG(DBG_TDI, ("IRDA: IRLMP_CONNECT_CONF ConnObj:%p\n",
pConn));
switch (pConn->ConnState)
{
case IRDA_CONN_CLOSING:
case IRDA_CONN_CREATED:
case IRDA_CONN_OPEN:
CTEAssert(0);
break;
case IRDA_CONN_OPENING:
CompleteConnection(pConn, pMsg);
break;
}
}
VOID
IrlmpGetValueByClassConf(IRDA_MSG *pMsg)
{
CTELockHandle hLock;
LIST_ENTRY *pListEntry;
UINT rc;
BOOLEAN RetryConn = FALSE;
DEBUGMSG(DBG_TDI, ("IRDA: IRLMP_GETVALUEBYCLASS_CONF\n"));
CTEGetLock(&IrdaLock, &hLock);
if (pIasIrp != NULL) {
PIRP pIrp;
PIO_STACK_LOCATION pIrpSp;
NTSTATUS Status = STATUS_CONNECTION_REFUSED;
pIrp = pIasIrp;
pIasIrp = NULL;
CTEFreeLock(&IrdaLock, hLock);
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
// getsockopt IAS query on connection object??
// I think not, helper will open a control channel.
// i.e. I am making the assumption that this IAS response is
// from a LsapSel value query and a connection will now
// be initiated
if ((UINT_PTR)pIrpSp->FileObject->FsContext2 == TDI_CONNECTION_FILE) {
PIRDA_CONN_OBJ pConn = pIrpSp->FileObject->FsContext;
CTEAssert(IS_VALID_CONN(pConn));
if (pConn->ConnState != IRDA_CONN_OPENING) {
Status = STATUS_CONNECTION_ABORTED;
} else {
if (pMsg->IRDA_MSG_IASStatus != IRLMP_IAS_SUCCESS &&
pMsg->IRDA_MSG_IASStatus != IRLMP_IAS_SUCCESS_LISTLEN_GREATER_THAN_ONE) {
DEBUGMSG(DBG_TDI, ("IRDA: IAS Query failed %d\n",
pMsg->IRDA_MSG_IASStatus));
if (pMsg->IRDA_MSG_IASStatus < IRLMP_IAS_NO_SUCH_OBJECT) {
Status = STATUS_IO_TIMEOUT;
}
if (pMsg->IRDA_MSG_IASStatus == IRLMP_MAC_MEDIA_BUSY ||
pMsg->IRDA_MSG_IASStatus == IRLMP_IRLAP_REMOTE_DISCOVERY_IN_PROGRESS) {
RetryConn = TRUE;
} else {
if (pConn->pAddr->UseIrlptMode == IRLPT_MODE2) {
//
// I just can't beleive this crap
// Try querying for "LSAPSel" rather than "LsapSel"
//
Status = InitiateIasQuery(pIrp, pIrpSp, pConn);
}
}
} else {
//
// it worked
//
if (pMsg->IRDA_MSG_pIasQuery->irdaAttribType != IAS_ATTRIB_VAL_INTEGER) {
CTEAssert(0);
} else {
//
// we got the lsap, proceed with the connection
//
pConn->RemoteLsapSel = pMsg->IRDA_MSG_pIasQuery->irdaAttribute.irdaAttribInt;
Status = InitiateConnection(pConn, pIrp);
}
}
if (Status != STATUS_PENDING) {
// failing the connection
pConn->ConnState = IRDA_CONN_CREATED;
if (RetryConn) {
//
// the irp will queue or completed, by this function
//
RetryConnection(pConn, pIrp);
pIrp=NULL;
} else {
//
// the request failed
//
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
}
}
}
} else {
//
// control file object
//
IAS_QUERY *pIasQuery = pIrp->AssociatedIrp.SystemBuffer;
ULONG ResultLen = sizeof(IAS_QUERY);
Status = STATUS_SUCCESS;
if (pMsg->IRDA_MSG_IASStatus != IRLMP_IAS_SUCCESS &&
pMsg->IRDA_MSG_IASStatus != IRLMP_IAS_SUCCESS_LISTLEN_GREATER_THAN_ONE) {
DEBUGMSG(DBG_TDI, ("IRDA: IAS Query failed %d\n",
pMsg->IRDA_MSG_IASStatus));
if (pMsg->IRDA_MSG_IASStatus < IRLMP_IAS_NO_SUCH_OBJECT) {
Status = STATUS_IO_TIMEOUT;
} else {
Status = STATUS_CONNECTION_REFUSED;
}
ResultLen = 0;
} else {
RtlCopyMemory(pIasQuery, pvIasQuery, sizeof(IAS_QUERY));
}
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = ResultLen;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
}
} else {
ASSERT(pIasIrp != NULL);
CTEFreeLock(&IrdaLock, hLock);
}
CTEGetLock(&IrdaLock, &hLock);
// Start the next Ias query if one is on the list and
// there is not one in progress
if (!IsListEmpty(&IasIrpList) && pIasIrp == NULL)
{
if (CTEScheduleEvent(&PendingIasEvent, NULL) == FALSE)
{
CTEAssert(0);
}
}
CTEFreeLock(&IrdaLock, hLock);
}
VOID
IrlmpDataConf(PIRDA_CONN_OBJ pConn, IRDA_MSG *pMsg)
{
CTELockHandle hLock;
LIST_ENTRY *pListEntry;
PIRP pIrp = NULL;
CTEAssert(IS_VALID_CONN(pConn));
// find the irp
GET_CONN_LOCK(pConn, &hLock);
// the desired irp should always be at the head of the list
// so this search will be short
for (pListEntry = pConn->SendIrpList.Flink;
pListEntry != &pConn->SendIrpList;
pListEntry = pListEntry->Flink)
{
pIrp = CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
if (pIrp == (PIRP) pMsg->IRDA_MSG_pTdiSendCompCnxt)
{
RemoveEntryList(pListEntry);
break;
}
pIrp = NULL;
}
FREE_CONN_LOCK(pConn, hLock);
if (pIrp)
{
NTSTATUS Status;
if (pMsg->IRDA_MSG_DataStatus == IRLMP_DATA_REQUEST_COMPLETED)
{
Status = STATUS_SUCCESS;
}
else
{
Status = STATUS_GRACEFUL_DISCONNECT;
}
DEBUGMSG(DBG_TDI, ("IRDA: IRLMP_DATA_CONF %s ConnObj:%p %d bytes, Irp:%p\n",
Status == STATUS_SUCCESS ? "Success":"Failed",
pConn, (ULONG)pIrp->IoStatus.Information, pIrp));
pIrp->IoStatus.Status = Status;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
}
else
{
DEBUGMSG(DBG_TDI, ("IRDA: IRLMP_DATA_CONF ConnObj:%p, Irp:%p NOT FOUND! pMsg=%p\n",
pConn, pMsg->IRDA_MSG_pTdiSendCompCnxt, pMsg));
ASSERT(0);
}
FreeIrdaBuf(IrdaMsgPool, pMsg);
}
VOID
BufferRecv(
PIRDA_CONN_OBJ pConn,
UCHAR *pData,
ULONG BytesAvailable,
UINT FinalSeg)
{
PIRDA_RECV_BUF pRecvBuf;
// Assumes conn lock is held
pRecvBuf = AllocIrdaBuf(RecvBufPool);
CTEAssert(pRecvBuf);
if (pRecvBuf)
{
InsertTailList(&pConn->RecvBufList, &pRecvBuf->Linkage);
pRecvBuf->Offset = 0;
pRecvBuf->Len = BytesAvailable;
pRecvBuf->FinalSeg = FinalSeg;
RtlCopyMemory(pRecvBuf->Data, pData,
pRecvBuf->Len);
}
DEBUGMSG(DBG_TDI, (" ConnObj:%p, %d bytes buffered at %p\n",
pConn, pRecvBuf->Len, pRecvBuf));
}
VOID
IrlmpDataInd(PIRDA_CONN_OBJ pConn, IRDA_MSG *pMsg)
{
NTSTATUS Status;
PIRDA_ADDR_OBJ pAddr = pConn->pAddr;
ULONG BytesAvailable, BytesTakenTotal, BytesTaken, BytesToCopy;
PIRP pIrp = NULL;
CTELockHandle hLock;
LIST_ENTRY *pListEntry;
UCHAR *pData;
UINT FinalSeg;
CTEAssert(IS_VALID_ADDR(pAddr));
// remove IrCOMM header byte
if (pAddr->Use9WireMode)
{
if (*pMsg->IRDA_MSG_pRead != 0)
{
DEBUGMSG(DBG_ERROR, ("IRDA: 9 wire first byte not zero!! Tossing packet\n"));
return;
}
pMsg->IRDA_MSG_pRead += 1;
}
#if DBG_CHECKSUM
// print first and last 4 bytes of frame to help isolate
// data corruption problem. Should be used with sledge
if ((pMsg->IRDA_MSG_pWrite - pMsg->IRDA_MSG_pRead) > 20)
DEBUGMSG(1, ("R(%X): %c%c%c%c, %c%c%c%c (%X)\n",
pMsg->IRDA_MSG_pRead,
*(pMsg->IRDA_MSG_pRead),
*(pMsg->IRDA_MSG_pRead+1),
*(pMsg->IRDA_MSG_pRead+2),
*(pMsg->IRDA_MSG_pRead+3),
*(pMsg->IRDA_MSG_pWrite-4),
*(pMsg->IRDA_MSG_pWrite-3),
*(pMsg->IRDA_MSG_pWrite-2),
*(pMsg->IRDA_MSG_pWrite-1),
pConn));
#endif
BytesAvailable = (ULONG) (pMsg->IRDA_MSG_pWrite - pMsg->IRDA_MSG_pRead);
BytesTakenTotal = 0;
pData = pMsg->IRDA_MSG_pRead;
FinalSeg = pMsg->IRDA_MSG_SegFlags & SEG_FINAL ? 1 : 0;
#if DBG
pConn->TotalFramesCnt += 1;
pConn->TotalByteCount += BytesAvailable;
#endif
GET_CONN_LOCK(pConn, &hLock);
pConn->TtpRecvCreditsLeft--;
CTEAssert(pConn->TtpRecvCreditsLeft >= 0);
if (pConn->ConnState != IRDA_CONN_OPEN)
{
DEBUGMSG(DBG_TDI, (" connection not open (state %d), ignoring\n",
pConn->ConnState));
FREE_CONN_LOCK(pConn, hLock);
return;
}
if (pConn->RecvBusy)
{
DEBUGMSG(DBG_TDI, ("IRDA: IRLMP_DATA_IND pConnObj:%p busy\n", pConn));
BufferRecv(pConn, pData, BytesAvailable, FinalSeg);
FREE_CONN_LOCK(pConn, hLock);
return;
}
FREE_CONN_LOCK(pConn, hLock);
do
{
PIO_STACK_LOCATION pIrpSp;
PTDI_REQUEST_KERNEL_RECEIVE pRecvReq;
pIrp = NULL;
GET_CONN_LOCK(pConn, &hLock);
if (!IsListEmpty(&pConn->RecvIrpList))
{
pListEntry = RemoveHeadList(&pConn->RecvIrpList);
pIrp = CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
if (IoSetCancelRoutine(pIrp, NULL) == NULL)
{
// Cancel routine is going to run. Indicate to the
// cancel routine that the Irp has already been removed
// from the list by setting Flink to NULL
pIrp->Tail.Overlay.ListEntry.Flink = NULL;
pIrp = NULL;
}
else
{
BytesTaken = 0;
Status = STATUS_MORE_PROCESSING_REQUIRED;
DEBUGMSG(DBG_ERROR, ("IRDA: IRLMP_DATA_IND, complete pending receive irp:%p\n",
pIrp));
}
}
FREE_CONN_LOCK(pConn, hLock);
if (pIrp == NULL) {
DEBUGMSG(DBG_TDI, ("IRDA: IRLMP_DATA_IND pConnObj:%p, indicate %d bytes\n",
pConn, BytesAvailable));
if (pAddr->pEventReceive) {
Status = pAddr->pEventReceive(
pAddr->pEventReceiveContext,
pConn->ClientContext,
TDI_RECEIVE_NORMAL | \
(FinalSeg ? TDI_RECEIVE_ENTIRE_MESSAGE : 0),
BytesAvailable,
BytesAvailable,
&BytesTaken,
pData,
&pIrp
);
} else {
BytesTaken= BytesAvailable;
Status=STATUS_SUCCESS;
}
BytesTakenTotal += BytesTaken;
BytesAvailable -= BytesTaken;
pData += BytesTaken;
}
switch (Status)
{
case STATUS_MORE_PROCESSING_REQUIRED:
CTEAssert(pIrp);
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
pRecvReq = (PTDI_REQUEST_KERNEL_RECEIVE) &pIrpSp->Parameters;
BytesToCopy = BytesAvailable <= pRecvReq->ReceiveLength ?
BytesAvailable : pRecvReq->ReceiveLength;
TdiCopyBufferToMdl(pData, // Source
0, // Source offset
BytesToCopy, // Number of bytes to copy
pIrp->MdlAddress,// Destination
0, // Destination offset
&BytesTaken); // actual bytes copied
CTEAssert(BytesTaken == BytesToCopy);
pIrp->IoStatus.Status = STATUS_SUCCESS;
pIrp->IoStatus.Information = BytesTaken;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
BytesTakenTotal += BytesTaken;
BytesAvailable -= BytesTaken;
pData += BytesTaken;
// fall through
case STATUS_SUCCESS:
#if DBG
if (Status == STATUS_SUCCESS)
{
DEBUGMSG(DBG_TDI, (" client took indicated data, BytesLeft %d, BytesTaken %d\n",
BytesAvailable, BytesTaken));
}
else
{
DEBUGMSG(DBG_TDI, (" Completed Irp %p, BytesLeft %d, BytesTaken %d\n",
pIrp, BytesAvailable, BytesTaken));
}
#endif
GET_CONN_LOCK(pConn, &hLock);
// Advance credit to peer
DEBUGMSG(DBG_TDI, (" TtpRecvCreditsLeft = %d\n",pConn->TtpRecvCreditsLeft));
if (pConn->TtpRecvCreditsLeft <= TTP_CREDIT_ADVANCE_THRESH)
{
int CreditsLeft;
IRDA_MSG IMsg;
CreditsLeft = pConn->TtpRecvCreditsLeft;
pConn->TtpRecvCreditsLeft = TTP_RECV_CREDITS;
FREE_CONN_LOCK(pConn, hLock);
IMsg.Prim = IRLMP_MORECREDIT_REQ;
IMsg.IRDA_MSG_TtpCredits = TTP_RECV_CREDITS - CreditsLeft;
#if DBG
pConn->CreditsExtended += (TTP_RECV_CREDITS - CreditsLeft);
#endif
IrlmpDown(pConn->IrlmpContext, &IMsg);
}
else
{
FREE_CONN_LOCK(pConn, hLock);
}
break;
case STATUS_DATA_NOT_ACCEPTED:
GET_CONN_LOCK(pConn, &hLock);
if (!IsListEmpty(&pConn->RecvIrpList))
{
FREE_CONN_LOCK(pConn, hLock);
continue;
}
pConn->RecvBusy = TRUE;
BufferRecv(pConn, pData, BytesAvailable, FinalSeg);
FREE_CONN_LOCK(pConn, hLock);
break;
}
} while (Status != STATUS_DATA_NOT_ACCEPTED &&
BytesAvailable);
}
UINT
TdiUp(void *pContext, IRDA_MSG *pMsg)
{
PIRDA_CONN_OBJ pConn = pContext;
CTEAssert(pConn ? IS_VALID_CONN(pConn) : 1);
switch (pMsg->Prim)
{
case IRLMP_DISCOVERY_CONF:
IrlmpDiscoveryConf(pMsg);
break;
case IRLMP_DISCOVERY_IND:
break;
case IRLMP_CONNECT_IND:
IrlmpConnectInd(pMsg);
break;
case IRLMP_DISCONNECT_IND:
IrlmpDisconnectInd(pConn, pMsg);
break;
case IRLMP_CONNECT_CONF:
IrlmpConnectConf(pConn, pMsg);
break;
case IRLMP_GETVALUEBYCLASS_CONF:
IrlmpGetValueByClassConf(pMsg);
break;
case IRLMP_DATA_CONF:
IrlmpDataConf(pConn, pMsg);
break;
case IRLMP_DATA_IND:
IrlmpDataInd(pConn, pMsg);
break;
case IRLAP_STATUS_IND:
{
CTELockHandle hLock;
PIRLINK_STATUS pLinkStatus = (PIRLINK_STATUS) pMsg->IRDA_MSG_pLinkStatus;
if (CTEMemCmp(pLinkStatus->ConnectedDeviceId,
LinkStatus.ConnectedDeviceId,
IRDA_DEV_ADDR_LEN) == 0)
{
if (pLinkStatus->Flags == LF_INTERRUPTED)
{
ConnectionStatusChange(NULL, CONNECTION_INTERRUPTED);
}
else if ((pLinkStatus->Flags & LF_CONNECTED) && ConnectionInterrupted)
{
ConnectionStatusChange(NULL, CONNECTION_UP);
}
}
/*
CTEGetLock(&IrdaLock, &hLock);
// we update the status only when it changes
// No longer interested in send and receives status
((PIRLINK_STATUS) (pMsg->IRDA_MSG_pLinkStatus))->Flags &= ~(LF_TX | LF_RX);
if (CTEMemCmp(&LinkStatus, pLinkStatus, sizeof(IRLINK_STATUS)) != 0)
{
CTEMemCopy(&LinkStatus, pLinkStatus, sizeof(IRLINK_STATUS));
LinkStatusUpdated = TRUE;
}
if (LinkStatusUpdated)
{
PLIST_ENTRY pListEntry;
PIRP pIrp;
pListEntry = RemoveHeadList(&StatusIrpList);
if (pListEntry != &StatusIrpList)
{
pIrp = CONTAINING_RECORD(pListEntry, IRP, Tail.Overlay.ListEntry);
if (IoSetCancelRoutine(pIrp, NULL) == NULL)
{
// Cancel routine is going to run. Mark Irp so cancel
// routine won't attempt to remove it from the list
pIrp->Tail.Overlay.ListEntry.Flink = NULL;
CTEFreeLock(&IrdaLock, hLock);
}
else
{
CTEMemCopy(pIrp->AssociatedIrp.SystemBuffer,
&LinkStatus, sizeof(IRLINK_STATUS));
CTEFreeLock(&IrdaLock, hLock);
pIrp->IoStatus.Information = sizeof(IRLINK_STATUS);
pIrp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(pIrp, IO_NETWORK_INCREMENT);
LinkStatusUpdated = FALSE;
}
}
else
{
CTEFreeLock(&IrdaLock, hLock);
}
}
else
{
CTEFreeLock(&IrdaLock, hLock);
}
*/
break;
}
case IRLMP_ACCESSMODE_CONF:
default:
DEBUGMSG(DBG_ERROR,
("IRDA: TdiUp(), Bad prim %s.\n", IrDAPrimTxt(pMsg->Prim)));
break;
}
return SUCCESS;
}
VOID
LazyDscvTimerExp(PVOID Context)
{
IRDA_MSG IMsg;
CTELockHandle hLock;
DEBUGMSG(DBG_DISCOVERY, ("IRDA: Lazy discovery timer expired\n"));
CTEGetLock(&IrdaLock, &hLock);
if (!IsListEmpty(&LazyDscvIrpList))
{
UINT OriginalTimeout;
UINT RandInc;
CTEFreeLock(&IrdaLock, hLock);
// Randomize lazy discovery time +1, +0, or -1
RandSeed = RandSeed * 0x3F57A10B + 1;
RandInc = RandSeed % 3;
OriginalTimeout = LazyDscvTimer.Timeout;
LazyDscvTimer.Timeout += (RandInc * 1000) - 1000;
IMsg.Prim = IRLMP_DISCOVERY_REQ;
IMsg.IRDA_MSG_SenseMedia = TRUE;
IrlmpDown(NULL, &IMsg);
IrdaTimerStart(&LazyDscvTimer);
LazyDscvTimer.Timeout = OriginalTimeout;
return;
}
else
{
LazyDscvTimerRunning = FALSE;
DEBUGMSG(DBG_TDI, ("IRDA: IrpList empty, ending lazy discovery\n"));
}
CTEFreeLock(&IrdaLock, hLock);
}
VOID CancelIrp(
PDEVICE_OBJECT DeviceObject,
PIRP pIrp)
{
CTELockHandle hLock;
DEBUGMSG(DBG_TDI, ("IRDA: Cancel Irp:%p\n", pIrp));
CTEGetLock(&IrdaLock, &hLock);
if (pIrp->Tail.Overlay.ListEntry.Flink != NULL) {
RemoveEntryList(&(pIrp->Tail.Overlay.ListEntry));
}
CTEFreeLock(&IrdaLock, hLock);
IoReleaseCancelSpinLock(pIrp->CancelIrql);
pIrp->IoStatus.Status = STATUS_CANCELLED;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
VOID CancelConnObjIrp(
PDEVICE_OBJECT DeviceObject,
PIRP pIrp)
{
PIRDA_CONN_OBJ pConn;
PIO_STACK_LOCATION pIrpSp;
CTELockHandle hLock;
DEBUGMSG(DBG_TDI, ("IRDA: Cancel ConnObj Irp:%p\n", pIrp));
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
pConn = pIrpSp->FileObject->FsContext;
CTEAssert(IS_VALID_CONN(pConn));
GET_CONN_LOCK(pConn, &hLock);
if (pIrp->Tail.Overlay.ListEntry.Flink != NULL)
{
RemoveEntryList(&(pIrp->Tail.Overlay.ListEntry));
}
FREE_CONN_LOCK(pConn, hLock);
DbgPrint("irda: irp %p canceled\n",pIrp);
IoReleaseCancelSpinLock(pIrp->CancelIrql);
pIrp->IoStatus.Status = STATUS_CANCELLED;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
VOID
PendIrp(
PLIST_ENTRY pList,
PIRP pIrp,
PIRDA_CONN_OBJ pConn,
BOOLEAN LockHeld)
{
CTELockHandle hLock;
PIRP IrpToComplete=NULL;
if (!LockHeld)
{
if (pConn)
{
GET_CONN_LOCK(pConn, &hLock);
}
else
{
CTEGetLock(&IrdaLock, &hLock);
}
}
InsertTailList(pList, &pIrp->Tail.Overlay.ListEntry);
IoMarkIrpPending(pIrp);
if (pConn)
{
IoSetCancelRoutine(pIrp, CancelConnObjIrp);
}
else
{
IoSetCancelRoutine(pIrp, CancelIrp);
}
pIrp->IoStatus.Status = STATUS_PENDING;
if (pIrp->Cancel)
{
if (IoSetCancelRoutine(pIrp, NULL) != NULL)
{
//
// My cancel routine was still set in the Irp so
// the Io manager never had a chance to call it
//
RemoveEntryList(&pIrp->Tail.Overlay.ListEntry);
pIrp->IoStatus.Status = STATUS_CANCELLED;
pIrp->IoStatus.Information = 0;
//
// since we may be holding a spinlock here we don't want to complete the
// irp now
//
IrpToComplete=pIrp;
#if DBG
pIrp=NULL;
#endif
}
}
if (!LockHeld)
{
if (pConn)
{
FREE_CONN_LOCK(pConn, hLock);
}
else
{
CTEFreeLock(&IrdaLock, hLock);
}
}
if (IrpToComplete != NULL) {
IoCompleteRequest(IrpToComplete, 0);
}
return ;
}
int
GetUnusedLsapSel()
{
PIRDA_ADDR_OBJ pAddr;
int LastLsapSel;
int LsapSel = gNextLsapSel;
// Assumes AddrObjList lock is held
LastLsapSel = LsapSel - 1;
if (LastLsapSel < IRDA_MIN_LSAP_SEL)
{
LastLsapSel = IRDA_MAX_LSAP_SEL;
}
while (LsapSel != LastLsapSel)
{
for (pAddr = AddrObjList; pAddr != NULL; pAddr = pAddr->pNext)
{
if (pAddr->LocalLsapSel == LsapSel)
break;
}
if (pAddr == NULL || pAddr->LocalLsapSel != LsapSel)
{
gNextLsapSel = LsapSel + 1;
if (gNextLsapSel > IRDA_MAX_LSAP_SEL)
{
gNextLsapSel = IRDA_MIN_LSAP_SEL;
}
return LsapSel;
}
LsapSel += 1;
if (LsapSel > IRDA_MAX_LSAP_SEL)
{
LsapSel = IRDA_MIN_LSAP_SEL;
}
}
return -1;
}
VOID
SetLsapSelAddr(
int LsapSel,
CHAR *ServiceName)
{
int Digit, i;
int StrLen = 0;
CHAR Str[4];
while (LsapSel > 0 && StrLen < 3)
{
Digit = LsapSel % 10;
LsapSel = LsapSel / 10;
Str[StrLen] = Digit + '0';
StrLen++;
}
RtlCopyMemory(ServiceName, LSAPSEL_TXT, LSAPSEL_TXTLEN);
for (i = 0; i < StrLen; i++)
ServiceName[i + LSAPSEL_TXTLEN] = Str[StrLen - 1 - i];
ServiceName[StrLen + LSAPSEL_TXTLEN] = 0;
}
BOOLEAN
MyStrEqual(
CHAR *Str1,
CHAR *Str2,
int Len)
{
while (*Str1 == *Str2 && Len--)
{
if (*Str1 == 0)
return TRUE;
Str1++; Str2++;
}
return FALSE;
}
#if 1
char *
IrpMJTxt(
PIO_STACK_LOCATION pIrpSp)
{
static char *MJTxt[] =
{
"IRP_MJ_CREATE",
"IRP_MJ_CREATE_NAMED_PIPE",
"IRP_MJ_CLOSE",
"IRP_MJ_READ",
"IRP_MP_MJ_WRITE",
"IRP_MJ_QUERY_INFO",
"IRP_MJ_SET_INFO",
"IRP_MJ_QUERY_EA",
"IRP_MJ_SET_EA",
"IRP_MJ_FLUSH_BUFFERS",
"IRP_MJ_QUERY_VOLUME_INFO",
"IRP_MJ_SET_VOLUME_INFO",
"IRP_MJ_DIRECTORY_CTRL",
"IRP_MJ_FILE_SYSTEM_CTRL",
"IRP_MJ_DEV_CONTROL",
"IRP_MJ_INTERNAL_DEV_CTRL",
"IRP_MJ_SHUTDOWN",
"IRP_MJ_LOCK_CTRL",
"IRP_MJ_CLEANUP",
"IRP_MJ_CREATE_MAILSLOT",
"IRP_MJ_QUERY_SECURITY",
"IRP_MJ_SET_SECURITY",
"IRP_MJ_QUERY_POWER",
"IRP_MJ_SET_POWER",
"IRP_MJ_DEV_CHANGE",
"IRP_MJ_QUERY_QUOTA",
"IRP_MJ_SET_QUOTA",
"IRP_MJ_PNP_POWER",
};
if (pIrpSp->MajorFunction < sizeof(MJTxt) / sizeof(char *))
{
return(MJTxt[pIrpSp->MajorFunction]);
}
return "UNKNOWN IRP_MJ_";
}
char *
IrpTdiTxt(
PIO_STACK_LOCATION pIrpSp)
{
static char *TdiTxt[] =
{
"UNKNOWN TDI_",
"TDI_ASSOC_ADDR",
"TDI_DISASSOC_ADDR",
"TDI_CONNECT",
"TDI_LISTEN",
"TDI_ACCEPT",
"TDI_DISC",
"TDI_SEND",
"TDI_RECV",
"TDI_SEND_DATAGRAM",
"TDI_RECV_DATAGRAM",
"TDI_SET_HANDLER",
"TDI_QUERY_INFO",
"TDI_SET_INFO",
"TDI_ACTION"
};
if (pIrpSp->MajorFunction == IRP_MJ_INTERNAL_DEVICE_CONTROL)
{
if (pIrpSp->MinorFunction < sizeof(TdiTxt) / sizeof(char *))
{
return(TdiTxt[pIrpSp->MinorFunction]);
}
else
return "UNKNOWN TDI_";
}
return "";
}
char *
IrpTdiObjTypeTxt(
PIO_STACK_LOCATION pIrpSp)
{
switch((UINT_PTR) pIrpSp->FileObject->FsContext2)
{
case TDI_TRANSPORT_ADDRESS_FILE: return "AddrObj";
case TDI_CONNECTION_FILE: return "ConnObj";
case TDI_CONTROL_CHANNEL_FILE: return "CtrlObj";
}
return "UNKNOWN";
}
char *
TdiEventTxt(
int EventType)
{
switch(EventType)
{
case TDI_EVENT_CONNECT: return "TDI_EVENT_CONN";
case TDI_EVENT_DISCONNECT: return "TDI_EVENT_DISC";
case TDI_EVENT_RECEIVE: return "TDI_EVENT_RECV";
case TDI_EVENT_ERROR: return "TDI_EVENT_ERR";
case TDI_EVENT_RECEIVE_DATAGRAM: return "TDI_EVENT_RECV_DATAGRAM";
case TDI_EVENT_RECEIVE_EXPEDITED: return "TDI_EVENT_RECV_EXPEDITED";
}
return "UNKNOWN TDI_EVENT_";
}
void
DumpObjects(void)
{
PIRDA_ADDR_OBJ pAddr;
PIRDA_CONN_OBJ pConn;
pAddr = AddrObjList;
/*
while (pAddr != NULL)
{
DEBUGMSG(DBG_TDI,
(" AddrObj:%X Loc:\"%s\",%d ConnObjList:%X pNext:%X\n",
pAddr,
pAddr->LocalAddr.irdaServiceName,
pAddr->LocalLsapSel,
pAddr->ConnObjList,
pAddr->pNext));
pConn = pAddr->ConnObjList;
while (pConn != NULL)
{
DEBUGMSG(DBG_TDI,
(" ConnObj:%X Loc:\"%s\",%d Rem:\"%s\",%d State:%d AddrObj:%X pNext:%X\n",
pConn,
pConn->LocalAddr.irdaServiceName,
pConn->LocalLsapSel,
pConn->RemoteAddr.irdaServiceName,
pConn->RemoteLsapSel,
pConn->ConnState,
pConn->pAddr,
pConn->pNext));
pConn = pConn->pNext;
}
pAddr = pAddr->pNext;
}
*/
}
char *
IrDAPrimTxt(
IRDA_SERVICE_PRIM Prim)
{
static char *IrDAPrimTxt[] =
{
"MAC_DATA_REQ",
"MAC_DATA_IND",
"MAC_DATA_RESP",
"MAC_DATA_CONF",
"MAC_CONTROL_REQ",
"MAC_CONTROL_CONF",
"IRLAP_DISCOVERY_REQ",
"IRLAP_DISCOVERY_IND",
"IRLAP_DISCOVERY_CONF",
"IRLAP_CONNECT_REQ",
"IRLAP_CONNECT_IND",
"IRLAP_CONNECT_RESP",
"IRLAP_CONNECT_CONF",
"IRLAP_DISCONNECT_REQ",
"IRLAP_DISCONNECT_IND",
"IRLAP_DATA_REQ",
"IRLAP_DATA_IND",
"IRLAP_DATA_CONF",
"IRLAP_UDATA_REQ",
"IRLAP_UDATA_IND",
"IRLAP_UDATA_CONF",
"IRLAP_STATUS_IND",
"IRLAP_FLOWON_REQ",
"IRLMP_DISCOVERY_REQ",
"IRLMP_DISCOVERY_IND",
"IRLMP_DISCOVERY_CONF",
"IRLMP_CONNECT_REQ",
"IRLMP_CONNECT_IND",
"IRLMP_CONNECT_RESP",
"IRLMP_CONNECT_CONF",
"IRLMP_DISCONNECT_REQ",
"IRLMP_DISCONNECT_IND",
"IRLMP_DATA_REQ",
"IRLMP_DATA_IND",
"IRLMP_DATA_CONF",
"IRLMP_UDATA_REQ",
"IRLMP_UDATA_IND",
"IRLMP_UDATA_CONF",
"IRLMP_ACCESSMODE_REQ",
"IRLMP_ACCESSMODE_IND",
"IRLMP_ACCESSMODE_CONF",
"IRLMP_MORECREDIT_REQ",
"IRLMP_GETVALUEBYCLASS_REQ",
"IRLMP_GETVALUEBYCLASS_CONF",
"IRLMP_REGISTERLSAP_REQ",
"IRLMP_ADDATTRIBUTE_REQ",
"IRLMP_DELATTRIBUTE_REQ",
};
if (Prim < sizeof(IrDAPrimTxt) / sizeof(char *))
{
return(IrDAPrimTxt[Prim]);
}
return "UNKNOWN PRIMITIVE";
}
char *
TdiQueryTxt(LONG Type)
{
switch(Type)
{
case TDI_QUERY_BROADCAST_ADDRESS: return "TDI_QUERY_BROADCAST_ADDRESS";
case TDI_QUERY_PROVIDER_INFO: return "TDI_QUERY_PROVIDER_INFO";
case TDI_QUERY_ADDRESS_INFO: return "TDI_QUERY_ADDRES_INFO";
case TDI_QUERY_CONNECTION_INFO: return "TDI_QUERY_CONNECTION_INFO";
case TDI_QUERY_PROVIDER_STATISTICS: return "TDI_QUERY_PROVIDER_STATISTICS";
default: return "Unknown TDI_QUERY_INFO";
}
}
#endif
Copy Permalink