path: root/gisi/pipe.c

/*
 *
 *  oFono - Open Source Telephony
 *
 *  Copyright (C) 2009-2010  Nokia Corporation and/or its subsidiary(-ies).
 *
 *  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 <stdint.h>
#include <errno.h>
#include <glib.h>

#include "client.h"
#include "pipe.h"

#define PN_PIPE			0xD9
#define PN_PIPE_INVALID_HANDLE	0xFF

struct isi_pipe_create_req {
	uint8_t cmd;
	uint8_t state_after;
	uint8_t priority;

	uint8_t device1;
	uint8_t object1;
	uint8_t type1;
	uint8_t pad;

	uint8_t device2;
	uint8_t object2;
	uint8_t type2;
	uint8_t n_sb;
};

struct isi_pipe_enable_req {
	uint8_t cmd;
	uint8_t pipe_handle;
	uint8_t pad;
};

struct isi_pipe_reset_req {
	uint8_t cmd;
	uint8_t pipe_handle;
	uint8_t state_after;
};

struct isi_pipe_remove_req {
	uint8_t cmd;
	uint8_t pipe_handle;
};

struct isi_pipe_resp {
	uint8_t pipe_handle;
	uint8_t error_code;
	uint8_t error1;
	uint8_t error2;
};

enum isi_pipe_message_id {
	PNS_PIPE_CREATE_REQ,
	PNS_PIPE_CREATE_RESP,
	PNS_PIPE_REMOVE_REQ,
	PNS_PIPE_REMOVE_RESP,
	PNS_PIPE_RESET_REQ,
	PNS_PIPE_RESET_RESP,
	PNS_PIPE_ENABLE_REQ,
	PNS_PIPE_ENABLE_RESP,
	PNS_PIPE_REDIRECT_REQ,
	PNS_PIPE_REDIRECT_RESP,
	PNS_PIPE_DISABLE_REQ,
	PNS_PIPE_DISABLE_RESP,
};

enum pn_pipe_error {	/* error codes */
	PN_PIPE_ERR_NO_ERROR,
	PN_PIPE_ERR_INVALID_PARAM,
	PN_PIPE_ERR_INVALID_HANDLE,
	PN_PIPE_ERR_INVALID_CTRL_ID,
	PN_PIPE_ERR_NOT_ALLOWED,
	PN_PIPE_ERR_PEP_IN_USE,
	PN_PIPE_ERR_OVERLOAD,
	PN_PIPE_ERR_DEV_DISCONNECTED,
	PN_PIPE_ERR_TIMEOUT,
	PN_PIPE_ERR_ALL_PIPES_IN_USE,
	PN_PIPE_ERR_GENERAL,
	PN_PIPE_ERR_NOT_SUPPORTED,
};

enum pn_pipe_state {	/* initial pipe state */
	PN_PIPE_DISABLE,
	PN_PIPE_ENABLE,
};

enum pn_msg_priority {
	PN_MSG_PRIORITY_LOW = 1,
	PN_MSG_PRIORITY_HIGH,
};

struct _GIsiPipe {
	GIsiClient *client;
	GIsiPipeHandler handler;
	GIsiPipeErrorHandler error_handler;
	void *opaque;
	int error;
	uint8_t handle;
	gboolean enabled;
	gboolean enabling;
};

static int g_isi_pipe_error(enum pn_pipe_error code)
{
	switch (code) {
	case PN_PIPE_ERR_NO_ERROR:
		return 0;
	case PN_PIPE_ERR_INVALID_PARAM:
		return -EINVAL;
	case PN_PIPE_ERR_INVALID_HANDLE:
		return -EBADF;
	case PN_PIPE_ERR_INVALID_CTRL_ID:
		return -ENOTSUP;
	case PN_PIPE_ERR_NOT_ALLOWED:
		return -EPERM;
	case PN_PIPE_ERR_PEP_IN_USE:
		return -EBUSY;
	case PN_PIPE_ERR_OVERLOAD:
		return -ENOBUFS;
	case PN_PIPE_ERR_DEV_DISCONNECTED:
		return -ENETDOWN;
	case PN_PIPE_ERR_TIMEOUT:
		return -ETIMEDOUT;
	case PN_PIPE_ERR_ALL_PIPES_IN_USE:
		return -ENFILE;
	case PN_PIPE_ERR_GENERAL:
		return -EAGAIN;
	case PN_PIPE_ERR_NOT_SUPPORTED:
		return -ENOSYS;
	}
	return -EBADMSG;
}

static void g_isi_pipe_handle_error(GIsiPipe *pipe, uint8_t code)
{
	int err = g_isi_pipe_error(code);

	if (err == 0)
		return;

	pipe->error = err;

	if (pipe->error_handler)
		pipe->error_handler(pipe);
}

static void g_isi_pipe_created(const GIsiMessage *msg, void *data)
{
	struct isi_pipe_resp *resp;
	size_t len = sizeof(struct isi_pipe_resp);
	GIsiPipe *pipe = data;

	if (g_isi_msg_error(msg) < 0) {
		g_isi_pipe_handle_error(pipe, PN_PIPE_ERR_TIMEOUT);
		return;
	}

	if (g_isi_msg_id(msg) != PNS_PIPE_CREATE_RESP)
		return;

	if (!g_isi_msg_data_get_struct(msg, 0, (const void **) &resp, len))
		return;

	if (resp->pipe_handle == PN_PIPE_INVALID_HANDLE) {
		g_isi_pipe_handle_error(pipe, resp->error_code);
		return;
	}

	pipe->handle = resp->pipe_handle;

	if (pipe->enabling)
		g_isi_pipe_start(pipe);

	if (pipe->handler)
		pipe->handler(pipe);
}

/**
 * Create a Phonet pipe in disabled state and with low priority.
 * @param modem ISI modem to create a pipe with
 * @param created optional callback for created event
 * @param obj1 Object handle of the first end point
 * @param obj2 Object handle of the second end point
 * @param type1 Type of the first end point
 * @param type2 Type of the second end point
 * @return a pipe object on success, NULL on error.
 */
GIsiPipe *g_isi_pipe_create(GIsiModem *modem, GIsiPipeHandler cb, uint16_t obj1,
				uint16_t obj2, uint8_t type1, uint8_t type2)
{
	struct isi_pipe_create_req msg = {
		.cmd = PNS_PIPE_CREATE_REQ,
		.state_after = PN_PIPE_DISABLE,
		.priority = PN_MSG_PRIORITY_LOW,
		.device1 = obj1 >> 8,
		.object1 = obj1 & 0xff,
		.type1 = type1,
		.device2 = obj2 >> 8,
		.object2 = obj2 & 0xff,
		.type2 = type2,
		.n_sb = 0,
	};
	size_t len = sizeof(msg);
	GIsiPipe *pipe;

	pipe = g_try_new0(GIsiPipe, 1);
	if (pipe == NULL) {
		errno = ENOMEM;
		return NULL;
	}

	pipe->client = g_isi_client_create(modem, PN_PIPE);
	if (pipe->client == NULL) {
		errno = ENOMEM;
		g_free(pipe);
		return NULL;
	}

	pipe->handler = cb;
	pipe->error_handler = NULL;
	pipe->error = 0;
	pipe->enabling = FALSE;
	pipe->enabled = FALSE;
	pipe->handle = PN_PIPE_INVALID_HANDLE;

	if (g_isi_client_send(pipe->client, &msg, len,
					g_isi_pipe_created, pipe, NULL))
		return pipe;

	g_isi_client_destroy(pipe->client);
	g_free(pipe);

	return NULL;
}

static void g_isi_pipe_enabled(const GIsiMessage *msg, void *data)
{
	GIsiPipe *pipe = data;
	const struct isi_pipe_resp *resp;
	size_t len = sizeof(struct isi_pipe_resp);

	if (g_isi_msg_error(msg) < 0) {
		g_isi_pipe_handle_error(pipe, PN_PIPE_ERR_TIMEOUT);
		return;
	}

	if (g_isi_msg_id(msg) != PNS_PIPE_ENABLE_RESP)
		return;

	if (!g_isi_msg_data_get_struct(msg, 0, (const void **) &resp, len))
		return;

	if (pipe->handle != resp->pipe_handle)
		return;

	g_isi_pipe_handle_error(pipe, resp->error_code);

	pipe->enabling = FALSE;

	if (!pipe->error)
		pipe->enabled = TRUE;
}

static void g_isi_pipe_enable(GIsiPipe *pipe)
{
	struct isi_pipe_enable_req msg = {
		.cmd = PNS_PIPE_ENABLE_REQ,
		.pipe_handle = pipe->handle,
	};
	size_t len = sizeof(msg);

	g_isi_client_send(pipe->client, &msg, len,
				g_isi_pipe_enabled, pipe, NULL);
}

/**
 * Enable a pipe, i.e. turn on data transfer between the two end points.
 * @param pipe pipe as returned from g_isi_pipe_create()
 * @return 0 on success or an error code
 */
int g_isi_pipe_start(GIsiPipe *pipe)
{
	if (pipe->error)
		return pipe->error;

	if (pipe->enabling || pipe->enabled)
		return 0;

	if (pipe->handle != PN_PIPE_INVALID_HANDLE)
		g_isi_pipe_enable(pipe);
	else
		pipe->enabling = TRUE;

	return 0;
}

/* Not very useful, it will never have time to trigger */
static void g_isi_pipe_removed(const GIsiMessage *msg, void *data)
{
	GIsiPipe *pipe = data;
	struct isi_pipe_resp *resp;
	size_t len = sizeof(struct isi_pipe_resp);

	if (g_isi_msg_error(msg) < 0) {
		g_isi_pipe_handle_error(pipe, PN_PIPE_ERR_TIMEOUT);
		return;
	}

	if (g_isi_msg_id(msg) != PNS_PIPE_REMOVE_RESP)
		return;

	if (!g_isi_msg_data_get_struct(msg, 0, (const void **) &resp, len))
		return;

	if (pipe->handle != resp->pipe_handle)
		return;

	pipe->handle = PN_PIPE_INVALID_HANDLE;
	pipe->error = -EPIPE;
}


static void g_isi_pipe_remove(GIsiPipe *pipe)
{
	struct isi_pipe_remove_req msg = {
		.cmd = PNS_PIPE_REMOVE_REQ,
		.pipe_handle = pipe->handle,
	};
	size_t len = sizeof(msg);

	g_isi_client_send(pipe->client, &msg, len,
				g_isi_pipe_removed, pipe, NULL);
}

/**
 * Destroy a pipe. If it was connected, it is removed.
 * @param pipe pipe as returned from g_isi_pipe_create()
 */
void g_isi_pipe_destroy(GIsiPipe *pipe)
{
	if (!pipe->error)
		g_isi_pipe_remove(pipe);

	g_isi_client_destroy(pipe->client);
	g_free(pipe);
}

void g_isi_pipe_set_error_handler(GIsiPipe *pipe, GIsiPipeErrorHandler cb)
{
	pipe->error_handler = cb;
}

int g_isi_pipe_get_error(const GIsiPipe *pipe)
{
	return pipe->error;
}

void *g_isi_pipe_set_userdata(GIsiPipe *pipe, void *opaque)
{
	void *old = pipe->opaque;

	pipe->opaque = opaque;
	return old;
}

void *g_isi_pipe_get_userdata(GIsiPipe *pipe)
{
	return pipe->opaque;
}

/**
 * Return a pipe handle.
 * @param pipe a ready-made pipe with handler data present. Available
 * after the pipe creation callback is called.
 * @return uint8_t handle.
 */

uint8_t g_isi_pipe_get_handle(GIsiPipe *pipe)
{
	return pipe->handle;
}