[deliverable/linux.git] / security / tomoyo / common.h

/*
 * security/tomoyo/common.h
 *
 * Common functions for TOMOYO.
 *
 * Copyright (C) 2005-2009  NTT DATA CORPORATION
 *
 * Version: 2.2.0-pre   2009/02/01
 *
 */

#ifndef _SECURITY_TOMOYO_COMMON_H
#define _SECURITY_TOMOYO_COMMON_H

#include <linux/ctype.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/file.h>
#include <linux/kmod.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/namei.h>
#include <linux/mount.h>
#include <linux/list.h>

struct dentry;
struct vfsmount;

/* Temporary buffer for holding pathnames. */
struct tomoyo_page_buffer {
	char buffer[4096];
};

/* Structure for holding a token. */
struct tomoyo_path_info {
	const char *name;
	u32 hash;          /* = full_name_hash(name, strlen(name)) */
	u16 total_len;     /* = strlen(name)                       */
	u16 const_len;     /* = tomoyo_const_part_length(name)     */
	bool is_dir;       /* = tomoyo_strendswith(name, "/")      */
	bool is_patterned; /* = tomoyo_path_contains_pattern(name) */
	u16 depth;         /* = tomoyo_path_depth(name)            */
};

/*
 * This is the max length of a token.
 *
 * A token consists of only ASCII printable characters.
 * Non printable characters in a token is represented in \ooo style
 * octal string. Thus, \ itself is represented as \\.
 */
#define TOMOYO_MAX_PATHNAME_LEN 4000

/* Structure for holding requested pathname. */
struct tomoyo_path_info_with_data {
	/* Keep "head" first, for this pointer is passed to tomoyo_free(). */
	struct tomoyo_path_info head;
	char barrier1[16]; /* Safeguard for overrun. */
	char body[TOMOYO_MAX_PATHNAME_LEN];
	char barrier2[16]; /* Safeguard for overrun. */
};

/*
 * Common header for holding ACL entries.
 *
 * Packing "struct tomoyo_acl_info" allows
 * "struct tomoyo_single_path_acl_record" to embed "u16" and
 * "struct tomoyo_double_path_acl_record" to embed "u8"
 * without enlarging their structure size.
 */
struct tomoyo_acl_info {
	struct list_head list;
	/*
	 * Type of this ACL entry.
	 *
	 * MSB is is_deleted flag.
	 */
	u8 type;
} __packed;

/* This ACL entry is deleted.           */
#define TOMOYO_ACL_DELETED        0x80

/* Structure for domain information. */
struct tomoyo_domain_info {
	struct list_head list;
	struct list_head acl_info_list;
	/* Name of this domain. Never NULL.          */
	const struct tomoyo_path_info *domainname;
	u8 profile;        /* Profile number to use. */
	u8 is_deleted;     /* Delete flag.
			      0 = active.
			      1 = deleted but undeletable.
			      255 = deleted and no longer undeletable. */
	bool quota_warned; /* Quota warnning flag.   */
	/* DOMAIN_FLAGS_*. Use tomoyo_set_domain_flag() to modify. */
	u8 flags;
};

/* Profile number is an integer between 0 and 255. */
#define TOMOYO_MAX_PROFILES 256

/* Ignore "allow_read" directive in exception policy. */
#define TOMOYO_DOMAIN_FLAGS_IGNORE_GLOBAL_ALLOW_READ 1
/*
 * This domain was unable to create a new domain at tomoyo_find_next_domain()
 * because the name of the domain to be created was too long or
 * it could not allocate memory.
 * More than one process continued execve() without domain transition.
 */
#define TOMOYO_DOMAIN_FLAGS_TRANSITION_FAILED        2

/*
 * Structure for "allow_read/write", "allow_execute", "allow_read",
 * "allow_write", "allow_create", "allow_unlink", "allow_mkdir", "allow_rmdir",
 * "allow_mkfifo", "allow_mksock", "allow_mkblock", "allow_mkchar",
 * "allow_truncate", "allow_symlink" and "allow_rewrite" directive.
 */
struct tomoyo_single_path_acl_record {
	struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_SINGLE_PATH_ACL */
	u16 perm;
	/* Pointer to single pathname. */
	const struct tomoyo_path_info *filename;
};

/* Structure for "allow_rename" and "allow_link" directive. */
struct tomoyo_double_path_acl_record {
	struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_DOUBLE_PATH_ACL */
	u8 perm;
	/* Pointer to single pathname. */
	const struct tomoyo_path_info *filename1;
	/* Pointer to single pathname. */
	const struct tomoyo_path_info *filename2;
};

/* Keywords for ACLs. */
#define TOMOYO_KEYWORD_ALIAS                     "alias "
#define TOMOYO_KEYWORD_ALLOW_READ                "allow_read "
#define TOMOYO_KEYWORD_DELETE                    "delete "
#define TOMOYO_KEYWORD_DENY_REWRITE              "deny_rewrite "
#define TOMOYO_KEYWORD_FILE_PATTERN              "file_pattern "
#define TOMOYO_KEYWORD_INITIALIZE_DOMAIN         "initialize_domain "
#define TOMOYO_KEYWORD_KEEP_DOMAIN               "keep_domain "
#define TOMOYO_KEYWORD_NO_INITIALIZE_DOMAIN      "no_initialize_domain "
#define TOMOYO_KEYWORD_NO_KEEP_DOMAIN            "no_keep_domain "
#define TOMOYO_KEYWORD_SELECT                    "select "
#define TOMOYO_KEYWORD_UNDELETE                  "undelete "
#define TOMOYO_KEYWORD_USE_PROFILE               "use_profile "
#define TOMOYO_KEYWORD_IGNORE_GLOBAL_ALLOW_READ  "ignore_global_allow_read"
/* A domain definition starts with <kernel>. */
#define TOMOYO_ROOT_NAME                         "<kernel>"
#define TOMOYO_ROOT_NAME_LEN                     (sizeof(TOMOYO_ROOT_NAME) - 1)

/* Index numbers for Access Controls. */
#define TOMOYO_MAC_FOR_FILE                  0  /* domain_policy.conf */
#define TOMOYO_MAX_ACCEPT_ENTRY              1
#define TOMOYO_VERBOSE                       2
#define TOMOYO_MAX_CONTROL_INDEX             3

/* Structure for reading/writing policy via securityfs interfaces. */
struct tomoyo_io_buffer {
	int (*read) (struct tomoyo_io_buffer *);
	int (*write) (struct tomoyo_io_buffer *);
	/* Exclusive lock for this structure.   */
	struct mutex io_sem;
	/* The position currently reading from. */
	struct list_head *read_var1;
	/* Extra variables for reading.         */
	struct list_head *read_var2;
	/* The position currently writing to.   */
	struct tomoyo_domain_info *write_var1;
	/* The step for reading.                */
	int read_step;
	/* Buffer for reading.                  */
	char *read_buf;
	/* EOF flag for reading.                */
	bool read_eof;
	/* Read domain ACL of specified PID?    */
	bool read_single_domain;
	/* Extra variable for reading.          */
	u8 read_bit;
	/* Bytes available for reading.         */
	int read_avail;
	/* Size of read buffer.                 */
	int readbuf_size;
	/* Buffer for writing.                  */
	char *write_buf;
	/* Bytes available for writing.         */
	int write_avail;
	/* Size of write buffer.                */
	int writebuf_size;
};

/* Check whether the domain has too many ACL entries to hold. */
bool tomoyo_domain_quota_is_ok(struct tomoyo_domain_info * const domain);
/* Transactional sprintf() for policy dump. */
bool tomoyo_io_printf(struct tomoyo_io_buffer *head, const char *fmt, ...)
	__attribute__ ((format(printf, 2, 3)));
/* Check whether the domainname is correct. */
bool tomoyo_is_correct_domain(const unsigned char *domainname,
			      const char *function);
/* Check whether the token is correct. */
bool tomoyo_is_correct_path(const char *filename, const s8 start_type,
			    const s8 pattern_type, const s8 end_type,
			    const char *function);
/* Check whether the token can be a domainname. */
bool tomoyo_is_domain_def(const unsigned char *buffer);
/* Check whether the given filename matches the given pattern. */
bool tomoyo_path_matches_pattern(const struct tomoyo_path_info *filename,
				 const struct tomoyo_path_info *pattern);
/* Read "alias" entry in exception policy. */
bool tomoyo_read_alias_policy(struct tomoyo_io_buffer *head);
/*
 * Read "initialize_domain" and "no_initialize_domain" entry
 * in exception policy.
 */
bool tomoyo_read_domain_initializer_policy(struct tomoyo_io_buffer *head);
/* Read "keep_domain" and "no_keep_domain" entry in exception policy. */
bool tomoyo_read_domain_keeper_policy(struct tomoyo_io_buffer *head);
/* Read "file_pattern" entry in exception policy. */
bool tomoyo_read_file_pattern(struct tomoyo_io_buffer *head);
/* Read "allow_read" entry in exception policy. */
bool tomoyo_read_globally_readable_policy(struct tomoyo_io_buffer *head);
/* Read "deny_rewrite" entry in exception policy. */
bool tomoyo_read_no_rewrite_policy(struct tomoyo_io_buffer *head);
/* Write domain policy violation warning message to console? */
bool tomoyo_verbose_mode(const struct tomoyo_domain_info *domain);
/* Convert double path operation to operation name. */
const char *tomoyo_dp2keyword(const u8 operation);
/* Get the last component of the given domainname. */
const char *tomoyo_get_last_name(const struct tomoyo_domain_info *domain);
/* Get warning message. */
const char *tomoyo_get_msg(const bool is_enforce);
/* Convert single path operation to operation name. */
const char *tomoyo_sp2keyword(const u8 operation);
/* Delete a domain. */
int tomoyo_delete_domain(char *data);
/* Create "alias" entry in exception policy. */
int tomoyo_write_alias_policy(char *data, const bool is_delete);
/*
 * Create "initialize_domain" and "no_initialize_domain" entry
 * in exception policy.
 */
int tomoyo_write_domain_initializer_policy(char *data, const bool is_not,
					   const bool is_delete);
/* Create "keep_domain" and "no_keep_domain" entry in exception policy. */
int tomoyo_write_domain_keeper_policy(char *data, const bool is_not,
				      const bool is_delete);
/*
 * Create "allow_read/write", "allow_execute", "allow_read", "allow_write",
 * "allow_create", "allow_unlink", "allow_mkdir", "allow_rmdir",
 * "allow_mkfifo", "allow_mksock", "allow_mkblock", "allow_mkchar",
 * "allow_truncate", "allow_symlink", "allow_rewrite", "allow_rename" and
 * "allow_link" entry in domain policy.
 */
int tomoyo_write_file_policy(char *data, struct tomoyo_domain_info *domain,
			     const bool is_delete);
/* Create "allow_read" entry in exception policy. */
int tomoyo_write_globally_readable_policy(char *data, const bool is_delete);
/* Create "deny_rewrite" entry in exception policy. */
int tomoyo_write_no_rewrite_policy(char *data, const bool is_delete);
/* Create "file_pattern" entry in exception policy. */
int tomoyo_write_pattern_policy(char *data, const bool is_delete);
/* Find a domain by the given name. */
struct tomoyo_domain_info *tomoyo_find_domain(const char *domainname);
/* Find or create a domain by the given name. */
struct tomoyo_domain_info *tomoyo_find_or_assign_new_domain(const char *
							    domainname,
							    const u8 profile);
/* Undelete a domain. */
struct tomoyo_domain_info *tomoyo_undelete_domain(const char *domainname);
/* Check mode for specified functionality. */
unsigned int tomoyo_check_flags(const struct tomoyo_domain_info *domain,
				const u8 index);
/* Allocate memory for structures. */
void *tomoyo_alloc_acl_element(const u8 acl_type);
/* Fill in "struct tomoyo_path_info" members. */
void tomoyo_fill_path_info(struct tomoyo_path_info *ptr);
/* Run policy loader when /sbin/init starts. */
void tomoyo_load_policy(const char *filename);
/* Change "struct tomoyo_domain_info"->flags. */
void tomoyo_set_domain_flag(struct tomoyo_domain_info *domain,
			    const bool is_delete, const u8 flags);

/* strcmp() for "struct tomoyo_path_info" structure. */
static inline bool tomoyo_pathcmp(const struct tomoyo_path_info *a,
				  const struct tomoyo_path_info *b)
{
	return a->hash != b->hash || strcmp(a->name, b->name);
}

/* Get type of an ACL entry. */
static inline u8 tomoyo_acl_type1(struct tomoyo_acl_info *ptr)
{
	return ptr->type & ~TOMOYO_ACL_DELETED;
}

/* Get type of an ACL entry. */
static inline u8 tomoyo_acl_type2(struct tomoyo_acl_info *ptr)
{
	return ptr->type;
}

/**
 * tomoyo_is_valid - Check whether the character is a valid char.
 *
 * @c: The character to check.
 *
 * Returns true if @c is a valid character, false otherwise.
 */
static inline bool tomoyo_is_valid(const unsigned char c)
{
	return c > ' ' && c < 127;
}

/**
 * tomoyo_is_invalid - Check whether the character is an invalid char.
 *
 * @c: The character to check.
 *
 * Returns true if @c is an invalid character, false otherwise.
 */
static inline bool tomoyo_is_invalid(const unsigned char c)
{
	return c && (c <= ' ' || c >= 127);
}

/* The list for "struct tomoyo_domain_info". */
extern struct list_head tomoyo_domain_list;
extern struct rw_semaphore tomoyo_domain_list_lock;

/* Lock for domain->acl_info_list. */
extern struct rw_semaphore tomoyo_domain_acl_info_list_lock;

/* Has /sbin/init started? */
extern bool tomoyo_policy_loaded;

/* The kernel's domain. */
extern struct tomoyo_domain_info tomoyo_kernel_domain;

/**
 * list_for_each_cookie - iterate over a list with cookie.
 * @pos:        the &struct list_head to use as a loop cursor.
 * @cookie:     the &struct list_head to use as a cookie.
 * @head:       the head for your list.
 *
 * Same with list_for_each() except that this primitive uses @cookie
 * so that we can continue iteration.
 * @cookie must be NULL when iteration starts, and @cookie will become
 * NULL when iteration finishes.
 */
#define list_for_each_cookie(pos, cookie, head)                       \
	for (({ if (!cookie)                                          \
				     cookie = head; }),               \
	     pos = (cookie)->next;                                    \
	     prefetch(pos->next), pos != (head) || ((cookie) = NULL); \
	     (cookie) = pos, pos = pos->next)

#endif /* !defined(_SECURITY_TOMOYO_COMMON_H) */
Commit	Line	Data
9590837b KT	1	/*
	2	* security/tomoyo/common.h
	3	*
	4	* Common functions for TOMOYO.
	5	*
	6	* Copyright (C) 2005-2009 NTT DATA CORPORATION
	7	*
	8	* Version: 2.2.0-pre 2009/02/01
	9	*
	10	*/
	11
	12	#ifndef _SECURITY_TOMOYO_COMMON_H
	13	#define _SECURITY_TOMOYO_COMMON_H
	14
	15	#include <linux/ctype.h>
	16	#include <linux/string.h>
	17	#include <linux/mm.h>
	18	#include <linux/file.h>
	19	#include <linux/kmod.h>
	20	#include <linux/fs.h>
	21	#include <linux/sched.h>
	22	#include <linux/namei.h>
	23	#include <linux/mount.h>
	24	#include <linux/list.h>
	25
	26	struct dentry;
	27	struct vfsmount;
	28
	29	/* Temporary buffer for holding pathnames. */
	30	struct tomoyo_page_buffer {
	31	char buffer[4096];
	32	};
	33
	34	/* Structure for holding a token. */
	35	struct tomoyo_path_info {
	36	const char *name;
	37	u32 hash; /* = full_name_hash(name, strlen(name)) */
	38	u16 total_len; /* = strlen(name) */
	39	u16 const_len; /* = tomoyo_const_part_length(name) */
	40	bool is_dir; /* = tomoyo_strendswith(name, "/") */
	41	bool is_patterned; /* = tomoyo_path_contains_pattern(name) */
	42	u16 depth; /* = tomoyo_path_depth(name) */
	43	};
	44
	45	/*
	46	* This is the max length of a token.
	47	*
	48	* A token consists of only ASCII printable characters.
	49	* Non printable characters in a token is represented in \ooo style
	50	* octal string. Thus, \ itself is represented as \\.
	51	*/
	52	#define TOMOYO_MAX_PATHNAME_LEN 4000
	53
	54	/* Structure for holding requested pathname. */
	55	struct tomoyo_path_info_with_data {
	56	/* Keep "head" first, for this pointer is passed to tomoyo_free(). */
	57	struct tomoyo_path_info head;
a106cbfd	58	char barrier1[16]; /* Safeguard for overrun. */
9590837b KT	59	char body[TOMOYO_MAX_PATHNAME_LEN];
	60	char barrier2[16]; /* Safeguard for overrun. */
	61	};
	62
	63	/*
	64	* Common header for holding ACL entries.
	65	*
	66	* Packing "struct tomoyo_acl_info" allows
	67	* "struct tomoyo_single_path_acl_record" to embed "u16" and
	68	* "struct tomoyo_double_path_acl_record" to embed "u8"
	69	* without enlarging their structure size.
	70	*/
	71	struct tomoyo_acl_info {
	72	struct list_head list;
	73	/*
	74	* Type of this ACL entry.
	75	*
	76	* MSB is is_deleted flag.
	77	*/
	78	u8 type;
	79	} __packed;
	80
	81	/* This ACL entry is deleted. */
	82	#define TOMOYO_ACL_DELETED 0x80
	83
	84	/* Structure for domain information. */
	85	struct tomoyo_domain_info {
	86	struct list_head list;
	87	struct list_head acl_info_list;
	88	/* Name of this domain. Never NULL. */
	89	const struct tomoyo_path_info *domainname;
	90	u8 profile; /* Profile number to use. */
	91	u8 is_deleted; /* Delete flag.
	92	0 = active.
	93	1 = deleted but undeletable.
	94	255 = deleted and no longer undeletable. */
	95	bool quota_warned; /* Quota warnning flag. */
	96	/* DOMAIN_FLAGS_. Use tomoyo_set_domain_flag() to modify. /
	97	u8 flags;
	98	};
	99
	100	/* Profile number is an integer between 0 and 255. */
	101	#define TOMOYO_MAX_PROFILES 256
	102
	103	/* Ignore "allow_read" directive in exception policy. */
	104	#define TOMOYO_DOMAIN_FLAGS_IGNORE_GLOBAL_ALLOW_READ 1
	105	/*
	106	* This domain was unable to create a new domain at tomoyo_find_next_domain()
	107	* because the name of the domain to be created was too long or
	108	* it could not allocate memory.
	109	* More than one process continued execve() without domain transition.
	110	*/
	111	#define TOMOYO_DOMAIN_FLAGS_TRANSITION_FAILED 2
	112
	113	/*
	114	* Structure for "allow_read/write", "allow_execute", "allow_read",
	115	* "allow_write", "allow_create", "allow_unlink", "allow_mkdir", "allow_rmdir",
	116	* "allow_mkfifo", "allow_mksock", "allow_mkblock", "allow_mkchar",
	117	* "allow_truncate", "allow_symlink" and "allow_rewrite" directive.
	118	*/
	119	struct tomoyo_single_path_acl_record {
	120	struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_SINGLE_PATH_ACL */
	121	u16 perm;
	122	/* Pointer to single pathname. */
123	const struct tomoyo_path_info *filename;
124	};
125
126	/* Structure for "allow_rename" and "allow_link" directive. */
127	struct tomoyo_double_path_acl_record {
128	struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_DOUBLE_PATH_ACL */
129	u8 perm;
130	/* Pointer to single pathname. */
131	const struct tomoyo_path_info *filename1;
132	/* Pointer to single pathname. */
133	const struct tomoyo_path_info *filename2;
134	};
135
136	/* Keywords for ACLs. */
137	#define TOMOYO_KEYWORD_ALIAS "alias "
138	#define TOMOYO_KEYWORD_ALLOW_READ "allow_read "
139	#define TOMOYO_KEYWORD_DELETE "delete "
140	#define TOMOYO_KEYWORD_DENY_REWRITE "deny_rewrite "
141	#define TOMOYO_KEYWORD_FILE_PATTERN "file_pattern "
142	#define TOMOYO_KEYWORD_INITIALIZE_DOMAIN "initialize_domain "
143	#define TOMOYO_KEYWORD_KEEP_DOMAIN "keep_domain "
144	#define TOMOYO_KEYWORD_NO_INITIALIZE_DOMAIN "no_initialize_domain "
145	#define TOMOYO_KEYWORD_NO_KEEP_DOMAIN "no_keep_domain "
146	#define TOMOYO_KEYWORD_SELECT "select "
147	#define TOMOYO_KEYWORD_UNDELETE "undelete "
148	#define TOMOYO_KEYWORD_USE_PROFILE "use_profile "
149	#define TOMOYO_KEYWORD_IGNORE_GLOBAL_ALLOW_READ "ignore_global_allow_read"
150	/* A domain definition starts with <kernel>. */
151	#define TOMOYO_ROOT_NAME "<kernel>"
152	#define TOMOYO_ROOT_NAME_LEN (sizeof(TOMOYO_ROOT_NAME) - 1)
153
154	/* Index numbers for Access Controls. */
155	#define TOMOYO_MAC_FOR_FILE 0 /* domain_policy.conf */
156	#define TOMOYO_MAX_ACCEPT_ENTRY 1
157	#define TOMOYO_VERBOSE 2
158	#define TOMOYO_MAX_CONTROL_INDEX 3
159
160	/* Structure for reading/writing policy via securityfs interfaces. */
161	struct tomoyo_io_buffer {
162	int (read) (struct tomoyo_io_buffer );
163	int (write) (struct tomoyo_io_buffer );
164	/* Exclusive lock for this structure. */
165	struct mutex io_sem;
166	/* The position currently reading from. */
167	struct list_head *read_var1;
168	/* Extra variables for reading. */
169	struct list_head *read_var2;
170	/* The position currently writing to. */
171	struct tomoyo_domain_info *write_var1;
172	/* The step for reading. */
173	int read_step;
174	/* Buffer for reading. */
175	char *read_buf;
176	/* EOF flag for reading. */
177	bool read_eof;
178	/* Read domain ACL of specified PID? */
179	bool read_single_domain;
180	/* Extra variable for reading. */
181	u8 read_bit;
182	/* Bytes available for reading. */
183	int read_avail;
184	/* Size of read buffer. */
185	int readbuf_size;
186	/* Buffer for writing. */
187	char *write_buf;
188	/* Bytes available for writing. */
189	int write_avail;
190	/* Size of write buffer. */
191	int writebuf_size;
192	};
193
194	/* Check whether the domain has too many ACL entries to hold. */
195	bool tomoyo_domain_quota_is_ok(struct tomoyo_domain_info * const domain);
196	/* Transactional sprintf() for policy dump. */
197	bool tomoyo_io_printf(struct tomoyo_io_buffer head, const char fmt, ...)
198	__attribute__ ((format(printf, 2, 3)));
199	/* Check whether the domainname is correct. */
200	bool tomoyo_is_correct_domain(const unsigned char *domainname,
201	const char *function);
202	/* Check whether the token is correct. */
203	bool tomoyo_is_correct_path(const char *filename, const s8 start_type,
204	const s8 pattern_type, const s8 end_type,
205	const char *function);
206	/* Check whether the token can be a domainname. */
207	bool tomoyo_is_domain_def(const unsigned char *buffer);
208	/* Check whether the given filename matches the given pattern. */
209	bool tomoyo_path_matches_pattern(const struct tomoyo_path_info *filename,
210	const struct tomoyo_path_info *pattern);
211	/* Read "alias" entry in exception policy. */
212	bool tomoyo_read_alias_policy(struct tomoyo_io_buffer *head);
213	/*
214	* Read "initialize_domain" and "no_initialize_domain" entry
215	* in exception policy.
216	*/
217	bool tomoyo_read_domain_initializer_policy(struct tomoyo_io_buffer *head);
218	/* Read "keep_domain" and "no_keep_domain" entry in exception policy. */
219	bool tomoyo_read_domain_keeper_policy(struct tomoyo_io_buffer *head);
220	/* Read "file_pattern" entry in exception policy. */
221	bool tomoyo_read_file_pattern(struct tomoyo_io_buffer *head);
222	/* Read "allow_read" entry in exception policy. */
223	bool tomoyo_read_globally_readable_policy(struct tomoyo_io_buffer *head);
224	/* Read "deny_rewrite" entry in exception policy. */
225	bool tomoyo_read_no_rewrite_policy(struct tomoyo_io_buffer *head);
226	/* Write domain policy violation warning message to console? */
227	bool tomoyo_verbose_mode(const struct tomoyo_domain_info *domain);
228	/* Convert double path operation to operation name. */
229	const char *tomoyo_dp2keyword(const u8 operation);
230	/* Get the last component of the given domainname. */
231	const char tomoyo_get_last_name(const struct tomoyo_domain_info domain);
232	/* Get warning message. */
233	const char *tomoyo_get_msg(const bool is_enforce);
234	/* Convert single path operation to operation name. */
235	const char *tomoyo_sp2keyword(const u8 operation);
236	/* Delete a domain. */
237	int tomoyo_delete_domain(char *data);
238	/* Create "alias" entry in exception policy. */
239	int tomoyo_write_alias_policy(char *data, const bool is_delete);
240	/*
241	* Create "initialize_domain" and "no_initialize_domain" entry
242	* in exception policy.
243	*/
244	int tomoyo_write_domain_initializer_policy(char *data, const bool is_not,
245	const bool is_delete);
246	/* Create "keep_domain" and "no_keep_domain" entry in exception policy. */
247	int tomoyo_write_domain_keeper_policy(char *data, const bool is_not,
248	const bool is_delete);
249	/*
250	* Create "allow_read/write", "allow_execute", "allow_read", "allow_write",
251	* "allow_create", "allow_unlink", "allow_mkdir", "allow_rmdir",
252	* "allow_mkfifo", "allow_mksock", "allow_mkblock", "allow_mkchar",
253	* "allow_truncate", "allow_symlink", "allow_rewrite", "allow_rename" and
254	* "allow_link" entry in domain policy.
255	*/
256	int tomoyo_write_file_policy(char data, struct tomoyo_domain_info domain,
257	const bool is_delete);
258	/* Create "allow_read" entry in exception policy. */
259	int tomoyo_write_globally_readable_policy(char *data, const bool is_delete);
260	/* Create "deny_rewrite" entry in exception policy. */
261	int tomoyo_write_no_rewrite_policy(char *data, const bool is_delete);
262	/* Create "file_pattern" entry in exception policy. */
263	int tomoyo_write_pattern_policy(char *data, const bool is_delete);
264	/* Find a domain by the given name. */
265	struct tomoyo_domain_info tomoyo_find_domain(const char domainname);
266	/* Find or create a domain by the given name. */
267	struct tomoyo_domain_info tomoyo_find_or_assign_new_domain(const char
268	domainname,
269	const u8 profile);
270	/* Undelete a domain. */
271	struct tomoyo_domain_info tomoyo_undelete_domain(const char domainname);
272	/* Check mode for specified functionality. */
273	unsigned int tomoyo_check_flags(const struct tomoyo_domain_info *domain,
274	const u8 index);
275	/* Allocate memory for structures. */
276	void *tomoyo_alloc_acl_element(const u8 acl_type);
277	/* Fill in "struct tomoyo_path_info" members. */
278	void tomoyo_fill_path_info(struct tomoyo_path_info *ptr);
279	/* Run policy loader when /sbin/init starts. */
280	void tomoyo_load_policy(const char *filename);
281	/* Change "struct tomoyo_domain_info"->flags. */
282	void tomoyo_set_domain_flag(struct tomoyo_domain_info *domain,
283	const bool is_delete, const u8 flags);
284
285	/* strcmp() for "struct tomoyo_path_info" structure. */
286	static inline bool tomoyo_pathcmp(const struct tomoyo_path_info *a,
287	const struct tomoyo_path_info *b)
288	{
289	return a->hash != b->hash \|\| strcmp(a->name, b->name);
290	}
291
292	/* Get type of an ACL entry. */
293	static inline u8 tomoyo_acl_type1(struct tomoyo_acl_info *ptr)
294	{
295	return ptr->type & ~TOMOYO_ACL_DELETED;
296	}
297
298	/* Get type of an ACL entry. */
299	static inline u8 tomoyo_acl_type2(struct tomoyo_acl_info *ptr)
300	{
301	return ptr->type;
302	}
303
304	/**
305	* tomoyo_is_valid - Check whether the character is a valid char.
306	*
307	* @c: The character to check.
308	*
309	* Returns true if @c is a valid character, false otherwise.
310	*/
311	static inline bool tomoyo_is_valid(const unsigned char c)
312	{
313	return c > ' ' && c < 127;
314	}
315
316	/**
317	* tomoyo_is_invalid - Check whether the character is an invalid char.
318	*
319	* @c: The character to check.
320	*
321	* Returns true if @c is an invalid character, false otherwise.
322	*/
323	static inline bool tomoyo_is_invalid(const unsigned char c)
324	{
325	return c && (c <= ' ' \|\| c >= 127);
326	}
327
328	/* The list for "struct tomoyo_domain_info". */
329	extern struct list_head tomoyo_domain_list;
330	extern struct rw_semaphore tomoyo_domain_list_lock;
331
332	/* Lock for domain->acl_info_list. */
333	extern struct rw_semaphore tomoyo_domain_acl_info_list_lock;
334
335	/* Has /sbin/init started? */
336	extern bool tomoyo_policy_loaded;
337
338	/* The kernel's domain. */
339	extern struct tomoyo_domain_info tomoyo_kernel_domain;
340
341	/**
342	* list_for_each_cookie - iterate over a list with cookie.
343	* @pos: the &struct list_head to use as a loop cursor.
344	* @cookie: the &struct list_head to use as a cookie.
345	* @head: the head for your list.
346	*
347	* Same with list_for_each() except that this primitive uses @cookie
348	* so that we can continue iteration.
349	* @cookie must be NULL when iteration starts, and @cookie will become
350	* NULL when iteration finishes.
351	*/
352	#define list_for_each_cookie(pos, cookie, head) \
353	for (({ if (!cookie) \
354	cookie = head; }), \
355	pos = (cookie)->next; \
356	prefetch(pos->next), pos != (head) \|\| ((cookie) = NULL); \
357	(cookie) = pos, pos = pos->next)
358
359	#endif /* !defined(_SECURITY_TOMOYO_COMMON_H) */