src/stc-manager-gdbus.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 "stc-manager-gdbus.h"
  18 #include "stc-manager.h"
  19 #include "stc-statistics.h"
  20 #include "stc-restriction.h"
  21 #include "stc-firewall.h"
  22 #include "stc-default-connection.h"
  23 #include "stc-manager-plugin-appstatus.h"
  24 #include "stc-manager-plugin-procfs.h"
  25 #include "helper-iptables.h"
  26
  27 static gboolean __stc_manager_gdbus_statistics_init(stc_s *stc)
  28 {
  29         __STC_LOG_FUNC_ENTER__;
  30         gboolean ret = TRUE;
  31         gchar *s = NULL;
  32
  33         StcObjectSkeleton *object = NULL;
  34         StcStatistics *statistics = NULL;
  35         s = g_strdup_printf(STC_DBUS_SERVICE_STATISTICS_PATH);
  36
  37         /* Add interface to default object path */
  38         object = stc_object_skeleton_new(s);
  39         g_free(s);
  40
  41         /* Make the newly created object export the interface
  42          * net.stc.statistics (note
  43          * that @object takes its own reference to @statistics).
  44          */
  45
  46         statistics = stc_statistics_skeleton_new();
  47         stc_object_skeleton_set_statistics(object, statistics);
  48         g_object_unref(statistics);
  49
  50         /* Register for method callbacks as signal callbacks */
  51
  52         g_signal_connect(statistics, "handle-init",
  53                          G_CALLBACK(handle_statistics_init),
  54                          stc);
  55
  56         g_signal_connect(statistics, "handle-get",
  57                          G_CALLBACK(handle_statistics_get),
  58                          stc);
  59
  60         g_signal_connect(statistics, "handle-get-all",
  61                          G_CALLBACK(handle_statistics_get_all),
  62                          stc);
  63
  64         g_signal_connect(statistics, "handle-reset",
  65                          G_CALLBACK(handle_statistics_reset),
  66                          stc);
  67
  68         /* Export the object (@manager takes its own reference to @object) */
  69         g_dbus_object_manager_server_export(stc->obj_mgr,
  70                                             G_DBUS_OBJECT_SKELETON(object));
  71         g_object_unref(object);
  72
  73         stc->statistics_obj = (gpointer)statistics;
  74
  75         __STC_LOG_FUNC_EXIT__;
  76         return ret;
  77 }
  78
  79 static gboolean __stc_manager_gdbus_restriction_init(stc_s *stc)
  80 {
  81         __STC_LOG_FUNC_ENTER__;
  82         gboolean ret = TRUE;
  83         gchar *s = NULL;
  84
  85         StcObjectSkeleton *object = NULL;
  86         StcRestriction *restriction = NULL;
  87         s = g_strdup_printf(STC_DBUS_SERVICE_RESTRICTION_PATH);
  88
  89         /* Add interface to default object path */
  90         object = stc_object_skeleton_new(s);
  91         g_free(s);
  92
  93         /* Make the newly created object export the interface
  94          * net.stc.restriction (note
  95          * that @object takes its own reference to @restriction).
  96          */
  97
  98         restriction = stc_restriction_skeleton_new();
  99         stc_object_skeleton_set_restriction(object, restriction);
 100         g_object_unref(restriction);
 101
 102         /* Register for method callbacks as signal callbacks */
 103
 104         g_signal_connect(restriction, "handle-set",
 105                          G_CALLBACK(handle_restriction_set), stc);
 106
 107         g_signal_connect(restriction, "handle-exclude",
 108                          G_CALLBACK(handle_restriction_exclude), stc);
 109
 110         g_signal_connect(restriction, "handle-get",
 111                          G_CALLBACK(handle_restriction_get), stc);
 112
 113         g_signal_connect(restriction, "handle-get-all",
 114                          G_CALLBACK(handle_restriction_get_all), stc);
 115
 116         g_signal_connect(restriction, "handle-get-state",
 117                          G_CALLBACK(handle_restriction_get_state),
 118                          stc);
 119
 120         g_signal_connect(restriction, "handle-unset",
 121                          G_CALLBACK(handle_restriction_unset), stc);
 122
 123         /* Export the object (@manager takes its own reference to @object) */
 124         g_dbus_object_manager_server_export(stc->obj_mgr,
 125                                             G_DBUS_OBJECT_SKELETON(object));
 126         g_object_unref(object);
 127
 128         stc->restriction_obj = (gpointer)restriction;
 129
 130         __STC_LOG_FUNC_EXIT__;
 131         return ret;
 132 }
 133
 134 static gboolean __stc_manager_gdbus_firewall_init(stc_s *stc)
 135 {
 136         __STC_LOG_FUNC_ENTER__;
 137         gboolean ret = TRUE;
 138         gchar *s = NULL;
 139
 140         StcObjectSkeleton *object = NULL;
 141         StcFirewall *firewall = NULL;
 142         s = g_strdup_printf(STC_DBUS_SERVICE_FIREWALL_PATH);
 143
 144         /* Add interface to default object path */
 145         object = stc_object_skeleton_new(s);
 146         g_free(s);
 147
 148         firewall = stc_firewall_skeleton_new();
 149         stc_object_skeleton_set_firewall(object, firewall);
 150         g_object_unref(firewall);
 151
 152         /* Register for method callbacks as signal callbacks */
 153
 154         g_signal_connect(firewall, "handle-lock",
 155                          G_CALLBACK(handle_firewall_lock),
 156                          stc);
 157
 158         g_signal_connect(firewall, "handle-unlock",
 159                          G_CALLBACK(handle_firewall_unlock),
 160                          stc);
 161
 162         g_signal_connect(firewall, "handle-get-lock",
 163                          G_CALLBACK(handle_firewall_get_lock),
 164                          stc);
 165
 166         g_signal_connect(firewall, "handle-add-chain",
 167                          G_CALLBACK(handle_firewall_add_chain),
 168                          stc);
 169
 170         g_signal_connect(firewall, "handle-remove-chain",
 171                          G_CALLBACK(handle_firewall_remove_chain),
 172                          stc);
 173
 174         g_signal_connect(firewall, "handle-flush-chain",
 175                          G_CALLBACK(handle_firewall_flush_chain),
 176                          stc);
 177
 178         g_signal_connect(firewall, "handle-get-all-chain",
 179                          G_CALLBACK(handle_firewall_get_all_chain),
 180                          stc);
 181
 182         g_signal_connect(firewall, "handle-set-chain",
 183                          G_CALLBACK(handle_firewall_set_chain),
 184                          stc);
 185
 186         g_signal_connect(firewall, "handle-unset-chain",
 187                          G_CALLBACK(handle_firewall_unset_chain),
 188                          stc);
 189
 190         g_signal_connect(firewall, "handle-add-rule",
 191                          G_CALLBACK(handle_firewall_add_rule),
 192                          stc);
 193
 194         g_signal_connect(firewall, "handle-remove-rule",
 195                          G_CALLBACK(handle_firewall_remove_rule),
 196                          stc);
 197
 198         g_signal_connect(firewall, "handle-update-rule",
 199                          G_CALLBACK(handle_firewall_update_rule),
 200                          stc);
 201
 202         g_signal_connect(firewall, "handle-get-all-rule",
 203                          G_CALLBACK(handle_firewall_get_all_rule),
 204                          stc);
 205
 206         /* Export the object (@manager takes its own reference to @object) */
 207         g_dbus_object_manager_server_export(stc->obj_mgr,
 208                                             G_DBUS_OBJECT_SKELETON(object));
 209         g_object_unref(object);
 210
 211         stc->firewall_obj = (gpointer)firewall;
 212
 213         __STC_LOG_FUNC_EXIT__;
 214         return ret;
 215 }
 216
 217 static gboolean __stc_manager_gdbus_manager_init(stc_s *stc)
 218 {
 219         __STC_LOG_FUNC_ENTER__;
 220         gboolean ret = TRUE;
 221         gchar *s = NULL;
 222
 223         StcObjectSkeleton *object = NULL;
 224         StcManager *manager = NULL;
 225         s = g_strdup_printf(STC_DBUS_SERVICE_MANAGER_PATH);
 226
 227         object = stc_object_skeleton_new(s);
 228         g_free(s);
 229
 230         manager = stc_manager_skeleton_new();
 231         stc_object_skeleton_set_manager(object, manager);
 232         g_object_unref(manager);
 233
 234         g_signal_connect(manager, "handle-stop",
 235                          G_CALLBACK(handle_manager_stop), stc);
 236
 237         g_dbus_object_manager_server_export(stc->obj_mgr,
 238                                             G_DBUS_OBJECT_SKELETON(object));
 239         g_object_unref(object);
 240
 241         stc->manager_obj = (gpointer)manager;
 242
 243         __STC_LOG_FUNC_EXIT__;
 244         return ret;
 245 }
 246
 247
 248 static void __stc_manager_gdbus_on_bus_acquired(GDBusConnection *connection,
 249                                                 const gchar *name,
 250                                                 gpointer user_data)
 251 {
 252         __STC_LOG_FUNC_ENTER__;
 253         stc_s* stc = (stc_s*)user_data;
 254
 255         stc->obj_mgr = g_dbus_object_manager_server_new("/net/stc");
 256
 257         STC_LOGD("path : %s", name);
 258
 259         stc->connection = connection;
 260
 261         if (__stc_manager_gdbus_statistics_init(stc) == FALSE) {
 262                 STC_LOGE("Can not signal connect to statistics"); //LCOV_EXCL_LINE
 263                 /* Deinitialize and quit manager */
 264         }
 265
 266         if (__stc_manager_gdbus_restriction_init(stc) == FALSE) {
 267                 STC_LOGE("Cannot signal connect to restriction"); //LCOV_EXCL_LINE
 268                 /* Deinitialize and quit manager */
 269         }
 270
 271         if (__stc_manager_gdbus_firewall_init(stc) == FALSE) {
 272                 STC_LOGE("Cannot signal connect to firewall"); //LCOV_EXCL_LINE
 273                 /* Deinitialize and quit manager */
 274         }
 275
 276         if (__stc_manager_gdbus_manager_init(stc) == FALSE) {
 277                 STC_LOGE("Cannot signal connect to manager"); //LCOV_EXCL_LINE
 278                 /* Deinitialize and quit manager */
 279         }
 280
 281         g_dbus_object_manager_server_set_connection(stc->obj_mgr,
 282                                                     stc->connection);
 283
 284         iptables_init();
 285         stc_default_connection_monitor_init(stc);
 286
 287         stc_plugin_appstatus_register_state_changed_cb(stc,
 288                         stc_plugin_procfs_app_status_changed, NULL);
 289
 290         __STC_LOG_FUNC_EXIT__;
 291 }
 292
 293 static void __stc_manager_gdbus_on_name_acquired(GDBusConnection *connection,
 294                                                  const gchar *name,
 295                                                  gpointer user_data)
 296 {
 297         STC_LOGD("name : %s", name);
 298 }
 299
 300 //LCOV_EXCL_START
 301 static void __stc_manager_gdbus_on_name_lost(GDBusConnection *connection,
 302                                              const gchar *name,
 303                                              gpointer user_data)
 304 {
 305         STC_LOGD("name : %s", name);
 306 }
 307 //LCOV_EXCL_STOP
 308
 309 void stc_manager_gdbus_init(gpointer stc_data)
 310 {
 311         __STC_LOG_FUNC_ENTER__;
 312         stc_s *stc = (stc_s *)stc_data;
 313
 314         stc->gdbus_owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
 315                                              STC_DBUS_SERVICE,
 316                                              G_BUS_NAME_OWNER_FLAGS_NONE,
 317                                              __stc_manager_gdbus_on_bus_acquired,
 318                                              __stc_manager_gdbus_on_name_acquired,
 319                                              __stc_manager_gdbus_on_name_lost,
 320                                              stc,
 321                                              NULL);
 322
 323         __STC_LOG_FUNC_EXIT__;
 324 }
 325
 326 void stc_manager_gdbus_deinit(gpointer stc_data)
 327 {
 328         __STC_LOG_FUNC_ENTER__;
 329         stc_s *stc = (stc_s *)stc_data;
 330
 331         stc_plugin_appstatus_deregister_state_changed_cb(stc);
 332         stc_default_connection_monitor_deinit(stc);
 333
 334         g_bus_unown_name(stc->gdbus_owner_id);
 335
 336         stc->statistics_obj = NULL;
 337         stc->restriction_obj = NULL;
 338         stc->firewall_obj = NULL;
 339         stc->manager_obj = NULL;
 340         __STC_LOG_FUNC_EXIT__;
 341 }
 342
 343 GVariant *stc_manager_gdbus_call_sync(GDBusConnection *connection,
 344                                       const char *dest, const char *path,
 345                                       const char *interface_name,
 346                                       const char *method, GVariant *params)
 347 {
 348         GError *error = NULL;
 349         GVariant *reply = NULL;
 350
 351         if (connection == NULL) {
 352                 STC_LOGE("Failed to get GDBusconnection"); //LCOV_EXCL_LINE
 353                 return reply; //LCOV_EXCL_LINE
 354         }
 355
 356         reply = g_dbus_connection_call_sync(connection,
 357                                             dest,
 358                                             path,
 359                                             interface_name,
 360                                             method,
 361                                             params,
 362                                             NULL,
 363                                             G_DBUS_CALL_FLAGS_NONE,
 364                                             (5 * 1000),  /* 5 seconds timeout */
 365                                             NULL,
 366                                             &error);
 367
 368         if (reply == NULL) {
 369                 if (error != NULL) {
 370                         STC_LOGE("g_dbus_connection_call_sync() failed" //LCOV_EXCL_LINE
 371                                  "error [%d: %s]", error->code, error->message);
 372                         g_error_free(error); //LCOV_EXCL_LINE
 373                 } else {
 374                         STC_LOGE("g_dbus_connection_call_sync() failed"); //LCOV_EXCL_LINE
 375                 }
 376
 377                 return NULL;
 378         }
 379
 380         return reply;
 381 }
 382
 383 guint stc_manager_gdbus_subscribe_signal(GDBusConnection *connection,
 384                                          const gchar *sender,
 385                                          const gchar *interface_name,
 386                                          const gchar *member,
 387                                          const gchar *object_path,
 388                                          const gchar *arg0,
 389                                          GDBusSignalFlags flags,
 390                                          GDBusSignalCallback callback,
 391                                          gpointer user_data,
 392                                          GDestroyNotify user_data_free_func)
 393 {
 394         if (connection == NULL) {
 395                 STC_LOGE("Failed to get GDBusconnection"); //LCOV_EXCL_LINE
 396                 return 0; //LCOV_EXCL_LINE
 397         }
 398
 399         return g_dbus_connection_signal_subscribe(connection,
 400                                                   sender,
 401                                                   interface_name,
 402                                                   member,
 403                                                   object_path,
 404                                                   NULL,
 405                                                   G_DBUS_SIGNAL_FLAGS_NONE,
 406                                                   callback,
 407                                                   user_data,
 408                                                   user_data_free_func);
 409 }
 410
 411 void stc_manager_gdbus_unsubscribe_signal(GDBusConnection *connection,
 412                                           guint subscription_id)
 413 {
 414         if (connection == NULL) {
 415                 STC_LOGE("Failed to get GDBusconnection"); //LCOV_EXCL_LINE
 416                 return; //LCOV_EXCL_LINE
 417         }
 418
 419         g_dbus_connection_signal_unsubscribe(connection, subscription_id);
 420 }
 421
 422 void stc_manager_gdbus_dict_foreach(GVariantIter *iter, dbus_dict_cb cb,
 423                                     void *user_data)
 424 {
 425         __STC_LOG_FUNC_ENTER__;
 426
 427         gchar *key = NULL;
 428         GVariant *value = NULL;
 429
 430         if (!cb) {
 431                 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 432                 return; //LCOV_EXCL_LINE
 433         }
 434
 435         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
 436                 DEBUG_GDBUS_KEY_VALUE(key, value);
 437                 if (key && cb)
 438                         cb(key, value, user_data);
 439         }
 440
 441         __STC_LOG_FUNC_EXIT__;
 442 }
 443
 444 gboolean stc_manager_dbus_emit_signal(GDBusConnection *connection,
 445                                       const gchar *object_path,
 446                                       const gchar *interface_name,
 447                                       const gchar *signal_name,
 448                                       GVariant *parameters)
 449 {
 450         gboolean rv = FALSE;
 451         GError *error = NULL;
 452
 453         if (connection == NULL) {
 454                 STC_LOGE("GDBusconnection is NULL"); //LCOV_EXCL_LINE
 455                 return 0;
 456         }
 457
 458         DEBUG_GDBUS_VARIANT("Signal params: ", parameters);
 459
 460         rv = g_dbus_connection_emit_signal(connection,
 461                                            NULL,
 462                                            object_path,
 463                                            interface_name,
 464                                            signal_name,
 465                                            parameters,
 466                                            &error);
 467         if (rv != TRUE) {
 468                 STC_LOGE("Failed to emit signal [%s] interface [%s] Error [%s]", //LCOV_EXCL_LINE
 469                          signal_name, interface_name, error->message);
 470                 g_error_free(error); //LCOV_EXCL_LINE
 471         } else {
 472                 STC_LOGD("[%s] signal sent on [%s] interface", signal_name,
 473                          interface_name);
 474         }
 475
 476         return rv;
 477 }
 478
 479 gboolean handle_manager_stop(StcManager *object,
 480                                GDBusMethodInvocation *invocation)
 481 {
 482         __STC_LOG_FUNC_ENTER__;
 483         GVariant *return_parameters = NULL;
 484
 485         STC_LOGI("stc manager stop");
 486
 487         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 488
 489         DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 490         STC_DBUS_REPLY(invocation, return_parameters);
 491
 492         stc_stop_manager();
 493
 494         __STC_LOG_FUNC_EXIT__;
 495         return TRUE;
 496 }