vcs.maemo.org Git - connman/blob - src/service.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2009  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <gdbus.h>
  27
  28 #include "connman.h"
  29
  30 static DBusConnection *connection = NULL;
  31
  32 static GSequence *service_list = NULL;
  33 static GHashTable *service_hash = NULL;
  34
  35 struct connman_service {
  36         gint refcount;
  37         char *identifier;
  38         char *path;
  39         enum connman_service_type type;
  40         enum connman_service_mode mode;
  41         enum connman_service_security security;
  42         enum connman_service_state state;
  43         connman_uint8_t strength;
  44         connman_bool_t favorite;
  45         unsigned int order;
  46         char *name;
  47         struct connman_device *device;
  48 };
  49
  50 static void append_path(gpointer value, gpointer user_data)
  51 {
  52         struct connman_service *service = value;
  53         DBusMessageIter *iter = user_data;
  54
  55         if (service->path == NULL)
  56                 return;
  57
  58         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
  59                                                         &service->path);
  60 }
  61
  62 void __connman_service_list(DBusMessageIter *iter)
  63 {
  64         DBG("");
  65
  66         g_sequence_foreach(service_list, append_path, iter);
  67 }
  68
  69 static const char *type2string(enum connman_service_type type)
  70 {
  71         switch (type) {
  72         case CONNMAN_SERVICE_TYPE_UNKNOWN:
  73                 break;
  74         case CONNMAN_SERVICE_TYPE_ETHERNET:
  75                 return "ethernet";
  76         case CONNMAN_SERVICE_TYPE_WIFI:
  77                 return "wifi";
  78         case CONNMAN_SERVICE_TYPE_WIMAX:
  79                 return "wimax";
  80         }
  81
  82         return NULL;
  83 }
  84
  85 static const char *mode2string(enum connman_service_mode mode)
  86 {
  87         switch (mode) {
  88         case CONNMAN_SERVICE_MODE_UNKNOWN:
  89                 break;
  90         case CONNMAN_SERVICE_MODE_MANAGED:
  91                 return "managed";
  92         case CONNMAN_SERVICE_MODE_ADHOC:
  93                 return "adhoc";
  94         }
  95
  96         return NULL;
  97 }
  98
  99 static const char *security2string(enum connman_service_security security)
 100 {
 101         switch (security) {
 102         case CONNMAN_SERVICE_SECURITY_UNKNOWN:
 103                 break;
 104         case CONNMAN_SERVICE_SECURITY_NONE:
 105                 return "none";
 106         case CONNMAN_SERVICE_SECURITY_WEP:
 107                 return "wep";
 108         case CONNMAN_SERVICE_SECURITY_WPA:
 109                 return "wpa";
 110         case CONNMAN_SERVICE_SECURITY_WPA2:
 111                 return "wpa2";
 112         }
 113
 114         return NULL;
 115 }
 116
 117 static const char *state2string(enum connman_service_state state)
 118 {
 119         switch (state) {
 120         case CONNMAN_SERVICE_STATE_UNKNOWN:
 121                 break;
 122         case CONNMAN_SERVICE_STATE_IDLE:
 123                 return "idle";
 124         case CONNMAN_SERVICE_STATE_ASSOCIATION:
 125                 return "association";
 126         case CONNMAN_SERVICE_STATE_CONFIGURATION:
 127                 return "configuration";
 128         case CONNMAN_SERVICE_STATE_READY:
 129                 return "ready";
 130         case CONNMAN_SERVICE_STATE_DISCONNECT:
 131                 return "disconnect";
 132         case CONNMAN_SERVICE_STATE_FAILURE:
 133                 return "failure";
 134         }
 135
 136         return NULL;
 137 }
 138
 139 static DBusMessage *get_properties(DBusConnection *conn,
 140                                         DBusMessage *msg, void *data)
 141 {
 142         struct connman_service *service = data;
 143         DBusMessage *reply;
 144         DBusMessageIter array, dict;
 145         const char *str;
 146
 147         DBG("conn %p", conn);
 148
 149         reply = dbus_message_new_method_return(msg);
 150         if (reply == NULL)
 151                 return NULL;
 152
 153         dbus_message_iter_init_append(reply, &array);
 154
 155         dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
 156                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 157                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 158                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 159
 160         str = type2string(service->type);
 161         if (str != NULL)
 162                 connman_dbus_dict_append_variant(&dict, "Type",
 163                                                 DBUS_TYPE_STRING, &str);
 164
 165         str = mode2string(service->mode);
 166         if (str != NULL)
 167                 connman_dbus_dict_append_variant(&dict, "Mode",
 168                                                 DBUS_TYPE_STRING, &str);
 169
 170         str = security2string(service->security);
 171         if (str != NULL)
 172                 connman_dbus_dict_append_variant(&dict, "Security",
 173                                                 DBUS_TYPE_STRING, &str);
 174
 175         str = state2string(service->state);
 176         if (str != NULL)
 177                 connman_dbus_dict_append_variant(&dict, "State",
 178                                                 DBUS_TYPE_STRING, &str);
 179
 180         if (service->strength > 0)
 181                 connman_dbus_dict_append_variant(&dict, "Strength",
 182                                         DBUS_TYPE_BYTE, &service->strength);
 183
 184         connman_dbus_dict_append_variant(&dict, "Favorite",
 185                                         DBUS_TYPE_BOOLEAN, &service->favorite);
 186
 187         if (service->name != NULL)
 188                 connman_dbus_dict_append_variant(&dict, "Name",
 189                                         DBUS_TYPE_STRING, &service->name);
 190
 191         dbus_message_iter_close_container(&array, &dict);
 192
 193         return reply;
 194 }
 195
 196 static DBusMessage *connect_service(DBusConnection *conn,
 197                                         DBusMessage *msg, void *data)
 198 {
 199         struct connman_service *service = data;
 200
 201         if (service->device != NULL) {
 202                 if (__connman_device_connect(service->device) < 0)
 203                         return __connman_error_failed(msg);
 204
 205                 service->state = CONNMAN_SERVICE_STATE_READY;
 206         }
 207
 208         return __connman_error_not_supported(msg);
 209 }
 210
 211 static DBusMessage *disconnect_service(DBusConnection *conn,
 212                                         DBusMessage *msg, void *data)
 213 {
 214         struct connman_service *service = data;
 215
 216         if (service->device != NULL) {
 217                 if (__connman_device_connect(service->device) < 0)
 218                         return __connman_error_failed(msg);
 219
 220                 service->state = CONNMAN_SERVICE_STATE_IDLE;
 221         }
 222
 223         return __connman_error_not_supported(msg);
 224 }
 225
 226 static DBusMessage *remove_service(DBusConnection *conn,
 227                                         DBusMessage *msg, void *data)
 228 {
 229         struct connman_service *service = data;
 230
 231         if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
 232                 return __connman_error_not_supported(msg);
 233
 234         connman_service_set_favorite(service, FALSE);
 235
 236         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 237 }
 238
 239 static DBusMessage *move_before(DBusConnection *conn,
 240                                         DBusMessage *msg, void *data)
 241 {
 242         struct connman_service *service = data;
 243
 244         if (service->favorite == FALSE)
 245                 return __connman_error_not_supported(msg);
 246
 247         return __connman_error_not_implemented(msg);
 248 }
 249
 250 static DBusMessage *move_after(DBusConnection *conn,
 251                                         DBusMessage *msg, void *data)
 252 {
 253         struct connman_service *service = data;
 254
 255         if (service->favorite == FALSE)
 256                 return __connman_error_not_supported(msg);
 257
 258         return __connman_error_not_implemented(msg);
 259 }
 260
 261 static GDBusMethodTable service_methods[] = {
 262         { "GetProperties", "",  "a{sv}", get_properties     },
 263         { "Connect",       "",  "",      connect_service    },
 264         { "Disconnect",    "",  "",      disconnect_service },
 265         { "Remove",        "",  "",      remove_service     },
 266         { "MoveBefore",    "o", "",      move_before        },
 267         { "MoveAfter",     "o", "",      move_after         },
 268         { },
 269 };
 270
 271 static GDBusSignalTable service_signals[] = {
 272         { "PropertyChanged", "sv" },
 273         { },
 274 };
 275
 276 static void service_free(gpointer data)
 277 {
 278         struct connman_service *service = data;
 279         char *path = service->path;
 280
 281         DBG("service %p", service);
 282
 283         g_hash_table_remove(service_hash, service->identifier);
 284
 285         service->path = NULL;
 286
 287         if (path != NULL) {
 288                 __connman_profile_changed();
 289
 290                 g_dbus_unregister_interface(connection, path,
 291                                                 CONNMAN_SERVICE_INTERFACE);
 292                 g_free(path);
 293         }
 294
 295         g_free(service->name);
 296         g_free(service->identifier);
 297         g_free(service);
 298 }
 299
 300 /**
 301  * connman_service_put:
 302  * @service: service structure
 303  *
 304  * Release service if no longer needed
 305  */
 306 void connman_service_put(struct connman_service *service)
 307 {
 308         DBG("service %p", service);
 309
 310         if (g_atomic_int_dec_and_test(&service->refcount) == TRUE) {
 311                 GSequenceIter *iter;
 312
 313                 iter = g_hash_table_lookup(service_hash, service->identifier);
 314                 if (iter != NULL)
 315                         g_sequence_remove(iter);
 316                 else
 317                         service_free(service);
 318         }
 319 }
 320
 321 static void __connman_service_initialize(struct connman_service *service)
 322 {
 323         DBG("service %p", service);
 324
 325         service->refcount = 1;
 326
 327         service->type     = CONNMAN_SERVICE_TYPE_UNKNOWN;
 328         service->mode     = CONNMAN_SERVICE_MODE_UNKNOWN;
 329         service->security = CONNMAN_SERVICE_SECURITY_UNKNOWN;
 330         service->state    = CONNMAN_SERVICE_STATE_UNKNOWN;
 331
 332         service->favorite = FALSE;
 333
 334         service->order = 0;
 335 }
 336
 337 /**
 338  * connman_service_create:
 339  *
 340  * Allocate a new service.
 341  *
 342  * Returns: a newly-allocated #connman_service structure
 343  */
 344 struct connman_service *connman_service_create(void)
 345 {
 346         struct connman_service *service;
 347
 348         service = g_try_new0(struct connman_service, 1);
 349         if (service == NULL)
 350                 return NULL;
 351
 352         DBG("service %p", service);
 353
 354         __connman_service_initialize(service);
 355
 356         return service;
 357 }
 358
 359 /**
 360  * connman_service_ref:
 361  * @service: service structure
 362  *
 363  * Increase reference counter of service
 364  */
 365 struct connman_service *connman_service_ref(struct connman_service *service)
 366 {
 367         g_atomic_int_inc(&service->refcount);
 368
 369         return service;
 370 }
 371
 372 /**
 373  * connman_service_unref:
 374  * @service: service structure
 375  *
 376  * Decrease reference counter of service
 377  */
 378 void connman_service_unref(struct connman_service *service)
 379 {
 380         connman_service_put(service);
 381 }
 382
 383 static gint service_compare(gconstpointer a, gconstpointer b,
 384                                                         gpointer user_data)
 385 {
 386         struct connman_service *service_a = (void *) a;
 387         struct connman_service *service_b = (void *) b;
 388
 389         if (service_a->order > service_b->order)
 390                 return -1;
 391
 392         if (service_a->order < service_b->order)
 393                 return 1;
 394
 395         if (service_a->favorite == TRUE && service_b->favorite == FALSE)
 396                 return -1;
 397
 398         if (service_a->favorite == FALSE && service_b->favorite == TRUE)
 399                 return 1;
 400
 401         return (gint) service_b->strength - (gint) service_a->strength;
 402 }
 403
 404 /**
 405  * connman_service_set_favorite:
 406  * @service: service structure
 407  * @favorite: favorite value
 408  *
 409  * Change the favorite setting of service
 410  */
 411 int connman_service_set_favorite(struct connman_service *service,
 412                                                 connman_bool_t favorite)
 413 {
 414         GSequenceIter *iter;
 415
 416         iter = g_hash_table_lookup(service_hash, service->identifier);
 417         if (iter == NULL)
 418                 return -ENOENT;
 419
 420         if (service->favorite)
 421                 return -EALREADY;
 422
 423         service->favorite = favorite;
 424
 425         g_sequence_sort_changed(iter, service_compare, NULL);
 426
 427         __connman_profile_changed();
 428
 429         return 0;
 430 }
 431
 432 /**
 433  * connman_service_lookup:
 434  * @identifier: service identifier
 435  *
 436  * Look up a service by identifier (reference count will not be increased)
 437  */
 438 struct connman_service *connman_service_lookup(const char *identifier)
 439 {
 440         GSequenceIter *iter;
 441
 442         iter = g_hash_table_lookup(service_hash, identifier);
 443         if (iter != NULL)
 444                 return g_sequence_get(iter);
 445
 446         return NULL;
 447 }
 448
 449 /**
 450  * connman_service_get:
 451  * @identifier: service identifier
 452  *
 453  * Look up a service by identifier or create a new one if not found
 454  */
 455 struct connman_service *connman_service_get(const char *identifier)
 456 {
 457         struct connman_service *service;
 458         GSequenceIter *iter;
 459
 460         iter = g_hash_table_lookup(service_hash, identifier);
 461         if (iter != NULL) {
 462                 service = g_sequence_get(iter);
 463                 if (service != NULL)
 464                         g_atomic_int_inc(&service->refcount);
 465                 return service;
 466         }
 467
 468         service = g_try_new0(struct connman_service, 1);
 469         if (service == NULL)
 470                 return NULL;
 471
 472         DBG("service %p", service);
 473
 474         __connman_service_initialize(service);
 475
 476         service->identifier = g_strdup(identifier);
 477
 478         iter = g_sequence_insert_sorted(service_list, service,
 479                                                 service_compare, NULL);
 480
 481         g_hash_table_insert(service_hash, service->identifier, iter);
 482
 483         return service;
 484 }
 485
 486 static int service_register(struct connman_service *service)
 487 {
 488         const char *path = __connman_profile_active();
 489
 490         if (service->path != NULL)
 491                 return -EALREADY;
 492
 493         service->path = g_strdup_printf("%s/%s", path, service->identifier);
 494
 495         g_dbus_register_interface(connection, service->path,
 496                                         CONNMAN_SERVICE_INTERFACE,
 497                                         service_methods, service_signals,
 498                                                         NULL, service, NULL);
 499
 500         __connman_profile_changed();
 501
 502         return 0;
 503 }
 504
 505 /**
 506  * connman_service_lookup_from_device:
 507  * @device: device structure
 508  *
 509  * Look up a service by device (reference count will not be increased)
 510  */
 511 struct connman_service *__connman_service_lookup_from_device(struct connman_device *device)
 512 {
 513         struct connman_service *service;
 514         char *name;
 515
 516         name = g_strdup_printf("%s_%d", __connman_device_get_type(device),
 517                                         connman_device_get_index(device));
 518
 519         service = connman_service_lookup(name);
 520
 521         g_free(name);
 522
 523         return service;
 524 }
 525
 526 static enum connman_service_type convert_device_type(struct connman_device *device)
 527 {
 528         enum connman_device_type type = connman_device_get_type(device);
 529
 530         switch (type) {
 531         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 532         case CONNMAN_DEVICE_TYPE_VENDOR:
 533         case CONNMAN_DEVICE_TYPE_WIFI:
 534         case CONNMAN_DEVICE_TYPE_WIMAX:
 535         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 536         case CONNMAN_DEVICE_TYPE_GPS:
 537         case CONNMAN_DEVICE_TYPE_HSO:
 538         case CONNMAN_DEVICE_TYPE_NOZOMI:
 539         case CONNMAN_DEVICE_TYPE_HUAWEI:
 540         case CONNMAN_DEVICE_TYPE_NOVATEL:
 541                 break;
 542         case CONNMAN_DEVICE_TYPE_ETHERNET:
 543                 return CONNMAN_SERVICE_TYPE_ETHERNET;
 544         }
 545
 546         return CONNMAN_SERVICE_TYPE_UNKNOWN;
 547 }
 548
 549 /**
 550  * connman_service_create_from_device:
 551  * @device: device structure
 552  *
 553  * Look up service by device and if not found, create one
 554  */
 555 struct connman_service *__connman_service_create_from_device(struct connman_device *device)
 556 {
 557         struct connman_service *service;
 558         char *name;
 559
 560         name = g_strdup_printf("%s_%d", __connman_device_get_type(device),
 561                                         connman_device_get_index(device));
 562
 563         service = connman_service_get(name);
 564         if (service == NULL)
 565                 goto done;
 566
 567         if (service->path != NULL) {
 568                 connman_service_put(service);
 569                 service = NULL;
 570                 goto done;
 571         }
 572
 573         service->type = convert_device_type(device);
 574
 575         service->device = device;
 576
 577         service_register(service);
 578
 579 done:
 580         g_free(name);
 581
 582         return service;
 583 }
 584
 585 /**
 586  * connman_service_lookup_from_network:
 587  * @device: device structure
 588  *
 589  * Look up a service by network (reference count will not be increased)
 590  */
 591 struct connman_service *__connman_service_lookup_from_network(struct connman_network *network)
 592 {
 593         struct connman_service *service;
 594         char *name;
 595
 596         name = g_strdup_printf("%s_%s", __connman_network_get_type(network),
 597                                         __connman_network_get_group(network));
 598
 599         service = connman_service_lookup(name);
 600
 601         g_free(name);
 602
 603         return service;
 604 }
 605
 606 static enum connman_service_type convert_network_type(struct connman_network *network)
 607 {
 608         enum connman_network_type type = connman_network_get_type(network);
 609
 610         switch (type) {
 611         case CONNMAN_NETWORK_TYPE_UNKNOWN:
 612         case CONNMAN_NETWORK_TYPE_VENDOR:
 613         case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
 614         case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
 615         case CONNMAN_NETWORK_TYPE_HSO:
 616                 break;
 617         case CONNMAN_NETWORK_TYPE_WIFI:
 618                 return CONNMAN_SERVICE_TYPE_WIFI;
 619         case CONNMAN_NETWORK_TYPE_WIMAX:
 620                 return CONNMAN_SERVICE_TYPE_WIMAX;
 621         }
 622
 623         return CONNMAN_SERVICE_TYPE_UNKNOWN;
 624 }
 625
 626 /**
 627  * connman_service_create_from_network:
 628  * @device: device structure
 629  *
 630  * Look up service by network and if not found, create one
 631  */
 632 struct connman_service *__connman_service_create_from_network(struct connman_network *network)
 633 {
 634         struct connman_service *service;
 635         char *name;
 636
 637         name = g_strdup_printf("%s_%s", __connman_network_get_type(network),
 638                                         __connman_network_get_group(network));
 639
 640         service = connman_service_get(name);
 641         if (service == NULL)
 642                 goto done;
 643
 644         if (service->path != NULL) {
 645                 connman_service_put(service);
 646                 service = NULL;
 647                 goto done;
 648         }
 649
 650         service->type = convert_network_type(network);
 651
 652         service_register(service);
 653
 654 done:
 655         g_free(name);
 656
 657         return service;
 658 }
 659
 660 int __connman_service_init(void)
 661 {
 662         DBG("");
 663
 664         connection = connman_dbus_get_connection();
 665
 666         service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
 667                                                                 NULL, NULL);
 668
 669         service_list = g_sequence_new(service_free);
 670
 671         return 0;
 672 }
 673
 674 void __connman_service_cleanup(void)
 675 {
 676         DBG("");
 677
 678         g_sequence_free(service_list);
 679         service_list = NULL;
 680
 681         g_hash_table_destroy(service_hash);
 682         service_hash = NULL;
 683
 684         dbus_connection_unref(connection);
 685 }