2 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include "stc-manager-gdbus.h"
18 #include "helper-firewall.h"
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"
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"
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"
38 #define BUF_SIZE_FOR_IP 64
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"
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"
60 static void __fw_add_rule_info_to_builder(GVariantBuilder *builder,
61 firewall_rule_s *rule)
63 if (builder == NULL || rule == NULL)
66 g_variant_builder_add(builder, "{sv}", RULE_CHAIN,
67 g_variant_new_string(rule->chain));
69 if (rule->direction != STC_FW_DIRECTION_NONE)
70 g_variant_builder_add(builder, "{sv}", RULE_DIRECTION,
71 g_variant_new_uint16(rule->direction));
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));
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));
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));
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));
89 if (rule->protocol != STC_FW_PROTOCOL_NONE)
90 g_variant_builder_add(builder, "{sv}", RULE_PROTOCOL,
91 g_variant_new_uint16(rule->protocol));
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));
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));
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));
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));
112 case STC_FW_FAMILY_V6:
114 char buf[BUF_SIZE_FOR_IP];
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));
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));
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));
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));
162 g_variant_builder_add(builder, "{sv}", RULE_SPORT1,
163 g_variant_new_uint32(rule->s_port1));
166 g_variant_builder_add(builder, "{sv}", RULE_SPORT2,
167 g_variant_new_uint32(rule->s_port2));
170 g_variant_builder_add(builder, "{sv}", RULE_DPORT1,
171 g_variant_new_uint32(rule->d_port1));
174 g_variant_builder_add(builder, "{sv}", RULE_DPORT2,
175 g_variant_new_uint32(rule->d_port2));
178 g_variant_builder_add(builder, "{sv}", RULE_IFNAME,
179 g_variant_new_string(rule->ifname));
181 if (rule->target_str)
182 g_variant_builder_add(builder, "{sv}", RULE_TARGET,
183 g_variant_new_string(rule->target_str));
186 static int __fw_add_chain(GDBusConnection *connection,
190 GVariant *message = NULL;
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));
199 if (message == NULL) {
200 STC_LOGE("Failed to invoke dbus method");
201 return STC_ERROR_FAIL;
204 g_variant_get(message, "(i)", &result);
205 STC_LOGD("Successfully added firewall chain [%d:%s]", result, chain);
206 g_variant_unref(message);
208 return STC_ERROR_NONE;
211 static int __fw6_add_chain(GDBusConnection *connection,
215 GVariant *message = NULL;
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));
224 if (message == NULL) {
225 STC_LOGE("Failed to invoke dbus method");
226 return STC_ERROR_FAIL;
229 g_variant_get(message, "(i)", &result);
230 STC_LOGD("Successfully added firewall6 chain [%d:%s]", result, chain);
231 g_variant_unref(message);
233 return STC_ERROR_NONE;
236 static int __fw_remove_chain(GDBusConnection *connection,
240 GVariant *message = NULL;
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));
249 if (message == NULL) {
250 STC_LOGE("Failed to invoke dbus method");
251 return STC_ERROR_FAIL;
254 g_variant_get(message, "(i)", &result);
255 STC_LOGD("Successfully removed firewall chain [%d:%s]", result, chain);
256 g_variant_unref(message);
258 return STC_ERROR_NONE;
261 static int __fw6_remove_chain(GDBusConnection *connection,
265 GVariant *message = NULL;
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));
274 if (message == NULL) {
275 STC_LOGE("Failed to invoke dbus method");
276 return STC_ERROR_FAIL;
279 g_variant_get(message, "(i)", &result);
280 STC_LOGD("Successfully removed firewall6 chain [%d:%s]", result, chain);
281 g_variant_unref(message);
283 return STC_ERROR_NONE;
286 static int __fw_flush_chain(GDBusConnection *connection,
290 GVariant *message = NULL;
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));
299 if (message == NULL) {
300 STC_LOGE("Failed to invoke dbus method");
301 return STC_ERROR_FAIL;
304 g_variant_get(message, "(i)", &result);
305 STC_LOGD("Successfully flushed firewall chain [%d:%s]", result, chain);
306 g_variant_unref(message);
308 return STC_ERROR_NONE;
311 static int __fw6_flush_chain(GDBusConnection *connection,
315 GVariant *message = NULL;
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));
324 if (message == NULL) {
325 STC_LOGE("Failed to invoke dbus method");
326 return STC_ERROR_FAIL;
329 g_variant_get(message, "(i)", &result);
330 STC_LOGD("Successfully flushed firewall6 chain [%d:%s]", result, chain);
331 g_variant_unref(message);
333 return STC_ERROR_NONE;
336 static int __fw_set_chain(firewall_chain_s *chain)
338 stc_error_e ret = STC_ERROR_NONE;
339 firewall_rule_s rule;
340 memset(&rule, 0, sizeof(firewall_rule_s));
342 switch (chain->target) {
343 case STC_FW_CHAIN_TARGET_INPUT:
344 rule.chain = g_strdup(FIREWALL_CHAIN_TARGET_IN);
346 case STC_FW_CHAIN_TARGET_OUTPUT:
347 rule.chain = g_strdup(FIREWALL_CHAIN_TARGET_OUT);
350 return STC_ERROR_INVALID_PARAMETER;
353 rule.target_str = g_strdup(chain->chain);
354 ret = firewall_rule_add(&rule);
357 g_free(rule.target_str);
362 static int __fw_unset_chain(firewall_chain_s *chain)
364 stc_error_e ret = STC_ERROR_NONE;
365 firewall_rule_s rule;
366 memset(&rule, 0, sizeof(firewall_rule_s));
368 switch (chain->target) {
369 case STC_FW_CHAIN_TARGET_INPUT:
370 rule.chain = g_strdup(FIREWALL_CHAIN_TARGET_IN);
372 case STC_FW_CHAIN_TARGET_OUTPUT:
373 rule.chain = g_strdup(FIREWALL_CHAIN_TARGET_OUT);
376 return STC_ERROR_INVALID_PARAMETER;
379 rule.target_str = g_strdup(chain->chain);
380 ret = firewall_rule_remove(&rule);
383 g_free(rule.target_str);
388 static int __fw_add_rule(GDBusConnection *connection,
389 firewall_rule_s *rule)
392 GVariantBuilder *builder = NULL;
393 GVariant *params = NULL;
394 GVariant *message = NULL;
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);
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,
408 if (message == NULL) {
409 STC_LOGE("Failed to invoke dbus method");
410 return STC_ERROR_FAIL;
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);
418 return STC_ERROR_NONE;
421 static int __fw6_add_rule(GDBusConnection *connection,
422 firewall_rule_s *rule)
425 GVariantBuilder *builder = NULL;
426 GVariant *params = NULL;
427 GVariant *message = NULL;
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);
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,
441 if (message == NULL) {
442 STC_LOGE("Failed to invoke dbus method");
443 return STC_ERROR_FAIL;
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);
451 return STC_ERROR_NONE;
454 static int __fw_remove_rule(GDBusConnection *connection,
455 firewall_rule_s *rule)
458 GVariantBuilder *builder = NULL;
459 GVariant *params = NULL;
460 GVariant *message = NULL;
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);
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,
474 if (message == NULL) {
475 STC_LOGE("Failed to invoke dbus method");
476 return STC_ERROR_FAIL;
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);
484 return STC_ERROR_NONE;
487 static int __fw6_remove_rule(GDBusConnection *connection,
488 firewall_rule_s *rule)
491 GVariantBuilder *builder = NULL;
492 GVariant *params = NULL;
493 GVariant *message = NULL;
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);
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,
507 if (message == NULL) {
508 STC_LOGE("Failed to invoke dbus method");
509 return STC_ERROR_FAIL;
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);
517 return STC_ERROR_NONE;
520 stc_error_e firewall_chain_add(firewall_chain_s *chain)
522 __STC_LOG_FUNC_ENTER__;
524 stc_error_e ret = STC_ERROR_NONE;
525 stc_s *stc = stc_get_manager();
527 if (!stc || !stc->connection) {
528 __STC_LOG_FUNC_EXIT__;
529 return STC_ERROR_UNINITIALIZED;
532 ret = __fw_add_chain(stc->connection, chain->chain);
533 if (ret != STC_ERROR_NONE) {
534 __STC_LOG_FUNC_EXIT__;
538 ret = __fw6_add_chain(stc->connection, chain->chain);
539 if (ret != STC_ERROR_NONE) {
540 __STC_LOG_FUNC_EXIT__;
544 __STC_LOG_FUNC_EXIT__;
548 stc_error_e firewall_chain_remove(firewall_chain_s *chain)
550 __STC_LOG_FUNC_ENTER__;
552 stc_error_e ret = STC_ERROR_NONE;
553 stc_s *stc = stc_get_manager();
555 if (!stc || !stc->connection) {
556 __STC_LOG_FUNC_EXIT__;
557 return STC_ERROR_UNINITIALIZED;
560 ret = __fw_remove_chain(stc->connection, chain->chain);
561 if (ret != STC_ERROR_NONE) {
562 __STC_LOG_FUNC_EXIT__;
566 ret = __fw6_remove_chain(stc->connection, chain->chain);
567 if (ret != STC_ERROR_NONE) {
568 __STC_LOG_FUNC_EXIT__;
572 __STC_LOG_FUNC_EXIT__;
576 stc_error_e firewall_chain_flush(firewall_chain_s *chain)
578 __STC_LOG_FUNC_ENTER__;
580 stc_error_e ret = STC_ERROR_NONE;
581 stc_s *stc = stc_get_manager();
583 if (!stc || !stc->connection) {
584 __STC_LOG_FUNC_EXIT__;
585 return STC_ERROR_UNINITIALIZED;
588 ret = __fw_flush_chain(stc->connection, chain->chain);
589 if (ret != STC_ERROR_NONE) {
590 __STC_LOG_FUNC_EXIT__;
594 ret = __fw6_flush_chain(stc->connection, chain->chain);
595 if (ret != STC_ERROR_NONE) {
596 __STC_LOG_FUNC_EXIT__;
600 __STC_LOG_FUNC_EXIT__;
604 stc_error_e firewall_chain_set(firewall_chain_s *chain)
606 __STC_LOG_FUNC_ENTER__;
608 stc_error_e ret = STC_ERROR_NONE;
609 ret = __fw_set_chain(chain);
611 __STC_LOG_FUNC_EXIT__;
615 stc_error_e firewall_chain_unset(firewall_chain_s *chain)
617 __STC_LOG_FUNC_ENTER__;
619 stc_error_e ret = STC_ERROR_NONE;
620 ret = __fw_unset_chain(chain);
622 __STC_LOG_FUNC_EXIT__;
626 stc_error_e firewall_rule_add(firewall_rule_s *rule)
628 __STC_LOG_FUNC_ENTER__;
630 stc_error_e ret = STC_ERROR_NONE;
631 stc_s *stc = stc_get_manager();
633 if (!stc || !stc->connection) {
634 __STC_LOG_FUNC_EXIT__;
635 return STC_ERROR_UNINITIALIZED;
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__;
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__;
654 ret = __fw_add_rule(stc->connection, rule);
655 if (ret != STC_ERROR_NONE) {
656 __STC_LOG_FUNC_EXIT__;
660 ret = __fw6_add_rule(stc->connection, rule);
661 if (ret != STC_ERROR_NONE) {
662 __STC_LOG_FUNC_EXIT__;
668 __STC_LOG_FUNC_EXIT__;
672 stc_error_e firewall_rule_remove(firewall_rule_s *rule)
674 __STC_LOG_FUNC_ENTER__;
676 stc_error_e ret = STC_ERROR_NONE;
677 stc_s *stc = stc_get_manager();
679 if (!stc || !stc->connection) {
680 __STC_LOG_FUNC_EXIT__;
681 return STC_ERROR_UNINITIALIZED;
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__;
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__;
700 ret = __fw_remove_rule(stc->connection, rule);
701 if (ret != STC_ERROR_NONE) {
702 __STC_LOG_FUNC_EXIT__;
706 ret = __fw6_remove_rule(stc->connection, rule);
707 if (ret != STC_ERROR_NONE) {
708 __STC_LOG_FUNC_EXIT__;
714 __STC_LOG_FUNC_EXIT__;