connectionMgr/inc/connectionMgr.h File Reference

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include <glib.h>
#include <liberregxml/erregapi.h>
#include "ecdc_err.h"
#include "commonData.h"
#include "connectScan.h"
#include "connectPing.h"
#include "connectScreen.h"
#include "editScreen.h"

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

Go to the source code of this file.

Classes
struct	screenPage_t
Defines
#define	COMMAND_WIRED   "wired.sh"
#define	COMMAND_IFUP_WIRED   "wired.sh start"
#define	COMMAND_WIRELESS   "wireless.sh"
#define	COMMAND_IFUP_WIRELESS   "wireless.sh start"
#define	COMMAND_IFDOWN_ALL   "cifs.sh umount ; wireless.sh stop ; wired.sh stop ; dialup.sh stop"
#define	COMMAND_SCAN_WIRELESS   "wireless.sh scan"
#define	COMMAND_STATUS_WIRELESS   "wireless.sh status"
#define	COMMAND_DIALUP   "dialup.sh"
#define	COMMAND_STATUS_DIALUP   "dialup.sh status"
#define	INTERFACE_WIRED   "eth0"
#define	INTERFACE_WIRELESS   "wlan0"
#define	INTERFACES_FILE_TMP   "/tmp/interfaces.tmp"
#define	RESOLVE_CONF_FILE_TMP   "/tmp/resolv.conf.tmp"
#define	HTTP_PROXY_FILE_TMP   "/tmp/http_proxy.tmp"
#define	COMMAND_MOUNT_SAMBA   "cifs.sh"
#define	DOWNLOADMGR_EXECUTABLE   "/usr/bin/downloadMgr"
#define	PCSHAREMGR_EXECUTABLE   "/usr/bin/pcshareMgr"
Typedefs
typedef void(*	on_tbsync_action_t )(void)
Enumerations
enum	cmgrScreen_t { cmgrScreenConnect_e = 0, cmgrScreenEdit_e, cmgrScreenUndef_e }
Functions
gboolean	main_get_background (void)
cmgrConnectType_t	main_get_connect_type (void)
gboolean	main_get_edit_only (void)
gboolean	main_get_use_last_connected (void)
gboolean	main_get_connect_after_reboot (void)
gboolean	main_get_wifi_disabled (void)
gboolean	main_get_dialup_disabled (void)
char *	main_get_screen_title (void)
void	cmgr_set_screen_mode (cmgrScreen_t mode)
cmgrScreen_t	cmgr_get_screen_mode (void)
GtkWidget *	cmgr_screens_create (void)
void	cmgr_set_pagebar ()
void	cmgr_add_on_toolbar_sync_action (on_tbsync_action_t action)
guint	on_cmgr_keypress (GtkWidget *widget, GdkEventKey *event, gpointer data)
void	main_start_child_process (void)
void	main_quit (void)
void	show_keyboard (gboolean show)
void	cmgr_get_back_page (const screenPage_t *curPage, screenPage_t *backPage)
void	cmgr_up_page (void)
void	cmgr_back_page (void)
gboolean	cmgrInstallIpcServer (void)
gboolean	cmgrStartIpcClientSetup (void)
void	prepare_registry_write (void)
void	do_registry_write (void)
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)
ecd_err_t	connect_enable_network (const regNetworkProfile_t *setting)
void	connect_enable_network_abort (void)
void	main_set_exit_value (int exitValue)
gboolean	on_cmgr_quit (gpointer data)

---

Define Documentation

#define COMMAND_DIALUP   "dialup.sh"

Definition at line 55 of file connectionMgr.h.

#define COMMAND_IFDOWN_ALL   "cifs.sh umount ; wireless.sh stop ; wired.sh stop ; dialup.sh stop"

Definition at line 52 of file connectionMgr.h.

#define COMMAND_IFUP_WIRED   "wired.sh start"

Definition at line 48 of file connectionMgr.h.

#define COMMAND_IFUP_WIRELESS   "wireless.sh start"

Definition at line 51 of file connectionMgr.h.

#define COMMAND_MOUNT_SAMBA   "cifs.sh"

Definition at line 65 of file connectionMgr.h.

#define COMMAND_SCAN_WIRELESS   "wireless.sh scan"

Definition at line 53 of file connectionMgr.h.

#define COMMAND_STATUS_DIALUP   "dialup.sh status"

Definition at line 56 of file connectionMgr.h.

#define COMMAND_STATUS_WIRELESS   "wireless.sh status"

Definition at line 54 of file connectionMgr.h.

#define COMMAND_WIRED   "wired.sh"

Definition at line 47 of file connectionMgr.h.

#define COMMAND_WIRELESS   "wireless.sh"

Definition at line 50 of file connectionMgr.h.

#define DOWNLOADMGR_EXECUTABLE   "/usr/bin/downloadMgr"

Definition at line 68 of file connectionMgr.h.

#define HTTP_PROXY_FILE_TMP   "/tmp/http_proxy.tmp"

Definition at line 63 of file connectionMgr.h.

#define INTERFACE_WIRED   "eth0"

Definition at line 58 of file connectionMgr.h.

#define INTERFACE_WIRELESS   "wlan0"

Definition at line 59 of file connectionMgr.h.

#define INTERFACES_FILE_TMP   "/tmp/interfaces.tmp"

Definition at line 61 of file connectionMgr.h.

#define PCSHAREMGR_EXECUTABLE   "/usr/bin/pcshareMgr"

Definition at line 69 of file connectionMgr.h.

#define RESOLVE_CONF_FILE_TMP   "/tmp/resolv.conf.tmp"

Definition at line 62 of file connectionMgr.h.

---

Typedef Documentation

typedef void(* on_tbsync_action_t)(void)

Definition at line 85 of file connectionMgr.h.

---

Enumeration Type Documentation

enum cmgrScreen_t

Enumerator:

cmgrScreenConnect_e
cmgrScreenEdit_e
cmgrScreenUndef_e

Definition at line 72 of file connectionMgr.h.

{
    cmgrScreenConnect_e = 0,
    cmgrScreenEdit_e,
    cmgrScreenUndef_e
} cmgrScreen_t;

---

Function Documentation

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:

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

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

(

)

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_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:

gboolean cmgrStartIpcClientSetup

(

void

)

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 *

setting

)

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);
    }
}

void do_registry_write

(

void

)

Definition at line 303 of file main.c.

{
    gboolean       b;
    
    // verify write lock
    g_assert(lock_write == erRegGetLockState());
    
    // save registry
    b = erRegStore();
    if (b == FALSE)
    {
        CN_ERRORPRINTF("erRegStore fails with return code [%d]", b);
    }

    // release lock
    erRegUnlock();
}

Here is the call graph for this function:

gboolean main_get_background

(

void

)

Definition at line 595 of file main.c.

{
    CN_LOGPRINTF("entry");
    return g_background;
}

gboolean main_get_connect_after_reboot

(

void

)

Definition at line 619 of file main.c.

{
    CN_LOGPRINTF("return [%d]", g_connect_after_reboot);
    return g_connect_after_reboot;
}

cmgrConnectType_t main_get_connect_type

(

void

)

Definition at line 601 of file main.c.

{
    CN_LOGPRINTF("return [%d]", g_connect_type);
    return g_connect_type;
}

gboolean main_get_dialup_disabled

(

void

)

Definition at line 631 of file main.c.

{
    CN_LOGPRINTF("return [%d]", g_dialup_disabled);
    return g_dialup_disabled;
}

gboolean main_get_edit_only

(

void

)

Definition at line 607 of file main.c.

{
    CN_LOGPRINTF("return [%d]", g_edit_only);
    return g_edit_only;
}

char* main_get_screen_title

(

void

)

Definition at line 637 of file main.c.

{
    CN_LOGPRINTF("return [%s]", g_screen_title);
    return g_screen_title;
}

gboolean main_get_use_last_connected

(

void

)

Definition at line 613 of file main.c.

{
    CN_LOGPRINTF("return [%d]", g_use_last_connected);
    return g_use_last_connected;
}

gboolean main_get_wifi_disabled

(

void

)

Definition at line 625 of file main.c.

{
    CN_LOGPRINTF("return [%d]", g_wifi_disabled);
    return g_wifi_disabled;
}

void main_quit

(

void

)

Definition at line 485 of file main.c.

{
    CN_LOGPRINTF("entry");

    if (g_exec_pid > 0)
    {
        // stop child process
        CN_WARNPRINTF("stop child process [%d]", g_exec_pid);
        kill(g_exec_pid, SIGTERM);
    }
    else if (gtk_main_level() > 0)
    {
        // no child process: stop gtk engine
        CN_WARNPRINTF("stop GTK main");
        gtk_main_quit();
    }
    else
    {
        // no child process, no in gtk_main, 
        // probably in initialisation phase: just quit
        CN_WARNPRINTF("_exit(1)");
        _exit(1);
    }
}

void main_set_exit_value

(

int

exitValue

)

void main_start_child_process

(

void

)

Definition at line 514 of file main.c.

{
    if (!g_background)
    {
       // no more screen updates from connection manager
       display_update_increase_level(NO_DISPLAY_UPDATE_LEVEL);
       // show_keyboard(FALSE);
       toolbar_setIconState(iconID_keyboard, iconState_grey);
    }

    g_idle_add(delayed_start_child_process, NULL);
}

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:

gboolean on_cmgr_quit

(

gpointer

data

)

void prepare_registry_write

(

void

)

Definition at line 277 of file main.c.

{
    gboolean       b;
    regLoad_t      regLoad;
    
    // acquire write lock
    b = erRegWriteLock();
    if (b == FALSE)
    {
        CN_ERRORPRINTF("erRegWriteLock fails with return code [%d]", b);
        g_assert_not_reached();
    }
    
    // reload section(s) that may be written
    erRegUnload(regNWProfiles_t);
    regLoad = erRegLoad(regNWProfiles_t);
    if (regLoad == loadError_t)
    {
        CN_ERRORPRINTF("erRegLoad(regNWProfiles_t) fails "
                       "with return code [%d]", 
                       regLoad);
        g_assert_not_reached();
    }
}

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: