code.delx.au - pulseaudio/blob - 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
  47 #include <samplerate.h>
  48
  49 #include "util.h"
  50 #include "xmalloc.h"
  51 #include "log.h"
  52
  53 void pa_make_nonblock_fd(int fd) {
  54     int v;
  55
  56     if ((v = fcntl(fd, F_GETFL)) >= 0)
  57         if (!(v & O_NONBLOCK))
  58             fcntl(fd, F_SETFL, v|O_NONBLOCK);
  59 }
  60
  61 int pa_make_secure_dir(const char* dir) {
  62     struct stat st;
  63
  64     if (mkdir(dir, 0700) < 0)
  65         if (errno != EEXIST)
  66             return -1;
  67
  68     if (lstat(dir, &st) < 0)
  69         goto fail;
  70
  71     if (!S_ISDIR(st.st_mode) || (st.st_uid != getuid()) || ((st.st_mode & 0777) != 0700))
  72         goto fail;
  73
  74     return 0;
  75
  76 fail:
  77     rmdir(dir);
  78     return -1;
  79 }
  80
  81 ssize_t pa_loop_read(int fd, void*data, size_t size) {
  82     ssize_t ret = 0;
  83     assert(fd >= 0 && data && size);
  84
  85     while (size > 0) {
  86         ssize_t r;
  87
  88         if ((r = read(fd, data, size)) < 0)
  89             return r;
  90
  91         if (r == 0)
  92             break;
  93
  94         ret += r;
  95         data = (uint8_t*) data + r;
  96         size -= r;
  97     }
  98
  99     return ret;
 100 }
 101
 102 ssize_t pa_loop_write(int fd, const void*data, size_t size) {
 103     ssize_t ret = 0;
 104     assert(fd >= 0 && data && size);
 105
 106     while (size > 0) {
 107         ssize_t r;
 108
 109         if ((r = write(fd, data, size)) < 0)
 110             return r;
 111
 112         if (r == 0)
 113             break;
 114
 115         ret += r;
 116         data = (uint8_t*) data + r;
 117         size -= r;
 118     }
 119
 120     return ret;
 121 }
 122
 123 void pa_check_signal_is_blocked(int sig) {
 124     struct sigaction sa;
 125     sigset_t set;
 126
 127 #ifdef HAVE_PTHREAD
 128     if (pthread_sigmask(SIG_SETMASK, NULL, &set) < 0) {
 129 #endif
 130         if (sigprocmask(SIG_SETMASK, NULL, &set) < 0) {
 131             pa_log(__FILE__": sigprocmask() failed: %s\n", strerror(errno));
 132             return;
 133         }
 134 #ifdef HAVE_PTHREAD
 135     }
 136 #endif
 137
 138     if (sigismember(&set, sig))
 139         return;
 140
 141     if (sigaction(sig, NULL, &sa) < 0) {
 142         pa_log(__FILE__": sigaction() failed: %s\n", strerror(errno));
 143         return;
 144     }
 145
 146     if (sa.sa_handler != SIG_DFL)
 147         return;
 148
 149     pa_log(__FILE__": WARNING: %s is not trapped. This might cause malfunction!\n", pa_strsignal(sig));
 150 }
 151
 152 /* The following is based on an example from the GNU libc documentation */
 153 char *pa_sprintf_malloc(const char *format, ...) {
 154     int  size = 100;
 155     char *c = NULL;
 156
 157     assert(format);
 158
 159     for(;;) {
 160         int r;
 161         va_list ap;
 162
 163         c = pa_xrealloc(c, size);
 164
 165         va_start(ap, format);
 166         r = vsnprintf(c, size, format, ap);
 167         va_end(ap);
 168
 169         if (r > -1 && r < size)
 170             return c;
 171
 172         if (r > -1)    /* glibc 2.1 */
 173             size = r+1;
 174         else           /* glibc 2.0 */
 175             size *= 2;
 176     }
 177 }
 178
 179 char *pa_vsprintf_malloc(const char *format, va_list ap) {
 180     int  size = 100;
 181     char *c = NULL;
 182
 183     assert(format);
 184
 185     for(;;) {
 186         int r;
 187         va_list ap;
 188
 189         c = pa_xrealloc(c, size);
 190         r = vsnprintf(c, size, format, ap);
 191
 192         if (r > -1 && r < size)
 193             return c;
 194
 195         if (r > -1)    /* glibc 2.1 */
 196             size = r+1;
 197         else           /* glibc 2.0 */
 198             size *= 2;
 199     }
 200 }
 201
 202
 203 char *pa_get_user_name(char *s, size_t l) {
 204     struct passwd pw, *r;
 205     char buf[1024];
 206     char *p;
 207
 208     if (!(p = getenv("USER")))
 209         if (!(p = getenv("LOGNAME")))
 210             if (!(p = getenv("USERNAME"))) {
 211
 212                 if (getpwuid_r(getuid(), &pw, buf, sizeof(buf), &r) != 0 || !r) {
 213                     snprintf(s, l, "%lu", (unsigned long) getuid());
 214                     return s;
 215                 }
 216
 217                 p = r->pw_name;
 218             }
 219
 220     snprintf(s, l, "%s", p);
 221     return s;
 222 }
 223
 224 char *pa_get_host_name(char *s, size_t l) {
 225     gethostname(s, l);
 226     s[l-1] = 0;
 227     return s;
 228 }
 229
 230 pa_usec_t pa_timeval_diff(const struct timeval *a, const struct timeval *b) {
 231     pa_usec_t r;
 232     assert(a && b);
 233
 234     if (pa_timeval_cmp(a, b) < 0) {
 235         const struct timeval *c;
 236         c = a;
 237         a = b;
 238         b = c;
 239     }
 240
 241     r = ((pa_usec_t) a->tv_sec - b->tv_sec)* 1000000;
 242
 243     if (a->tv_usec > b->tv_usec)
 244         r += ((pa_usec_t) a->tv_usec - b->tv_usec);
 245     else if (a->tv_usec < b->tv_usec)
 246         r -= ((pa_usec_t) b->tv_usec - a->tv_usec);
 247
 248     return r;
 249 }
 250
 251 int pa_timeval_cmp(const struct timeval *a, const struct timeval *b) {
 252     assert(a && b);
 253
 254     if (a->tv_sec < b->tv_sec)
 255         return -1;
 256
 257     if (a->tv_sec > b->tv_sec)
 258         return 1;
 259
 260     if (a->tv_usec < b->tv_usec)
 261         return -1;
 262
 263     if (a->tv_usec > b->tv_usec)
 264         return 1;
 265
 266     return 0;
 267 }
 268
 269 pa_usec_t pa_age(const struct timeval *tv) {
 270     struct timeval now;
 271     assert(tv);
 272     gettimeofday(&now, NULL);
 273     return pa_timeval_diff(&now, tv);
 274 }
 275
 276 void pa_timeval_add(struct timeval *tv, pa_usec_t v) {
 277     unsigned long secs;
 278     assert(tv);
 279
 280     secs = (v/1000000);
 281     tv->tv_sec += (unsigned long) secs;
 282     v -= secs*1000000;
 283
 284     tv->tv_usec += v;
 285
 286     while (tv->tv_usec >= 1000000) {
 287         tv->tv_sec++;
 288         tv->tv_usec -= 1000000;
 289     }
 290 }
 291
 292 #define NICE_LEVEL (-15)
 293
 294 void pa_raise_priority(void) {
 295     if (setpriority(PRIO_PROCESS, 0, NICE_LEVEL) < 0)
 296         pa_log(__FILE__": setpriority() failed: %s\n", strerror(errno));
 297     else
 298         pa_log(__FILE__": Successfully gained nice level %i.\n", NICE_LEVEL);
 299
 300 #ifdef _POSIX_PRIORITY_SCHEDULING
 301     {
 302         struct sched_param sp;
 303
 304         if (sched_getparam(0, &sp) < 0) {
 305             pa_log(__FILE__": sched_getparam() failed: %s\n", strerror(errno));
 306             return;
 307         }
 308
 309         sp.sched_priority = 1;
 310         if (sched_setscheduler(0, SCHED_FIFO, &sp) < 0) {
 311             pa_log(__FILE__": sched_setscheduler() failed: %s\n", strerror(errno));
 312             return;
 313         }
 314
 315         pa_log(__FILE__": Successfully enabled SCHED_FIFO scheduling.\n");
 316     }
 317 #endif
 318 }
 319
 320 void pa_reset_priority(void) {
 321 #ifdef _POSIX_PRIORITY_SCHEDULING
 322     {
 323         struct sched_param sp;
 324         sched_getparam(0, &sp);
 325         sp.sched_priority = 0;
 326         sched_setscheduler(0, SCHED_OTHER, &sp);
 327     }
 328 #endif
 329
 330     setpriority(PRIO_PROCESS, 0, 0);
 331 }
 332
 333 int pa_fd_set_cloexec(int fd, int b) {
 334     int v;
 335     assert(fd >= 0);
 336
 337     if ((v = fcntl(fd, F_GETFD, 0)) < 0)
 338         return -1;
 339
 340     v = (v & ~FD_CLOEXEC) | (b ? FD_CLOEXEC : 0);
 341
 342     if (fcntl(fd, F_SETFD, v) < 0)
 343         return -1;
 344
 345     return 0;
 346 }
 347
 348 char *pa_get_binary_name(char *s, size_t l) {
 349     char path[PATH_MAX];
 350     int i;
 351     assert(s && l);
 352
 353     /* This works on Linux only */
 354
 355     snprintf(path, sizeof(path), "/proc/%u/exe", (unsigned) getpid());
 356     if ((i = readlink(path, s, l-1)) < 0)
 357         return NULL;
 358
 359     s[i] = 0;
 360     return s;
 361 }
 362
 363 char *pa_path_get_filename(const char *p) {
 364     char *fn;
 365
 366     if ((fn = strrchr(p, '/')))
 367         return fn+1;
 368
 369     return (char*) p;
 370 }
 371
 372 int pa_parse_boolean(const char *v) {
 373
 374     if (!strcmp(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on"))
 375         return 1;
 376     else if (!strcmp(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off"))
 377         return 0;
 378
 379     return -1;
 380 }
 381
 382 char *pa_split(const char *c, const char *delimiter, const char**state) {
 383     const char *current = *state ? *state : c;
 384     size_t l;
 385
 386     if (!*current)
 387         return NULL;
 388
 389     l = strcspn(current, delimiter);
 390     *state = current+l;
 391
 392     if (**state)
 393         (*state)++;
 394
 395     return pa_xstrndup(current, l);
 396 }
 397
 398 #define WHITESPACE " \t\n"
 399
 400 char *pa_split_spaces(const char *c, const char **state) {
 401     const char *current = *state ? *state : c;
 402     size_t l;
 403
 404     if (!*current)
 405         return NULL;
 406
 407     current += strspn(current, WHITESPACE);
 408     l = strcspn(current, WHITESPACE);
 409
 410     *state = current+l;
 411
 412     return pa_xstrndup(current, l);
 413 }
 414
 415 const char *pa_strsignal(int sig) {
 416     switch(sig) {
 417         case SIGINT: return "SIGINT";
 418         case SIGTERM: return "SIGTERM";
 419         case SIGUSR1: return "SIGUSR1";
 420         case SIGUSR2: return "SIGUSR2";
 421         case SIGXCPU: return "SIGXCPU";
 422         case SIGPIPE: return "SIGPIPE";
 423         case SIGCHLD: return "SIGCHLD";
 424         case SIGHUP: return "SIGHUP";
 425         default: return "UNKNOWN SIGNAL";
 426     }
 427 }
 428
 429 int pa_parse_resample_method(const char *string) {
 430     assert(string);
 431
 432     if (!strcmp(string, "sinc-best-quality"))
 433         return SRC_SINC_BEST_QUALITY;
 434     else if (!strcmp(string, "sinc-medium-quality"))
 435         return SRC_SINC_MEDIUM_QUALITY;
 436     else if (!strcmp(string, "sinc-fastest"))
 437         return SRC_SINC_FASTEST;
 438     else if (!strcmp(string, "zero-order-hold"))
 439         return SRC_ZERO_ORDER_HOLD;
 440     else if (!strcmp(string, "linear"))
 441         return SRC_LINEAR;
 442     else
 443         return -1;
 444 }
 445
 446 static int is_group(gid_t gid, const char *name) {
 447     struct group group, *result = NULL;
 448     long n = sysconf(_SC_GETGR_R_SIZE_MAX);
 449     void *data;
 450     int r = -1;
 451
 452     assert(n > 0);
 453     data = pa_xmalloc(n);
 454
 455     if (getgrgid_r(gid, &group, data, n, &result) < 0 || !result) {
 456         pa_log(__FILE__ ": getgrgid_r(%u) failed: %s\n", gid, strerror(errno));
 457         goto finish;
 458     }
 459
 460
 461     r = strcmp(name, result->gr_name) == 0;
 462
 463 finish:
 464     pa_xfree(data);
 465
 466     return r;
 467 }
 468
 469 int pa_uid_in_group(const char *name, gid_t *gid) {
 470     gid_t *gids, tgid;
 471     long n = sysconf(_SC_NGROUPS_MAX);
 472     int r = -1, i;
 473
 474     assert(n > 0);
 475
 476     gids = pa_xmalloc(sizeof(gid_t)*n);
 477
 478     if ((n = getgroups(n, gids)) < 0) {
 479         pa_log(__FILE__": getgroups() failed: %s\n", strerror(errno));
 480         goto finish;
 481     }
 482
 483     for (i = 0; i < n; i++) {
 484         if (is_group(gids[i], name) > 0) {
 485             *gid = gids[i];
 486             r = 1;
 487             goto finish;
 488         }
 489     }
 490
 491     if (is_group(tgid = getgid(), name) > 0) {
 492         *gid = tgid;
 493         r = 1;
 494         goto finish;
 495     }
 496
 497     r = 0;
 498
 499 finish:
 500
 501     pa_xfree(gids);
 502     return r;
 503 }
 504
 505 int pa_lock_fd(int fd, int b) {
 506
 507     struct flock flock;
 508
 509     flock.l_type = b ? F_WRLCK : F_UNLCK;
 510     flock.l_whence = SEEK_SET;
 511     flock.l_start = 0;
 512     flock.l_len = 0;
 513
 514     if (fcntl(fd, F_SETLKW, &flock) < 0) {
 515         pa_log(__FILE__": %slock failed: %s\n", !b ? "un" : "", strerror(errno));
 516         return -1;
 517     }
 518
 519     return 0;
 520 }
 521
 522 char* pa_strip_nl(char *s) {
 523     assert(s);
 524
 525     s[strcspn(s, "\r\n")] = 0;
 526     return s;
 527 }
 528
 529 int pa_lock_lockfile(const char *fn) {
 530     int fd;
 531     assert(fn);
 532
 533     if ((fd = open(fn, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR)) < 0) {
 534         pa_log(__FILE__": failed to create lock file '%s'\n", fn);
 535         goto fail;
 536     }
 537
 538     if (pa_lock_fd(fd, 1) < 0)
 539         goto fail;
 540
 541     return fd;
 542
 543 fail:
 544
 545     if (fd >= 0)
 546         close(fd);
 547
 548     return -1;
 549 }
 550
 551
 552 int pa_unlock_lockfile(int fd) {
 553     int r = 0;
 554     assert(fd >= 0);
 555
 556     if (pa_lock_fd(fd, 0) < 0) {
 557         pa_log(__FILE__": WARNING: failed to unlock file.\n");
 558         r = -1;
 559     }
 560
 561     if (close(fd) < 0) {
 562         pa_log(__FILE__": WARNING: failed to close lock file.\n");
 563         r = -1;
 564     }
 565
 566     return r;
 567 }
 568