1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * security/tomoyo/file.c
   4 *
   5 * Copyright (C) 2005-2011  NTT DATA CORPORATION
   6 */
   7
   8#include "common.h"
   9#include <linux/slab.h>
  10
  11/*
  12 * Mapping table from "enum tomoyo_path_acl_index" to "enum tomoyo_mac_index".
  13 */
  14static const u8 tomoyo_p2mac[TOMOYO_MAX_PATH_OPERATION] = {
  15	[TOMOYO_TYPE_EXECUTE]    = TOMOYO_MAC_FILE_EXECUTE,
  16	[TOMOYO_TYPE_READ]       = TOMOYO_MAC_FILE_OPEN,
  17	[TOMOYO_TYPE_WRITE]      = TOMOYO_MAC_FILE_OPEN,
  18	[TOMOYO_TYPE_APPEND]     = TOMOYO_MAC_FILE_OPEN,
  19	[TOMOYO_TYPE_UNLINK]     = TOMOYO_MAC_FILE_UNLINK,
  20	[TOMOYO_TYPE_GETATTR]    = TOMOYO_MAC_FILE_GETATTR,
  21	[TOMOYO_TYPE_RMDIR]      = TOMOYO_MAC_FILE_RMDIR,
  22	[TOMOYO_TYPE_TRUNCATE]   = TOMOYO_MAC_FILE_TRUNCATE,
  23	[TOMOYO_TYPE_SYMLINK]    = TOMOYO_MAC_FILE_SYMLINK,
  24	[TOMOYO_TYPE_CHROOT]     = TOMOYO_MAC_FILE_CHROOT,
  25	[TOMOYO_TYPE_UMOUNT]     = TOMOYO_MAC_FILE_UMOUNT,
  26};
  27
  28/*
  29 * Mapping table from "enum tomoyo_mkdev_acl_index" to "enum tomoyo_mac_index".
  30 */
  31const u8 tomoyo_pnnn2mac[TOMOYO_MAX_MKDEV_OPERATION] = {
  32	[TOMOYO_TYPE_MKBLOCK] = TOMOYO_MAC_FILE_MKBLOCK,
  33	[TOMOYO_TYPE_MKCHAR]  = TOMOYO_MAC_FILE_MKCHAR,
  34};
  35
  36/*
  37 * Mapping table from "enum tomoyo_path2_acl_index" to "enum tomoyo_mac_index".
  38 */
  39const u8 tomoyo_pp2mac[TOMOYO_MAX_PATH2_OPERATION] = {
  40	[TOMOYO_TYPE_LINK]       = TOMOYO_MAC_FILE_LINK,
  41	[TOMOYO_TYPE_RENAME]     = TOMOYO_MAC_FILE_RENAME,
  42	[TOMOYO_TYPE_PIVOT_ROOT] = TOMOYO_MAC_FILE_PIVOT_ROOT,
  43};
  44
  45/*
  46 * Mapping table from "enum tomoyo_path_number_acl_index" to
  47 * "enum tomoyo_mac_index".
  48 */
  49const u8 tomoyo_pn2mac[TOMOYO_MAX_PATH_NUMBER_OPERATION] = {
  50	[TOMOYO_TYPE_CREATE] = TOMOYO_MAC_FILE_CREATE,
  51	[TOMOYO_TYPE_MKDIR]  = TOMOYO_MAC_FILE_MKDIR,
  52	[TOMOYO_TYPE_MKFIFO] = TOMOYO_MAC_FILE_MKFIFO,
  53	[TOMOYO_TYPE_MKSOCK] = TOMOYO_MAC_FILE_MKSOCK,
  54	[TOMOYO_TYPE_IOCTL]  = TOMOYO_MAC_FILE_IOCTL,
  55	[TOMOYO_TYPE_CHMOD]  = TOMOYO_MAC_FILE_CHMOD,
  56	[TOMOYO_TYPE_CHOWN]  = TOMOYO_MAC_FILE_CHOWN,
  57	[TOMOYO_TYPE_CHGRP]  = TOMOYO_MAC_FILE_CHGRP,
  58};
  59
  60/**
  61 * tomoyo_put_name_union - Drop reference on "struct tomoyo_name_union".
  62 *
  63 * @ptr: Pointer to "struct tomoyo_name_union".
  64 *
  65 * Returns nothing.
  66 */
  67void tomoyo_put_name_union(struct tomoyo_name_union *ptr)
  68{
  69	tomoyo_put_group(ptr->group);
  70	tomoyo_put_name(ptr->filename);
  71}
  72
  73/**
  74 * tomoyo_compare_name_union - Check whether a name matches "struct tomoyo_name_union" or not.
  75 *
  76 * @name: Pointer to "struct tomoyo_path_info".
  77 * @ptr:  Pointer to "struct tomoyo_name_union".
  78 *
  79 * Returns "struct tomoyo_path_info" if @name matches @ptr, NULL otherwise.
  80 */
  81const struct tomoyo_path_info *
  82tomoyo_compare_name_union(const struct tomoyo_path_info *name,
  83			  const struct tomoyo_name_union *ptr)
  84{
  85	if (ptr->group)
  86		return tomoyo_path_matches_group(name, ptr->group);
  87	if (tomoyo_path_matches_pattern(name, ptr->filename))
  88		return ptr->filename;
  89	return NULL;
  90}
  91
  92/**
  93 * tomoyo_put_number_union - Drop reference on "struct tomoyo_number_union".
  94 *
  95 * @ptr: Pointer to "struct tomoyo_number_union".
  96 *
  97 * Returns nothing.
  98 */
  99void tomoyo_put_number_union(struct tomoyo_number_union *ptr)
 100{
 101	tomoyo_put_group(ptr->group);
 102}
 103
 104/**
 105 * tomoyo_compare_number_union - Check whether a value matches "struct tomoyo_number_union" or not.
 106 *
 107 * @value: Number to check.
 108 * @ptr:   Pointer to "struct tomoyo_number_union".
 109 *
 110 * Returns true if @value matches @ptr, false otherwise.
 111 */
 112bool tomoyo_compare_number_union(const unsigned long value,
 113				 const struct tomoyo_number_union *ptr)
 114{
 115	if (ptr->group)
 116		return tomoyo_number_matches_group(value, value, ptr->group);
 117	return value >= ptr->values[0] && value <= ptr->values[1];
 118}
 119
 120/**
 121 * tomoyo_add_slash - Add trailing '/' if needed.
 122 *
 123 * @buf: Pointer to "struct tomoyo_path_info".
 124 *
 125 * Returns nothing.
 126 *
 127 * @buf must be generated by tomoyo_encode() because this function does not
 128 * allocate memory for adding '/'.
 129 */
 130static void tomoyo_add_slash(struct tomoyo_path_info *buf)
 131{
 132	if (buf->is_dir)
 133		return;
 134	/*
 135	 * This is OK because tomoyo_encode() reserves space for appending "/".
 136	 */
 137	strcat((char *) buf->name, "/");
 138	tomoyo_fill_path_info(buf);
 139}
 140
 141/**
 142 * tomoyo_get_realpath - Get realpath.
 143 *
 144 * @buf:  Pointer to "struct tomoyo_path_info".
 145 * @path: Pointer to "struct path".
 146 *
 147 * Returns true on success, false otherwise.
 148 */
 149static bool tomoyo_get_realpath(struct tomoyo_path_info *buf, const struct path *path)
 150{
 151	buf->name = tomoyo_realpath_from_path(path);
 152	if (buf->name) {
 153		tomoyo_fill_path_info(buf);
 154		return true;
 155	}
 156	return false;
 157}
 158
 159/**
 160 * tomoyo_audit_path_log - Audit path request log.
 161 *
 162 * @r: Pointer to "struct tomoyo_request_info".
 163 *
 164 * Returns 0 on success, negative value otherwise.
 165 */
 166static int tomoyo_audit_path_log(struct tomoyo_request_info *r)
 167{
 168	return tomoyo_supervisor(r, "file %s %s\n", tomoyo_path_keyword
 169				 [r->param.path.operation],
 170				 r->param.path.filename->name);
 171}
 172
 173/**
 174 * tomoyo_audit_path2_log - Audit path/path request log.
 175 *
 176 * @r: Pointer to "struct tomoyo_request_info".
 177 *
 178 * Returns 0 on success, negative value otherwise.
 179 */
 180static int tomoyo_audit_path2_log(struct tomoyo_request_info *r)
 181{
 182	return tomoyo_supervisor(r, "file %s %s %s\n", tomoyo_mac_keywords
 183				 [tomoyo_pp2mac[r->param.path2.operation]],
 184				 r->param.path2.filename1->name,
 185				 r->param.path2.filename2->name);
 186}
 187
 188/**
 189 * tomoyo_audit_mkdev_log - Audit path/number/number/number request log.
 190 *
 191 * @r: Pointer to "struct tomoyo_request_info".
 192 *
 193 * Returns 0 on success, negative value otherwise.
 194 */
 195static int tomoyo_audit_mkdev_log(struct tomoyo_request_info *r)
 196{
 197	return tomoyo_supervisor(r, "file %s %s 0%o %u %u\n",
 198				 tomoyo_mac_keywords
 199				 [tomoyo_pnnn2mac[r->param.mkdev.operation]],
 200				 r->param.mkdev.filename->name,
 201				 r->param.mkdev.mode, r->param.mkdev.major,
 202				 r->param.mkdev.minor);
 203}
 204
 205/**
 206 * tomoyo_audit_path_number_log - Audit path/number request log.
 207 *
 208 * @r: Pointer to "struct tomoyo_request_info".
 209 *
 210 * Returns 0 on success, negative value otherwise.
 211 */
 212static int tomoyo_audit_path_number_log(struct tomoyo_request_info *r)
 213{
 214	const u8 type = r->param.path_number.operation;
 215	u8 radix;
 216	char buffer[64];
 217
 218	switch (type) {
 219	case TOMOYO_TYPE_CREATE:
 220	case TOMOYO_TYPE_MKDIR:
 221	case TOMOYO_TYPE_MKFIFO:
 222	case TOMOYO_TYPE_MKSOCK:
 223	case TOMOYO_TYPE_CHMOD:
 224		radix = TOMOYO_VALUE_TYPE_OCTAL;
 225		break;
 226	case TOMOYO_TYPE_IOCTL:
 227		radix = TOMOYO_VALUE_TYPE_HEXADECIMAL;
 228		break;
 229	default:
 230		radix = TOMOYO_VALUE_TYPE_DECIMAL;
 231		break;
 232	}
 233	tomoyo_print_ulong(buffer, sizeof(buffer), r->param.path_number.number,
 234			   radix);
 235	return tomoyo_supervisor(r, "file %s %s %s\n", tomoyo_mac_keywords
 236				 [tomoyo_pn2mac[type]],
 237				 r->param.path_number.filename->name, buffer);
 238}
 239
 240/**
 241 * tomoyo_check_path_acl - Check permission for path operation.
 242 *
 243 * @r:   Pointer to "struct tomoyo_request_info".
 244 * @ptr: Pointer to "struct tomoyo_acl_info".
 245 *
 246 * Returns true if granted, false otherwise.
 247 *
 248 * To be able to use wildcard for domain transition, this function sets
 249 * matching entry on success. Since the caller holds tomoyo_read_lock(),
 250 * it is safe to set matching entry.
 251 */
 252static bool tomoyo_check_path_acl(struct tomoyo_request_info *r,
 253				  const struct tomoyo_acl_info *ptr)
 254{
 255	const struct tomoyo_path_acl *acl = container_of(ptr, typeof(*acl),
 256							 head);
 257
 258	if (acl->perm & (1 << r->param.path.operation)) {
 259		r->param.path.matched_path =
 260			tomoyo_compare_name_union(r->param.path.filename,
 261						  &acl->name);
 262		return r->param.path.matched_path != NULL;
 263	}
 264	return false;
 265}
 266
 267/**
 268 * tomoyo_check_path_number_acl - Check permission for path number operation.
 269 *
 270 * @r:   Pointer to "struct tomoyo_request_info".
 271 * @ptr: Pointer to "struct tomoyo_acl_info".
 272 *
 273 * Returns true if granted, false otherwise.
 274 */
 275static bool tomoyo_check_path_number_acl(struct tomoyo_request_info *r,
 276					 const struct tomoyo_acl_info *ptr)
 277{
 278	const struct tomoyo_path_number_acl *acl =
 279		container_of(ptr, typeof(*acl), head);
 280
 281	return (acl->perm & (1 << r->param.path_number.operation)) &&
 282		tomoyo_compare_number_union(r->param.path_number.number,
 283					    &acl->number) &&
 284		tomoyo_compare_name_union(r->param.path_number.filename,
 285					  &acl->name);
 286}
 287
 288/**
 289 * tomoyo_check_path2_acl - Check permission for path path operation.
 290 *
 291 * @r:   Pointer to "struct tomoyo_request_info".
 292 * @ptr: Pointer to "struct tomoyo_acl_info".
 293 *
 294 * Returns true if granted, false otherwise.
 295 */
 296static bool tomoyo_check_path2_acl(struct tomoyo_request_info *r,
 297				   const struct tomoyo_acl_info *ptr)
 298{
 299	const struct tomoyo_path2_acl *acl =
 300		container_of(ptr, typeof(*acl), head);
 301
 302	return (acl->perm & (1 << r->param.path2.operation)) &&
 303		tomoyo_compare_name_union(r->param.path2.filename1, &acl->name1)
 304		&& tomoyo_compare_name_union(r->param.path2.filename2,
 305					     &acl->name2);
 306}
 307
 308/**
 309 * tomoyo_check_mkdev_acl - Check permission for path number number number operation.
 310 *
 311 * @r:   Pointer to "struct tomoyo_request_info".
 312 * @ptr: Pointer to "struct tomoyo_acl_info".
 313 *
 314 * Returns true if granted, false otherwise.
 315 */
 316static bool tomoyo_check_mkdev_acl(struct tomoyo_request_info *r,
 317				   const struct tomoyo_acl_info *ptr)
 318{
 319	const struct tomoyo_mkdev_acl *acl =
 320		container_of(ptr, typeof(*acl), head);
 321
 322	return (acl->perm & (1 << r->param.mkdev.operation)) &&
 323		tomoyo_compare_number_union(r->param.mkdev.mode,
 324					    &acl->mode) &&
 325		tomoyo_compare_number_union(r->param.mkdev.major,
 326					    &acl->major) &&
 327		tomoyo_compare_number_union(r->param.mkdev.minor,
 328					    &acl->minor) &&
 329		tomoyo_compare_name_union(r->param.mkdev.filename,
 330					  &acl->name);
 331}
 332
 333/**
 334 * tomoyo_same_path_acl - Check for duplicated "struct tomoyo_path_acl" entry.
 335 *
 336 * @a: Pointer to "struct tomoyo_acl_info".
 337 * @b: Pointer to "struct tomoyo_acl_info".
 338 *
 339 * Returns true if @a == @b except permission bits, false otherwise.
 340 */
 341static bool tomoyo_same_path_acl(const struct tomoyo_acl_info *a,
 342				 const struct tomoyo_acl_info *b)
 343{
 344	const struct tomoyo_path_acl *p1 = container_of(a, typeof(*p1), head);
 345	const struct tomoyo_path_acl *p2 = container_of(b, typeof(*p2), head);
 346
 347	return tomoyo_same_name_union(&p1->name, &p2->name);
 348}
 349
 350/**
 351 * tomoyo_merge_path_acl - Merge duplicated "struct tomoyo_path_acl" entry.
 352 *
 353 * @a:         Pointer to "struct tomoyo_acl_info".
 354 * @b:         Pointer to "struct tomoyo_acl_info".
 355 * @is_delete: True for @a &= ~@b, false for @a |= @b.
 356 *
 357 * Returns true if @a is empty, false otherwise.
 358 */
 359static bool tomoyo_merge_path_acl(struct tomoyo_acl_info *a,
 360				  struct tomoyo_acl_info *b,
 361				  const bool is_delete)
 362{
 363	u16 * const a_perm = &container_of(a, struct tomoyo_path_acl, head)
 364		->perm;
 365	u16 perm = *a_perm;
 366	const u16 b_perm = container_of(b, struct tomoyo_path_acl, head)->perm;
 367
 368	if (is_delete)
 369		perm &= ~b_perm;
 370	else
 371		perm |= b_perm;
 372	*a_perm = perm;
 373	return !perm;
 374}
 375
 376/**
 377 * tomoyo_update_path_acl - Update "struct tomoyo_path_acl" list.
 378 *
 379 * @perm:  Permission.
 380 * @param: Pointer to "struct tomoyo_acl_param".
 381 *
 382 * Returns 0 on success, negative value otherwise.
 383 *
 384 * Caller holds tomoyo_read_lock().
 385 */
 386static int tomoyo_update_path_acl(const u16 perm,
 387				  struct tomoyo_acl_param *param)
 388{
 389	struct tomoyo_path_acl e = {
 390		.head.type = TOMOYO_TYPE_PATH_ACL,
 391		.perm = perm
 392	};
 393	int error;
 394
 395	if (!tomoyo_parse_name_union(param, &e.name))
 396		error = -EINVAL;
 397	else
 398		error = tomoyo_update_domain(&e.head, sizeof(e), param,
 399					     tomoyo_same_path_acl,
 400					     tomoyo_merge_path_acl);
 401	tomoyo_put_name_union(&e.name);
 402	return error;
 403}
 404
 405/**
 406 * tomoyo_same_mkdev_acl - Check for duplicated "struct tomoyo_mkdev_acl" entry.
 407 *
 408 * @a: Pointer to "struct tomoyo_acl_info".
 409 * @b: Pointer to "struct tomoyo_acl_info".
 410 *
 411 * Returns true if @a == @b except permission bits, false otherwise.
 412 */
 413static bool tomoyo_same_mkdev_acl(const struct tomoyo_acl_info *a,
 414					 const struct tomoyo_acl_info *b)
 415{
 416	const struct tomoyo_mkdev_acl *p1 = container_of(a, typeof(*p1), head);
 417	const struct tomoyo_mkdev_acl *p2 = container_of(b, typeof(*p2), head);
 418
 419	return tomoyo_same_name_union(&p1->name, &p2->name) &&
 420		tomoyo_same_number_union(&p1->mode, &p2->mode) &&
 421		tomoyo_same_number_union(&p1->major, &p2->major) &&
 422		tomoyo_same_number_union(&p1->minor, &p2->minor);
 423}
 424
 425/**
 426 * tomoyo_merge_mkdev_acl - Merge duplicated "struct tomoyo_mkdev_acl" entry.
 427 *
 428 * @a:         Pointer to "struct tomoyo_acl_info".
 429 * @b:         Pointer to "struct tomoyo_acl_info".
 430 * @is_delete: True for @a &= ~@b, false for @a |= @b.
 431 *
 432 * Returns true if @a is empty, false otherwise.
 433 */
 434static bool tomoyo_merge_mkdev_acl(struct tomoyo_acl_info *a,
 435				   struct tomoyo_acl_info *b,
 436				   const bool is_delete)
 437{
 438	u8 *const a_perm = &container_of(a, struct tomoyo_mkdev_acl,
 439					 head)->perm;
 440	u8 perm = *a_perm;
 441	const u8 b_perm = container_of(b, struct tomoyo_mkdev_acl, head)
 442		->perm;
 443
 444	if (is_delete)
 445		perm &= ~b_perm;
 446	else
 447		perm |= b_perm;
 448	*a_perm = perm;
 449	return !perm;
 450}
 451
 452/**
 453 * tomoyo_update_mkdev_acl - Update "struct tomoyo_mkdev_acl" list.
 454 *
 455 * @perm:  Permission.
 456 * @param: Pointer to "struct tomoyo_acl_param".
 457 *
 458 * Returns 0 on success, negative value otherwise.
 459 *
 460 * Caller holds tomoyo_read_lock().
 461 */
 462static int tomoyo_update_mkdev_acl(const u8 perm,
 463				   struct tomoyo_acl_param *param)
 464{
 465	struct tomoyo_mkdev_acl e = {
 466		.head.type = TOMOYO_TYPE_MKDEV_ACL,
 467		.perm = perm
 468	};
 469	int error;
 470
 471	if (!tomoyo_parse_name_union(param, &e.name) ||
 472	    !tomoyo_parse_number_union(param, &e.mode) ||
 473	    !tomoyo_parse_number_union(param, &e.major) ||
 474	    !tomoyo_parse_number_union(param, &e.minor))
 475		error = -EINVAL;
 476	else
 477		error = tomoyo_update_domain(&e.head, sizeof(e), param,
 478					     tomoyo_same_mkdev_acl,
 479					     tomoyo_merge_mkdev_acl);
 480	tomoyo_put_name_union(&e.name);
 481	tomoyo_put_number_union(&e.mode);
 482	tomoyo_put_number_union(&e.major);
 483	tomoyo_put_number_union(&e.minor);
 484	return error;
 485}
 486
 487/**
 488 * tomoyo_same_path2_acl - Check for duplicated "struct tomoyo_path2_acl" entry.
 489 *
 490 * @a: Pointer to "struct tomoyo_acl_info".
 491 * @b: Pointer to "struct tomoyo_acl_info".
 492 *
 493 * Returns true if @a == @b except permission bits, false otherwise.
 494 */
 495static bool tomoyo_same_path2_acl(const struct tomoyo_acl_info *a,
 496				  const struct tomoyo_acl_info *b)
 497{
 498	const struct tomoyo_path2_acl *p1 = container_of(a, typeof(*p1), head);
 499	const struct tomoyo_path2_acl *p2 = container_of(b, typeof(*p2), head);
 500
 501	return tomoyo_same_name_union(&p1->name1, &p2->name1) &&
 502		tomoyo_same_name_union(&p1->name2, &p2->name2);
 503}
 504
 505/**
 506 * tomoyo_merge_path2_acl - Merge duplicated "struct tomoyo_path2_acl" entry.
 507 *
 508 * @a:         Pointer to "struct tomoyo_acl_info".
 509 * @b:         Pointer to "struct tomoyo_acl_info".
 510 * @is_delete: True for @a &= ~@b, false for @a |= @b.
 511 *
 512 * Returns true if @a is empty, false otherwise.
 513 */
 514static bool tomoyo_merge_path2_acl(struct tomoyo_acl_info *a,
 515				   struct tomoyo_acl_info *b,
 516				   const bool is_delete)
 517{
 518	u8 * const a_perm = &container_of(a, struct tomoyo_path2_acl, head)
 519		->perm;
 520	u8 perm = *a_perm;
 521	const u8 b_perm = container_of(b, struct tomoyo_path2_acl, head)->perm;
 522
 523	if (is_delete)
 524		perm &= ~b_perm;
 525	else
 526		perm |= b_perm;
 527	*a_perm = perm;
 528	return !perm;
 529}
 530
 531/**
 532 * tomoyo_update_path2_acl - Update "struct tomoyo_path2_acl" list.
 533 *
 534 * @perm:  Permission.
 535 * @param: Pointer to "struct tomoyo_acl_param".
 536 *
 537 * Returns 0 on success, negative value otherwise.
 538 *
 539 * Caller holds tomoyo_read_lock().
 540 */
 541static int tomoyo_update_path2_acl(const u8 perm,
 542				   struct tomoyo_acl_param *param)
 543{
 544	struct tomoyo_path2_acl e = {
 545		.head.type = TOMOYO_TYPE_PATH2_ACL,
 546		.perm = perm
 547	};
 548	int error;
 549
 550	if (!tomoyo_parse_name_union(param, &e.name1) ||
 551	    !tomoyo_parse_name_union(param, &e.name2))
 552		error = -EINVAL;
 553	else
 554		error = tomoyo_update_domain(&e.head, sizeof(e), param,
 555					     tomoyo_same_path2_acl,
 556					     tomoyo_merge_path2_acl);
 557	tomoyo_put_name_union(&e.name1);
 558	tomoyo_put_name_union(&e.name2);
 559	return error;
 560}
 561
 562/**
 563 * tomoyo_path_permission - Check permission for single path operation.
 564 *
 565 * @r:         Pointer to "struct tomoyo_request_info".
 566 * @operation: Type of operation.
 567 * @filename:  Filename to check.
 568 *
 569 * Returns 0 on success, negative value otherwise.
 570 *
 571 * Caller holds tomoyo_read_lock().
 572 */
 573static int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
 574				  const struct tomoyo_path_info *filename)
 575{
 576	int error;
 577
 578	r->type = tomoyo_p2mac[operation];
 579	r->mode = tomoyo_get_mode(r->domain->ns, r->profile, r->type);
 580	if (r->mode == TOMOYO_CONFIG_DISABLED)
 581		return 0;
 582	r->param_type = TOMOYO_TYPE_PATH_ACL;
 583	r->param.path.filename = filename;
 584	r->param.path.operation = operation;
 585	do {
 586		tomoyo_check_acl(r, tomoyo_check_path_acl);
 587		error = tomoyo_audit_path_log(r);
 588	} while (error == TOMOYO_RETRY_REQUEST);
 589	return error;
 590}
 591
 592/**
 593 * tomoyo_execute_permission - Check permission for execute operation.
 594 *
 595 * @r:         Pointer to "struct tomoyo_request_info".
 596 * @filename:  Filename to check.
 597 *
 598 * Returns 0 on success, negative value otherwise.
 599 *
 600 * Caller holds tomoyo_read_lock().
 601 */
 602int tomoyo_execute_permission(struct tomoyo_request_info *r,
 603			      const struct tomoyo_path_info *filename)
 604{
 605	/*
 606	 * Unlike other permission checks, this check is done regardless of
 607	 * profile mode settings in order to check for domain transition
 608	 * preference.
 609	 */
 610	r->type = TOMOYO_MAC_FILE_EXECUTE;
 611	r->mode = tomoyo_get_mode(r->domain->ns, r->profile, r->type);
 612	r->param_type = TOMOYO_TYPE_PATH_ACL;
 613	r->param.path.filename = filename;
 614	r->param.path.operation = TOMOYO_TYPE_EXECUTE;
 615	tomoyo_check_acl(r, tomoyo_check_path_acl);
 616	r->ee->transition = r->matched_acl && r->matched_acl->cond ?
 617		r->matched_acl->cond->transit : NULL;
 618	if (r->mode != TOMOYO_CONFIG_DISABLED)
 619		return tomoyo_audit_path_log(r);
 620	return 0;
 621}
 622
 623/**
 624 * tomoyo_same_path_number_acl - Check for duplicated "struct tomoyo_path_number_acl" entry.
 625 *
 626 * @a: Pointer to "struct tomoyo_acl_info".
 627 * @b: Pointer to "struct tomoyo_acl_info".
 628 *
 629 * Returns true if @a == @b except permission bits, false otherwise.
 630 */
 631static bool tomoyo_same_path_number_acl(const struct tomoyo_acl_info *a,
 632					const struct tomoyo_acl_info *b)
 633{
 634	const struct tomoyo_path_number_acl *p1 = container_of(a, typeof(*p1),
 635							       head);
 636	const struct tomoyo_path_number_acl *p2 = container_of(b, typeof(*p2),
 637							       head);
 638
 639	return tomoyo_same_name_union(&p1->name, &p2->name) &&
 640		tomoyo_same_number_union(&p1->number, &p2->number);
 641}
 642
 643/**
 644 * tomoyo_merge_path_number_acl - Merge duplicated "struct tomoyo_path_number_acl" entry.
 645 *
 646 * @a:         Pointer to "struct tomoyo_acl_info".
 647 * @b:         Pointer to "struct tomoyo_acl_info".
 648 * @is_delete: True for @a &= ~@b, false for @a |= @b.
 649 *
 650 * Returns true if @a is empty, false otherwise.
 651 */
 652static bool tomoyo_merge_path_number_acl(struct tomoyo_acl_info *a,
 653					 struct tomoyo_acl_info *b,
 654					 const bool is_delete)
 655{
 656	u8 * const a_perm = &container_of(a, struct tomoyo_path_number_acl,
 657					  head)->perm;
 658	u8 perm = *a_perm;
 659	const u8 b_perm = container_of(b, struct tomoyo_path_number_acl, head)
 660		->perm;
 661
 662	if (is_delete)
 663		perm &= ~b_perm;
 664	else
 665		perm |= b_perm;
 666	*a_perm = perm;
 667	return !perm;
 668}
 669
 670/**
 671 * tomoyo_update_path_number_acl - Update ioctl/chmod/chown/chgrp ACL.
 672 *
 673 * @perm:  Permission.
 674 * @param: Pointer to "struct tomoyo_acl_param".
 675 *
 676 * Returns 0 on success, negative value otherwise.
 677 */
 678static int tomoyo_update_path_number_acl(const u8 perm,
 679					 struct tomoyo_acl_param *param)
 680{
 681	struct tomoyo_path_number_acl e = {
 682		.head.type = TOMOYO_TYPE_PATH_NUMBER_ACL,
 683		.perm = perm
 684	};
 685	int error;
 686
 687	if (!tomoyo_parse_name_union(param, &e.name) ||
 688	    !tomoyo_parse_number_union(param, &e.number))
 689		error = -EINVAL;
 690	else
 691		error = tomoyo_update_domain(&e.head, sizeof(e), param,
 692					     tomoyo_same_path_number_acl,
 693					     tomoyo_merge_path_number_acl);
 694	tomoyo_put_name_union(&e.name);
 695	tomoyo_put_number_union(&e.number);
 696	return error;
 697}
 698
 699/**
 700 * tomoyo_path_number_perm - Check permission for "create", "mkdir", "mkfifo", "mksock", "ioctl", "chmod", "chown", "chgrp".
 701 *
 702 * @type:   Type of operation.
 703 * @path:   Pointer to "struct path".
 704 * @number: Number.
 705 *
 706 * Returns 0 on success, negative value otherwise.
 707 */
 708int tomoyo_path_number_perm(const u8 type, const struct path *path,
 709			    unsigned long number)
 710{
 711	struct tomoyo_request_info r;
 712	struct tomoyo_obj_info obj = {
 713		.path1 = { .mnt = path->mnt, .dentry = path->dentry },
 714	};
 715	int error = -ENOMEM;
 716	struct tomoyo_path_info buf;
 717	int idx;
 718
 719	if (tomoyo_init_request_info(&r, NULL, tomoyo_pn2mac[type])
 720	    == TOMOYO_CONFIG_DISABLED || !path->dentry)
 721		return 0;
 722	idx = tomoyo_read_lock();
 723	if (!tomoyo_get_realpath(&buf, path))
 724		goto out;
 725	r.obj = &obj;
 726	if (type == TOMOYO_TYPE_MKDIR)
 727		tomoyo_add_slash(&buf);
 728	r.param_type = TOMOYO_TYPE_PATH_NUMBER_ACL;
 729	r.param.path_number.operation = type;
 730	r.param.path_number.filename = &buf;
 731	r.param.path_number.number = number;
 732	do {
 733		tomoyo_check_acl(&r, tomoyo_check_path_number_acl);
 734		error = tomoyo_audit_path_number_log(&r);
 735	} while (error == TOMOYO_RETRY_REQUEST);
 736	kfree(buf.name);
 737 out:
 738	tomoyo_read_unlock(idx);
 739	if (r.mode != TOMOYO_CONFIG_ENFORCING)
 740		error = 0;
 741	return error;
 742}
 743
 744/**
 745 * tomoyo_check_open_permission - Check permission for "read" and "write".
 746 *
 747 * @domain: Pointer to "struct tomoyo_domain_info".
 748 * @path:   Pointer to "struct path".
 749 * @flag:   Flags for open().
 750 *
 751 * Returns 0 on success, negative value otherwise.
 752 */
 753int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
 754				 const struct path *path, const int flag)
 755{
 756	const u8 acc_mode = ACC_MODE(flag);
 757	int error = 0;
 758	struct tomoyo_path_info buf;
 759	struct tomoyo_request_info r;
 760	struct tomoyo_obj_info obj = {
 761		.path1 = { .mnt = path->mnt, .dentry = path->dentry },
 762	};
 763	int idx;
 764
 765	buf.name = NULL;
 766	r.mode = TOMOYO_CONFIG_DISABLED;
 767	idx = tomoyo_read_lock();
 768	if (acc_mode &&
 769	    tomoyo_init_request_info(&r, domain, TOMOYO_MAC_FILE_OPEN)
 770	    != TOMOYO_CONFIG_DISABLED) {
 771		if (!tomoyo_get_realpath(&buf, path)) {
 772			error = -ENOMEM;
 773			goto out;
 774		}
 775		r.obj = &obj;
 776		if (acc_mode & MAY_READ)
 777			error = tomoyo_path_permission(&r, TOMOYO_TYPE_READ,
 778						       &buf);
 779		if (!error && (acc_mode & MAY_WRITE))
 780			error = tomoyo_path_permission(&r, (flag & O_APPEND) ?
 781						       TOMOYO_TYPE_APPEND :
 782						       TOMOYO_TYPE_WRITE,
 783						       &buf);
 784	}
 785 out:
 786	kfree(buf.name);
 787	tomoyo_read_unlock(idx);
 788	if (r.mode != TOMOYO_CONFIG_ENFORCING)
 789		error = 0;
 790	return error;
 791}
 792
 793/**
 794 * tomoyo_path_perm - Check permission for "unlink", "rmdir", "truncate", "symlink", "append", "chroot" and "unmount".
 795 *
 796 * @operation: Type of operation.
 797 * @path:      Pointer to "struct path".
 798 * @target:    Symlink's target if @operation is TOMOYO_TYPE_SYMLINK,
 799 *             NULL otherwise.
 800 *
 801 * Returns 0 on success, negative value otherwise.
 802 */
 803int tomoyo_path_perm(const u8 operation, const struct path *path, const char *target)
 804{
 805	struct tomoyo_request_info r;
 806	struct tomoyo_obj_info obj = {
 807		.path1 = { .mnt = path->mnt, .dentry = path->dentry },
 808	};
 809	int error;
 810	struct tomoyo_path_info buf;
 811	bool is_enforce;
 812	struct tomoyo_path_info symlink_target;
 813	int idx;
 814
 815	if (tomoyo_init_request_info(&r, NULL, tomoyo_p2mac[operation])
 816	    == TOMOYO_CONFIG_DISABLED)
 817		return 0;
 818	is_enforce = (r.mode == TOMOYO_CONFIG_ENFORCING);
 819	error = -ENOMEM;
 820	buf.name = NULL;
 821	idx = tomoyo_read_lock();
 822	if (!tomoyo_get_realpath(&buf, path))
 823		goto out;
 824	r.obj = &obj;
 825	switch (operation) {
 826	case TOMOYO_TYPE_RMDIR:
 827	case TOMOYO_TYPE_CHROOT:
 828		tomoyo_add_slash(&buf);
 829		break;
 830	case TOMOYO_TYPE_SYMLINK:
 831		symlink_target.name = tomoyo_encode(target);
 832		if (!symlink_target.name)
 833			goto out;
 834		tomoyo_fill_path_info(&symlink_target);
 835		obj.symlink_target = &symlink_target;
 836		break;
 837	}
 838	error = tomoyo_path_permission(&r, operation, &buf);
 839	if (operation == TOMOYO_TYPE_SYMLINK)
 840		kfree(symlink_target.name);
 841 out:
 842	kfree(buf.name);
 843	tomoyo_read_unlock(idx);
 844	if (!is_enforce)
 845		error = 0;
 846	return error;
 847}
 848
 849/**
 850 * tomoyo_mkdev_perm - Check permission for "mkblock" and "mkchar".
 851 *
 852 * @operation: Type of operation. (TOMOYO_TYPE_MKCHAR or TOMOYO_TYPE_MKBLOCK)
 853 * @path:      Pointer to "struct path".
 854 * @mode:      Create mode.
 855 * @dev:       Device number.
 856 *
 857 * Returns 0 on success, negative value otherwise.
 858 */
 859int tomoyo_mkdev_perm(const u8 operation, const struct path *path,
 860		      const unsigned int mode, unsigned int dev)
 861{
 862	struct tomoyo_request_info r;
 863	struct tomoyo_obj_info obj = {
 864		.path1 = { .mnt = path->mnt, .dentry = path->dentry },
 865	};
 866	int error = -ENOMEM;
 867	struct tomoyo_path_info buf;
 868	int idx;
 869
 870	if (tomoyo_init_request_info(&r, NULL, tomoyo_pnnn2mac[operation])
 871	    == TOMOYO_CONFIG_DISABLED)
 872		return 0;
 873	idx = tomoyo_read_lock();
 874	error = -ENOMEM;
 875	if (tomoyo_get_realpath(&buf, path)) {
 876		r.obj = &obj;
 877		dev = new_decode_dev(dev);
 878		r.param_type = TOMOYO_TYPE_MKDEV_ACL;
 879		r.param.mkdev.filename = &buf;
 880		r.param.mkdev.operation = operation;
 881		r.param.mkdev.mode = mode;
 882		r.param.mkdev.major = MAJOR(dev);
 883		r.param.mkdev.minor = MINOR(dev);
 884		tomoyo_check_acl(&r, tomoyo_check_mkdev_acl);
 885		error = tomoyo_audit_mkdev_log(&r);
 886		kfree(buf.name);
 887	}
 888	tomoyo_read_unlock(idx);
 889	if (r.mode != TOMOYO_CONFIG_ENFORCING)
 890		error = 0;
 891	return error;
 892}
 893
 894/**
 895 * tomoyo_path2_perm - Check permission for "rename", "link" and "pivot_root".
 896 *
 897 * @operation: Type of operation.
 898 * @path1:      Pointer to "struct path".
 899 * @path2:      Pointer to "struct path".
 900 *
 901 * Returns 0 on success, negative value otherwise.
 902 */
 903int tomoyo_path2_perm(const u8 operation, const struct path *path1,
 904		      const struct path *path2)
 905{
 906	int error = -ENOMEM;
 907	struct tomoyo_path_info buf1;
 908	struct tomoyo_path_info buf2;
 909	struct tomoyo_request_info r;
 910	struct tomoyo_obj_info obj = {
 911		.path1 = { .mnt = path1->mnt, .dentry = path1->dentry },
 912		.path2 = { .mnt = path2->mnt, .dentry = path2->dentry }
 913	};
 914	int idx;
 915
 916	if (tomoyo_init_request_info(&r, NULL, tomoyo_pp2mac[operation])
 917	    == TOMOYO_CONFIG_DISABLED)
 918		return 0;
 919	buf1.name = NULL;
 920	buf2.name = NULL;
 921	idx = tomoyo_read_lock();
 922	if (!tomoyo_get_realpath(&buf1, path1) ||
 923	    !tomoyo_get_realpath(&buf2, path2))
 924		goto out;
 925	switch (operation) {
 926	case TOMOYO_TYPE_RENAME:
 927	case TOMOYO_TYPE_LINK:
 928		if (!d_is_dir(path1->dentry))
 929			break;
 930		/* fall through */
 931	case TOMOYO_TYPE_PIVOT_ROOT:
 932		tomoyo_add_slash(&buf1);
 933		tomoyo_add_slash(&buf2);
 934		break;
 935	}
 936	r.obj = &obj;
 937	r.param_type = TOMOYO_TYPE_PATH2_ACL;
 938	r.param.path2.operation = operation;
 939	r.param.path2.filename1 = &buf1;
 940	r.param.path2.filename2 = &buf2;
 941	do {
 942		tomoyo_check_acl(&r, tomoyo_check_path2_acl);
 943		error = tomoyo_audit_path2_log(&r);
 944	} while (error == TOMOYO_RETRY_REQUEST);
 945 out:
 946	kfree(buf1.name);
 947	kfree(buf2.name);
 948	tomoyo_read_unlock(idx);
 949	if (r.mode != TOMOYO_CONFIG_ENFORCING)
 950		error = 0;
 951	return error;
 952}
 953
 954/**
 955 * tomoyo_same_mount_acl - Check for duplicated "struct tomoyo_mount_acl" entry.
 956 *
 957 * @a: Pointer to "struct tomoyo_acl_info".
 958 * @b: Pointer to "struct tomoyo_acl_info".
 959 *
 960 * Returns true if @a == @b, false otherwise.
 961 */
 962static bool tomoyo_same_mount_acl(const struct tomoyo_acl_info *a,
 963				  const struct tomoyo_acl_info *b)
 964{
 965	const struct tomoyo_mount_acl *p1 = container_of(a, typeof(*p1), head);
 966	const struct tomoyo_mount_acl *p2 = container_of(b, typeof(*p2), head);
 967
 968	return tomoyo_same_name_union(&p1->dev_name, &p2->dev_name) &&
 969		tomoyo_same_name_union(&p1->dir_name, &p2->dir_name) &&
 970		tomoyo_same_name_union(&p1->fs_type, &p2->fs_type) &&
 971		tomoyo_same_number_union(&p1->flags, &p2->flags);
 972}
 973
 974/**
 975 * tomoyo_update_mount_acl - Write "struct tomoyo_mount_acl" list.
 976 *
 977 * @param: Pointer to "struct tomoyo_acl_param".
 978 *
 979 * Returns 0 on success, negative value otherwise.
 980 *
 981 * Caller holds tomoyo_read_lock().
 982 */
 983static int tomoyo_update_mount_acl(struct tomoyo_acl_param *param)
 984{
 985	struct tomoyo_mount_acl e = { .head.type = TOMOYO_TYPE_MOUNT_ACL };
 986	int error;
 987
 988	if (!tomoyo_parse_name_union(param, &e.dev_name) ||
 989	    !tomoyo_parse_name_union(param, &e.dir_name) ||
 990	    !tomoyo_parse_name_union(param, &e.fs_type) ||
 991	    !tomoyo_parse_number_union(param, &e.flags))
 992		error = -EINVAL;
 993	else
 994		error = tomoyo_update_domain(&e.head, sizeof(e), param,
 995					     tomoyo_same_mount_acl, NULL);
 996	tomoyo_put_name_union(&e.dev_name);
 997	tomoyo_put_name_union(&e.dir_name);
 998	tomoyo_put_name_union(&e.fs_type);
 999	tomoyo_put_number_union(&e.flags);
1000	return error;
1001}
1002
1003/**
1004 * tomoyo_write_file - Update file related list.
1005 *
1006 * @param: Pointer to "struct tomoyo_acl_param".
1007 *
1008 * Returns 0 on success, negative value otherwise.
1009 *
1010 * Caller holds tomoyo_read_lock().
1011 */
1012int tomoyo_write_file(struct tomoyo_acl_param *param)
1013{
1014	u16 perm = 0;
1015	u8 type;
1016	const char *operation = tomoyo_read_token(param);
1017
1018	for (type = 0; type < TOMOYO_MAX_PATH_OPERATION; type++)
1019		if (tomoyo_permstr(operation, tomoyo_path_keyword[type]))
1020			perm |= 1 << type;
1021	if (perm)
1022		return tomoyo_update_path_acl(perm, param);
1023	for (type = 0; type < TOMOYO_MAX_PATH2_OPERATION; type++)
1024		if (tomoyo_permstr(operation,
1025				   tomoyo_mac_keywords[tomoyo_pp2mac[type]]))
1026			perm |= 1 << type;
1027	if (perm)
1028		return tomoyo_update_path2_acl(perm, param);
1029	for (type = 0; type < TOMOYO_MAX_PATH_NUMBER_OPERATION; type++)
1030		if (tomoyo_permstr(operation,
1031				   tomoyo_mac_keywords[tomoyo_pn2mac[type]]))
1032			perm |= 1 << type;
1033	if (perm)
1034		return tomoyo_update_path_number_acl(perm, param);
1035	for (type = 0; type < TOMOYO_MAX_MKDEV_OPERATION; type++)
1036		if (tomoyo_permstr(operation,
1037				   tomoyo_mac_keywords[tomoyo_pnnn2mac[type]]))
1038			perm |= 1 << type;
1039	if (perm)
1040		return tomoyo_update_mkdev_acl(perm, param);
1041	if (tomoyo_permstr(operation,
1042			   tomoyo_mac_keywords[TOMOYO_MAC_FILE_MOUNT]))
1043		return tomoyo_update_mount_acl(param);
1044	return -EINVAL;
1045}