chiark / gitweb /
bootctl: typo fix in help message
[elogind.git] / src / libudev / libudev-util.c
1 /***
2   This file is part of systemd.
3
4   Copyright 2008-2012 Kay Sievers <kay@vrfy.org>
5
6   systemd is free software; you can redistribute it and/or modify it
7   under the terms of the GNU Lesser General Public License as published by
8   the Free Software Foundation; either version 2.1 of the License, or
9   (at your option) any later version.
10
11   systemd is distributed in the hope that it will be useful, but
12   WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14   Lesser General Public License for more details.
15
16   You should have received a copy of the GNU Lesser General Public License
17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
18 ***/
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <stddef.h>
23 #include <unistd.h>
24 #include <errno.h>
25 #include <string.h>
26 #include <dirent.h>
27 #include <ctype.h>
28 #include <fcntl.h>
29 #include <time.h>
30 #include <pwd.h>
31 #include <grp.h>
32 #include <sys/stat.h>
33 #include <sys/param.h>
34
35 #include "device-nodes.h"
36 #include "libudev.h"
37 #include "libudev-private.h"
38 #include "utf8.h"
39
40 /**
41  * SECTION:libudev-util
42  * @short_description: utils
43  *
44  * Utilities useful when dealing with devices and device node names.
45  */
46
47 int util_delete_path(struct udev *udev, const char *path)
48 {
49         char p[UTIL_PATH_SIZE];
50         char *pos;
51         int err = 0;
52
53         if (path[0] == '/')
54                 while(path[1] == '/')
55                         path++;
56         strscpy(p, sizeof(p), path);
57         pos = strrchr(p, '/');
58         if (pos == p || pos == NULL)
59                 return 0;
60
61         for (;;) {
62                 *pos = '\0';
63                 pos = strrchr(p, '/');
64
65                 /* don't remove the last one */
66                 if ((pos == p) || (pos == NULL))
67                         break;
68
69                 err = rmdir(p);
70                 if (err < 0) {
71                         if (errno == ENOENT)
72                                 err = 0;
73                         break;
74                 }
75         }
76         return err;
77 }
78
79 uid_t util_lookup_user(struct udev *udev, const char *user)
80 {
81         char *endptr;
82         struct passwd pwbuf;
83         struct passwd *pw;
84         uid_t uid;
85         size_t buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
86         char *buf = alloca(buflen);
87
88         if (streq(user, "root"))
89                 return 0;
90         uid = strtoul(user, &endptr, 10);
91         if (endptr[0] == '\0')
92                 return uid;
93
94         errno = getpwnam_r(user, &pwbuf, buf, buflen, &pw);
95         if (pw != NULL)
96                 return pw->pw_uid;
97         if (errno == 0 || errno == ENOENT || errno == ESRCH)
98                 udev_err(udev, "specified user '%s' unknown\n", user);
99         else
100                 udev_err(udev, "error resolving user '%s': %m\n", user);
101         return 0;
102 }
103
104 gid_t util_lookup_group(struct udev *udev, const char *group)
105 {
106         char *endptr;
107         struct group grbuf;
108         struct group *gr;
109         gid_t gid = 0;
110         size_t buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
111         char *buf = NULL;
112
113         if (streq(group, "root"))
114                 return 0;
115         gid = strtoul(group, &endptr, 10);
116         if (endptr[0] == '\0')
117                 return gid;
118         gid = 0;
119         for (;;) {
120                 char *newbuf;
121
122                 newbuf = realloc(buf, buflen);
123                 if (!newbuf)
124                         break;
125                 buf = newbuf;
126                 errno = getgrnam_r(group, &grbuf, buf, buflen, &gr);
127                 if (gr != NULL) {
128                         gid = gr->gr_gid;
129                 } else if (errno == ERANGE) {
130                         buflen *= 2;
131                         continue;
132                 } else if (errno == 0 || errno == ENOENT || errno == ESRCH) {
133                         udev_err(udev, "specified group '%s' unknown\n", group);
134                 } else {
135                         udev_err(udev, "error resolving group '%s': %m\n", group);
136                 }
137                 break;
138         }
139         free(buf);
140         return gid;
141 }
142
143 /* handle "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
144 int util_resolve_subsys_kernel(struct udev *udev, const char *string,
145                                char *result, size_t maxsize, int read_value)
146 {
147         char temp[UTIL_PATH_SIZE];
148         char *subsys;
149         char *sysname;
150         struct udev_device *dev;
151         char *attr;
152
153         if (string[0] != '[')
154                 return -1;
155
156         strscpy(temp, sizeof(temp), string);
157
158         subsys = &temp[1];
159
160         sysname = strchr(subsys, '/');
161         if (sysname == NULL)
162                 return -1;
163         sysname[0] = '\0';
164         sysname = &sysname[1];
165
166         attr = strchr(sysname, ']');
167         if (attr == NULL)
168                 return -1;
169         attr[0] = '\0';
170         attr = &attr[1];
171         if (attr[0] == '/')
172                 attr = &attr[1];
173         if (attr[0] == '\0')
174                 attr = NULL;
175
176         if (read_value && attr == NULL)
177                 return -1;
178
179         dev = udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
180         if (dev == NULL)
181                 return -1;
182
183         if (read_value) {
184                 const char *val;
185
186                 val = udev_device_get_sysattr_value(dev, attr);
187                 if (val != NULL)
188                         strscpy(result, maxsize, val);
189                 else
190                         result[0] = '\0';
191                 udev_dbg(udev, "value '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
192         } else {
193                 size_t l;
194                 char *s;
195
196                 s = result;
197                 l = strpcpyl(&s, maxsize, udev_device_get_syspath(dev), NULL);
198                 if (attr != NULL)
199                         strpcpyl(&s, l, "/", attr, NULL);
200                 udev_dbg(udev, "path '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
201         }
202         udev_device_unref(dev);
203         return 0;
204 }
205 ssize_t util_get_sys_core_link_value(struct udev *udev, const char *slink, const char *syspath, char *value, size_t size)
206 {
207         char path[UTIL_PATH_SIZE];
208         char target[UTIL_PATH_SIZE];
209         ssize_t len;
210         const char *pos;
211
212         strscpyl(path, sizeof(path), syspath, "/", slink, NULL);
213         len = readlink(path, target, sizeof(target));
214         if (len <= 0 || len == (ssize_t)sizeof(target))
215                 return -1;
216         target[len] = '\0';
217         pos = strrchr(target, '/');
218         if (pos == NULL)
219                 return -1;
220         pos = &pos[1];
221         return strscpy(value, size, pos);
222 }
223
224 int util_resolve_sys_link(struct udev *udev, char *syspath, size_t size)
225 {
226         char link_target[UTIL_PATH_SIZE];
227
228         ssize_t len;
229         int i;
230         int back;
231         char *base = NULL;
232
233         len = readlink(syspath, link_target, sizeof(link_target));
234         if (len <= 0 || len == (ssize_t)sizeof(link_target))
235                 return -1;
236         link_target[len] = '\0';
237
238         for (back = 0; startswith(&link_target[back * 3], "../"); back++)
239                 ;
240         for (i = 0; i <= back; i++) {
241                 base = strrchr(syspath, '/');
242                 if (base == NULL)
243                         return -EINVAL;
244                 base[0] = '\0';
245         }
246
247         strscpyl(base, size - (base - syspath), "/", &link_target[back * 3], NULL);
248         return 0;
249 }
250
251 int util_log_priority(const char *priority)
252 {
253         char *endptr;
254         int prio;
255
256         prio = strtol(priority, &endptr, 10);
257         if (endptr[0] == '\0' || isspace(endptr[0]))
258                 return prio;
259         if (startswith(priority, "err"))
260                 return LOG_ERR;
261         if (startswith(priority, "info"))
262                 return LOG_INFO;
263         if (startswith(priority, "debug"))
264                 return LOG_DEBUG;
265         return 0;
266 }
267
268 size_t util_path_encode(const char *src, char *dest, size_t size)
269 {
270         size_t i, j;
271
272         for (i = 0, j = 0; src[i] != '\0'; i++) {
273                 if (src[i] == '/') {
274                         if (j+4 >= size) {
275                                 j = 0;
276                                 break;
277                         }
278                         memcpy(&dest[j], "\\x2f", 4);
279                         j += 4;
280                 } else if (src[i] == '\\') {
281                         if (j+4 >= size) {
282                                 j = 0;
283                                 break;
284                         }
285                         memcpy(&dest[j], "\\x5c", 4);
286                         j += 4;
287                 } else {
288                         if (j+1 >= size) {
289                                 j = 0;
290                                 break;
291                         }
292                         dest[j] = src[i];
293                         j++;
294                 }
295         }
296         dest[j] = '\0';
297         return j;
298 }
299
300 void util_remove_trailing_chars(char *path, char c)
301 {
302         size_t len;
303
304         if (path == NULL)
305                 return;
306         len = strlen(path);
307         while (len > 0 && path[len-1] == c)
308                 path[--len] = '\0';
309 }
310
311 int util_replace_whitespace(const char *str, char *to, size_t len)
312 {
313         size_t i, j;
314
315         /* strip trailing whitespace */
316         len = strnlen(str, len);
317         while (len && isspace(str[len-1]))
318                 len--;
319
320         /* strip leading whitespace */
321         i = 0;
322         while (isspace(str[i]) && (i < len))
323                 i++;
324
325         j = 0;
326         while (i < len) {
327                 /* substitute multiple whitespace with a single '_' */
328                 if (isspace(str[i])) {
329                         while (isspace(str[i]))
330                                 i++;
331                         to[j++] = '_';
332                 }
333                 to[j++] = str[i++];
334         }
335         to[j] = '\0';
336         return 0;
337 }
338
339 /* allow chars in whitelist, plain ascii, hex-escaping and valid utf8 */
340 int util_replace_chars(char *str, const char *white)
341 {
342         size_t i = 0;
343         int replaced = 0;
344
345         while (str[i] != '\0') {
346                 int len;
347
348                 if (whitelisted_char_for_devnode(str[i], white)) {
349                         i++;
350                         continue;
351                 }
352
353                 /* accept hex encoding */
354                 if (str[i] == '\\' && str[i+1] == 'x') {
355                         i += 2;
356                         continue;
357                 }
358
359                 /* accept valid utf8 */
360                 len = utf8_encoded_valid_unichar(&str[i]);
361                 if (len > 1) {
362                         i += len;
363                         continue;
364                 }
365
366                 /* if space is allowed, replace whitespace with ordinary space */
367                 if (isspace(str[i]) && white != NULL && strchr(white, ' ') != NULL) {
368                         str[i] = ' ';
369                         i++;
370                         replaced++;
371                         continue;
372                 }
373
374                 /* everything else is replaced with '_' */
375                 str[i] = '_';
376                 i++;
377                 replaced++;
378         }
379         return replaced;
380 }
381
382 /**
383  * udev_util_encode_string:
384  * @str: input string to be encoded
385  * @str_enc: output string to store the encoded input string
386  * @len: maximum size of the output string, which may be
387  *       four times as long as the input string
388  *
389  * Encode all potentially unsafe characters of a string to the
390  * corresponding 2 char hex value prefixed by '\x'.
391  *
392  * Returns: 0 if the entire string was copied, non-zero otherwise.
393  **/
394 _public_ int udev_util_encode_string(const char *str, char *str_enc, size_t len)
395 {
396         return encode_devnode_name(str, str_enc, len);
397 }
398
399 /*
400  * http://sites.google.com/site/murmurhash/
401  *
402  * All code is released to the public domain. For business purposes,
403  * Murmurhash is under the MIT license.
404  *
405  */
406 static unsigned int murmur_hash2(const char *key, size_t len, unsigned int seed)
407 {
408         /*
409          *  'm' and 'r' are mixing constants generated offline.
410          *  They're not really 'magic', they just happen to work well.
411          */
412         const unsigned int m = 0x5bd1e995;
413         const int r = 24;
414
415         /* initialize the hash to a 'random' value */
416         unsigned int h = seed ^ len;
417
418         /* mix 4 bytes at a time into the hash */
419         const unsigned char * data = (const unsigned char *)key;
420
421         while(len >= sizeof(unsigned int)) {
422                 unsigned int k;
423
424                 memcpy(&k, data, sizeof(k));
425                 k *= m;
426                 k ^= k >> r;
427                 k *= m;
428                 h *= m;
429                 h ^= k;
430
431                 data += sizeof(k);
432                 len -= sizeof(k);
433         }
434
435         /* handle the last few bytes of the input array */
436         switch(len) {
437         case 3:
438                 h ^= data[2] << 16;
439         case 2:
440                 h ^= data[1] << 8;
441         case 1:
442                 h ^= data[0];
443                 h *= m;
444         };
445
446         /* do a few final mixes of the hash to ensure the last few bytes are well-incorporated */
447         h ^= h >> 13;
448         h *= m;
449         h ^= h >> 15;
450
451         return h;
452 }
453
454 unsigned int util_string_hash32(const char *str)
455 {
456         return murmur_hash2(str, strlen(str), 0);
457 }
458
459 /* get a bunch of bit numbers out of the hash, and set the bits in our bit field */
460 uint64_t util_string_bloom64(const char *str)
461 {
462         uint64_t bits = 0;
463         unsigned int hash = util_string_hash32(str);
464
465         bits |= 1LLU << (hash & 63);
466         bits |= 1LLU << ((hash >> 6) & 63);
467         bits |= 1LLU << ((hash >> 12) & 63);
468         bits |= 1LLU << ((hash >> 18) & 63);
469         return bits;
470 }
471
472 ssize_t print_kmsg(const char *fmt, ...)
473 {
474         int fd;
475         va_list ap;
476         char text[1024];
477         ssize_t len;
478         ssize_t ret;
479
480         fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC);
481         if (fd < 0)
482                 return -errno;
483
484         len = snprintf(text, sizeof(text), "<30>systemd-udevd[%u]: ", getpid());
485
486         va_start(ap, fmt);
487         len += vsnprintf(text + len, sizeof(text) - len, fmt, ap);
488         va_end(ap);
489
490         ret = write(fd, text, len);
491         if (ret < 0)
492                 ret = -errno;
493         close(fd);
494         return ret;
495 }