shared/util.c

   1 /*
   2  * kmod - interface to kernel module operations
   3  *
   4  * Copyright (C) 2011-2013  ProFUSION embedded systems
   5  * Copyright (C) 2012  Lucas De Marchi <lucas.de.marchi@gmail.com>
   6  * Copyright (C) 2013-2014  Intel Corporation. All rights reserved.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <assert.h>
  23 #include <ctype.h>
  24 #include <errno.h>
  25 #include <stdarg.h>
  26 #include <stddef.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31
  32 #include <shared/missing.h>
  33 #include <shared/util.h>
  34
  35 #define USEC_PER_SEC  1000000ULL
  36 #define NSEC_PER_USEC 1000ULL
  37
  38 static const struct kmod_ext {
  39         const char *ext;
  40         size_t len;
  41 } kmod_exts[] = {
  42         {KMOD_EXTENSION_UNCOMPRESSED, sizeof(KMOD_EXTENSION_UNCOMPRESSED) - 1},
  43 #ifdef ENABLE_ZLIB
  44         {".ko.gz", sizeof(".ko.gz") - 1},
  45 #endif
  46 #ifdef ENABLE_XZ
  47         {".ko.xz", sizeof(".ko.xz") - 1},
  48 #endif
  49         { }
  50 };
  51
  52 assert_cc(EAGAIN == EWOULDBLOCK);
  53
  54 /* string handling functions and memory allocations                         */
  55 /* ************************************************************************ */
  56
  57 void *memdup(const void *p, size_t n)
  58 {
  59         void *r = malloc(n);
  60
  61         if (r == NULL)
  62                 return NULL;
  63
  64         return memcpy(r, p, n);
  65 }
  66
  67 char *strchr_replace(char *s, char c, char r)
  68 {
  69         char *p;
  70
  71         for (p = s; *p != '\0'; p++) {
  72                 if (*p == c)
  73                         *p = r;
  74         }
  75
  76         return s;
  77 }
  78
  79 /* module-related functions                                                 */
  80 /* ************************************************************************ */
  81 int alias_normalize(const char *alias, char buf[static PATH_MAX], size_t *len)
  82 {
  83         size_t i;
  84
  85         for (i = 0; i < PATH_MAX - 1; i++) {
  86                 const char c = alias[i];
  87                 switch (c) {
  88                 case '-':
  89                         buf[i] = '_';
  90                         break;
  91                 case ']':
  92                         return -EINVAL;
  93                 case '[':
  94                         while (alias[i] != ']' && alias[i] != '\0') {
  95                                 buf[i] = alias[i];
  96                                 i++;
  97                         }
  98
  99                         if (alias[i] != ']')
 100                                 return -EINVAL;
 101
 102                         buf[i] = alias[i];
 103                         break;
 104                 case '\0':
 105                         goto finish;
 106                 default:
 107                         buf[i] = c;
 108                 }
 109         }
 110
 111 finish:
 112         buf[i] = '\0';
 113         if (len)
 114                 *len = i;
 115
 116         return 0;
 117 }
 118
 119 /*
 120  * Replace dashes with underscores.
 121  * Dashes inside character range patterns (e.g. [0-9]) are left unchanged.
 122  *
 123  * For convenience, it returns error if @s is NULL
 124  */
 125 int underscores(char *s)
 126 {
 127         unsigned int i;
 128
 129         if (!s)
 130                 return -EINVAL;
 131
 132         for (i = 0; s[i]; i++) {
 133                 switch (s[i]) {
 134                 case '-':
 135                         s[i] = '_';
 136                         break;
 137                 case ']':
 138                         return -EINVAL;
 139                 case '[':
 140                         i += strcspn(&s[i], "]");
 141                         if (!s[i])
 142                                 return -EINVAL;
 143                         break;
 144                 }
 145         }
 146
 147         return 0;
 148 }
 149
 150 char *modname_normalize(const char *modname, char buf[static PATH_MAX], size_t *len)
 151 {
 152         size_t s;
 153
 154         for (s = 0; s < PATH_MAX - 1; s++) {
 155                 const char c = modname[s];
 156                 if (c == '-')
 157                         buf[s] = '_';
 158                 else if (c == '\0' || c == '.')
 159                         break;
 160                 else
 161                         buf[s] = c;
 162         }
 163
 164         buf[s] = '\0';
 165
 166         if (len)
 167                 *len = s;
 168
 169         return buf;
 170 }
 171
 172 char *path_to_modname(const char *path, char buf[static PATH_MAX], size_t *len)
 173 {
 174         char *modname;
 175
 176         modname = basename(path);
 177         if (modname == NULL || modname[0] == '\0')
 178                 return NULL;
 179
 180         return modname_normalize(modname, buf, len);
 181 }
 182
 183 bool path_ends_with_kmod_ext(const char *path, size_t len)
 184 {
 185         const struct kmod_ext *eitr;
 186
 187         for (eitr = kmod_exts; eitr->ext != NULL; eitr++) {
 188                 if (len <= eitr->len)
 189                         continue;
 190                 if (streq(path + len - eitr->len, eitr->ext))
 191                         return true;
 192         }
 193
 194         return false;
 195 }
 196
 197 /* read-like and fread-like functions                                       */
 198 /* ************************************************************************ */
 199 ssize_t read_str_safe(int fd, char *buf, size_t buflen)
 200 {
 201         size_t todo = buflen - 1;
 202         size_t done = 0;
 203
 204         do {
 205                 ssize_t r = read(fd, buf + done, todo);
 206
 207                 if (r == 0)
 208                         break;
 209                 else if (r > 0) {
 210                         todo -= r;
 211                         done += r;
 212                 } else {
 213                         if (errno == EAGAIN || errno == EINTR)
 214                                 continue;
 215                         else
 216                                 return -errno;
 217                 }
 218         } while (todo > 0);
 219
 220         buf[done] = '\0';
 221         return done;
 222 }
 223
 224 ssize_t write_str_safe(int fd, const char *buf, size_t buflen)
 225 {
 226         size_t todo = buflen;
 227         size_t done = 0;
 228
 229         do {
 230                 ssize_t r = write(fd, buf + done, todo);
 231
 232                 if (r == 0)
 233                         break;
 234                 else if (r > 0) {
 235                         todo -= r;
 236                         done += r;
 237                 } else {
 238                         if (errno == EAGAIN || errno == EINTR)
 239                                 continue;
 240                         else
 241                                 return -errno;
 242                 }
 243         } while (todo > 0);
 244
 245         return done;
 246 }
 247
 248 int read_str_long(int fd, long *value, int base)
 249 {
 250         char buf[32], *end;
 251         long v;
 252         int err;
 253
 254         *value = 0;
 255         err = read_str_safe(fd, buf, sizeof(buf));
 256         if (err < 0)
 257                 return err;
 258         errno = 0;
 259         v = strtol(buf, &end, base);
 260         if (end == buf || !isspace(*end))
 261                 return -EINVAL;
 262
 263         *value = v;
 264         return 0;
 265 }
 266
 267 int read_str_ulong(int fd, unsigned long *value, int base)
 268 {
 269         char buf[32], *end;
 270         long v;
 271         int err;
 272
 273         *value = 0;
 274         err = read_str_safe(fd, buf, sizeof(buf));
 275         if (err < 0)
 276                 return err;
 277         errno = 0;
 278         v = strtoul(buf, &end, base);
 279         if (end == buf || !isspace(*end))
 280                 return -EINVAL;
 281         *value = v;
 282         return 0;
 283 }
 284
 285 /*
 286  * Read one logical line from a configuration file.
 287  *
 288  * Line endings may be escaped with backslashes, to form one logical line from
 289  * several physical lines.  No end of line character(s) are included in the
 290  * result.
 291  *
 292  * If linenum is not NULL, it is incremented by the number of physical lines
 293  * which have been read.
 294  */
 295 char *freadline_wrapped(FILE *fp, unsigned int *linenum)
 296 {
 297         int size = 256;
 298         int i = 0, n = 0;
 299         _cleanup_free_ char *buf = malloc(size);
 300
 301         if (buf == NULL)
 302                 return NULL;
 303
 304         for(;;) {
 305                 int ch = getc_unlocked(fp);
 306
 307                 switch(ch) {
 308                 case EOF:
 309                         if (i == 0)
 310                                 return NULL;
 311                         /* else fall through */
 312
 313                 case '\n':
 314                         n++;
 315
 316                         {
 317                                 char *ret = buf;
 318                                 ret[i] = '\0';
 319                                 buf = NULL;
 320                                 if (linenum)
 321                                         *linenum += n;
 322                                 return ret;
 323                         }
 324
 325                 case '\\':
 326                         ch = getc_unlocked(fp);
 327
 328                         if (ch == '\n') {
 329                                 n++;
 330                                 continue;
 331                         }
 332                         /* else fall through */
 333
 334                 default:
 335                         buf[i++] = ch;
 336
 337                         if (i == size) {
 338                                 char *tmp;
 339                                 size *= 2;
 340                                 tmp = realloc(buf, size);
 341                                 if (!tmp)
 342                                         return NULL;
 343                                 buf = tmp;
 344                         }
 345                 }
 346         }
 347 }
 348
 349 /* path handling functions                                                  */
 350 /* ************************************************************************ */
 351
 352 bool path_is_absolute(const char *p)
 353 {
 354         assert(p != NULL);
 355
 356         return p[0] == '/';
 357 }
 358
 359 char *path_make_absolute_cwd(const char *p)
 360 {
 361         _cleanup_free_ char *cwd = NULL;
 362         size_t plen, cwdlen;
 363         char *r;
 364
 365         if (path_is_absolute(p))
 366                 return strdup(p);
 367
 368         cwd = get_current_dir_name();
 369         if (!cwd)
 370                 return NULL;
 371
 372         plen = strlen(p);
 373         cwdlen = strlen(cwd);
 374
 375         /* cwd + '/' + p + '\0' */
 376         r = realloc(cwd, cwdlen + 1 + plen + 1);
 377         if (r == NULL)
 378                 return NULL;
 379
 380         cwd = NULL;
 381         r[cwdlen] = '/';
 382         memcpy(&r[cwdlen + 1], p, plen + 1);
 383
 384         return r;
 385 }
 386
 387 static inline int is_dir(const char *path)
 388 {
 389         struct stat st;
 390
 391         if (stat(path, &st) >= 0)
 392                 return S_ISDIR(st.st_mode);
 393
 394         return -errno;
 395 }
 396
 397 int mkdir_p(const char *path, int len, mode_t mode)
 398 {
 399         char *start, *end;
 400
 401         start = strndupa(path, len);
 402         end = start + len;
 403
 404         /*
 405          * scan backwards, replacing '/' with '\0' while the component doesn't
 406          * exist
 407          */
 408         for (;;) {
 409                 int r = is_dir(start);
 410                 if (r > 0) {
 411                         end += strlen(end);
 412
 413                         if (end == start + len)
 414                                 return 0;
 415
 416                         /* end != start, since it would be caught on the first
 417                          * iteration */
 418                         *end = '/';
 419                         break;
 420                 } else if (r == 0)
 421                         return -ENOTDIR;
 422
 423                 if (end == start)
 424                         break;
 425
 426                 *end = '\0';
 427
 428                 /* Find the next component, backwards, discarding extra '/'*/
 429                 while (end > start && *end != '/')
 430                         end--;
 431
 432                 while (end > start && *(end - 1) == '/')
 433                         end--;
 434         }
 435
 436         for (; end < start + len;) {
 437                 if (mkdir(start, mode) < 0 && errno != EEXIST)
 438                         return -errno;
 439
 440                 end += strlen(end);
 441                 *end = '/';
 442         }
 443
 444         return 0;
 445 }
 446
 447 int mkdir_parents(const char *path, mode_t mode)
 448 {
 449         char *end = strrchr(path, '/');
 450
 451         /* no parent directories */
 452         if (end == NULL)
 453                 return 0;
 454
 455         return mkdir_p(path, end - path, mode);
 456 }
 457
 458 unsigned long long ts_usec(const struct timespec *ts)
 459 {
 460         return (unsigned long long) ts->tv_sec * USEC_PER_SEC +
 461                (unsigned long long) ts->tv_nsec / NSEC_PER_USEC;
 462 }
 463
 464 unsigned long long stat_mstamp(const struct stat *st)
 465 {
 466 #ifdef HAVE_STRUCT_STAT_ST_MTIM
 467         return ts_usec(&st->st_mtim);
 468 #else
 469         return (unsigned long long) st->st_mtime;
 470 #endif
 471 }