misc.c

驱动开发,经过测试可以直接编译后使用,编译使用DDK中的build工具

            //

            ATMSM_SET_MEMBER_STATE(pMemberToDrop, ATMSM_MEMBER_CLOSING);

            pVc->ulNumActiveMembers--;
            pVc->ulNumDroppingMembers++;

            RELEASE_ADAPTER_GEN_LOCK(pAdapt);
            bLockReleased = TRUE;

            Status = NdisClDropParty(
                        NdisPartyHandle, 
                        NULL, 
                        0
                        );

            if(NDIS_STATUS_PENDING != Status)
            {

               AtmSmDropPartyComplete(
                  Status, 
                  (NDIS_HANDLE)pMemberToDrop
                  );
            }
         }
         else
         {

            //
            // This is the last active party. Check if any DropParty()'s are
            // yet to finish.
            //
            if(0 != pVc->ulNumDroppingMembers)
            {
               //
               // This member will have to wait till all DropParty()s are
               // complete. Mark the ClusterControlVc so that we send
               // a CloseCall() when all DropParty()s are done.
               //
               ATMSM_SET_VC_STATE(pVc, ATMSM_VC_NEED_CLOSING);
            }
            else
            {
               //
               // Last active party, and no DropParty pending.
               //
               NdisVcHandle = pVc->NdisVcHandle;


               ATMSM_SET_VC_STATE(pVc, ATMSM_VC_CLOSING);
               ATMSM_SET_MEMBER_STATE(pMemberToDrop, ATMSM_MEMBER_CLOSING);

               pVc->ulNumActiveMembers--;
               pVc->ulNumDroppingMembers++;

               RELEASE_ADAPTER_GEN_LOCK(pAdapt);
               bLockReleased = TRUE;

               Status = NdisClCloseCall(
                           NdisVcHandle,
                           NdisPartyHandle,
                           NULL,
                           0
                           );

               if(NDIS_STATUS_PENDING != Status)
               {

                  AtmSmCloseCallComplete(
                     Status,
                     (NDIS_HANDLE)pVc,
                     (NDIS_HANDLE)pMemberToDrop
                     );
               }
            }
         }
         break;

      case ATMSM_MEMBER_CONNECTING:
         //
         // Mark it so that we'll delete it when the AddParty/MakeCall
         // completes.
         //
         pMemberToDrop->ulFlags |= ATMSM_MEMBER_INVALID;
         break;

      case ATMSM_MEMBER_CLOSING:
         NOTHING;
         break;

      case ATMSM_MEMBER_IDLE:
         //
         // No connection. Just unlink this from the IntF and free it.
         //

         RELEASE_ADAPTER_GEN_LOCK(pAdapt);
         bLockReleased = TRUE;

         DeleteMemberInfoFromVc(pVc, pMemberToDrop);
         break;

      default:
         ASSERT(FALSE);
         break;
   }

   if(!bLockReleased)
   {

      RELEASE_ADAPTER_GEN_LOCK(pAdapt);
   }

   TraceOut(AtmSmDropMemberFromVc);
}

PCO_CALL_PARAMETERS AtmSmPrepareCallParameters(
   IN  PATMSM_ADAPTER          pAdapt,
   IN  PHW_ADDR                pHwAddr,
   IN  BOOLEAN                 IsMakeCall,
   IN  BOOLEAN                 IsMultipointVC
   )
/*++

Routine Description:

    Allocate and fill in call parameters for use in a MakeCall

Arguments:

    pAdapt          - Ptr to Adapter
    pHwAddr         - Points to the Called ATM address and subaddress
    IsMakeCall      - MakeCall or AddParty

Return Value:

    Allocated Call Parameter

--*/
{
   PATMSM_FLOW_SPEC                        pFlowSpec;
   PCO_CALL_PARAMETERS                     pCallParameters;
   PCO_CALL_MANAGER_PARAMETERS             pCallMgrParameters;

   PQ2931_CALLMGR_PARAMETERS               pAtmCallMgrParameters;

   //
   //  All Info Elements that we need to fill:
   //
   Q2931_IE                            UNALIGNED *      pIe;
   AAL_PARAMETERS_IE                   UNALIGNED *      pAalIe;
   ATM_TRAFFIC_DESCRIPTOR_IE           UNALIGNED *      pTrafficDescriptor;
   ATM_BROADBAND_BEARER_CAPABILITY_IE  UNALIGNED *      pBbc;
   ATM_BLLI_IE                         UNALIGNED *      pBlli;
   ATM_QOS_CLASS_IE                    UNALIGNED *      pQos;

   ULONG                               RequestSize;

   RequestSize =   sizeof(CO_CALL_PARAMETERS) +
                   sizeof(CO_CALL_MANAGER_PARAMETERS) +
                   sizeof(Q2931_CALLMGR_PARAMETERS) +
                   (IsMakeCall? ATMSM_MAKE_CALL_IE_SPACE : 
                   ATMSM_ADD_PARTY_IE_SPACE);

   AtmSmAllocMem(&pCallParameters, PCO_CALL_PARAMETERS, RequestSize);

   if(NULL == pCallParameters)
   {

      return(pCallParameters);
   }

   pFlowSpec = &(pAdapt->VCFlowSpec);

   //
   //  Zero out everything
   //
   NdisZeroMemory((PUCHAR)pCallParameters, RequestSize);

   //
   //  Distribute space amongst the various structures
   //
   pCallMgrParameters = (PCO_CALL_MANAGER_PARAMETERS)
                        ((PUCHAR)pCallParameters +
                           sizeof(CO_CALL_PARAMETERS));


   //
   //  Set pointers to link the above structures together
   //
   pCallParameters->CallMgrParameters = pCallMgrParameters;
   pCallParameters->MediaParameters = (PCO_MEDIA_PARAMETERS)NULL;


   pCallMgrParameters->CallMgrSpecific.ParamType = 0;
   pCallMgrParameters->CallMgrSpecific.Length =
      sizeof(Q2931_CALLMGR_PARAMETERS) +
      (IsMakeCall? ATMSM_MAKE_CALL_IE_SPACE : 
   ATMSM_ADD_PARTY_IE_SPACE);

   pAtmCallMgrParameters = (PQ2931_CALLMGR_PARAMETERS)
                           pCallMgrParameters->CallMgrSpecific.Parameters;

   if(IsMultipointVC)
      pCallParameters->Flags |= MULTIPOINT_VC;

   //
   //  Call Manager generic flow parameters:
   //    
   pCallMgrParameters->Transmit.TokenRate = (pFlowSpec->SendBandwidth);
   pCallMgrParameters->Transmit.TokenBucketSize = (pFlowSpec->SendMaxSize);
   pCallMgrParameters->Transmit.MaxSduSize = pFlowSpec->SendMaxSize;
   pCallMgrParameters->Transmit.PeakBandwidth = (pFlowSpec->SendBandwidth);
   pCallMgrParameters->Transmit.ServiceType = pFlowSpec->ServiceType;

   //
   // We are setting up unidirectional calls, so receive side values are 0's.
   // Note: for PMP it should be 0 in all cases
   //
   pCallMgrParameters->Receive.ServiceType = pFlowSpec->ServiceType;

   //
   //  Q2931 Call Manager Parameters:
   //

   //
   //  Called address:
   //
   //
   pAtmCallMgrParameters->CalledParty = pHwAddr->Address;

   //  NOTE: Add Called Subaddress IE for E164.

   //
   //  Calling address:
   //
   pAtmCallMgrParameters->CallingParty = pAdapt->ConfiguredAddress;

   //
   //  RFC 1755 (Sec 5) says that the following IEs MUST be present in the
   //  SETUP message, so fill them all.
   //
   //      AAL Parameters
   //      Traffic Descriptor (MakeCall only)
   //      Broadband Bearer Capability (MakeCall only)
   //      Broadband Low Layer Info
   //      QoS (MakeCall only)
   //

   //
   //  Initialize the Info Element list
   //
   pAtmCallMgrParameters->InfoElementCount = 0;
   pIe = (PQ2931_IE)(pAtmCallMgrParameters->InfoElements);


   //
   //  AAL Parameters:
   //

   {
      UNALIGNED AAL5_PARAMETERS   *pAal5;

      pIe->IEType = IE_AALParameters;
      pIe->IELength = SIZEOF_Q2931_IE + SIZEOF_AAL_PARAMETERS_IE;
      pAalIe = (PAAL_PARAMETERS_IE)pIe->IE;
      pAalIe->AALType = AAL_TYPE_AAL5;
      pAal5 = &(pAalIe->AALSpecificParameters.AAL5Parameters);
      pAal5->ForwardMaxCPCSSDUSize = pFlowSpec->SendMaxSize;
      pAal5->BackwardMaxCPCSSDUSize = pFlowSpec->ReceiveMaxSize;
   }

   pAtmCallMgrParameters->InfoElementCount++;
   pIe = (PQ2931_IE)((PUCHAR)pIe + pIe->IELength);


   //
   //  Traffic Descriptor:
   //

   if(IsMakeCall)
   {

      pIe->IEType = IE_TrafficDescriptor;
      pIe->IELength = SIZEOF_Q2931_IE + SIZEOF_ATM_TRAFFIC_DESCR_IE;
      pTrafficDescriptor = (PATM_TRAFFIC_DESCRIPTOR_IE)pIe->IE;

      if(SERVICETYPE_BESTEFFORT == pFlowSpec->ServiceType)
      {

         pTrafficDescriptor->ForwardTD.PeakCellRateCLP01 =
            BYTES_TO_CELLS(pFlowSpec->SendBandwidth);
         pTrafficDescriptor->BestEffort = TRUE;

      }
      else
      {

         //  Predictive/Guaranteed service 
         // (we map this to CBR, see BBC below)

         pTrafficDescriptor->ForwardTD.PeakCellRateCLP01 =
            BYTES_TO_CELLS(pFlowSpec->SendBandwidth);
         pTrafficDescriptor->BestEffort = FALSE;
      }

      pAtmCallMgrParameters->InfoElementCount++;
      pIe = (PQ2931_IE)((PUCHAR)pIe + pIe->IELength);
   }

   //
   //  Broadband Bearer Capability
   //

   if(IsMakeCall)
   {

      pIe->IEType = IE_BroadbandBearerCapability;
      pIe->IELength = SIZEOF_Q2931_IE + SIZEOF_ATM_BBC_IE;
      pBbc = (PATM_BROADBAND_BEARER_CAPABILITY_IE)pIe->IE;

      pBbc->BearerClass = BCOB_X;
      pBbc->UserPlaneConnectionConfig = UP_P2P;
      if(SERVICETYPE_BESTEFFORT == pFlowSpec->ServiceType)
      {

         pBbc->TrafficType = TT_NOIND;
         pBbc->TimingRequirements = TR_NOIND;
         pBbc->ClippingSusceptability = CLIP_NOT;

      }
      else
      {

         pBbc->TrafficType = TT_CBR;
         pBbc->TimingRequirements = TR_END_TO_END;
         pBbc->ClippingSusceptability = CLIP_SUS;
      }

      pAtmCallMgrParameters->InfoElementCount++;
      pIe = (PQ2931_IE)((PUCHAR)pIe + pIe->IELength);
   }

   //
   //  Broadband Lower Layer Information
   //

   pIe->IEType = IE_BLLI;
   pIe->IELength = SIZEOF_Q2931_IE + SIZEOF_ATM_BLLI_IE;
   pBlli = (PATM_BLLI_IE)pIe->IE;
   NdisMoveMemory((PUCHAR)pBlli,
      (PUCHAR)&AtmSmDefaultBlli,
      sizeof(ATM_BLLI_IE));

   pAtmCallMgrParameters->InfoElementCount++;
   pIe = (PQ2931_IE)((PUCHAR)pIe + pIe->IELength);

   //
   //  QoS
   //

   if(IsMakeCall)
   {

      pIe->IEType = IE_QOSClass;
      pIe->IELength = SIZEOF_Q2931_IE + SIZEOF_ATM_QOS_IE;
      pQos = (PATM_QOS_CLASS_IE)pIe->IE;
      if(SERVICETYPE_BESTEFFORT == pFlowSpec->ServiceType)
      {
         pQos->QOSClassForward = pQos->QOSClassBackward = 0;

      }
      else
      {

         pQos->QOSClassForward = pQos->QOSClassBackward = 1;
      }

      pAtmCallMgrParameters->InfoElementCount++;
      pIe = (PQ2931_IE)((PUCHAR)pIe + pIe->IELength);
   }

   return(pCallParameters);
}

NTSTATUS VerifyRecvOpenContext(
   PATMSM_ADAPTER      pAdapt
   )
/*++

Routine Description:
    This routine is used to verify that an open context passed is valid

    Note: we add a reference on the adapter 

Arguments:

Return Value:

--*/
{
   NTSTATUS Status = STATUS_SUCCESS;
   
   PATMSM_ADAPTER pAdapter;    
   ULONG ulNum = 0;
   
   if(pAdapt == NULL)
   {
      return STATUS_UNSUCCESSFUL;
   }
                          
   ACQUIRE_GLOBAL_LOCK();
   
   // walk the adapter list to see if this adapter exists
   for(pAdapter = AtmSmGlobal.pAdapterList; pAdapter &&
      ulNum < AtmSmGlobal.ulAdapterCount; 
      pAdapter = pAdapter->pAdapterNext)
   {
      if(pAdapt == pAdapter)
         break;
   }
   
   if(pAdapter == NULL || ulNum == AtmSmGlobal.ulAdapterCount)
   {
      RELEASE_GLOBAL_LOCK();
      return STATUS_UNSUCCESSFUL;
   }

   if(atmsm_adapter_signature != pAdapt->ulSignature)
      Status = STATUS_INVALID_PARAMETER;
   else
   {
      if(AtmSmReferenceAdapter(pAdapt))
      {
         if(FALSE == pAdapt->fAdapterOpenedForRecv)
         {
            Status = STATUS_INVALID_PARAMETER;

            // remove the reference
            AtmSmDereferenceAdapter(pAdapt);
         }
      }
      else
         Status = STATUS_UNSUCCESSFUL;
   }

   RELEASE_GLOBAL_LOCK();

   return Status;
}

NTSTATUS VerifyConnectContext(
   PATMSM_VC       pVc
   )
/*++

Routine Description:
    This routine is used to verify that a connect context passed is valid

    Note: we add a reference on the VC

Arguments:

Return Value:

--*/
{
   NTSTATUS Status = STATUS_SUCCESS;

   try
   {

      if((atmsm_vc_signature != pVc->ulSignature) ||
         (NULL == pVc->pAdapt))
         Status = STATUS_INVALID_PARAMETER;
      else
      {

         if(!AtmSmReferenceVc(pVc))
            Status = STATUS_UNSUCCESSFUL;
         else
         {

            PATMSM_ADAPTER      pAdapt = pVc->pAdapt;

            if(atmsm_adapter_signature != pAdapt->ulSignature)
            {
               Status = STATUS_INVALID_PARAMETER;

               // remove the VC reference
               AtmSmDereferenceVc(pVc);
            }

         }
      }

   }except(EXCEPTION_EXECUTE_HANDLER)
   {

      Status = GetExceptionCode(); 
      DbgErr(("VerifyConnectContext: CC 0x%x exception - 0x%x\n", 
         pVc, Status));
      return Status;
   }

   return Status;
}

UINT CopyPacketToIrp(
   PIRP            pIrp,
   PNDIS_PACKET    pPkt
   )
/*++

Routine Description:
    This routine is used to copy the connects of a packet into the user supplied
    buffer.

Arguments:

Return Value: