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(iptables_rule_s *rule)
 411 {
 412         FREE(rule->chain);
 413         FREE(rule->ifname);
 414         FREE(rule->nfacct_name);
 415         FREE(rule->target);
 416         FREE(rule->log_prefix);
 417         FREE(rule->nflog_prefix);
 418         FREE(rule);
 419 }
 420
 421 static void __free_6_rule(ip6tables_rule_s *rule)
 422 {
 423         FREE(rule->chain);
 424         FREE(rule->ifname);
 425         FREE(rule->nfacct_name);
 426         FREE(rule->target);
 427         FREE(rule->log_prefix);
 428         FREE(rule->nflog_prefix);
 429         FREE(rule);
 430 }
 431
 432 gboolean handle_iptables_stop(StcManager *object,
 433                                    GDBusMethodInvocation *invocation)
 434 {
 435         __LOG_FUNC_ENTER__;
 436         GVariant *return_parameters = NULL;
 437
 438         STC_LOGI("stc manager stop");
 439         stc_set_keep_alive(TRUE);
 440
 441         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 442
 443         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 444         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 445
 446         stc_stop_iptables();
 447
 448         __LOG_FUNC_EXIT__;
 449         return TRUE;
 450 }
 451
 452 gboolean handle_iptables_add_rule(StcRule *object,
 453                                GDBusMethodInvocation *invocation,
 454                                GVariant *rules,
 455                                void *user_data)
 456 {
 457         __LOG_FUNC_ENTER__;
 458         stc_error_e ret = STC_ERROR_NONE;
 459         GVariant *return_parameters = NULL;
 460
 461         stc_set_keep_alive(TRUE);
 462
 463         if (rules != NULL) {
 464                 GVariantIter *iter = NULL;
 465
 466                 g_variant_get(rules, "a{sv}", &iter);
 467
 468                 iptables_rule_s *rule = MALLOC0(iptables_rule_s, 1);
 469                 if (rule != NULL) {
 470                         memset(rule, 0, sizeof(iptables_rule_s));
 471
 472                         stc_iptables_gdbus_dict_foreach(iter,
 473                                                         __stc_extract_rule,
 474                                                         rule);
 475
 476                         ret = iptables_add_rule(rule);
 477                         if (ret != STC_ERROR_NONE) {
 478                                  //LCOV_EXCL_START
 479                                 STC_LOGE("Failed add rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 480                                          rule->direction, rule->ifname, rule->classid,
 481                                          rule->nfacct_name, rule->target);
 482
 483                                 __free_rule(rule);
 484                                 g_variant_iter_free(iter);
 485
 486                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 487                                 __LOG_FUNC_EXIT__;
 488                                 return TRUE;
 489                                  //LCOV_EXCL_STOP
 490                         }
 491
 492                         __free_rule(rule);
 493                 }
 494
 495                 g_variant_iter_free(iter);
 496         } else {
 497                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 498                                               STC_ERROR_INVALID_PARAMETER);
 499                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 500                 return TRUE; //LCOV_EXCL_LINE
 501         }
 502
 503         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 504
 505         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 506         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 507
 508         __LOG_FUNC_EXIT__;
 509         return TRUE;
 510 }
 511
 512 gboolean handle_iptables_insert_rule(StcRule *object,
 513                                GDBusMethodInvocation *invocation,
 514                                GVariant *rules,
 515                                void *user_data)
 516 {
 517         __LOG_FUNC_ENTER__;
 518         stc_error_e ret = STC_ERROR_NONE;
 519         GVariant *return_parameters = NULL;
 520
 521         stc_set_keep_alive(TRUE);
 522
 523         if (rules != NULL) {
 524                 GVariantIter *iter = NULL;
 525
 526                 g_variant_get(rules, "a{sv}", &iter);
 527
 528                 iptables_rule_s *rule = MALLOC0(iptables_rule_s, 1);
 529                 if (rule != NULL) {
 530                         memset(rule, 0, sizeof(iptables_rule_s));
 531
 532                         stc_iptables_gdbus_dict_foreach(iter,
 533                                                         __stc_extract_rule,
 534                                                         rule);
 535
 536                         ret = iptables_insert_rule(rule);
 537                         if (ret != STC_ERROR_NONE) {
 538                                  //LCOV_EXCL_START
 539                                 STC_LOGE("Failed insert rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 540                                          rule->direction, rule->ifname, rule->classid,
 541                                          rule->nfacct_name, rule->target);
 542
 543                                 __free_rule(rule);
 544                                 g_variant_iter_free(iter);
 545
 546                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 547                                 __LOG_FUNC_EXIT__;
 548                                 return TRUE;
 549                                  //LCOV_EXCL_STOP
 550                         }
 551
 552                         __free_rule(rule);
 553                 }
 554
 555                 g_variant_iter_free(iter);
 556         } else {
 557                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 558                                               STC_ERROR_INVALID_PARAMETER);
 559                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 560                 return TRUE; //LCOV_EXCL_LINE
 561         }
 562
 563         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 564
 565         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 566         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 567
 568         __LOG_FUNC_EXIT__;
 569         return TRUE;
 570 }
 571
 572 gboolean handle_iptables_remove_rule(StcRule *object,
 573                                GDBusMethodInvocation *invocation,
 574                                GVariant *rules,
 575                                void *user_data)
 576 {
 577         __LOG_FUNC_ENTER__;
 578         stc_error_e ret = STC_ERROR_NONE;
 579         GVariant *return_parameters = NULL;
 580
 581         stc_set_keep_alive(TRUE);
 582
 583         if (rules != NULL) {
 584                 GVariantIter *iter = NULL;
 585                 g_variant_get(rules, "a{sv}", &iter);
 586
 587                 iptables_rule_s *rule = MALLOC0(iptables_rule_s, 1);
 588                 if (rule != NULL) {
 589                         memset(rule, 0, sizeof(iptables_rule_s));
 590
 591                         stc_iptables_gdbus_dict_foreach(iter,
 592                                                         __stc_extract_rule,
 593                                                         rule);
 594
 595                         ret = iptables_remove_rule(rule);
 596                         if (ret != STC_ERROR_NONE) {
 597                                  //LCOV_EXCL_START
 598                                 STC_LOGE("Failed remove rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 599                                          rule->direction, rule->ifname, rule->classid,
 600                                          rule->nfacct_name, rule->target);
 601
 602                                 __free_rule(rule);
 603                                 g_variant_iter_free(iter);
 604
 605                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 606                                 __LOG_FUNC_EXIT__;
 607                                 return TRUE;
 608                                  //LCOV_EXCL_STOP
 609                         }
 610
 611                         __free_rule(rule);
 612                 }
 613
 614                 g_variant_iter_free(iter);
 615         } else {
 616                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 617                                               STC_ERROR_INVALID_PARAMETER);
 618                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 619                 return TRUE; //LCOV_EXCL_LINE
 620         }
 621
 622         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 623
 624         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 625         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 626
 627         __LOG_FUNC_EXIT__;
 628         return TRUE;
 629 }
 630
 631 gboolean handle_iptables_add_chain(StcChain *object,
 632                                    GDBusMethodInvocation *invocation,
 633                                    const gchar *chain,
 634                                    void *user_data)
 635 {
 636         __LOG_FUNC_ENTER__;
 637         stc_error_e ret = STC_ERROR_NONE;
 638         GVariant *return_parameters = NULL;
 639
 640         stc_set_keep_alive(TRUE);
 641
 642         ret = iptables_add_chain(chain);
 643         if (ret < STC_ERROR_NONE) {
 644                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 645                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 646                 return TRUE; //LCOV_EXCL_LINE
 647         }
 648
 649         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 650
 651         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 652         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 653
 654         __LOG_FUNC_EXIT__;
 655         return TRUE;
 656 }
 657
 658 gboolean handle_iptables_remove_chain(StcChain *object,
 659                                GDBusMethodInvocation *invocation,
 660                                const gchar *chain,
 661                                void *user_data)
 662 {
 663         __LOG_FUNC_ENTER__;
 664         stc_error_e ret = STC_ERROR_NONE;
 665         GVariant *return_parameters = NULL;
 666
 667         stc_set_keep_alive(TRUE);
 668
 669         ret = iptables_remove_chain(chain);
 670         if (ret < STC_ERROR_NONE) {
 671                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 672                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 673                 return TRUE; //LCOV_EXCL_LINE
 674         }
 675
 676         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 677
 678         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 679         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 680
 681         __LOG_FUNC_EXIT__;
 682         return TRUE;
 683 }
 684
 685 gboolean handle_iptables_flush_chain(StcChain *object,
 686                                GDBusMethodInvocation *invocation,
 687                                const gchar *chain,
 688                                void *user_data)
 689 {
 690         __LOG_FUNC_ENTER__;
 691         stc_error_e ret = STC_ERROR_NONE;
 692         GVariant *return_parameters = NULL;
 693
 694         stc_set_keep_alive(TRUE);
 695
 696         ret = iptables_flush_chain(chain);
 697         if (ret < STC_ERROR_NONE) {
 698                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 699                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 700                 return TRUE; //LCOV_EXCL_LINE
 701         }
 702
 703         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 704
 705         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 706         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 707
 708         __LOG_FUNC_EXIT__;
 709         return TRUE;
 710 }
 711
 712 gboolean handle_ip6tables_add_rule(StcRule *object,
 713                                GDBusMethodInvocation *invocation,
 714                                GVariant *rules,
 715                                void *user_data)
 716 {
 717         __LOG_FUNC_ENTER__;
 718         stc_error_e ret = STC_ERROR_NONE;
 719         GVariant *return_parameters = NULL;
 720
 721         stc_set_keep_alive(TRUE);
 722
 723         if (rules != NULL) {
 724                 GVariantIter *iter = NULL;
 725
 726                 g_variant_get(rules, "a{sv}", &iter);
 727
 728                 ip6tables_rule_s *rule = MALLOC0(ip6tables_rule_s, 1);
 729                 if (rule != NULL) {
 730                         memset(rule, 0, sizeof(ip6tables_rule_s));
 731
 732                         stc_iptables_gdbus_dict_foreach(iter,
 733                                                         __stc_extract_6_rule,
 734                                                         rule);
 735
 736                         ret = ip6tables_add_rule(rule);
 737                         if (ret != STC_ERROR_NONE) {
 738                                  //LCOV_EXCL_START
 739                                 STC_LOGE("Failed add rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 740                                          rule->direction, rule->ifname, rule->classid,
 741                                          rule->nfacct_name, rule->target);
 742
 743                                 __free_6_rule(rule);
 744                                 g_variant_iter_free(iter);
 745
 746                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 747                                 __LOG_FUNC_EXIT__;
 748                                 return TRUE;
 749                                  //LCOV_EXCL_STOP
 750                         }
 751
 752                         __free_6_rule(rule);
 753                 }
 754
 755                 g_variant_iter_free(iter);
 756         } else {
 757                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 758                                               STC_ERROR_INVALID_PARAMETER);
 759                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 760                 return TRUE; //LCOV_EXCL_LINE
 761         }
 762
 763         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 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_ip6tables_insert_rule(StcRule *object,
 773                                GDBusMethodInvocation *invocation,
 774                                GVariant *rules,
 775                                void *user_data)
 776 {
 777         __LOG_FUNC_ENTER__;
 778         stc_error_e ret = STC_ERROR_NONE;
 779         GVariant *return_parameters = NULL;
 780
 781         stc_set_keep_alive(TRUE);
 782
 783         if (rules != NULL) {
 784                 GVariantIter *iter = NULL;
 785
 786                 g_variant_get(rules, "a{sv}", &iter);
 787
 788                 ip6tables_rule_s *rule = MALLOC0(ip6tables_rule_s, 1);
 789                 if (rule != NULL) {
 790                         memset(rule, 0, sizeof(ip6tables_rule_s));
 791
 792                         stc_iptables_gdbus_dict_foreach(iter,
 793                                                         __stc_extract_6_rule,
 794                                                         rule);
 795
 796                         ret = ip6tables_insert_rule(rule);
 797                         if (ret != STC_ERROR_NONE) {
 798                                  //LCOV_EXCL_START
 799                                 STC_LOGE("Failed insert rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 800                                          rule->direction, rule->ifname, rule->classid,
 801                                          rule->nfacct_name, rule->target);
 802
 803                                 __free_6_rule(rule);
 804                                 g_variant_iter_free(iter);
 805
 806                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 807                                 __LOG_FUNC_EXIT__;
 808                                 return TRUE;
 809                                  //LCOV_EXCL_STOP
 810                         }
 811
 812                         __free_6_rule(rule);
 813                 }
 814
 815                 g_variant_iter_free(iter);
 816         } else {
 817                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 818                                               STC_ERROR_INVALID_PARAMETER);
 819                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 820                 return TRUE; //LCOV_EXCL_LINE
 821         }
 822
 823         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 824
 825         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 826         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 827
 828         __LOG_FUNC_EXIT__;
 829         return TRUE;
 830 }
 831
 832 gboolean handle_ip6tables_remove_rule(StcRule *object,
 833                                GDBusMethodInvocation *invocation,
 834                                GVariant *rules,
 835                                void *user_data)
 836 {
 837         __LOG_FUNC_ENTER__;
 838         stc_error_e ret = STC_ERROR_NONE;
 839         GVariant *return_parameters = NULL;
 840
 841         stc_set_keep_alive(TRUE);
 842
 843         if (rules != NULL) {
 844                 GVariantIter *iter = NULL;
 845                 g_variant_get(rules, "a{sv}", &iter);
 846
 847                 ip6tables_rule_s *rule = MALLOC0(ip6tables_rule_s, 1);
 848                 if (rule != NULL) {
 849                         memset(rule, 0, sizeof(ip6tables_rule_s));
 850
 851                         stc_iptables_gdbus_dict_foreach(iter,
 852                                                         __stc_extract_6_rule,
 853                                                         rule);
 854
 855                         ret = ip6tables_remove_rule(rule);
 856                         if (ret != STC_ERROR_NONE) {
 857                                  //LCOV_EXCL_START
 858                                 STC_LOGE("Failed remove rule [%s:%d:%s:%d:%s:%s]", rule->chain,
 859                                          rule->direction, rule->ifname, rule->classid,
 860                                          rule->nfacct_name, rule->target);
 861
 862                                 __free_6_rule(rule);
 863                                 g_variant_iter_free(iter);
 864
 865                                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret);
 866                                 __LOG_FUNC_EXIT__;
 867                                 return TRUE;
 868                                  //LCOV_EXCL_STOP
 869                         }
 870
 871                         __free_6_rule(rule);
 872                 }
 873
 874                 g_variant_iter_free(iter);
 875         } else {
 876                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
 877                                               STC_ERROR_INVALID_PARAMETER);
 878                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 879                 return TRUE; //LCOV_EXCL_LINE
 880         }
 881
 882         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 883
 884         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 885         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 886
 887         __LOG_FUNC_EXIT__;
 888         return TRUE;
 889 }
 890
 891 gboolean handle_ip6tables_add_chain(StcChain *object,
 892                                GDBusMethodInvocation *invocation,
 893                                const gchar *chain,
 894                                void *user_data)
 895 {
 896         __LOG_FUNC_ENTER__;
 897         stc_error_e ret = STC_ERROR_NONE;
 898         GVariant *return_parameters = NULL;
 899
 900         stc_set_keep_alive(TRUE);
 901
 902         ret = ip6tables_add_chain(chain);
 903         if (ret < STC_ERROR_NONE) {
 904                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 905                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 906                 return TRUE; //LCOV_EXCL_LINE
 907         }
 908
 909         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 910
 911         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 912         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 913
 914         __LOG_FUNC_EXIT__;
 915         return TRUE;
 916 }
 917
 918 gboolean handle_ip6tables_remove_chain(StcChain *object,
 919                                GDBusMethodInvocation *invocation,
 920                                const gchar *chain,
 921                                void *user_data)
 922 {
 923         __LOG_FUNC_ENTER__;
 924         stc_error_e ret = STC_ERROR_NONE;
 925         GVariant *return_parameters = NULL;
 926
 927         stc_set_keep_alive(TRUE);
 928
 929         ret = ip6tables_remove_chain(chain);
 930         if (ret < STC_ERROR_NONE) {
 931                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 932                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 933                 return TRUE; //LCOV_EXCL_LINE
 934         }
 935
 936         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 937
 938         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 939         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 940
 941         __LOG_FUNC_EXIT__;
 942         return TRUE;
 943 }
 944
 945 gboolean handle_ip6tables_flush_chain(StcChain *object,
 946                                GDBusMethodInvocation *invocation,
 947                                const gchar *chain,
 948                                void *user_data)
 949 {
 950         __LOG_FUNC_ENTER__;
 951         stc_error_e ret = STC_ERROR_NONE;
 952         GVariant *return_parameters = NULL;
 953
 954         stc_set_keep_alive(TRUE);
 955
 956         ret = ip6tables_flush_chain(chain);
 957         if (ret < STC_ERROR_NONE) {
 958                 STC_IPTABLES_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
 959                 __LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
 960                 return TRUE; //LCOV_EXCL_LINE
 961         }
 962
 963         return_parameters = g_variant_new("(i)", STC_ERROR_NONE);
 964
 965         STC_DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
 966         STC_IPTABLES_DBUS_REPLY(invocation, return_parameters);
 967
 968         __LOG_FUNC_EXIT__;
 969         return TRUE;
 970 }