src/helper/helper-firewall.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "stc-manager-gdbus.h"
  18 #include "helper-firewall.h"
  19
  20 #define STC_FIREWALL_DBUS_SERVICE                    "net.stc.iptables"
  21 #define STC_FIREWALL_DBUS_RULE_INTERFACE             STC_FIREWALL_DBUS_SERVICE ".rule"
  22 #define STC_FIREWALL_DBUS_CHAIN_INTERFACE            STC_FIREWALL_DBUS_SERVICE ".chain"
  23 #define STC_FIREWALL_DBUS_RULE_PATH                  "/net/stc/iptables/rule"
  24 #define STC_FIREWALL_DBUS_CHAIN_PATH                 "/net/stc/iptables/chain"
  25
  26 #define STC_FIREWALL_DBUS_METHOD_ADD_CHAIN           "IptAddChain"
  27 #define STC_FIREWALL_DBUS_METHOD_REMOVE_CHAIN        "IptRemoveChain"
  28 #define STC_FIREWALL_DBUS_METHOD_FLUSH_CHAIN         "IptFlushChain"
  29 #define STC_FIREWALL6_DBUS_METHOD_ADD_CHAIN          "Ip6tAddChain"
  30 #define STC_FIREWALL6_DBUS_METHOD_REMOVE_CHAIN       "Ip6tRemoveChain"
  31 #define STC_FIREWALL6_DBUS_METHOD_FLUSH_CHAIN        "Ip6tFlushChain"
  32
  33 #define STC_FIREWALL_DBUS_METHOD_ADD_RULE            "IptAddRule"
  34 #define STC_FIREWALL_DBUS_METHOD_REMOVE_RULE         "IptRemoveRule"
  35 #define STC_FIREWALL6_DBUS_METHOD_ADD_RULE           "Ip6tAddRule"
  36 #define STC_FIREWALL6_DBUS_METHOD_REMOVE_RULE        "Ip6tRemoveRule"
  37
  38 #define BUF_SIZE_FOR_IP 64
  39
  40 #define RULE_CHAIN      "chain"
  41 #define RULE_DIRECTION  "direction"
  42 #define RULE_IFNAME     "ifname"
  43 #define RULE_PROTOCOL   "protocol"
  44 #define RULE_TARGET     "target"
  45
  46 #define RULE_FAMILY     "family"
  47 #define RULE_SIPTYPE    "s_ip_type"
  48 #define RULE_SIP1       "s_ip1"
  49 #define RULE_SIP2       "s_ip2"
  50 #define RULE_DIPTYPE    "d_ip_type"
  51 #define RULE_DIP1       "d_ip1"
  52 #define RULE_DIP2       "d_ip2"
  53 #define RULE_SPORTTYPE  "s_port_type"
  54 #define RULE_SPORT1     "s_port1"
  55 #define RULE_SPORT2     "s_port2"
  56 #define RULE_DPORTTYPE  "d_port_type"
  57 #define RULE_DPORT1     "d_port1"
  58 #define RULE_DPORT2     "d_port2"
  59
  60 static void __fw_add_rule_info_to_builder(GVariantBuilder *builder,
  61                                        firewall_rule_s *rule)
  62 {
  63         if (builder == NULL || rule == NULL)
  64                 return;
  65
  66         g_variant_builder_add(builder, "{sv}", RULE_CHAIN,
  67                         g_variant_new_string(rule->chain));
  68
  69         if (rule->direction != STC_FW_DIRECTION_NONE)
  70                 g_variant_builder_add(builder, "{sv}", RULE_DIRECTION,
  71                                 g_variant_new_uint16(rule->direction));
  72
  73         if (rule->s_ip_type != STC_FW_IP_NONE)
  74                 g_variant_builder_add(builder, "{sv}", RULE_SIPTYPE,
  75                                 g_variant_new_uint16(rule->s_ip_type));
  76
  77         if (rule->d_ip_type != STC_FW_IP_NONE)
  78                 g_variant_builder_add(builder, "{sv}", RULE_DIPTYPE,
  79                                 g_variant_new_uint16(rule->d_ip_type));
  80
  81         if (rule->s_port_type != STC_FW_PORT_NONE)
  82                 g_variant_builder_add(builder, "{sv}", RULE_SPORTTYPE,
  83                                 g_variant_new_uint16(rule->s_port_type));
  84
  85         if (rule->d_port_type != STC_FW_PORT_NONE)
  86                 g_variant_builder_add(builder, "{sv}", RULE_DPORTTYPE,
  87                                 g_variant_new_uint16(rule->d_port_type));
  88
  89         if (rule->protocol != STC_FW_PROTOCOL_NONE)
  90                 g_variant_builder_add(builder, "{sv}", RULE_PROTOCOL,
  91                                 g_variant_new_uint16(rule->protocol));
  92
  93         switch (rule->family) {
  94         case STC_FW_FAMILY_V4:
  95                 if (rule->s_ip1.Ipv4.s_addr)
  96                         g_variant_builder_add(builder, "{sv}", RULE_SIP1,
  97                                         g_variant_new_uint32(rule->s_ip1.Ipv4.s_addr));
  98
  99                 if (rule->s_ip2.Ipv4.s_addr)
 100                         g_variant_builder_add(builder, "{sv}", RULE_SIP2,
 101                                         g_variant_new_uint32(rule->s_ip2.Ipv4.s_addr));
 102
 103                 if (rule->d_ip1.Ipv4.s_addr)
 104                         g_variant_builder_add(builder, "{sv}", RULE_DIP1,
 105                                         g_variant_new_uint32(rule->d_ip1.Ipv4.s_addr));
 106
 107                 if (rule->d_ip2.Ipv4.s_addr)
 108                         g_variant_builder_add(builder, "{sv}", RULE_DIP2,
 109                                         g_variant_new_uint32(rule->d_ip2.Ipv4.s_addr));
 110
 111                 break;
 112         case STC_FW_FAMILY_V6:
 113                 {
 114                         char buf[BUF_SIZE_FOR_IP];
 115
 116                         if (rule->s_ip1.Ipv6.s6_addr32[0] || rule->s_ip1.Ipv6.s6_addr32[1] ||
 117                                 rule->s_ip1.Ipv6.s6_addr32[2] || rule->s_ip1.Ipv6.s6_addr32[3]) {
 118                                 memset(buf, 0, sizeof(buf));
 119                                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 120                                         rule->s_ip1.Ipv6.s6_addr32[0], rule->s_ip1.Ipv6.s6_addr32[1],
 121                                         rule->s_ip1.Ipv6.s6_addr32[2], rule->s_ip1.Ipv6.s6_addr32[3]);
 122                                 g_variant_builder_add(builder, "{sv}", RULE_SIP1,
 123                                                         g_variant_new_string(buf));
 124                         }
 125
 126                         if (rule->s_ip2.Ipv6.s6_addr32[0] || rule->s_ip2.Ipv6.s6_addr32[1] ||
 127                                 rule->s_ip2.Ipv6.s6_addr32[2] || rule->s_ip2.Ipv6.s6_addr32[3]) {
 128                                 memset(buf, 0, sizeof(buf));
 129                                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 130                                         rule->s_ip2.Ipv6.s6_addr32[0], rule->s_ip2.Ipv6.s6_addr32[1],
 131                                         rule->s_ip2.Ipv6.s6_addr32[2], rule->s_ip2.Ipv6.s6_addr32[3]);
 132                                 g_variant_builder_add(builder, "{sv}", RULE_SIP2,
 133                                                         g_variant_new_string(buf));
 134                         }
 135
 136                         if (rule->d_ip1.Ipv6.s6_addr32[0] || rule->d_ip1.Ipv6.s6_addr32[1] ||
 137                                 rule->d_ip1.Ipv6.s6_addr32[2] || rule->d_ip1.Ipv6.s6_addr32[3]) {
 138                                 memset(buf, 0, sizeof(buf));
 139                                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 140                                         rule->d_ip1.Ipv6.s6_addr32[0], rule->d_ip1.Ipv6.s6_addr32[1],
 141                                         rule->d_ip1.Ipv6.s6_addr32[2], rule->d_ip1.Ipv6.s6_addr32[3]);
 142                                 g_variant_builder_add(builder, "{sv}", RULE_DIP1,
 143                                                         g_variant_new_string(buf));
 144                         }
 145
 146                         if (rule->d_ip2.Ipv6.s6_addr32[0] || rule->d_ip2.Ipv6.s6_addr32[1] ||
 147                                 rule->d_ip2.Ipv6.s6_addr32[2] || rule->d_ip2.Ipv6.s6_addr32[3]) {
 148                                 memset(buf, 0, sizeof(buf));
 149                                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 150                                         rule->d_ip2.Ipv6.s6_addr32[0], rule->d_ip2.Ipv6.s6_addr32[1],
 151                                         rule->d_ip2.Ipv6.s6_addr32[2], rule->d_ip2.Ipv6.s6_addr32[3]);
 152                                 g_variant_builder_add(builder, "{sv}", RULE_DIP2,
 153                                                         g_variant_new_string(buf));
 154                         }
 155                 }
 156                 break;
 157         default:
 158                 break;
 159         }
 160
 161         if (rule->s_port1)
 162                 g_variant_builder_add(builder, "{sv}", RULE_SPORT1,
 163                                 g_variant_new_uint32(rule->s_port1));
 164
 165         if (rule->s_port2)
 166                 g_variant_builder_add(builder, "{sv}", RULE_SPORT2,
 167                                 g_variant_new_uint32(rule->s_port2));
 168
 169         if (rule->d_port1)
 170                 g_variant_builder_add(builder, "{sv}", RULE_DPORT1,
 171                                 g_variant_new_uint32(rule->d_port1));
 172
 173         if (rule->d_port2)
 174                 g_variant_builder_add(builder, "{sv}", RULE_DPORT2,
 175                                 g_variant_new_uint32(rule->d_port2));
 176
 177         if (rule->ifname)
 178                 g_variant_builder_add(builder, "{sv}", RULE_IFNAME,
 179                                 g_variant_new_string(rule->ifname));
 180
 181         if (rule->target_str)
 182                 g_variant_builder_add(builder, "{sv}", RULE_TARGET,
 183                                 g_variant_new_string(rule->target_str));
 184 }
 185
 186 static int __fw_add_chain(GDBusConnection *connection,
 187                                 const char *chain)
 188 {
 189         int result = 0;
 190         GVariant *message = NULL;
 191
 192         message = stc_manager_gdbus_call_sync(connection,
 193                                               STC_FIREWALL_DBUS_SERVICE,
 194                                               STC_FIREWALL_DBUS_CHAIN_PATH,
 195                                               STC_FIREWALL_DBUS_CHAIN_INTERFACE,
 196                                               STC_FIREWALL_DBUS_METHOD_ADD_CHAIN,
 197                                               g_variant_new("(s)", chain));
 198
 199         if (message == NULL) {
 200                 STC_LOGE("Failed to invoke dbus method");
 201                 return STC_ERROR_FAIL;
 202         }
 203
 204         g_variant_get(message, "(i)", &result);
 205         STC_LOGD("Successfully added firewall chain [%d:%s]", result, chain);
 206         g_variant_unref(message);
 207
 208         return STC_ERROR_NONE;
 209 }
 210
 211 static int __fw6_add_chain(GDBusConnection *connection,
 212                                  const char *chain)
 213 {
 214         int result = 0;
 215         GVariant *message = NULL;
 216
 217         message = stc_manager_gdbus_call_sync(connection,
 218                                               STC_FIREWALL_DBUS_SERVICE,
 219                                               STC_FIREWALL_DBUS_CHAIN_PATH,
 220                                               STC_FIREWALL_DBUS_CHAIN_INTERFACE,
 221                                               STC_FIREWALL6_DBUS_METHOD_ADD_CHAIN,
 222                                               g_variant_new("(s)", chain));
 223
 224         if (message == NULL) {
 225                 STC_LOGE("Failed to invoke dbus method");
 226                 return STC_ERROR_FAIL;
 227         }
 228
 229         g_variant_get(message, "(i)", &result);
 230         STC_LOGD("Successfully added firewall6 chain [%d:%s]", result, chain);
 231         g_variant_unref(message);
 232
 233         return STC_ERROR_NONE;
 234 }
 235
 236 static int __fw_remove_chain(GDBusConnection *connection,
 237                                    const char *chain)
 238 {
 239         int result = 0;
 240         GVariant *message = NULL;
 241
 242         message = stc_manager_gdbus_call_sync(connection,
 243                                               STC_FIREWALL_DBUS_SERVICE,
 244                                               STC_FIREWALL_DBUS_CHAIN_PATH,
 245                                               STC_FIREWALL_DBUS_CHAIN_INTERFACE,
 246                                               STC_FIREWALL_DBUS_METHOD_REMOVE_CHAIN,
 247                                               g_variant_new("(s)", chain));
 248
 249         if (message == NULL) {
 250                 STC_LOGE("Failed to invoke dbus method");
 251                 return STC_ERROR_FAIL;
 252         }
 253
 254         g_variant_get(message, "(i)", &result);
 255         STC_LOGD("Successfully removed firewall chain [%d:%s]", result, chain);
 256         g_variant_unref(message);
 257
 258         return STC_ERROR_NONE;
 259 }
 260
 261 static int __fw6_remove_chain(GDBusConnection *connection,
 262                                     const char *chain)
 263 {
 264         int result = 0;
 265         GVariant *message = NULL;
 266
 267         message = stc_manager_gdbus_call_sync(connection,
 268                                               STC_FIREWALL_DBUS_SERVICE,
 269                                               STC_FIREWALL_DBUS_CHAIN_PATH,
 270                                               STC_FIREWALL_DBUS_CHAIN_INTERFACE,
 271                                               STC_FIREWALL6_DBUS_METHOD_REMOVE_CHAIN,
 272                                               g_variant_new("(s)", chain));
 273
 274         if (message == NULL) {
 275                 STC_LOGE("Failed to invoke dbus method");
 276                 return STC_ERROR_FAIL;
 277         }
 278
 279         g_variant_get(message, "(i)", &result);
 280         STC_LOGD("Successfully removed firewall6 chain [%d:%s]", result, chain);
 281         g_variant_unref(message);
 282
 283         return STC_ERROR_NONE;
 284 }
 285
 286 static int __fw_flush_chain(GDBusConnection *connection,
 287                                   const char *chain)
 288 {
 289         int result = 0;
 290         GVariant *message = NULL;
 291
 292         message = stc_manager_gdbus_call_sync(connection,
 293                                               STC_FIREWALL_DBUS_SERVICE,
 294                                               STC_FIREWALL_DBUS_CHAIN_PATH,
 295                                               STC_FIREWALL_DBUS_CHAIN_INTERFACE,
 296                                               STC_FIREWALL_DBUS_METHOD_FLUSH_CHAIN,
 297                                               g_variant_new("(s)", chain));
 298
 299         if (message == NULL) {
 300                 STC_LOGE("Failed to invoke dbus method");
 301                 return STC_ERROR_FAIL;
 302         }
 303
 304         g_variant_get(message, "(i)", &result);
 305         STC_LOGD("Successfully flushed firewall chain [%d:%s]", result, chain);
 306         g_variant_unref(message);
 307
 308         return STC_ERROR_NONE;
 309 }
 310
 311 static int __fw6_flush_chain(GDBusConnection *connection,
 312                                    const char *chain)
 313 {
 314         int result = 0;
 315         GVariant *message = NULL;
 316
 317         message = stc_manager_gdbus_call_sync(connection,
 318                                               STC_FIREWALL_DBUS_SERVICE,
 319                                               STC_FIREWALL_DBUS_CHAIN_PATH,
 320                                               STC_FIREWALL_DBUS_CHAIN_INTERFACE,
 321                                               STC_FIREWALL6_DBUS_METHOD_FLUSH_CHAIN,
 322                                               g_variant_new("(s)", chain));
 323
 324         if (message == NULL) {
 325                 STC_LOGE("Failed to invoke dbus method");
 326                 return STC_ERROR_FAIL;
 327         }
 328
 329         g_variant_get(message, "(i)", &result);
 330         STC_LOGD("Successfully flushed firewall6 chain [%d:%s]", result, chain);
 331         g_variant_unref(message);
 332
 333         return STC_ERROR_NONE;
 334 }
 335
 336 static int __fw_set_chain(firewall_chain_s *chain)
 337 {
 338         stc_error_e ret = STC_ERROR_NONE;
 339         firewall_rule_s rule;
 340         memset(&rule, 0, sizeof(firewall_rule_s));
 341
 342         switch (chain->target) {
 343         case STC_FW_CHAIN_TARGET_INPUT:
 344                 rule.chain = g_strdup(FIREWALL_CHAIN_TARGET_IN);
 345                 break;
 346         case STC_FW_CHAIN_TARGET_OUTPUT:
 347                 rule.chain = g_strdup(FIREWALL_CHAIN_TARGET_OUT);
 348                 break;
 349         default:
 350                 return STC_ERROR_INVALID_PARAMETER;
 351         }
 352
 353         rule.target_str = g_strdup(chain->chain);
 354         ret = firewall_rule_add(&rule);
 355
 356         g_free(rule.chain);
 357         g_free(rule.target_str);
 358
 359         return ret;
 360 }
 361
 362 static int __fw_unset_chain(firewall_chain_s *chain)
 363 {
 364         stc_error_e ret = STC_ERROR_NONE;
 365         firewall_rule_s rule;
 366         memset(&rule, 0, sizeof(firewall_rule_s));
 367
 368         switch (chain->target) {
 369         case STC_FW_CHAIN_TARGET_INPUT:
 370                 rule.chain = g_strdup(FIREWALL_CHAIN_TARGET_IN);
 371                 break;
 372         case STC_FW_CHAIN_TARGET_OUTPUT:
 373                 rule.chain = g_strdup(FIREWALL_CHAIN_TARGET_OUT);
 374                 break;
 375         default:
 376                 return STC_ERROR_INVALID_PARAMETER;
 377         }
 378
 379         rule.target_str = g_strdup(chain->chain);
 380         ret = firewall_rule_remove(&rule);
 381
 382         g_free(rule.chain);
 383         g_free(rule.target_str);
 384
 385         return ret;
 386 }
 387
 388 static int __fw_add_rule(GDBusConnection *connection,
 389                                firewall_rule_s *rule)
 390 {
 391         int result = 0;
 392         GVariantBuilder *builder = NULL;
 393         GVariant *params = NULL;
 394         GVariant *message = NULL;
 395
 396         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 397         __fw_add_rule_info_to_builder(builder, rule);
 398         params = g_variant_new("(a{sv})", builder);
 399         g_variant_builder_unref(builder);
 400
 401         message = stc_manager_gdbus_call_sync(connection,
 402                                               STC_FIREWALL_DBUS_SERVICE,
 403                                               STC_FIREWALL_DBUS_RULE_PATH,
 404                                               STC_FIREWALL_DBUS_RULE_INTERFACE,
 405                                               STC_FIREWALL_DBUS_METHOD_ADD_RULE,
 406                                               params);
 407
 408         if (message == NULL) {
 409                 STC_LOGE("Failed to invoke dbus method");
 410                 return STC_ERROR_FAIL;
 411         }
 412
 413         g_variant_get(message, "(i)", &result);
 414         STC_LOGD("Successfully added firewall rule [%d:%s]",
 415                                 result, rule->chain);
 416         g_variant_unref(message);
 417
 418         return STC_ERROR_NONE;
 419 }
 420
 421 static int __fw6_add_rule(GDBusConnection *connection,
 422                                 firewall_rule_s *rule)
 423 {
 424         int result = 0;
 425         GVariantBuilder *builder = NULL;
 426         GVariant *params = NULL;
 427         GVariant *message = NULL;
 428
 429         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 430         __fw_add_rule_info_to_builder(builder, rule);
 431         params = g_variant_new("(a{sv})", builder);
 432         g_variant_builder_unref(builder);
 433
 434         message = stc_manager_gdbus_call_sync(connection,
 435                                               STC_FIREWALL_DBUS_SERVICE,
 436                                               STC_FIREWALL_DBUS_RULE_PATH,
 437                                               STC_FIREWALL_DBUS_RULE_INTERFACE,
 438                                               STC_FIREWALL6_DBUS_METHOD_ADD_RULE,
 439                                               params);
 440
 441         if (message == NULL) {
 442                 STC_LOGE("Failed to invoke dbus method");
 443                 return STC_ERROR_FAIL;
 444         }
 445
 446         g_variant_get(message, "(i)", &result);
 447         STC_LOGD("Successfully added firewall6 rule [%d:%s]",
 448                                 result, rule->chain);
 449         g_variant_unref(message);
 450
 451         return STC_ERROR_NONE;
 452 }
 453
 454 static int __fw_remove_rule(GDBusConnection *connection,
 455                                   firewall_rule_s *rule)
 456 {
 457         int result = 0;
 458         GVariantBuilder *builder = NULL;
 459         GVariant *params = NULL;
 460         GVariant *message = NULL;
 461
 462         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 463         __fw_add_rule_info_to_builder(builder, rule);
 464         params = g_variant_new("(a{sv})", builder);
 465         g_variant_builder_unref(builder);
 466
 467         message = stc_manager_gdbus_call_sync(connection,
 468                                               STC_FIREWALL_DBUS_SERVICE,
 469                                               STC_FIREWALL_DBUS_RULE_PATH,
 470                                               STC_FIREWALL_DBUS_RULE_INTERFACE,
 471                                               STC_FIREWALL_DBUS_METHOD_REMOVE_RULE,
 472                                               params);
 473
 474         if (message == NULL) {
 475                 STC_LOGE("Failed to invoke dbus method");
 476                 return STC_ERROR_FAIL;
 477         }
 478
 479         g_variant_get(message, "(i)", &result);
 480         STC_LOGD("Successfully removed firewall rule [%d:%s]",
 481                                 result, rule->chain);
 482         g_variant_unref(message);
 483
 484         return STC_ERROR_NONE;
 485 }
 486
 487 static int __fw6_remove_rule(GDBusConnection *connection,
 488                                    firewall_rule_s *rule)
 489 {
 490         int result = 0;
 491         GVariantBuilder *builder = NULL;
 492         GVariant *params = NULL;
 493         GVariant *message = NULL;
 494
 495         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 496         __fw_add_rule_info_to_builder(builder, rule);
 497         params = g_variant_new("(a{sv})", builder);
 498         g_variant_builder_unref(builder);
 499
 500         message = stc_manager_gdbus_call_sync(connection,
 501                                               STC_FIREWALL_DBUS_SERVICE,
 502                                               STC_FIREWALL_DBUS_RULE_PATH,
 503                                               STC_FIREWALL_DBUS_RULE_INTERFACE,
 504                                               STC_FIREWALL6_DBUS_METHOD_REMOVE_RULE,
 505                                               params);
 506
 507         if (message == NULL) {
 508                 STC_LOGE("Failed to invoke dbus method");
 509                 return STC_ERROR_FAIL;
 510         }
 511
 512         g_variant_get(message, "(i)", &result);
 513         STC_LOGD("Successfully removed firewall6 rule [%d:%s]",
 514                                 result, rule->chain);
 515         g_variant_unref(message);
 516
 517         return STC_ERROR_NONE;
 518 }
 519
 520 stc_error_e firewall_chain_add(firewall_chain_s *chain)
 521 {
 522         __STC_LOG_FUNC_ENTER__;
 523
 524         stc_error_e ret = STC_ERROR_NONE;
 525         stc_s *stc = stc_get_manager();
 526
 527         if (!stc || !stc->connection) {
 528                 __STC_LOG_FUNC_EXIT__;
 529                 return STC_ERROR_UNINITIALIZED;
 530         }
 531
 532         ret = __fw_add_chain(stc->connection, chain->chain);
 533         if (ret != STC_ERROR_NONE) {
 534                 __STC_LOG_FUNC_EXIT__;
 535                 return ret;
 536         }
 537
 538         ret = __fw6_add_chain(stc->connection, chain->chain);
 539         if (ret != STC_ERROR_NONE) {
 540                 __STC_LOG_FUNC_EXIT__;
 541                 return ret;
 542         }
 543
 544         __STC_LOG_FUNC_EXIT__;
 545         return ret;
 546 }
 547
 548 stc_error_e firewall_chain_remove(firewall_chain_s *chain)
 549 {
 550         __STC_LOG_FUNC_ENTER__;
 551
 552         stc_error_e ret = STC_ERROR_NONE;
 553         stc_s *stc = stc_get_manager();
 554
 555         if (!stc || !stc->connection) {
 556                 __STC_LOG_FUNC_EXIT__;
 557                 return STC_ERROR_UNINITIALIZED;
 558         }
 559
 560         ret = __fw_remove_chain(stc->connection, chain->chain);
 561         if (ret != STC_ERROR_NONE) {
 562                 __STC_LOG_FUNC_EXIT__;
 563                 return ret;
 564         }
 565
 566         ret = __fw6_remove_chain(stc->connection, chain->chain);
 567         if (ret != STC_ERROR_NONE) {
 568                 __STC_LOG_FUNC_EXIT__;
 569                 return ret;
 570         }
 571
 572         __STC_LOG_FUNC_EXIT__;
 573         return ret;
 574 }
 575
 576 stc_error_e firewall_chain_flush(firewall_chain_s *chain)
 577 {
 578         __STC_LOG_FUNC_ENTER__;
 579
 580         stc_error_e ret = STC_ERROR_NONE;
 581         stc_s *stc = stc_get_manager();
 582
 583         if (!stc || !stc->connection) {
 584                 __STC_LOG_FUNC_EXIT__;
 585                 return STC_ERROR_UNINITIALIZED;
 586         }
 587
 588         ret = __fw_flush_chain(stc->connection, chain->chain);
 589         if (ret != STC_ERROR_NONE) {
 590                 __STC_LOG_FUNC_EXIT__;
 591                 return ret;
 592         }
 593
 594         ret = __fw6_flush_chain(stc->connection, chain->chain);
 595         if (ret != STC_ERROR_NONE) {
 596                 __STC_LOG_FUNC_EXIT__;
 597                 return ret;
 598         }
 599
 600         __STC_LOG_FUNC_EXIT__;
 601         return ret;
 602 }
 603
 604 stc_error_e firewall_chain_set(firewall_chain_s *chain)
 605 {
 606         __STC_LOG_FUNC_ENTER__;
 607
 608         stc_error_e ret = STC_ERROR_NONE;
 609         ret = __fw_set_chain(chain);
 610
 611         __STC_LOG_FUNC_EXIT__;
 612         return ret;
 613 }
 614
 615 stc_error_e firewall_chain_unset(firewall_chain_s *chain)
 616 {
 617         __STC_LOG_FUNC_ENTER__;
 618
 619         stc_error_e ret = STC_ERROR_NONE;
 620         ret = __fw_unset_chain(chain);
 621
 622         __STC_LOG_FUNC_EXIT__;
 623         return ret;
 624 }
 625
 626 stc_error_e firewall_rule_add(firewall_rule_s *rule)
 627 {
 628         __STC_LOG_FUNC_ENTER__;
 629
 630         stc_error_e ret = STC_ERROR_NONE;
 631         stc_s *stc = stc_get_manager();
 632
 633         if (!stc || !stc->connection) {
 634                 __STC_LOG_FUNC_EXIT__;
 635                 return STC_ERROR_UNINITIALIZED;
 636         }
 637
 638         switch (rule->family) {
 639         case STC_FW_FAMILY_V4:
 640                 ret = __fw_add_rule(stc->connection, rule);
 641                 if (ret != STC_ERROR_NONE) {
 642                         __STC_LOG_FUNC_EXIT__;
 643                         return ret;
 644                 }
 645                 break;
 646         case STC_FW_FAMILY_V6:
 647                 ret = __fw6_add_rule(stc->connection, rule);
 648                 if (ret != STC_ERROR_NONE) {
 649                         __STC_LOG_FUNC_EXIT__;
 650                         return ret;
 651                 }
 652                 break;
 653         default:
 654                 ret = __fw_add_rule(stc->connection, rule);
 655                 if (ret != STC_ERROR_NONE) {
 656                         __STC_LOG_FUNC_EXIT__;
 657                         return ret;
 658                 }
 659
 660                 ret = __fw6_add_rule(stc->connection, rule);
 661                 if (ret != STC_ERROR_NONE) {
 662                         __STC_LOG_FUNC_EXIT__;
 663                         return ret;
 664                 }
 665                 break;
 666         }
 667
 668         __STC_LOG_FUNC_EXIT__;
 669         return ret;
 670 }
 671
 672 stc_error_e firewall_rule_remove(firewall_rule_s *rule)
 673 {
 674         __STC_LOG_FUNC_ENTER__;
 675
 676         stc_error_e ret = STC_ERROR_NONE;
 677         stc_s *stc = stc_get_manager();
 678
 679         if (!stc || !stc->connection) {
 680                 __STC_LOG_FUNC_EXIT__;
 681                 return STC_ERROR_UNINITIALIZED;
 682         }
 683
 684         switch (rule->family) {
 685         case STC_FW_FAMILY_V4:
 686                 ret = __fw_remove_rule(stc->connection, rule);
 687                 if (ret != STC_ERROR_NONE) {
 688                         __STC_LOG_FUNC_EXIT__;
 689                         return ret;
 690                 }
 691                 break;
 692         case STC_FW_FAMILY_V6:
 693                 ret = __fw6_remove_rule(stc->connection, rule);
 694                 if (ret != STC_ERROR_NONE) {
 695                         __STC_LOG_FUNC_EXIT__;
 696                         return ret;
 697                 }
 698                 break;
 699         default:
 700                 ret = __fw_remove_rule(stc->connection, rule);
 701                 if (ret != STC_ERROR_NONE) {
 702                         __STC_LOG_FUNC_EXIT__;
 703                         return ret;
 704                 }
 705
 706                 ret = __fw6_remove_rule(stc->connection, rule);
 707                 if (ret != STC_ERROR_NONE) {
 708                         __STC_LOG_FUNC_EXIT__;
 709                         return ret;
 710                 }
 711                 break;
 712         }
 713
 714         __STC_LOG_FUNC_EXIT__;
 715         return ret;
 716 }