src/profile.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  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 <string.h>
  27
  28 #include <glib.h>
  29 #include <gdbus.h>
  30
  31 #include "connman.h"
  32
  33 #define PROFILE_DEFAULT_IDENT  "default"
  34
  35 struct connman_profile {
  36         char *ident;
  37         char *path;
  38         char *name;
  39         connman_bool_t offlinemode;
  40 };
  41
  42 static GHashTable *profile_hash = NULL;
  43 static struct connman_profile *default_profile = NULL;
  44
  45 static DBusConnection *connection = NULL;
  46
  47 static void append_path(gpointer key, gpointer value, gpointer user_data)
  48 {
  49         struct connman_profile *profile = value;
  50         DBusMessageIter *iter = user_data;
  51
  52         dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
  53                                                         &profile->path);
  54 }
  55
  56 void __connman_profile_list(DBusMessageIter *iter, void *user_data)
  57 {
  58         g_hash_table_foreach(profile_hash, append_path, iter);
  59 }
  60
  61 static void profiles_changed(void)
  62 {
  63         connman_dbus_property_changed_array(CONNMAN_MANAGER_PATH,
  64                         CONNMAN_MANAGER_INTERFACE, "Profiles",
  65                         DBUS_TYPE_OBJECT_PATH, __connman_profile_list, NULL);
  66 }
  67
  68 static void name_changed(struct connman_profile *profile)
  69 {
  70         connman_dbus_property_changed_basic(profile->path,
  71                                 CONNMAN_PROFILE_INTERFACE, "Name",
  72                                         DBUS_TYPE_STRING, &profile->name);
  73 }
  74
  75 static void offlinemode_changed(struct connman_profile *profile)
  76 {
  77         connman_dbus_property_changed_basic(profile->path,
  78                                 CONNMAN_PROFILE_INTERFACE, "OfflineMode",
  79                                 DBUS_TYPE_BOOLEAN, &profile->offlinemode);
  80
  81         if (profile != default_profile)
  82                 return;
  83
  84         connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
  85                                 CONNMAN_MANAGER_INTERFACE, "OfflineMode",
  86                                 DBUS_TYPE_BOOLEAN, &profile->offlinemode);
  87 }
  88
  89 connman_bool_t __connman_profile_get_offlinemode(void)
  90 {
  91         if (default_profile == NULL)
  92                 return FALSE;
  93
  94         DBG("offlinemode %d", default_profile->offlinemode);
  95
  96         return default_profile->offlinemode;
  97 }
  98
  99 int __connman_profile_set_offlinemode(connman_bool_t offlinemode,
 100                                         connman_bool_t all_devices)
 101 {
 102         DBG("offlinemode %d", offlinemode);
 103
 104         if (default_profile == NULL)
 105                 return -EINVAL;
 106
 107         if (default_profile->offlinemode == offlinemode)
 108                 return -EALREADY;
 109
 110         default_profile->offlinemode = offlinemode;
 111         offlinemode_changed(default_profile);
 112
 113         if (all_devices)
 114                 __connman_device_set_offlinemode(offlinemode);
 115
 116         return 0;
 117 }
 118
 119 int __connman_profile_save_default(void)
 120 {
 121         DBG("");
 122
 123         if (default_profile != NULL)
 124                 __connman_storage_save_profile(default_profile);
 125
 126         return 0;
 127 }
 128
 129 const char *__connman_profile_active_ident(void)
 130 {
 131         DBG("");
 132
 133         return PROFILE_DEFAULT_IDENT;
 134 }
 135
 136 const char *__connman_profile_active_path(void)
 137 {
 138         DBG("");
 139
 140         if (default_profile == NULL)
 141                 return NULL;
 142
 143         return default_profile->path;
 144 }
 145
 146 static guint changed_timeout = 0;
 147
 148 static gboolean services_changed(gpointer user_data)
 149 {
 150         struct connman_profile *profile = default_profile;
 151         connman_dbus_append_cb_t function = NULL;
 152
 153         changed_timeout = 0;
 154
 155         if (profile == NULL)
 156                 return FALSE;
 157
 158         if (g_strcmp0(profile->ident, PROFILE_DEFAULT_IDENT) == 0) {
 159                 function = __connman_service_list;
 160
 161                 connman_dbus_property_changed_array(CONNMAN_MANAGER_PATH,
 162                                 CONNMAN_MANAGER_INTERFACE, "Services",
 163                                 DBUS_TYPE_OBJECT_PATH, function, NULL);
 164         }
 165
 166         connman_dbus_property_changed_array(profile->path,
 167                                 CONNMAN_PROFILE_INTERFACE, "Services",
 168                                 DBUS_TYPE_OBJECT_PATH, function, NULL);
 169
 170         return FALSE;
 171 }
 172
 173 void __connman_profile_changed(gboolean delayed)
 174 {
 175         DBG("");
 176
 177         if (changed_timeout > 0) {
 178                 g_source_remove(changed_timeout);
 179                 changed_timeout = 0;
 180         }
 181
 182         if (__connman_connection_update_gateway() == TRUE) {
 183                 services_changed(NULL);
 184                 return;
 185         }
 186
 187         if (delayed == FALSE) {
 188                 services_changed(NULL);
 189                 return;
 190         }
 191
 192         changed_timeout = g_timeout_add_seconds(1, services_changed, NULL);
 193 }
 194
 195 int __connman_profile_add_network(struct connman_network *network)
 196 {
 197         struct connman_service *service;
 198
 199         DBG("network %p", network);
 200
 201         service = __connman_service_create_from_network(network);
 202         if (service == NULL)
 203                 return -EINVAL;
 204
 205         return 0;
 206 }
 207
 208 int __connman_profile_update_network(struct connman_network *network)
 209 {
 210         DBG("network %p", network);
 211
 212         __connman_service_update_from_network(network);
 213
 214         return 0;
 215 }
 216
 217 int __connman_profile_remove_network(struct connman_network *network)
 218 {
 219         DBG("network %p", network);
 220
 221         __connman_service_remove_from_network(network);
 222
 223         return 0;
 224 }
 225
 226 static DBusMessage *get_properties(DBusConnection *conn,
 227                                         DBusMessage *msg, void *data)
 228 {
 229         struct connman_profile *profile = data;
 230         DBusMessage *reply;
 231         DBusMessageIter array, dict;
 232
 233         DBG("conn %p", conn);
 234
 235         reply = dbus_message_new_method_return(msg);
 236         if (reply == NULL)
 237                 return NULL;
 238
 239         dbus_message_iter_init_append(reply, &array);
 240
 241         connman_dbus_dict_open(&array, &dict);
 242
 243         if (profile->name != NULL)
 244                 connman_dbus_dict_append_basic(&dict, "Name",
 245                                         DBUS_TYPE_STRING, &profile->name);
 246
 247         connman_dbus_dict_append_basic(&dict, "OfflineMode",
 248                                 DBUS_TYPE_BOOLEAN, &profile->offlinemode);
 249
 250         connman_dbus_dict_append_array(&dict, "Services",
 251                         DBUS_TYPE_OBJECT_PATH, __connman_service_list, NULL);
 252
 253         connman_dbus_dict_close(&array, &dict);
 254
 255         return reply;
 256 }
 257
 258 static DBusMessage *set_property(DBusConnection *conn,
 259                                         DBusMessage *msg, void *data)
 260 {
 261         struct connman_profile *profile = data;
 262         DBusMessageIter iter, value;
 263         const char *name;
 264         int type;
 265
 266         DBG("conn %p", conn);
 267
 268         if (dbus_message_iter_init(msg, &iter) == FALSE)
 269                 return __connman_error_invalid_arguments(msg);
 270
 271         dbus_message_iter_get_basic(&iter, &name);
 272         dbus_message_iter_next(&iter);
 273         dbus_message_iter_recurse(&iter, &value);
 274
 275         if (__connman_security_check_privilege(msg,
 276                                         CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
 277                 return __connman_error_permission_denied(msg);
 278
 279         type = dbus_message_iter_get_arg_type(&value);
 280
 281         if (g_str_equal(name, "Name") == TRUE) {
 282                 const char *name;
 283
 284                 if (type != DBUS_TYPE_STRING)
 285                         return __connman_error_invalid_arguments(msg);
 286
 287                 dbus_message_iter_get_basic(&value, &name);
 288
 289                 g_free(profile->name);
 290                 profile->name = g_strdup(name);
 291
 292                 if (profile->name != NULL)
 293                         name_changed(profile);
 294
 295                 __connman_storage_save_profile(profile);
 296         } else if (g_str_equal(name, "OfflineMode") == TRUE) {
 297                 connman_bool_t offlinemode;
 298
 299                 if (type != DBUS_TYPE_BOOLEAN)
 300                         return __connman_error_invalid_arguments(msg);
 301
 302                 dbus_message_iter_get_basic(&value, &offlinemode);
 303
 304                 if (profile->offlinemode == offlinemode)
 305                         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 306
 307                 profile->offlinemode = offlinemode;
 308                 offlinemode_changed(profile);
 309
 310                 __connman_storage_save_profile(profile);
 311         } else
 312                 return __connman_error_invalid_property(msg);
 313
 314         return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 315 }
 316
 317 static GDBusMethodTable profile_methods[] = {
 318         { "GetProperties", "",   "a{sv}", get_properties },
 319         { "SetProperty",   "sv", "",      set_property   },
 320         { },
 321 };
 322
 323 static GDBusSignalTable profile_signals[] = {
 324         { "PropertyChanged", "sv" },
 325         { },
 326 };
 327
 328 static void free_profile(struct connman_profile *profile)
 329 {
 330         g_free(profile->name);
 331         g_free(profile->path);
 332         g_free(profile->ident);
 333         g_free(profile);
 334 }
 335
 336 static void unregister_profile(gpointer data)
 337 {
 338         struct connman_profile *profile = data;
 339
 340         DBG("profile %p", profile);
 341
 342         connman_info("Removing profile %s", profile->ident);
 343
 344         g_dbus_unregister_interface(connection, profile->path,
 345                                                 CONNMAN_PROFILE_INTERFACE);
 346
 347         if (g_strcmp0(profile->ident, PROFILE_DEFAULT_IDENT) == 0)
 348                 default_profile = NULL;
 349
 350         free_profile(profile);
 351 }
 352
 353 static int create_profile(const char *ident, const char *name,
 354                                                         const char **path)
 355 {
 356         struct connman_profile *profile;
 357
 358         DBG("ident %s name %s", ident, name);
 359
 360         profile = g_try_new0(struct connman_profile, 1);
 361         if (profile == NULL)
 362                 return -ENOMEM;
 363
 364         profile->ident = g_strdup(ident);
 365         profile->path = g_strdup_printf("/profile/%s", ident);
 366
 367         if (profile->ident == NULL || profile->path == NULL) {
 368                 free_profile(profile);
 369                 return -ENOMEM;
 370         }
 371
 372         if (g_hash_table_lookup(profile_hash, profile->path) != NULL) {
 373                 free_profile(profile);
 374                 return -EEXIST;
 375         }
 376
 377         profile->name = g_strdup(name);
 378
 379         __connman_storage_load_profile(profile);
 380
 381         g_hash_table_insert(profile_hash, g_strdup(profile->path), profile);
 382
 383         connman_info("Adding profile %s", ident);
 384
 385         if (g_strcmp0(ident, PROFILE_DEFAULT_IDENT) == 0)
 386                 default_profile = profile;
 387
 388         g_dbus_register_interface(connection, profile->path,
 389                                         CONNMAN_PROFILE_INTERFACE,
 390                                         profile_methods, profile_signals,
 391                                                         NULL, profile, NULL);
 392
 393         if (path != NULL)
 394                 *path = profile->path;
 395
 396         DBG("profile %p path %s", profile, profile->path);
 397
 398         return 0;
 399 }
 400
 401 int __connman_profile_create(const char *name, const char **path)
 402 {
 403         struct connman_profile *profile;
 404         int err;
 405
 406         DBG("name %s", name);
 407
 408         if (connman_dbus_validate_ident(name) == FALSE)
 409                 return -EINVAL;
 410
 411         err = create_profile(name, NULL, path);
 412         if (err < 0)
 413                 return err;
 414
 415         profile = g_hash_table_lookup(profile_hash, *path);
 416         if (profile == NULL)
 417                 return -EIO;
 418
 419         __connman_storage_save_profile(profile);
 420
 421         profiles_changed();
 422
 423         return 0;
 424 }
 425
 426 int __connman_profile_remove(const char *path)
 427 {
 428         struct connman_profile *profile;
 429
 430         DBG("path %s", path);
 431
 432         if (default_profile != NULL &&
 433                                 g_strcmp0(path, default_profile->path) == 0)
 434                 return -EINVAL;
 435
 436         profile = g_hash_table_lookup(profile_hash, path);
 437         if (profile == NULL)
 438                 return -ENXIO;
 439
 440         __connman_storage_delete_profile(profile->ident);
 441
 442         g_hash_table_remove(profile_hash, path);
 443
 444         profiles_changed();
 445
 446         return 0;
 447 }
 448
 449 static int profile_init(void)
 450 {
 451         GDir *dir;
 452         const gchar *file;
 453
 454         DBG("");
 455
 456         dir = g_dir_open(STORAGEDIR, 0, NULL);
 457         if (dir != NULL) {
 458                 while ((file = g_dir_read_name(dir)) != NULL) {
 459                         GString *str;
 460                         gchar *ident;
 461
 462                         if (g_str_has_suffix(file, ".profile") == FALSE)
 463                                 continue;
 464
 465                         ident = g_strrstr(file, ".profile");
 466                         if (ident == NULL)
 467                                 continue;
 468
 469                         str = g_string_new_len(file, ident - file);
 470                         if (str == NULL)
 471                                 continue;
 472
 473                         ident = g_string_free(str, FALSE);
 474
 475                         if (connman_dbus_validate_ident(ident) == TRUE)
 476                                 create_profile(ident, NULL, NULL);
 477
 478                         g_free(ident);
 479                 }
 480
 481                 g_dir_close(dir);
 482         }
 483
 484         if (default_profile == NULL)
 485                 create_profile(PROFILE_DEFAULT_IDENT, "Default", NULL);
 486
 487         profiles_changed();
 488
 489         return 0;
 490 }
 491
 492 static int profile_load(struct connman_profile *profile)
 493 {
 494         GKeyFile *keyfile;
 495         GError *error = NULL;
 496         connman_bool_t offlinemode;
 497         char *name;
 498
 499         DBG("profile %p", profile);
 500
 501         keyfile = __connman_storage_open_profile(profile->ident);
 502         if (keyfile == NULL)
 503                 return -EIO;
 504
 505         name = g_key_file_get_string(keyfile, "global", "Name", NULL);
 506         if (name != NULL) {
 507                 g_free(profile->name);
 508                 profile->name = name;
 509         }
 510
 511         offlinemode = g_key_file_get_boolean(keyfile, "global",
 512                                                 "OfflineMode", &error);
 513         if (error == NULL)
 514                 profile->offlinemode = offlinemode;
 515         g_clear_error(&error);
 516
 517         __connman_storage_close_profile(profile->ident, keyfile, FALSE);
 518
 519         return 0;
 520 }
 521
 522 static int profile_save(struct connman_profile *profile)
 523 {
 524         GKeyFile *keyfile;
 525
 526         DBG("profile %p", profile);
 527
 528         keyfile = __connman_storage_open_profile(profile->ident);
 529         if (keyfile == NULL)
 530                 return -EIO;
 531
 532         if (profile->name != NULL)
 533                 g_key_file_set_string(keyfile, "global",
 534                                                 "Name", profile->name);
 535
 536         g_key_file_set_boolean(keyfile, "global",
 537                                         "OfflineMode", profile->offlinemode);
 538
 539         __connman_storage_close_profile(profile->ident, keyfile, TRUE);
 540
 541         return 0;
 542 }
 543
 544 static struct connman_storage profile_storage = {
 545         .name           = "profile",
 546         .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
 547         .profile_init   = profile_init,
 548         .profile_load   = profile_load,
 549         .profile_save   = profile_save,
 550 };
 551
 552 int __connman_profile_init(void)
 553 {
 554         DBG("");
 555
 556         connection = connman_dbus_get_connection();
 557         if (connection == NULL)
 558                 return -1;
 559
 560         if (connman_storage_register(&profile_storage) < 0)
 561                 connman_error("Failed to register profile storage");
 562
 563         profile_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
 564                                                 g_free, unregister_profile);
 565
 566         return 0;
 567 }
 568
 569 void __connman_profile_cleanup(void)
 570 {
 571         DBG("");
 572
 573         if (connection == NULL)
 574                 return;
 575
 576         g_hash_table_destroy(profile_hash);
 577         profile_hash = NULL;
 578
 579         connman_storage_unregister(&profile_storage);
 580
 581         dbus_connection_unref(connection);
 582 }