--- modules/history-agent.c | 686 +++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 686 insertions(+), 0 deletions(-) create mode 100644 modules/history-agent.c diff --git a/modules/history-agent.c b/modules/history-agent.c new file mode 100644 index 0000000..6979195 --- /dev/null +++ b/modules/history-agent.c @@ -0,0 +1,686 @@ +/* + * + * oFono - Open Source Telephony + * + * Copyright (C) 2008-2011 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 <errno.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <sys/stat.h> +#include <sys/mman.h> +#include <glib.h> +#include <gdbus.h> +#include <ofono.h> + +#define OFONO_API_SUBJECT_TO_CHANGE +#include <ofono/plugin.h> +#include <ofono/log.h> +#include <ofono/modem.h> +#include <ofono/dbus.h> +#include "common.h" +#include "storage.h" + +#define HISTORY_SPOOL_MODE 0600 +#define HISTORY_SPOOL_BASE STORAGEDIR "/%s/history" +#define HISTORY_SPOOL_PATH HISTORY_SPOOL_BASE "/%08x" + +#define HISTORY_INTERFACE "org.ofono.History" +#define AGENT_INTERFACE "org.ofono.HistoryAgent" + +struct history_agent { + DBusConnection *conn; + const char *path; + char *imsi; + + char *agent_path; + char *agent_owner; + guint agent_watch; + + GQueue *queue; + guint32 next_idx; + guint32 current_idx; + DBusPendingCall *agent_call; +}; + +static void process_queue(struct history_agent *history); + +static void agent_reply_cb(DBusPendingCall *call, void *data) +{ + struct history_agent *history = data; + DBusMessage *reply = dbus_pending_call_steal_reply(call); + DBusError error; + char *path; + + dbus_error_init(&error); + + if (dbus_set_error_from_message(&error, reply) == TRUE) { + ofono_error("Agent method failed: %s", error.name); + dbus_error_free(&error); + goto done; + } + + DBG("index: %08x", history->current_idx); + + path = g_strdup_printf(HISTORY_SPOOL_PATH, history->imsi, + history->current_idx); + unlink(path); + g_free(path); + +done: + dbus_message_unref(reply); + + history->agent_call = NULL; + + process_queue(history); +} + +static const char *buffer_next(const unsigned char **buffer, size_t *size) +{ + const void *ptr = *buffer; + guint32 len; + + if (*size < 5) + return NULL; + + len = *((guint32 *) ptr); + if (len == 0) + return NULL; + + if (len + 4 > *size) + return NULL; + + *size -= len + 4; + *buffer += len + 4; + + return ptr + 4; +} + +static void process_history(struct history_agent *history, + const unsigned char *buffer, size_t size) +{ + const unsigned char *ptr = buffer; + size_t len = size; + DBusMessage *msg; + DBusMessageIter iter, dict; + const char *method; + + method = buffer_next(&ptr, &len); + if (method == NULL) + return; + + DBG("method: %s", method); + + msg = dbus_message_new_method_call(history->agent_owner, + history->agent_path, + AGENT_INTERFACE, method); + if (msg == NULL) + return; + + dbus_message_iter_init_append(msg, &iter); + + dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + OFONO_PROPERTIES_ARRAY_SIGNATURE, &dict); + + while (1) { + const char *key, *val; + + key = buffer_next(&ptr, &len); + if (key == NULL) + break; + + val = buffer_next(&ptr, &len); + if (val == NULL) + break; + + ofono_dbus_dict_append(&dict, key, DBUS_TYPE_STRING, &val); + } + + dbus_message_iter_close_container(&iter, &dict); + + if (dbus_connection_send_with_reply(history->conn, msg, + &history->agent_call, -1) == FALSE) { + ofono_error("Sending D-Bus method failed"); + goto done; + } + + dbus_pending_call_set_notify(history->agent_call, agent_reply_cb, + history, NULL); + + dbus_pending_call_unref(history->agent_call); + +done: + dbus_message_unref(msg); +} + +static void process_queue(struct history_agent *history) +{ + int fd; + struct stat st; + unsigned char *addr; + char *path; + gpointer head; + + DBG("owner: %s", history->agent_owner); + + if (history->agent_owner == NULL) + return; + + if (history->agent_call != NULL) + return; + + head = g_queue_pop_head(history->queue); + if (head == NULL) { + history->next_idx = 0; + return; + } + + history->current_idx = GPOINTER_TO_UINT(head); + + DBG("index: %08x", history->current_idx); + + path = g_strdup_printf(HISTORY_SPOOL_PATH, history->imsi, + history->current_idx); + fd = TFR(open(path, O_RDONLY)); + g_free(path); + + if (fd < 0) { + ofono_error("Failed to open history index %08x", + history->current_idx); + return; + } + + if (TFR(fstat(fd, &st)) < 0) + goto done; + + addr = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); + if (addr == MAP_FAILED) + goto done; + + process_history(history, addr, st.st_size); + + munmap(addr, st.st_size); + +done: + TFR(close(fd)); +} + +static gint compare_index(gconstpointer a, gconstpointer b, + gpointer user_data) +{ + guint32 one = GPOINTER_TO_UINT(a); + guint32 two = GPOINTER_TO_UINT(b); + + return one - two; +} + +static void process_spool(struct history_agent *history) +{ + GDir *dir; + char *path; + gpointer tail; + + path = g_strdup_printf(HISTORY_SPOOL_BASE, history->imsi); + + DBG("path: %s", path); + + dir = g_dir_open(path, 0, NULL); + + g_free(path); + + if (dir == NULL) + return; + + while (1) { + const char *path; + guint32 idx; + + path = g_dir_read_name(dir); + if (path == NULL) + break; + + idx = strtol(path, NULL, 16); + if (errno == ERANGE || errno == EINVAL) + continue; + + DBG("index: %08x", idx); + + g_queue_insert_sorted(history->queue, GUINT_TO_POINTER(idx), + compare_index, NULL); + } + + g_dir_close(dir); + + tail = g_queue_peek_tail(history->queue); + if (tail == NULL) + return; + + history->next_idx = GPOINTER_TO_UINT(tail); +} + +static void array_append(GByteArray *array, const char *str) +{ + guint32 len; + + if (str == NULL) { + len = 0; + g_byte_array_append(array, (guint8 *) &len, 4); + } else { + len = strlen(str) + 1; + g_byte_array_append(array, (guint8 *) &len, 4); + g_byte_array_append(array, (guint8 *) str, len); + } +} + +static void create_history(struct history_agent *history, + const char *method, ...) +{ + GByteArray *array; + va_list args; + + DBG("method: %s", method); + + array = g_byte_array_sized_new(128); + if (array == NULL) + return; + + array_append(array, method); + + va_start(args, method); + + while (1) { + const char *key, *val; + + key = va_arg(args, const char *); + if (key == NULL) + break; + + array_append(array, key); + + val = va_arg(args, const char *); + + array_append(array, val); + } + + va_end(args); + + array_append(array, NULL); + + history->next_idx++; + + DBG("index: %08x", history->next_idx); + + write_file(array->data, array->len, HISTORY_SPOOL_MODE, + HISTORY_SPOOL_PATH, history->imsi, history->next_idx); + + g_byte_array_free(array, TRUE); + + g_queue_push_tail(history->queue, GUINT_TO_POINTER(history->next_idx)); + + process_queue(history); +} + +static void free_agent_data(struct history_agent *history) +{ + if (history->agent_call != NULL) { + dbus_pending_call_cancel(history->agent_call); + history->agent_call = NULL; + } + + g_free(history->agent_path); + history->agent_path = NULL; + + g_free(history->agent_owner); + history->agent_owner = NULL; +} + +static void agent_disconnect_cb(DBusConnection *conn, void *data) +{ + struct history_agent *history = data; + + history->agent_watch = 0; + + free_agent_data(history); +} + +static DBusMessage *register_agent(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + struct history_agent *history = data; + const char *path, *sender; + + sender = dbus_message_get_sender(msg); + + DBG("sender: %s", sender); + + if (history->agent_owner != NULL) + return __ofono_error_busy(msg); + + if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_INVALID) == FALSE) + return __ofono_error_invalid_args(msg); + + if (!__ofono_dbus_valid_object_path(path)) + return __ofono_error_invalid_format(msg); + + history->agent_path = g_strdup(path); + history->agent_owner = g_strdup(sender); + + history->agent_watch = g_dbus_add_disconnect_watch(history->conn, + sender, agent_disconnect_cb, + history, NULL); + + process_queue(history); + + return dbus_message_new_method_return(msg); +} + +static DBusMessage *unregister_agent(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + struct history_agent *history = data; + const char *path, *sender; + + sender = dbus_message_get_sender(msg); + + DBG("sender: %s", sender); + + if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, + DBUS_TYPE_INVALID) == FALSE) + return __ofono_error_invalid_args(msg); + + if (history->agent_owner == NULL) + return __ofono_error_not_available(msg); + + if (g_str_equal(sender, history->agent_owner) == FALSE) + return __ofono_error_access_denied(msg); + + g_dbus_remove_watch(history->conn, history->agent_watch); + history->agent_watch = 0; + + free_agent_data(history); + + return dbus_message_new_method_return(msg); +} + +static GDBusMethodTable history_methods[] = { + { "RegisterAgent", "o", "", register_agent }, + { "UnregisterAgent", "o", "", unregister_agent }, + { } +}; + +static void send_release(struct history_agent *history) +{ + DBusMessage *msg; + + msg = dbus_message_new_method_call(history->agent_owner, + history->agent_path, + AGENT_INTERFACE, "Release"); + if (msg == NULL) + return; + + dbus_message_set_no_reply(msg, TRUE); + + g_dbus_send_message(history->conn, msg); +} + +static void free_history(struct history_agent *history) +{ + g_queue_free(history->queue); + + g_free(history->imsi); + g_free(history); +} + +static int history_probe(struct ofono_history_context *context) +{ + struct history_agent *history; + struct ofono_atom *atom; + struct ofono_sim *sim; + + DBG("modem: %p", context->modem); + + history = g_try_new0(struct history_agent, 1); + if (history == NULL) + return -ENOMEM; + + history->conn = ofono_dbus_get_connection(); + history->path = ofono_modem_get_path(context->modem); + + atom = __ofono_modem_find_atom(context->modem, OFONO_ATOM_TYPE_SIM); + sim = __ofono_atom_get_data(atom); + + history->imsi = g_strdup(ofono_sim_get_imsi(sim)); + + DBG("imsi: %s", history->imsi); + + history->queue = g_queue_new(); + + process_spool(history); + + if (g_dbus_register_interface(history->conn, history->path, + HISTORY_INTERFACE, history_methods, + NULL, NULL, history, NULL) == FALSE) { + ofono_error("Could not create %s interface", + HISTORY_INTERFACE); + free_history(history); + return -EIO; + } + + ofono_modem_add_interface(context->modem, HISTORY_INTERFACE); + + context->data = history; + + return 0; +} + +static void history_remove(struct ofono_history_context *context) +{ + struct history_agent *history = context->data; + + DBG("modem: %p", context->modem); + + ofono_modem_remove_interface(context->modem, HISTORY_INTERFACE); + + if (history->agent_watch > 0) { + g_dbus_remove_watch(history->conn, history->agent_watch); + + send_release(history); + } + + free_agent_data(history); + + g_dbus_unregister_interface(history->conn, history->path, + HISTORY_INTERFACE); + + free_history(history); +} + +static void history_call_ended(struct ofono_history_context *context, + const struct ofono_call *call, + time_t start, time_t end) +{ + struct history_agent *history = context->data; + char stime_str[29], etime_str[29]; + const char *number_str, *name_str, *dir_str; + + strftime(stime_str, 28, "%Y-%m-%dT%H:%M:%S%z", localtime(&start)); + stime_str[28] = '\0'; + + strftime(etime_str, 28, "%Y-%m-%dT%H:%M:%S%z", localtime(&end)); + etime_str[28] = '\0'; + + dir_str = call->direction == 0 ? "outgoing" : "incoming"; + + if (call->clip_validity == 0) + number_str = phone_number_to_string(&call->phone_number); + else + number_str = ""; + + if (call->cnap_validity == 0) + name_str = call->name; + else + name_str = ""; + + create_history(history, "CallEnded", "Number", number_str, + "Name", name_str, + "Direction", dir_str, + "StartTime", stime_str, + "EndTime", etime_str, NULL); +} + +static void history_call_missed(struct ofono_history_context *context, + const struct ofono_call *call, + time_t when) +{ + struct history_agent *history = context->data; + char time_str[29]; + const char *number_str, *name_str; + + strftime(time_str, 28, "%Y-%m-%dT%H:%M:%S%z", localtime(&when)); + time_str[28] = '\0'; + + if (call->clip_validity == 0) + number_str = phone_number_to_string(&call->phone_number); + else + number_str = ""; + + if (call->cnap_validity == 0) + name_str = call->name; + else + name_str = ""; + + create_history(history, "CallMissed", "Number", number_str, + "Name", name_str, + "LocalTime", time_str, NULL); +} + +static void history_sms_received(struct ofono_history_context *context, + const struct ofono_uuid *uuid, + const char *from, + const struct tm *remote, + const struct tm *local, + const char *text) +{ + struct history_agent *history = context->data; + char ltime_str[29], rtime_str[29]; + const char *uuid_str; + + strftime(rtime_str, 28, "%Y-%m-%dT%H:%M:%S%z", remote); + rtime_str[28] = '\0'; + + strftime(ltime_str, 28, "%Y-%m-%dT%H:%M:%S%z", local); + ltime_str[28] = '\0'; + + uuid_str = ofono_uuid_to_str(uuid); + + create_history(history, "MessageReceived", "Identifier", uuid_str, + "Sender", from, + "Text", text, + "RemoteTime", rtime_str, + "LocalTime", ltime_str, NULL); +} + +static void history_sms_send_pending(struct ofono_history_context *context, + const struct ofono_uuid *uuid, + const char *to, time_t when, + const char *text) +{ + struct history_agent *history = context->data; + char time_str[29]; + const char *uuid_str; + + strftime(time_str, 28, "%Y-%m-%dT%H:%M:%S%z", localtime(&when)); + time_str[28] = '\0'; + + uuid_str = ofono_uuid_to_str(uuid); + + create_history(history, "MessageSubmitted", "Identifier", uuid_str, + "Receiver", to, + "Text", text, + "LocalTime", time_str, NULL); +} + +static void history_sms_send_status(struct ofono_history_context *context, + const struct ofono_uuid *uuid, time_t when, + enum ofono_history_sms_status status) +{ + struct history_agent *history = context->data; + char time_str[29]; + const char *uuid_str, *status_str = NULL; + + switch (status) { + case OFONO_HISTORY_SMS_STATUS_PENDING: + status_str = "pending"; + break; + case OFONO_HISTORY_SMS_STATUS_SUBMITTED: + status_str = "submitted"; + break; + case OFONO_HISTORY_SMS_STATUS_SUBMIT_FAILED: + status_str = "submit-failed"; + break; + case OFONO_HISTORY_SMS_STATUS_DELIVERED: + status_str = "delivered"; + break; + case OFONO_HISTORY_SMS_STATUS_DELIVER_FAILED: + status_str = "deliver-failed"; + break; + } + + if (status_str == NULL) + return; + + strftime(time_str, 28, "%Y-%m-%dT%H:%M:%S%z", localtime(&when)); + time_str[28] = '\0'; + + uuid_str = ofono_uuid_to_str(uuid); + + create_history(history, "MessageStatus", "Identifier", uuid_str, + "Status", status_str, + "LocalTime", time_str, NULL); +} + +static struct ofono_history_driver history_driver = { + .name = "History Agent", + .probe = history_probe, + .remove = history_remove, + .call_ended = history_call_ended, + .call_missed = history_call_missed, + .sms_received = history_sms_received, + .sms_send_pending = history_sms_send_pending, + .sms_send_status = history_sms_send_status, +}; + +static int history_agent_init(void) +{ + return ofono_history_driver_register(&history_driver); +} + +static void history_agent_exit(void) +{ + ofono_history_driver_unregister(&history_driver); +} + +OFONO_PLUGIN_DEFINE(history_agent, "History Agent Plugin", + VERSION, OFONO_PLUGIN_PRIORITY_DEFAULT, + history_agent_init, history_agent_exit) -- 1.7.4