Use g_slist function to remove items from ofono watchlist. --- src/watch.c | 69 ++++++++++++++++++++++++++++------------------------------ 1 files changed, 33 insertions(+), 36 deletions(-) diff --git a/src/watch.c b/src/watch.c index f93b68c..cd3d908 100644 --- a/src/watch.c +++ b/src/watch.c @@ -46,58 +46,55 @@ unsigned int __ofono_watchlist_add_item(struct ofono_watchlist *watchlist, return item->id; } -gboolean __ofono_watchlist_remove_item(struct ofono_watchlist *watchlist, - unsigned int id) +static gint watchlist_item_compare_by_id(gconstpointer a, gconstpointer b) { - struct ofono_watchlist_item *item; - GSList *p; - GSList *c; - - p = NULL; - c = watchlist->items; + const struct ofono_watchlist_item *item = a; + unsigned int id = GPOINTER_TO_UINT(b); - while (c) { - item = c->data; + if (item->id < id) + return -1; - if (item->id != id) { - p = c; - c = c->next; - continue; - } + if (item->id > id) + return 1; - if (p) - p->next = c->next; - else - watchlist->items = c->next; - - if (item->destroy) - item->destroy(item->notify_data); + return 0; +} - if (watchlist->destroy) - watchlist->destroy(item); - g_slist_free_1(c); +static void watchlist_remove_item(void *data, void *user_data) +{ + struct ofono_watchlist_item *item = data; + struct ofono_watchlist *watchlist = user_data; - return TRUE; - } + if (item->destroy) + item->destroy(item->notify_data); - return FALSE; + if (watchlist->destroy) + watchlist->destroy(item); } -void __ofono_watchlist_free(struct ofono_watchlist *watchlist) +gboolean __ofono_watchlist_remove_item(struct ofono_watchlist *watchlist, + unsigned int id) { struct ofono_watchlist_item *item; GSList *l; - for (l = watchlist->items; l; l = l->next) { - item = l->data; + l = g_slist_find_custom(watchlist->items, GUINT_TO_POINTER(id), + watchlist_item_compare_by_id); + if (l == NULL) + return FALSE; - if (item->destroy) - item->destroy(item->notify_data); + item = l->data; - if (watchlist->destroy) - watchlist->destroy(item); - } + watchlist->items = g_slist_remove(watchlist->items, item); + watchlist_remove_item(item, watchlist); + + return TRUE; +} + +void __ofono_watchlist_free(struct ofono_watchlist *watchlist) +{ + g_slist_foreach(watchlist->items, watchlist_remove_item, watchlist); g_slist_free(watchlist->items); watchlist->items = NULL; g_free(watchlist); -- 1.6.3.3

oFono properties: "Powered": Whether the emulator is powered on. "Type": Type could be one of supported emulator type, default is DUN. --- src/emulator.c | 28 +++++++++++++++++++++++++++- 1 files changed, 27 insertions(+), 1 deletions(-) diff --git a/src/emulator.c b/src/emulator.c index 7551eb6..86a2eee 100644 --- a/src/emulator.c +++ b/src/emulator.c @@ -288,7 +288,33 @@ error: static DBusMessage *emulator_get_properties(DBusConnection *conn, DBusMessage *msg, void *data) { - return dbus_message_new_method_return(msg); + struct ofono_emulator *e = data; + DBusMessage *reply; + DBusMessageIter iter; + DBusMessageIter dict; + const char *type_str; + int type; + + 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); + + ofono_dbus_dict_append(&dict, "Powered", DBUS_TYPE_BOOLEAN, + &e->powered); + + type = e->driver->type; + type_str = ofono_emulator_type_to_str(type); + ofono_dbus_dict_append(&dict, "Type", DBUS_TYPE_STRING, &type_str); + + dbus_message_iter_close_container(&iter, &dict); + + return reply; } static DBusMessage *emulator_enable(DBusConnection *conn, -- 1.6.3.3

Add dun_watch to watch emulator status update in gprs atom. So that gprs atom could get notified when we get request to create new PPP connection from DUN client; --- src/gprs.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 63 insertions(+), 0 deletions(-) diff --git a/src/gprs.c b/src/gprs.c index 829a22c..dd58c51 100644 --- a/src/gprs.c +++ b/src/gprs.c @@ -77,6 +77,10 @@ struct ofono_gprs { char *imsi; DBusMessage *pending; struct ofono_gprs_context *context_driver; + struct ofono_watchlist *status_watches; + struct ofono_emulator *dun; + unsigned int dun_watch; + unsigned int dun_status_watch; const struct ofono_gprs_driver *driver; void *driver_data; struct ofono_atom *atom; @@ -1386,6 +1390,39 @@ void ofono_gprs_context_deactivated(struct ofono_gprs_context *gc, } } +static void dun_status_watch(struct ofono_emulator *e, + enum ofono_emulator_status status, + void *data, void *user_data) +{ + if (e == NULL) + return; + + switch (status) { + default: + break; + } +} + +static void dun_watch(struct ofono_atom *atom, + enum ofono_atom_watch_condition cond, + void *data) +{ + struct ofono_gprs *gprs = data; + struct ofono_emulator *e = __ofono_atom_get_data(atom); + + if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) { + gprs->dun_status_watch = 0; + gprs->dun = NULL; + return; + } + + DBG(""); + + gprs->dun = e; + gprs->dun_status_watch = __ofono_emulator_add_status_watch(e, + dun_status_watch, gprs, NULL); +} + int ofono_gprs_context_driver_register(const struct ofono_gprs_context_driver *d) { DBG("driver: %p, name: %s", d, d->name); @@ -1535,6 +1572,18 @@ static void gprs_unregister(struct ofono_atom *atom) gprs->netreg = NULL; } + if (gprs->dun_watch) { + if (gprs->dun_status_watch) { + __ofono_emulator_remove_status_watch(gprs->dun, + gprs->dun_status_watch); + gprs->dun_status_watch = 0; + } + + __ofono_modem_remove_atom_watch(modem, gprs->dun_watch); + gprs->dun_watch = 0; + gprs->dun = NULL; + } + ofono_modem_remove_interface(modem, OFONO_DATA_CONNECTION_MANAGER_INTERFACE); g_dbus_unregister_interface(conn, path, @@ -1778,6 +1827,7 @@ void ofono_gprs_register(struct ofono_gprs *gprs) const char *path = __ofono_atom_get_path(gprs->atom); struct ofono_atom *netreg_atom; struct ofono_atom *sim_atom; + struct ofono_atom *dun_atom; if (!g_dbus_register_interface(conn, path, OFONO_DATA_CONNECTION_MANAGER_INTERFACE, @@ -1792,6 +1842,8 @@ void ofono_gprs_register(struct ofono_gprs *gprs) ofono_modem_add_interface(modem, OFONO_DATA_CONNECTION_MANAGER_INTERFACE); + gprs->status_watches = __ofono_watchlist_new(g_free); + sim_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_SIM); if (sim_atom) { @@ -1811,6 +1863,17 @@ void ofono_gprs_register(struct ofono_gprs *gprs) netreg_watch(netreg_atom, OFONO_ATOM_WATCH_CONDITION_REGISTERED, gprs); + gprs->dun_watch = __ofono_modem_add_atom_watch(modem, + OFONO_ATOM_TYPE_EMULATOR_DUN, + dun_watch, gprs, NULL); + + dun_atom = __ofono_modem_find_atom(modem, + OFONO_ATOM_TYPE_EMULATOR_DUN); + + if (dun_atom && __ofono_atom_get_registered(dun_atom)) + dun_watch(dun_atom, + OFONO_ATOM_WATCH_CONDITION_REGISTERED, gprs); + __ofono_atom_register(gprs->atom, gprs_unregister); } -- 1.6.3.3

Defines APIs to send final/intermediate/unsolicited result to DUN client. --- include/emulator.h | 2 ++ src/emulator.c | 28 ++++++++++++++++++++++++++++ src/ofono.h | 10 ++++++++++ 3 files changed, 40 insertions(+), 0 deletions(-) diff --git a/include/emulator.h b/include/emulator.h index c76dbc7..8b10f8c 100644 --- a/include/emulator.h +++ b/include/emulator.h @@ -50,6 +50,8 @@ struct ofono_emulator_driver { int (*disable)(struct ofono_emulator *e); }; +enum _GAtServerResult; + const char *ofono_emulator_get_path(struct ofono_emulator *e); struct ofono_emulator *ofono_emulator_find(struct ofono_modem *modem, diff --git a/src/emulator.c b/src/emulator.c index 86a2eee..aa203f1 100644 --- a/src/emulator.c +++ b/src/emulator.c @@ -401,6 +401,34 @@ static gboolean ofono_emulator_dbus_register(struct ofono_modem *modem, return TRUE; } +void ofono_emulator_send_final(struct ofono_emulator *e, GAtServerResult result) +{ + g_at_server_send_final(e->server, result); +} + +void ofono_emulator_send_ext_final(struct ofono_emulator *e, const char *result) +{ + g_at_server_send_ext_final(e->server, result); +} + +void ofono_emulator_send_intermediate(struct ofono_emulator *e, + const char *result) +{ + g_at_server_send_intermediate(e->server, result); +} + +void ofono_emulator_send_unsolicited(struct ofono_emulator *e, + const char *result) +{ + g_at_server_send_unsolicited(e->server, result); +} + +void ofono_emulator_send_info(struct ofono_emulator *e, const char *line, + gboolean last) +{ + g_at_server_send_info(e->server, line, last); +} + unsigned int __ofono_emulator_add_status_watch(struct ofono_emulator *e, ofono_emulator_status_notify_cb_t notify, void *data, ofono_destroy_func destroy) diff --git a/src/ofono.h b/src/ofono.h index dc560df..2a63386 100644 --- a/src/ofono.h +++ b/src/ofono.h @@ -296,3 +296,13 @@ unsigned int __ofono_emulator_add_status_watch(struct ofono_emulator *e, gboolean __ofono_emulator_remove_status_watch(struct ofono_emulator *e, unsigned int id); +void ofono_emulator_send_final(struct ofono_emulator *e, + enum _GAtServerResult result); +void ofono_emulator_send_ext_final(struct ofono_emulator *e, + const char *result); +void ofono_emulator_send_intermediate(struct ofono_emulator *e, + const char *result); +void ofono_emulator_send_unsolicited(struct ofono_emulator *e, + const char *result); +void ofono_emulator_send_info(struct ofono_emulator *e, const char *line, + gboolean last); -- 1.6.3.3

Implement dial up support in GPRS atom. --- src/gprs.c | 439 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 437 insertions(+), 2 deletions(-) diff --git a/src/gprs.c b/src/gprs.c index dd58c51..cb83e23 100644 --- a/src/gprs.c +++ b/src/gprs.c @@ -39,6 +39,7 @@ #include "common.h" #include "storage.h" #include "idmap.h" +#include "gatserver.h" #define GPRS_FLAG_ATTACHING 0x1 #define GPRS_FLAG_RECHECK 0x2 @@ -48,6 +49,10 @@ #define MAX_CONTEXT_NAME_LENGTH 127 #define MAX_CONTEXTS 256 +#define DUN_LOCAL "192.168.1.1" +#define DUN_PEER "192.168.1.2" +#define EMULATOR_GPRS_TIMEOUT 20 + static GSList *g_drivers = NULL; static GSList *g_context_drivers = NULL; @@ -55,6 +60,7 @@ enum gprs_context_type { GPRS_CONTEXT_TYPE_INTERNET = 0, GPRS_CONTEXT_TYPE_MMS, GPRS_CONTEXT_TYPE_WAP, + GPRS_CONTEXT_TYPE_DUN, GPRS_CONTEXT_TYPE_INVALID, }; @@ -81,6 +87,9 @@ struct ofono_gprs { struct ofono_emulator *dun; unsigned int dun_watch; unsigned int dun_status_watch; + int attach_source; + int context_source; + int timeout_source; const struct ofono_gprs_driver *driver; void *driver_data; struct ofono_atom *atom; @@ -115,6 +124,13 @@ struct pri_context { struct ofono_gprs *gprs; }; +struct gprs_dun_data { + struct ofono_gprs *gprs; + ofono_emulator_gprs_connect_cb cb; + void *cb_data; + struct pri_context *context; +}; + static void gprs_netreg_update(struct ofono_gprs *gprs); static const char *gprs_context_type_to_string(int type) @@ -168,6 +184,21 @@ static struct pri_context *gprs_context_by_path(struct ofono_gprs *gprs, return NULL; } +static struct pri_context *gprs_context_by_type(struct ofono_gprs *gprs, + enum gprs_context_type type) +{ + GSList *l; + + for (l = gprs->contexts; l; l = l->next) { + struct pri_context *ctx = l->data; + + if (type == ctx->type) + return ctx; + } + + return NULL; +} + static void context_settings_free(struct context_settings *settings) { g_free(settings->interface); @@ -401,6 +432,53 @@ static DBusMessage *pri_get_properties(DBusConnection *conn, return reply; } +static void dun_activate(const char *interface, const char *local, + const char *peer, + const char **dns, + void *data) +{ + DBusConnection *conn = ofono_dbus_get_connection(); + struct pri_context *ctx = data; + const char *netmask = "255.255.255.255"; + dbus_bool_t value; + + DBG("%p %s", ctx, interface); + + ctx->active = TRUE; + + /* If we don't have the interface, don't bother emitting any settings, + * as nobody can make use of them + */ + if (interface != NULL) + pri_update_context_settings(ctx, interface, TRUE, + local, netmask, peer, dns); + + value = ctx->active; + ofono_dbus_signal_property_changed(conn, ctx->path, + OFONO_DATA_CONTEXT_INTERFACE, + "Active", DBUS_TYPE_BOOLEAN, + &value); +} + +static void dun_deactivate(struct pri_context *ctx) +{ + DBusConnection *conn = ofono_dbus_get_connection(); + dbus_bool_t value; + + gprs_cid_release(ctx->gprs, ctx->context.cid); + ctx->context.cid = 0; + + ctx->active = FALSE; + + pri_reset_context_settings(ctx); + + value = ctx->active; + ofono_dbus_signal_property_changed(conn, ctx->path, + OFONO_DATA_CONTEXT_INTERFACE, + "Active", DBUS_TYPE_BOOLEAN, + &value); +} + static void pri_activate_callback(const struct ofono_error *error, const char *interface, ofono_bool_t static_ip, const char *ip, const char *netmask, @@ -417,7 +495,8 @@ static void pri_activate_callback(const struct ofono_error *error, if (error->type != OFONO_ERROR_TYPE_NO_ERROR) { DBG("Activating context failed with error: %s", telephony_error_to_str(error)); - __ofono_dbus_pending_reply(&gc->pending, + if (gc && gc->pending) + __ofono_dbus_pending_reply(&gc->pending, __ofono_error_failed(gc->pending)); gprs_cid_release(ctx->gprs, ctx->context.cid); @@ -427,7 +506,9 @@ static void pri_activate_callback(const struct ofono_error *error, } ctx->active = TRUE; - __ofono_dbus_pending_reply(&gc->pending, + + if (gc && gc->pending) + __ofono_dbus_pending_reply(&gc->pending, dbus_message_new_method_return(gc->pending)); /* If we don't have the interface, don't bother emitting any settings, @@ -693,6 +774,12 @@ static DBusMessage *pri_set_property(DBusConnection *conn, gc->pending = dbus_message_ref(msg); + if (ctx->type == GPRS_CONTEXT_TYPE_DUN) { + /* Not support yet */ + ofono_error("Active DUN context are not yet supported"); + return __ofono_error_failed(msg); + } + if (value) gc->driver->activate_primary(gc, &ctx->context, pri_activate_callback, ctx); @@ -1095,6 +1182,82 @@ static DBusMessage *gprs_set_property(DBusConnection *conn, return dbus_message_new_method_return(msg); } +static struct pri_context *ofono_gprs_create_context( + struct ofono_gprs *gprs, + const char *name, const char *typestr) +{ + DBusConnection *conn = ofono_dbus_get_connection(); + struct pri_context *context; + const char *path; + enum gprs_context_type type; + char **objpath_list; + unsigned int id; + + if (strlen(name) == 0 || strlen(name) > MAX_CONTEXT_NAME_LENGTH) + return NULL; + + type = gprs_context_string_to_type(typestr); + + if (type == GPRS_CONTEXT_TYPE_INVALID) + return NULL; + + if (gprs->last_context_id) + id = idmap_alloc_next(gprs->pid_map, gprs->last_context_id); + else + id = idmap_alloc(gprs->pid_map); + + if (id > idmap_get_max(gprs->pid_map)) + return NULL; + + context = pri_context_create(gprs, name, type); + context->id = id; + + if (!context) { + ofono_error("Unable to allocate context struct"); + return NULL; + } + + DBG("Registering new context"); + + if (!context_dbus_register(context)) { + ofono_error("Unable to register primary context"); + return NULL; + } + + gprs->last_context_id = id; + + if (gprs->settings) { + g_key_file_set_string(gprs->settings, context->key, + "Name", context->name); + g_key_file_set_string(gprs->settings, context->key, + "AccessPointName", + context->context.apn); + g_key_file_set_string(gprs->settings, context->key, + "Username", context->context.username); + g_key_file_set_string(gprs->settings, context->key, + "Password", context->context.password); + g_key_file_set_string(gprs->settings, context->key, "Type", + gprs_context_type_to_string(context->type)); + storage_sync(gprs->imsi, SETTINGS_STORE, gprs->settings); + } + + gprs->contexts = g_slist_append(gprs->contexts, context); + + objpath_list = gprs_contexts_path_list(gprs->contexts); + + if (objpath_list) { + path = __ofono_atom_get_path(gprs->atom); + ofono_dbus_signal_array_property_changed(conn, path, + OFONO_DATA_CONNECTION_MANAGER_INTERFACE, + "PrimaryContexts", + DBUS_TYPE_OBJECT_PATH, &objpath_list); + + g_strfreev(objpath_list); + } + + return context; +} + static DBusMessage *gprs_create_context(DBusConnection *conn, DBusMessage *msg, void *data) { @@ -1390,14 +1553,284 @@ void ofono_gprs_context_deactivated(struct ofono_gprs_context *gc, } } +static ofono_bool_t set_primary_context_powered(struct pri_context *ctx, + ofono_bool_t value) +{ + struct ofono_gprs_context *gc = ctx->gprs->context_driver; + + if (gc == NULL || gc->driver->activate_primary == NULL || + gc->driver->deactivate_primary == NULL || + ctx->gprs->cid_map == NULL) + return FALSE; + + if (gc->pending) + return FALSE; + + if (ctx->active == value) + return FALSE; + + if (value && !ctx->gprs->attached) + return FALSE; + + if (ctx->gprs->flags & GPRS_FLAG_ATTACHING) + return FALSE; + + if (value) { + ctx->context.cid = gprs_cid_alloc(ctx->gprs); + + if (ctx->context.cid == 0) + return FALSE; + + if (ctx->context.cid != + idmap_get_min(ctx->gprs->cid_map)) { + ofono_error("Multiple active contexts are" + " not yet supported"); + + gprs_cid_release(ctx->gprs, ctx->context.cid); + ctx->context.cid = 0; + + return FALSE; + } + } + + if (value) + gc->driver->activate_primary(gc, &ctx->context, + pri_activate_callback, ctx); + else + gc->driver->deactivate_primary(gc, ctx->context.cid, + pri_deactivate_callback, ctx); + + return TRUE; +} + +static void ofono_emulator_dun_disconnect(struct ofono_gprs *gprs, + struct ofono_emulator_req *req) +{ + struct pri_context *dun; + + dun = gprs_context_by_type(gprs, GPRS_CONTEXT_TYPE_DUN); + if (!dun) { + req->cb(G_AT_SERVER_RESULT_NO_CARRIER, req->cb_data); + return; + } + + dun_deactivate(dun); + + context_dbus_unregister(dun); + gprs->contexts = g_slist_remove(gprs->contexts, dun); + + req->cb(G_AT_SERVER_RESULT_NO_CARRIER, req->cb_data); +} + +static void ofono_emulator_dun_connect(struct ofono_gprs *gprs, + struct ofono_emulator_dun_connect_req *req) +{ + struct pri_context *dun; + const char *dns[3]; + + dun = gprs_context_by_type(gprs, GPRS_CONTEXT_TYPE_DUN); + if (!dun) { + req->cb(G_AT_SERVER_RESULT_ERROR, req->cb_data); + return; + } + + dns[0] = req->dns1; + dns[1] = req->dns2; + dns[2] = 0; + + dun_activate(req->iface, req->local, req->peer, dns, dun); + + req->cb(G_AT_SERVER_RESULT_OK, req->cb_data); +} + +static void ofono_emulator_remove_sources(struct ofono_gprs *gprs) +{ + if (gprs == NULL) + return; + + if (gprs->timeout_source) + g_source_remove(gprs->timeout_source); + + if (gprs->attach_source) + g_source_remove(gprs->attach_source); + + if (gprs->context_source) + g_source_remove(gprs->context_source); +} + +static gboolean emulator_gprs_timeout(gpointer user_data) +{ + struct gprs_dun_data *data = user_data; + struct ofono_gprs *gprs = data->gprs; + struct pri_context *context = data->context; + struct ofono_error error; + + ofono_emulator_remove_sources(gprs); + + if (context->active == TRUE) + goto done; + + error.type = OFONO_ERROR_TYPE_FAILURE; + data->cb(&error, NULL, NULL, NULL, NULL, data->cb_data); + +done: + g_free(data); + + return FALSE; +} + +static gboolean pri_context_update(gpointer user_data) +{ + struct gprs_dun_data *data = user_data; + struct ofono_gprs *gprs = data->gprs; + struct pri_context *context = data->context; + struct context_settings *settings = context->settings; + struct ofono_error error; + + DBG("active %d\n", context->active); + + if (context->active != TRUE) + return TRUE; + + gprs->context_source = 0; + g_source_remove(gprs->timeout_source); + + error.type = OFONO_ERROR_TYPE_NO_ERROR; + + data->cb(&error, settings->interface, DUN_LOCAL, DUN_PEER, + (const char **)settings->dns, + data->cb_data); + + g_free(data); + + return FALSE; +} + +static gboolean gprs_attach_update(gpointer user_data) +{ + struct gprs_dun_data *data = user_data; + struct ofono_gprs *gprs = data->gprs; + struct pri_context *context = data->context; + + DBG("attached %d driver attached %d\n", gprs->attached, + gprs->driver_attached); + + if (gprs->attached != TRUE || gprs->driver_attached != TRUE) + return TRUE; + + gprs->attach_source = 0; + + if (context->active != TRUE) { + set_primary_context_powered(context, TRUE); + + /* wait until the primary context is actived */ + gprs->context_source = g_timeout_add_seconds(1, + pri_context_update, data); + return FALSE; + } + + pri_context_update(data); + + return FALSE; +} + +static ofono_bool_t gprs_dun_connect(struct pri_context *dun, + ofono_emulator_gprs_connect_cb cb, + void *cb_data) +{ + struct ofono_gprs *gprs = dun->gprs; + struct pri_context *context; + struct gprs_dun_data *data = g_try_new0(struct gprs_dun_data, 1); + + if (!data) + return FALSE; + + /* Create context for real modem if not connected yet */ + if (gprs->contexts) + context = gprs_context_by_type(gprs, + GPRS_CONTEXT_TYPE_INTERNET); + else + context = ofono_gprs_create_context(gprs, + "default", "internet"); + + if (!context) + return FALSE; + + data->gprs = gprs; + data->cb = cb; + data->cb_data = cb_data; + data->context = context; + + gprs->timeout_source = g_timeout_add_seconds(EMULATOR_GPRS_TIMEOUT, + emulator_gprs_timeout, data); + + /* check gprs attaching status */ + if (!gprs->powered || !gprs->attached || !gprs->driver_attached) { + gprs->powered = TRUE; + + gprs_netreg_update(gprs); + + /* wait until GPRS is attached */ + gprs->attach_source = g_timeout_add_seconds(1, + gprs_attach_update, data); + return TRUE; + } + + gprs_attach_update(data); + + return TRUE; +} + +static void ofono_emulator_gprs_connect(struct ofono_gprs *gprs, + struct ofono_emulator_gprs_connect_req *req) +{ + const char *dial_str = req->dial_str; + struct pri_context *dun; + struct ofono_error error; + + DBG("dial call %s", dial_str); + + /* Create DUN context if not exists */ + dun = gprs_context_by_type(gprs, GPRS_CONTEXT_TYPE_DUN); + if (!dun) { + dun = ofono_gprs_create_context(gprs, "dun", "dun"); + if (!dun) + goto error; + } + + if (!gprs_dun_connect(dun, req->cb, req->cb_data)) + goto error; + + return; +error: + error.type = OFONO_ERROR_TYPE_FAILURE; + req->cb(&error, NULL, NULL, NULL, NULL, req->cb_data); +} + static void dun_status_watch(struct ofono_emulator *e, enum ofono_emulator_status status, void *data, void *user_data) { + struct ofono_gprs *gprs = user_data; + if (e == NULL) return; switch (status) { + case OFONO_EMULATOR_STATUS_GPRS_CONNECT: + ofono_emulator_gprs_connect(gprs, data); + break; + case OFONO_EMULATOR_STATUS_DUN_CONNECTING: + ofono_emulator_dun_connect(gprs, data); + break; + case OFONO_EMULATOR_STATUS_DUN_CONNECTED: + break; + case OFONO_EMULATOR_STATUS_DUN_DISCONNECTED: + ofono_emulator_dun_disconnect(gprs, data); + break; + case OFONO_EMULATOR_STATUS_DESTROY: + ofono_emulator_remove_sources(gprs); + break; default: break; } @@ -1584,6 +2017,8 @@ static void gprs_unregister(struct ofono_atom *atom) gprs->dun = NULL; } + ofono_emulator_remove_sources(gprs); + ofono_modem_remove_interface(modem, OFONO_DATA_CONNECTION_MANAGER_INTERFACE); g_dbus_unregister_interface(conn, path, -- 1.6.3.3

Watch GPRS status changes to notify DUN client any unsolicited result, like +CGREG status changes. --- include/gprs.h | 11 +++++++ src/emulator.c | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/gprs.c | 64 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 163 insertions(+), 0 deletions(-) diff --git a/include/gprs.h b/include/gprs.h index a1cbcd9..ca23c45 100644 --- a/include/gprs.h +++ b/include/gprs.h @@ -36,6 +36,8 @@ typedef void (*ofono_gprs_status_cb_t)(const struct ofono_error *error, typedef void (*ofono_gprs_cb_t)(const struct ofono_error *error, void *data); +typedef void (*ofono_gprs_status_notify_cb_t)(const int status, void *data); + struct ofono_gprs_driver { const char *name; int (*probe)(struct ofono_gprs *gprs, unsigned int vendor, @@ -67,6 +69,15 @@ void ofono_gprs_set_cid_range(struct ofono_gprs *gprs, void ofono_gprs_add_context(struct ofono_gprs *gprs, struct ofono_gprs_context *gc); +unsigned int __ofono_gprs_add_status_watch(struct ofono_gprs *gprs, + ofono_gprs_status_notify_cb_t cb, + void *data, ofono_destroy_func destroy); + +gboolean __ofono_gprs_remove_status_watch(struct ofono_gprs *gprs, + unsigned int id); + +int ofono_gprs_get_status(struct ofono_gprs *gprs); + #ifdef __cplusplus } #endif diff --git a/src/emulator.c b/src/emulator.c index 546a48b..3bb32ae 100644 --- a/src/emulator.c +++ b/src/emulator.c @@ -68,6 +68,10 @@ struct ofono_emulator { int netreg_lac; int netreg_ci; int gprs_status; + + struct ofono_gprs *gprs; + unsigned int gprs_watch; + unsigned int gprs_status_watch; }; static GSList *emulator_list; @@ -767,6 +771,18 @@ static void emulator_remove(struct ofono_atom *atom) if (e->driver->remove) e->driver->remove(e); + if (e->gprs_watch) { + if (e->gprs_status_watch) { + __ofono_gprs_remove_status_watch(e->gprs, + e->gprs_status_watch); + e->gprs_status_watch = 0; + } + + __ofono_modem_remove_atom_watch(e->modem, e->gprs_watch); + e->gprs_watch = 0; + e->gprs = NULL; + } + __ofono_watchlist_free(e->status_watches); ofono_emulator_release_id(e->id); g_free(e); @@ -794,6 +810,76 @@ void ofono_emulator_disable(struct ofono_emulator *e) e->powered = FALSE; } +static void emulator_gprs_update(struct ofono_emulator *e) +{ + GAtServer *server = e->server; + char buf[256]; + + switch (e->modem_cgreg) { + case 0: + break; + case 1: + snprintf(buf, sizeof(buf), "+CGREG: %d", e->gprs_status); + g_at_server_send_unsolicited(server, buf); + break; + case 2: + snprintf(buf, sizeof(buf), "+CGREG: %d", e->gprs_status); + g_at_server_send_unsolicited(server, buf); + break; + default: + break; + } +} + +static void gprs_status_changed(int status, void *data) +{ + struct ofono_emulator *e = data; + + DBG("%d", status); + + e->gprs_status = status; + + emulator_gprs_update(e); +} + +static void gprs_watch(struct ofono_atom *atom, + enum ofono_atom_watch_condition cond, + void *data) +{ + struct ofono_emulator *e = data; + struct ofono_gprs *gprs; + + if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) { + e->gprs_status_watch = 0; + e->gprs = NULL; + return; + } + + gprs = __ofono_atom_get_data(atom); + e->gprs = gprs; + e->gprs_status = ofono_gprs_get_status(gprs); + e->gprs_status_watch = __ofono_gprs_add_status_watch(e->gprs, + gprs_status_changed, e, NULL); + + emulator_gprs_update(e); +} + +static void add_gprs_watches(struct ofono_emulator *e) +{ + struct ofono_modem *modem = e->modem; + struct ofono_atom *gprs_atom; + + e->gprs_watch = __ofono_modem_add_atom_watch(modem, + OFONO_ATOM_TYPE_GPRS, + gprs_watch, e, NULL); + + gprs_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_GPRS); + + if (gprs_atom && __ofono_atom_get_registered(gprs_atom)) + gprs_watch(gprs_atom, + OFONO_ATOM_WATCH_CONDITION_REGISTERED, e); +} + static int set_powered(struct ofono_emulator *e, ofono_bool_t powered, int fd) { int val; @@ -843,6 +929,8 @@ ofono_bool_t ofono_emulator_enable(struct ofono_emulator *e, int fd) g_at_server_register(e->server, "+CGATT", cgatt_cb, e, NULL); g_at_server_register(e->server, "+CGDCONT", cgdcont_cb, e, NULL); + add_gprs_watches(e); + g_io_channel_unref(channel); e->powered = TRUE; diff --git a/src/gprs.c b/src/gprs.c index cb83e23..3ed056a 100644 --- a/src/gprs.c +++ b/src/gprs.c @@ -142,6 +142,8 @@ static const char *gprs_context_type_to_string(int type) return "mms"; case GPRS_CONTEXT_TYPE_WAP: return "wap"; + case GPRS_CONTEXT_TYPE_DUN: + return "dun"; } return NULL; @@ -155,6 +157,8 @@ static enum gprs_context_type gprs_context_string_to_type(const char *str) return GPRS_CONTEXT_TYPE_WAP; else if (g_str_equal(str, "mms")) return GPRS_CONTEXT_TYPE_MMS; + else if (g_str_equal(str, "dun")) + return GPRS_CONTEXT_TYPE_DUN; return GPRS_CONTEXT_TYPE_INVALID; } @@ -1467,6 +1471,51 @@ static GDBusSignalTable manager_signals[] = { { } }; +unsigned int __ofono_gprs_add_status_watch(struct ofono_gprs *gprs, + ofono_gprs_status_notify_cb_t notify, + void *data, ofono_destroy_func destroy) +{ + struct ofono_watchlist_item *item; + + DBG("%p", gprs); + + if (gprs == NULL) + return 0; + + if (notify == NULL) + return 0; + + item = g_new0(struct ofono_watchlist_item, 1); + + item->notify = notify; + item->destroy = destroy; + item->notify_data = data; + + return __ofono_watchlist_add_item(gprs->status_watches, item); +} + +gboolean __ofono_gprs_remove_status_watch(struct ofono_gprs *gprs, + unsigned int id) +{ + DBG("%p", gprs); + + return __ofono_watchlist_remove_item(gprs->status_watches, id); +} + +static void notify_status_watches(struct ofono_gprs *gprs) +{ + struct ofono_watchlist_item *item; + GSList *l; + ofono_gprs_status_notify_cb_t notify; + + for (l = gprs->status_watches->items; l; l = l->next) { + item = l->data; + notify = item->notify; + + notify(gprs->status, item->notify_data); + } +} + void ofono_gprs_detached_notify(struct ofono_gprs *gprs) { if (gprs->driver_attached == FALSE) @@ -1476,6 +1525,8 @@ void ofono_gprs_detached_notify(struct ofono_gprs *gprs) gprs_attached_update(gprs); + notify_status_watches(gprs); + /* TODO: The network forced a detach, we should wait for some time * and try to re-attach */ @@ -1489,6 +1540,8 @@ void ofono_gprs_status_notify(struct ofono_gprs *gprs, int status) gprs->status = status; gprs_attached_update(gprs); + + notify_status_watches(gprs); } void ofono_gprs_set_cid_range(struct ofono_gprs *gprs, @@ -1944,6 +1997,14 @@ struct ofono_modem *ofono_gprs_context_get_modem(struct ofono_gprs_context *gc) return __ofono_atom_get_modem(gc->atom); } +int ofono_gprs_get_status(struct ofono_gprs *gprs) +{ + if (gprs == NULL) + return -1; + + return gprs->status; +} + int ofono_gprs_driver_register(const struct ofono_gprs_driver *d) { DBG("driver: %p, name: %s", d, d->name); @@ -1971,6 +2032,9 @@ static void gprs_unregister(struct ofono_atom *atom) const char *path = __ofono_atom_get_path(atom); GSList *l; + __ofono_watchlist_free(gprs->status_watches); + gprs->status_watches = NULL; + if (gprs->settings) { storage_close(gprs->imsi, SETTINGS_STORE, gprs->settings, TRUE); -- 1.6.3.3

DUN client may request us to attach/deattach GPRS network. In such case, use gprs_netreg_update to update gprs status. --- src/gprs.c | 15 +++++++++++++++ 1 files changed, 15 insertions(+), 0 deletions(-) diff --git a/src/gprs.c b/src/gprs.c index 3ed056a..1f9e396 100644 --- a/src/gprs.c +++ b/src/gprs.c @@ -1860,6 +1860,18 @@ error: req->cb(&error, NULL, NULL, NULL, NULL, req->cb_data); } +static void ofono_emulator_set_cgatt(struct ofono_gprs *gprs, + struct ofono_emulator_req *req) +{ + int *mode = req->data; + + gprs->powered = *mode; + + gprs_netreg_update(gprs); + + req->cb(G_AT_SERVER_RESULT_OK, req->cb_data); +} + static void dun_status_watch(struct ofono_emulator *e, enum ofono_emulator_status status, void *data, void *user_data) @@ -1881,6 +1893,9 @@ static void dun_status_watch(struct ofono_emulator *e, case OFONO_EMULATOR_STATUS_DUN_DISCONNECTED: ofono_emulator_dun_disconnect(gprs, data); break; + case OFONO_EMULATOR_STATUS_SET_CGATT: + ofono_emulator_set_cgatt(gprs, data); + break; case OFONO_EMULATOR_STATUS_DESTROY: ofono_emulator_remove_sources(gprs); break; -- 1.6.3.3