db/rules-db.sql

   1 -- !!! CAUTION !!!
   2 -- 1. Beware of updating schema!
   3 --    We can drop views and triggers,
   4 --    but we should copy data from tables
   5 --    according to the schema version!
   6 -- 2. If you change definition of tables
   7 --    update the schema counter at the bottom!!
   8
   9 .load librules-db-sql-udf.so
  10 PRAGMA foreign_keys = ON;
  11 PRAGMA auto_vacuum = NONE;
  12
  13 BEGIN EXCLUSIVE TRANSACTION;
  14
  15 -- Update here on every schema change! Integer value.
  16 PRAGMA user_version = 3;
  17
  18 CREATE TABLE IF NOT EXISTS  app (
  19     app_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
  20     label_id INTEGER NOT NULL,
  21     UNIQUE(label_id),
  22
  23     FOREIGN KEY(label_id) REFERENCES label(label_id)
  24 );
  25
  26
  27 CREATE TABLE IF NOT EXISTS app_permission (
  28     app_id INTEGER NOT NULL,
  29     permission_id INTEGER NOT NULL,
  30     is_volatile INTEGER NOT NULL  DEFAULT 0,
  31     is_enabled INTEGER NOT NULL  DEFAULT 1,
  32
  33     PRIMARY KEY(app_id, permission_id),
  34
  35     FOREIGN KEY(app_id) REFERENCES app(app_id),
  36     FOREIGN KEY(permission_id) REFERENCES permission(permission_id)
  37 );
  38
  39 -- Used by ltl_ view
  40 CREATE INDEX IF NOT EXISTS app_permission_permission_id_index ON app_permission(permission_id);
  41
  42 CREATE TABLE IF NOT EXISTS app_path (
  43     app_id INTEGER NOT NULL,
  44     path TEXT NOT NULL,
  45     label_id INTEGER NOT NULL,
  46     access INTEGER NOT NULL,
  47     access_reverse INTEGER NOT NULL,
  48     app_path_type_id INTEGER NOT NULL ,
  49
  50     -- TODO:
  51     -- Desired behavior should be:
  52     -- allow one app to register a path only once (already implemented by the primary key)
  53     -- prohibit two apps registering the same path with different labels (probably cannot be done by SQL constraints)
  54     -- allow two apps to register the same path if label is also same
  55
  56     PRIMARY KEY (app_id, path),
  57
  58     FOREIGN KEY(app_id) REFERENCES app(app_id),
  59     FOREIGN KEY(label_id) REFERENCES label(label_id),
  60     FOREIGN KEY(app_path_type_id) REFERENCES app_path_type(app_path_type_id)
  61 );
  62
  63 -- Used by ltl_ view
  64 CREATE INDEX IF NOT EXISTS app_path_app_path_type_id_index ON app_path(app_path_type_id);
  65
  66 CREATE TABLE IF NOT EXISTS app_path_type (
  67     app_path_type_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
  68     name TEXT NOT NULL ,
  69
  70     UNIQUE (name)
  71 );
  72
  73
  74 CREATE TABLE IF NOT EXISTS permission_permission_rule (
  75     permission_id INTEGER NOT NULL,
  76     target_permission_id INTEGER NOT NULL,
  77     access INTEGER NOT NULL DEFAULT 0,
  78     is_reverse INTEGER NOT NULL  DEFAULT 0,
  79
  80     PRIMARY KEY (permission_id, target_permission_id, is_reverse),
  81
  82     FOREIGN KEY(permission_id) REFERENCES permission(permission_id),
  83     FOREIGN KEY(target_permission_id) REFERENCES permission(permission_id)
  84 );
  85
  86 CREATE TABLE IF NOT EXISTS permission_label_rule (
  87     permission_id INTEGER NOT NULL,
  88     label_id INTEGER NOT NULL,
  89     access INTEGER NOT NULL DEFAULT 0,
  90     is_reverse INTEGER NOT NULL  DEFAULT 0,
  91
  92     PRIMARY KEY (permission_id,label_id, is_reverse),
  93
  94     FOREIGN KEY(permission_id) REFERENCES permission(permission_id),
  95     FOREIGN KEY(label_id) REFERENCES label(label_id)
  96 );
  97
  98 -- Used by ltl_ view
  99 CREATE INDEX IF NOT EXISTS permission_label_rule_label_id_index ON permission_label_rule(label_id);
 100
 101 CREATE TABLE IF NOT EXISTS permission_app_path_type_rule (
 102     permission_id INTEGER NOT NULL,
 103     app_path_type_id INTEGER NOT NULL,
 104     access INTEGER NOT NULL DEFAULT 0,
 105     is_reverse INTEGER NOT NULL  DEFAULT 0,
 106
 107     PRIMARY KEY (permission_id, app_path_type_id, is_reverse),
 108
 109     FOREIGN KEY(permission_id) REFERENCES permission(permission_id),
 110     FOREIGN KEY(app_path_type_id) REFERENCES app_path_type(app_path_type_id)
 111 );
 112
 113 -- Used by ltl_ view
 114 CREATE INDEX IF NOT EXISTS permission_app_path_type_rule_app_path_type_id_index
 115     ON permission_app_path_type_rule(app_path_type_id);
 116
 117 CREATE TABLE IF NOT EXISTS label_app_path_type_rule (
 118     label_id INTEGER NOT NULL,
 119     app_path_type_id INTEGER NOT NULL,
 120     access INTEGER NOT NULL DEFAULT 0,
 121     is_reverse INTEGER NOT NULL  DEFAULT 0,
 122
 123     PRIMARY KEY (label_id, app_path_type_id, is_reverse),
 124
 125     FOREIGN KEY(label_id) REFERENCES label(label_id),
 126     FOREIGN KEY(app_path_type_id) REFERENCES app_path_type(app_path_type_id)
 127 );
 128
 129 CREATE TABLE IF NOT EXISTS label (
 130     label_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
 131     name TEXT NOT NULL,
 132
 133     UNIQUE(name)
 134 );
 135
 136 CREATE TABLE IF NOT EXISTS permission_type (
 137     permission_type_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
 138     type_name TEXT NOT NULL,
 139
 140     UNIQUE(type_name)
 141 );
 142
 143 CREATE TABLE IF NOT EXISTS permission (
 144     permission_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT ,
 145     permission_type_id INTEGER NOT NULL,
 146     name TEXT NOT NULL,
 147
 148     UNIQUE (name, permission_type_id),
 149
 150     FOREIGN KEY(permission_type_id) REFERENCES permission_type(permission_type_id)
 151 );
 152
 153 -- Not aggregated rules
 154 CREATE TABLE IF NOT EXISTS all_smack_binary_rules(
 155     subject TEXT NOT NULL,
 156     object  TEXT NOT NULL,
 157     access  INTEGER NOT NULL,
 158     is_volatile INTEGER NOT NULL
 159 );
 160
 161 -- Index used for grouping and sorting by (subject, object)
 162 -- and used for filtering by subject
 163 CREATE INDEX IF NOT EXISTS all_smack_binary_rules_subject_object_index
 164     ON all_smack_binary_rules(subject,  object);
 165
 166 -- Index used for filtering by object
 167 CREATE INDEX IF NOT EXISTS all_smack_binary_rules_object_index
 168     ON all_smack_binary_rules(object);
 169
 170 -- TEMPORARY TABLES ------------------------------------------------------------
 171 -- Definitions are repeated in code.
 172
 173 CREATE TEMPORARY TABLE modified_label(
 174    name TEXT NOT NULL PRIMARY KEY
 175 );
 176
 177 -- Not aggregated subset of modified rules
 178 CREATE TEMPORARY TABLE all_smack_binary_rules_modified(
 179     subject TEXT NOT NULL,
 180     object  TEXT NOT NULL,
 181     access  INTEGER NOT NULL,
 182     is_volatile INTEGER NOT NULL
 183 );
 184
 185 -- Aggregated subset of rules after changes
 186 CREATE TEMPORARY TABLE current_smack_rule_modified(
 187     subject TEXT NOT NULL,
 188     object  TEXT NOT NULL,
 189     access  INTEGER NOT NULL
 190 );
 191
 192 -- Aggregated subset of rules before changes
 193 CREATE TEMPORARY TABLE history_smack_rule_modified(
 194     subject TEXT NOT NULL,
 195     object  TEXT NOT NULL,
 196     access  INTEGER NOT NULL
 197 );
 198
 199
 200 -- PERMISSION VIEW -------------------------------------------------------------
 201 DROP VIEW IF EXISTS permission_view;
 202 CREATE VIEW permission_view AS
 203 SELECT      permission.permission_id, permission.name, permission_type.type_name
 204 FROM        permission
 205 INNER JOIN  permission_type USING(permission_type_id);
 206
 207 DROP TRIGGER IF EXISTS permission_view_insert_trigger;
 208 CREATE TRIGGER permission_view_insert_trigger
 209 INSTEAD OF INSERT ON permission_view
 210 BEGIN
 211     -- Add the permission
 212     INSERT OR IGNORE INTO permission(name,permission_type_id)
 213     SELECT      NEW.name, permission_type.permission_type_id
 214     FROM        permission_type
 215     WHERE       permission_type.type_name = NEW.type_name;
 216
 217
 218     -- Delete the previous definition of the permission
 219     DELETE FROM permission_label_rule_view
 220     WHERE       permission_name = NEW.name AND
 221                 permission_type_name = NEW.type_name;
 222
 223     DELETE FROM permission_permission_rule_view
 224     WHERE       permission_name = NEW.name AND
 225                 permission_type_name = NEW.type_name;
 226
 227     DELETE FROM permission_app_path_type_rule_view
 228     WHERE       permission_name = NEW.name AND
 229                 permission_type_name = NEW.type_name;
 230
 231 END;
 232
 233 -- PERMISSION TO LABEL RULE VIEW -----------------------------------------------
 234 DROP VIEW IF EXISTS permission_label_rule_view;
 235 CREATE VIEW permission_label_rule_view AS
 236 SELECT
 237         permission_view.permission_id       AS permission_id,
 238         permission_view.name                AS permission_name,
 239         permission_view.type_name           AS permission_type_name,
 240         label.name                              AS label_name,
 241         permission_label_rule.access            AS access,
 242         permission_label_rule.is_reverse        AS is_reverse
 243 FROM    permission_label_rule
 244 LEFT JOIN permission_view USING(permission_id)
 245 LEFT JOIN label USING(label_id);
 246
 247
 248 -- Preferred way of adding permission rules would be to use these ONE, multi-row
 249 -- insert statement, with one check of a condition
 250 -- that there is such permission id. It's impossible to make those inserts in C,
 251 -- so the programmer has to secure, that there is a permission with a given id.
 252 -- (Check it and insert in the same transaction)
 253 -- In runtime we accept ONLY inserts with label.
 254 -- All other kinds of permissions are filled during the database creation.
 255 DROP TRIGGER IF EXISTS permission_label_rule_view_insert_trigger;
 256 CREATE TRIGGER permission_label_rule_view_insert_trigger
 257 INSTEAD OF INSERT ON permission_label_rule_view
 258 BEGIN
 259     -- Adding api features adds a label it it's not present.
 260     INSERT OR IGNORE INTO label(name) VALUES (NEW.label_name);
 261
 262     INSERT OR REPLACE INTO permission_label_rule(permission_id,
 263                                                  label_id,
 264                                                  access,
 265                                                  is_reverse)
 266     SELECT      NEW.permission_id,
 267                 label.label_id,
 268                 str_to_access(NEW.access),
 269                 NEW.is_reverse
 270     FROM        label
 271     WHERE       label.name = NEW.label_name;
 272 END;
 273
 274
 275 -- TODO: Potential problem - undeleted labels.
 276 DROP TRIGGER IF EXISTS permission_label_rule_view_delete_trigger;
 277 CREATE TRIGGER permission_label_rule_view_delete_trigger
 278 INSTEAD OF DELETE ON permission_label_rule_view
 279 BEGIN
 280         DELETE FROM permission_label_rule
 281         WHERE   permission_label_rule.permission_id
 282                 IN (SELECT permission_view.permission_id
 283                     FROM   permission_view
 284                     WHERE  permission_view.name = OLD.permission_name AND
 285                            permission_view.type_name = OLD.permission_type_name);
 286 END;
 287
 288
 289 -- PERMISSION TO APP PATH TYPE RULE VIEW ---------------------------------------
 290 DROP VIEW IF EXISTS permission_app_path_type_rule_view;
 291 CREATE VIEW permission_app_path_type_rule_view AS
 292 SELECT
 293         permission_view.permission_id       AS permission_id,
 294         permission_view.name                AS permission_name,
 295         permission_view.type_name           AS permission_type_name,
 296         app_path_type.name                      AS app_path_type_name,
 297         permission_app_path_type_rule.access       AS access,
 298         permission_app_path_type_rule.is_reverse   AS is_reverse
 299 FROM    permission_app_path_type_rule
 300 LEFT JOIN permission_view USING(permission_id)
 301 LEFT JOIN app_path_type USING(app_path_type_id);
 302
 303
 304 DROP TRIGGER IF EXISTS permission_app_path_type_rule_view_insert_trigger;
 305 CREATE TRIGGER permission_app_path_type_rule_view_insert_trigger
 306 INSTEAD OF INSERT
 307 ON permission_app_path_type_rule_view
 308 WHEN NEW.permission_id IS NULL
 309 BEGIN
 310     INSERT INTO permission_app_path_type_rule(permission_id,
 311                                               app_path_type_id,
 312                                               access,
 313                                               is_reverse)
 314     SELECT      permission_view.permission_id,
 315                 app_path_type.app_path_type_id,
 316                 str_to_access(NEW.access),
 317                 NEW.is_reverse
 318     FROM        permission_view, app_path_type
 319     WHERE       permission_view.name = NEW.permission_name AND
 320                 permission_view.type_name = NEW.permission_type_name AND
 321                 app_path_type.name = NEW.app_path_type_name;
 322 END;
 323
 324 DROP TRIGGER IF EXISTS permission_app_path_type_rule_view_delete_trigger;
 325 CREATE TRIGGER permission_app_path_type_rule_view_delete_trigger
 326 INSTEAD OF DELETE
 327 ON permission_app_path_type_rule_view
 328 BEGIN
 329     -- Delete the rule
 330     DELETE FROM permission_app_path_type_rule
 331     WHERE       permission_app_path_type_rule.permission_id
 332                 IN (SELECT permission_view.permission_id
 333                     FROM   permission_view
 334                     WHERE  permission_view.name = OLD.permission_name AND
 335                            permission_view.type_name = OLD.permission_type_name);
 336 END;
 337
 338
 339 CREATE TRIGGER permission_app_path_type_id_rule_view_insert_trigger
 340 INSTEAD OF INSERT
 341 ON permission_app_path_type_rule_view
 342 WHEN NEW.permission_id IS NOT NULL
 343 BEGIN
 344     INSERT OR REPLACE INTO permission_app_path_type_rule(permission_id,
 345                                                          app_path_type_id,
 346                                                          access,
 347                                                          is_reverse)
 348     SELECT      NEW.permission_id,
 349                 app_path_type.app_path_type_id,
 350                 str_to_access(NEW.access),
 351                 NEW.is_reverse
 352     FROM        app_path_type
 353     WHERE       app_path_type.name = NEW.app_path_type_name;
 354 END;
 355
 356
 357 -- LABEL TO APP PATH TYPE RULE VIEW --------------------------------------------
 358 DROP VIEW IF EXISTS label_app_path_type_rule_view;
 359 CREATE VIEW label_app_path_type_rule_view AS
 360 SELECT
 361         label_app_path_type_rule.label_id   AS label_id,
 362         label.name                          AS label_name,
 363         app_path_type.name                  AS app_path_type_name,
 364         label_app_path_type_rule.access     AS access,
 365         label_app_path_type_rule.is_reverse AS is_reverse
 366 FROM    label_app_path_type_rule
 367 LEFT JOIN label USING(label_id)
 368 LEFT JOIN app_path_type USING(app_path_type_id);
 369
 370
 371 DROP TRIGGER IF EXISTS label_app_path_type_rule_view_insert_trigger;
 372 CREATE TRIGGER label_app_path_type_rule_view_insert_trigger
 373 INSTEAD OF INSERT
 374 ON label_app_path_type_rule_view
 375 BEGIN
 376     INSERT OR IGNORE INTO label(name) VALUES (NEW.label_name);
 377
 378     INSERT INTO label_app_path_type_rule(label_id,
 379                                          app_path_type_id,
 380                                          access,
 381                                          is_reverse)
 382     SELECT      label.label_id,
 383                 app_path_type.app_path_type_id,
 384                 str_to_access(NEW.access),
 385                 NEW.is_reverse
 386     FROM        label, app_path_type
 387     WHERE       label.name = NEW.label_name AND
 388                 app_path_type.name = NEW.app_path_type_name;
 389 END;
 390
 391
 392 DROP TRIGGER IF EXISTS label_app_path_type_rule_view_delete_trigger;
 393 CREATE TRIGGER label_app_path_type_rule_view_delete_trigger
 394 INSTEAD OF DELETE
 395 ON label_app_path_type_rule_view
 396 BEGIN
 397     -- Delete the rules with this label
 398     DELETE FROM label_app_path_type_rule
 399     WHERE       label_app_path_type_rule.label_id
 400                 IN (SELECT label.label_id
 401                     FROM   label
 402                     WHERE  label.name = OLD.label_name);
 403
 404     -- Delete the label if it's not referenced
 405     DELETE FROM label_view
 406     WHERE label_view.name = OLD.label_name;
 407 END;
 408
 409 -- PERMISSION TO PERMISSION RULE VIEW ------------------------------------------
 410 DROP VIEW IF EXISTS permission_permission_rule_view;
 411 CREATE VIEW permission_permission_rule_view AS
 412 SELECT
 413         tmp_permission_view.permission_id       AS permission_id,
 414         tmp_permission_view.name                AS permission_name,
 415         tmp_permission_view.type_name           AS permission_type_name,
 416         tmp_target_permission_view.name         AS target_permission_name,
 417         tmp_target_permission_view.type_name    AS target_permission_type_name,
 418         permission_permission_rule.access       AS access,
 419         permission_permission_rule.is_reverse   AS is_reverse
 420 FROM    permission_permission_rule
 421 LEFT JOIN permission_view AS tmp_permission_view USING(permission_id)
 422 LEFT JOIN permission_view AS tmp_target_permission_view
 423 ON permission_permission_rule.target_permission_id = tmp_target_permission_view.permission_id;
 424
 425
 426 -- Trigger for manual addition of rules.
 427 DROP TRIGGER IF EXISTS permission_permission_rule_view_insert_trigger;
 428 CREATE TRIGGER  permission_permission_rule_view_insert_trigger
 429 INSTEAD OF INSERT ON  permission_permission_rule_view
 430 BEGIN
 431
 432     INSERT OR REPLACE INTO permission_permission_rule(permission_id,
 433                                                       target_permission_id,
 434                                                       access,
 435                                                       is_reverse)
 436     SELECT  tmp_permission_view.permission_id,
 437             tmp_target_permission_view.permission_id,
 438             str_to_access(NEW.access),
 439             NEW.is_reverse
 440     FROM    permission_view AS tmp_permission_view,
 441             permission_view AS tmp_target_permission_view
 442     WHERE   tmp_permission_view.name = NEW.permission_name AND
 443             tmp_permission_view.type_name = NEW.permission_type_name AND
 444             tmp_target_permission_view.name = NEW.target_permission_name AND
 445             tmp_target_permission_view.type_name = NEW.target_permission_type_name;
 446 END;
 447
 448
 449 DROP TRIGGER IF EXISTS permission_permission_rule_view_delete_trigger;
 450 CREATE TRIGGER  permission_permission_rule_view_delete_trigger
 451 INSTEAD OF DELETE ON  permission_permission_rule_view
 452 BEGIN
 453     -- Delete the rule
 454     DELETE FROM permission_permission_rule
 455     WHERE       permission_permission_rule.permission_id
 456                 IN (SELECT permission_view.permission_id
 457                     FROM   permission_view
 458                     WHERE  permission_view.name = OLD.permission_name AND
 459                            permission_view.type_name = OLD.permission_type_name);
 460 END;
 461
 462
 463
 464 -- LABEL VIEW ------------------------------------------------------------------
 465 -- There are no INSTEAD OF triggers on regular tables.
 466 -- We use a view to delete unreferenced labels:
 467 DROP VIEW IF EXISTS label_view;
 468 CREATE VIEW label_view AS SELECT * FROM label;
 469
 470 DROP TRIGGER IF EXISTS label_view_delete_trigger;
 471 CREATE TRIGGER label_view_delete_trigger
 472 INSTEAD OF DELETE ON label_view
 473 WHEN    OLD.label_id NOT IN (SELECT app.label_id
 474                              FROM   app) AND
 475         OLD.label_id NOT IN (SELECT permission_label_rule.label_id
 476                              FROM   permission_label_rule) AND
 477         OLD.label_id NOT IN (SELECT app_path.label_id
 478                              FROM   app_path) AND
 479         OLD.label_id NOT IN (SELECT label_app_path_type_rule.label_id
 480                              FROM   label_app_path_type_rule)
 481 BEGIN
 482         DELETE FROM label WHERE label.name = OLD.name;
 483 END;
 484
 485
 486 -- APPLICATION VIEW ------------------------------------------------------------
 487 DROP VIEW IF EXISTS application_view;
 488 CREATE VIEW application_view AS
 489 SELECT      app.app_id, label.name
 490 FROM        label
 491 INNER JOIN  app USING(label_id);
 492
 493 DROP TRIGGER IF EXISTS application_view_insert_trigger;
 494 CREATE TRIGGER application_view_insert_trigger
 495 INSTEAD OF INSERT ON application_view
 496 BEGIN
 497     -- The app's label could have been added by the permission.
 498     INSERT OR IGNORE INTO label(name) VALUES (NEW.name);
 499
 500     -- Add application:
 501     INSERT INTO app(label_id)
 502     SELECT label_id
 503     FROM   label
 504     WHERE  label.name = NEW.name;
 505
 506     -- Add the permission granted to all applications
 507     INSERT INTO app_permission_view(app_id, name, type_name, is_volatile, is_enabled)
 508     VALUES (last_insert_rowid(), "ALL_APPS", "ALL_APPS", 0, 1);
 509
 510 END;
 511
 512
 513 DROP TRIGGER IF EXISTS application_view_delete_trigger;
 514 CREATE TRIGGER application_view_delete_trigger
 515 INSTEAD OF DELETE ON application_view
 516 BEGIN
 517         -- Delete rules that correspond to app's paths:
 518         DELETE FROM permission_label_rule
 519         WHERE       permission_label_rule.label_id IN
 520                    (SELECT     app_path.label_id
 521                     FROM       app_path
 522                     INNER JOIN application_view USING(app_id)
 523                     WHERE      application_view.name = OLD.name);
 524
 525         -- Delete path
 526         DELETE FROM path_view
 527         WHERE path_view.owner_app_label_name=OLD.name;
 528
 529         -- Delete apps permissions:
 530         DELETE FROM app_permission
 531         WHERE       app_permission.app_id
 532                     IN (SELECT application_view.app_id
 533                         FROM   application_view
 534                         WHERE  application_view.name = OLD.name
 535                         LIMIT  1);
 536
 537         -- Delete application
 538         DELETE FROM app
 539         WHERE app.app_id IN (SELECT application_view.app_id
 540                              FROM   application_view
 541                              WHERE  application_view.name = OLD.name
 542                              LIMIT  1);
 543
 544         -- Delete label
 545         DELETE FROM label_view
 546         WHERE label_view.name = OLD.name;
 547 END;
 548
 549
 550 -- PATH VIEW -------------------------------------------------------------------
 551 DROP VIEW IF EXISTS path_view;
 552 CREATE VIEW path_view AS
 553 SELECT  application_view.name   AS owner_app_label_name,
 554         app_path.path           AS path,
 555         label.name              AS path_label_name,
 556         app_path.access         AS access,
 557         app_path.access_reverse AS access_reverse,
 558         app_path_type.name      AS path_type_name
 559
 560 FROM    app_path
 561 LEFT JOIN app_path_type     USING (app_path_type_id)
 562 LEFT JOIN application_view  USING (app_id)
 563 LEFT JOIN label             USING (label_id);
 564
 565
 566 -- For an existing application we add a path.
 567 DROP TRIGGER IF EXISTS path_view_insert_trigger;
 568 CREATE TRIGGER path_view_insert_trigger
 569 INSTEAD OF INSERT ON path_view
 570 WHEN NEW.owner_app_label_name IN (SELECT application_view.name
 571                                   FROM application_view)
 572 BEGIN
 573     -- The path's label could have been added by the permission.
 574     INSERT OR IGNORE INTO label(name) VALUES (NEW.path_label_name);
 575
 576     -- Add the path
 577     INSERT OR IGNORE INTO app_path(app_id, path, label_id, access, access_reverse, app_path_type_id)
 578     SELECT  application_view.app_id,
 579             NEW.path,
 580             label.label_id,
 581             str_to_access(NEW.access),
 582             str_to_access(NEW.access_reverse),
 583             app_path_type.app_path_type_id
 584     FROM    application_view, app_path_type, label
 585     WHERE   application_view.name = NEW.owner_app_label_name AND
 586             app_path_type.name = NEW.path_type_name AND
 587             label.name = NEW.path_label_name;
 588 END;
 589
 590 DROP TRIGGER IF EXISTS path_view_delete_trigger;
 591 CREATE TRIGGER path_view_delete_trigger
 592 INSTEAD OF DELETE ON path_view
 593 BEGIN
 594         -- Delete the path
 595         DELETE FROM app_path
 596         WHERE app_path.app_id IN (SELECT  app.app_id
 597                                   FROM    app, label
 598                                   WHERE   label.name = OLD.owner_app_label_name AND
 599                                           app.label_id = label.label_id);
 600
 601         -- Delete the path's label if it's not used any more
 602         DELETE FROM label_view WHERE label_view.name = OLD.path_label_name;
 603 END;
 604
 605 -- APP PERMISSION LIST VIEW ----------------------------------------------------
 606 -- Used in check_app_permission_internal to check if permissions are present
 607 -- TODO: Check if SQLite optimizer doesn't change app_permission_view to the same code.
 608 DROP VIEW IF EXISTS app_permission_list_view;
 609 CREATE VIEW app_permission_list_view AS
 610 SELECT      app_permission.app_id AS app_id,
 611             app_permission.permission_id AS permission_id,
 612             permission_view.name AS permission_name,
 613             permission_view.type_name AS permission_type_name,
 614             app_permission.is_volatile AS is_volatile,
 615             app_permission.is_enabled AS is_enabled
 616 FROM        app_permission
 617 INNER JOIN  permission_view USING(permission_id);
 618
 619
 620
 621
 622 -- APP PERMISSION VIEW ---------------------------------------------------------
 623 DROP VIEW IF EXISTS app_permission_view;
 624 CREATE VIEW app_permission_view AS
 625 SELECT      application_view.app_id,
 626             application_view.name  AS app_name,
 627             permission_view.permission_id,
 628             permission_view.name,
 629             permission_view.type_name,
 630             app_permission.is_volatile,
 631             app_permission.is_enabled
 632 FROM        app_permission
 633 INNER JOIN  application_view USING(app_id)
 634 INNER JOIN  permission_view USING(permission_id);
 635
 636
 637 DROP TRIGGER IF EXISTS app_permission_view_insert_trigger;
 638 CREATE TRIGGER app_permission_view_insert_trigger
 639 INSTEAD OF INSERT ON app_permission_view
 640 BEGIN
 641     INSERT OR IGNORE INTO app_permission(app_id, permission_id, is_volatile, is_enabled)
 642     SELECT      NEW.app_id,
 643                 permission_view.permission_id,
 644                 NEW.is_volatile,
 645                 NEW.is_enabled
 646     FROM        permission_view
 647     WHERE       permission_view.name = NEW.name AND
 648                 permission_view.type_name = NEW.type_name;
 649 END;
 650
 651
 652
 653
 654 -- It's forbidden do change permission from not volatile to volatile.
 655 -- We have to check it before inserting anything.
 656 -- Used in updating permissions
 657 DROP TRIGGER IF EXISTS app_permission_view_update_trigger;
 658 CREATE TRIGGER app_permission_view_update_trigger
 659 INSTEAD OF UPDATE ON app_permission_view
 660 BEGIN
 661     UPDATE OR IGNORE app_permission
 662     SET              is_enabled = NEW.is_enabled
 663     WHERE            app_permission.app_id = OLD.app_id AND
 664                      app_permission.permission_id
 665                      IN (SELECT  permission_view.permission_id
 666                          FROM    permission_view
 667                          WHERE   permission_view.name = OLD.name AND
 668                                  permission_view.type_name = OLD.type_name
 669                          LIMIT 1);
 670 END;
 671
 672
 673 DROP TRIGGER IF EXISTS app_permission_view_delete_trigger;
 674 CREATE TRIGGER app_permission_view_delete_trigger
 675 INSTEAD OF DELETE ON app_permission_view
 676 BEGIN
 677     DELETE FROM app_permission
 678     WHERE       app_permission.app_id
 679                 IN (SELECT application_view.app_id
 680                     FROM   application_view
 681                     WHERE  application_view.name = OLD.app_name
 682                     LIMIT  1)
 683                 AND
 684                 app_permission.permission_id NOT IN (SELECT permission_view.permission_id
 685                                                      FROM   permission_view
 686                                                      WHERE  permission_view.name = "ALL_APPS" AND
 687                                                             permission_view.type_name = "ALL_APPS");
 688     -- Delete paths
 689     DELETE FROM path_view
 690     WHERE path_view.owner_app_label_name=OLD.app_name;
 691
 692 END;
 693
 694 -- APP PERMISSION VOLATILE VIEW ------------------------------------------------
 695 DROP VIEW IF EXISTS app_permission_volatile_view;
 696 CREATE VIEW app_permission_volatile_view AS
 697 SELECT      *
 698 FROM        app_permission_view
 699 WHERE       app_permission_view.is_volatile = 1;
 700
 701
 702 DROP TRIGGER IF EXISTS app_permission_volatile_view_delete_trigger;
 703 CREATE TRIGGER app_permission_volatile_view_delete_trigger
 704 INSTEAD OF DELETE ON app_permission_volatile_view
 705 BEGIN
 706     DELETE FROM app_permission
 707     WHERE       app_permission.is_volatile = 1 AND
 708                 app_permission.app_id
 709                 IN (SELECT application_view.app_id
 710                     FROM   application_view
 711                     WHERE  application_view.name = OLD.app_name
 712                     LIMIT  1);
 713 END;
 714
 715
 716 -- APPLICATIONS PERMISSIONS ID -------------------------------------------------
 717 -- All applications and their permissions
 718 DROP VIEW IF EXISTS app_label_with_permission_view;
 719 CREATE VIEW app_label_with_permission_view AS
 720 SELECT      app_permission.permission_id,
 721             application_view.name,
 722             application_view.app_id,
 723             app_permission.is_volatile
 724 FROM        app_permission
 725 INNER JOIN  application_view USING(app_id)
 726 WHERE       app_permission.is_enabled = 1;
 727
 728
 729
 730 -- PERMISSION TO PERMISSION RULE VIEW ------------------------------------------
 731 -- ltl = label to label
 732 DROP VIEW IF EXISTS ltl_permission_permission_rule_view;
 733 CREATE VIEW ltl_permission_permission_rule_view AS
 734 SELECT      app1.name AS subject,
 735             app2.name AS object,
 736             p.access,
 737             app1.is_volatile OR app2.is_volatile AS is_volatile
 738 FROM        permission_permission_rule AS p
 739 INNER JOIN  app_label_with_permission_view AS app1 USING(permission_id)
 740 INNER JOIN  app_label_with_permission_view AS app2
 741             ON app2.permission_id = p.target_permission_id
 742 WHERE       is_reverse = 0 AND app1.app_id != app2.app_id
 743 UNION ALL
 744 SELECT      app2.name AS subject,
 745             app1.name AS object,
 746             p.access,
 747             app1.is_volatile OR app2.is_volatile AS is_volatile
 748 FROM        permission_permission_rule AS p
 749 INNER JOIN  app_label_with_permission_view AS app1 USING(permission_id)
 750 INNER JOIN  app_label_with_permission_view AS app2
 751             ON app2.permission_id = p.target_permission_id
 752 WHERE       is_reverse = 1 AND app1.app_id != app2.app_id;
 753
 754 -- PERMISSION TO LABEL RULE VIEW -----------------------------------------------
 755 -- ltl = label to label
 756 DROP VIEW IF EXISTS ltl_permission_label_rule_view;
 757 CREATE VIEW ltl_permission_label_rule_view AS
 758 SELECT      app.name AS subject,
 759             label.name AS object,
 760             p.access,
 761             app.is_volatile
 762 FROM        permission_label_rule AS p
 763 INNER JOIN  app_label_with_permission_view AS app USING(permission_id)
 764 INNER JOIN  label USING(label_id)
 765 WHERE       is_reverse = 0 AND app.name != label.name
 766 UNION ALL
 767 SELECT      label.name AS subject,
 768             app.name AS object,
 769             p.access,
 770             app.is_volatile
 771 FROM        permission_label_rule AS p
 772 INNER JOIN  app_label_with_permission_view AS app USING(permission_id)
 773 INNER JOIN  label USING(label_id)
 774 WHERE       is_reverse = 1 AND app.name != label.name;
 775
 776
 777
 778
 779 -- PERMISSION TO PATH TYPE RULE VIEW -------------------------------------------
 780 -- ltl = label to label
 781 DROP VIEW IF EXISTS ltl_permission_app_path_type_rule_view;
 782 CREATE VIEW ltl_permission_app_path_type_rule_view AS
 783 SELECT      app.name AS subject,
 784             label.name AS object,
 785             p.access,
 786             app.is_volatile
 787 FROM        permission_app_path_type_rule AS p
 788 INNER JOIN  app_label_with_permission_view AS app USING(permission_id)
 789 INNER JOIN  app_path USING(app_path_type_id)
 790 INNER JOIN  label USING(label_id)
 791 WHERE       is_reverse = 0 AND app.name != label.name
 792 UNION ALL
 793 SELECT      label.name AS subject,
 794             app.name AS object,
 795             p.access,
 796             app.is_volatile
 797 FROM        permission_app_path_type_rule AS p
 798 INNER JOIN  app_label_with_permission_view AS app USING(permission_id)
 799 INNER JOIN  app_path USING(app_path_type_id)
 800 INNER JOIN  label USING(label_id)
 801 WHERE       is_reverse = 1 AND app.name != label.name;
 802
 803
 804 -- LABEL TO PATH TYPE RULE VIEW -------------------------------------------
 805 -- ltl = label to label
 806 DROP VIEW IF EXISTS ltl_label_app_path_type_rule_view;
 807 CREATE VIEW ltl_label_app_path_type_rule_view AS
 808 SELECT      label.name AS subject,
 809             path_label.name AS object,
 810             l.access AS access,
 811             0 AS is_volatile
 812 FROM        label_app_path_type_rule AS l
 813 INNER JOIN  label USING(label_id)
 814 INNER JOIN  app_path USING(app_path_type_id)
 815 INNER JOIN  label AS path_label ON app_path.label_id = path_label.label_id
 816 WHERE       is_reverse = 0 AND path_label.name != label.name
 817 UNION ALL
 818 SELECT      path_label.name AS subject,
 819             label.name AS object,
 820             l.access AS access,
 821             0 AS is_volatile
 822 FROM        label_app_path_type_rule AS l
 823 INNER JOIN  label USING(label_id)
 824 INNER JOIN  app_path USING(app_path_type_id)
 825 INNER JOIN  label AS path_label ON app_path.label_id = path_label.label_id
 826 WHERE       is_reverse = 1 AND path_label.name != label.name;
 827
 828
 829 -- PERMISSION TO APPLICATION'S OWN PATHS ---------------------------------------
 830 -- ltl = label to label
 831 DROP VIEW IF EXISTS ltl_app_path_view;
 832 CREATE VIEW ltl_app_path_view AS
 833 SELECT      application_view.name   AS subject,
 834             label.name              AS object,
 835             app_path.access         AS access
 836 FROM        app_path
 837 INNER JOIN  application_view USING(app_id)
 838 INNER JOIN  label USING(label_id);
 839
 840
 841 -- PERMISSION FROM PATHS TO APPLICATIONS ---------------------------------------
 842 -- ltl = label to label
 843 DROP VIEW IF EXISTS ltl_app_path_reverse_view;
 844 CREATE VIEW ltl_app_path_reverse_view AS
 845 SELECT      label.name                AS subject,
 846             application_view.name     AS object,
 847             app_path.access_reverse   AS access
 848 FROM        app_path
 849 INNER JOIN  application_view USING(app_id)
 850 INNER JOIN  label USING(label_id)
 851 WHERE       app_path.access_reverse != 0 ;
 852
 853
 854 -- SMACK RULES VIEWS -----------------------------------------------------------
 855 DROP VIEW IF EXISTS all_smack_binary_rules_view;
 856 CREATE VIEW all_smack_binary_rules_view AS
 857 SELECT  subject,
 858         object,
 859         access,
 860         is_volatile
 861 FROM   (SELECT subject, object, access, is_volatile
 862         FROM   ltl_permission_permission_rule_view
 863         UNION ALL
 864         SELECT subject, object, access, is_volatile
 865         FROM   ltl_permission_label_rule_view
 866         UNION ALL
 867         SELECT subject, object, access, is_volatile
 868         FROM   ltl_permission_app_path_type_rule_view
 869         UNION ALL
 870         SELECT subject, object, access, is_volatile
 871         FROM   ltl_label_app_path_type_rule_view
 872         UNION ALL
 873         SELECT subject, object, access, 0
 874         FROM   ltl_app_path_view
 875         UNION ALL
 876         SELECT subject, object, access, 0
 877         FROM   ltl_app_path_reverse_view
 878        );
 879
 880 -- ALL INSERTED DATA VIEW ------------------------------------------------------
 881 -- This view is used to clear the database from inserted rules.
 882 -- We loose all information about installed applications
 883 -- and folders.
 884 DROP VIEW IF EXISTS all_inserted_data;
 885 CREATE VIEW all_inserted_data AS
 886 SELECT      *
 887 FROM        label;
 888
 889 DROP TRIGGER IF EXISTS all_inserted_data_delete_trigger;
 890 CREATE TRIGGER all_inserted_data_delete_trigger INSTEAD OF
 891 DELETE ON all_inserted_data
 892 BEGIN
 893     DELETE FROM permission_label_rule;
 894     DELETE FROM permission_permission_rule;
 895     DELETE FROM permission_app_path_type_rule;
 896
 897     DELETE FROM app_permission;
 898
 899     DELETE FROM permission;
 900     DELETE FROM permission_type;
 901
 902     DELETE FROM app_path;
 903     DELETE FROM app_path_type;
 904     DELETE FROM app;
 905
 906     DELETE FROM label;
 907 END;
 908
 909
 910
 911 -- SMACK RULES MODIFICATIONS VIEW ----------------------------------------------
 912 -- This definition is repeated during opening a connection with the database.
 913 -- Used to get all smack rules, even volatile.
 914 -- Ensure it's the same!
 915 CREATE TEMPORARY VIEW modified_smack_rules AS
 916 SELECT  subject, object,
 917         access_to_str(access_add) AS access_add,
 918         access_to_str(access_del) AS access_del
 919 FROM    (
 920         SELECT     subject, object,
 921                    s1.access & ~s2.access AS access_add,
 922                    s2.access & ~s1.access AS access_del
 923         FROM       current_smack_rule_modified AS s1
 924         INNER JOIN history_smack_rule_modified AS s2
 925                    USING (subject, object)
 926         WHERE      s1.access != s2.access
 927
 928         UNION
 929
 930         SELECT     subject, object,
 931                    s1.access AS access_add,
 932                    0 AS access_del
 933         FROM       current_smack_rule_modified AS s1
 934         LEFT JOIN  history_smack_rule_modified s2
 935                    USING (subject, object)
 936         WHERE      s2.subject IS NULL AND
 937                    s2.object  IS NULL
 938
 939         UNION
 940
 941         SELECT     subject, object,
 942                    0 AS access_add,
 943                    s1.access AS access_del
 944         FROM       history_smack_rule_modified s1
 945         LEFT JOIN  current_smack_rule_modified AS s2
 946                    USING (subject, object)
 947         WHERE      s2.subject IS NULL AND
 948                    s2.object  IS NULL
 949         )
 950 ORDER BY subject, object ASC;
 951
 952 COMMIT TRANSACTION;