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