blob: f3d0b1a020f334c1f164b9d18a6c3becfb6ac8b5 [file] [log] [blame]
/*
*
* OBEX Server
*
* Copyright (C) 2007-2010 Nokia Corporation
* Copyright (C) 2007-2010 Marcel Holtmann <marcel@holtmann.org>
*
*
* 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 <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <inttypes.h>
#include <glib.h>
#include "gdbus.h"
#include "obexd.h"
#include "plugin.h"
#include "log.h"
#include "obex.h"
#include "mimetype.h"
#include "service.h"
#include "ftp.h"
#define PCSUITE_CHANNEL 24
#define PCSUITE_WHO_SIZE 8
#define PCSUITE_RECORD "<?xml version=\"1.0\" encoding=\"UTF-8\" ?> \
<record> \
<attribute id=\"0x0001\"> \
<sequence> \
<uuid value=\"00005005-0000-1000-8000-0002ee000001\"/> \
</sequence> \
</attribute> \
\
<attribute id=\"0x0004\"> \
<sequence> \
<sequence> \
<uuid value=\"0x0100\"/> \
</sequence> \
<sequence> \
<uuid value=\"0x0003\"/> \
<uint8 value=\"%u\" name=\"channel\"/> \
</sequence> \
<sequence> \
<uuid value=\"0x0008\"/> \
</sequence> \
</sequence> \
</attribute> \
\
<attribute id=\"0x0005\"> \
<sequence> \
<uuid value=\"0x1002\"/> \
</sequence> \
</attribute> \
\
<attribute id=\"0x0009\"> \
<sequence> \
<sequence> \
<uuid value=\"00005005-0000-1000-8000-0002ee000001\"/> \
<uint16 value=\"0x0100\" name=\"version\"/> \
</sequence> \
</sequence> \
</attribute> \
\
<attribute id=\"0x0100\"> \
<text value=\"%s\" name=\"name\"/> \
</attribute> \
</record>"
#define BACKUP_BUS_NAME "com.nokia.backup.plugin"
#define BACKUP_PATH "/com/nokia/backup"
#define BACKUP_PLUGIN_INTERFACE "com.nokia.backup.plugin"
#define BACKUP_DBUS_TIMEOUT (1000 * 60 * 15)
static const uint8_t FTP_TARGET[TARGET_SIZE] = {
0xF9, 0xEC, 0x7B, 0xC4, 0x95, 0x3C, 0x11, 0xD2,
0x98, 0x4E, 0x52, 0x54, 0x00, 0xDC, 0x9E, 0x09 };
static const uint8_t PCSUITE_WHO[PCSUITE_WHO_SIZE] = {
'P', 'C', ' ', 'S', 'u', 'i', 't', 'e' };
struct pcsuite_session {
struct ftp_session *ftp;
char *lock_file;
int fd;
};
static void *pcsuite_connect(struct obex_session *os, int *err)
{
struct pcsuite_session *pcsuite;
struct ftp_session *ftp;
int fd;
char *filename;
DBG("");
ftp = ftp_connect(os, err);
if (ftp == NULL)
return NULL;
filename = g_build_filename(g_get_home_dir(), ".pcsuite", NULL);
fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0644);
if (fd < 0 && errno != EEXIST) {
error("open(%s): %s(%d)", filename, strerror(errno), errno);
goto fail;
}
/* Try to remove the file before retrying since it could be
that some process left/crash without removing it */
if (fd < 0) {
if (remove(filename) < 0) {
error("remove(%s): %s(%d)", filename, strerror(errno),
errno);
goto fail;
}
fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0644);
if (fd < 0) {
error("open(%s): %s(%d)", filename, strerror(errno),
errno);
goto fail;
}
}
DBG("%s created", filename);
pcsuite = g_new0(struct pcsuite_session, 1);
pcsuite->ftp = ftp;
pcsuite->lock_file = filename;
pcsuite->fd = fd;
DBG("session %p created", pcsuite);
if (err)
*err = 0;
return pcsuite;
fail:
if (ftp)
ftp_disconnect(os, ftp);
if (err)
*err = -errno;
g_free(filename);
return NULL;
}
static int pcsuite_get(struct obex_session *os, void *user_data)
{
struct pcsuite_session *pcsuite = user_data;
DBG("%p", pcsuite);
return ftp_get(os, pcsuite->ftp);
}
static int pcsuite_chkput(struct obex_session *os, void *user_data)
{
struct pcsuite_session *pcsuite = user_data;
DBG("%p", pcsuite);
return ftp_chkput(os, pcsuite->ftp);
}
static int pcsuite_put(struct obex_session *os, void *user_data)
{
struct pcsuite_session *pcsuite = user_data;
DBG("%p", pcsuite);
return ftp_put(os, pcsuite->ftp);
}
static int pcsuite_setpath(struct obex_session *os, void *user_data)
{
struct pcsuite_session *pcsuite = user_data;
DBG("%p", pcsuite);
return ftp_setpath(os, pcsuite->ftp);
}
static int pcsuite_action(struct obex_session *os, void *user_data)
{
struct pcsuite_session *pcsuite = user_data;
DBG("%p", pcsuite);
return ftp_action(os, pcsuite->ftp);
}
static void pcsuite_disconnect(struct obex_session *os, void *user_data)
{
struct pcsuite_session *pcsuite = user_data;
DBG("%p", pcsuite);
if (pcsuite->fd >= 0)
close(pcsuite->fd);
if (pcsuite->lock_file) {
remove(pcsuite->lock_file);
g_free(pcsuite->lock_file);
}
if (pcsuite->ftp)
ftp_disconnect(os, pcsuite->ftp);
g_free(pcsuite);
}
static struct obex_service_driver pcsuite = {
.name = "Nokia OBEX PC Suite Services",
.service = OBEX_PCSUITE,
.channel = PCSUITE_CHANNEL,
.secure = TRUE,
.record = PCSUITE_RECORD,
.target = FTP_TARGET,
.target_size = TARGET_SIZE,
.who = PCSUITE_WHO,
.who_size = PCSUITE_WHO_SIZE,
.connect = pcsuite_connect,
.get = pcsuite_get,
.put = pcsuite_put,
.chkput = pcsuite_chkput,
.setpath = pcsuite_setpath,
.action = pcsuite_action,
.disconnect = pcsuite_disconnect
};
struct backup_object {
gchar *cmd;
int fd;
int oflag;
int error_code;
mode_t mode;
DBusPendingCall *pending_call;
DBusConnection *conn;
};
static void on_backup_dbus_notify(DBusPendingCall *pending_call,
void *user_data)
{
struct backup_object *obj = user_data;
DBusMessage *reply;
const char *filename;
int error_code;
DBG("Notification received for pending call - %s", obj->cmd);
reply = dbus_pending_call_steal_reply(pending_call);
if (reply && dbus_message_get_args(reply, NULL, DBUS_TYPE_INT32,
&error_code, DBUS_TYPE_STRING,
&filename, DBUS_TYPE_INVALID)) {
obj->error_code = error_code;
if (filename) {
DBG("Notification - file path = %s, error_code = %d",
filename, error_code);
if (error_code == 0)
obj->fd = open(filename,obj->oflag,obj->mode);
}
} else
DBG("Notification timed out or connection got closed");
if (reply)
dbus_message_unref(reply);
dbus_pending_call_unref(pending_call);
obj->pending_call = NULL;
dbus_connection_unref(obj->conn);
obj->conn = NULL;
if (obj->fd >= 0) {
DBG("File opened, setting io flags, cmd = %s",
obj->cmd);
if (obj->oflag == O_RDONLY)
obex_object_set_io_flags(user_data, G_IO_IN, 0);
else
obex_object_set_io_flags(user_data, G_IO_OUT, 0);
} else {
DBG("File open error, setting io error, cmd = %s",
obj->cmd);
obex_object_set_io_flags(user_data, G_IO_ERR, -EPERM);
}
}
static gboolean send_backup_dbus_message(const char *oper,
struct backup_object *obj,
size_t *size)
{
DBusConnection *conn;
DBusMessage *msg;
DBusPendingCall *pending_call;
gboolean ret = FALSE;
dbus_uint32_t file_size;
file_size = size ? *size : 0;
conn = g_dbus_setup_bus(DBUS_BUS_SESSION, NULL, NULL);
if (conn == NULL)
return FALSE;
msg = dbus_message_new_method_call(BACKUP_BUS_NAME, BACKUP_PATH,
BACKUP_PLUGIN_INTERFACE,
"request");
if (msg == NULL) {
dbus_connection_unref(conn);
return FALSE;
}
dbus_message_append_args(msg, DBUS_TYPE_STRING, &oper,
DBUS_TYPE_STRING, &obj->cmd,
DBUS_TYPE_INT32, &file_size,
DBUS_TYPE_INVALID);
if (strcmp(oper, "open") == 0) {
ret = dbus_connection_send_with_reply(conn, msg, &pending_call,
BACKUP_DBUS_TIMEOUT);
dbus_message_unref(msg);
if (ret) {
obj->conn = conn;
obj->pending_call = pending_call;
ret = dbus_pending_call_set_notify(pending_call,
on_backup_dbus_notify,
obj, NULL);
} else
dbus_connection_unref(conn);
} else {
ret = dbus_connection_send(conn, msg, NULL);
dbus_message_unref(msg);
dbus_connection_unref(conn);
}
return ret;
}
static void *backup_open(const char *name, int oflag, mode_t mode,
void *context, size_t *size, int *err)
{
struct backup_object *obj = g_new0(struct backup_object, 1);
DBG("cmd = %s", name);
obj->cmd = g_path_get_basename(name);
obj->oflag = oflag;
obj->mode = mode;
obj->fd = -1;
obj->pending_call = NULL;
obj->conn = NULL;
obj->error_code = 0;
if (send_backup_dbus_message("open", obj, size) == FALSE) {
g_free(obj);
obj = NULL;
}
if (err)
*err = 0;
return obj;
}
static int backup_close(void *object)
{
struct backup_object *obj = object;
size_t size = 0;
DBG("cmd = %s", obj->cmd);
if (obj->fd != -1)
close(obj->fd);
if (obj->pending_call) {
dbus_pending_call_cancel(obj->pending_call);
dbus_pending_call_unref(obj->pending_call);
dbus_connection_unref(obj->conn);
}
send_backup_dbus_message("close", obj, &size);
g_free(obj->cmd);
g_free(obj);
return 0;
}
static ssize_t backup_read(void *object, void *buf, size_t count)
{
struct backup_object *obj = object;
ssize_t ret = 0;
if (obj->pending_call) {
DBG("cmd = %s, IN WAITING STAGE", obj->cmd);
return -EAGAIN;
}
if (obj->fd != -1) {
DBG("cmd = %s, READING DATA", obj->cmd);
ret = read(obj->fd, buf, count);
if (ret < 0)
ret = -errno;
} else {
DBG("cmd = %s, PERMANENT FAILURE", obj->cmd);
ret = obj->error_code ? -obj->error_code : -ENOENT;
}
return ret;
}
static ssize_t backup_write(void *object, const void *buf, size_t count)
{
struct backup_object *obj = object;
ssize_t ret = 0;
if (obj->pending_call) {
DBG("cmd = %s, IN WAITING STAGE", obj->cmd);
return -EAGAIN;
}
if (obj->fd != -1) {
ret = write(obj->fd, buf, count);
DBG("cmd = %s, WRITTING", obj->cmd);
if (ret < 0) {
error("backup: cmd = %s", obj->cmd);
ret = -errno;
}
} else {
error("backup: cmd = %s", obj->cmd);
ret = obj->error_code ? -obj->error_code : -ENOENT;
}
return ret;
}
static int backup_flush(void *object)
{
DBG("%p", object);
return 0;
}
static struct obex_mime_type_driver backup = {
.target = FTP_TARGET,
.target_size = TARGET_SIZE,
.mimetype = "application/vnd.nokia-backup",
.open = backup_open,
.close = backup_close,
.read = backup_read,
.write = backup_write,
.flush = backup_flush,
};
static int pcsuite_init(void)
{
int err;
err = obex_service_driver_register(&pcsuite);
if (err < 0)
return err;
err = obex_mime_type_driver_register(&backup);
if (err < 0)
obex_service_driver_unregister(&pcsuite);
return err;
}
static void pcsuite_exit(void)
{
obex_mime_type_driver_unregister(&backup);
obex_service_driver_unregister(&pcsuite);
}
OBEX_PLUGIN_DEFINE(pcsuite, pcsuite_init, pcsuite_exit)