pppbacpcomponent.c

这是全套的PPP协议的源码

	    		strcpy(partialString,pBacpConfigStrings->configString);

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

			/* process local alternates */

			alternateConfigString = pBacpConfigStrings->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,
				    					   bacpOption->name,
				    					   bacpOption->optionType,"BACP",
				    					   bacpOption->optionTypeString) != OK)
					{
					return ERROR;
					}

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

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

			/* process remote alternates */

			alternateConfigString = 
							pBacpConfigStrings->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,
					    					bacpOption->name,
					    					bacpOption->optionType,"BACP",
					    					bacpOption->optionTypeString) != OK)
					{
					return ERROR;
					}

	    		alternateConfigString = alternateConfigString->next;
	    		}
			}

	/* free the BACP config strings from the profile data */

    	for (options = 1; options <= NUMBER_OF_BACP_OPTIONS; options++)
			{
			bacpOptionConfigStringsFree 
								(&pProfileData->bacpConfigStrings[options]);
			}

       
        if (pProfileData->bacpConfigStrings != NULL)
          {
          pfwFree (pProfileData->bacpConfigStrings);
          pProfileData->bacpConfigStrings = NULL;     
          }
       }

	
	/* set the state data */

	pStackData->stateData.action_table = &bacpStateActionTable;
	pStackData->stateData.old_state = PPP_INITIAL_STATE;
	pStackData->stateData.state = PPP_INITIAL_STATE;

	/* initialize the favored peer id */

	pStackData->local_favored_peer_id = 0xffffffff;
	pStackData->remote_favored_peer_id = 0;
	pStackData->favored_peer_is_me = FALSE;

	pProfileData->stackData = pStackData;

	return OK;
	}

/*******************************************************************************
* bacpStackDataDestruct - clean up stack data 
*
* When the BACP plugin object is deleted from the stack, this function is called 
* to do the clean up. The memory used by the option_lists, the send queues and 
* the active port queue is freed. 
*
* RETURNS: OK or ERROR
*/
LOCAL STATUS bacpStackDataDestruct
	(
	PFW_OBJ * pfw,			/* framework reference */
	void * stackData,		/* stack data */
	void * profileData		/* profile data */
	)
	{
	BACP_STACK_DATA * pStackData = (BACP_STACK_DATA *) stackData;

	/* free the option lists */ 

	free_ppp_option_lists (&pStackData->option_lists);
	
	/* free the active port queue */

	free_active_port_list ((LINK *)&pStackData->active_port_queue);

	/* free the send queue */

	free_bap_buffer_list ((LINK *) &pStackData->call_request_send_queue);
	free_bap_buffer_list ((LINK *) &pStackData->callback_request_send_queue);
	free_bap_buffer_list ((LINK *) &pStackData->link_drop_request_send_queue);
	free_bap_buffer_list ((LINK *) &pStackData->call_indication_send_queue);

	return OK;
	}

/*******************************************************************************
* bacpProfileDataConstruct - initialize BACP profile data
*
* The framework calls this function when the first configuration parameter 
* associated with the Plugin object is added to the profile to initialize the 
* profile data associated with the Plugin object. This function initializes 
* the profile data parameters to their default values and calls 
* bacp_optionsHandler () to copy the default option string into 
* the option member of profile data. 
*
* RETURNS: OK or ERROR
*/
LOCAL STATUS bacpProfileDataConstruct
	(
	PFW_OBJ * pfw, 			/* framework reference */
	void * pData			/* profile data */
	)
	{
	BACP_PROFILE_DATA * pProfileData = (BACP_PROFILE_DATA *) pData;

	bzero (pData, sizeof (BACP_PROFILE_DATA));

	/* initialize the non negotiable profile parameters */

	pProfileData->maximum_number_of_bacp_configuration_requests =
								MAXIMUM_CONFIGURATION_REQUESTS;

	pProfileData->maximum_bacp_configuration_request_send_interval = 
							MAXIMUM_CONFIGURATION_REQUEST_SEND_INTERVAL;

	pProfileData->maximum_bacp_configuration_request_backoff_interval = 0;

	pProfileData->maximum_number_of_bacp_termination_requests = 
								MAXIMUM_TERMINATION_REQUESTS;

	pProfileData->maximum_bacp_termination_request_send_interval = 
							MAXIMUM_TERMINATION_REQUEST_SEND_INTERVAL;

	pProfileData->maximum_number_of_configuration_failures = 
								MAXIMUM_CONFIGURATION_FAILURES;

	pProfileData->maximum_number_of_bap_call_requests =
							MAXIMUM_BAP_CALL_REQUESTS;

	pProfileData->maximum_bap_call_request_send_interval = 
							MAXIMUM_BAP_CALL_REQUEST_RETRANSMIT_INTERVAL;

	pProfileData->maximum_number_of_bap_callback_requests =
							MAXIMUM_BAP_CALLBACK_REQUESTS;

	pProfileData->maximum_bap_callback_request_send_interval =  
							MAXIMUM_BAP_CALLBACK_REQUEST_RETRANSMIT_INTERVAL;

	pProfileData->maximum_number_of_bap_linkdrop_requests =
							MAXIMUM_BAP_LINKDROP_REQUESTS;

	pProfileData->maximum_bap_linkdrop_request_send_interval = 
							MAXIMUM_BAP_LINKDROP_REQUEST_RETRANSMIT_INTERVAL;

	pProfileData->maximum_number_of_bap_status_indications =
							MAXIMUM_BAP_STATUS_INDICATIONS;

	pProfileData->maximum_bap_status_indication_send_interval = 
							MAXIMUM_BAP_STATUS_INDICATION_RETRANSMIT_INTERVAL;

	/* generate config string structures for the BACP options */

	pProfileData->bacpConfigStrings = pfwMalloc (pfw, sizeof (BACP_CONFIG_STRINGS)
												 * (NUMBER_OF_BACP_OPTIONS + 1)); 

	if (pProfileData->bacpConfigStrings == NULL)
		return ERROR;

	bzero ((char *)pProfileData->bacpConfigStrings, 
		   sizeof (BACP_CONFIG_STRINGS) * (NUMBER_OF_BACP_OPTIONS + 1));



	/* set a default value */ 

	bacp_optionsHandler (pfw, BACP_FAVORED_PEER, PFW_PARAMETER_SET,
			pProfileData, "Local:Negotiation Required,Negotiable");

	bacp_optionsHandler (pfw, BACP_FAVORED_PEER, PFW_PARAMETER_SET,
			pProfileData, "Remote:Negotiation Required,Negotiable");
 
	return OK;
	}

/*******************************************************************************
* bacpProfileDataDestruct - clean up profile data 
*
* The framework calls this function before freeing the profile data so that all 
* the internal structures be freed. This function frees the memory held by the 
* option member of BACP_PROFILE_DATA structure. 
*
* RETURNS: OK or ERROR
*/
LOCAL STATUS bacpProfileDataDestruct
    (
	PFW_OBJ * pfw,			/* framework reference */
	void * profileData		/* profile data */
	)
	{
	BACP_PROFILE_DATA * pProfileData = (BACP_PROFILE_DATA *) profileData;
	UINT options = 0;

	/* free profile remote config string */

	
	if (!pProfileData->bacpConfigStrings)
		return OK;

    /* free profile config strings */

  	for (options = 1; options <= NUMBER_OF_BACP_OPTIONS; options++)
	    {
	    bacpOptionConfigStringsFree (&pProfileData->bacpConfigStrings[options]);
	    }
    if (pProfileData->bacpConfigStrings != NULL)
        {
        pfwFree (pProfileData->bacpConfigStrings);
        pProfileData->bacpConfigStrings = NULL;     
        }
    return OK;
	}

/*******************************************************************************
* bacpProfileDataCopy - profileData object copy constructor
*
* The framework calls this function to copy the profile data to another profile.
* This function copies profile data from a source profile to destination profile.
*
* RETURNS: OK or ERROR
*/
LOCAL STATUS bacpProfileDataCopy
    (
	PFW_OBJ * pfw,			/* framework reference */
	void * srcProfileData,	/* source profile data */
	void * dstProfileData	/* destination profile data */
	)
	{
	BACP_PROFILE_DATA * pSrcProfileData = (BACP_PROFILE_DATA *) srcProfileData;
	BACP_PROFILE_DATA * pDstProfileData = (BACP_PROFILE_DATA *) dstProfileData;
	BACP_CONFIG_STRINGS * pSrcOption = NULL;
	BACP_CONFIG_STRINGS * pDstOption = NULL;
	ALTERNATE_OPTION_STRING * pAlternateConfigString = NULL;
	ALTERNATE_OPTION_STRING * pNewAlternateString = NULL;
	UINT options = 0;
	UINT stringLength = 0;

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

	if (!pSrcProfileData->bacpConfigStrings)
		return OK;

	pDstProfileData->bacpConfigStrings = 
	pfwMalloc (pfw, sizeof (BACP_CONFIG_STRINGS) * (NUMBER_OF_BACP_OPTIONS + 1)); 

	if (!pDstProfileData->bacpConfigStrings)
		{
	    bacpProfileDataDestruct(pfw,pDstProfileData);
		return ERROR;
		}

	bzero ((char *)pDstProfileData->bacpConfigStrings, 
		   sizeof (BACP_CONFIG_STRINGS) * (NUMBER_OF_BACP_OPTIONS + 1));

	for (options = 1; options < NUMBER_OF_BACP_OPTIONS; options++)
		{
		pSrcOption = &pSrcProfileData->bacpConfigStrings [options];
		pDstOption = &pDstProfileData->bacpConfigStrings [options];

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

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

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

			bzero (pDstOption->configString, stringLength);
			strcpy (pDstOption->configString, pSrcOption->configString);
			}

		pAlternateConfigString = pSrcOption->localAlternateConfigString;
		pNewAlternateString = NULL;

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

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

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

			bzero ((void *)pNewAlternateString,
					(stringLength + sizeof (ALTERNATE_OPTION_STRING)));

			pNewAlternateString->preference = 
									pAlternateConfigString->preference;
			strcpy (pNewAlternateString->configString,
					pAlternateConfigString->configString);

			pAlternateConfigString = pAlternateConfigString->next;
			}

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

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

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

			bzero (pDstOption->remoteConfigString, stringLength);
			strcpy (pDstOption->remoteConfigString, 
								pSrcOption->remoteConfigString);
			}

		pAlternateConfigString = pSrcOption->remoteAlternateConfigString;
		pNewAlternateString = NULL;

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

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

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

			bzero ((void *)pNewAlternateString,
					(stringLength + sizeof (ALTERNATE_OPTION_STRING)));

			pNewAlternateString->preference = 
									pAlternateConfigString->preference;

			strcpy (pNewAlternateString->configString,
						pAlternateConfigString->configString);

			pAlternateConfigString = pAlternateConfigString->next;
			}

		}
	return OK;
	}