pppipcpcomponent.c

这是全套的PPP协议的源码

        }
	else
		return ERROR;

    optionList = (isLocalConfig) ? &pNcpStackData->option_lists.configured : 
                                 &pNcpStackData->option_lists.remote_configured;

	if (bDeleteEntry)
		{

		optionEntry = find_matching_option(optionList,ipcpOption->optionType);
		if (optionEntry != NULL)
			{
       		delete_entry_from_list((LINK *) optionList,(LINK *) optionEntry);
       		free_ppp_option_list_entry(optionEntry);
			}
        if (!isRasRemoteDone)
            {
			isRasRemoteDone = TRUE;
	        isLocalConfig = FALSE;
            goto ras_remote_configuration;
            }

		free_ppp_tx_accepted_option_list(
  				             &pNcpStackData->option_lists.tx_accepted);

        return OK;
		}

	bzero (partialString, sizeof (partialString));
	strcpy(partialString,value);

	if (generate_option_list_entry(pfw,&pNcpStackData->option_lists,
				    partialString,
				    ipcpOption->name,
				    ipcpOption->optionType,"IPCP",
				    ipcpOption->optionTypeString) != OK)
		{
		return ERROR;
		}
    if (!isRasRemoteDone)
        {
		isRasRemoteDone = TRUE;
        isLocalConfig = FALSE;
        goto ras_remote_configuration;
        }

	free_ppp_tx_accepted_option_list(
  				             &pNcpStackData->option_lists.tx_accepted);
    return OK;
    }

#if 0
/*******************************************************************************
* retry_ipcp_configure_request -
* NOMANUAL
*/
STATUS retry_ipcp_configure_request
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    int                   backoffStarted
    )
    {
    NCP_STACK_DATA * pNcpStackData = 
                                   (NCP_STACK_DATA *) pluginState->stackData;
    NCP_PROFILE_DATA * pNcpProfileData = 
			                       (NCP_PROFILE_DATA *) pluginState->profileData;


    if (pNcpStackData->stateData.state == PPP_STOPPED_STATE &&
        (backoffStarted > 0))
        {
        execute_ppp_state_machine (pluginState,PPP_DOWN_EVENT,NULL);
        execute_ppp_state_machine (pluginState,PPP_UP_EVENT,NULL);
        pNcpStackData->configuration_request_backoff_period_started = FALSE;
        return OK;
        }

    if ((pNcpStackData->stateData.state > PPP_STOPPING_STATE) && 
	(pNcpStackData->stateData.state < PPP_OPENED_STATE))
	{
	if (++pNcpStackData->number_of_ncp_configuration_requests <
	   (pNcpProfileData->maximum_number_of_configuration_requests))
	    {
	    execute_ppp_state_machine (pluginState,
		PPP_TIMEOUT_WITH_COUNTER_GREATER_THAN_ZERO_EVENT, NULL);
	    }
	else
	    {
	    if (pNcpStackData->last_txed_ncp_configuration_request_packet
		!= NULL)
		{
		netMblkClChainFree (
		    pNcpStackData->last_txed_ncp_configuration_request_packet);
		pNcpStackData->last_txed_ncp_configuration_request_packet=NULL;
		}

        if (pNcpStackData->last_rxed_ncp_configuration_request_packet
        != NULL)
        {
        netMblkClChainFree (
            pNcpStackData->last_rxed_ncp_configuration_request_packet);
        pNcpStackData->last_rxed_ncp_configuration_request_packet=NULL;
        }

	    execute_ppp_state_machine (pluginState,
				PPP_TIMEOUT_WITH_COUNTER_EXPIRED_EVENT,NULL);

	    pNcpStackData->number_of_ncp_configuration_requests = 0x00000000L;
			
	    if (pNcpStackData->stateData.state == PPP_STOPPED_STATE &&
                pNcpProfileData->maximum_configuration_request_backoff_interval> 0)
		{
		if (pfwTimerStart(pNcpStackData->ncp_timer,PFW_SECOND,
		   pNcpProfileData->maximum_configuration_request_backoff_interval,
		   retry_ipcp_configure_request,1) == ERROR)
		    {
		    printf ("Back off start failed: state = %d\n",
				    pNcpStackData->stateData.state);
		    }

		pNcpStackData->configuration_request_backoff_period_started = TRUE;
		}
	    }
	}
    return OK;
    }

/*******************************************************************************
* retry_ipcp_termination_request -
* NOMANUAL
*/
STATUS retry_ipcp_termination_request
    (
    PFW_PLUGIN_OBJ_STATE * pluginState,
    int arg
    )
    {
    NCP_STACK_DATA * pStackData = (NCP_STACK_DATA *) pluginState->stackData;
    NCP_PROFILE_DATA * pProfileData = 
			    (NCP_PROFILE_DATA *) pluginState->profileData;

    if ((pStackData->stateData.state == PPP_CLOSING_STATE) ||
	(pStackData->stateData.state == PPP_STOPPING_STATE))
	{
	if (pStackData->number_of_ncp_termination_requests < 
		pProfileData->maximum_number_of_termination_requests)
	    {
	    execute_ppp_state_machine (pluginState,
		PPP_TIMEOUT_WITH_COUNTER_GREATER_THAN_ZERO_EVENT,NULL);
	    }
	else
	    {
	    execute_ppp_state_machine (pluginState,
			PPP_TIMEOUT_WITH_COUNTER_EXPIRED_EVENT,NULL);
	    }
	}
    return OK;
    }

#endif
/*******************************************************************************************
 * setStackLRIpAddrFromRAS - sets the Local and Remote IP addresses for a stack connection
 *                           in progress.
 */
LOCAL STATUS setStackLRIpAddrFromRAS(PFW_PLUGIN_OBJ_STATE * componentState, void *eventData)
{
     unsigned int pppParam = 0;
     char paramBuf[512];
	 char ipaddrString[INET_ADDR_LEN];
     char *plid_ptr = NULL;
     UINT32 plid = 0;
     UINT32 routerId = 0;
     UINT32 hostIp = 0;
     struct in_addr ipaddr;
     IPCP_STACK_DATA * pIpcpStackData = (IPCP_STACK_DATA *)componentState->stackData;
     NCP_STACK_DATA *  pNcpStackData = (NCP_STACK_DATA *) &pIpcpStackData->stackData;
     OPTION_LIST_ENTRY * optionEntry = NULL;
     OPTION_LIST * optionList = NULL;

     bzero (paramBuf, sizeof (paramBuf));	

     pIpcpStackData->useRasAddress = FALSE;
     pIpcpStackData->validRasAddress = FALSE;

     pppParam = pfwParameterIdGet(componentState->pluginObj->pfwObj,"ipcp_ipAddr");
     pfwStackParamGet(componentState->stackObj, pppParam, paramBuf);

	 /* if we dont have a #, then there is no RAS pool, return 0 */
	 if ((char *)strstr(paramBuf, "#") == NULL)
		 return (OK);
     if (!(strtok_r(paramBuf,"#",&plid_ptr)))
         return (OK);
     plid = atoi(plid_ptr);

     pIpcpStackData->useRasAddress = TRUE;
 
     if (RAS_GetIpAddr(plid, &routerId, &hostIp) == ERROR)
         {
         optionList = &pNcpStackData->option_lists.configured;
         if ((optionEntry = find_matching_option(optionList,IP_ADDRESS_OPTION_TYPE))
             != NULL)
             {
             delete_entry_from_list((LINK *) optionList,(LINK *) optionEntry);
             free_ppp_option_list_entry(optionEntry);
             }

         optionList = &pNcpStackData->option_lists.remote_configured;
         if ((optionEntry = find_matching_option(optionList,IP_ADDRESS_OPTION_TYPE))
             != NULL)
             {
             delete_entry_from_list((LINK *) optionList,(LINK *) optionEntry);
             free_ppp_option_list_entry(optionEntry);
             }

         free_ppp_tx_accepted_option_list(&pNcpStackData->option_lists.tx_accepted);
         return (ERROR);
         }

     /* Change profile values for this stack */

     pIpcpStackData->validRasAddress = TRUE;

     bzero(paramBuf, 64);
     ipaddr.s_addr = htonl(routerId);
     bzero(ipaddrString, INET_ADDR_LEN);
     inet_ntoa_b(ipaddr, ipaddrString);
     sprintf(paramBuf,"Local:");
     sprintf(paramBuf,
             "Local:Negotiation Required,Not Negotiable:%s",
             ipaddrString);
     pfwStackParamSet(componentState->stackObj, pppParam, paramBuf);
     bzero(paramBuf, 64);
     ipaddr.s_addr = htonl(hostIp);
     bzero(ipaddrString, INET_ADDR_LEN);
     inet_ntoa_b(ipaddr, ipaddrString);
     sprintf(paramBuf,"Remote:");
     sprintf(paramBuf,
             "Remote:Negotiation Required,Not Negotiable:%s",
             ipaddrString);
     pfwStackParamSet(componentState->stackObj, pppParam, paramBuf);
     bzero(paramBuf, 64);
     sprintf(paramBuf, "Remote:Alternate:%s@%d",ipaddrString,plid);
     pfwStackParamSet(componentState->stackObj, pppParam, paramBuf);

     return (OK);
}

/*******************************************************************************************
 * relStackLRIpAddrToRAS - releases the IP address used for a stack connection that has
 *                         been terminated
 */

LOCAL STATUS relStackLRIpAddrToRAS
    (
    PFW_PLUGIN_OBJ_STATE * componentState,
    void *eventData
    )
    {
    unsigned int pppParam = 0;
    char paramBuf[512];
    char *pid_ptr = NULL;
    UINT32 plid = 0;
    char *ip_ptr = NULL;
    UINT32 hostIp = 0;
    IPCP_STACK_DATA *pIpcpStackData = (IPCP_STACK_DATA *)componentState->stackData;
    NCP_STACK_DATA * pNcpStackData = (NCP_STACK_DATA *) pIpcpStackData;

    /* Restore default values for next connection */

    ncpLinkReset (pNcpStackData);

    if (!pIpcpStackData->validRasAddress)
        return OK;

    bzero (paramBuf, sizeof (paramBuf));

    pppParam = pfwParameterIdGet(componentState->pluginObj->pfwObj,"ipcp_ipAddr");
    pfwStackParamGet(componentState->stackObj, pppParam, paramBuf);

    ip_ptr = strstr(paramBuf, "Alternate:");
    if (!ip_ptr)
        return (ERROR);
    ip_ptr += 10;
    if (!(strtok_r(ip_ptr,"@",&pid_ptr)))
        return (OK);
    pid_ptr = strtok_r(NULL,"}",&pid_ptr);
    if (!pid_ptr)
        return (OK);
    plid = atoi(pid_ptr);
    hostIp = ntohl(inet_addr(ip_ptr));

    pIpcpStackData->validRasAddress = FALSE;

    if (RAS_RelIpAddr(plid, hostIp) == ERROR)
        {
#ifdef PPP_DEBUG
        printf ("\nCAN NOT RETURN IP ADDRESS! pool = %d, IP = %x\n",plid, hostIp);
#endif /* PPP_DEBUG */
        return (ERROR);
        }

    /* restore the ipcp_ipAddr parameter */
    pfwStackParamSet(componentState->stackObj, pppParam, "Remote:");

    bzero(paramBuf, 64);
    sprintf(paramBuf,"Remote:");
    sprintf(paramBuf,"Local:");
    sprintf(paramBuf, "RAS-AMM#%d", plid);
    pfwStackParamSet(componentState->stackObj, pppParam, paramBuf);

    return (OK);
    }



/*******************************************************************************
* lcpOptionConfigStringsFree - frees the LCP option configuration string
*
*/
LOCAL void ipcpOptionConfigStringsFree 
	(
	IPCP_CONFIG_STRINGS	*pOptionConfigStrings
	)
	{
	ALTERNATE_OPTION_STRING	*alternateConfigString = NULL;
	ALTERNATE_OPTION_STRING	*nextAlternateString = NULL;

	if (pOptionConfigStrings != NULL)
		{
		if (pOptionConfigStrings->configString)
			{
			pfwFree ((void *)pOptionConfigStrings->configString);
			pOptionConfigStrings->configString = NULL;
			}


		if (pOptionConfigStrings->remoteConfigString)
			{
			pfwFree ((void *)pOptionConfigStrings->remoteConfigString);
			pOptionConfigStrings->remoteConfigString = NULL;
			}

		if (pOptionConfigStrings->alternateConfigString)
			{
			alternateConfigString = 
					pOptionConfigStrings->alternateConfigString;

			pOptionConfigStrings->alternateConfigString = NULL;

			while (alternateConfigString != NULL)
	    		{
	    		nextAlternateString = alternateConfigString->next;
	    		pfwFree((void *)alternateConfigString);
	    		alternateConfigString = nextAlternateString;
	    		}
			}

		}
	}


/*******************************************************************************
* initialize_ipcp_mibs -
* 
* NOMANUAL
*/
void initialize_ipcp_mibs
    (
    PFW_PLUGIN_OBJ_STATE * pluginState
    )
    {
    IPCP_STACK_DATA *pStackData = (IPCP_STACK_DATA *)pluginState->stackData;
    NCP_STACK_DATA *pNcpStackData = (NCP_STACK_DATA *) pluginState->stackData;
    IPCP_CONFIG_OPTION  *ipcpOption;

    pStackData->ipcp_mibs.pppIpOperStatus = M2_pppIpOperStatus_not_opened;
    pStackData->ipcp_mibs.pppIpLocalToRemoteCompressionProtocol = 
			M2_pppIpLocalToRemoteCompressionProtocol_none;
    pStackData->ipcp_mibs.pppIpRemoteToLocalCompressionProtocol =
			M2_pppIpRemoteToLocalCompressionProtocol_none;
    pStackData->ipcp_mibs.pppIpRemoteMaxSlotId = 0;
    pStackData->ipcp_mibs.pppIpLocalMaxSlotId = 0;
    pStackData->ipcp_mibs.pppIpConfigAdminStatus = 
			M2_pppIpConfigAdminStatus_close;

    if (copy_option (&pNcpStackData->option_lists.configured,
                    IP_COMPRESSION_OPTION_TYPE,
                    &ipcpOption,sizeof(ipcpOption))
        == FAIL)
        {
        pStackData->ipcp_mibs.pppIpConfigCompression =
                    M2_pppIpConfigCompression_none;
        }
    else
        {
        pStackData->ipcp_mibs.pppIpConfigCompression =
                     M2_pppIpConfigCompression_vj_tcp;
        }

    }



/*******************************************************************************
* getIpcpOptionName - Get IPCP option name from the IPCP Componet strcuture. 
* 
* RETURNS: IPCP option name address if found else NULL
*
* NOMANUAL
*/

char * getIpcpOptionName 
    (
    PFW_OBJ * pfw,      /* framework */
    char * optionName   /* option name to get */
    )
    {
    PPP_IPCP_COMPONENT * pComponentData = NULL;
    IPCP_CONFIG_OPTION * ipcpOption     = NULL;
    int options = 0;

    pComponentData = (PPP_IPCP_COMPONENT *) pfwPluginObjGet (pfw, "PPP_IPCP");

    if (pComponentData == NULL)
        return NULL;

    for (options = IP_COMPRESSION_OPTION_TYPE; options <= NUMBER_OF_IPCP_OPTIONS; options++)
        {
        ipcpOption = &pComponentData->option[options];
        if (strcmp (ipcpOption->name, optionName) == 0)
            {
            return (ipcpOption->name);
            }
        }
    return NULL;
	}