src/database/tables/table-firewall.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * This file implements restrictions entity handler methods.
  19  *
  20  * @file        table-restrictions.c
  21  */
  22
  23 #include "stc-db.h"
  24 #include "db-internal.h"
  25 #include "table-firewall.h"
  26
  27 #define BUF_SIZE_FOR_IP   64
  28
  29 /* DELETE statements */
  30 #define DELETE_FIREWALL_CHAIN "DELETE FROM fw_chains " \
  31         "WHERE chain = ?"
  32
  33 #define DELETE_FIREWALL_RULE "DELETE FROM fw_rules " \
  34         "WHERE key = ?"
  35
  36 #define DELETE_FIREWALL_RULE_PER_CHAIN "DELETE FROM fw_rules " \
  37         "WHERE chain = ?"
  38
  39 /* SELECT statements */
  40 #define SELECT_FIREWALL_LOCK "SELECT state FROM fw_lock " \
  41         "WHERE name = ?"
  42
  43 #define SELECT_FIREWALL_CHAIN "SELECT chain, " \
  44         "target, priority FROM fw_chains"
  45
  46 #define SELECT_FIREWALL_RULE "SELECT key, " \
  47         "chain, direction, s_ip_type, d_ip_type, s_port_type, " \
  48         "d_port_type, protocol, family, s_ip1, s_ip2, d_ip1, d_ip2, " \
  49         "s_port1, s_port2, d_port1, d_port2, ifname, target, " \
  50         "log_level, log_prefix, " \
  51         "nflog_group, nflog_prefix, nflog_range, nflog_threshold, " \
  52         "identifier " \
  53         "FROM fw_rules"
  54
  55 #define SELECT_FIREWALL_RULE_PER_CHAIN "SELECT key, " \
  56         "chain, direction, s_ip_type, d_ip_type, s_port_type, " \
  57         "d_port_type, protocol, family, s_ip1, s_ip2, d_ip1, d_ip2, " \
  58         "s_port1, s_port2, d_port1, d_port2, ifname, target, " \
  59         "log_level, log_prefix, " \
  60         "nflog_group, nflog_prefix, nflog_range, nflog_threshold, " \
  61         "identifier " \
  62         "FROM fw_rules INDEXED BY rules_index " \
  63         "WHERE chain = ?"
  64
  65 /* UPDATE statement */
  66 #define UPDATE_FIREWALL_LOCK "UPDATE fw_lock " \
  67         "SET state = ? WHERE name = ?"
  68
  69 #define UPDATE_FIREWALL_CHAIN "UPDATE fw_chains " \
  70         "SET target = ?, priority = ? " \
  71         "WHERE chain = ?"
  72
  73 #define UPDATE_FIREWALL_RULE "UPDATE fw_rules " \
  74         "SET chain = ?, direction = ?, s_ip_type = ?, d_ip_type = ?, " \
  75         "s_port_type = ?, d_port_type = ?, protocol = ?, family = ?, " \
  76         "s_ip1 = ?, s_ip2 = ?, d_ip1 = ?, d_ip2 = ?, s_port1 = ?, " \
  77         "s_port2 = ?, d_port1 = ?, d_port2 = ?, ifname = ?, target = ?, " \
  78         "log_level = ?, log_prefix = ?, " \
  79         "nflog_group = ?, nflog_prefix = ?, nflog_range = ?, nflog_threshold = ?, " \
  80         "identifier = ?, key = ? " \
  81         "WHERE key = ?"
  82
  83 /* INSERT statement */
  84 #define INSERT_FIREWALL_LOCK "INSERT INTO fw_lock " \
  85         "(name, state) VALUES (?, ?)"
  86
  87 #define INSERT_FIREWALL_CHAIN "INSERT INTO fw_chains " \
  88         "(chain, target, priority) " \
  89         "VALUES (?, ?, ?)"
  90
  91 #define INSERT_FIREWALL_RULE "INSERT INTO fw_rules " \
  92         "(key, chain, direction, s_ip_type, d_ip_type, s_port_type, " \
  93         "d_port_type, protocol, family, s_ip1, s_ip2, d_ip1, d_ip2, " \
  94         "s_port1, s_port2, d_port1, d_port2, ifname, target, " \
  95         "log_level, log_prefix, " \
  96         "nflog_group, nflog_prefix, nflog_range, nflog_threshold, " \
  97         "identifier) " \
  98         "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, " \
  99         "?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
 100
 101 static void __finalize_delete(void);
 102
 103 #define PREPARE_DELETE(stm, query) do { \
 104         rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
 105         if (rc != SQLITE_OK) { \
 106                 stm = NULL; \
 107                 __finalize_delete(); \
 108                 STC_LOGE("Failed to prepare \"%s\" query" \
 109                          , query); \
 110                 return rc; \
 111         } \
 112 } while (0)
 113
 114 static void __finalize_select(void);
 115
 116 #define PREPARE_SELECT(stm, query) do { \
 117         rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
 118         if (rc != SQLITE_OK) { \
 119                 stm = NULL; \
 120                 __finalize_select(); \
 121                 STC_LOGE("Failed to prepare \"%s\" query" \
 122                          , query); \
 123                 return rc; \
 124         } \
 125 } while (0)
 126
 127 static void __finalize_update(void);
 128
 129 #define PREPARE_UPDATE(stm, query) do { \
 130         rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
 131         if (rc != SQLITE_OK) { \
 132                 stm = NULL; \
 133                 __finalize_update(); \
 134                 STC_LOGE("Failed to prepare \"%s\" query" \
 135                          , query); \
 136                 return rc; \
 137         } \
 138 } while (0)
 139
 140 static void __finalize_insert(void);
 141
 142 #define PREPARE_INSERT(stm, query) do { \
 143         rc = sqlite3_prepare_v2(db, query, -1, &stm, NULL); \
 144         if (rc != SQLITE_OK) { \
 145                 stm = NULL; \
 146                 __finalize_insert(); \
 147                 STC_LOGE("Failed to prepare \"%s\" query" \
 148                          , query); \
 149                 return rc; \
 150         } \
 151 } while (0)
 152
 153 #define FINALIZE(stm) do { \
 154         if (stm) { \
 155                 sqlite3_finalize(stm); \
 156                 stm = NULL; \
 157         } \
 158 } while (0)
 159
 160 /* DELETE statements */
 161 static sqlite3_stmt *delete_fw_chain;
 162 static sqlite3_stmt *delete_fw_rule;
 163 static sqlite3_stmt *delete_fw_rule_per_chain;
 164
 165 /* SELECT statements */
 166 static sqlite3_stmt *select_fw_lock;
 167 static sqlite3_stmt *select_fw_chain;
 168 static sqlite3_stmt *select_fw_rule;
 169 static sqlite3_stmt *select_fw_rule_per_chain;
 170
 171 /* UPDATE statements */
 172 static sqlite3_stmt *update_fw_lock;
 173 static sqlite3_stmt *update_fw_chain;
 174 static sqlite3_stmt *update_fw_rule;
 175
 176 /* INSERT statements */
 177 static sqlite3_stmt *insert_fw_lock;
 178 static sqlite3_stmt *insert_fw_chain;
 179 static sqlite3_stmt *insert_fw_rule;
 180
 181 static int __prepare_delete(sqlite3 *db)
 182 {
 183         __STC_LOG_FUNC_ENTER__;
 184         int rc;
 185         static int initialized;
 186
 187         if (initialized) {
 188                 __STC_LOG_FUNC_EXIT__;
 189                 return SQLITE_OK;
 190         }
 191
 192         PREPARE_DELETE(delete_fw_chain, DELETE_FIREWALL_CHAIN);
 193         PREPARE_DELETE(delete_fw_rule, DELETE_FIREWALL_RULE);
 194         PREPARE_DELETE(delete_fw_rule_per_chain, DELETE_FIREWALL_RULE_PER_CHAIN);
 195
 196         initialized = 1;
 197         __STC_LOG_FUNC_EXIT__;
 198         return rc;
 199 }
 200
 201 static void __finalize_delete(void)
 202 {
 203         __STC_LOG_FUNC_ENTER__;
 204
 205         FINALIZE(delete_fw_chain);
 206         FINALIZE(delete_fw_rule);
 207         FINALIZE(delete_fw_rule_per_chain);
 208
 209         __STC_LOG_FUNC_EXIT__;
 210 }
 211
 212 static int __prepare_select(sqlite3 *db)
 213 {
 214         __STC_LOG_FUNC_ENTER__;
 215         int rc;
 216         static int initialized;
 217
 218         if (initialized) {
 219                 __STC_LOG_FUNC_EXIT__;
 220                 return SQLITE_OK;
 221         }
 222
 223         PREPARE_SELECT(select_fw_lock, SELECT_FIREWALL_LOCK);
 224         PREPARE_SELECT(select_fw_chain, SELECT_FIREWALL_CHAIN);
 225         PREPARE_SELECT(select_fw_rule, SELECT_FIREWALL_RULE);
 226         PREPARE_SELECT(select_fw_rule_per_chain, SELECT_FIREWALL_RULE_PER_CHAIN);
 227
 228         initialized = 1;
 229         __STC_LOG_FUNC_EXIT__;
 230         return rc;
 231 }
 232
 233 static void __finalize_select(void)
 234 {
 235         __STC_LOG_FUNC_ENTER__;
 236
 237         FINALIZE(select_fw_lock);
 238         FINALIZE(select_fw_chain);
 239         FINALIZE(select_fw_rule);
 240         FINALIZE(select_fw_rule_per_chain);
 241
 242         __STC_LOG_FUNC_EXIT__;
 243 }
 244
 245 static int __prepare_update(sqlite3 *db)
 246 {
 247         __STC_LOG_FUNC_ENTER__;
 248         int rc;
 249         static int initialized;
 250
 251         if (initialized) {
 252                 __STC_LOG_FUNC_EXIT__;
 253                 return SQLITE_OK;
 254         }
 255
 256         PREPARE_UPDATE(update_fw_lock, UPDATE_FIREWALL_LOCK);
 257         PREPARE_UPDATE(update_fw_chain, UPDATE_FIREWALL_CHAIN);
 258         PREPARE_UPDATE(update_fw_rule, UPDATE_FIREWALL_RULE);
 259
 260         initialized = 1;
 261         __STC_LOG_FUNC_EXIT__;
 262         return rc;
 263 }
 264
 265 static void __finalize_update(void)
 266 {
 267         __STC_LOG_FUNC_ENTER__;
 268
 269         FINALIZE(update_fw_lock);
 270         FINALIZE(update_fw_chain);
 271         FINALIZE(update_fw_rule);
 272
 273         __STC_LOG_FUNC_EXIT__;
 274 }
 275
 276 static int __prepare_insert(sqlite3 *db)
 277 {
 278         __STC_LOG_FUNC_ENTER__;
 279         int rc;
 280         static int initialized;
 281
 282         if (initialized) {
 283                 __STC_LOG_FUNC_EXIT__;
 284                 return SQLITE_OK;
 285         }
 286
 287         PREPARE_INSERT(insert_fw_lock, INSERT_FIREWALL_LOCK);
 288         PREPARE_INSERT(insert_fw_chain, INSERT_FIREWALL_CHAIN);
 289         PREPARE_INSERT(insert_fw_rule, INSERT_FIREWALL_RULE);
 290
 291         initialized = 1;
 292         __STC_LOG_FUNC_EXIT__;
 293         return rc;
 294 }
 295
 296 static void __finalize_insert(void)
 297 {
 298         __STC_LOG_FUNC_ENTER__;
 299
 300         FINALIZE(insert_fw_lock);
 301         FINALIZE(insert_fw_chain);
 302         FINALIZE(insert_fw_rule);
 303
 304         __STC_LOG_FUNC_EXIT__;
 305 }
 306
 307 stc_error_e table_firewall_insert_lock(char *name, int state)
 308 {
 309         stc_error_e error_code = STC_ERROR_NONE;
 310         sqlite3_stmt *stmt = insert_fw_lock;
 311
 312         DB_ACTION(sqlite3_bind_text(stmt, 1, name ? name : "",
 313                                         -1, SQLITE_TRANSIENT));
 314         DB_ACTION(sqlite3_bind_int(stmt, 2, state));
 315
 316         if (sqlite3_step(stmt) != SQLITE_DONE) {
 317                 STC_LOGE("Failed to insert firewall lock state: %s\n",
 318                          sqlite3_errmsg(stc_db_get_database()));
 319
 320                 error_code = STC_ERROR_DB_FAILED;
 321                 goto handle_error;
 322         }
 323
 324         STC_LOGD("Firewall lock state inserted [%d]", state);
 325
 326 handle_error:
 327         sqlite3_reset(stmt);
 328         return error_code;
 329 }
 330
 331 stc_error_e table_firewall_update_lock(char *name, int state)
 332 {
 333         stc_error_e error_code = STC_ERROR_NONE;
 334         sqlite3_stmt *stmt = update_fw_lock;
 335
 336         DB_ACTION(sqlite3_bind_int(stmt, 1, state));
 337         DB_ACTION(sqlite3_bind_text(stmt, 2, name ? name : "",
 338                                         -1, SQLITE_TRANSIENT));
 339
 340         if (sqlite3_step(stmt) != SQLITE_DONE) {
 341                 STC_LOGE("Failed to update firewall lock state: %s\n",
 342                          sqlite3_errmsg(stc_db_get_database()));
 343
 344                 error_code = STC_ERROR_DB_FAILED;
 345                 goto handle_error;
 346         }
 347
 348         STC_LOGD("Firewall lock state updated [%d]", state);
 349
 350 handle_error:
 351         sqlite3_reset(stmt);
 352         return error_code;
 353 }
 354
 355 stc_error_e table_firewall_get_lock(char *name, int *state)
 356 {
 357         int rc;
 358         stc_error_e error_code = STC_ERROR_NONE;
 359         sqlite3_stmt *stmt = select_fw_lock;
 360
 361         if (!name)
 362                 return STC_ERROR_DB_FAILED;
 363
 364         DB_ACTION(sqlite3_bind_text(stmt, 1, name,
 365                                         -1, SQLITE_TRANSIENT));
 366
 367         rc = sqlite3_step(stmt);
 368
 369         switch (rc) {
 370         case SQLITE_DONE:
 371                 break;
 372         case SQLITE_ROW:
 373                 *state = sqlite3_column_int(stmt, 0);
 374                 break;
 375         case SQLITE_ERROR:
 376         default:
 377                 STC_LOGE("Failed to get firewall lock state: %s\n",
 378                          sqlite3_errmsg(stc_db_get_database()));
 379
 380                 error_code = STC_ERROR_DB_FAILED;
 381                 goto handle_error;
 382         }
 383
 384         STC_LOGD("Firewall lock state [%d]", *state);
 385
 386 handle_error:
 387         sqlite3_reset(stmt);
 388         return error_code;
 389 }
 390
 391 stc_error_e table_firewall_insert_chain(firewall_chain_s *info)
 392 {
 393         stc_error_e error_code = STC_ERROR_NONE;
 394         sqlite3_stmt *stmt = insert_fw_chain;
 395
 396         if (!info) {
 397                 error_code = STC_ERROR_INVALID_PARAMETER;
 398                 goto handle_error;
 399         }
 400
 401         DB_ACTION(sqlite3_bind_text(stmt, 1, info->chain ? info->chain : "",
 402                                         -1, SQLITE_TRANSIENT));
 403         DB_ACTION(sqlite3_bind_int(stmt, 2, info->target));
 404         DB_ACTION(sqlite3_bind_int(stmt, 3, info->priority));
 405
 406         if (sqlite3_step(stmt) != SQLITE_DONE) {
 407                 STC_LOGE("Failed to insert firewall chain: %s\n",
 408                          sqlite3_errmsg(stc_db_get_database()));
 409                 error_code = STC_ERROR_DB_FAILED;
 410                 goto handle_error;
 411         }
 412
 413         STC_LOGD("Firewall chain inserted [%s]", info->chain);
 414
 415 handle_error:
 416         sqlite3_reset(stmt);
 417         return error_code;
 418 }
 419
 420 stc_error_e table_firewall_delete_chain(firewall_chain_s *info)
 421 {
 422         stc_error_e error_code = STC_ERROR_NONE;
 423         sqlite3_stmt *stmt = delete_fw_chain;
 424
 425         if (!info) {
 426                 error_code = STC_ERROR_INVALID_PARAMETER;
 427                 goto handle_error;
 428         }
 429
 430         DB_ACTION(sqlite3_bind_text(stmt, 1, info->chain ? info->chain : "",
 431                                     -1, SQLITE_TRANSIENT));
 432
 433         if (sqlite3_step(stmt) != SQLITE_DONE) {
 434                 STC_LOGE("Failed to delete firewall chain %s\n",
 435                          sqlite3_errmsg(stc_db_get_database()));
 436                 error_code = STC_ERROR_DB_FAILED;
 437                 goto handle_error;
 438         }
 439
 440         STC_LOGD("Firewall chain deleted [%s]", info->chain);
 441
 442 handle_error:
 443
 444         sqlite3_reset(stmt);
 445         return error_code;
 446 }
 447
 448 stc_error_e table_firewall_flush_chain(firewall_chain_s *info)
 449 {
 450         stc_error_e error_code = STC_ERROR_NONE;
 451         sqlite3_stmt *stmt = delete_fw_rule_per_chain;
 452
 453         if (!info) {
 454                 error_code = STC_ERROR_INVALID_PARAMETER;
 455                 goto handle_error;
 456         }
 457
 458         DB_ACTION(sqlite3_bind_text(stmt, 1, info->chain ? info->chain : "",
 459                                     -1, SQLITE_TRANSIENT));
 460
 461         if (sqlite3_step(stmt) != SQLITE_DONE) {
 462                 STC_LOGE("Failed to flush firewall chain %s\n",
 463                          sqlite3_errmsg(stc_db_get_database()));
 464                 error_code = STC_ERROR_DB_FAILED;
 465                 goto handle_error;
 466         }
 467
 468         STC_LOGD("Firewall chain flushed [%s]", info->chain);
 469
 470 handle_error:
 471
 472         sqlite3_reset(stmt);
 473         return error_code;
 474 }
 475
 476 stc_error_e table_firewall_update_chain(firewall_chain_s *info)
 477 {
 478         stc_error_e error_code = STC_ERROR_NONE;
 479         sqlite3_stmt *stmt = update_fw_chain;
 480
 481         if (!info) {
 482                 error_code = STC_ERROR_INVALID_PARAMETER;
 483                 goto handle_error;
 484         }
 485
 486         DB_ACTION(sqlite3_bind_int(stmt, 1, info->target));
 487         DB_ACTION(sqlite3_bind_int(stmt, 2, info->priority));
 488         DB_ACTION(sqlite3_bind_text(stmt, 3, info->chain ? info->chain : "",
 489                                         -1, SQLITE_TRANSIENT));
 490
 491         if (sqlite3_step(stmt) != SQLITE_DONE) {
 492                 STC_LOGE("Failed to update firewall chain: %s\n",
 493                          sqlite3_errmsg(stc_db_get_database()));
 494                 error_code = STC_ERROR_DB_FAILED;
 495                 goto handle_error;
 496         }
 497
 498         STC_LOGD("Firewall chain updated [%s]", info->chain);
 499
 500 handle_error:
 501         sqlite3_reset(stmt);
 502         return error_code;
 503 }
 504
 505 stc_error_e table_firewall_foreach_chain(firewall_chain_cb info_cb,
 506                                        void *user_data)
 507 {
 508         firewall_chain_s info;
 509         int rc;
 510         stc_error_e error_code = STC_ERROR_NONE;
 511         sqlite3_stmt *stmt = select_fw_chain;
 512
 513         do {
 514                 rc = sqlite3_step(stmt);
 515
 516                 memset(&info, 0, sizeof(info));
 517
 518                 switch (rc) {
 519                 case SQLITE_DONE:
 520                         break;
 521                 case SQLITE_ROW:
 522                         info.chain = (char *)sqlite3_column_text(stmt, 0);
 523                         info.target = sqlite3_column_int(stmt, 1);
 524                         info.priority = sqlite3_column_int(stmt, 2);
 525
 526                         if (info_cb(&info, user_data) == STC_CANCEL)
 527                                 rc = SQLITE_DONE;
 528                         break;
 529                 case SQLITE_ERROR:
 530                 default:
 531                         STC_LOGE("Failed to enumerate firewall chains: %s\n",
 532                                  sqlite3_errmsg(stc_db_get_database()));
 533
 534                         error_code = STC_ERROR_DB_FAILED;
 535                 }
 536         } while (rc == SQLITE_ROW);
 537
 538         sqlite3_reset(stmt);
 539         return error_code;
 540 }
 541
 542 stc_error_e table_firewall_insert_rule(firewall_rule_s *info)
 543 {
 544         stc_error_e error_code = STC_ERROR_NONE;
 545         char buf[BUF_SIZE_FOR_IP];
 546         sqlite3_stmt *stmt = insert_fw_rule;
 547
 548         if (!info) {
 549                 error_code = STC_ERROR_INVALID_PARAMETER;
 550                 goto handle_error;
 551         }
 552
 553         DB_ACTION(sqlite3_bind_int64(stmt, 1, info->key));
 554         DB_ACTION(sqlite3_bind_text(stmt, 2, info->chain ? info->chain : "",
 555                                         -1, SQLITE_TRANSIENT));
 556         DB_ACTION(sqlite3_bind_int(stmt, 3, info->direction));
 557         DB_ACTION(sqlite3_bind_int(stmt, 4, info->s_ip_type));
 558         DB_ACTION(sqlite3_bind_int(stmt, 5, info->d_ip_type));
 559         DB_ACTION(sqlite3_bind_int(stmt, 6, info->s_port_type));
 560         DB_ACTION(sqlite3_bind_int(stmt, 7, info->d_port_type));
 561         DB_ACTION(sqlite3_bind_int(stmt, 8, info->protocol));
 562         DB_ACTION(sqlite3_bind_int(stmt, 9, info->family));
 563         if (info->family == STC_FW_FAMILY_V4) {
 564                 memset(buf, 0, sizeof(buf));
 565                 snprintf(buf, sizeof(buf), "%08x", info->s_ip1.Ipv4.s_addr);
 566                 DB_ACTION(sqlite3_bind_text(stmt, 10, buf, -1, SQLITE_TRANSIENT));
 567
 568                 memset(buf, 0, sizeof(buf));
 569                 snprintf(buf, sizeof(buf), "%08x", info->s_ip2.Ipv4.s_addr);
 570                 DB_ACTION(sqlite3_bind_text(stmt, 11, buf, -1, SQLITE_TRANSIENT));
 571
 572                 memset(buf, 0, sizeof(buf));
 573                 snprintf(buf, sizeof(buf), "%08x", info->d_ip1.Ipv4.s_addr);
 574                 DB_ACTION(sqlite3_bind_text(stmt, 12, buf, -1, SQLITE_TRANSIENT));
 575
 576                 memset(buf, 0, sizeof(buf));
 577                 snprintf(buf, sizeof(buf), "%08x", info->d_ip2.Ipv4.s_addr);
 578                 DB_ACTION(sqlite3_bind_text(stmt, 13, buf, -1, SQLITE_TRANSIENT));
 579         } else if (info->family == STC_FW_FAMILY_V6) {
 580                 memset(buf, 0, sizeof(buf));
 581                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 582                         info->s_ip1.Ipv6.s6_addr32[0], info->s_ip1.Ipv6.s6_addr32[1],
 583                         info->s_ip1.Ipv6.s6_addr32[2], info->s_ip1.Ipv6.s6_addr32[3]);
 584                 DB_ACTION(sqlite3_bind_text(stmt, 10, buf, -1, SQLITE_TRANSIENT));
 585
 586                 memset(buf, 0, sizeof(buf));
 587                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 588                         info->s_ip2.Ipv6.s6_addr32[0], info->s_ip2.Ipv6.s6_addr32[1],
 589                         info->s_ip2.Ipv6.s6_addr32[2], info->s_ip2.Ipv6.s6_addr32[3]);
 590                 DB_ACTION(sqlite3_bind_text(stmt, 11, buf, -1, SQLITE_TRANSIENT));
 591
 592                 memset(buf, 0, sizeof(buf));
 593                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 594                         info->d_ip1.Ipv6.s6_addr32[0], info->d_ip1.Ipv6.s6_addr32[1],
 595                         info->d_ip1.Ipv6.s6_addr32[2], info->d_ip1.Ipv6.s6_addr32[3]);
 596                 DB_ACTION(sqlite3_bind_text(stmt, 12, buf, -1, SQLITE_TRANSIENT));
 597
 598                 memset(buf, 0, sizeof(buf));
 599                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 600                         info->d_ip2.Ipv6.s6_addr32[0], info->d_ip2.Ipv6.s6_addr32[1],
 601                         info->d_ip2.Ipv6.s6_addr32[2], info->d_ip2.Ipv6.s6_addr32[3]);
 602                 DB_ACTION(sqlite3_bind_text(stmt, 13, buf, -1, SQLITE_TRANSIENT));
 603         } else {
 604                 DB_ACTION(sqlite3_bind_text(stmt, 10, "", -1, SQLITE_TRANSIENT));
 605                 DB_ACTION(sqlite3_bind_text(stmt, 11, "", -1, SQLITE_TRANSIENT));
 606                 DB_ACTION(sqlite3_bind_text(stmt, 12, "", -1, SQLITE_TRANSIENT));
 607                 DB_ACTION(sqlite3_bind_text(stmt, 13, "", -1, SQLITE_TRANSIENT));
 608         }
 609         DB_ACTION(sqlite3_bind_int(stmt, 14, info->s_port1));
 610         DB_ACTION(sqlite3_bind_int(stmt, 15, info->s_port2));
 611         DB_ACTION(sqlite3_bind_int(stmt, 16, info->d_port1));
 612         DB_ACTION(sqlite3_bind_int(stmt, 17, info->d_port2));
 613         DB_ACTION(sqlite3_bind_text(stmt, 18, info->ifname ? info->ifname : "",
 614                                         -1, SQLITE_TRANSIENT));
 615         DB_ACTION(sqlite3_bind_int(stmt, 19, info->target));
 616         DB_ACTION(sqlite3_bind_int(stmt, 20, info->log_level));
 617         DB_ACTION(sqlite3_bind_text(stmt, 21, info->log_prefix ? info->log_prefix : "",
 618                                         -1, SQLITE_TRANSIENT));
 619         DB_ACTION(sqlite3_bind_int(stmt, 22, info->nflog_group));
 620         DB_ACTION(sqlite3_bind_text(stmt, 23, info->nflog_prefix ? info->nflog_prefix : "",
 621                                         -1, SQLITE_TRANSIENT));
 622         DB_ACTION(sqlite3_bind_int(stmt, 24, info->nflog_range));
 623         DB_ACTION(sqlite3_bind_int(stmt, 25, info->nflog_threshold));
 624         DB_ACTION(sqlite3_bind_text(stmt, 26, info->identifier ? info->identifier : "",
 625                                         -1, SQLITE_TRANSIENT));
 626
 627         if (sqlite3_step(stmt) != SQLITE_DONE) {
 628                 STC_LOGE("Failed to insert firewall rule: %s\n",
 629                          sqlite3_errmsg(stc_db_get_database()));
 630                 error_code = STC_ERROR_DB_FAILED;
 631                 goto handle_error;
 632         }
 633
 634         STC_LOGD("Firewall rule inserted [%s]", info->chain);
 635
 636 handle_error:
 637         sqlite3_reset(stmt);
 638         return error_code;
 639 }
 640
 641 stc_error_e table_firewall_delete_rule(firewall_rule_s *info)
 642 {
 643         stc_error_e error_code = STC_ERROR_NONE;
 644         sqlite3_stmt *stmt = delete_fw_rule;
 645
 646         if (!info) {
 647                 error_code = STC_ERROR_INVALID_PARAMETER;
 648                 goto handle_error;
 649         }
 650
 651         DB_ACTION(sqlite3_bind_int64(stmt, 1, info->key));
 652
 653         if (sqlite3_step(stmt) != SQLITE_DONE) {
 654                 STC_LOGE("Failed to delete firewall rule %s\n",
 655                          sqlite3_errmsg(stc_db_get_database()));
 656                 error_code = STC_ERROR_DB_FAILED;
 657                 goto handle_error;
 658         }
 659
 660         STC_LOGD("Firewall rule deleted [%s]", info->chain);
 661
 662 handle_error:
 663
 664         sqlite3_reset(stmt);
 665         return error_code;
 666 }
 667
 668 stc_error_e table_firewall_update_rule(firewall_rule_s *info, guint key)
 669 {
 670         stc_error_e error_code = STC_ERROR_NONE;
 671         char buf[BUF_SIZE_FOR_IP];
 672         sqlite3_stmt *stmt = update_fw_rule;
 673
 674         if (!info) {
 675                 error_code = STC_ERROR_INVALID_PARAMETER;
 676                 goto handle_error;
 677         }
 678
 679         DB_ACTION(sqlite3_bind_text(stmt, 1, info->chain ? info->chain : "",
 680                                         -1, SQLITE_TRANSIENT));
 681         DB_ACTION(sqlite3_bind_int(stmt, 2, info->direction));
 682         DB_ACTION(sqlite3_bind_int(stmt, 3, info->s_ip_type));
 683         DB_ACTION(sqlite3_bind_int(stmt, 4, info->d_ip_type));
 684         DB_ACTION(sqlite3_bind_int(stmt, 5, info->s_port_type));
 685         DB_ACTION(sqlite3_bind_int(stmt, 6, info->d_port_type));
 686         DB_ACTION(sqlite3_bind_int(stmt, 7, info->protocol));
 687         DB_ACTION(sqlite3_bind_int(stmt, 8, info->family));
 688         if (info->family == STC_FW_FAMILY_V4) {
 689                 memset(buf, 0, sizeof(buf));
 690                 snprintf(buf, sizeof(buf), "%08x", info->s_ip1.Ipv4.s_addr);
 691                 DB_ACTION(sqlite3_bind_text(stmt, 9, buf, -1, SQLITE_TRANSIENT));
 692
 693                 memset(buf, 0, sizeof(buf));
 694                 snprintf(buf, sizeof(buf), "%08x", info->s_ip2.Ipv4.s_addr);
 695                 DB_ACTION(sqlite3_bind_text(stmt, 10, buf, -1, SQLITE_TRANSIENT));
 696
 697                 memset(buf, 0, sizeof(buf));
 698                 snprintf(buf, sizeof(buf), "%08x", info->d_ip1.Ipv4.s_addr);
 699                 DB_ACTION(sqlite3_bind_text(stmt, 11, buf, -1, SQLITE_TRANSIENT));
 700
 701                 memset(buf, 0, sizeof(buf));
 702                 snprintf(buf, sizeof(buf), "%08x", info->d_ip2.Ipv4.s_addr);
 703                 DB_ACTION(sqlite3_bind_text(stmt, 12, buf, -1, SQLITE_TRANSIENT));
 704         } else if (info->family == STC_FW_FAMILY_V6) {
 705                 memset(buf, 0, sizeof(buf));
 706                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 707                         info->s_ip1.Ipv6.s6_addr32[0], info->s_ip1.Ipv6.s6_addr32[1],
 708                         info->s_ip1.Ipv6.s6_addr32[2], info->s_ip1.Ipv6.s6_addr32[3]);
 709                 DB_ACTION(sqlite3_bind_text(stmt, 9, buf, -1, SQLITE_TRANSIENT));
 710
 711                 memset(buf, 0, sizeof(buf));
 712                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 713                         info->s_ip2.Ipv6.s6_addr32[0], info->s_ip2.Ipv6.s6_addr32[1],
 714                         info->s_ip2.Ipv6.s6_addr32[2], info->s_ip2.Ipv6.s6_addr32[3]);
 715                 DB_ACTION(sqlite3_bind_text(stmt, 10, buf, -1, SQLITE_TRANSIENT));
 716
 717                 memset(buf, 0, sizeof(buf));
 718                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 719                         info->d_ip1.Ipv6.s6_addr32[0], info->d_ip1.Ipv6.s6_addr32[1],
 720                         info->d_ip1.Ipv6.s6_addr32[2], info->d_ip1.Ipv6.s6_addr32[3]);
 721                 DB_ACTION(sqlite3_bind_text(stmt, 11, buf, -1, SQLITE_TRANSIENT));
 722
 723                 memset(buf, 0, sizeof(buf));
 724                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 725                         info->d_ip2.Ipv6.s6_addr32[0], info->d_ip2.Ipv6.s6_addr32[1],
 726                         info->d_ip2.Ipv6.s6_addr32[2], info->d_ip2.Ipv6.s6_addr32[3]);
 727                 DB_ACTION(sqlite3_bind_text(stmt, 12, buf, -1, SQLITE_TRANSIENT));
 728         } else {
 729                 DB_ACTION(sqlite3_bind_text(stmt, 9, "", -1, SQLITE_TRANSIENT));
 730                 DB_ACTION(sqlite3_bind_text(stmt, 10, "", -1, SQLITE_TRANSIENT));
 731                 DB_ACTION(sqlite3_bind_text(stmt, 11, "", -1, SQLITE_TRANSIENT));
 732                 DB_ACTION(sqlite3_bind_text(stmt, 12, "", -1, SQLITE_TRANSIENT));
 733         }
 734         DB_ACTION(sqlite3_bind_int(stmt, 13, info->s_port1));
 735         DB_ACTION(sqlite3_bind_int(stmt, 14, info->s_port2));
 736         DB_ACTION(sqlite3_bind_int(stmt, 15, info->d_port1));
 737         DB_ACTION(sqlite3_bind_int(stmt, 16, info->d_port2));
 738         DB_ACTION(sqlite3_bind_text(stmt, 17, info->ifname ? info->ifname : "",
 739                                         -1, SQLITE_TRANSIENT));
 740         DB_ACTION(sqlite3_bind_int(stmt, 18, info->target));
 741         DB_ACTION(sqlite3_bind_int(stmt, 19, info->log_level));
 742         DB_ACTION(sqlite3_bind_text(stmt, 20, info->log_prefix ? info->log_prefix : "",
 743                                         -1, SQLITE_TRANSIENT));
 744         DB_ACTION(sqlite3_bind_int(stmt, 21, info->nflog_group));
 745         DB_ACTION(sqlite3_bind_text(stmt, 22, info->nflog_prefix ? info->nflog_prefix : "",
 746                                         -1, SQLITE_TRANSIENT));
 747         DB_ACTION(sqlite3_bind_int(stmt, 23, info->nflog_range));
 748         DB_ACTION(sqlite3_bind_int(stmt, 24, info->nflog_threshold));
 749         DB_ACTION(sqlite3_bind_text(stmt, 25, info->identifier ? info->identifier : "",
 750                                         -1, SQLITE_TRANSIENT));
 751         DB_ACTION(sqlite3_bind_int64(stmt, 26, info->key));
 752         DB_ACTION(sqlite3_bind_int64(stmt, 27, key));
 753
 754         if (sqlite3_step(stmt) != SQLITE_DONE) {
 755                 STC_LOGE("Failed to update firewall rule %s\n",
 756                          sqlite3_errmsg(stc_db_get_database()));
 757                 error_code = STC_ERROR_DB_FAILED;
 758                 goto handle_error;
 759         }
 760
 761         STC_LOGD("Firewall rule updated [%s]", info->chain);
 762
 763 handle_error:
 764
 765         sqlite3_reset(stmt);
 766         return error_code;
 767 }
 768
 769 stc_error_e table_firewall_foreach_rule(firewall_rule_cb info_cb,
 770                                        void *user_data)
 771 {
 772         firewall_rule_s info;
 773         int rc;
 774         stc_error_e error_code = STC_ERROR_NONE;
 775         sqlite3_stmt *stmt = select_fw_rule;
 776
 777         do {
 778                 rc = sqlite3_step(stmt);
 779
 780                 memset(&info, 0, sizeof(info));
 781
 782                 switch (rc) {
 783                 case SQLITE_DONE:
 784                         break;
 785                 case SQLITE_ROW:
 786                         info.key = sqlite3_column_int64(stmt, 0);
 787                         info.chain = (char *)sqlite3_column_text(stmt, 1);
 788                         info.direction = sqlite3_column_int(stmt, 2);
 789                         info.s_ip_type = sqlite3_column_int(stmt, 3);
 790                         info.d_ip_type = sqlite3_column_int(stmt, 4);
 791                         info.s_port_type = sqlite3_column_int(stmt, 5);
 792                         info.d_port_type = sqlite3_column_int(stmt, 6);
 793                         info.protocol = sqlite3_column_int(stmt, 7);
 794                         info.family = sqlite3_column_int(stmt, 8);
 795                         if (info.family == STC_FW_FAMILY_V4) {
 796                                 sscanf((char *)sqlite3_column_text(stmt, 9), "%08x",
 797                                                                 &(info.s_ip1.Ipv4.s_addr));
 798                                 sscanf((char *)sqlite3_column_text(stmt, 10), "%08x",
 799                                                                 &(info.s_ip2.Ipv4.s_addr));
 800                                 sscanf((char *)sqlite3_column_text(stmt, 11), "%08x",
 801                                                                 &(info.d_ip1.Ipv4.s_addr));
 802                                 sscanf((char *)sqlite3_column_text(stmt, 12), "%08x",
 803                                                                 &(info.d_ip2.Ipv4.s_addr));
 804                         } else if (info.family == STC_FW_FAMILY_V6) {
 805                                 sscanf((char *)sqlite3_column_text(stmt, 9), "%08x:%08x:%08x:%08x",
 806                                         &(info.s_ip1.Ipv6.s6_addr32[0]), &(info.s_ip1.Ipv6.s6_addr32[1]),
 807                                         &(info.s_ip1.Ipv6.s6_addr32[2]), &(info.s_ip1.Ipv6.s6_addr32[3]));
 808                                 sscanf((char *)sqlite3_column_text(stmt, 10), "%08x:%08x:%08x:%08x",
 809                                         &(info.s_ip2.Ipv6.s6_addr32[0]), &(info.s_ip2.Ipv6.s6_addr32[1]),
 810                                         &(info.s_ip2.Ipv6.s6_addr32[2]), &(info.s_ip2.Ipv6.s6_addr32[3]));
 811                                 sscanf((char *)sqlite3_column_text(stmt, 11), "%08x:%08x:%08x:%08x",
 812                                         &(info.d_ip1.Ipv6.s6_addr32[0]), &(info.d_ip1.Ipv6.s6_addr32[1]),
 813                                         &(info.d_ip1.Ipv6.s6_addr32[2]), &(info.d_ip1.Ipv6.s6_addr32[3]));
 814                                 sscanf((char *)sqlite3_column_text(stmt, 12), "%08x:%08x:%08x:%08x",
 815                                         &(info.d_ip2.Ipv6.s6_addr32[0]), &(info.d_ip2.Ipv6.s6_addr32[1]),
 816                                         &(info.d_ip2.Ipv6.s6_addr32[2]), &(info.d_ip2.Ipv6.s6_addr32[3]));
 817                         }
 818                         info.s_port1 = sqlite3_column_int(stmt, 13);
 819                         info.s_port2 = sqlite3_column_int(stmt, 14);
 820                         info.d_port1 = sqlite3_column_int(stmt, 15);
 821                         info.d_port2 = sqlite3_column_int(stmt, 16);
 822                         info.ifname = (char *)sqlite3_column_text(stmt, 17);
 823                         info.target = sqlite3_column_int(stmt, 18);
 824                         info.log_level = sqlite3_column_int(stmt, 19);
 825                         info.log_prefix = (char *)sqlite3_column_text(stmt, 20);
 826                         info.nflog_group = sqlite3_column_int(stmt, 21);
 827                         info.nflog_prefix = (char *)sqlite3_column_text(stmt, 22);
 828                         info.nflog_range = sqlite3_column_int(stmt, 23);
 829                         info.nflog_threshold = sqlite3_column_int(stmt, 24);
 830                         info.identifier = (char *)sqlite3_column_text(stmt, 25);
 831
 832                         if (info_cb(&info, user_data) == STC_CANCEL)
 833                                 rc = SQLITE_DONE;
 834                         break;
 835                 case SQLITE_ERROR:
 836                 default:
 837                         STC_LOGE("Failed to enumerate firewall rules: %s\n",
 838                                  sqlite3_errmsg(stc_db_get_database()));
 839
 840                         error_code = STC_ERROR_DB_FAILED;
 841                 }
 842         } while (rc == SQLITE_ROW);
 843
 844         sqlite3_reset(stmt);
 845         return error_code;
 846 }
 847
 848 stc_error_e table_firewall_prepare(sqlite3 *db)
 849 {
 850         __STC_LOG_FUNC_ENTER__;
 851
 852         stc_error_e error_code = STC_ERROR_NONE;
 853
 854         if (db == NULL) {
 855                 __STC_LOG_FUNC_EXIT__;
 856                 return STC_ERROR_FAIL;
 857         }
 858
 859         DB_ACTION(__prepare_delete(db));
 860         DB_ACTION(__prepare_select(db));
 861         DB_ACTION(__prepare_update(db));
 862         DB_ACTION(__prepare_insert(db));
 863
 864 handle_error:
 865
 866         __STC_LOG_FUNC_EXIT__;
 867         return error_code;
 868 }
 869
 870 void table_firewall_finalize(void)
 871 {
 872         __STC_LOG_FUNC_ENTER__;
 873         __finalize_delete();
 874         __finalize_select();
 875         __finalize_update();
 876         __finalize_insert();
 877         __STC_LOG_FUNC_EXIT__;
 878 }