/*
* libudev - interface to udev device information
*
- * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2008-2009 Kay Sievers <kay.sievers@vrfy.org>
*
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
*/
#include <stdio.h>
ssize_t len;
const char *pos;
- util_strlcpy(path, syspath, sizeof(path));
- util_strlcat(path, "/", sizeof(path));
- util_strlcat(path, slink, sizeof(path));
+ util_strscpyl(path, sizeof(path), syspath, "/", slink, NULL);
len = readlink(path, path, sizeof(path));
if (len < 0 || len >= (ssize_t) sizeof(path))
return -1;
if (pos == NULL)
return -1;
pos = &pos[1];
- info(udev, "resolved link to: '%s'\n", pos);
- return util_strlcpy(value, pos, size);
+ dbg(udev, "resolved link to: '%s'\n", pos);
+ return util_strscpy(value, size, pos);
}
ssize_t util_get_sys_subsystem(struct udev *udev, const char *syspath, char *subsystem, size_t size)
int len;
int i;
int back;
+ char *base;
len = readlink(syspath, link_target, sizeof(link_target));
if (len <= 0)
;
dbg(udev, "base '%s', tail '%s', back %i\n", syspath, &link_target[back * 3], back);
for (i = 0; i <= back; i++) {
- char *pos = strrchr(syspath, '/');
-
- if (pos == NULL)
+ base = strrchr(syspath, '/');
+ if (base == NULL)
return -1;
- pos[0] = '\0';
+ base[0] = '\0';
}
dbg(udev, "after moving back '%s'\n", syspath);
- util_strlcat(syspath, "/", size);
- util_strlcat(syspath, &link_target[back * 3], size);
+ util_strscpyl(base, size - (base - syspath), "/", &link_target[back * 3], NULL);
return 0;
}
return 0;
}
-size_t util_path_encode(char *s, size_t len)
+size_t util_path_encode(const char *src, char *dest, size_t size)
{
- char t[(len * 3)+1];
size_t i, j;
- t[0] = '\0';
- for (i = 0, j = 0; s[i] != '\0'; i++) {
- if (s[i] == '/') {
- memcpy(&t[j], "\\x2f", 4);
+ for (i = 0, j = 0; src[i] != '\0'; i++) {
+ if (src[i] == '/') {
+ if (j+4 >= size) {
+ j = 0;
+ break;
+ }
+ memcpy(&dest[j], "\\x2f", 4);
j += 4;
- } else if (s[i] == '\\') {
- memcpy(&t[j], "\\x5c", 4);
+ } else if (src[i] == '\\') {
+ if (j+4 >= size) {
+ j = 0;
+ break;
+ }
+ memcpy(&dest[j], "\\x5c", 4);
j += 4;
} else {
- t[j] = s[i];
+ if (j+1 >= size) {
+ j = 0;
+ break;
+ }
+ dest[j] = src[i];
j++;
}
}
- t[j] = '\0';
- strncpy(s, t, len);
+ dest[j] = '\0';
return j;
}
if (memcmp(&s[i], "\\x2f", 4) == 0) {
s[j] = '/';
i += 4;
- }else if (memcmp(&s[i], "\\x5c", 4) == 0) {
+ } else if (memcmp(&s[i], "\\x5c", 4) == 0) {
s[j] = '\\';
i += 4;
} else {
path[--len] = '\0';
}
-size_t util_strlcpy(char *dst, const char *src, size_t size)
+/*
+ * Concatenates strings. In any case, terminates in _all_ cases with '\0'
+ * and moves the @dest pointer forward to the added '\0'. Returns the
+ * remaining size, and 0 if the string was truncated.
+ */
+size_t util_strpcpy(char **dest, size_t size, const char *src)
{
- size_t bytes = 0;
- char *q = dst;
- const char *p = src;
- char ch;
-
- while ((ch = *p++)) {
- if (bytes+1 < size)
- *q++ = ch;
- bytes++;
+ size_t len;
+
+ len = strlen(src);
+ if (len >= size) {
+ if (size > 1)
+ *dest = mempcpy(*dest, src, size-1);
+ size = 0;
+ *dest[0] = '\0';
+ } else {
+ if (len > 0) {
+ *dest = mempcpy(*dest, src, len);
+ size -= len;
+ }
+ *dest[0] = '\0';
}
+ return size;
+}
+
+/* concatenates list of strings, moves dest forward */
+size_t util_strpcpyl(char **dest, size_t size, const char *src, ...)
+{
+ va_list va;
+
+ va_start(va, src);
+ do {
+ size = util_strpcpy(dest, size, src);
+ src = va_arg(va, char *);
+ } while (src != NULL);
+ va_end(va);
- /* If size == 0 there is no space for a final null... */
- if (size)
- *q = '\0';
- return bytes;
+ return size;
}
-size_t util_strlcat(char *dst, const char *src, size_t size)
+/* copies string */
+size_t util_strscpy(char *dest, size_t size, const char *src)
{
- size_t bytes = 0;
- char *q = dst;
- const char *p = src;
- char ch;
-
- while (bytes < size && *q) {
- q++;
- bytes++;
- }
- if (bytes == size)
- return (bytes + strlen(src));
+ char *s;
- while ((ch = *p++)) {
- if (bytes+1 < size)
- *q++ = ch;
- bytes++;
- }
+ s = dest;
+ return util_strpcpy(&s, size, src);
+}
- *q = '\0';
- return bytes;
+/* concatenates list of strings */
+size_t util_strscpyl(char *dest, size_t size, const char *src, ...)
+{
+ va_list va;
+ char *s;
+
+ va_start(va, src);
+ s = dest;
+ do {
+ size = util_strpcpy(&s, size, src);
+ src = va_arg(va, char *);
+ } while (src != NULL);
+ va_end(va);
+
+ return size;
}
/* count of characters used to encode one unicode char */
return len;
}
+int udev_util_replace_whitespace(const char *str, char *to, size_t len)
+{
+ size_t i, j;
+
+ /* strip trailing whitespace */
+ len = strnlen(str, len);
+ while (len && isspace(str[len-1]))
+ len--;
+
+ /* strip leading whitespace */
+ i = 0;
+ while (isspace(str[i]) && (i < len))
+ i++;
+
+ j = 0;
+ while (i < len) {
+ /* substitute multiple whitespace with a single '_' */
+ if (isspace(str[i])) {
+ while (isspace(str[i]))
+ i++;
+ to[j++] = '_';
+ }
+ to[j++] = str[i++];
+ }
+ to[j] = '\0';
+ return 0;
+}
+
+static int is_whitelisted(char c, const char *white)
+{
+ if ((c >= '0' && c <= '9') ||
+ (c >= 'A' && c <= 'Z') ||
+ (c >= 'a' && c <= 'z') ||
+ strchr("#+-.:=@_", c) != NULL ||
+ (white != NULL && strchr(white, c) != NULL))
+ return 1;
+ return 0;
+}
+
/* allow chars in whitelist, plain ascii, hex-escaping and valid utf8 */
-int util_replace_chars(char *str, const char *white)
+int udev_util_replace_chars(char *str, const char *white)
{
size_t i = 0;
int replaced = 0;
while (str[i] != '\0') {
int len;
- /* accept whitelist */
- if (white != NULL && strchr(white, str[i]) != NULL) {
- i++;
- continue;
- }
-
- /* accept plain ascii char */
- if ((str[i] >= '0' && str[i] <= '9') ||
- (str[i] >= 'A' && str[i] <= 'Z') ||
- (str[i] >= 'a' && str[i] <= 'z')) {
+ if (is_whitelisted(str[i], white)) {
i++;
continue;
}
}
/* if space is allowed, replace whitespace with ordinary space */
- if (isspace(str[i]) && strchr(white, ' ') != NULL) {
+ if (isspace(str[i]) && white != NULL && strchr(white, ' ') != NULL) {
str[i] = ' ';
i++;
replaced++;
i++;
replaced++;
}
-
return replaced;
}
+
+/**
+ * util_encode_string:
+ * @str: input string to be encoded
+ * @str_enc: output string to store the encoded input string
+ * @len: maximum size of the output string, which may be
+ * four times as long as the input string
+ *
+ * Encode all potentially unsafe characters of a string to the
+ * corresponding hex value prefixed by '\x'.
+ *
+ * Returns: 0 if the entire string was copied, non-zero otherwise.
+ **/
+int udev_util_encode_string(const char *str, char *str_enc, size_t len)
+{
+ size_t i, j;
+
+ if (str == NULL || str_enc == NULL || len == 0)
+ return -1;
+
+ str_enc[0] = '\0';
+ for (i = 0, j = 0; str[i] != '\0'; i++) {
+ int seqlen;
+
+ seqlen = utf8_encoded_valid_unichar(&str[i]);
+ if (seqlen > 1) {
+ memcpy(&str_enc[j], &str[i], seqlen);
+ j += seqlen;
+ i += (seqlen-1);
+ } else if (str[i] == '\\' || !is_whitelisted(str[i], NULL)) {
+ sprintf(&str_enc[j], "\\x%02x", (unsigned char) str[i]);
+ j += 4;
+ } else {
+ str_enc[j] = str[i];
+ j++;
+ }
+ if (j+3 >= len)
+ goto err;
+ }
+ str_enc[j] = '\0';
+ return 0;
+err:
+ return -1;
+}
+
+void util_set_fd_cloexec(int fd)
+{
+ int flags;
+
+ flags = fcntl(fd, F_GETFD);
+ if (flags < 0)
+ flags = FD_CLOEXEC;
+ else
+ flags |= FD_CLOEXEC;
+ fcntl(fd, F_SETFD, flags);
+}
+
+unsigned int util_string_hash32(const char *str)
+{
+ unsigned int hash = 0;
+
+ while (str[0] != '\0') {
+ hash += str[0] << 4;
+ hash += str[0] >> 4;
+ hash *= 11;
+ str++;
+ }
+ return hash;
+}
~ianmdlvl / elogind.git / blobdiff