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