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 API 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 API 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 API 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                 STC_LOGD("There is no lock state [%s]", name);
 372                 error_code = STC_ERROR_NO_DATA;
 373                 goto handle_error;
 374         case SQLITE_ROW:
 375                 *state = sqlite3_column_int(stmt, 0);
 376                 break;
 377         case SQLITE_ERROR:
 378         default:
 379                 STC_LOGE("Failed to get firewall lock state: %s\n",
 380                          sqlite3_errmsg(stc_db_get_database()));
 381
 382                 error_code = STC_ERROR_DB_FAILED;
 383                 goto handle_error;
 384         }
 385
 386         STC_LOGD("Firewall lock state [%d]", *state);
 387
 388 handle_error:
 389         sqlite3_reset(stmt);
 390         return error_code;
 391 }
 392
 393 API stc_error_e table_firewall_insert_chain(firewall_chain_s *info)
 394 {
 395         stc_error_e error_code = STC_ERROR_NONE;
 396         sqlite3_stmt *stmt = insert_fw_chain;
 397
 398         if (!info) {
 399                 error_code = STC_ERROR_INVALID_PARAMETER;
 400                 goto handle_error;
 401         }
 402
 403         DB_ACTION(sqlite3_bind_text(stmt, 1, info->chain ? info->chain : "",
 404                                         -1, SQLITE_TRANSIENT));
 405         DB_ACTION(sqlite3_bind_int(stmt, 2, info->target));
 406         DB_ACTION(sqlite3_bind_int(stmt, 3, info->priority));
 407
 408         if (sqlite3_step(stmt) != SQLITE_DONE) {
 409                 STC_LOGE("Failed to insert firewall chain: %s\n",
 410                          sqlite3_errmsg(stc_db_get_database()));
 411                 error_code = STC_ERROR_DB_FAILED;
 412                 goto handle_error;
 413         }
 414
 415         STC_LOGD("Firewall chain inserted [%s]", info->chain);
 416
 417 handle_error:
 418         sqlite3_reset(stmt);
 419         return error_code;
 420 }
 421
 422 API stc_error_e table_firewall_delete_chain(firewall_chain_s *info)
 423 {
 424         stc_error_e error_code = STC_ERROR_NONE;
 425         sqlite3_stmt *stmt = delete_fw_chain;
 426
 427         if (!info) {
 428                 error_code = STC_ERROR_INVALID_PARAMETER;
 429                 goto handle_error;
 430         }
 431
 432         DB_ACTION(sqlite3_bind_text(stmt, 1, info->chain ? info->chain : "",
 433                                     -1, SQLITE_TRANSIENT));
 434
 435         if (sqlite3_step(stmt) != SQLITE_DONE) {
 436                 STC_LOGE("Failed to delete firewall chain %s\n",
 437                          sqlite3_errmsg(stc_db_get_database()));
 438                 error_code = STC_ERROR_DB_FAILED;
 439                 goto handle_error;
 440         }
 441
 442         STC_LOGD("Firewall chain deleted [%s]", info->chain);
 443
 444 handle_error:
 445
 446         sqlite3_reset(stmt);
 447         return error_code;
 448 }
 449
 450 API stc_error_e table_firewall_flush_chain(firewall_chain_s *info)
 451 {
 452         stc_error_e error_code = STC_ERROR_NONE;
 453         sqlite3_stmt *stmt = delete_fw_rule_per_chain;
 454
 455         if (!info) {
 456                 error_code = STC_ERROR_INVALID_PARAMETER;
 457                 goto handle_error;
 458         }
 459
 460         DB_ACTION(sqlite3_bind_text(stmt, 1, info->chain ? info->chain : "",
 461                                     -1, SQLITE_TRANSIENT));
 462
 463         if (sqlite3_step(stmt) != SQLITE_DONE) {
 464                 STC_LOGE("Failed to flush firewall chain %s\n",
 465                          sqlite3_errmsg(stc_db_get_database()));
 466                 error_code = STC_ERROR_DB_FAILED;
 467                 goto handle_error;
 468         }
 469
 470         STC_LOGD("Firewall chain flushed [%s]", info->chain);
 471
 472 handle_error:
 473
 474         sqlite3_reset(stmt);
 475         return error_code;
 476 }
 477
 478 API stc_error_e table_firewall_update_chain(firewall_chain_s *info)
 479 {
 480         stc_error_e error_code = STC_ERROR_NONE;
 481         sqlite3_stmt *stmt = update_fw_chain;
 482
 483         if (!info) {
 484                 error_code = STC_ERROR_INVALID_PARAMETER;
 485                 goto handle_error;
 486         }
 487
 488         DB_ACTION(sqlite3_bind_int(stmt, 1, info->target));
 489         DB_ACTION(sqlite3_bind_int(stmt, 2, info->priority));
 490         DB_ACTION(sqlite3_bind_text(stmt, 3, info->chain ? info->chain : "",
 491                                         -1, SQLITE_TRANSIENT));
 492
 493         if (sqlite3_step(stmt) != SQLITE_DONE) {
 494                 STC_LOGE("Failed to update firewall chain: %s\n",
 495                          sqlite3_errmsg(stc_db_get_database()));
 496                 error_code = STC_ERROR_DB_FAILED;
 497                 goto handle_error;
 498         }
 499
 500         STC_LOGD("Firewall chain updated [%s]", info->chain);
 501
 502 handle_error:
 503         sqlite3_reset(stmt);
 504         return error_code;
 505 }
 506
 507 API stc_error_e table_firewall_foreach_chain(firewall_chain_cb info_cb,
 508                                        void *user_data)
 509 {
 510         firewall_chain_s info;
 511         int rc;
 512         stc_error_e error_code = STC_ERROR_NONE;
 513         sqlite3_stmt *stmt = select_fw_chain;
 514
 515         do {
 516                 rc = sqlite3_step(stmt);
 517
 518                 memset(&info, 0, sizeof(info));
 519
 520                 switch (rc) {
 521                 case SQLITE_DONE:
 522                         break;
 523                 case SQLITE_ROW:
 524                         info.chain = (char *)sqlite3_column_text(stmt, 0);
 525                         info.target = sqlite3_column_int(stmt, 1);
 526                         info.priority = sqlite3_column_int(stmt, 2);
 527
 528                         if (info_cb(&info, user_data) == STC_CANCEL)
 529                                 rc = SQLITE_DONE;
 530                         break;
 531                 case SQLITE_ERROR:
 532                 default:
 533                         STC_LOGE("Failed to enumerate firewall chains: %s\n",
 534                                  sqlite3_errmsg(stc_db_get_database()));
 535
 536                         error_code = STC_ERROR_DB_FAILED;
 537                 }
 538         } while (rc == SQLITE_ROW);
 539
 540         sqlite3_reset(stmt);
 541         return error_code;
 542 }
 543
 544 API stc_error_e table_firewall_insert_rule(firewall_rule_s *info)
 545 {
 546         stc_error_e error_code = STC_ERROR_NONE;
 547         char buf[BUF_SIZE_FOR_IP];
 548         sqlite3_stmt *stmt = insert_fw_rule;
 549
 550         if (!info) {
 551                 error_code = STC_ERROR_INVALID_PARAMETER;
 552                 goto handle_error;
 553         }
 554
 555         DB_ACTION(sqlite3_bind_int64(stmt, 1, info->key));
 556         DB_ACTION(sqlite3_bind_text(stmt, 2, info->chain ? info->chain : "",
 557                                         -1, SQLITE_TRANSIENT));
 558         DB_ACTION(sqlite3_bind_int(stmt, 3, info->direction));
 559         DB_ACTION(sqlite3_bind_int(stmt, 4, info->s_ip_type));
 560         DB_ACTION(sqlite3_bind_int(stmt, 5, info->d_ip_type));
 561         DB_ACTION(sqlite3_bind_int(stmt, 6, info->s_port_type));
 562         DB_ACTION(sqlite3_bind_int(stmt, 7, info->d_port_type));
 563         DB_ACTION(sqlite3_bind_int(stmt, 8, info->protocol));
 564         DB_ACTION(sqlite3_bind_int(stmt, 9, info->family));
 565         if (info->family == STC_FW_FAMILY_V4) {
 566                 memset(buf, 0, sizeof(buf));
 567                 snprintf(buf, sizeof(buf), "%08x", info->s_ip1.Ipv4.s_addr);
 568                 DB_ACTION(sqlite3_bind_text(stmt, 10, buf, -1, SQLITE_TRANSIENT));
 569
 570                 memset(buf, 0, sizeof(buf));
 571                 snprintf(buf, sizeof(buf), "%08x", info->s_ip2.Ipv4.s_addr);
 572                 DB_ACTION(sqlite3_bind_text(stmt, 11, buf, -1, SQLITE_TRANSIENT));
 573
 574                 memset(buf, 0, sizeof(buf));
 575                 snprintf(buf, sizeof(buf), "%08x", info->d_ip1.Ipv4.s_addr);
 576                 DB_ACTION(sqlite3_bind_text(stmt, 12, buf, -1, SQLITE_TRANSIENT));
 577
 578                 memset(buf, 0, sizeof(buf));
 579                 snprintf(buf, sizeof(buf), "%08x", info->d_ip2.Ipv4.s_addr);
 580                 DB_ACTION(sqlite3_bind_text(stmt, 13, buf, -1, SQLITE_TRANSIENT));
 581         } else if (info->family == STC_FW_FAMILY_V6) {
 582                 memset(buf, 0, sizeof(buf));
 583                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 584                         info->s_ip1.Ipv6.s6_addr32[0], info->s_ip1.Ipv6.s6_addr32[1],
 585                         info->s_ip1.Ipv6.s6_addr32[2], info->s_ip1.Ipv6.s6_addr32[3]);
 586                 DB_ACTION(sqlite3_bind_text(stmt, 10, buf, -1, SQLITE_TRANSIENT));
 587
 588                 memset(buf, 0, sizeof(buf));
 589                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 590                         info->s_ip2.Ipv6.s6_addr32[0], info->s_ip2.Ipv6.s6_addr32[1],
 591                         info->s_ip2.Ipv6.s6_addr32[2], info->s_ip2.Ipv6.s6_addr32[3]);
 592                 DB_ACTION(sqlite3_bind_text(stmt, 11, buf, -1, SQLITE_TRANSIENT));
 593
 594                 memset(buf, 0, sizeof(buf));
 595                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 596                         info->d_ip1.Ipv6.s6_addr32[0], info->d_ip1.Ipv6.s6_addr32[1],
 597                         info->d_ip1.Ipv6.s6_addr32[2], info->d_ip1.Ipv6.s6_addr32[3]);
 598                 DB_ACTION(sqlite3_bind_text(stmt, 12, buf, -1, SQLITE_TRANSIENT));
 599
 600                 memset(buf, 0, sizeof(buf));
 601                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 602                         info->d_ip2.Ipv6.s6_addr32[0], info->d_ip2.Ipv6.s6_addr32[1],
 603                         info->d_ip2.Ipv6.s6_addr32[2], info->d_ip2.Ipv6.s6_addr32[3]);
 604                 DB_ACTION(sqlite3_bind_text(stmt, 13, buf, -1, SQLITE_TRANSIENT));
 605         } else {
 606                 DB_ACTION(sqlite3_bind_text(stmt, 10, "", -1, SQLITE_TRANSIENT));
 607                 DB_ACTION(sqlite3_bind_text(stmt, 11, "", -1, SQLITE_TRANSIENT));
 608                 DB_ACTION(sqlite3_bind_text(stmt, 12, "", -1, SQLITE_TRANSIENT));
 609                 DB_ACTION(sqlite3_bind_text(stmt, 13, "", -1, SQLITE_TRANSIENT));
 610         }
 611         DB_ACTION(sqlite3_bind_int(stmt, 14, info->s_port1));
 612         DB_ACTION(sqlite3_bind_int(stmt, 15, info->s_port2));
 613         DB_ACTION(sqlite3_bind_int(stmt, 16, info->d_port1));
 614         DB_ACTION(sqlite3_bind_int(stmt, 17, info->d_port2));
 615         DB_ACTION(sqlite3_bind_text(stmt, 18, info->ifname ? info->ifname : "",
 616                                         -1, SQLITE_TRANSIENT));
 617         DB_ACTION(sqlite3_bind_int(stmt, 19, info->target));
 618         DB_ACTION(sqlite3_bind_int(stmt, 20, info->log_level));
 619         DB_ACTION(sqlite3_bind_text(stmt, 21, info->log_prefix ? info->log_prefix : "",
 620                                         -1, SQLITE_TRANSIENT));
 621         DB_ACTION(sqlite3_bind_int(stmt, 22, info->nflog_group));
 622         DB_ACTION(sqlite3_bind_text(stmt, 23, info->nflog_prefix ? info->nflog_prefix : "",
 623                                         -1, SQLITE_TRANSIENT));
 624         DB_ACTION(sqlite3_bind_int(stmt, 24, info->nflog_range));
 625         DB_ACTION(sqlite3_bind_int(stmt, 25, info->nflog_threshold));
 626         DB_ACTION(sqlite3_bind_text(stmt, 26, info->identifier ? info->identifier : "",
 627                                         -1, SQLITE_TRANSIENT));
 628
 629         if (sqlite3_step(stmt) != SQLITE_DONE) {
 630                 STC_LOGE("Failed to insert firewall rule: %s\n",
 631                          sqlite3_errmsg(stc_db_get_database()));
 632                 error_code = STC_ERROR_DB_FAILED;
 633                 goto handle_error;
 634         }
 635
 636         STC_LOGD("Firewall rule inserted [%s]", info->chain);
 637
 638 handle_error:
 639         sqlite3_reset(stmt);
 640         return error_code;
 641 }
 642
 643 API stc_error_e table_firewall_delete_rule(firewall_rule_s *info)
 644 {
 645         stc_error_e error_code = STC_ERROR_NONE;
 646         sqlite3_stmt *stmt = delete_fw_rule;
 647
 648         if (!info) {
 649                 error_code = STC_ERROR_INVALID_PARAMETER;
 650                 goto handle_error;
 651         }
 652
 653         DB_ACTION(sqlite3_bind_int64(stmt, 1, info->key));
 654
 655         if (sqlite3_step(stmt) != SQLITE_DONE) {
 656                 STC_LOGE("Failed to delete firewall rule %s\n",
 657                          sqlite3_errmsg(stc_db_get_database()));
 658                 error_code = STC_ERROR_DB_FAILED;
 659                 goto handle_error;
 660         }
 661
 662         STC_LOGD("Firewall rule deleted [%s]", info->chain);
 663
 664 handle_error:
 665
 666         sqlite3_reset(stmt);
 667         return error_code;
 668 }
 669
 670 API stc_error_e table_firewall_update_rule(firewall_rule_s *info, guint key)
 671 {
 672         stc_error_e error_code = STC_ERROR_NONE;
 673         char buf[BUF_SIZE_FOR_IP];
 674         sqlite3_stmt *stmt = update_fw_rule;
 675
 676         if (!info) {
 677                 error_code = STC_ERROR_INVALID_PARAMETER;
 678                 goto handle_error;
 679         }
 680
 681         DB_ACTION(sqlite3_bind_text(stmt, 1, info->chain ? info->chain : "",
 682                                         -1, SQLITE_TRANSIENT));
 683         DB_ACTION(sqlite3_bind_int(stmt, 2, info->direction));
 684         DB_ACTION(sqlite3_bind_int(stmt, 3, info->s_ip_type));
 685         DB_ACTION(sqlite3_bind_int(stmt, 4, info->d_ip_type));
 686         DB_ACTION(sqlite3_bind_int(stmt, 5, info->s_port_type));
 687         DB_ACTION(sqlite3_bind_int(stmt, 6, info->d_port_type));
 688         DB_ACTION(sqlite3_bind_int(stmt, 7, info->protocol));
 689         DB_ACTION(sqlite3_bind_int(stmt, 8, info->family));
 690         if (info->family == STC_FW_FAMILY_V4) {
 691                 memset(buf, 0, sizeof(buf));
 692                 snprintf(buf, sizeof(buf), "%08x", info->s_ip1.Ipv4.s_addr);
 693                 DB_ACTION(sqlite3_bind_text(stmt, 9, buf, -1, SQLITE_TRANSIENT));
 694
 695                 memset(buf, 0, sizeof(buf));
 696                 snprintf(buf, sizeof(buf), "%08x", info->s_ip2.Ipv4.s_addr);
 697                 DB_ACTION(sqlite3_bind_text(stmt, 10, buf, -1, SQLITE_TRANSIENT));
 698
 699                 memset(buf, 0, sizeof(buf));
 700                 snprintf(buf, sizeof(buf), "%08x", info->d_ip1.Ipv4.s_addr);
 701                 DB_ACTION(sqlite3_bind_text(stmt, 11, buf, -1, SQLITE_TRANSIENT));
 702
 703                 memset(buf, 0, sizeof(buf));
 704                 snprintf(buf, sizeof(buf), "%08x", info->d_ip2.Ipv4.s_addr);
 705                 DB_ACTION(sqlite3_bind_text(stmt, 12, buf, -1, SQLITE_TRANSIENT));
 706         } else if (info->family == STC_FW_FAMILY_V6) {
 707                 memset(buf, 0, sizeof(buf));
 708                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 709                         info->s_ip1.Ipv6.s6_addr32[0], info->s_ip1.Ipv6.s6_addr32[1],
 710                         info->s_ip1.Ipv6.s6_addr32[2], info->s_ip1.Ipv6.s6_addr32[3]);
 711                 DB_ACTION(sqlite3_bind_text(stmt, 9, buf, -1, SQLITE_TRANSIENT));
 712
 713                 memset(buf, 0, sizeof(buf));
 714                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 715                         info->s_ip2.Ipv6.s6_addr32[0], info->s_ip2.Ipv6.s6_addr32[1],
 716                         info->s_ip2.Ipv6.s6_addr32[2], info->s_ip2.Ipv6.s6_addr32[3]);
 717                 DB_ACTION(sqlite3_bind_text(stmt, 10, buf, -1, SQLITE_TRANSIENT));
 718
 719                 memset(buf, 0, sizeof(buf));
 720                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 721                         info->d_ip1.Ipv6.s6_addr32[0], info->d_ip1.Ipv6.s6_addr32[1],
 722                         info->d_ip1.Ipv6.s6_addr32[2], info->d_ip1.Ipv6.s6_addr32[3]);
 723                 DB_ACTION(sqlite3_bind_text(stmt, 11, buf, -1, SQLITE_TRANSIENT));
 724
 725                 memset(buf, 0, sizeof(buf));
 726                 snprintf(buf, sizeof(buf), "%08x:%08x:%08x:%08x",
 727                         info->d_ip2.Ipv6.s6_addr32[0], info->d_ip2.Ipv6.s6_addr32[1],
 728                         info->d_ip2.Ipv6.s6_addr32[2], info->d_ip2.Ipv6.s6_addr32[3]);
 729                 DB_ACTION(sqlite3_bind_text(stmt, 12, buf, -1, SQLITE_TRANSIENT));
 730         } else {
 731                 DB_ACTION(sqlite3_bind_text(stmt, 9, "", -1, SQLITE_TRANSIENT));
 732                 DB_ACTION(sqlite3_bind_text(stmt, 10, "", -1, SQLITE_TRANSIENT));
 733                 DB_ACTION(sqlite3_bind_text(stmt, 11, "", -1, SQLITE_TRANSIENT));
 734                 DB_ACTION(sqlite3_bind_text(stmt, 12, "", -1, SQLITE_TRANSIENT));
 735         }
 736         DB_ACTION(sqlite3_bind_int(stmt, 13, info->s_port1));
 737         DB_ACTION(sqlite3_bind_int(stmt, 14, info->s_port2));
 738         DB_ACTION(sqlite3_bind_int(stmt, 15, info->d_port1));
 739         DB_ACTION(sqlite3_bind_int(stmt, 16, info->d_port2));
 740         DB_ACTION(sqlite3_bind_text(stmt, 17, info->ifname ? info->ifname : "",
 741                                         -1, SQLITE_TRANSIENT));
 742         DB_ACTION(sqlite3_bind_int(stmt, 18, info->target));
 743         DB_ACTION(sqlite3_bind_int(stmt, 19, info->log_level));
 744         DB_ACTION(sqlite3_bind_text(stmt, 20, info->log_prefix ? info->log_prefix : "",
 745                                         -1, SQLITE_TRANSIENT));
 746         DB_ACTION(sqlite3_bind_int(stmt, 21, info->nflog_group));
 747         DB_ACTION(sqlite3_bind_text(stmt, 22, info->nflog_prefix ? info->nflog_prefix : "",
 748                                         -1, SQLITE_TRANSIENT));
 749         DB_ACTION(sqlite3_bind_int(stmt, 23, info->nflog_range));
 750         DB_ACTION(sqlite3_bind_int(stmt, 24, info->nflog_threshold));
 751         DB_ACTION(sqlite3_bind_text(stmt, 25, info->identifier ? info->identifier : "",
 752                                         -1, SQLITE_TRANSIENT));
 753         DB_ACTION(sqlite3_bind_int64(stmt, 26, info->key));
 754         DB_ACTION(sqlite3_bind_int64(stmt, 27, key));
 755
 756         if (sqlite3_step(stmt) != SQLITE_DONE) {
 757                 STC_LOGE("Failed to update firewall rule %s\n",
 758                          sqlite3_errmsg(stc_db_get_database()));
 759                 error_code = STC_ERROR_DB_FAILED;
 760                 goto handle_error;
 761         }
 762
 763         STC_LOGD("Firewall rule updated [%s]", info->chain);
 764
 765 handle_error:
 766
 767         sqlite3_reset(stmt);
 768         return error_code;
 769 }
 770
 771 API stc_error_e table_firewall_foreach_rule(firewall_rule_cb info_cb,
 772                                        void *user_data)
 773 {
 774         firewall_rule_s info;
 775         int rc;
 776         stc_error_e error_code = STC_ERROR_NONE;
 777         sqlite3_stmt *stmt = select_fw_rule;
 778
 779         do {
 780                 rc = sqlite3_step(stmt);
 781
 782                 memset(&info, 0, sizeof(info));
 783
 784                 switch (rc) {
 785                 case SQLITE_DONE:
 786                         break;
 787                 case SQLITE_ROW:
 788                         info.key = sqlite3_column_int64(stmt, 0);
 789                         info.chain = (char *)sqlite3_column_text(stmt, 1);
 790                         info.direction = sqlite3_column_int(stmt, 2);
 791                         info.s_ip_type = sqlite3_column_int(stmt, 3);
 792                         info.d_ip_type = sqlite3_column_int(stmt, 4);
 793                         info.s_port_type = sqlite3_column_int(stmt, 5);
 794                         info.d_port_type = sqlite3_column_int(stmt, 6);
 795                         info.protocol = sqlite3_column_int(stmt, 7);
 796                         info.family = sqlite3_column_int(stmt, 8);
 797                         if (info.family == STC_FW_FAMILY_V4) {
 798                                 sscanf((char *)sqlite3_column_text(stmt, 9), "%08x",
 799                                                                 &(info.s_ip1.Ipv4.s_addr));
 800                                 sscanf((char *)sqlite3_column_text(stmt, 10), "%08x",
 801                                                                 &(info.s_ip2.Ipv4.s_addr));
 802                                 sscanf((char *)sqlite3_column_text(stmt, 11), "%08x",
 803                                                                 &(info.d_ip1.Ipv4.s_addr));
 804                                 sscanf((char *)sqlite3_column_text(stmt, 12), "%08x",
 805                                                                 &(info.d_ip2.Ipv4.s_addr));
 806                         } else if (info.family == STC_FW_FAMILY_V6) {
 807                                 sscanf((char *)sqlite3_column_text(stmt, 9), "%08x:%08x:%08x:%08x",
 808                                         &(info.s_ip1.Ipv6.s6_addr32[0]), &(info.s_ip1.Ipv6.s6_addr32[1]),
 809                                         &(info.s_ip1.Ipv6.s6_addr32[2]), &(info.s_ip1.Ipv6.s6_addr32[3]));
 810                                 sscanf((char *)sqlite3_column_text(stmt, 10), "%08x:%08x:%08x:%08x",
 811                                         &(info.s_ip2.Ipv6.s6_addr32[0]), &(info.s_ip2.Ipv6.s6_addr32[1]),
 812                                         &(info.s_ip2.Ipv6.s6_addr32[2]), &(info.s_ip2.Ipv6.s6_addr32[3]));
 813                                 sscanf((char *)sqlite3_column_text(stmt, 11), "%08x:%08x:%08x:%08x",
 814                                         &(info.d_ip1.Ipv6.s6_addr32[0]), &(info.d_ip1.Ipv6.s6_addr32[1]),
 815                                         &(info.d_ip1.Ipv6.s6_addr32[2]), &(info.d_ip1.Ipv6.s6_addr32[3]));
 816                                 sscanf((char *)sqlite3_column_text(stmt, 12), "%08x:%08x:%08x:%08x",
 817                                         &(info.d_ip2.Ipv6.s6_addr32[0]), &(info.d_ip2.Ipv6.s6_addr32[1]),
 818                                         &(info.d_ip2.Ipv6.s6_addr32[2]), &(info.d_ip2.Ipv6.s6_addr32[3]));
 819                         }
 820                         info.s_port1 = sqlite3_column_int(stmt, 13);
 821                         info.s_port2 = sqlite3_column_int(stmt, 14);
 822                         info.d_port1 = sqlite3_column_int(stmt, 15);
 823                         info.d_port2 = sqlite3_column_int(stmt, 16);
 824                         info.ifname = (char *)sqlite3_column_text(stmt, 17);
 825                         info.target = sqlite3_column_int(stmt, 18);
 826                         info.log_level = sqlite3_column_int(stmt, 19);
 827                         info.log_prefix = (char *)sqlite3_column_text(stmt, 20);
 828                         info.nflog_group = sqlite3_column_int(stmt, 21);
 829                         info.nflog_prefix = (char *)sqlite3_column_text(stmt, 22);
 830                         info.nflog_range = sqlite3_column_int(stmt, 23);
 831                         info.nflog_threshold = sqlite3_column_int(stmt, 24);
 832                         info.identifier = (char *)sqlite3_column_text(stmt, 25);
 833
 834                         if (info_cb(&info, user_data) == STC_CANCEL)
 835                                 rc = SQLITE_DONE;
 836                         break;
 837                 case SQLITE_ERROR:
 838                 default:
 839                         STC_LOGE("Failed to enumerate firewall rules: %s\n",
 840                                  sqlite3_errmsg(stc_db_get_database()));
 841
 842                         error_code = STC_ERROR_DB_FAILED;
 843                 }
 844         } while (rc == SQLITE_ROW);
 845
 846         sqlite3_reset(stmt);
 847         return error_code;
 848 }
 849
 850 stc_error_e table_firewall_prepare(sqlite3 *db)
 851 {
 852         __STC_LOG_FUNC_ENTER__;
 853
 854         stc_error_e error_code = STC_ERROR_NONE;
 855
 856         if (db == NULL) {
 857                 __STC_LOG_FUNC_EXIT__;
 858                 return STC_ERROR_FAIL;
 859         }
 860
 861         DB_ACTION(__prepare_delete(db));
 862         DB_ACTION(__prepare_select(db));
 863         DB_ACTION(__prepare_update(db));
 864         DB_ACTION(__prepare_insert(db));
 865
 866 handle_error:
 867
 868         __STC_LOG_FUNC_EXIT__;
 869         return error_code;
 870 }
 871
 872 void table_firewall_finalize(void)
 873 {
 874         __STC_LOG_FUNC_ENTER__;
 875         __finalize_delete();
 876         __finalize_select();
 877         __finalize_update();
 878         __finalize_insert();
 879         __STC_LOG_FUNC_EXIT__;
 880 }