code.delx.au - pulseaudio/blob - src/modules/module-device-manager.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2006-2008 Lennart Poettering
   5   Copyright 2009 Colin Guthrie
   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 #include <unistd.h>
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <sys/types.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <ctype.h>
  34
  35 #include <pulse/xmalloc.h>
  36 #include <pulse/volume.h>
  37 #include <pulse/timeval.h>
  38 #include <pulse/util.h>
  39 #include <pulse/rtclock.h>
  40
  41 #include <pulsecore/core-error.h>
  42 #include <pulsecore/module.h>
  43 #include <pulsecore/core-util.h>
  44 #include <pulsecore/modargs.h>
  45 #include <pulsecore/log.h>
  46 #include <pulsecore/core-subscribe.h>
  47 #include <pulsecore/sink-input.h>
  48 #include <pulsecore/source-output.h>
  49 #include <pulsecore/namereg.h>
  50 #include <pulsecore/protocol-native.h>
  51 #include <pulsecore/pstream.h>
  52 #include <pulsecore/pstream-util.h>
  53 #include <pulsecore/database.h>
  54
  55 #include "module-device-manager-symdef.h"
  56
  57 PA_MODULE_AUTHOR("Colin Guthrie");
  58 PA_MODULE_DESCRIPTION("Keep track of devices (and their descriptions) both past and present");
  59 PA_MODULE_VERSION(PACKAGE_VERSION);
  60 PA_MODULE_LOAD_ONCE(TRUE);
  61 PA_MODULE_USAGE(
  62     "do_routing=<Automatically route streams based on a priority list (unique per-role)?> "
  63     "on_hotplug=<When new device becomes available, recheck streams?> "
  64     "on_rescue=<When device becomes unavailable, recheck streams?>");
  65
  66 #define SAVE_INTERVAL (10 * PA_USEC_PER_SEC)
  67
  68 static const char* const valid_modargs[] = {
  69     "do_routing",
  70     "on_hotplug",
  71     "on_rescue",
  72     NULL
  73 };
  74
  75 #define NUM_ROLES 9
  76 enum {
  77     ROLE_NONE,
  78     ROLE_VIDEO,
  79     ROLE_MUSIC,
  80     ROLE_GAME,
  81     ROLE_EVENT,
  82     ROLE_PHONE,
  83     ROLE_ANIMATION,
  84     ROLE_PRODUCTION,
  85     ROLE_A11Y,
  86 };
  87
  88 typedef uint32_t role_indexes_t[NUM_ROLES];
  89
  90 struct userdata {
  91     pa_core *core;
  92     pa_module *module;
  93     pa_subscription *subscription;
  94     pa_hook_slot
  95         *sink_new_hook_slot,
  96         *source_new_hook_slot,
  97         *sink_input_new_hook_slot,
  98         *source_output_new_hook_slot,
  99         *sink_put_hook_slot,
 100         *source_put_hook_slot,
 101         *sink_unlink_hook_slot,
 102         *source_unlink_hook_slot,
 103         *connection_unlink_hook_slot;
 104     pa_time_event *save_time_event;
 105     pa_database *database;
 106
 107     pa_native_protocol *protocol;
 108     pa_idxset *subscribed;
 109
 110     pa_bool_t on_hotplug;
 111     pa_bool_t on_rescue;
 112     pa_bool_t do_routing;
 113
 114     role_indexes_t preferred_sinks;
 115     role_indexes_t preferred_sources;
 116 };
 117
 118 #define ENTRY_VERSION 1
 119
 120 struct entry {
 121     uint8_t version;
 122     char description[PA_NAME_MAX];
 123     role_indexes_t priority;
 124 } PA_GCC_PACKED;
 125
 126 enum {
 127     SUBCOMMAND_TEST,
 128     SUBCOMMAND_READ,
 129     SUBCOMMAND_RENAME,
 130     SUBCOMMAND_DELETE,
 131     SUBCOMMAND_ROLE_DEVICE_PRIORITY_ROUTING,
 132     SUBCOMMAND_PREFER_DEVICE,
 133     SUBCOMMAND_DEFER_DEVICE,
 134     SUBCOMMAND_SUBSCRIBE,
 135     SUBCOMMAND_EVENT
 136 };
 137
 138 static void save_time_callback(pa_mainloop_api*a, pa_time_event* e, const struct timeval *t, void *userdata) {
 139     struct userdata *u = userdata;
 140
 141     pa_assert(a);
 142     pa_assert(e);
 143     pa_assert(u);
 144
 145     pa_assert(e == u->save_time_event);
 146     u->core->mainloop->time_free(u->save_time_event);
 147     u->save_time_event = NULL;
 148
 149     pa_database_sync(u->database);
 150     pa_log_info("Synced.");
 151 }
 152
 153 static struct entry* read_entry(struct userdata *u, const char *name) {
 154     pa_datum key, data;
 155     struct entry *e;
 156
 157     pa_assert(u);
 158     pa_assert(name);
 159
 160     key.data = (char*) name;
 161     key.size = strlen(name);
 162
 163     pa_zero(data);
 164
 165     if (!pa_database_get(u->database, &key, &data))
 166         goto fail;
 167
 168     if (data.size != sizeof(struct entry)) {
 169         pa_log_debug("Database contains entry for device %s of wrong size %lu != %lu. Probably due to upgrade, ignoring.", name, (unsigned long) data.size, (unsigned long) sizeof(struct entry));
 170         goto fail;
 171     }
 172
 173     e = (struct entry*) data.data;
 174
 175     if (e->version != ENTRY_VERSION) {
 176         pa_log_debug("Version of database entry for device %s doesn't match our version. Probably due to upgrade, ignoring.", name);
 177         goto fail;
 178     }
 179
 180     if (!memchr(e->description, 0, sizeof(e->description))) {
 181         pa_log_warn("Database contains entry for device %s with missing NUL byte in description", name);
 182         goto fail;
 183     }
 184
 185     return e;
 186
 187 fail:
 188
 189     pa_datum_free(&data);
 190     return NULL;
 191 }
 192
 193 static void trigger_save(struct userdata *u) {
 194     pa_native_connection *c;
 195     uint32_t idx;
 196
 197     for (c = pa_idxset_first(u->subscribed, &idx); c; c = pa_idxset_next(u->subscribed, &idx)) {
 198         pa_tagstruct *t;
 199
 200         t = pa_tagstruct_new(NULL, 0);
 201         pa_tagstruct_putu32(t, PA_COMMAND_EXTENSION);
 202         pa_tagstruct_putu32(t, 0);
 203         pa_tagstruct_putu32(t, u->module->index);
 204         pa_tagstruct_puts(t, u->module->name);
 205         pa_tagstruct_putu32(t, SUBCOMMAND_EVENT);
 206
 207         pa_pstream_send_tagstruct(pa_native_connection_get_pstream(c), t);
 208     }
 209
 210     if (u->save_time_event)
 211         return;
 212
 213     u->save_time_event = pa_core_rttime_new(u->core, pa_rtclock_now() + SAVE_INTERVAL, save_time_callback, u);
 214 }
 215
 216 static pa_bool_t entries_equal(const struct entry *a, const struct entry *b) {
 217     /** @todo: Compare the priority lists too */
 218     if (strncmp(a->description, b->description, sizeof(a->description)))
 219         return FALSE;
 220
 221     return TRUE;
 222 }
 223
 224 static inline struct entry *load_or_initialize_entry(struct userdata *u, struct entry *entry, const char *name, const char *prefix) {
 225     struct entry *old;
 226
 227     pa_assert(u);
 228     pa_assert(entry);
 229     pa_assert(name);
 230     pa_assert(prefix);
 231
 232     if ((old = read_entry(u, name)))
 233         *entry = *old;
 234     else {
 235         /* This is a new device, so make sure we write it's priority list correctly */
 236         role_indexes_t max_priority;
 237         pa_datum key;
 238         pa_bool_t done;
 239
 240         pa_zero(max_priority);
 241         done = !pa_database_first(u->database, &key, NULL);
 242
 243         /* Find all existing devices with the same prefix so we calculate the current max priority for each role */
 244         while (!done) {
 245             pa_datum next_key;
 246
 247             done = !pa_database_next(u->database, &key, &next_key, NULL);
 248
 249             if (key.size > strlen(prefix) && strncmp(key.data, prefix, strlen(prefix)) == 0) {
 250                 char *name2;
 251                 struct entry *e;
 252
 253                 name2 = pa_xstrndup(key.data, key.size);
 254
 255                 if ((e = read_entry(u, name2))) {
 256                     for (uint32_t i = 0; i < NUM_ROLES; ++i) {
 257                         max_priority[i] = PA_MAX(max_priority[i], e->priority[i]);
 258                     }
 259
 260                     pa_xfree(e);
 261                 }
 262
 263                 pa_xfree(name2);
 264             }
 265             pa_datum_free(&key);
 266             key = next_key;
 267         }
 268
 269         /* Actually initialise our entry now we've calculated it */
 270         for (uint32_t i = 0; i < NUM_ROLES; ++i) {
 271             entry->priority[i] = max_priority[i] + 1;
 272         }
 273     }
 274
 275     return old;
 276 }
 277
 278 static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
 279     struct userdata *u = userdata;
 280     struct entry entry, *old = NULL;
 281     char *name = NULL;
 282     pa_datum key, data;
 283
 284     pa_assert(c);
 285     pa_assert(u);
 286
 287     if (t != (PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW) &&
 288         t != (PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE) &&
 289         t != (PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_NEW) &&
 290         t != (PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE))
 291         return;
 292
 293     pa_zero(entry);
 294     entry.version = ENTRY_VERSION;
 295
 296     if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK) {
 297         pa_sink *sink;
 298
 299         if (!(sink = pa_idxset_get_by_index(c->sinks, idx)))
 300             return;
 301
 302         name = pa_sprintf_malloc("sink:%s", sink->name);
 303
 304         old = load_or_initialize_entry(u, &entry, name, "sink:");
 305
 306         pa_strlcpy(entry.description, pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION)), sizeof(entry.description));
 307
 308     } else {
 309         pa_source *source;
 310
 311         pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE);
 312
 313         if (!(source = pa_idxset_get_by_index(c->sources, idx)))
 314             return;
 315
 316         if (source->monitor_of)
 317             return;
 318
 319         name = pa_sprintf_malloc("source:%s", source->name);
 320
 321         old = load_or_initialize_entry(u, &entry, name, "source:");
 322
 323         pa_strlcpy(entry.description, pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION)), sizeof(entry.description));
 324     }
 325
 326     if (old) {
 327
 328         if (entries_equal(old, &entry)) {
 329             pa_xfree(old);
 330             pa_xfree(name);
 331             return;
 332         }
 333
 334         pa_xfree(old);
 335     }
 336
 337     key.data = name;
 338     key.size = strlen(name);
 339
 340     data.data = &entry;
 341     data.size = sizeof(entry);
 342
 343     pa_log_info("Storing device %s.", name);
 344
 345     pa_database_set(u->database, &key, &data, TRUE);
 346
 347     pa_xfree(name);
 348
 349     trigger_save(u);
 350 }
 351
 352 static pa_hook_result_t sink_new_hook_callback(pa_core *c, pa_sink_new_data *new_data, struct userdata *u) {
 353     char *name;
 354     struct entry *e;
 355
 356     pa_assert(c);
 357     pa_assert(new_data);
 358     pa_assert(u);
 359
 360     name = pa_sprintf_malloc("sink:%s", new_data->name);
 361
 362     if ((e = read_entry(u, name))) {
 363         if (strncmp(e->description, pa_proplist_gets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION), sizeof(e->description)) != 0) {
 364             pa_log_info("Restoring description for sink %s.", new_data->name);
 365             pa_proplist_sets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION, e->description);
 366         }
 367
 368         pa_xfree(e);
 369     }
 370
 371     pa_xfree(name);
 372
 373     return PA_HOOK_OK;
 374 }
 375
 376 static pa_hook_result_t source_new_hook_callback(pa_core *c, pa_source_new_data *new_data, struct userdata *u) {
 377     char *name;
 378     struct entry *e;
 379
 380     pa_assert(c);
 381     pa_assert(new_data);
 382     pa_assert(u);
 383
 384     name = pa_sprintf_malloc("source:%s", new_data->name);
 385
 386     if ((e = read_entry(u, name))) {
 387         if (strncmp(e->description, pa_proplist_gets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION), sizeof(e->description)) != 0) {
 388             /* NB, We cannot detect if we are a monitor here... this could mess things up a bit... */
 389             pa_log_info("Restoring description for source %s.", new_data->name);
 390             pa_proplist_sets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION, e->description);
 391         }
 392
 393         pa_xfree(e);
 394     }
 395
 396     pa_xfree(name);
 397
 398     return PA_HOOK_OK;
 399 }
 400
 401 static char *get_name(const char *key, const char *prefix) {
 402     char *t;
 403
 404     if (strncmp(key, prefix, strlen(prefix)))
 405         return NULL;
 406
 407     t = pa_xstrdup(key + strlen(prefix));
 408     return t;
 409 }
 410
 411 static uint32_t get_role_index(const char* role) {
 412     pa_assert(role);
 413
 414     if (strcmp(role, "") == 0)
 415         return ROLE_NONE;
 416     if (strcmp(role, "video") == 0)
 417         return ROLE_VIDEO;
 418     if (strcmp(role, "music") == 0)
 419         return ROLE_MUSIC;
 420     if (strcmp(role, "game") == 0)
 421         return ROLE_GAME;
 422     if (strcmp(role, "event") == 0)
 423         return ROLE_EVENT;
 424     if (strcmp(role, "phone") == 0)
 425         return ROLE_PHONE;
 426     if (strcmp(role, "animation") == 0)
 427         return ROLE_ANIMATION;
 428     if (strcmp(role, "production") == 0)
 429         return ROLE_PRODUCTION;
 430     if (strcmp(role, "a11y") == 0)
 431         return ROLE_A11Y;
 432     return PA_INVALID_INDEX;
 433 }
 434
 435 static void update_highest_priority_device_indexes(struct userdata *u, const char *prefix, void *ignore_device) {
 436     role_indexes_t *indexes, highest_priority_available;
 437     pa_datum key;
 438     pa_bool_t done, sink_mode;
 439
 440     pa_assert(u);
 441     pa_assert(prefix);
 442
 443     sink_mode = (strcmp(prefix, "sink:") == 0);
 444
 445     if (sink_mode)
 446         indexes = &u->preferred_sinks;
 447     else
 448         indexes = &u->preferred_sources;
 449
 450     for (uint32_t i = 0; i < NUM_ROLES; ++i) {
 451         *indexes[i] = PA_INVALID_INDEX;
 452     }
 453     pa_zero(highest_priority_available);
 454
 455     done = !pa_database_first(u->database, &key, NULL);
 456
 457     /* Find all existing devices with the same prefix so we find the highest priority device for each role */
 458     while (!done) {
 459         pa_datum next_key;
 460
 461         done = !pa_database_next(u->database, &key, &next_key, NULL);
 462
 463         if (key.size > strlen(prefix) && strncmp(key.data, prefix, strlen(prefix)) == 0) {
 464             char *name;
 465             struct entry *e;
 466
 467             name = pa_xstrndup(key.data, key.size);
 468
 469             if ((e = read_entry(u, name))) {
 470                 for (uint32_t i = 0; i < NUM_ROLES; ++i) {
 471                     if (highest_priority_available[i] && e->priority[i] < highest_priority_available[i]) {
 472                         /* We've found a device with a higher priority than that we've currently got,
 473                            so see if it is currently available or not and update our list */
 474                         uint32_t idx;
 475                         pa_bool_t found = FALSE;
 476                         char *device_name = get_name(name, prefix);
 477
 478                         if (sink_mode) {
 479                             pa_sink *sink;
 480
 481                             PA_IDXSET_FOREACH(sink, u->core->sinks, idx) {
 482                                 if ((pa_sink*) ignore_device == sink)
 483                                     continue;
 484                                 if (strcmp(sink->name, device_name) == 0) {
 485                                     found = TRUE;
 486                                     idx = sink->index; /* Is this needed? */
 487                                     break;
 488                                 }
 489                             }
 490                         } else {
 491                             pa_source *source;
 492
 493                             PA_IDXSET_FOREACH(source, u->core->sources, idx) {
 494                                 if ((pa_source*) ignore_device == source)
 495                                     continue;
 496                                 if (strcmp(source->name, device_name) == 0) {
 497                                     found = TRUE;
 498                                     idx = source->index; /* Is this needed? */
 499                                     break;
 500                                 }
 501                             }
 502                         }
 503                         if (found) {
 504                             highest_priority_available[i] = e->priority[i];
 505                             *indexes[i] = idx;
 506                         }
 507
 508                         pa_xfree(device_name);
 509                     }
 510                 }
 511
 512                 pa_xfree(e);
 513             }
 514
 515             pa_xfree(name);
 516         }
 517
 518         pa_datum_free(&key);
 519         key = next_key;
 520     }
 521 }
 522
 523
 524 static pa_hook_result_t sink_input_new_hook_callback(pa_core *c, pa_sink_input_new_data *new_data, struct userdata *u) {
 525     pa_assert(c);
 526     pa_assert(new_data);
 527     pa_assert(u);
 528
 529     if (!u->do_routing)
 530         return PA_HOOK_OK;
 531
 532     if (new_data->sink)
 533         pa_log_debug("Not restoring device for stream, because already set.");
 534     else {
 535         const char *role;
 536         uint32_t role_index;
 537
 538         if (!(role = pa_proplist_gets(new_data->proplist, PA_PROP_MEDIA_ROLE)))
 539             role_index = get_role_index("");
 540         else
 541             role_index = get_role_index(role);
 542
 543         if (PA_INVALID_INDEX != role_index) {
 544             uint32_t device_index;
 545
 546             device_index = u->preferred_sinks[role_index];
 547             if (PA_INVALID_INDEX != device_index) {
 548                 pa_sink *sink;
 549
 550                 if ((sink = pa_idxset_get_by_index(u->core->sinks, device_index))) {
 551                     new_data->sink = sink;
 552                     new_data->save_sink = TRUE;
 553                 }
 554             }
 555         }
 556     }
 557
 558     return PA_HOOK_OK;
 559 }
 560
 561 static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_output_new_data *new_data, struct userdata *u) {
 562     pa_assert(c);
 563     pa_assert(new_data);
 564     pa_assert(u);
 565
 566     if (!u->do_routing)
 567         return PA_HOOK_OK;
 568
 569     if (new_data->direct_on_input)
 570         return PA_HOOK_OK;
 571
 572     if (new_data->source)
 573         pa_log_debug("Not restoring device for stream, because already set");
 574     else {
 575         const char *role;
 576         uint32_t role_index;
 577
 578         if (!(role = pa_proplist_gets(new_data->proplist, PA_PROP_MEDIA_ROLE)))
 579             role_index = get_role_index("");
 580         else
 581             role_index = get_role_index(role);
 582
 583         if (PA_INVALID_INDEX != role_index) {
 584             uint32_t device_index;
 585
 586             device_index = u->preferred_sources[role_index];
 587             if (PA_INVALID_INDEX != device_index) {
 588                 pa_source *source;
 589
 590                 if ((source = pa_idxset_get_by_index(u->core->sources, device_index))) {
 591                     new_data->source = source;
 592                     new_data->save_source = TRUE;
 593                 }
 594             }
 595         }
 596     }
 597
 598     return PA_HOOK_OK;
 599 }
 600
 601 static pa_hook_result_t reroute_sinks(struct userdata *u, pa_sink *ignore_sink) {
 602     pa_sink_input *si;
 603     uint32_t idx;
 604
 605     pa_assert(u);
 606
 607     if (!u->do_routing)
 608         return PA_HOOK_OK;
 609
 610     update_highest_priority_device_indexes(u, "sink:", ignore_sink);
 611
 612     PA_IDXSET_FOREACH(si, u->core->sink_inputs, idx) {
 613         const char *role;
 614         uint32_t role_index, device_index;
 615         pa_sink *sink;
 616
 617         if (si->save_sink)
 618             continue;
 619
 620         /* Skip this if it is already in the process of being moved anyway */
 621         if (!si->sink)
 622             continue;
 623
 624         /* It might happen that a stream and a sink are set up at the
 625         same time, in which case we want to make sure we don't
 626         interfere with that */
 627         if (!PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(si)))
 628             continue;
 629
 630         if (!(role = pa_proplist_gets(si->proplist, PA_PROP_MEDIA_ROLE)))
 631             role_index = get_role_index("");
 632         else
 633             role_index = get_role_index(role);
 634
 635         if (PA_INVALID_INDEX == role_index)
 636             continue;
 637
 638         device_index = u->preferred_sinks[role_index];
 639         if (PA_INVALID_INDEX == device_index)
 640             continue;
 641
 642         if (!(sink = pa_idxset_get_by_index(u->core->sinks, device_index)))
 643             continue;
 644
 645         if (si->sink != sink)
 646             pa_sink_input_move_to(si, sink, TRUE);
 647     }
 648
 649     return PA_HOOK_OK;
 650 }
 651
 652 static pa_hook_result_t reroute_sources(struct userdata *u, pa_source* ignore_source) {
 653     pa_source_output *so;
 654     uint32_t idx;
 655
 656     pa_assert(u);
 657
 658     if (!u->do_routing)
 659         return PA_HOOK_OK;
 660
 661     update_highest_priority_device_indexes(u, "source:", ignore_source);
 662
 663     PA_IDXSET_FOREACH(so, u->core->source_outputs, idx) {
 664         const char *role;
 665         uint32_t role_index, device_index;
 666         pa_source *source;
 667
 668         if (so->save_source)
 669             continue;
 670
 671         if (so->direct_on_input)
 672             continue;
 673
 674         /* Skip this if it is already in the process of being moved anyway */
 675         if (!so->source)
 676             continue;
 677
 678         /* It might happen that a stream and a source are set up at the
 679         same time, in which case we want to make sure we don't
 680         interfere with that */
 681         if (!PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(so)))
 682             continue;
 683
 684         if (!(role = pa_proplist_gets(so->proplist, PA_PROP_MEDIA_ROLE)))
 685             role_index = get_role_index("");
 686         else
 687             role_index = get_role_index(role);
 688
 689         if (PA_INVALID_INDEX == role_index)
 690             continue;
 691
 692         device_index = u->preferred_sources[role_index];
 693         if (PA_INVALID_INDEX == device_index)
 694             continue;
 695
 696         if (!(source = pa_idxset_get_by_index(u->core->sources, device_index)))
 697             continue;
 698
 699         if (so->source != source)
 700             pa_source_output_move_to(so, source, TRUE);
 701     }
 702
 703     return PA_HOOK_OK;
 704 }
 705
 706 static pa_hook_result_t sink_put_hook_callback(pa_core *c, PA_GCC_UNUSED pa_sink *sink, struct userdata *u) {
 707     pa_assert(c);
 708     pa_assert(u);
 709     pa_assert(u->core == c);
 710     pa_assert(u->on_hotplug);
 711
 712     return reroute_sinks(u, NULL);
 713 }
 714
 715 static pa_hook_result_t source_put_hook_callback(pa_core *c, PA_GCC_UNUSED pa_source *source, struct userdata *u) {
 716     pa_assert(c);
 717     pa_assert(u);
 718     pa_assert(u->core == c);
 719     pa_assert(u->on_hotplug);
 720
 721     return reroute_sources(u, NULL);
 722 }
 723
 724 static pa_hook_result_t sink_unlink_hook_callback(pa_core *c, pa_sink *sink, struct userdata *u) {
 725     pa_assert(c);
 726     pa_assert(sink);
 727     pa_assert(u);
 728     pa_assert(u->core == c);
 729     pa_assert(u->on_rescue);
 730
 731     /* There's no point in doing anything if the core is shut down anyway */
 732     if (c->state == PA_CORE_SHUTDOWN)
 733         return PA_HOOK_OK;
 734
 735     return reroute_sinks(u, sink);
 736 }
 737
 738 static pa_hook_result_t source_unlink_hook_callback(pa_core *c, pa_source *source, struct userdata *u) {
 739     pa_assert(c);
 740     pa_assert(source);
 741     pa_assert(u);
 742     pa_assert(u->core == c);
 743     pa_assert(u->on_rescue);
 744
 745     /* There's no point in doing anything if the core is shut down anyway */
 746     if (c->state == PA_CORE_SHUTDOWN)
 747         return PA_HOOK_OK;
 748
 749     return reroute_sources(u, source);
 750 }
 751
 752
 753 static void apply_entry(struct userdata *u, const char *name, struct entry *e) {
 754     pa_sink *sink;
 755     pa_source *source;
 756     uint32_t idx;
 757     char *n;
 758
 759     pa_assert(u);
 760     pa_assert(name);
 761     pa_assert(e);
 762
 763     if ((n = get_name(name, "sink:"))) {
 764         for (sink = pa_idxset_first(u->core->sinks, &idx); sink; sink = pa_idxset_next(u->core->sinks, &idx)) {
 765             if (!pa_streq(sink->name, n)) {
 766                 continue;
 767             }
 768
 769             pa_log_info("Setting description for sink %s.", sink->name);
 770             pa_sink_set_description(sink, e->description);
 771         }
 772         pa_xfree(n);
 773     }
 774     else if ((n = get_name(name, "source:"))) {
 775         for (source = pa_idxset_first(u->core->sources, &idx); source; source = pa_idxset_next(u->core->sources, &idx)) {
 776             if (!pa_streq(source->name, n)) {
 777                 continue;
 778             }
 779
 780             if (source->monitor_of) {
 781                 pa_log_warn("Cowardly refusing to set the description for monitor source %s.", source->name);
 782                 continue;
 783             }
 784
 785             pa_log_info("Setting description for source %s.", source->name);
 786             pa_source_set_description(source, e->description);
 787         }
 788         pa_xfree(n);
 789     }
 790 }
 791
 792
 793 #define EXT_VERSION 1
 794
 795 static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connection *c, uint32_t tag, pa_tagstruct *t) {
 796   struct userdata *u;
 797   uint32_t command;
 798   pa_tagstruct *reply = NULL;
 799
 800   pa_assert(p);
 801   pa_assert(m);
 802   pa_assert(c);
 803   pa_assert(t);
 804
 805   u = m->userdata;
 806
 807   if (pa_tagstruct_getu32(t, &command) < 0)
 808     goto fail;
 809
 810   reply = pa_tagstruct_new(NULL, 0);
 811   pa_tagstruct_putu32(reply, PA_COMMAND_REPLY);
 812   pa_tagstruct_putu32(reply, tag);
 813
 814   switch (command) {
 815     case SUBCOMMAND_TEST: {
 816       if (!pa_tagstruct_eof(t))
 817         goto fail;
 818
 819       pa_tagstruct_putu32(reply, EXT_VERSION);
 820       break;
 821     }
 822
 823     case SUBCOMMAND_READ: {
 824       pa_datum key;
 825       pa_bool_t done;
 826
 827       if (!pa_tagstruct_eof(t))
 828         goto fail;
 829
 830       done = !pa_database_first(u->database, &key, NULL);
 831
 832       while (!done) {
 833         pa_datum next_key;
 834         struct entry *e;
 835         char *name;
 836
 837         done = !pa_database_next(u->database, &key, &next_key, NULL);
 838
 839         name = pa_xstrndup(key.data, key.size);
 840         pa_datum_free(&key);
 841
 842         if ((e = read_entry(u, name))) {
 843           pa_tagstruct_puts(reply, name);
 844           pa_tagstruct_puts(reply, e->description);
 845
 846           pa_xfree(e);
 847         }
 848
 849         pa_xfree(name);
 850
 851         key = next_key;
 852       }
 853
 854       break;
 855     }
 856
 857     case SUBCOMMAND_RENAME: {
 858
 859         struct entry *e;
 860         const char *device, *description;
 861
 862         if (pa_tagstruct_gets(t, &device) < 0 ||
 863           pa_tagstruct_gets(t, &description) < 0)
 864           goto fail;
 865
 866         if (!device || !*device || !description || !*description)
 867           goto fail;
 868
 869         if ((e = read_entry(u, device)) && ENTRY_VERSION == e->version) {
 870             pa_datum key, data;
 871
 872             pa_strlcpy(e->description, description, sizeof(e->description));
 873
 874             key.data = (char *) device;
 875             key.size = strlen(device);
 876
 877             data.data = e;
 878             data.size = sizeof(*e);
 879
 880             if (pa_database_set(u->database, &key, &data, TRUE) == 0) {
 881                 apply_entry(u, device, e);
 882
 883                 trigger_save(u);
 884             }
 885             else
 886                 pa_log_warn("Could not save device");
 887
 888             pa_xfree(e);
 889         }
 890         else
 891             pa_log_warn("Could not rename device %s, no entry in database", device);
 892
 893       break;
 894     }
 895
 896     case SUBCOMMAND_DELETE:
 897
 898       while (!pa_tagstruct_eof(t)) {
 899         const char *name;
 900         pa_datum key;
 901
 902         if (pa_tagstruct_gets(t, &name) < 0)
 903           goto fail;
 904
 905         key.data = (char*) name;
 906         key.size = strlen(name);
 907
 908         /** @todo: Reindex the priorities */
 909         pa_database_unset(u->database, &key);
 910       }
 911
 912       trigger_save(u);
 913
 914       break;
 915
 916     case SUBCOMMAND_ROLE_DEVICE_PRIORITY_ROUTING: {
 917
 918         pa_bool_t enable;
 919
 920         if (pa_tagstruct_get_boolean(t, &enable) < 0)
 921             goto fail;
 922
 923         u->do_routing = enable;
 924
 925         break;
 926     }
 927
 928     case SUBCOMMAND_PREFER_DEVICE:
 929     case SUBCOMMAND_DEFER_DEVICE: {
 930
 931         const char *role, *device;
 932         struct entry *e;
 933         uint32_t role_index;
 934
 935         if (pa_tagstruct_gets(t, &role) < 0 ||
 936             pa_tagstruct_gets(t, &device) < 0)
 937             goto fail;
 938
 939         if (!role || !device || !*device)
 940             goto fail;
 941
 942         role_index = get_role_index(role);
 943         if (PA_INVALID_INDEX == role_index)
 944             goto fail;
 945
 946         if ((e = read_entry(u, device)) && ENTRY_VERSION == e->version) {
 947             pa_datum key, data;
 948             pa_bool_t done;
 949             char* prefix = NULL;
 950             uint32_t priority;
 951             pa_bool_t haschanged = FALSE;
 952
 953             if (strncmp(device, "sink:", 5) == 0)
 954                 prefix = pa_xstrdup("sink:");
 955             else if (strncmp(device, "source:", 7) == 0)
 956                 prefix = pa_xstrdup("source:");
 957
 958             if (!prefix)
 959                 goto fail;
 960
 961             priority = e->priority[role_index];
 962
 963             /* Now we need to load up all the other entries of this type and shuffle the priroities around */
 964
 965             done = !pa_database_first(u->database, &key, NULL);
 966
 967             while (!done && !haschanged) {
 968                 pa_datum next_key;
 969
 970                 done = !pa_database_next(u->database, &key, &next_key, NULL);
 971
 972                 /* Only read devices with the right prefix */
 973                 if (key.size > strlen(prefix) && strncmp(key.data, prefix, strlen(prefix)) == 0) {
 974                     char *name;
 975                     struct entry *e2;
 976
 977                     name = pa_xstrndup(key.data, key.size);
 978
 979                     if ((e2 = read_entry(u, name))) {
 980                         if (SUBCOMMAND_PREFER_DEVICE == command) {
 981                             /* PREFER */
 982                             if (e2->priority[role_index] == (priority - 1)) {
 983                                 e2->priority[role_index]++;
 984                                 haschanged = TRUE;
 985                             }
 986                         } else {
 987                             /* DEFER */
 988                             if (e2->priority[role_index] == (priority + 1)) {
 989                                 e2->priority[role_index]--;
 990                                 haschanged = TRUE;
 991                             }
 992                         }
 993
 994                         if (haschanged) {
 995                             data.data = e2;
 996                             data.size = sizeof(*e2);
 997
 998                             if (pa_database_set(u->database, &key, &data, TRUE))
 999                                 pa_log_warn("Could not save device");
1000                         }
1001
1002                         pa_xfree(e2);
1003                     }
1004
1005                     pa_xfree(name);
1006                 }
1007
1008                 pa_datum_free(&key);
1009                 key = next_key;
1010             }
1011
1012             /* Now write out our actual entry */
1013             if (haschanged) {
1014                 if (SUBCOMMAND_PREFER_DEVICE == command)
1015                     e->priority[role_index]--;
1016                 else
1017                     e->priority[role_index]++;
1018
1019                 key.data = (char *) device;
1020                 key.size = strlen(device);
1021
1022                 data.data = e;
1023                 data.size = sizeof(*e);
1024
1025                 if (pa_database_set(u->database, &key, &data, TRUE))
1026                     pa_log_warn("Could not save device");
1027
1028                 trigger_save(u);
1029             }
1030
1031             pa_xfree(e);
1032
1033             pa_xfree(prefix);
1034         }
1035         else
1036             pa_log_warn("Could not reorder device %s, no entry in database", device);
1037
1038         break;
1039     }
1040
1041     case SUBCOMMAND_SUBSCRIBE: {
1042
1043       pa_bool_t enabled;
1044
1045       if (pa_tagstruct_get_boolean(t, &enabled) < 0 ||
1046         !pa_tagstruct_eof(t))
1047         goto fail;
1048
1049       if (enabled)
1050         pa_idxset_put(u->subscribed, c, NULL);
1051       else
1052         pa_idxset_remove_by_data(u->subscribed, c, NULL);
1053
1054       break;
1055     }
1056
1057     default:
1058       goto fail;
1059   }
1060
1061   pa_pstream_send_tagstruct(pa_native_connection_get_pstream(c), reply);
1062   return 0;
1063
1064   fail:
1065
1066   if (reply)
1067     pa_tagstruct_free(reply);
1068
1069   return -1;
1070 }
1071
1072 static pa_hook_result_t connection_unlink_hook_cb(pa_native_protocol *p, pa_native_connection *c, struct userdata *u) {
1073     pa_assert(p);
1074     pa_assert(c);
1075     pa_assert(u);
1076
1077     pa_idxset_remove_by_data(u->subscribed, c, NULL);
1078     return PA_HOOK_OK;
1079 }
1080
1081 int pa__init(pa_module*m) {
1082     pa_modargs *ma = NULL;
1083     struct userdata *u;
1084     char *fname;
1085     pa_sink *sink;
1086     pa_source *source;
1087     pa_sink_input *si;
1088     pa_source_output *so;
1089     uint32_t idx;
1090     pa_bool_t do_routing = FALSE, on_hotplug = TRUE, on_rescue = TRUE;
1091
1092     pa_assert(m);
1093
1094     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
1095         pa_log("Failed to parse module arguments");
1096         goto fail;
1097     }
1098
1099     if (pa_modargs_get_value_boolean(ma, "do_routing", &do_routing) < 0 ||
1100         pa_modargs_get_value_boolean(ma, "on_hotplug", &on_hotplug) < 0 ||
1101         pa_modargs_get_value_boolean(ma, "on_rescue", &on_rescue) < 0) {
1102         pa_log("on_hotplug= and on_rescue= expect boolean arguments");
1103         goto fail;
1104     }
1105
1106     m->userdata = u = pa_xnew0(struct userdata, 1);
1107     u->core = m->core;
1108     u->module = m;
1109     u->do_routing = do_routing;
1110     u->on_hotplug = on_hotplug;
1111     u->on_rescue = on_rescue;
1112     u->subscribed = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1113
1114     u->protocol = pa_native_protocol_get(m->core);
1115     pa_native_protocol_install_ext(u->protocol, m, extension_cb);
1116
1117     u->connection_unlink_hook_slot = pa_hook_connect(&pa_native_protocol_hooks(u->protocol)[PA_NATIVE_HOOK_CONNECTION_UNLINK], PA_HOOK_NORMAL, (pa_hook_cb_t) connection_unlink_hook_cb, u);
1118
1119     u->subscription = pa_subscription_new(m->core, PA_SUBSCRIPTION_MASK_SINK|PA_SUBSCRIPTION_MASK_SOURCE, subscribe_callback, u);
1120
1121     /* Used to handle device description management */
1122     u->sink_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_NEW], PA_HOOK_EARLY, (pa_hook_cb_t) sink_new_hook_callback, u);
1123     u->source_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_NEW], PA_HOOK_EARLY, (pa_hook_cb_t) source_new_hook_callback, u);
1124
1125     /* The following slots are used to deal with routing */
1126     /* A little bit later than module-stream-restore, module-intended-roles */
1127     u->sink_input_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], PA_HOOK_EARLY+15, (pa_hook_cb_t) sink_input_new_hook_callback, u);
1128     u->source_output_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_NEW], PA_HOOK_EARLY+15, (pa_hook_cb_t) source_output_new_hook_callback, u);
1129
1130     if (on_hotplug) {
1131         /* A little bit later than module-stream-restore, module-intended-roles */
1132         u->sink_put_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], PA_HOOK_LATE+15, (pa_hook_cb_t) sink_put_hook_callback, u);
1133         u->source_put_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PUT], PA_HOOK_LATE+15, (pa_hook_cb_t) source_put_hook_callback, u);
1134     }
1135
1136     if (on_rescue) {
1137         /* A little bit later than module-stream-restore, module-intended-roles, a little bit earlier than module-rescue-streams, ... */
1138         u->sink_unlink_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_UNLINK], PA_HOOK_LATE+15, (pa_hook_cb_t) sink_unlink_hook_callback, u);
1139         u->source_unlink_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], PA_HOOK_LATE+15, (pa_hook_cb_t) source_unlink_hook_callback, u);
1140     }
1141
1142     if (!(fname = pa_state_path("device-manager", TRUE)))
1143         goto fail;
1144
1145     if (!(u->database = pa_database_open(fname, TRUE))) {
1146         pa_log("Failed to open volume database '%s': %s", fname, pa_cstrerror(errno));
1147         pa_xfree(fname);
1148         goto fail;
1149     }
1150
1151     pa_log_info("Sucessfully opened database file '%s'.", fname);
1152     pa_xfree(fname);
1153
1154     /* We cycle over all the available sinks so that they are added to our database if they are not in it yet */
1155     PA_IDXSET_FOREACH(sink, m->core->sinks, idx)
1156         subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW, sink->index, u);
1157
1158     PA_IDXSET_FOREACH(source, m->core->sources, idx)
1159         subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_NEW, source->index, u);
1160
1161     /* Update our caches (all available devices will be present in our database now */
1162     update_highest_priority_device_indexes(u, "sink:", NULL);
1163     update_highest_priority_device_indexes(u, "source:", NULL);
1164
1165     PA_IDXSET_FOREACH(si, m->core->sink_inputs, idx)
1166         subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, si->index, u);
1167
1168     PA_IDXSET_FOREACH(so, m->core->source_outputs, idx)
1169         subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_NEW, so->index, u);
1170
1171     pa_modargs_free(ma);
1172     return 0;
1173
1174 fail:
1175     pa__done(m);
1176
1177     if (ma)
1178         pa_modargs_free(ma);
1179
1180     return  -1;
1181 }
1182
1183 void pa__done(pa_module*m) {
1184     struct userdata* u;
1185
1186     pa_assert(m);
1187
1188     if (!(u = m->userdata))
1189         return;
1190
1191     if (u->subscription)
1192         pa_subscription_free(u->subscription);
1193
1194     if (u->sink_new_hook_slot)
1195         pa_hook_slot_free(u->sink_new_hook_slot);
1196     if (u->source_new_hook_slot)
1197         pa_hook_slot_free(u->source_new_hook_slot);
1198
1199     if (u->sink_input_new_hook_slot)
1200         pa_hook_slot_free(u->sink_input_new_hook_slot);
1201     if (u->source_output_new_hook_slot)
1202         pa_hook_slot_free(u->source_output_new_hook_slot);
1203
1204     if (u->sink_put_hook_slot)
1205         pa_hook_slot_free(u->sink_put_hook_slot);
1206     if (u->source_put_hook_slot)
1207         pa_hook_slot_free(u->source_put_hook_slot);
1208
1209     if (u->sink_unlink_hook_slot)
1210         pa_hook_slot_free(u->sink_unlink_hook_slot);
1211     if (u->source_unlink_hook_slot)
1212         pa_hook_slot_free(u->source_unlink_hook_slot);
1213
1214     if (u->save_time_event)
1215         u->core->mainloop->time_free(u->save_time_event);
1216
1217     if (u->database)
1218         pa_database_close(u->database);
1219
1220     if (u->protocol) {
1221         pa_native_protocol_remove_ext(u->protocol, m);
1222         pa_native_protocol_unref(u->protocol);
1223     }
1224
1225     if (u->subscribed)
1226         pa_idxset_free(u->subscribed, NULL, NULL);
1227
1228     pa_xfree(u);
1229 }