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 pa_log(__FILE__": Successfully gained nice level %i.\n", NICE_LEVEL);
 388
 389 #ifdef _POSIX_PRIORITY_SCHEDULING
 390     {
 391         struct sched_param sp;
 392
 393         if (sched_getparam(0, &sp) < 0) {
 394             pa_log(__FILE__": sched_getparam() failed: %s\n", strerror(errno));
 395             return;
 396         }
 397
 398         sp.sched_priority = 1;
 399         if (sched_setscheduler(0, SCHED_FIFO, &sp) < 0) {
 400             pa_log(__FILE__": sched_setscheduler() failed: %s\n", strerror(errno));
 401             return;
 402         }
 403
 404         pa_log(__FILE__": Successfully enabled SCHED_FIFO scheduling.\n");
 405     }
 406 #endif
 407 }
 408
 409 /* Reset the priority to normal, inverting the changes made by pa_raise_priority() */
 410 void pa_reset_priority(void) {
 411 #ifdef _POSIX_PRIORITY_SCHEDULING
 412     {
 413         struct sched_param sp;
 414         sched_getparam(0, &sp);
 415         sp.sched_priority = 0;
 416         sched_setscheduler(0, SCHED_OTHER, &sp);
 417     }
 418 #endif
 419
 420     setpriority(PRIO_PROCESS, 0, 0);
 421 }
 422
 423 /* Set the FD_CLOEXEC flag for a fd */
 424 int pa_fd_set_cloexec(int fd, int b) {
 425     int v;
 426     assert(fd >= 0);
 427
 428     if ((v = fcntl(fd, F_GETFD, 0)) < 0)
 429         return -1;
 430
 431     v = (v & ~FD_CLOEXEC) | (b ? FD_CLOEXEC : 0);
 432
 433     if (fcntl(fd, F_SETFD, v) < 0)
 434         return -1;
 435
 436     return 0;
 437 }
 438
 439 /* Return the binary file name of the current process. Works on Linux
 440  * only. This shoul be used for eyecandy only, don't rely on return
 441  * non-NULL! */
 442 char *pa_get_binary_name(char *s, size_t l) {
 443     char path[PATH_MAX];
 444     int i;
 445     assert(s && l);
 446
 447     /* This works on Linux only */
 448
 449     snprintf(path, sizeof(path), "/proc/%u/exe", (unsigned) getpid());
 450     if ((i = readlink(path, s, l-1)) < 0)
 451         return NULL;
 452
 453     s[i] = 0;
 454     return s;
 455 }
 456
 457 /* Return a pointer to the filename inside a path (which is the last
 458  * component). */
 459 char *pa_path_get_filename(const char *p) {
 460     char *fn;
 461
 462     if ((fn = strrchr(p, '/')))
 463         return fn+1;
 464
 465     return (char*) p;
 466 }
 467
 468 /* Try to parse a boolean string value.*/
 469 int pa_parse_boolean(const char *v) {
 470
 471     if (!strcmp(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on"))
 472         return 1;
 473     else if (!strcmp(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off"))
 474         return 0;
 475
 476     return -1;
 477 }
 478
 479 /* Split the specified string wherever one of the strings in delimiter
 480  * occurs. Each time it is called returns a newly allocated string
 481  * with pa_xmalloc(). The variable state points to, should be
 482  * initiallized to NULL before the first call. */
 483 char *pa_split(const char *c, const char *delimiter, const char**state) {
 484     const char *current = *state ? *state : c;
 485     size_t l;
 486
 487     if (!*current)
 488         return NULL;
 489
 490     l = strcspn(current, delimiter);
 491     *state = current+l;
 492
 493     if (**state)
 494         (*state)++;
 495
 496     return pa_xstrndup(current, l);
 497 }
 498
 499 /* What is interpreted as whitespace? */
 500 #define WHITESPACE " \t\n"
 501
 502 /* Split a string into words. Otherwise similar to pa_split(). */
 503 char *pa_split_spaces(const char *c, const char **state) {
 504     const char *current = *state ? *state : c;
 505     size_t l;
 506
 507     if (!*current || *c == 0)
 508         return NULL;
 509
 510     current += strspn(current, WHITESPACE);
 511     l = strcspn(current, WHITESPACE);
 512
 513     *state = current+l;
 514
 515     return pa_xstrndup(current, l);
 516 }
 517
 518 /* Return the name of an UNIX signal. Similar to GNU's strsignal() */
 519 const char *pa_strsignal(int sig) {
 520     switch(sig) {
 521         case SIGINT: return "SIGINT";
 522         case SIGTERM: return "SIGTERM";
 523         case SIGUSR1: return "SIGUSR1";
 524         case SIGUSR2: return "SIGUSR2";
 525         case SIGXCPU: return "SIGXCPU";
 526         case SIGPIPE: return "SIGPIPE";
 527         case SIGCHLD: return "SIGCHLD";
 528         case SIGHUP: return "SIGHUP";
 529         default: return "UNKNOWN SIGNAL";
 530     }
 531 }
 532
 533
 534 /* Check whether the specified GID and the group name match */
 535 static int is_group(gid_t gid, const char *name) {
 536     struct group group, *result = NULL;
 537     long n;
 538     void *data;
 539     int r = -1;
 540
 541 #ifdef HAVE_GETGRGID_R
 542 #ifdef _SC_GETGR_R_SIZE_MAX
 543     n = sysconf(_SC_GETGR_R_SIZE_MAX);
 544 #else
 545     n = -1;
 546 #endif
 547     if (n < 0) n = 512;
 548     data = pa_xmalloc(n);
 549
 550     if (getgrgid_r(gid, &group, data, n, &result) < 0 || !result) {
 551         pa_log(__FILE__ ": getgrgid_r(%u) failed: %s\n", gid, strerror(errno));
 552         goto finish;
 553     }
 554
 555
 556     r = strcmp(name, result->gr_name) == 0;
 557
 558 finish:
 559     pa_xfree(data);
 560 #else
 561     /* XXX Not thread-safe, but needed on OSes (e.g. FreeBSD 4.X) that do not
 562      * support getgrgid_r. */
 563     if ((result = getgrgid(gid)) == NULL) {
 564         pa_log(__FILE__ ": getgrgid(%u) failed: %s\n", gid, strerror(errno));
 565         goto finish;
 566     }
 567
 568     r = strcmp(name, result->gr_name) == 0;
 569
 570 finish:
 571 #endif
 572
 573     return r;
 574 }
 575
 576 /* Check the current user is member of the specified group */
 577 int pa_uid_in_group(const char *name, gid_t *gid) {
 578     gid_t *gids, tgid;
 579     long n = sysconf(_SC_NGROUPS_MAX);
 580     int r = -1, i;
 581
 582     assert(n > 0);
 583
 584     gids = pa_xmalloc(sizeof(gid_t)*n);
 585
 586     if ((n = getgroups(n, gids)) < 0) {
 587         pa_log(__FILE__": getgroups() failed: %s\n", strerror(errno));
 588         goto finish;
 589     }
 590
 591     for (i = 0; i < n; i++) {
 592         if (is_group(gids[i], name) > 0) {
 593             *gid = gids[i];
 594             r = 1;
 595             goto finish;
 596         }
 597     }
 598
 599     if (is_group(tgid = getgid(), name) > 0) {
 600         *gid = tgid;
 601         r = 1;
 602         goto finish;
 603     }
 604
 605     r = 0;
 606
 607 finish:
 608
 609     pa_xfree(gids);
 610     return r;
 611 }
 612
 613 /* Lock or unlock a file entirely. (advisory) */
 614 int pa_lock_fd(int fd, int b) {
 615
 616     struct flock flock;
 617
 618     flock.l_type = b ? F_WRLCK : F_UNLCK;
 619     flock.l_whence = SEEK_SET;
 620     flock.l_start = 0;
 621     flock.l_len = 0;
 622
 623     if (fcntl(fd, F_SETLKW, &flock) < 0) {
 624         pa_log(__FILE__": %slock failed: %s\n", !b ? "un" : "", strerror(errno));
 625         return -1;
 626     }
 627
 628     return 0;
 629 }
 630
 631 /* Remove trailing newlines from a string */
 632 char* pa_strip_nl(char *s) {
 633     assert(s);
 634
 635     s[strcspn(s, "\r\n")] = 0;
 636     return s;
 637 }
 638
 639 /* Create a temporary lock file and lock it. */
 640 int pa_lock_lockfile(const char *fn) {
 641     int fd;
 642     assert(fn);
 643
 644     if ((fd = open(fn, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR)) < 0) {
 645         pa_log(__FILE__": failed to create lock file '%s'\n", fn);
 646         goto fail;
 647     }
 648
 649     if (pa_lock_fd(fd, 1) < 0)
 650         goto fail;
 651
 652     return fd;
 653
 654 fail:
 655
 656     if (fd >= 0)
 657         close(fd);
 658
 659     return -1;
 660 }
 661
 662 /* Unlock a temporary lcok file */
 663 int pa_unlock_lockfile(int fd) {
 664     int r = 0;
 665     assert(fd >= 0);
 666
 667     if (pa_lock_fd(fd, 0) < 0) {
 668         pa_log(__FILE__": WARNING: failed to unlock file.\n");
 669         r = -1;
 670     }
 671
 672     if (close(fd) < 0) {
 673         pa_log(__FILE__": WARNING: failed to close lock file.\n");
 674         r = -1;
 675     }
 676
 677     return r;
 678 }
 679
 680 /* Try to open a configuration file. If "env" is specified, open the
 681  * value of the specified environment variable. Otherwise look for a
 682  * file "local" in the home directory or a file "global" in global
 683  * file system. If "result" is non-NULL, a pointer to a newly
 684  * allocated buffer containing the used configuration file is
 685  * stored there.*/
 686 FILE *pa_open_config_file(const char *global, const char *local, const char *env, char **result) {
 687     const char *e;
 688     char h[PATH_MAX];
 689
 690     if (env && (e = getenv(env))) {
 691         if (result)
 692             *result = pa_xstrdup(e);
 693         return fopen(e, "r");
 694     }
 695
 696     if (local && pa_get_home_dir(h, sizeof(h))) {
 697         FILE *f;
 698         char *l;
 699
 700         l = pa_sprintf_malloc("%s/%s", h, local);
 701         f = fopen(l, "r");
 702
 703         if (f || errno != ENOENT) {
 704             if (result)
 705                 *result = l;
 706             else
 707                 pa_xfree(l);
 708             return f;
 709         }
 710
 711         pa_xfree(l);
 712     }
 713
 714     if (!global) {
 715         if (result)
 716             *result = NULL;
 717         errno = ENOENT;
 718         return NULL;
 719     }
 720
 721     if (result)
 722         *result = pa_xstrdup(global);
 723
 724     return fopen(global, "r");
 725 }
 726
 727 /* Format the specified data as a hexademical string */
 728 char *pa_hexstr(const uint8_t* d, size_t dlength, char *s, size_t slength) {
 729     size_t i = 0, j = 0;
 730     const char hex[] = "0123456789abcdef";
 731     assert(d && s && slength > 0);
 732
 733     while (i < dlength && j+3 <= slength) {
 734         s[j++] = hex[*d >> 4];
 735         s[j++] = hex[*d & 0xF];
 736
 737         d++;
 738         i++;
 739     }
 740
 741     s[j < slength ? j : slength] = 0;
 742     return s;
 743 }
 744
 745 /* Convert a hexadecimal digit to a number or -1 if invalid */
 746 static int hexc(char c) {
 747     if (c >= '0' && c <= '9')
 748         return c - '0';
 749
 750     if (c >= 'A' && c <= 'F')
 751         return c - 'A' + 10;
 752
 753     if (c >= 'a' && c <= 'f')
 754         return c - 'a' + 10;
 755
 756     return -1;
 757 }
 758
 759 /* Parse a hexadecimal string as created by pa_hexstr() to a BLOB */
 760 size_t pa_parsehex(const char *p, uint8_t *d, size_t dlength) {
 761     size_t j = 0;
 762     assert(p && d);
 763
 764     while (j < dlength && *p) {
 765         int b;
 766
 767         if ((b = hexc(*(p++))) < 0)
 768             return (size_t) -1;
 769
 770         d[j] = (uint8_t) (b << 4);
 771
 772         if (!*p)
 773             return (size_t) -1;
 774
 775         if ((b = hexc(*(p++))) < 0)
 776             return (size_t) -1;
 777
 778         d[j] |= (uint8_t) b;
 779         j++;
 780     }
 781
 782     return j;
 783 }
 784
 785 /* Return the fully qualified domain name in *s */
 786 char *pa_get_fqdn(char *s, size_t l) {
 787     char hn[256];
 788     struct addrinfo *a, hints;
 789
 790     if (!pa_get_host_name(hn, sizeof(hn)))
 791         return NULL;
 792
 793     memset(&hints, 0, sizeof(hints));
 794     hints.ai_family = AF_UNSPEC;
 795     hints.ai_flags = AI_CANONNAME;
 796
 797     if (getaddrinfo(hn, NULL, &hints, &a) < 0 || !a || !a->ai_canonname || !*a->ai_canonname)
 798         return pa_strlcpy(s, hn, l);
 799
 800     pa_strlcpy(s, a->ai_canonname, l);
 801     freeaddrinfo(a);
 802     return s;
 803 }
 804
 805 /* Returns nonzero when *s starts with *pfx */
 806 int pa_startswith(const char *s, const char *pfx) {
 807     size_t l;
 808     assert(s && pfx);
 809     l = strlen(pfx);
 810
 811     return strlen(s) >= l && strncmp(s, pfx, l) == 0;
 812 }
 813
 814 /* if fn is null return the polypaudio run time path in s (/tmp/polypaudio)
 815  * if fn is non-null and starts with / return fn in s
 816  * otherwise append fn to the run time path and return it in s */
 817 char *pa_runtime_path(const char *fn, char *s, size_t l) {
 818     char u[256];
 819
 820     if (fn && *fn == '/')
 821         return pa_strlcpy(s, fn, l);
 822
 823     snprintf(s, l, PA_RUNTIME_PATH_PREFIX"%s%s%s", pa_get_user_name(u, sizeof(u)), fn ? "/" : "", fn ? fn : "");
 824     return s;
 825 }