pppvsend.c

这是全套的PPP协议的源码

               RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 
                                      stackData->pfwRFC2233CountPair,
                                      M2_ctrId_ifInDiscards, 1);        
               return (ERROR);
               }

           dst = newMblk->mBlkHdr.mData;

           newMblk->mBlkHdr = mBlk->mBlkHdr;
           newMblk->mBlkPktHdr = mBlk->mBlkPktHdr;
           newMblk->mBlkHdr.mData = dst;
         
           newMblk->mBlkHdr.mData += sizeof (PPP_HEADER);
           bcopy (mBlk->mBlkHdr.mData, newMblk->mBlkHdr.mData, bufferSize); 
            
           netMblkClFree(mBlk);
           mBlk = newMblk;
           }
       }

   if (mBlk->mBlkHdr.mNext == NULL)
       mBlk->mBlkPktHdr.len = mBlk->mBlkHdr.mLen;

   mBlk->mBlkHdr.mFlags |= M_PKTHDR;

   if (stackData->mode == END_NORMAL_MODE)
        {

        /* update RFC1213 counters */

        end->mib2Tbl.ifInUcastPkts++;

        end->mib2Tbl.ifInOctets += mBlk->mBlkPktHdr.len;

        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest,
				stackData->pfwRFC2233CountPair,
                               M2_ctrId_ifInUcastPkts, 1);       
        RFC2233_COUNTER_UPDATE(stackData->pfwRFC2233CountTest, 
				stackData->pfwRFC2233CountPair,
                               M2_ctrId_ifHCInUcastPkts, 1);       
        return(netJobAdd ((FUNCPTR)end->receiveRtn,(int)end,(int)mBlk,0,0,0));
        }

   /* we are in POLLED mode and Queue is not full */

   if (stackData->receivedPacketQHead == NULL)
       {
       stackData->receivedPacketQTail = mBlk;
       stackData->receivedPacketQHead = stackData->receivedPacketQTail;
       }
   else
       {
       stackData->receivedPacketQTail->mBlkHdr.mNextPkt = mBlk;
       stackData->receivedPacketQTail = mBlk;
       }

   stackData->receivedPacketQSize++;

   return (OK);
   }



/* END DRIVER FUNCTIONS */

/***************************************************************************
*
* pppVsEndLoad - Load PPP VS END driver into the MUX
*
* NOMANUAL
*/

END_OBJ * pppVsEndLoad
   (
   char *initString, 	/* We receive the connectionId in the initString */
   void *tmp
   )
   {
   PPP_DRV_CTRL  *pDrvCtrl;
   PFW_PLUGIN_OBJ_STATE *state;
   PFW_STACK_ID connectionId;
   PFW_ID pfwId;
   int hwlen=0;
   char *holder = NULL;
   char *token;
   UINT8 pppEndBuf[6];

   /* In the first pass of muxDevLoad, driver supplies its name */ 

   if (initString[0] == 0)
       {
       bcopy((char *)"ppp", initString, 3);
       return (NULL);
       }

   /*
    * In the second pass, driver performs the actual initialization.
    * The initString passed to muxDevLoad in pppVsEndStackAdd contains
    * the state in hex.
    */ 

   strtok_r (initString, ":", &holder);
   token = strtok_r (NULL, ":", &holder);

   /* strtoul, string to unsigned long: interpret number as hex: base = 16 */ 

   state = (PFW_PLUGIN_OBJ_STATE *)strtoul(token, NULL, 16);

   /* allocate the device structure */

   pDrvCtrl = (PPP_DRV_CTRL *)malloc(sizeof(PPP_DRV_CTRL));

   if (pDrvCtrl == NULL)
      {
      return (NULL);
      }

   bzero((char *)pDrvCtrl, sizeof (PPP_DRV_CTRL));

   ((PPP_VS_END_STACK_DATA *)state->stackData)->pDrvCtrl = pDrvCtrl;

   pDrvCtrl->state = state;
   connectionId = pfwStackIdGet(state->stackObj);
   pfwId = pfwIdGet (state->pluginObj->pfwObj);
   pDrvCtrl->unitNum = (pfwId - 1)* PPP_END_MAX_SESSIONS_PER_FRWK + connectionId;

   /* Store the cookie (END_OBJ) in the PPP driver control structure */

    /* store the netPoolId in the end object */

    pDrvCtrl->end.pNetPool = pfwNetPoolIdGet (state->pluginObj->pfwObj);

    /* Pointer back to the device data. */

    pDrvCtrl->end.devObject.pDevice = (void *)pDrvCtrl;

    /* Assign the NET_FUNCS in the END_OBJ */ 

    hwlen = IPV4_ADDR_LEN;

    if  ((END_OBJ_INIT (&(pDrvCtrl->end), 
                        (DEV_OBJ *)pDrvCtrl, 
                        "ppp", 
                        pDrvCtrl->unitNum, 
                        &pppFuncTable, 
                        "ppp END Driver.") == ERROR) || 
      ((pDrvCtrl->end.pMib2Tbl = m2IfAlloc(M2_ifType_ppp,
                                           (UINT8*) pppEndBuf,
                                           0,    /* interface addr length*/
                                           1500, /* default MTU */
                                           0, "ppp",
                                           pDrvCtrl->unitNum)) == NULL))
        {
        return (NULL);
        }

    END_OBJ_READY (&(pDrvCtrl->end),IFF_POINTOPOINT | IFF_NOARP | 
                   IFF_RUNNING | IFF_NOTRAILERS | IFF_MULTICAST |
                   END_MIB_2233);

    return (&(pDrvCtrl->end));
    }


/***************************************************************************
*
* pppUnload - Release PPP VS END driver from MUX
*
* NOMANUAL
*/
 
LOCAL STATUS pppUnload
    (
    END_OBJ * pEnd
    )
    {
    PPP_DRV_CTRL *pDrvCtrl = (PPP_DRV_CTRL *)pEnd;

    if (pEnd->txSem != NULL)
	{
	semDelete (pEnd->txSem);
	pEnd->txSem = NULL;
	}

    /* Free MIB-II entries */

    m2IfFree(pDrvCtrl->end.pMib2Tbl);
    pDrvCtrl->end.pMib2Tbl = NULL;

    END_OBJECT_UNLOAD (&pDrvCtrl->end);
 
    return OK;
    }

 
/***************************************************************************
*
* pppStart - activate PPP VS END driver
*
* NOMANUAL
*/

LOCAL STATUS pppStart
    (
    PPP_DRV_CTRL *pDrvCtrl
    )
    {
    char ifName[PFW_MAX_NAME_LENGTH];
    struct ifnet * pIfnet;

#ifdef VIRTUAL_STACK
    PPP_VS_END_STACK_DATA *pStackData = (PPP_VS_END_STACK_DATA *)
                                      pDrvCtrl->state->stackData;
 
    if (pStackData == NULL ||
        pppEndVirtualStackSet(pStackData->vsid) == ERROR)
        return (ERROR);
#endif /* VIRTUAL_STACK */

    /* No interrupts to connect, just validate device */

    sprintf(ifName,"ppp%d",pDrvCtrl->unitNum);

    if ((pIfnet = ifunit (ifName)) == NULL)
        return (ERROR);

    return (OK);
    }


/***************************************************************************
*
* pppStop - deactivate PPP VS END driver
*
* NOMANUAL
*/

LOCAL STATUS pppStop
    (
    PPP_DRV_CTRL *pDrvCtrl
    )
    {
    char ifName[PFW_MAX_NAME_LENGTH];
    struct ifnet * pIfnet;
#ifdef VIRTUAL_STACK
    PPP_VS_END_STACK_DATA *pStackData = (PPP_VS_END_STACK_DATA *)
                                      pDrvCtrl->state->stackData;
 
    if (pStackData == NULL ||
        pppEndVirtualStackSet(pStackData->vsid) == ERROR)
        return (ERROR);
#endif /* VIRTUAL_STACK */

    /* No interrupts to disconnect, just validate device */

    sprintf(ifName,"ppp%d",pDrvCtrl->unitNum);

    if ((pIfnet = ifunit (ifName)) == NULL)
        return ERROR;

    return (OK);
    }


/***************************************************************************
*
* pppSend - accept data from MUX and send to physical layer
*
* NOMANUAL
*/

LOCAL STATUS pppSend
    (
    void * pCookie,
    M_BLK_ID pMblk
    )
    {
#ifdef PPP_END_PMP_CAPABLE
    UINT32 dstIpAddr;
#endif /* PPP_END_PMP_CAPABLE */

    PPP_DRV_CTRL *pDrvCtrl;
    END_OBJ *end;
    int retVal;
    PPP_VS_END_STACK_DATA * pStackData;

#ifdef PPP_DEBUG
    printf ("pppSend\n");
#endif /* PPP_DEBUG*/

    end = (END_OBJ *)pCookie;

    /* Get the pDrvCtrl structure from the END_OBJ */

    pDrvCtrl = (PPP_DRV_CTRL *) end->devObject.pDevice;

    /* Get stackData required for implementation of RFC 2233 counters */

    pStackData = (PPP_VS_END_STACK_DATA *)(pDrvCtrl->state)->stackData;

    if (pStackData->txBlocked == TRUE)
        {
        return (END_ERR_BLOCK);
        }

#ifdef PPP_END_PMP_CAPABLE
    /* PMP pMblk->mBlkPktHdr.rcvif contains the dst IP address */ 

    if ((void *)pMblk->mBlkPktHdr.rcvif == NULL)
        {
        netMblkClChainFree (pMblk);
        return ERROR;
        }

    bcopy((char *)(&pMblk->mBlkPktHdr.rcvif),(char *)&dstIpAddr,
                   IPV4_ADDR_LEN);

    pMblk->mBlkPktHdr.rcvif = NULL;

    if (pStackData->supportPMP)
        {
        if (dstIpAddr == pStackData->dstIpAddr)
            pDrvCtrl = pStackData->pDstDrvCtrl;
        else
            pDrvCtrl = RAS_pmpGetDriver(pStackData->rasPoolId,
                                        ntohl(dstIpAddr));

        if (!pDrvCtrl)
            {
            netMblkClChainFree (pMblk);
            return (ERROR);
            }
        }
#endif /* PPP_END_PMP_CAPABLE */

    /* update RFC 1213 counters */

    pDrvCtrl->end.mib2Tbl.ifOutUcastPkts++;

    pDrvCtrl->end.mib2Tbl.ifOutOctets += pMblk->mBlkPktHdr.len;

    RFC2233_COUNTER_UPDATE(pStackData->pfwRFC2233CountTest, 
			    pStackData->pfwRFC2233CountPair,
                           M2_ctrId_ifOutUcastPkts, 1);         
    RFC2233_COUNTER_UPDATE(pStackData->pfwRFC2233CountTest, 
			    pStackData->pfwRFC2233CountPair,
                           M2_ctrId_ifHCOutUcastPkts, 1);        

    retVal = pfwSend (pDrvCtrl->state, pMblk);

    return (retVal);
    }


/***************************************************************************
*
* pppEndPollReceive - receive frames in poll mode (system-mode debugging)
*
* NOMANUAL
*/

LOCAL STATUS pppEndPollReceive
    (
    void * pCookie,
    M_BLK_ID pMblk
    )
    {
    PPP_DRV_CTRL *pDrvCtrl;
    END_OBJ *end;
    PPP_VS_END_STACK_DATA *stackData;
    M_BLK_ID packet;
    int length;

    end = (END_OBJ *)pCookie;

    /*  Get the pDrvCtrl structure from the END_OBJ */

    pDrvCtrl = (PPP_DRV_CTRL *) end->devObject.pDevice;

    if (pfwPluginObjStateLock (pDrvCtrl->state) != OK)
	return ERROR;

    stackData = (PPP_VS_END_STACK_DATA *)pDrvCtrl->state->stackData;

    if (stackData->mode != END_POLLED_MODE)
	{
	pfwPluginObjStateRelease(pDrvCtrl->state);
	return ERROR;
	}

    if (stackData->receivedPacketQHead == NULL)
	{
	pfwPluginObjStateRelease(pDrvCtrl->state);
	return EAGAIN;
	}

    /* get the first packet in the queue */

    packet = stackData->receivedPacketQHead;

    /* compute total length of received mBuf chain */

    length = (packet->mBlkHdr.mNext != NULL) ? packet->mBlkPktHdr.len :\
                                               packet->mBlkHdr.mLen;
    /* 
     * Upper layer provides the buffer.
     * If buffer is not large enough, we return.
     */

    if (((pMblk->mBlkHdr.mData + length) >= 
	    (pMblk->pClBlk->clNode.pClBuf + pMblk->pClBlk->clSize)) ||
	(!(pMblk->mBlkHdr.mFlags & M_EXT)))
	{
	pfwPluginObjStateRelease(pDrvCtrl->state);
	return EAGAIN;
	}
    
    /* delete packet from head of queue */

    if ((stackData->receivedPacketQHead = packet->mBlkHdr.mNextPkt) == NULL)
	stackData->receivedPacketQTail = NULL;

    stackData->receivedPacketQSize--;

    /* copy data from received packet chain to supplied buffer */

    netMblkToBufCopy(packet, pMblk->mBlkHdr.mData, NULL);

    pMblk->mBlkHdr.mLen = length;
    pMblk->mBlkPktHdr.len = length;
    pMblk->mBlkHdr.mFlags |= M_PKTHDR;