common.h revision b22b8b9fd90eecfb7133e56b4e113595f09f4492
1/* 2 * security/tomoyo/common.h 3 * 4 * Header file for TOMOYO. 5 * 6 * Copyright (C) 2005-2010 NTT DATA CORPORATION 7 */ 8 9#ifndef _SECURITY_TOMOYO_COMMON_H 10#define _SECURITY_TOMOYO_COMMON_H 11 12#include <linux/ctype.h> 13#include <linux/string.h> 14#include <linux/mm.h> 15#include <linux/file.h> 16#include <linux/kmod.h> 17#include <linux/fs.h> 18#include <linux/sched.h> 19#include <linux/namei.h> 20#include <linux/mount.h> 21#include <linux/list.h> 22#include <linux/cred.h> 23#include <linux/poll.h> 24struct linux_binprm; 25 26/********** Constants definitions. **********/ 27 28/* 29 * TOMOYO uses this hash only when appending a string into the string 30 * table. Frequency of appending strings is very low. So we don't need 31 * large (e.g. 64k) hash size. 256 will be sufficient. 32 */ 33#define TOMOYO_HASH_BITS 8 34#define TOMOYO_MAX_HASH (1u<<TOMOYO_HASH_BITS) 35 36#define TOMOYO_EXEC_TMPSIZE 4096 37 38/* Profile number is an integer between 0 and 255. */ 39#define TOMOYO_MAX_PROFILES 256 40 41/* Group number is an integer between 0 and 255. */ 42#define TOMOYO_MAX_ACL_GROUPS 256 43 44/* Index numbers for operation mode. */ 45enum tomoyo_mode_index { 46 TOMOYO_CONFIG_DISABLED, 47 TOMOYO_CONFIG_LEARNING, 48 TOMOYO_CONFIG_PERMISSIVE, 49 TOMOYO_CONFIG_ENFORCING, 50 TOMOYO_CONFIG_MAX_MODE, 51 TOMOYO_CONFIG_WANT_REJECT_LOG = 64, 52 TOMOYO_CONFIG_WANT_GRANT_LOG = 128, 53 TOMOYO_CONFIG_USE_DEFAULT = 255, 54}; 55 56/* Index numbers for entry type. */ 57enum tomoyo_policy_id { 58 TOMOYO_ID_GROUP, 59 TOMOYO_ID_PATH_GROUP, 60 TOMOYO_ID_NUMBER_GROUP, 61 TOMOYO_ID_TRANSITION_CONTROL, 62 TOMOYO_ID_AGGREGATOR, 63 TOMOYO_ID_MANAGER, 64 TOMOYO_ID_NAME, 65 TOMOYO_ID_ACL, 66 TOMOYO_ID_DOMAIN, 67 TOMOYO_MAX_POLICY 68}; 69 70/* Index numbers for domain's attributes. */ 71enum tomoyo_domain_info_flags_index { 72 /* Quota warnning flag. */ 73 TOMOYO_DIF_QUOTA_WARNED, 74 /* 75 * This domain was unable to create a new domain at 76 * tomoyo_find_next_domain() because the name of the domain to be 77 * created was too long or it could not allocate memory. 78 * More than one process continued execve() without domain transition. 79 */ 80 TOMOYO_DIF_TRANSITION_FAILED, 81 TOMOYO_MAX_DOMAIN_INFO_FLAGS 82}; 83 84/* Index numbers for group entries. */ 85enum tomoyo_group_id { 86 TOMOYO_PATH_GROUP, 87 TOMOYO_NUMBER_GROUP, 88 TOMOYO_MAX_GROUP 89}; 90 91/* Index numbers for type of numeric values. */ 92enum tomoyo_value_type { 93 TOMOYO_VALUE_TYPE_INVALID, 94 TOMOYO_VALUE_TYPE_DECIMAL, 95 TOMOYO_VALUE_TYPE_OCTAL, 96 TOMOYO_VALUE_TYPE_HEXADECIMAL, 97}; 98 99/* Index numbers for domain transition control keywords. */ 100enum tomoyo_transition_type { 101 /* Do not change this order, */ 102 TOMOYO_TRANSITION_CONTROL_NO_RESET, 103 TOMOYO_TRANSITION_CONTROL_RESET, 104 TOMOYO_TRANSITION_CONTROL_NO_INITIALIZE, 105 TOMOYO_TRANSITION_CONTROL_INITIALIZE, 106 TOMOYO_TRANSITION_CONTROL_NO_KEEP, 107 TOMOYO_TRANSITION_CONTROL_KEEP, 108 TOMOYO_MAX_TRANSITION_TYPE 109}; 110 111/* Index numbers for Access Controls. */ 112enum tomoyo_acl_entry_type_index { 113 TOMOYO_TYPE_PATH_ACL, 114 TOMOYO_TYPE_PATH2_ACL, 115 TOMOYO_TYPE_PATH_NUMBER_ACL, 116 TOMOYO_TYPE_MKDEV_ACL, 117 TOMOYO_TYPE_MOUNT_ACL, 118}; 119 120/* Index numbers for access controls with one pathname. */ 121enum tomoyo_path_acl_index { 122 TOMOYO_TYPE_EXECUTE, 123 TOMOYO_TYPE_READ, 124 TOMOYO_TYPE_WRITE, 125 TOMOYO_TYPE_APPEND, 126 TOMOYO_TYPE_UNLINK, 127 TOMOYO_TYPE_GETATTR, 128 TOMOYO_TYPE_RMDIR, 129 TOMOYO_TYPE_TRUNCATE, 130 TOMOYO_TYPE_SYMLINK, 131 TOMOYO_TYPE_CHROOT, 132 TOMOYO_TYPE_UMOUNT, 133 TOMOYO_MAX_PATH_OPERATION 134}; 135 136/* Index numbers for /sys/kernel/security/tomoyo/stat interface. */ 137enum tomoyo_memory_stat_type { 138 TOMOYO_MEMORY_POLICY, 139 TOMOYO_MEMORY_AUDIT, 140 TOMOYO_MEMORY_QUERY, 141 TOMOYO_MAX_MEMORY_STAT 142}; 143 144enum tomoyo_mkdev_acl_index { 145 TOMOYO_TYPE_MKBLOCK, 146 TOMOYO_TYPE_MKCHAR, 147 TOMOYO_MAX_MKDEV_OPERATION 148}; 149 150/* Index numbers for access controls with two pathnames. */ 151enum tomoyo_path2_acl_index { 152 TOMOYO_TYPE_LINK, 153 TOMOYO_TYPE_RENAME, 154 TOMOYO_TYPE_PIVOT_ROOT, 155 TOMOYO_MAX_PATH2_OPERATION 156}; 157 158/* Index numbers for access controls with one pathname and one number. */ 159enum tomoyo_path_number_acl_index { 160 TOMOYO_TYPE_CREATE, 161 TOMOYO_TYPE_MKDIR, 162 TOMOYO_TYPE_MKFIFO, 163 TOMOYO_TYPE_MKSOCK, 164 TOMOYO_TYPE_IOCTL, 165 TOMOYO_TYPE_CHMOD, 166 TOMOYO_TYPE_CHOWN, 167 TOMOYO_TYPE_CHGRP, 168 TOMOYO_MAX_PATH_NUMBER_OPERATION 169}; 170 171/* Index numbers for /sys/kernel/security/tomoyo/ interfaces. */ 172enum tomoyo_securityfs_interface_index { 173 TOMOYO_DOMAINPOLICY, 174 TOMOYO_EXCEPTIONPOLICY, 175 TOMOYO_DOMAIN_STATUS, 176 TOMOYO_PROCESS_STATUS, 177 TOMOYO_STAT, 178 TOMOYO_SELFDOMAIN, 179 TOMOYO_AUDIT, 180 TOMOYO_VERSION, 181 TOMOYO_PROFILE, 182 TOMOYO_QUERY, 183 TOMOYO_MANAGER 184}; 185 186/* Index numbers for special mount operations. */ 187enum tomoyo_special_mount { 188 TOMOYO_MOUNT_BIND, /* mount --bind /source /dest */ 189 TOMOYO_MOUNT_MOVE, /* mount --move /old /new */ 190 TOMOYO_MOUNT_REMOUNT, /* mount -o remount /dir */ 191 TOMOYO_MOUNT_MAKE_UNBINDABLE, /* mount --make-unbindable /dir */ 192 TOMOYO_MOUNT_MAKE_PRIVATE, /* mount --make-private /dir */ 193 TOMOYO_MOUNT_MAKE_SLAVE, /* mount --make-slave /dir */ 194 TOMOYO_MOUNT_MAKE_SHARED, /* mount --make-shared /dir */ 195 TOMOYO_MAX_SPECIAL_MOUNT 196}; 197 198/* Index numbers for functionality. */ 199enum tomoyo_mac_index { 200 TOMOYO_MAC_FILE_EXECUTE, 201 TOMOYO_MAC_FILE_OPEN, 202 TOMOYO_MAC_FILE_CREATE, 203 TOMOYO_MAC_FILE_UNLINK, 204 TOMOYO_MAC_FILE_GETATTR, 205 TOMOYO_MAC_FILE_MKDIR, 206 TOMOYO_MAC_FILE_RMDIR, 207 TOMOYO_MAC_FILE_MKFIFO, 208 TOMOYO_MAC_FILE_MKSOCK, 209 TOMOYO_MAC_FILE_TRUNCATE, 210 TOMOYO_MAC_FILE_SYMLINK, 211 TOMOYO_MAC_FILE_MKBLOCK, 212 TOMOYO_MAC_FILE_MKCHAR, 213 TOMOYO_MAC_FILE_LINK, 214 TOMOYO_MAC_FILE_RENAME, 215 TOMOYO_MAC_FILE_CHMOD, 216 TOMOYO_MAC_FILE_CHOWN, 217 TOMOYO_MAC_FILE_CHGRP, 218 TOMOYO_MAC_FILE_IOCTL, 219 TOMOYO_MAC_FILE_CHROOT, 220 TOMOYO_MAC_FILE_MOUNT, 221 TOMOYO_MAC_FILE_UMOUNT, 222 TOMOYO_MAC_FILE_PIVOT_ROOT, 223 TOMOYO_MAX_MAC_INDEX 224}; 225 226/* Index numbers for category of functionality. */ 227enum tomoyo_mac_category_index { 228 TOMOYO_MAC_CATEGORY_FILE, 229 TOMOYO_MAX_MAC_CATEGORY_INDEX 230}; 231 232/* 233 * Retry this request. Returned by tomoyo_supervisor() if policy violation has 234 * occurred in enforcing mode and the userspace daemon decided to retry. 235 * 236 * We must choose a positive value in order to distinguish "granted" (which is 237 * 0) and "rejected" (which is a negative value) and "retry". 238 */ 239#define TOMOYO_RETRY_REQUEST 1 240 241/* Index numbers for /sys/kernel/security/tomoyo/stat interface. */ 242enum tomoyo_policy_stat_type { 243 /* Do not change this order. */ 244 TOMOYO_STAT_POLICY_UPDATES, 245 TOMOYO_STAT_POLICY_LEARNING, /* == TOMOYO_CONFIG_LEARNING */ 246 TOMOYO_STAT_POLICY_PERMISSIVE, /* == TOMOYO_CONFIG_PERMISSIVE */ 247 TOMOYO_STAT_POLICY_ENFORCING, /* == TOMOYO_CONFIG_ENFORCING */ 248 TOMOYO_MAX_POLICY_STAT 249}; 250 251/* Index numbers for profile's PREFERENCE values. */ 252enum tomoyo_pref_index { 253 TOMOYO_PREF_MAX_AUDIT_LOG, 254 TOMOYO_PREF_MAX_LEARNING_ENTRY, 255 TOMOYO_MAX_PREF 256}; 257 258/********** Structure definitions. **********/ 259 260/* Common header for holding ACL entries. */ 261struct tomoyo_acl_head { 262 struct list_head list; 263 bool is_deleted; 264} __packed; 265 266/* Common header for shared entries. */ 267struct tomoyo_shared_acl_head { 268 struct list_head list; 269 atomic_t users; 270} __packed; 271 272struct tomoyo_policy_namespace; 273 274/* Structure for request info. */ 275struct tomoyo_request_info { 276 struct tomoyo_domain_info *domain; 277 /* For holding parameters. */ 278 union { 279 struct { 280 const struct tomoyo_path_info *filename; 281 /* For using wildcards at tomoyo_find_next_domain(). */ 282 const struct tomoyo_path_info *matched_path; 283 /* One of values in "enum tomoyo_path_acl_index". */ 284 u8 operation; 285 } path; 286 struct { 287 const struct tomoyo_path_info *filename1; 288 const struct tomoyo_path_info *filename2; 289 /* One of values in "enum tomoyo_path2_acl_index". */ 290 u8 operation; 291 } path2; 292 struct { 293 const struct tomoyo_path_info *filename; 294 unsigned int mode; 295 unsigned int major; 296 unsigned int minor; 297 /* One of values in "enum tomoyo_mkdev_acl_index". */ 298 u8 operation; 299 } mkdev; 300 struct { 301 const struct tomoyo_path_info *filename; 302 unsigned long number; 303 /* 304 * One of values in 305 * "enum tomoyo_path_number_acl_index". 306 */ 307 u8 operation; 308 } path_number; 309 struct { 310 const struct tomoyo_path_info *type; 311 const struct tomoyo_path_info *dir; 312 const struct tomoyo_path_info *dev; 313 unsigned long flags; 314 int need_dev; 315 } mount; 316 } param; 317 u8 param_type; 318 bool granted; 319 u8 retry; 320 u8 profile; 321 u8 mode; /* One of tomoyo_mode_index . */ 322 u8 type; 323}; 324 325/* Structure for holding a token. */ 326struct tomoyo_path_info { 327 const char *name; 328 u32 hash; /* = full_name_hash(name, strlen(name)) */ 329 u16 const_len; /* = tomoyo_const_part_length(name) */ 330 bool is_dir; /* = tomoyo_strendswith(name, "/") */ 331 bool is_patterned; /* = tomoyo_path_contains_pattern(name) */ 332}; 333 334/* Structure for holding string data. */ 335struct tomoyo_name { 336 struct tomoyo_shared_acl_head head; 337 struct tomoyo_path_info entry; 338}; 339 340/* Structure for holding a word. */ 341struct tomoyo_name_union { 342 /* Either @filename or @group is NULL. */ 343 const struct tomoyo_path_info *filename; 344 struct tomoyo_group *group; 345}; 346 347/* Structure for holding a number. */ 348struct tomoyo_number_union { 349 unsigned long values[2]; 350 struct tomoyo_group *group; /* Maybe NULL. */ 351 /* One of values in "enum tomoyo_value_type". */ 352 u8 value_type[2]; 353}; 354 355/* Structure for "path_group"/"number_group" directive. */ 356struct tomoyo_group { 357 struct tomoyo_shared_acl_head head; 358 const struct tomoyo_path_info *group_name; 359 struct list_head member_list; 360}; 361 362/* Structure for "path_group" directive. */ 363struct tomoyo_path_group { 364 struct tomoyo_acl_head head; 365 const struct tomoyo_path_info *member_name; 366}; 367 368/* Structure for "number_group" directive. */ 369struct tomoyo_number_group { 370 struct tomoyo_acl_head head; 371 struct tomoyo_number_union number; 372}; 373 374/* Common header for individual entries. */ 375struct tomoyo_acl_info { 376 struct list_head list; 377 bool is_deleted; 378 u8 type; /* One of values in "enum tomoyo_acl_entry_type_index". */ 379} __packed; 380 381/* Structure for domain information. */ 382struct tomoyo_domain_info { 383 struct list_head list; 384 struct list_head acl_info_list; 385 /* Name of this domain. Never NULL. */ 386 const struct tomoyo_path_info *domainname; 387 /* Namespace for this domain. Never NULL. */ 388 struct tomoyo_policy_namespace *ns; 389 u8 profile; /* Profile number to use. */ 390 u8 group; /* Group number to use. */ 391 bool is_deleted; /* Delete flag. */ 392 bool flags[TOMOYO_MAX_DOMAIN_INFO_FLAGS]; 393 atomic_t users; /* Number of referring credentials. */ 394}; 395 396/* 397 * Structure for "file execute", "file read", "file write", "file append", 398 * "file unlink", "file getattr", "file rmdir", "file truncate", 399 * "file symlink", "file chroot" and "file unmount" directive. 400 */ 401struct tomoyo_path_acl { 402 struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_ACL */ 403 u16 perm; /* Bitmask of values in "enum tomoyo_path_acl_index". */ 404 struct tomoyo_name_union name; 405}; 406 407/* 408 * Structure for "file create", "file mkdir", "file mkfifo", "file mksock", 409 * "file ioctl", "file chmod", "file chown" and "file chgrp" directive. 410 */ 411struct tomoyo_path_number_acl { 412 struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_NUMBER_ACL */ 413 /* Bitmask of values in "enum tomoyo_path_number_acl_index". */ 414 u8 perm; 415 struct tomoyo_name_union name; 416 struct tomoyo_number_union number; 417}; 418 419/* Structure for "file mkblock" and "file mkchar" directive. */ 420struct tomoyo_mkdev_acl { 421 struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_MKDEV_ACL */ 422 u8 perm; /* Bitmask of values in "enum tomoyo_mkdev_acl_index". */ 423 struct tomoyo_name_union name; 424 struct tomoyo_number_union mode; 425 struct tomoyo_number_union major; 426 struct tomoyo_number_union minor; 427}; 428 429/* 430 * Structure for "file rename", "file link" and "file pivot_root" directive. 431 */ 432struct tomoyo_path2_acl { 433 struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH2_ACL */ 434 u8 perm; /* Bitmask of values in "enum tomoyo_path2_acl_index". */ 435 struct tomoyo_name_union name1; 436 struct tomoyo_name_union name2; 437}; 438 439/* Structure for "file mount" directive. */ 440struct tomoyo_mount_acl { 441 struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_MOUNT_ACL */ 442 struct tomoyo_name_union dev_name; 443 struct tomoyo_name_union dir_name; 444 struct tomoyo_name_union fs_type; 445 struct tomoyo_number_union flags; 446}; 447 448/* Structure for holding a line from /sys/kernel/security/tomoyo/ interface. */ 449struct tomoyo_acl_param { 450 char *data; 451 struct list_head *list; 452 struct tomoyo_policy_namespace *ns; 453 bool is_delete; 454}; 455 456#define TOMOYO_MAX_IO_READ_QUEUE 64 457 458/* 459 * Structure for reading/writing policy via /sys/kernel/security/tomoyo 460 * interfaces. 461 */ 462struct tomoyo_io_buffer { 463 void (*read) (struct tomoyo_io_buffer *); 464 int (*write) (struct tomoyo_io_buffer *); 465 int (*poll) (struct file *file, poll_table *wait); 466 /* Exclusive lock for this structure. */ 467 struct mutex io_sem; 468 char __user *read_user_buf; 469 size_t read_user_buf_avail; 470 struct { 471 struct list_head *ns; 472 struct list_head *domain; 473 struct list_head *group; 474 struct list_head *acl; 475 size_t avail; 476 unsigned int step; 477 unsigned int query_index; 478 u16 index; 479 u8 acl_group_index; 480 u8 bit; 481 u8 w_pos; 482 bool eof; 483 bool print_this_domain_only; 484 bool print_transition_related_only; 485 const char *w[TOMOYO_MAX_IO_READ_QUEUE]; 486 } r; 487 struct { 488 struct tomoyo_policy_namespace *ns; 489 /* The position currently writing to. */ 490 struct tomoyo_domain_info *domain; 491 /* Bytes available for writing. */ 492 size_t avail; 493 bool is_delete; 494 } w; 495 /* Buffer for reading. */ 496 char *read_buf; 497 /* Size of read buffer. */ 498 size_t readbuf_size; 499 /* Buffer for writing. */ 500 char *write_buf; 501 /* Size of write buffer. */ 502 size_t writebuf_size; 503 /* Type of this interface. */ 504 enum tomoyo_securityfs_interface_index type; 505 /* Users counter protected by tomoyo_io_buffer_list_lock. */ 506 u8 users; 507 /* List for telling GC not to kfree() elements. */ 508 struct list_head list; 509}; 510 511/* 512 * Structure for "initialize_domain"/"no_initialize_domain"/"keep_domain"/ 513 * "no_keep_domain" keyword. 514 */ 515struct tomoyo_transition_control { 516 struct tomoyo_acl_head head; 517 u8 type; /* One of values in "enum tomoyo_transition_type". */ 518 /* True if the domainname is tomoyo_get_last_name(). */ 519 bool is_last_name; 520 const struct tomoyo_path_info *domainname; /* Maybe NULL */ 521 const struct tomoyo_path_info *program; /* Maybe NULL */ 522}; 523 524/* Structure for "aggregator" keyword. */ 525struct tomoyo_aggregator { 526 struct tomoyo_acl_head head; 527 const struct tomoyo_path_info *original_name; 528 const struct tomoyo_path_info *aggregated_name; 529}; 530 531/* Structure for policy manager. */ 532struct tomoyo_manager { 533 struct tomoyo_acl_head head; 534 bool is_domain; /* True if manager is a domainname. */ 535 /* A path to program or a domainname. */ 536 const struct tomoyo_path_info *manager; 537}; 538 539struct tomoyo_preference { 540 unsigned int learning_max_entry; 541 bool enforcing_verbose; 542 bool learning_verbose; 543 bool permissive_verbose; 544}; 545 546/* Structure for /sys/kernel/security/tomnoyo/profile interface. */ 547struct tomoyo_profile { 548 const struct tomoyo_path_info *comment; 549 struct tomoyo_preference *learning; 550 struct tomoyo_preference *permissive; 551 struct tomoyo_preference *enforcing; 552 struct tomoyo_preference preference; 553 u8 default_config; 554 u8 config[TOMOYO_MAX_MAC_INDEX + TOMOYO_MAX_MAC_CATEGORY_INDEX]; 555 unsigned int pref[TOMOYO_MAX_PREF]; 556}; 557 558/* Structure for representing YYYY/MM/DD hh/mm/ss. */ 559struct tomoyo_time { 560 u16 year; 561 u8 month; 562 u8 day; 563 u8 hour; 564 u8 min; 565 u8 sec; 566}; 567 568/* Structure for policy namespace. */ 569struct tomoyo_policy_namespace { 570 /* Profile table. Memory is allocated as needed. */ 571 struct tomoyo_profile *profile_ptr[TOMOYO_MAX_PROFILES]; 572 /* List of "struct tomoyo_group". */ 573 struct list_head group_list[TOMOYO_MAX_GROUP]; 574 /* List of policy. */ 575 struct list_head policy_list[TOMOYO_MAX_POLICY]; 576 /* The global ACL referred by "use_group" keyword. */ 577 struct list_head acl_group[TOMOYO_MAX_ACL_GROUPS]; 578 /* List for connecting to tomoyo_namespace_list list. */ 579 struct list_head namespace_list; 580 /* Profile version. Currently only 20100903 is defined. */ 581 unsigned int profile_version; 582 /* Name of this namespace (e.g. "<kernel>", "</usr/sbin/httpd>" ). */ 583 const char *name; 584}; 585 586/********** Function prototypes. **********/ 587 588void tomoyo_init_policy_namespace(struct tomoyo_policy_namespace *ns); 589bool tomoyo_str_starts(char **src, const char *find); 590const char *tomoyo_get_exe(void); 591void tomoyo_normalize_line(unsigned char *buffer); 592void tomoyo_check_profile(void); 593int tomoyo_open_control(const u8 type, struct file *file); 594int tomoyo_close_control(struct tomoyo_io_buffer *head); 595int tomoyo_poll_control(struct file *file, poll_table *wait); 596ssize_t tomoyo_read_control(struct tomoyo_io_buffer *head, char __user *buffer, 597 const int buffer_len); 598ssize_t tomoyo_write_control(struct tomoyo_io_buffer *head, 599 const char __user *buffer, const int buffer_len); 600bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r); 601void tomoyo_warn_oom(const char *function); 602const struct tomoyo_path_info * 603tomoyo_compare_name_union(const struct tomoyo_path_info *name, 604 const struct tomoyo_name_union *ptr); 605bool tomoyo_compare_number_union(const unsigned long value, 606 const struct tomoyo_number_union *ptr); 607int tomoyo_get_mode(const struct tomoyo_policy_namespace *ns, const u8 profile, 608 const u8 index); 609void tomoyo_io_printf(struct tomoyo_io_buffer *head, const char *fmt, ...) 610 __attribute__ ((format(printf, 2, 3))); 611bool tomoyo_correct_domain(const unsigned char *domainname); 612bool tomoyo_correct_path(const char *filename); 613bool tomoyo_correct_word(const char *string); 614bool tomoyo_domain_def(const unsigned char *buffer); 615bool tomoyo_parse_name_union(struct tomoyo_acl_param *param, 616 struct tomoyo_name_union *ptr); 617const struct tomoyo_path_info * 618tomoyo_path_matches_group(const struct tomoyo_path_info *pathname, 619 const struct tomoyo_group *group); 620bool tomoyo_number_matches_group(const unsigned long min, 621 const unsigned long max, 622 const struct tomoyo_group *group); 623bool tomoyo_path_matches_pattern(const struct tomoyo_path_info *filename, 624 const struct tomoyo_path_info *pattern); 625bool tomoyo_parse_number_union(struct tomoyo_acl_param *param, 626 struct tomoyo_number_union *ptr); 627bool tomoyo_tokenize(char *buffer, char *w[], size_t size); 628bool tomoyo_verbose_mode(const struct tomoyo_domain_info *domain); 629int tomoyo_init_request_info(struct tomoyo_request_info *r, 630 struct tomoyo_domain_info *domain, 631 const u8 index); 632int tomoyo_mount_permission(char *dev_name, struct path *path, 633 const char *type, unsigned long flags, 634 void *data_page); 635int tomoyo_write_aggregator(struct tomoyo_acl_param *param); 636int tomoyo_write_transition_control(struct tomoyo_acl_param *param, 637 const u8 type); 638int tomoyo_write_file(struct tomoyo_acl_param *param); 639int tomoyo_write_group(struct tomoyo_acl_param *param, const u8 type); 640int tomoyo_supervisor(struct tomoyo_request_info *r, const char *fmt, ...) 641 __attribute__ ((format(printf, 2, 3))); 642struct tomoyo_domain_info *tomoyo_find_domain(const char *domainname); 643struct tomoyo_domain_info *tomoyo_assign_domain(const char *domainname, 644 const bool transit); 645struct tomoyo_profile *tomoyo_profile(const struct tomoyo_policy_namespace *ns, 646 const u8 profile); 647struct tomoyo_policy_namespace *tomoyo_assign_namespace 648(const char *domainname); 649struct tomoyo_group *tomoyo_get_group(struct tomoyo_acl_param *param, 650 const u8 idx); 651unsigned int tomoyo_check_flags(const struct tomoyo_domain_info *domain, 652 const u8 index); 653void tomoyo_fill_path_info(struct tomoyo_path_info *ptr); 654void tomoyo_load_policy(const char *filename); 655void tomoyo_put_number_union(struct tomoyo_number_union *ptr); 656char *tomoyo_encode(const char *str); 657char *tomoyo_realpath_nofollow(const char *pathname); 658char *tomoyo_realpath_from_path(struct path *path); 659bool tomoyo_memory_ok(void *ptr); 660void *tomoyo_commit_ok(void *data, const unsigned int size); 661const struct tomoyo_path_info *tomoyo_get_name(const char *name); 662void tomoyo_convert_time(time_t time, struct tomoyo_time *stamp); 663void tomoyo_update_stat(const u8 index); 664void __init tomoyo_mm_init(void); 665int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation, 666 const struct tomoyo_path_info *filename); 667int tomoyo_check_open_permission(struct tomoyo_domain_info *domain, 668 struct path *path, const int flag); 669int tomoyo_path_number_perm(const u8 operation, struct path *path, 670 unsigned long number); 671int tomoyo_mkdev_perm(const u8 operation, struct path *path, 672 const unsigned int mode, unsigned int dev); 673int tomoyo_path_perm(const u8 operation, struct path *path); 674int tomoyo_path2_perm(const u8 operation, struct path *path1, 675 struct path *path2); 676int tomoyo_find_next_domain(struct linux_binprm *bprm); 677void tomoyo_print_ulong(char *buffer, const int buffer_len, 678 const unsigned long value, const u8 type); 679void tomoyo_put_name_union(struct tomoyo_name_union *ptr); 680void tomoyo_notify_gc(struct tomoyo_io_buffer *head, const bool is_register); 681void tomoyo_memory_free(void *ptr); 682int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size, 683 struct tomoyo_acl_param *param, 684 bool (*check_duplicate) (const struct tomoyo_acl_info 685 *, 686 const struct tomoyo_acl_info 687 *), 688 bool (*merge_duplicate) (struct tomoyo_acl_info *, 689 struct tomoyo_acl_info *, 690 const bool)); 691int tomoyo_update_policy(struct tomoyo_acl_head *new_entry, const int size, 692 struct tomoyo_acl_param *param, 693 bool (*check_duplicate) (const struct tomoyo_acl_head 694 *, 695 const struct tomoyo_acl_head 696 *)); 697void tomoyo_check_acl(struct tomoyo_request_info *r, 698 bool (*check_entry) (struct tomoyo_request_info *, 699 const struct tomoyo_acl_info *)); 700char *tomoyo_read_token(struct tomoyo_acl_param *param); 701bool tomoyo_permstr(const char *string, const char *keyword); 702 703const char *tomoyo_yesno(const unsigned int value); 704void tomoyo_write_log(struct tomoyo_request_info *r, const char *fmt, ...) 705 __attribute__ ((format(printf, 2, 3))); 706void tomoyo_write_log2(struct tomoyo_request_info *r, int len, const char *fmt, 707 va_list args); 708void tomoyo_read_log(struct tomoyo_io_buffer *head); 709int tomoyo_poll_log(struct file *file, poll_table *wait); 710char *tomoyo_init_log(struct tomoyo_request_info *r, int len, const char *fmt, 711 va_list args); 712 713/********** External variable definitions. **********/ 714 715/* Lock for GC. */ 716extern struct srcu_struct tomoyo_ss; 717 718/* The list for "struct tomoyo_domain_info". */ 719extern struct list_head tomoyo_domain_list; 720 721extern struct list_head tomoyo_name_list[TOMOYO_MAX_HASH]; 722 723/* Lock for protecting policy. */ 724extern struct mutex tomoyo_policy_lock; 725 726/* Has /sbin/init started? */ 727extern bool tomoyo_policy_loaded; 728 729/* The kernel's domain. */ 730extern struct tomoyo_domain_info tomoyo_kernel_domain; 731extern struct tomoyo_policy_namespace tomoyo_kernel_namespace; 732extern struct list_head tomoyo_namespace_list; 733 734extern const char * const tomoyo_mac_keywords[TOMOYO_MAX_MAC_INDEX + 735 TOMOYO_MAX_MAC_CATEGORY_INDEX]; 736extern const char * const tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION]; 737extern const u8 tomoyo_index2category[TOMOYO_MAX_MAC_INDEX]; 738 739 740extern const u8 tomoyo_pnnn2mac[TOMOYO_MAX_MKDEV_OPERATION]; 741extern const u8 tomoyo_pp2mac[TOMOYO_MAX_PATH2_OPERATION]; 742extern const u8 tomoyo_pn2mac[TOMOYO_MAX_PATH_NUMBER_OPERATION]; 743 744extern const char * const tomoyo_dif[TOMOYO_MAX_DOMAIN_INFO_FLAGS]; 745extern const char * const tomoyo_mode[TOMOYO_CONFIG_MAX_MODE]; 746extern unsigned int tomoyo_memory_quota[TOMOYO_MAX_MEMORY_STAT]; 747extern unsigned int tomoyo_memory_used[TOMOYO_MAX_MEMORY_STAT]; 748 749/********** Inlined functions. **********/ 750 751/** 752 * tomoyo_read_lock - Take lock for protecting policy. 753 * 754 * Returns index number for tomoyo_read_unlock(). 755 */ 756static inline int tomoyo_read_lock(void) 757{ 758 return srcu_read_lock(&tomoyo_ss); 759} 760 761/** 762 * tomoyo_read_unlock - Release lock for protecting policy. 763 * 764 * @idx: Index number returned by tomoyo_read_lock(). 765 * 766 * Returns nothing. 767 */ 768static inline void tomoyo_read_unlock(int idx) 769{ 770 srcu_read_unlock(&tomoyo_ss, idx); 771} 772 773/** 774 * tomoyo_pathcmp - strcmp() for "struct tomoyo_path_info" structure. 775 * 776 * @a: Pointer to "struct tomoyo_path_info". 777 * @b: Pointer to "struct tomoyo_path_info". 778 * 779 * Returns true if @a == @b, false otherwise. 780 */ 781static inline bool tomoyo_pathcmp(const struct tomoyo_path_info *a, 782 const struct tomoyo_path_info *b) 783{ 784 return a->hash != b->hash || strcmp(a->name, b->name); 785} 786 787/** 788 * tomoyo_put_name - Drop reference on "struct tomoyo_name". 789 * 790 * @name: Pointer to "struct tomoyo_path_info". Maybe NULL. 791 * 792 * Returns nothing. 793 */ 794static inline void tomoyo_put_name(const struct tomoyo_path_info *name) 795{ 796 if (name) { 797 struct tomoyo_name *ptr = 798 container_of(name, typeof(*ptr), entry); 799 atomic_dec(&ptr->head.users); 800 } 801} 802 803/** 804 * tomoyo_put_group - Drop reference on "struct tomoyo_group". 805 * 806 * @group: Pointer to "struct tomoyo_group". Maybe NULL. 807 * 808 * Returns nothing. 809 */ 810static inline void tomoyo_put_group(struct tomoyo_group *group) 811{ 812 if (group) 813 atomic_dec(&group->head.users); 814} 815 816/** 817 * tomoyo_domain - Get "struct tomoyo_domain_info" for current thread. 818 * 819 * Returns pointer to "struct tomoyo_domain_info" for current thread. 820 */ 821static inline struct tomoyo_domain_info *tomoyo_domain(void) 822{ 823 return current_cred()->security; 824} 825 826/** 827 * tomoyo_real_domain - Get "struct tomoyo_domain_info" for specified thread. 828 * 829 * @task: Pointer to "struct task_struct". 830 * 831 * Returns pointer to "struct tomoyo_security" for specified thread. 832 */ 833static inline struct tomoyo_domain_info *tomoyo_real_domain(struct task_struct 834 *task) 835{ 836 return task_cred_xxx(task, security); 837} 838 839/** 840 * tomoyo_same_name_union - Check for duplicated "struct tomoyo_name_union" entry. 841 * 842 * @a: Pointer to "struct tomoyo_name_union". 843 * @b: Pointer to "struct tomoyo_name_union". 844 * 845 * Returns true if @a == @b, false otherwise. 846 */ 847static inline bool tomoyo_same_name_union 848(const struct tomoyo_name_union *a, const struct tomoyo_name_union *b) 849{ 850 return a->filename == b->filename && a->group == b->group; 851} 852 853/** 854 * tomoyo_same_number_union - Check for duplicated "struct tomoyo_number_union" entry. 855 * 856 * @a: Pointer to "struct tomoyo_number_union". 857 * @b: Pointer to "struct tomoyo_number_union". 858 * 859 * Returns true if @a == @b, false otherwise. 860 */ 861static inline bool tomoyo_same_number_union 862(const struct tomoyo_number_union *a, const struct tomoyo_number_union *b) 863{ 864 return a->values[0] == b->values[0] && a->values[1] == b->values[1] && 865 a->group == b->group && a->value_type[0] == b->value_type[0] && 866 a->value_type[1] == b->value_type[1]; 867} 868 869/** 870 * tomoyo_current_namespace - Get "struct tomoyo_policy_namespace" for current thread. 871 * 872 * Returns pointer to "struct tomoyo_policy_namespace" for current thread. 873 */ 874static inline struct tomoyo_policy_namespace *tomoyo_current_namespace(void) 875{ 876 return tomoyo_domain()->ns; 877} 878 879#if defined(CONFIG_SLOB) 880 881/** 882 * tomoyo_round2 - Round up to power of 2 for calculating memory usage. 883 * 884 * @size: Size to be rounded up. 885 * 886 * Returns @size. 887 * 888 * Since SLOB does not round up, this function simply returns @size. 889 */ 890static inline int tomoyo_round2(size_t size) 891{ 892 return size; 893} 894 895#else 896 897/** 898 * tomoyo_round2 - Round up to power of 2 for calculating memory usage. 899 * 900 * @size: Size to be rounded up. 901 * 902 * Returns rounded size. 903 * 904 * Strictly speaking, SLAB may be able to allocate (e.g.) 96 bytes instead of 905 * (e.g.) 128 bytes. 906 */ 907static inline int tomoyo_round2(size_t size) 908{ 909#if PAGE_SIZE == 4096 910 size_t bsize = 32; 911#else 912 size_t bsize = 64; 913#endif 914 if (!size) 915 return 0; 916 while (size > bsize) 917 bsize <<= 1; 918 return bsize; 919} 920 921#endif 922 923/** 924 * list_for_each_cookie - iterate over a list with cookie. 925 * @pos: the &struct list_head to use as a loop cursor. 926 * @head: the head for your list. 927 */ 928#define list_for_each_cookie(pos, head) \ 929 if (!pos) \ 930 pos = srcu_dereference((head)->next, &tomoyo_ss); \ 931 for ( ; pos != (head); pos = srcu_dereference(pos->next, &tomoyo_ss)) 932 933#endif /* !defined(_SECURITY_TOMOYO_COMMON_H) */ 934