pppradiuscomponent.c

这是全套的PPP协议的源码

       while (*str && (*str != ':')) str++;

       if (*str == ':')
           {
           *str = 0;
            str ++;
           }
       }

    if ((serverData->serverConfig = (RADIUS_SERVER_CONFIG *) 
               pfwMalloc(pfw, serverData->serverCount *
               sizeof (RADIUS_SERVER_CONFIG))) == NULL)
       {
       return;
       }

    str = serverData->serverString;

    for (i = 0; i < serverData->serverCount; i++)
       {
       serverData->serverConfig[i].IpAddress = str;
       str += strlen (str) + 1;
       serverData->serverConfig[i].portNumber = atoi(str);
       str += strlen (str) + 1;
       }

    serverData->serverFlag = RADIUS_SERVER_OTHER;
    }


/*******************************************************************************
* radiusProcessFramedRoute - parse the framed route attribute from server
*
* The format of framed attribute value returned by RADIUS server is a string
*  "destination[/mask] gateway metrics ..."
*
*/
LOCAL void radiusProcessFramedRoute
    (
    char * configString,
    RADIUS_RECEIVED_ATTRIBUTES * attr,
    PFW_OBJ * pfw
    )
    {
    char * pDest = 0;
    char * pMask = 0;
    char * pGate = 0;
    char * str;
    ULONG ipAddr;

    pDest = str = configString;

    /* scan for destination IP address in dot decimal notation */
    while (*str && (isdigit(*str) || (*str == '.'))) str++;

    /* the destination IP address should be followed by space or '/' */
    if ((*str != ' ') && (*str != '/'))
       {
       return;
       }

    /* see if the destination IP is followed by netmask */
    if (*str == '/')
       {
       *str = 0; str ++;
       pMask = str;

       while (*str && (isdigit(*str))) str++;

       if (*str != ' ')
          {
          return;
          }
       }


    *str = 0; str ++;
    pGate = str;

    /* scan for gateway IP address in dot decimal notation */
    while (*str && (isdigit(*str) || (*str == '.'))) str++;

    if (*str != ' ')
       {
       return;
       }
    *str = 0;

    /* free old data, if any */
    if (attr->gateway != NULL)
        pfwFree(attr->gateway);
    if (attr->destination != NULL)
        pfwFree(attr->destination);

    attr->gateway = pfwMalloc(pfw, strlen(pGate) + 1);
    attr->destination = pfwMalloc(pfw, strlen(pDest) + 1);

    if (attr->destination != NULL)
       strcpy(attr->destination, pDest);

    if (attr->gateway != NULL)
       strcpy(attr->gateway, pGate);

    if (pMask)
       {
       attr->destMask = 0xffffffff << (32 - atoi(pMask));
       }
    else
       {
       /* if netmask is absent,  infer from the destination IP */

       ipAddr = inet_addr(pDest);
       
       if (IN_CLASSA(ipAddr))
	   {
           attr->destMask = IN_CLASSA_NET;
	   }
       else if (IN_CLASSB(ipAddr))
	   {
           attr->destMask = IN_CLASSB_NET;
           }
       else
	   {
           attr->destMask = IN_CLASSC_NET;
           }
       }

    }

/*******************************************************************************
* radius_serviceType
*
*/
LOCAL STATUS radius_serviceType
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE opertype,
    void *pData,
    char *value
    )
    {
    char ** pConfigString;
    RADIUS_PROFILE_DATA * pProfileData = (RADIUS_PROFILE_DATA *)pData;

    pConfigString = &pProfileData->radius_serviceType;

    return radius_stringProfileHandler (pfw, opertype,
                                        pConfigString, value);
    }

/*******************************************************************************
* radius_authenticationServer
*
*/
LOCAL STATUS radius_authenticationServer
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE opertype,
    void *pData,
    char *value
    )
    {
    char ** pConfigString;
    RADIUS_PROFILE_DATA * pProfileData = (RADIUS_PROFILE_DATA *)pData;

    pConfigString = &pProfileData->radius_authenticationServer;

    return radius_stringProfileHandler (pfw, opertype,
                                        pConfigString, value);
    }

/*******************************************************************************
* radius_accountingServer
*
*/
LOCAL STATUS radius_accountingServer
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE opertype,
    void *pData,
    char *value
    )
    {
    char ** pConfigString;
    RADIUS_PROFILE_DATA * pProfileData = (RADIUS_PROFILE_DATA *)pData;

    pConfigString = &pProfileData->radius_accountingServer;

    return radius_stringProfileHandler (pfw, opertype,
                                        pConfigString, value);
    }

/*******************************************************************************
* radius_nasIPaddress
*
*/
LOCAL STATUS radius_nasIPaddress
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE opertype,
    void *pData,
    char *value
    )
    {
    char ** pConfigString;
    RADIUS_PROFILE_DATA * pProfileData = (RADIUS_PROFILE_DATA *)pData;

    pConfigString = &pProfileData->radius_nasIPaddress;

    return radius_stringProfileHandler (pfw, opertype,
                                        pConfigString, value);
    }

/*******************************************************************************
* radius_nasIdentifier
*
*/
LOCAL STATUS radius_nasIdentifier
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE opertype,
    void *pData,
    char *value
    )
    {
    char ** pConfigString;
    RADIUS_PROFILE_DATA * pProfileData = (RADIUS_PROFILE_DATA *)pData;

    pConfigString = &pProfileData->radius_nasIdentifier;

    return radius_stringProfileHandler (pfw, opertype,
                                        pConfigString, value);
    }

/*******************************************************************************
* radius_radius_authenticationServer_retries
*
*/
LOCAL STATUS radius_authenticationServer_retries
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE opertype,
    void *pData,
    char *value
    )
    {
    ULONG * pConfigData;
    RADIUS_PROFILE_DATA * pProfileData = (RADIUS_PROFILE_DATA *)pData;

    pConfigData = &pProfileData->radius_authenticationServer_retries;

    return radius_longProfileHandler (pfw, opertype,
                                        pConfigData, value);
    }

/*******************************************************************************
* radius_radius_accountingServer_retries
*
*/
LOCAL STATUS radius_accountingServer_retries
    (
    PFW_OBJ *pfw,
    PFW_PARAMETER_OPERATION_TYPE opertype,
    void *pData,
    char *value
    )
    {
    ULONG * pConfigData;
    RADIUS_PROFILE_DATA * pProfileData = (RADIUS_PROFILE_DATA *)pData;

    pConfigData = &pProfileData->radius_accountingServer_retries;

    return radius_longProfileHandler (pfw, opertype,
                                        pConfigData, value);
    }

/*******************************************************************************
* radius_stringProfileHandler -
*
*/

LOCAL STATUS radius_stringProfileHandler
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE opertype,
    char **pConfigString, 
    char *value
    )
    {
    int valueLength;
    int stringLength;

    if ((value == NULL) || (pConfigString == NULL))
	return (ERROR);

    if (opertype == PFW_PARAMETER_SET)
	{
	valueLength = strlen(value);

        if (*pConfigString != NULL)
            {
            /* do we have a long enough buffer */
            if ((stringLength = strlen(*pConfigString)) < valueLength)
                {
                pfwFree(*pConfigString);
                *pConfigString = NULL;
                }
            }

        stringLength = valueLength;

        if (*pConfigString == NULL)
            if ((*pConfigString = pfwMalloc(pfw,stringLength + 1)) == NULL)
                return ERROR;

        bzero(*pConfigString,stringLength+1);
        strcpy(*pConfigString,value);

        return OK;
        }

    if (opertype == PFW_PARAMETER_GET)
        {
	if (*pConfigString) sprintf(value,"{%s}",*pConfigString);
        return OK;
        }

    return (ERROR);
    }


/*******************************************************************************
* radius_intProfileHandler -
*
*/

LOCAL STATUS radius_longProfileHandler
    (
    PFW_OBJ * pfw,
    PFW_PARAMETER_OPERATION_TYPE opertype,
    ULONG *pConfigData, 
    char *value
    )
    {
    int configValue;

    if ((value == NULL) || (pConfigData == NULL))
	return (ERROR);

    if (opertype == PFW_PARAMETER_SET)
	{
	if ((configValue = atoi(value)) > 0)
	    *pConfigData = configValue;

	return (OK);
        }

    if (opertype == PFW_PARAMETER_GET)
        {
	sprintf(value,"%ld",*pConfigData);
        return OK;
        }

    return (ERROR);
    }


/*******************************************************************************
* radiusClearPapData - free PAP authentication data 
*
*/
LOCAL void radiusClearPapData
    (
    PAP_AUTHENTICATION_DATA *pap
    )
    {

    if (pap->userName != NULL)
        pfwFree(pap->userName);
    if (pap->password != NULL)
        pfwFree(pap->password);

    if (pap->attributeRequestHandle)
       radius_delete_attribute_list(pap->attributeRequestHandle);
    if (pap->attributeResponseHandle)
       radius_delete_attribute_list(pap->attributeResponseHandle);

    bzero ((void *)pap, sizeof (PAP_AUTHENTICATION_DATA));
    }

/*******************************************************************************
* radiusClearChapData - free CHAP authentication data 
*
*/
LOCAL void radiusClearChapData
    (
    CHAP_AUTHENTICATION_DATA *chap
    )
    {

    if (chap->userName != NULL)
        pfwFree(chap->userName);
    if (chap->response != NULL)
        pfwFree(chap->response);
    if (chap->challenge != NULL)
        pfwFree(chap->challenge);

    if (chap->attributeRequestHandle)
       radius_delete_attribute_list(chap->attributeRequestHandle);
    if (chap->attributeResponseHandle)
       radius_delete_attribute_list(chap->attributeResponseHandle);

    bzero ((void *)chap, sizeof (CHAP_AUTHENTICATION_DATA));
    }

/*******************************************************************************
* radiusClearAcctData - free accounting data 
*
*/
LOCAL void radiusClearAcctData