Sample code for Data Profiles

static const char DefaultCid[] = "default";
static const char automaticApn[] = "auto";
static const char PdpIpv4[] = "ipv4";
static const char PdpIpv6[] = "ipv6";
static const char PdpIpv4v6[] = "ipv4v6";
static const char AuthPap[] = "pap";
static const char AuthChap[] = "chap";
static const char AuthPapChap[] = "pap-chap";
static const char Map[] = "map";
static const char Cid[] = "cid";
static const char Rmnet[] = "rmnet";
 
// Structure used to set the configuration
typedef struct
{
    char   cid[10];                                 // profile identifier
    char   pdp[10];                                 // packet data protocol
    char   apn[LE_MDC_APN_NAME_MAX_LEN];            // access point network
    char   auth[10];                                // authentication level
    char   userName[LE_MDC_USER_NAME_MAX_LEN];      // username for authentication
    char   password[LE_MDC_PASSWORD_NAME_MAX_LEN];  // password for authentication
}
Configuration_t;
 
// Tests cases
typedef enum
{
    TEST_SYNC,
    TEST_ASYNC,
    TEST_MAX
} Testcase_t;
 
// Tests definition
struct
{
    char testName[20];
    Testcase_t  testCase;
} testsDef[] = {
                    TEST_DEF(TEST_SYNC),
                    TEST_DEF(TEST_ASYNC),
                    TEST_DEF(TEST_MAX)
};
 
//! [Data_session]
//--------------------------------------------------------------------------------------------------
/**
 * Session handler response for connection and disconnection.
 */
//--------------------------------------------------------------------------------------------------
static void SessionHandlerFunc
(
    le_mdc_ProfileRef_t profileRef,
    le_result_t result,
    void* contextPtr
)
{
    le_result_t* activationPtr = contextPtr;
    *activationPtr = result;
 
    LE_INFO("Session result %d for profile %d", result, le_mdc_GetProfileIndex(profileRef));
 
    le_sem_Post(AsyncTestSemaphore);
}
 
//--------------------------------------------------------------------------------------------------
/**
 * Start asynchronous session.
 */
//--------------------------------------------------------------------------------------------------
static void SessionStartAsync
(
    void* param1Ptr,
    void* param2Ptr
)
{
    le_mdc_ProfileRef_t profileRef = param1Ptr;
 
    le_mdc_StartSessionAsync(profileRef, SessionHandlerFunc, param2Ptr);
}
 
//--------------------------------------------------------------------------------------------------
/**
 * Stop asynchronous session.
 */
//--------------------------------------------------------------------------------------------------
static void SessionStopAsync
(
    void* param1Ptr,
    void* param2Ptr
)
{
    le_mdc_ProfileRef_t profileRef = param1Ptr;
 
    le_mdc_StopSessionAsync(profileRef, SessionHandlerFunc, param2Ptr);
}
//! [Data_session]
//--------------------------------------------------------------------------------------------------
/**
 * Set the configuration.
 *
 */
//--------------------------------------------------------------------------------------------------
static void SetConfiguration
(
    le_mdc_ProfileRef_t* profileRefPtr
)
{
    // Check the configuration file
    FILE* configFilePtr = fopen("/tmp/config.txt","r");
    Configuration_t configuration;
 
    memset(&configuration, 0, sizeof(Configuration_t));
 
    // if configuration file absent, use default settings
    if (NULL == configFilePtr)
    {
        le_utf8_Copy(configuration.cid, DefaultCid, sizeof(configuration.cid), NULL);
        le_utf8_Copy(configuration.pdp, PdpIpv4, sizeof(configuration.pdp), NULL);
        le_utf8_Copy(configuration.apn, automaticApn, sizeof(configuration.apn), NULL);
    }
    else
    {
        // Get the configuration from the file
        fseek(configFilePtr, 0, SEEK_END);
        uint32_t len = ftell(configFilePtr);
        char cmdLine[ len + 1 ];
        char* saveLinePtr;
        char* saveParamPtr;
        char* cmdLinePtr;
 
        memset(cmdLine,0,len+1);
        fseek(configFilePtr, 0, SEEK_SET);
        fread(cmdLine, 1, len, configFilePtr);
        fclose(configFilePtr);
 
        // Get first line
        cmdLinePtr = strtok_r(cmdLine, "\r\n", &saveLinePtr);
 
        // Get profile number
        char* cidPtr =  strtok_r(cmdLinePtr, " ", &saveParamPtr);
        LE_ASSERT(NULL != cidPtr);
        le_utf8_Copy(configuration.cid, cidPtr, sizeof(configuration.cid), NULL);
 
        // Get pdp type
        char* pdpPtr = strtok_r(NULL, " ", &saveParamPtr);
        LE_ASSERT(NULL != pdpPtr);
        le_utf8_Copy(configuration.pdp, pdpPtr, sizeof(configuration.pdp), NULL);
 
        // Get apn
        char* apnPtr = strtok_r(NULL, " ", &saveParamPtr);
        LE_ASSERT(NULL != apnPtr);
        le_utf8_Copy(configuration.apn, apnPtr, sizeof(configuration.apn), NULL);
 
        // Get authentication
        char* authPtr = strtok_r(NULL, " ", &saveParamPtr);
        if (NULL != authPtr)
        {
            le_utf8_Copy(configuration.auth, authPtr, sizeof(configuration.auth), NULL);
        }
 
        // Get username
        char* userNamePtr = strtok_r(NULL, " ", &saveParamPtr);
        if (NULL != userNamePtr)
        {
            le_utf8_Copy(configuration.userName, userNamePtr, sizeof(configuration.userName), NULL);
        }
 
        // Get password
        char* passwordPtr = strtok_r(NULL, " ", &saveParamPtr);
        if (NULL != passwordPtr)
        {
            le_utf8_Copy(configuration.password, passwordPtr, sizeof(configuration.password), NULL);
        }
 
        // Get optional lines
        cmdLinePtr = strtok_r(NULL, "\r\n", &saveLinePtr);
 
        while (cmdLinePtr)
        {
            char* optionPtr = strtok_r(cmdLinePtr, " ", &saveParamPtr);
 
            // Check mapping cid
            if (strncmp(optionPtr, Map, strlen(Map)) == 0)
            {
                LE_INFO("mapping cid");
                char* cidPtr = strtok_r(NULL, " ", &saveParamPtr);
 
                if (strncmp(cidPtr, Cid, strlen(Cid)) == 0)
                {
                    int cid = strtol((const char*) cidPtr+strlen(Cid), NULL, 10);
 
                    if (0 != errno)
                    {
                        LE_ERROR("Bad cid %d %m", errno);
                        exit(EXIT_FAILURE);
                    }
 
                    LE_INFO("map cid %d", cid);
 
                    char* rmnetPtr = strtok_r(NULL, " ", &saveParamPtr);
 
                    if (0 == strncmp(rmnetPtr, Rmnet, strlen(Rmnet)))
                    {
                        int rmnet = strtol(rmnetPtr+strlen(Rmnet), NULL, 10);
 
                        if (0 != errno)
                        {
                            LE_ERROR("Bad rmnet %d %m", errno);
                            exit(EXIT_FAILURE);
                        }
 
                        le_mdc_ProfileRef_t profileRef = le_mdc_GetProfile(cid);
 
                        char string[20];
                        memset(string,0,sizeof(string));
                        snprintf(string,sizeof(string),"rmnet_data%d", rmnet);
                        LE_INFO("cid %d rmnet: %s", cid, string);
 
                        LE_ASSERT(le_mdc_MapProfileOnNetworkInterface(profileRef, string) == LE_OK);
                    }
                }
            }
 
            cmdLinePtr = strtok_r(NULL, "\r\n", &saveLinePtr);
        }
    }
 
    uint32_t profile;
 
    if ( strncmp(configuration.cid, DefaultCid, sizeof(DefaultCid)) == 0 )
    {
        profile = LE_MDC_DEFAULT_PROFILE;
    }
    else
    {
        profile = strtol(configuration.cid, NULL, 10);
 
        if (errno != 0)
        {
            LE_ERROR("Bad profile %d %m", errno);
            exit(EXIT_FAILURE);
        }
    }
//! [Profile_parameters]
    // Get the profile reference
    *profileRefPtr = le_mdc_GetProfile(profile);
    LE_ASSERT(NULL != *profileRefPtr);
 
    // Check the current state of the cid
    le_mdc_ConState_t state = LE_MDC_DISCONNECTED;
 
    // Check the state
    LE_ASSERT(LE_OK == le_mdc_GetSessionState(*profileRefPtr, &state));
 
    // If already connected, disconnect the session
    if (LE_MDC_CONNECTED == state)
    {
        LE_ASSERT(le_mdc_StopSession(*profileRefPtr) == LE_OK);
    }
 
    // Set pdp type
    le_mdc_Pdp_t pdp = LE_MDC_PDP_UNKNOWN;
 
    if (0 == strncmp(configuration.pdp, PdpIpv4, sizeof(PdpIpv4)))
    {
        pdp = LE_MDC_PDP_IPV4;
    }
    else if (0 == strncmp(configuration.pdp, PdpIpv6, sizeof(PdpIpv6)))
    {
        pdp = LE_MDC_PDP_IPV6;
    }
    else if (0 == strncmp(configuration.pdp, PdpIpv4v6, sizeof(PdpIpv4v6)))
    {
        pdp = LE_MDC_PDP_IPV4V6;
    }
 
    LE_ASSERT(LE_OK == le_mdc_SetPDP(*profileRefPtr, pdp));
 
    // Set APN
    if (0 == strncmp(configuration.apn, automaticApn, sizeof(automaticApn)))
    {
        // Set default APN
        LE_ASSERT(LE_OK == le_mdc_SetDefaultAPN(*profileRefPtr));
    }
    else
    {
        LE_ASSERT(LE_OK == le_mdc_SetAPN(*profileRefPtr, configuration.apn));
    }
 
    le_mdc_Auth_t auth = LE_MDC_AUTH_NONE;
    if ('\0' != configuration.auth[0])
    {
        // Set the authentication, username and password
        if (0 == strncmp(configuration.auth, AuthPapChap, sizeof(AuthPapChap)))
        {
            auth = LE_MDC_AUTH_PAP | LE_MDC_AUTH_CHAP;
        }
        // Set the authentication, username and password
        else if (0 == strncmp(configuration.auth, AuthPap, sizeof(AuthPap)))
        {
            auth = LE_MDC_AUTH_PAP;
        }
        else if (0 == strncmp(configuration.auth, AuthChap, sizeof(AuthChap)))
        {
            auth = LE_MDC_AUTH_CHAP;
        }
 
        if (LE_MDC_AUTH_NONE != auth)
        {
            LE_ASSERT(LE_OK == le_mdc_SetAuthentication(*profileRefPtr,
                                                auth,
                                                configuration.userName,
                                                configuration.password));
        }
    }
 
    LE_INFO("cid: %d pdp: %d apn: %s auth: %d username: %s password: %s",
            le_mdc_GetProfileIndex(*profileRefPtr), pdp, configuration.apn, auth,
            configuration.userName, configuration.password);
}