ppplcpcomponent.c

这是全套的PPP协议的源码

	lcp_optionsHandler (pfw,LCP_MAGIC_NUMBER,PFW_PARAMETER_SET,
	    pProfileData,"Remote:Negotiation Not Required,Negotiable:0");

/* WindNet Multilink - Start */

    lcp_optionsHandler (pfw,LCP_MULTILINK_MAXIMUM_RECEIVED_RECONSTRUCTED_UNIT,
					PFW_PARAMETER_SET, pProfileData,
					"Local:"); 

    lcp_optionsHandler (pfw,LCP_MULTILINK_MAXIMUM_RECEIVED_RECONSTRUCTED_UNIT,
					PFW_PARAMETER_SET, pProfileData,
					"Remote:"); 

    lcp_optionsHandler (pfw,LCP_LINK_DISCRIMINATOR,
					PFW_PARAMETER_SET, pProfileData,
					"Local:"); 

    lcp_optionsHandler (pfw,LCP_LINK_DISCRIMINATOR,
					PFW_PARAMETER_SET, pProfileData,
					"Remote:"); 

/* WindNet Multilink - End */

    return OK;
    }

/*******************************************************************************
* lcp_setStackData - 
*/
LOCAL STATUS lcp_setStackData
    (
    PFW_OBJ             *pfw,
    LCP_PROFILE_DATA    *profileData,
	LCP_CONFIG_OPTION	*lcpOption,
	char				*value
    )
    {
    LCP_STACK_DATA 		*pStackData = profileData->stackData;
    OPTION_LIST 		*optionList = NULL;
    OPTION_LIST_ENTRY 	*optionEntry = NULL;
    char 				partialString[256];
    int 				stringLength = 0;
	BOOLEAN				isLocalConfig;
	BOOLEAN				bDeleteEntry=FALSE;
    
    /* Continue only if this profile is associated with stack */
	if (!pStackData)
        {
	    return OK;
        }

	if (value == NULL)
		return ERROR;

	if (strstr(value,"Remote") != NULL)
		{
 		isLocalConfig = FALSE;
 		if (strlen (value) <= 7) /* 7 ==> strlen("Remote:") */
			{
			bDeleteEntry = TRUE;
			}
		}
	else if (strstr (value, "Local") != NULL)
		{
		isLocalConfig = TRUE;
		if (strlen (value) <= 6) /* 6 ==> strlen("Local:") */
			{
			bDeleteEntry = TRUE;
			}
		}
	else
		return ERROR;
	

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

	if (bDeleteEntry)
		{
		optionEntry = find_matching_option(optionList,lcpOption->optionType);
		if (optionEntry != NULL)
			{
    		delete_entry_from_list((LINK *) optionList,(LINK *) optionEntry);
       		free_ppp_option_list_entry(optionEntry);
			free_ppp_tx_accepted_option_list(
  				             &pStackData->option_lists.tx_accepted);
			}
		return OK;
		}

	free_ppp_tx_accepted_option_list(
  				             &pStackData->option_lists.tx_accepted);


	stringLength = strlen(value) + 1;
	bzero(partialString,stringLength);
	strcpy(partialString,value);

	if (generate_option_list_entry(pfw,&pStackData->option_lists,
				    partialString,
				    lcpOption->name,
				    lcpOption->optionType,"LCP",
				    lcpOption->optionTypeString) != OK)
		{
		return ERROR;
		}

	return OK;
    }

/*******************************************************************************
* lcpProfileDataCopy - profileData object copy constructor
*
*
*/
LOCAL STATUS lcpProfileDataCopy
    (
    PFW_OBJ * pfw,
    void * srcProfileData,
    void * dstProfileData
    )
    {
    LCP_PROFILE_DATA * pSrcProfileData = (LCP_PROFILE_DATA *) srcProfileData;
    LCP_PROFILE_DATA * pDstProfileData = (LCP_PROFILE_DATA *) dstProfileData;
    LCP_CONFIG_STRINGS * srcOption = NULL;
    LCP_CONFIG_STRINGS * dstOption = NULL;
    ALTERNATE_OPTION_STRING * alternateConfigString = NULL;
    ALTERNATE_OPTION_STRING * newAlternateString = NULL;
    unsigned int options = 0;
    unsigned int stringLength = 0;

	bzero (dstProfileData, sizeof(LCP_PROFILE_DATA));
    bcopy(srcProfileData,dstProfileData, sizeof(LCP_PROFILE_DATA));

	if (!pSrcProfileData->lcpConfigStrings)
		return OK;

	pDstProfileData->lcpConfigStrings = 
	pfwMalloc (pfw, sizeof (LCP_CONFIG_STRINGS) * (NUMBER_OF_LCP_OPTIONS + 1)); 

	if (!pDstProfileData->lcpConfigStrings)
		{
	    lcpProfileDataDestruct(pfw,pDstProfileData);
		return ERROR;
		}

	bzero ((char *)pDstProfileData->lcpConfigStrings, 
		   sizeof (LCP_CONFIG_STRINGS) * (NUMBER_OF_LCP_OPTIONS + 1));

  	for (options = 1; options < NUMBER_OF_LCP_OPTIONS; options++)
	{
	srcOption = &pSrcProfileData->lcpConfigStrings[options];
	dstOption = &pDstProfileData->lcpConfigStrings[options];

	if (srcOption->configString != NULL)
	    {
	    stringLength = strlen(srcOption->configString)+1;

	    /* make a copy of the remote string */

	    if ((dstOption->configString = pfwMalloc(pfw,stringLength)) == NULL)
		{
		lcpProfileDataDestruct (pfw,pDstProfileData);
		return ERROR;
		}

	    bzero(dstOption->configString,stringLength);
	    strcpy(dstOption->configString,srcOption->configString);
	    }

	alternateConfigString = srcOption->localAlternateConfigString;
	newAlternateString = NULL;

	while (alternateConfigString != NULL)
	    {
	    stringLength = strlen(alternateConfigString->configString) + 1;

	    /* make a copy of the alternate config string */

	    if (newAlternateString != NULL)
		{
		if((newAlternateString->next = pfwMalloc(pfw,stringLength +
				    sizeof(ALTERNATE_OPTION_STRING))) == NULL)
		    {
		    lcpProfileDataDestruct(pfw,pDstProfileData);
		    return ERROR;
		    }
		else
		    newAlternateString = newAlternateString->next;
		}
	    else 
		{
		if((newAlternateString = pfwMalloc(pfw,stringLength +
				    sizeof(ALTERNATE_OPTION_STRING))) == NULL)
		    {
		    lcpProfileDataDestruct(pfw,pDstProfileData);
		    return ERROR;
		    }
		else
		    dstOption->localAlternateConfigString = newAlternateString;
		}

	    bzero ((void *)newAlternateString,
			    (stringLength + sizeof(ALTERNATE_OPTION_STRING)));
	    newAlternateString->preference = alternateConfigString->preference;
	    strcpy (newAlternateString->configString,
				    alternateConfigString->configString);

	    alternateConfigString = alternateConfigString->next;
	    }

	if (srcOption->remoteConfigString != NULL)
	    {
	    stringLength = strlen(srcOption->remoteConfigString)+1;

	    /* make a copy of the remote string */

	    if ((dstOption->remoteConfigString = pfwMalloc(pfw,stringLength))
		== NULL)
		{
		lcpProfileDataDestruct (pfw,pDstProfileData);
		return ERROR;
		}

	    bzero(dstOption->remoteConfigString,stringLength);
	    strcpy(dstOption->remoteConfigString,srcOption->remoteConfigString);
	    }

	alternateConfigString = srcOption->remoteAlternateConfigString;
	newAlternateString = NULL;

	while (alternateConfigString != NULL)
	    {
	    stringLength = strlen(alternateConfigString->configString) + 1;

	    /* make a copy of the alternate config string */

	    if (newAlternateString != NULL)
		{
		if((newAlternateString->next = pfwMalloc(pfw,stringLength +
				    sizeof(ALTERNATE_OPTION_STRING))) == NULL)
		    {
		    lcpProfileDataDestruct(pfw,pDstProfileData);
		    return ERROR;
		    }
		else
		    newAlternateString = newAlternateString->next;
		}
	    else 
		{
		if((newAlternateString = pfwMalloc(pfw,stringLength +
				    sizeof(ALTERNATE_OPTION_STRING))) == NULL)
		    {
		    lcpProfileDataDestruct(pfw,pDstProfileData);
		    return ERROR;
		    }
		else
		    dstOption->remoteAlternateConfigString = newAlternateString;
		}

	    bzero ((void *)newAlternateString,
			    (stringLength + sizeof(ALTERNATE_OPTION_STRING)));
	    newAlternateString->preference = alternateConfigString->preference;
	    strcpy (newAlternateString->configString,
				    alternateConfigString->configString);

	    alternateConfigString = alternateConfigString->next;
	    }

	}
	return OK;
    }

/*******************************************************************************
*lcpStackDataConstruct - initialize stack data 
*
*
*/
LOCAL STATUS lcpStackDataConstruct
    (
    PFW_OBJ * pfw,
    void * stackData,
    void * profileData
    )
    {
    LCP_STACK_DATA 			* pStackData = (LCP_STACK_DATA *) stackData;
    LCP_PROFILE_DATA 		*pProfileData = (LCP_PROFILE_DATA *) profileData;

    #if 0
    char * configString;
    #endif

    char partialString[256];
    LCP_CONFIG_OPTION		*lcpOption = NULL;
	LCP_CONFIG_STRINGS		*pLcpConfigStrings = NULL;
    ALTERNATE_OPTION_STRING *alternateConfigString = NULL;
    int 					options = 0;
    int 					stringLength = 0;
	PPP_LCP_COMPONENT		*pComponentData = NULL;

	pComponentData = (PPP_LCP_COMPONENT *)pfwPluginObjGet (pfw, "PPP_LCP");

	if (pComponentData == NULL)
		return ERROR;

	bzero (partialString, sizeof (partialString));
  	bzero(stackData, sizeof(LCP_STACK_DATA));

    pStackData->copy_of_initial_rxed_lcp_configuration_request_packet = NULL;
    pStackData->copy_of_last_rxed_lcp_configuration_request_packet = NULL;
    pStackData->copy_of_last_txed_lcp_configuration_request_packet = NULL;

	pProfileData->stackData = pStackData;  /* WindNet Multilink */

    if ((pStackData->lcpUpEventObj = pfwEventObjGet(pfw,"LCP_UP_EVENT")) ==NULL)
	{
	return ERROR;
	}

#if 0 /* WindNet Multilink - Not supported in this MP release */

    if ((pStackData->pEchoReplyReceivedEventObj = pfwEventObjGet(pfw,
									"LCP_ECHO_REPLY_RECEIVED_EVENT")) ==NULL)
	{
	return ERROR;
	}

#endif /* WindNet Multilink - Not supported in this MP release */

    if ((pStackData->netPoolId = pfwNetPoolIdGet(pfw)) == NULL)
	{
	printf("LCP: MUST have a valid NetPoolId; See pfwCreate()\n");
	return ERROR;
	}

    srandom((int) tickGet());

    pStackData->id_sequence_number = (BYTE)(tickGet() &0xff);

	if (pProfileData->lcpConfigStrings != NULL)
		{
    	for (options = 1; options < NUMBER_OF_LCP_OPTIONS; options++)
			{
			lcpOption = &pComponentData->option[options]; 
			pLcpConfigStrings = &pProfileData->lcpConfigStrings[options]; 

			if (pLcpConfigStrings->configString == NULL && 
	  			  pLcpConfigStrings->remoteConfigString == NULL)
	    		continue;

			if (pLcpConfigStrings->configString != NULL)
	    		{
	    		stringLength = strlen(pLcpConfigStrings->configString) + 1;
	    		bzero(partialString,stringLength);
	    		strcpy(partialString,pLcpConfigStrings->configString);

	    		if (generate_option_list_entry(
											pfw,&pStackData->option_lists,
					    					partialString,
					    					lcpOption->name,
					    					lcpOption->optionType,"LCP",
					    					lcpOption->optionTypeString) != OK)
						{
						return ERROR;
						}
	    		}

			/* process local alternates */

			alternateConfigString = pLcpConfigStrings->localAlternateConfigString;
			while (alternateConfigString != NULL)
	    		{
	    		stringLength = strlen(alternateConfigString->configString) + 1;
	    		bzero(partialString,stringLength);
	    		strcpy(partialString, alternateConfigString->configString);

	    		if (generate_option_list_entry(
										   pfw,&pStackData->option_lists,
				   						   partialString,
				    					   lcpOption->name,
				    					   lcpOption->optionType,"LCP",
				    					   lcpOption->optionTypeString) != OK)
					{
					return ERROR;
					}

	    		alternateConfigString = alternateConfigString->next;
	    		}
	
			if (pLcpConfigStrings->remoteConfigString != NULL)
	    		{
	    		stringLength = strlen(pLcpConfigStrings->remoteConfigString)+1;
	    		bzero(partialString,stringLength);
	    		strcpy(partialString, pLcpConfigStrings->remoteConfigString);

	    		if (generate_option_list_entry(
											pfw,&pStackData->option_lists,
					    					partialString,
					    					lcpOption->name,
					    					lcpOption->optionType,"LCP",
					    					lcpOption->optionTypeString) != OK)
					{
					return ERROR;
					}
	    		}

			/* process remote alternates */

			alternateConfigString = 
							pLcpConfigStrings->remoteAlternateConfigString;

			while (alternateConfigString != NULL)
	    		{
	    		stringLength = strlen(alternateConfigString->configString) + 1;
	    		bzero(partialString,stringLength);
	    		strcpy(partialString, alternateConfigString->configString);

	   		 	if (generate_option_list_entry(
											pfw,&pStackData->option_lists,
					   				 		partialString,
					    					lcpOption->name,
					    					lcpOption->optionType,"LCP",
					    					lcpOption->optionTypeString) != OK)