pppradiuscomponent.c

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

        }

    return OK;
    }

#ifdef INET6
/*******************************************************************************
* radiusIpv6cpUpEventHandler - Process IPV6CP UP event
*
* Routes and interface mask are set when IPV6CP reaches the open state
*/
LOCAL STATUS radiusIpv6cpUpEventHandler
    (
    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;
    RADIUS_RECEIVED_ATTRIBUTES * attr;
    char routeString[80];

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

    memset(&routeString[0], '\0', sizeof (routeString));

    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;


    /* Add IPv6 route if destination prefix, gateway and prefix length are present */
    if ((attr->destPrefixLength != 0) && (attr->gatewayIPv6 != NULL)
                        && (attr->destinationPrefix != NULL))
    {
        sprintf (routeString, "add -net -inet6 %s %s -prefixlen %u", attr->destinationPrefix,
            attr->gatewayIPv6, attr->destPrefixLength);
    }
    /* Add IPv6 route if only destination prefix and gateway are present */
    else if ((attr->destPrefixLength == 0) && (attr->gatewayIPv6 != NULL)
                        && (attr->destinationPrefix != NULL))
    {
        sprintf (routeString, "add -net -inet6 %s %s", attr->destinationPrefix,
            attr->gatewayIPv6);
    }


    routec(&routeString[0]);

    return OK;
    }

/*******************************************************************************
* radiusIpv6cpDownEventHandler - Process IPV6CP DOWN event
*
* Routes are removed when the IPV6CP goes out of open state
*/
LOCAL STATUS radiusIpv6cpDownEventHandler
    (
    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;
    RADIUS_RECEIVED_ATTRIBUTES * attr;
    char routeString[80];

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

    memset(&routeString[0], '\0', sizeof (routeString));
    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;

    /* Delete IPv6 route if destination prefix, gateway and prefix length are present */
    if ((attr->destPrefixLength != 0) && (attr->gatewayIPv6 != NULL)
                        && (attr->destinationPrefix != NULL))
    {
        sprintf (routeString, "delete -net -inet6 %s %s -prefixlen %u", attr->destinationPrefix,
            attr->gatewayIPv6, attr->destPrefixLength);
    }
    /* Delete IPv6 route if only destination prefix and gateway are present */
    else if ((attr->destPrefixLength == 0) && (attr->gatewayIPv6 != NULL)
                        && (attr->destinationPrefix != NULL))
    {
        sprintf (routeString, "delete -net -inet6 %s %s", attr->destinationPrefix,
            attr->gatewayIPv6);
    }

    routec(&routeString[0]);

    return OK;
}


#endif /* INET6 */
/*******************************************************************************
* challengeAuthVerify - Authenticate the user using CHAP
*
* Send an RADIUS_ACCESS_REQUEST to the RADIUS server to authenticate the user
*/
LOCAL void challengeAuthVerify
    (
    PFW_PLUGIN_OBJ_STATE * state,
    char * userName,
    char * response,
    unsigned int responseLen,
    char * challenge,
    unsigned int challengeLen,
    BYTE id,
    CHALLENGE_AUTH_METHOD method,
    REMOTE_AUTHENTICATION_CALLBACKS * radiusCallbacks
    )
    {
    RADIUS_SERVER_HANDLE  authServerHandle;
    RADIUS_ATTRIBUTE_LIST_HANDLE attributeListHandle;
    CHAP_AUTHENTICATION_DATA * chap;
    PFW_OBJ                  * pfw;
    RADIUS_STACK_DATA        * pStackData;
    PFW_PLUGIN_OBJ_STATE     * adapterState;
    PHY_PORT_INTERFACE       * phyPortInterface;
    UINT                       nasPort, nasPortType;
    PPP_LINK_STATUS_ENTRY_INTERFACE *pppLinkStatusEntryInterface;
    PFW_PLUGIN_OBJ_STATE     * lcpState;
    UINT               framedMTU;

    pfw = state->pluginObj->pfwObj;
    pStackData = (RADIUS_STACK_DATA *) state->stackData;
    chap = &pStackData->chapAuthData;

    if (pfwPluginObjStateLock (state) == ERROR)
    {
    logMsg("challengeAuthVerify - unable to lock state\n",
                          0, 0, 0, 0, 0, 0 );
    return;
    }

    /* Allow authentication only if configured */
    if (!(pStackData->radiusFlags & RADIUS_ALLOW_AUTHENTICATION))
        {
        pfwPluginObjStateRelease (state);
        radiusCallbacks->authErrorCallback(state, id);
        return;
        }

    /* Ignore authenticate request if previous request is pending */
    if (pStackData->radiusState & RADIUS_CHAP_AUTH_PENDING)
        {
        pfwPluginObjStateRelease (state);
#ifdef PPP_DEBUG
        logMsg("CHAP Authentication Pending, Ignoring...\n",
                    0, 0, 0, 0, 0, 0);
#endif /* PPP_DEBUG */
        chap->id = id;
        return;
    }

    if ((authServerHandle = get_radius_server(&pStackData->authServerData,
         RADIUS_AUTHENTICATION_SERVER_TYPE)) == INVALID_HANDLE)
        {
        pfwPluginObjStateRelease (state);
        radiusCallbacks->authErrorCallback(state, id);
#ifdef PPP_DEBUG
        logMsg("Could not get proper RADIUS server handle\n", 0, 0, 0, 0, 0, 0);
#endif
        return;
        }

#ifdef PPP_DEBUG
        logMsg("Got RADIUS server handle\n", 0, 0, 0, 0, 0, 0);
#endif

        chap->userName = pfwMalloc (pfw, strlen(userName) + 1);
        chap->response = pfwMalloc (pfw, responseLen + 1);
        chap->challenge = pfwMalloc (pfw, challengeLen);
        attributeListHandle = radius_create_attribute_list();

        if ((attributeListHandle == INVALID_HANDLE) ||
            (chap->userName == NULL) ||
            (chap->response == NULL) ||
            (chap->challenge == NULL))
        {
        pfwPluginObjStateRelease (state);
        radiusClearChapData(chap);
        radiusCallbacks->authErrorCallback(state, id);
#ifdef PPP_DEBUG
        logMsg("Could not get proper attribute list handle\n", 0, 0, 0, 0, 0, 0);
#endif
        return;
        }
#ifdef PPP_DEBUG
        logMsg("Got proper attribute list handle\n", 0, 0, 0, 0, 0, 0);
#endif
        phyPortInterface = (PHY_PORT_INTERFACE *)
            pStackData->physicalPortInterface.interfaceObj;
        adapterState =
            pStackData->physicalPortInterface.state;

        if (phyPortInterface != NULL)
       {
           nasPort = htonl(phyPortInterface->portNumberGet(adapterState));
           nasPortType = htonl(phyPortInterface->portTypeGet(adapterState));
           }

        pppLinkStatusEntryInterface = (PPP_LINK_STATUS_ENTRY_INTERFACE *)
        pStackData->pppLinkStatusEntryInterface.interfaceObj;
        lcpState = pStackData->pppLinkStatusEntryInterface.state;

        if (pppLinkStatusEntryInterface != NULL)
        {
        framedMTU = htonl(pppLinkStatusEntryInterface->pppLinkStatusRemoteMRUGet(lcpState));/* Remote MRU may be the local MTU */
        }

        bzero(chap->userName, strlen(userName) + 1);
        bcopy(userName, chap->userName, strlen(userName));
        bcopy(challenge, chap->challenge, challengeLen);
        bcopy(response, chap->response + 1, responseLen);

#ifdef PPP_DEBUG
        logMsg("Now to chapping\n", 0, 0, 0, 0, 0, 0);
#endif
        chap->id = id;
        chap->response[0] = id;
        chap->responseLen = responseLen;
        chap->challengeLen = challengeLen;
        chap->pfw = pfw;
        chap->state = state;
        chap->pStackData = pStackData;
        chap->radiusCallbacks = radiusCallbacks;
        chap->attributeRequestHandle = attributeListHandle;
        pStackData->state = state;
        radius_add_attribute_to_list (attributeListHandle,
           RADIUS_USER_NAME, strlen(userName), (BYTE *) userName);

#ifdef PPP_DEBUG
        logMsg("username added\n", 0, 0, 0, 0, 0, 0);
#endif

        radius_add_attribute_to_list (attributeListHandle,
           RADIUS_CHAP_PASSWORD, responseLen + 1, (BYTE *) chap->response);

#ifdef PPP_DEBUG
        logMsg("chap passowrd added\n", 0, 0, 0, 0, 0, 0);
#endif
        radius_add_attribute_to_list (attributeListHandle,
           RADIUS_CHAP_CHALLENGE, challengeLen, (BYTE *) challenge);

#ifdef PPP_DEBUG
        logMsg("chap challenge added\n", 0, 0, 0, 0, 0, 0);
#endif

        radius_add_attribute_to_list (attributeListHandle,
           RADIUS_SERVICE_TYPE, 4, (BYTE *) &pStackData->serviceType);

#ifdef PPP_DEBUG
        logMsg("service type added\n", 0, 0, 0, 0, 0, 0);
#endif

        radius_add_attribute_to_list (attributeListHandle,
           RADIUS_FRAMED_PROTOCOL, 4, (BYTE *) &pStackData->framedProtocol);

#ifdef PPP_DEBUG
        logMsg("Framed protocol added\n", 0, 0, 0, 0, 0, 0);
#endif
        if (phyPortInterface != NULL)
       {
           radius_add_attribute_to_list (attributeListHandle,
              RADIUS_NAS_PORT, 4, (BYTE *) &nasPort);

           radius_add_attribute_to_list (attributeListHandle,
              RADIUS_NAS_PORT_TYPE, 4, (BYTE *) &nasPortType);
       }

#ifdef PPP_DEBUG
        logMsg("Added NAS port type\n", 0, 0, 0, 0, 0, 0);
#endif

    if (pppLinkStatusEntryInterface != NULL)
        {
        radius_add_attribute_to_list (attributeListHandle,
           RADIUS_FRAMED_MTU, 4, (BYTE *) &framedMTU);
        }

#ifdef INET6
         if (!IN6_IS_ADDR_UNSPECIFIED (&(pStackData->nasIPv6address)))
         {
#ifdef PPP_DEBUG
        logMsg("Address is not unspecified\n", 0, 0, 0, 0, 0, 0);
#endif

             radius_add_attribute_to_list (attributeListHandle,
                RADIUS_NAS_IPV6_ADDRESS, 16, (BYTE *) &(pStackData->nasIPv6address));

         }
#endif
        if (pStackData->nasIdentifier != NULL)
           radius_add_attribute_to_list (attributeListHandle,
               RADIUS_NAS_IDENTIFIER, strlen(pStackData->nasIdentifier),
                            (BYTE *) pStackData->nasIdentifier);

        if (pStackData->nasIPaddress != 0)
           radius_add_attribute_to_list (attributeListHandle,
               RADIUS_NAS_IP_ADDRESS, 4, (BYTE *) &pStackData->nasIPaddress);

        radiusClearRcvdAttr(&pStackData->rcvdAttributes);

        pStackData->radiusState |= RADIUS_CHAP_AUTH_PENDING;
        ++pStackData->numberOfRadiusPendingRequest;
        pfwPluginObjStateRelease (state);

#ifdef PPP_DEBUG
        logMsg("radiusSendRequest being sent\n", 0, 0, 0, 0, 0, 0);
#endif
        netJobAdd((FUNCPTR) radiusSendRequest, (int) authServerHandle,
           (int) chap, (int) &pStackData->chapRequestCallbacks,
           (int) RADIUS_ACCESS_REQUEST, (int) chap->attributeRequestHandle);
    }

/*******************************************************************************
* passwordAuthVerify - Authenticate the user using PAP
*
* Send an RADIUS_ACCESS_REQUEST to the RADIUS server to authenticate the user
*/
LOCAL void passwordAuthVerify
    (
    PFW_PLUGIN_OBJ_STATE * state,
    char * userName,
    char * password,
    BYTE id,
    REMOTE_AUTHENTICATION_CALLBACKS * radiusCallbacks
    )
    {
    RADIUS_SERVER_HANDLE  authServerHandle;
    RADIUS_ATTRIBUTE_LIST_HANDLE attributeListHandle;
    PAP_AUTHENTICATION_DATA * pap;
    PFW_OBJ                 * pfw;
    RADIUS_STACK_DATA       * pStackData;
    PFW_PLUGIN_OBJ_STATE    * adapterState;
    PHY_PORT_INTERFACE      * phyPortInterface;
    UINT                      nasPort, nasPortType;
    PPP_LINK_STATUS_ENTRY_INTERFACE *pppLinkStatusEntryInterface;
    PFW_PLUGIN_OBJ_STATE     * lcpState;
    UINT               framedMTU;


    pfw = state->pluginObj->pfwObj;
    pStackData = (RADIUS_STACK_DATA *) state->stackData;
    pap = &pStackData->papAuthData;

    if (pfwPluginObjStateLock (state) == ERROR)
    {
    logMsg("passwordAuthVerify - unable to lock state\n",
                          0, 0, 0, 0, 0, 0 );
    return;
    }

    /* Allow authentication only if configured */
    if (!(pStackData->radiusFlags & RADIUS_ALLOW_AUTHENTICATION))
        {
        pfwPluginObjStateRelease (state);
        radiusCallbacks->authErrorCallback(state, id);
        return;
        }

    /* Ignore authenticate request if previous request is pending */
    if (pStackData->radiusState & RADIUS_PAP_AUTH_PENDING)
        {
        pfwPluginObjStateRelease (state);
#ifdef PPP_DEBUG
        logMsg("PAP Authentication Pending, Ignoring...\n",
                    0, 0, 0, 0, 0, 0);
#endif /* PPP_DEBUG */
        pap->id = id;
        return;
    }

    if ((authServerHandle = get_radius_server(&pStackData->authServerData,
         RADIUS_AUTHENTICATION_SERVER_TYPE)) == INVALID_HANDLE)
        {
        pfwPluginObjStateRelease (state);
        radiusCallbacks->authErrorCallback(state, id);
        return;
        }

#ifdef PPP_DEBUG
        logMsg("Got RADIUS server handle...\n",
                    0, 0, 0, 0, 0, 0);
#endif /* PPP_DEBUG */

        pap->userName = pfwMalloc (pfw, strlen(userName) + 1);
        pap->password = pfwMalloc (pfw, strlen(password) + 1);
        attributeListHandle = radius_crea