chiark / gitweb /
Fix service file to match installed elogind binary location
[elogind.git] / src / basic / smack-util.c
1 /***
2   This file is part of systemd.
3
4   Copyright 2013 Intel Corporation
5
6   Author: Auke Kok <auke-jan.h.kok@intel.com>
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <string.h>
24 #include <sys/stat.h>
25 #include <sys/xattr.h>
26 #include <unistd.h>
27
28 #include "alloc-util.h"
29 #include "fileio.h"
30 #include "log.h"
31 #include "macro.h"
32 #include "path-util.h"
33 #include "process-util.h"
34 #include "smack-util.h"
35 #include "string-table.h"
36 #include "xattr-util.h"
37
38 #ifdef HAVE_SMACK
39 bool mac_smack_use(void) {
40         static int cached_use = -1;
41
42         if (cached_use < 0)
43                 cached_use = access("/sys/fs/smackfs/", F_OK) >= 0;
44
45         return cached_use;
46 }
47
48 #if 0 /// UNNEEDED by elogind
49 static const char* const smack_attr_table[_SMACK_ATTR_MAX] = {
50         [SMACK_ATTR_ACCESS]     = "security.SMACK64",
51         [SMACK_ATTR_EXEC]       = "security.SMACK64EXEC",
52         [SMACK_ATTR_MMAP]       = "security.SMACK64MMAP",
53         [SMACK_ATTR_TRANSMUTE]  = "security.SMACK64TRANSMUTE",
54         [SMACK_ATTR_IPIN]       = "security.SMACK64IPIN",
55         [SMACK_ATTR_IPOUT]      = "security.SMACK64IPOUT",
56 };
57
58 DEFINE_STRING_TABLE_LOOKUP(smack_attr, SmackAttr);
59
60 int mac_smack_read(const char *path, SmackAttr attr, char **label) {
61         assert(path);
62         assert(attr >= 0 && attr < _SMACK_ATTR_MAX);
63         assert(label);
64
65         if (!mac_smack_use())
66                 return 0;
67
68         return getxattr_malloc(path, smack_attr_to_string(attr), label, true);
69 }
70
71 int mac_smack_read_fd(int fd, SmackAttr attr, char **label) {
72         assert(fd >= 0);
73         assert(attr >= 0 && attr < _SMACK_ATTR_MAX);
74         assert(label);
75
76         if (!mac_smack_use())
77                 return 0;
78
79         return fgetxattr_malloc(fd, smack_attr_to_string(attr), label);
80 }
81
82 int mac_smack_apply(const char *path, SmackAttr attr, const char *label) {
83         int r;
84
85         assert(path);
86         assert(attr >= 0 && attr < _SMACK_ATTR_MAX);
87
88         if (!mac_smack_use())
89                 return 0;
90
91         if (label)
92                 r = lsetxattr(path, smack_attr_to_string(attr), label, strlen(label), 0);
93         else
94                 r = lremovexattr(path, smack_attr_to_string(attr));
95         if (r < 0)
96                 return -errno;
97
98         return 0;
99 }
100
101 int mac_smack_apply_fd(int fd, SmackAttr attr, const char *label) {
102         int r;
103
104         assert(fd >= 0);
105         assert(attr >= 0 && attr < _SMACK_ATTR_MAX);
106
107         if (!mac_smack_use())
108                 return 0;
109
110         if (label)
111                 r = fsetxattr(fd, smack_attr_to_string(attr), label, strlen(label), 0);
112         else
113                 r = fremovexattr(fd, smack_attr_to_string(attr));
114         if (r < 0)
115                 return -errno;
116
117         return 0;
118 }
119
120 int mac_smack_apply_pid(pid_t pid, const char *label) {
121         const char *p;
122         int r = 0;
123
124         assert(label);
125
126         if (!mac_smack_use())
127                 return 0;
128
129         p = procfs_file_alloca(pid, "attr/current");
130         r = write_string_file(p, label, 0);
131         if (r < 0)
132                 return r;
133
134         return r;
135 }
136 #endif // 0
137
138 int mac_smack_fix(const char *path, bool ignore_enoent, bool ignore_erofs) {
139         struct stat st;
140         int r = 0;
141
142         assert(path);
143
144         if (!mac_smack_use())
145                 return 0;
146
147         /*
148          * Path must be in /dev and must exist
149          */
150         if (!path_startswith(path, "/dev"))
151                 return 0;
152
153         r = lstat(path, &st);
154         if (r >= 0) {
155                 const char *label;
156
157                 /*
158                  * Label directories and character devices "*".
159                  * Label symlinks "_".
160                  * Don't change anything else.
161                  */
162
163                 if (S_ISDIR(st.st_mode))
164                         label = SMACK_STAR_LABEL;
165                 else if (S_ISLNK(st.st_mode))
166                         label = SMACK_FLOOR_LABEL;
167                 else if (S_ISCHR(st.st_mode))
168                         label = SMACK_STAR_LABEL;
169                 else
170                         return 0;
171
172                 r = lsetxattr(path, "security.SMACK64", label, strlen(label), 0);
173
174                 /* If the FS doesn't support labels, then exit without warning */
175                 if (r < 0 && errno == EOPNOTSUPP)
176                         return 0;
177         }
178
179         if (r < 0) {
180                 /* Ignore ENOENT in some cases */
181                 if (ignore_enoent && errno == ENOENT)
182                         return 0;
183
184                 if (ignore_erofs && errno == EROFS)
185                         return 0;
186
187                 r = log_debug_errno(errno, "Unable to fix SMACK label of %s: %m", path);
188         }
189
190         return r;
191 }
192
193 #if 0 /// UNNEEDED by elogind
194 int mac_smack_copy(const char *dest, const char *src) {
195         int r = 0;
196         _cleanup_free_ char *label = NULL;
197
198         assert(dest);
199         assert(src);
200
201         r = mac_smack_read(src, SMACK_ATTR_ACCESS, &label);
202         if (r < 0)
203                 return r;
204
205         r = mac_smack_apply(dest, SMACK_ATTR_ACCESS, label);
206         if (r < 0)
207                 return r;
208
209         return r;
210 }
211 #endif // 0
212
213 #else
214 bool mac_smack_use(void) {
215         return false;
216 }
217
218 #if 0 /// UNNEEDED by elogind
219 int mac_smack_read(const char *path, SmackAttr attr, char **label) {
220         return -EOPNOTSUPP;
221 }
222
223 int mac_smack_read_fd(int fd, SmackAttr attr, char **label) {
224         return -EOPNOTSUPP;
225 }
226
227 int mac_smack_apply(const char *path, SmackAttr attr, const char *label) {
228         return 0;
229 }
230
231 int mac_smack_apply_fd(int fd, SmackAttr attr, const char *label) {
232         return 0;
233 }
234
235 int mac_smack_apply_pid(pid_t pid, const char *label) {
236         return 0;
237 }
238 #endif // 0
239
240 int mac_smack_fix(const char *path, bool ignore_enoent, bool ignore_erofs) {
241         return 0;
242 }
243
244 #if 0 /// UNNEEDED by elogind
245 int mac_smack_copy(const char *dest, const char *src) {
246         return 0;
247 }
248 #endif // 0
249 #endif