code.delx.au - pulseaudio/blob - src/utils/padsp.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2006 Lennart Poettering
   5   Copyright 2006-2007 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #ifdef _FILE_OFFSET_BITS
  28 #undef _FILE_OFFSET_BITS
  29 #endif
  30
  31 #ifndef _LARGEFILE64_SOURCE
  32 #define _LARGEFILE64_SOURCE 1
  33 #endif
  34
  35 #include <sys/soundcard.h>
  36 #include <sys/ioctl.h>
  37 #include <pthread.h>
  38 #include <unistd.h>
  39 #include <sys/socket.h>
  40 #include <sys/stat.h>
  41 #include <dlfcn.h>
  42 #include <errno.h>
  43 #include <fcntl.h>
  44 #include <string.h>
  45 #include <stdarg.h>
  46 #include <stdio.h>
  47 #include <signal.h>
  48
  49 #ifdef __linux__
  50 #include <linux/sockios.h>
  51 #endif
  52
  53 #include <pulse/pulseaudio.h>
  54 #include <pulse/gccmacro.h>
  55 #include <pulsecore/llist.h>
  56
  57 /* On some systems SIOCINQ isn't defined, but FIONREAD is just an alias */
  58 #if !defined(SIOCINQ) && defined(FIONREAD)
  59 # define SIOCINQ FIONREAD
  60 #endif
  61
  62 /* make sure gcc doesn't redefine open and friends as macros */
  63 #undef open
  64 #undef open64
  65
  66 typedef enum {
  67     FD_INFO_MIXER,
  68     FD_INFO_STREAM,
  69 } fd_info_type_t;
  70
  71 typedef struct fd_info fd_info;
  72
  73 struct fd_info {
  74     pthread_mutex_t mutex;
  75     int ref;
  76     int unusable;
  77
  78     fd_info_type_t type;
  79     int app_fd, thread_fd;
  80
  81     pa_sample_spec sample_spec;
  82     size_t fragment_size;
  83     unsigned n_fragments;
  84
  85     pa_threaded_mainloop *mainloop;
  86     pa_context *context;
  87     pa_stream *play_stream;
  88     pa_stream *rec_stream;
  89     int play_precork;
  90     int rec_precork;
  91
  92     pa_io_event *io_event;
  93     pa_io_event_flags_t io_flags;
  94
  95     void *buf;
  96     size_t rec_offset;
  97
  98     int operation_success;
  99
 100     pa_cvolume sink_volume, source_volume;
 101     uint32_t sink_index, source_index;
 102     int volume_modify_count;
 103
 104     int optr_n_blocks;
 105
 106     PA_LLIST_FIELDS(fd_info);
 107 };
 108
 109 static int dsp_drain(fd_info *i);
 110 static void fd_info_remove_from_list(fd_info *i);
 111
 112 static pthread_mutex_t fd_infos_mutex = PTHREAD_MUTEX_INITIALIZER;
 113 static pthread_mutex_t func_mutex = PTHREAD_MUTEX_INITIALIZER;
 114
 115 static PA_LLIST_HEAD(fd_info, fd_infos) = NULL;
 116
 117 static int (*_ioctl)(int, int, void*) = NULL;
 118 static int (*_close)(int) = NULL;
 119 static int (*_open)(const char *, int, mode_t) = NULL;
 120 static FILE* (*_fopen)(const char *path, const char *mode) = NULL;
 121 static int (*_stat)(const char *, struct stat *) = NULL;
 122 #ifdef _STAT_VER
 123 static int (*___xstat)(int, const char *, struct stat *) = NULL;
 124 #endif
 125 #ifdef HAVE_OPEN64
 126 static int (*_open64)(const char *, int, mode_t) = NULL;
 127 static FILE* (*_fopen64)(const char *path, const char *mode) = NULL;
 128 static int (*_stat64)(const char *, struct stat64 *) = NULL;
 129 #ifdef _STAT_VER
 130 static int (*___xstat64)(int, const char *, struct stat64 *) = NULL;
 131 #endif
 132 #endif
 133 static int (*_fclose)(FILE *f) = NULL;
 134 static int (*_access)(const char *, int) = NULL;
 135
 136 /* dlsym() violates ISO C, so confide the breakage into this function to
 137  * avoid warnings. */
 138 typedef void (*fnptr)(void);
 139 static inline fnptr dlsym_fn(void *handle, const char *symbol) {
 140     return (fnptr) (long) dlsym(handle, symbol);
 141 }
 142
 143 #define LOAD_IOCTL_FUNC() \
 144 do { \
 145     pthread_mutex_lock(&func_mutex); \
 146     if (!_ioctl)  \
 147         _ioctl = (int (*)(int, int, void*)) dlsym_fn(RTLD_NEXT, "ioctl"); \
 148     pthread_mutex_unlock(&func_mutex); \
 149 } while(0)
 150
 151 #define LOAD_OPEN_FUNC() \
 152 do { \
 153     pthread_mutex_lock(&func_mutex); \
 154     if (!_open) \
 155         _open = (int (*)(const char *, int, mode_t)) dlsym_fn(RTLD_NEXT, "open"); \
 156     pthread_mutex_unlock(&func_mutex); \
 157 } while(0)
 158
 159 #define LOAD_OPEN64_FUNC() \
 160 do { \
 161     pthread_mutex_lock(&func_mutex); \
 162     if (!_open64) \
 163         _open64 = (int (*)(const char *, int, mode_t)) dlsym_fn(RTLD_NEXT, "open64"); \
 164     pthread_mutex_unlock(&func_mutex); \
 165 } while(0)
 166
 167 #define LOAD_CLOSE_FUNC() \
 168 do { \
 169     pthread_mutex_lock(&func_mutex); \
 170     if (!_close) \
 171         _close = (int (*)(int)) dlsym_fn(RTLD_NEXT, "close"); \
 172     pthread_mutex_unlock(&func_mutex); \
 173 } while(0)
 174
 175 #define LOAD_ACCESS_FUNC() \
 176 do { \
 177     pthread_mutex_lock(&func_mutex); \
 178     if (!_access) \
 179         _access = (int (*)(const char*, int)) dlsym_fn(RTLD_NEXT, "access"); \
 180     pthread_mutex_unlock(&func_mutex); \
 181 } while(0)
 182
 183 #define LOAD_STAT_FUNC() \
 184 do { \
 185     pthread_mutex_lock(&func_mutex); \
 186     if (!_stat) \
 187         _stat = (int (*)(const char *, struct stat *)) dlsym_fn(RTLD_NEXT, "stat"); \
 188     pthread_mutex_unlock(&func_mutex); \
 189 } while(0)
 190
 191 #define LOAD_STAT64_FUNC() \
 192 do { \
 193     pthread_mutex_lock(&func_mutex); \
 194     if (!_stat64) \
 195         _stat64 = (int (*)(const char *, struct stat64 *)) dlsym_fn(RTLD_NEXT, "stat64"); \
 196     pthread_mutex_unlock(&func_mutex); \
 197 } while(0)
 198
 199 #define LOAD_XSTAT_FUNC() \
 200 do { \
 201     pthread_mutex_lock(&func_mutex); \
 202     if (!___xstat) \
 203         ___xstat = (int (*)(int, const char *, struct stat *)) dlsym_fn(RTLD_NEXT, "__xstat"); \
 204     pthread_mutex_unlock(&func_mutex); \
 205 } while(0)
 206
 207 #define LOAD_XSTAT64_FUNC() \
 208 do { \
 209     pthread_mutex_lock(&func_mutex); \
 210     if (!___xstat64) \
 211         ___xstat64 = (int (*)(int, const char *, struct stat64 *)) dlsym_fn(RTLD_NEXT, "__xstat64"); \
 212     pthread_mutex_unlock(&func_mutex); \
 213 } while(0)
 214
 215 #define LOAD_FOPEN_FUNC() \
 216 do { \
 217     pthread_mutex_lock(&func_mutex); \
 218     if (!_fopen) \
 219         _fopen = (FILE* (*)(const char *, const char*)) dlsym_fn(RTLD_NEXT, "fopen"); \
 220     pthread_mutex_unlock(&func_mutex); \
 221 } while(0)
 222
 223 #define LOAD_FOPEN64_FUNC() \
 224 do { \
 225     pthread_mutex_lock(&func_mutex); \
 226     if (!_fopen64) \
 227         _fopen64 = (FILE* (*)(const char *, const char*)) dlsym_fn(RTLD_NEXT, "fopen64"); \
 228     pthread_mutex_unlock(&func_mutex); \
 229 } while(0)
 230
 231 #define LOAD_FCLOSE_FUNC() \
 232 do { \
 233     pthread_mutex_lock(&func_mutex); \
 234     if (!_fclose) \
 235         _fclose = (int (*)(FILE *)) dlsym_fn(RTLD_NEXT, "fclose"); \
 236     pthread_mutex_unlock(&func_mutex); \
 237 } while(0)
 238
 239 #define CONTEXT_CHECK_DEAD_GOTO(i, label) do { \
 240 if (!(i)->context || pa_context_get_state((i)->context) != PA_CONTEXT_READY) { \
 241     debug(DEBUG_LEVEL_NORMAL, __FILE__": Not connected: %s\n", (i)->context ? pa_strerror(pa_context_errno((i)->context)) : "NULL"); \
 242     goto label; \
 243 } \
 244 } while(0)
 245
 246 #define PLAYBACK_STREAM_CHECK_DEAD_GOTO(i, label) do { \
 247 if (!(i)->context || pa_context_get_state((i)->context) != PA_CONTEXT_READY || \
 248     !(i)->play_stream || pa_stream_get_state((i)->play_stream) != PA_STREAM_READY) { \
 249     debug(DEBUG_LEVEL_NORMAL, __FILE__": Not connected: %s\n", (i)->context ? pa_strerror(pa_context_errno((i)->context)) : "NULL"); \
 250     goto label; \
 251 } \
 252 } while(0)
 253
 254 #define RECORD_STREAM_CHECK_DEAD_GOTO(i, label) do { \
 255 if (!(i)->context || pa_context_get_state((i)->context) != PA_CONTEXT_READY || \
 256     !(i)->rec_stream || pa_stream_get_state((i)->rec_stream) != PA_STREAM_READY) { \
 257     debug(DEBUG_LEVEL_NORMAL, __FILE__": Not connected: %s\n", (i)->context ? pa_strerror(pa_context_errno((i)->context)) : "NULL"); \
 258     goto label; \
 259 } \
 260 } while(0)
 261
 262 static void debug(int level, const char *format, ...) PA_GCC_PRINTF_ATTR(2,3);
 263
 264 #define DEBUG_LEVEL_ALWAYS                0
 265 #define DEBUG_LEVEL_NORMAL                1
 266 #define DEBUG_LEVEL_VERBOSE                2
 267
 268 static void debug(int level, const char *format, ...) {
 269     va_list ap;
 270     const char *dlevel_s;
 271     int dlevel;
 272
 273     dlevel_s = getenv("PADSP_DEBUG");
 274     if (!dlevel_s)
 275         return;
 276
 277     dlevel = atoi(dlevel_s);
 278
 279     if (dlevel < level)
 280         return;
 281
 282     va_start(ap, format);
 283     vfprintf(stderr, format, ap);
 284     va_end(ap);
 285 }
 286
 287 static int padsp_disabled(void) {
 288     static int *sym;
 289     static int sym_resolved = 0;
 290
 291     /* If the current process has a symbol __padsp_disabled__ we use
 292      * it to detect whether we should enable our stuff or not. A
 293      * program needs to be compiled with -rdynamic for this to work!
 294      * The symbol must be an int containing a three bit bitmask: bit 1
 295      * -> disable /dev/dsp emulation, bit 2 -> disable /dev/sndstat
 296      * emulation, bit 3 -> disable /dev/mixer emulation. Hence a value
 297      * of 7 disables padsp entirely. */
 298
 299     pthread_mutex_lock(&func_mutex);
 300     if (!sym_resolved) {
 301         sym = (int*) dlsym(RTLD_DEFAULT, "__padsp_disabled__");
 302         sym_resolved = 1;
 303     }
 304     pthread_mutex_unlock(&func_mutex);
 305
 306     if (!sym)
 307         return 0;
 308
 309     return *sym;
 310 }
 311
 312 static int dsp_cloak_enable(void) {
 313     if (padsp_disabled() & 1)
 314         return 0;
 315
 316     if (getenv("PADSP_NO_DSP") || getenv("PULSE_INTERNAL"))
 317         return 0;
 318
 319     return 1;
 320 }
 321
 322 static int sndstat_cloak_enable(void) {
 323     if (padsp_disabled() & 2)
 324         return 0;
 325
 326     if (getenv("PADSP_NO_SNDSTAT") || getenv("PULSE_INTERNAL"))
 327         return 0;
 328
 329     return 1;
 330 }
 331
 332 static int mixer_cloak_enable(void) {
 333     if (padsp_disabled() & 4)
 334         return 0;
 335
 336     if (getenv("PADSP_NO_MIXER") || getenv("PULSE_INTERNAL"))
 337         return 0;
 338
 339     return 1;
 340 }
 341 static pthread_key_t recursion_key;
 342
 343 static void recursion_key_alloc(void) {
 344     pthread_key_create(&recursion_key, NULL);
 345 }
 346
 347 static int function_enter(void) {
 348     /* Avoid recursive calls */
 349     static pthread_once_t recursion_key_once = PTHREAD_ONCE_INIT;
 350     pthread_once(&recursion_key_once, recursion_key_alloc);
 351
 352     if (pthread_getspecific(recursion_key))
 353         return 0;
 354
 355     pthread_setspecific(recursion_key, (void*) 1);
 356     return 1;
 357 }
 358
 359 static void function_exit(void) {
 360     pthread_setspecific(recursion_key, NULL);
 361 }
 362
 363 static void fd_info_free(fd_info *i) {
 364     assert(i);
 365
 366     debug(DEBUG_LEVEL_NORMAL, __FILE__": freeing fd info (fd=%i)\n", i->app_fd);
 367
 368     dsp_drain(i);
 369
 370     if (i->mainloop)
 371         pa_threaded_mainloop_stop(i->mainloop);
 372
 373     if (i->play_stream) {
 374         pa_stream_disconnect(i->play_stream);
 375         pa_stream_unref(i->play_stream);
 376     }
 377
 378     if (i->rec_stream) {
 379         pa_stream_disconnect(i->rec_stream);
 380         pa_stream_unref(i->rec_stream);
 381     }
 382
 383     if (i->context) {
 384         pa_context_disconnect(i->context);
 385         pa_context_unref(i->context);
 386     }
 387
 388     if (i->mainloop)
 389         pa_threaded_mainloop_free(i->mainloop);
 390
 391     if (i->app_fd >= 0) {
 392         LOAD_CLOSE_FUNC();
 393         _close(i->app_fd);
 394     }
 395
 396     if (i->thread_fd >= 0) {
 397         LOAD_CLOSE_FUNC();
 398         _close(i->thread_fd);
 399     }
 400
 401     free(i->buf);
 402
 403     pthread_mutex_destroy(&i->mutex);
 404     free(i);
 405 }
 406
 407 static fd_info *fd_info_ref(fd_info *i) {
 408     assert(i);
 409
 410     pthread_mutex_lock(&i->mutex);
 411     assert(i->ref >= 1);
 412     i->ref++;
 413
 414     debug(DEBUG_LEVEL_VERBOSE, __FILE__": ref++, now %i\n", i->ref);
 415     pthread_mutex_unlock(&i->mutex);
 416
 417     return i;
 418 }
 419
 420 static void fd_info_unref(fd_info *i) {
 421     int r;
 422     pthread_mutex_lock(&i->mutex);
 423     assert(i->ref >= 1);
 424     r = --i->ref;
 425     debug(DEBUG_LEVEL_VERBOSE, __FILE__": ref--, now %i\n", i->ref);
 426     pthread_mutex_unlock(&i->mutex);
 427
 428     if (r <= 0)
 429         fd_info_free(i);
 430 }
 431
 432 static void context_state_cb(pa_context *c, void *userdata) {
 433     fd_info *i = userdata;
 434     assert(c);
 435
 436     switch (pa_context_get_state(c)) {
 437         case PA_CONTEXT_READY:
 438         case PA_CONTEXT_TERMINATED:
 439         case PA_CONTEXT_FAILED:
 440             pa_threaded_mainloop_signal(i->mainloop, 0);
 441             break;
 442
 443         case PA_CONTEXT_UNCONNECTED:
 444         case PA_CONTEXT_CONNECTING:
 445         case PA_CONTEXT_AUTHORIZING:
 446         case PA_CONTEXT_SETTING_NAME:
 447             break;
 448     }
 449 }
 450
 451 static void reset_params(fd_info *i) {
 452     assert(i);
 453
 454     i->sample_spec.format = PA_SAMPLE_U8;
 455     i->sample_spec.channels = 1;
 456     i->sample_spec.rate = 8000;
 457     i->fragment_size = 0;
 458     i->n_fragments = 0;
 459 }
 460
 461 static const char *client_name(char *buf, size_t n) {
 462     char p[PATH_MAX];
 463     const char *e;
 464
 465     if ((e = getenv("PADSP_CLIENT_NAME")))
 466         return e;
 467
 468     if (pa_get_binary_name(p, sizeof(p)))
 469         snprintf(buf, n, "OSS Emulation[%s]", p);
 470     else
 471         snprintf(buf, n, "OSS");
 472
 473     return buf;
 474 }
 475
 476 static const char *stream_name(void) {
 477     const char *e;
 478
 479     if ((e = getenv("PADSP_STREAM_NAME")))
 480         return e;
 481
 482     return "Audio Stream";
 483 }
 484
 485 static void atfork_prepare(void) {
 486     fd_info *i;
 487
 488     debug(DEBUG_LEVEL_NORMAL, __FILE__": atfork_prepare() enter\n");
 489
 490     function_enter();
 491
 492     pthread_mutex_lock(&fd_infos_mutex);
 493
 494     for (i = fd_infos; i; i = i->next) {
 495         pthread_mutex_lock(&i->mutex);
 496         pa_threaded_mainloop_lock(i->mainloop);
 497     }
 498
 499     pthread_mutex_lock(&func_mutex);
 500
 501     debug(DEBUG_LEVEL_NORMAL, __FILE__": atfork_prepare() exit\n");
 502 }
 503
 504 static void atfork_parent(void) {
 505     fd_info *i;
 506
 507     debug(DEBUG_LEVEL_NORMAL, __FILE__": atfork_parent() enter\n");
 508
 509     pthread_mutex_unlock(&func_mutex);
 510
 511     for (i = fd_infos; i; i = i->next) {
 512         pa_threaded_mainloop_unlock(i->mainloop);
 513         pthread_mutex_unlock(&i->mutex);
 514     }
 515
 516     pthread_mutex_unlock(&fd_infos_mutex);
 517
 518     function_exit();
 519
 520     debug(DEBUG_LEVEL_NORMAL, __FILE__": atfork_parent() exit\n");
 521 }
 522
 523 static void atfork_child(void) {
 524     fd_info *i;
 525
 526     debug(DEBUG_LEVEL_NORMAL, __FILE__": atfork_child() enter\n");
 527
 528     /* We do only the bare minimum to get all fds closed */
 529     pthread_mutex_init(&func_mutex, NULL);
 530     pthread_mutex_init(&fd_infos_mutex, NULL);
 531
 532     for (i = fd_infos; i; i = i->next) {
 533         pthread_mutex_init(&i->mutex, NULL);
 534
 535         if (i->context) {
 536             pa_context_disconnect(i->context);
 537             pa_context_unref(i->context);
 538             i->context = NULL;
 539         }
 540
 541         if (i->play_stream) {
 542             pa_stream_unref(i->play_stream);
 543             i->play_stream = NULL;
 544         }
 545
 546         if (i->rec_stream) {
 547             pa_stream_unref(i->rec_stream);
 548             i->rec_stream = NULL;
 549         }
 550
 551         if (i->app_fd >= 0) {
 552             LOAD_CLOSE_FUNC();
 553             _close(i->app_fd);
 554             i->app_fd = -1;
 555         }
 556
 557         if (i->thread_fd >= 0) {
 558             LOAD_CLOSE_FUNC();
 559             _close(i->thread_fd);
 560             i->thread_fd = -1;
 561         }
 562
 563         i->unusable = 1;
 564     }
 565
 566     function_exit();
 567
 568     debug(DEBUG_LEVEL_NORMAL, __FILE__": atfork_child() exit\n");
 569 }
 570
 571 static void install_atfork(void) {
 572     pthread_atfork(atfork_prepare, atfork_parent, atfork_child);
 573 }
 574
 575 static void stream_success_cb(pa_stream *s, int success, void *userdata) {
 576     fd_info *i = userdata;
 577
 578     assert(s);
 579     assert(i);
 580
 581     i->operation_success = success;
 582     pa_threaded_mainloop_signal(i->mainloop, 0);
 583 }
 584
 585 static void context_success_cb(pa_context *c, int success, void *userdata) {
 586     fd_info *i = userdata;
 587
 588     assert(c);
 589     assert(i);
 590
 591     i->operation_success = success;
 592     pa_threaded_mainloop_signal(i->mainloop, 0);
 593 }
 594
 595 static fd_info* fd_info_new(fd_info_type_t type, int *_errno) {
 596     fd_info *i;
 597     int sfds[2] = { -1, -1 };
 598     char name[64];
 599     static pthread_once_t install_atfork_once = PTHREAD_ONCE_INIT;
 600
 601     debug(DEBUG_LEVEL_NORMAL, __FILE__": fd_info_new()\n");
 602
 603     signal(SIGPIPE, SIG_IGN); /* Yes, ugly as hell */
 604
 605     pthread_once(&install_atfork_once, install_atfork);
 606
 607     if (!(i = malloc(sizeof(fd_info)))) {
 608         *_errno = ENOMEM;
 609         goto fail;
 610     }
 611
 612     i->app_fd = i->thread_fd = -1;
 613     i->type = type;
 614
 615     i->mainloop = NULL;
 616     i->context = NULL;
 617     i->play_stream = NULL;
 618     i->rec_stream = NULL;
 619     i->play_precork = 0;
 620     i->rec_precork = 0;
 621     i->io_event = NULL;
 622     i->io_flags = 0;
 623     pthread_mutex_init(&i->mutex, NULL);
 624     i->ref = 1;
 625     i->buf = NULL;
 626     i->rec_offset = 0;
 627     i->unusable = 0;
 628     pa_cvolume_reset(&i->sink_volume, 2);
 629     pa_cvolume_reset(&i->source_volume, 2);
 630     i->volume_modify_count = 0;
 631     i->sink_index = (uint32_t) -1;
 632     i->source_index = (uint32_t) -1;
 633     i->optr_n_blocks = 0;
 634     PA_LLIST_INIT(fd_info, i);
 635
 636     reset_params(i);
 637
 638     if (socketpair(AF_UNIX, SOCK_STREAM, 0, sfds) < 0) {
 639         *_errno = errno;
 640         debug(DEBUG_LEVEL_NORMAL, __FILE__": socket() failed: %s\n", strerror(errno));
 641         goto fail;
 642     }
 643
 644     i->app_fd = sfds[0];
 645     i->thread_fd = sfds[1];
 646
 647     if (!(i->mainloop = pa_threaded_mainloop_new())) {
 648         *_errno = EIO;
 649         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_threaded_mainloop_new() failed\n");
 650         goto fail;
 651     }
 652
 653     if (!(i->context = pa_context_new(pa_threaded_mainloop_get_api(i->mainloop), client_name(name, sizeof(name))))) {
 654         *_errno = EIO;
 655         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_context_new() failed\n");
 656         goto fail;
 657     }
 658
 659     pa_context_set_state_callback(i->context, context_state_cb, i);
 660
 661     if (pa_context_connect(i->context, NULL, 0, NULL) < 0) {
 662         *_errno = ECONNREFUSED;
 663         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_context_connect() failed: %s\n", pa_strerror(pa_context_errno(i->context)));
 664         goto fail;
 665     }
 666
 667     pa_threaded_mainloop_lock(i->mainloop);
 668
 669     if (pa_threaded_mainloop_start(i->mainloop) < 0) {
 670         *_errno = EIO;
 671         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_threaded_mainloop_start() failed\n");
 672         goto unlock_and_fail;
 673     }
 674
 675     /* Wait until the context is ready */
 676     pa_threaded_mainloop_wait(i->mainloop);
 677
 678     if (pa_context_get_state(i->context) != PA_CONTEXT_READY) {
 679         *_errno = ECONNREFUSED;
 680         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_context_connect() failed: %s\n", pa_strerror(pa_context_errno(i->context)));
 681         goto unlock_and_fail;
 682     }
 683
 684     pa_threaded_mainloop_unlock(i->mainloop);
 685     return i;
 686
 687 unlock_and_fail:
 688
 689     pa_threaded_mainloop_unlock(i->mainloop);
 690
 691 fail:
 692
 693     if (i)
 694         fd_info_unref(i);
 695
 696     return NULL;
 697 }
 698
 699 static void fd_info_add_to_list(fd_info *i) {
 700     assert(i);
 701
 702     pthread_mutex_lock(&fd_infos_mutex);
 703     PA_LLIST_PREPEND(fd_info, fd_infos, i);
 704     pthread_mutex_unlock(&fd_infos_mutex);
 705
 706     fd_info_ref(i);
 707 }
 708
 709 static void fd_info_remove_from_list(fd_info *i) {
 710     assert(i);
 711
 712     pthread_mutex_lock(&fd_infos_mutex);
 713     PA_LLIST_REMOVE(fd_info, fd_infos, i);
 714     pthread_mutex_unlock(&fd_infos_mutex);
 715
 716     fd_info_unref(i);
 717 }
 718
 719 static fd_info* fd_info_find(int fd) {
 720     fd_info *i;
 721
 722     pthread_mutex_lock(&fd_infos_mutex);
 723
 724     for (i = fd_infos; i; i = i->next)
 725         if (i->app_fd == fd && !i->unusable) {
 726             fd_info_ref(i);
 727             break;
 728         }
 729
 730     pthread_mutex_unlock(&fd_infos_mutex);
 731
 732     return i;
 733 }
 734
 735 static void fix_metrics(fd_info *i) {
 736     size_t fs;
 737     char t[PA_SAMPLE_SPEC_SNPRINT_MAX];
 738
 739     fs = pa_frame_size(&i->sample_spec);
 740
 741     /* Don't fix things more than necessary */
 742     if ((i->fragment_size % fs) == 0 &&
 743         i->n_fragments >= 2 &&
 744         i->fragment_size > 0)
 745         return;
 746
 747     i->fragment_size = (i->fragment_size/fs)*fs;
 748
 749     /* Number of fragments set? */
 750     if (i->n_fragments < 2) {
 751         if (i->fragment_size > 0) {
 752             i->n_fragments = (unsigned) (pa_bytes_per_second(&i->sample_spec) / 2 / i->fragment_size);
 753             if (i->n_fragments < 2)
 754                 i->n_fragments = 2;
 755         } else
 756             i->n_fragments = 12;
 757     }
 758
 759     /* Fragment size set? */
 760     if (i->fragment_size <= 0) {
 761         i->fragment_size = pa_bytes_per_second(&i->sample_spec) / 2 / i->n_fragments;
 762         if (i->fragment_size < 1024)
 763             i->fragment_size = 1024;
 764     }
 765
 766     debug(DEBUG_LEVEL_NORMAL, __FILE__": sample spec: %s\n", pa_sample_spec_snprint(t, sizeof(t), &i->sample_spec));
 767     debug(DEBUG_LEVEL_NORMAL, __FILE__": fixated metrics to %i fragments, %li bytes each.\n", i->n_fragments, (long)i->fragment_size);
 768 }
 769
 770 static void stream_request_cb(pa_stream *s, size_t length, void *userdata) {
 771     fd_info *i = userdata;
 772     assert(s);
 773
 774     if (i->io_event) {
 775         pa_mainloop_api *api;
 776         size_t n;
 777
 778         api = pa_threaded_mainloop_get_api(i->mainloop);
 779
 780         if (s == i->play_stream) {
 781             n = pa_stream_writable_size(i->play_stream);
 782             if (n == (size_t)-1) {
 783                 debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_writable_size(): %s\n",
 784                     pa_strerror(pa_context_errno(i->context)));
 785             }
 786
 787             if (n >= i->fragment_size)
 788                 i->io_flags |= PA_IO_EVENT_INPUT;
 789             else
 790                 i->io_flags &= ~PA_IO_EVENT_INPUT;
 791         }
 792
 793         if (s == i->rec_stream) {
 794             n = pa_stream_readable_size(i->rec_stream);
 795             if (n == (size_t)-1) {
 796                 debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_readable_size(): %s\n",
 797                     pa_strerror(pa_context_errno(i->context)));
 798             }
 799
 800             if (n >= i->fragment_size)
 801                 i->io_flags |= PA_IO_EVENT_OUTPUT;
 802             else
 803                 i->io_flags &= ~PA_IO_EVENT_OUTPUT;
 804         }
 805
 806         api->io_enable(i->io_event, i->io_flags);
 807     }
 808 }
 809
 810 static void stream_latency_update_cb(pa_stream *s, void *userdata) {
 811     fd_info *i = userdata;
 812     assert(s);
 813
 814     pa_threaded_mainloop_signal(i->mainloop, 0);
 815 }
 816
 817 static void fd_info_shutdown(fd_info *i) {
 818     assert(i);
 819
 820     if (i->io_event) {
 821         pa_mainloop_api *api;
 822         api = pa_threaded_mainloop_get_api(i->mainloop);
 823         api->io_free(i->io_event);
 824         i->io_event = NULL;
 825         i->io_flags = 0;
 826     }
 827
 828     if (i->thread_fd >= 0) {
 829         close(i->thread_fd);
 830         i->thread_fd = -1;
 831     }
 832 }
 833
 834 static int fd_info_copy_data(fd_info *i, int force) {
 835     size_t n;
 836
 837     if (!i->play_stream && !i->rec_stream)
 838         return -1;
 839
 840     if ((i->play_stream) && (pa_stream_get_state(i->play_stream) == PA_STREAM_READY)) {
 841         n = pa_stream_writable_size(i->play_stream);
 842
 843         if (n == (size_t)-1) {
 844             debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_writable_size(): %s\n",
 845                 pa_strerror(pa_context_errno(i->context)));
 846             return -1;
 847         }
 848
 849         while (n >= i->fragment_size || force) {
 850             ssize_t r;
 851
 852             if (!i->buf) {
 853                 if (!(i->buf = malloc(i->fragment_size))) {
 854                     debug(DEBUG_LEVEL_NORMAL, __FILE__": malloc() failed.\n");
 855                     return -1;
 856                 }
 857             }
 858
 859             if ((r = read(i->thread_fd, i->buf, i->fragment_size)) <= 0) {
 860
 861                 if (errno == EAGAIN)
 862                     break;
 863
 864                 debug(DEBUG_LEVEL_NORMAL, __FILE__": read(): %s\n", r == 0 ? "EOF" : strerror(errno));
 865                 return -1;
 866             }
 867
 868             if (pa_stream_write(i->play_stream, i->buf, (size_t) r, free, 0LL, PA_SEEK_RELATIVE) < 0) {
 869                 debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_write(): %s\n", pa_strerror(pa_context_errno(i->context)));
 870                 return -1;
 871             }
 872
 873             i->buf = NULL;
 874
 875             assert(n >= (size_t) r);
 876             n -= (size_t) r;
 877         }
 878
 879         if (n >= i->fragment_size)
 880             i->io_flags |= PA_IO_EVENT_INPUT;
 881         else
 882             i->io_flags &= ~PA_IO_EVENT_INPUT;
 883     }
 884
 885     if ((i->rec_stream) && (pa_stream_get_state(i->rec_stream) == PA_STREAM_READY)) {
 886         n = pa_stream_readable_size(i->rec_stream);
 887
 888         if (n == (size_t)-1) {
 889             debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_readable_size(): %s\n",
 890                 pa_strerror(pa_context_errno(i->context)));
 891             return -1;
 892         }
 893
 894         while (n >= i->fragment_size || force) {
 895             ssize_t r;
 896             const void *data;
 897             const char *buf;
 898             size_t len;
 899
 900             if (pa_stream_peek(i->rec_stream, &data, &len) < 0) {
 901                 debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_peek(): %s\n", pa_strerror(pa_context_errno(i->context)));
 902                 return -1;
 903             }
 904
 905             if (!data)
 906                 break;
 907
 908             buf = (const char*)data + i->rec_offset;
 909
 910             if ((r = write(i->thread_fd, buf, len - i->rec_offset)) <= 0) {
 911
 912                 if (errno == EAGAIN)
 913                     break;
 914
 915                 debug(DEBUG_LEVEL_NORMAL, __FILE__": write(): %s\n", strerror(errno));
 916                 return -1;
 917             }
 918
 919             assert((size_t)r <= len - i->rec_offset);
 920             i->rec_offset += (size_t) r;
 921
 922             if (i->rec_offset == len) {
 923                 if (pa_stream_drop(i->rec_stream) < 0) {
 924                     debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_drop(): %s\n", pa_strerror(pa_context_errno(i->context)));
 925                     return -1;
 926                 }
 927                 i->rec_offset = 0;
 928             }
 929
 930             assert(n >= (size_t) r);
 931             n -= (size_t) r;
 932         }
 933
 934         if (n >= i->fragment_size)
 935             i->io_flags |= PA_IO_EVENT_OUTPUT;
 936         else
 937             i->io_flags &= ~PA_IO_EVENT_OUTPUT;
 938     }
 939
 940     if (i->io_event) {
 941         pa_mainloop_api *api;
 942
 943         api = pa_threaded_mainloop_get_api(i->mainloop);
 944         api->io_enable(i->io_event, i->io_flags);
 945     }
 946
 947     /* So, we emptied the socket now, let's tell dsp_empty_socket()
 948      * about this */
 949     pa_threaded_mainloop_signal(i->mainloop, 0);
 950
 951     return 0;
 952 }
 953
 954 static void stream_state_cb(pa_stream *s, void * userdata) {
 955     fd_info *i = userdata;
 956     assert(s);
 957
 958     switch (pa_stream_get_state(s)) {
 959
 960         case PA_STREAM_READY:
 961             debug(DEBUG_LEVEL_NORMAL, __FILE__": stream established.\n");
 962             break;
 963
 964         case PA_STREAM_FAILED:
 965             if (s == i->play_stream) {
 966                 debug(DEBUG_LEVEL_NORMAL,
 967                     __FILE__": pa_stream_connect_playback() failed: %s\n",
 968                     pa_strerror(pa_context_errno(i->context)));
 969                 pa_stream_unref(i->play_stream);
 970                 i->play_stream = NULL;
 971             } else if (s == i->rec_stream) {
 972                 debug(DEBUG_LEVEL_NORMAL,
 973                     __FILE__": pa_stream_connect_record() failed: %s\n",
 974                     pa_strerror(pa_context_errno(i->context)));
 975                 pa_stream_unref(i->rec_stream);
 976                 i->rec_stream = NULL;
 977             }
 978             fd_info_shutdown(i);
 979             break;
 980
 981         case PA_STREAM_TERMINATED:
 982         case PA_STREAM_UNCONNECTED:
 983         case PA_STREAM_CREATING:
 984             break;
 985     }
 986 }
 987
 988 static int create_playback_stream(fd_info *i) {
 989     pa_buffer_attr attr;
 990     int n, flags;
 991
 992     assert(i);
 993
 994     fix_metrics(i);
 995
 996     if (!(i->play_stream = pa_stream_new(i->context, stream_name(), &i->sample_spec, NULL))) {
 997         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_new() failed: %s\n", pa_strerror(pa_context_errno(i->context)));
 998         goto fail;
 999     }
1000
1001     pa_stream_set_state_callback(i->play_stream, stream_state_cb, i);
1002     pa_stream_set_write_callback(i->play_stream, stream_request_cb, i);
1003     pa_stream_set_latency_update_callback(i->play_stream, stream_latency_update_cb, i);
1004
1005     memset(&attr, 0, sizeof(attr));
1006     attr.maxlength = (uint32_t) (i->fragment_size * (i->n_fragments+1));
1007     attr.tlength = (uint32_t) (i->fragment_size * i->n_fragments);
1008     attr.prebuf = (uint32_t) i->fragment_size;
1009     attr.minreq = (uint32_t) i->fragment_size;
1010
1011     flags = PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE|PA_STREAM_EARLY_REQUESTS;
1012     if (i->play_precork) {
1013         flags |= PA_STREAM_START_CORKED;
1014         debug(DEBUG_LEVEL_NORMAL, __FILE__": creating stream corked\n");
1015     }
1016     if (pa_stream_connect_playback(i->play_stream, NULL, &attr, flags, NULL, NULL) < 0) {
1017         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_connect_playback() failed: %s\n", pa_strerror(pa_context_errno(i->context)));
1018         goto fail;
1019     }
1020
1021     n = (int) i->fragment_size;
1022     setsockopt(i->app_fd, SOL_SOCKET, SO_SNDBUF, &n, sizeof(n));
1023     n = (int) i->fragment_size;
1024     setsockopt(i->thread_fd, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n));
1025
1026     return 0;
1027
1028 fail:
1029     return -1;
1030 }
1031
1032 static int create_record_stream(fd_info *i) {
1033     pa_buffer_attr attr;
1034     int n, flags;
1035
1036     assert(i);
1037
1038     fix_metrics(i);
1039
1040     if (!(i->rec_stream = pa_stream_new(i->context, stream_name(), &i->sample_spec, NULL))) {
1041         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_new() failed: %s\n", pa_strerror(pa_context_errno(i->context)));
1042         goto fail;
1043     }
1044
1045     pa_stream_set_state_callback(i->rec_stream, stream_state_cb, i);
1046     pa_stream_set_read_callback(i->rec_stream, stream_request_cb, i);
1047     pa_stream_set_latency_update_callback(i->rec_stream, stream_latency_update_cb, i);
1048
1049     memset(&attr, 0, sizeof(attr));
1050     attr.maxlength = (uint32_t) (i->fragment_size * (i->n_fragments+1));
1051     attr.fragsize = (uint32_t) i->fragment_size;
1052
1053     flags = PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE;
1054     if (i->rec_precork) {
1055         flags |= PA_STREAM_START_CORKED;
1056         debug(DEBUG_LEVEL_NORMAL, __FILE__": creating stream corked\n");
1057     }
1058     if (pa_stream_connect_record(i->rec_stream, NULL, &attr, flags) < 0) {
1059         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_connect_record() failed: %s\n", pa_strerror(pa_context_errno(i->context)));
1060         goto fail;
1061     }
1062
1063     n = (int) i->fragment_size;
1064     setsockopt(i->app_fd, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n));
1065     n = (int) i->fragment_size;
1066     setsockopt(i->thread_fd, SOL_SOCKET, SO_SNDBUF, &n, sizeof(n));
1067
1068     return 0;
1069
1070 fail:
1071     return -1;
1072 }
1073
1074 static void free_streams(fd_info *i) {
1075     assert(i);
1076
1077     if (i->play_stream) {
1078         pa_stream_disconnect(i->play_stream);
1079         pa_stream_unref(i->play_stream);
1080         i->play_stream = NULL;
1081         i->io_flags |= PA_IO_EVENT_INPUT;
1082     }
1083
1084     if (i->rec_stream) {
1085         pa_stream_disconnect(i->rec_stream);
1086         pa_stream_unref(i->rec_stream);
1087         i->rec_stream = NULL;
1088         i->io_flags |= PA_IO_EVENT_OUTPUT;
1089     }
1090
1091     if (i->io_event) {
1092         pa_mainloop_api *api;
1093
1094         api = pa_threaded_mainloop_get_api(i->mainloop);
1095         api->io_enable(i->io_event, i->io_flags);
1096     }
1097 }
1098
1099 static void io_event_cb(pa_mainloop_api *api, pa_io_event *e, int fd, pa_io_event_flags_t flags, void *userdata) {
1100     fd_info *i = userdata;
1101
1102     pa_threaded_mainloop_signal(i->mainloop, 0);
1103
1104     if (flags & PA_IO_EVENT_INPUT) {
1105
1106         if (!i->play_stream) {
1107             if (create_playback_stream(i) < 0)
1108                 goto fail;
1109         } else {
1110             if (fd_info_copy_data(i, 0) < 0)
1111                 goto fail;
1112         }
1113
1114     } else if (flags & PA_IO_EVENT_OUTPUT) {
1115
1116         if (!i->rec_stream) {
1117             if (create_record_stream(i) < 0)
1118                 goto fail;
1119         } else {
1120             if (fd_info_copy_data(i, 0) < 0)
1121                 goto fail;
1122         }
1123
1124     } else if (flags & (PA_IO_EVENT_HANGUP|PA_IO_EVENT_ERROR))
1125         goto fail;
1126
1127     return;
1128
1129 fail:
1130     /* We can't do anything better than removing the event source */
1131     fd_info_shutdown(i);
1132 }
1133
1134 static int dsp_open(int flags, int *_errno) {
1135     fd_info *i;
1136     pa_mainloop_api *api;
1137     int ret;
1138     int f;
1139
1140     debug(DEBUG_LEVEL_NORMAL, __FILE__": dsp_open()\n");
1141
1142     if (!(i = fd_info_new(FD_INFO_STREAM, _errno)))
1143         return -1;
1144
1145     if ((flags & O_NONBLOCK) == O_NONBLOCK) {
1146         if ((f = fcntl(i->app_fd, F_GETFL)) >= 0)
1147             fcntl(i->app_fd, F_SETFL, f|O_NONBLOCK);
1148     }
1149     if ((f = fcntl(i->thread_fd, F_GETFL)) >= 0)
1150         fcntl(i->thread_fd, F_SETFL, f|O_NONBLOCK);
1151
1152     fcntl(i->app_fd, F_SETFD, FD_CLOEXEC);
1153     fcntl(i->thread_fd, F_SETFD, FD_CLOEXEC);
1154
1155     pa_threaded_mainloop_lock(i->mainloop);
1156     api = pa_threaded_mainloop_get_api(i->mainloop);
1157
1158     switch (flags & O_ACCMODE) {
1159     case O_RDONLY:
1160         i->io_flags = PA_IO_EVENT_OUTPUT;
1161         shutdown(i->thread_fd, SHUT_RD);
1162         shutdown(i->app_fd, SHUT_WR);
1163         break;
1164     case O_WRONLY:
1165         i->io_flags = PA_IO_EVENT_INPUT;
1166         shutdown(i->thread_fd, SHUT_WR);
1167         shutdown(i->app_fd, SHUT_RD);
1168         break;
1169     case O_RDWR:
1170         i->io_flags = PA_IO_EVENT_INPUT | PA_IO_EVENT_OUTPUT;
1171         break;
1172     default:
1173         return -1;
1174     }
1175
1176     if (!(i->io_event = api->io_new(api, i->thread_fd, i->io_flags, io_event_cb, i)))
1177         goto fail;
1178
1179     pa_threaded_mainloop_unlock(i->mainloop);
1180
1181     debug(DEBUG_LEVEL_NORMAL, __FILE__": dsp_open() succeeded, fd=%i\n", i->app_fd);
1182
1183     fd_info_add_to_list(i);
1184     ret = i->app_fd;
1185     fd_info_unref(i);
1186
1187     return ret;
1188
1189 fail:
1190     pa_threaded_mainloop_unlock(i->mainloop);
1191
1192     if (i)
1193         fd_info_unref(i);
1194
1195     *_errno = EIO;
1196
1197     debug(DEBUG_LEVEL_NORMAL, __FILE__": dsp_open() failed\n");
1198
1199     return -1;
1200 }
1201
1202 static void sink_info_cb(pa_context *context, const pa_sink_info *si, int eol, void *userdata) {
1203     fd_info *i = userdata;
1204
1205     if (!si || eol < 0) {
1206         i->operation_success = 0;
1207         pa_threaded_mainloop_signal(i->mainloop, 0);
1208         return;
1209     }
1210
1211     if (eol)
1212         return;
1213
1214     if (!pa_cvolume_equal(&i->sink_volume, &si->volume))
1215         i->volume_modify_count++;
1216
1217     i->sink_volume = si->volume;
1218     i->sink_index = si->index;
1219
1220     i->operation_success = 1;
1221     pa_threaded_mainloop_signal(i->mainloop, 0);
1222 }
1223
1224 static void source_info_cb(pa_context *context, const pa_source_info *si, int eol, void *userdata) {
1225     fd_info *i = userdata;
1226
1227     if (!si || eol < 0) {
1228         i->operation_success = 0;
1229         pa_threaded_mainloop_signal(i->mainloop, 0);
1230         return;
1231     }
1232
1233     if (eol)
1234         return;
1235
1236     if (!pa_cvolume_equal(&i->source_volume, &si->volume))
1237         i->volume_modify_count++;
1238
1239     i->source_volume = si->volume;
1240     i->source_index = si->index;
1241
1242     i->operation_success = 1;
1243     pa_threaded_mainloop_signal(i->mainloop, 0);
1244 }
1245
1246 static void subscribe_cb(pa_context *context, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
1247     fd_info *i = userdata;
1248     pa_operation *o = NULL;
1249
1250     if (i->sink_index != idx)
1251         return;
1252
1253     if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) != PA_SUBSCRIPTION_EVENT_CHANGE)
1254         return;
1255
1256     if (!(o = pa_context_get_sink_info_by_index(i->context, i->sink_index, sink_info_cb, i))) {
1257         debug(DEBUG_LEVEL_NORMAL, __FILE__": Failed to get sink info: %s", pa_strerror(pa_context_errno(i->context)));
1258         return;
1259     }
1260
1261     pa_operation_unref(o);
1262 }
1263
1264 static int mixer_open(int flags, int *_errno) {
1265     fd_info *i;
1266     pa_operation *o = NULL;
1267     int ret;
1268
1269     debug(DEBUG_LEVEL_NORMAL, __FILE__": mixer_open()\n");
1270
1271     if (!(i = fd_info_new(FD_INFO_MIXER, _errno)))
1272         return -1;
1273
1274     pa_threaded_mainloop_lock(i->mainloop);
1275
1276     pa_context_set_subscribe_callback(i->context, subscribe_cb, i);
1277
1278     if (!(o = pa_context_subscribe(i->context, PA_SUBSCRIPTION_MASK_SINK | PA_SUBSCRIPTION_MASK_SOURCE, context_success_cb, i))) {
1279         debug(DEBUG_LEVEL_NORMAL, __FILE__": Failed to subscribe to events: %s", pa_strerror(pa_context_errno(i->context)));
1280         *_errno = EIO;
1281         goto fail;
1282     }
1283
1284     i->operation_success = 0;
1285     while (pa_operation_get_state(o) != PA_OPERATION_DONE) {
1286         pa_threaded_mainloop_wait(i->mainloop);
1287         CONTEXT_CHECK_DEAD_GOTO(i, fail);
1288     }
1289
1290     pa_operation_unref(o);
1291     o = NULL;
1292
1293     if (!i->operation_success) {
1294         debug(DEBUG_LEVEL_NORMAL, __FILE__":Failed to subscribe to events: %s", pa_strerror(pa_context_errno(i->context)));
1295         *_errno = EIO;
1296         goto fail;
1297     }
1298
1299     /* Get sink info */
1300
1301     if (!(o = pa_context_get_sink_info_by_name(i->context, NULL, sink_info_cb, i))) {
1302         debug(DEBUG_LEVEL_NORMAL, __FILE__": Failed to get sink info: %s", pa_strerror(pa_context_errno(i->context)));
1303         *_errno = EIO;
1304         goto fail;
1305     }
1306
1307     i->operation_success = 0;
1308     while (pa_operation_get_state(o) != PA_OPERATION_DONE) {
1309         pa_threaded_mainloop_wait(i->mainloop);
1310         CONTEXT_CHECK_DEAD_GOTO(i, fail);
1311     }
1312
1313     pa_operation_unref(o);
1314     o = NULL;
1315
1316     if (!i->operation_success) {
1317         debug(DEBUG_LEVEL_NORMAL, __FILE__": Failed to get sink info: %s", pa_strerror(pa_context_errno(i->context)));
1318         *_errno = EIO;
1319         goto fail;
1320     }
1321
1322     /* Get source info */
1323
1324     if (!(o = pa_context_get_source_info_by_name(i->context, NULL, source_info_cb, i))) {
1325         debug(DEBUG_LEVEL_NORMAL, __FILE__": Failed to get source info: %s", pa_strerror(pa_context_errno(i->context)));
1326         *_errno = EIO;
1327         goto fail;
1328     }
1329
1330     i->operation_success = 0;
1331     while (pa_operation_get_state(o) != PA_OPERATION_DONE) {
1332         pa_threaded_mainloop_wait(i->mainloop);
1333         CONTEXT_CHECK_DEAD_GOTO(i, fail);
1334     }
1335
1336     pa_operation_unref(o);
1337     o = NULL;
1338
1339     if (!i->operation_success) {
1340         debug(DEBUG_LEVEL_NORMAL, __FILE__": Failed to get source info: %s", pa_strerror(pa_context_errno(i->context)));
1341         *_errno = EIO;
1342         goto fail;
1343     }
1344
1345     pa_threaded_mainloop_unlock(i->mainloop);
1346
1347     debug(DEBUG_LEVEL_NORMAL, __FILE__": mixer_open() succeeded, fd=%i\n", i->app_fd);
1348
1349     fd_info_add_to_list(i);
1350     ret = i->app_fd;
1351     fd_info_unref(i);
1352
1353     return ret;
1354
1355 fail:
1356     if (o)
1357         pa_operation_unref(o);
1358
1359     pa_threaded_mainloop_unlock(i->mainloop);
1360
1361     if (i)
1362         fd_info_unref(i);
1363
1364     *_errno = EIO;
1365
1366     debug(DEBUG_LEVEL_NORMAL, __FILE__": mixer_open() failed\n");
1367
1368     return -1;
1369 }
1370
1371 static int sndstat_open(int flags, int *_errno) {
1372     static const char sndstat[] =
1373         "Sound Driver:3.8.1a-980706 (PulseAudio Virtual OSS)\n"
1374         "Kernel: POSIX\n"
1375         "Config options: 0\n"
1376         "\n"
1377         "Installed drivers:\n"
1378         "Type 255: PulseAudio Virtual OSS\n"
1379         "\n"
1380         "Card config:\n"
1381         "PulseAudio Virtual OSS\n"
1382         "\n"
1383         "Audio devices:\n"
1384         "0: PulseAudio Virtual OSS\n"
1385         "\n"
1386         "Synth devices: NOT ENABLED IN CONFIG\n"
1387         "\n"
1388         "Midi devices:\n"
1389         "\n"
1390         "Timers:\n"
1391         "\n"
1392         "Mixers:\n"
1393         "0: PulseAudio Virtual OSS\n";
1394
1395     char fn[] = "/tmp/padsp-sndstat-XXXXXX";
1396     mode_t u;
1397     int fd = -1;
1398     int e;
1399
1400     debug(DEBUG_LEVEL_NORMAL, __FILE__": sndstat_open()\n");
1401
1402     if (flags != O_RDONLY
1403 #ifdef O_LARGEFILE
1404         && flags != (O_RDONLY|O_LARGEFILE)
1405 #endif
1406        ) {
1407         *_errno = EACCES;
1408         debug(DEBUG_LEVEL_NORMAL, __FILE__": bad access!\n");
1409         goto fail;
1410     }
1411
1412     u = umask(0077);
1413     fd = mkstemp(fn);
1414     e = errno;
1415     umask(u);
1416
1417     if (fd < 0) {
1418         *_errno = e;
1419         debug(DEBUG_LEVEL_NORMAL, __FILE__": mkstemp() failed: %s\n", strerror(errno));
1420         goto fail;
1421     }
1422
1423     unlink(fn);
1424
1425     if (write(fd, sndstat, sizeof(sndstat) -1) != sizeof(sndstat)-1) {
1426         *_errno = errno;
1427         debug(DEBUG_LEVEL_NORMAL, __FILE__": write() failed: %s\n", strerror(errno));
1428         goto fail;
1429     }
1430
1431     if (lseek(fd, SEEK_SET, 0) < 0) {
1432         *_errno = errno;
1433         debug(DEBUG_LEVEL_NORMAL, __FILE__": lseek() failed: %s\n", strerror(errno));
1434         goto fail;
1435     }
1436
1437     return fd;
1438
1439 fail:
1440     if (fd >= 0)
1441         close(fd);
1442     return -1;
1443 }
1444
1445 static int real_open(const char *filename, int flags, mode_t mode) {
1446     int r, _errno = 0;
1447
1448     debug(DEBUG_LEVEL_VERBOSE, __FILE__": open(%s)\n", filename?filename:"NULL");
1449
1450     if (!function_enter()) {
1451         LOAD_OPEN_FUNC();
1452         return _open(filename, flags, mode);
1453     }
1454
1455     if (filename && dsp_cloak_enable() && (strcmp(filename, "/dev/dsp") == 0 || strcmp(filename, "/dev/adsp") == 0))
1456         r = dsp_open(flags, &_errno);
1457     else if (filename && mixer_cloak_enable() && strcmp(filename, "/dev/mixer") == 0)
1458         r = mixer_open(flags, &_errno);
1459     else if (filename && sndstat_cloak_enable() && strcmp(filename, "/dev/sndstat") == 0)
1460         r = sndstat_open(flags, &_errno);
1461     else {
1462         function_exit();
1463         LOAD_OPEN_FUNC();
1464         return _open(filename, flags, mode);
1465     }
1466
1467     function_exit();
1468
1469     if (_errno)
1470         errno = _errno;
1471
1472     return r;
1473 }
1474
1475 int open(const char *filename, int flags, ...) {
1476     va_list args;
1477     mode_t mode = 0;
1478
1479     if (flags & O_CREAT) {
1480         va_start(args, flags);
1481         if (sizeof(mode_t) < sizeof(int))
1482             mode = (mode_t) va_arg(args, int);
1483         else
1484             mode = va_arg(args, mode_t);
1485         va_end(args);
1486     }
1487
1488     return real_open(filename, flags, mode);
1489 }
1490
1491 static int mixer_ioctl(fd_info *i, unsigned long request, void*argp, int *_errno) {
1492     int ret = -1;
1493
1494     switch (request) {
1495         case SOUND_MIXER_READ_DEVMASK :
1496             debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_READ_DEVMASK\n");
1497
1498             *(int*) argp = SOUND_MASK_PCM | SOUND_MASK_IGAIN;
1499             break;
1500
1501         case SOUND_MIXER_READ_RECMASK :
1502             debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_READ_RECMASK\n");
1503
1504             *(int*) argp = SOUND_MASK_IGAIN;
1505             break;
1506
1507         case SOUND_MIXER_READ_STEREODEVS:
1508             debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_READ_STEREODEVS\n");
1509
1510             pa_threaded_mainloop_lock(i->mainloop);
1511             *(int*) argp = 0;
1512             if (i->sink_volume.channels > 1)
1513                 *(int*) argp |= SOUND_MASK_PCM;
1514             if (i->source_volume.channels > 1)
1515                 *(int*) argp |= SOUND_MASK_IGAIN;
1516             pa_threaded_mainloop_unlock(i->mainloop);
1517
1518             break;
1519
1520         case SOUND_MIXER_READ_RECSRC:
1521             debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_READ_RECSRC\n");
1522
1523             *(int*) argp = SOUND_MASK_IGAIN;
1524             break;
1525
1526         case SOUND_MIXER_WRITE_RECSRC:
1527             debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_WRITE_RECSRC\n");
1528             break;
1529
1530         case SOUND_MIXER_READ_CAPS:
1531             debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_READ_CAPS\n");
1532
1533             *(int*) argp = 0;
1534             break;
1535
1536         case SOUND_MIXER_READ_PCM:
1537         case SOUND_MIXER_READ_IGAIN: {
1538             pa_cvolume *v;
1539
1540             if (request == SOUND_MIXER_READ_PCM)
1541                 debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_READ_PCM\n");
1542             else
1543                 debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_READ_IGAIN\n");
1544
1545             pa_threaded_mainloop_lock(i->mainloop);
1546
1547             if (request == SOUND_MIXER_READ_PCM)
1548                 v = &i->sink_volume;
1549             else
1550                 v = &i->source_volume;
1551
1552             *(int*) argp =
1553                 ((v->values[0]*100/PA_VOLUME_NORM)) |
1554                 ((v->values[v->channels > 1 ? 1 : 0]*100/PA_VOLUME_NORM)  << 8);
1555
1556             pa_threaded_mainloop_unlock(i->mainloop);
1557
1558             break;
1559         }
1560
1561         case SOUND_MIXER_WRITE_PCM:
1562         case SOUND_MIXER_WRITE_IGAIN: {
1563             pa_cvolume v, *pv;
1564
1565             if (request == SOUND_MIXER_WRITE_PCM)
1566                 debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_WRITE_PCM\n");
1567             else
1568                 debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_WRITE_IGAIN\n");
1569
1570             pa_threaded_mainloop_lock(i->mainloop);
1571
1572             if (request == SOUND_MIXER_WRITE_PCM) {
1573                 v = i->sink_volume;
1574                 pv = &i->sink_volume;
1575             } else {
1576                 v = i->source_volume;
1577                 pv = &i->source_volume;
1578             }
1579
1580             pv->values[0] = ((*(int*) argp & 0xFF)*PA_VOLUME_NORM)/100;
1581             pv->values[1] = ((*(int*) argp >> 8)*PA_VOLUME_NORM)/100;
1582
1583             if (!pa_cvolume_equal(pv, &v)) {
1584                 pa_operation *o;
1585
1586                 if (request == SOUND_MIXER_WRITE_PCM)
1587                     o = pa_context_set_sink_volume_by_index(i->context, i->sink_index, pv, context_success_cb, i);
1588                 else
1589                     o = pa_context_set_source_volume_by_index(i->context, i->source_index, pv, context_success_cb, i);
1590
1591                 if (!o)
1592                     debug(DEBUG_LEVEL_NORMAL, __FILE__":Failed set volume: %s", pa_strerror(pa_context_errno(i->context)));
1593                 else {
1594
1595                     i->operation_success = 0;
1596                     while (pa_operation_get_state(o) != PA_OPERATION_DONE) {
1597                         CONTEXT_CHECK_DEAD_GOTO(i, exit_loop);
1598
1599                         pa_threaded_mainloop_wait(i->mainloop);
1600                     }
1601                 exit_loop:
1602
1603                     if (!i->operation_success)
1604                         debug(DEBUG_LEVEL_NORMAL, __FILE__": Failed to set volume: %s\n", pa_strerror(pa_context_errno(i->context)));
1605
1606                     pa_operation_unref(o);
1607                 }
1608
1609                 /* We don't wait for completion here */
1610                 i->volume_modify_count++;
1611             }
1612
1613             pa_threaded_mainloop_unlock(i->mainloop);
1614
1615             break;
1616         }
1617
1618         case SOUND_MIXER_INFO: {
1619             mixer_info *mi = argp;
1620
1621             debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_MIXER_INFO\n");
1622
1623             memset(mi, 0, sizeof(mixer_info));
1624             strncpy(mi->id, "PULSEAUDIO", sizeof(mi->id));
1625             strncpy(mi->name, "PulseAudio Virtual OSS", sizeof(mi->name));
1626             pa_threaded_mainloop_lock(i->mainloop);
1627             mi->modify_counter = i->volume_modify_count;
1628             pa_threaded_mainloop_unlock(i->mainloop);
1629             break;
1630         }
1631
1632         default:
1633             debug(DEBUG_LEVEL_NORMAL, __FILE__": unknown ioctl 0x%08lx\n", request);
1634
1635             *_errno = EINVAL;
1636             goto fail;
1637     }
1638
1639     ret = 0;
1640
1641 fail:
1642
1643     return ret;
1644 }
1645
1646 static int map_format(int *fmt, pa_sample_spec *ss) {
1647
1648     switch (*fmt) {
1649         case AFMT_MU_LAW:
1650             ss->format = PA_SAMPLE_ULAW;
1651             break;
1652
1653         case AFMT_A_LAW:
1654             ss->format = PA_SAMPLE_ALAW;
1655             break;
1656
1657         case AFMT_S8:
1658             *fmt = AFMT_U8;
1659             /* fall through */
1660         case AFMT_U8:
1661             ss->format = PA_SAMPLE_U8;
1662             break;
1663
1664         case AFMT_U16_BE:
1665             *fmt = AFMT_S16_BE;
1666             /* fall through */
1667         case AFMT_S16_BE:
1668             ss->format = PA_SAMPLE_S16BE;
1669             break;
1670
1671         case AFMT_U16_LE:
1672             *fmt = AFMT_S16_LE;
1673             /* fall through */
1674         case AFMT_S16_LE:
1675             ss->format = PA_SAMPLE_S16LE;
1676             break;
1677
1678         default:
1679             ss->format = PA_SAMPLE_S16NE;
1680             *fmt = AFMT_S16_NE;
1681             break;
1682     }
1683
1684     return 0;
1685 }
1686
1687 static int map_format_back(pa_sample_format_t format) {
1688     switch (format) {
1689         case PA_SAMPLE_S16LE: return AFMT_S16_LE;
1690         case PA_SAMPLE_S16BE: return AFMT_S16_BE;
1691         case PA_SAMPLE_ULAW: return AFMT_MU_LAW;
1692         case PA_SAMPLE_ALAW: return AFMT_A_LAW;
1693         case PA_SAMPLE_U8: return AFMT_U8;
1694         default:
1695             abort();
1696     }
1697 }
1698
1699 static int dsp_flush_fd(int fd) {
1700 #ifdef SIOCINQ
1701     int l;
1702
1703     if (ioctl(fd, SIOCINQ, &l) < 0) {
1704         debug(DEBUG_LEVEL_NORMAL, __FILE__": SIOCINQ: %s\n", strerror(errno));
1705         return -1;
1706     }
1707
1708     while (l > 0) {
1709         char buf[1024];
1710         size_t k;
1711
1712         k = (size_t) l > sizeof(buf) ? sizeof(buf) : (size_t) l;
1713         if (read(fd, buf, k) < 0)
1714             debug(DEBUG_LEVEL_NORMAL, __FILE__": read(): %s\n", strerror(errno));
1715         l -= k;
1716     }
1717
1718     return 0;
1719 #else
1720 # warning "Your platform does not support SIOCINQ, something might not work as intended."
1721     return 0;
1722 #endif
1723 }
1724
1725 static int dsp_flush_socket(fd_info *i) {
1726     int res = 0;
1727
1728     if ((i->thread_fd < 0) && (i->app_fd < 0))
1729         return -1;
1730
1731     if (i->thread_fd >= 0)
1732         res = dsp_flush_fd(i->thread_fd);
1733
1734     if (res < 0)
1735         return res;
1736
1737     if (i->app_fd >= 0)
1738         res = dsp_flush_fd(i->app_fd);
1739
1740     if (res < 0)
1741         return res;
1742
1743     return 0;
1744 }
1745
1746 static int dsp_empty_socket(fd_info *i) {
1747 #ifdef SIOCINQ
1748     int ret = -1;
1749
1750     /* Empty the socket */
1751     for (;;) {
1752         int l;
1753
1754         if (i->thread_fd < 0)
1755             break;
1756
1757         if (ioctl(i->thread_fd, SIOCINQ, &l) < 0) {
1758             debug(DEBUG_LEVEL_NORMAL, __FILE__": SIOCINQ: %s\n", strerror(errno));
1759             break;
1760         }
1761
1762         if (!l) {
1763             ret = 0;
1764             break;
1765         }
1766
1767         pa_threaded_mainloop_wait(i->mainloop);
1768     }
1769
1770     return ret;
1771 #else
1772 # warning "Your platform does not support SIOCINQ, something might not work as intended."
1773     return 0;
1774 #endif
1775 }
1776
1777 static int dsp_drain(fd_info *i) {
1778     pa_operation *o = NULL;
1779     int r = -1;
1780
1781     if (!i->mainloop)
1782         return 0;
1783
1784     debug(DEBUG_LEVEL_NORMAL, __FILE__": Draining.\n");
1785
1786     pa_threaded_mainloop_lock(i->mainloop);
1787
1788     if (dsp_empty_socket(i) < 0)
1789         goto fail;
1790
1791     if (!i->play_stream)
1792         goto fail;
1793
1794     debug(DEBUG_LEVEL_NORMAL, __FILE__": Really draining.\n");
1795
1796     if (!(o = pa_stream_drain(i->play_stream, stream_success_cb, i))) {
1797         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_drain(): %s\n", pa_strerror(pa_context_errno(i->context)));
1798         goto fail;
1799     }
1800
1801     i->operation_success = 0;
1802     while (pa_operation_get_state(o) != PA_OPERATION_DONE) {
1803         PLAYBACK_STREAM_CHECK_DEAD_GOTO(i, fail);
1804
1805         pa_threaded_mainloop_wait(i->mainloop);
1806     }
1807
1808     if (!i->operation_success) {
1809         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_drain() 2: %s\n", pa_strerror(pa_context_errno(i->context)));
1810         goto fail;
1811     }
1812
1813     r = 0;
1814
1815 fail:
1816
1817     if (o)
1818         pa_operation_unref(o);
1819
1820     pa_threaded_mainloop_unlock(i->mainloop);
1821
1822     return 0;
1823 }
1824
1825 static int dsp_trigger(fd_info *i) {
1826     pa_operation *o = NULL;
1827     int r = -1;
1828
1829     if (!i->play_stream)
1830         return 0;
1831
1832     pa_threaded_mainloop_lock(i->mainloop);
1833
1834     if (dsp_empty_socket(i) < 0)
1835         goto fail;
1836
1837     debug(DEBUG_LEVEL_NORMAL, __FILE__": Triggering.\n");
1838
1839     if (!(o = pa_stream_trigger(i->play_stream, stream_success_cb, i))) {
1840         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_trigger(): %s\n", pa_strerror(pa_context_errno(i->context)));
1841         goto fail;
1842     }
1843
1844     i->operation_success = 0;
1845     while (!pa_operation_get_state(o) != PA_OPERATION_DONE) {
1846         PLAYBACK_STREAM_CHECK_DEAD_GOTO(i, fail);
1847
1848         pa_threaded_mainloop_wait(i->mainloop);
1849     }
1850
1851     if (!i->operation_success) {
1852         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_trigger(): %s\n", pa_strerror(pa_context_errno(i->context)));
1853         goto fail;
1854     }
1855
1856     r = 0;
1857
1858 fail:
1859
1860     if (o)
1861         pa_operation_unref(o);
1862
1863     pa_threaded_mainloop_unlock(i->mainloop);
1864
1865     return 0;
1866 }
1867
1868 static int dsp_cork(fd_info *i, pa_stream *s, int b) {
1869     pa_operation *o = NULL;
1870     int r = -1;
1871
1872     pa_threaded_mainloop_lock(i->mainloop);
1873
1874     if (!(o = pa_stream_cork(s, b, stream_success_cb, i))) {
1875         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_cork(): %s\n", pa_strerror(pa_context_errno(i->context)));
1876         goto fail;
1877     }
1878
1879     i->operation_success = 0;
1880     while (!pa_operation_get_state(o) != PA_OPERATION_DONE) {
1881         if (s == i->play_stream)
1882             PLAYBACK_STREAM_CHECK_DEAD_GOTO(i, fail);
1883         else if (s == i->rec_stream)
1884             RECORD_STREAM_CHECK_DEAD_GOTO(i, fail);
1885
1886         pa_threaded_mainloop_wait(i->mainloop);
1887     }
1888
1889     if (!i->operation_success) {
1890         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_cork(): %s\n", pa_strerror(pa_context_errno(i->context)));
1891         goto fail;
1892     }
1893
1894     r = 0;
1895
1896 fail:
1897
1898     if (o)
1899         pa_operation_unref(o);
1900
1901     pa_threaded_mainloop_unlock(i->mainloop);
1902
1903     return 0;
1904 }
1905
1906 static int dsp_ioctl(fd_info *i, unsigned long request, void*argp, int *_errno) {
1907     int ret = -1;
1908
1909     if (i->thread_fd == -1) {
1910         /*
1911          * We've encountered some fatal error and are just waiting
1912          * for a close.
1913          */
1914         debug(DEBUG_LEVEL_NORMAL, __FILE__": got ioctl 0x%08lx in fatal error state\n", request);
1915         *_errno = EIO;
1916         return -1;
1917     }
1918
1919     switch (request) {
1920         case SNDCTL_DSP_SETFMT: {
1921             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_SETFMT: %i\n", *(int*) argp);
1922
1923             pa_threaded_mainloop_lock(i->mainloop);
1924
1925             if (*(int*) argp == AFMT_QUERY)
1926                 *(int*) argp = map_format_back(i->sample_spec.format);
1927             else {
1928                 map_format((int*) argp, &i->sample_spec);
1929                 free_streams(i);
1930             }
1931
1932             pa_threaded_mainloop_unlock(i->mainloop);
1933             break;
1934         }
1935
1936         case SNDCTL_DSP_SPEED: {
1937             pa_sample_spec ss;
1938             int valid;
1939             char t[256];
1940
1941             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_SPEED: %i\n", *(int*) argp);
1942
1943             pa_threaded_mainloop_lock(i->mainloop);
1944
1945             ss = i->sample_spec;
1946             ss.rate = *(int*) argp;
1947
1948             if ((valid = pa_sample_spec_valid(&ss))) {
1949                 i->sample_spec = ss;
1950                 free_streams(i);
1951             }
1952
1953             debug(DEBUG_LEVEL_NORMAL, __FILE__": ss: %s\n", pa_sample_spec_snprint(t, sizeof(t), &i->sample_spec));
1954
1955             pa_threaded_mainloop_unlock(i->mainloop);
1956
1957             if (!valid) {
1958                 *_errno = EINVAL;
1959                 goto fail;
1960             }
1961
1962             break;
1963         }
1964
1965         case SNDCTL_DSP_STEREO:
1966             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_STEREO: %i\n", *(int*) argp);
1967
1968             pa_threaded_mainloop_lock(i->mainloop);
1969
1970             i->sample_spec.channels = *(int*) argp ? 2 : 1;
1971             free_streams(i);
1972
1973             pa_threaded_mainloop_unlock(i->mainloop);
1974             return 0;
1975
1976         case SNDCTL_DSP_CHANNELS: {
1977             pa_sample_spec ss;
1978             int valid;
1979
1980             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_CHANNELS: %i\n", *(int*) argp);
1981
1982             pa_threaded_mainloop_lock(i->mainloop);
1983
1984             ss = i->sample_spec;
1985             ss.channels = *(int*) argp;
1986
1987             if ((valid = pa_sample_spec_valid(&ss))) {
1988                 i->sample_spec = ss;
1989                 free_streams(i);
1990             }
1991
1992             pa_threaded_mainloop_unlock(i->mainloop);
1993
1994             if (!valid) {
1995                 *_errno = EINVAL;
1996                 goto fail;
1997             }
1998
1999             break;
2000         }
2001
2002         case SNDCTL_DSP_GETBLKSIZE:
2003             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_GETBLKSIZE\n");
2004
2005             pa_threaded_mainloop_lock(i->mainloop);
2006
2007             fix_metrics(i);
2008             *(int*) argp = i->fragment_size;
2009
2010             pa_threaded_mainloop_unlock(i->mainloop);
2011
2012             break;
2013
2014         case SNDCTL_DSP_SETFRAGMENT:
2015             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_SETFRAGMENT: 0x%08x\n", *(int*) argp);
2016
2017             pa_threaded_mainloop_lock(i->mainloop);
2018
2019             i->fragment_size = 1 << ((*(int*) argp) & 31);
2020             i->n_fragments = (*(int*) argp) >> 16;
2021
2022             /* 0x7FFF means that we can set whatever we like */
2023             if (i->n_fragments == 0x7FFF)
2024                 i->n_fragments = 12;
2025
2026             free_streams(i);
2027
2028             pa_threaded_mainloop_unlock(i->mainloop);
2029
2030             break;
2031
2032         case SNDCTL_DSP_GETCAPS:
2033             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_CAPS\n");
2034
2035             *(int*)  argp = DSP_CAP_DUPLEX | DSP_CAP_TRIGGER
2036 #ifdef DSP_CAP_MULTI
2037               | DSP_CAP_MULTI
2038 #endif
2039               ;
2040             break;
2041
2042         case SNDCTL_DSP_GETODELAY: {
2043             int l;
2044
2045             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_GETODELAY\n");
2046
2047             pa_threaded_mainloop_lock(i->mainloop);
2048
2049             *(int*) argp = 0;
2050
2051             for (;;) {
2052                 pa_usec_t usec;
2053
2054                 PLAYBACK_STREAM_CHECK_DEAD_GOTO(i, exit_loop);
2055
2056                 if (pa_stream_get_latency(i->play_stream, &usec, NULL) >= 0) {
2057                     *(int*) argp = pa_usec_to_bytes(usec, &i->sample_spec);
2058                     break;
2059                 }
2060
2061                 if (pa_context_errno(i->context) != PA_ERR_NODATA) {
2062                     debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_get_latency(): %s\n", pa_strerror(pa_context_errno(i->context)));
2063                     break;
2064                 }
2065
2066                 pa_threaded_mainloop_wait(i->mainloop);
2067             }
2068
2069         exit_loop:
2070
2071 #ifdef SIOCINQ
2072             if (ioctl(i->thread_fd, SIOCINQ, &l) < 0)
2073                 debug(DEBUG_LEVEL_NORMAL, __FILE__": SIOCINQ failed: %s\n", strerror(errno));
2074             else
2075                 *(int*) argp += l;
2076 #else
2077 # warning "Your platform does not support SIOCINQ, something might not work as intended."
2078 #endif
2079
2080             pa_threaded_mainloop_unlock(i->mainloop);
2081
2082             debug(DEBUG_LEVEL_NORMAL, __FILE__": ODELAY: %i\n", *(int*) argp);
2083
2084             break;
2085         }
2086
2087         case SNDCTL_DSP_RESET: {
2088             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_RESET\n");
2089
2090             pa_threaded_mainloop_lock(i->mainloop);
2091
2092             free_streams(i);
2093             dsp_flush_socket(i);
2094
2095             i->optr_n_blocks = 0;
2096
2097             pa_threaded_mainloop_unlock(i->mainloop);
2098             break;
2099         }
2100
2101         case SNDCTL_DSP_GETFMTS: {
2102             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_GETFMTS\n");
2103
2104             *(int*) argp = AFMT_MU_LAW|AFMT_A_LAW|AFMT_U8|AFMT_S16_LE|AFMT_S16_BE;
2105             break;
2106         }
2107
2108         case SNDCTL_DSP_POST:
2109             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_POST\n");
2110
2111             if (dsp_trigger(i) < 0)
2112                 *_errno = EIO;
2113             break;
2114
2115         case SNDCTL_DSP_GETTRIGGER:
2116             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_GETTRIGGER\n");
2117
2118             *(int*) argp = 0;
2119             if (!i->play_precork)
2120                 *(int*) argp |= PCM_ENABLE_OUTPUT;
2121             if (!i->rec_precork)
2122                 *(int*) argp |= PCM_ENABLE_INPUT;
2123
2124             break;
2125
2126         case SNDCTL_DSP_SETTRIGGER:
2127             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_SETTRIGGER: 0x%08x\n", *(int*) argp);
2128
2129             if (!i->io_event) {
2130                 *_errno = EIO;
2131                 break;
2132             }
2133
2134             i->play_precork = !((*(int*) argp) & PCM_ENABLE_OUTPUT);
2135
2136             if (i->play_stream) {
2137                 if (dsp_cork(i, i->play_stream, !((*(int*) argp) & PCM_ENABLE_OUTPUT)) < 0)
2138                     *_errno = EIO;
2139                 if (dsp_trigger(i) < 0)
2140                     *_errno = EIO;
2141             }
2142
2143             i->rec_precork = !((*(int*) argp) & PCM_ENABLE_INPUT);
2144
2145             if (i->rec_stream) {
2146                 if (dsp_cork(i, i->rec_stream, !((*(int*) argp) & PCM_ENABLE_INPUT)) < 0)
2147                     *_errno = EIO;
2148             }
2149
2150             break;
2151
2152         case SNDCTL_DSP_SYNC:
2153             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_SYNC\n");
2154
2155             if (dsp_drain(i) < 0)
2156                 *_errno = EIO;
2157
2158             break;
2159
2160         case SNDCTL_DSP_GETOSPACE:
2161         case SNDCTL_DSP_GETISPACE: {
2162             audio_buf_info *bi = (audio_buf_info*) argp;
2163             int l = 0;
2164             size_t k = 0;
2165
2166             if (request == SNDCTL_DSP_GETOSPACE)
2167                 debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_GETOSPACE\n");
2168             else
2169                 debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_GETISPACE\n");
2170
2171             pa_threaded_mainloop_lock(i->mainloop);
2172
2173             fix_metrics(i);
2174
2175             if (request == SNDCTL_DSP_GETOSPACE) {
2176                 if (i->play_stream) {
2177                     if ((k = pa_stream_writable_size(i->play_stream)) == (size_t) -1)
2178                         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_writable_size(): %s\n", pa_strerror(pa_context_errno(i->context)));
2179                 } else
2180                     k = i->fragment_size * i->n_fragments;
2181
2182 #ifdef SIOCINQ
2183                 if (ioctl(i->thread_fd, SIOCINQ, &l) < 0) {
2184                     debug(DEBUG_LEVEL_NORMAL, __FILE__": SIOCINQ failed: %s\n", strerror(errno));
2185                     l = 0;
2186                 }
2187 #else
2188 # warning "Your platform does not dsp_flush_fd, something might not work as intended."
2189 #endif
2190
2191                 bi->bytes = k > (size_t) l ? k - l : 0;
2192             } else {
2193                 if (i->rec_stream) {
2194                     if ((k = pa_stream_readable_size(i->rec_stream)) == (size_t) -1)
2195                         debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_readable_size(): %s\n", pa_strerror(pa_context_errno(i->context)));
2196                 } else
2197                     k = 0;
2198
2199 #ifdef SIOCINQ
2200                 if (ioctl(i->app_fd, SIOCINQ, &l) < 0) {
2201                     debug(DEBUG_LEVEL_NORMAL, __FILE__": SIOCINQ failed: %s\n", strerror(errno));
2202                     l = 0;
2203                 }
2204 #else
2205 # warning "Your platform does not dsp_flush_fd, something might not work as intended."
2206 #endif
2207                 bi->bytes = k + l;
2208             }
2209
2210             bi->fragsize = i->fragment_size;
2211             bi->fragstotal = i->n_fragments;
2212             bi->fragments = bi->bytes / bi->fragsize;
2213
2214             pa_threaded_mainloop_unlock(i->mainloop);
2215
2216             debug(DEBUG_LEVEL_NORMAL, __FILE__": fragsize=%i, fragstotal=%i, bytes=%i, fragments=%i\n", bi->fragsize, bi->fragstotal, bi->bytes, bi->fragments);
2217
2218             break;
2219         }
2220
2221         case SOUND_PCM_READ_RATE:
2222             debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_PCM_READ_RATE\n");
2223
2224             pa_threaded_mainloop_lock(i->mainloop);
2225             *(int*) argp = i->sample_spec.rate;
2226             pa_threaded_mainloop_unlock(i->mainloop);
2227             break;
2228
2229         case SOUND_PCM_READ_CHANNELS:
2230             debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_PCM_READ_CHANNELS\n");
2231
2232             pa_threaded_mainloop_lock(i->mainloop);
2233             *(int*) argp = i->sample_spec.channels;
2234             pa_threaded_mainloop_unlock(i->mainloop);
2235             break;
2236
2237         case SOUND_PCM_READ_BITS:
2238             debug(DEBUG_LEVEL_NORMAL, __FILE__": SOUND_PCM_READ_BITS\n");
2239
2240             pa_threaded_mainloop_lock(i->mainloop);
2241             *(int*) argp = pa_sample_size(&i->sample_spec)*8;
2242             pa_threaded_mainloop_unlock(i->mainloop);
2243             break;
2244
2245         case SNDCTL_DSP_GETOPTR: {
2246             count_info *info;
2247
2248             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_GETOPTR\n");
2249
2250             info = (count_info*) argp;
2251             memset(info, 0, sizeof(*info));
2252
2253             pa_threaded_mainloop_lock(i->mainloop);
2254
2255             for (;;) {
2256                 pa_usec_t usec;
2257
2258                 PLAYBACK_STREAM_CHECK_DEAD_GOTO(i, exit_loop2);
2259
2260                 if (pa_stream_get_time(i->play_stream, &usec) >= 0) {
2261                     size_t k = pa_usec_to_bytes(usec, &i->sample_spec);
2262                     int m;
2263
2264                     info->bytes = (int) k;
2265                     m = k / i->fragment_size;
2266                     info->blocks = m - i->optr_n_blocks;
2267                     i->optr_n_blocks = m;
2268
2269                     break;
2270                 }
2271
2272                 if (pa_context_errno(i->context) != PA_ERR_NODATA) {
2273                     debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_get_latency(): %s\n", pa_strerror(pa_context_errno(i->context)));
2274                     break;
2275                 }
2276
2277                 pa_threaded_mainloop_wait(i->mainloop);
2278             }
2279
2280         exit_loop2:
2281
2282             pa_threaded_mainloop_unlock(i->mainloop);
2283
2284             debug(DEBUG_LEVEL_NORMAL, __FILE__": GETOPTR bytes=%i, blocks=%i, ptr=%i\n", info->bytes, info->blocks, info->ptr);
2285
2286             break;
2287         }
2288
2289         case SNDCTL_DSP_GETIPTR:
2290             debug(DEBUG_LEVEL_NORMAL, __FILE__": invalid ioctl SNDCTL_DSP_GETIPTR\n");
2291             goto inval;
2292
2293         case SNDCTL_DSP_SETDUPLEX:
2294             debug(DEBUG_LEVEL_NORMAL, __FILE__": SNDCTL_DSP_SETDUPLEX\n");
2295             /* this is a no-op */
2296             break;
2297
2298         default:
2299             /* Mixer ioctls are valid on /dev/dsp aswell */
2300             return mixer_ioctl(i, request, argp, _errno);
2301
2302 inval:
2303             *_errno = EINVAL;
2304             goto fail;
2305     }
2306
2307     ret = 0;
2308
2309 fail:
2310
2311     return ret;
2312 }
2313
2314 #ifdef sun
2315 int ioctl(int fd, int request, ...) {
2316 #else
2317 int ioctl(int fd, unsigned long request, ...) {
2318 #endif
2319     fd_info *i;
2320     va_list args;
2321     void *argp;
2322     int r, _errno = 0;
2323
2324     debug(DEBUG_LEVEL_VERBOSE, __FILE__": ioctl()\n");
2325
2326     va_start(args, request);
2327     argp = va_arg(args, void *);
2328     va_end(args);
2329
2330     if (!function_enter()) {
2331         LOAD_IOCTL_FUNC();
2332         return _ioctl(fd, request, argp);
2333     }
2334
2335     if (!(i = fd_info_find(fd))) {
2336         function_exit();
2337         LOAD_IOCTL_FUNC();
2338         return _ioctl(fd, request, argp);
2339     }
2340
2341     if (i->type == FD_INFO_MIXER)
2342         r = mixer_ioctl(i, request, argp, &_errno);
2343     else
2344         r = dsp_ioctl(i, request, argp, &_errno);
2345
2346     fd_info_unref(i);
2347
2348     if (_errno)
2349         errno = _errno;
2350
2351     function_exit();
2352
2353     return r;
2354 }
2355
2356 int close(int fd) {
2357     fd_info *i;
2358
2359     debug(DEBUG_LEVEL_VERBOSE, __FILE__": close()\n");
2360
2361     if (!function_enter()) {
2362         LOAD_CLOSE_FUNC();
2363         return _close(fd);
2364     }
2365
2366     if (!(i = fd_info_find(fd))) {
2367         function_exit();
2368         LOAD_CLOSE_FUNC();
2369         return _close(fd);
2370     }
2371
2372     fd_info_remove_from_list(i);
2373     fd_info_unref(i);
2374
2375     function_exit();
2376
2377     return 0;
2378 }
2379
2380 int access(const char *pathname, int mode) {
2381
2382     debug(DEBUG_LEVEL_VERBOSE, __FILE__": access(%s)\n", pathname?pathname:"NULL");
2383
2384     if (!pathname ||
2385         (strcmp(pathname, "/dev/dsp") != 0 &&
2386          strcmp(pathname, "/dev/adsp") != 0 &&
2387          strcmp(pathname, "/dev/sndstat") != 0 &&
2388          strcmp(pathname, "/dev/mixer") != 0 )) {
2389         LOAD_ACCESS_FUNC();
2390         return _access(pathname, mode);
2391     }
2392
2393     if (mode & X_OK) {
2394         debug(DEBUG_LEVEL_NORMAL, __FILE__": access(%s, %x) = EACCESS\n", pathname, mode);
2395         errno = EACCES;
2396         return -1;
2397     }
2398
2399     debug(DEBUG_LEVEL_NORMAL, __FILE__": access(%s, %x) = OK\n", pathname, mode);
2400
2401     return 0;
2402 }
2403
2404 int stat(const char *pathname, struct stat *buf) {
2405 #ifdef HAVE_OPEN64
2406     struct stat64 parent;
2407 #else
2408     struct stat parent;
2409 #endif
2410     int ret;
2411
2412     if (!pathname ||
2413         !buf ||
2414         ( strcmp(pathname, "/dev/dsp") != 0 &&
2415           strcmp(pathname, "/dev/adsp") != 0 &&
2416           strcmp(pathname, "/dev/sndstat") != 0 &&
2417           strcmp(pathname, "/dev/mixer") != 0 )) {
2418         debug(DEBUG_LEVEL_VERBOSE, __FILE__": stat(%s)\n", pathname?pathname:"NULL");
2419         LOAD_STAT_FUNC();
2420         return _stat(pathname, buf);
2421     }
2422
2423     debug(DEBUG_LEVEL_NORMAL, __FILE__": stat(%s)\n", pathname);
2424
2425 #ifdef _STAT_VER
2426 #ifdef HAVE_OPEN64
2427     ret = __xstat64(_STAT_VER, "/dev", &parent);
2428 #else
2429     ret = __xstat(_STAT_VER, "/dev", &parent);
2430 #endif
2431 #else
2432 #ifdef HAVE_OPEN64
2433     ret = stat64("/dev", &parent);
2434 #else
2435     ret = stat("/dev", &parent);
2436 #endif
2437 #endif
2438
2439     if (ret) {
2440         debug(DEBUG_LEVEL_NORMAL, __FILE__": unable to stat \"/dev\"\n");
2441         return -1;
2442     }
2443
2444     buf->st_dev = parent.st_dev;
2445     buf->st_ino = 0xDEADBEEF;   /* FIXME: Can we do this in a safe way? */
2446     buf->st_mode = S_IFCHR | S_IRUSR | S_IWUSR;
2447     buf->st_nlink = 1;
2448     buf->st_uid = getuid();
2449     buf->st_gid = getgid();
2450     buf->st_rdev = 0x0E03;      /* FIXME: Linux specific */
2451     buf->st_size = 0;
2452     buf->st_atime = 1181557705;
2453     buf->st_mtime = 1181557705;
2454     buf->st_ctime = 1181557705;
2455     buf->st_blksize = 1;
2456     buf->st_blocks = 0;
2457
2458     return 0;
2459 }
2460
2461 #ifdef HAVE_OPEN64
2462
2463 int stat64(const char *pathname, struct stat64 *buf) {
2464     struct stat oldbuf;
2465     int ret;
2466
2467     debug(DEBUG_LEVEL_VERBOSE, __FILE__": stat64(%s)\n", pathname?pathname:"NULL");
2468
2469     if (!pathname ||
2470         !buf ||
2471         ( strcmp(pathname, "/dev/dsp") != 0 &&
2472           strcmp(pathname, "/dev/adsp") != 0 &&
2473           strcmp(pathname, "/dev/sndstat") != 0 &&
2474           strcmp(pathname, "/dev/mixer") != 0 )) {
2475         LOAD_STAT64_FUNC();
2476         return _stat64(pathname, buf);
2477     }
2478
2479     ret = stat(pathname, &oldbuf);
2480     if (ret)
2481         return ret;
2482
2483     buf->st_dev = oldbuf.st_dev;
2484     buf->st_ino = oldbuf.st_ino;
2485     buf->st_mode = oldbuf.st_mode;
2486     buf->st_nlink = oldbuf.st_nlink;
2487     buf->st_uid = oldbuf.st_uid;
2488     buf->st_gid = oldbuf.st_gid;
2489     buf->st_rdev = oldbuf.st_rdev;
2490     buf->st_size = oldbuf.st_size;
2491     buf->st_atime = oldbuf.st_atime;
2492     buf->st_mtime = oldbuf.st_mtime;
2493     buf->st_ctime = oldbuf.st_ctime;
2494     buf->st_blksize = oldbuf.st_blksize;
2495     buf->st_blocks = oldbuf.st_blocks;
2496
2497     return 0;
2498 }
2499
2500 int open64(const char *filename, int flags, ...) {
2501     va_list args;
2502     mode_t mode = 0;
2503
2504     debug(DEBUG_LEVEL_VERBOSE, __FILE__": open64(%s)\n", filename?filename:"NULL");
2505
2506     if (flags & O_CREAT) {
2507         va_start(args, flags);
2508         if (sizeof(mode_t) < sizeof(int))
2509             mode = va_arg(args, int);
2510         else
2511             mode = va_arg(args, mode_t);
2512         va_end(args);
2513     }
2514
2515     if (!filename ||
2516         ( strcmp(filename, "/dev/dsp") != 0 &&
2517           strcmp(filename, "/dev/adsp") != 0 &&
2518           strcmp(filename, "/dev/sndstat") != 0 &&
2519           strcmp(filename, "/dev/mixer") != 0 )) {
2520         LOAD_OPEN64_FUNC();
2521         return _open64(filename, flags, mode);
2522     }
2523
2524     return real_open(filename, flags, mode);
2525 }
2526
2527 #endif
2528
2529 #ifdef _STAT_VER
2530
2531 int __xstat(int ver, const char *pathname, struct stat *buf) {
2532     debug(DEBUG_LEVEL_VERBOSE, __FILE__": __xstat(%s)\n", pathname?pathname:"NULL");
2533
2534     if (!pathname ||
2535         !buf ||
2536         ( strcmp(pathname, "/dev/dsp") != 0 &&
2537           strcmp(pathname, "/dev/adsp") != 0 &&
2538           strcmp(pathname, "/dev/sndstat") != 0 &&
2539           strcmp(pathname, "/dev/mixer") != 0 )) {
2540         LOAD_XSTAT_FUNC();
2541         return ___xstat(ver, pathname, buf);
2542     }
2543
2544     if (ver != _STAT_VER) {
2545         errno = EINVAL;
2546         return -1;
2547     }
2548
2549     return stat(pathname, buf);
2550 }
2551
2552 #ifdef HAVE_OPEN64
2553
2554 int __xstat64(int ver, const char *pathname, struct stat64 *buf) {
2555     debug(DEBUG_LEVEL_VERBOSE, __FILE__": __xstat64(%s)\n", pathname?pathname:"NULL");
2556
2557     if (!pathname ||
2558         !buf ||
2559         ( strcmp(pathname, "/dev/dsp") != 0 &&
2560           strcmp(pathname, "/dev/adsp") != 0 &&
2561           strcmp(pathname, "/dev/sndstat") != 0 &&
2562           strcmp(pathname, "/dev/mixer") != 0 )) {
2563         LOAD_XSTAT64_FUNC();
2564         return ___xstat64(ver, pathname, buf);
2565     }
2566
2567     if (ver != _STAT_VER) {
2568         errno = EINVAL;
2569         return -1;
2570     }
2571
2572     return stat64(pathname, buf);
2573 }
2574
2575 #endif
2576
2577 #endif
2578
2579 FILE* fopen(const char *filename, const char *mode) {
2580     FILE *f = NULL;
2581     int fd;
2582     mode_t m;
2583
2584     debug(DEBUG_LEVEL_VERBOSE, __FILE__": fopen(%s)\n", filename?filename:"NULL");
2585
2586     if (!filename ||
2587         !mode ||
2588         ( strcmp(filename, "/dev/dsp") != 0 &&
2589           strcmp(filename, "/dev/adsp") != 0 &&
2590           strcmp(filename, "/dev/sndstat") != 0 &&
2591           strcmp(filename, "/dev/mixer") != 0 )) {
2592         LOAD_FOPEN_FUNC();
2593         return _fopen(filename, mode);
2594     }
2595
2596     switch (mode[0]) {
2597     case 'r':
2598         m = O_RDONLY;
2599         break;
2600     case 'w':
2601     case 'a':
2602         m = O_WRONLY;
2603         break;
2604     default:
2605         errno = EINVAL;
2606         return NULL;
2607     }
2608
2609     if ((((mode[1] == 'b') || (mode[1] == 't')) && (mode[2] == '+')) || (mode[1] == '+'))
2610         m = O_RDWR;
2611
2612     if ((fd = real_open(filename, m, 0)) < 0)
2613         return NULL;
2614
2615     if (!(f = fdopen(fd, mode))) {
2616         close(fd);
2617         return NULL;
2618     }
2619
2620     return f;
2621 }
2622
2623 #ifdef HAVE_OPEN64
2624
2625 FILE *fopen64(const char *filename, const char *mode) {
2626
2627     debug(DEBUG_LEVEL_VERBOSE, __FILE__": fopen64(%s)\n", filename?filename:"NULL");
2628
2629     if (!filename ||
2630         !mode ||
2631         ( strcmp(filename, "/dev/dsp") != 0 &&
2632           strcmp(filename, "/dev/adsp") != 0 &&
2633           strcmp(filename, "/dev/sndstat") != 0 &&
2634           strcmp(filename, "/dev/mixer") != 0 )) {
2635         LOAD_FOPEN64_FUNC();
2636         return _fopen64(filename, mode);
2637     }
2638
2639     return fopen(filename, mode);
2640 }
2641
2642 #endif
2643
2644 int fclose(FILE *f) {
2645     fd_info *i;
2646
2647     debug(DEBUG_LEVEL_VERBOSE, __FILE__": fclose()\n");
2648
2649     if (!function_enter()) {
2650         LOAD_FCLOSE_FUNC();
2651         return _fclose(f);
2652     }
2653
2654     if (!(i = fd_info_find(fileno(f)))) {
2655         function_exit();
2656         LOAD_FCLOSE_FUNC();
2657         return _fclose(f);
2658     }
2659
2660     fd_info_remove_from_list(i);
2661
2662     /* Dirty trick to avoid that the fd is not freed twice, once by us
2663      * and once by the real fclose() */
2664     i->app_fd = -1;
2665
2666     fd_info_unref(i);
2667
2668     function_exit();
2669
2670     LOAD_FCLOSE_FUNC();
2671     return _fclose(f);
2672 }