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";


// 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];                                // authentification level
    char   userName[LE_MDC_USER_NAME_MAX_LEN];      // username for authentification
    char   password[LE_MDC_PASSWORD_NAME_MAX_LEN];  // password for authentification
}
Configuration_t;

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
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 (configFilePtr == NULL)
    {
        strncpy(configuration.cid, DefaultCid, sizeof(DefaultCid));
        strncpy(configuration.pdp, PdpIpv4, sizeof(PdpIpv4));
        strncpy(configuration.apn, automaticApn, sizeof(automaticApn));
    }
    else
    {
        // Get the configuration from the file
        fseek(configFilePtr, 0, SEEK_END);
        uint32_t len = ftell(configFilePtr);
        char cmdLine[ len + 1 ];
        memset(cmdLine,0,len+1);
        fseek(configFilePtr, 0, SEEK_SET);
        fread(cmdLine, 1, len, configFilePtr);
        fclose(configFilePtr);

        // Replace last character
        if (( cmdLine[len-1] == '\n' ) || ( cmdLine[len-1] == '\r' ))
        {
            cmdLine[len-1]=' ';
        }

        // Get profile number
        char* cidPtr =  strtok(cmdLine, " ");
        LE_ASSERT(cidPtr != NULL);
        strncpy(configuration.cid, cidPtr, strlen(cidPtr));

        // Get pdp type
        char* pdpPtr = strtok(NULL, " ");
        LE_ASSERT(pdpPtr != NULL);
        strncpy(configuration.pdp, pdpPtr, strlen(pdpPtr));

        // Get apn
        char* apnPtr = strtok(NULL, " ");
        LE_ASSERT(apnPtr != NULL);
        strncpy(configuration.apn, apnPtr, strlen(apnPtr));

        // Get authentification
        char* authPtr = strtok(NULL, " ");
        if (authPtr != NULL)
        {
            strncpy(configuration.auth, authPtr, strlen(authPtr));
        }

        // Get username
        char* userNamePtr = strtok(NULL, " ");
        if (userNamePtr != NULL)
        {
            strncpy(configuration.userName, userNamePtr, strlen(userNamePtr));
        }

        // Get password
        char* passwordPtr = strtok(NULL, " ");
        if(passwordPtr != NULL)
        {
            strncpy(configuration.password, passwordPtr, strlen(passwordPtr));
        }
    }

    uint32_t profile;

    if ( strncmp(configuration.cid, DefaultCid, sizeof(DefaultCid)) == 0 )
    {
        profile = LE_MDC_DEFAULT_PROFILE;
    }
    else
    {
        profile = atoi(configuration.cid);
    }

    // Get the profile reference
    *profileRefPtr = le_mdc_GetProfile(profile);
    LE_ASSERT( *profileRefPtr != NULL );

    // Check the current state of the cid
    le_mdc_ConState_t state = LE_MDC_DISCONNECTED;

    // Check the state
    LE_ASSERT( le_mdc_GetSessionState(*profileRefPtr, &state) == LE_OK );

    // If already connected, disconnect the session
    if ( state == LE_MDC_CONNECTED )
    {
        LE_ASSERT(le_mdc_StopSession(*profileRefPtr) == LE_OK);
    }

    // Set pdp type
    le_mdc_Pdp_t pdp = LE_MDC_PDP_UNKNOWN;

    if ( strncmp(configuration.pdp, PdpIpv4, sizeof(PdpIpv4)) == 0 )
    {
        pdp = LE_MDC_PDP_IPV4;
    }
    else if ( strncmp(configuration.pdp, PdpIpv6, sizeof(PdpIpv6)) == 0 )
    {
        pdp = LE_MDC_PDP_IPV6;
    }
    else if ( strncmp(configuration.pdp, PdpIpv4v6, sizeof(PdpIpv4v6)) == 0 )
    {
        pdp = LE_MDC_PDP_IPV4V6;
    }

    LE_ASSERT( le_mdc_SetPDP(*profileRefPtr, pdp) == LE_OK );

    // Set APN
    if ( strncmp(configuration.apn, automaticApn, sizeof(automaticApn)) == 0 )
    {
        // Set default APN
        LE_ASSERT( le_mdc_SetDefaultAPN(*profileRefPtr) == LE_OK );
    }
    else
    {
        LE_ASSERT( le_mdc_SetAPN(*profileRefPtr, configuration.apn) == LE_OK );
    }

    le_mdc_Auth_t auth = LE_MDC_AUTH_NONE;
    if ( configuration.auth[0] != '\0' )
    {
        // Set the authentification, username and password
        if ( strncmp(configuration.auth, AuthPap, sizeof(AuthPap)) == 0 )
        {
            auth = LE_MDC_AUTH_PAP;
        }
        else if ( strncmp(configuration.auth, AuthChap, sizeof(AuthChap)) == 0 )
        {
            auth = LE_MDC_AUTH_CHAP;
        }

        if (auth != LE_MDC_AUTH_NONE)
        {
            LE_ASSERT( le_mdc_SetAuthentication( *profileRefPtr,
                                                 auth,
                                                 configuration.userName,
                                                 configuration.password ) == LE_OK );
        }
    }

    LE_INFO("cid: %d pdp: %d apn: %s auth: %d username: %s password: %s", profile, pdp,
            configuration.apn, auth, configuration.userName, configuration.password);
}