src/stc-firewall.c

   1 /*
   2  * Smart Traffic Control (STC)
   3  *
   4  * Copyright (c) 2017 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 /**
  21  * This file implements Smart Traffic Control (STC) user library.
  22  *
  23  * @file        stc-firewall.c
  24  * @author      Tak hyunuk (hyunuk.tak@samsung.com)
  25  * @version     0.1
  26  */
  27
  28 /*****************************************************************************
  29  *  Standard headers
  30  *****************************************************************************/
  31 #include <glib.h>
  32 #include <gio/gio.h>
  33
  34 /*****************************************************************************
  35  *  System headers
  36  *****************************************************************************/
  37
  38 /*****************************************************************************
  39  *  Smart Traffic Control (STC) library headers
  40  *****************************************************************************/
  41 #include "stc.h"
  42
  43 #include "stc-private.h"
  44
  45 #include "stc-dbus.h"
  46 #include "stc-log.h"
  47 #include "stc-util.h"
  48 #include "stc-event.h"
  49
  50 #include "stc-info.h"
  51 #include "stc-firewall.h"
  52
  53 /*****************************************************************************
  54  *  Macros and Typedefs
  55  *****************************************************************************/
  56
  57 /*****************************************************************************
  58  *  Global Variables
  59  *****************************************************************************/
  60
  61 static GSList *g_fw_chain_list = NULL;
  62 static GSList *g_fw_rule_list = NULL;
  63
  64 /*****************************************************************************
  65  *  Local Functions Definition
  66  *****************************************************************************/
  67
  68 //LCOV_EXCL_START
  69 static void __stc_fw_init_chain(void *data, const char *name)
  70 {
  71         stc_fw_chain_s *chain = (stc_fw_chain_s *)data;
  72
  73         memset(chain, 0, sizeof(stc_fw_chain_s));
  74         chain->chain = g_strdup(name);
  75         chain->created = true;
  76 }
  77
  78 static void __stc_fw_set_chain(void *data,
  79                         stc_firewall_chain_target_e target)
  80 {
  81         stc_fw_chain_s *chain = (stc_fw_chain_s *)data;
  82         chain->target = target;
  83 }
  84
  85 static void __stc_fw_clone_chain(void *a, void *b)
  86 {
  87         stc_fw_chain_s *origin = (stc_fw_chain_s *)a;
  88         stc_fw_chain_s *cloned = (stc_fw_chain_s *)b;
  89
  90         cloned->chain = g_strdup(origin->chain);
  91         cloned->priority = origin->priority;
  92         cloned->target = origin->target;
  93         cloned->created = origin->created;
  94 }
  95
  96 static void __stc_fw_deinit_chain(void *data)
  97 {
  98         stc_fw_chain_s *chain = (stc_fw_chain_s *)data;
  99         FREE(chain->chain);
 100         FREE(chain);
 101         chain = NULL;
 102 }
 103
 104 static void __stc_fw_init_rule(void *data)
 105 {
 106         stc_fw_rule_s *rule = (stc_fw_rule_s *)data;
 107
 108         memset(rule, 0, sizeof(stc_fw_rule_s));
 109 }
 110
 111 static void __stc_fw_clone_rule(void *a, void *b)
 112 {
 113         stc_fw_rule_s *origin = (stc_fw_rule_s *)a;
 114         stc_fw_rule_s *cloned = (stc_fw_rule_s *)b;
 115
 116         FREE(cloned->chain);
 117         cloned->chain = g_strdup(origin->chain);
 118         cloned->direction = origin->direction;
 119         cloned->s_ip_type = origin->s_ip_type;
 120         cloned->d_ip_type = origin->d_ip_type;
 121         cloned->s_port_type = origin->s_port_type;
 122         cloned->d_port_type = origin->d_port_type;
 123         cloned->protocol = origin->protocol;
 124         cloned->family = origin->family;
 125         FREE(cloned->s_ip1);
 126         FREE(cloned->s_ip2);
 127         FREE(cloned->d_ip1);
 128         FREE(cloned->d_ip2);
 129         cloned->s_ip1 = g_strdup(origin->s_ip1);
 130         cloned->s_ip2 = g_strdup(origin->s_ip2);
 131         cloned->d_ip1 = g_strdup(origin->d_ip1);
 132         cloned->d_ip2 = g_strdup(origin->d_ip2);
 133         cloned->s_port1 = origin->s_port1;
 134         cloned->s_port2 = origin->s_port2;
 135         cloned->d_port1 = origin->d_port1;
 136         cloned->d_port2 = origin->d_port2;
 137         FREE(cloned->ifname);
 138         cloned->ifname = g_strdup(origin->ifname);
 139         cloned->target = origin->target;
 140         cloned->log_level = origin->log_level;
 141         FREE(cloned->log_prefix);
 142         cloned->log_prefix = g_strdup(origin->log_prefix);
 143         cloned->nflog_group = origin->nflog_group;
 144         FREE(cloned->nflog_prefix);
 145         cloned->nflog_prefix = g_strdup(origin->nflog_prefix);
 146         cloned->nflog_range = origin->nflog_range;
 147         cloned->nflog_threshold = origin->nflog_threshold;
 148         FREE(cloned->identifier);
 149         cloned->identifier = g_strdup(origin->identifier);
 150         cloned->key = origin->key;
 151 }
 152
 153 static void __stc_fw_deinit_rule(void *data)
 154 {
 155         stc_fw_rule_s *rule = (stc_fw_rule_s *)data;
 156
 157         FREE(rule->chain);
 158         FREE(rule->s_ip1);
 159         FREE(rule->s_ip2);
 160         FREE(rule->d_ip1);
 161         FREE(rule->d_ip2);
 162         FREE(rule->ifname);
 163         FREE(rule->log_prefix);
 164         FREE(rule->nflog_prefix);
 165         FREE(rule->identifier);
 166         FREE(rule);
 167         rule = NULL;
 168 }
 169
 170 static void __stc_fw_add_to_chain_list(stc_firewall_chain_h chain_h)
 171 {
 172         g_fw_chain_list = g_slist_append(g_fw_chain_list, chain_h);
 173 }
 174
 175 static bool __stc_fw_check_chain_validity(stc_firewall_chain_h chain_h)
 176 {
 177         if (!chain_h)
 178                 return false;
 179
 180         if (g_slist_find(g_fw_chain_list, chain_h))
 181                 return true;
 182         else
 183                 return false;
 184 }
 185
 186 static bool __stc_fw_check_chain_created(stc_firewall_chain_h chain_h)
 187 {
 188         stc_fw_chain_s *chain = (stc_fw_chain_s *)chain_h;
 189
 190         return chain->created;
 191 }
 192
 193 static void __stc_fw_remove_from_chain_list(stc_firewall_chain_h chain_h)
 194 {
 195         g_fw_chain_list = g_slist_remove(g_fw_chain_list, chain_h);
 196 }
 197
 198 static void __stc_fw_add_to_rule_list(stc_firewall_rule_h rule_h)
 199 {
 200         g_fw_rule_list = g_slist_append(g_fw_rule_list, rule_h);
 201 }
 202
 203 static bool __stc_fw_check_rule_validity(stc_firewall_rule_h rule_h)
 204 {
 205         if (!rule_h)
 206                 return false;
 207
 208         if (g_slist_find(g_fw_rule_list, rule_h))
 209                 return true;
 210         else
 211                 return false;
 212 }
 213
 214 static bool __stc_fw_check_rule_created(stc_firewall_rule_h rule_h)
 215 {
 216         stc_fw_rule_s *rule = (stc_fw_rule_s *)rule_h;
 217
 218         if (rule->key)
 219                 return false;
 220         else
 221                 return true;
 222 }
 223
 224 static void __stc_fw_remove_from_rule_list(stc_firewall_rule_h rule_h)
 225 {
 226         g_fw_rule_list = g_slist_remove(g_fw_rule_list, rule_h);
 227 }
 228
 229 static void __stc_fw_make_rule_params(
 230                         stc_fw_rule_s *rule, GVariant **params)
 231 {
 232         GVariantBuilder *builder;
 233
 234         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 235
 236         g_variant_builder_add(builder, "{sv}",
 237                 STC_FW_RULE_CHAIN,
 238                 g_variant_new_string(rule->chain));
 239
 240         if (rule->direction != STC_FIREWALL_DIRECTION_NONE)
 241                 g_variant_builder_add(builder, "{sv}",
 242                         STC_FW_RULE_DIRECTION,
 243                         g_variant_new_uint16(rule->direction));
 244
 245         if (rule->s_ip_type != STC_FIREWALL_IP_NONE)
 246                 g_variant_builder_add(builder, "{sv}",
 247                         STC_FW_RULE_SIPTYPE,
 248                         g_variant_new_uint16(rule->s_ip_type));
 249
 250         if (rule->d_ip_type != STC_FIREWALL_IP_NONE)
 251                 g_variant_builder_add(builder, "{sv}",
 252                         STC_FW_RULE_DIPTYPE,
 253                         g_variant_new_uint16(rule->d_ip_type));
 254
 255         if (rule->s_port_type != STC_FIREWALL_PORT_NONE)
 256                 g_variant_builder_add(builder, "{sv}",
 257                         STC_FW_RULE_SPORTTYPE,
 258                         g_variant_new_uint16(rule->s_port_type));
 259
 260         if (rule->d_port_type != STC_FIREWALL_PORT_NONE)
 261                 g_variant_builder_add(builder, "{sv}",
 262                         STC_FW_RULE_DPORTTYPE,
 263                         g_variant_new_uint16(rule->d_port_type));
 264
 265         if (rule->protocol != STC_FIREWALL_PROTOCOL_NONE)
 266                 g_variant_builder_add(builder, "{sv}",
 267                         STC_FW_RULE_PROTOCOL,
 268                         g_variant_new_uint16(rule->protocol));
 269
 270         if (rule->family != STC_FIREWALL_FAMILY_NONE)
 271                 g_variant_builder_add(builder, "{sv}",
 272                         STC_FW_RULE_FAMILY,
 273                         g_variant_new_uint16(rule->family));
 274
 275         if (rule->s_ip1)
 276                 g_variant_builder_add(builder, "{sv}",
 277                         STC_FW_RULE_SIP1,
 278                         g_variant_new_string(rule->s_ip1));
 279
 280         if (rule->s_ip2)
 281                 g_variant_builder_add(builder, "{sv}",
 282                         STC_FW_RULE_SIP2,
 283                         g_variant_new_string(rule->s_ip2));
 284
 285         if (rule->d_ip1)
 286                 g_variant_builder_add(builder, "{sv}",
 287                         STC_FW_RULE_DIP1,
 288                         g_variant_new_string(rule->d_ip1));
 289
 290         if (rule->d_ip2)
 291                 g_variant_builder_add(builder, "{sv}",
 292                         STC_FW_RULE_DIP2,
 293                         g_variant_new_string(rule->d_ip2));
 294
 295         if (rule->s_port1)
 296                 g_variant_builder_add(builder, "{sv}",
 297                         STC_FW_RULE_SPORT1,
 298                         g_variant_new_uint32(rule->s_port1));
 299
 300         if (rule->s_port2)
 301                 g_variant_builder_add(builder, "{sv}",
 302                         STC_FW_RULE_SPORT2,
 303                         g_variant_new_uint32(rule->s_port2));
 304
 305         if (rule->d_port1)
 306                 g_variant_builder_add(builder, "{sv}",
 307                         STC_FW_RULE_DPORT1,
 308                         g_variant_new_uint32(rule->d_port1));
 309
 310         if (rule->d_port2)
 311                 g_variant_builder_add(builder, "{sv}",
 312                         STC_FW_RULE_DPORT2,
 313                         g_variant_new_uint32(rule->d_port2));
 314
 315         if (rule->ifname)
 316                 g_variant_builder_add(builder, "{sv}",
 317                         STC_FW_RULE_IFNAME,
 318                         g_variant_new_string(rule->ifname));
 319
 320         if (rule->target)
 321                 g_variant_builder_add(builder, "{sv}",
 322                         STC_FW_RULE_TARGET,
 323                         g_variant_new_uint16(rule->target));
 324
 325         if (rule->log_level)
 326                 g_variant_builder_add(builder, "{sv}",
 327                         STC_FW_RULE_LOG_LEVEL,
 328                         g_variant_new_uint16(rule->log_level));
 329
 330         if (rule->log_prefix)
 331                 g_variant_builder_add(builder, "{sv}",
 332                         STC_FW_RULE_LOG_PREFIX,
 333                         g_variant_new_string(rule->log_prefix));
 334
 335         if (rule->nflog_group)
 336                 g_variant_builder_add(builder, "{sv}",
 337                         STC_FW_RULE_NFLOG_GROUP,
 338                         g_variant_new_uint16(rule->nflog_group));
 339
 340         if (rule->nflog_prefix)
 341                 g_variant_builder_add(builder, "{sv}",
 342                         STC_FW_RULE_NFLOG_PREFIX,
 343                         g_variant_new_string(rule->nflog_prefix));
 344
 345         if (rule->nflog_range)
 346                 g_variant_builder_add(builder, "{sv}",
 347                         STC_FW_RULE_NFLOG_RANGE,
 348                         g_variant_new_uint16(rule->nflog_range));
 349
 350         if (rule->nflog_threshold)
 351                 g_variant_builder_add(builder, "{sv}",
 352                         STC_FW_RULE_NFLOG_THRESHOLD,
 353                         g_variant_new_uint16(rule->nflog_threshold));
 354
 355         if (rule->identifier)
 356                 g_variant_builder_add(builder, "{sv}",
 357                         STC_FW_RULE_IDENTIFIER,
 358                         g_variant_new_string(rule->identifier));
 359
 360         if (rule->key > 0)
 361                 g_variant_builder_add(builder, "{sv}",
 362                         STC_FW_RULE_KEY,
 363                         g_variant_new_uint32(rule->key));
 364
 365         *params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 366         g_variant_builder_unref(builder);
 367 }
 368
 369 static void __stc_fw_extract_chain(const char *key,
 370                         GVariant *value, void *user_data)
 371 {
 372         stc_fw_chain_s *chain = (stc_fw_chain_s *)user_data;
 373
 374         if (chain == NULL)
 375                 return;
 376
 377         if (!g_strcmp0(key, STC_FW_CHAIN_NAME)) {
 378                 guint str_length;
 379                 const gchar *str = g_variant_get_string(value, &str_length);
 380                 chain->chain = g_strdup(str);
 381
 382         } else if (!g_strcmp0(key, STC_FW_CHAIN_PRIORITY)) {
 383                 chain->priority = g_variant_get_uint32(value);
 384
 385         } else if (!g_strcmp0(key, STC_FW_CHAIN_TARGET)) {
 386                 chain->target = g_variant_get_uint16(value);
 387
 388         }
 389
 390 }
 391
 392 static void __stc_fw_extract_rule(const char *key,
 393                         GVariant *value, void *user_data)
 394 {
 395         stc_fw_rule_s *rule = (stc_fw_rule_s *)user_data;
 396
 397         if (rule == NULL)
 398                 return;
 399
 400         if (!g_strcmp0(key, STC_FW_RULE_CHAIN)) {
 401                 guint str_length;
 402                 const gchar *str = g_variant_get_string(value, &str_length);
 403                 rule->chain = g_strdup(str);
 404
 405         } else if (!g_strcmp0(key, STC_FW_RULE_DIRECTION)) {
 406                 rule->direction = g_variant_get_uint16(value);
 407
 408         } else if (!g_strcmp0(key, STC_FW_RULE_SIPTYPE)) {
 409                 rule->s_ip_type = g_variant_get_uint16(value);
 410
 411         } else if (!g_strcmp0(key, STC_FW_RULE_DIPTYPE)) {
 412                 rule->d_ip_type = g_variant_get_uint16(value);
 413
 414         } else if (!g_strcmp0(key, STC_FW_RULE_SPORTTYPE)) {
 415                 rule->s_port_type = g_variant_get_uint16(value);
 416
 417         } else if (!g_strcmp0(key, STC_FW_RULE_DPORTTYPE)) {
 418                 rule->d_port_type = g_variant_get_uint16(value);
 419
 420         } else if (!g_strcmp0(key, STC_FW_RULE_PROTOCOL)) {
 421                 rule->protocol = g_variant_get_uint16(value);
 422
 423         } else if (!g_strcmp0(key, STC_FW_RULE_FAMILY)) {
 424                 rule->family = g_variant_get_uint16(value);
 425
 426         } else if (!g_strcmp0(key, STC_FW_RULE_SIP1)) {
 427                 guint str_length;
 428                 const gchar *str = g_variant_get_string(value, &str_length);
 429                 rule->s_ip1 = g_strdup(str);
 430
 431         } else if (!g_strcmp0(key, STC_FW_RULE_SIP2)) {
 432                 guint str_length;
 433                 const gchar *str = g_variant_get_string(value, &str_length);
 434                 rule->s_ip2 = g_strdup(str);
 435
 436         } else if (!g_strcmp0(key, STC_FW_RULE_DIP1)) {
 437                 guint str_length;
 438                 const gchar *str = g_variant_get_string(value, &str_length);
 439                 rule->d_ip1 = g_strdup(str);
 440
 441         } else if (!g_strcmp0(key, STC_FW_RULE_DIP2)) {
 442                 guint str_length;
 443                 const gchar *str = g_variant_get_string(value, &str_length);
 444                 rule->d_ip2 = g_strdup(str);
 445
 446         } else if (!g_strcmp0(key, STC_FW_RULE_SPORT1)) {
 447                 rule->s_port1 = g_variant_get_uint32(value);
 448
 449         } else if (!g_strcmp0(key, STC_FW_RULE_SPORT2)) {
 450                 rule->s_port2 = g_variant_get_uint32(value);
 451
 452         } else if (!g_strcmp0(key, STC_FW_RULE_DPORT1)) {
 453                 rule->d_port1 = g_variant_get_uint32(value);
 454
 455         } else if (!g_strcmp0(key, STC_FW_RULE_DPORT2)) {
 456                 rule->d_port2 = g_variant_get_uint32(value);
 457
 458         } else if (!g_strcmp0(key, STC_FW_RULE_IFNAME)) {
 459                 guint str_length;
 460                 const gchar *str = g_variant_get_string(value, &str_length);
 461                 rule->ifname = g_strdup(str);
 462
 463         } else if (!g_strcmp0(key, STC_FW_RULE_TARGET)) {
 464                 rule->target = g_variant_get_uint16(value);
 465
 466         } else if (!g_strcmp0(key, STC_FW_RULE_LOG_LEVEL)) {
 467                 rule->log_level = g_variant_get_uint16(value);
 468
 469         } else if (!g_strcmp0(key, STC_FW_RULE_LOG_PREFIX)) {
 470                 guint str_length;
 471                 const gchar *str = g_variant_get_string(value, &str_length);
 472                 rule->log_prefix = g_strdup(str);
 473
 474         } else if (!g_strcmp0(key, STC_FW_RULE_NFLOG_GROUP)) {
 475                 rule->nflog_group = g_variant_get_uint16(value);
 476
 477         } else if (!g_strcmp0(key, STC_FW_RULE_NFLOG_PREFIX)) {
 478                 guint str_length;
 479                 const gchar *str = g_variant_get_string(value, &str_length);
 480                 rule->nflog_prefix = g_strdup(str);
 481
 482         } else if (!g_strcmp0(key, STC_FW_RULE_NFLOG_RANGE)) {
 483                 rule->nflog_range = g_variant_get_uint16(value);
 484
 485         } else if (!g_strcmp0(key, STC_FW_RULE_NFLOG_THRESHOLD)) {
 486                 rule->nflog_threshold = g_variant_get_uint16(value);
 487
 488         } else if (!g_strcmp0(key, STC_FW_RULE_IDENTIFIER)) {
 489                 guint str_length;
 490                 const gchar *str = g_variant_get_string(value, &str_length);
 491                 rule->identifier = g_strdup(str);
 492
 493         } else if (!g_strcmp0(key, STC_FW_RULE_KEY)) {
 494                 rule->key = g_variant_get_uint32(value);
 495
 496         }
 497
 498 }
 499
 500 static void __stc_fw_print_chain(stc_fw_chain_s *chain)
 501 {
 502         if (chain == NULL)
 503                 return;
 504
 505         STC_LOGD(STC_HR_SINGLE);
 506
 507         STC_LOGD("[%s][%s][%u]", (chain->chain) ? chain->chain : "",
 508                 _stc_convert_fw_chain_target_to_string(chain->target),
 509                 chain->priority);
 510
 511         STC_LOGD(STC_HR_SINGLE);
 512 }
 513
 514 static void __stc_fw_print_rule(stc_fw_rule_s *rule)
 515 {
 516         if (rule == NULL)
 517                 return;
 518
 519         STC_LOGD(STC_HR_SINGLE);
 520
 521         STC_LOGD("[%s][%s][%s][%s][%s][%s][%s][%s][%s][%s]",
 522                 (rule->chain) ? rule->chain : "",
 523                 _stc_convert_fw_direction_to_string(rule->direction),
 524                 (rule->ifname) ? rule->ifname : "",
 525                 _stc_convert_fw_family_type_to_string(rule->family),
 526                 _stc_convert_fw_ip_type_to_string(rule->s_ip_type),
 527                 (rule->s_ip1) ? rule->s_ip1 : "",
 528                 (rule->s_ip2) ? rule->s_ip2 : "",
 529                 _stc_convert_fw_ip_type_to_string(rule->d_ip_type),
 530                 (rule->d_ip1) ? rule->d_ip1 : "",
 531                 (rule->d_ip2) ? rule->d_ip2 : "");
 532
 533         STC_LOGD("[%s][%s][%d][%d][%s][%d][%d][%s][%d][%s][%d][%s][%d][%d]",
 534                 _stc_convert_fw_protocol_type_to_string(rule->protocol),
 535                 _stc_convert_fw_port_type_to_string(rule->s_port_type),
 536                 rule->s_port1,
 537                 rule->s_port2,
 538                 _stc_convert_fw_port_type_to_string(rule->d_port_type),
 539                 rule->d_port1,
 540                 rule->d_port2,
 541                 _stc_convert_fw_rule_target_to_string(rule->target),
 542                 rule->log_level,
 543                 rule->log_prefix,
 544                 rule->nflog_group,
 545                 rule->nflog_prefix,
 546                 rule->nflog_range,
 547                 rule->nflog_threshold);
 548
 549         STC_LOGD(STC_HR_SINGLE);
 550 }
 551
 552 stc_error_e _stc_fw_lock(void)
 553 {
 554         GVariant *message = NULL;
 555         stc_error_e error = STC_ERROR_NONE;
 556         int result = 0;
 557
 558         message = _stc_dbus_invoke_method(
 559                 STC_MANAGER_SERVICE,
 560                 STC_MANAGER_FW_PATH,
 561                 STC_MANAGER_FW_INTERFACE,
 562                 STC_MANAGER_FW_METHOD_LOCK,
 563                 NULL,
 564                 &error);
 565
 566         STC_RETURN_VAL_IF(message == NULL,
 567                 error, "Failed to invoke dbus method");
 568
 569         g_variant_get(message, "(i)", &result);
 570         STC_LOGI("Successfully lock firewall [%d]", result);
 571         g_variant_unref(message);
 572
 573         return STC_ERROR_NONE;
 574 }
 575
 576 stc_error_e _stc_fw_unlock(void)
 577 {
 578         GVariant *message = NULL;
 579         stc_error_e error = STC_ERROR_NONE;
 580         int result = 0;
 581
 582         message = _stc_dbus_invoke_method(
 583                 STC_MANAGER_SERVICE,
 584                 STC_MANAGER_FW_PATH,
 585                 STC_MANAGER_FW_INTERFACE,
 586                 STC_MANAGER_FW_METHOD_UNLOCK,
 587                 NULL,
 588                 &error);
 589
 590         STC_RETURN_VAL_IF(message == NULL,
 591                 error, "Failed to invoke dbus method");
 592
 593         g_variant_get(message, "(i)", &result);
 594         STC_LOGI("Successfully lock firewall [%d]", result);
 595         g_variant_unref(message);
 596
 597         return STC_ERROR_NONE;
 598 }
 599
 600 stc_error_e _stc_fw_get_lock(stc_firewall_lock_e *state)
 601 {
 602         GVariant *message = NULL;
 603         stc_error_e error = STC_ERROR_NONE;
 604         int result = 0;
 605
 606         message = _stc_dbus_invoke_method(
 607                 STC_MANAGER_SERVICE,
 608                 STC_MANAGER_FW_PATH,
 609                 STC_MANAGER_FW_INTERFACE,
 610                 STC_MANAGER_FW_METHOD_GET_LOCK,
 611                 NULL,
 612                 &error);
 613
 614         STC_RETURN_VAL_IF(message == NULL,
 615                 error, "Failed to invoke dbus method");
 616
 617         g_variant_get(message, "(i)", &result);
 618         *state = (stc_firewall_lock_e)result;
 619
 620         STC_LOGI("Successfully get firewall lock state [%d]", result);
 621         g_variant_unref(message);
 622
 623         return STC_ERROR_NONE;
 624 }
 625
 626
 627 stc_error_e _stc_fw_chain_add(stc_fw_chain_s *chain)
 628 {
 629         GVariant *message = NULL;
 630         GVariant *params = NULL;
 631         stc_error_e error = STC_ERROR_NONE;
 632         int result = 0;
 633
 634         params = g_variant_new("(s)", chain->chain);
 635
 636         message = _stc_dbus_invoke_method(
 637                 STC_MANAGER_SERVICE,
 638                 STC_MANAGER_FW_PATH,
 639                 STC_MANAGER_FW_INTERFACE,
 640                 STC_MANAGER_FW_METHOD_ADD_CHAIN,
 641                 params,
 642                 &error);
 643
 644         STC_RETURN_VAL_IF(message == NULL,
 645                 error, "Failed to invoke dbus method");
 646
 647         g_variant_get(message, "(i)", &result);
 648         STC_LOGI("Successfully add firewall chain [%d]", result);
 649         g_variant_unref(message);
 650
 651         return STC_ERROR_NONE;
 652 }
 653
 654 stc_error_e _stc_fw_chain_remove(stc_fw_chain_s *chain)
 655 {
 656         GVariant *message = NULL;
 657         GVariant *params = NULL;
 658         stc_error_e error = STC_ERROR_NONE;
 659         int result = 0;
 660
 661         params = g_variant_new("(s)", chain->chain);
 662
 663         message = _stc_dbus_invoke_method(
 664                 STC_MANAGER_SERVICE,
 665                 STC_MANAGER_FW_PATH,
 666                 STC_MANAGER_FW_INTERFACE,
 667                 STC_MANAGER_FW_METHOD_REMOVE_CHAIN,
 668                 params,
 669                 &error);
 670
 671         STC_RETURN_VAL_IF(message == NULL,
 672                 error, "Failed to invoke dbus method");
 673
 674         g_variant_get(message, "(i)", &result);
 675         STC_LOGI("Successfully remove firewall chain [%d]", result);
 676         g_variant_unref(message);
 677
 678         return STC_ERROR_NONE;
 679 }
 680
 681 stc_error_e _stc_fw_chain_flush(stc_fw_chain_s *chain)
 682 {
 683         GVariant *message = NULL;
 684         GVariant *params = NULL;
 685         stc_error_e error = STC_ERROR_NONE;
 686         int result = 0;
 687
 688         params = g_variant_new("(s)", chain->chain);
 689
 690         message = _stc_dbus_invoke_method(
 691                 STC_MANAGER_SERVICE,
 692                 STC_MANAGER_FW_PATH,
 693                 STC_MANAGER_FW_INTERFACE,
 694                 STC_MANAGER_FW_METHOD_FLUSH_CHAIN,
 695                 params,
 696                 &error);
 697
 698         STC_RETURN_VAL_IF(message == NULL,
 699                 error, "Failed to invoke dbus method");
 700
 701         g_variant_get(message, "(i)", &result);
 702         STC_LOGI("Successfully flush firewall chain [%d]", result);
 703         g_variant_unref(message);
 704
 705         return STC_ERROR_NONE;
 706 }
 707
 708 stc_error_e _stc_fw_chain_foreach(stc_firewall_chain_info_cb callback,
 709                                 void *user_data)
 710 {
 711         GVariant *message = NULL;
 712         stc_error_e error = STC_ERROR_NONE;
 713         GVariantIter *iter = NULL;
 714         GVariantIter *iter_row = NULL;
 715         GSList *chain_list = NULL;
 716         GSList *list = NULL;
 717         stc_callback_ret_e rv = STC_CALLBACK_CANCEL;
 718
 719         message = _stc_dbus_invoke_method(
 720                 STC_MANAGER_SERVICE,
 721                 STC_MANAGER_FW_PATH,
 722                 STC_MANAGER_FW_INTERFACE,
 723                 STC_MANAGER_FW_METHOD_GET_ALL_CHAIN,
 724                 NULL,
 725                 &error);
 726
 727         STC_RETURN_VAL_IF(message == NULL,
 728                 error, "Failed to invoke dbus method");
 729
 730         g_variant_get(message, "(aa{sv})", &iter);
 731
 732         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 733                 stc_fw_chain_s *chain = MALLOC0(stc_fw_chain_s, 1);
 734
 735                 if (chain)
 736                         chain->created = false;
 737
 738                 _stc_dbus_dictionary_foreach(iter_row,
 739                         __stc_fw_extract_chain, chain);
 740
 741                 __stc_fw_print_chain(chain);
 742
 743                 chain_list = g_slist_append(chain_list, (stc_fw_chain_s *)chain);
 744
 745                 g_variant_iter_free(iter_row);
 746         }
 747
 748         g_variant_iter_free(iter);
 749         g_variant_unref(message);
 750
 751         if ((int)g_slist_length(chain_list) == 0) {
 752                 STC_LOGD("There are no firewall chains");
 753                 return STC_ERROR_NONE;
 754         }
 755
 756         for (list = chain_list; list; list = list->next) {
 757                 stc_fw_chain_s *chain = (stc_fw_chain_s *)list->data;
 758                 __stc_fw_add_to_chain_list((stc_firewall_chain_h)chain);
 759                 rv = callback((stc_firewall_chain_h)chain, user_data);
 760                 __stc_fw_remove_from_chain_list((stc_firewall_chain_h)chain);
 761                 if (rv == false)
 762                         break;
 763         }
 764
 765         g_slist_free_full(chain_list, __stc_fw_deinit_chain);
 766
 767         return STC_ERROR_NONE;
 768 }
 769
 770 stc_error_e _stc_fw_chain_set(stc_fw_chain_s *chain)
 771 {
 772         GVariant *message = NULL;
 773         GVariant *params = NULL;
 774         stc_error_e error = STC_ERROR_NONE;
 775         int result = 0;
 776
 777         params = g_variant_new("(su)", chain->chain, chain->target);
 778
 779         message = _stc_dbus_invoke_method(
 780                 STC_MANAGER_SERVICE,
 781                 STC_MANAGER_FW_PATH,
 782                 STC_MANAGER_FW_INTERFACE,
 783                 STC_MANAGER_FW_METHOD_SET_CHAIN,
 784                 params,
 785                 &error);
 786
 787         STC_RETURN_VAL_IF(message == NULL,
 788                 error, "Failed to invoke dbus method");
 789
 790         g_variant_get(message, "(i)", &result);
 791         STC_LOGI("Successfully set firewall chain [%d]", result);
 792         g_variant_unref(message);
 793
 794         return STC_ERROR_NONE;
 795 }
 796
 797 stc_error_e _stc_fw_chain_unset(stc_fw_chain_s *chain)
 798 {
 799         GVariant *message = NULL;
 800         GVariant *params = NULL;
 801         stc_error_e error = STC_ERROR_NONE;
 802         int result = 0;
 803
 804         params = g_variant_new("(s)", chain->chain);
 805
 806         message = _stc_dbus_invoke_method(
 807                 STC_MANAGER_SERVICE,
 808                 STC_MANAGER_FW_PATH,
 809                 STC_MANAGER_FW_INTERFACE,
 810                 STC_MANAGER_FW_METHOD_UNSET_CHAIN,
 811                 params,
 812                 &error);
 813
 814         STC_RETURN_VAL_IF(message == NULL,
 815                 error, "Failed to invoke dbus method");
 816
 817         g_variant_get(message, "(i)", &result);
 818         STC_LOGI("Successfully unset firewall chain [%d]", result);
 819         g_variant_unref(message);
 820
 821         return STC_ERROR_NONE;
 822 }
 823
 824 stc_error_e _stc_fw_rule_add(stc_fw_rule_s *rule)
 825 {
 826         GVariant *message = NULL;
 827         GVariant *params = NULL;
 828         stc_error_e error = STC_ERROR_NONE;
 829         int result = 0;
 830
 831         __stc_fw_make_rule_params(rule, &params);
 832
 833         message = _stc_dbus_invoke_method(
 834                 STC_MANAGER_SERVICE,
 835                 STC_MANAGER_FW_PATH,
 836                 STC_MANAGER_FW_INTERFACE,
 837                 STC_MANAGER_FW_METHOD_ADD_RULE,
 838                 params,
 839                 &error);
 840
 841         STC_RETURN_VAL_IF(message == NULL,
 842                 error, "Failed to invoke dbus method");
 843
 844         g_variant_get(message, "(i)", &result);
 845         STC_LOGI("Successfully add firewall rule [%d]", result);
 846         g_variant_unref(message);
 847
 848         return STC_ERROR_NONE;
 849 }
 850
 851 stc_error_e _stc_fw_rule_remove(stc_fw_rule_s *rule)
 852 {
 853         GVariant *message = NULL;
 854         GVariant *params = NULL;
 855         stc_error_e error = STC_ERROR_NONE;
 856         int result = 0;
 857
 858         __stc_fw_make_rule_params(rule, &params);
 859
 860         message = _stc_dbus_invoke_method(
 861                 STC_MANAGER_SERVICE,
 862                 STC_MANAGER_FW_PATH,
 863                 STC_MANAGER_FW_INTERFACE,
 864                 STC_MANAGER_FW_METHOD_REMOVE_RULE,
 865                 params,
 866                 &error);
 867
 868         STC_RETURN_VAL_IF(message == NULL,
 869                 error, "Failed to invoke dbus method");
 870
 871         g_variant_get(message, "(i)", &result);
 872         STC_LOGI("Successfully remove firewall rule [%d]", result);
 873         g_variant_unref(message);
 874
 875         return STC_ERROR_NONE;
 876 }
 877
 878 stc_error_e _stc_fw_rule_update(stc_fw_rule_s *rule)
 879 {
 880         GVariant *message = NULL;
 881         GVariant *params = NULL;
 882         stc_error_e error = STC_ERROR_NONE;
 883         int result = 0;
 884
 885         __stc_fw_make_rule_params(rule, &params);
 886
 887         message = _stc_dbus_invoke_method(
 888                 STC_MANAGER_SERVICE,
 889                 STC_MANAGER_FW_PATH,
 890                 STC_MANAGER_FW_INTERFACE,
 891                 STC_MANAGER_FW_METHOD_UPDATE_RULE,
 892                 params,
 893                 &error);
 894
 895         STC_RETURN_VAL_IF(message == NULL,
 896                 error, "Failed to invoke dbus method");
 897
 898         g_variant_get(message, "(i)", &result);
 899         STC_LOGI("Successfully update firewall rule [%d]", result);
 900         g_variant_unref(message);
 901
 902         return STC_ERROR_NONE;
 903 }
 904
 905 stc_error_e _stc_fw_rule_foreach(stc_firewall_rule_info_cb callback,
 906                                 void *user_data)
 907 {
 908         GVariant *message = NULL;
 909         stc_error_e error = STC_ERROR_NONE;
 910         GVariantIter *iter = NULL;
 911         GVariantIter *iter_row = NULL;
 912         GSList *rule_list = NULL;
 913         GSList *list = NULL;
 914         stc_callback_ret_e rv = STC_CALLBACK_CANCEL;
 915
 916         message = _stc_dbus_invoke_method(
 917                 STC_MANAGER_SERVICE,
 918                 STC_MANAGER_FW_PATH,
 919                 STC_MANAGER_FW_INTERFACE,
 920                 STC_MANAGER_FW_METHOD_GET_ALL_RULE,
 921                 NULL,
 922                 &error);
 923
 924         STC_RETURN_VAL_IF(message == NULL,
 925                 error, "Failed to invoke dbus method");
 926
 927         g_variant_get(message, "(aa{sv})", &iter);
 928
 929         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 930                 stc_fw_rule_s *rule = MALLOC0(stc_fw_rule_s, 1);
 931
 932                 _stc_dbus_dictionary_foreach(iter_row,
 933                         __stc_fw_extract_rule, rule);
 934
 935                 __stc_fw_print_rule(rule);
 936
 937                 rule_list = g_slist_append(rule_list, (stc_fw_rule_s *)rule);
 938
 939                 g_variant_iter_free(iter_row);
 940         }
 941
 942         g_variant_iter_free(iter);
 943         g_variant_unref(message);
 944
 945         if ((int)g_slist_length(rule_list) == 0) {
 946                 STC_LOGD("There are no firewall rules");
 947                 return STC_ERROR_NONE;
 948         }
 949
 950         for (list = rule_list; list; list = list->next) {
 951                 stc_fw_rule_s *rule = (stc_fw_rule_s *)list->data;
 952                 __stc_fw_add_to_rule_list((stc_firewall_rule_h)rule);
 953                 rv = callback((stc_firewall_rule_h)rule, user_data);
 954                 __stc_fw_remove_from_rule_list((stc_firewall_rule_h)rule);
 955                 if (rv == false)
 956                         break;
 957         }
 958
 959         g_slist_free_full(rule_list, __stc_fw_deinit_rule);
 960
 961         return STC_ERROR_NONE;
 962 }
 963
 964 EXPORT_API int stc_firewall_lock(stc_h stc)
 965 {
 966         int ret = STC_ERROR_NONE;
 967
 968         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
 969
 970         if (!(_stc_handle_check_validity(stc))) {
 971                 STC_LOGE("Invalid parameter");
 972                 return STC_ERROR_INVALID_PARAMETER;
 973         }
 974
 975         ret = _stc_fw_lock();
 976         if (ret != STC_ERROR_NONE) {
 977                 STC_LOGE("Failed to lock firewall [%s]",
 978                         _stc_convert_error_type_to_string(ret));
 979                 return ret;
 980         }
 981
 982         STC_LOGI("Firewall successfully locked");
 983
 984         return STC_ERROR_NONE;
 985 }
 986
 987 EXPORT_API int stc_firewall_unlock(stc_h stc)
 988 {
 989         int ret = STC_ERROR_NONE;
 990
 991         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
 992
 993         if (!(_stc_handle_check_validity(stc))) {
 994                 STC_LOGE("Invalid parameter");
 995                 return STC_ERROR_INVALID_PARAMETER;
 996         }
 997
 998         ret = _stc_fw_unlock();
 999         if (ret != STC_ERROR_NONE) {
1000                 STC_LOGE("Failed to unlock firewall [%s]",
1001                         _stc_convert_error_type_to_string(ret));
1002                 return ret;
1003         }
1004
1005         STC_LOGI("Firewall successfully unlocked");
1006
1007         return STC_ERROR_NONE;
1008 }
1009
1010 EXPORT_API int stc_firewall_get_lock(stc_h stc, stc_firewall_lock_e *state)
1011 {
1012         int ret = STC_ERROR_NONE;
1013
1014         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1015
1016         if (!(_stc_handle_check_validity(stc))) {
1017                 STC_LOGE("Invalid parameter");
1018                 return STC_ERROR_INVALID_PARAMETER;
1019         }
1020
1021         ret = _stc_fw_get_lock(state);
1022         if (ret != STC_ERROR_NONE) {
1023                 STC_LOGE("Failed to get firewall lock state [%s]",
1024                         _stc_convert_error_type_to_string(ret));
1025                 return ret;
1026         }
1027
1028         STC_LOGI("Firewall successfully get lock state");
1029
1030         return STC_ERROR_NONE;
1031 }
1032
1033 EXPORT_API int stc_firewall_chain_create(stc_h stc, const char *name,
1034                                 stc_firewall_chain_h *chain_h)
1035 {
1036         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1037
1038         if (!(_stc_handle_check_validity(stc))) {
1039                 STC_LOGE("Invalid parameter");
1040                 return STC_ERROR_INVALID_PARAMETER;
1041         }
1042
1043         if (!chain_h || !name) {
1044                 STC_LOGE("Invalid parameter");
1045                 return STC_ERROR_INVALID_PARAMETER;
1046         }
1047
1048         stc_fw_chain_s *fw_chain = MALLOC0(stc_fw_chain_s, 1);
1049         if (!fw_chain) {
1050                 STC_LOGE("Memory allocation failed");
1051                 return STC_ERROR_OUT_OF_MEMORY;
1052         }
1053
1054         __stc_fw_init_chain(fw_chain, name);
1055         __stc_fw_add_to_chain_list((stc_firewall_chain_h)fw_chain);
1056
1057         *chain_h = (stc_firewall_chain_h)fw_chain;
1058
1059         STC_LOGI("Firewall chain successfully created");
1060
1061         return STC_ERROR_NONE;
1062 }
1063
1064 EXPORT_API int stc_firewall_chain_clone(stc_firewall_chain_h origin_h,
1065                         stc_firewall_chain_h *cloned_chain_h)
1066 {
1067         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1068
1069         if (__stc_fw_check_chain_validity(origin_h) == false ||
1070                 cloned_chain_h == NULL) {
1071                 STC_LOGE("Invalid parameter");
1072                 return STC_ERROR_INVALID_PARAMETER;
1073         }
1074
1075         stc_fw_chain_s *fw_chain = MALLOC0(stc_fw_chain_s, 1);
1076         if (!fw_chain) {
1077                 STC_LOGE("Memory allocation failed");
1078                 return STC_ERROR_OUT_OF_MEMORY;
1079         }
1080
1081         __stc_fw_clone_chain(origin_h, fw_chain);
1082         __stc_fw_add_to_chain_list((stc_firewall_chain_h)fw_chain);
1083
1084         *cloned_chain_h = (stc_firewall_chain_h)fw_chain;
1085
1086         STC_LOGI("Firewall chain successfully cloned");
1087
1088         return STC_ERROR_NONE;
1089 }
1090
1091 EXPORT_API int stc_firewall_chain_destroy(stc_firewall_chain_h chain_h)
1092 {
1093         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1094
1095         if (__stc_fw_check_chain_validity(chain_h) == false) {
1096                 STC_LOGE("Invalid parameter");
1097                 return STC_ERROR_INVALID_PARAMETER;
1098         }
1099
1100         __stc_fw_remove_from_chain_list(chain_h);
1101         __stc_fw_deinit_chain(chain_h);
1102
1103         STC_LOGI("Firewall rule successfully destroyed");
1104
1105         return STC_ERROR_NONE;
1106 }
1107
1108 EXPORT_API int stc_firewall_chain_get_name(stc_firewall_chain_h chain_h, char **name)
1109 {
1110         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1111
1112         if (__stc_fw_check_chain_validity(chain_h) == false) {
1113                 STC_LOGE("Invalid parameter");
1114                 return STC_ERROR_INVALID_PARAMETER;
1115         }
1116
1117         if (!name) {
1118                 STC_LOGE("Invalid parameter");
1119                 return STC_ERROR_INVALID_PARAMETER;
1120         }
1121
1122         stc_fw_chain_s *fw_chain = (stc_fw_chain_s *)chain_h;
1123
1124         *name = g_strdup(fw_chain->chain);
1125
1126         STC_LOGI("Chain [%s]", *name);
1127
1128         return STC_ERROR_NONE;
1129 }
1130
1131 EXPORT_API int stc_firewall_chain_get_target(stc_firewall_chain_h chain_h,
1132                                 stc_firewall_chain_target_e *target)
1133 {
1134         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1135
1136         if (__stc_fw_check_chain_validity(chain_h) == false) {
1137                 STC_LOGE("Invalid parameter");
1138                 return STC_ERROR_INVALID_PARAMETER;
1139         }
1140
1141         if (!target) {
1142                 STC_LOGE("Invalid parameter");
1143                 return STC_ERROR_INVALID_PARAMETER;
1144         }
1145
1146         stc_fw_chain_s *fw_chain = (stc_fw_chain_s *)chain_h;
1147
1148         *target = fw_chain->target;
1149
1150         STC_LOGI("Target [%s]", _stc_convert_fw_chain_target_to_string(*target));
1151
1152         return STC_ERROR_NONE;
1153 }
1154
1155 EXPORT_API int stc_firewall_chain_get_priority(stc_firewall_chain_h chain_h,
1156                                 unsigned int *priority)
1157 {
1158         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1159
1160         if (__stc_fw_check_chain_validity(chain_h) == false) {
1161                 STC_LOGE("Invalid parameter");
1162                 return STC_ERROR_INVALID_PARAMETER;
1163         }
1164
1165         if (!priority) {
1166                 STC_LOGE("Invalid parameter");
1167                 return STC_ERROR_INVALID_PARAMETER;
1168         }
1169
1170         stc_fw_chain_s *fw_chain = (stc_fw_chain_s *)chain_h;
1171
1172         *priority = fw_chain->priority;
1173
1174         STC_LOGI("Priority [%u]", *priority);
1175
1176         return STC_ERROR_NONE;
1177 }
1178
1179 EXPORT_API int stc_firewall_chain_add(stc_firewall_chain_h chain_h)
1180 {
1181         int ret = STC_ERROR_NONE;
1182
1183         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1184
1185         if (__stc_fw_check_chain_validity(chain_h) == false) {
1186                 STC_LOGE("Invalid parameter");
1187                 return STC_ERROR_INVALID_PARAMETER;
1188         }
1189
1190         if (__stc_fw_check_chain_created(chain_h) == false) {
1191                 STC_LOGE("Invalid parameter");
1192                 return STC_ERROR_INVALID_PARAMETER;
1193         }
1194
1195         ret = _stc_fw_chain_add((stc_fw_chain_s *)chain_h);
1196         if (ret != STC_ERROR_NONE) {
1197                 STC_LOGE("Failed to add firewall cahin [%s]",
1198                         _stc_convert_error_type_to_string(ret));
1199                 return ret;
1200         }
1201
1202         return STC_ERROR_NONE;
1203 }
1204
1205 EXPORT_API int stc_firewall_chain_remove(stc_firewall_chain_h chain_h)
1206 {
1207         int ret = STC_ERROR_NONE;
1208
1209         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1210
1211         if (__stc_fw_check_chain_validity(chain_h) == false) {
1212                 STC_LOGE("Invalid parameter");
1213                 return STC_ERROR_INVALID_PARAMETER;
1214         }
1215
1216         if (__stc_fw_check_chain_created(chain_h) == true) {
1217                 STC_LOGE("Invalid parameter");
1218                 return STC_ERROR_INVALID_PARAMETER;
1219         }
1220
1221         ret = _stc_fw_chain_remove((stc_fw_chain_s *)chain_h);
1222         if (ret != STC_ERROR_NONE) {
1223                 STC_LOGE("Failed to remove firewall cahin [%s]",
1224                         _stc_convert_error_type_to_string(ret));
1225                 return ret;
1226         }
1227
1228         return STC_ERROR_NONE;
1229 }
1230
1231 EXPORT_API int stc_firewall_chain_flush(stc_firewall_chain_h chain_h)
1232 {
1233         int ret = STC_ERROR_NONE;
1234
1235         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1236
1237         if (__stc_fw_check_chain_validity(chain_h) == false) {
1238                 STC_LOGE("Invalid parameter");
1239                 return STC_ERROR_INVALID_PARAMETER;
1240         }
1241
1242         if (__stc_fw_check_chain_created(chain_h) == true) {
1243                 STC_LOGE("Invalid parameter");
1244                 return STC_ERROR_INVALID_PARAMETER;
1245         }
1246
1247         ret = _stc_fw_chain_flush((stc_fw_chain_s *)chain_h);
1248         if (ret != STC_ERROR_NONE) {
1249                 STC_LOGE("Failed to flush firewall cahin [%s]",
1250                         _stc_convert_error_type_to_string(ret));
1251                 return ret;
1252         }
1253
1254         return STC_ERROR_NONE;
1255 }
1256
1257 EXPORT_API int stc_firewall_chain_foreach(stc_h stc,
1258                                 stc_firewall_chain_info_cb callback, void *user_data)
1259 {
1260         int ret = STC_ERROR_NONE;
1261
1262         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1263
1264         if (!(_stc_handle_check_validity(stc))) {
1265                 STC_LOGE("Invalid parameter");
1266                 return STC_ERROR_INVALID_PARAMETER;
1267         }
1268
1269         if (callback == NULL) {
1270                 STC_LOGE("Invalid parameter");
1271                 return STC_ERROR_INVALID_PARAMETER;
1272         }
1273
1274         ret = _stc_fw_chain_foreach(callback, user_data);
1275         if (ret != STC_ERROR_NONE) {
1276                 STC_LOGE("Failed to get all firewall chain [%s]",
1277                         _stc_convert_error_type_to_string(ret));
1278                 return ret;
1279         }
1280
1281         return STC_ERROR_NONE;
1282 }
1283
1284 EXPORT_API int stc_firewall_chain_set(stc_firewall_chain_h chain_h,
1285                                 stc_firewall_chain_target_e target)
1286 {
1287         int ret = STC_ERROR_NONE;
1288
1289         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1290
1291         if (__stc_fw_check_chain_validity(chain_h) == false) {
1292                 STC_LOGE("Invalid parameter");
1293                 return STC_ERROR_INVALID_PARAMETER;
1294         }
1295
1296         if (__stc_fw_check_chain_created(chain_h) == true) {
1297                 STC_LOGE("Invalid parameter");
1298                 return STC_ERROR_INVALID_PARAMETER;
1299         }
1300
1301         __stc_fw_set_chain(chain_h, target);
1302
1303         ret = _stc_fw_chain_set((stc_fw_chain_s *)chain_h);
1304         if (ret != STC_ERROR_NONE) {
1305                 STC_LOGE("Failed to set firewall cahin [%s]",
1306                         _stc_convert_error_type_to_string(ret));
1307                 return ret;
1308         }
1309
1310         return STC_ERROR_NONE;
1311 }
1312
1313 EXPORT_API int stc_firewall_chain_unset(stc_firewall_chain_h chain_h)
1314 {
1315         int ret = STC_ERROR_NONE;
1316
1317         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1318
1319         if (__stc_fw_check_chain_validity(chain_h) == false) {
1320                 STC_LOGE("Invalid parameter");
1321                 return STC_ERROR_INVALID_PARAMETER;
1322         }
1323
1324         if (__stc_fw_check_chain_created(chain_h) == true) {
1325                 STC_LOGE("Invalid parameter");
1326                 return STC_ERROR_INVALID_PARAMETER;
1327         }
1328
1329         ret = _stc_fw_chain_unset((stc_fw_chain_s *)chain_h);
1330         if (ret != STC_ERROR_NONE) {
1331                 STC_LOGE("Failed to unset firewall cahin [%s]",
1332                         _stc_convert_error_type_to_string(ret));
1333                 return ret;
1334         }
1335
1336         return STC_ERROR_NONE;
1337 }
1338
1339 EXPORT_API int stc_firewall_rule_create(stc_h stc, stc_firewall_rule_h *rule_h)
1340 {
1341         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1342
1343         if (!(_stc_handle_check_validity(stc))) {
1344                 STC_LOGE("Invalid parameter");
1345                 return STC_ERROR_INVALID_PARAMETER;
1346         }
1347
1348         if (!rule_h) {
1349                 STC_LOGE("Invalid parameter");
1350                 return STC_ERROR_INVALID_PARAMETER;
1351         }
1352
1353         stc_fw_rule_s *fw_rule = MALLOC0(stc_fw_rule_s, 1);
1354         if (!fw_rule) {
1355                 STC_LOGE("Memory allocation failed");
1356                 return STC_ERROR_OUT_OF_MEMORY;
1357         }
1358
1359         __stc_fw_init_rule(fw_rule);
1360         __stc_fw_add_to_rule_list((stc_firewall_rule_h)fw_rule);
1361
1362         *rule_h = (stc_firewall_rule_h)fw_rule;
1363
1364         STC_LOGI("Firewall rule successfully created");
1365
1366         return STC_ERROR_NONE;
1367 }
1368
1369 EXPORT_API int stc_firewall_rule_clone(stc_firewall_rule_h origin_h,
1370                         stc_firewall_rule_h *cloned_rule_h)
1371 {
1372         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1373
1374         if (__stc_fw_check_rule_validity(origin_h) == false ||
1375                 cloned_rule_h == NULL) {
1376                 STC_LOGE("Invalid parameter");
1377                 return STC_ERROR_INVALID_PARAMETER;
1378         }
1379
1380         stc_fw_rule_s *fw_rule = MALLOC0(stc_fw_rule_s, 1);
1381         if (!fw_rule) {
1382                 STC_LOGE("Memory allocation failed");
1383                 return STC_ERROR_OUT_OF_MEMORY;
1384         }
1385
1386         __stc_fw_clone_rule(origin_h, fw_rule);
1387         __stc_fw_add_to_rule_list((stc_firewall_rule_h)fw_rule);
1388
1389         *cloned_rule_h = (stc_firewall_rule_h)fw_rule;
1390
1391         STC_LOGI("Firewall rule successfully cloned");
1392
1393         return STC_ERROR_NONE;
1394 }
1395
1396 EXPORT_API int stc_firewall_rule_destroy(stc_firewall_rule_h rule_h)
1397 {
1398         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1399
1400         if (__stc_fw_check_rule_validity(rule_h) == false) {
1401                 STC_LOGE("Invalid parameter");
1402                 return STC_ERROR_INVALID_PARAMETER;
1403         }
1404
1405         __stc_fw_remove_from_rule_list(rule_h);
1406         __stc_fw_deinit_rule(rule_h);
1407
1408         STC_LOGI("Firewall rule successfully destroyed");
1409
1410         return STC_ERROR_NONE;
1411 }
1412
1413 EXPORT_API int stc_firewall_rule_set_chain(stc_firewall_rule_h rule_h, char *chain)
1414 {
1415         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1416
1417         if (__stc_fw_check_rule_validity(rule_h) == false) {
1418                 STC_LOGE("Invalid parameter");
1419                 return STC_ERROR_INVALID_PARAMETER;
1420         }
1421
1422         if (!chain || strlen(chain) == 0) {
1423                 STC_LOGE("Invalid parameter");
1424                 return STC_ERROR_INVALID_PARAMETER;
1425         }
1426
1427         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1428
1429         FREE(fw_rule->chain);
1430         fw_rule->chain = g_strdup(chain);
1431
1432         STC_LOGI("Chain [%s]", fw_rule->chain);
1433
1434         return STC_ERROR_NONE;
1435 }
1436
1437 EXPORT_API int stc_firewall_rule_set_direction(stc_firewall_rule_h rule_h,
1438                                 stc_firewall_direction_e direction)
1439 {
1440         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1441
1442         if (__stc_fw_check_rule_validity(rule_h) == false) {
1443                 STC_LOGE("Invalid parameter");
1444                 return STC_ERROR_INVALID_PARAMETER;
1445         }
1446
1447         if (direction > STC_FIREWALL_DIRECTION_OUT) {
1448                 STC_LOGE("Invalid parameter");
1449                 return STC_ERROR_INVALID_PARAMETER;
1450         }
1451
1452         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1453
1454         fw_rule->direction = direction;
1455
1456         STC_LOGI("Direction [%u]", fw_rule->direction);
1457
1458         return STC_ERROR_NONE;
1459 }
1460
1461 EXPORT_API int stc_firewall_rule_set_src_ip_type(stc_firewall_rule_h rule_h,
1462                                 stc_firewall_ip_type_e type)
1463 {
1464         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1465
1466         if (__stc_fw_check_rule_validity(rule_h) == false) {
1467                 STC_LOGE("Invalid parameter");
1468                 return STC_ERROR_INVALID_PARAMETER;
1469         }
1470
1471         if (type > STC_FIREWALL_IP_RANGE) {
1472                 STC_LOGE("Invalid parameter");
1473                 return STC_ERROR_INVALID_PARAMETER;
1474         }
1475
1476         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1477
1478         fw_rule->s_ip_type = type;
1479
1480         STC_LOGI("Source IP type [%u]", fw_rule->s_ip_type);
1481
1482         return STC_ERROR_NONE;
1483 }
1484
1485 EXPORT_API int stc_firewall_rule_set_dst_ip_type(stc_firewall_rule_h rule_h,
1486                                 stc_firewall_ip_type_e type)
1487 {
1488         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1489
1490         if (__stc_fw_check_rule_validity(rule_h) == false) {
1491                 STC_LOGE("Invalid parameter");
1492                 return STC_ERROR_INVALID_PARAMETER;
1493         }
1494
1495         if (type > STC_FIREWALL_IP_RANGE) {
1496                 STC_LOGE("Invalid parameter");
1497                 return STC_ERROR_INVALID_PARAMETER;
1498         }
1499
1500         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1501
1502         fw_rule->d_ip_type = type;
1503
1504         STC_LOGI("Destination IP type [%u]", fw_rule->d_ip_type);
1505
1506         return STC_ERROR_NONE;
1507 }
1508
1509 EXPORT_API int stc_firewall_rule_set_src_port_type(stc_firewall_rule_h rule_h,
1510                                 stc_firewall_port_type_e type)
1511 {
1512         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1513
1514         if (__stc_fw_check_rule_validity(rule_h) == false) {
1515                 STC_LOGE("Invalid parameter");
1516                 return STC_ERROR_INVALID_PARAMETER;
1517         }
1518
1519         if (type > STC_FIREWALL_PORT_RANGE) {
1520                 STC_LOGE("Invalid parameter");
1521                 return STC_ERROR_INVALID_PARAMETER;
1522         }
1523
1524         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1525
1526         fw_rule->s_port_type = type;
1527
1528         STC_LOGI("Source port type [%u]", fw_rule->s_port_type);
1529
1530         return STC_ERROR_NONE;
1531 }
1532
1533 EXPORT_API int stc_firewall_rule_set_dst_port_type(stc_firewall_rule_h rule_h,
1534                                 stc_firewall_port_type_e type)
1535 {
1536         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1537
1538         if (__stc_fw_check_rule_validity(rule_h) == false) {
1539                 STC_LOGE("Invalid parameter");
1540                 return STC_ERROR_INVALID_PARAMETER;
1541         }
1542
1543         if (type > STC_FIREWALL_PORT_RANGE) {
1544                 STC_LOGE("Invalid parameter");
1545                 return STC_ERROR_INVALID_PARAMETER;
1546         }
1547
1548         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1549
1550         fw_rule->d_port_type = type;
1551
1552         STC_LOGI("Destination port type [%u]", fw_rule->d_port_type);
1553
1554         return STC_ERROR_NONE;
1555 }
1556
1557 EXPORT_API int stc_firewall_rule_set_protocol_type(stc_firewall_rule_h rule_h,
1558                                 stc_firewall_protocol_type_e type)
1559 {
1560         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1561
1562         if (__stc_fw_check_rule_validity(rule_h) == false) {
1563                 STC_LOGE("Invalid parameter");
1564                 return STC_ERROR_INVALID_PARAMETER;
1565         }
1566
1567         if (type > STC_FIREWALL_PROTOCOL_ALL) {
1568                 STC_LOGE("Invalid parameter");
1569                 return STC_ERROR_INVALID_PARAMETER;
1570         }
1571
1572         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1573
1574         fw_rule->protocol = type;
1575
1576         STC_LOGI("Protocol type [%u]", fw_rule->protocol);
1577
1578         return STC_ERROR_NONE;
1579 }
1580
1581 EXPORT_API int stc_firewall_rule_set_family_type(stc_firewall_rule_h rule_h,
1582                                 stc_firewall_family_type_e type)
1583 {
1584         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1585
1586         if (__stc_fw_check_rule_validity(rule_h) == false) {
1587                 STC_LOGE("Invalid parameter");
1588                 return STC_ERROR_INVALID_PARAMETER;
1589         }
1590
1591         if (type > STC_FIREWALL_FAMILY_V6) {
1592                 STC_LOGE("Invalid parameter");
1593                 return STC_ERROR_INVALID_PARAMETER;
1594         }
1595
1596         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1597
1598         fw_rule->family = type;
1599
1600         STC_LOGI("Family type [%u]", fw_rule->family);
1601
1602         return STC_ERROR_NONE;
1603 }
1604
1605 EXPORT_API int stc_firewall_rule_set_src_ip(stc_firewall_rule_h rule_h,
1606                                 char *ip1, char *ip2)
1607 {
1608         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1609
1610         if (__stc_fw_check_rule_validity(rule_h) == false) {
1611                 STC_LOGE("Invalid parameter");
1612                 return STC_ERROR_INVALID_PARAMETER;
1613         }
1614
1615         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1616
1617         FREE(fw_rule->s_ip1);
1618         FREE(fw_rule->s_ip2);
1619         fw_rule->s_ip1 = g_strdup(ip1);
1620         fw_rule->s_ip2 = g_strdup(ip2);
1621
1622         STC_LOGI("Source IP [%s:%s]", fw_rule->s_ip1, fw_rule->s_ip2);
1623
1624         return STC_ERROR_NONE;
1625 }
1626
1627 EXPORT_API int stc_firewall_rule_set_dst_ip(stc_firewall_rule_h rule_h,
1628                                 char *ip1, char *ip2)
1629 {
1630         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1631
1632         if (__stc_fw_check_rule_validity(rule_h) == false) {
1633                 STC_LOGE("Invalid parameter");
1634                 return STC_ERROR_INVALID_PARAMETER;
1635         }
1636
1637         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1638
1639         FREE(fw_rule->d_ip1);
1640         FREE(fw_rule->d_ip2);
1641         fw_rule->d_ip1 = g_strdup(ip1);
1642         fw_rule->d_ip2 = g_strdup(ip2);
1643
1644         STC_LOGI("Destination IP [%s:%s]", fw_rule->d_ip1, fw_rule->d_ip2);
1645
1646         return STC_ERROR_NONE;
1647 }
1648
1649 EXPORT_API int stc_firewall_rule_set_src_port(stc_firewall_rule_h rule_h,
1650                                 unsigned int port1, unsigned int port2)
1651 {
1652         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1653
1654         if (__stc_fw_check_rule_validity(rule_h) == false) {
1655                 STC_LOGE("Invalid parameter");
1656                 return STC_ERROR_INVALID_PARAMETER;
1657         }
1658
1659         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1660
1661         fw_rule->s_port1 = port1;
1662         fw_rule->s_port2 = port2;
1663
1664         STC_LOGI("Source port [%u:%u]", fw_rule->s_port1, fw_rule->s_port2);
1665
1666         return STC_ERROR_NONE;
1667 }
1668
1669 EXPORT_API int stc_firewall_rule_set_dst_port(stc_firewall_rule_h rule_h,
1670                                 unsigned int port1, unsigned int port2)
1671 {
1672         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1673
1674         if (__stc_fw_check_rule_validity(rule_h) == false) {
1675                 STC_LOGE("Invalid parameter");
1676                 return STC_ERROR_INVALID_PARAMETER;
1677         }
1678
1679         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1680
1681         fw_rule->d_port1 = port1;
1682         fw_rule->d_port2 = port2;
1683
1684         STC_LOGI("Destination port [%u:%u]", fw_rule->d_port1, fw_rule->d_port2);
1685
1686         return STC_ERROR_NONE;
1687 }
1688
1689 EXPORT_API int stc_firewall_rule_set_ifname(stc_firewall_rule_h rule_h, char *ifname)
1690 {
1691         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1692
1693         if (__stc_fw_check_rule_validity(rule_h) == false) {
1694                 STC_LOGE("Invalid parameter");
1695                 return STC_ERROR_INVALID_PARAMETER;
1696         }
1697
1698         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1699
1700         FREE(fw_rule->ifname);
1701         fw_rule->ifname = g_strdup(ifname);
1702
1703         STC_LOGI("Interface name [%s]", fw_rule->ifname);
1704
1705         return STC_ERROR_NONE;
1706 }
1707
1708 EXPORT_API int stc_firewall_rule_set_target(stc_firewall_rule_h rule_h,
1709                                 stc_firewall_rule_target_e target)
1710 {
1711         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1712
1713         if (__stc_fw_check_rule_validity(rule_h) == false) {
1714                 STC_LOGE("Invalid parameter");
1715                 return STC_ERROR_INVALID_PARAMETER;
1716         }
1717
1718         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1719
1720         fw_rule->target = target;
1721
1722         STC_LOGI("Target [%s]",
1723                 _stc_convert_fw_rule_target_to_string(fw_rule->target));
1724
1725         return STC_ERROR_NONE;
1726 }
1727
1728 EXPORT_API int stc_firewall_rule_set_log_level(stc_firewall_rule_h rule_h,
1729                         unsigned char level)
1730 {
1731         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1732
1733         if (__stc_fw_check_rule_validity(rule_h) == false) {
1734                 STC_LOGE("Invalid parameter");
1735                 return STC_ERROR_INVALID_PARAMETER;
1736         }
1737
1738         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1739
1740         fw_rule->log_level = level;
1741
1742         STC_LOGI("Log level [%u]", fw_rule->log_level);
1743
1744         return STC_ERROR_NONE;
1745 }
1746
1747 EXPORT_API int stc_firewall_rule_set_log_prefix(stc_firewall_rule_h rule_h,
1748                         char *prefix)
1749 {
1750         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1751
1752         if (__stc_fw_check_rule_validity(rule_h) == false) {
1753                 STC_LOGE("Invalid parameter");
1754                 return STC_ERROR_INVALID_PARAMETER;
1755         }
1756
1757         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1758
1759         FREE(fw_rule->log_prefix);
1760         fw_rule->log_prefix = g_strdup(prefix);
1761
1762         STC_LOGI("Log prefix [%s]", fw_rule->log_prefix);
1763
1764         return STC_ERROR_NONE;
1765 }
1766
1767 EXPORT_API int stc_firewall_rule_set_nflog_group(stc_firewall_rule_h rule_h,
1768                         unsigned int group)
1769 {
1770         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1771
1772         if (__stc_fw_check_rule_validity(rule_h) == false) {
1773                 STC_LOGE("Invalid parameter");
1774                 return STC_ERROR_INVALID_PARAMETER;
1775         }
1776
1777         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1778
1779         fw_rule->nflog_group = group;
1780
1781         STC_LOGI("Nflog group [%d]", fw_rule->nflog_group);
1782
1783         return STC_ERROR_NONE;
1784 }
1785
1786 EXPORT_API int stc_firewall_rule_set_nflog_prefix(stc_firewall_rule_h rule_h,
1787                         char *prefix)
1788 {
1789         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1790
1791         if (__stc_fw_check_rule_validity(rule_h) == false) {
1792                 STC_LOGE("Invalid parameter");
1793                 return STC_ERROR_INVALID_PARAMETER;
1794         }
1795
1796         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1797
1798         FREE(fw_rule->nflog_prefix);
1799         fw_rule->nflog_prefix = g_strdup(prefix);
1800
1801         STC_LOGI("Nflog prefix [%s]", fw_rule->nflog_prefix);
1802
1803         return STC_ERROR_NONE;
1804 }
1805
1806 EXPORT_API int stc_firewall_rule_set_nflog_range(stc_firewall_rule_h rule_h,
1807                         unsigned int range)
1808 {
1809         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1810
1811         if (__stc_fw_check_rule_validity(rule_h) == false) {
1812                 STC_LOGE("Invalid parameter");
1813                 return STC_ERROR_INVALID_PARAMETER;
1814         }
1815
1816         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1817
1818         fw_rule->nflog_range = range;
1819
1820         STC_LOGI("Nflog range [%d]", fw_rule->nflog_range);
1821
1822         return STC_ERROR_NONE;
1823 }
1824
1825 EXPORT_API int stc_firewall_rule_set_nflog_threshold(stc_firewall_rule_h rule_h,
1826                         unsigned int threshold)
1827 {
1828         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1829
1830         if (__stc_fw_check_rule_validity(rule_h) == false) {
1831                 STC_LOGE("Invalid parameter");
1832                 return STC_ERROR_INVALID_PARAMETER;
1833         }
1834
1835         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1836
1837         fw_rule->nflog_threshold = threshold;
1838
1839         STC_LOGI("Nflog threshold [%d]", fw_rule->nflog_threshold);
1840
1841         return STC_ERROR_NONE;
1842 }
1843
1844 EXPORT_API int stc_firewall_rule_get_chain(stc_firewall_rule_h rule_h, char **chain)
1845 {
1846         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1847
1848         if (__stc_fw_check_rule_validity(rule_h) == false) {
1849                 STC_LOGE("Invalid parameter");
1850                 return STC_ERROR_INVALID_PARAMETER;
1851         }
1852
1853         if (!chain) {
1854                 STC_LOGE("Invalid parameter");
1855                 return STC_ERROR_INVALID_PARAMETER;
1856         }
1857
1858         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1859
1860         *chain = g_strdup(fw_rule->chain);
1861
1862         STC_LOGI("Chain [%s]", *chain);
1863
1864         return STC_ERROR_NONE;
1865 }
1866
1867 EXPORT_API int stc_firewall_rule_get_direction(stc_firewall_rule_h rule_h,
1868                                 stc_firewall_direction_e *direction)
1869 {
1870         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1871
1872         if (__stc_fw_check_rule_validity(rule_h) == false) {
1873                 STC_LOGE("Invalid parameter");
1874                 return STC_ERROR_INVALID_PARAMETER;
1875         }
1876
1877         if (!direction) {
1878                 STC_LOGE("Invalid parameter");
1879                 return STC_ERROR_INVALID_PARAMETER;
1880         }
1881
1882         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1883
1884         *direction = fw_rule->direction;
1885
1886         STC_LOGI("Direction [%s]", _stc_convert_fw_direction_to_string(*direction));
1887
1888         return STC_ERROR_NONE;
1889 }
1890
1891 EXPORT_API int stc_firewall_rule_get_src_ip_type(stc_firewall_rule_h rule_h,
1892                                 stc_firewall_ip_type_e *type)
1893 {
1894         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1895
1896         if (__stc_fw_check_rule_validity(rule_h) == false) {
1897                 STC_LOGE("Invalid parameter");
1898                 return STC_ERROR_INVALID_PARAMETER;
1899         }
1900
1901         if (!type) {
1902                 STC_LOGE("Invalid parameter");
1903                 return STC_ERROR_INVALID_PARAMETER;
1904         }
1905
1906         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1907
1908         *type = fw_rule->s_ip_type;
1909
1910         STC_LOGI("Source IP type [%s]", _stc_convert_fw_ip_type_to_string(*type));
1911
1912         return STC_ERROR_NONE;
1913 }
1914
1915 EXPORT_API int stc_firewall_rule_get_dst_ip_type(stc_firewall_rule_h rule_h,
1916                                 stc_firewall_ip_type_e *type)
1917 {
1918         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1919
1920         if (__stc_fw_check_rule_validity(rule_h) == false) {
1921                 STC_LOGE("Invalid parameter");
1922                 return STC_ERROR_INVALID_PARAMETER;
1923         }
1924
1925         if (!type) {
1926                 STC_LOGE("Invalid parameter");
1927                 return STC_ERROR_INVALID_PARAMETER;
1928         }
1929
1930         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1931
1932         *type = fw_rule->d_ip_type;
1933
1934         STC_LOGI("Destination IP type [%s]", _stc_convert_fw_ip_type_to_string(*type));
1935
1936         return STC_ERROR_NONE;
1937 }
1938
1939 EXPORT_API int stc_firewall_rule_get_src_port_type(stc_firewall_rule_h rule_h,
1940                                 stc_firewall_port_type_e *type)
1941 {
1942         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1943
1944         if (__stc_fw_check_rule_validity(rule_h) == false) {
1945                 STC_LOGE("Invalid parameter");
1946                 return STC_ERROR_INVALID_PARAMETER;
1947         }
1948
1949         if (!type) {
1950                 STC_LOGE("Invalid parameter");
1951                 return STC_ERROR_INVALID_PARAMETER;
1952         }
1953
1954         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1955
1956         *type = fw_rule->s_port_type;
1957
1958         STC_LOGI("Source port type [%s]", _stc_convert_fw_port_type_to_string(*type));
1959
1960         return STC_ERROR_NONE;
1961 }
1962
1963 EXPORT_API int stc_firewall_rule_get_dst_port_type(stc_firewall_rule_h rule_h,
1964                                 stc_firewall_port_type_e *type)
1965 {
1966         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1967
1968         if (__stc_fw_check_rule_validity(rule_h) == false) {
1969                 STC_LOGE("Invalid parameter");
1970                 return STC_ERROR_INVALID_PARAMETER;
1971         }
1972
1973         if (!type) {
1974                 STC_LOGE("Invalid parameter");
1975                 return STC_ERROR_INVALID_PARAMETER;
1976         }
1977
1978         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
1979
1980         *type = fw_rule->d_port_type;
1981
1982         STC_LOGI("Destination port type [%s]", _stc_convert_fw_port_type_to_string(*type));
1983
1984         return STC_ERROR_NONE;
1985 }
1986
1987 EXPORT_API int stc_firewall_rule_get_protocol_type(stc_firewall_rule_h rule_h,
1988                                 stc_firewall_protocol_type_e *type)
1989 {
1990         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
1991
1992         if (__stc_fw_check_rule_validity(rule_h) == false) {
1993                 STC_LOGE("Invalid parameter");
1994                 return STC_ERROR_INVALID_PARAMETER;
1995         }
1996
1997         if (!type) {
1998                 STC_LOGE("Invalid parameter");
1999                 return STC_ERROR_INVALID_PARAMETER;
2000         }
2001
2002         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2003
2004         *type = fw_rule->protocol;
2005
2006         STC_LOGI("Protocol type [%s]", _stc_convert_fw_protocol_type_to_string(*type));
2007
2008         return STC_ERROR_NONE;
2009 }
2010
2011 EXPORT_API int stc_firewall_rule_get_family_type(stc_firewall_rule_h rule_h,
2012                                 stc_firewall_family_type_e *type)
2013 {
2014         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2015
2016         if (__stc_fw_check_rule_validity(rule_h) == false) {
2017                 STC_LOGE("Invalid parameter");
2018                 return STC_ERROR_INVALID_PARAMETER;
2019         }
2020
2021         if (!type) {
2022                 STC_LOGE("Invalid parameter");
2023                 return STC_ERROR_INVALID_PARAMETER;
2024         }
2025
2026         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2027
2028         *type = fw_rule->family;
2029
2030         STC_LOGI("Address family type [%s]", _stc_convert_fw_family_type_to_string(*type));
2031
2032         return STC_ERROR_NONE;
2033 }
2034
2035 EXPORT_API int stc_firewall_rule_get_src_ip(stc_firewall_rule_h rule_h,
2036                                 char **ip1, char **ip2)
2037 {
2038         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2039
2040         if (__stc_fw_check_rule_validity(rule_h) == false) {
2041                 STC_LOGE("Invalid parameter");
2042                 return STC_ERROR_INVALID_PARAMETER;
2043         }
2044
2045         if (!ip1 || !ip2) {
2046                 STC_LOGE("Invalid parameter");
2047                 return STC_ERROR_INVALID_PARAMETER;
2048         }
2049
2050         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2051
2052         *ip1 = g_strdup(fw_rule->s_ip1);
2053         *ip2 = g_strdup(fw_rule->s_ip2);
2054
2055         STC_LOGI("Source IP [%s:%s]", *ip1, *ip2);
2056
2057         return STC_ERROR_NONE;
2058 }
2059
2060 EXPORT_API int stc_firewall_rule_get_dst_ip(stc_firewall_rule_h rule_h,
2061                                 char **ip1, char **ip2)
2062 {
2063         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2064
2065         if (__stc_fw_check_rule_validity(rule_h) == false) {
2066                 STC_LOGE("Invalid parameter");
2067                 return STC_ERROR_INVALID_PARAMETER;
2068         }
2069
2070         if (!ip1 || !ip2) {
2071                 STC_LOGE("Invalid parameter");
2072                 return STC_ERROR_INVALID_PARAMETER;
2073         }
2074
2075         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2076
2077         *ip1 = g_strdup(fw_rule->d_ip1);
2078         *ip2 = g_strdup(fw_rule->d_ip2);
2079
2080         STC_LOGI("Destination IP [%s:%s]", *ip1, *ip2);
2081
2082         return STC_ERROR_NONE;
2083 }
2084
2085 EXPORT_API int stc_firewall_rule_get_src_port(stc_firewall_rule_h rule_h,
2086                                 unsigned int *port1, unsigned int *port2)
2087 {
2088         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2089
2090         if (__stc_fw_check_rule_validity(rule_h) == false) {
2091                 STC_LOGE("Invalid parameter");
2092                 return STC_ERROR_INVALID_PARAMETER;
2093         }
2094
2095         if (!port1 || !port2) {
2096                 STC_LOGE("Invalid parameter");
2097                 return STC_ERROR_INVALID_PARAMETER;
2098         }
2099
2100         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2101
2102         *port1 = fw_rule->s_port1;
2103         *port2 = fw_rule->s_port2;
2104
2105         STC_LOGI("Source port [%u:%u]", *port1, *port2);
2106
2107         return STC_ERROR_NONE;
2108 }
2109
2110 EXPORT_API int stc_firewall_rule_get_dst_port(stc_firewall_rule_h rule_h,
2111                                 unsigned int *port1, unsigned int *port2)
2112 {
2113         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2114
2115         if (__stc_fw_check_rule_validity(rule_h) == false) {
2116                 STC_LOGE("Invalid parameter");
2117                 return STC_ERROR_INVALID_PARAMETER;
2118         }
2119
2120         if (!port1 || !port2) {
2121                 STC_LOGE("Invalid parameter");
2122                 return STC_ERROR_INVALID_PARAMETER;
2123         }
2124
2125         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2126
2127         *port1 = fw_rule->d_port1;
2128         *port2 = fw_rule->d_port2;
2129
2130         STC_LOGI("Destination port [%u:%u]", *port1, *port2);
2131
2132         return STC_ERROR_NONE;
2133 }
2134
2135 EXPORT_API int stc_firewall_rule_get_ifname(stc_firewall_rule_h rule_h, char **ifname)
2136 {
2137         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2138
2139         if (__stc_fw_check_rule_validity(rule_h) == false) {
2140                 STC_LOGE("Invalid parameter");
2141                 return STC_ERROR_INVALID_PARAMETER;
2142         }
2143
2144         if (!ifname) {
2145                 STC_LOGE("Invalid parameter");
2146                 return STC_ERROR_INVALID_PARAMETER;
2147         }
2148
2149         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2150
2151         *ifname = g_strdup(fw_rule->ifname);
2152
2153         STC_LOGI("Interface name [%s]", *ifname);
2154
2155         return STC_ERROR_NONE;
2156 }
2157
2158 EXPORT_API int stc_firewall_rule_get_target(stc_firewall_rule_h rule_h,
2159                                 stc_firewall_rule_target_e *target)
2160 {
2161         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2162
2163         if (__stc_fw_check_rule_validity(rule_h) == false) {
2164                 STC_LOGE("Invalid parameter");
2165                 return STC_ERROR_INVALID_PARAMETER;
2166         }
2167
2168         if (!target) {
2169                 STC_LOGE("Invalid parameter");
2170                 return STC_ERROR_INVALID_PARAMETER;
2171         }
2172
2173         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2174
2175         *target = fw_rule->target;
2176
2177         STC_LOGI("Target [%s]", _stc_convert_fw_rule_target_to_string(*target));
2178
2179         return STC_ERROR_NONE;
2180 }
2181
2182 EXPORT_API int stc_firewall_rule_get_log_level(stc_firewall_rule_h rule_h,
2183                         unsigned char *level)
2184 {
2185         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2186
2187         if (__stc_fw_check_rule_validity(rule_h) == false) {
2188                 STC_LOGE("Invalid parameter");
2189                 return STC_ERROR_INVALID_PARAMETER;
2190         }
2191
2192         if (!level) {
2193                 STC_LOGE("Invalid parameter");
2194                 return STC_ERROR_INVALID_PARAMETER;
2195         }
2196
2197         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2198
2199         *level = fw_rule->log_level;
2200
2201         STC_LOGI("Log level [%u]", *level);
2202
2203         return STC_ERROR_NONE;
2204 }
2205
2206 EXPORT_API int stc_firewall_rule_get_log_prefix(stc_firewall_rule_h rule_h,
2207                         char **prefix)
2208 {
2209         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2210
2211         if (__stc_fw_check_rule_validity(rule_h) == false) {
2212                 STC_LOGE("Invalid parameter");
2213                 return STC_ERROR_INVALID_PARAMETER;
2214         }
2215
2216         if (!prefix) {
2217                 STC_LOGE("Invalid parameter");
2218                 return STC_ERROR_INVALID_PARAMETER;
2219         }
2220
2221         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2222
2223         *prefix = g_strdup(fw_rule->log_prefix);
2224
2225         STC_LOGI("Log prefix [%s]", *prefix);
2226
2227         return STC_ERROR_NONE;
2228 }
2229
2230 EXPORT_API int stc_firewall_rule_get_nflog_group(stc_firewall_rule_h rule_h,
2231                         unsigned int *group)
2232 {
2233         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2234
2235         if (__stc_fw_check_rule_validity(rule_h) == false) {
2236                 STC_LOGE("Invalid parameter");
2237                 return STC_ERROR_INVALID_PARAMETER;
2238         }
2239
2240         if (!group) {
2241                 STC_LOGE("Invalid parameter");
2242                 return STC_ERROR_INVALID_PARAMETER;
2243         }
2244
2245         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2246
2247         *group = fw_rule->nflog_group;
2248
2249         STC_LOGI("Nflog group [%d]", *group);
2250
2251         return STC_ERROR_NONE;
2252 }
2253
2254 EXPORT_API int stc_firewall_rule_get_nflog_prefix(stc_firewall_rule_h rule_h,
2255                         char **prefix)
2256 {
2257         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2258
2259         if (__stc_fw_check_rule_validity(rule_h) == false) {
2260                 STC_LOGE("Invalid parameter");
2261                 return STC_ERROR_INVALID_PARAMETER;
2262         }
2263
2264         if (!prefix) {
2265                 STC_LOGE("Invalid parameter");
2266                 return STC_ERROR_INVALID_PARAMETER;
2267         }
2268
2269         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2270
2271         *prefix = g_strdup(fw_rule->nflog_prefix);
2272
2273         STC_LOGI("Nflog prefix [%s]", *prefix);
2274
2275         return STC_ERROR_NONE;
2276 }
2277
2278 EXPORT_API int stc_firewall_rule_get_nflog_range(stc_firewall_rule_h rule_h,
2279                         unsigned int *range)
2280 {
2281         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2282
2283         if (__stc_fw_check_rule_validity(rule_h) == false) {
2284                 STC_LOGE("Invalid parameter");
2285                 return STC_ERROR_INVALID_PARAMETER;
2286         }
2287
2288         if (!range) {
2289                 STC_LOGE("Invalid parameter");
2290                 return STC_ERROR_INVALID_PARAMETER;
2291         }
2292
2293         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2294
2295         *range = fw_rule->nflog_range;
2296
2297         STC_LOGI("Nflog range [%d]", *range);
2298
2299         return STC_ERROR_NONE;
2300 }
2301
2302 EXPORT_API int stc_firewall_rule_get_nflog_threshold(stc_firewall_rule_h rule_h,
2303                         unsigned int *threshold)
2304 {
2305         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2306
2307         if (__stc_fw_check_rule_validity(rule_h) == false) {
2308                 STC_LOGE("Invalid parameter");
2309                 return STC_ERROR_INVALID_PARAMETER;
2310         }
2311
2312         if (!threshold) {
2313                 STC_LOGE("Invalid parameter");
2314                 return STC_ERROR_INVALID_PARAMETER;
2315         }
2316
2317         stc_fw_rule_s *fw_rule = (stc_fw_rule_s *)rule_h;
2318
2319         *threshold = fw_rule->nflog_threshold;
2320
2321         STC_LOGI("Nflog threshold [%d]", *threshold);
2322
2323         return STC_ERROR_NONE;
2324 }
2325
2326 EXPORT_API int stc_firewall_rule_add(stc_firewall_rule_h rule_h)
2327 {
2328         int ret = STC_ERROR_NONE;
2329
2330         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2331
2332         if (__stc_fw_check_rule_validity(rule_h) == false) {
2333                 STC_LOGE("Invalid parameter");
2334                 return STC_ERROR_INVALID_PARAMETER;
2335         }
2336
2337         if (__stc_fw_check_rule_created(rule_h) == false) {
2338                 STC_LOGE("Invalid parameter");
2339                 return STC_ERROR_INVALID_PARAMETER;
2340         }
2341
2342         ret = _stc_fw_rule_add((stc_fw_rule_s *)rule_h);
2343         if (ret != STC_ERROR_NONE) {
2344                 STC_LOGE("Failed to add firewall rule [%s]",
2345                         _stc_convert_error_type_to_string(ret));
2346                 return ret;
2347         }
2348
2349         return STC_ERROR_NONE;
2350 }
2351
2352 EXPORT_API int stc_firewall_rule_remove(stc_firewall_rule_h rule_h)
2353 {
2354         int ret = STC_ERROR_NONE;
2355
2356         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2357
2358         if (__stc_fw_check_rule_validity(rule_h) == false) {
2359                 STC_LOGE("Invalid parameter");
2360                 return STC_ERROR_INVALID_PARAMETER;
2361         }
2362
2363         if (__stc_fw_check_rule_created(rule_h) == true) {
2364                 STC_LOGE("Invalid parameter");
2365                 return STC_ERROR_INVALID_PARAMETER;
2366         }
2367
2368         ret = _stc_fw_rule_remove((stc_fw_rule_s *)rule_h);
2369         if (ret != STC_ERROR_NONE) {
2370                 STC_LOGE("Failed to remove firewall rule [%s]",
2371                         _stc_convert_error_type_to_string(ret));
2372                 return ret;
2373         }
2374
2375         return STC_ERROR_NONE;
2376 }
2377
2378 EXPORT_API int stc_firewall_rule_update(stc_firewall_rule_h rule_h)
2379 {
2380         int ret = STC_ERROR_NONE;
2381
2382         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2383
2384         if (__stc_fw_check_rule_validity(rule_h) == false) {
2385                 STC_LOGE("Invalid parameter");
2386                 return STC_ERROR_INVALID_PARAMETER;
2387         }
2388
2389         if (__stc_fw_check_rule_created(rule_h) == true) {
2390                 STC_LOGE("Invalid parameter");
2391                 return STC_ERROR_INVALID_PARAMETER;
2392         }
2393
2394         ret = _stc_fw_rule_update((stc_fw_rule_s *)rule_h);
2395         if (ret != STC_ERROR_NONE) {
2396                 STC_LOGE("Failed to update firewall rule [%s]",
2397                         _stc_convert_error_type_to_string(ret));
2398                 return ret;
2399         }
2400
2401         return STC_ERROR_NONE;
2402 }
2403 EXPORT_API int stc_firewall_rule_foreach(stc_h stc,
2404                                 stc_firewall_rule_info_cb callback, void *user_data)
2405 {
2406         int ret = STC_ERROR_NONE;
2407
2408         CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW);
2409
2410         if (!(_stc_handle_check_validity(stc))) {
2411                 STC_LOGE("Invalid parameter");
2412                 return STC_ERROR_INVALID_PARAMETER;
2413         }
2414
2415         if (callback == NULL) {
2416                 STC_LOGE("Invalid parameter");
2417                 return STC_ERROR_INVALID_PARAMETER;
2418         }
2419
2420         ret = _stc_fw_rule_foreach(callback, user_data);
2421         if (ret != STC_ERROR_NONE) {
2422                 STC_LOGE("Failed to get all firewall rule [%s]",
2423                         _stc_convert_error_type_to_string(ret));
2424                 return ret;
2425         }
2426
2427         return STC_ERROR_NONE;
2428 }