blob: 14b184811ca6266884843bba253a3a6b8162fb93 [file] [log] [blame]
/*
*
* OBEX Server
*
* Copyright (C) 2013 BMW Car IT GmbH. 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 as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* 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 <errno.h>
#include <glib.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h>
#include "gobex/gobex.h"
#include "gobex/gobex-apparam.h"
#include "obexd/src/obexd.h"
#include "obexd/src/plugin.h"
#include "obexd/src/log.h"
#include "obexd/src/obex.h"
#include "obexd/src/service.h"
#include "obexd/src/mimetype.h"
#include "obexd/src/map_ap.h"
#include "map-event.h"
#include "obexd/src/manager.h"
struct mns_session {
GString *buffer;
GObexApparam *inparams;
char *remote_address;
uint8_t mas_instance_id;
};
static const uint8_t MNS_TARGET[TARGET_SIZE] = {
0xbb, 0x58, 0x2b, 0x41, 0x42, 0x0c, 0x11, 0xdb,
0xb0, 0xde, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66 };
static int get_params(struct obex_session *os, struct mns_session *mns)
{
const uint8_t *buffer;
ssize_t size;
size = obex_get_apparam(os, &buffer);
if (size < 0)
size = 0;
mns->inparams = g_obex_apparam_decode(buffer, size);
if (mns->inparams == NULL) {
DBG("Error when parsing parameters!");
return -EBADR;
}
return 0;
}
static void reset_request(struct mns_session *mns)
{
if (mns->buffer) {
g_string_free(mns->buffer, TRUE);
mns->buffer = NULL;
}
if (mns->inparams) {
g_obex_apparam_free(mns->inparams);
mns->inparams = NULL;
}
}
static void mns_session_free(struct mns_session *mns)
{
reset_request(mns);
if (mns->remote_address)
g_free(mns->remote_address);
g_free(mns);
}
static void *mns_connect(struct obex_session *os, int *err)
{
struct mns_session *mns;
char *address;
manager_register_session(os);
mns = g_new0(struct mns_session, 1);
if (obex_getpeername(os, &address) == 0) {
mns->remote_address = g_strdup(address);
g_free(address);
}
DBG("MNS connected to %s", mns->remote_address);
if (err)
*err = 0;
return mns;
}
static void mns_disconnect(struct obex_session *os, void *user_data)
{
struct mns_session *mns = user_data;
DBG("MNS disconnected from %s", mns->remote_address);
manager_unregister_session(os);
mns_session_free(mns);
}
static int mns_put(struct obex_session *os, void *user_data)
{
struct mns_session *mns = user_data;
const char *type = obex_get_type(os);
const char *name = obex_get_name(os);
int ret;
DBG("PUT: name %s type %s mns %p", name, type, mns);
if (type == NULL)
return -EBADR;
ret = get_params(os, mns);
if (ret < 0)
goto failed;
ret = obex_put_stream_start(os, name);
if (ret < 0)
goto failed;
return 0;
failed:
reset_request(mns);
return ret;
}
static void parse_event_report_type(struct map_event *event, const char *value)
{
if (!g_ascii_strcasecmp(value, "NewMessage"))
event->type = MAP_ET_NEW_MESSAGE;
else if (!g_ascii_strcasecmp(value, "DeliverySuccess"))
event->type = MAP_ET_DELIVERY_SUCCESS;
else if (!g_ascii_strcasecmp(value, "SendingSuccess"))
event->type = MAP_ET_SENDING_SUCCESS;
else if (!g_ascii_strcasecmp(value, "DeliveryFailure"))
event->type = MAP_ET_DELIVERY_FAILURE;
else if (!g_ascii_strcasecmp(value, "SendingFailure"))
event->type = MAP_ET_SENDING_FAILURE;
else if (!g_ascii_strcasecmp(value, "MemoryFull"))
event->type = MAP_ET_MEMORY_FULL;
else if (!g_ascii_strcasecmp(value, "MemoryAvailable"))
event->type = MAP_ET_MEMORY_AVAILABLE;
else if (!g_ascii_strcasecmp(value, "MessageDeleted"))
event->type = MAP_ET_MESSAGE_DELETED;
else if (!g_ascii_strcasecmp(value, "MessageShift"))
event->type = MAP_ET_MESSAGE_SHIFT;
}
static void parse_event_report_handle(struct map_event *event,
const char *value)
{
event->handle = strtoull(value, NULL, 16);
}
static void parse_event_report_folder(struct map_event *event,
const char *value)
{
g_free(event->folder);
if (g_str_has_prefix(value, "/"))
event->folder = g_strdup(value);
else
event->folder = g_strconcat("/", value, NULL);
}
static void parse_event_report_old_folder(struct map_event *event,
const char *value)
{
g_free(event->old_folder);
if (g_str_has_prefix(value, "/"))
event->old_folder = g_strdup(value);
else
event->old_folder = g_strconcat("/", value, NULL);
}
static void parse_event_report_msg_type(struct map_event *event,
const char *value)
{
g_free(event->msg_type);
event->msg_type = g_strdup(value);
}
static void parse_event_report_date_time(struct map_event *event,
const char *value)
{
g_free(event->datetime);
event->datetime = g_strdup(value);
}
static void parse_event_report_subject(struct map_event *event,
const char *value)
{
g_free(event->subject);
event->subject = g_strdup(value);
}
static void parse_event_report_sender_name(struct map_event *event,
const char *value)
{
g_free(event->sender_name);
event->sender_name = g_strdup(value);
}
static void parse_event_report_priority(struct map_event *event,
const char *value)
{
g_free(event->priority);
event->priority = g_strdup(value);
}
static struct map_event_report_parser {
const char *name;
void (*func) (struct map_event *event, const char *value);
} event_report_parsers[] = {
{ "type", parse_event_report_type },
{ "handle", parse_event_report_handle },
{ "folder", parse_event_report_folder },
{ "old_folder", parse_event_report_old_folder },
{ "msg_type", parse_event_report_msg_type },
{ "datetime", parse_event_report_date_time },
{ "subject", parse_event_report_subject },
{ "sender_name", parse_event_report_sender_name },
{ "priority", parse_event_report_priority },
{ }
};
static void event_report_element(GMarkupParseContext *ctxt,
const char *element, const char **names,
const char **values, gpointer user_data,
GError **gerr)
{
struct map_event *event = user_data;
const char *key;
int i;
if (strcasecmp("event", element) != 0)
return;
for (i = 0, key = names[i]; key; key = names[++i]) {
struct map_event_report_parser *parser;
for (parser = event_report_parsers; parser && parser->name;
parser++) {
if (strcasecmp(key, parser->name) == 0) {
if (values[i])
parser->func(event, values[i]);
break;
}
}
}
}
static const GMarkupParser event_report_parser = {
event_report_element,
NULL,
NULL,
NULL,
NULL
};
static void map_event_free(struct map_event *event)
{
g_free(event->folder);
g_free(event->old_folder);
g_free(event->msg_type);
g_free(event->datetime);
g_free(event->subject);
g_free(event->sender_name);
g_free(event->priority);
g_free(event);
}
static void *event_report_open(const char *name, int oflag, mode_t mode,
void *driver_data, size_t *size, int *err)
{
struct mns_session *mns = driver_data;
DBG("");
g_obex_apparam_get_uint8(mns->inparams, MAP_AP_MASINSTANCEID,
&mns->mas_instance_id);
mns->buffer = g_string_new("");
if (err != NULL)
*err = 0;
return mns;
}
static int event_report_close(void *obj)
{
struct mns_session *mns = obj;
GMarkupParseContext *ctxt;
struct map_event *event;
DBG("");
event = g_new0(struct map_event, 1);
ctxt = g_markup_parse_context_new(&event_report_parser, 0, event,
NULL);
g_markup_parse_context_parse(ctxt, mns->buffer->str, mns->buffer->len,
NULL);
g_markup_parse_context_free(ctxt);
map_dispatch_event(mns->mas_instance_id, mns->remote_address, event);
map_event_free(event);
reset_request(mns);
return 0;
}
static ssize_t event_report_write(void *obj, const void *buf, size_t count)
{
struct mns_session *mns = obj;
DBG("");
g_string_append_len(mns->buffer, buf, count);
return count;
}
static struct obex_service_driver mns = {
.name = "Message Notification server",
.service = OBEX_MNS,
.target = MNS_TARGET,
.target_size = TARGET_SIZE,
.connect = mns_connect,
.put = mns_put,
.disconnect = mns_disconnect,
};
static struct obex_mime_type_driver mime_event_report = {
.target = MNS_TARGET,
.target_size = TARGET_SIZE,
.mimetype = "x-bt/MAP-event-report",
.open = event_report_open,
.close = event_report_close,
.write = event_report_write,
};
static int mns_init(void)
{
int err;
err = obex_mime_type_driver_register(&mime_event_report);
if (err < 0)
goto fail_mime_event;
err = obex_service_driver_register(&mns);
if (err < 0)
goto fail_mns_reg;
return 0;
fail_mns_reg:
obex_mime_type_driver_unregister(&mime_event_report);
fail_mime_event:
return err;
}
static void mns_exit(void)
{
obex_service_driver_unregister(&mns);
obex_mime_type_driver_unregister(&mime_event_report);
}
OBEX_PLUGIN_DEFINE(mns, mns_init, mns_exit)