src/monitor/stc-default-connection.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <vconf/vconf.h>
  18 #include <openssl/sha.h>
  19
  20 #include "stc-monitor.h"
  21 #include "stc-manager-gdbus.h"
  22 #include "stc-default-connection.h"
  23
  24 /* connman service dbus details */
  25 #define CONNMAN_SERVICE                          "net.connman"
  26 #define CONNMAN_PATH                             "/net/connman"
  27
  28 #define CONNMAN_MANAGER_PATH                     "/"
  29 #define CONNMAN_MANAGER_INTERFACE                CONNMAN_SERVICE ".Manager"
  30 #define CONNMAN_SERVICE_INTERFACE                CONNMAN_SERVICE ".Service"
  31
  32 #define CONNMAN_CELLULAR_SERVICE_PROFILE_PREFIX  CONNMAN_PATH "/service/cellular_"
  33 #define CONNMAN_WIFI_SERVICE_PROFILE_PREFIX      CONNMAN_PATH "/service/wifi_"
  34 #define CONNMAN_ETHERNET_SERVICE_PROFILE_PREFIX  CONNMAN_PATH "/service/ethernet_"
  35 #define CONNMAN_BLUETOOTH_SERVICE_PROFILE_PREFIX CONNMAN_PATH "/service/bluetooth_"
  36
  37 #define CONNMAN_SIGNAL_PROPERTY_CHANGED          "PropertyChanged"
  38
  39 /* telephony service dbus details */
  40 #define TELEPHONY_SERVICE                        "org.tizen.telephony"
  41 #define TELEPHONY_DEFAULT_PATH                   "/org/tizen/telephony"
  42
  43 #define TELEPHONY_SERVICE_MANAGER                TELEPHONY_SERVICE".Manager"
  44 #define TELEPHONY_SIM_INTERFACE                  TELEPHONY_SERVICE".Sim"
  45
  46 #define TELEPHONY_GET_MODEMS                     "GetModems"
  47 #define TELEPHONY_GET_IMSI                       "GetIMSI"
  48
  49 #define SIM_SLOT_SINGLE 1
  50
  51 #define VCONF_TELEPHONY_DEFAULT_DATA_SERVICE     "db/telephony/dualsim/default_data_service"
  52
  53 default_connection_s g_default_connection;
  54 guint g_default_connection_sub_id = 0;
  55
  56 static int __telephony_get_current_sim(void)
  57 {
  58         int sim_slot_count = 0;
  59         int current_sim = 0;
  60
  61         if (vconf_get_int(VCONFKEY_TELEPHONY_SIM_SLOT_COUNT, &sim_slot_count) != 0) {
  62                 STC_LOGD("failed to get sim slot count");
  63                 return -1;
  64         }
  65
  66         if (sim_slot_count == SIM_SLOT_SINGLE) {
  67                STC_LOGD("It's single sim model");
  68                return current_sim;
  69         }
  70
  71         if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &current_sim) != 0) {
  72                 STC_LOGD("failed to get default data service = %d\n",
  73                          current_sim);
  74                 return -1;
  75         }
  76
  77         return current_sim;
  78 }
  79
  80 static void __make_imsi_to_subscriber_id(char *imsi)
  81 {
  82         int i = 0;
  83         SHA256_CTX ctx;
  84         unsigned char md[SHA256_DIGEST_LENGTH];
  85
  86         SHA256_Init(&ctx);
  87         SHA256_Update(&ctx, imsi, strlen(imsi));
  88         SHA256_Final(md, &ctx);
  89
  90         for (i = 0; i < SHA256_DIGEST_LENGTH; ++i)
  91                 snprintf(g_default_connection.subscriber_id + (i * 2), 3, "%02x", md[i]);
  92 }
  93
  94 static void __telephony_get_modem_subscriber_id(GDBusConnection *connection,
  95                                        const char *default_modem_name)
  96 {
  97         GVariant *message = NULL;
  98         char tel_path[MAX_PATH_LENGTH];
  99         char imsi[IMSI_LENGTH];
 100         const char *plmn = NULL;
 101         int plmn_len = 0;
 102         const char *msin = NULL;
 103         int msin_len = 0;
 104
 105         snprintf(tel_path, sizeof(tel_path), "%s/%s", TELEPHONY_DEFAULT_PATH,
 106                  default_modem_name);
 107         message = stc_manager_gdbus_call_sync(connection,
 108                                               TELEPHONY_SERVICE,
 109                                               tel_path,
 110                                               TELEPHONY_SIM_INTERFACE,
 111                                               TELEPHONY_GET_IMSI,
 112                                               NULL);
 113         if (message == NULL) {
 114                 STC_LOGE("Failed to get services informations");
 115                 goto done;
 116         }
 117
 118         DEBUG_PARAMS(message);
 119         DEBUG_PARAM_TYPE(message);
 120         g_variant_get(message, "(&s&s)", &plmn, &msin);
 121         plmn_len = strlen(plmn);
 122         msin_len = strlen(msin);
 123
 124         if (msin_len + plmn_len >= IMSI_LENGTH) {
 125                 STC_LOGD("Incorrect length of mobile subscriber identifier + net id");
 126                 goto done;
 127         }
 128
 129         snprintf(imsi, IMSI_LENGTH, "%s%s", plmn, msin);
 130         __make_imsi_to_subscriber_id(imsi);
 131
 132 done:
 133         g_variant_unref(message);
 134         return;
 135 }
 136
 137 static void __telephony_update_default_modem_subscriber_id(GDBusConnection *connection)
 138 {
 139         GVariant *message = NULL;
 140         GVariantIter *iter = NULL;
 141         gchar *default_modem_name = NULL;
 142         gchar *modem_name = NULL;
 143         int current_sim = __telephony_get_current_sim();
 144
 145         if (current_sim < 0) {
 146                 STC_LOGI("Sim not found");
 147                 return;
 148         }
 149
 150         message = stc_manager_gdbus_call_sync(connection,
 151                                               TELEPHONY_SERVICE,
 152                                               TELEPHONY_DEFAULT_PATH,
 153                                               TELEPHONY_SERVICE_MANAGER,
 154                                               TELEPHONY_GET_MODEMS,
 155                                               NULL);
 156         if (message == NULL) {
 157                 STC_LOGE("Failed to get services informations");
 158                 return;
 159         }
 160
 161         g_variant_get(message, "(as)", &iter);
 162         DEBUG_PARAMS(message);
 163         DEBUG_PARAM_TYPE(message);
 164         while (g_variant_iter_loop(iter, "s", &modem_name)) {
 165                 if (current_sim == 0) {
 166                         default_modem_name = g_strdup(modem_name);
 167                         FREE(modem_name);
 168                         break;
 169                 }
 170                 current_sim--;
 171         }
 172
 173         __telephony_get_modem_subscriber_id(connection, default_modem_name);
 174
 175         FREE(default_modem_name);
 176         g_variant_iter_free(iter);
 177         g_variant_unref(message);
 178         return;
 179 }
 180
 181 static void __print_default_connection_info(void)
 182 {
 183         STC_LOGI("============= default connection info ============");
 184         STC_LOGI("path    [%s]", g_default_connection.path);
 185         STC_LOGI("type    [%d]", g_default_connection.type);
 186         STC_LOGI("ifname  [%s]", g_default_connection.ifname);
 187         STC_LOGI("roaming [%u]", g_default_connection.roaming ? TRUE : FALSE);
 188         if (g_default_connection.type == STC_IFACE_DATACALL)
 189                 STC_LOGI("sub_id  [%s]", g_default_connection.subscriber_id);
 190         STC_LOGI("==================================================");
 191 }
 192
 193 static void __reset_default_connection_data(void)
 194 {
 195         FREE(g_default_connection.path);
 196         FREE(g_default_connection.ifname);
 197         g_default_connection.type = STC_IFACE_UNKNOWN;
 198         g_default_connection.roaming = FALSE;
 199 }
 200
 201 static gboolean __is_cellular_internet_profile(const char *profile)
 202 {
 203         const char internet_suffix[] = "_1";
 204
 205         if (profile == NULL)
 206                 return FALSE;
 207
 208         if (g_str_has_prefix(profile, CONNMAN_CELLULAR_SERVICE_PROFILE_PREFIX)
 209             == TRUE) {
 210                 char *suffix = strrchr(profile, '_');
 211                 if (g_strcmp0(suffix, internet_suffix) == 0)
 212                         return TRUE;
 213         }
 214
 215         return FALSE;
 216 }
 217
 218 static gboolean __is_cellular_profile(const char *profile)
 219 {
 220         if (profile == NULL)
 221                 return FALSE;
 222
 223         return g_str_has_prefix(profile,
 224                                 CONNMAN_CELLULAR_SERVICE_PROFILE_PREFIX);
 225 }
 226
 227 static gboolean __is_wifi_profile(const char *profile)
 228 {
 229         if (profile == NULL)
 230                 return FALSE;
 231
 232         return g_str_has_prefix(profile, CONNMAN_WIFI_SERVICE_PROFILE_PREFIX);
 233 }
 234
 235 static gboolean __is_ethernet_profile(const char *profile)
 236 {
 237         if (profile == NULL)
 238                 return FALSE;
 239
 240         return g_str_has_prefix(profile,
 241                                 CONNMAN_ETHERNET_SERVICE_PROFILE_PREFIX);
 242 }
 243
 244 static gboolean __is_bluetooth_profile(const char *profile)
 245 {
 246         if (profile == NULL)
 247                 return FALSE;
 248
 249         return g_str_has_prefix(profile,
 250                                 CONNMAN_BLUETOOTH_SERVICE_PROFILE_PREFIX);
 251 }
 252
 253 static gboolean __is_connected(GVariantIter *array)
 254 {
 255         gboolean is_connected = FALSE;
 256         GVariant *variant = NULL;
 257         gchar *key = NULL;
 258
 259         while (g_variant_iter_loop(array, "{sv}", &key, &variant)) {
 260                 if (g_strcmp0(key, "State") != 0)
 261                         continue;
 262
 263                 if (g_variant_is_of_type(variant, G_VARIANT_TYPE_STRING)) {
 264                         const gchar *state = NULL;
 265
 266                         state = g_variant_get_string(variant, NULL);
 267                         if (g_strcmp0(state, "ready") == 0 ||
 268                             g_strcmp0(state, "online") == 0)
 269                                 is_connected = TRUE;
 270                 }
 271
 272                 g_free(key);
 273                 g_variant_unref(variant);
 274                 break;
 275         }
 276
 277         return is_connected;
 278 }
 279
 280 static void __get_default_connection_info(GDBusConnection *connection,
 281                                           const char *object_path)
 282 {
 283         GVariant *message = NULL;
 284         GVariantIter *iter = NULL;
 285         GVariant *variant = NULL;
 286         gchar *key = NULL;
 287
 288         if (object_path == NULL) {
 289                 STC_LOGI("Object path is NULL, so information not available.");
 290                 return;
 291         }
 292
 293         message = stc_manager_gdbus_call_sync(connection,
 294                                               CONNMAN_SERVICE,
 295                                               object_path,
 296                                               CONNMAN_SERVICE_INTERFACE,
 297                                               "GetProperties", NULL);
 298         if (message == NULL) {
 299                 STC_LOGE("Failed to get services informations");
 300                 goto done;
 301         }
 302
 303         g_variant_get(message, "(a{sv})", &iter);
 304         if (iter == NULL) {
 305                 STC_LOGE("Profile %s doesn't exist", object_path);
 306                 goto done;
 307         }
 308
 309         while (g_variant_iter_loop(iter, "{sv}", &key, &variant)) {
 310                 if (g_strcmp0(key, "Ethernet") == 0) {
 311                         GVariantIter *iter1 = NULL;
 312                         GVariant *variant1 = NULL;
 313                         gchar *key1 = NULL;
 314
 315                         g_variant_get(variant, "a{sv}", &iter1);
 316                         if (iter1 == NULL)
 317                                 continue;
 318
 319                         while (g_variant_iter_loop(iter1, "{sv}", &key1,
 320                                                    &variant1)) {
 321                                 if (g_strcmp0(key1, "Interface") == 0) {
 322                                         const gchar *value =
 323                                                 g_variant_get_string(variant1,
 324                                                                      NULL);
 325                                         g_default_connection.ifname =
 326                                                 g_strdup(value);
 327                                 }
 328                         }
 329
 330                         g_variant_iter_free(iter1);
 331
 332                 } else if (g_strcmp0(key, "Roaming") == 0) {
 333                         gboolean roaming = 0;
 334
 335                         if (g_variant_is_of_type(variant,
 336                                                  G_VARIANT_TYPE_BOOLEAN)) {
 337                                 roaming = g_variant_get_boolean(variant);
 338                                 g_default_connection.roaming = roaming;
 339                         }
 340                 }
 341         }
 342
 343 done:
 344         if (iter)
 345                 g_variant_iter_free(iter);
 346
 347         if (message)
 348                 g_variant_unref(message);
 349
 350         return;
 351 }
 352
 353 static stc_error_e __get_default_profile(GDBusConnection *connection)
 354 {
 355         GVariant *message = NULL;
 356         GVariantIter *iter = NULL;
 357         GVariantIter *next;
 358         gchar *object_path;
 359
 360         message = stc_manager_gdbus_call_sync(connection,
 361                                               CONNMAN_SERVICE,
 362                                               CONNMAN_MANAGER_PATH,
 363                                               CONNMAN_MANAGER_INTERFACE,
 364                                               "GetServices", NULL);
 365         if (message == NULL) {
 366                 STC_LOGE("Failed to get profiles");
 367                 return STC_ERROR_FAIL;
 368         }
 369
 370         g_variant_get(message, "(a(oa{sv}))", &iter);
 371         while (g_variant_iter_loop(iter, "(oa{sv})", &object_path, &next)) {
 372                 if (object_path == NULL)
 373                         continue;
 374
 375                 if (__is_cellular_profile(object_path) &&
 376                     !__is_cellular_internet_profile(object_path))
 377                         continue;
 378
 379                 if (__is_connected(next) == TRUE) {
 380                         /* reset old default connection data */
 381                         FREE(g_default_connection.path);
 382                         FREE(g_default_connection.ifname);
 383                         g_default_connection.type = STC_IFACE_UNKNOWN;
 384                         g_default_connection.roaming = FALSE;
 385
 386                         g_default_connection.path = g_strdup(object_path);
 387                         g_free(object_path);
 388                         g_variant_iter_free(next);
 389                         break;
 390                 }
 391         }
 392
 393         g_variant_iter_free(iter);
 394         g_variant_unref(message);
 395
 396         if (__is_cellular_profile(g_default_connection.path)) {
 397                 g_default_connection.type = STC_IFACE_DATACALL;
 398                 __telephony_update_default_modem_subscriber_id(connection);
 399         } else if (__is_wifi_profile(g_default_connection.path)) {
 400                 g_default_connection.type = STC_IFACE_WIFI;
 401         } else if (__is_ethernet_profile(g_default_connection.path)) {
 402                 g_default_connection.type = STC_IFACE_WIRED;
 403         } else if (__is_bluetooth_profile(g_default_connection.path)) {
 404                 g_default_connection.type = STC_IFACE_BLUETOOTH;
 405         } else {
 406                 g_default_connection.type = STC_IFACE_UNKNOWN;
 407         }
 408
 409         __get_default_connection_info(connection, g_default_connection.path);
 410
 411         __print_default_connection_info();
 412
 413         stc_monitor_update_rstn_by_default_connection(&g_default_connection);
 414
 415         return STC_ERROR_NONE;
 416 }
 417
 418 static void _service_signal_cb(GDBusConnection *conn,
 419                                const gchar *name, const gchar *path,
 420                                const gchar *interface, const gchar *sig,
 421                                GVariant *param, gpointer user_data)
 422 {
 423         gchar *sigvalue = NULL;
 424         GVariant *variant = NULL;
 425         stc_s *stc = (stc_s *)stc_get_manager();
 426         ret_msg_if(stc == NULL, "failed to get stc data");
 427
 428         if (path == NULL || param == NULL)
 429                 goto done;
 430
 431         g_variant_get(param, "(sv)", &sigvalue, &variant);
 432         if (sigvalue == NULL)
 433                 goto done;
 434
 435         if (g_strcmp0(sig, CONNMAN_SIGNAL_PROPERTY_CHANGED) != 0)
 436                 goto done;
 437
 438         if (g_strcmp0(sigvalue, "State") == 0 &&
 439             g_variant_is_of_type(variant, G_VARIANT_TYPE_STRING)) {
 440                 const gchar *state = NULL;
 441
 442                 state = g_variant_get_string(variant, NULL);
 443                 if (g_strcmp0(state, "ready") == 0 ||
 444                     g_strcmp0(state, "online") == 0) {
 445                         if (g_strcmp0(g_default_connection.path, path)) {
 446                                 __reset_default_connection_data();
 447                                 __get_default_profile(stc->connection);
 448                         }
 449                 } else {
 450                         if (g_strcmp0(g_default_connection.path, path) == 0) {
 451                                 __reset_default_connection_data();
 452                                 __get_default_profile(stc->connection);
 453                         }
 454                 }
 455         } else if (g_strcmp0(sigvalue, "Roaming") == 0) {
 456                 if (g_strcmp0(g_default_connection.path, path) == 0) {
 457                         gboolean roaming = 0;
 458
 459                         if (g_variant_is_of_type(variant,
 460                                                  G_VARIANT_TYPE_BOOLEAN)) {
 461                                 roaming = g_variant_get_boolean(variant);
 462                                 g_default_connection.roaming = roaming;
 463                         }
 464                 }
 465         } else {
 466                 ;//Do nothing
 467         }
 468 done:
 469         if (sigvalue)
 470                 g_free(sigvalue);
 471
 472         if (variant)
 473                 g_variant_unref(variant);
 474
 475         return;
 476 }
 477
 478 stc_error_e stc_default_connection_monitor_init(stc_s *stc)
 479 {
 480         ret_value_msg_if(stc == NULL, STC_ERROR_INVALID_PARAMETER, "failed to get stc data");
 481
 482         __get_default_profile(stc->connection);
 483         g_default_connection_sub_id =
 484                 stc_manager_gdbus_subscribe_signal(stc->connection,
 485                                                    CONNMAN_SERVICE,
 486                                                    CONNMAN_SERVICE_INTERFACE,
 487                                                    CONNMAN_SIGNAL_PROPERTY_CHANGED,
 488                                                    NULL, NULL,
 489                                                    G_DBUS_SIGNAL_FLAGS_NONE,
 490                                                    _service_signal_cb,
 491                                                    NULL, NULL);
 492
 493         STC_LOGI("Successfully subscribed connman [%s] signal", CONNMAN_SIGNAL_PROPERTY_CHANGED);
 494         return STC_ERROR_NONE;
 495 }
 496
 497 stc_error_e stc_default_connection_monitor_deinit(stc_s *stc)
 498 {
 499         ret_value_msg_if(stc == NULL, STC_ERROR_INVALID_PARAMETER, "failed to get stc data");
 500
 501         stc_manager_gdbus_unsubscribe_signal(stc->connection,
 502                                              g_default_connection_sub_id);
 503         FREE(g_default_connection.path);
 504         FREE(g_default_connection.ifname);
 505         return STC_ERROR_NONE;
 506 }
 507
 508 gchar *stc_default_connection_get_ifname(void)
 509 {
 510         return g_strdup(g_default_connection.ifname);
 511 }
 512
 513 default_connection_s *stc_get_default_connection(void)
 514 {
 515         return &g_default_connection;
 516 }