src/notifier.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 GSList *notifier_list = NULL;
  33
  34 static gint compare_priority(gconstpointer a, gconstpointer b)
  35 {
  36         const struct connman_notifier *notifier1 = a;
  37         const struct connman_notifier *notifier2 = b;
  38
  39         return notifier2->priority - notifier1->priority;
  40 }
  41
  42 /**
  43  * connman_notifier_register:
  44  * @notifier: notifier module
  45  *
  46  * Register a new notifier module
  47  *
  48  * Returns: %0 on success
  49  */
  50 int connman_notifier_register(struct connman_notifier *notifier)
  51 {
  52         DBG("notifier %p name %s", notifier, notifier->name);
  53
  54         notifier_list = g_slist_insert_sorted(notifier_list, notifier,
  55                                                         compare_priority);
  56
  57         return 0;
  58 }
  59
  60 /**
  61  * connman_notifier_unregister:
  62  * @notifier: notifier module
  63  *
  64  * Remove a previously registered notifier module
  65  */
  66 void connman_notifier_unregister(struct connman_notifier *notifier)
  67 {
  68         DBG("notifier %p name %s", notifier, notifier->name);
  69
  70         notifier_list = g_slist_remove(notifier_list, notifier);
  71 }
  72
  73 #define MAX_TECHNOLOGIES 10
  74
  75 static volatile gint registered[MAX_TECHNOLOGIES];
  76 static volatile gint enabled[MAX_TECHNOLOGIES];
  77 static volatile gint connected[MAX_TECHNOLOGIES];
  78
  79 void __connman_notifier_list_registered(DBusMessageIter *iter, void *user_data)
  80 {
  81         int i;
  82
  83         for (i = 0; i < 10; i++) {
  84                 const char *type = __connman_service_type2string(i);
  85
  86                 if (type == NULL)
  87                         continue;
  88
  89                 if (g_atomic_int_get(&registered[i]) > 0)
  90                         dbus_message_iter_append_basic(iter,
  91                                                 DBUS_TYPE_STRING, &type);
  92         }
  93 }
  94
  95 void __connman_notifier_list_enabled(DBusMessageIter *iter, void *user_data)
  96 {
  97         int i;
  98
  99         for (i = 0; i < 10; i++) {
 100                 const char *type = __connman_service_type2string(i);
 101
 102                 if (type == NULL)
 103                         continue;
 104
 105                 if (g_atomic_int_get(&enabled[i]) > 0)
 106                         dbus_message_iter_append_basic(iter,
 107                                                 DBUS_TYPE_STRING, &type);
 108         }
 109 }
 110
 111 void __connman_notifier_list_connected(DBusMessageIter *iter, void *user_data)
 112 {
 113         int i;
 114
 115         for (i = 0; i < 10; i++) {
 116                 const char *type = __connman_service_type2string(i);
 117
 118                 if (type == NULL)
 119                         continue;
 120
 121                 if (g_atomic_int_get(&connected[i]) > 0)
 122                         dbus_message_iter_append_basic(iter,
 123                                                 DBUS_TYPE_STRING, &type);
 124         }
 125 }
 126
 127 static void technology_registered(enum connman_service_type type,
 128                                                 connman_bool_t registered)
 129 {
 130         DBusMessage *signal;
 131         DBusMessageIter iter;
 132
 133         DBG("type %d registered %d", type, registered);
 134
 135         signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
 136                                 CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
 137         if (signal == NULL)
 138                 return;
 139
 140         dbus_message_iter_init_append(signal, &iter);
 141         connman_dbus_property_append_variable_array(&iter,
 142                                 "AvailableTechnologies", DBUS_TYPE_STRING,
 143                                         __connman_notifier_list_registered);
 144
 145         g_dbus_send_message(connection, signal);
 146 }
 147
 148 static void technology_enabled(enum connman_service_type type,
 149                                                 connman_bool_t enabled)
 150 {
 151         DBusMessage *signal;
 152         DBusMessageIter iter;
 153         GSList *list;
 154
 155         DBG("type %d enabled %d", type, enabled);
 156
 157         signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
 158                                 CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
 159         if (signal == NULL)
 160                 goto done;
 161
 162         dbus_message_iter_init_append(signal, &iter);
 163         connman_dbus_property_append_variable_array(&iter,
 164                                 "EnabledTechnologies", DBUS_TYPE_STRING,
 165                                         __connman_notifier_list_enabled);
 166
 167         g_dbus_send_message(connection, signal);
 168
 169 done:
 170         for (list = notifier_list; list; list = list->next) {
 171                 struct connman_notifier *notifier = list->data;
 172
 173                 if (notifier->service_enabled)
 174                         notifier->service_enabled(type, enabled);
 175         }
 176 }
 177
 178 static void technology_connected(enum connman_service_type type,
 179                                                 connman_bool_t connected)
 180 {
 181         DBusMessage *signal;
 182         DBusMessageIter iter;
 183
 184         DBG("type %d connected %d", type, connected);
 185
 186         signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
 187                                 CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
 188         if (signal == NULL)
 189                 return;
 190
 191         dbus_message_iter_init_append(signal, &iter);
 192         connman_dbus_property_append_variable_array(&iter,
 193                                 "ConnectedTechnologies", DBUS_TYPE_STRING,
 194                                         __connman_notifier_list_connected);
 195
 196         g_dbus_send_message(connection, signal);
 197 }
 198
 199 void __connman_notifier_register(enum connman_service_type type)
 200 {
 201         DBG("type %d", type);
 202
 203         switch (type) {
 204         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 205         case CONNMAN_SERVICE_TYPE_SYSTEM:
 206         case CONNMAN_SERVICE_TYPE_VPN:
 207                 return;
 208         case CONNMAN_SERVICE_TYPE_ETHERNET:
 209         case CONNMAN_SERVICE_TYPE_WIFI:
 210         case CONNMAN_SERVICE_TYPE_WIMAX:
 211         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 212         case CONNMAN_SERVICE_TYPE_CELLULAR:
 213                 break;
 214         }
 215
 216         if (g_atomic_int_exchange_and_add(&registered[type], 1) == 0)
 217                 technology_registered(type, TRUE);
 218 }
 219
 220 void __connman_notifier_unregister(enum connman_service_type type)
 221 {
 222         DBG("type %d", type);
 223
 224         switch (type) {
 225         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 226         case CONNMAN_SERVICE_TYPE_SYSTEM:
 227         case CONNMAN_SERVICE_TYPE_VPN:
 228                 return;
 229         case CONNMAN_SERVICE_TYPE_ETHERNET:
 230         case CONNMAN_SERVICE_TYPE_WIFI:
 231         case CONNMAN_SERVICE_TYPE_WIMAX:
 232         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 233         case CONNMAN_SERVICE_TYPE_CELLULAR:
 234                 break;
 235         }
 236
 237         if (g_atomic_int_dec_and_test(&registered[type]) == TRUE)
 238                 technology_registered(type, FALSE);
 239 }
 240
 241 void __connman_notifier_enable(enum connman_service_type type)
 242 {
 243         DBG("type %d", type);
 244
 245         switch (type) {
 246         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 247         case CONNMAN_SERVICE_TYPE_SYSTEM:
 248         case CONNMAN_SERVICE_TYPE_VPN:
 249                 return;
 250         case CONNMAN_SERVICE_TYPE_ETHERNET:
 251         case CONNMAN_SERVICE_TYPE_WIFI:
 252         case CONNMAN_SERVICE_TYPE_WIMAX:
 253         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 254         case CONNMAN_SERVICE_TYPE_CELLULAR:
 255                 break;
 256         }
 257
 258         if (g_atomic_int_exchange_and_add(&enabled[type], 1) == 0)
 259                 technology_enabled(type, TRUE);
 260 }
 261
 262 void __connman_notifier_disable(enum connman_service_type type)
 263 {
 264         DBG("type %d", type);
 265
 266         switch (type) {
 267         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 268         case CONNMAN_SERVICE_TYPE_SYSTEM:
 269         case CONNMAN_SERVICE_TYPE_VPN:
 270                 return;
 271         case CONNMAN_SERVICE_TYPE_ETHERNET:
 272         case CONNMAN_SERVICE_TYPE_WIFI:
 273         case CONNMAN_SERVICE_TYPE_WIMAX:
 274         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 275         case CONNMAN_SERVICE_TYPE_CELLULAR:
 276                 break;
 277         }
 278
 279         if (g_atomic_int_dec_and_test(&enabled[type]) == TRUE)
 280                 technology_enabled(type, FALSE);
 281 }
 282
 283 void __connman_notifier_connect(enum connman_service_type type)
 284 {
 285         DBG("type %d", type);
 286
 287         switch (type) {
 288         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 289         case CONNMAN_SERVICE_TYPE_SYSTEM:
 290         case CONNMAN_SERVICE_TYPE_VPN:
 291                 return;
 292         case CONNMAN_SERVICE_TYPE_ETHERNET:
 293         case CONNMAN_SERVICE_TYPE_WIFI:
 294         case CONNMAN_SERVICE_TYPE_WIMAX:
 295         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 296         case CONNMAN_SERVICE_TYPE_CELLULAR:
 297                 break;
 298         }
 299
 300         if (g_atomic_int_exchange_and_add(&connected[type], 1) == 0)
 301                 technology_connected(type, TRUE);
 302 }
 303
 304 void __connman_notifier_disconnect(enum connman_service_type type)
 305 {
 306         DBG("type %d", type);
 307
 308         switch (type) {
 309         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 310         case CONNMAN_SERVICE_TYPE_SYSTEM:
 311         case CONNMAN_SERVICE_TYPE_VPN:
 312                 return;
 313         case CONNMAN_SERVICE_TYPE_ETHERNET:
 314         case CONNMAN_SERVICE_TYPE_WIFI:
 315         case CONNMAN_SERVICE_TYPE_WIMAX:
 316         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 317         case CONNMAN_SERVICE_TYPE_CELLULAR:
 318                 break;
 319         }
 320
 321         if (g_atomic_int_dec_and_test(&connected[type]) == TRUE)
 322                 technology_connected(type, FALSE);
 323 }
 324
 325 static void technology_default(enum connman_service_type type)
 326 {
 327         const char *str;
 328
 329         str = __connman_service_type2string(type);
 330         if (str == NULL)
 331                 str = "";
 332
 333         connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
 334                         CONNMAN_MANAGER_INTERFACE, "DefaultTechnology",
 335                                                 DBUS_TYPE_STRING, &str);
 336 }
 337
 338 void __connman_notifier_default_changed(struct connman_service *service)
 339 {
 340         enum connman_service_type type = connman_service_get_type(service);
 341         GSList *list;
 342
 343         technology_default(type);
 344
 345         for (list = notifier_list; list; list = list->next) {
 346                 struct connman_notifier *notifier = list->data;
 347
 348                 if (notifier->default_changed)
 349                         notifier->default_changed(service);
 350         }
 351 }
 352
 353 static void offlinemode_changed(dbus_bool_t enabled)
 354 {
 355         DBG("enabled %d", enabled);
 356
 357         connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
 358                                 CONNMAN_MANAGER_INTERFACE, "OfflineMode",
 359                                                 DBUS_TYPE_BOOLEAN, &enabled);
 360 }
 361
 362 void __connman_notifier_offlinemode(connman_bool_t enabled)
 363 {
 364         GSList *list;
 365
 366         DBG("enabled %d", enabled);
 367
 368         __connman_profile_changed(FALSE);
 369
 370         offlinemode_changed(enabled);
 371
 372         for (list = notifier_list; list; list = list->next) {
 373                 struct connman_notifier *notifier = list->data;
 374
 375                 if (notifier->offline_mode)
 376                         notifier->offline_mode(enabled);
 377         }
 378 }
 379
 380 connman_bool_t __connman_notifier_is_enabled(enum connman_service_type type)
 381 {
 382         DBG("type %d", type);
 383
 384         switch (type) {
 385         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 386         case CONNMAN_SERVICE_TYPE_SYSTEM:
 387         case CONNMAN_SERVICE_TYPE_VPN:
 388                 return FALSE;
 389         case CONNMAN_SERVICE_TYPE_ETHERNET:
 390         case CONNMAN_SERVICE_TYPE_WIFI:
 391         case CONNMAN_SERVICE_TYPE_WIMAX:
 392         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 393         case CONNMAN_SERVICE_TYPE_CELLULAR:
 394                 break;
 395         }
 396
 397         if (g_atomic_int_get(&enabled[type]) > 0)
 398                 return TRUE;
 399
 400         return FALSE;
 401 }
 402
 403 int __connman_notifier_init(void)
 404 {
 405         DBG("");
 406
 407         connection = connman_dbus_get_connection();
 408
 409         return 0;
 410 }
 411
 412 void __connman_notifier_cleanup(void)
 413 {
 414         DBG("");
 415
 416         dbus_connection_unref(connection);
 417 }