It implements the emulator manager to create or destroy emulators. The type of emulator can be DUN, HFP AG or SPP. --- Makefile.am | 6 +- include/dbus.h | 2 + include/emulator.h | 41 ++++++ src/emulator.c | 355 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/ofono.h | 10 ++ 5 files changed, 412 insertions(+), 2 deletions(-) create mode 100644 include/emulator.h create mode 100644 src/emulator.c diff --git a/Makefile.am b/Makefile.am index 463e52e..707c622 100644 --- a/Makefile.am +++ b/Makefile.am @@ -12,7 +12,8 @@ include_HEADERS = include/log.h include/plugin.h include/history.h \ include/netreg.h include/voicecall.h include/devinfo.h \ include/cbs.h include/call-volume.h \ include/gprs.h include/gprs-context.h \ - include/radio-settings.h include/stk.h + include/radio-settings.h include/stk.h \ + include/emulator.h nodist_include_HEADERS = include/version.h @@ -259,7 +260,8 @@ src_ofonod_SOURCES = $(gdbus_sources) $(builtin_sources) \ src/simutil.h src/simutil.c src/storage.h \ src/storage.c src/cbs.c src/watch.c src/call-volume.c \ src/gprs.c src/idmap.h src/idmap.c \ - src/radio-settings.c src/stkutil.h src/stkutil.c + src/radio-settings.c src/stkutil.h src/stkutil.c \ + src/emulator.c src_ofonod_LDADD = $(builtin_libadd) @GLIB_LIBS@ @DBUS_LIBS@ @CAPNG_LIBS@ -ldl diff --git a/include/dbus.h b/include/dbus.h index 5bf0505..948bec5 100644 --- a/include/dbus.h +++ b/include/dbus.h @@ -47,6 +47,8 @@ extern "C" { #define OFONO_SMS_MANAGER_INTERFACE "org.ofono.SmsManager" #define OFONO_VOICECALL_INTERFACE "org.ofono.VoiceCall" #define OFONO_VOICECALL_MANAGER_INTERFACE "org.ofono.VoiceCallManager" +#define OFONO_EMULATOR_INTERFACE "org.ofono.Emulator" +#define OFONO_EMULATOR_MANAGER_INTERFACE "org.ofono.EmulatorManager" /* Essentially a{sv} */ #define OFONO_PROPERTIES_ARRAY_SIGNATURE DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING \ diff --git a/include/emulator.h b/include/emulator.h new file mode 100644 index 0000000..c3bdaa9 --- /dev/null +++ b/include/emulator.h @@ -0,0 +1,41 @@ +/* + * + * oFono - Open Source Telephony + * + * Copyright (C) 2008-2010 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the 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 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 + * + */ + +#ifndef __OFONO_EMULATOR_H +#define __OFONO_EMULATOR_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include <ofono/types.h> + +struct ofono_emulator; + +void ofono_emulator_register(struct ofono_emulator *emulator); +struct ofono_emulator *ofono_emulator_create(struct ofono_modem *modem); +void ofono_emulator_remove(struct ofono_emulator *emulator); + +#ifdef __cplusplus +} +#endif + +#endif /* __OFONO_EMULATOR_H */ diff --git a/src/emulator.c b/src/emulator.c new file mode 100644 index 0000000..ef8fe70 --- /dev/null +++ b/src/emulator.c @@ -0,0 +1,355 @@ +/* + * + * oFono - Open Source Telephony + * + * Copyright (C) 2008-2010 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the 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 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 + * + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <string.h> +#include <stdio.h> +#include <time.h> +#include <errno.h> +#include <glib.h> +#include <gdbus.h> + +#include "ofono.h" +#include "common.h" + +#include "gatserver.h" + +#define MAX_EMULATOR_NUMS 3 + +struct ofono_emulator { + unsigned int emulator_ids; + GSList *emulator_list; + struct ofono_atom *atom; +}; + +struct emulator { + struct ofono_emulator *oe; + unsigned int id; + enum ofono_emulator_type type; + GAtServer *server; + unsigned int timeout_source; +}; + +static void emulator_dbus_unregister(void *data, void *user_data); + +static unsigned int emulator_next_id(struct ofono_emulator *oe) +{ + unsigned int i; + + for (i = 1; i < sizeof(oe->emulator_ids) * 8; i++) { + if (oe->emulator_ids & (0x1 << i)) + continue; + + oe->emulator_ids |= (0x1 << i); + + return i; + } + + return 0; +} + +static void emulator_release_id(struct ofono_emulator *oe, int id) +{ + oe->emulator_ids &= ~(0x1 << id); +} + +static enum ofono_emulator_type emulator_str_to_type(const char *type) +{ + if (!strcmp(type, "DUN")) + return OFONO_EMULATOR_TYPE_DUN; + else if (!strcmp(type, "HFP AG")) + return OFONO_EMULATOR_TYPE_HFPAG; + else if (!strcmp(type, "SPP")) + return OFONO_EMULATOR_TYPE_SPP; + + return OFONO_EMULATOR_TYPE_NONE; +} + +static const char *emulator_build_path(const struct ofono_emulator *oe, + const struct emulator *e) +{ + static char path[256]; + + snprintf(path, sizeof(path), "%s/emulator%02d", + __ofono_atom_get_path(oe->atom), e->id); + + return path; +} + +static void emulator_remove(void *data) +{ + struct emulator *e = data; + struct ofono_emulator *oe = e->oe; + GAtServer *server = e->server; + + oe->emulator_list = g_slist_remove(oe->emulator_list, e); + emulator_release_id(oe, e->id); + + g_at_server_shutdown(server); + g_at_server_unref(server); + server = NULL; + + g_free(e); + e = NULL; +} + +static struct emulator *emulator_create(struct ofono_emulator *oe, + enum ofono_emulator_type type, + int fd) +{ + struct emulator *e; + GAtServer *server; + GIOChannel *channel; + + if (fd <= 0) + return NULL; + + channel = g_io_channel_unix_new(fd); + + server = g_at_server_new(channel); + if (!server) + goto error; + + e = g_try_new0(struct emulator, 1); + if (!e) + goto error; + + e->oe = oe; + e->id = emulator_next_id(oe); + e->type = type; + e->server = server; + + oe->emulator_list = g_slist_prepend(oe->emulator_list, e); + + g_io_channel_unref(channel); + + return e; + +error: + if (channel) { + g_io_channel_shutdown(channel, FALSE, NULL); + g_io_channel_unref(channel); + } + + if (server) { + g_at_server_shutdown(server); + g_at_server_unref(server); + } + + g_free(e); + + return NULL; +} + +static gboolean real_destroy(void *data) +{ + struct emulator *e = data; + + e->timeout_source = 0; + + emulator_dbus_unregister(e, NULL); + + return FALSE; +} + +static DBusMessage *emulator_destroy(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + struct emulator *e = data; + DBusMessage *reply; + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + e->timeout_source = g_timeout_add_seconds(1, real_destroy, e); + + return reply; +} + +static GDBusMethodTable emulator_methods[] = { + { "Destroy", "", "", emulator_destroy }, + { } +}; + +static GDBusSignalTable emulator_signals[] = { + { "PropertyChanged", "sv" }, +}; + +static void emulator_dbus_unregister(void *data, void *user_data) +{ + DBusConnection *conn = ofono_dbus_get_connection(); + struct emulator *e = data; + struct ofono_emulator *oe = e->oe; + const char *path; + + if (e->timeout_source) + g_source_remove(e->timeout_source); + + path = emulator_build_path(oe, e); + + g_dbus_unregister_interface(conn, path, OFONO_EMULATOR_INTERFACE); + + return; +} + +static gboolean emulator_dbus_register(struct ofono_emulator *oe, + struct emulator *e) +{ + DBusConnection *conn = ofono_dbus_get_connection(); + const char *path = emulator_build_path(oe, e); + + if (!g_dbus_register_interface(conn, path, + OFONO_EMULATOR_INTERFACE, + emulator_methods, emulator_signals, + NULL, e, emulator_remove)) { + ofono_error("Could not create emulator %s", path); + emulator_remove(e); + + return FALSE; + } + + return TRUE; +} + +static DBusMessage *manager_create(DBusConnection *conn, DBusMessage *msg, + void *data) +{ + DBusMessage *reply; + struct ofono_emulator *oe = data; + struct emulator *e; + enum ofono_emulator_type type; + const char *type_str, *path; + int fd; + + if (!oe) + return FALSE; + + if (g_slist_length(oe->emulator_list) >= MAX_EMULATOR_NUMS) + return __ofono_error_failed(msg); + + if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &type_str, + DBUS_TYPE_UNIX_FD, &fd, + DBUS_TYPE_INVALID) == FALSE) + return __ofono_error_invalid_args(msg); + + type = emulator_str_to_type(type_str); + if (type == OFONO_EMULATOR_TYPE_NONE) + return __ofono_error_invalid_args(msg); + + e = emulator_create(oe, type, fd); + if (!e) + return __ofono_error_failed(msg); + + if (!emulator_dbus_register(oe, e)) + return __ofono_error_failed(msg); + + reply = dbus_message_new_method_return(msg); + path = emulator_build_path(oe, e); + dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_INVALID); + + emit_emulator_list_changed(oe); + + return reply; +} + +static GDBusMethodTable emulator_manager_methods[] = { + { "Create", "sh", "", manager_create }, + { } +}; + +static GDBusSignalTable emulator_manager_signals[] = { + { "PropertyChanged", "sv" }, +}; + +static void emulator_remove_all(struct ofono_atom *atom) +{ + struct ofono_emulator *oe = __ofono_atom_get_data(atom); + + DBG("atom: %p", atom); + + if (oe == NULL) + return; + + if (oe->emulator_list) { + g_slist_foreach(oe->emulator_list, emulator_dbus_unregister, + NULL); + g_slist_free(oe->emulator_list); + } + + g_free(oe); +} + +static void ofono_emulator_unregister(struct ofono_atom *atom) +{ + DBusConnection *conn = ofono_dbus_get_connection(); + struct ofono_modem *modem = __ofono_atom_get_modem(atom); + const char *path = __ofono_atom_get_path(atom); + + ofono_modem_remove_interface(modem, OFONO_EMULATOR_MANAGER_INTERFACE); + + g_dbus_unregister_interface(conn, path, + OFONO_EMULATOR_MANAGER_INTERFACE); +} + +void ofono_emulator_register(struct ofono_emulator *oe) +{ + DBusConnection *conn = ofono_dbus_get_connection(); + struct ofono_modem *modem = __ofono_atom_get_modem(oe->atom); + const char *path = __ofono_atom_get_path(oe->atom); + + if (!g_dbus_register_interface(conn, path, + OFONO_EMULATOR_MANAGER_INTERFACE, + emulator_manager_methods, + emulator_manager_signals, + NULL, oe, NULL)) { + ofono_error("Could not create %s interface", + OFONO_EMULATOR_MANAGER_INTERFACE); + return; + } + + ofono_modem_add_interface(modem, OFONO_EMULATOR_MANAGER_INTERFACE); + + __ofono_atom_register(oe->atom, ofono_emulator_unregister); +} + +struct ofono_emulator *ofono_emulator_create(struct ofono_modem *modem) +{ + struct ofono_emulator *oe; + + oe = g_try_new0(struct ofono_emulator, 1); + if (oe == NULL) + return NULL; + + oe->atom = __ofono_modem_add_atom(modem, OFONO_ATOM_TYPE_EMULATOR, + emulator_remove_all, oe); + + return oe; +} + +void ofono_emulator_remove(struct ofono_emulator *oe) +{ + __ofono_atom_free(oe->atom); +} diff --git a/src/ofono.h b/src/ofono.h index f93760e..4995830 100644 --- a/src/ofono.h +++ b/src/ofono.h @@ -116,6 +116,7 @@ enum ofono_atom_type { OFONO_ATOM_TYPE_GPRS_CONTEXT = 17, OFONO_ATOM_TYPE_RADIO_SETTINGS = 18, OFONO_ATOM_TYPE_STK = 19, + OFONO_ATOM_TYPE_EMULATOR = 20, }; enum ofono_atom_watch_condition { @@ -265,3 +266,12 @@ struct sms; void __ofono_message_waiting_mwi(struct ofono_message_waiting *mw, struct sms *sms, gboolean *out_discard); + +#include <ofono/emulator.h> + +enum ofono_emulator_type { + OFONO_EMULATOR_TYPE_NONE = 0, + OFONO_EMULATOR_TYPE_DUN, + OFONO_EMULATOR_TYPE_HFPAG, + OFONO_EMULATOR_TYPE_SPP, +}; -- 1.6.3.3

To list the object path of all available emulators. --- src/emulator.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 52 insertions(+), 0 deletions(-) diff --git a/src/emulator.c b/src/emulator.c index f9f7108..e6ffb78 100644 --- a/src/emulator.c +++ b/src/emulator.c @@ -257,6 +257,25 @@ static gboolean emulator_dbus_register(struct ofono_emulator *oe, return TRUE; } +static int emulators_path_list(struct ofono_emulator *oe, char ***objlist) +{ + GSList *emulator_list = oe->emulator_list; + GSList *l; + struct emulator *e; + int i; + + *objlist = g_new0(char *, g_slist_length(emulator_list) + 1); + if (*objlist == NULL) + return -1; + + for (i = 0, l = emulator_list; l; l = l->next, i++) { + e = l->data; + (*objlist)[i] = g_strdup(emulator_build_path(oe, e)); + } + + return 0; +} + static DBusMessage *manager_create(DBusConnection *conn, DBusMessage *msg, void *data) { @@ -299,7 +318,40 @@ static DBusMessage *manager_create(DBusConnection *conn, DBusMessage *msg, return reply; } + +static DBusMessage *manager_get_properties(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + struct ofono_emulator *oe = data; + DBusMessage *reply; + DBusMessageIter iter; + DBusMessageIter dict; + char **objpath_list; + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + dbus_message_iter_init_append(reply, &iter); + + dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + OFONO_PROPERTIES_ARRAY_SIGNATURE, + &dict); + + emulators_path_list(oe, &objpath_list); + + ofono_dbus_dict_append_array(&dict, "Emulators", DBUS_TYPE_OBJECT_PATH, + &objpath_list); + + g_strfreev(objpath_list); + + dbus_message_iter_close_container(&iter, &dict); + + return reply; +} + static GDBusMethodTable emulator_manager_methods[] = { + { "GetProperties", "", "a{sv}", manager_get_properties }, { "Create", "sh", "", manager_create }, { } }; -- 1.6.3.3

--- src/emulator.c | 33 +++++++++++++++++++++++++++++++++ 1 files changed, 33 insertions(+), 0 deletions(-) diff --git a/src/emulator.c b/src/emulator.c index bed0f46..f1cb9ef 100644 --- a/src/emulator.c +++ b/src/emulator.c @@ -212,7 +212,40 @@ static DBusMessage *emulator_destroy(DBusConnection *conn, return reply; } +static DBusMessage *emulator_get_properties(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + struct emulator *e = data; + DBusMessage *reply; + DBusMessageIter iter; + DBusMessageIter dict; + const char *type, *path; + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + dbus_message_iter_init_append(reply, &iter); + + dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + OFONO_PROPERTIES_ARRAY_SIGNATURE, + &dict); + + type = emulator_type_to_str(e->type); + + ofono_dbus_dict_append(&dict, "TYPE", DBUS_TYPE_STRING, &type); + + path = emulator_build_path(e->oe, e); + + ofono_dbus_dict_append(&dict, "PATH", DBUS_TYPE_STRING, &path); + + dbus_message_iter_close_container(&iter, &dict); + + return reply; +} + static GDBusMethodTable emulator_methods[] = { + { "GetProperties", "", "a{sv}", emulator_get_properties }, { "Destroy", "", "", emulator_destroy }, { } }; -- 1.6.3.3

--- plugins/phonesim.c | 6 ++++++ 1 files changed, 6 insertions(+), 0 deletions(-) diff --git a/plugins/phonesim.c b/plugins/phonesim.c index d0cd7f3..49d3af3 100644 --- a/plugins/phonesim.c +++ b/plugins/phonesim.c @@ -57,6 +57,7 @@ #include <ofono/voicecall.h> #include <ofono/gprs.h> #include <ofono/gprs-context.h> +#include <ofono/emulator.h> #include <drivers/atmodem/vendor.h> #include <drivers/atmodem/sim-poll.h> @@ -278,6 +279,7 @@ static void phonesim_pre_sim(struct ofono_modem *modem) { struct phonesim_data *data = ofono_modem_get_data(modem); struct ofono_sim *sim; + struct ofono_emulator *emulator; DBG("%p", modem); @@ -293,6 +295,10 @@ static void phonesim_pre_sim(struct ofono_modem *modem) if (sim) ofono_sim_inserted_notify(sim, TRUE); + + emulator = ofono_emulator_create(modem); + if (emulator) + ofono_emulator_register(emulator); } static void phonesim_post_sim(struct ofono_modem *modem) -- 1.6.3.3

It's used to either dial voicecall or GPRS dial up. --- src/emulator.c | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/ofono.h | 8 ++++++ 2 files changed, 86 insertions(+), 0 deletions(-) diff --git a/src/emulator.c b/src/emulator.c index e66e9ca..1063b0c 100644 --- a/src/emulator.c +++ b/src/emulator.c @@ -115,6 +115,80 @@ static const char *emulator_build_path(const struct ofono_emulator *oe, return path; } +static void dial_common_cb(GAtServerResult res, void *user_data) +{ + struct emulator *e = user_data; + GAtServer *server = e->server; + + g_at_server_send_final(server, res); + + e->status = OFONO_EMULATOR_STATUS_IDLE; + + notify_status_watches(e, NULL); +} + +static gboolean dial_call(struct emulator *e, const char *dial_str) +{ + struct ofono_emulator_dial_req *req = NULL; + + DBG("dial call %s", dial_str); + + req = g_try_new0(struct ofono_emulator_dial_req, 1); + if (!req) + return FALSE; + + req->dial_str = dial_str; + req->cb = dial_common_cb; + req->data = e; + + if (dial_str[0] == '*' || dial_str[0] == '#') { + /* Supplementary service request */ + g_at_server_send_intermediate(e->server, "CONNECT"); + + e->status = OFONO_EMULATOR_STATUS_GPRS_CONNECT; + + notify_status_watches(e, req); + } else { + e->status = OFONO_EMULATOR_STATUS_DIAL_VOICECALL; + + notify_status_watches(e, req); + } + + g_free(req); + + return TRUE; +} + +static void dial_cb(GAtServerRequestType type, GAtResult *result, + gpointer user_data) +{ + struct emulator *e = user_data; + GAtServer *server = e->server; + GAtServerResult res = G_AT_SERVER_RESULT_ERROR; + GAtResultIter iter; + const char *dial_str; + + if (type != G_AT_SERVER_REQUEST_TYPE_SET) + goto error; + + g_at_result_iter_init(&iter, result); + + if (!g_at_result_iter_next(&iter, "D")) + goto error; + + dial_str = g_at_result_iter_raw_line(&iter); + if (!dial_str) + goto error; + + if (!dial_call(e, dial_str)) + goto error; + + return; + +error: + g_at_server_send_final(server, res); +} + static void emulator_remove(void *data) { struct emulator *e = data; @@ -128,6 +202,8 @@ static void emulator_remove(void *data) oe->emulator_list = g_slist_remove(oe->emulator_list, e); emulator_release_id(oe, e->id); + g_at_server_unregister(server, "D"); + g_at_server_shutdown(server); g_at_server_unref(server); server = NULL; @@ -163,6 +239,8 @@ static struct emulator *emulator_create(struct ofono_emulator *oe, e->server = server; e->status = OFONO_EMULATOR_STATUS_CREATE; + g_at_server_register(e->server, "D", dial_cb, e, NULL); + oe->emulator_list = g_slist_prepend(oe->emulator_list, e); notify_status_watches(e, NULL); diff --git a/src/ofono.h b/src/ofono.h index 047260c..e1d272e 100644 --- a/src/ofono.h +++ b/src/ofono.h @@ -287,6 +287,14 @@ enum ofono_emulator_type { OFONO_EMULATOR_TYPE_SPP, }; +typedef void (*ofono_emulator_cb_t)(enum _GAtServerResult res, void *data); + +struct ofono_emulator_dial_req { + const char *dial_str; + ofono_emulator_cb_t cb; + void *data; +}; + typedef void (*ofono_emulator_status_notify_cb_t)(struct emulator *e, enum ofono_emulator_status status, void *data, void *user_data); -- 1.6.3.3

--- Makefile.am | 6 +- gatchat/test-emulator.c | 616 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 621 insertions(+), 1 deletions(-) create mode 100644 gatchat/test-emulator.c diff --git a/Makefile.am b/Makefile.am index 707c622..12cdd3e 100644 --- a/Makefile.am +++ b/Makefile.am @@ -383,7 +383,8 @@ unit_test_caif_SOURCES = unit/test-caif.c $(gatchat_sources) \ unit_test_caif_LDADD = @GLIB_LIBS@ unit_objects += $(unit_test_caif_OBJECTS) -noinst_PROGRAMS += gatchat/gsmdial gatchat/test-server gatchat/test-qcdm +noinst_PROGRAMS += gatchat/gsmdial gatchat/test-server gatchat/test-qcdm \ + gatchat/test-emulator gatchat_gsmdial_SOURCES = gatchat/gsmdial.c $(gatchat_sources) gatchat_gsmdial_LDADD = @GLIB_LIBS@ @@ -394,6 +395,9 @@ gatchat_test_server_LDADD = @GLIB_LIBS@ -lutil gatchat_test_qcdm_SOURCES = gatchat/test-qcdm.c $(gatchat_sources) gatchat_test_qcdm_LDADD = @GLIB_LIBS@ +gatchat_test_emulator_SOURCES = gatchat/test-emulator.c $(gatchat_sources) \ + $(gdbus_sources) +gatchat_test_emulator_LDADD = @GLIB_LIBS@ -lutil -ldbus-1 DISTCHECK_CONFIGURE_FLAGS = --disable-datafiles diff --git a/gatchat/test-emulator.c b/gatchat/test-emulator.c new file mode 100644 index 0000000..96a248e --- /dev/null +++ b/gatchat/test-emulator.c @@ -0,0 +1,616 @@ +/* + * + * oFono - Open Source Telephony + * + * Copyright (C) 2008-2010 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the 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 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 + * + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <unistd.h> +#include <stdio.h> +#include <getopt.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <signal.h> +#include <sys/signalfd.h> + +#include <gdbus.h> +#include <glib.h> +#include <utmp.h> +#include <pty.h> + +#include <sys/types.h> +#include <sys/stat.h> + +#include "gatserver.h" + +#define OFONO_SERVICE "org.ofono" +#define OFONO_MANAGER_INTERFACE "org.ofono.Manager" +#define OFONO_EMULATOR_MANAGER_INTERFACE "org.ofono.EmulatorManager" + +#define DEFAULT_TCP_PORT 12346 +#define DEFAULT_SOCK_PATH "./server_sock" + +struct sock_server{ + int server_sock; +}; + +static GMainLoop *mainloop; +static DBusConnection *connection; +static char *modem_path; +static unsigned int server_watch; +static unsigned int emulator_manager_watch; +const char *emulator = "DUN"; + +typedef void (*DBusNotifyFunction) (DBusMessage *message, void *user_data); + +static gboolean send_method_call_with_block(const char *dest, const char *path, + const char *interface, const char *method, + DBusNotifyFunction cb, + void *user_data, int type, ...) +{ + DBusMessage *msg, *reply; + DBusError err; + va_list args; + + msg = dbus_message_new_method_call(dest, path, interface, method); + if (!msg) { + g_print("Unable to allocate new D-Bus %s message\n", method); + return FALSE; + } + + va_start(args, type); + + if (!dbus_message_append_args_valist(msg, type, args)) { + dbus_message_unref(msg); + va_end(args); + return FALSE; + } + + va_end(args); + + dbus_error_init(&err); + reply = dbus_connection_send_with_reply_and_block(connection, msg, 100, + &err); + if (!reply) { + dbus_message_unref(msg); + g_print("ofono replied with an error: %s, %s\n", + err.name, err.message); + dbus_error_free(&err); + return FALSE; + } + + cb(reply, user_data); + + dbus_message_unref(msg); + + return TRUE; +} + +static gboolean server_cleanup() +{ + if (server_watch) + g_source_remove(server_watch); + + g_free(modem_path); + + g_dbus_remove_watch(connection, emulator_manager_watch); + + dbus_connection_unref(connection); + + unlink(DEFAULT_SOCK_PATH); + + g_main_loop_quit(mainloop); + + return FALSE; +} + +static void server_destroy(gpointer user) +{ + struct sock_server *data = user; + + g_free(data); +} + +static void create_emulator_cb(DBusMessage *reply, gpointer user_data) +{ + DBusError derr; + + dbus_error_init(&derr); + + if (dbus_set_error_from_message(&derr, reply)) { + g_print("Create reply: %s\n", derr.message); + dbus_error_free(&derr); + } + + dbus_message_unref(reply); +} + +static void create_emulator(int fd) +{ + if (!connection || !modem_path || !emulator) + return; + + g_print("Create %s emulator on %s fd %d\n", emulator, + modem_path, fd); + + send_method_call_with_block(OFONO_SERVICE, modem_path, + OFONO_EMULATOR_MANAGER_INTERFACE, + "Create", create_emulator_cb, + NULL, DBUS_TYPE_STRING, &emulator, + DBUS_TYPE_UNIX_FD, &fd, + DBUS_TYPE_INVALID); +} + +static void set_raw_mode(int fd) +{ + struct termios options; + + tcgetattr(fd, &options); + + /* Set TTY as raw mode to disable echo back of input characters + * when they are received from Modem to avoid feedback loop */ + options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); + + tcsetattr(fd, TCSANOW, &options); +} + +static gboolean create_tty(const char *modem_path) +{ + int master, slave; + char pty_name[256]; + + if (!modem_path) + return FALSE; + + if (openpty(&master, &slave, pty_name, NULL, NULL) < 0) + return FALSE; + + set_raw_mode(slave); + + g_print("new pty is created at %s\n", pty_name); + + create_emulator(master); + + close(master); + + return TRUE; +} + +static gboolean on_socket_connected(GIOChannel *chan, GIOCondition cond, + gpointer user) +{ + struct sockaddr saddr; + unsigned int len = sizeof(saddr); + int fd; + struct sock_server *data = user; + + if (cond != G_IO_IN) + goto error; + + fd = accept(data->server_sock, &saddr, &len); + if (fd == -1) + goto error; + + create_emulator(fd); + + close(fd); + + return TRUE; + +error: + g_free(data); + + return FALSE; +} + +static struct sock_server *socket_common(int sk, struct sockaddr *addr, + const char *modem_path) +{ + struct sock_server *sock; + int reuseaddr = 1; + + setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr)); + + if (bind(sk, addr, sizeof(struct sockaddr)) < 0) { + g_print("Can't bind socket: %s (%d)", strerror(errno), errno); + + close(sk); + + return NULL; + } + + if (listen(sk, 1) < 0) { + g_print("Can't listen on socket: %s (%d)", + strerror(errno), errno); + + close(sk); + + return NULL; + } + + sock = g_try_new0(struct sock_server, 1); + if (!sock) + return FALSE; + + sock->server_sock = sk; + + return sock; +} + +static gboolean create_tcp(const char *modem_path, int port) +{ + struct sockaddr_in addr; + int sk; + struct sock_server *server; + GIOChannel *server_io; + + if (!modem_path) + return FALSE; + + sk = socket(PF_INET, SOCK_STREAM, 0); + if (sk < 0) { + g_print("Can't create tcp/ip socket: %s (%d)\n", + strerror(errno), errno); + return FALSE; + } + + memset(&addr, 0, sizeof(addr)); + + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = INADDR_ANY; + addr.sin_port = htons(port); + + server = socket_common(sk, (struct sockaddr *) &addr, modem_path); + if (!server) + return FALSE; + + g_print("new tcp is created at tcp port %d\n", port); + + server_io = g_io_channel_unix_new(sk); + + g_io_channel_set_close_on_unref(server_io, TRUE); + + server_watch = g_io_add_watch_full(server_io, + G_PRIORITY_DEFAULT, + G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + on_socket_connected, server, server_destroy); + + g_io_channel_unref(server_io); + + return TRUE; +} + +static gboolean create_unix(const char *modem_path, const char *sock_path) +{ + struct sockaddr_un addr; + int sk; + struct sock_server *server; + GIOChannel *server_io; + + if (!modem_path) + return FALSE; + + sk = socket(AF_UNIX, SOCK_STREAM, 0); + if (sk < 0) { + g_print("Can't create unix socket: %s (%d)\n", + strerror(errno), errno); + + return FALSE; + } + + memset(&addr, 0, sizeof(addr)); + + addr.sun_family = AF_UNIX; + strncpy(addr.sun_path, sock_path, sizeof(addr.sun_path) - 1); + + /* Unlink any existing socket for this session */ + unlink(addr.sun_path); + + server = socket_common(sk, (struct sockaddr *) &addr, modem_path); + if (!server) + return FALSE; + + g_print("new unix socket is created at %s\n", sock_path); + + server_io = g_io_channel_unix_new(sk); + + g_io_channel_set_close_on_unref(server_io, TRUE); + + server_watch = g_io_add_watch_full(server_io, + G_PRIORITY_DEFAULT, + G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + on_socket_connected, server, server_destroy); + + g_io_channel_unref(server_io); + + return TRUE; +} + +static gboolean test_emulator(int type) +{ + if (!connection || !modem_path || !emulator) + return FALSE; + + switch (type) { + case 0: + if (create_tty("/phonesim1") == FALSE) + return FALSE; + break; + case 1: + if (create_tcp("/phonesim1", DEFAULT_TCP_PORT) == FALSE) + return FALSE; + break; + case 2: + if (create_unix("/phonesim1", DEFAULT_SOCK_PATH) == FALSE) + return FALSE; + break; + } + + return TRUE; +} + +static gboolean signal_cb(GIOChannel *channel, GIOCondition cond, gpointer data) +{ + int signal_fd = GPOINTER_TO_INT(data); + struct signalfd_siginfo si; + ssize_t res; + + if (cond & (G_IO_NVAL | G_IO_ERR)) + return FALSE; + + res = read(signal_fd, &si, sizeof(si)); + if (res != sizeof(si)) + return FALSE; + + switch (si.ssi_signo) { + case SIGINT: + server_cleanup(); + break; + case SIGTERM: + server_cleanup(); + break; + default: + break; + } + + return TRUE; +} + +static int create_signal_io() +{ + sigset_t mask; + GIOChannel *signal_io; + int signal_fd, signal_source; + + sigemptyset(&mask); + sigaddset(&mask, SIGTERM); + sigaddset(&mask, SIGINT); + + if (sigprocmask(SIG_BLOCK, &mask, NULL) < 0) { + g_error("Can't set signal mask"); + return 1; + } + + signal_fd = signalfd(-1, &mask, 0); + if (signal_fd < 0) { + g_error("Can't create signal filedescriptor"); + return 1; + } + + signal_io = g_io_channel_unix_new(signal_fd); + + g_io_channel_set_close_on_unref(signal_io, TRUE); + + signal_source = g_io_add_watch(signal_io, + G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + signal_cb, GINT_TO_POINTER(signal_fd)); + + g_io_channel_unref(signal_io); + + return signal_source; +} + +static void usage(void) +{ + g_print("test-emulator - Emulator manager testing\n" + "Usage:\n"); + g_print("\ttest-emulator [-t type] [-e emulator] \n"); + g_print("Types:\n" + "\t0: Pseudo TTY port (default)\n" + "\t1: TCP sock at port 12346)\n" + "\t2: Unix sock at ./server_sock\n\n" + "Emulators:\n" + "\tDUN: Dial-up Network (default)\n" + "\tHFP AG: Hands-free Profile\n" + "\tSPP: Serial Port Profile\n"); +} + +static void get_properties_cb(DBusMessage *reply, gpointer user_data) +{ + DBusError err; + DBusMessageIter iter, iter_entry, iter_property, iter_arrary, sub; + char *property, *modem_obj_path_local; + + dbus_error_init(&err); + if (dbus_set_error_from_message(&err, reply)) { + g_print("ofono replied with an error: %s, %s\n", + err.name, err.message); + dbus_error_free(&err); + goto done; + } + + dbus_message_iter_init(reply, &iter); + + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) { + g_print("Unexpected signature in ListModems return\n"); + goto done; + } + + dbus_message_iter_recurse(&iter, &iter_entry); + + if (dbus_message_iter_get_arg_type(&iter_entry) + != DBUS_TYPE_DICT_ENTRY) { + g_print("Unexpected signature in ListModems return 2, %c\n", + dbus_message_iter_get_arg_type(&iter_entry)); + goto done; + } + + dbus_message_iter_recurse(&iter_entry, &iter_property); + + dbus_message_iter_get_basic(&iter_property, &property); + + dbus_message_iter_next(&iter_property); + dbus_message_iter_recurse(&iter_property, &iter_arrary); + dbus_message_iter_recurse(&iter_arrary, &sub); + while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { + + dbus_message_iter_get_basic(&sub, &modem_obj_path_local); + modem_path = g_strdup(modem_obj_path_local); + if (modem_path) + break; + dbus_message_iter_next(&sub); + } + +done: + dbus_message_unref(reply); +} + +static gboolean emulator_manager_property_changed(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + DBusMessageIter iter, sub, array; + const char *property, *emu_obj_path; + GSList *emu_list = NULL; + + dbus_message_iter_init(msg, &iter); + + if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) { + g_print("Unexpected signature in emulator manager" + " PropertyChanged signal"); + return TRUE; + } + + dbus_message_iter_get_basic(&iter, &property); + + dbus_message_iter_next(&iter); + dbus_message_iter_recurse(&iter, &sub); + if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_ARRAY) { + g_print("Unexpected signature in emulator manager" + " PropertyChanged signal"); + return TRUE; + } + dbus_message_iter_recurse(&sub, &array); + while (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_INVALID) { + dbus_message_iter_get_basic(&array, &emu_obj_path); + if (emu_obj_path) { + g_print("Emulator path %s\n", emu_obj_path); + emu_list = g_slist_prepend(emu_list, + g_strdup(emu_obj_path)); + } + dbus_message_iter_next(&array); + } + + if (g_slist_length(emu_list) == 0) { + g_print("All emulators destroyed. Quit.\n"); + g_slist_free(emu_list); + server_cleanup(); + + return TRUE; + } + + g_slist_foreach(emu_list, (GFunc) g_free, NULL); + g_slist_free(emu_list); + + return TRUE; +} + +int main(int argc, char **argv) +{ + int opt, signal_source; + int type = 0; + DBusError error; + + dbus_error_init(&error); + + connection = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &error); + if (!connection) { + if (dbus_error_is_set(&error) == TRUE) { + g_print("Unable to hop onto D-Bus: %s\n", + error.message); + dbus_error_free(&error); + } else { + g_print("Unable to hop onto D-Bus\n"); + } + + return -1; + } + + while ((opt = getopt(argc, argv, "ht:e:")) != EOF) { + switch (opt) { + case 't': + type = atoi(optarg); + break; + case 'e': + emulator = optarg; + break; + case 'h': + usage(); + exit(1); + break; + default: + break; + } + } + + emulator_manager_watch = g_dbus_add_signal_watch(connection, NULL, NULL, + OFONO_EMULATOR_MANAGER_INTERFACE, + "PropertyChanged", + emulator_manager_property_changed, + NULL, NULL); + if (!emulator_manager_watch) + exit(1); + + send_method_call_with_block(OFONO_SERVICE, "/", OFONO_MANAGER_INTERFACE, + "GetProperties", get_properties_cb, + NULL, DBUS_TYPE_INVALID); + + if (!test_emulator(type)) { + g_free(modem_path); + exit(1); + } + + signal_source = create_signal_io(); + + mainloop = g_main_loop_new(NULL, FALSE); + + g_main_loop_run(mainloop); + + g_main_loop_unref(mainloop); + + g_source_remove(signal_source); + + return 0; +} -- 1.6.3.3

To remove all emulators in current modem --- test/destroy-emulator | 19 +++++++++++++++++++ 1 files changed, 19 insertions(+), 0 deletions(-) create mode 100755 test/destroy-emulator diff --git a/test/destroy-emulator b/test/destroy-emulator new file mode 100755 index 0000000..3b8ecfb --- /dev/null +++ b/test/destroy-emulator @@ -0,0 +1,19 @@ +#!/usr/bin/python + +import dbus +import sys + +bus = dbus.SystemBus() + +if len(sys.argv) == 2: + path = sys.argv[1] +else: + manager = dbus.Interface(bus.get_object('org.ofono', '/'), + 'org.ofono.Manager') + properties = manager.GetProperties() + path = properties["Modems"][0] + +emulator = dbus.Interface(bus.get_object('org.ofono', path), + 'org.ofono.EmulatorManager') + +emulator.DestroyAll() -- 1.6.3.3

Add doc for emulator interface. --- doc/emulator-api.txt | 32 ++++++++++++++++++++++++++++++++ 1 files changed, 32 insertions(+), 0 deletions(-) create mode 100644 doc/emulator-api.txt diff --git a/doc/emulator-api.txt b/doc/emulator-api.txt new file mode 100644 index 0000000..42af66d --- /dev/null +++ b/doc/emulator-api.txt @@ -0,0 +1,32 @@ +Emulator hierarchy +=================== + +Service org.ofono +Interface org.ofono.Emulator +Object path [variable prefix]/{modem0,modem1,...}/{emulator01,emulator02,...} + +Methods dict GetProperties() + + Returns all properties for this object. See the + properties section for available properties. + + void Destroy() + + Destroy the emulator and unregister from D-Bus + interface. + +Signals PropertyChanged(string property, variant value) + + Signal is emitted whenever a property has changed. + The new value is passed as the signal argument. + +Properties string Type [readonly] + + Contains the type of current emulator. The type can be + one of: + - "DUN" - Dial-Up Network. + - "HFP AG" - Hands-free gateway role. + - "SPP" - Serial Port Profile. + + string PATH [readonly] + Contains the object path of current emulator. -- 1.6.3.3