pppradiuscomponent.c

Radius PNE 3.3 source code, running at more than vxworks6.x version.

    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);
    }

#ifdef INET6
/*******************************************************************************
* radius_nasIPv6address
*
*/
LOCAL STATUS radius_nasIPv6address
    (
    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_nasIPv6address;

    return radius_stringProfileHandler (pfw, opertype,
                                        pConfigString, value);
    }
#endif /* INET6 */
/*******************************************************************************
* 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
    (
    ACCOUNTING_DATA *acct
    )
    {
    if (acct->attributeRequestHandle)
       radius_delete_attribute_list(acct->attributeRequestHandle);
    if (acct->attributeResponseHandle)
       radius_delete_attribute_list(acct->attributeResponseHandle);

    bzero ((void *)acct, sizeof (ACCOUNTING_DATA));
    }

/*******************************************************************************
* radiusClearRcvdAttr - free RADIUS server returned parameters
*
*/
LOCAL void radiusClearRcvdAttr
    (
    RADIUS_RECEIVED_ATTRIBUTES *attr
    )
    {
    if (attr->class != NULL)
        pfwFree(attr->class);
    if (attr->userName != NULL)
        pfwFree(attr->userName);
    if (attr->gateway != NULL)
        pfwFree(attr->gateway);
    if (attr->destination != NULL)
        pfwFree(attr->destination);
#ifdef INET6
    if (attr->destinationPrefix != NULL)
    pfwFree(attr->destinationPrefix);
    if (attr->gatewayIPv6 != NULL)
    pfwFree(attr->gatewayIPv6);
    if (attr->framedIPv6Pool != NULL)
    pfwFree(attr->framedIPv6Pool);
#endif /* INET6 */
    bzero ((void *)attr, sizeof (RADIUS_RECEIVED_ATTRIBUTES));
    }

/*******************************************************************************
* radiusClearServerData - free RADIUS server configuration
*
*/
LOCAL void radiusClearServerData
    (
    RADIUS_SERVER_DATA  *serverData
    )
    {
    if (serverData->serverString != NULL)
       pfwFree(serverData->serverString);

    if (serverData->serverConfig != NULL)
       pfwFree(serverData->serverConfig);

    bzero ((void *)serverData, sizeof (RADIUS_SERVER_DATA));
    }

/*******************************************************************************
* radiusIpcpUpEventHandler - Process IPCP UP event
*
* Routes and interface mask are set when IPCP reaches the open state
*/
LOCAL STATUS radiusIpcpUpEventHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void * eventData
    )
    {
    int id;
    PFW_OBJ       * pfwObj;
    PFW_STACK_OBJ * stackObj;
    PFW_PLUGIN_OBJ  * pluginObj;
    PFW_PLUGIN_OBJ_STATE * radiusState;
    RADIUS_STACK_DATA * pStackData;
    PPP_IP_ROUTES_INTERFACE  * ipRoutesInterface;
    PFW_PLUGIN_OBJ_STATE * ipState;
    RADIUS_RECEIVED_ATTRIBUTES * attr;

    pfwObj   = state->pluginObj->pfwObj;
    stackObj = state->stackObj;

    if ((pluginObj = pfwPluginObjGet(pfwObj, "PPP_RADIUS")) == NULL)
        {
        logMsg("Could not find PPP_RADIUS plugin object\n",
                          0, 0, 0, 0, 0, 0 );
        return ERROR;
        }

    if ((radiusState = pfwPluginObjStateGet(stackObj, pluginObj)) == NULL)
        {
        logMsg("Could not find PPP_RADIUS plugin object State\n",
                          0, 0, 0, 0, 0, 0 );
        return ERROR;
        }

    pStackData = (RADIUS_STACK_DATA *) radiusState->stackData;
    attr = &pStackData->rcvdAttributes;

    if (pStackData->pppIpRoutesInterface.interfaceObj == NULL)
    {
    if ((id = pfwInterfaceIdGet(pfwObj, "PPP_IP_ROUTES_INTERFACE")) > 0)
        {
        if (pfwInterfaceObjAndStateGetViaStackObj(stackObj,
                    id, &pStackData->pppIpRoutesInterface) != OK)
        {
        pfwPrintError (__FILE__, "radiusIpcpUpEventHandler",
                               __LINE__, NULL, stackObj,
                       "PPP_IP_ROUTES_INTERFACE get error");
        return ERROR;
        }
        }
    else
        return ERROR;
        }

    ipRoutesInterface =
    (PPP_IP_ROUTES_INTERFACE*)pStackData->pppIpRoutesInterface.interfaceObj;
    ipState = pStackData->pppIpRoutesInterface.state;

    /* Add route if both destination and gateway are present */
    if ((attr->destination != NULL) && (attr->gateway != NULL))
    {
        ipRoutesInterface->ipRouteAdd(ipState, attr->destination,
                                attr->gateway, attr->destMask, 0, 0);
        }

    /* Set interface mask */
    if (attr->ipNetMask)
        {
        ipRoutesInterface->ipSetIfMask(ipState, attr->ipNetMask);
        }

    return OK;
    }

/*******************************************************************************
* radiusIpcpDownEventHandler - Process IPCP DOWN event
*
* Routes are removed when the IPCP goes out of open state
*/
LOCAL STATUS radiusIpcpDownEventHandler
    (
    PFW_PLUGIN_OBJ_STATE * state,
    void * eventData
    )
    {
    PFW_OBJ       * pfwObj;
    PFW_STACK_OBJ * stackObj;
    PFW_PLUGIN_OBJ  * pluginObj;
    PFW_PLUGIN_OBJ_STATE * radiusState;
    RADIUS_STACK_DATA * pStackData;
    PPP_IP_ROUTES_INTERFACE  * ipRoutesInterface;
    PFW_PLUGIN_OBJ_STATE * ipState;
    RADIUS_RECEIVED_ATTRIBUTES * attr;

    pfwObj   = state->pluginObj->pfwObj;
    stackObj = state->stackObj;

    if ((pluginObj = pfwPluginObjGet(pfwObj, "PPP_RADIUS")) == NULL)
        {
        logMsg("Could not find PPP_RADIUS plugin object\n",
                          0, 0, 0, 0, 0, 0 );
        return ERROR;
        }

    if ((radiusState = pfwPluginObjStateGet(stackObj, pluginObj)) == NULL)
        {
        logMsg("Could not find PPP_RADIUS plugin object State\n",
                          0, 0, 0, 0, 0, 0 );
        return ERROR;
        }

    pStackData = (RADIUS_STACK_DATA *) radiusState->stackData;
    attr = &pStackData->rcvdAttributes;

    if (attr->destination == NULL)
    {
        return OK;
        }

    ipRoutesInterface =
    (PPP_IP_ROUTES_INTERFACE*)pStackData->pppIpRoutesInterface.interfaceObj;
    ipState = pStackData->pppIpRoutesInterface.state;

    /* Delete the installed route */
    if (ipRoutesInterface)
        {
        ipRoutesInterface->ipRouteDelete(ipState,
                         attr->destination, attr->destMask, 0, 0);