udprcv.c

网络驱动开发

               Tsdu,                   // TSDU data chain
               TsduDescriptor          // for call to TdiReturnChainedReceives
		         );

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

   return( Status );
}


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

NTSTATUS
_I_TdiReceiveDGComplete(
   PDEVICE_OBJECT    pDeviceObject,
   PIRP              Irp,
   void              *Context,
   BOOLEAN           bReceiveDGOnEventComplete
   )
{
   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_TdiReceiveDGComplete: 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_TdiReceiveDGComplete: 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_TdiReceiveDGComplete
//
// Purpose
// Completion of a DG receive initiated by a call to TdiReceiveDatagram.
//
// Parameters
//
// Return Value
// 
// Remarks
// Calls common _I_TdiReceiveDGComplete function to do the work.
//

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

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

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

/////////////////////////////////////////////////////////////////////////////
//// TDIH_TdiReceiveDatagram
//
// Purpose
// This is the hook for TdiReceiveDatagram
//
// Parameters
//
// Return Value
// 
// Remarks
//

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

   KdPrint(( "TDIH_TdiReceiveDatagram: 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_TdiReceiveDatagram 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_TdiReceiveDGComplete,
         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));

      RC = IoCallDriver(pLowerDeviceObject, Irp);

      try_return(RC);

      try_exit:   NOTHING;
   }
   finally
   {
   }

   return(RC);
}