src/stc-iptables-util.c

   1 /*
   2  *  Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License version 2 as
   6  *  published by the Free Software Foundation.
   7  *
   8  *  This program is distributed in the hope that it will be useful,
   9  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *  GNU General Public License for more details.
  12  *
  13  *  You should have received a copy of the GNU General Public License
  14  *  along with this program; if not, write to the Free Software
  15  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  16  */
  17
  18 #include <string.h>
  19
  20 #include "stc-iptables.h"
  21 #include "stc-iptables-util.h"
  22 #include "helper-iptables.h"
  23 #include "helper-ip6tables.h"
  24 #include "helper-log.h"
  25
  26 #define BUF_SIZE_FOR_IP 64
  27
  28 #define RULE_CHAIN      "chain"
  29 #define RULE_DIRECTION  "direction"
  30 #define RULE_IFNAME     "ifname"
  31 #define RULE_CGROUP     "cgroup"
  32 #define RULE_NFACCT     "nfacct"
  33 #define RULE_PROTOCOL   "protocol"
  34 #define RULE_TARGET     "target"
  35 #define RULE_TARGETTYPE "target_type"
  36
  37 #define RULE_FAMILY     "family"
  38 #define RULE_SIPTYPE    "s_ip_type"
  39 #define RULE_SIP1       "s_ip1"
  40 #define RULE_SIP2       "s_ip2"
  41 #define RULE_DIPTYPE    "d_ip_type"
  42 #define RULE_DIP1       "d_ip1"
  43 #define RULE_DIP2       "d_ip2"
  44 #define RULE_SPORTTYPE  "s_port_type"
  45 #define RULE_SPORT1     "s_port1"
  46 #define RULE_SPORT2     "s_port2"
  47 #define RULE_DPORTTYPE  "d_port_type"
  48 #define RULE_DPORT1     "d_port1"
  49 #define RULE_DPORT2     "d_port2"
  50
  51 #define RULE_LOG_LEVEL       "log_level"
  52 #define RULE_LOG_PREFIX      "log_prefix"
  53 #define RULE_NFLOG_GROUP     "nflog_group"
  54 #define RULE_NFLOG_PREFIX    "nflog_prefix"
  55 #define RULE_NFLOG_RANGE     "nflog_range"
  56 #define RULE_NFLOG_THRESHOLD "nflog_threshold"
  57
  58 #define STC_IPTABLES_DBUS_ERROR_NAME "net.stc.iptables.Error.Failed"
  59
  60 #define STC_IPTABLES_DBUS_REPLY(invocation, parameters) \
  61                 g_dbus_method_invocation_return_value((invocation), parameters);
  62
  63 #define STC_IPTABLES_DBUS_REPLY_ERROR(invocation, err_num) \
  64                 g_dbus_method_invocation_return_dbus_error((invocation), \
  65                                                            STC_IPTABLES_DBUS_ERROR_NAME, \
  66                                                            stc_iptables_err_strs[-(err_num)])
  67
  68 static const gchar *stc_iptables_err_strs[] = {
  69                 "ERROR_NONE",
  70                 "NOT_PERMITTED",
  71                 "OUT_OF_MEMORY",
  72                 "PERMISSION_DENIED",
  73                 "INVALID_OPERATION",
  74                 "INVALID_PARAMETER",
  75                 "OPERATION_FAILED"
  76         };
  77
  78 void __stc_extract_rule(const char *key, GVariant *value,
  79                                void *user_data)
  80 {
  81         iptables_rule_s *rule = (iptables_rule_s *)user_data;
  82         if (rule == NULL)
  83                 return;
  84
  85         if (!g_strcmp0(key, RULE_CHAIN)) {
  86                 gsize len = 0;
  87                 rule->chain = g_variant_dup_string(value, &len);
  88                 STC_LOGD("%s: [%s]", RULE_CHAIN, rule->chain);
  89
  90         } else if (!g_strcmp0(key, RULE_DIRECTION)) {
  91                 rule->direction = g_variant_get_uint16(value);
  92                 STC_LOGD("%s: [%u]", RULE_DIRECTION, rule->direction);
  93
  94         } else if (!g_strcmp0(key, RULE_SIPTYPE)) {
  95                 rule->s_ip_type = g_variant_get_uint16(value);
  96                 STC_LOGD("%s: [%u]", RULE_SIPTYPE, rule->s_ip_type);
  97
  98         } else if (!g_strcmp0(key, RULE_DIPTYPE)) {
  99                 rule->d_ip_type = g_variant_get_uint16(value);
 100                 STC_LOGD("%s: [%u]", RULE_DIPTYPE, rule->d_ip_type);
 101
 102         } else if (!g_strcmp0(key, RULE_SPORTTYPE)) {
 103                 rule->s_port_type = g_variant_get_uint16(value);
 104                 STC_LOGD("%s: [%u]", RULE_SPORTTYPE, rule->s_port_type);
 105
 106         } else if (!g_strcmp0(key, RULE_DPORTTYPE)) {
 107                 rule->d_port_type = g_variant_get_uint16(value);
 108                 STC_LOGD("%s: [%u]", RULE_DPORTTYPE, rule->d_port_type);
 109
 110         } else if (!g_strcmp0(key, RULE_SIP1)) {
 111                 if (rule->s_ip_type != IPTABLES_IP_NONE) {
 112                         rule->s_ip1.s_addr = g_variant_get_uint32(value);
 113                         STC_LOGD("%s: [%08x]", RULE_SIP1, rule->s_ip1.s_addr);
 114                 }
 115
 116         } else if (!g_strcmp0(key, RULE_SIP2)) {
 117                 if (rule->s_ip_type != IPTABLES_IP_NONE) {
 118                         rule->s_ip2.s_addr = g_variant_get_uint32(value);
 119                         STC_LOGD("%s: [%08x]", RULE_SIP2, rule->s_ip2.s_addr);
 120                 }
 121
 122         } else if (!g_strcmp0(key, RULE_DIP1)) {
 123                 if (rule->d_ip_type != IPTABLES_IP_NONE) {
 124                         rule->d_ip1.s_addr = g_variant_get_uint32(value);
 125                         STC_LOGD("%s: [%08x]", RULE_DIP1, rule->d_ip1.s_addr);
 126                 }
 127
 128         } else if (!g_strcmp0(key, RULE_DIP2)) {
 129                 if (rule->d_ip_type != IPTABLES_IP_NONE) {
 130                         rule->d_ip2.s_addr = g_variant_get_uint32(value);
 131                         STC_LOGD("%s: [%08x]", RULE_DIP2, rule->d_ip2.s_addr);
 132                 }
 133
 134         } else if (!g_strcmp0(key, RULE_SPORT1)) {
 135                 if (rule->s_port_type != IPTABLES_PORT_NONE) {
 136                         rule->s_port1 = g_variant_get_uint32(value);
 137                         STC_LOGD("%s: [%04x]", RULE_SPORT1, rule->s_port1);
 138                 }
 139
 140         } else if (!g_strcmp0(key, RULE_SPORT2)) {
 141                 if (rule->s_port_type != IPTABLES_PORT_NONE) {
 142                         rule->s_port2 = g_variant_get_uint32(value);
 143                         STC_LOGD("%s: [%04x]", RULE_SPORT2, rule->s_port2);
 144                 }
 145
 146         } else if (!g_strcmp0(key, RULE_DPORT1)) {
 147                 if (rule->d_port_type != IPTABLES_PORT_NONE) {
 148                         rule->d_port1 = g_variant_get_uint32(value);
 149                         STC_LOGD("%s: [%04x]", RULE_DPORT1, rule->d_port1);
 150                 }
 151
 152         } else if (!g_strcmp0(key, RULE_DPORT2)) {
 153                 if (rule->d_port_type != IPTABLES_PORT_NONE) {
 154                         rule->d_port2 = g_variant_get_uint32(value);
 155                         STC_LOGD("%s: [%04x]", RULE_DPORT2, rule->d_port2);
 156                 }
 157
 158         } else if (!g_strcmp0(key, RULE_IFNAME)) {
 159                 if (rule->direction != IPTABLES_DIRECTION_NONE) {
 160                         gsize len = 0;
 161                         rule->ifname = g_variant_dup_string(value, &len);
 162                         STC_LOGD("%s: [%s]", RULE_IFNAME, rule->ifname);
 163                 }
 164
 165         } else if (!g_strcmp0(key, RULE_CGROUP)) {
 166                 rule->classid = g_variant_get_uint32(value);
 167                 STC_LOGD("%s: [%u]", RULE_CGROUP, rule->classid);
 168
 169         } else if (!g_strcmp0(key, RULE_NFACCT)) {
 170                 gsize len = 0;
 171                 rule->nfacct_name = g_variant_dup_string(value, &len);
 172                 STC_LOGD("%s: [%s]", RULE_NFACCT, rule->nfacct_name);
 173
 174         } else if (!g_strcmp0(key, RULE_PROTOCOL)) {
 175                 rule->protocol = g_variant_get_uint16(value);
 176                 STC_LOGD("%s: [%u]", RULE_PROTOCOL, rule->protocol);
 177
 178         } else if (!g_strcmp0(key, RULE_TARGET)) {
 179                 gsize len = 0;
 180                 rule->target = g_variant_dup_string(value, &len);
 181                 STC_LOGD("%s: [%s]", RULE_TARGET, rule->target);
 182
 183         } else if (!g_strcmp0(key, RULE_TARGETTYPE)) {
 184                 rule->target_type = g_variant_get_uint16(value);
 185                 STC_LOGD("%s: [%u]", RULE_TARGETTYPE, rule->target_type);
 186
 187         } else if (!g_strcmp0(key, RULE_LOG_LEVEL)) {
 188                 if (rule->target_type == IPTABLES_ACTION_LOG) {
 189                         rule->log_level = g_variant_get_uint16(value);
 190                         STC_LOGD("%s: [%u]", RULE_LOG_LEVEL, rule->log_level);
 191                 }
 192
 193         } else if (!g_strcmp0(key, RULE_LOG_PREFIX)) {
 194                 if (rule->target_type == IPTABLES_ACTION_LOG) {
 195                         gsize len = 0;
 196                         rule->log_prefix = g_variant_dup_string(value, &len);
 197                         STC_LOGD("%s: [%s]", RULE_LOG_PREFIX, rule->log_prefix);
 198                 }
 199
 200         } else if (!g_strcmp0(key, RULE_NFLOG_GROUP)) {
 201                 if (rule->target_type == IPTABLES_ACTION_NFLOG) {
 202                         rule->nflog_group = g_variant_get_uint16(value);
 203                         STC_LOGD("%s: [%u]", RULE_NFLOG_GROUP, rule->nflog_group);
 204                 }
 205
 206         } else if (!g_strcmp0(key, RULE_NFLOG_PREFIX)) {
 207                 if (rule->target_type == IPTABLES_ACTION_NFLOG) {
 208                         gsize len = 0;
 209                         rule->nflog_prefix = g_variant_dup_string(value, &len);
 210                         STC_LOGD("%s: [%s]", RULE_NFLOG_PREFIX, rule->nflog_prefix);
 211                 }
 212
 213         } else if (!g_strcmp0(key, RULE_NFLOG_RANGE)) {
 214                 if (rule->target_type == IPTABLES_ACTION_NFLOG) {
 215                         rule->nflog_range = g_variant_get_uint16(value);
 216                         STC_LOGD("%s: [%u]", RULE_NFLOG_RANGE, rule->nflog_range);
 217                 }
 218
 219         } else if (!g_strcmp0(key, RULE_NFLOG_THRESHOLD)) {
 220                 if (rule->target_type == IPTABLES_ACTION_NFLOG) {
 221                         rule->nflog_threshold = g_variant_get_uint16(value);
 222                         STC_LOGD("%s: [%u]", RULE_NFLOG_THRESHOLD, rule->nflog_threshold);
 223                 }
 224
 225         } else {
 226                 STC_LOGD("Unknown rule [%s]", key); //LCOV_EXCL_LINE
 227         }
 228 }
 229
 230 void __stc_extract_6_rule(const char *key, GVariant *value,
 231                                void *user_data)
 232 {
 233         ip6tables_rule_s *rule = (ip6tables_rule_s *)user_data;
 234         if (rule == NULL)
 235                 return;
 236
 237         if (!g_strcmp0(key, RULE_CHAIN)) {
 238                 gsize len = 0;
 239                 rule->chain = g_variant_dup_string(value, &len);
 240                 STC_LOGD("%s: [%s]", RULE_CHAIN, rule->chain);
 241
 242         } else if (!g_strcmp0(key, RULE_DIRECTION)) {
 243                 rule->direction = g_variant_get_uint16(value);
 244                 STC_LOGD("%s: [%u]", RULE_DIRECTION, rule->direction);
 245
 246         } else if (!g_strcmp0(key, RULE_SIPTYPE)) {
 247                 rule->s_ip_type = g_variant_get_uint16(value);
 248                 STC_LOGD("%s: [%u]", RULE_SIPTYPE, rule->s_ip_type);
 249
 250         } else if (!g_strcmp0(key, RULE_DIPTYPE)) {
 251                 rule->d_ip_type = g_variant_get_uint16(value);
 252                 STC_LOGD("%s: [%u]", RULE_DIPTYPE, rule->d_ip_type);
 253
 254         } else if (!g_strcmp0(key, RULE_SPORTTYPE)) {
 255                 rule->s_port_type = g_variant_get_uint16(value);
 256                 STC_LOGD("%s: [%u]", RULE_SPORTTYPE, rule->s_port_type);
 257
 258         } else if (!g_strcmp0(key, RULE_DPORTTYPE)) {
 259                 rule->d_port_type = g_variant_get_uint16(value);
 260                 STC_LOGD("%s: [%u]", RULE_DPORTTYPE, rule->d_port_type);
 261
 262         } else if (!g_strcmp0(key, RULE_SIP1)) {
 263                 if (rule->s_ip_type != IP6TABLES_IP_NONE) {
 264                         gsize len = 0;
 265                         char *str = g_variant_dup_string(value, &len);
 266                         sscanf(str, "%08x:%08x:%08x:%08x",
 267                                 &(rule->s_ip1.s6_addr32[0]), &(rule->s_ip1.s6_addr32[1]),
 268                                 &(rule->s_ip1.s6_addr32[2]), &(rule->s_ip1.s6_addr32[3]));
 269                         STC_LOGD("%s: [%08x:%08x:%08x:%08x]", RULE_SIP1,
 270                                 rule->s_ip1.s6_addr32[0], rule->s_ip1.s6_addr32[1],
 271                                 rule->s_ip1.s6_addr32[2], rule->s_ip1.s6_addr32[3]);
 272                         FREE(str);
 273                 }
 274
 275         } else if (!g_strcmp0(key, RULE_SIP2)) {
 276                 if (rule->s_ip_type != IP6TABLES_IP_NONE) {
 277                         gsize len = 0;
 278                         char *str = g_variant_dup_string(value, &len);
 279                         sscanf(str, "%08x:%08x:%08x:%08x",
 280                                 &(rule->s_ip2.s6_addr32[0]), &(rule->s_ip2.s6_addr32[1]),
 281                                 &(rule->s_ip2.s6_addr32[2]), &(rule->s_ip2.s6_addr32[3]));
 282                         STC_LOGD("%s: [%08x:%08x:%08x:%08x]", RULE_SIP2,
 283                                 rule->s_ip2.s6_addr32[0], rule->s_ip2.s6_addr32[1],
 284                                 rule->s_ip2.s6_addr32[2], rule->s_ip2.s6_addr32[3]);
 285                         FREE(str);
 286                 }
 287
 288         } else if (!g_strcmp0(key, RULE_DIP1)) {
 289                 if (rule->d_ip_type != IP6TABLES_IP_NONE) {
 290                         gsize len = 0;
 291                         char *str = g_variant_dup_string(value, &len);
 292                         sscanf(str, "%08x:%08x:%08x:%08x",
 293                                 &(rule->d_ip1.s6_addr32[0]), &(rule->d_ip1.s6_addr32[1]),
 294                                 &(rule->d_ip1.s6_addr32[2]), &(rule->d_ip1.s6_addr32[3]));
 295                         STC_LOGD("%s: [%08x:%08x:%08x:%08x]", RULE_DIP1,
 296                                 rule->d_ip1.s6_addr32[0], rule->d_ip1.s6_addr32[1],
 297                                 rule->d_ip1.s6_addr32[2], rule->d_ip1.s6_addr32[3]);
 298                         FREE(str);
 299                 }
 300
 301         } else if (!g_strcmp0(key, RULE_DIP2)) {
 302                 if (rule->d_ip_type != IP6TABLES_IP_NONE) {
 303                         gsize len = 0;
 304                         char *str = g_variant_dup_string(value, &len);
 305                         sscanf(str, "%08x:%08x:%08x:%08x",
 306                                 &(rule->d_ip2.s6_addr32[0]), &(rule->d_ip2.s6_addr32[1]),
 307                                 &(rule->d_ip2.s6_addr32[2]), &(rule->d_ip2.s6_addr32[3]));
 308                         STC_LOGD("%s: [%08x:%08x:%08x:%08x]", RULE_DIP2,
 309                                 rule->d_ip2.s6_addr32[0], rule->d_ip2.s6_addr32[1],
 310                                 rule->d_ip2.s6_addr32[2], rule->d_ip2.s6_addr32[3]);
 311                         FREE(str);
 312                 }
 313
 314         } else if (!g_strcmp0(key, RULE_SPORT1)) {
 315                 if (rule->s_port_type != IP6TABLES_PORT_NONE) {
 316                         rule->s_port1 = g_variant_get_uint32(value);
 317                         STC_LOGD("%s: [%04x]", RULE_SPORT1, rule->s_port1);
 318                 }
 319
 320         } else if (!g_strcmp0(key, RULE_SPORT2)) {
 321                 if (rule->s_port_type != IP6TABLES_PORT_NONE) {
 322                         rule->s_port2 = g_variant_get_uint32(value);
 323                         STC_LOGD("%s: [%04x]", RULE_SPORT2, rule->s_port2);
 324                 }
 325
 326         } else if (!g_strcmp0(key, RULE_DPORT1)) {
 327                 if (rule->d_port_type != IP6TABLES_PORT_NONE) {
 328                         rule->d_port1 = g_variant_get_uint32(value);
 329                         STC_LOGD("%s: [%04x]", RULE_DPORT1, rule->d_port1);
 330                 }
 331
 332         } else if (!g_strcmp0(key, RULE_DPORT2)) {
 333                 if (rule->d_port_type != IP6TABLES_PORT_NONE) {
 334                         rule->d_port2 = g_variant_get_uint32(value);
 335                         STC_LOGD("%s: [%04x]", RULE_DPORT2, rule->d_port2);
 336                 }
 337
 338         } else if (!g_strcmp0(key, RULE_IFNAME)) {
 339                 if (rule->direction != IP6TABLES_DIRECTION_NONE) {
 340                         gsize len = 0;
 341                         rule->ifname = g_variant_dup_string(value, &len);
 342                         STC_LOGD("%s: [%s]", RULE_IFNAME, rule->ifname);
 343                 }
 344
 345         } else if (!g_strcmp0(key, RULE_CGROUP)) {
 346                 rule->classid = g_variant_get_uint32(value);
 347                 STC_LOGD("%s: [%u]", RULE_CGROUP, rule->classid);
 348
 349         } else if (!g_strcmp0(key, RULE_NFACCT)) {
 350                 gsize len = 0;
 351                 rule->nfacct_name = g_variant_dup_string(value, &len);
 352                 STC_LOGD("%s: [%s]", RULE_NFACCT, rule->nfacct_name);
 353
 354         } else if (!g_strcmp0(key, RULE_PROTOCOL)) {
 355                 rule->protocol = g_variant_get_uint16(value);
 356                 STC_LOGD("%s: [%u]", RULE_PROTOCOL, rule->protocol);
 357
 358         } else if (!g_strcmp0(key, RULE_TARGET)) {
 359                 gsize len = 0;
 360                 rule->target = g_variant_dup_string(value, &len);
 361                 STC_LOGD("%s: [%s]", RULE_TARGET, rule->target);
 362
 363         } else if (!g_strcmp0(key, RULE_TARGETTYPE)) {
 364                 rule->target_type = g_variant_get_uint16(value);
 365                 STC_LOGD("%s: [%u]", RULE_TARGETTYPE, rule->target_type);
 366
 367         } else if (!g_strcmp0(key, RULE_LOG_LEVEL)) {
 368                 if (rule->target_type == IP6TABLES_ACTION_LOG) {
 369                         rule->log_level = g_variant_get_uint16(value);
 370                         STC_LOGD("%s: [%u]", RULE_LOG_LEVEL, rule->log_level);
 371                 }
 372
 373         } else if (!g_strcmp0(key, RULE_LOG_PREFIX)) {
 374                 if (rule->target_type == IP6TABLES_ACTION_LOG) {
 375                         gsize len = 0;
 376                         rule->log_prefix = g_variant_dup_string(value, &len);
 377                         STC_LOGD("%s: [%s]", RULE_LOG_PREFIX, rule->log_prefix);
 378                 }
 379
 380         } else if (!g_strcmp0(key, RULE_NFLOG_GROUP)) {
 381                 if (rule->target_type == IP6TABLES_ACTION_NFLOG) {
 382                         rule->nflog_group = g_variant_get_uint16(value);
 383                         STC_LOGD("%s: [%u]", RULE_NFLOG_GROUP, rule->nflog_group);
 384                 }
 385
 386         } else if (!g_strcmp0(key, RULE_NFLOG_PREFIX)) {
 387                 if (rule->target_type == IP6TABLES_ACTION_NFLOG) {
 388                         gsize len = 0;
 389                         rule->nflog_prefix = g_variant_dup_string(value, &len);
 390                         STC_LOGD("%s: [%s]", RULE_NFLOG_PREFIX, rule->nflog_prefix);
 391                 }
 392
 393         } else if (!g_strcmp0(key, RULE_NFLOG_RANGE)) {
 394                 if (rule->target_type == IP6TABLES_ACTION_NFLOG) {
 395                         rule->nflog_range = g_variant_get_uint16(value);
 396                         STC_LOGD("%s: [%u]", RULE_NFLOG_RANGE, rule->nflog_range);
 397                 }
 398
 399         } else if (!g_strcmp0(key, RULE_NFLOG_THRESHOLD)) {
 400                 if (rule->target_type == IP6TABLES_ACTION_NFLOG) {
 401                         rule->nflog_threshold = g_variant_get_uint16(value);
 402                         STC_LOGD("%s: [%u]", RULE_NFLOG_THRESHOLD, rule->nflog_threshold);
 403                 }
 404
 405         } else {
 406                 STC_LOGD("Unknown rule [%s]", key); //LCOV_EXCL_LINE
 407         }
 408 }
 409
 410 static void __free_rule(gpointer data)
 411 {
 412         iptables_rule_s *rule = (iptables_rule_s *)data;
 413
 414         FREE(rule->chain);
 415         FREE(rule->ifname);
 416         FREE(rule->nfacct_name);
 417         FREE(rule->target);
 418         FREE(rule->log_prefix);
 419         FREE(rule->nflog_prefix);
 420         FREE(rule);
 421 }
 422
 423 static void __free_6_rule(gpointer data)
 424 {
 425         ip6tables_rule_s *rule = (ip6tables_rule_s *)data;
 426
 427         FREE(rule->chain);
 428         FREE(rule->ifname);
 429         FREE(rule->nfacct_name);
 430         FREE(rule->target);
 431         FREE(rule->log_prefix);
 432         FREE(rule->nflog_prefix);
 433         FREE(rule);
 434 }
 435
 436 gboolean handle_iptables_stop(StcManager *object,
 437                                    GDBusMethodInvocation *invocation)
 438 {
 439         __LOG_FUNC_ENTER__;
 440         GVariant *return_parameters = NULL;
 441
 442         STC_LOGI("stc manager stop");
 443         stc_set_keep_alive(TRUE);
 444
 445         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 446
 447         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 448         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 449
 450         stc_stop_iptables();
 451
 452         __LOG_FUNC_EXIT__;
 453         return TRUE;
 454 }
 455
 456 gboolean handle_iptables_add_rule(StcRule *object,
 457                                GDBusMethodInvocation *invocation,
 458                                GVariant *rules,
 459                                void *user_data)
 460 {
 461         __LOG_FUNC_ENTER__;
 462         stc_error_e ret = STC_ERROR_NONE;
 463         GVariant *return_parameters = NULL;
 464
 465         stc_set_keep_alive(TRUE);
 466
 467         if (rules != NULL) {
 468                 GVariantIter *iter = NULL;
 469
 470                 g_variant_get(rules, "a{sv}", &iter);
 471
 472                 iptables_rule_s *rule = MALLOC0(iptables_rule_s, 1);
 473                 if (rule != NULL) {
 474                         memset(rule, 0, sizeof(iptables_rule_s));
 475
 476                         stc_iptables_gdbus_dict_foreach(iter,
 477                                                         __stc_extract_rule,
 478                                                         rule);
 479
 480                         ret = iptables_add_rule(rule);
 481                         if (ret != STC_ERROR_NONE) {
 482                                  //LCOV_EXCL_START
 483                                 STC_LOGE("Failed add rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 484                                          rule->direction, rule->ifname, rule->classid,
 485                                          rule->nfacct_name, rule->target);
 486
 487                                 __free_rule(rule);
 488                                 g_variant_iter_free(iter);
 489
 490                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 491                                 __LOG_FUNC_EXIT__;
 492                                 return TRUE;
 493                                  //LCOV_EXCL_STOP
 494                         }
 495
 496                         __free_rule(rule);
 497                 }
 498
 499                 g_variant_iter_free(iter);
 500         } else {
 501                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 502                                               STC_ERROR_INVALID_PARAMETER);
 503                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 504                 return TRUE; //LCOV_EXCL_LINE
 505         }
 506
 507         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 508
 509         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 510         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 511
 512         __LOG_FUNC_EXIT__;
 513         return TRUE;
 514 }
 515
 516 gboolean handle_iptables_insert_rule(StcRule *object,
 517                                GDBusMethodInvocation *invocation,
 518                                GVariant *rules,
 519                                void *user_data)
 520 {
 521         __LOG_FUNC_ENTER__;
 522         stc_error_e ret = STC_ERROR_NONE;
 523         GVariant *return_parameters = NULL;
 524
 525         stc_set_keep_alive(TRUE);
 526
 527         if (rules != NULL) {
 528                 GVariantIter *iter = NULL;
 529
 530                 g_variant_get(rules, "a{sv}", &iter);
 531
 532                 iptables_rule_s *rule = MALLOC0(iptables_rule_s, 1);
 533                 if (rule != NULL) {
 534                         memset(rule, 0, sizeof(iptables_rule_s));
 535
 536                         stc_iptables_gdbus_dict_foreach(iter,
 537                                                         __stc_extract_rule,
 538                                                         rule);
 539
 540                         ret = iptables_insert_rule(rule);
 541                         if (ret != STC_ERROR_NONE) {
 542                                  //LCOV_EXCL_START
 543                                 STC_LOGE("Failed insert rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 544                                          rule->direction, rule->ifname, rule->classid,
 545                                          rule->nfacct_name, rule->target);
 546
 547                                 __free_rule(rule);
 548                                 g_variant_iter_free(iter);
 549
 550                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 551                                 __LOG_FUNC_EXIT__;
 552                                 return TRUE;
 553                                  //LCOV_EXCL_STOP
 554                         }
 555
 556                         __free_rule(rule);
 557                 }
 558
 559                 g_variant_iter_free(iter);
 560         } else {
 561                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 562                                               STC_ERROR_INVALID_PARAMETER);
 563                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 564                 return TRUE; //LCOV_EXCL_LINE
 565         }
 566
 567         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 568
 569         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 570         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 571
 572         __LOG_FUNC_EXIT__;
 573         return TRUE;
 574 }
 575
 576 gboolean handle_iptables_remove_rule(StcRule *object,
 577                                GDBusMethodInvocation *invocation,
 578                                GVariant *rules,
 579                                void *user_data)
 580 {
 581         __LOG_FUNC_ENTER__;
 582         stc_error_e ret = STC_ERROR_NONE;
 583         GVariant *return_parameters = NULL;
 584
 585         stc_set_keep_alive(TRUE);
 586
 587         if (rules != NULL) {
 588                 GVariantIter *iter = NULL;
 589                 g_variant_get(rules, "a{sv}", &iter);
 590
 591                 iptables_rule_s *rule = MALLOC0(iptables_rule_s, 1);
 592                 if (rule != NULL) {
 593                         memset(rule, 0, sizeof(iptables_rule_s));
 594
 595                         stc_iptables_gdbus_dict_foreach(iter,
 596                                                         __stc_extract_rule,
 597                                                         rule);
 598
 599                         ret = iptables_remove_rule(rule);
 600                         if (ret != STC_ERROR_NONE) {
 601                                  //LCOV_EXCL_START
 602                                 STC_LOGE("Failed remove rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 603                                          rule->direction, rule->ifname, rule->classid,
 604                                          rule->nfacct_name, rule->target);
 605
 606                                 __free_rule(rule);
 607                                 g_variant_iter_free(iter);
 608
 609                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 610                                 __LOG_FUNC_EXIT__;
 611                                 return TRUE;
 612                                  //LCOV_EXCL_STOP
 613                         }
 614
 615                         __free_rule(rule);
 616                 }
 617
 618                 g_variant_iter_free(iter);
 619         } else {
 620                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 621                                               STC_ERROR_INVALID_PARAMETER);
 622                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 623                 return TRUE; //LCOV_EXCL_LINE
 624         }
 625
 626         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 627
 628         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 629         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 630
 631         __LOG_FUNC_EXIT__;
 632         return TRUE;
 633 }
 634
 635 gboolean handle_iptables_add_chain(StcChain *object,
 636                                    GDBusMethodInvocation *invocation,
 637                                    const gchar *chain,
 638                                    void *user_data)
 639 {
 640         __LOG_FUNC_ENTER__;
 641         stc_error_e ret = STC_ERROR_NONE;
 642         GVariant *return_parameters = NULL;
 643
 644         stc_set_keep_alive(TRUE);
 645
 646         ret = iptables_add_chain(chain);
 647         if (ret < STC_ERROR_NONE) {
 648                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 649                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 650                 return TRUE; //LCOV_EXCL_LINE
 651         }
 652
 653         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 654
 655         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 656         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 657
 658         __LOG_FUNC_EXIT__;
 659         return TRUE;
 660 }
 661
 662 gboolean handle_iptables_remove_chain(StcChain *object,
 663                                GDBusMethodInvocation *invocation,
 664                                const gchar *chain,
 665                                void *user_data)
 666 {
 667         __LOG_FUNC_ENTER__;
 668         stc_error_e ret = STC_ERROR_NONE;
 669         GVariant *return_parameters = NULL;
 670
 671         stc_set_keep_alive(TRUE);
 672
 673         ret = iptables_remove_chain(chain);
 674         if (ret < STC_ERROR_NONE) {
 675                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 676                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 677                 return TRUE; //LCOV_EXCL_LINE
 678         }
 679
 680         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 681
 682         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 683         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 684
 685         __LOG_FUNC_EXIT__;
 686         return TRUE;
 687 }
 688
 689 gboolean handle_iptables_flush_chain(StcChain *object,
 690                                GDBusMethodInvocation *invocation,
 691                                const gchar *chain,
 692                                void *user_data)
 693 {
 694         __LOG_FUNC_ENTER__;
 695         stc_error_e ret = STC_ERROR_NONE;
 696         GVariant *return_parameters = NULL;
 697
 698         stc_set_keep_alive(TRUE);
 699
 700         ret = iptables_flush_chain(chain);
 701         if (ret < STC_ERROR_NONE) {
 702                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 703                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 704                 return TRUE; //LCOV_EXCL_LINE
 705         }
 706
 707         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 708
 709         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 710         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 711
 712         __LOG_FUNC_EXIT__;
 713         return TRUE;
 714 }
 715
 716 gboolean handle_iptables_add_list(StcRule *object,
 717                                GDBusMethodInvocation *invocation,
 718                                GVariant *rule_list,
 719                                void *user_data)
 720 {
 721         __LOG_FUNC_ENTER__;
 722         GVariantIter *iter = NULL;
 723         GVariantIter *iter_row = NULL;
 724         stc_error_e ret = STC_ERROR_NONE;
 725         GSList *iptables_list = NULL;
 726         GVariant *return_parameters = NULL;
 727         struct timespec start, end;
 728         time_t sec;
 729         long int nsec;
 730
 731         stc_set_keep_alive(TRUE);
 732
 733         clock_gettime(CLOCK_MONOTONIC, &start);
 734
 735         g_variant_get(rule_list, "aa{sv}", &iter);
 736         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 737                 iptables_rule_s *rule = MALLOC0(iptables_rule_s, 1);
 738                 if (rule != NULL) {
 739                         stc_iptables_gdbus_dict_foreach(iter_row,
 740                                                         __stc_extract_rule,
 741                                                         rule);
 742
 743                         iptables_list = g_slist_append(iptables_list, rule);
 744                 }
 745                 g_variant_iter_free(iter_row);
 746         }
 747         g_variant_iter_free(iter);
 748
 749         ret = iptables_add_rule_list(iptables_list);
 750
 751         g_slist_free_full(iptables_list, __free_rule);
 752
 753         clock_gettime(CLOCK_MONOTONIC, &end);
 754
 755         sec = end.tv_sec - start.tv_sec;
 756         nsec = end.tv_nsec - start.tv_nsec;
 757         if (nsec < 0)
 758                 nsec += 1000000000;
 759
 760         STC_LOGD("%s to add list [%3ld.%09ld]s",
 761                 ret == STC_ERROR_NONE ? "Successed" : "Failed", sec, nsec);
 762
 763         return_parameters = g_variant_new("(i)", ret);
 764
 765         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 766         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 767
 768         __LOG_FUNC_EXIT__;
 769         return TRUE;
 770 }
 771
 772 gboolean handle_iptables_remove_list(StcRule *object,
 773                                GDBusMethodInvocation *invocation,
 774                                GVariant *rule_list,
 775                                void *user_data)
 776 {
 777         __LOG_FUNC_ENTER__;
 778         GVariantIter *iter = NULL;
 779         GVariantIter *iter_row = NULL;
 780         stc_error_e ret = STC_ERROR_NONE;
 781         GSList *iptables_list = NULL;
 782         GVariant *return_parameters = NULL;
 783         struct timespec start, end;
 784         time_t sec;
 785         long int nsec;
 786
 787         stc_set_keep_alive(TRUE);
 788
 789         clock_gettime(CLOCK_MONOTONIC, &start);
 790
 791         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 792
 793         g_variant_get(rule_list, "aa{sv}", &iter);
 794         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 795                 iptables_rule_s *rule = MALLOC0(iptables_rule_s, 1);
 796                 if (rule != NULL) {
 797                         stc_iptables_gdbus_dict_foreach(iter_row,
 798                                                         __stc_extract_rule,
 799                                                         rule);
 800
 801                         iptables_list = g_slist_append(iptables_list, rule);
 802                 }
 803                 g_variant_iter_free(iter_row);
 804         }
 805         g_variant_iter_free(iter);
 806
 807         ret = iptables_remove_rule_list(iptables_list);
 808
 809         g_slist_free_full(iptables_list, __free_rule);
 810
 811         clock_gettime(CLOCK_MONOTONIC, &end);
 812
 813         sec = end.tv_sec - start.tv_sec;
 814         nsec = end.tv_nsec - start.tv_nsec;
 815         if (nsec < 0)
 816                 nsec += 1000000000;
 817
 818         STC_LOGD("%s to remove list [%3ld.%09ld]s",
 819                 ret == STC_ERROR_NONE ? "Successed" : "Failed", sec, nsec);
 820
 821         return_parameters = g_variant_new("(i)", ret);
 822
 823         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 824         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 825
 826         __LOG_FUNC_EXIT__;
 827         return TRUE;
 828 }
 829
 830 gboolean handle_ip6tables_add_rule(StcRule *object,
 831                                GDBusMethodInvocation *invocation,
 832                                GVariant *rules,
 833                                void *user_data)
 834 {
 835         __LOG_FUNC_ENTER__;
 836         stc_error_e ret = STC_ERROR_NONE;
 837         GVariant *return_parameters = NULL;
 838
 839         stc_set_keep_alive(TRUE);
 840
 841         if (rules != NULL) {
 842                 GVariantIter *iter = NULL;
 843
 844                 g_variant_get(rules, "a{sv}", &iter);
 845
 846                 ip6tables_rule_s *rule = MALLOC0(ip6tables_rule_s, 1);
 847                 if (rule != NULL) {
 848                         memset(rule, 0, sizeof(ip6tables_rule_s));
 849
 850                         stc_iptables_gdbus_dict_foreach(iter,
 851                                                         __stc_extract_6_rule,
 852                                                         rule);
 853
 854                         ret = ip6tables_add_rule(rule);
 855                         if (ret != STC_ERROR_NONE) {
 856                                  //LCOV_EXCL_START
 857                                 STC_LOGE("Failed add rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 858                                          rule->direction, rule->ifname, rule->classid,
 859                                          rule->nfacct_name, rule->target);
 860
 861                                 __free_6_rule(rule);
 862                                 g_variant_iter_free(iter);
 863
 864                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 865                                 __LOG_FUNC_EXIT__;
 866                                 return TRUE;
 867                                  //LCOV_EXCL_STOP
 868                         }
 869
 870                         __free_6_rule(rule);
 871                 }
 872
 873                 g_variant_iter_free(iter);
 874         } else {
 875                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 876                                               STC_ERROR_INVALID_PARAMETER);
 877                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 878                 return TRUE; //LCOV_EXCL_LINE
 879         }
 880
 881         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 882
 883         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 884         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 885
 886         __LOG_FUNC_EXIT__;
 887         return TRUE;
 888 }
 889
 890 gboolean handle_ip6tables_insert_rule(StcRule *object,
 891                                GDBusMethodInvocation *invocation,
 892                                GVariant *rules,
 893                                void *user_data)
 894 {
 895         __LOG_FUNC_ENTER__;
 896         stc_error_e ret = STC_ERROR_NONE;
 897         GVariant *return_parameters = NULL;
 898
 899         stc_set_keep_alive(TRUE);
 900
 901         if (rules != NULL) {
 902                 GVariantIter *iter = NULL;
 903
 904                 g_variant_get(rules, "a{sv}", &iter);
 905
 906                 ip6tables_rule_s *rule = MALLOC0(ip6tables_rule_s, 1);
 907                 if (rule != NULL) {
 908                         memset(rule, 0, sizeof(ip6tables_rule_s));
 909
 910                         stc_iptables_gdbus_dict_foreach(iter,
 911                                                         __stc_extract_6_rule,
 912                                                         rule);
 913
 914                         ret = ip6tables_insert_rule(rule);
 915                         if (ret != STC_ERROR_NONE) {
 916                                  //LCOV_EXCL_START
 917                                 STC_LOGE("Failed insert rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 918                                          rule->direction, rule->ifname, rule->classid,
 919                                          rule->nfacct_name, rule->target);
 920
 921                                 __free_6_rule(rule);
 922                                 g_variant_iter_free(iter);
 923
 924                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 925                                 __LOG_FUNC_EXIT__;
 926                                 return TRUE;
 927                                  //LCOV_EXCL_STOP
 928                         }
 929
 930                         __free_6_rule(rule);
 931                 }
 932
 933                 g_variant_iter_free(iter);
 934         } else {
 935                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 936                                               STC_ERROR_INVALID_PARAMETER);
 937                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 938                 return TRUE; //LCOV_EXCL_LINE
 939         }
 940
 941         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 942
 943         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 944         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 945
 946         __LOG_FUNC_EXIT__;
 947         return TRUE;
 948 }
 949
 950 gboolean handle_ip6tables_remove_rule(StcRule *object,
 951                                GDBusMethodInvocation *invocation,
 952                                GVariant *rules,
 953                                void *user_data)
 954 {
 955         __LOG_FUNC_ENTER__;
 956         stc_error_e ret = STC_ERROR_NONE;
 957         GVariant *return_parameters = NULL;
 958
 959         stc_set_keep_alive(TRUE);
 960
 961         if (rules != NULL) {
 962                 GVariantIter *iter = NULL;
 963                 g_variant_get(rules, "a{sv}", &iter);
 964
 965                 ip6tables_rule_s *rule = MALLOC0(ip6tables_rule_s, 1);
 966                 if (rule != NULL) {
 967                         memset(rule, 0, sizeof(ip6tables_rule_s));
 968
 969                         stc_iptables_gdbus_dict_foreach(iter,
 970                                                         __stc_extract_6_rule,
 971                                                         rule);
 972
 973                         ret = ip6tables_remove_rule(rule);
 974                         if (ret != STC_ERROR_NONE) {
 975                                  //LCOV_EXCL_START
 976                                 STC_LOGE("Failed remove rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 977                                          rule->direction, rule->ifname, rule->classid,
 978                                          rule->nfacct_name, rule->target);
 979
 980                                 __free_6_rule(rule);
 981                                 g_variant_iter_free(iter);
 982
 983                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 984                                 __LOG_FUNC_EXIT__;
 985                                 return TRUE;
 986                                  //LCOV_EXCL_STOP
 987                         }
 988
 989                         __free_6_rule(rule);
 990                 }
 991
 992                 g_variant_iter_free(iter);
 993         } else {
 994                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 995                                               STC_ERROR_INVALID_PARAMETER);
 996                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 997                 return TRUE; //LCOV_EXCL_LINE
 998         }
 999
1000         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
1001
1002         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
1003         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
1004
1005         __LOG_FUNC_EXIT__;
1006         return TRUE;
1007 }
1008
1009 gboolean handle_ip6tables_add_chain(StcChain *object,
1010                                GDBusMethodInvocation *invocation,
1011                                const gchar *chain,
1012                                void *user_data)
1013 {
1014         __LOG_FUNC_ENTER__;
1015         stc_error_e ret = STC_ERROR_NONE;
1016         GVariant *return_parameters = NULL;
1017
1018         stc_set_keep_alive(TRUE);
1019
1020         ret = ip6tables_add_chain(chain);
1021         if (ret < STC_ERROR_NONE) {
1022                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
1023                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
1024                 return TRUE; //LCOV_EXCL_LINE
1025         }
1026
1027         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
1028
1029         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
1030         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
1031
1032         __LOG_FUNC_EXIT__;
1033         return TRUE;
1034 }
1035
1036 gboolean handle_ip6tables_remove_chain(StcChain *object,
1037                                GDBusMethodInvocation *invocation,
1038                                const gchar *chain,
1039                                void *user_data)
1040 {
1041         __LOG_FUNC_ENTER__;
1042         stc_error_e ret = STC_ERROR_NONE;
1043         GVariant *return_parameters = NULL;
1044
1045         stc_set_keep_alive(TRUE);
1046
1047         ret = ip6tables_remove_chain(chain);
1048         if (ret < STC_ERROR_NONE) {
1049                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
1050                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
1051                 return TRUE; //LCOV_EXCL_LINE
1052         }
1053
1054         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
1055
1056         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
1057         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
1058
1059         __LOG_FUNC_EXIT__;
1060         return TRUE;
1061 }
1062
1063 gboolean handle_ip6tables_flush_chain(StcChain *object,
1064                                GDBusMethodInvocation *invocation,
1065                                const gchar *chain,
1066                                void *user_data)
1067 {
1068         __LOG_FUNC_ENTER__;
1069         stc_error_e ret = STC_ERROR_NONE;
1070         GVariant *return_parameters = NULL;
1071
1072         stc_set_keep_alive(TRUE);
1073
1074         ret = ip6tables_flush_chain(chain);
1075         if (ret < STC_ERROR_NONE) {
1076                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
1077                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
1078                 return TRUE; //LCOV_EXCL_LINE
1079         }
1080
1081         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
1082
1083         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
1084         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
1085
1086         __LOG_FUNC_EXIT__;
1087         return TRUE;
1088 }
1089
1090 gboolean handle_ip6tables_add_list(StcRule *object,
1091                                GDBusMethodInvocation *invocation,
1092                                GVariant *rule_list,
1093                                void *user_data)
1094 {
1095         __LOG_FUNC_ENTER__;
1096         GVariantIter *iter = NULL;
1097         GVariantIter *iter_row = NULL;
1098         stc_error_e ret = STC_ERROR_NONE;
1099         GSList *iptables_list = NULL;
1100         GVariant *return_parameters = NULL;
1101         struct timespec start, end;
1102         time_t sec;
1103         long int nsec;
1104
1105         stc_set_keep_alive(TRUE);
1106
1107         clock_gettime(CLOCK_MONOTONIC, &start);
1108
1109         g_variant_get(rule_list, "aa{sv}", &iter);
1110         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
1111                 ip6tables_rule_s *rule = MALLOC0(ip6tables_rule_s, 1);
1112                 if (rule != NULL) {
1113                         stc_iptables_gdbus_dict_foreach(iter_row,
1114                                                         __stc_extract_6_rule,
1115                                                         rule);
1116
1117                         iptables_list = g_slist_append(iptables_list, rule);
1118                 }
1119                 g_variant_iter_free(iter_row);
1120         }
1121         g_variant_iter_free(iter);
1122
1123         clock_gettime(CLOCK_MONOTONIC, &end);
1124
1125         ret = ip6tables_add_rule_list(iptables_list);
1126
1127         g_slist_free_full(iptables_list, __free_6_rule);
1128
1129         sec = end.tv_sec - start.tv_sec;
1130         nsec = end.tv_nsec - start.tv_nsec;
1131         if (nsec < 0)
1132                 nsec += 1000000000;
1133
1134         STC_LOGD("%s to add list [%3ld.%09ld]s",
1135                 ret == STC_ERROR_NONE ? "Successed" : "Failed", sec, nsec);
1136
1137         return_parameters = g_variant_new("(i)", ret);
1138
1139         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
1140         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
1141
1142         __LOG_FUNC_EXIT__;
1143         return TRUE;
1144 }
1145
1146 gboolean handle_ip6tables_remove_list(StcRule *object,
1147                                GDBusMethodInvocation *invocation,
1148                                GVariant *rule_list,
1149                                void *user_data)
1150 {
1151         __LOG_FUNC_ENTER__;
1152         GVariantIter *iter = NULL;
1153         GVariantIter *iter_row = NULL;
1154         stc_error_e ret = STC_ERROR_NONE;
1155         GSList *iptables_list = NULL;
1156         GVariant *return_parameters = NULL;
1157         struct timespec start, end;
1158         time_t sec;
1159         long int nsec;
1160
1161         stc_set_keep_alive(TRUE);
1162
1163         clock_gettime(CLOCK_MONOTONIC, &start);
1164
1165         g_variant_get(rule_list, "aa{sv}", &iter);
1166         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
1167                 ip6tables_rule_s *rule = MALLOC0(ip6tables_rule_s, 1);
1168                 if (rule != NULL) {
1169                         stc_iptables_gdbus_dict_foreach(iter_row,
1170                                                         __stc_extract_6_rule,
1171                                                         rule);
1172
1173                         iptables_list = g_slist_append(iptables_list, rule);
1174                 }
1175                 g_variant_iter_free(iter_row);
1176         }
1177         g_variant_iter_free(iter);
1178
1179         ret = ip6tables_remove_rule_list(iptables_list);
1180
1181         g_slist_free_full(iptables_list, __free_6_rule);
1182
1183         clock_gettime(CLOCK_MONOTONIC, &end);
1184
1185         sec = end.tv_sec - start.tv_sec;
1186         nsec = end.tv_nsec - start.tv_nsec;
1187         if (nsec < 0)
1188                 nsec += 1000000000;
1189
1190         STC_LOGD("%s to add list [%3ld.%09ld]s",
1191                 ret == STC_ERROR_NONE ? "Successed" : "Failed", sec, nsec);
1192
1193         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
1194
1195         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
1196         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
1197
1198         __LOG_FUNC_EXIT__;
1199         return TRUE;
1200 }