에프에이리눅스 / 1611_0007_prime_oven

Blame view

kernel/linux-imx6_3.14.28/security/selinux/ss/context.h 3.97 KB
edit raw normal view history
6b13f685e   김민수   BSP 최초 추가 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
  /*
   * A security context is a set of security attributes
   * associated with each subject and object controlled
   * by the security policy.  Security contexts are
    * externally represented as variable-length strings
   * that can be interpreted by a user or application
   * with an understanding of the security policy.
   * Internally, the security server uses a simple
   * structure.  This structure is private to the
   * security server and can be changed without affecting
   * clients of the security server.
   *
   * Author : Stephen Smalley, <sds@epoch.ncsc.mil>
   */
  #ifndef _SS_CONTEXT_H_
  #define _SS_CONTEXT_H_
  
  #include "ebitmap.h"
  #include "mls_types.h"
  #include "security.h"
  
  /*
   * A security context consists of an authenticated user
   * identity, a role, a type and a MLS range.
   */
  struct context {
  	u32 user;
  	u32 role;
  	u32 type;
  	u32 len;        /* length of string in bytes */
  	struct mls_range range;
  	char *str;	/* string representation if context cannot be mapped. */
  };
  
  static inline void mls_context_init(struct context *c)
  {
  	memset(&c->range, 0, sizeof(c->range));
  }
  
  static inline int mls_context_cpy(struct context *dst, struct context *src)
  {
  	int rc;
  
  	dst->range.level[0].sens = src->range.level[0].sens;
  	rc = ebitmap_cpy(&dst->range.level[0].cat, &src->range.level[0].cat);
  	if (rc)
  		goto out;
  
  	dst->range.level[1].sens = src->range.level[1].sens;
  	rc = ebitmap_cpy(&dst->range.level[1].cat, &src->range.level[1].cat);
  	if (rc)
  		ebitmap_destroy(&dst->range.level[0].cat);
  out:
  	return rc;
  }
  
  /*
   * Sets both levels in the MLS range of 'dst' to the low level of 'src'.
   */
  static inline int mls_context_cpy_low(struct context *dst, struct context *src)
  {
  	int rc;
  
  	dst->range.level[0].sens = src->range.level[0].sens;
  	rc = ebitmap_cpy(&dst->range.level[0].cat, &src->range.level[0].cat);
  	if (rc)
  		goto out;
  
  	dst->range.level[1].sens = src->range.level[0].sens;
  	rc = ebitmap_cpy(&dst->range.level[1].cat, &src->range.level[0].cat);
  	if (rc)
  		ebitmap_destroy(&dst->range.level[0].cat);
  out:
  	return rc;
  }
  
  /*
   * Sets both levels in the MLS range of 'dst' to the high level of 'src'.
   */
  static inline int mls_context_cpy_high(struct context *dst, struct context *src)
  {
  	int rc;
  
  	dst->range.level[0].sens = src->range.level[1].sens;
  	rc = ebitmap_cpy(&dst->range.level[0].cat, &src->range.level[1].cat);
  	if (rc)
  		goto out;
  
  	dst->range.level[1].sens = src->range.level[1].sens;
  	rc = ebitmap_cpy(&dst->range.level[1].cat, &src->range.level[1].cat);
  	if (rc)
  		ebitmap_destroy(&dst->range.level[0].cat);
  out:
  	return rc;
  }
  
  static inline int mls_context_cmp(struct context *c1, struct context *c2)
  {
  	return ((c1->range.level[0].sens == c2->range.level[0].sens) &&
  		ebitmap_cmp(&c1->range.level[0].cat, &c2->range.level[0].cat) &&
  		(c1->range.level[1].sens == c2->range.level[1].sens) &&
  		ebitmap_cmp(&c1->range.level[1].cat, &c2->range.level[1].cat));
  }
  
  static inline void mls_context_destroy(struct context *c)
  {
  	ebitmap_destroy(&c->range.level[0].cat);
  	ebitmap_destroy(&c->range.level[1].cat);
  	mls_context_init(c);
  }
  
  static inline void context_init(struct context *c)
  {
  	memset(c, 0, sizeof(*c));
  }
  
  static inline int context_cpy(struct context *dst, struct context *src)
  {
  	int rc;
  
  	dst->user = src->user;
  	dst->role = src->role;
  	dst->type = src->type;
  	if (src->str) {
  		dst->str = kstrdup(src->str, GFP_ATOMIC);
  		if (!dst->str)
  			return -ENOMEM;
  		dst->len = src->len;
  	} else {
  		dst->str = NULL;
  		dst->len = 0;
  	}
  	rc = mls_context_cpy(dst, src);
  	if (rc) {
  		kfree(dst->str);
  		return rc;
  	}
  	return 0;
  }
  
  static inline void context_destroy(struct context *c)
  {
  	c->user = c->role = c->type = 0;
  	kfree(c->str);
  	c->str = NULL;
  	c->len = 0;
  	mls_context_destroy(c);
  }
  
  static inline int context_cmp(struct context *c1, struct context *c2)
  {
  	if (c1->len && c2->len)
  		return (c1->len == c2->len && !strcmp(c1->str, c2->str));
  	if (c1->len || c2->len)
  		return 0;
  	return ((c1->user == c2->user) &&
  		(c1->role == c2->role) &&
  		(c1->type == c2->type) &&
  		mls_context_cmp(c1, c2));
  }
  
  #endif	/* _SS_CONTEXT_H_ */