/**

@file usb_moded-dbus.c

Copyright (C) 2010 Nokia Corporation. All rights reserved.

@author: Philippe De Swert <philippe.de-swert@nokia.com>

This program is free software; you can redistribute it and/or

modify it under the terms of the Lesser GNU General Public License

version 2 as published by the Free Software Foundation.

This program 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 Lesser GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

02110-1301 USA

*/

#include <stdio.h>

#include <string.h>

#include <dbus/dbus.h>

#include <dbus/dbus-glib.h>

#include <dbus/dbus-glib-lowlevel.h>

#include "usb_moded-dbus.h"

#include "usb_moded-dbus-private.h"

#include "usb_moded.h"

#include "usb_moded-modes.h"

#include "usb_moded-log.h"

#define INIT_DONE_INTERFACE "com.nokia.startup.signal"

#define INIT_DONE_SIGNAL "init_done"

#define INIT_DONE_MATCH "type='signal',interface='"INIT_DONE_INTERFACE"',member='"INIT_DONE_SIGNAL"'"

/**

* Issues "sig_usb_config_ind" signal.

*/

static void usb_moded_send_config_signal(const char *section, const char *key, const char *value)

{

log_debug(USB_MODE_CONFIG_SIGNAL_NAME ": %s %s %s\n", section, key, value);

if (dbus_connection_sys)

{

DBusMessage* msg = dbus_message_new_signal(USB_MODE_OBJECT, USB_MODE_INTERFACE, USB_MODE_CONFIG_SIGNAL_NAME);

if (msg) {

dbus_message_append_args(msg, DBUS_TYPE_STRING, &section,

DBUS_TYPE_STRING, &key,

DBUS_TYPE_STRING, &value,

DBUS_TYPE_INVALID);

dbus_connection_send(dbus_connection_sys, msg, NULL);

dbus_message_unref(msg);

}

}

}

static DBusHandlerResult msg_handler(DBusConnection *const connection, DBusMessage *const msg, gpointer const user_data)

{

DBusHandlerResult status = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

DBusMessage *reply = 0;

const char *interface = dbus_message_get_interface(msg);

const char *member = dbus_message_get_member(msg);

const char *object = dbus_message_get_path(msg);

int type = dbus_message_get_type(msg);

"\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"

"<node name=\"" USB_MODE_OBJECT "\">\n"

" <interface name=\"org.freedesktop.DBus.Introspectable\">\n"

" <method name=\"Introspect\">\n"

" <arg name=\"xml\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" </interface>\n"

" <interface name=\"" USB_MODE_INTERFACE "\">\n"

" <method name=\"" USB_MODE_STATE_REQUEST "\">\n"

" <arg name=\"mode\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"" USB_MODE_STATE_SET "\">\n"

" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n"

" <arg name=\"mode\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"" USB_MODE_CONFIG_SET "\">\n"

" <arg name=\"config\" type=\"s\" direction=\"in\"/>\n"

" <arg name=\"config\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"" USB_MODE_NETWORK_SET "\">\n"

" <arg name=\"key\" type=\"s\" direction=\"in\"/>\n"

" <arg name=\"value\" type=\"s\" direction=\"in\"/>\n"

" <arg name=\"key\" type=\"s\" direction=\"out\"/>\n"

" <arg name=\"value\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"" USB_MODE_NETWORK_GET "\">\n"

" <arg name=\"key\" type=\"s\" direction=\"in\"/>\n"

" <arg name=\"key\" type=\"s\" direction=\"out\"/>\n"

" <arg name=\"value\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"" USB_MODE_CONFIG_GET "\">\n"

" <arg name=\"mode\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"" USB_MODE_LIST "\">\n"

" <arg name=\"modes\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"" USB_MODE_RESCUE_OFF "\"/>\n"

" <signal name=\"" USB_MODE_SIGNAL_NAME "\">\n"

" <arg name=\"mode\" type=\"s\"/>\n"

" </signal>\n"

" <signal name=\"" USB_MODE_ERROR_SIGNAL_NAME "\">\n"

" <arg name=\"error\" type=\"s\"/>\n"

" </signal>\n"

" <signal name=\"" USB_MODE_SUPPORTED_MODES_SIGNAL_NAME "\">\n"

" <arg name=\"modes\" type=\"s\"/>\n"

" </signal>\n"

" <signal name=\"" USB_MODE_CONFIG_SIGNAL_NAME "\">\n"

" <arg name=\"section\" type=\"s\"/>\n"

" <arg name=\"key\" type=\"s\"/>\n"

" <arg name=\"value\" type=\"s\"/>\n"

" </signal>\n"

" </interface>\n"

"</node>\n";

(void)user_data;

if(!interface || !member || !object) goto EXIT;

if( type == DBUS_MESSAGE_TYPE_SIGNAL )

{

if( !strcmp(interface, INIT_DONE_INTERFACE) && !strcmp(member, INIT_DONE_SIGNAL) ) {

/* Auto-disable rescue mode when bootup is finished */

if( rescue_mode ) {

rescue_mode = FALSE;

log_debug("init done reached - rescue mode disabled");

}

}

goto EXIT;

}

if( type == DBUS_MESSAGE_TYPE_METHOD_CALL && !strcmp(interface, USB_MODE_INTERFACE) && !strcmp(object, USB_MODE_OBJECT))

{

status = DBUS_HANDLER_RESULT_HANDLED;

if(!strcmp(member, USB_MODE_STATE_REQUEST))

{

/* To the outside we want to keep CHARGING and CHARGING_FALLBACK the same */

if(!strcmp(MODE_CHARGING_FALLBACK, mode))

if((reply = dbus_message_new_method_return(msg)))

dbus_message_append_args (reply, DBUS_TYPE_STRING, &mode, DBUS_TYPE_INVALID);

}

else if(!strcmp(member, USB_MODE_STATE_SET))

{

char *use = 0;

DBusError err = DBUS_ERROR_INIT;

if(!dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &use, DBUS_TYPE_INVALID))

reply = dbus_message_new_error(msg, DBUS_ERROR_INVALID_ARGS, member);

else

{

/* check if usb is connected, since it makes no sense to change mode if it isn't */

if(!get_usb_connection_state())

{

log_warning("USB not connected, not changing mode!\n");

/* check if the mode exists */

if(valid_mode(use))

goto error_reply;

/* do not change mode if the mode requested is the one already set */

if(strcmp(use, get_usb_mode()) != 0)

{

usb_moded_mode_cleanup(get_usb_module());

if((reply = dbus_message_new_method_return(msg)))

dbus_message_append_args (reply, DBUS_TYPE_STRING, &use, DBUS_TYPE_INVALID);

}

dbus_error_free(&err);

}

else if(!strcmp(member, USB_MODE_CONFIG_SET))

{

char *config = 0;

DBusError err = DBUS_ERROR_INIT;

if(!dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &config, DBUS_TYPE_INVALID))

reply = dbus_message_new_error(msg, DBUS_ERROR_INVALID_ARGS, member);

else

{

int ret = set_mode_setting(config);

if (ret == SET_CONFIG_UPDATED)

usb_moded_send_config_signal(MODE_SETTING_ENTRY, MODE_SETTING_KEY, config);

if (SET_CONFIG_OK(ret))

if((reply = dbus_message_new_method_return(msg)))

dbus_message_append_args (reply, DBUS_TYPE_STRING, &config, DBUS_TYPE_INVALID);

}

else

}

else if(!strcmp(member, USB_MODE_HIDE))

{

char *config = 0;

DBusError err = DBUS_ERROR_INIT;

if(!dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &config, DBUS_TYPE_INVALID))

reply = dbus_message_new_error(msg, DBUS_ERROR_INVALID_ARGS, member);

else

{

/* error checking is done when setting configuration */

int ret = set_hide_mode_setting(config);

if (ret == SET_CONFIG_UPDATED)

usb_moded_send_config_signal(MODE_SETTING_ENTRY, MODE_HIDE_KEY, config);

if (SET_CONFIG_OK(ret))

{

if((reply = dbus_message_new_method_return(msg)))

dbus_message_append_args (reply, DBUS_TYPE_STRING, &config, DBUS_TYPE_INVALID);

}

else

}

else if(!strcmp(member, USB_MODE_UNHIDE))

{

char *config = 0;

DBusError err = DBUS_ERROR_INIT;

if(!dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &config, DBUS_TYPE_INVALID))

reply = dbus_message_new_error(msg, DBUS_ERROR_INVALID_ARGS, member);

else

{

/* error checking is done when setting configuration */

int ret = set_unhide_mode_setting(config);

if (ret == SET_CONFIG_UPDATED)

usb_moded_send_config_signal(MODE_SETTING_ENTRY, MODE_HIDE_KEY, config);

if (SET_CONFIG_OK(ret))

if((reply = dbus_message_new_method_return(msg)))

dbus_message_append_args (reply, DBUS_TYPE_STRING, &config, DBUS_TYPE_INVALID);

}

else

else if(!strcmp(member, USB_MODE_HIDDEN_GET))

{

char *config = get_hidden_modes();

if(!config)

if((reply = dbus_message_new_method_return(msg)))

dbus_message_append_args (reply, DBUS_TYPE_STRING, &config, DBUS_TYPE_INVALID);

else if(!strcmp(member, USB_MODE_NETWORK_SET))

{

char *config = 0, *setting = 0;

DBusError err = DBUS_ERROR_INIT;

if(!dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &config, DBUS_TYPE_STRING, &setting, DBUS_TYPE_INVALID))

reply = dbus_message_new_error(msg, DBUS_ERROR_INVALID_ARGS, member);

else

{

int ret = set_network_setting(config, setting);

if (ret == SET_CONFIG_UPDATED)

usb_moded_send_config_signal(NETWORK_ENTRY, config, setting);

if (SET_CONFIG_OK(ret))

if((reply = dbus_message_new_method_return(msg)))

dbus_message_append_args (reply, DBUS_TYPE_STRING, &config, DBUS_TYPE_STRING, &setting, DBUS_TYPE_INVALID);

}

else

else if(!strcmp(member, USB_MODE_NETWORK_GET))

{

char *config = 0;

DBusError err = DBUS_ERROR_INIT;

if(!dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &config, DBUS_TYPE_INVALID))

{

reply = dbus_message_new_error(msg, DBUS_ERROR_INVALID_ARGS, member);

}

else

{

setting = get_network_setting(config);

if(setting)

{

if((reply = dbus_message_new_method_return(msg)))

dbus_message_append_args (reply, DBUS_TYPE_STRING, &config, DBUS_TYPE_STRING, &setting, DBUS_TYPE_INVALID);

}

else

reply = dbus_message_new_error(msg, DBUS_ERROR_INVALID_ARGS, config);

}

}

else if(!strcmp(member, USB_MODE_CONFIG_GET))

{

if(!config)

{

/* Config is corrupted or we do not have a mode

* configured, fallback to undefined. */

config = g_strdup(MODE_UNDEFINED);

}

if((reply = dbus_message_new_method_return(msg)))

dbus_message_append_args (reply, DBUS_TYPE_STRING, &config, DBUS_TYPE_INVALID);

else if(!strcmp(member, USB_MODE_LIST))

{

if((reply = dbus_message_new_method_return(msg)))

dbus_message_append_args (reply, DBUS_TYPE_STRING, (const char *) &mode_list, DBUS_TYPE_INVALID);

g_free(mode_list);

else if(!strcmp(member, USB_MODE_RESCUE_OFF))

{

rescue_mode = FALSE;

reply = dbus_message_new_method_return(msg);

}

else

{

/*unknown methods are handled here */

reply = dbus_message_new_error(msg, DBUS_ERROR_UNKNOWN_METHOD, member);

}

if( !reply )

{

reply = dbus_message_new_error(msg, DBUS_ERROR_FAILED, member);

}

}

else if( type == DBUS_MESSAGE_TYPE_METHOD_CALL && !strcmp(interface, "org.freedesktop.DBus.Introspectable") &&

!strcmp(object, USB_MODE_OBJECT) && !strcmp(member, "Introspect"))

{

dbus_message_append_args (reply, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID);

}

EXIT:

if(reply)

{

if( !dbus_message_get_no_reply(msg) )

{

if( !dbus_connection_send(connection, reply, 0) )

log_debug("Failed sending reply. Out Of Memory!\n");

}

dbus_message_unref(reply);

}

return status;

}

/**

* Init dbus for usb_moded

*

* @return TRUE when everything went ok

*/

gboolean usb_moded_dbus_init(void)

{

gboolean status = FALSE;

DBusError error;

int ret;

dbus_error_init(&error);

/* connect to system bus */

goto EXIT;

}

/* Initialise message handlers */

if (!dbus_connection_add_filter(dbus_connection_sys, msg_handler, NULL, NULL))

goto EXIT;

/* Acquire D-Bus service */

ret = dbus_bus_request_name(dbus_connection_sys, USB_MODE_SERVICE, DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);

{

log_debug("failed claiming dbus name\n");

if( dbus_error_is_set(&error) )

log_debug("DBUS ERROR: %s, %s \n", error.name, error.message);

goto EXIT;

}

/* only match on signals/methods we support (if needed)

dbus_bus_add_match(dbus_connection_sys, USB_MODE_INTERFACE, &error);

*/

/* Listen to init-done signals */

dbus_bus_add_match(dbus_connection_sys, INIT_DONE_MATCH, 0);

dbus_threads_init_default();

/* Connect D-Bus to the mainloop */

dbus_connection_setup_with_g_main(dbus_connection_sys, NULL);

/* everything went fine */

status = TRUE;

dbus_error_free(&error);

return status;

}

/**

* Clean up the dbus connections on exit

*

*/

void usb_moded_dbus_cleanup(void)

{

/* clean up system bus connection */

dbus_connection_remove_filter(dbus_connection_sys, msg_handler, NULL);

dbus_connection_unref(dbus_connection_sys);

dbus_connection_sys = NULL;

}

}

/**

* @param signal_type the type of signal (normal, error, ...)

* @@param content string which can be mode name, error, list of modes, ...

{

int result = 1;

DBusMessage* msg = 0;

if(!dbus_connection_sys)

{

log_err("Dbus system connection broken!\n");

goto EXIT;

}

if (NULL == msg)

{

log_debug("Message Null\n");

goto EXIT;

}

// append arguments onto signal

if (!dbus_message_append_args(msg, DBUS_TYPE_STRING, &content, DBUS_TYPE_INVALID))

{

log_debug("Appending arguments failed. Out Of Memory!\n");

goto EXIT;

}

// send the message on the correct bus and flush the connection

goto EXIT;

}

result = 0;

EXIT:

// free the message

if(msg != 0)

dbus_message_unref(msg);

return result;

}

/**

* Send regular usb_moded state signal

*

* @param state_ind the signal name

*

*/

int usb_moded_send_signal(const char *state_ind)

return(usb_moded_dbus_signal(USB_MODE_SIGNAL_NAME, state_ind));

}

/**

* Send regular usb_moded error signal

*

*

*/

int usb_moded_send_error_signal(const char *error)

{

return(usb_moded_dbus_signal(USB_MODE_ERROR_SIGNAL_NAME, error));

/**

* Send regular usb_moded mode list signal

*

*

*/

int usb_moded_send_supported_modes_signal(const char *supported_modes)

{

/**

* Send regular usb_moded hidden mode list signal

*

* @return 0 on success, 1 on failure

* @param hidden_modes list of supported modes

*

*/

int usb_moded_send_hidden_modes_signal(const char *hidden_modes)

{

return(usb_moded_dbus_signal(USB_MODE_HIDDEN_MODES_SIGNAL_NAME, hidden_modes));

}