* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "config.h"
-
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include "libudev.h"
#include "libudev-private.h"
-static ssize_t get_sys_link(struct udev *udev, const char *slink, const char *syspath, char *subsystem, size_t size)
+static ssize_t get_sys_link(struct udev *udev, const char *slink, const char *syspath, char *value, size_t size)
{
char path[UTIL_PATH_SIZE];
ssize_t len;
if (pos == NULL)
return -1;
pos = &pos[1];
- return util_strlcpy(subsystem, pos, size);
+ dbg(udev, "resolved link to: '%s'\n", pos);
+ return util_strlcpy(value, pos, size);
}
ssize_t util_get_sys_subsystem(struct udev *udev, const char *syspath, char *subsystem, size_t size)
return 0;
}
-struct util_name_entry *util_name_list_add(struct udev *udev, struct list_head *name_list,
- const char *name, const char *value, int sort)
-{
- struct util_name_entry *name_loop;
- struct util_name_entry *name_new;
-
- /* avoid duplicate entries */
- list_for_each_entry(name_loop, name_list, node) {
- if (strcmp(name_loop->name, name) == 0) {
- dbg(udev, "'%s' is already in the list\n", name);
- return name_loop;
- }
- }
-
- if (sort) {
- list_for_each_entry(name_loop, name_list, node) {
- if (strcmp(name_loop->name, name) > 0)
- break;
- }
- }
-
- name_new = malloc(sizeof(struct util_name_entry));
- if (name_new == NULL)
- return NULL;
- memset(name_new, 0x00, sizeof(struct util_name_entry));
- name_new->name = strdup(name);
- if (name_new->name == NULL) {
- free(name_new);
- return NULL;
- }
- if (value != NULL) {
- name_new->value = strdup(value);
- if (name_new->value == NULL) {
- free(name_new);
- return NULL;
- }
- }
- dbg(udev, "adding '%s=%s'\n", name_new->name, name_new->value);
- list_add_tail(&name_new->node, &name_loop->node);
- return name_new;
-}
-
-void util_name_list_cleanup(struct udev *udev, struct list_head *name_list)
-{
- struct util_name_entry *name_loop;
- struct util_name_entry *name_tmp;
-
- list_for_each_entry_safe(name_loop, name_tmp, name_list, node) {
- list_del(&name_loop->node);
- free(name_loop->name);
- free(name_loop->value);
- free(name_loop);
- }
-}
-
int util_log_priority(const char *priority)
{
char *endptr;
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);
j++;
}
}
- t[j] = '\0';
- strncpy(s, t, len);
+ if (len == 0)
+ return j;
+ i = (j < len - 1) ? j : len - 1;
+ memcpy(s, t, i);
+ s[i] = '\0';
return j;
}
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;
+}