2 * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
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.
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
26 static void AsyncReadyCallback(GObject *source_object,
27 GAsyncResult *res, gpointer user_data)
29 MainLoop *M = (MainLoop *)user_data;
30 GLOGD("Succeeded to response async callback");
36 this->chain[0] = '\0';
52 this->iface[0] = '\0';
70 error_e Firewall::SetRule(const char *chain, guint16 direction,
71 guint16 siptype, guint16 diptype, guint16 sporttype,
72 guint16 dporttype, guint16 protocol, guint16 family,
73 const char *sip1, const char *dip1, const char *sip2,
74 const char *dip2, guint32 dport1, guint32 dport2,
75 guint32 sport1, guint32 sport2, const char *iface,
78 if (chain == NULL || strlen(chain) == 0)
79 this->m_Rule.chain[0] = '\0';
81 g_strlcpy(this->m_Rule.chain, chain, CHAIN_LEN);
83 if (sip1 == NULL || strlen(sip1) == 0)
84 this->m_Rule.sip1[0] = '\0';
86 g_strlcpy(this->m_Rule.sip1, sip1, IP_LEN);
88 if (sip2 == NULL || strlen(sip2) == 0)
89 this->m_Rule.sip2[0] = '\0';
91 g_strlcpy(this->m_Rule.sip2, sip2, IP_LEN);
93 if (dip1 == NULL || strlen(dip1) == 0)
94 this->m_Rule.dip1[0] = '\0';
96 g_strlcpy(this->m_Rule.dip1, dip1, IP_LEN);
98 if (dip2 == NULL || strlen(dip2) == 0)
99 this->m_Rule.dip2[0] = '\0';
101 g_strlcpy(this->m_Rule.dip2, dip2, IP_LEN);
103 if (iface == NULL || strlen(iface) == 0)
104 this->m_Rule.iface[0] = '\0';
106 g_strlcpy(this->m_Rule.iface, iface, IFACE_LEN);
109 this->m_Rule.direction = direction;
110 this->m_Rule.siptype = siptype;
111 this->m_Rule.diptype = diptype;
112 this->m_Rule.sporttype = sporttype;
113 this->m_Rule.dporttype = dporttype;
114 this->m_Rule.protocol = protocol;
115 this->m_Rule.family = family;
116 this->m_Rule.dport1 = dport1;
117 this->m_Rule.dport2 = dport2;
118 this->m_Rule.sport1 = sport1;
119 this->m_Rule.sport2 = sport2;
120 this->m_Rule.target = target;
125 void Firewall::MakeRuleParams(GVariant **params)
127 GVariantBuilder *builder;
129 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
131 g_variant_builder_add(builder, "{sv}",
133 g_variant_new_string(this->m_Rule.chain));
135 g_variant_builder_add(builder, "{sv}",
136 FIREWALL_RULE_DIRECTION,
137 g_variant_new_uint16(this->m_Rule.direction));
139 g_variant_builder_add(builder, "{sv}",
140 FIREWALL_RULE_IFNAME,
141 g_variant_new_string(this->m_Rule.iface));
143 g_variant_builder_add(builder, "{sv}",
144 FIREWALL_RULE_PROTOCOL,
145 g_variant_new_uint16(this->m_Rule.protocol));
147 g_variant_builder_add(builder, "{sv}",
148 FIREWALL_RULE_TARGET,
149 g_variant_new_uint16(this->m_Rule.target));
151 g_variant_builder_add(builder, "{sv}",
152 FIREWALL_RULE_FAMILY,
153 g_variant_new_uint16(this->m_Rule.family));
155 g_variant_builder_add(builder, "{sv}",
156 FIREWALL_RULE_SIPTYPE,
157 g_variant_new_uint16(this->m_Rule.siptype));
159 g_variant_builder_add(builder, "{sv}",
161 g_variant_new_string(this->m_Rule.sip1));
163 g_variant_builder_add(builder, "{sv}",
165 g_variant_new_string(this->m_Rule.sip2));
167 g_variant_builder_add(builder, "{sv}",
168 FIREWALL_RULE_DIPTYPE,
169 g_variant_new_uint16(this->m_Rule.diptype));
171 g_variant_builder_add(builder, "{sv}",
173 g_variant_new_string(this->m_Rule.dip1));
175 g_variant_builder_add(builder, "{sv}",
177 g_variant_new_string(this->m_Rule.dip2));
179 g_variant_builder_add(builder, "{sv}",
180 FIREWALL_RULE_SPORTTYPE,
181 g_variant_new_uint16(this->m_Rule.sporttype));
183 g_variant_builder_add(builder, "{sv}",
184 FIREWALL_RULE_SPORT1,
185 g_variant_new_uint32(this->m_Rule.sport1));
187 g_variant_builder_add(builder, "{sv}",
188 FIREWALL_RULE_SPORT2,
189 g_variant_new_uint32(this->m_Rule.sport2));
191 g_variant_builder_add(builder, "{sv}",
192 FIREWALL_RULE_DPORTTYPE,
193 g_variant_new_uint16(this->m_Rule.dporttype));
195 g_variant_builder_add(builder, "{sv}",
196 FIREWALL_RULE_DPORT1,
197 g_variant_new_uint32(this->m_Rule.dport1));
199 g_variant_builder_add(builder, "{sv}",
200 FIREWALL_RULE_DPORT2,
201 g_variant_new_uint32(this->m_Rule.dport2));
203 *params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
204 g_variant_builder_unref(builder);
207 error_e Firewall::GetAllRule(void)
210 error_e error = ERROR_NONE;
212 error = InvokeMethodNonblock(STC_MGR_SERVICE,
213 STC_MGR_FIREWALL_PATH,
214 STC_MGR_FIREWALL_INTERFACE,
215 STC_MGR_METHOD_FIREWALL_GET_ALL,
221 if (error != ERROR_NONE) {
222 GLOGD("Failed to invoke dbus method nonblock");
226 GLOGD("Succeeded to get all restriction");
232 error_e Firewall::UpdateRule(void)
234 GVariant *message = NULL;
235 GVariant *params = NULL;
236 error_e error = ERROR_NONE;
239 MakeRuleParams(¶ms);
241 message = InvokeMethod(STC_MGR_SERVICE,
242 STC_MGR_FIREWALL_PATH,
243 STC_MGR_FIREWALL_INTERFACE,
244 STC_MGR_METHOD_FIREWALL_UPDATE,
248 if (message == NULL) {
249 GLOGD("Failed to invoke dbus method");
253 g_variant_get(message, "(i)", &result);
254 GLOGD("Succeeded to set restriction [%d]", result);
255 g_variant_unref(message);
260 error_e Firewall::RemoveRule(void)
262 GVariant *message = NULL;
263 GVariant *params = NULL;
264 error_e error = ERROR_NONE;
267 MakeRuleParams(¶ms);
269 message = InvokeMethod(STC_MGR_SERVICE,
270 STC_MGR_FIREWALL_PATH,
271 STC_MGR_FIREWALL_INTERFACE,
272 STC_MGR_METHOD_FIREWALL_REMOVE,
276 if (message == NULL) {
277 GLOGD("Failed to invoke dbus method");
281 g_variant_get(message, "(i)", &result);
282 GLOGD("Succeeded to set restriction [%d]", result);
283 g_variant_unref(message);
288 error_e Firewall::AddRule(void)
290 GVariant *message = NULL;
291 GVariant *params = NULL;
292 error_e error = ERROR_NONE;
295 MakeRuleParams(¶ms);
297 message = InvokeMethod(STC_MGR_SERVICE,
298 STC_MGR_FIREWALL_PATH,
299 STC_MGR_FIREWALL_INTERFACE,
300 STC_MGR_METHOD_FIREWALL_ADD,
304 if (message == NULL) {
305 GLOGD("Failed to invoke dbus method");
309 g_variant_get(message, "(i)", &result);
310 GLOGD("Succeeded to set restriction [%d]", result);
311 g_variant_unref(message);
316 error_e Firewall::SetChain(const char *chain, unsigned int target)
318 GVariant *message = NULL;
319 error_e error = ERROR_NONE;
322 message = InvokeMethod(STC_MGR_SERVICE,
323 STC_MGR_FIREWALL_PATH,
324 STC_MGR_FIREWALL_INTERFACE,
325 STC_MGR_METHOD_FIREWALL_SET,
326 g_variant_new("(su)", chain, target),
329 if (message == NULL) {
330 GLOGD("Failed to invoke dbus method");
334 g_variant_get(message, "(i)", &result);
335 GLOGD("Succeeded to set restriction [%d]", result);
336 g_variant_unref(message);
341 error_e Firewall::UnsetChain(const char *chain)
343 GVariant *message = NULL;
344 error_e error = ERROR_NONE;
347 message = InvokeMethod(STC_MGR_SERVICE,
348 STC_MGR_FIREWALL_PATH,
349 STC_MGR_FIREWALL_INTERFACE,
350 STC_MGR_METHOD_FIREWALL_UNSET,
351 g_variant_new("(s)", chain),
354 if (message == NULL) {
355 GLOGD("Failed to invoke dbus method");
359 g_variant_get(message, "(i)", &result);
360 GLOGD("Succeeded to set restriction [%d]", result);
361 g_variant_unref(message);
366 error_e Firewall::FlushChain(const char *chain)
368 GVariant *message = NULL;
369 error_e error = ERROR_NONE;
372 message = InvokeMethod(STC_MGR_SERVICE,
373 STC_MGR_FIREWALL_PATH,
374 STC_MGR_FIREWALL_INTERFACE,
375 STC_MGR_METHOD_FIREWALL_FLUSH,
376 g_variant_new("(s)", chain),
379 if (message == NULL) {
380 GLOGD("Failed to invoke dbus method");
384 g_variant_get(message, "(i)", &result);
385 GLOGD("Succeeded to set restriction [%d]", result);
386 g_variant_unref(message);
391 error_e Firewall::GetAllChain(void)
394 error_e error = ERROR_NONE;
396 error = InvokeMethodNonblock(STC_MGR_SERVICE,
397 STC_MGR_FIREWALL_PATH,
398 STC_MGR_FIREWALL_INTERFACE,
399 STC_MGR_METHOD_FIREWALL_GET_CHAIN,
405 if (error != ERROR_NONE) {
406 GLOGD("Failed to invoke dbus method nonblock");
410 GLOGD("Succeeded to get all restriction");
416 error_e Firewall::RemoveChain(const char *chain)
418 GVariant *message = NULL;
419 error_e error = ERROR_NONE;
422 message = InvokeMethod(STC_MGR_SERVICE,
423 STC_MGR_FIREWALL_PATH,
424 STC_MGR_FIREWALL_INTERFACE,
425 STC_MGR_METHOD_FIREWALL_REMOVE_CHAIN,
426 g_variant_new("(s)", chain),
429 if (message == NULL) {
430 GLOGD("Failed to invoke dbus method");
434 g_variant_get(message, "(i)", &result);
435 GLOGD("Succeeded to set restriction [%d]", result);
436 g_variant_unref(message);
441 error_e Firewall::AddChain(const char *chain)
443 GVariant *message = NULL;
444 error_e error = ERROR_NONE;
447 message = InvokeMethod(STC_MGR_SERVICE,
448 STC_MGR_FIREWALL_PATH,
449 STC_MGR_FIREWALL_INTERFACE,
450 STC_MGR_METHOD_FIREWALL_ADD_CHAIN,
451 g_variant_new("(s)", chain),
454 if (message == NULL) {
455 GLOGD("Failed to invoke dbus method");
459 g_variant_get(message, "(i)", &result);
460 GLOGD("Succeeded to set restriction [%d]", result);
461 g_variant_unref(message);
466 error_e Firewall::GetLock(int *state)
468 GVariant *message = NULL;
469 error_e error = ERROR_NONE;
471 message = InvokeMethod(STC_MGR_SERVICE,
472 STC_MGR_FIREWALL_PATH,
473 STC_MGR_FIREWALL_INTERFACE,
474 STC_MGR_METHOD_FIREWALL_GET_LOCK,
478 if (message == NULL) {
479 GLOGD("Failed to invoke dbus method");
483 g_variant_get(message, "(i)", &state);
484 GLOGD("Succeeded to get lock state[%d]", state);
485 g_variant_unref(message);
490 error_e Firewall::Unlock()
492 GVariant *message = NULL;
493 error_e error = ERROR_NONE;
496 message = InvokeMethod(STC_MGR_SERVICE,
497 STC_MGR_FIREWALL_PATH,
498 STC_MGR_FIREWALL_INTERFACE,
499 STC_MGR_METHOD_FIREWALL_UNLOCK,
503 if (message == NULL) {
504 GLOGD("Failed to invoke dbus method");
508 g_variant_get(message, "(i)", &result);
509 GLOGD("Succeeded to unlock result[%d]", result);
510 g_variant_unref(message);
515 error_e Firewall::Lock()
517 GVariant *message = NULL;
518 error_e error = ERROR_NONE;
521 message = InvokeMethod(STC_MGR_SERVICE,
522 STC_MGR_FIREWALL_PATH,
523 STC_MGR_FIREWALL_INTERFACE,
524 STC_MGR_METHOD_FIREWALL_LOCK,
528 if (message == NULL) {
529 GLOGD("Failed to invoke dbus method");
533 g_variant_get(message, "(i)", &result);
534 GLOGD("Succeeded to unlock result[%d]", result);
535 g_variant_unref(message);