polyp/util.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of polypaudio.
   5
   6   polypaudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   polypaudio 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
  17   License along with polypaudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <signal.h>
  29 #include <errno.h>
  30 #include <assert.h>
  31 #include <string.h>
  32 #include <stdio.h>
  33 #include <fcntl.h>
  34 #include <unistd.h>
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <pwd.h>
  38 #include <signal.h>
  39 #include <pthread.h>
  40 #include <sys/time.h>
  41 #include <sched.h>
  42 #include <sys/resource.h>
  43 #include <limits.h>
  44 #include <unistd.h>
  45 #include <grp.h>
  46 #include <netdb.h>
  47
  48 #include <samplerate.h>
  49
  50 #include "util.h"
  51 #include "xmalloc.h"
  52 #include "log.h"
  53
  54 #define PA_RUNTIME_PATH_PREFIX "/tmp/polypaudio-"
  55
  56 /** Make a file descriptor nonblock. Doesn't do any error checking */
  57 void pa_make_nonblock_fd(int fd) {
  58     int v;
  59     assert(fd >= 0);
  60
  61     if ((v = fcntl(fd, F_GETFL)) >= 0)
  62         if (!(v & O_NONBLOCK))
  63             fcntl(fd, F_SETFL, v|O_NONBLOCK);
  64 }
  65
  66 /** Creates a directory securely */
  67 int pa_make_secure_dir(const char* dir) {
  68     struct stat st;
  69     assert(dir);
  70
  71     if (mkdir(dir, 0700) < 0)
  72         if (errno != EEXIST)
  73             return -1;
  74
  75     if (lstat(dir, &st) < 0)
  76         goto fail;
  77
  78     if (!S_ISDIR(st.st_mode) || (st.st_uid != getuid()) || ((st.st_mode & 0777) != 0700))
  79         goto fail;
  80
  81     return 0;
  82
  83 fail:
  84     rmdir(dir);
  85     return -1;
  86 }
  87
  88 /* Creates a the parent directory of the specified path securely */
  89 int pa_make_secure_parent_dir(const char *fn) {
  90     int ret = -1;
  91     char *slash, *dir = pa_xstrdup(fn);
  92
  93     if (!(slash = strrchr(dir, '/')))
  94         goto finish;
  95     *slash = 0;
  96
  97     if (pa_make_secure_dir(dir) < 0)
  98         goto finish;
  99
 100     ret = 0;
 101
 102 finish:
 103     pa_xfree(dir);
 104     return ret;
 105 }
 106
 107
 108 /** Calls read() in a loop. Makes sure that as much as 'size' bytes,
 109  * unless EOF is reached or an error occured */
 110 ssize_t pa_loop_read(int fd, void*data, size_t size) {
 111     ssize_t ret = 0;
 112     assert(fd >= 0 && data && size);
 113
 114     while (size > 0) {
 115         ssize_t r;
 116
 117         if ((r = read(fd, data, size)) < 0)
 118             return r;
 119
 120         if (r == 0)
 121             break;
 122
 123         ret += r;
 124         data = (uint8_t*) data + r;
 125         size -= r;
 126     }
 127
 128     return ret;
 129 }
 130
 131 /** Similar to pa_loop_read(), but wraps write() */
 132 ssize_t pa_loop_write(int fd, const void*data, size_t size) {
 133     ssize_t ret = 0;
 134     assert(fd >= 0 && data && size);
 135
 136     while (size > 0) {
 137         ssize_t r;
 138
 139         if ((r = write(fd, data, size)) < 0)
 140             return r;
 141
 142         if (r == 0)
 143             break;
 144
 145         ret += r;
 146         data = (uint8_t*) data + r;
 147         size -= r;
 148     }
 149
 150     return ret;
 151 }
 152
 153 /* Print a warning messages in case that the given signal is not
 154  * blocked or trapped */
 155 void pa_check_signal_is_blocked(int sig) {
 156     struct sigaction sa;
 157     sigset_t set;
 158
 159     /* If POSIX threads are supported use thread-aware
 160      * pthread_sigmask() function, to check if the signal is
 161      * blocked. Otherwise fall back to sigprocmask() */
 162
 163 #ifdef HAVE_PTHREAD
 164     if (pthread_sigmask(SIG_SETMASK, NULL, &set) < 0) {
 165 #endif
 166         if (sigprocmask(SIG_SETMASK, NULL, &set) < 0) {
 167             pa_log(__FILE__": sigprocmask() failed: %s\n", strerror(errno));
 168             return;
 169         }
 170 #ifdef HAVE_PTHREAD
 171     }
 172 #endif
 173
 174     if (sigismember(&set, sig))
 175         return;
 176
 177     /* Check whether the signal is trapped */
 178
 179     if (sigaction(sig, NULL, &sa) < 0) {
 180         pa_log(__FILE__": sigaction() failed: %s\n", strerror(errno));
 181         return;
 182     }
 183
 184     if (sa.sa_handler != SIG_DFL)
 185         return;
 186
 187     pa_log(__FILE__": WARNING: %s is not trapped. This might cause malfunction!\n", pa_strsignal(sig));
 188 }
 189
 190 /* The following function is based on an example from the GNU libc
 191  * documentation. This function is similar to GNU's asprintf(). */
 192 char *pa_sprintf_malloc(const char *format, ...) {
 193     int  size = 100;
 194     char *c = NULL;
 195
 196     assert(format);
 197
 198     for(;;) {
 199         int r;
 200         va_list ap;
 201
 202         c = pa_xrealloc(c, size);
 203
 204         va_start(ap, format);
 205         r = vsnprintf(c, size, format, ap);
 206         va_end(ap);
 207
 208         if (r > -1 && r < size)
 209             return c;
 210
 211         if (r > -1)    /* glibc 2.1 */
 212             size = r+1;
 213         else           /* glibc 2.0 */
 214             size *= 2;
 215     }
 216 }
 217
 218 /* Same as the previous function, but use a va_list instead of an
 219  * ellipsis */
 220 char *pa_vsprintf_malloc(const char *format, va_list ap) {
 221     int  size = 100;
 222     char *c = NULL;
 223
 224     assert(format);
 225
 226     for(;;) {
 227         int r;
 228         va_list ap;
 229
 230         c = pa_xrealloc(c, size);
 231         r = vsnprintf(c, size, format, ap);
 232
 233         if (r > -1 && r < size)
 234             return c;
 235
 236         if (r > -1)    /* glibc 2.1 */
 237             size = r+1;
 238         else           /* glibc 2.0 */
 239             size *= 2;
 240     }
 241 }
 242
 243 /* Return the current username in the specified string buffer. */
 244 char *pa_get_user_name(char *s, size_t l) {
 245     struct passwd pw, *r;
 246     char buf[1024];
 247     char *p;
 248     assert(s && l > 0);
 249
 250     if (!(p = getenv("USER")) && !(p = getenv("LOGNAME")) && !(p = getenv("USERNAME"))) {
 251
 252 #ifdef HAVE_GETPWUID_R
 253         if (getpwuid_r(getuid(), &pw, buf, sizeof(buf), &r) != 0 || !r) {
 254 #else
 255             /* XXX Not thread-safe, but needed on OSes (e.g. FreeBSD 4.X)
 256              * that do not support getpwuid_r. */
 257             if ((r = getpwuid(getuid())) == NULL) {
 258 #endif
 259                 snprintf(s, l, "%lu", (unsigned long) getuid());
 260                 return s;
 261             }
 262
 263             p = r->pw_name;
 264         }
 265
 266     return pa_strlcpy(s, p, l);
 267     }
 268
 269 /* Return the current hostname in the specified buffer. */
 270 char *pa_get_host_name(char *s, size_t l) {
 271     assert(s && l > 0);
 272     if (gethostname(s, l) < 0) {
 273         pa_log(__FILE__": gethostname(): %s\n", strerror(errno));
 274         return NULL;
 275     }
 276     s[l-1] = 0;
 277     return s;
 278 }
 279
 280 /* Return the home directory of the current user */
 281 char *pa_get_home_dir(char *s, size_t l) {
 282     char *e;
 283     char buf[1024];
 284     struct passwd pw, *r;
 285     assert(s && l);
 286
 287     if ((e = getenv("HOME")))
 288         return pa_strlcpy(s, e, l);
 289
 290     if (getpwuid_r(getuid(), &pw, buf, sizeof(buf), &r) != 0 || !r) {
 291         pa_log(__FILE__": getpwuid_r() failed\n");
 292         return NULL;
 293     }
 294
 295     return pa_strlcpy(s, r->pw_dir, l);
 296 }
 297
 298 /* Similar to OpenBSD's strlcpy() function */
 299 char *pa_strlcpy(char *b, const char *s, size_t l) {
 300     assert(b && s && l > 0);
 301
 302     strncpy(b, s, l);
 303     b[l-1] = 0;
 304     return b;
 305 }
 306
 307 /* Calculate the difference between the two specfified timeval
 308  * timestamsps. */
 309 pa_usec_t pa_timeval_diff(const struct timeval *a, const struct timeval *b) {
 310     pa_usec_t r;
 311     assert(a && b);
 312
 313     /* Check which whan is the earlier time and swap the two arguments if reuqired. */
 314     if (pa_timeval_cmp(a, b) < 0) {
 315         const struct timeval *c;
 316         c = a;
 317         a = b;
 318         b = c;
 319     }
 320
 321     /* Calculate the second difference*/
 322     r = ((pa_usec_t) a->tv_sec - b->tv_sec)* 1000000;
 323
 324     /* Calculate the microsecond difference */
 325     if (a->tv_usec > b->tv_usec)
 326         r += ((pa_usec_t) a->tv_usec - b->tv_usec);
 327     else if (a->tv_usec < b->tv_usec)
 328         r -= ((pa_usec_t) b->tv_usec - a->tv_usec);
 329
 330     return r;
 331 }
 332
 333 /* Compare the two timeval structs and return 0 when equal, negative when a < b, positive otherwse */
 334 int pa_timeval_cmp(const struct timeval *a, const struct timeval *b) {
 335     assert(a && b);
 336
 337     if (a->tv_sec < b->tv_sec)
 338         return -1;
 339
 340     if (a->tv_sec > b->tv_sec)
 341         return 1;
 342
 343     if (a->tv_usec < b->tv_usec)
 344         return -1;
 345
 346     if (a->tv_usec > b->tv_usec)
 347         return 1;
 348
 349     return 0;
 350 }
 351
 352 /* Return the time difference between now and the specified timestamp */
 353 pa_usec_t pa_timeval_age(const struct timeval *tv) {
 354     struct timeval now;
 355     assert(tv);
 356     gettimeofday(&now, NULL);
 357     return pa_timeval_diff(&now, tv);
 358 }
 359
 360 /* Add the specified time inmicroseconds to the specified timeval structure */
 361 void pa_timeval_add(struct timeval *tv, pa_usec_t v) {
 362     unsigned long secs;
 363     assert(tv);
 364
 365     secs = (v/1000000);
 366     tv->tv_sec += (unsigned long) secs;
 367     v -= secs*1000000;
 368
 369     tv->tv_usec += v;
 370
 371     /* Normalize */
 372     while (tv->tv_usec >= 1000000) {
 373         tv->tv_sec++;
 374         tv->tv_usec -= 1000000;
 375     }
 376 }
 377
 378 #define NICE_LEVEL (-15)
 379
 380 /* Raise the priority of the current process as much as possible and
 381 sensible: set the nice level to -15 and enable realtime scheduling if
 382 supported.*/
 383 void pa_raise_priority(void) {
 384
 385     if (setpriority(PRIO_PROCESS, 0, NICE_LEVEL) < 0)
 386         pa_log(__FILE__": setpriority() failed: %s\n", strerror(errno));
 387 /*     else */
 388 /*         pa_log(__FILE__": Successfully gained nice level %i.\n", NICE_LEVEL); */
 389
 390 #ifdef _POSIX_PRIORITY_SCHEDULING
 391     {
 392         struct sched_param sp;
 393
 394         if (sched_getparam(0, &sp) < 0) {
 395             pa_log(__FILE__": sched_getparam() failed: %s\n", strerror(errno));
 396             return;
 397         }
 398
 399         sp.sched_priority = 1;
 400         if (sched_setscheduler(0, SCHED_FIFO, &sp) < 0) {
 401             pa_log(__FILE__": sched_setscheduler() failed: %s\n", strerror(errno));
 402             return;
 403         }
 404
 405 /*         pa_log(__FILE__": Successfully enabled SCHED_FIFO scheduling.\n"); */
 406     }
 407 #endif
 408 }
 409
 410 /* Reset the priority to normal, inverting the changes made by pa_raise_priority() */
 411 void pa_reset_priority(void) {
 412 #ifdef _POSIX_PRIORITY_SCHEDULING
 413     {
 414         struct sched_param sp;
 415         sched_getparam(0, &sp);
 416         sp.sched_priority = 0;
 417         sched_setscheduler(0, SCHED_OTHER, &sp);
 418     }
 419 #endif
 420
 421     setpriority(PRIO_PROCESS, 0, 0);
 422 }
 423
 424 /* Set the FD_CLOEXEC flag for a fd */
 425 int pa_fd_set_cloexec(int fd, int b) {
 426     int v;
 427     assert(fd >= 0);
 428
 429     if ((v = fcntl(fd, F_GETFD, 0)) < 0)
 430         return -1;
 431
 432     v = (v & ~FD_CLOEXEC) | (b ? FD_CLOEXEC : 0);
 433
 434     if (fcntl(fd, F_SETFD, v) < 0)
 435         return -1;
 436
 437     return 0;
 438 }
 439
 440 /* Return the binary file name of the current process. Works on Linux
 441  * only. This shoul be used for eyecandy only, don't rely on return
 442  * non-NULL! */
 443 char *pa_get_binary_name(char *s, size_t l) {
 444     char path[PATH_MAX];
 445     int i;
 446     assert(s && l);
 447
 448     /* This works on Linux only */
 449
 450     snprintf(path, sizeof(path), "/proc/%u/exe", (unsigned) getpid());
 451     if ((i = readlink(path, s, l-1)) < 0)
 452         return NULL;
 453
 454     s[i] = 0;
 455     return s;
 456 }
 457
 458 /* Return a pointer to the filename inside a path (which is the last
 459  * component). */
 460 char *pa_path_get_filename(const char *p) {
 461     char *fn;
 462
 463     if ((fn = strrchr(p, '/')))
 464         return fn+1;
 465
 466     return (char*) p;
 467 }
 468
 469 /* Try to parse a boolean string value.*/
 470 int pa_parse_boolean(const char *v) {
 471
 472     if (!strcmp(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on"))
 473         return 1;
 474     else if (!strcmp(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off"))
 475         return 0;
 476
 477     return -1;
 478 }
 479
 480 /* Split the specified string wherever one of the strings in delimiter
 481  * occurs. Each time it is called returns a newly allocated string
 482  * with pa_xmalloc(). The variable state points to, should be
 483  * initiallized to NULL before the first call. */
 484 char *pa_split(const char *c, const char *delimiter, const char**state) {
 485     const char *current = *state ? *state : c;
 486     size_t l;
 487
 488     if (!*current)
 489         return NULL;
 490
 491     l = strcspn(current, delimiter);
 492     *state = current+l;
 493
 494     if (**state)
 495         (*state)++;
 496
 497     return pa_xstrndup(current, l);
 498 }
 499
 500 /* What is interpreted as whitespace? */
 501 #define WHITESPACE " \t\n"
 502
 503 /* Split a string into words. Otherwise similar to pa_split(). */
 504 char *pa_split_spaces(const char *c, const char **state) {
 505     const char *current = *state ? *state : c;
 506     size_t l;
 507
 508     if (!*current || *c == 0)
 509         return NULL;
 510
 511     current += strspn(current, WHITESPACE);
 512     l = strcspn(current, WHITESPACE);
 513
 514     *state = current+l;
 515
 516     return pa_xstrndup(current, l);
 517 }
 518
 519 /* Return the name of an UNIX signal. Similar to GNU's strsignal() */
 520 const char *pa_strsignal(int sig) {
 521     switch(sig) {
 522         case SIGINT: return "SIGINT";
 523         case SIGTERM: return "SIGTERM";
 524         case SIGUSR1: return "SIGUSR1";
 525         case SIGUSR2: return "SIGUSR2";
 526         case SIGXCPU: return "SIGXCPU";
 527         case SIGPIPE: return "SIGPIPE";
 528         case SIGCHLD: return "SIGCHLD";
 529         case SIGHUP: return "SIGHUP";
 530         default: return "UNKNOWN SIGNAL";
 531     }
 532 }
 533
 534
 535 /* Check whether the specified GID and the group name match */
 536 static int is_group(gid_t gid, const char *name) {
 537     struct group group, *result = NULL;
 538     long n;
 539     void *data;
 540     int r = -1;
 541
 542 #ifdef HAVE_GETGRGID_R
 543 #ifdef _SC_GETGR_R_SIZE_MAX
 544     n = sysconf(_SC_GETGR_R_SIZE_MAX);
 545 #else
 546     n = -1;
 547 #endif
 548     if (n < 0) n = 512;
 549     data = pa_xmalloc(n);
 550
 551     if (getgrgid_r(gid, &group, data, n, &result) < 0 || !result) {
 552         pa_log(__FILE__ ": getgrgid_r(%u) failed: %s\n", gid, strerror(errno));
 553         goto finish;
 554     }
 555
 556
 557     r = strcmp(name, result->gr_name) == 0;
 558
 559 finish:
 560     pa_xfree(data);
 561 #else
 562     /* XXX Not thread-safe, but needed on OSes (e.g. FreeBSD 4.X) that do not
 563      * support getgrgid_r. */
 564     if ((result = getgrgid(gid)) == NULL) {
 565         pa_log(__FILE__ ": getgrgid(%u) failed: %s\n", gid, strerror(errno));
 566         goto finish;
 567     }
 568
 569     r = strcmp(name, result->gr_name) == 0;
 570
 571 finish:
 572 #endif
 573
 574     return r;
 575 }
 576
 577 /* Check the current user is member of the specified group */
 578 int pa_uid_in_group(const char *name, gid_t *gid) {
 579     gid_t *gids, tgid;
 580     long n = sysconf(_SC_NGROUPS_MAX);
 581     int r = -1, i;
 582
 583     assert(n > 0);
 584
 585     gids = pa_xmalloc(sizeof(gid_t)*n);
 586
 587     if ((n = getgroups(n, gids)) < 0) {
 588         pa_log(__FILE__": getgroups() failed: %s\n", strerror(errno));
 589         goto finish;
 590     }
 591
 592     for (i = 0; i < n; i++) {
 593         if (is_group(gids[i], name) > 0) {
 594             *gid = gids[i];
 595             r = 1;
 596             goto finish;
 597         }
 598     }
 599
 600     if (is_group(tgid = getgid(), name) > 0) {
 601         *gid = tgid;
 602         r = 1;
 603         goto finish;
 604     }
 605
 606     r = 0;
 607
 608 finish:
 609
 610     pa_xfree(gids);
 611     return r;
 612 }
 613
 614 /* Lock or unlock a file entirely. (advisory) */
 615 int pa_lock_fd(int fd, int b) {
 616     struct flock flock;
 617
 618     /* Try a R/W lock first */
 619
 620     flock.l_type = b ? F_WRLCK : F_UNLCK;
 621     flock.l_whence = SEEK_SET;
 622     flock.l_start = 0;
 623     flock.l_len = 0;
 624
 625     if (fcntl(fd, F_SETLKW, &flock) >= 0)
 626         return 0;
 627
 628     /* Perhaps the file descriptor qas opened for read only, than try again with a read lock. */
 629     if (b && errno == EBADF) {
 630         flock.l_type = F_RDLCK;
 631         if (fcntl(fd, F_SETLKW, &flock) >= 0)
 632             return 0;
 633     }
 634
 635     pa_log(__FILE__": %slock failed: %s\n", !b ? "un" : "", strerror(errno));
 636     return -1;
 637 }
 638
 639 /* Remove trailing newlines from a string */
 640 char* pa_strip_nl(char *s) {
 641     assert(s);
 642
 643     s[strcspn(s, "\r\n")] = 0;
 644     return s;
 645 }
 646
 647 /* Create a temporary lock file and lock it. */
 648 int pa_lock_lockfile(const char *fn) {
 649     int fd;
 650     assert(fn);
 651
 652     if ((fd = open(fn, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR)) < 0) {
 653         pa_log(__FILE__": failed to create lock file '%s': %s\n", fn, strerror(errno));
 654         goto fail;
 655     }
 656
 657     if (pa_lock_fd(fd, 1) < 0)
 658         pa_log(__FILE__": failed to lock file '%s'.\n", fn);
 659         goto fail;
 660
 661     return fd;
 662
 663 fail:
 664
 665     if (fd >= 0) {
 666         unlink(fn);
 667         close(fd);
 668     }
 669
 670     return -1;
 671 }
 672
 673 /* Unlock a temporary lcok file */
 674 int pa_unlock_lockfile(const char *fn, int fd) {
 675     int r = 0;
 676     assert(fn && fd >= 0);
 677
 678     if (unlink(fn) < 0) {
 679         pa_log(__FILE__": WARNING: unable to remove lock file '%s': %s\n", fn, strerror(errno));
 680         r = -1;
 681     }
 682
 683     if (pa_lock_fd(fd, 0) < 0) {
 684         pa_log(__FILE__": WARNING: failed to unlock file '%s'.\n", fn);
 685         r = -1;
 686     }
 687
 688     if (close(fd) < 0) {
 689         pa_log(__FILE__": WARNING: failed to close lock file '%s': %s\n", fn, strerror(errno));
 690         r = -1;
 691     }
 692
 693     return r;
 694 }
 695
 696 /* Try to open a configuration file. If "env" is specified, open the
 697  * value of the specified environment variable. Otherwise look for a
 698  * file "local" in the home directory or a file "global" in global
 699  * file system. If "result" is non-NULL, a pointer to a newly
 700  * allocated buffer containing the used configuration file is
 701  * stored there.*/
 702 FILE *pa_open_config_file(const char *global, const char *local, const char *env, char **result) {
 703     const char *e;
 704     char h[PATH_MAX];
 705
 706     if (env && (e = getenv(env))) {
 707         if (result)
 708             *result = pa_xstrdup(e);
 709         return fopen(e, "r");
 710     }
 711
 712     if (local && pa_get_home_dir(h, sizeof(h))) {
 713         FILE *f;
 714         char *l;
 715
 716         l = pa_sprintf_malloc("%s/%s", h, local);
 717         f = fopen(l, "r");
 718
 719         if (f || errno != ENOENT) {
 720             if (result)
 721                 *result = l;
 722             else
 723                 pa_xfree(l);
 724             return f;
 725         }
 726
 727         pa_xfree(l);
 728     }
 729
 730     if (!global) {
 731         if (result)
 732             *result = NULL;
 733         errno = ENOENT;
 734         return NULL;
 735     }
 736
 737     if (result)
 738         *result = pa_xstrdup(global);
 739
 740     return fopen(global, "r");
 741 }
 742
 743 /* Format the specified data as a hexademical string */
 744 char *pa_hexstr(const uint8_t* d, size_t dlength, char *s, size_t slength) {
 745     size_t i = 0, j = 0;
 746     const char hex[] = "0123456789abcdef";
 747     assert(d && s && slength > 0);
 748
 749     while (i < dlength && j+3 <= slength) {
 750         s[j++] = hex[*d >> 4];
 751         s[j++] = hex[*d & 0xF];
 752
 753         d++;
 754         i++;
 755     }
 756
 757     s[j < slength ? j : slength] = 0;
 758     return s;
 759 }
 760
 761 /* Convert a hexadecimal digit to a number or -1 if invalid */
 762 static int hexc(char c) {
 763     if (c >= '0' && c <= '9')
 764         return c - '0';
 765
 766     if (c >= 'A' && c <= 'F')
 767         return c - 'A' + 10;
 768
 769     if (c >= 'a' && c <= 'f')
 770         return c - 'a' + 10;
 771
 772     return -1;
 773 }
 774
 775 /* Parse a hexadecimal string as created by pa_hexstr() to a BLOB */
 776 size_t pa_parsehex(const char *p, uint8_t *d, size_t dlength) {
 777     size_t j = 0;
 778     assert(p && d);
 779
 780     while (j < dlength && *p) {
 781         int b;
 782
 783         if ((b = hexc(*(p++))) < 0)
 784             return (size_t) -1;
 785
 786         d[j] = (uint8_t) (b << 4);
 787
 788         if (!*p)
 789             return (size_t) -1;
 790
 791         if ((b = hexc(*(p++))) < 0)
 792             return (size_t) -1;
 793
 794         d[j] |= (uint8_t) b;
 795         j++;
 796     }
 797
 798     return j;
 799 }
 800
 801 /* Return the fully qualified domain name in *s */
 802 char *pa_get_fqdn(char *s, size_t l) {
 803     char hn[256];
 804     struct addrinfo *a, hints;
 805
 806     if (!pa_get_host_name(hn, sizeof(hn)))
 807         return NULL;
 808
 809     memset(&hints, 0, sizeof(hints));
 810     hints.ai_family = AF_UNSPEC;
 811     hints.ai_flags = AI_CANONNAME;
 812
 813     if (getaddrinfo(hn, NULL, &hints, &a) < 0 || !a || !a->ai_canonname || !*a->ai_canonname)
 814         return pa_strlcpy(s, hn, l);
 815
 816     pa_strlcpy(s, a->ai_canonname, l);
 817     freeaddrinfo(a);
 818     return s;
 819 }
 820
 821 /* Returns nonzero when *s starts with *pfx */
 822 int pa_startswith(const char *s, const char *pfx) {
 823     size_t l;
 824     assert(s && pfx);
 825     l = strlen(pfx);
 826
 827     return strlen(s) >= l && strncmp(s, pfx, l) == 0;
 828 }
 829
 830 /* if fn is null return the polypaudio run time path in s (/tmp/polypaudio)
 831  * if fn is non-null and starts with / return fn in s
 832  * otherwise append fn to the run time path and return it in s */
 833 char *pa_runtime_path(const char *fn, char *s, size_t l) {
 834     char u[256];
 835
 836     if (fn && *fn == '/')
 837         return pa_strlcpy(s, fn, l);
 838
 839     snprintf(s, l, PA_RUNTIME_PATH_PREFIX"%s%s%s", pa_get_user_name(u, sizeof(u)), fn ? "/" : "", fn ? fn : "");
 840     return s;
 841 }