profiles/network/server.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2004-2010  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 <stdio.h>
  29 #include <unistd.h>
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #include <netinet/in.h>
  33
  34 #include <glib.h>
  35
  36 #include "lib/bluetooth.h"
  37 #include "lib/bnep.h"
  38 #include "lib/sdp.h"
  39 #include "lib/sdp_lib.h"
  40 #include "lib/uuid.h"
  41
  42 #include "gdbus/gdbus.h"
  43
  44 #include "btio/btio.h"
  45 #include "src/dbus-common.h"
  46 #include "src/adapter.h"
  47 #include "src/log.h"
  48 #include "src/error.h"
  49 #include "src/sdpd.h"
  50 #include "src/shared/util.h"
  51
  52 #include "bnep.h"
  53 #include "server.h"
  54
  55 #define NETWORK_SERVER_INTERFACE "org.bluez.NetworkServer1"
  56 #define BNEP_INTERFACE "bnep%d"
  57 #define SETUP_TIMEOUT           1
  58
  59 /* Pending Authorization */
  60 struct network_session {
  61         bdaddr_t        dst;            /* Remote Bluetooth Address */
  62         char            dev[16];        /* Interface name */
  63         GIOChannel      *io;            /* Pending connect channel */
  64         guint           watch;          /* BNEP socket watch */
  65 };
  66
  67 struct network_adapter {
  68         struct btd_adapter *adapter;    /* Adapter pointer */
  69         GIOChannel      *io;            /* Bnep socket */
  70         struct network_session *setup;  /* Setup in progress */
  71         GSList          *servers;       /* Server register to adapter */
  72 };
  73
  74 /* Main server structure */
  75 struct network_server {
  76         bdaddr_t        src;            /* Bluetooth Local Address */
  77         char            *name;          /* Server service name */
  78         char            *bridge;        /* Bridge name */
  79         uint32_t        record_id;      /* Service record id */
  80         uint16_t        id;             /* Service class identifier */
  81         GSList          *sessions;      /* Active connections */
  82         struct network_adapter *na;     /* Adapter reference */
  83         guint           watch_id;       /* Client service watch */
  84 };
  85
  86 static GSList *adapters = NULL;
  87 static gboolean security = TRUE;
  88
  89 #ifdef  TIZEN_FEATURE_BLUEZ_MODIFY
  90 static gboolean server_disconnected_cb(GIOChannel *chan,
  91                         GIOCondition cond, gpointer user_data);
  92 #endif
  93
  94 static struct network_adapter *find_adapter(GSList *list,
  95                                         struct btd_adapter *adapter)
  96 {
  97         for (; list; list = list->next) {
  98                 struct network_adapter *na = list->data;
  99
 100                 if (na->adapter == adapter)
 101                         return na;
 102         }
 103
 104         return NULL;
 105 }
 106
 107 static struct network_server *find_server(GSList *list, uint16_t id)
 108 {
 109         for (; list; list = list->next) {
 110                 struct network_server *ns = list->data;
 111
 112                 if (ns->id == id)
 113                         return ns;
 114         }
 115
 116         return NULL;
 117 }
 118
 119 static struct network_server *find_server_by_uuid(GSList *list,
 120                                                         const char *uuid)
 121 {
 122         bt_uuid_t srv_uuid, bnep_uuid;
 123
 124         if (!bt_string_to_uuid(&srv_uuid, uuid)) {
 125                 for (; list; list = list->next) {
 126                         struct network_server *ns = list->data;
 127
 128                         bt_uuid16_create(&bnep_uuid, ns->id);
 129
 130                         /* UUID value compare */
 131                         if (!bt_uuid_cmp(&srv_uuid, &bnep_uuid))
 132                                 return ns;
 133                 }
 134         } else {
 135                 for (; list; list = list->next) {
 136                         struct network_server *ns = list->data;
 137
 138                         /* String value compare */
 139                         switch (ns->id) {
 140                         case BNEP_SVC_PANU:
 141                                 if (!strcasecmp(uuid, "panu"))
 142                                         return ns;
 143                                 break;
 144                         case BNEP_SVC_NAP:
 145                                 if (!strcasecmp(uuid, "nap"))
 146                                         return ns;
 147                                 break;
 148                         case BNEP_SVC_GN:
 149                                 if (!strcasecmp(uuid, "gn"))
 150                                         return ns;
 151                                 break;
 152                         }
 153                 }
 154         }
 155
 156         return NULL;
 157 }
 158
 159 #ifdef  TIZEN_FEATURE_BLUEZ_MODIFY
 160 static struct network_session *find_session(GSList *list, GIOChannel *io)
 161 {
 162         GSList *l;
 163
 164         for (l = list; l; l = l->next) {
 165                 struct network_session *session = l->data;
 166
 167                 if (session && session->io == io)
 168                         return session;
 169         }
 170
 171         return NULL;
 172 }
 173
 174 static struct network_session *find_session_by_addr(GSList *list,
 175                                                                                                         bdaddr_t dst_addr)
 176 {
 177         GSList *l;
 178
 179         for (l = list; l; l = l->next) {
 180                 struct network_session *session = l->data;
 181
 182                 if (!bacmp(&session->dst, &dst_addr))
 183                         return session;
 184
 185         }
 186
 187         return NULL;
 188 }
 189 #endif
 190
 191 static sdp_record_t *server_record_new(const char *name, uint16_t id)
 192 {
 193         sdp_list_t *svclass, *pfseq, *apseq, *root, *aproto;
 194         uuid_t root_uuid, pan, l2cap, bnep;
 195         sdp_profile_desc_t profile[1];
 196         sdp_list_t *proto[2];
 197         sdp_data_t *v, *p;
 198         uint16_t psm = BNEP_PSM, version = 0x0100;
 199         uint16_t security_desc = (security ? 0x0001 : 0x0000);
 200 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 201         uint16_t net_access_type = 0x000a;
 202         uint32_t max_net_access_rate = 0x001312d0;
 203 #else
 204         uint16_t net_access_type = 0xfffe;
 205         uint32_t max_net_access_rate = 0;
 206 #endif
 207         const char *desc = "Network service";
 208         sdp_record_t *record;
 209
 210         record = sdp_record_alloc();
 211         if (!record)
 212                 return NULL;
 213
 214         record->attrlist = NULL;
 215         record->pattern = NULL;
 216
 217         switch (id) {
 218         case BNEP_SVC_NAP:
 219                 sdp_uuid16_create(&pan, NAP_SVCLASS_ID);
 220                 svclass = sdp_list_append(NULL, &pan);
 221                 sdp_set_service_classes(record, svclass);
 222
 223                 sdp_uuid16_create(&profile[0].uuid, NAP_PROFILE_ID);
 224                 profile[0].version = 0x0100;
 225                 pfseq = sdp_list_append(NULL, &profile[0]);
 226                 sdp_set_profile_descs(record, pfseq);
 227
 228                 sdp_set_info_attr(record, name, NULL, desc);
 229
 230                 sdp_attr_add_new(record, SDP_ATTR_NET_ACCESS_TYPE,
 231                                         SDP_UINT16, &net_access_type);
 232                 sdp_attr_add_new(record, SDP_ATTR_MAX_NET_ACCESSRATE,
 233                                         SDP_UINT32, &max_net_access_rate);
 234                 break;
 235         case BNEP_SVC_GN:
 236                 sdp_uuid16_create(&pan, GN_SVCLASS_ID);
 237                 svclass = sdp_list_append(NULL, &pan);
 238                 sdp_set_service_classes(record, svclass);
 239
 240                 sdp_uuid16_create(&profile[0].uuid, GN_PROFILE_ID);
 241                 profile[0].version = 0x0100;
 242                 pfseq = sdp_list_append(NULL, &profile[0]);
 243                 sdp_set_profile_descs(record, pfseq);
 244
 245                 sdp_set_info_attr(record, name, NULL, desc);
 246                 break;
 247         case BNEP_SVC_PANU:
 248                 sdp_uuid16_create(&pan, PANU_SVCLASS_ID);
 249                 svclass = sdp_list_append(NULL, &pan);
 250                 sdp_set_service_classes(record, svclass);
 251
 252                 sdp_uuid16_create(&profile[0].uuid, PANU_PROFILE_ID);
 253                 profile[0].version = 0x0100;
 254                 pfseq = sdp_list_append(NULL, &profile[0]);
 255                 sdp_set_profile_descs(record, pfseq);
 256
 257                 sdp_set_info_attr(record, name, NULL, desc);
 258                 break;
 259         default:
 260                 sdp_record_free(record);
 261                 return NULL;
 262         }
 263
 264         sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
 265         root = sdp_list_append(NULL, &root_uuid);
 266         sdp_set_browse_groups(record, root);
 267
 268         sdp_uuid16_create(&l2cap, L2CAP_UUID);
 269         proto[0] = sdp_list_append(NULL, &l2cap);
 270         p = sdp_data_alloc(SDP_UINT16, &psm);
 271         proto[0] = sdp_list_append(proto[0], p);
 272         apseq    = sdp_list_append(NULL, proto[0]);
 273
 274         sdp_uuid16_create(&bnep, BNEP_UUID);
 275         proto[1] = sdp_list_append(NULL, &bnep);
 276         v = sdp_data_alloc(SDP_UINT16, &version);
 277         proto[1] = sdp_list_append(proto[1], v);
 278
 279         /* Supported protocols */
 280         {
 281                 uint16_t ptype[] = {
 282                         0x0800,  /* IPv4 */
 283                         0x0806,  /* ARP */
 284                 };
 285                 sdp_data_t *head, *pseq;
 286                 int p;
 287
 288                 for (p = 0, head = NULL; p < 2; p++) {
 289                         sdp_data_t *data = sdp_data_alloc(SDP_UINT16, &ptype[p]);
 290                         if (head)
 291                                 sdp_seq_append(head, data);
 292                         else
 293                                 head = data;
 294                 }
 295                 pseq = sdp_data_alloc(SDP_SEQ16, head);
 296                 proto[1] = sdp_list_append(proto[1], pseq);
 297         }
 298
 299         apseq = sdp_list_append(apseq, proto[1]);
 300
 301         aproto = sdp_list_append(NULL, apseq);
 302         sdp_set_access_protos(record, aproto);
 303
 304         sdp_add_lang_attr(record);
 305
 306         sdp_attr_add_new(record, SDP_ATTR_SECURITY_DESC,
 307                                 SDP_UINT16, &security_desc);
 308
 309         sdp_data_free(p);
 310         sdp_data_free(v);
 311         sdp_list_free(apseq, NULL);
 312         sdp_list_free(root, NULL);
 313         sdp_list_free(aproto, NULL);
 314         sdp_list_free(proto[0], NULL);
 315         sdp_list_free(proto[1], NULL);
 316         sdp_list_free(svclass, NULL);
 317         sdp_list_free(pfseq, NULL);
 318
 319         return record;
 320 }
 321
 322 static void session_free(void *data)
 323 {
 324         struct network_session *session = data;
 325
 326         if (session->watch)
 327                 g_source_remove(session->watch);
 328
 329         if (session->io)
 330                 g_io_channel_unref(session->io);
 331
 332         g_free(session);
 333 }
 334
 335 static void setup_destroy(void *user_data)
 336 {
 337         struct network_adapter *na = user_data;
 338         struct network_session *setup = na->setup;
 339
 340         if (!setup)
 341                 return;
 342
 343         na->setup = NULL;
 344
 345         session_free(setup);
 346 }
 347
 348 #ifdef  TIZEN_FEATURE_BLUEZ_MODIFY
 349 static gboolean server_disconnected_cb(GIOChannel *chan,
 350                         GIOCondition cond, gpointer user_data)
 351 {
 352         struct network_server *ns = NULL;
 353         struct network_session *session = NULL;
 354         char address[20] = {0};
 355         const char* paddr = address;
 356         char *name_str = NULL;
 357
 358         info("server_disconnected_cb");
 359
 360         if (!user_data)
 361                 return FALSE;
 362
 363         ns = (struct network_server *) user_data;
 364
 365         session = find_session(ns->sessions, chan);
 366         if (session) {
 367                 name_str = g_strdup(session->dev);
 368                 ba2str(&session->dst, address);
 369         } else {
 370                 info("Session is not exist!");
 371                 name_str = g_strdup("bnep");
 372         }
 373
 374         g_dbus_emit_signal(btd_get_dbus_connection(),
 375                         adapter_get_path(ns->na->adapter),
 376                         NETWORK_SERVER_INTERFACE, "PeerDisconnected",
 377                         DBUS_TYPE_STRING, &name_str,
 378                         DBUS_TYPE_STRING, &paddr,
 379                         DBUS_TYPE_INVALID);
 380
 381         if (session) {
 382                 ns->sessions = g_slist_remove(ns->sessions, session);
 383                 session_free(session);
 384         }
 385
 386         if (g_slist_length(ns->sessions) == 0 &&
 387                 name_str != NULL) {
 388                 bnep_if_down_wrapper(name_str);
 389                 ns->sessions = NULL;
 390         }
 391
 392         g_free(name_str);
 393
 394         return FALSE;
 395 }
 396 #endif
 397
 398 static gboolean bnep_setup(GIOChannel *chan,
 399                         GIOCondition cond, gpointer user_data)
 400 {
 401         const uint8_t bt_base[] = { 0x00, 0x00, 0x10, 0x00, 0x80, 0x00,
 402                                         0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB };
 403         struct network_adapter *na = user_data;
 404         struct network_server *ns;
 405         uint8_t packet[BNEP_MTU];
 406         struct bnep_setup_conn_req *req = (void *) packet;
 407         uint16_t dst_role = 0;
 408         uint32_t val;
 409         int n, sk;
 410         char *bridge = NULL;
 411
 412         if (cond & G_IO_NVAL)
 413                 return FALSE;
 414
 415         if (cond & (G_IO_ERR | G_IO_HUP)) {
 416                 error("Hangup or error on BNEP socket");
 417                 return FALSE;
 418         }
 419
 420         sk = g_io_channel_unix_get_fd(chan);
 421
 422         /*
 423          * BNEP_SETUP_CONNECTION_REQUEST_MSG should be read and left in case
 424          * of kernel setup connection msg handling.
 425          */
 426         n = recv(sk, packet, sizeof(packet), MSG_PEEK);
 427         if (n < 0) {
 428                 error("read(): %s(%d)", strerror(errno), errno);
 429                 return FALSE;
 430         }
 431
 432         /*
 433          * Initial received data packet is BNEP_SETUP_CONNECTION_REQUEST_MSG
 434          * minimal size of this frame is 3 octets: 1 byte of BNEP Type +
 435          * 1 byte of BNEP Control Type + 1 byte of BNEP services UUID size.
 436          */
 437         if (n < 3) {
 438                 error("To few setup connection request data received");
 439                 return FALSE;
 440         }
 441
 442         switch (req->uuid_size) {
 443         case 2:
 444                 dst_role = get_be16(req->service);
 445                 break;
 446         case 16:
 447                 if (memcmp(&req->service[4], bt_base, sizeof(bt_base)) != 0)
 448                         break;
 449
 450                 /* Intentional no-brake */
 451
 452         case 4:
 453                 val = get_be32(req->service);
 454                 if (val > 0xffff)
 455                         break;
 456
 457                 dst_role = val;
 458                 break;
 459         default:
 460                 break;
 461         }
 462
 463         ns = find_server(na->servers, dst_role);
 464         if (!ns || !ns->record_id || !ns->bridge)
 465                 error("Server error, bridge not initialized: (0x%x)", dst_role);
 466         else
 467                 bridge = ns->bridge;
 468
 469         strncpy(na->setup->dev, BNEP_INTERFACE, 16);
 470         na->setup->dev[15] = '\0';
 471
 472         if (bnep_server_add(sk, bridge, na->setup->dev, &na->setup->dst,
 473                                                         packet, n) < 0)
 474                 error("BNEP server cannot be added");
 475
 476 #ifdef  TIZEN_FEATURE_BLUEZ_MODIFY
 477 if (ns) {
 478         /* Emit connected signal to BT application */
 479         const gchar *adapter_path = adapter_get_path(na->adapter);
 480         const char *pdev = na->setup->dev;
 481         char address[24] = { 0 };
 482         char *paddr = address;
 483
 484         ba2str(&na->setup->dst, paddr);
 485
 486         ns->sessions = g_slist_append(ns->sessions, na->setup);
 487
 488         g_dbus_emit_signal(btd_get_dbus_connection(), adapter_path,
 489                         NETWORK_SERVER_INTERFACE, "PeerConnected",
 490                         DBUS_TYPE_STRING, &pdev,
 491                         DBUS_TYPE_STRING, &paddr,
 492                         DBUS_TYPE_INVALID);
 493
 494         na->setup->watch = g_io_add_watch_full(chan, G_PRIORITY_DEFAULT,
 495                                         G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 496                                         server_disconnected_cb, ns, NULL);
 497 }
 498 #endif
 499
 500         na->setup = NULL;
 501
 502         return FALSE;
 503 }
 504
 505 static void connect_event(GIOChannel *chan, GError *err, gpointer user_data)
 506 {
 507         struct network_adapter *na = user_data;
 508
 509         if (err) {
 510                 error("%s", err->message);
 511                 setup_destroy(na);
 512                 return;
 513         }
 514
 515         g_io_channel_set_close_on_unref(chan, TRUE);
 516
 517         na->setup->watch = g_io_add_watch_full(chan, G_PRIORITY_DEFAULT,
 518                                 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 519                                 bnep_setup, na, setup_destroy);
 520 }
 521
 522 static void auth_cb(DBusError *derr, void *user_data)
 523 {
 524         struct network_adapter *na = user_data;
 525         GError *err = NULL;
 526
 527         if (derr) {
 528                 error("Access denied: %s", derr->message);
 529                 goto reject;
 530         }
 531
 532         if (!bt_io_accept(na->setup->io, connect_event, na, NULL,
 533                                                         &err)) {
 534                 error("bt_io_accept: %s", err->message);
 535                 g_error_free(err);
 536                 goto reject;
 537         }
 538
 539         return;
 540
 541 reject:
 542         g_io_channel_shutdown(na->setup->io, TRUE, NULL);
 543         setup_destroy(na);
 544 }
 545
 546 static void confirm_event(GIOChannel *chan, gpointer user_data)
 547 {
 548         struct network_adapter *na = user_data;
 549         struct network_server *ns;
 550         bdaddr_t src, dst;
 551         char address[18];
 552         GError *err = NULL;
 553         guint ret;
 554
 555         bt_io_get(chan, &err,
 556                         BT_IO_OPT_SOURCE_BDADDR, &src,
 557                         BT_IO_OPT_DEST_BDADDR, &dst,
 558                         BT_IO_OPT_DEST, address,
 559                         BT_IO_OPT_INVALID);
 560         if (err) {
 561                 error("%s", err->message);
 562                 g_error_free(err);
 563                 goto drop;
 564         }
 565
 566         DBG("BNEP: incoming connect from %s", address);
 567
 568         if (na->setup) {
 569                 error("Refusing connect from %s: setup in progress", address);
 570                 goto drop;
 571         }
 572
 573         ns = find_server(na->servers, BNEP_SVC_NAP);
 574         if (!ns || !ns->record_id || !ns->bridge)
 575                 goto drop;
 576
 577         na->setup = g_new0(struct network_session, 1);
 578         bacpy(&na->setup->dst, &dst);
 579         na->setup->io = g_io_channel_ref(chan);
 580
 581         ret = btd_request_authorization(&src, &dst, BNEP_SVC_UUID,
 582                                         auth_cb, na);
 583         if (ret == 0) {
 584                 error("Refusing connect from %s", address);
 585                 setup_destroy(na);
 586                 goto drop;
 587         }
 588
 589         return;
 590
 591 drop:
 592         g_io_channel_shutdown(chan, TRUE, NULL);
 593 }
 594
 595 int server_init(gboolean secure)
 596 {
 597         security = secure;
 598
 599         return 0;
 600 }
 601
 602 static uint32_t register_server_record(struct network_server *ns)
 603 {
 604         sdp_record_t *record;
 605
 606         record = server_record_new(ns->name, ns->id);
 607         if (!record) {
 608                 error("Unable to allocate new service record");
 609                 return 0;
 610         }
 611
 612         if (adapter_service_add(ns->na->adapter, record) < 0) {
 613                 error("Failed to register service record");
 614                 sdp_record_free(record);
 615                 return 0;
 616         }
 617
 618         DBG("got record id 0x%x", record->handle);
 619
 620         return record->handle;
 621 }
 622
 623 static void server_remove_sessions(struct network_server *ns)
 624 {
 625         GSList *list;
 626
 627         for (list = ns->sessions; list; list = list->next) {
 628                 struct network_session *session = list->data;
 629
 630                 if (*session->dev == '\0')
 631                         continue;
 632
 633                 bnep_server_delete(ns->bridge, session->dev, &session->dst);
 634         }
 635
 636 #ifndef TIZEN_FEATURE_BLUEZ_MODIFY
 637         g_slist_free_full(ns->sessions, session_free);
 638
 639         ns->sessions = NULL;
 640 #endif
 641 }
 642
 643 static void server_disconnect(DBusConnection *conn, void *user_data)
 644 {
 645         struct network_server *ns = user_data;
 646
 647         server_remove_sessions(ns);
 648
 649         ns->watch_id = 0;
 650
 651         if (ns->record_id) {
 652                 adapter_service_remove(ns->na->adapter, ns->record_id);
 653                 ns->record_id = 0;
 654         }
 655
 656         g_free(ns->bridge);
 657         ns->bridge = NULL;
 658 }
 659
 660 static DBusMessage *register_server(DBusConnection *conn,
 661                                 DBusMessage *msg, void *data)
 662 {
 663         struct network_adapter *na = data;
 664         struct network_server *ns;
 665         DBusMessage *reply;
 666         const char *uuid, *bridge;
 667
 668         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &uuid,
 669                                 DBUS_TYPE_STRING, &bridge, DBUS_TYPE_INVALID))
 670                 return btd_error_invalid_args(msg);
 671
 672         ns = find_server_by_uuid(na->servers, uuid);
 673         if (ns == NULL)
 674                 return btd_error_failed(msg, "Invalid UUID");
 675
 676         if (ns->record_id)
 677                 return btd_error_already_exists(msg);
 678
 679         reply = dbus_message_new_method_return(msg);
 680         if (!reply)
 681                 return NULL;
 682
 683         ns->record_id = register_server_record(ns);
 684         if (!ns->record_id)
 685                 return btd_error_failed(msg, "SDP record registration failed");
 686
 687         g_free(ns->bridge);
 688         ns->bridge = g_strdup(bridge);
 689
 690         ns->watch_id = g_dbus_add_disconnect_watch(conn,
 691                                         dbus_message_get_sender(msg),
 692                                         server_disconnect, ns, NULL);
 693
 694         return reply;
 695 }
 696
 697 static DBusMessage *unregister_server(DBusConnection *conn,
 698                                         DBusMessage *msg, void *data)
 699 {
 700         struct network_adapter *na = data;
 701         struct network_server *ns;
 702         DBusMessage *reply;
 703         const char *uuid;
 704
 705         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &uuid,
 706                                                         DBUS_TYPE_INVALID))
 707                 return btd_error_invalid_args(msg);
 708
 709         ns = find_server_by_uuid(na->servers, uuid);
 710         if (!ns)
 711                 return btd_error_failed(msg, "Invalid UUID");
 712
 713 #ifdef  TIZEN_FEATURE_BLUEZ_MODIFY
 714         if (!ns->record_id)
 715                 return btd_error_not_available(msg);
 716 #endif
 717
 718         reply = dbus_message_new_method_return(msg);
 719         if (!reply)
 720                 return NULL;
 721
 722         g_dbus_remove_watch(conn, ns->watch_id);
 723
 724         server_disconnect(conn, ns);
 725
 726         return reply;
 727 }
 728
 729 static void adapter_free(struct network_adapter *na)
 730 {
 731         if (na->io != NULL) {
 732                 g_io_channel_shutdown(na->io, TRUE, NULL);
 733                 g_io_channel_unref(na->io);
 734         }
 735
 736         setup_destroy(na);
 737         btd_adapter_unref(na->adapter);
 738         g_free(na);
 739 }
 740
 741 static void server_free(void *data)
 742 {
 743         struct network_server *ns = data;
 744
 745         if (!ns)
 746                 return;
 747
 748         server_remove_sessions(ns);
 749
 750         if (ns->record_id)
 751                 adapter_service_remove(ns->na->adapter, ns->record_id);
 752
 753         g_dbus_remove_watch(btd_get_dbus_connection(), ns->watch_id);
 754         g_free(ns->name);
 755         g_free(ns->bridge);
 756
 757         g_free(ns);
 758 }
 759
 760 static void path_unregister(void *data)
 761 {
 762         struct network_adapter *na = data;
 763
 764         DBG("Unregistered interface %s on path %s",
 765                 NETWORK_SERVER_INTERFACE, adapter_get_path(na->adapter));
 766
 767         g_slist_free_full(na->servers, server_free);
 768
 769         adapters = g_slist_remove(adapters, na);
 770         adapter_free(na);
 771 }
 772
 773 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 774 static DBusMessage *disconnect_device(DBusConnection *conn, DBusMessage *msg,
 775                                                                 void *data)
 776 {
 777         struct network_adapter *na = data;
 778         struct network_server *ns;
 779         struct network_session *session;
 780         const char *addr = NULL;
 781         bdaddr_t dst_addr;
 782
 783         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &addr,
 784                                                         DBUS_TYPE_INVALID))
 785                 return btd_error_invalid_args(msg);
 786
 787         ns = find_server(na->servers, BNEP_SVC_NAP);
 788
 789         str2ba(addr, &dst_addr);
 790         session = find_session_by_addr(ns->sessions, dst_addr);
 791
 792         if (session == NULL)
 793                 return btd_error_failed(msg, "No active session");
 794
 795         if (session->io == NULL)
 796                 return btd_error_not_connected(msg);
 797
 798         bnep_if_down_wrapper(session->dev);
 799         bnep_conndel_wrapper(&dst_addr);
 800
 801         return dbus_message_new_method_return(msg);
 802 }
 803
 804 static DBusMessage *get_properties(DBusConnection *conn,
 805                                         DBusMessage *msg, void *data)
 806 {
 807         struct network_adapter *na = data;
 808         struct network_server *ns;
 809         struct network_session *session;
 810         const char *addr = NULL;
 811         bdaddr_t dst_addr;
 812         DBusMessage *reply;
 813         DBusMessageIter iter;
 814         DBusMessageIter dict;
 815         dbus_bool_t connected;
 816         const char *property;
 817
 818         if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &addr,
 819                                                         DBUS_TYPE_INVALID))
 820                 return btd_error_invalid_args(msg);
 821
 822         reply = dbus_message_new_method_return(msg);
 823         if (!reply)
 824                 return NULL;
 825
 826         dbus_message_iter_init_append(reply, &iter);
 827
 828         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 829                 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 830                 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 831                 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 832
 833         ns = find_server(na->servers, BNEP_SVC_NAP);
 834
 835         str2ba(addr, &dst_addr);
 836         session = find_session_by_addr(ns->sessions, dst_addr);
 837
 838         connected = (session && session->io) ? TRUE : FALSE;
 839         dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &connected);
 840
 841         /* Interface */
 842         property = session ? session->dev : "";
 843         dict_append_entry(&dict, "Interface", DBUS_TYPE_STRING, &property);
 844
 845         dbus_message_iter_close_container(&iter, &dict);
 846
 847         return reply;
 848 }
 849 #endif
 850
 851 #ifdef  TIZEN_FEATURE_BLUEZ_MODIFY
 852 static GDBusSignalTable server_signals[] = {
 853         { GDBUS_SIGNAL("PeerConnected",
 854                         GDBUS_ARGS({ "device", "s" }, { "address", "s" })) },
 855         { GDBUS_SIGNAL("PeerDisconnected",
 856                         GDBUS_ARGS({ "device", "s" }, { "address", "s" })) },
 857         { }
 858 };
 859 #endif
 860
 861 static const GDBusMethodTable server_methods[] = {
 862         { GDBUS_METHOD("Register",
 863                         GDBUS_ARGS({ "uuid", "s" }, { "bridge", "s" }), NULL,
 864                         register_server) },
 865         { GDBUS_METHOD("Unregister",
 866                         GDBUS_ARGS({ "uuid", "s" }), NULL,
 867                         unregister_server) },
 868 #ifdef TIZEN_FEATURE_BLUEZ_MODIFY
 869         { GDBUS_METHOD("Disconnect",
 870                         GDBUS_ARGS({ "address", "s" }), NULL,
 871                         disconnect_device) },
 872         { GDBUS_METHOD("GetProperties",
 873                         GDBUS_ARGS({ "address", "s" }),
 874                         GDBUS_ARGS({ "properties", "a{sv}" }),
 875                         get_properties) },
 876 #endif
 877         { }
 878 };
 879
 880 static struct network_adapter *create_adapter(struct btd_adapter *adapter)
 881 {
 882         struct network_adapter *na;
 883         GError *err = NULL;
 884
 885         na = g_new0(struct network_adapter, 1);
 886         na->adapter = btd_adapter_ref(adapter);
 887
 888         na->io = bt_io_listen(NULL, confirm_event, na, NULL, &err,
 889                                 BT_IO_OPT_SOURCE_BDADDR,
 890                                 btd_adapter_get_address(adapter),
 891                                 BT_IO_OPT_PSM, BNEP_PSM,
 892                                 BT_IO_OPT_OMTU, BNEP_MTU,
 893                                 BT_IO_OPT_IMTU, BNEP_MTU,
 894                                 BT_IO_OPT_SEC_LEVEL,
 895                                 security ? BT_IO_SEC_MEDIUM : BT_IO_SEC_LOW,
 896                                 BT_IO_OPT_INVALID);
 897         if (!na->io) {
 898                 error("%s", err->message);
 899                 g_error_free(err);
 900                 adapter_free(na);
 901                 return NULL;
 902         }
 903
 904         return na;
 905 }
 906
 907 int server_register(struct btd_adapter *adapter, uint16_t id)
 908 {
 909         struct network_adapter *na;
 910         struct network_server *ns;
 911         const char *path;
 912
 913         na = find_adapter(adapters, adapter);
 914         if (!na) {
 915                 na = create_adapter(adapter);
 916                 if (!na)
 917                         return -EINVAL;
 918                 adapters = g_slist_append(adapters, na);
 919         }
 920
 921         ns = find_server(na->servers, id);
 922         if (ns)
 923                 return 0;
 924
 925         ns = g_new0(struct network_server, 1);
 926
 927         ns->name = g_strdup("Network service");
 928
 929         path = adapter_get_path(adapter);
 930
 931         if (g_slist_length(na->servers) > 0)
 932                 goto done;
 933
 934 #ifndef  TIZEN_FEATURE_BLUEZ_MODIFY
 935         if (!g_dbus_register_interface(btd_get_dbus_connection(), path,
 936                                                 NETWORK_SERVER_INTERFACE,
 937                                                 server_methods, NULL, NULL, na,
 938                                                 path_unregister)) {
 939                 error("D-Bus failed to register %s interface",
 940                                                 NETWORK_SERVER_INTERFACE);
 941                 server_free(ns);
 942                 return -1;
 943         }
 944 #else
 945         ns->sessions = NULL;
 946
 947         if (!g_dbus_register_interface(btd_get_dbus_connection(),
 948                                         path, NETWORK_SERVER_INTERFACE,
 949                                         server_methods, server_signals,
 950                                         NULL,
 951                                         na, path_unregister)) {
 952                 error("D-Bus failed to register %s interface",
 953                                         NETWORK_SERVER_INTERFACE);
 954                 server_free(ns);
 955                 return -1;
 956         }
 957 #endif
 958
 959         DBG("Registered interface %s on path %s", NETWORK_SERVER_INTERFACE,
 960                                                                         path);
 961
 962 done:
 963         bacpy(&ns->src, btd_adapter_get_address(adapter));
 964         ns->id = id;
 965         ns->na = na;
 966         ns->record_id = 0;
 967         na->servers = g_slist_append(na->servers, ns);
 968
 969         return 0;
 970 }
 971
 972 int server_unregister(struct btd_adapter *adapter, uint16_t id)
 973 {
 974         struct network_adapter *na;
 975         struct network_server *ns;
 976
 977         na = find_adapter(adapters, adapter);
 978         if (!na)
 979                 return -EINVAL;
 980
 981         ns = find_server(na->servers, id);
 982         if (!ns)
 983                 return -EINVAL;
 984
 985         na->servers = g_slist_remove(na->servers, ns);
 986         server_free(ns);
 987
 988         if (g_slist_length(na->servers) > 0)
 989                 return 0;
 990
 991         g_dbus_unregister_interface(btd_get_dbus_connection(),
 992                                                 adapter_get_path(adapter),
 993                                                 NETWORK_SERVER_INTERFACE);
 994
 995         return 0;
 996 }