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