str.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * Copyright 2009, 2010 Daniel Borkmann.
   4  * Subject to the GPL, version 2.
   5  */
   6
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <stdarg.h>
  10 #include <arpa/inet.h>
  11
  12 #include "str.h"
  13 #include "die.h"
  14 #include "xmalloc.h"
  15
  16 size_t strlcpy(char *dest, const char *src, size_t size)
  17 {
  18         size_t ret = strlen(src);
  19
  20         if (size) {
  21                 size_t len = (ret >= size) ? size - 1 : ret;
  22
  23                 memcpy(dest, src, len);
  24                 dest[len] = '\0';
  25         }
  26
  27         return ret;
  28 }
  29
  30 static inline int vslprintf(char *dst, size_t size, const char *fmt, va_list ap)
  31 {
  32         int ret;
  33
  34         ret = vsnprintf(dst, size, fmt, ap);
  35         dst[size - 1] = '\0';
  36
  37         return ret;
  38 }
  39
  40 int slprintf(char *dst, size_t size, const char *fmt, ...)
  41 {
  42         int ret;
  43         va_list ap;
  44
  45         va_start(ap, fmt);
  46         ret = vslprintf(dst, size, fmt, ap);
  47         va_end(ap);
  48
  49         return ret;
  50 }
  51
  52 int slprintf_nocheck(char *dst, size_t size, const char *fmt, ...)
  53 {
  54         int ret;
  55         va_list ap;
  56
  57         va_start(ap, fmt);
  58         ret = vslprintf(dst, size, fmt, ap);
  59         va_end(ap);
  60
  61         return ret;
  62 }
  63
  64 noinline void *xmemset(void *s, int c, size_t n)
  65 {
  66         size_t i;
  67         uint8_t *ptr = s;
  68
  69         for (i = 0; i < n; ++i)
  70                 ptr[i] = (uint8_t) c;
  71
  72         return ptr;
  73 }
  74
  75 char *strtrim_right(char *p, char c)
  76 {
  77         char *end;
  78         size_t len;
  79
  80         len = strlen(p);
  81         while (*p && len) {
  82                 end = p + len - 1;
  83                 if (c == *end)
  84                         *end = 0;
  85                 else
  86                         break;
  87                 len = strlen(p);
  88         }
  89
  90         return p;
  91 }
  92
  93 char *argv2str(int startind, int argc, char **argv)
  94 {
  95         off_t offset = 0;
  96         char *str = NULL;
  97         int ret, i;
  98
  99         for (i = startind; i < argc; ++i) {
 100                 size_t tlen = (i < argc - 1) ? 2 : 1;
 101                 size_t alen = strlen(argv[i]) + tlen;
 102                 size_t slen = str ? strlen(str) : 0;
 103
 104                 str = xrealloc(str, slen + alen);
 105                 ret = slprintf(str + offset, strlen(argv[i]) + tlen, "%s%s",
 106                                 argv[i], tlen == 2 ? " " : "");
 107                 if (ret < 0)
 108                         panic("Cannot concatenate string!\n");
 109                 else
 110                         offset += ret;
 111         }
 112
 113         return str;
 114 }
 115
 116 char **argv_insert(char **argv, size_t *count, const char *str)
 117 {
 118         argv = xrealloc(argv, (*count + 2) * sizeof(char *));
 119         argv[*count] = str ? xstrdup(str) : xstrdup("");
 120         argv[*count + 1] = NULL;
 121
 122         *count += 1;
 123         return argv;
 124 }
 125
 126 void argv_free(char **argv)
 127 {
 128         char **tmp = argv;
 129
 130         for (; argv && *argv; argv++)
 131                 free(*argv);
 132
 133         free(tmp);
 134 }
 135
 136 int str2mac(const char *str, uint8_t *mac, size_t len)
 137 {
 138         int i, count;
 139         unsigned int tmp[6];
 140
 141         if (!str)
 142                return -EINVAL;
 143         if (len < 6)
 144                 return -ENOSPC;
 145
 146         errno = 0;
 147         count = sscanf(str, "%02X:%02X:%02X:%02X:%02X:%02X",
 148                         &tmp[0], &tmp[1], &tmp[2], &tmp[3], &tmp[4], &tmp[5]);
 149
 150         if (errno || count != 6)
 151                 count = sscanf(str, "%02x:%02x:%02x:%02x:%02x:%02x",
 152                         &tmp[0], &tmp[1], &tmp[2], &tmp[3], &tmp[4], &tmp[5]);
 153
 154         if (count != 6)
 155                 return -EINVAL;
 156         if (errno)
 157                 return -errno;
 158
 159         for (i = 0; i < 6; i++)
 160                 mac[i] = (uint8_t)tmp[i];
 161
 162         return 0;
 163 }
 164
 165 char *str2fqdn(const char *str)
 166 {
 167         size_t slen = strlen(str);
 168         size_t flen = 0;
 169         char *fqdn;
 170         char *tmp;
 171         char *dup;
 172         int i = 0;
 173         int c = 0;
 174
 175         dup = xstrdup(str);
 176         tmp = dup;
 177
 178         fqdn = xzmalloc(slen + 2);
 179
 180         while (tmp <= dup + slen && c++ <= slen) {
 181                 if (tmp[i] == '.' || tmp[i] == '\0') {
 182                         size_t dlen;
 183
 184                         tmp[i] = '\0';
 185                         dlen = strlen(tmp);
 186                         fqdn[flen] = dlen;
 187                         memcpy(&fqdn[flen + 1], tmp, dlen);
 188                         flen += dlen + 1;
 189                         tmp += dlen + 1;
 190                         i = 0;
 191
 192                         continue;
 193                 }
 194
 195                 i++;
 196         }
 197
 198         xfree(dup);
 199         return fqdn;
 200 }