src/signal-handler.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <dbus/dbus-glib-lowlevel.h>
  23
  24 #include <vconf.h>
  25 #include <vconf-keys.h>
  26
  27 #include "log.h"
  28 #include "util.h"
  29 #include "netdbus.h"
  30 #include "netsupplicant.h"
  31 #include "wifi-state.h"
  32 #include "wifi-indicator.h"
  33 #include "wifi-ssid-scan.h"
  34 #include "wifi-background-scan.h"
  35 #include "network-state.h"
  36 #include "neterror.h"
  37 #include "wifi.h"
  38
  39 #define SIGNAL_SCAN_DONE                "ScanDone"
  40 #define SIGNAL_BSS_ADDED                "BSSAdded"
  41 #define SIGNAL_PROPERTIES_CHANGED                       "PropertiesChanged"
  42
  43 #define CONNMAN_SIGNAL_SERVICES_CHANGED         "ServicesChanged"
  44 #define CONNMAN_SIGNAL_PROPERTY_CHANGED         "PropertyChanged"
  45
  46 #define CONNMAN_MANAGER_SIGNAL_FILTER           "type='signal',interface='net.connman.Manager'"
  47 #define CONNMAN_TECHNOLOGY_SIGNAL_FILTER        "type='signal',interface='net.connman.Technology'"
  48 #define CONNMAN_SERVICE_SIGNAL_FILTER           "type='signal',interface='net.connman.Service'"
  49 #define SUPPLICANT_INTERFACE_SIGNAL_FILTER      "type='signal',interface='fi.w1.wpa_supplicant1.Interface'"
  50
  51
  52 static DBusConnection *signal_connection = NULL;
  53
  54 static char *__netconfig_get_property(DBusMessage *msg, int *prop_value)
  55 {
  56         DBusMessageIter args, variant;
  57         char *property = NULL;
  58         dbus_bool_t data;
  59
  60         /** read these parameters */
  61         if (!dbus_message_iter_init(msg, &args)) {
  62                 ERR("Message does not have parameters");
  63         } else if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_STRING) {
  64                 ERR("Argument is not string");
  65         } else {
  66                 dbus_message_iter_get_basic(&args, &property);
  67                 dbus_message_iter_next(&args);
  68                 dbus_message_iter_recurse(&args, &variant);
  69                 /* Right now, checking for only 'Powered' property which has
  70                  * Boolean type values
  71                  */
  72                 if (dbus_message_iter_get_arg_type(&variant) == DBUS_TYPE_BOOLEAN) {
  73                         dbus_message_iter_get_basic(&variant, &data);
  74                         if (data)
  75                                 *prop_value = TRUE;
  76                         else
  77                                 *prop_value = FALSE;
  78                 } else {
  79                         *prop_value = FALSE;
  80                 }
  81         }
  82
  83         return property;
  84 }
  85
  86 static void __netconfig_technology_signal_handler(DBusMessage *msg)
  87 {
  88         char *key = NULL;
  89         const char *tech = NULL;
  90         dbus_bool_t value = FALSE;
  91
  92         if (netconfig_dbus_get_basic_params_string(msg,
  93                         &key, DBUS_TYPE_BOOLEAN, &value) != TRUE)
  94                 return;
  95
  96         tech = dbus_message_get_path(msg);
  97         if (key == NULL || tech == NULL)
  98                 return;
  99
 100         if (g_str_has_prefix(tech, CONNMAN_WIFI_TECHNOLOGY_PREFIX) == TRUE) {
 101                 INFO("Wi-Fi Technology %s, property %d", key, value);
 102
 103                 if (g_strcmp0(key, "Powered") == 0) {
 104                         /* Power state */
 105                         if (value == TRUE)
 106                                 netconfig_wifi_update_power_state(TRUE);
 107                         else
 108                                 netconfig_wifi_update_power_state(FALSE);
 109
 110                         netconfig_set_power_in_progress(FALSE);
 111                         netconfig_check_fm_waiting();
 112                 } else if (g_strcmp0(key, "Connected") == 0) {
 113                         /* Connection state */
 114                 } else if (g_strcmp0(key, "Tethering") == 0) {
 115                         /* Tethering state */
 116                         if (value == TRUE)
 117                                 netconfig_wifi_update_power_state(FALSE);
 118                         else
 119                                 netconfig_wifi_update_power_state(TRUE);
 120                 }
 121         } else if (g_str_has_prefix(tech,
 122                         CONNMAN_CELLULAR_TECHNOLOGY_PREFIX) == TRUE) {
 123                 /* Cellular technology state */
 124         }
 125 }
 126
 127 static void __netconfig_wifi_service_state_signal_handler(DBusMessage *msg)
 128 {
 129         char *sigvalue = NULL;
 130         char *property = NULL;
 131         char *service_profile = NULL;
 132         DBusMessageIter args, variant;
 133
 134         service_profile = (char *)dbus_message_get_path(msg);
 135         if (service_profile == NULL)
 136                 return;
 137
 138         dbus_message_iter_init(msg, &args);
 139         dbus_message_iter_get_basic(&args, &sigvalue);
 140         if (sigvalue == NULL)
 141                 return;
 142
 143         if (g_str_equal(sigvalue, "State") == TRUE) {
 144                 dbus_message_iter_next(&args);
 145                 dbus_message_iter_recurse(&args, &variant);
 146                 dbus_message_iter_get_basic(&variant, &property);
 147
 148                 DBG("[%s] %s", property, service_profile);
 149                 if (netconfig_is_wifi_profile(service_profile) == TRUE) {
 150                         int wifi_state = 0;
 151
 152                         vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
 153                         if (wifi_state == VCONFKEY_WIFI_OFF)
 154                                 return;
 155
 156                         if (g_str_equal(property, "ready") == TRUE ||
 157                                         g_str_equal(property, "online") == TRUE) {
 158                                 if (wifi_state >= VCONFKEY_WIFI_CONNECTED)
 159                                         return;
 160
 161                                 netconfig_set_default_profile(service_profile);
 162
 163                                 netconfig_wifi_state_set_service_state(NETCONFIG_WIFI_CONNECTED);
 164
 165                         } else if (g_str_equal(property, "failure") == TRUE ||
 166                                         g_str_equal(property, "disconnect") == TRUE ||
 167                                         g_str_equal(property, "idle") == TRUE) {
 168                                 if (netconfig_get_default_profile() == NULL ||
 169                                                 netconfig_is_wifi_profile(netconfig_get_default_profile())
 170                                                 != TRUE) {
 171                                         netconfig_wifi_state_set_service_state(NETCONFIG_WIFI_IDLE);
 172                                         return;
 173                                 }
 174
 175                                 if (g_str_equal(service_profile, netconfig_get_default_profile()) != TRUE)
 176                                         return;
 177
 178                                 netconfig_set_default_profile(NULL);
 179
 180                                 netconfig_wifi_state_set_service_state(NETCONFIG_WIFI_IDLE);
 181
 182                         } else if (g_str_equal(property, "association") == TRUE ||
 183                                         g_str_equal(property, "configuration") == TRUE) {
 184                                 if (netconfig_get_default_profile() == NULL ||
 185                                                 netconfig_is_wifi_profile(netconfig_get_default_profile())
 186                                                 != TRUE) {
 187                                         netconfig_wifi_state_set_service_state(NETCONFIG_WIFI_CONNECTING);
 188                                         return;
 189                                 }
 190
 191                                 if (g_str_equal(service_profile, netconfig_get_default_profile()) != TRUE)
 192                                         return;
 193
 194                                 netconfig_set_default_profile(NULL);
 195
 196                                 netconfig_wifi_state_set_service_state(NETCONFIG_WIFI_CONNECTING);
 197                         }
 198                 } else {
 199                         if (g_str_equal(property, "ready") == TRUE ||
 200                                         g_str_equal(property, "online") == TRUE) {
 201                                 if (netconfig_get_default_profile() == NULL)
 202                                         netconfig_set_default_profile(service_profile);
 203
 204                         } else if (g_str_equal(property, "failure") == TRUE ||
 205                                         g_str_equal(property, "disconnect") == TRUE ||
 206                                         g_str_equal(property, "idle") == TRUE) {
 207                                 if (netconfig_get_default_profile() == NULL)
 208                                         return;
 209
 210                                 if (g_str_equal(service_profile, netconfig_get_default_profile()) != TRUE)
 211                                         return;
 212
 213                                 netconfig_set_default_profile(NULL);
 214
 215                         } else if (g_str_equal(property, "association") == TRUE ||
 216                                         g_str_equal(property, "configuration") == TRUE) {
 217                                 if (netconfig_get_default_profile() == NULL)
 218                                         return;
 219
 220                                 if (g_str_equal(service_profile, netconfig_get_default_profile()) != TRUE)
 221                                         return;
 222
 223                                 netconfig_set_default_profile(NULL);
 224                         }
 225                 }
 226         }
 227 }
 228
 229 static DBusHandlerResult __netconfig_signal_filter_handler(
 230                 DBusConnection *conn, DBusMessage *msg, void *user_data)
 231 {
 232         char *sigvalue = NULL;
 233
 234         if (msg == NULL) {
 235                 DBG("Invalid Message. Ignore");
 236                 return DBUS_HANDLER_RESULT_HANDLED;
 237         }
 238
 239         if (dbus_message_is_signal(msg, CONNMAN_MANAGER_INTERFACE,
 240                         CONNMAN_SIGNAL_PROPERTY_CHANGED)) {
 241                 /* We have handled this message, don't pass it on */
 242                 return DBUS_HANDLER_RESULT_HANDLED;
 243         } else if (dbus_message_is_signal(msg, CONNMAN_TECHNOLOGY_INTERFACE,
 244                         CONNMAN_SIGNAL_PROPERTY_CHANGED)) {
 245                 __netconfig_technology_signal_handler(msg);
 246
 247                 return DBUS_HANDLER_RESULT_HANDLED;
 248         } else if (dbus_message_is_signal(msg, CONNMAN_SERVICE_INTERFACE,
 249                         CONNMAN_SIGNAL_PROPERTY_CHANGED)) {
 250                 __netconfig_wifi_service_state_signal_handler(msg);
 251
 252                 return DBUS_HANDLER_RESULT_HANDLED;
 253         } else if (dbus_message_is_signal(msg, CONNMAN_MANAGER_INTERFACE,
 254                         CONNMAN_SIGNAL_SERVICES_CHANGED)) {
 255                 DBG("Received CONNMAN_SIGNAL_SERVICES_CHANGED message");
 256                 netconfig_wifi_check_network_notification(msg);
 257
 258                 return DBUS_HANDLER_RESULT_HANDLED;
 259         } else if (dbus_message_is_signal(msg, SUPPLICANT_INTERFACE ".Interface",
 260                         SIGNAL_PROPERTIES_CHANGED)) {
 261                 dbus_bool_t scanning = FALSE;
 262                 void *property = &scanning;
 263
 264                 if (netconfig_dbus_get_basic_params_array(msg,
 265                                 &sigvalue, &property) != TRUE)
 266                         return DBUS_HANDLER_RESULT_HANDLED;
 267
 268                 if (sigvalue == NULL)
 269                         return DBUS_HANDLER_RESULT_HANDLED;
 270
 271                 if (scanning == TRUE)
 272                         netconfig_wifi_set_scanning(TRUE);
 273
 274                 return DBUS_HANDLER_RESULT_HANDLED;
 275         } else if (dbus_message_is_signal(msg, SUPPLICANT_INTERFACE ".Interface",
 276                         SIGNAL_BSS_ADDED)) {
 277                 if (netconfig_wifi_get_ssid_scan_state() == TRUE)
 278                         netconfig_wifi_bss_added(msg);
 279
 280                 return DBUS_HANDLER_RESULT_HANDLED;
 281         } else if (dbus_message_is_signal(msg, SUPPLICANT_INTERFACE ".Interface",
 282                         SIGNAL_SCAN_DONE)) {
 283                 netconfig_wifi_set_scanning(FALSE);
 284
 285                 if (netconfig_wifi_get_bgscan_state() != TRUE) {
 286                         if (netconfig_wifi_get_ssid_scan_state() == TRUE)
 287                                 netconfig_wifi_notify_ssid_scan_done();
 288                         else
 289                                 netconfig_wifi_ssid_scan(NULL);
 290                 }
 291
 292                 return DBUS_HANDLER_RESULT_HANDLED;
 293         }
 294
 295         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 296 }
 297
 298 void netconfig_register_signal(void)
 299 {
 300         DBusConnection *conn = NULL;
 301         DBusError err;
 302
 303         DBG("Register DBus signal filters");
 304
 305         dbus_error_init(&err);
 306         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
 307         if (conn == NULL) {
 308                 ERR("Error! Failed to connect to the D-BUS daemon: [%s]",
 309                                 err.message);
 310                 dbus_error_free(&err);
 311                 return;
 312         }
 313
 314         signal_connection = conn;
 315
 316         dbus_connection_setup_with_g_main(conn, NULL);
 317
 318         /* listening to messages from all objects as no path is specified */
 319         /* see signals from the given interface */
 320         dbus_bus_add_match(conn, CONNMAN_MANAGER_SIGNAL_FILTER, &err);
 321         dbus_connection_flush(conn);
 322         if (dbus_error_is_set(&err)) {
 323                 ERR("Error! Match Error (%s)", err.message);
 324                 dbus_error_free(&err);
 325                 return;
 326         }
 327
 328         dbus_bus_add_match(conn, CONNMAN_TECHNOLOGY_SIGNAL_FILTER, &err);
 329         dbus_connection_flush(conn);
 330         if (dbus_error_is_set(&err)) {
 331                 ERR("Error! Match Error (%s)", err.message);
 332                 dbus_error_free(&err);
 333                 return;
 334         }
 335
 336         dbus_bus_add_match(conn, CONNMAN_SERVICE_SIGNAL_FILTER, &err);
 337         dbus_connection_flush(conn);
 338         if (dbus_error_is_set(&err)) {
 339                 ERR("Error! Match Error (%s)", err.message);
 340                 dbus_error_free(&err);
 341                 return;
 342         }
 343
 344         dbus_bus_add_match(conn, SUPPLICANT_INTERFACE_SIGNAL_FILTER, &err);
 345         dbus_connection_flush(conn);
 346         if (dbus_error_is_set(&err)) {
 347                 ERR("Error! Match Error (%s)", err.message);
 348                 dbus_error_free(&err);
 349                 return;
 350         }
 351
 352         if (dbus_connection_add_filter(conn,
 353                         __netconfig_signal_filter_handler, NULL, NULL) == FALSE) {
 354                 ERR("Error! dbus_connection_add_filter() failed");
 355                 return;
 356         }
 357
 358         INFO("Successfully register signal filters");
 359 }
 360
 361 void netconfig_deregister_signal(void)
 362 {
 363         if (signal_connection == NULL) {
 364                 ERR("Error! Already de-registered. Nothing to be done");
 365                 return;
 366         }
 367
 368         dbus_connection_remove_filter(signal_connection,
 369                                 __netconfig_signal_filter_handler, NULL);
 370         INFO("Successfully remove DBus signal filters");
 371
 372         dbus_connection_unref(signal_connection);
 373         signal_connection = NULL;
 374
 375         netconfig_wifi_deinit_bgscan();
 376 }