pppoethernet.c

这是全套的PPP协议的源码

		pStackData->userHandle = userHandle;
		pStackData->stackObjCallbacks = callbacks;
		pComponent->pppOEServiceNameMap[i] = pComponentState;

		pProfileData=(PPPOE_PROFILE_DATA *)pComponentState->profileData;

		if (strlen(pProfileData->acNameTag) == 0)
		    {
            /* profile has no name for the AC, use default name */

		    sprintf(pProfileData->acNameTag,PPPOE_DEFAULT_AC_NAME);
		    }

		pComponent->pppOEServices++;
		return OK;
		}
	    }
	}

    printf("PPPOE: Too many services; Max allowed = %d\n",
	    pComponent->pppOEMaxServices);
    return ERROR;
    }

/*******************************************************************************
*
* pppOEServiceNameDelete - delete a service name and all corresponding stacks 
*
* This routine deletes the stacks corresponding to the svcName
*
* RETURNS: OK on success and ERROR otherwise
*/
STATUS pppOEServiceNameDelete
    (
    PFW_OBJ * pfw,		/* pfw from which to delete service */
    char * svcName       	/* service name we're deleting */
    )
    {
    PPPOE_STACK_DATA * pStackData =  NULL;
    PFW_PLUGIN_OBJ_STATE * pComponentState;
    int i;
    char service[32];
    PPPOE_COMPONENT *pComponent;
    BOOL found = FALSE;

    if (pfw == NULL)
	{
	printf ("PPPOE: Null framework object \n");
	return ERROR;
	}

    pComponent =(PPPOE_COMPONENT *)pfwPluginObjGet(pfw,"PPP_O_ETHERNET");

    bzero(service,32);

    if (strlen(svcName))
	strcpy(service,svcName);
    else
	sprintf(service,"%s","ANY");

    for (i = 1 ; i <= pComponent->pppOEMaxServices ; i++)
	{
	if ((pComponentState = pComponent->pppOEServiceNameMap[i]) == NULL)
	    {
	    continue;
	    }

	pStackData = (PPPOE_STACK_DATA *)pComponentState->stackData;

	if (!strcmp(pStackData->serviceName,service))
	    {
	    /* delete connection */

	    pfwStackDelete (pComponentState->stackObj);
	    found = TRUE;
	    }
	}

    if (!found)
        {
        printf("PPPOE: No such service: %s\n",svcName);
        return (ERROR);
        }
    else
        return (OK);
    }

/*******************************************************************************
* pppOEStackObjResolve - obtain stack object from received PPPOE frame 
*
* This is the stack object resolver and it returns a valid stack object
* within which the frame will be processed further or ERROR if cannot
* determine the stack object
*
* RETURNS: The stack object if successful and ERROR otherwise 
*/

LOCAL PFW_STACK_OBJ * pppOEStackObjResolve
    (
    PFW_PLUGIN_OBJ * pPluginObj,	/* this component */
    M_BLK_ID         pFrame,            /* the received ethernet frame */
    ULONG            portId
    )
    {
    struct ether_header * pEtherHdr = NULL;
    PPPOE_HEADER  * pPPPOEHeader = NULL;
    PPPOE_TLV * pTlv = NULL;
    PPPOE_TLV * foundTlv = NULL;
    PFW_STACK_OBJ * stackObj;
    PPPOE_COMPONENT * pComponent = (PPPOE_COMPONENT *)pPluginObj;
    PFW_STACK_STATUS stackStatus = PFW_STACK_ADD_IN_PROGRESS;
    PFW_PLUGIN_OBJ_STATE * pppoeACState = NULL;

    if (pFrame == NULL)
	return NULL;

    /* if we dont have the headers in the first MBLK drop the packet */

    if (pFrame->mBlkHdr.mLen >= 
	    (sizeof(struct ether_header) + sizeof(PPPOE_HEADER)))
	{
	pEtherHdr = mtod (pFrame, struct ether_header *);
	}
    else
	return NULL;

    /* ethertype field has to indicate session or a discovery frame */

    if ((ntohs(pEtherHdr->ether_type) != ETHERTYPE_PPPOE_DISCOVERY) &&
	(ntohs(pEtherHdr->ether_type) != ETHERTYPE_PPPOE_SESSION))
	return NULL;
    /*
     * check the PPPOE header and in the case of DISCOVERY packets
     * PPPOE expects a contiguous buffer!!
     */

    pPPPOEHeader = (PPPOE_HEADER *)(pFrame->mBlkHdr.mData + 
				    sizeof(struct ether_header));

    /* check if we have as much data as the header says we do */

    if (pFrame->mBlkHdr.mLen < (ntohs(pPPPOEHeader->pppOE_length) +
			    sizeof(PPPOE_HEADER) + sizeof(struct ether_header)))
	return NULL;

    /* point to the first tlv */

    pTlv = (PPPOE_TLV *)((char *)pPPPOEHeader + sizeof(PPPOE_HEADER));

    /*
     * try to find the stack object depending on the type of PPOE packet
     */
    switch (pPPPOEHeader->pppOE_code)
	{
	/* these two cases are encountered by the Access concentarator */

	case PPPOE_CODE_PADI:
	    /* incoming PADI must have a service name tag */

	    if ((foundTlv = pppOEFindTlv(PPPOE_TAG_SVC_NAME,pTlv,pFrame))!=NULL)
		{
	        return (pppOESvcStackObjGet(pComponent, foundTlv, portId));
		}
	   /* this will return NULL */
	   break;

	case PPPOE_CODE_PADR:
	    /* search for and return the AC cookie we inserted in the PADO */

	    if ((foundTlv=pppOEFindTlv(PPPOE_TAG_AC_COOKIE,pTlv,pFrame)) !=NULL)
		{
	        bcopy(PPPOE_TAG_VALUE(foundTlv),(char *)&stackObj,
					       sizeof(PFW_STACK_OBJ *));
		/* verify if AC cookie  is valid */

		if (pppOEVerifyACCookie (pComponent, stackObj) != OK)
		    break;
		else
		    {
		    PPPOE_STACK_DATA * pStackData;

		    pppoeACState = pfwPluginObjStateGet(stackObj,pPluginObj);
		    if (pppoeACState == NULL)
			break;
		    pStackData = pppoeACState->stackData;

		    /*
		     * if we've received a request based on our PADO with 
		     * multiple serviceNames in it and we need to find the
		     * stack based on the serviceName in this request
		     */
		    if (!strcmp(pStackData->serviceName,"ANY"))
			{
			if ((foundTlv = pppOEFindTlv(PPPOE_TAG_SVC_NAME,
					             pTlv,pFrame))!=NULL)
			    {
			    /*
			     * we dont accept a zero length service name tag
			     * in a PADR
			     */
			    if (PPPOE_TAG_LENGTH(foundTlv) == 0)
				break;
			    return (pppOESvcStackObjGet(pComponent, foundTlv, portId));
			    }
			else 
			    break; /* cant find a service name in this frame */
			}
		    return (stackObj);
		    }
		}
	   /* this will return NULL */
	   break;

	/* these two cases are encountered by the client/host */

	case PPPOE_CODE_PADO:
	    /*
	     * a PADO must have a AC name tag; if it does we find
	     * the host unique cookie that we sent out in the PADI
	     * and return it as our stack object 
	     */
	    if ((foundTlv=pppOEFindTlv(PPPOE_TAG_AC_NAME,pTlv,pFrame)) !=NULL)
		{
		if ((foundTlv = pppOEFindTlv(PPPOE_TAG_HOST_UNIQ,pTlv,pFrame))
		    !=NULL)
		    {
		    /* the host cookie is the stack object that sent the PADI */

		    bcopy(PPPOE_TAG_VALUE(foundTlv),(char *)&stackObj,
					       sizeof(PFW_STACK_OBJ *));

		    /* verify that stack is valid */

		    if (pfwStackStatusGet (stackObj, &stackStatus) != OK)
			break;
		    else
			return (stackObj);
		    }
		}
	   /* this will return NULL */

	   break;

	case PPPOE_CODE_PADS:
	    /*
	     * check session ID to be non NULL. If it is NULL an AC error
	     * occured; return NULL after printing any AC system errors 
	     */
	    if (ntohs(pPPPOEHeader->pppOE_session) == PPPOE_SESSION_DISCOVERY)
		/*|| (pPPPOEHeader->pppOE_code == 0))*/
		{
		if ((foundTlv=pppOEFindTlv(PPPOE_TAG_AC_SYSTEM_ERROR,pTlv,
							    pFrame)) != NULL)
		    {
		    char message[256];
		    bzero(message,sizeof(message));
		    strncpy(message,PPPOE_TAG_VALUE(foundTlv),255);

		    if (message[0] != '\0')
			printf ("PPPOE: AC SYSTEM ERROR: %s\n",message);
		    }
		break;
		}

	    /* Once again the host cookie is our stack object */

	    if ((foundTlv=pppOEFindTlv(PPPOE_TAG_HOST_UNIQ,pTlv,pFrame)) !=NULL)
		{
	        bcopy(PPPOE_TAG_VALUE(foundTlv), (char *)&stackObj,
						       sizeof(PFW_STACK_OBJ *));
		/* verify that stack is valid */

		if (pfwStackStatusGet (stackObj, &stackStatus) != OK)
		    break;
		else
		    return (stackObj);
		}
	   /* this will return NULL */

	   break;

	/* encountered by both AC and host during the session phase */

	case PPPOE_CODE_SESSION:
	case PPPOE_CODE_PADT:
	    /* find the stackObj from the MAP(sessionID,stack object) */

	    stackObj = pppOEStackObjGet(pComponent,
		    ntohs(pPPPOEHeader->pppOE_session),
		    pEtherHdr->ether_shost);

	    /* verify that stack is valid and ready */

	    if ((pfwStackStatusGet (stackObj, &stackStatus) != OK) ||
		(stackStatus != PFW_STACK_READY))
		break;
	    else
		return (stackObj);

	default:
	    break;
	}

    return NULL;
    }

/*******************************************************************************
* pppOEProfileDataConstruct - initialize profile data for PPP over Ethernet
*
* This function is called by the framework to get default values for the
* parameters managed and supported by this component
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS pppOEProfileDataConstruct
    (
    PFW_OBJ * pfw,
    void * pProfileData 	/* reference to this component's profile data */
    )
    {
    PPPOE_PROFILE_DATA * pPPPOEProfileData = (PPPOE_PROFILE_DATA *)pProfileData;

    bzero((void *)pPPPOEProfileData, sizeof(PPPOE_PROFILE_DATA));

    /* set some default values */

    pPPPOEProfileData->connectionMode = PPPOE_HOST_MODE;
    pPPPOEProfileData->discoveryRetries = PPPOE_DISCOVERY_RETRIES;
    pPPPOEProfileData->minDiscTimeout = PPPOE_MIN_TIMEOUT;

    return OK;
    }

/*******************************************************************************
* pppOEStackDataConstruct - initialize stack data for PPP over Ethernet
*
* This function is called by the framework at the time this component is
* included in a stack for the purpose of allowing the component to initialize
* its stack data
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS pppOEStackDataConstruct
    (
    PFW_OBJ * pfw,
    void * stackData, 	/* reference to this component's stack data */
    void * profileData	/* reference to this component's profile data */
    )
    {
    PPPOE_STACK_DATA * pStackData = (PPPOE_STACK_DATA *)stackData;

    bzero((void *)pStackData, sizeof(PPPOE_STACK_DATA));

    pStackData->collectPppAttributesEvent = NULL;
    pStackData->lcpUpFlag = FALSE;

    pStackData->sendPADT = TRUE;

    if  ((pStackData->netPoolId = pfwNetPoolIdGet(pfw)) == NULL)
	{
	printf ("PPPOE: must have a valid netPoolId; see pfwCreate()\n");
	return ERROR;
	}

    if  (NULL == (pStackData->pppSubordinateLayerDeadEvent =
                  pfwEventObjGet(pfw, "PPP_SUB_LAYER_DEAD_EVENT")))
    return(ERROR);

    return OK;
    }

/*******************************************************************************
* pppOEStackDataDestruct - clean up and close stack data
*
* This function is called by the framework at the time this component is
* removed from a stack for the purpose of allowing the component to cleanup
* its stack data
*
* RETURNS: OK on success and ERROR otherwise
*/

LOCAL STATUS pppOEStackDataDestruct
    (
    PFW_OBJ * pfw,
    void * stackData, 	/* reference to this component's stack data */
    void * profileData	/* reference to this component's profile data */
    )
    {
    PPPOE_STACK_DATA * pStackData = (PPPOE_STACK_DATA *)stackData;

    PPPOE_FREE_RECVD_PKT(pStackData);
    PPPOE_FREE_RETRY_PKT(pStackData);

    return OK;
    }

/*******************************************************************************
* pppOEStackDel - Delete an established PPPOE session
*
* This is the first interface invoked by the framework when deleting a 
* PPP connection
* 
* RETURNS: OK on success and ERROR otherwise
*/
LOCAL STATUS pppOEStackDel
    (
    PFW_PLUGIN_OBJ_STATE * pComponentState /* our state for this stack */
    )
    {
    PPPOE_COMPONENT * pComponent = 
			    (PPPOE_COMPONENT *)pComponentState->pluginObj;

    PPPOE_STACK_DATA * pStackData =
			    (PPPOE_STACK_DATA *)(pComponentState->stackData);