drivers/network/afd/afd/info.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * FILE:             drivers/net/afd/afd/info.c
   5  * PURPOSE:          Ancillary functions driver
   6  * PROGRAMMER:       Art Yerkes (ayerkes@speakeasy.net)
   7  * UPDATE HISTORY:
   8  * 20040708 Created
   9  */
  10
  11 #include "afd.h"
  12
  13 NTSTATUS NTAPI
  14 AfdGetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
  15             PIO_STACK_LOCATION IrpSp ) {
  16     NTSTATUS Status = STATUS_SUCCESS;
  17     PAFD_INFO InfoReq = LockRequest(Irp, IrpSp, TRUE, NULL);
  18     PFILE_OBJECT FileObject = IrpSp->FileObject;
  19     PAFD_FCB FCB = FileObject->FsContext;
  20     PLIST_ENTRY CurrentEntry;
  21
  22     UNREFERENCED_PARAMETER(DeviceObject);
  23
  24     AFD_DbgPrint(MID_TRACE,("Called %p %x\n", InfoReq,
  25                             InfoReq ? InfoReq->InformationClass : 0));
  26
  27     if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
  28
  29     if (!InfoReq)
  30         return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
  31
  32     _SEH2_TRY {
  33         switch( InfoReq->InformationClass ) {
  34         case AFD_INFO_RECEIVE_WINDOW_SIZE:
  35             InfoReq->Information.Ulong = FCB->Recv.Size;
  36             break;
  37
  38         case AFD_INFO_SEND_WINDOW_SIZE:
  39             InfoReq->Information.Ulong = FCB->Send.Size;
  40             AFD_DbgPrint(MID_TRACE,("Send window size %u\n", FCB->Send.Size));
  41             break;
  42
  43         case AFD_INFO_GROUP_ID_TYPE:
  44             InfoReq->Information.LargeInteger.u.HighPart = FCB->GroupType;
  45             InfoReq->Information.LargeInteger.u.LowPart = FCB->GroupID;
  46             AFD_DbgPrint(MID_TRACE, ("Group ID: %u Group Type: %u\n", FCB->GroupID, FCB->GroupType));
  47             break;
  48
  49         case AFD_INFO_BLOCKING_MODE:
  50             InfoReq->Information.Boolean = FCB->NonBlocking;
  51             break;
  52
  53     case AFD_INFO_INLINING_MODE:
  54         InfoReq->Information.Boolean = FCB->OobInline;
  55         break;
  56
  57     case AFD_INFO_RECEIVE_CONTENT_SIZE:
  58         InfoReq->Information.Ulong = FCB->Recv.Content - FCB->Recv.BytesUsed;
  59         break;
  60
  61         case AFD_INFO_SENDS_IN_PROGRESS:
  62             InfoReq->Information.Ulong = 0;
  63
  64             /* Count the queued sends */
  65             CurrentEntry = FCB->PendingIrpList[FUNCTION_SEND].Flink;
  66             while (CurrentEntry != &FCB->PendingIrpList[FUNCTION_SEND])
  67             {
  68                  InfoReq->Information.Ulong++;
  69                  CurrentEntry = CurrentEntry->Flink;
  70             }
  71
  72         /* This needs to count too because when this is dispatched
  73          * the user-mode IRP has already been completed and therefore
  74          * will NOT be in our pending IRP list. We count this as one send
  75          * outstanding although it could be multiple since we batch sends
  76          * when waiting for the in flight request to return, so this number
  77          * may not be accurate but it really doesn't matter that much since
  78          * it's more or less a zero/non-zero comparison to determine whether
  79          * we can shutdown the socket
  80          */
  81         if (FCB->SendIrp.InFlightRequest)
  82             InfoReq->Information.Ulong++;
  83         break;
  84
  85         default:
  86             AFD_DbgPrint(MIN_TRACE,("Unknown info id %x\n",
  87                                     InfoReq->InformationClass));
  88             Status = STATUS_INVALID_PARAMETER;
  89             break;
  90         }
  91     } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
  92         AFD_DbgPrint(MIN_TRACE,("Exception executing GetInfo\n"));
  93         Status = STATUS_INVALID_PARAMETER;
  94     } _SEH2_END;
  95
  96     AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
  97
  98     return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
  99 }
 100
 101 NTSTATUS NTAPI
 102 AfdSetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 103             PIO_STACK_LOCATION IrpSp ) {
 104     NTSTATUS Status = STATUS_SUCCESS;
 105     PAFD_INFO InfoReq = LockRequest(Irp, IrpSp, FALSE, NULL);
 106     PFILE_OBJECT FileObject = IrpSp->FileObject;
 107     PAFD_FCB FCB = FileObject->FsContext;
 108     PCHAR NewBuffer;
 109
 110     UNREFERENCED_PARAMETER(DeviceObject);
 111
 112     if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
 113
 114     if (!InfoReq)
 115         return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
 116
 117     _SEH2_TRY {
 118         switch (InfoReq->InformationClass) {
 119             case AFD_INFO_BLOCKING_MODE:
 120                 AFD_DbgPrint(MID_TRACE,("Blocking mode set to %u\n", InfoReq->Information.Boolean));
 121                 FCB->NonBlocking = InfoReq->Information.Boolean;
 122                 break;
 123             case AFD_INFO_INLINING_MODE:
 124                 FCB->OobInline = InfoReq->Information.Boolean;
 125                 break;
 126             case AFD_INFO_RECEIVE_WINDOW_SIZE:
 127                 NewBuffer = ExAllocatePoolWithTag(PagedPool,
 128                                                   InfoReq->Information.Ulong,
 129                                                   TAG_AFD_DATA_BUFFER);
 130
 131                 if (NewBuffer)
 132                 {
 133                     if (FCB->Recv.Content > InfoReq->Information.Ulong)
 134                         FCB->Recv.Content = InfoReq->Information.Ulong;
 135
 136                     if (FCB->Recv.Window)
 137                     {
 138                         RtlCopyMemory(NewBuffer,
 139                                       FCB->Recv.Window,
 140                                       FCB->Recv.Content);
 141
 142                         ExFreePoolWithTag(FCB->Recv.Window, TAG_AFD_DATA_BUFFER);
 143                     }
 144
 145                     FCB->Recv.Size = InfoReq->Information.Ulong;
 146                     FCB->Recv.Window = NewBuffer;
 147
 148                     Status = STATUS_SUCCESS;
 149                 }
 150                 else
 151                 {
 152                     Status = STATUS_NO_MEMORY;
 153                 }
 154                 break;
 155             case AFD_INFO_SEND_WINDOW_SIZE:
 156                 NewBuffer = ExAllocatePoolWithTag(PagedPool,
 157                                                   InfoReq->Information.Ulong,
 158                                                   TAG_AFD_DATA_BUFFER);
 159
 160                 if (NewBuffer)
 161                 {
 162                     if (FCB->Send.BytesUsed > InfoReq->Information.Ulong)
 163                         FCB->Send.BytesUsed = InfoReq->Information.Ulong;
 164
 165                     if (FCB->Send.Window)
 166                     {
 167                         RtlCopyMemory(NewBuffer,
 168                                       FCB->Send.Window,
 169                                       FCB->Send.BytesUsed);
 170
 171                         ExFreePoolWithTag(FCB->Send.Window, TAG_AFD_DATA_BUFFER);
 172                     }
 173
 174                     FCB->Send.Size = InfoReq->Information.Ulong;
 175                     FCB->Send.Window = NewBuffer;
 176
 177                     Status = STATUS_SUCCESS;
 178                 }
 179                 else
 180                 {
 181                     Status = STATUS_NO_MEMORY;
 182                 }
 183                 break;
 184             default:
 185                 AFD_DbgPrint(MIN_TRACE,("Unknown request %u\n", InfoReq->InformationClass));
 186                 break;
 187         }
 188     } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
 189         AFD_DbgPrint(MIN_TRACE,("Exception executing SetInfo\n"));
 190         Status = STATUS_INVALID_PARAMETER;
 191     } _SEH2_END;
 192
 193     AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
 194
 195     return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
 196 }
 197
 198 NTSTATUS NTAPI
 199 AfdGetSockName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 200                 PIO_STACK_LOCATION IrpSp ) {
 201     NTSTATUS Status = STATUS_SUCCESS;
 202     PFILE_OBJECT FileObject = IrpSp->FileObject;
 203     PAFD_FCB FCB = FileObject->FsContext;
 204     PMDL Mdl = NULL;
 205
 206     UNREFERENCED_PARAMETER(DeviceObject);
 207     ASSERT(Irp->MdlAddress == NULL);
 208
 209     if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
 210
 211     if( FCB->AddressFile.Object == NULL && FCB->Connection.Object == NULL ) {
 212          return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
 213     }
 214
 215     Mdl = IoAllocateMdl( Irp->UserBuffer,
 216                          IrpSp->Parameters.DeviceIoControl.OutputBufferLength,
 217                          FALSE,
 218                          FALSE,
 219                          NULL );
 220
 221     if( Mdl != NULL ) {
 222         _SEH2_TRY {
 223             MmProbeAndLockPages( Mdl, Irp->RequestorMode, IoModifyAccess );
 224         } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
 225             AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
 226             Status = _SEH2_GetExceptionCode();
 227         } _SEH2_END;
 228
 229         if( NT_SUCCESS(Status) ) {
 230                 Status = TdiQueryInformation( FCB->Connection.Object
 231                                                 ? FCB->Connection.Object
 232                                                 : FCB->AddressFile.Object,
 233                                               TDI_QUERY_ADDRESS_INFO,
 234                                               Mdl );
 235         }
 236
 237         /* Check if MmProbeAndLockPages or TdiQueryInformation failed and
 238          * clean up Mdl */
 239         if (!NT_SUCCESS(Status) && Irp->MdlAddress != Mdl)
 240             IoFreeMdl(Mdl);
 241     } else
 242         Status = STATUS_INSUFFICIENT_RESOURCES;
 243
 244     return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
 245 }
 246
 247 NTSTATUS NTAPI
 248 AfdGetPeerName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 249                 PIO_STACK_LOCATION IrpSp ) {
 250     NTSTATUS Status;
 251     PFILE_OBJECT FileObject = IrpSp->FileObject;
 252     PAFD_FCB FCB = FileObject->FsContext;
 253
 254     UNREFERENCED_PARAMETER(DeviceObject);
 255
 256     if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
 257
 258     if (FCB->RemoteAddress == NULL) {
 259         AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
 260         return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
 261     }
 262
 263     if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength >= TaLengthOfTransportAddress(FCB->RemoteAddress))
 264     {
 265         RtlCopyMemory(Irp->UserBuffer, FCB->RemoteAddress, TaLengthOfTransportAddress(FCB->RemoteAddress));
 266         Status = STATUS_SUCCESS;
 267     }
 268     else
 269     {
 270         AFD_DbgPrint(MIN_TRACE,("Buffer too small\n"));
 271         Status = STATUS_BUFFER_TOO_SMALL;
 272     }
 273
 274     return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
 275 }