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                 }
 117         } else if (g_str_has_prefix(tech,
 118                         CONNMAN_CELLULAR_TECHNOLOGY_PREFIX) == TRUE) {
 119                 /* Cellular technology state */
 120         }
 121 }
 122
 123 static void __netconfig_wifi_service_state_signal_handler(DBusMessage *msg)
 124 {
 125         char *sigvalue = NULL;
 126         char *property = NULL;
 127         char *service_profile = NULL;
 128         DBusMessageIter args, variant;
 129
 130         service_profile = (char *)dbus_message_get_path(msg);
 131         if (service_profile == NULL)
 132                 return;
 133
 134         dbus_message_iter_init(msg, &args);
 135         dbus_message_iter_get_basic(&args, &sigvalue);
 136         if (sigvalue == NULL)
 137                 return;
 138
 139         if (g_str_equal(sigvalue, "State") == TRUE) {
 140                 dbus_message_iter_next(&args);
 141                 dbus_message_iter_recurse(&args, &variant);
 142                 dbus_message_iter_get_basic(&variant, &property);
 143
 144                 DBG("[%s] %s", property, service_profile);
 145                 if (netconfig_is_wifi_profile(service_profile) == TRUE) {
 146                         int wifi_state = 0;
 147
 148                         vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
 149                         if (wifi_state == VCONFKEY_WIFI_OFF)
 150                                 return;
 151
 152                         if (g_str_equal(property, "ready") == TRUE ||
 153                                         g_str_equal(property, "online") == TRUE) {
 154                                 if (wifi_state >= VCONFKEY_WIFI_CONNECTED)
 155                                         return;
 156
 157                                 netconfig_set_default_profile(service_profile);
 158
 159                                 netconfig_wifi_state_set_service_state(NETCONFIG_WIFI_CONNECTED);
 160
 161                         } else if (g_str_equal(property, "failure") == TRUE ||
 162                                         g_str_equal(property, "disconnect") == TRUE ||
 163                                         g_str_equal(property, "idle") == TRUE) {
 164                                 if (netconfig_get_default_profile() == NULL ||
 165                                                 netconfig_is_wifi_profile(netconfig_get_default_profile())
 166                                                 != TRUE) {
 167                                         netconfig_wifi_state_set_service_state(NETCONFIG_WIFI_IDLE);
 168                                         return;
 169                                 }
 170
 171                                 if (g_str_equal(service_profile, netconfig_get_default_profile()) != TRUE)
 172                                         return;
 173
 174                                 netconfig_set_default_profile(NULL);
 175
 176                                 netconfig_wifi_state_set_service_state(NETCONFIG_WIFI_IDLE);
 177
 178                         } else if (g_str_equal(property, "association") == TRUE ||
 179                                         g_str_equal(property, "configuration") == TRUE) {
 180                                 if (netconfig_get_default_profile() == NULL ||
 181                                                 netconfig_is_wifi_profile(netconfig_get_default_profile())
 182                                                 != TRUE) {
 183                                         netconfig_wifi_state_set_service_state(NETCONFIG_WIFI_CONNECTING);
 184                                         return;
 185                                 }
 186
 187                                 if (g_str_equal(service_profile, netconfig_get_default_profile()) != TRUE)
 188                                         return;
 189
 190                                 netconfig_set_default_profile(NULL);
 191
 192                                 netconfig_wifi_state_set_service_state(NETCONFIG_WIFI_CONNECTING);
 193                         }
 194                 } else {
 195                         if (g_str_equal(property, "ready") == TRUE ||
 196                                         g_str_equal(property, "online") == TRUE) {
 197                                 if (netconfig_get_default_profile() == NULL)
 198                                         netconfig_set_default_profile(service_profile);
 199
 200                         } else if (g_str_equal(property, "failure") == TRUE ||
 201                                         g_str_equal(property, "disconnect") == TRUE ||
 202                                         g_str_equal(property, "idle") == TRUE) {
 203                                 if (netconfig_get_default_profile() == NULL)
 204                                         return;
 205
 206                                 if (g_str_equal(service_profile, netconfig_get_default_profile()) != TRUE)
 207                                         return;
 208
 209                                 netconfig_set_default_profile(NULL);
 210
 211                         } else if (g_str_equal(property, "association") == TRUE ||
 212                                         g_str_equal(property, "configuration") == TRUE) {
 213                                 if (netconfig_get_default_profile() == NULL)
 214                                         return;
 215
 216                                 if (g_str_equal(service_profile, netconfig_get_default_profile()) != TRUE)
 217                                         return;
 218
 219                                 netconfig_set_default_profile(NULL);
 220                         }
 221                 }
 222         }
 223 }
 224
 225 static DBusHandlerResult __netconfig_signal_filter_handler(
 226                 DBusConnection *conn, DBusMessage *msg, void *user_data)
 227 {
 228         char *sigvalue = NULL;
 229
 230         if (msg == NULL) {
 231                 DBG("Invalid Message. Ignore");
 232                 return DBUS_HANDLER_RESULT_HANDLED;
 233         }
 234
 235         if (dbus_message_is_signal(msg, CONNMAN_MANAGER_INTERFACE,
 236                         CONNMAN_SIGNAL_PROPERTY_CHANGED)) {
 237                 /* We have handled this message, don't pass it on */
 238                 return DBUS_HANDLER_RESULT_HANDLED;
 239         } else if (dbus_message_is_signal(msg, CONNMAN_TECHNOLOGY_INTERFACE,
 240                         CONNMAN_SIGNAL_PROPERTY_CHANGED)) {
 241                 __netconfig_technology_signal_handler(msg);
 242
 243                 return DBUS_HANDLER_RESULT_HANDLED;
 244         } else if (dbus_message_is_signal(msg, CONNMAN_SERVICE_INTERFACE,
 245                         CONNMAN_SIGNAL_PROPERTY_CHANGED)) {
 246                 __netconfig_wifi_service_state_signal_handler(msg);
 247
 248                 return DBUS_HANDLER_RESULT_HANDLED;
 249         } else if (dbus_message_is_signal(msg, CONNMAN_MANAGER_INTERFACE,
 250                         CONNMAN_SIGNAL_SERVICES_CHANGED)) {
 251                 DBG("Received CONNMAN_SIGNAL_SERVICES_CHANGED message");
 252                 netconfig_wifi_check_network_notification(msg);
 253
 254                 return DBUS_HANDLER_RESULT_HANDLED;
 255         } else if (dbus_message_is_signal(msg, SUPPLICANT_INTERFACE ".Interface",
 256                         SIGNAL_PROPERTIES_CHANGED)) {
 257                 dbus_bool_t scanning = FALSE;
 258                 void *property = &scanning;
 259
 260                 if (netconfig_dbus_get_basic_params_array(msg,
 261                                 &sigvalue, &property) != TRUE)
 262                         return DBUS_HANDLER_RESULT_HANDLED;
 263
 264                 if (sigvalue == NULL)
 265                         return DBUS_HANDLER_RESULT_HANDLED;
 266
 267                 if (scanning == TRUE)
 268                         netconfig_wifi_set_scanning(TRUE);
 269
 270                 return DBUS_HANDLER_RESULT_HANDLED;
 271         } else if (dbus_message_is_signal(msg, SUPPLICANT_INTERFACE ".Interface",
 272                         SIGNAL_BSS_ADDED)) {
 273                 if (netconfig_wifi_get_ssid_scan_state() == TRUE)
 274                         netconfig_wifi_bss_added(msg);
 275
 276                 return DBUS_HANDLER_RESULT_HANDLED;
 277         } else if (dbus_message_is_signal(msg, SUPPLICANT_INTERFACE ".Interface",
 278                         SIGNAL_SCAN_DONE)) {
 279                 netconfig_wifi_set_scanning(FALSE);
 280
 281                 if (netconfig_wifi_get_bgscan_state() != TRUE) {
 282                         if (netconfig_wifi_get_ssid_scan_state() == TRUE)
 283                                 netconfig_wifi_notify_ssid_scan_done();
 284                         else
 285                                 netconfig_wifi_ssid_scan(NULL);
 286                 }
 287
 288                 return DBUS_HANDLER_RESULT_HANDLED;
 289         }
 290
 291         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 292 }
 293
 294 void netconfig_register_signal(void)
 295 {
 296         DBusConnection *conn = NULL;
 297         DBusError err;
 298
 299         DBG("Register DBus signal filters");
 300
 301         dbus_error_init(&err);
 302         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
 303         if (conn == NULL) {
 304                 ERR("Error! Failed to connect to the D-BUS daemon: [%s]",
 305                                 err.message);
 306                 dbus_error_free(&err);
 307                 return;
 308         }
 309
 310         signal_connection = conn;
 311
 312         dbus_connection_setup_with_g_main(conn, NULL);
 313
 314         /* listening to messages from all objects as no path is specified */
 315         /* see signals from the given interface */
 316         dbus_bus_add_match(conn, CONNMAN_MANAGER_SIGNAL_FILTER, &err);
 317         dbus_connection_flush(conn);
 318         if (dbus_error_is_set(&err)) {
 319                 ERR("Error! Match Error (%s)", err.message);
 320                 dbus_error_free(&err);
 321                 return;
 322         }
 323
 324         dbus_bus_add_match(conn, CONNMAN_TECHNOLOGY_SIGNAL_FILTER, &err);
 325         dbus_connection_flush(conn);
 326         if (dbus_error_is_set(&err)) {
 327                 ERR("Error! Match Error (%s)", err.message);
 328                 dbus_error_free(&err);
 329                 return;
 330         }
 331
 332         dbus_bus_add_match(conn, CONNMAN_SERVICE_SIGNAL_FILTER, &err);
 333         dbus_connection_flush(conn);
 334         if (dbus_error_is_set(&err)) {
 335                 ERR("Error! Match Error (%s)", err.message);
 336                 dbus_error_free(&err);
 337                 return;
 338         }
 339
 340         dbus_bus_add_match(conn, SUPPLICANT_INTERFACE_SIGNAL_FILTER, &err);
 341         dbus_connection_flush(conn);
 342         if (dbus_error_is_set(&err)) {
 343                 ERR("Error! Match Error (%s)", err.message);
 344                 dbus_error_free(&err);
 345                 return;
 346         }
 347
 348         if (dbus_connection_add_filter(conn,
 349                         __netconfig_signal_filter_handler, NULL, NULL) == FALSE) {
 350                 ERR("Error! dbus_connection_add_filter() failed");
 351                 return;
 352         }
 353
 354         INFO("Successfully register signal filters");
 355 }
 356
 357 void netconfig_deregister_signal(void)
 358 {
 359         if (signal_connection == NULL) {
 360                 ERR("Error! Already de-registered. Nothing to be done");
 361                 return;
 362         }
 363
 364         dbus_connection_remove_filter(signal_connection,
 365                                 __netconfig_signal_filter_handler, NULL);
 366         INFO("Successfully remove DBus signal filters");
 367
 368         dbus_connection_unref(signal_connection);
 369         signal_connection = NULL;
 370
 371         netconfig_wifi_deinit_bgscan();
 372 }