connectionMgr/inc/commonData.h File Reference

connectionMgr - common data handling getting and setting data from/into registry More...

#include <glib.h>
#include <liberregxml/erregapi.h>
#include "scanThread.h"

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	networkProfile_t
Defines
#define	REDIRECT_URL   "https://ids.irexnet.com:443/redirector"
#define	MAX_WIRED_PROFILES   6
#define	MAX_WIRELESS_PROFILES   12
#define	MAX_DIALUP_PROFILES   6
Enumerations
enum	cmgrConnectType_t { cmgrConnectUnknown_e, cmgrConnectIDS_e, cmgrConnectPCShare_e, cmgrConnectUndef_e }
Functions
void	common_data_init (void)
void	common_data_destroy (void)
void	common_data_store (void)
int	common_data_get_n_profiles (void)
const regNetworkProfile_t *	common_data_get_profiledata (const gint index)
gboolean	common_data_set_profiledata (gint index, const regNetworkProfile_t *setting, const gboolean preferred)
guint	common_data_remove_profile (guint index)
const regPCProfile_t *	common_data_get_pcsharedata (const gint index)
gboolean	common_data_reach_max_profiles (connection_t networkType)
int	common_data_init_network_profiles (connection_t networkType, networkProfile_t **pNetworks)
void	common_data_destroy_network_profiles (networkProfile_t *pNetworks, guint nProfiles)
int	common_data_get_profile_index (networkProfile_t *pNetworks, int nProfiles, int regIndex)
int	common_data_get_reg_index (networkProfile_t *pNetworks, int nProfiles, int profileIndex)

---

Detailed Description

connectionMgr - common data handling getting and setting data from/into registry

Copyright (C) 2007 iRex Technologies BV.

Definition in file commonData.h.

---

Define Documentation

#define MAX_DIALUP_PROFILES   6

Definition at line 38 of file commonData.h.

#define MAX_WIRED_PROFILES   6

Definition at line 36 of file commonData.h.

#define MAX_WIRELESS_PROFILES   12

Definition at line 37 of file commonData.h.

#define REDIRECT_URL   "https://ids.irexnet.com:443/redirector"

Definition at line 34 of file commonData.h.

---

Enumeration Type Documentation

enum cmgrConnectType_t

Enumerator:

cmgrConnectUnknown_e
cmgrConnectIDS_e
cmgrConnectPCShare_e
cmgrConnectUndef_e

Definition at line 41 of file commonData.h.

{
    cmgrConnectUnknown_e,
    cmgrConnectIDS_e,
    cmgrConnectPCShare_e,
    cmgrConnectUndef_e
} cmgrConnectType_t;

---

Function Documentation

void common_data_destroy

(

void

)

Definition at line 63 of file commonData.c.

{
    CN_LOGPRINTF("entry");

    if (g_netConfig)
    {
        erRegFreeNetworkProfiles(g_netConfig, g_networks);
        g_networks = NULL;
        g_netConfig = NULL;
    }

    if (g_pcConfig)
    {
        erRegFreePCProfiles(g_pcConfig, g_pcshares);
        g_pcConfig = NULL;
        g_pcshares = NULL;
    }
}

Here is the call graph for this function:

void common_data_destroy_network_profiles	(	networkProfile_t *	pNetworks,
		guint	nProfiles
	)

Definition at line 531 of file commonData.c.

{
    CN_LOGPRINTF("entry");
    free_network_profile_t(pNetworks, nProfiles);
}

Here is the call graph for this function:

int common_data_get_n_profiles

(

void

)

Definition at line 180 of file commonData.c.

{
    CN_LOGPRINTF("entry");

    g_return_val_if_fail((g_netConfig != NULL), 0);
    return g_netConfig->size;
}

const regPCProfile_t* common_data_get_pcsharedata

(

const gint

index

)

Definition at line 275 of file commonData.c.

{
    CN_LOGPRINTF("entry: index [%d]", index);

    g_return_val_if_fail((g_pcConfig != NULL), NULL);

    if (index < g_pcConfig->size)
    {
        return g_pcshares[index];
    }
    else
    {
        return NULL;
    }
}

int common_data_get_profile_index	(	networkProfile_t *	pNetworks,
		int	nProfiles,
		int	regIndex
	)

Definition at line 538 of file commonData.c.

{
    CN_LOGPRINTF("entry");

    const networkProfile_t    *settings;
    int                       i, j;
    int                       profileIndex = -1;

    if ((nProfiles > 0) && (pNetworks))
    {
        for (i = 0; i < nProfiles; i++)
        {
            settings = &pNetworks[i];
            if (settings 
                && settings->nRegProfiles
                && settings->regSettingsList
                && settings->regIndexList)
            {
                for (j = 0; j < settings->nRegProfiles; j++)
                {
                    if (settings->regIndexList[j] == regIndex)
                    {
                        profileIndex = i;
                        break;
                    }
                }
            }
        }
    }

    return profileIndex;
}

const regNetworkProfile_t* common_data_get_profiledata

(

const gint

index

)

Definition at line 209 of file commonData.c.

{
    CN_LOGPRINTF("entry: index [%d]", index);

    g_return_val_if_fail((g_netConfig != NULL), NULL);

    if (index < g_netConfig->size)
    {
        return g_networks[index];
    }
    else
    {
        return NULL;
    }
}

int common_data_get_reg_index	(	networkProfile_t *	pNetworks,
		int	nProfiles,
		int	profileIndex
	)

Definition at line 573 of file commonData.c.

{
    CN_LOGPRINTF("entry");

    const networkProfile_t    *settings;
    int                       regIndex = -1;

    if ((nProfiles > 0) && (pNetworks))
    {
        if ((profileIndex >= 0) && (profileIndex < nProfiles))
        {
            settings = &pNetworks[profileIndex];
            if (settings 
                && (settings->nRegProfiles > 0)
                && settings->regSettingsList
                && settings->regIndexList)
            {
                if ((settings->nActiveIndex >= 0) 
                     && (settings->nActiveIndex < settings->nRegProfiles))
                {
                    regIndex = settings->regIndexList[settings->nActiveIndex];
                }
            }
        }
    }

    return regIndex;
}

void common_data_init

(

void

)

Definition at line 52 of file commonData.c.

{
    CN_LOGPRINTF("entry");
 
    // Read all network profiles from registry
    erRegGetNetworkProfiles(&g_netConfig, &g_networks);

    // Read all PC profiles from registry
    erRegGetPCProfiles(&g_pcConfig, &g_pcshares);
}

Here is the call graph for this function:

int common_data_init_network_profiles	(	connection_t	networkType,
		networkProfile_t **	pNetworks
	)

Definition at line 467 of file commonData.c.

{
    int                        i, profileIndex;
    int                        nRegNetworks;
    const regNetworkProfile_t* pRegNetwork; 
    networkProfile_t*          pNetwork;
    int                        nNetworks;
    networkProfile_t*          pNetworksList;

    CN_LOGPRINTF("entry networkType[%d]", networkType);
   
    // get how many profiles in registry
    nRegNetworks = common_data_get_n_profiles();
    if (nRegNetworks == 0)
    {
        CN_WARNPRINTF("No network profiles in registry.");
        return 0;
    }
    
    // get how many 'networkType' profiles 
    nNetworks = common_data_get_n_profiles_by_networktype(networkType);
   
    // sepcial case
    if (nNetworks == 0)
    {
        CN_WARNPRINTF("Can't find any [%d] network profiles.", networkType);
        return 0;
    }

    // get the 'networkType' profiles
    pNetworksList = new_network_profile_t(nNetworks);
    g_return_val_if_fail(pNetworksList != NULL, 0);

    profileIndex = 0;
    for (i = 0; i < nRegNetworks; i++)
    {
        pRegNetwork = common_data_get_profiledata(i);
        if (pRegNetwork && pRegNetwork->connection == networkType)
        {
            pNetwork = &pNetworksList[profileIndex];
            
            // scanSettings
            pNetwork->scanSettings = NULL;
            // regSettingsList
            pNetwork->regSettingsList = g_new0(regNetworkProfile_t*, 1);
            pNetwork->regSettingsList[0] = erRegDupNetworkProfile(pRegNetwork);
            // regIndexList
            pNetwork->regIndexList = g_new0(int, 1);
            pNetwork->regIndexList[0] =  i;
            // nRegProfiles
            pNetwork->nRegProfiles = 1;
            // nActiveIndex
            pNetwork->nActiveIndex = 0;

            profileIndex++;
        }
    }
   
    CN_LOGPRINTF("return nNetworks=%d", nNetworks);
    *pNetworks = pNetworksList;
    return nNetworks;
}

Here is the call graph for this function:

gboolean common_data_reach_max_profiles

(

connection_t

networkType

)

Definition at line 291 of file commonData.c.

{
    CN_LOGPRINTF("entry networkType[%d]", networkType);
    int      num, max;

    switch (networkType)
    {
        case wired_t:
            max = MAX_WIRED_PROFILES;
            break;
        case wireless_t:
            max = MAX_WIRELESS_PROFILES;
            break;
        case dialup_t:
            max = MAX_DIALUP_PROFILES;
            break;
        default:
            CN_WARNPRINTF("unknow networkType[%d]", networkType);
            max = 0;
            break;
    }

    num = common_data_get_n_profiles_by_networktype(networkType);
    CN_LOGPRINTF("num[%d] >= max[%d] ?", num, max);
    return ((num >= max) ? TRUE : FALSE);
}

Here is the call graph for this function:

guint common_data_remove_profile

(

guint

index

)

Definition at line 247 of file commonData.c.

{
    CN_LOGPRINTF("entry: index [%d]", index);
    
    int i;
    guint num_profiles = g_netConfig->size;
    g_return_val_if_fail((index < num_profiles), num_profiles);

    // remove the last network ID
    g_free( g_netConfig->networkList[num_profiles-1] );
    g_netConfig->networkList[num_profiles-1] = NULL;

    // remove the specified network setting
    g_free( g_networks[index] );
    for (i = index ; i < num_profiles - 1 ; i++)
    {
        g_networks[i] = g_networks[i+1];
    }
    g_networks[num_profiles-1] = NULL;

    // update profile count and report
    g_netConfig->size = num_profiles - 1;

    g_configChanged = TRUE;

    return g_netConfig->size;
}

gboolean common_data_set_profiledata	(	gint	index,
		const regNetworkProfile_t *	setting,
		const gboolean	preferred
	)

Definition at line 322 of file commonData.c.

{
    gboolean addNew = FALSE;
    gboolean reachMax = FALSE;
    gboolean ok = FALSE;
    regNetworkProfile_t* tmp_setting;

    CN_LOGPRINTF("entry: index [%d]", index);

    g_return_val_if_fail((g_netConfig != NULL), ok);
    g_return_val_if_fail((index <= g_netConfig->size), ok);
    
    // add new profile if needed
    while (g_netConfig->size <= index)
    {
        // before adding the new profile, check whether can add it or not
        g_return_val_if_fail(setting != NULL, ok);
        reachMax = common_data_reach_max_profiles(setting->connection);
        g_return_val_if_fail(reachMax == FALSE, ok);
        
        common_data_add_profile();
        addNew = TRUE;
    }

    // make preferred if needed
    if (preferred  &&  index < g_netConfig->size)
    {
        tmp_setting = g_networks[index];
        while (index > 0)
        {
            g_networks[index] = g_networks[index-1];
            --index;
        }
        g_networks[index] = tmp_setting;
    }
    
    if (   setting == NULL
        || setting->name == NULL
        || setting->name[0] == '\0')
    {
        // empty setting
        common_data_remove_profile(index);
    }
    else
    {
        prepare_registry_write();

        // store profile
        gchar* ID = g_netConfig->networkList[index];
        if (   erRegSetNetworkProfile(ID, (regNetworkProfile_t*)setting) 
            && erRegValidate() )
        {
            // refresh local administration if succeeded
            erRegFreeNetworkProfile( g_networks[index] );
            g_networks[index] = erRegGetNetworkProfile(ID);
            ok = TRUE;
        }
        else
        {
            CN_LOGPRINTF("Set profile [%d] [%s] failed", index, ID);
            if (addNew)
            {
                // undo the changes if failed
                common_data_remove_profile(index);
            }
        }

        do_registry_write();
    }

    g_configChanged = TRUE;
    return ok;
}

Here is the call graph for this function:

void common_data_store

(

void

)

Definition at line 82 of file commonData.c.

{
    CN_LOGPRINTF("entry");

    if ( g_configChanged == FALSE)
    {
        // nothing to save
        return;
    }

    gint index;
    char* theID;
    gboolean NWStored;
    regNetworkConfig_t* theNetworkConfig = NULL;
    regNetworkProfile_t* theNetworkProfile = NULL;
        
    // refresh registry data
    prepare_registry_write();

    // remove all network profiles from registry ...
    theNetworkConfig = erRegGetNetworkConfig();
    if (theNetworkConfig)
    {
        // remove old network profiles
        for (index = 0; index < theNetworkConfig->size; index++)
        {
            theID = theNetworkConfig->networkList[index];
            if (erRegRemoveNetworkProfile(theID) == FALSE)
            {
                CN_WARNPRINTF("could not remove %s", 
                        theNetworkConfig->networkList[index]);
            }
        }
        erRegFreeNetworkConfig(theNetworkConfig);

        // remove old netfork config
        erRegRemoveNetworkConfig();
    }
    else
    {
        CN_WARNPRINTF("could not retrieve theNetworkConfig");
    }

    // ... then write our network profiles to registry ...
    theNetworkConfig = g_new0(regNetworkConfig_t, 1);
    theNetworkConfig->size = g_netConfig->size;
    CN_STOREPRINTF("theNetworkConfig->size %d", theNetworkConfig->size);
    theNetworkConfig->networkList = g_new0(gchar*, 
                        (theNetworkConfig->size + 1));

    for (index = 0 ; index < g_netConfig->size ; index++)
    {
        theNetworkProfile = g_networks[index];

        if (theNetworkProfile == NULL)
        {
            CN_STOREPRINTF("theNetworkProfile = NULL");
        }
        else
        {
            theID = g_strdup_printf("NW_%d", index);
            NWStored = erRegSetNetworkProfile(theID, theNetworkProfile);

            if (NWStored)
            {
                CN_STOREPRINTF("id %s was stored", theID);
                theNetworkConfig->networkList[index] = g_strdup(theID);
            }
            else
            {
                CN_STOREPRINTF("id %s was NOT stored", theID);
                if (theNetworkConfig->size > 0)
                {
                    theNetworkConfig->size = theNetworkConfig->size - 1;
                }
            }
        }
    }
    if (theNetworkConfig->size > 0)
    {
        NWStored = erRegSetNetworkConfig(theNetworkConfig);
        CN_STOREPRINTF("erRegSetNetworkConfig() returned %s", 
                       (NWStored == TRUE) ? "TRUE" : "FALSE");
    }
    erRegFreeNetworkConfig(theNetworkConfig);

    //
    // ... and store registry to disk
    do_registry_write();
    CN_STOREPRINTF("Stored registry");
    g_configChanged = FALSE;
}

Here is the call graph for this function: