src/stc-pcap.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-db.h"
  18 #include "stc-pcap.h"
  19 #include "stc-manager-plugin-pcap.h"
  20
  21 #define PCAP_DBUS_ERROR_NAME "net.stc.pcap.Error.Failed"
  22
  23 #define STC_PCAP_DBUS_REPLY_ERROR(invocation, err_num) \
  24         g_dbus_method_invocation_return_dbus_error((invocation), \
  25                                                    PCAP_DBUS_ERROR_NAME, \
  26                                                    stc_err_strs[-(err_num)])
  27
  28 static const gchar *stc_err_strs[] = {
  29         "ERROR_NONE",
  30         "FAIL",
  31         "DB_FAILED",
  32         "OUT_OF_MEMORY",
  33         "INVALID_PARAMETER",
  34         "NO_DATA",
  35         "ALREADY_DATA",
  36         "UNINITIALIZED",
  37         "PERMISSION_DENIED",
  38         "NOTIMPL"
  39 };
  40
  41 gboolean __validate_pcap(stc_pcap_s *pcap)
  42 {
  43         __STC_LOG_FUNC_ENTER__;
  44
  45         if (pcap == NULL) {
  46                 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
  47                 return FALSE; //LCOV_EXCL_LINE
  48         }
  49
  50         if (pcap->ifname == NULL ||
  51                 pcap->ifname[0] == '\0') {
  52                 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
  53                 return FALSE; //LCOV_EXCL_LINE
  54         }
  55
  56         __STC_LOG_FUNC_EXIT__;
  57         return TRUE;
  58 }
  59
  60 static void __stc_extract_pcap(const char *key, GVariant *value,
  61                                            void *user_data)
  62 {
  63         stc_pcap_s *pcap = (stc_pcap_s *) user_data;
  64         if (pcap == NULL) {
  65                 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
  66                 return; //LCOV_EXCL_LINE
  67         }
  68
  69         if (!g_strcmp0(key, STC_PCAP_IFNAME)) {
  70                 gsize str_length;
  71                 const gchar *str = g_variant_get_string(value, &str_length);
  72                 pcap->ifname = g_strdup(str);
  73                 STC_LOGD("ifname: [%s]", pcap->ifname);
  74
  75         } else if (!g_strcmp0(key, STC_PCAP_NFLOG_GROUP)) {
  76                 pcap->nflog_group = g_variant_get_uint32(value);
  77                 STC_LOGD("nflog group: [%d]", pcap->nflog_group);
  78
  79         } else {
  80                 STC_LOGD("Unknown select rule"); //LCOV_EXCL_LINE
  81         }
  82 }
  83
  84 gboolean handle_pcap_start(StcPcap *object,
  85                                 GDBusMethodInvocation *invocation,
  86                                 GVariant *parameters,
  87                                 void *user_data)
  88 {
  89         __STC_LOG_FUNC_ENTER__;
  90         GVariantIter *iter = NULL;
  91         stc_pcap_s pcap;
  92         int ret = STC_ERROR_NONE;
  93
  94         memset(&pcap, 0, sizeof(stc_pcap_s));
  95
  96         g_variant_get(parameters, "a{sv}", &iter);
  97         if (iter != NULL) {
  98                 stc_manager_gdbus_dict_foreach(iter,
  99                                                __stc_extract_pcap,
 100                                                &pcap);
 101                 g_variant_iter_free(iter);
 102         }
 103
 104         if (__validate_pcap(&pcap) == FALSE) {
 105                 STC_PCAP_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 106                                                  STC_ERROR_INVALID_PARAMETER);
 107                 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 108                 return TRUE;
 109         }
 110
 111         ret = stc_plugin_pcap_register_loop(pcap.ifname, pcap.nflog_group);
 112         if (ret != STC_ERROR_NONE) {
 113                 STC_PCAP_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 114                 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 115                 return TRUE;
 116         }
 117
 118         STC_DBUS_REPLY_ERROR_NONE(invocation);
 119         __STC_LOG_FUNC_EXIT__;
 120         return TRUE;
 121 }
 122
 123 gboolean handle_pcap_stop(StcPcap *object,
 124                                 GDBusMethodInvocation *invocation,
 125                                 GVariant *parameters,
 126                                 void *user_data)
 127 {
 128         __STC_LOG_FUNC_ENTER__;
 129         GVariantIter *iter = NULL;
 130         stc_pcap_s pcap;
 131         int ret = STC_ERROR_NONE;
 132
 133         memset(&pcap, 0, sizeof(stc_pcap_s));
 134
 135         g_variant_get(parameters, "a{sv}", &iter);
 136         if (iter != NULL) {
 137                 stc_manager_gdbus_dict_foreach(iter,
 138                                                __stc_extract_pcap,
 139                                                &pcap);
 140                 g_variant_iter_free(iter);
 141         }
 142
 143         if (__validate_pcap(&pcap) == FALSE) {
 144                 STC_PCAP_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 145                                                  STC_ERROR_INVALID_PARAMETER);
 146                 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 147                 return TRUE;
 148         }
 149
 150         ret = stc_plugin_pcap_unregister_loop(pcap.ifname, pcap.nflog_group);
 151         if (ret != STC_ERROR_NONE) {
 152                 STC_PCAP_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 153                 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 154                 return TRUE;
 155         }
 156
 157         STC_DBUS_REPLY_ERROR_NONE(invocation);
 158         __STC_LOG_FUNC_EXIT__;
 159         return TRUE;
 160 }
 161
 162 gboolean handle_pcap_get_all(StcPcap *object,
 163                                 GDBusMethodInvocation *invocation,
 164                                 void *user_data)
 165 {
 166         __STC_LOG_FUNC_ENTER__;
 167         GVariantBuilder *builder = NULL;
 168         GVariant *return_parameters = NULL;
 169
 170         builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
 171
 172         stc_plugin_pcap_get_all_loop(builder);
 173
 174         return_parameters = g_variant_new("(aa{sv})", builder);
 175         g_variant_builder_unref(builder);
 176
 177         DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 178         STC_DBUS_REPLY(invocation, return_parameters);
 179         __STC_LOG_FUNC_EXIT__;
 180         return TRUE;
 181 }
 182
 183 gboolean handle_pcap_find_all_devs(StcPcap *object,
 184                                 GDBusMethodInvocation *invocation,
 185                                 void *user_data)
 186 {
 187         __STC_LOG_FUNC_ENTER__;
 188         GVariantBuilder *builder = NULL;
 189         GVariant *return_parameters = NULL;
 190
 191         builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
 192
 193         stc_plugin_pcap_find_all_devs(builder);
 194
 195         return_parameters = g_variant_new("(aa{sv})", builder);
 196         g_variant_builder_unref(builder);
 197
 198         DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 199         STC_DBUS_REPLY(invocation, return_parameters);
 200         __STC_LOG_FUNC_EXIT__;
 201         return TRUE;
 202 }