connectionMgr/src/connectionMgr.c File Reference

connectionMgr - Main routines to create an environment for the Network-connection application and to handle key strokes More...

#include <stdio.h>
#include <unistd.h>
#include <wait.h>
#include <sys/socket.h>
#include <sys/errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <glib/gutils.h>
#include <gtk/gtk.h>
#include <libergtk/ergtk.h>
#include <liberipc/eripcconnect.h>
#include <liberipc/eripctoolbar.h>
#include <liberregxml/erregapi.h>
#include "connectionMgrLog.h"
#include "displayStatus.h"
#include <liberdm/connectionMgrConstants.h>
#include "erbusy.h"
#include "pagebar.h"
#include "toolbar.h"
#include "connectScreenData.h"
#include "connectionMgr.h"
#include "connectScreen.h"
#include "connectScreenOptions.h"
#include "editScreen.h"
#include "background.h"
#include "modemUtils.h"

Go to the source code of this file.

Defines
#define	SERVER_BUFFER_SIZE   1024
Functions
static void	on_toolbar_synchronised (void)
static void	on_goto_page (gint new_page)
static gboolean	hook_screen_refresh_typing (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)
static gboolean	on_idle_show_keyboard (gpointer data)
static gboolean	on_idle_hide_keyboard (gpointer data)
static void	connectMessageReceived (gpointer data, gint source_fd, GdkInputCondition condition)
GtkWidget *	cmgr_screens_create (void)
void	cmgr_set_screen_mode (cmgrScreen_t mode)
cmgrScreen_t	cmgr_get_screen_mode (void)
void	cmgr_set_toolbar (void)
void	cmgr_set_pagebar (void)
guint	on_cmgr_keypress (GtkWidget *widget, GdkEventKey *event, gpointer data)
static void	on_cmgr_icon_clicked (int iconID, int iconState)
static void	on_cmgr_toolbar_synchronised (void)
void	cmgr_add_on_toolbar_sync_action (on_tbsync_action_t action)
static void	keyboard_remove_idle_handler_ids (void)
static gboolean	keyboard_is_running (void)
static void	do_show_keyboard ()
static void	do_hide_keyboard (int iconState)
void	show_keyboard (gboolean show)
gboolean	cmgrInstallIpcServer ()
gboolean	connectStartIpcClientSetup ()
void	cmgr_scan_ctxt_init (void)
void	cmgr_scan_ctxt_destory (void)
scanContext_t *	cmgr_get_scan_ctxt (void)
void	cmgr_ping_ctxt_init (void)
void	cmgr_ping_ctxt_destory (void)
pingContext_t *	cmgr_get_ping_ctxt (void)
void	connect_disable_network ()
void	connect_enable_network_abort ()
static gboolean	is_hex_key (const char *key)
static void	add_key_prefix (const char *pkey, char **ppkey)
ecd_err_t	connect_enable_network (const regNetworkProfile_t *regNetworkProfile)
static void	cmgr_get_up_page (const screenPage_t *curPage, screenPage_t *upPage)
void	cmgr_get_back_page (const screenPage_t *curPage, screenPage_t *backPage)
static void	cmgr_get_cur_screen_page (screenPage_t *page)
static void	cmgr_goto_screen_page (const screenPage_t *page)
void	cmgr_up_page (void)
static gboolean	on_delayed_cmgr_back_page (gpointer data)
void	cmgr_back_page (void)
Variables
static GtkWidget *	g_connectScreens = NULL
static GtkWidget *	g_editScreens = NULL
static cmgrScreen_t	g_screen_mode = cmgrScreenUndef_e
static scanContext_t *	g_scan_ctxt = NULL
static pingContext_t *	g_ping_ctxt = NULL
static volatile int	enable_pid = 0
static on_tbsync_action_t	on_toolbar_sync_actions [] = { NULL, NULL }
static guint	g_show_idle_handler_id = 0
static guint	g_hide_idle_handler_id = 0
static erServerChannel_t	theServerChannel
static erClientChannel_t	g_ipc_channel_setup

---

Detailed Description

connectionMgr - Main routines to create an environment for the Network-connection application and to handle key strokes

connectionMgr - Main routines to create an environment for the Network-connection application and to handle key strokes

Copyright (C) 2007 iRex Technologies BV.

Definition in file connectionMgr.c.

---

Define Documentation

#define SERVER_BUFFER_SIZE   1024

Definition at line 89 of file connectionMgr.c.

---

Function Documentation

static void add_key_prefix	(	const char *	pkey,
		char **	ppkey
	)			[static]

Definition at line 719 of file connectionMgr.c.

{
    if (is_hex_key(pkey))
    {
       *ppkey = g_strdup(pkey);
    }
    else
    {
        *ppkey = g_strdup_printf("s:%s", pkey);
    }

    CN_LOGPRINTF("output[%s]", *ppkey);
}

Here is the call graph for this function:

void cmgr_add_on_toolbar_sync_action

(

on_tbsync_action_t

action

)

Definition at line 295 of file connectionMgr.c.

{
    int elementSize, arraySize;
    int i, sz;

    CN_LOGPRINTF("entry");
    
    g_assert(action != NULL);

    elementSize = sizeof(on_toolbar_sync_actions[0]);
    arraySize = sizeof(on_toolbar_sync_actions);
    sz = arraySize / elementSize;
    
    for (i = 0; i < sz; i++)
    {
        if (on_toolbar_sync_actions[i] == NULL)
        {
            on_toolbar_sync_actions[i] = action;
            return;
        }
    }

    g_assert_not_reached();
}

void cmgr_back_page

(

void

)

Definition at line 1257 of file connectionMgr.c.

{
    // wait for a while to show back icon active state
    g_timeout_add(500, on_delayed_cmgr_back_page, NULL);
}

Here is the call graph for this function:

void cmgr_get_back_page	(	const screenPage_t *	curPage,
		screenPage_t *	backPage
	)

Definition at line 1030 of file connectionMgr.c.

{
    CN_LOGPRINTF("entry [%p][%p]", curPage, backPage);
    
    g_return_if_fail(curPage != NULL);
    g_return_if_fail(backPage != NULL);

    if ((curPage->screen == cmgrScreenConnect_e)
       && (curPage->page == connectScreenOptions_e))
    {
         backPage->screen = cmgrScreenUndef_e;
         backPage->page = -1;
    }
    else if ((curPage->screen == cmgrScreenConnect_e) 
            && (curPage->page == connectScreenProfiles_e))
    {
        backPage->screen = cmgrScreenConnect_e;
        backPage->page = connectScreenOptions_e;
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenProfiles_e))
    { 
        backPage->screen = cmgrScreenUndef_e;
        backPage->page = -1; 
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenSearch_e))
    { 
        backPage->screen = cmgrScreenUndef_e;
        backPage->page = -1;
    }
    else if ((curPage->screen == cmgrScreenEdit_e)
            && (curPage->page == editScreenWireless_e))
    {
        if (edit_get_back_overview())
        {
            backPage->screen = cmgrScreenEdit_e;
            backPage->page = editScreenOverview_e;
        }
        else 
        {
            if (edit_get_wizard_mode())
            {
                backPage->screen = cmgrScreenEdit_e;
                backPage->page = editScreenSearch_e;
            }
            else
            {
                backPage->screen = cmgrScreenUndef_e;
                backPage->page = -1; 
            }
        }
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenOverview_e))
    {
        backPage->screen = cmgrScreenUndef_e;
        backPage->page = -1; 
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenDialup_e))
    {
        if (edit_get_back_overview())
        {
            backPage->screen = cmgrScreenEdit_e;
            backPage->page = editScreenOverview_e;
        }
        else
        {
            backPage->screen = cmgrScreenUndef_e;
            backPage->page = -1; 
        }
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenProxy_e))
    {
        backPage->screen = cmgrScreenEdit_e; 
        backPage->page = editScreenOverview_e;
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenStatic_e))
    {
        backPage->screen = cmgrScreenEdit_e;
        backPage->page = editScreenOverview_e;
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenWirelessExt_e))
    {
        if (edit_get_back_overview())
        {
            backPage->screen = cmgrScreenEdit_e;
            backPage->page = editScreenOverview_e;
        }
        else
        {
            backPage->screen = cmgrScreenUndef_e; 
            backPage->page = -1; 
        }
    }
    else
    {
        backPage->screen = cmgrScreenUndef_e;
        backPage->page = -1;
    }
    CN_LOGPRINTF("backPage[%d,%d]", backPage->screen, backPage->page);
}

Here is the call graph for this function:

static void cmgr_get_cur_screen_page

(

screenPage_t *

page

)

[static]

Definition at line 1139 of file connectionMgr.c.

{
    g_return_if_fail(page != NULL);

    page->screen = cmgr_get_screen_mode();
    switch (page->screen)
    {
        case cmgrScreenConnect_e:
            page->page = connect_get_current_page(NULL);
            break;
        case cmgrScreenEdit_e:
            page->page = edit_get_current_page(NULL);
            break;
        default:
            page->page = -1;
            break;
    }
}

Here is the call graph for this function:

pingContext_t* cmgr_get_ping_ctxt

(

void

)

Definition at line 673 of file connectionMgr.c.

{
    CN_LOGPRINTF("return %p", g_ping_ctxt);
    return g_ping_ctxt;
}

scanContext_t* cmgr_get_scan_ctxt

(

void

)

Definition at line 651 of file connectionMgr.c.

{
    CN_LOGPRINTF("return %p", g_scan_ctxt);
    return g_scan_ctxt;
}

cmgrScreen_t cmgr_get_screen_mode

(

void

)

Definition at line 197 of file connectionMgr.c.

{
    CN_LOGPRINTF("entry: g_screen_mode [%d]", g_screen_mode);
    return g_screen_mode;
}

static void cmgr_get_up_page	(	const screenPage_t *	curPage,
		screenPage_t *	upPage
	)			[static]

Definition at line 944 of file connectionMgr.c.

{
    CN_LOGPRINTF("entry [%p][%p]", curPage, upPage);

    g_return_if_fail(curPage != NULL);
    g_return_if_fail(upPage != NULL);

    if ((curPage->screen == cmgrScreenConnect_e)
         && (curPage->page == connectScreenOptions_e))
    {
        upPage->screen = cmgrScreenUndef_e;
        upPage->page = -1;
    }
    else if ((curPage->screen == cmgrScreenConnect_e)
            && (curPage->page == connectScreenProfiles_e))
    {
        upPage->screen = cmgrScreenUndef_e;
        upPage->page = -1;
    }
    else if ((curPage->screen == cmgrScreenEdit_e)
            && (curPage->page == editScreenProfiles_e))
    {
        if (main_get_edit_only())
        {    
            upPage->screen = cmgrScreenUndef_e;
            upPage->page = -1;
        }
        else
        {
            upPage->screen = cmgrScreenConnect_e;
            upPage->page = connectScreenOptions_e;
        }
    }
    else if ((curPage->screen == cmgrScreenEdit_e)
            && (curPage->screen == editScreenSearch_e))
    { 
        upPage->screen = cmgrScreenEdit_e;
        upPage->page = editScreenProfiles_e;
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenWireless_e))
    {
        upPage->screen = cmgrScreenEdit_e;
        upPage->page = editScreenProfiles_e;
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenOverview_e)) 
    {
        upPage->screen = cmgrScreenEdit_e;
        upPage->page = editScreenProfiles_e;
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenDialup_e))
    {
        upPage->screen = cmgrScreenEdit_e;
        upPage->page = editScreenProfiles_e;
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenProxy_e))
    {
        upPage->screen = cmgrScreenEdit_e;
        upPage->page = editScreenProfiles_e;
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenStatic_e))
    {
        upPage->screen = cmgrScreenEdit_e;
        upPage->page = editScreenProfiles_e;
    }
    else if ((curPage->screen == cmgrScreenEdit_e) 
            && (curPage->page == editScreenWirelessExt_e))
    {
        upPage->screen = cmgrScreenEdit_e;
        upPage->page = editScreenProfiles_e;
    }
    else
    {
        upPage->screen = cmgrScreenUndef_e;
        upPage->page = -1;
    }
    CN_LOGPRINTF("upPage[%d,%d]", upPage->screen, upPage->page);
}

Here is the call graph for this function:

static void cmgr_goto_screen_page

(

const screenPage_t *

page

)

[static]

Definition at line 1159 of file connectionMgr.c.

{
    scanContext_t* ctxt;

    CN_LOGPRINTF("entry [%p]", page);
    
    cmgr_set_screen_mode(page->screen); 
    switch (page->screen)
    {
        case cmgrScreenConnect_e:
            connect_goto_page(page->page);

            // for connectScreenOptions, scan automatically
            if (page->page == connectScreenOptions_e)
            {
                connect_options_display();

                connect_options_restore_scan_ctxt();
                ctxt = cmgr_get_scan_ctxt();
                connect_scan(ctxt, TRUE);
            }
            break;
        case cmgrScreenEdit_e:
            edit_goto_page(page->page);
            break;
        default:
            break;
    }
}

Here is the call graph for this function:

void cmgr_ping_ctxt_destory

(

void

)

Definition at line 665 of file connectionMgr.c.

{
    CN_LOGPRINTF("entry");

    connect_ping_ctxt_destory(g_ping_ctxt);
    g_ping_ctxt = NULL;
}

Here is the call graph for this function:

void cmgr_ping_ctxt_init

(

void

)

Definition at line 657 of file connectionMgr.c.

{
    CN_LOGPRINTF("entry");

    cmgr_ping_ctxt_destory();
    g_ping_ctxt = connect_ping_ctxt_new();
}

Here is the call graph for this function:

void cmgr_scan_ctxt_destory

(

void

)

Definition at line 643 of file connectionMgr.c.

{
    CN_LOGPRINTF("entry");

    connect_scan_ctxt_destory(g_scan_ctxt);
    g_scan_ctxt = NULL;
}

Here is the call graph for this function:

void cmgr_scan_ctxt_init

(

void

)

Definition at line 635 of file connectionMgr.c.

{
    CN_LOGPRINTF("entry");

    cmgr_scan_ctxt_destory();
    g_scan_ctxt = connect_scan_ctxt_new();
}

Here is the call graph for this function:

GtkWidget* cmgr_screens_create

(

void

)

Definition at line 108 of file connectionMgr.c.

{
    GtkWidget* screens;
    guint      signal_id;

    CN_LOGPRINTF("entry");

    // screens
    screens = gtk_vbox_new(FALSE, 0);

    // g_connectScreens
    g_connectScreens = connect_screen_create();
    connect_screen_set_text();
    gtk_box_pack_start(GTK_BOX(screens), g_connectScreens, 
                       FALSE, FALSE, 0);
    gtk_widget_hide(g_connectScreens);

    // g_editScreens
    g_editScreens = edit_screen_create();
    edit_screen_set_text();
    gtk_box_pack_start(GTK_BOX(screens), g_editScreens, FALSE, FALSE, 0);
    gtk_widget_hide(g_editScreens);

    // install class-specific screen update handlers
    //   erGtkEntry
    signal_id = g_signal_lookup("screen-refresh", ERGTK_ENTRY_TYPE);
    g_assert(signal_id > 0);
    g_signal_add_emission_hook(signal_id, 
                               0, 
                               hook_screen_refresh_typing, 
                               (gpointer)TEXT_ENTRY_CHANGED_LEVEL, 
                               NULL);
    //   erGtkToggleButton
    signal_id = g_signal_lookup("toggled", ERGTK_TOGGLE_BUTTON_TYPE);
    g_assert(signal_id > 0);
    g_signal_add_emission_hook(signal_id, 
                                0, 
                                hook_screen_refresh_typing, 
                                (gpointer)SETTING_ITEM_CHANGE, 
                                NULL);

    gtk_widget_show(screens);
    return screens;
}

Here is the call graph for this function:

void cmgr_set_pagebar

(

void

)

Definition at line 224 of file connectionMgr.c.

{
    CN_LOGPRINTF("entry: g_screen_mode [%d]", g_screen_mode);
    
    switch (g_screen_mode)
    {
        case cmgrScreenConnect_e:
            connect_set_pagebar();
            break;

        case cmgrScreenEdit_e:
            edit_set_pagebar();
            break;

        default:
            CN_LOGPRINTF("Illegal screen g_screen_mode [%d]", 
                          g_screen_mode);
    }
}

Here is the call graph for this function:

void cmgr_set_screen_mode

(

cmgrScreen_t

mode

)

Definition at line 153 of file connectionMgr.c.

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

    if (mode != g_screen_mode)
    {
        switch (mode)
        {
            case cmgrScreenConnect_e:
                g_screen_mode = cmgrScreenConnect_e;
                
                bg_display_title();

                gtk_widget_hide(g_editScreens);
                gtk_widget_show(g_connectScreens);

                connect_set_pagebar();
                connect_set_toolbar();
                
                connect_screen_display();
                break;

            case cmgrScreenEdit_e:
                g_screen_mode = cmgrScreenEdit_e;

                bg_display_title();

                gtk_widget_hide(g_connectScreens);
                gtk_widget_show(g_editScreens);

                edit_set_toolbar();
                edit_set_pagebar();
                
                edit_screen_display();
                break;

            default:
                CN_LOGPRINTF("Illegal screen mode [%d]", mode);
        }
    }
}

Here is the call graph for this function:

void cmgr_set_toolbar

(

void

)

Definition at line 203 of file connectionMgr.c.

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

    switch (g_screen_mode)
    {
        case cmgrScreenConnect_e:
            connect_set_toolbar();
            break;

        case cmgrScreenEdit_e:
            edit_set_toolbar();
            break;

        default:
            CN_LOGPRINTF("Illegal screen g_screen_mode [%d]", 
                          g_screen_mode);
    }

}

Here is the call graph for this function:

void cmgr_up_page

(

void

)

Definition at line 1190 of file connectionMgr.c.

{
    screenPage_t curPage, upPage;
    editMode_t mode;

    CN_LOGPRINTF("entry");
 
    cmgr_get_cur_screen_page(&curPage);
    cmgr_get_up_page(&curPage, &upPage);
    
    if ((upPage.screen == cmgrScreenUndef_e)
        || (upPage.page == -1))
    {
        main_quit();
    }
    else
    {
        cmgr_goto_screen_page(&upPage);

        // The behaviour of up page to editScreenProfiles_e 
        // will lead to the profile editor is not only 
        // for filling in encryption key for access point.
        // So here, need to change the edit mode 
        // to be editModeConnectNormal_e
        if (upPage.screen == cmgrScreenEdit_e
            && upPage.page == editScreenProfiles_e)
        {
            mode = edit_get_mode();
            if ((mode == editModeConnectFillIn_e) 
                || (mode == editModeConnectCreate_e))
            {
                edit_set_mode(editModeConnectNormal_e);
            }
        }
    }
}

Here is the call graph for this function:

gboolean cmgrInstallIpcServer

(

void

)

Definition at line 530 of file connectionMgr.c.

{
    int     ret;
    int     fd = -1;
    int     returnValue;

    CN_IPCPRINTF("entry");

    ret = erIpcOpenServerChannel(ER_CONNECT_CHANNEL, &theServerChannel);

    if (ret != (-1))
    {
        fd = erIpcGetServerFd(theServerChannel);

        CN_IPCPRINTF("erIpcGetServerFd returned %d\n", fd);

        // gtk specific mechanism to monitor input file descriptor.
        returnValue = gdk_input_add(fd, 
                                    GDK_INPUT_READ, 
                                    connectMessageReceived, 
                                    (gpointer) theServerChannel);

        CN_IPCPRINTF("gdk_input_add returned %d", returnValue);
        return TRUE;
    }
    else
    {
        CN_ERRORPRINTF("Could not open server channel");
        return FALSE;
    }
}

Here is the call graph for this function:

void connect_disable_network

(

void

)

Definition at line 679 of file connectionMgr.c.

{
    // disable all interfaces
    system(COMMAND_IFDOWN_ALL);
}

ecd_err_t connect_enable_network

(

const regNetworkProfile_t *

regNetworkProfile

)

Definition at line 733 of file connectionMgr.c.

{
    ecd_err_t err = ECD_FAILURE;
    char *command[128];
    int arg = 0;
    char *freelist[128];
    int free_arg = 0;
    int rc;
    struct in_addr address;
    struct in_addr netmask;
    struct in_addr broadcast;
    char *encrkey;

    CN_LOGPRINTF("entry");
    g_return_val_if_fail((regNetworkProfile != NULL), err);

    if (regNetworkProfile->connection != dialup_t)
    {
        FILE* fd_iface  = NULL;
        FILE* fd_resolv = NULL;
        FILE* fd_proxy  = NULL;

        // Create temporary files
        fd_iface  = fopen(INTERFACES_FILE_TMP,   "w");
        fd_resolv = fopen(RESOLVE_CONF_FILE_TMP, "w");
        fd_proxy  = fopen(HTTP_PROXY_FILE_TMP,   "w");
        g_return_val_if_fail((   fd_iface  != NULL
                              && fd_resolv != NULL
                              && fd_proxy  != NULL), err);

        // interface name
        fputs("iface ", fd_iface);
    
        switch (regNetworkProfile->connection)
        {
            case wired_t:
                fputs(INTERFACE_WIRED, fd_iface);
                break;
            case wireless_t:
                fputs(INTERFACE_WIRELESS, fd_iface);
                break;
            default:
                CN_ERRORPRINTF("Illegal setting->connection [%d]", 
                               (int)regNetworkProfile->connection);
                return err;
        }

        fputs(" inet ", fd_iface);  //type TCP/IP

        // static or dynamic IP address
        switch (regNetworkProfile->addressMode)
        {
            case dhcp_t:
                fputs("dhcp ", fd_iface);
                break;

            case static_t:
                // static IP address etc.
                fputs(  "static ", fd_iface);
                fputs("\n  address ", fd_iface); 
                fputs(regNetworkProfile->ipSettings->address, fd_iface);
                fputs("\n  netmask ", fd_iface); 
                fputs(regNetworkProfile->ipSettings->netmask, fd_iface);
                fputs("\n  gateway ", fd_iface); 
                fputs(regNetworkProfile->ipSettings->gateway, fd_iface);

                // static DNS server address
                fputs("nameserver ", fd_resolv);
                fputs(regNetworkProfile->ipSettings->dns, fd_resolv);
                break;

            default:
                CN_ERRORPRINTF("Illegal setting->addresMode [%d]", 
                                (int)regNetworkProfile->addressMode);
                return err;
        }

        // Put proxy setting in environment
        if (regNetworkProfile->proxySettings == NULL)
        {
            CN_WARNPRINTF("No proxy needs to be specified");
            g_unsetenv("http_proxy");
            g_unsetenv("https_proxy");
        }
        else
        {
            char proxyString[256];

            snprintf(proxyString, sizeof(proxyString), 
                    "http://%s:%s", 
                    regNetworkProfile->proxySettings->address, 
                    regNetworkProfile->proxySettings->port);
            fputs(proxyString, fd_proxy);
            CN_WARNPRINTF("Setting proxy to %s", proxyString);

            g_setenv("http_proxy", proxyString, 1);
            g_setenv("https_proxy", proxyString, 1);
        }

        // close temporary files
        fputc('\n', fd_iface);   fclose(fd_iface);
        fputc('\n', fd_resolv);  fclose(fd_resolv);
        fputc('\n', fd_proxy);   fclose(fd_proxy);
    }

    // command-line to start network interface
    switch (regNetworkProfile->connection)
    {
        case wired_t:
            err = ECD_WIRED_ERROR;
            arg = 0;
            command[arg++] = COMMAND_WIRED;
            command[arg++] = "start";
            if (regNetworkProfile->addressMode == static_t)
            {
                //inet_aton(regNetworkProfile->ipSettings->address, &address);
                //inet_aton(regNetworkProfile->ipSettings->netmask, &netmask);
                address.s_addr = inet_addr(regNetworkProfile->ipSettings->address);
                netmask.s_addr = inet_addr(regNetworkProfile->ipSettings->netmask);
                broadcast.s_addr = address.s_addr | ~netmask.s_addr;

                command[arg++] = "static";
                command[arg++] = regNetworkProfile->ipSettings->address;
                command[arg++] = regNetworkProfile->ipSettings->netmask;
                command[arg++] = freelist[free_arg++] = strdup(inet_ntoa(broadcast));
                command[arg++] = regNetworkProfile->ipSettings->gateway;
                command[arg++] = regNetworkProfile->ipSettings->dns;
            }
            else
            {
                command[arg++] = "dhcp";
            }
            break;

        case wireless_t:
            err = ECD_WIRELESS_ERROR;
            arg = 0;
            command[arg++] = COMMAND_WIRELESS;
            command[arg++] = "start";
            command[arg++] = regNetworkProfile->wirelessSettings->SSID;

            switch (regNetworkProfile->wirelessSettings->encrType)
            {
                case encr_none_t:
                    /* ignore */ ;
                    break;
                case encr_wep_t:
                    command[arg++] = "enc";
                    encrkey = regNetworkProfile->wirelessSettings->encrKey;
                    add_key_prefix(encrkey, &freelist[free_arg]);
                    command[arg++] = freelist[free_arg];
                    free_arg++;
                   break;
                case encr_wpa_t:
                    command[arg++] = "wpa";
                    encrkey = regNetworkProfile->wirelessSettings->encrKey;
                    command[arg++] = encrkey;
                    break;
                default:
                    // TODO: support these settings
                    CN_ERRORPRINTF("Support the ascii settings");
                    break;
            }
            break; // end wireless_t

        case dialup_t:
            err = ECD_DIALUP_ERROR;
            arg = 0;
            command[arg++] = COMMAND_DIALUP;
            command[arg++] = "start";
            command[arg++] = regNetworkProfile->dialupSettings->phone;
            command[arg++] = regNetworkProfile->dialupSettings->user;
            command[arg++] = regNetworkProfile->dialupSettings->password;
            break; // end dialup_t

        default:
            /* ignore, has been tested before */ ;
    }
  
    // now execute the command, at last
    command[arg] = NULL;
    if ((enable_pid = fork()) == 0)
    {
        printf("Execvp returned %d\n", execvp(command[0], command));
        printf("execvp error: %d %s", errno, strerror(errno));
        exit(1);
    }
    waitpid(enable_pid, &rc, 0);
    if (WIFEXITED(rc) && WEXITSTATUS(rc) == 0)
    {
        err = ECD_NO_ERROR;
    }
    enable_pid = 0;

    for (free_arg--; free_arg >= 0; free(freelist[free_arg--]));

    FILE *fd = fopen("/tmp/profile_name.tmp", "w");
    fputs(regNetworkProfile->name, fd);
    fputs("\n", fd);
    fclose(fd);
    
    CN_LOGPRINTF("done: err [%d]", err);
    return err;
}

Here is the call graph for this function:

void connect_enable_network_abort

(

void

)

Definition at line 685 of file connectionMgr.c.

{
    // stop network enable, when needed
    if (enable_pid > 0)
    {
        CN_WARNPRINTF("Sending SIGTERM to enable_pid [%d]", enable_pid);
        kill(enable_pid, SIGTERM);
    }
}

static void connectMessageReceived	(	gpointer	data,
		gint	source_fd,
		GdkInputCondition	condition
	)			[static]

Definition at line 579 of file connectionMgr.c.

{
    char    szBuffer[SERVER_BUFFER_SIZE];
    int     nBuf = SERVER_BUFFER_SIZE;
    int     page;
    
    erIpcCmd_t command;
    //st_ContentType_e contentType;

    erIpcGetMessage((erServerChannel_t) data, szBuffer, &nBuf);

    CN_IPCPRINTF("Received %s\n", szBuffer);

    if (cnParseCommand(szBuffer, &command) >= 0)
    {
        switch (command.cc)
        {
            case ccCnGotoPage:
                page = atoi(command.arg[0]);
                CN_IPCPRINTF("Connect Goto Page: %d\n", page);
                gdk_threads_enter();
                on_goto_page(page);
                gdk_threads_leave();
                break;
           
            case ccCnToolbar:
                {
                    int iconID    = atoi(command.arg[0]);
                    int iconState = atoi(command.arg[1]);
                    CN_LOGPRINTF("ccCnToolbarIcon: iconID [%d] iconState [%d]", 
                                  iconID, iconState);
                    gdk_threads_enter();
                    on_cmgr_icon_clicked(iconID, iconState);
                    gdk_threads_leave();
                }
                break;

            case ccCnToolbarSync:
                    gdk_threads_enter();
                    CN_LOGPRINTF("ccCnToolbarSync");
                    on_cmgr_toolbar_synchronised();
                    gdk_threads_leave();
                break;

            default:
                CN_IPCPRINTF("UNKNOWN COMMAND %d", command.cc);
                break;
        }
    }
}

Here is the call graph for this function:

gboolean connectStartIpcClientSetup

(

)

Definition at line 562 of file connectionMgr.c.

{
    int ret;

    CN_LOGPRINTF("entry\n");

    ret = erIpcStartClient(ER_SETUP_CHANNEL, &g_ipc_channel_setup);
    CN_IPCPRINTF("erIpcStartClient returned %d\n", ret);

    return (ret == 0) ? TRUE : FALSE;
}

Here is the call graph for this function:

static void do_hide_keyboard

(

int

iconState

)

[static]

Definition at line 464 of file connectionMgr.c.

{
    g_assert((iconState == iconState_grey) 
            || (iconState == iconState_normal));

    // remove the old display update
    // keyboard will refresh the screen later
    keyboard_remove_idle_handler_ids();

    // block screen updates until keyboard hides
    display_update_increase_level(KEYBOARD_SHOW_HIDE_LEVEL);

    // update GTK objects then hide keyboard, 
    // rely on display update by keyboard
    g_hide_idle_handler_id = g_idle_add(on_idle_hide_keyboard, 
                                        (gpointer) iconState);
}

Here is the call graph for this function:

static void do_show_keyboard

(

)

[static]

Definition at line 418 of file connectionMgr.c.

{

    // remove the old display update, 
    // keyboard will refresh the screen later
    keyboard_remove_idle_handler_ids();

    // block screen updates until keyboard shows
    display_update_increase_level(KEYBOARD_SHOW_HIDE_LEVEL);
    
    // update GTK objects then show keyboard,
    // rely on display update by keyboard
    g_show_idle_handler_id = g_idle_add(on_idle_show_keyboard, NULL);
}

Here is the call graph for this function:

static gboolean hook_screen_refresh_typing	(	GSignalInvocationHint *	ihint,
		guint	n_param_values,
		const GValue *	param_values,
		gpointer	user_data
	)			[static]

Definition at line 362 of file connectionMgr.c.

{
    int level = (int)user_data;

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

    display_update_request_screen_refresh(level, WAVEFORM_TYPING);

    return TRUE;  // TRUE = continue gtk signal handling
}

Here is the call graph for this function:

static gboolean is_hex_key

(

const char *

key

)

[static]

Definition at line 695 of file connectionMgr.c.

{
    int i, len;
    gboolean ret = TRUE;

    if ((key == NULL) 
        || ((len = strlen(key)) == 0))
    {
        return TRUE;
    }

    for (i = 0; i < len; i++)
    {
        if (!isxdigit(key[i]))
        {
            ret = FALSE;
            break;
        }
    }

    CN_LOGPRINTF("return %d", ret);
    return ret;
}

static gboolean keyboard_is_running

(

void

)

[static]

Definition at line 400 of file connectionMgr.c.

{
    const char *cmd = "ps -ef | grep matchbox-keyboard | grep -v grep";
    gboolean running = FALSE;
    
    if (system(cmd) == 0)
    {
        running = TRUE;
    }

    CN_LOGPRINTF("return %d", running);
    return running;
}

static void keyboard_remove_idle_handler_ids

(

void

)

[static]

Definition at line 379 of file connectionMgr.c.

{
    if (g_show_idle_handler_id)
    {
        CN_DMPRINTF("\nRemoving the old show keyboard idle handler.\n");
       
        g_source_remove(g_show_idle_handler_id);
        g_show_idle_handler_id = 0;
    }

    if (g_hide_idle_handler_id)
    {
        CN_DMPRINTF("\nRemoving the old hide keyboard idle handler.\n");

        g_source_remove(g_hide_idle_handler_id);
        g_hide_idle_handler_id = 0;
    }

    display_update_remove_idle_handler_id();
}

Here is the call graph for this function:

static void on_cmgr_icon_clicked	(	int	iconID,
		int	iconState
	)			[static]

Definition at line 268 of file connectionMgr.c.

{
    cmgrScreen_t mode;

    CN_LOGPRINTF("entry iconID[%d] iconState[%d]", iconID, iconState);

    mode = cmgr_get_screen_mode();
    switch (mode)
    {
        case cmgrScreenEdit_e:
            on_edit_icon_clicked(iconID, iconState); 
            break;
        case cmgrScreenConnect_e:
            on_connect_icon_clicked(iconID, iconState);
            break;
        default:
            break;
    }
}

Here is the call graph for this function:

guint on_cmgr_keypress	(	GtkWidget *	widget,
		GdkEventKey *	event,
		gpointer	data
	)

Definition at line 245 of file connectionMgr.c.

{
    guint   returnValue = 0;    // return FALSE => default gtk handling

    CN_LOGPRINTF("entry");

    switch (cmgr_get_screen_mode())
    {
        case cmgrScreenConnect_e:
            returnValue = on_connect_keypress(event);
            break;
        case cmgrScreenEdit_e:
            returnValue = on_edit_keypress(event);
            break;
        default:
            /* ignore */ ;
    }
    
    return returnValue;
}

Here is the call graph for this function:

static void on_cmgr_toolbar_synchronised

(

void

)

[static]

Definition at line 288 of file connectionMgr.c.

{
    CN_LOGPRINTF("entry");

    on_toolbar_synchronised();
}

Here is the call graph for this function:

static gboolean on_delayed_cmgr_back_page

(

gpointer

data

)

[static]

Definition at line 1228 of file connectionMgr.c.

{
    screenPage_t curPage, backPage;

    CN_LOGPRINTF("entry");

    erbusy_blink();

    cmgr_get_cur_screen_page(&curPage);
    cmgr_get_back_page(&curPage, &backPage);

    // before back, restore the previous settings
    switch (curPage.screen)
    {
        case cmgrScreenEdit_e:
            edit_restore_network_settings(curPage.page);
            break;
        case cmgrScreenConnect_e:
            // nothing need to do
            break;
        default:
            break;
    }

    cmgr_goto_screen_page(&backPage);

    return FALSE;
}

Here is the call graph for this function:

static void on_goto_page

(

gint

new_page

)

[static]

Definition at line 345 of file connectionMgr.c.

{
    CN_LOGPRINTF("entry");

    switch (cmgr_get_screen_mode())
    {
        case cmgrScreenConnect_e:
            on_connect_goto_page(new_page);
            break;
        case cmgrScreenEdit_e:
            on_edit_goto_page(new_page);
            break;
        default:
            /* ignore */ ;
    }
}

Here is the call graph for this function:

static gboolean on_idle_hide_keyboard

(

gpointer

data

)

[static]

Definition at line 482 of file connectionMgr.c.

{
    gboolean running = keyboard_is_running();
    int iconState = (int)data;

    toolbar_setIconState(iconID_keyboard, iconState);

    if (!running)
    {
        // from hide to hide, keyboard doesn't do refresh the screen,
        // do it on connectionMgr side
        CN_DMPRINTF("\nfrom hide to hide, " 
                      "rely on cmgr refresh the screen\n");
        display_update_request_screen_refresh(KEYBOARD_SHOW_HIDE_LEVEL, 
                                         WAVEFORM_FULLSCREEN);
    }
    else
    {
        CN_DMPRINTF("\nfrom show to hide, "
                    "rely on keyboard refresh the screen\n");
        // allow display updates again
        display_update_decrease_level(LOWEST_LEVEL);
    }

    g_hide_idle_handler_id = 0;
    return FALSE;               // don't call me again
}

Here is the call graph for this function:

static gboolean on_idle_show_keyboard

(

gpointer

data

)

[static]

Definition at line 433 of file connectionMgr.c.

{
    gboolean running = keyboard_is_running();

    toolbar_setIconState(iconID_keyboard, iconState_selected);

    if (running)
    {
        // from show to show, keyboard doesn't refresh the screen,
        // do it on connectionMgr side
        CN_DMPRINTF("\nfrom show to show, " 
                    "rely on cmgr refresh the screen\n");
        display_update_request_screen_refresh(KEYBOARD_SHOW_HIDE_LEVEL, 
                                              WAVEFORM_FULLSCREEN);
    }
    else
    {
        CN_DMPRINTF("\nfrom hide to show, "
                    "rely on keyboard refresh the screen\n");
        // allow display updates again
        display_update_decrease_level(LOWEST_LEVEL);
    }

    g_show_idle_handler_id = 0;
    return FALSE;               // don't call me again
}

Here is the call graph for this function:

static void on_toolbar_synchronised

(

void

)

[static]

Definition at line 320 of file connectionMgr.c.

{
    int elementSize, arraySize;
    int i, sz;

    CN_LOGPRINTF("entry");

    display_update_request_screen_refresh(TEXT_ENTRY_CHANGED_LEVEL, 
                                          WAVEFORM_TYPING);

    elementSize = sizeof(on_toolbar_sync_actions[0]);
    arraySize = sizeof(on_toolbar_sync_actions);
    sz = arraySize / elementSize;

    // call functions for registered on_toolbar_sync_actions
    for (i = 0; i < sz; i++)
    {
        if (on_toolbar_sync_actions[i] != NULL)
        {
            on_toolbar_sync_actions[i] ();
            on_toolbar_sync_actions[i] = NULL;
        }
    }
}

Here is the call graph for this function:

void show_keyboard

(

gboolean

show

)

Definition at line 511 of file connectionMgr.c.

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

    if (show)
    {
        // keyboard requested
        do_show_keyboard();
    }
    else
    {
        // keyboard not requested
        do_hide_keyboard(iconState_grey);
    }
}

Here is the call graph for this function:

---

Variable Documentation

volatile int enable_pid = 0 [static]

Definition at line 68 of file connectionMgr.c.

GtkWidget* g_connectScreens = NULL [static]

Definition at line 60 of file connectionMgr.c.

GtkWidget* g_editScreens = NULL [static]

Definition at line 61 of file connectionMgr.c.

guint g_hide_idle_handler_id = 0 [static]

Definition at line 74 of file connectionMgr.c.

erClientChannel_t g_ipc_channel_setup [static]

Definition at line 91 of file connectionMgr.c.

pingContext_t* g_ping_ctxt = NULL [static]

Definition at line 66 of file connectionMgr.c.

scanContext_t* g_scan_ctxt = NULL [static]

Definition at line 65 of file connectionMgr.c.

cmgrScreen_t g_screen_mode = cmgrScreenUndef_e [static]

Definition at line 62 of file connectionMgr.c.

guint g_show_idle_handler_id = 0 [static]

Definition at line 73 of file connectionMgr.c.

on_tbsync_action_t on_toolbar_sync_actions[] = { NULL, NULL } [static]

Definition at line 71 of file connectionMgr.c.

erServerChannel_t theServerChannel [static]

Definition at line 90 of file connectionMgr.c.