pppipstatemachinefunction.c

这是全套的PPP协议的源码

    OPTION_LIST_ENTRY * sptr_option   = NULL;
    struct in_addr localAddr, remoteAddr;

    PARAMETER_NOT_USED (end_state);
    PARAMETER_NOT_USED (pMblk);

    bzero ((char *)&localAddr, sizeof (localAddr));
    bzero ((char *)&remoteAddr, sizeof (remoteAddr));

    sptr_option = find_matching_option (&pNcpStackData->option_lists.tx_accepted,
                                         IP_ADDRESS_OPTION_TYPE);

    if (sptr_option != NULL)
        {
        memcpy (&localAddr.s_addr, sptr_option->uptr_data, sptr_option->length);
        }

    sptr_option = find_matching_option (&pNcpStackData->option_lists.rx_accepted,
                                           IP_ADDRESS_OPTION_TYPE);

    if (sptr_option != NULL)
       {
       memcpy (&remoteAddr.s_addr, sptr_option->uptr_data, sptr_option->length);
       }

    inet_ntoa_b(localAddr, (char *)&pStackData->localAddr);
    inet_ntoa_b(remoteAddr, (char *)&pStackData->remoteAddr);

#ifdef PPP_DEBUG
    printf ("local address is %s remote Addr is %s\n",
               pStackData->localAddr,  pStackData->remoteAddr);
#endif
    }

/*******************************************************************************
*
* build_dns_addr_accepted_parameters -
*/

LOCAL void build_dns_addr_accepted_parameters 
    (
    PFW_PLUGIN_OBJ_STATE *              pluginState,
    M_BLK_ID                            pMblk,
    PPP_STATE                           end_state
    )
    {
    IPCP_STACK_DATA *   pStackData    = (IPCP_STACK_DATA *) pluginState->stackData;
    NCP_STACK_DATA *    pNcpStackData = (NCP_STACK_DATA *) pluginState->stackData;
    OPTION_LIST_ENTRY *       sptr_option         = NULL;
    BOOL	                  primaryDnsUpdate    = FALSE;
    BOOL	                  secondaryDnsUpdate  = FALSE;
    PPP_IP_DNS_INTERFACE *    pIpDnsInterface     = NULL;
    struct in_addr primaryDnsAddr, secondaryDnsAddr;
    PFW_INTERFACE_STATE_PAIR  pppIpDnsInterface;
    int                       id                  = 0;

    PARAMETER_NOT_USED (end_state);
    PARAMETER_NOT_USED (pMblk);

    sptr_option = find_matching_option (&pNcpStackData->option_lists.tx_accepted,
        PRIMARY_DNS_ADDRESS);

    if (sptr_option != NULL)
        {
        primaryDnsUpdate = TRUE;
        memcpy (&primaryDnsAddr.s_addr, sptr_option->uptr_data, 
                                       sptr_option->length);
        inet_ntoa_b(primaryDnsAddr, (char *)&pStackData->primaryDnsAddr);
        }

    sptr_option = find_matching_option (&pNcpStackData->option_lists.tx_accepted,
                            SECONDARY_DNS_ADDRESS);

    if (sptr_option != NULL)
        {
        secondaryDnsUpdate = TRUE;
        memcpy (&secondaryDnsAddr.s_addr, sptr_option->uptr_data, 
                   sptr_option->length);
        inet_ntoa_b(secondaryDnsAddr, (char *)&pStackData->secondaryDnsAddr);
        }

    if ((!secondaryDnsUpdate) && (!primaryDnsUpdate))
        {
        /* nothing to do */
        return;
        }

#ifdef PPP_DEBUG
    printf ("Primary DNS address is %s Secondary DNS Addr is %s\n",
         pStackData->primaryDnsAddr, 
         pStackData->secondaryDnsAddr);
#endif

    if ((id = pfwInterfaceIdGet(pluginState->pluginObj->pfwObj,
                          "PPP_IP_DNS_INTERFACE")) > 0)
        {
        if (pfwInterfaceObjAndStateGetViaStackObj(pluginState->stackObj,
                              id, &pppIpDnsInterface) != OK)
             {
             pfwPrintError (__FILE__, "ipcp_this_layer_up", __LINE__, 
                         NULL, pluginState->stackObj, 
                        "PPP_IP_DNS_INTERFACE get error");
             printf ("failed to get PPP_IP_DNS_INTERFACE:stack 0x%x\n",
                             (UINT32) pluginState->stackObj);
             return;
             }
        }
   else
        {
        printf ("pfwInterfaceIdGet failed for PPP_IP_DNS_INTERFACE:stack 0x%x\n",
                          (UINT32) pluginState->stackObj);
        return;
        }

    pIpDnsInterface = (PPP_IP_DNS_INTERFACE *)pppIpDnsInterface.interfaceObj;

    /* set the primary and secondary DNS server addresses to the */
    /* addresses negotiated by IPCP 				 */

    pIpDnsInterface->ipDnsAddressSet(pppIpDnsInterface.state,
	    ((primaryDnsUpdate == TRUE) ? pStackData->primaryDnsAddr:NULL),
	    ((secondaryDnsUpdate == TRUE) ? pStackData->secondaryDnsAddr:NULL));

    pfwInterfaceReferenceDelete(pppIpDnsInterface.interfaceObj);
    }


/*******************************************************************************
* copy_negotiated_ipcp_options_to_mib_variables -
*/
LOCAL void copy_negotiated_ipcp_options_to_mib_variables
    (
    PFW_PLUGIN_OBJ_STATE * pluginState
    )
    {
    IPCP_STACK_DATA * pStackData    = (IPCP_STACK_DATA *) pluginState->stackData;
    NCP_STACK_DATA *  pNcpStackData = (NCP_STACK_DATA *) pluginState->stackData;

    UINT8   vjcParameters[4] = {0,0,0,0};

    /* LOCAL SIDE: tx_accepted: Remote to Local */

    if (copy_option (&pNcpStackData->option_lists.tx_accepted,
             IP_COMPRESSION_OPTION_TYPE, vjcParameters, sizeof(vjcParameters))
                                                                      == PASS)
        {
	/* Get the Van Jacobson configuration parameters */

        pStackData->ipcp_mibs.pppIpRemoteToLocalCompressionProtocol = 
            M2_pppIpRemoteToLocalCompressionProtocol_vj_tcp;
        pStackData->ipcp_mibs.pppIpLocalMaxSlotId = vjcParameters[2];
        }
    else
        {
        pStackData->ipcp_mibs.pppIpRemoteToLocalCompressionProtocol = 
            M2_pppIpRemoteToLocalCompressionProtocol_none;
        pStackData->ipcp_mibs.pppIpLocalMaxSlotId = 0;
        }

    /* REMOTE SIDE: rx_accepted: Local to Remote */

    if ((copy_option (&pNcpStackData->option_lists.rx_accepted,
                IP_COMPRESSION_OPTION_TYPE, vjcParameters, sizeof(vjcParameters)))
                                                                     == PASS)
        {
	/* Get the Van Jacobson configuration parameters */

        pStackData->ipcp_mibs.pppIpLocalToRemoteCompressionProtocol = 
            M2_pppIpLocalToRemoteCompressionProtocol_vj_tcp;
        pStackData->ipcp_mibs.pppIpRemoteMaxSlotId = vjcParameters[2];
        }
    else
        {
        pStackData->ipcp_mibs.pppIpLocalToRemoteCompressionProtocol =
            M2_pppIpLocalToRemoteCompressionProtocol_none;
        pStackData->ipcp_mibs.pppIpRemoteMaxSlotId = 0;
        }

    /* Set the IP Operational Status in the MIB to open */

    pStackData->ipcp_mibs.pppIpOperStatus = M2_pppIpOperStatus_opened;

    pStackData->ipcp_mibs.pppIpConfigAdminStatus = 
					M2_pppIpConfigAdminStatus_open;
    }


/*******************************************************************************
* copVJCOption -  calls the VJC interface functions to copy the VJC 
* configuration option
* 
* RETURNS: N/A
*/

LOCAL STATUS copyVJCOption 
    (
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState
    )
    {
    PFW_OBJ	*              pPfwObj        = NULL;
    PPP_VJC_INTERFACE *    pVjcInterface  = NULL;
    PFW_PLUGIN_OBJ_STATE * pVjcState      = NULL;
    PFW_PLUGIN_OBJ *       pVjcPluginObj  = NULL;
    USHORT                 protocolType   = 0;
    BYTE                   numberOfSlots  = 0;
    BYTE                   connIdCompress = 0;
    BYTE                   vjcMaxSlotId   = 0;
    int                    id             = 0;
    char *                 cp             = NULL;
    IPCP_STACK_DATA *      pStackData     = NULL;
    NCP_STACK_DATA *       pNcpStackData  = NULL;
    BYTE                   compressionParameters[SIZE_OF_VJC_PARAMS];

    pPfwObj        = pPfwPlugingObjState->pluginObj->pfwObj;
    pStackData     = (IPCP_STACK_DATA *) pPfwPlugingObjState->stackData;
    pNcpStackData  = (NCP_STACK_DATA *)  pPfwPlugingObjState->stackData;

    if ((copy_option (&pNcpStackData->option_lists.rx_accepted, 
                        IP_COMPRESSION_OPTION_TYPE, compressionParameters, 
                           SIZE_OF_VJC_PARAMS)) != PASS)
        return ERROR;

    cp = (char *) &compressionParameters[0];
    GETSHORT (protocolType, cp);
    GETCHAR (vjcMaxSlotId, cp);
    GETCHAR (connIdCompress, cp);

    if ((pVjcPluginObj = (PFW_PLUGIN_OBJ *)pfwComponentObjGetByProtocol (
           pPfwObj, (UINT)protocolType)) == NULL)
        {
        printf ("IPCP tlu failed to get VJC componentObj\n");
        return ERROR;
        }

    if ((pfwStackPluginObjAdd (pPfwPlugingObjState->stackObj, pVjcPluginObj))
                                                             == ERROR)
        {
        printf ("IPCP tlu failed to add VJC pluginObj\n");
        return ERROR;
        }

    if ((id = pfwInterfaceIdGet (pPfwObj, "PPP_VJC_INTERFACE")) > 0)
        {
        if (pfwInterfaceObjAndStateGetViaStackObj(pPfwPlugingObjState->stackObj,
                                  id, &pStackData->pppHCInterface) != OK)
            {
            pfwPrintError (__FILE__, "ipcp_this_layer_up", __LINE__, 
                                   NULL, pPfwPlugingObjState->stackObj, 
                                  "PPP_VJC_INTERFACE get error");
            printf ("PPP_VJC_INTERFACE get failed\n");
            return ERROR;
            }
        }
    else
        {
        printf ("VJC Interface Id Get failed \n");
        return ERROR;
        }

    pVjcInterface = (PPP_VJC_INTERFACE *)
                                    pStackData->pppHCInterface.interfaceObj;
    pVjcState     = pStackData->pppHCInterface.state;
	
    /* Set the Van Jacobson configuration parameters */

    numberOfSlots = vjcMaxSlotId + 1;
    pVjcInterface->setSlotNumbers (pVjcState, numberOfSlots);
    pVjcInterface->setConnIdCompress (pVjcState, (BOOL) connIdCompress);
    pStackData->compressionProtocolId = protocolType;
    pStackData->hcConfigured = TRUE;

    return OK;

    }


/*******************************************************************************
* copyHeaderCompressionOption - calls the HC interface functions
* 
* RETURNS: N/A
*/

LOCAL STATUS copyHeaderCompressionOption 
    (
    PFW_PLUGIN_OBJ_STATE *        pPfwPlugingObjState,
    PFW_INTERFACE_STATE_PAIR *    pHcInterfaceStatePair     
    )
    {
    PFW_PLUGIN_OBJ *              pHcPluginObj           = NULL;
    HC_CONFIGURATION_OPTION       hcConfigInfo;
    HC_PPP_CONFIGURATION_OPTION * pHcConfigData          = NULL;
    OPTION_LIST_ENTRY *           pIpCompressionOption   = NULL;
    PFW_OBJ	*                     pPfwObj                = NULL;
    PPP_HC_INTERFACE *            pHcInterface           = NULL;
    PFW_PLUGIN_OBJ_STATE *        pHcPluginObjState      = NULL;
    int                           hcComponentInterfaceId = 0;
    NCP_STACK_DATA *              pNcpStackData          = 
                         (NCP_STACK_DATA *) pPfwPlugingObjState->stackData;



    pPfwObj = pPfwPlugingObjState->pluginObj->pfwObj;

    pIpCompressionOption = find_matching_option (
                                  &pNcpStackData->option_lists.configured, 
                                  IP_COMPRESSION_OPTION_TYPE);
    if (NULL == pIpCompressionOption)
        return ERROR;

    memset (&hcConfigInfo, 0x0, sizeof (HC_CONFIGURATION_OPTION));
    memcpy (&hcConfigInfo, pIpCompressionOption->uptr_data, 
                                  pIpCompressionOption->length);

    pHcConfigData = pfwMalloc (pPfwObj, 
                                  sizeof (HC_PPP_CONFIGURATION_OPTION));
    if (NULL == pHcConfigData)
        return ERROR;


    /* Set wether the compression is for IPCP or IPV6CP */

    if (0 == strcmp (pPfwPlugingObjState->pluginObj->name, "PPP_IPV6CP"))
        pHcConfigData->protocol = PPP_IPV6_PROTOCOL;
    else if (0 == strcmp (pPfwPlugingObjState->pluginObj->name, "PPP_IPCP"))
        pHcConfigData->protocol = PPP_IP_PROTOCOL;
    else
        {
        printf ("%s: Invalid access to Header Compression \n",
                      pPfwPlugingObjState->pluginObj->name);
        pfwFree (pHcConfigData);
        return ERROR;
        }   
       
    pHcConfigData->isActive       = TRUE;
    pHcConfigData->tcpSpace       = ntohs (hcConfigInfo.tcpSpace);
    pHcConfigData->nonTcpSpace    = ntohs (hcConfigInfo.nonTcpSpace);
    pHcConfigData->fMaxPeriod     = ntohs (hcConfigInfo.fMaxPeriod);
    pHcConfigData->fMaxTime       = ntohs (hcConfigInfo.fMaxTime);
    pHcConfigData->maxHeader      = ntohs (hcConfigInfo.maxHeader);

    if ((0 != hcConfigInfo.rtCompressionType) && 
                                  (0 != hcConfigInfo.rtCompressionLength))
        pHcConfigData->rtpCompressionEnabled = TRUE;
    else
        pHcConfigData->rtpCompressionEnabled = FALSE;

    pHcPluginObj = (PFW_PLUGIN_OBJ *) pfwPluginObjGet (pPfwObj, "HC");

    if (NULL == pHcPluginObj)
        {
        printf ("%s failed to get HC component Obj \n",
                 pPfwPlugingObjState->pluginObj->name);
        pfwFree (pHcConfigData);
        return ERROR;
        }   

    if (ERROR == hcComponentStackAdd (pPfwPlugingObjState->stackObj,
                                   pHcPluginObj))
        {
        printf ("HC component Addition failed for %s \n",
                 pPfwPlugingObjState->pluginObj->name);
        pfwFree (pHcConfigData);
        return ERROR;
        }

    hcComponentInterfaceId = pfwInterfaceIdGet (pPfwObj, "PPP_HC_INTERFACE");

    if (0 == hcComponentInterfaceId)
        {
        printf ("%s failed to get PPP_HC_INTERFACE interface id \n",
                 pPfwPlugingObjState->pluginObj->name);
        pfwFree (pHcConfigData);
        return ERROR;
        }   

    if (pfwInterfaceObjAndStateGetViaStackObj (pPfwPlugingObjState->stackObj,
                     hcComponentInterfaceId, pHcInterfaceStatePair) != OK)
        {
        printf ("%s failed to get HC interface state pair \n",
                 pPfwPlugingObjState->pluginObj->name); 
        pfwFree (pHcConfigData);
        return ERROR;
        }

	/* Set the Header Compression configuration parameters */

    pHcInterface      = (PPP_HC_INTERFACE *) 
                                  pHcInterfaceStatePair->interfaceObj;
    pHcPluginObjState = pHcInterfaceStatePair->state;

    if (ERROR == pHcInterface->hcInitialize (pHcPluginObjState, pHcConfigData))
        {
        printf ("%s failed in intializing HC interface: hcInitialize () \n",
                 pPfwPlugingObjState->pluginObj->name); 
        pfwFree (pHcConfigData);
        return ERROR;
        }

    /* We have to free only if HC Interface doesn't take care this */

    pfwFree (pHcConfigData);

    return OK;

    }


/******************************************************************************
* hcComponentStackAdd - Adding the HC component to the stack
*
* This function adds the HC Component to the stack if it's not been added
* previously. If the component is already added it returns OK
*
* RETURNS: OK - if addition is successful or if HC component has already been added
*          ERROR - only if the pfwStackPluginObjAdd fails
*/

LOCAL STATUS hcComponentStackAdd
    (
    PFW_STACK_OBJ *        pPfwStackObj,
    PFW_PLUGIN_OBJ *       pHcPfwPluginObj
    )
    {
    PFW_PLUGIN_OBJ_STATE * pPfwPlugingObjState = NULL;

    pPfwPlugingObjState = pfwPluginObjStateGet (pPfwStackObj, pHcPfwPluginObj);

    /* Add the HC component only if not in the stack */

    if (NULL == pPfwPlugingObjState)
        {
        if (ERROR == pfwStackPluginObjAdd (pPfwStackObj, pHcPfwPluginObj))
            {
#ifdef PPP_DEBUG
            printf ("HC Component Addition to the stack 0x%x failed \n",
                    (UINT32) pPfwStackObj);
#endif
            return ERROR;
            }
        }

    return OK;
    }