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