proxy.c revision 71812b42755cf65c694873ac66bcaa6bf3c817ca 
1/*
2 *
3 *  BlueZ - Bluetooth protocol stack for Linux
4 *
5 *  Copyright (C) 2004-2008  Marcel Holtmann <marcel@holtmann.org>
6 *
7 *
8 *  This program is free software; you can redistribute it and/or modify
9 *  it under the terms of the GNU General Public License as published by
10 *  the Free Software Foundation; either version 2 of the License, or
11 *  (at your option) any later version.
12 *
13 *  This program is distributed in the hope that it will be useful,
14 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *  GNU General Public License for more details.
17 *
18 *  You should have received a copy of the GNU General Public License
19 *  along with this program; if not, write to the Free Software
20 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
21 *
22 */
23
24#ifdef HAVE_CONFIG_H
25#include <config.h>
26#endif
27
28#include <ctype.h>
29#include <dirent.h>
30#include <errno.h>
31#include <fcntl.h>
32#include <stdio.h>
33#include <stdlib.h>
34#include <string.h>
35#include <termios.h>
36#include <unistd.h>
37#include <arpa/inet.h>
38#include <sys/param.h>
39#include <sys/ioctl.h>
40#include <sys/stat.h>
41#include <sys/types.h>
42#include <sys/un.h>
43
44#include <bluetooth/bluetooth.h>
45#include <bluetooth/hci.h>
46#include <bluetooth/hci_lib.h>
47#include <bluetooth/sdp.h>
48#include <bluetooth/sdp_lib.h>
49#include <bluetooth/rfcomm.h>
50
51#include <glib.h>
52#include <gdbus.h>
53
54#include "../src/dbus-common.h"
55
56#include "logging.h"
57#include "textfile.h"
58
59#include "error.h"
60#include "storage.h"
61#include "sdpd.h"
62#include "glib-helper.h"
63
64#define SERIAL_PORT_NAME	"spp"
65#define SERIAL_PORT_UUID	"00001101-0000-1000-8000-00805F9B34FB"
66
67#define DIALUP_NET_NAME		"dun"
68#define DIALUP_NET_UUID		"00001103-0000-1000-8000-00805F9B34FB"
69
70#define SERIAL_PROXY_INTERFACE	"org.bluez.SerialProxy"
71#define SERIAL_MANAGER_INTERFACE "org.bluez.SerialProxyManager"
72#define BUF_SIZE		1024
73
74typedef enum {
75	TTY_PROXY,
76	UNIX_SOCKET_PROXY,
77	TCP_SOCKET_PROXY,
78	UNKNOWN_PROXY_TYPE = 0xFF
79} proxy_type_t;
80
81struct serial_adapter {
82	bdaddr_t	src;		/* Adapter address */
83	char		*path;		/* D-Bus path */
84	DBusConnection	*conn;		/* Adapter connection */
85	GSList		*proxies;	/* Proxies list */
86};
87
88struct serial_proxy {
89	bdaddr_t	dst;		/* Remote address */
90	char		*path;		/* Proxy path */
91	char		*uuid128;	/* UUID 128 */
92	char		*address;	/* TTY or Unix socket name */
93	short int	port;		/* TCP port */
94	proxy_type_t	type;		/* TTY or Unix socket */
95	struct termios  sys_ti;		/* Default TTY setting */
96	struct termios  proxy_ti;	/* Proxy TTY settings */
97	uint8_t		channel;	/* RFCOMM channel */
98	uint32_t	record_id;	/* Service record id */
99	GIOChannel	*io;		/* Server listen */
100	guint		rfcomm_watch;	/* RFCOMM watch: Remote */
101	guint		local_watch;	/* Local watch: TTY or Unix socket */
102	struct serial_adapter *adapter;	/* Adapter pointer */
103};
104
105static GSList *adapters = NULL;
106static int sk_counter = 0;
107
108static void disable_proxy(struct serial_proxy *prx)
109{
110	if (prx->rfcomm_watch) {
111		g_source_remove(prx->rfcomm_watch);
112		prx->rfcomm_watch = 0;
113	}
114
115	if (prx->local_watch) {
116		g_source_remove(prx->local_watch);
117		prx->local_watch = 0;
118	}
119
120	remove_record_from_server(prx->record_id);
121	prx->record_id = 0;
122
123	g_io_channel_unref(prx->io);
124	prx->io = NULL;
125}
126
127static void proxy_free(struct serial_proxy *prx)
128{
129	g_free(prx->path);
130	g_free(prx->address);
131	g_free(prx->uuid128);
132	g_free(prx);
133}
134
135static inline DBusMessage *does_not_exist(DBusMessage *msg,
136					const char *description)
137{
138	return g_dbus_create_error(msg, ERROR_INTERFACE ".DoesNotExist",
139				description);
140}
141
142static inline DBusMessage *invalid_arguments(DBusMessage *msg,
143					const char *description)
144{
145	return g_dbus_create_error(msg, ERROR_INTERFACE ".InvalidArguments",
146				description);
147}
148
149static inline DBusMessage *failed(DBusMessage *msg, const char *description)
150{
151	return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
152				description);
153}
154
155static void add_lang_attr(sdp_record_t *r)
156{
157	sdp_lang_attr_t base_lang;
158	sdp_list_t *langs = 0;
159
160	/* UTF-8 MIBenum (http://www.iana.org/assignments/character-sets) */
161	base_lang.code_ISO639 = (0x65 << 8) | 0x6e;
162	base_lang.encoding = 106;
163	base_lang.base_offset = SDP_PRIMARY_LANG_BASE;
164	langs = sdp_list_append(0, &base_lang);
165	sdp_set_lang_attr(r, langs);
166	sdp_list_free(langs, 0);
167}
168
169static sdp_record_t *proxy_record_new(const char *uuid128, uint8_t channel)
170{
171	sdp_list_t *apseq, *aproto, *profiles, *proto[2], *root, *svclass_id;
172	uuid_t uuid, root_uuid, l2cap, rfcomm;
173	sdp_profile_desc_t profile;
174	sdp_record_t *record;
175	sdp_data_t *ch;
176
177	record = sdp_record_alloc();
178	if (!record)
179		return NULL;
180
181	sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
182	root = sdp_list_append(NULL, &root_uuid);
183	sdp_set_browse_groups(record, root);
184	sdp_list_free(root, NULL);
185
186	bt_string2uuid(&uuid, uuid128);
187	svclass_id = sdp_list_append(NULL, &uuid);
188	sdp_set_service_classes(record, svclass_id);
189	sdp_list_free(svclass_id, NULL);
190
191	sdp_uuid16_create(&profile.uuid, SERIAL_PORT_PROFILE_ID);
192	profile.version = 0x0100;
193	profiles = sdp_list_append(NULL, &profile);
194	sdp_set_profile_descs(record, profiles);
195	sdp_list_free(profiles, NULL);
196
197	sdp_uuid16_create(&l2cap, L2CAP_UUID);
198	proto[0] = sdp_list_append(NULL, &l2cap);
199	apseq = sdp_list_append(NULL, proto[0]);
200
201	sdp_uuid16_create(&rfcomm, RFCOMM_UUID);
202	proto[1] = sdp_list_append(NULL, &rfcomm);
203	ch = sdp_data_alloc(SDP_UINT8, &channel);
204	proto[1] = sdp_list_append(proto[1], ch);
205	apseq = sdp_list_append(apseq, proto[1]);
206
207	aproto = sdp_list_append(NULL, apseq);
208	sdp_set_access_protos(record, aproto);
209
210	add_lang_attr(record);
211
212	sdp_set_info_attr(record, "Port Proxy Entity",
213				NULL, "Port Proxy Entity");
214
215	sdp_data_free(ch);
216	sdp_list_free(proto[0], NULL);
217	sdp_list_free(proto[1], NULL);
218	sdp_list_free(apseq, NULL);
219	sdp_list_free(aproto, NULL);
220
221	return record;
222}
223
224static GIOError channel_write(GIOChannel *chan, char *buf, size_t size)
225{
226	GIOError err = G_IO_ERROR_NONE;
227	gsize wbytes, written;
228
229	wbytes = written = 0;
230	while (wbytes < size) {
231		err = g_io_channel_write(chan,
232				buf + wbytes,
233				size - wbytes,
234				&written);
235
236		if (err != G_IO_ERROR_NONE)
237			return err;
238
239		wbytes += written;
240	}
241
242	return err;
243}
244
245static gboolean forward_data(GIOChannel *chan, GIOCondition cond, gpointer data)
246{
247	char buf[BUF_SIZE];
248	GIOChannel *dest = data;
249	GIOError err;
250	size_t rbytes;
251
252	if (cond & G_IO_NVAL)
253		return FALSE;
254
255	if (cond & (G_IO_HUP | G_IO_ERR)) {
256		/* Try forward remaining data */
257		do {
258			rbytes = 0;
259			err = g_io_channel_read(chan, buf, sizeof(buf), &rbytes);
260			if (err != G_IO_ERROR_NONE || rbytes == 0)
261				break;
262
263			err = channel_write(dest, buf, rbytes);
264		} while (err == G_IO_ERROR_NONE);
265
266		g_io_channel_close(dest);
267		return FALSE;
268	}
269
270	rbytes = 0;
271	err = g_io_channel_read(chan, buf, sizeof(buf), &rbytes);
272	if (err != G_IO_ERROR_NONE)
273		return FALSE;
274
275	err = channel_write(dest, buf, rbytes);
276	if (err != G_IO_ERROR_NONE)
277		return FALSE;
278
279	return TRUE;
280}
281
282static inline int unix_socket_connect(const char *address)
283{
284	struct sockaddr_un addr;
285	int err, sk;
286
287	memset(&addr, 0, sizeof(addr));
288	addr.sun_family = PF_UNIX;
289
290	if (strncmp("x00", address, 3) == 0) {
291		/*
292		 * Abstract namespace: first byte NULL, x00
293		 * must be removed from the original address.
294		 */
295		strcpy(addr.sun_path + 1, address + 3);
296	} else {
297		/* Filesystem address */
298		strcpy(addr.sun_path, address);
299	}
300
301	/* Unix socket */
302	sk = socket(AF_UNIX, SOCK_STREAM, 0);
303	if (sk < 0) {
304		err = errno;
305		error("Unix socket(%s) create failed: %s(%d)",
306				address, strerror(err), err);
307		return -err;
308	}
309
310	if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
311		err = errno;
312		error("Unix socket(%s) connect failed: %s(%d)",
313				address, strerror(err), err);
314		close(sk);
315		errno = err;
316		return -err;
317	}
318
319	return sk;
320}
321
322static int tcp_socket_connect(const char *address)
323{
324	struct sockaddr_in addr;
325	int err, sk;
326	unsigned short int port;
327
328	memset(&addr, 0, sizeof(addr));
329
330	if (strncmp(address, "localhost", 9) != 0) {
331		error("Address should have the form localhost:port.");
332		return -1;
333	}
334	port = atoi(strchr(address, ':') + 1);
335	if (port <= 0) {
336		error("Invalid port '%d'.", port);
337		return -1;
338	}
339	addr.sin_family = AF_INET;
340	addr.sin_addr.s_addr = inet_addr("127.0.0.1");
341	addr.sin_port = htons(port);
342
343	sk = socket(PF_INET, SOCK_STREAM, 0);
344	if (sk < 0) {
345		err = errno;
346		error("TCP socket(%s) create failed %s(%d)", address,
347							strerror(err), err);
348		return -err;
349	}
350	if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
351		err = errno;
352		error("TCP socket(%s) connect failed: %s(%d)",
353						address, strerror(err), err);
354		close(sk);
355		errno = err;
356		return -err;
357	}
358	return sk;
359}
360
361static inline int tty_open(const char *tty, struct termios *ti)
362{
363	int err, sk;
364
365	sk = open(tty, O_RDWR | O_NOCTTY);
366	if (sk < 0) {
367		err = errno;
368		error("Can't open TTY %s: %s(%d)", tty, strerror(err), err);
369		return -err;
370	}
371
372	if (ti && tcsetattr(sk, TCSANOW, ti) < 0) {
373		err = errno;
374		error("Can't change serial settings: %s(%d)",
375				strerror(err), err);
376		close(sk);
377		errno = err;
378		return -err;
379	}
380
381	return sk;
382}
383
384static void connect_event_cb(GIOChannel *chan, int err, const bdaddr_t *src,
385				const bdaddr_t *dst, gpointer data)
386{
387	struct serial_proxy *prx = data;
388	GIOChannel *io;
389	int sk;
390
391	if (err < 0) {
392		error("accept: %s (%d)", strerror(-err), -err);
393		return;
394	}
395
396	bacpy(&prx->dst, dst);
397
398	switch (prx->type) {
399	case UNIX_SOCKET_PROXY:
400		sk = unix_socket_connect(prx->address);
401		break;
402	case TTY_PROXY:
403		sk = tty_open(prx->address, &prx->proxy_ti);
404		break;
405	case TCP_SOCKET_PROXY:
406		sk = tcp_socket_connect(prx->address);
407		break;
408	default:
409		sk = -1;
410	}
411
412	if (sk < 0) {
413		g_io_channel_unref(chan);
414		return;
415	}
416
417	g_io_channel_set_close_on_unref(chan, TRUE);
418	io = g_io_channel_unix_new(sk);
419	g_io_channel_set_close_on_unref(io, TRUE);
420
421	prx->rfcomm_watch = g_io_add_watch(chan,
422				G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
423				forward_data, io);
424
425	prx->local_watch = g_io_add_watch(io,
426				G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
427				forward_data, chan);
428
429	g_io_channel_unref(chan);
430	g_io_channel_unref(io);
431
432	return;
433}
434
435static DBusMessage *proxy_enable(DBusConnection *conn,
436				DBusMessage *msg, void *data)
437{
438	struct serial_proxy *prx = data;
439	struct serial_adapter *adapter = prx->adapter;
440	sdp_record_t *record;
441
442	if (prx->io)
443		return failed(msg, "Already enabled");
444
445	/* Listen */
446	prx->io = bt_rfcomm_listen_allocate(&adapter->src, &prx->channel, 0,
447				connect_event_cb, prx);
448	if (!prx->io) {
449		const char *strerr = strerror(errno);
450		error("RFCOMM listen socket failed: %s(%d)", strerr, errno);
451		return failed(msg, strerr);
452	}
453
454	g_io_channel_set_close_on_unref(prx->io, TRUE);
455
456	record = proxy_record_new(prx->uuid128, prx->channel);
457	if (!record) {
458		g_io_channel_unref(prx->io);
459		return failed(msg, "Unable to allocate new service record");
460	}
461
462	if (add_record_to_server(&adapter->src, record) < 0) {
463		sdp_record_free(record);
464		g_io_channel_unref(prx->io);
465		return failed(msg, "Service registration failed");
466	}
467
468	prx->record_id = record->handle;
469
470	return dbus_message_new_method_return(msg);
471}
472
473static DBusMessage *proxy_disable(DBusConnection *conn,
474				DBusMessage *msg, void *data)
475{
476	struct serial_proxy *prx = data;
477
478	if (!prx->io)
479		return failed(msg, "Not enabled");
480
481	/* Remove the watches and unregister the record */
482	disable_proxy(prx);
483
484	return dbus_message_new_method_return(msg);
485}
486
487static DBusMessage *proxy_get_info(DBusConnection *conn,
488				DBusMessage *msg, void *data)
489{
490	struct serial_proxy *prx = data;
491	DBusMessage *reply;
492	DBusMessageIter iter, dict;
493	dbus_bool_t boolean;
494
495	reply = dbus_message_new_method_return(msg);
496	if (!reply)
497		return NULL;
498
499	dbus_message_iter_init_append(reply, &iter);
500
501	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
502			DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
503			DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
504			DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
505
506	dbus_message_iter_append_dict_entry(&dict, "uuid",
507			DBUS_TYPE_STRING, &prx->uuid128);
508
509	dbus_message_iter_append_dict_entry(&dict, "address",
510			DBUS_TYPE_STRING, &prx->address);
511
512	if (prx->channel)
513		dbus_message_iter_append_dict_entry(&dict, "channel",
514				DBUS_TYPE_BYTE, &prx->channel);
515
516	boolean = (prx->io ? TRUE : FALSE);
517	dbus_message_iter_append_dict_entry(&dict, "enabled",
518			DBUS_TYPE_BOOLEAN, &boolean);
519
520	boolean = (prx->rfcomm_watch ? TRUE : FALSE);
521	dbus_message_iter_append_dict_entry(&dict, "connected",
522			DBUS_TYPE_BOOLEAN, &boolean);
523
524	/* If connected: append the remote address */
525	if (boolean) {
526		char bda[18];
527		const char *pstr = bda;
528
529		ba2str(&prx->dst, bda);
530		dbus_message_iter_append_dict_entry(&dict, "address",
531				DBUS_TYPE_STRING, &pstr);
532	}
533
534	dbus_message_iter_close_container(&iter, &dict);
535
536	return reply;
537}
538
539static struct {
540	const char	*str;
541	speed_t		speed;
542} supported_speed[]  = {
543	{"50",		B50	},
544	{"300",		B300	},
545	{"600",		B600	},
546	{"1200",	B1200	},
547	{"1800",	B1800	},
548	{"2400",	B2400	},
549	{"4800",	B4800	},
550	{"9600",	B9600	},
551	{"19200",	B19200	},
552	{"38400",	B38400	},
553	{"57600",	B57600	},
554	{"115200",	B115200	},
555	{ NULL,		B0	}
556};
557
558static speed_t str2speed(const char *str, speed_t *speed)
559{
560	int i;
561
562	for (i = 0; supported_speed[i].str; i++) {
563		if (strcmp(supported_speed[i].str, str) != 0)
564			continue;
565
566		if (speed)
567			*speed = supported_speed[i].speed;
568
569		return supported_speed[i].speed;
570	}
571
572	return B0;
573}
574
575static int set_parity(const char *str, tcflag_t *ctrl)
576{
577	if (strcasecmp("even", str) == 0) {
578		*ctrl |= PARENB;
579		*ctrl &= ~PARODD;
580	} else if (strcasecmp("odd", str) == 0) {
581		*ctrl |= PARENB;
582		*ctrl |= PARODD;
583	} else if (strcasecmp("mark", str) == 0)
584		*ctrl |= PARENB;
585	else if ((strcasecmp("none", str) == 0) ||
586			(strcasecmp("space", str) == 0))
587		*ctrl &= ~PARENB;
588	else
589		return -1;
590
591	return 0;
592}
593
594static int set_databits(uint8_t databits, tcflag_t *ctrl)
595{
596	if (databits < 5 || databits > 8)
597		return -EINVAL;
598
599	*ctrl &= ~CSIZE;
600	switch (databits) {
601	case 5:
602		*ctrl |= CS5;
603		break;
604	case 6:
605		*ctrl |= CS6;
606		break;
607	case 7:
608		*ctrl |= CS7;
609		break;
610	case 8:
611		*ctrl |= CS8;
612		break;
613	}
614
615	return 0;
616}
617
618static int set_stopbits(uint8_t stopbits, tcflag_t *ctrl)
619{
620	/* 1.5 will not be allowed */
621	switch (stopbits) {
622	case 1:
623		*ctrl &= ~CSTOPB;
624		return 0;
625	case 2:
626		*ctrl |= CSTOPB;
627		return 0;
628	}
629
630	return -EINVAL;
631}
632
633static DBusMessage *proxy_set_serial_params(DBusConnection *conn,
634						DBusMessage *msg, void *data)
635{
636	struct serial_proxy *prx = data;
637	struct serial_adapter *adapter = prx->adapter;
638	const char *ratestr, *paritystr;
639	uint8_t databits, stopbits;
640	tcflag_t ctrl;		/* Control mode flags */
641	speed_t speed = B0;	/* In/Out speed */
642
643	/* Don't allow change TTY settings if it is open */
644	if (prx->local_watch)
645		return failed(msg, "Not allowed");
646
647	if (!dbus_message_get_args(msg, NULL,
648				DBUS_TYPE_STRING, &ratestr,
649				DBUS_TYPE_BYTE, &databits,
650				DBUS_TYPE_BYTE, &stopbits,
651				DBUS_TYPE_STRING, &paritystr,
652				DBUS_TYPE_INVALID))
653		return NULL;
654
655	if (str2speed(ratestr, &speed)  == B0)
656		return invalid_arguments(msg, "Invalid baud rate");
657
658	ctrl = prx->proxy_ti.c_cflag;
659	if (set_databits(databits, &ctrl) < 0)
660		return invalid_arguments(msg, "Invalid data bits");
661
662	if (set_stopbits(stopbits, &ctrl) < 0)
663		return invalid_arguments(msg, "Invalid stop bits");
664
665	if (set_parity(paritystr, &ctrl) < 0)
666		return invalid_arguments(msg, "Invalid parity");
667
668	prx->proxy_ti.c_cflag = ctrl;
669	prx->proxy_ti.c_cflag |= (CLOCAL | CREAD);
670	cfsetispeed(&prx->proxy_ti, speed);
671	cfsetospeed(&prx->proxy_ti, speed);
672
673	proxy_store(&adapter->src, prx->uuid128, prx->address, NULL,
674				prx->channel, 0, &prx->proxy_ti);
675
676	return dbus_message_new_method_return(msg);
677}
678
679static GDBusMethodTable proxy_methods[] = {
680	{ "Enable",			"",	"",	proxy_enable },
681	{ "Disable",			"",	"",	proxy_disable },
682	{ "GetInfo",			"",	"a{sv}",proxy_get_info },
683	{ "SetSerialParameters",	"syys",	"",	proxy_set_serial_params },
684	{ },
685};
686
687static void proxy_path_unregister(gpointer data)
688{
689	struct serial_proxy *prx = data;
690	int sk;
691
692	info("Unregistered proxy: %s", prx->address);
693
694	if (prx->type != TTY_PROXY)
695		goto done;
696
697	/* Restore the initial TTY configuration */
698	sk =  open(prx->address, O_RDWR | O_NOCTTY);
699	if (sk) {
700		tcsetattr(sk, TCSAFLUSH, &prx->sys_ti);
701		close(sk);
702	}
703done:
704
705	proxy_free(prx);
706}
707
708static int register_proxy_object(struct serial_proxy *prx, char *outpath, size_t size)
709{
710	struct serial_adapter *adapter = prx->adapter;
711	char path[MAX_PATH_LENGTH + 1];
712
713	snprintf(path, MAX_PATH_LENGTH, "%s/proxy%d",
714			adapter->path, sk_counter++);
715
716	if (!g_dbus_register_interface(adapter->conn, path,
717					SERIAL_PROXY_INTERFACE,
718					proxy_methods, NULL, NULL,
719					prx, proxy_path_unregister)) {
720		error("D-Bus failed to register %s path", path);
721		return -1;
722	}
723
724	prx->path = g_strdup(path);
725	adapter->proxies = g_slist_append(adapter->proxies, prx);
726
727	if (outpath)
728		strncpy(outpath, path, size);
729
730	info("Registered proxy: %s", path);
731
732	return 0;
733}
734
735static int proxy_tty_register(struct serial_adapter *adapter,
736				const char *uuid128, const char *address,
737				struct termios *ti, char *outpath, size_t size,
738				gboolean save)
739{
740	struct termios sys_ti;
741	struct serial_proxy *prx;
742	int sk, ret;
743
744	sk = open(address, O_RDONLY | O_NOCTTY);
745	if (sk < 0) {
746		error("Cant open TTY: %s(%d)", strerror(errno), errno);
747		return -EINVAL;
748	}
749
750	prx = g_new0(struct serial_proxy, 1);
751	prx->address = g_strdup(address);
752	prx->uuid128 = g_strdup(uuid128);
753	prx->type = TTY_PROXY;
754	prx->adapter = adapter;
755
756	/* Current TTY settings */
757	memset(&sys_ti, 0, sizeof(sys_ti));
758	tcgetattr(sk, &sys_ti);
759	memcpy(&prx->sys_ti, &sys_ti, sizeof(sys_ti));
760	close(sk);
761
762	if (!ti) {
763		/* Use current settings */
764		memcpy(&prx->proxy_ti, &sys_ti, sizeof(sys_ti));
765	} else {
766		/* New TTY settings: user provided */
767		memcpy(&prx->proxy_ti, ti, sizeof(*ti));
768	}
769
770	ret = register_proxy_object(prx, outpath, size);
771	if (ret < 0)
772		proxy_free(prx);
773
774	if (save)
775		proxy_store(&adapter->src, uuid128, address, NULL,
776			prx->channel, 0, &prx->proxy_ti);
777
778	return ret;
779}
780
781static int proxy_socket_register(struct serial_adapter *adapter,
782				const char *uuid128, const char *address,
783				char *outpath, size_t size, gboolean save)
784{
785	struct serial_proxy *prx;
786	int ret;
787
788	prx = g_new0(struct serial_proxy, 1);
789	prx->address = g_strdup(address);
790	prx->uuid128 = g_strdup(uuid128);
791	prx->type = UNIX_SOCKET_PROXY;
792	prx->adapter = adapter;
793
794	ret = register_proxy_object(prx, outpath, size);
795	if (ret < 0)
796		proxy_free(prx);
797
798	if (save)
799		proxy_store(&adapter->src, uuid128, address, NULL,
800				prx->channel, 0, NULL);
801
802	return ret;
803}
804
805static int proxy_tcp_register(struct serial_adapter *adapter,
806				const char *uuid128, const char *address,
807				char *outpath, size_t size, gboolean save)
808{
809	struct serial_proxy *prx;
810	int ret;
811
812	prx = g_new0(struct serial_proxy, 1);
813	prx->address = g_strdup(address);
814	prx->uuid128 = g_strdup(uuid128);
815	prx->type = TCP_SOCKET_PROXY;
816	prx->adapter = adapter;
817
818	ret = register_proxy_object(prx, outpath, size);
819	if (ret < 0)
820		proxy_free(prx);
821
822	if (save)
823		proxy_store(&adapter->src, uuid128, address, NULL,
824				prx->channel, 0, NULL);
825
826	return ret;
827}
828
829static proxy_type_t addr2type(const char *address)
830{
831	struct stat st;
832
833	if (stat(address, &st) < 0) {
834		/*
835		 * Unix socket: if the sun_path starts with null byte
836		 * it refers to abstract namespace. 'x00' will be used
837		 * to represent the null byte.
838		 */
839		if (strncmp("localhost:", address, 10) == 0)
840			return TCP_SOCKET_PROXY;
841		if (strncmp("x00", address, 3) != 0)
842			return UNKNOWN_PROXY_TYPE;
843		else
844			return UNIX_SOCKET_PROXY;
845	} else {
846		/* Filesystem: char device or unix socket */
847		if (S_ISCHR(st.st_mode) && strncmp("/dev/", address, 4) == 0)
848			return TTY_PROXY;
849		else if (S_ISSOCK(st.st_mode))
850			return UNIX_SOCKET_PROXY;
851		else
852			return UNKNOWN_PROXY_TYPE;
853	}
854}
855
856static int proxy_addrcmp(gconstpointer proxy, gconstpointer addr)
857{
858	const struct serial_proxy *prx = proxy;
859	const char *address = addr;
860
861	return strcmp(prx->address, address);
862}
863
864static int proxy_pathcmp(gconstpointer proxy, gconstpointer p)
865{
866	const struct serial_proxy *prx = proxy;
867	const char *path = p;
868
869	return strcmp(prx->path, path);
870}
871
872static DBusMessage *create_proxy(DBusConnection *conn,
873				DBusMessage *msg, void *data)
874{
875	struct serial_adapter *adapter = data;
876	char path[MAX_PATH_LENGTH + 1];
877	const char *uuid128, *address, *ppath = path;
878	DBusMessage *reply;
879	proxy_type_t type;
880	uuid_t uuid;
881	int ret;
882
883	if (!dbus_message_get_args(msg, NULL,
884				DBUS_TYPE_STRING, &uuid128,
885				DBUS_TYPE_STRING, &address,
886				DBUS_TYPE_INVALID))
887		return NULL;
888
889	if (bt_string2uuid(&uuid, uuid128) < 0)
890		return invalid_arguments(msg, "Invalid UUID");
891
892	type = addr2type(address);
893	if (type == UNKNOWN_PROXY_TYPE)
894		return invalid_arguments(msg, "Invalid address");
895
896	/* Only one proxy per address(TTY or unix socket) is allowed */
897	if (g_slist_find_custom(adapter->proxies, address, proxy_addrcmp))
898		return g_dbus_create_error(msg, ERROR_INTERFACE ".AlreadyExist",
899						"Proxy already exists");
900
901	reply = dbus_message_new_method_return(msg);
902	if (!reply)
903		return NULL;
904
905	switch (type) {
906	case UNIX_SOCKET_PROXY:
907		ret = proxy_socket_register(adapter, uuid128, address,
908						path, sizeof(path), TRUE);
909		break;
910	case TTY_PROXY:
911		ret = proxy_tty_register(adapter, uuid128, address,
912				NULL, path, sizeof(path), TRUE);
913		break;
914	case TCP_SOCKET_PROXY:
915		ret = proxy_tcp_register(adapter, uuid128, address,
916					path, sizeof(path), TRUE);
917		break;
918	default:
919		ret = -1;
920	}
921	if (ret < 0) {
922		dbus_message_unref(reply);
923		return failed(msg, "Create object path failed");
924	}
925
926	g_dbus_emit_signal(adapter->conn, adapter->path,
927			SERIAL_MANAGER_INTERFACE, "ProxyCreated",
928			DBUS_TYPE_STRING, &ppath,
929			DBUS_TYPE_INVALID);
930
931	dbus_message_append_args(reply,
932			DBUS_TYPE_STRING, &ppath,
933			DBUS_TYPE_INVALID);
934
935	return reply;
936}
937
938static DBusMessage *list_proxies(DBusConnection *conn,
939				DBusMessage *msg, void *data)
940{
941	struct serial_adapter *adapter = data;
942	const GSList *l;
943	DBusMessage *reply;
944	DBusMessageIter iter, iter_array;
945
946	reply = dbus_message_new_method_return(msg);
947	if (!reply)
948		return NULL;
949
950	dbus_message_iter_init_append(reply, &iter);
951	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
952			DBUS_TYPE_STRING_AS_STRING, &iter_array);
953
954	for (l = adapter->proxies; l; l = l->next) {
955		struct serial_proxy *prx = l->data;
956
957		dbus_message_iter_append_basic(&iter_array,
958				DBUS_TYPE_STRING, &prx->path);
959	}
960
961	dbus_message_iter_close_container(&iter, &iter_array);
962
963	return reply;
964}
965
966static DBusMessage *remove_proxy(DBusConnection *conn,
967				DBusMessage *msg, void *data)
968{
969	struct serial_adapter *adapter = data;
970	struct serial_proxy *prx;
971	const char *path;
972	GSList *l;
973
974	if (!dbus_message_get_args(msg, NULL,
975				DBUS_TYPE_STRING, &path,
976				DBUS_TYPE_INVALID))
977		return NULL;
978
979	l = g_slist_find_custom(adapter->proxies, path, proxy_pathcmp);
980	if (!l)
981		return does_not_exist(msg, "Invalid proxy path");
982
983	g_dbus_emit_signal(conn, adapter->path,
984			SERIAL_MANAGER_INTERFACE, "ProxyRemoved",
985			DBUS_TYPE_STRING, &path,
986			DBUS_TYPE_INVALID);
987
988	prx = l->data;
989	proxy_delete(&adapter->src, prx->address);
990	adapter->proxies = g_slist_remove(adapter->proxies, prx);
991
992	g_dbus_unregister_interface(conn, path, SERIAL_PROXY_INTERFACE);
993
994	return dbus_message_new_method_return(msg);
995}
996
997static void manager_path_unregister(void *data)
998{
999	struct serial_adapter *adapter = data;
1000	GSList *l;
1001
1002	/* Remove proxy objects */
1003	for (l = adapter->proxies; l; l = l->next) {
1004		struct serial_proxy *prx = l->data;
1005		char *path = g_strdup(prx->path);
1006
1007		g_dbus_unregister_interface(adapter->conn, path,
1008					SERIAL_PROXY_INTERFACE);
1009		g_free(path);
1010	}
1011
1012	if (adapter->conn)
1013		dbus_connection_unref(adapter->conn);
1014
1015	adapters = g_slist_remove(adapters, adapter);
1016	g_slist_free(adapter->proxies);
1017	g_free(adapter->path);
1018	g_free(adapter);
1019}
1020
1021static GDBusMethodTable manager_methods[] = {
1022	{ "CreateProxy",		"ss",	"s",	create_proxy },
1023	{ "ListProxies",		"",	"as",	list_proxies },
1024	{ "RemoveProxy",		"s",	"",	remove_proxy },
1025	{ },
1026};
1027
1028static GDBusSignalTable manager_signals[] = {
1029	{ "ProxyCreated",		"s"	},
1030	{ "ProxyRemoved",		"s"	},
1031	{ }
1032};
1033
1034static void parse_proxy(char *key, char *value, void *data)
1035{
1036	struct serial_adapter *adapter = data;
1037	char uuid128[MAX_LEN_UUID_STR], tmp[3];
1038	char *pvalue;
1039	proxy_type_t type;
1040	int ch, opts, pos;
1041	struct termios ti;
1042	uint8_t *pti;
1043
1044	memset(uuid128, 0, sizeof(uuid128));
1045	ch = opts = pos = 0;
1046	if (sscanf(value,"%s %d 0x%04X %n", uuid128, &ch, &opts, &pos) != 3)
1047		return;
1048
1049	/* Extracting name */
1050	value += pos;
1051	pvalue = strchr(value, ':');
1052	if (!pvalue)
1053		return;
1054
1055	/* FIXME: currently name is not used */
1056	*pvalue = '\0';
1057
1058	type = addr2type(key);
1059	switch (type) {
1060	case TTY_PROXY:
1061		/* Extracting termios */
1062		pvalue++;
1063		if (!pvalue || strlen(pvalue) != (2 * sizeof(ti)))
1064			return;
1065
1066		memset(&ti, 0, sizeof(ti));
1067		memset(tmp, 0, sizeof(tmp));
1068
1069		/* Converting to termios struct */
1070		pti = (uint8_t *) &ti;
1071		for (pos = 0; pos < sizeof(ti); pos++, pvalue += 2, pti++) {
1072			memcpy(tmp, pvalue, 2);
1073			*pti = (uint8_t) strtol(tmp, NULL, 16);
1074		}
1075
1076		proxy_tty_register(adapter, uuid128, key, &ti, NULL, 0, FALSE);
1077		break;
1078	case UNIX_SOCKET_PROXY:
1079		proxy_socket_register(adapter, uuid128, key, NULL, 0, FALSE);
1080		break;
1081	case TCP_SOCKET_PROXY:
1082		proxy_tcp_register(adapter, uuid128, key, NULL, 0, FALSE);
1083		break;
1084	default:
1085		return;
1086	}
1087}
1088
1089static void register_stored(struct serial_adapter *adapter)
1090{
1091	char filename[PATH_MAX + 1];
1092	char address[18];
1093
1094	ba2str(&adapter->src, address);
1095	snprintf(filename, PATH_MAX, "%s/%s/proxy", STORAGEDIR, address);
1096	textfile_foreach(filename, parse_proxy, adapter);
1097}
1098
1099static struct serial_adapter *find_adapter(GSList *list, const char *path)
1100{
1101	GSList *l;
1102
1103	for (l = list; l; l = l->next) {
1104		struct serial_adapter *adapter = l->data;
1105
1106		if (g_str_equal(adapter->path, path))
1107			return adapter;
1108	}
1109
1110	return NULL;
1111}
1112
1113int proxy_register(DBusConnection *conn, const char *path, bdaddr_t *src)
1114{
1115	struct serial_adapter *adapter;
1116
1117	adapter = find_adapter(adapters, path);
1118	if (adapter)
1119		return -EINVAL;
1120
1121	adapter = g_new0(struct serial_adapter, 1);
1122	adapter->conn = dbus_connection_ref(conn);
1123	bacpy(&adapter->src, src);
1124	adapter->path = g_strdup(path);
1125
1126	if (!g_dbus_register_interface(conn, path,
1127					SERIAL_MANAGER_INTERFACE,
1128					manager_methods, manager_signals, NULL,
1129					adapter, manager_path_unregister)) {
1130		error("Failed to register %s interface to %s",
1131				SERIAL_MANAGER_INTERFACE, path);
1132		return -1;
1133	}
1134
1135	register_stored(adapter);
1136
1137	adapters = g_slist_append(adapters, adapter);
1138
1139	info("Registered interface %s on path %s",
1140		SERIAL_MANAGER_INTERFACE, path);
1141
1142	return 0;
1143}
1144
1145void proxy_unregister(const char *path)
1146{
1147	struct serial_adapter *adapter;
1148
1149	adapter = find_adapter(adapters, path);
1150	if (!adapter)
1151		return;
1152
1153	g_dbus_unregister_interface(adapter->conn, path,
1154			SERIAL_MANAGER_INTERFACE);
1155}
1156