Debian Codegraph @

src/shared/clean-ipc.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <fcntl.h>
4 #include <mqueue.h>
5 #include <stdio.h>
6 #include <sys/ipc.h>
7 #include <sys/msg.h>
8 #include <sys/sem.h>
9 #include <sys/shm.h>
10 #include <sys/stat.h>
11 #include <unistd.h>
12
13 #include "alloc-util.h"
14 #include "clean-ipc.h"
15 #include "dirent-util.h"
16 #include "fd-util.h"
17 #include "fileio.h"
18 #include "format-util.h"
19 #include "log.h"
20 #include "path-util.h"
21 #include "user-util.h"
22
23 static bool match_uid_gid(uid_t subject_uid, gid_t subject_gid, uid_t delete_uid, gid_t delete_gid) {
24
25 if (uid_is_valid(delete_uid) && subject_uid == delete_uid)
26 return true;
27
28 if (gid_is_valid(delete_gid) && subject_gid == delete_gid)
29 return true;
30
31 return false;
32 }
33
34 static int clean_sysvipc_shm(uid_t delete_uid, gid_t delete_gid, bool rm) {
35 _cleanup_fclose_ FILE *f = NULL;
36 bool first = true;
37 int ret = 0, r;
38
39 f = fopen("/proc/sysvipc/shm", "re");
40 if (!f) {
41 if (errno == ENOENT)
42 return 0;
43
44 return log_warning_errno(errno, "Failed to open %s: %m", "/proc/sysvipc/shm");
45 }
46
47 for (;;) {
48 _cleanup_free_ char *line = NULL;
49 unsigned n_attached;
50 pid_t cpid, lpid;
51 uid_t uid, cuid;
52 gid_t gid, cgid;
53 int shmid;
54
55 r = read_line(f, LONG_LINE_MAX, &line);
56 if (r < 0)
57 return log_warning_errno(r, "Failed to read /proc/sysvipc/shm: %m");
58 if (r == 0)
59 break;
60
61 if (first) {
62 first = false;
63 continue;
64 }
65
66 if (sscanf(line, "%*i %i %*o %*u " PID_FMT " " PID_FMT " %u " UID_FMT " " GID_FMT " " UID_FMT " " GID_FMT,
67 &shmid, &cpid, &lpid, &n_attached, &uid, &gid, &cuid, &cgid) != 8)
68 continue;
69
70 if (n_attached > 0)
71 continue;
72
73 if (!match_uid_gid(uid, gid, delete_uid, delete_gid))
74 continue;
75
76 if (!rm)
77 return 1;
78
79 if (shmctl(shmid, IPC_RMID, NULL) < 0) {
80
81 /* Ignore entries that are already deleted */
82 if (IN_SET(errno, EIDRM, EINVAL))
83 continue;
84
85 ret = log_warning_errno(errno,
86 "Failed to remove SysV shared memory segment %i: %m",
87 shmid);
88 } else {
89 log_debug("Removed SysV shared memory segment %i.", shmid);
90 if (ret == 0)
91 ret = 1;
92 }
93 }
94
95 return ret;
96 }
97
98 static int clean_sysvipc_sem(uid_t delete_uid, gid_t delete_gid, bool rm) {
99 _cleanup_fclose_ FILE *f = NULL;
100 bool first = true;
101 int ret = 0, r;
102
103 f = fopen("/proc/sysvipc/sem", "re");
104 if (!f) {
105 if (errno == ENOENT)
106 return 0;
107
108 return log_warning_errno(errno, "Failed to open %s: %m", "/proc/sysvipc/sem");
109 }
110
111 for (;;) {
112 _cleanup_free_ char *line = NULL;
113 uid_t uid, cuid;
114 gid_t gid, cgid;
115 int semid;
116
117 r = read_line(f, LONG_LINE_MAX, &line);
118 if (r < 0)
119 return log_warning_errno(r, "Failed to read /proc/sysvipc/sem: %m");
120 if (r == 0)
121 break;
122
123 if (first) {
124 first = false;
125 continue;
126 }
127
128 if (sscanf(line, "%*i %i %*o %*u " UID_FMT " " GID_FMT " " UID_FMT " " GID_FMT,
129 &semid, &uid, &gid, &cuid, &cgid) != 5)
130 continue;
131
132 if (!match_uid_gid(uid, gid, delete_uid, delete_gid))
133 continue;
134
135 if (!rm)
136 return 1;
137
138 if (semctl(semid, 0, IPC_RMID) < 0) {
139
140 /* Ignore entries that are already deleted */
141 if (IN_SET(errno, EIDRM, EINVAL))
142 continue;
143
144 ret = log_warning_errno(errno,
145 "Failed to remove SysV semaphores object %i: %m",
146 semid);
147 } else {
148 log_debug("Removed SysV semaphore %i.", semid);
149 if (ret == 0)
150 ret = 1;
151 }
152 }
153
154 return ret;
155 }
156
157 static int clean_sysvipc_msg(uid_t delete_uid, gid_t delete_gid, bool rm) {
158 _cleanup_fclose_ FILE *f = NULL;
159 bool first = true;
160 int ret = 0, r;
161
162 f = fopen("/proc/sysvipc/msg", "re");
163 if (!f) {
164 if (errno == ENOENT)
165 return 0;
166
167 return log_warning_errno(errno, "Failed to open %s: %m", "/proc/sysvipc/msg");
168 }
169
170 for (;;) {
171 _cleanup_free_ char *line = NULL;
172 uid_t uid, cuid;
173 gid_t gid, cgid;
174 pid_t cpid, lpid;
175 int msgid;
176
177 r = read_line(f, LONG_LINE_MAX, &line);
178 if (r < 0)
179 return log_warning_errno(r, "Failed to read /proc/sysvipc/msg: %m");
180 if (r == 0)
181 break;
182
183 if (first) {
184 first = false;
185 continue;
186 }
187
188 if (sscanf(line, "%*i %i %*o %*u %*u " PID_FMT " " PID_FMT " " UID_FMT " " GID_FMT " " UID_FMT " " GID_FMT,
189 &msgid, &cpid, &lpid, &uid, &gid, &cuid, &cgid) != 7)
190 continue;
191
192 if (!match_uid_gid(uid, gid, delete_uid, delete_gid))
193 continue;
194
195 if (!rm)
196 return 1;
197
198 if (msgctl(msgid, IPC_RMID, NULL) < 0) {
199
200 /* Ignore entries that are already deleted */
201 if (IN_SET(errno, EIDRM, EINVAL))
202 continue;
203
204 ret = log_warning_errno(errno,
205 "Failed to remove SysV message queue %i: %m",
206 msgid);
207 } else {
208 log_debug("Removed SysV message queue %i.", msgid);
209 if (ret == 0)
210 ret = 1;
211 }
212 }
213
214 return ret;
215 }
216
217 static int clean_posix_shm_internal(const char *dirname, DIR *dir, uid_t uid, gid_t gid, bool rm) {
218 int ret = 0, r;
219
220 assert(dir);
221
222 FOREACH_DIRENT_ALL(de, dir, goto fail) {
223 struct stat st;
224
225 if (dot_or_dot_dot(de->d_name))
226 continue;
227
228 if (fstatat(dirfd(dir), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
229 if (errno == ENOENT)
230 continue;
231
232 ret = log_warning_errno(errno, "Failed to stat() POSIX shared memory segment %s/%s: %m",
233 dirname, de->d_name);
234 continue;
235 }
236
237 if (S_ISDIR(st.st_mode)) {
238 _cleanup_closedir_ DIR *kid = NULL;
239
240 kid = xopendirat(dirfd(dir), de->d_name, O_NOFOLLOW|O_NOATIME);
241 if (!kid) {
242 if (errno != ENOENT)
243 ret = log_warning_errno(errno, "Failed to enter shared memory directory %s/%s: %m",
244 dirname, de->d_name);
245 } else {
246 r = clean_posix_shm_internal(de->d_name, kid, uid, gid, rm);
247 if (r < 0)
248 ret = r;
249 }
250
251 if (!match_uid_gid(st.st_uid, st.st_gid, uid, gid))
252 continue;
253
254 if (!rm)
255 return 1;
256
257 if (unlinkat(dirfd(dir), de->d_name, AT_REMOVEDIR) < 0) {
258
259 if (errno == ENOENT)
260 continue;
261
262 ret = log_warning_errno(errno, "Failed to remove POSIX shared memory directory %s/%s: %m",
263 dirname, de->d_name);
264 } else {
265 log_debug("Removed POSIX shared memory directory %s", de->d_name);
266 if (ret == 0)
267 ret = 1;
268 }
269 } else {
270
271 if (!match_uid_gid(st.st_uid, st.st_gid, uid, gid))
272 continue;
273
274 if (!rm)
275 return 1;
276
277 if (unlinkat(dirfd(dir), de->d_name, 0) < 0) {
278
279 if (errno == ENOENT)
280 continue;
281
282 ret = log_warning_errno(errno, "Failed to remove POSIX shared memory segment %s: %m", de->d_name);
283 } else {
284 log_debug("Removed POSIX shared memory segment %s", de->d_name);
285 if (ret == 0)
286 ret = 1;
287 }
288 }
289 }
290
291 return ret;
292
293 fail:
294 return log_warning_errno(errno, "Failed to read /dev/shm: %m");
295 }
296
297 static int clean_posix_shm(uid_t uid, gid_t gid, bool rm) {
298 _cleanup_closedir_ DIR *dir = NULL;
299
300 dir = opendir("/dev/shm");
301 if (!dir) {
302 if (errno == ENOENT)
303 return 0;
304
305 return log_warning_errno(errno, "Failed to open %s: %m", "/dev/shm");
306 }
307
308 return clean_posix_shm_internal("/dev/shm", dir, uid, gid, rm);
309 }
310
311 static int clean_posix_mq(uid_t uid, gid_t gid, bool rm) {
312 _cleanup_closedir_ DIR *dir = NULL;
313 int ret = 0;
314
315 dir = opendir("/dev/mqueue");
316 if (!dir) {
317 if (errno == ENOENT)
318 return 0;
319
320 return log_warning_errno(errno, "Failed to open %s: %m", "/dev/mqueue");
321 }
322
323 FOREACH_DIRENT_ALL(de, dir, goto fail) {
324 struct stat st;
325 char fn[1+strlen(de->d_name)+1];
326
327 if (dot_or_dot_dot(de->d_name))
328 continue;
329
330 if (fstatat(dirfd(dir), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
331 if (errno == ENOENT)
332 continue;
333
334 ret = log_warning_errno(errno,
335 "Failed to stat() MQ segment %s: %m",
336 de->d_name);
337 continue;
338 }
339
340 if (!match_uid_gid(st.st_uid, st.st_gid, uid, gid))
341 continue;
342
343 if (!rm)
344 return 1;
345
346 fn[0] = '/';
347 strcpy(fn+1, de->d_name);
348
349 if (mq_unlink(fn) < 0) {
350 if (errno == ENOENT)
351 continue;
352
353 ret = log_warning_errno(errno,
354 "Failed to unlink POSIX message queue %s: %m",
355 fn);
356 } else {
357 log_debug("Removed POSIX message queue %s", fn);
358 if (ret == 0)
359 ret = 1;
360 }
361 }
362
363 return ret;
364
365 fail:
366 return log_warning_errno(errno, "Failed to read /dev/mqueue: %m");
367 }
368
369 int clean_ipc_internal(uid_t uid, gid_t gid, bool rm) {
370 int ret = 0, r;
371
372 /* If 'rm' is true, clean all IPC objects owned by either the specified UID or the specified GID. Return the
373 * last error encountered or == 0 if no matching IPC objects have been found or > 0 if matching IPC objects
374 * have been found and have been removed.
375 *
376 * If 'rm' is false, just search for IPC objects owned by either the specified UID or the specified GID. In
377 * this case we return < 0 on error, > 0 if we found a matching object, == 0 if we didn't.
378 *
379 * As special rule: if UID/GID is specified as root we'll silently not clean up things, and always claim that
380 * there are IPC objects for it. */
381
382 if (uid == 0) {
383 if (!rm)
384 return 1;
385
386 uid = UID_INVALID;
387 }
388 if (gid == 0) {
389 if (!rm)
390 return 1;
391
392 gid = GID_INVALID;
393 }
394
395 /* Anything to do? */
396 if (!uid_is_valid(uid) && !gid_is_valid(gid))
397 return 0;
398
399 r = clean_sysvipc_shm(uid, gid, rm);
400 if (r != 0) {
401 if (!rm)
402 return r;
403 if (ret == 0)
404 ret = r;
405 }
406
407 r = clean_sysvipc_sem(uid, gid, rm);
408 if (r != 0) {
409 if (!rm)
410 return r;
411 if (ret == 0)
412 ret = r;
413 }
414
415 r = clean_sysvipc_msg(uid, gid, rm);
416 if (r != 0) {
417 if (!rm)
418 return r;
419 if (ret == 0)
420 ret = r;
421 }
422
423 r = clean_posix_shm(uid, gid, rm);
424 if (r != 0) {
425 if (!rm)
426 return r;
427 if (ret == 0)
428 ret = r;
429 }
430
431 r = clean_posix_mq(uid, gid, rm);
432 if (r != 0) {
433 if (!rm)
434 return r;
435 if (ret == 0)
436 ret = r;
437 }
438
439 return ret;
440 }
441
442 int clean_ipc_by_uid(uid_t uid) {
443 return clean_ipc_internal(uid, GID_INVALID, true);
444 }
445
446 int clean_ipc_by_gid(gid_t gid) {
447 return clean_ipc_internal(UID_INVALID, gid, true);
448 }