connections.c

Go to the documentation of this file.

/*
 * File name: connections.c
 */

/*
 * This file is part of sysd.
 *
 * sysd is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * sysd is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * Copyright (C) 2009 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

#include "config.h"

// system include files, between < >
#include <glib.h>
#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <utime.h>

// ereader include files, between < >

// local include files, between " "
#include "log.h"
#include "busy.h"
#include "conf.h"
#include "connections.h"
#include "ipc.h"
#include "process.h"

#define UNUSED(x) (void)(x)
    

//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------
 
enum state_conn
{
    CONN_STATE_OFF = 0,         // module in low power mode (but initialised)
    CONN_STATE_FLIGHTMODE,
    CONN_STATE_LOWBATT,
    CONN_STATE_LOADING,
    CONN_STATE_UNLOADING,
    CONN_STATE_CONNECTING,
    CONN_STATE_CONNECTED,
    CONN_STATE_DISCONNECTING,
    CONN_STATE_DISCONNECTED,
    CONN_STATE_INITIALISING,    // we've just returned from standby and are initialising
    CONN_STATE_INIT_WAITING,    // like initialising, but we must connect when done
};

typedef struct 
{
    const gchar *medium;        // connection medium
    const gchar *application;   // command line to start the conn-mgr application
} medium_t;


//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------

static const gint TIMEOUT_STARTUP_COMPLETED  = 40; // seconds
static const gint MIN_BATTERY_LEVEL_3G_START = 25; // minimum battery level (%) to *start* connection
static const gint MIN_BATTERY_LEVEL_3G_KEEP  = 20; // minimum battery level (%) to *keep* connection


#if WARNING_ON
static const gchar *conn_state_str[] =
        {
            [CONN_STATE_OFF]           = "OFF",
            [CONN_STATE_FLIGHTMODE]    = "FLIGHTMODE",
            [CONN_STATE_LOWBATT]       = "LOWBATT",
            [CONN_STATE_LOADING]       = "LOADING",
            [CONN_STATE_UNLOADING]     = "UNLOADING",
            [CONN_STATE_CONNECTING]    = "CONNECTING",
            [CONN_STATE_CONNECTED]     = "CONNECTED",
            [CONN_STATE_DISCONNECTING] = "DISCONNECTING",
            [CONN_STATE_DISCONNECTED]  = "DISCONNECTED",
            [CONN_STATE_INITIALISING]  = "INITIALISING",      
            [CONN_STATE_INIT_WAITING]  = "INITWAITING",
        };
#endif

static const medium_t media_list[] =
    {
        // medium,      application
#if MACHINE_IS_DR1000SW || MACHINE_IS_DR800SW
        { "wifi",      "/usr/bin/conn_wifi --background" },
        { "bluetooth", "/usr/bin/conn_blue --background" },
#elif MACHINE_IS_DR800SG
        { "3g",        "/usr/bin/conn_3g --background"   },
#endif
        { NULL, NULL }
    };


typedef enum { REQ_CONNECT = 0, REQ_DISCONNECT, REQ_FLIGHTMODE, REQ_LOWBATT } Request;

#if (LOGGING_ON)
static const char* req_names[] =
        {
            [REQ_CONNECT]    = "REQ_CONNECT",
            [REQ_DISCONNECT] = "REQ_DISCONNECT",
            [REQ_FLIGHTMODE] = "REQ_FLIGHTMODE",
            [REQ_LOWBATT]    = "REQ_LOWBATT"
        };
#endif

//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static enum state_conn       g_conn_state            = CONN_STATE_OFF;
static Request               g_request               = REQ_DISCONNECT;    // direction to go
static proc_t                *g_service              = NULL;
static gchar                 *g_medium               = "3g";
static gchar                 *g_profile              = NULL;
static gchar                 *g_disconnect_reason    = NULL;
static guint                 g_starting_source       = 0;
static GSList                *g_app_list             = NULL;


//============================================================================
// Local Function Definitions
//============================================================================

static void start_medium(const char *medium);
static void stop_medium(void);
static gboolean on_service_starting_timeout(gpointer data);
static void enter_disconnected_state();
static void enter_off_state();
static void conn_enable_lowbatt();
static void conn_disable_lowbatt();
static void conn_set_lowbatt(gboolean is_enabled);

#define set_string( str, val ) { g_free(str); str = g_strdup(val); }


//============================================================================
// Local Function Implementation
//============================================================================

#define EPA_INFO_FILE "/home/root/epa.txt"

static gint get_cooloff()
{
    float level;
    gint cooloff = 0;
    gint sec2wait = 0;
    
    FILE *f = fopen(EPA_INFO_FILE, "rb");
    if (f)
    {
        fscanf(f, "level: %f %%\n", &level);
        fscanf(f, "cool-off: %d sec", &cooloff);
        LOGPRINTF("level: %f, cool-off: %d", level, cooloff);
        fclose(f);
    }

    if (cooloff > 0)
    {
        struct stat st;
        struct timeval now;
        stat(EPA_INFO_FILE, &st);
        gettimeofday(&now, NULL);
        
        if (st.st_mtime > now.tv_sec)
        {
            // clock was set back after EPA_INFO_FILE was written,
            // touch file to make sure the cool off time will be reached
            utime(EPA_INFO_FILE, NULL);
            sec2wait = cooloff;
        }
        else
        {
            sec2wait = (st.st_mtime + cooloff) - now.tv_sec;
            if (sec2wait < 0)
            {
                // cooloff time has already passed
                sec2wait = 0;
            }
        }
        LOGPRINTF("now: %ld, file: %ld, sec2wait: %d", now.tv_sec, st.st_mtime, sec2wait);
    }

    return sec2wait;
}


static gint app_count()
{
    return g_slist_length(g_app_list);
}


static void app_add(const char *ipc_service)
{
    LOGPRINTF("entry: %s", ipc_service);

    GSList *li = g_app_list;
    
    while ( (li != NULL) && (li->data != NULL) )
    {
        if (strcmp(li->data, ipc_service) == 0)
        {
            return;
        }
        li = li->next;
    }

    // not found, add to list
    g_app_list = g_slist_prepend(g_app_list, g_strdup(ipc_service));
}


static void app_remove_all()
{
    LOGPRINTF("entry");
    g_slist_free(g_app_list);
    g_app_list = NULL;
}


static void app_remove(const char *ipc_service)
{
    LOGPRINTF("entry: %s", ipc_service);

    GSList *li = g_app_list;
    
    while ( (li != NULL) && (li->data != NULL) )
    {
        if (strcmp(li->data, ipc_service) == 0)
        {
            // app found, delete from list
            g_free(li->data);
            g_app_list = g_slist_delete_link(g_app_list, li);
            return;
        }
        li = li->next;
    }
}


static const gchar *medium_application(const char *medium)
{
    const medium_t *p_medlst;   // pointer in media_list[]

    LOGPRINTF("entry: %s", medium);
    
    for (p_medlst = media_list ; p_medlst->medium ; p_medlst++)
    {
        if (strcmp(p_medlst->medium, medium) == 0)
        {
            return p_medlst->application;
        }
    }
    return NULL;
}


#if MACHINE_IS_DR800SG
static void on_3g_ready(GPid pid, gint status, gpointer data)
{
    if (WIFEXITED(status) && (WEXITSTATUS(status) == 0))
    {
        LOGPRINTF("3G should be ready");
        conn_set_initialising(FALSE);
    }
    else
    {
        LOGPRINTF("abnormal exit status, ignore 3G ready");
    }
}
#endif


void conn_on_enter_standby(void)
{
#if MACHINE_IS_DR800SG
    if (g_conn_state != CONN_STATE_FLIGHTMODE) {
        LOGPRINTF("Disabling 3g");
        sys_spawn_sync("3g_off.sh");
    }
#endif
}


void conn_on_leave_standby(void)
{
#if MACHINE_IS_DR800SG
    if (g_conn_state != CONN_STATE_FLIGHTMODE) {
        LOGPRINTF("Enabling 3g");
        conn_set_initialising(TRUE);
        sys_spawn_async_with_callback("3g_boot.sh", on_3g_ready, NULL);
    }
#endif
}


static void set_request(Request req)
{
    LOGPRINTF("from %s -> %s", req_names[g_request], req_names[req]);
    g_request = req;
}


static void set_conn_state(enum state_conn new_state)
{
    LOGPRINTF("changing state %s -> %s", conn_state_str[g_conn_state], conn_state_str[new_state]);
    g_conn_state = new_state;
}


gboolean conn_is_online(void)
{
    return (g_conn_state == CONN_STATE_CONNECTED);
}


gboolean conn_is_initialising(void)
{
    return (g_conn_state == CONN_STATE_INITIALISING || 
            g_conn_state == CONN_STATE_INIT_WAITING);
}


gboolean conn_is_stopped()
{
    return (g_conn_state == CONN_STATE_OFF || 
            g_conn_state == CONN_STATE_FLIGHTMODE || 
            g_conn_state == CONN_STATE_LOWBATT || 
            g_conn_state == CONN_STATE_INITIALISING ||
            g_conn_state == CONN_STATE_INIT_WAITING);
}


void conn_check_battery(gint level)
{
    static gboolean warning_shown = FALSE;

    if (level < MIN_BATTERY_LEVEL_3G_KEEP)
    {
        conn_enable_lowbatt();
    }
    else if ((level <= MIN_BATTERY_LEVEL_3G_KEEP) && conn_is_online())
    {
        if (!warning_shown)
        {
            // show pre warning when nearing minimum battery level
            ipc_show_message("3glowwarning", NULL, NULL);
            warning_shown = TRUE;
        }
    }
    else
    {
        conn_disable_lowbatt();
        if (warning_shown)
        {
            warning_shown = FALSE;
        }
    }
}


static void clear_starting_source()
{
    if (g_starting_source > 0)
    {
        g_source_remove(g_starting_source);
        g_starting_source = 0;
    }
}


static void on_medium_started(void)
{
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    
    if (!g_service)
    {
        ERRORPRINTF("Huh? startupComplete received but no service running. Ignored.");
        return;
    }
    if (g_starting_source == 0)
    {
        ERRORPRINTF("Huh? startupComplete received but no timer running. Timed out?");
        return;
    }

    g_assert(g_conn_state == CONN_STATE_LOADING);
    clear_starting_source();
    enter_disconnected_state();

}


static void on_medium_exited(void)
{
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    
    clear_starting_source();

    // service (process) not present anymore
    g_service = NULL;

#if MACHINE_IS_DR800SG
    {
        // callout to bring down medium (unload modules, suspend or disable power)
        gchar *command = g_strconcat(g_medium, "_stop.sh", NULL);
        sys_spawn_sync(command);
        g_free(command);
    }
#endif
    
    switch (g_conn_state)
    {
        case CONN_STATE_OFF:
        case CONN_STATE_LOWBATT:
            LOGPRINTF("already in state %s", conn_state_str[g_conn_state]);
            break;
        
        case CONN_STATE_FLIGHTMODE:
            // turn off power to module in flightmode (same is in device standby)
            conn_on_enter_standby();
            break;

        case CONN_STATE_INITIALISING:
        case CONN_STATE_INIT_WAITING:
        case CONN_STATE_LOADING:
        case CONN_STATE_CONNECTING:
        case CONN_STATE_CONNECTED:
        case CONN_STATE_DISCONNECTING:
        case CONN_STATE_DISCONNECTED:
            WARNPRINTF("Medium EXITED unexpectedly, turning off");
            set_string(g_disconnect_reason, "connect-failed");
            if (g_request == REQ_CONNECT) set_request(REQ_DISCONNECT);
            enter_off_state();
            break;

        case CONN_STATE_UNLOADING:
            enter_off_state();
            break;
    }
}


static void start_medium(const char *medium)
{
    LOGPRINTF("entry - medium [%s]", medium);
    
    g_assert(medium);
    if (g_service)
    {
        ERRORPRINTF("Huh? A service (%s) is still running. Ignored.", g_service->command);
        return;
    }

    // callout to bring up medium (load modules, wakeup or enable power)
    gchar *command = g_strconcat(g_medium, "_start.sh", NULL);
    sys_spawn_sync(command);
    g_free(command);
    
    // start connection manager for medium
    g_service = process_start( medium_application(g_medium),
                               NULL,
                               G_CALLBACK(on_medium_started),
                               G_CALLBACK(on_medium_exited),
                               PS_WAIT_STARTED );
    if (g_service != NULL) {
        g_starting_source = g_timeout_add_seconds(TIMEOUT_STARTUP_COMPLETED, on_service_starting_timeout, NULL);
    } else {
        ERRORPRINTF("cannot start medium %s", medium_application(g_medium));
    }
}


static void stop_medium(void)
{
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    
    clear_starting_source();

    app_remove_all();

    if (g_service)
    {
        LOGPRINTF("stopping g_medium [%s] pid [%d]", g_medium, g_service->pid);
        process_stop(g_service);
    }
}


static gboolean on_service_starting_timeout(gpointer data)
{
    UNUSED(data);
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    g_assert(g_conn_state == CONN_STATE_LOADING);
    stop_medium();
    set_request(REQ_DISCONNECT);
    set_conn_state(CONN_STATE_UNLOADING);

    return FALSE;  // don't call again
}

static void force_statusbar_state(char *state)
{
    gchar *icon = g_strdup_printf("statusbar_%s", g_medium);
    ipc_menu_set_statusitem_state(icon, state);
    g_free(icon);
}


void conn_update_statusbar()
{
    const char* state = NULL;
    switch (g_conn_state) {
    case CONN_STATE_INITIALISING:
    case CONN_STATE_INIT_WAITING:
        state = "disabled";
        break;
    case CONN_STATE_FLIGHTMODE:
        state = "flightmode";
        break;
    case CONN_STATE_CONNECTED:
        state = "connected";
        break;
    case CONN_STATE_OFF:
    case CONN_STATE_LOWBATT:
    case CONN_STATE_LOADING:
    case CONN_STATE_UNLOADING:
    case CONN_STATE_CONNECTING:
    case CONN_STATE_DISCONNECTED:
    case CONN_STATE_DISCONNECTING:
        state = "disconnected";
        break;
    }
    gchar *icon = g_strdup_printf("statusbar_%s", g_medium);
    ipc_menu_set_statusitem_state(icon, state);
    g_free(icon);
}


void conn_set_initialising(gboolean is_init)
{
    LOGPRINTF("entry [%d]", is_init);

    if (is_init) {
        // if we're initialising, just set the state
        set_conn_state(CONN_STATE_INITIALISING);
    } else {
        if (g_request == REQ_FLIGHTMODE) {
            // flight mode was enabled during init, shut it down
            WARNPRINTF("Flightmode was requested, but we were initialising. Shutting down");
            conn_on_enter_standby();
            set_conn_state(CONN_STATE_FLIGHTMODE);
            conn_update_statusbar();
        } else if (g_conn_state==CONN_STATE_INIT_WAITING) {
            // connection requested, go immediately to connecting
            LOGPRINTF("3G now ready, starting");
            busy_remove_foreground(0);
            set_conn_state(CONN_STATE_LOADING);
            set_request(REQ_CONNECT);
            start_medium("3g");
        } else {
            // no connection requested, just go to off
            LOGPRINTF("3G now ready");
            set_conn_state(CONN_STATE_OFF);
        }
    }
}


static void enter_connected_state()
{
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    set_conn_state(CONN_STATE_CONNECTED);
    set_string(g_disconnect_reason, NULL);

    switch (g_request) {
    case REQ_FLIGHTMODE:
        LOGPRINTF("got flightmode request while connecting...disconnecting");
        set_conn_state(CONN_STATE_DISCONNECTING);
        ipc_disconnect(g_service->ipc_service);
        break;
    case REQ_LOWBATT:
        LOGPRINTF("got lowbattery request while connecting...disconnecting");
        set_conn_state(CONN_STATE_DISCONNECTING);
        ipc_disconnect(g_service->ipc_service);
        break;
    case REQ_CONNECT:
        // goal achieved, done
        ipc_broadcast_conn_status(TRUE, g_medium, g_profile, NULL);
        sys_update_rgb_led();
        conn_update_statusbar();
        break;
    case REQ_DISCONNECT:
        LOGPRINTF("got disconnect request while connecting...disconnecting");
        set_conn_state(CONN_STATE_DISCONNECTING);
        ipc_disconnect(g_service->ipc_service);
        break;
    }
}


static void enter_disconnected_state()
{
    LOGPRINTF("state=%s  req=%s  g_medium=%s", conn_state_str[g_conn_state],
            req_names[g_request], g_medium ? g_medium : "NULL");
    set_conn_state(CONN_STATE_DISCONNECTED);
    conn_update_statusbar();
    sys_update_rgb_led();

    switch (g_request) {
    case REQ_CONNECT:
        set_conn_state(CONN_STATE_CONNECTING);
        ipc_connect(g_service->ipc_service, g_medium, g_profile);
        break;
    case REQ_FLIGHTMODE:
    case REQ_LOWBATT:
    case REQ_DISCONNECT:
        set_conn_state(CONN_STATE_UNLOADING);
        stop_medium();
        break;
    }
}


static void enter_off_state()
{
    LOGPRINTF("state=%s  req=%s  g_medium=%s", conn_state_str[g_conn_state],
            req_names[g_request], g_medium ? g_medium : "NULL");

    enum state_conn old_state = g_conn_state;
    set_conn_state(CONN_STATE_OFF);
    conn_update_statusbar();
    sys_update_rgb_led();
    if (old_state != CONN_STATE_FLIGHTMODE)
    {
        ipc_broadcast_conn_status(FALSE, g_medium, g_profile, "connect-failed");
    }
    else if (g_request==REQ_DISCONNECT)
    {
        LOGPRINTF("old state is flight mode and disconnect request -> reenable 3g");
        conn_on_leave_standby();
    }

    switch (g_request) {
    case REQ_DISCONNECT:
        LOGPRINTF("unloading done, state is OFF -- reason [%s]", g_disconnect_reason);
        if (g_disconnect_reason && strcmp(g_disconnect_reason, "sar-limit-reached")==0)
        {
            ipc_show_message("3gsarlimit", NULL, NULL);
        }
        break;
    case REQ_LOWBATT:
        LOGPRINTF("unloading done, state lowbatt");
        conn_set_lowbatt(TRUE);
        break;
    case REQ_FLIGHTMODE:
        LOGPRINTF("unloading done, setting flightmode");
        conn_set_flightmode(TRUE);
        break;
    case REQ_CONNECT:
        LOGPRINTF("connect request during unloading, loading");
        set_conn_state(CONN_STATE_LOADING);
        // NOTE: hardcoded
        start_medium("3g");
        break;
    }
}


//============================================================================
// Function Implementation
//============================================================================

static void on_flightmode_dialog_return(eripc_context_t *context,
                                        const eripc_event_info_t *info,
                                        void  *user_data)
{
    UNUSED(context);
    UNUSED(info);
    LOGPRINTF("entry");
    gchar *ipc_service = user_data;
    ipc_send_conn_status(ipc_service, FALSE, g_medium, g_profile, "flightmode");
    g_free(ipc_service);
}


static void on_lowbatt_dialog_return(eripc_context_t *context,
                                     const eripc_event_info_t *info,
                                     void  *user_data)
{
    UNUSED(context);
    UNUSED(info);
    LOGPRINTF("entry");
    gchar *ipc_service = user_data;
    ipc_send_conn_status(ipc_service, FALSE, g_medium, g_profile, "lowbattery");
    g_free(ipc_service);
}


// received connConnect from application
gboolean conn_connect(const char *ipc_service, const char *medium, const char *profile)
{
    gboolean retval = FALSE;
    int cooloff = get_cooloff();

    LOGPRINTF("state=%s  req=%s  medium=[%s]  profile=[%s]", conn_state_str[g_conn_state],
            req_names[g_request], medium ? medium : "NULL", profile ? profile : "NULL");
        
    if (g_conn_state==CONN_STATE_INITIALISING)
    {
        LOGPRINTF("Connection still initialising, waiting until complete");
        busy_add_foreground(0, BUSY_DIALOG_DIRECT, NULL);
        set_conn_state(CONN_STATE_INIT_WAITING);
        return TRUE;
    }

    // it's possible to open new connections when already online
    // but don't start new connections when OFFLINE and below MIN_BATTERY_LEVEL_3G_START
    if (g_conn_state == CONN_STATE_OFF && sys_battery_level() < MIN_BATTERY_LEVEL_3G_START)
    {
        ipc_show_message("3glowconnect", on_lowbatt_dialog_return, g_strdup(ipc_service));
        return FALSE;
    }

    if (cooloff > 0)
    {
        LOGPRINTF("Need to cool off for another %d minutes [%d]", (cooloff+60-1) / 60, cooloff);
        gchar *message = g_strdup_printf("3gcooloff_%d", (cooloff+60-1) / 60);
        ipc_show_message(message, on_lowbatt_dialog_return, g_strdup(ipc_service));
        g_free(message);
        return FALSE;
    }
    
    if (g_conn_state != CONN_STATE_FLIGHTMODE) {
        app_add(ipc_service);
        set_string(g_profile, profile);     // not used
    }

    // on emulator: always return connected
    if (sys_is_emulator() && g_conn_state != CONN_STATE_FLIGHTMODE) {
        WARNPRINTF("emulator mode");
        ipc_send_conn_status(ipc_service, TRUE, medium, profile, NULL);
        return TRUE;
    }

    switch (g_conn_state) {
    case CONN_STATE_INITIALISING:
    case CONN_STATE_INIT_WAITING:
        break;
    case CONN_STATE_OFF:
        set_conn_state(CONN_STATE_LOADING);
        set_request(REQ_CONNECT);
        start_medium(medium);
        retval = TRUE;
        break;
    case CONN_STATE_LOWBATT:
        ipc_show_message("3glowconnect", on_lowbatt_dialog_return, g_strdup(ipc_service));
        break;
    case CONN_STATE_FLIGHTMODE:
        ipc_show_message("flightmode", on_flightmode_dialog_return, g_strdup(ipc_service));
        break;
    case CONN_STATE_DISCONNECTED:
        set_conn_state(CONN_STATE_CONNECTING);
        set_request(REQ_CONNECT);
        ipc_connect(g_service->ipc_service, medium, profile);
        retval = TRUE;
        break;
    case CONN_STATE_CONNECTED:
        ipc_send_conn_status(ipc_service, TRUE, medium, profile, NULL);
        retval = TRUE;
        break;
    case CONN_STATE_LOADING:
    case CONN_STATE_UNLOADING:
    case CONN_STATE_CONNECTING:
    case CONN_STATE_DISCONNECTING:
        set_request(REQ_CONNECT);
        retval = TRUE;
        break;
    default:
        WARNPRINTF("unhandled state [%d]", g_conn_state);
        break;
    }
    return retval;
}


// received connDisconnect from application
gboolean conn_disconnect(const char *ipc_service)
{
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    
    app_remove(ipc_service);

    if (sys_is_emulator()) {
        WARNPRINTF("emulator mode");
        ipc_send_conn_status(ipc_service, FALSE, g_medium, g_profile, NULL);
        return TRUE;
    }

    switch (g_conn_state) {
    case CONN_STATE_INITIALISING:
    case CONN_STATE_INIT_WAITING:
    case CONN_STATE_OFF:
    case CONN_STATE_FLIGHTMODE:
    case CONN_STATE_LOWBATT:
    case CONN_STATE_DISCONNECTED:
        LOGPRINTF("got disconnect request in state %s - cleanup", conn_state_str[g_conn_state]);
        return FALSE;
    case CONN_STATE_CONNECTED:
        if (app_count() == 0) {
            // no applications using connection, disconnect
            set_conn_state(CONN_STATE_DISCONNECTING);
            set_request(REQ_DISCONNECT);
            ipc_disconnect(g_service->ipc_service);
        }
        break;
    case CONN_STATE_LOADING:
    case CONN_STATE_UNLOADING:
    case CONN_STATE_CONNECTING:
        if (app_count() == 0) {
            set_request(REQ_DISCONNECT);
        }
        return TRUE;
    case CONN_STATE_DISCONNECTING:
        if (app_count() == 0) {
            set_request(REQ_DISCONNECT);
            // try to cancel connecting by sending disconnect to ConnMgr
            LOGPRINTF("trying to cancel conn. mgr");
            ipc_disconnect(g_service->ipc_service);
        }
        return TRUE;
    }
    return FALSE;
}


static gboolean handle_connected_event(const char* medium, const char* profile)
{
    LOGPRINTF("state=%s  req=%s  medium=[%s]  profile=[%s]", conn_state_str[g_conn_state],
            req_names[g_request], medium ? medium : "NULL", profile ? profile : "NULL");
    g_assert(g_service);
    int rc = FALSE;

    switch (g_conn_state) {
        case CONN_STATE_INITIALISING:
        case CONN_STATE_INIT_WAITING:
        case CONN_STATE_OFF:
        case CONN_STATE_FLIGHTMODE:
        case CONN_STATE_LOWBATT:
        case CONN_STATE_DISCONNECTED:
        case CONN_STATE_CONNECTED:
        case CONN_STATE_LOADING:
        case CONN_STATE_UNLOADING:
        case CONN_STATE_DISCONNECTING:
            WARNPRINTF("received status CONNECTED %s/%s but state is %s. Ignored.", medium, profile, conn_state_str[g_conn_state]);
            return FALSE;
            break;
        case CONN_STATE_CONNECTING:
            enter_connected_state();
            rc = TRUE;
            break;
    }
    return rc;
}


static gboolean handle_disconnected_event(const char* medium, const char* profile, const char* reason)
{
    LOGPRINTF("state=%s  req=%s  reason=%s", conn_state_str[g_conn_state],
            req_names[g_request], reason ? reason : "NULL");
    int rc = FALSE;

    set_string(g_disconnect_reason, reason);
    switch (g_conn_state) {
        case CONN_STATE_INITIALISING:
        case CONN_STATE_INIT_WAITING:
        case CONN_STATE_OFF:
        case CONN_STATE_FLIGHTMODE:
        case CONN_STATE_LOWBATT:
        case CONN_STATE_DISCONNECTED:
        case CONN_STATE_LOADING:
        case CONN_STATE_UNLOADING:
            WARNPRINTF("received status DISCONNECTED %s/%s but state is %s. Ignored.", medium, profile, conn_state_str[g_conn_state]);
            break;
        case CONN_STATE_CONNECTED:
            set_request(REQ_DISCONNECT);
            enter_disconnected_state();
            break;
        case CONN_STATE_DISCONNECTING:
            enter_disconnected_state();
            rc = TRUE;
            break;
        case CONN_STATE_CONNECTING:
            WARNPRINTF("connecting failed, request disconnect");
            set_request(REQ_DISCONNECT);
            enter_disconnected_state();
            break;
    }
    return rc;
}


// received connConnectionStatus from connection manager
gboolean conn_set_status(gboolean is_connected, const char *medium, const char *profile, const char* reason)
{
    int rc = FALSE;
    if (is_connected) {
        rc = handle_connected_event(medium, profile);
    } else {
        rc = handle_disconnected_event(medium, profile, reason);
    }
    return rc;
}


// received connConnectionStatusRequest from application
gboolean conn_status_request(const char *ipc_service)
{
    gboolean rc = FALSE;
    
    LOGPRINTF("entry");

    switch (g_conn_state)
    {
        case CONN_STATE_CONNECTED:
            ipc_send_conn_status(ipc_service, TRUE, g_medium, g_profile, "");
            rc = TRUE;
            break;
                   
        case CONN_STATE_INITIALISING:
        case CONN_STATE_INIT_WAITING:
        case CONN_STATE_OFF:
        case CONN_STATE_FLIGHTMODE:
        case CONN_STATE_LOWBATT:
        case CONN_STATE_DISCONNECTED:
            ipc_send_conn_status(ipc_service, FALSE, NULL, NULL, g_disconnect_reason);
            rc = TRUE;
            break;

        case CONN_STATE_LOADING:
        case CONN_STATE_UNLOADING:
        case CONN_STATE_CONNECTING:
        case CONN_STATE_DISCONNECTING:
            WARNPRINTF("Received status request but state is %s. Status will follow", conn_state_str[g_conn_state]);
            break;
    }
    return rc;
}


// received connAddProfile from application
gboolean conn_add_profile(const char *medium)
{
    UNUSED(medium);
    LOGPRINTF("entry");
    return FALSE;
}


// received connEditProfile from application
gboolean conn_edit_profile(const char *medium, const char *profile)
{
    UNUSED(medium);
    UNUSED(profile);
    LOGPRINTF("entry");
    return FALSE;
}


static void conn_enable_lowbatt()
{
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    switch (g_conn_state)
    {
        case CONN_STATE_OFF:
            set_request(REQ_LOWBATT);
            set_conn_state(CONN_STATE_LOWBATT);
            conn_update_statusbar();
            break;
        case CONN_STATE_FLIGHTMODE:
            LOGPRINTF("flightmode has preference over lowbatt. Ignoring");
            break;
        case CONN_STATE_LOWBATT:
            LOGPRINTF("already in state %s", conn_state_str[g_conn_state]);
            break;
        case CONN_STATE_INITIALISING:
        case CONN_STATE_INIT_WAITING:
        case CONN_STATE_LOADING:
        case CONN_STATE_UNLOADING:
        case CONN_STATE_DISCONNECTING:
        case CONN_STATE_CONNECTING:
            set_request(REQ_LOWBATT);
            break;
        case CONN_STATE_CONNECTED:
            set_request(REQ_LOWBATT);
            set_conn_state(CONN_STATE_DISCONNECTING);
            ipc_show_message("3glowdisconnected", NULL, NULL);
            ipc_disconnect(g_service->ipc_service);
            break;
        case CONN_STATE_DISCONNECTED:
            set_request(REQ_LOWBATT);
            set_conn_state(CONN_STATE_UNLOADING);
            stop_medium();
            break;
    }
}


static void conn_disable_lowbatt()
{
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    switch (g_conn_state)
    {
        case CONN_STATE_OFF:
        case CONN_STATE_FLIGHTMODE:
            LOGPRINTF("already in state %s", conn_state_str[g_conn_state]);
            break;
        case CONN_STATE_LOWBATT:
            set_request(REQ_DISCONNECT);
            enter_off_state();
            break;
        case CONN_STATE_INITIALISING:
        case CONN_STATE_INIT_WAITING:
        case CONN_STATE_LOADING:
        case CONN_STATE_CONNECTING:
        case CONN_STATE_CONNECTED:
        case CONN_STATE_DISCONNECTED:
            LOGPRINTF("cannot disable lowbatt in state %s. Ignoring", conn_state_str[g_conn_state]);
            break;
        case CONN_STATE_UNLOADING:
            set_request(REQ_DISCONNECT);
            break;
        case CONN_STATE_DISCONNECTING:
            // TODO check if there are connections
            break;
    }
}


// lowbatt mode changed
void conn_set_lowbatt(gboolean is_enabled)
{
    LOGPRINTF("entry: is_enabled [%d]", is_enabled);

    if (is_enabled) {
        conn_enable_lowbatt();
    } else {
        conn_disable_lowbatt();
    }
}


static void conn_enable_flightmode()
{
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    switch (g_conn_state)
    {
        case CONN_STATE_OFF:
        case CONN_STATE_LOWBATT:
            conn_on_enter_standby();
            set_request(REQ_FLIGHTMODE);
            set_conn_state(CONN_STATE_FLIGHTMODE);
            conn_update_statusbar();
            break;
        case CONN_STATE_FLIGHTMODE:
            LOGPRINTF("already in state %s", conn_state_str[g_conn_state]);
            break;
        case CONN_STATE_INITIALISING:
        case CONN_STATE_INIT_WAITING:
            /* we use force_statusbar_state here because conn_disable_flightmode 
             * updates based on g_conn_state and the state will remain ..._INIT* for
             * the entire 5-10 seconds of modem init 
             */
            force_statusbar_state("flightmode");
            set_request(REQ_FLIGHTMODE);
            break;
        case CONN_STATE_LOADING:
        case CONN_STATE_UNLOADING:
        case CONN_STATE_DISCONNECTING:
        case CONN_STATE_CONNECTING:
            set_request(REQ_FLIGHTMODE);
            break;
        case CONN_STATE_CONNECTED:
            set_request(REQ_FLIGHTMODE);
            set_conn_state(CONN_STATE_DISCONNECTING);
            ipc_disconnect(g_service->ipc_service);
            break;
        case CONN_STATE_DISCONNECTED:
            set_request(REQ_FLIGHTMODE);
            set_conn_state(CONN_STATE_UNLOADING);
            stop_medium();
            break;
    }
}


static void conn_disable_flightmode()
{
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    switch (g_conn_state)
    {
        case CONN_STATE_OFF:
        case CONN_STATE_LOWBATT:
            LOGPRINTF("already in state %s", conn_state_str[g_conn_state]);
            break;
        case CONN_STATE_FLIGHTMODE:
            set_request(REQ_DISCONNECT);
            enter_off_state();
            break;
        case CONN_STATE_INITIALISING:
        case CONN_STATE_INIT_WAITING:
            force_statusbar_state("disconnected");
            set_request(REQ_DISCONNECT);
            break;
        case CONN_STATE_LOADING:
        case CONN_STATE_CONNECTING:
        case CONN_STATE_CONNECTED:
        case CONN_STATE_DISCONNECTED:
            LOGPRINTF("cannot disable flightmode in state %s. Ignoring", conn_state_str[g_conn_state]);
            break;
        case CONN_STATE_UNLOADING:
            set_request(REQ_DISCONNECT);
            break;
        case CONN_STATE_DISCONNECTING:
            // TODO check if there are connections
            break;
    }
}


// flight mode changed
void conn_set_flightmode (gboolean is_enabled)
{
    LOGPRINTF("entry: is_enabled [%d]", is_enabled);

    if (is_enabled) {
        conn_enable_flightmode();
    } else {
        conn_disable_flightmode();
    }
}


// statusbar icon clicked
void conn_on_statusitem_activated (void)
{
    if (g_conn_state == CONN_STATE_FLIGHTMODE)
    {
        conf_set_flightmode(FALSE);
    }
}


void conn_stop(void)
{
    LOGPRINTF("state=%s  req=%s", conn_state_str[g_conn_state], req_names[g_request]);
    switch (g_conn_state)
    {
        case CONN_STATE_OFF:
        case CONN_STATE_FLIGHTMODE:
        case CONN_STATE_LOWBATT:
            // already unloaded
            break;
        case CONN_STATE_INIT_WAITING:
            set_request(REQ_DISCONNECT);
            // NOTE: cancel connect request by sending disconnect
            //       even though medium is not running yet
            busy_remove_foreground(0);
            enter_off_state();
            break;
        case CONN_STATE_INITIALISING:
        case CONN_STATE_LOADING:
        case CONN_STATE_UNLOADING:
        case CONN_STATE_DISCONNECTING:
            set_request(REQ_DISCONNECT);
            break;
        case CONN_STATE_CONNECTING:
            set_request(REQ_DISCONNECT);
            // NOTE: cancel connect request by sending disconnect
            ipc_disconnect(g_service->ipc_service);
            break;
        case CONN_STATE_CONNECTED:
            set_request(REQ_DISCONNECT);
            set_conn_state(CONN_STATE_DISCONNECTING);
            ipc_disconnect(g_service->ipc_service);
            break;
        case CONN_STATE_DISCONNECTED:
            set_request(REQ_DISCONNECT);
            set_conn_state(CONN_STATE_UNLOADING);
            stop_medium();
            break;
    }
}