connectionMgr/src/main.c File Reference

#include "config.h"
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include <liberipc/eripctoolbar.h>
#include <liberdm/connectionMgrConstants.h>
#include <liberdm/display.h>
#include "connectionMgrLog.h"
#include "displayStatus.h"
#include "background.h"
#include "connectScreenData.h"
#include "connectionMgr.h"
#include "connectionMgrData.h"
#include "connectScreen.h"
#include "editScreen.h"
#include "connectBackground.h"
#include "connectScan.h"
#include "pingThread.h"
#include "scanThread.h"
#include "languages.h"
#include "erbusy.h"
#include "pagebar.h"
#include "system.h"
#include "toolbar.h"

Go to the source code of this file.

Functions
static void	parse_arguments (int argc, char **argv)
static gboolean	delayed_start_child_process (gpointer user_data)
static void	on_sigterm (int signo)
static void	on_sigchld (int signo)
static void	on_main_window_destroy (GtkWidget *widget, gpointer data)
static gboolean	on_main_window_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer p)
static gboolean	on_main_window_focus_out_event (GtkWidget *widget, GdkEventFocus *event, gpointer p)
static void	load_registry (void)
static void	release_registry (void)
void	prepare_registry_write (void)
void	do_registry_write (void)
void	get_wifi_and_dialup_status (void)
int	main (int argc, char **argv)
void	main_quit (void)
void	main_start_child_process (void)
gboolean	main_get_background ()
cmgrConnectType_t	main_get_connect_type ()
gboolean	main_get_edit_only ()
gboolean	main_get_use_last_connected ()
gboolean	main_get_connect_after_reboot (void)
gboolean	main_get_wifi_disabled (void)
gboolean	main_get_dialup_disabled (void)
char *	main_get_screen_title ()
Variables
static gboolean	g_connect_after_reboot = FALSE
static gboolean	g_stay_connected = FALSE
static gboolean	g_edit_only = FALSE
static gboolean	g_background = FALSE
static gboolean	g_content_only = FALSE
static gchar *	g_content_uuid = NULL
static gboolean	g_use_last_connected = FALSE
static gboolean	g_wifi_disabled = FALSE
static gboolean	g_dialup_disabled = TRUE
static char *	g_screen_title = NULL
static int	g_exitValue = CONNECT_ERROR
static GtkWidget *	g_main_window = NULL
static cmgrConnectType_t	g_connect_type = cmgrConnectUnknown_e
static int	exec_argc = 0
static char *	exec_argv [10]
static pid_t	g_exec_pid = 0

---

Function Documentation

static gboolean delayed_start_child_process

(

gpointer

user_data

)

[static]

Definition at line 527 of file main.c.

{
    int   i;
    pid_t pid;

    CN_LOGPRINTF("entry");

    // execute command, when specified
    if (exec_argc == 0)
    {
        // no command yet: determine command to execute
        if (connect_data_get_connect_type() == cmgrConnectIDS_e)
        {
            exec_argv[exec_argc++] = DOWNLOADMGR_EXECUTABLE;
            if (g_background)
            {
                exec_argv[exec_argc++] = "--background";
            }
            if (g_content_only)
            {
                exec_argv[exec_argc++] = "--content-only";
            }
            if (g_content_uuid)
            {
                exec_argv[exec_argc++] = "--content-uuid";
                exec_argv[exec_argc++] = g_content_uuid;
            }
        }
        else if (connect_data_get_connect_type() == cmgrConnectPCShare_e)
        {
            exec_argv[exec_argc++] = PCSHAREMGR_EXECUTABLE;
            if (g_background)
            {
                exec_argv[exec_argc++] = "--background";
            }
        }
    }

    // execute command
    if (exec_argc > 0)
    {
        exec_argv[exec_argc] = NULL;
        g_assert( exec_argc < (sizeof(exec_argv)/sizeof(exec_argv[0])) );

        CN_WARNPRINTF("execute command [%s]", exec_argv[0]);
        for (i = 0 ; i < exec_argc ; i++)
        {
            CN_WARNPRINTF("    argv[%d] = [%s]", i, exec_argv[i]);
        }

        pid = fork_exec_no_wait(exec_argc, exec_argv);
        if (pid > 0)
        {
            g_exec_pid = pid;
        }
        else
        {
            CN_ERRORPRINTF("Execute [%s] failed "
                           "- fork_exec_no_wait returns [%d]", 
                           exec_argv[0], pid);
            g_exitValue = CONNECT_ERROR;
        }
    }

    return FALSE;  // don't call me again
}

Here is the call graph for this function:

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:

void get_wifi_and_dialup_status

(

void

)

Definition at line 321 of file main.c.

{
    int status;
    
    CN_LOGPRINTF("Checking status of WiFi...");
    status = system(COMMAND_STATUS_WIRELESS);
    if (WEXITSTATUS(status) == 0)
    {
        g_wifi_disabled = FALSE;
    }
    else
    {
        g_wifi_disabled = TRUE;
    }
    CN_LOGPRINTF("WiFi present? [%d]", g_wifi_disabled);
    
    CN_LOGPRINTF("Checking status of Dialup...");
    status = system(COMMAND_STATUS_DIALUP);
    if (WEXITSTATUS(status) == 0)
    {
        g_dialup_disabled = FALSE;
    }
    else
    {
        g_dialup_disabled = TRUE;
    }
    CN_LOGPRINTF("Dialup present? [%d]", g_dialup_disabled);
}

static void load_registry

(

void

)

[static]

Definition at line 223 of file main.c.

{
    gboolean       b;
    regLoad_t      regLoad;
    
    // init registry locking
    b = erRegRWLockInit();
    if (b == FALSE)
    {
        CN_ERRORPRINTF("erRegRWLockInit fails with return code [%d]", b);
        g_assert_not_reached();
    }
    
    // acquire read-only lock
    b = erRegReadLock();
    if (b == FALSE)
    {
        CN_ERRORPRINTF("erRegReadLock fails with return code [%d]", b);
        g_assert_not_reached();
    }
    
    // load registry sections used
    regLoad = erRegLoad(regBasis_t);
    if (regLoad == loadError_t)
    {
        CN_ERRORPRINTF("erRegLoad(regBasis_t) fails with return code [%d]", 
                        regLoad);
        g_assert_not_reached();
    }
    regLoad = erRegLoad(regNWProfiles_t);
    if (regLoad == loadError_t)
    {
        CN_ERRORPRINTF("erRegLoad(regNWProfiles_t) "
                       "fails with return code [%d]", 
                       regLoad);
        g_assert_not_reached();
    }
    
    // release lock, all data now in memory
    erRegUnlock();
}

Here is the call graph for this function:

int main	(	int	argc,
		char **	argv
	)

Definition at line 350 of file main.c.

{
    GtkWidget* clientArea = NULL;
    GtkWidget* screens = NULL;
    GtkWidget* widget;

    scanContext_t *ctxt;

    parse_arguments(argc, argv);
    
    // catch the SIGTERM signal
    struct sigaction on_term;
    memset(&on_term, 0x00, sizeof(on_term));
    on_term.sa_handler = on_sigterm;
    sigaction(SIGTERM, &on_term, NULL);

    // catch the SIGCHLD signal
    struct sigaction on_chld;
    memset(&on_chld, 0x00, sizeof(on_chld));
    on_chld.sa_handler = on_sigchld;
    on_chld.sa_flags   = SA_NOCLDSTOP;
    sigaction(SIGCHLD, &on_chld, NULL);

    // init threads - needed for screen refresh idle handling 
    g_thread_init(NULL);
    gdk_threads_init();

    // open the RC file associate with this program
    gtk_rc_parse(DATA_DIR "/connectionMgr.rc");
    CN_LOGPRINTF("rc file %s", DATA_DIR "/connectionMgr.rc");

    gtk_init(&argc, &argv);
    
    // check for WiFi and Dialup hardware status
    get_wifi_and_dialup_status();

    load_registry();
    cmgr_data_init();
    languagesInit();

    // note: set connect type only 
    // after connection mgr data has been initialized
    if (g_connect_type != cmgrConnectUnknown_e)
    {
        CN_WARNPRINTF("g_connect_type [%d]", g_connect_type);
        connect_data_set_connect_type(g_connect_type);
    }

    // init the context for scan and ping
    cmgr_scan_ctxt_init();
    cmgr_ping_ctxt_init();

    if (!g_background)
    {
        erbusy_init();
        pagebar_init();
        toolbar_init();
        cmgrInstallIpcServer();

        // => only request a refresh on the main window expose event
        display_update_increase_level(MAIN_WINDOW_EXPOSE_LEVEL);

        // create the main, top level, window 
        widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        gtk_window_set_title(GTK_WINDOW(widget), PACKAGE " " VERSION);
        gtk_window_position(GTK_WINDOW(widget), GTK_WIN_POS_CENTER);
        gtk_container_set_border_width(GTK_CONTAINER(widget), 0);
        gtk_widget_set_size_request(GTK_WIDGET(widget), 
                                    SCREEN_WIDTH, CLIENT_AREA);
        gtk_window_set_modal(GTK_WINDOW(widget), TRUE);
        gtk_window_set_resizable(GTK_WINDOW(widget), FALSE);
        g_signal_connect(G_OBJECT(widget), "destroy", 
                G_CALLBACK(on_main_window_destroy), NULL);
        g_signal_connect_after(G_OBJECT(widget), "expose-event", 
                           G_CALLBACK(on_main_window_expose_event), NULL);
        g_signal_connect(G_OBJECT(widget), "focus-out-event", 
                         G_CALLBACK(on_main_window_focus_out_event), NULL);
        g_signal_connect(G_OBJECT(widget), "key-press-event", 
                         G_CALLBACK(on_cmgr_keypress), NULL);
        gtk_widget_show(widget);
        g_main_window = widget;

        // create and display the application background and screens
        clientArea = bg_create(g_main_window);
        screens = cmgr_screens_create();
        gtk_container_add(GTK_CONTAINER(clientArea), screens);

        // show the correct screen
        if (main_get_edit_only())
        {
            cmgr_set_screen_mode(cmgrScreenEdit_e);
            edit_set_mode(editModeNormal_e);
        }
        else
        {
            cmgr_set_screen_mode(cmgrScreenConnect_e);
        }
    }
    else
    {
        connect_background_restore_scan_ctxt();
        ctxt = cmgr_get_scan_ctxt();
        connect_scan(ctxt, FALSE);
    }

    gdk_threads_enter();
    gtk_main();
    gdk_threads_leave();

    CN_WARNPRINTF("exitValue after gtk_main [%d]", g_exitValue);

    // save connection manager settings
    connect_data_store();

    // wait for pingThread and scanThread to end
    pingThread_stop();
    pingThread_wait(30);
    scanThread_stop();
    scanThread_wait(30);

    cmgr_scan_ctxt_destory();
    cmgr_ping_ctxt_destory();
 
    // disconnect, unless requested otherwise
    if (!g_stay_connected)
    {
        connect_disable_network();
    }

    release_registry();

    CN_WARNPRINTF("exit connectionMgr [%d]", g_exitValue);
    return g_exitValue;
}

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

static void on_main_window_destroy	(	GtkWidget *	widget,
		gpointer	data
	)			[static]

Definition at line 684 of file main.c.

{
    CN_WARNPRINTF("entry");

    //clean up or store stuff before the app ends
    gtk_main_quit();
}

static gboolean on_main_window_expose_event	(	GtkWidget *	widget,
		GdkEventExpose *	event,
		gpointer	p
	)			[static]

Definition at line 692 of file main.c.

{
    CN_LOGPRINTF("entry");
    display_update_request_screen_refresh(MAIN_WINDOW_EXPOSE_LEVEL, 
                                          WAVEFORM_FULLSCREEN);
    
    if (!main_get_edit_only())
    {
        gtk_idle_add(delay_erbusy_blink, NULL);
    }
   
    return FALSE;
}

Here is the call graph for this function:

static gboolean on_main_window_focus_out_event	(	GtkWidget *	widget,
		GdkEventFocus *	event,
		gpointer	p
	)			[static]

Definition at line 708 of file main.c.

{
    CN_LOGPRINTF("entry");

    return FALSE;
}

static void on_sigchld

(

int

signo

)

[static]

Definition at line 660 of file main.c.

{
    CN_WARNPRINTF("    -- entry connectionMgr");

    // check which process has died and free resources
    pid_t pid;
    int   status;
    while ( (pid = waitpid(-1, &status, WNOHANG)) > 0)
    {
        CN_WARNPRINTF("pid [%d]", pid);
        if (pid == g_exec_pid)
        {
            g_exec_pid = 0;
            if ( WIFEXITED(status) )
            {
                g_exitValue = WEXITSTATUS(status);
            }
            main_quit();
        }
    }

    CN_WARNPRINTF("    -- leave connectionMgr");
}

Here is the call graph for this function:

static void on_sigterm

(

int

signo

)

[static]

Definition at line 645 of file main.c.

{
    CN_WARNPRINTF("    -- entry connectionMgr, my pid [%d]", getpid());

    // stop main process, prepare to quit application
    gdk_threads_enter();
    main_quit();
    gdk_threads_leave();

    show_keyboard(FALSE);
    g_stay_connected = FALSE;

    CN_WARNPRINTF("    -- leave connectionMgr");
}

Here is the call graph for this function:

static void parse_arguments	(	int	argc,
		char **	argv
	)			[static]

Definition at line 100 of file main.c.

{
    static const char *usage_text =
                        "\n"
                        "usage: %s [options]\n"
                        "\n"
                        "options:\n"
                        "    --help\n"
                        "        Print help text and quit\n"
                        "    --background\n"
                        "        Operate in background, no GUI\n"
                        "    --connect-ids\n"
                        "        Connect to iDS\n"
                        "    --connect-pc\n"
                        "        Connect to PC share\n"
                        "    --content-only\n"
                        "        Download content items, skip software upgrades\n"
                        "    --content-uuid <uuid>\n"
                        "        Together with --content-only, download only this content item\n"
                        "    --edit-only\n"
                        "        Edit profiles only, do connect automatically\n"
                        "    --use-last-connected\n"
                        "        Use last connected profile first\n"
                        "    --stay-connected\n"
                        "        Keep network enabled when exiting connection manager\n"
                        "    --connect-after-reboot\n"
                        "        Connect automatically after rebooting\n"
                        "    --title <text>\n"
                        "        <text> = screen title\n"
                        "    --execute\n"
                        "        When connected to IDS, execute rest of the arguments as a new command\n"
                        "\n";
    int i;

    // parse connectionMgr options
    for (i = 0 ; i < argc ; i++)
    {
        if (strcmp(argv[i], "--help") == 0)
        {
            printf(usage_text, argv[0]);
            _exit(0);
        }
        else if(strcmp(argv[i], "--background") == 0)
        {
            g_background = TRUE;
        }
        else if(strcmp(argv[i], "--connect-ids") == 0)
        {
            g_connect_type = cmgrConnectIDS_e;
        }
        else if(strcmp(argv[i], "--connect-pc") == 0)
        {
            g_connect_type = cmgrConnectPCShare_e;
        }
        else if(strcmp(argv[i], "--content-only") == 0)
        {
            g_content_only = TRUE;
        }
        else if(strcmp(argv[i], "--content-uuid") == 0)
        {
            if (++i < argc)
            {
                g_content_uuid = argv[i];
            }
            else
            {
                i--;  // oops
            }
        }
        else if(strcmp(argv[i], "--edit-only") == 0)
        {
            g_edit_only = TRUE;
        }
        else if(strcmp(argv[i], "--use-last-connected") == 0)
        {
            g_use_last_connected = TRUE;
        }
        else if(strcmp(argv[i], "--stay-connected") == 0)
        {
            g_stay_connected = TRUE;
        }
        else if (strcmp(argv[i], "--connect-after-reboot") == 0)
        {
            g_connect_after_reboot = TRUE;
        }
        else if (strcmp(argv[i], "--title") == 0)
        {
            if (++i < argc)
            {
                g_screen_title = argv[i];
            }
            else
            {
                i--;  // oops
            }
        }
        else if (strcmp(argv[i], "--execute") == 0)
        {
            i++;
            if ( argc - i >= sizeof(exec_argv)/sizeof(exec_argv[0]) )
            {
                printf("\nToo many arguments for option [%s]\n", argv[i]);
                printf(usage_text, argv[0]);
                _exit(1);
            }

            exec_argc = 0;
            while (i < argc)
            {
                exec_argv[exec_argc++] = argv[i++];
            }
            exec_argv[exec_argc] = NULL;
        }
        else if (strncmp(argv[i], "--", 2) == 0)
        {
            printf("\nInvalid option: %s\n", argv[i]);
            printf(usage_text, argv[0]);
            _exit(1);
        }
    }
}

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:

static void release_registry

(

void

)

[static]

Definition at line 266 of file main.c.

{
    // unload registry sections
    erRegUnload(regNWProfiles_t);
    erRegUnload(regBasis_t);

    // discard registry locking
    erRegRWLockDestroy();
}

Here is the call graph for this function:

---

Variable Documentation

int exec_argc = 0 [static]

Definition at line 79 of file main.c.

char* exec_argv[10] [static]

Definition at line 80 of file main.c.

gboolean g_background = FALSE [static]

Definition at line 65 of file main.c.

gboolean g_connect_after_reboot = FALSE [static]

Definition at line 62 of file main.c.

cmgrConnectType_t g_connect_type = cmgrConnectUnknown_e [static]

Definition at line 78 of file main.c.

gboolean g_content_only = FALSE [static]

Definition at line 66 of file main.c.

gchar* g_content_uuid = NULL [static]

Definition at line 67 of file main.c.

gboolean g_dialup_disabled = TRUE [static]

Definition at line 70 of file main.c.

gboolean g_edit_only = FALSE [static]

Definition at line 64 of file main.c.

pid_t g_exec_pid = 0 [static]

Definition at line 81 of file main.c.

int g_exitValue = CONNECT_ERROR [static]

Definition at line 74 of file main.c.

GtkWidget* g_main_window = NULL [static]

Definition at line 75 of file main.c.

char* g_screen_title = NULL [static]

Definition at line 71 of file main.c.

gboolean g_stay_connected = FALSE [static]

Definition at line 63 of file main.c.

gboolean g_use_last_connected = FALSE [static]

Definition at line 68 of file main.c.

gboolean g_wifi_disabled = FALSE [static]

Definition at line 69 of file main.c.