tcprcv.c

网络驱动开发

   }

   //
   // Sanity Check On Caller's Receive Event Handler
   //
   if( !pAddrObj->ao_chainedrcv )
   {
	   KdPrint(( "TDIH_TdiChainedReceiveEventHandler: Caller Event Handler NULL!!!\n" ));

      return( STATUS_DATA_NOT_ACCEPTED );
   }

   pTDIH_DeviceExtension = pAddrObj->ao_DeviceExtension;

   //
   // Pass To Receive Event Handler Set On The Address Object
   //
	Status = pAddrObj->ao_chainedrcv(
               pAddrObj->ao_chainedrcvcontext,
		         ConnectionContext,
               ReceiveFlags,
               ReceiveLength,    // length of client data in TSDU
               StartingOffset,   // offset of start of client data in TSDU
               Tsdu,             // TSDU data chain
               TsduDescriptor    // for call to TdiReturnChainedReceives
		         );

	KdPrint(( "TDIH_TdiChainedReceiveEventHandler: Status: 0x%8.8X\n",
      Status ));

   return( Status );
}

/////////////////////////////////////////////////////////////////////////////
//// _I_TdiReceiveComplete
//
// Purpose
// Common handler for handling completion of receives initiated by calling
// TdiReceive and receives initiated from a receive event handler.
//
// Parameters
//   bReceiveOnEventComplete - TRUE if completing a receive initiated
//     from a receive event handler. FALSE if completing a receive initiated
//     by calling TdiReceive.
//
// Return Value
// 
// Remarks
// In the PassThru sample there is no difference in the way the receives
// are completed.
//

NTSTATUS
_I_TdiReceiveComplete(
   PDEVICE_OBJECT    pDeviceObject,
   PIRP              Irp,
   void              *Context,
   BOOLEAN           bReceiveOnEventComplete
   )
{
   PTDIH_DeviceExtension   pTDIH_DeviceExtension;
   BOOLEAN                 CanDetachProceed = FALSE;
   PDEVICE_OBJECT          pAssociatedDeviceObject = NULL;
	NTSTATUS                Status = Irp->IoStatus.Status;
   ULONG                   nByteCount = Irp->IoStatus.Information;

#if DBG
   KdPrint(( "_I_TdiReceiveComplete: Final Status: 0x%8.8X; Bytes Transfered: %d\n",
      Status, nByteCount ));
#endif

   pTDIH_DeviceExtension = (PTDIH_DeviceExtension )(Context);

   ASSERT( pTDIH_DeviceExtension );
   //
   // Propogate The IRP Pending Flag
   //
   if (Irp->PendingReturned)
   {
      IoMarkIrpPending(Irp);
   }

   // Ensure that this is a valid device object pointer, else return
   // immediately.
   pAssociatedDeviceObject = pTDIH_DeviceExtension->pFilterDeviceObject;

   if (pAssociatedDeviceObject != pDeviceObject)
   {
      KdPrint(( "_I_TdiReceiveComplete: Invalid Device Object Pointer\n" ));
      return(STATUS_SUCCESS);
   }

   // Note that you could do all sorts of processing at this point
   // depending upon the results of the operation. Be careful though
   // about what you chose to do, about the fact that this completion
   // routine is being invoked in an arbitrary thread context and probably
   // at high IRQL.

   UTIL_DecrementLargeInteger(
      pTDIH_DeviceExtension->OutstandingIoRequests,
      (unsigned long)1,
      &(pTDIH_DeviceExtension->IoRequestsSpinLock)
      );

   // If the outstanding count is 0, signal the appropriate event which will
   // allow any pending detach to proceed.
   UTIL_IsLargeIntegerZero(
      CanDetachProceed,
      pTDIH_DeviceExtension->OutstandingIoRequests,
      &(pTDIH_DeviceExtension->IoRequestsSpinLock)
      );

   if (CanDetachProceed)
   {
      // signal the event object. Note that this is simply an
      // advisory check we do here (to wake up a sleeping thread).
      // It is the responsibility of the thread performing the detach to
      // ensure that no operations are truly in progress.
      KeSetEvent(&(pTDIH_DeviceExtension->IoInProgressEvent), IO_NO_INCREMENT, FALSE);
   }

   // Although the success return value is hard-coded here, you can
   // return an appropriate value (either success or more-processing-reqd)
   // based upon what it is that you wish to do in your completion routine.
   return(STATUS_SUCCESS);
}


/////////////////////////////////////////////////////////////////////////////
//// TDIH_TdiReceiveComplete
//
// Purpose
// Completion of a receive initiated by a call to TdiReceive.
//
// Parameters
//
// Return Value
// 
// Remarks
// Calls common _I_TdiReceiveComplete function to do the work.
//

NTSTATUS
TDIH_TdiReceiveComplete(
   PDEVICE_OBJECT    pDeviceObject,
   PIRP              Irp,
   void              *Context
   )
{
   return( _I_TdiReceiveComplete(
               pDeviceObject,
               Irp,
               Context,
               FALSE      // NOT In Event
               )
            );
}


/////////////////////////////////////////////////////////////////////////////
//// TDIH_TdiReceiveOnEventComplete
//
// Purpose
// Completion of a receive initiated from receive event handler.
//
// Parameters
//
// Return Value
// 
// Remarks
// Calls common _I_TdiReceiveComplete function to do the work.
//

NTSTATUS
TDIH_TdiReceiveOnEventComplete(
   PDEVICE_OBJECT    pDeviceObject,
   PIRP              Irp,
   void              *Context
   )
{
   return( _I_TdiReceiveComplete(
               pDeviceObject,
               Irp,
               Context,
               TRUE      // Completion Of Receive From Event Handler
               )
            );
}


/////////////////////////////////////////////////////////////////////////////
//// TDIH_TdiReceive
//
// Purpose
// This is the hook for TdiReceive
//
// Parameters
//
// Return Value
// 
// Remarks
//

NTSTATUS
TDIH_TdiReceive(
   PTDIH_DeviceExtension   pTDIH_DeviceExtension,
   PIRP                    Irp,
   PIO_STACK_LOCATION      IrpSp
   )
{
   NTSTATUS RC;

   KdPrint(( "TDIH_TdiReceive: Entry...\n" ));

   try
   {
      PDEVICE_OBJECT       pLowerDeviceObject = NULL;

      pLowerDeviceObject = pTDIH_DeviceExtension->LowerDeviceObject;

      // Be careful about not screwing up badly. This is actually not recommended by the I/O Manager.
      if (Irp->CurrentLocation == 1)
      {
         ULONG ReturnedInformation = 0;

         // Bad!! Fudge the error code. Break if we can ...

         KdPrint(("TDIH_TdiReceive encountered bogus current location\n"));

   //      UTIL_BreakPoint();
         RC = STATUS_INVALID_DEVICE_REQUEST;
         Irp->IoStatus.Status = RC;
         Irp->IoStatus.Information = ReturnedInformation;
         IoCompleteRequest(Irp, IO_NO_INCREMENT);

         return( RC );
      }

      IoCopyCurrentIrpStackLocationToNext( Irp );

      IoSetCompletionRoutine(
         Irp,
         TDIH_TdiReceiveComplete,
         pTDIH_DeviceExtension,
         TRUE,
         TRUE,
         TRUE
         );

      UTIL_IncrementLargeInteger(
         pTDIH_DeviceExtension->OutstandingIoRequests,
         (unsigned long)1,
         &(pTDIH_DeviceExtension->IoRequestsSpinLock)
         );

      // Clear the fast-IO notification event protected by the resource
      // we have acquired.
      KeClearEvent(&(pTDIH_DeviceExtension->IoInProgressEvent));

      //
      // Call TCP Device To Queue The Receive
      //
      RC = IoCallDriver(pLowerDeviceObject, Irp);

      try_return(RC);

      try_exit:   NOTHING;
   }
   finally
   {
   }

   return(RC);
}