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
  34 #include <pulse/gccmacro.h>
  35 #include <pulse/xmalloc.h>
  36 #include <pulse/timeval.h>
  37 #include <pulse/rtclock.h>
  38
  39 #include <pulsecore/core-error.h>
  40 #include <pulsecore/module.h>
  41 #include <pulsecore/core-util.h>
  42 #include <pulsecore/modargs.h>
  43 #include <pulsecore/log.h>
  44 #include <pulsecore/core-subscribe.h>
  45 #include <pulsecore/sink-input.h>
  46 #include <pulsecore/source-output.h>
  47 #include <pulsecore/namereg.h>
  48 #include <pulsecore/protocol-native.h>
  49 #include <pulsecore/pstream.h>
  50 #include <pulsecore/pstream-util.h>
  51 #include <pulsecore/database.h>
  52 #include <pulsecore/tagstruct.h>
  53
  54 #include "module-device-manager-symdef.h"
  55
  56 PA_MODULE_AUTHOR("Colin Guthrie");
  57 PA_MODULE_DESCRIPTION("Keep track of devices (and their descriptions) both past and present and prioritise by role");
  58 PA_MODULE_VERSION(PACKAGE_VERSION);
  59 PA_MODULE_LOAD_ONCE(TRUE);
  60 PA_MODULE_USAGE(
  61     "do_routing=<Automatically route streams based on a priority list (unique per-role)?> "
  62     "on_hotplug=<When new device becomes available, recheck streams?> "
  63     "on_rescue=<When device becomes unavailable, recheck streams?>");
  64
  65 #define SAVE_INTERVAL (10 * PA_USEC_PER_SEC)
  66 #define DUMP_DATABASE
  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     ROLE_MAX
  87 };
  88
  89 typedef uint32_t role_indexes_t[NUM_ROLES];
  90
  91 static const char* role_names[NUM_ROLES] = {
  92     "none",
  93     "video",
  94     "music",
  95     "game",
  96     "event",
  97     "phone",
  98     "animation",
  99     "production",
 100     "a11y",
 101 };
 102
 103 struct userdata {
 104     pa_core *core;
 105     pa_module *module;
 106     pa_subscription *subscription;
 107     pa_hook_slot
 108         *sink_new_hook_slot,
 109         *source_new_hook_slot,
 110         *sink_input_new_hook_slot,
 111         *source_output_new_hook_slot,
 112         *sink_put_hook_slot,
 113         *source_put_hook_slot,
 114         *sink_unlink_hook_slot,
 115         *source_unlink_hook_slot,
 116         *connection_unlink_hook_slot;
 117     pa_time_event *save_time_event;
 118     pa_database *database;
 119
 120     pa_native_protocol *protocol;
 121     pa_idxset *subscribed;
 122
 123     pa_bool_t on_hotplug;
 124     pa_bool_t on_rescue;
 125     pa_bool_t do_routing;
 126
 127     role_indexes_t preferred_sinks;
 128     role_indexes_t preferred_sources;
 129 };
 130
 131 #define ENTRY_VERSION 1
 132
 133 struct entry {
 134     uint8_t version;
 135     char *description;
 136     pa_bool_t user_set_description;
 137     char *icon;
 138     role_indexes_t priority;
 139 };
 140
 141 enum {
 142     SUBCOMMAND_TEST,
 143     SUBCOMMAND_READ,
 144     SUBCOMMAND_RENAME,
 145     SUBCOMMAND_DELETE,
 146     SUBCOMMAND_ROLE_DEVICE_PRIORITY_ROUTING,
 147     SUBCOMMAND_REORDER,
 148     SUBCOMMAND_SUBSCRIBE,
 149     SUBCOMMAND_EVENT
 150 };
 151
 152
 153 /* Forward declarations */
 154 #ifdef DUMP_DATABASE
 155 static void dump_database(struct userdata *);
 156 #endif
 157 static void notify_subscribers(struct userdata *);
 158
 159
 160 static void save_time_callback(pa_mainloop_api*a, pa_time_event* e, const struct timeval *t, void *userdata) {
 161     struct userdata *u = userdata;
 162
 163     pa_assert(a);
 164     pa_assert(e);
 165     pa_assert(u);
 166
 167     pa_assert(e == u->save_time_event);
 168     u->core->mainloop->time_free(u->save_time_event);
 169     u->save_time_event = NULL;
 170
 171     pa_database_sync(u->database);
 172     pa_log_info("Synced.");
 173
 174 #ifdef DUMP_DATABASE
 175     dump_database(u);
 176 #endif
 177 }
 178
 179 static void trigger_save(struct userdata *u) {
 180
 181     pa_assert(u);
 182
 183     notify_subscribers(u);
 184
 185     if (u->save_time_event)
 186         return;
 187
 188     u->save_time_event = pa_core_rttime_new(u->core, pa_rtclock_now() + SAVE_INTERVAL, save_time_callback, u);
 189 }
 190
 191 static struct entry* entry_new(void) {
 192     struct entry *r = pa_xnew0(struct entry, 1);
 193     r->version = ENTRY_VERSION;
 194     return r;
 195 }
 196
 197 static void entry_free(struct entry* e) {
 198     pa_assert(e);
 199
 200     pa_xfree(e->description);
 201     pa_xfree(e->icon);
 202 }
 203
 204 static pa_bool_t entry_write(struct userdata *u, const char *name, const struct entry *e) {
 205     pa_tagstruct *t;
 206     pa_datum key, data;
 207     pa_bool_t r;
 208
 209     pa_assert(u);
 210     pa_assert(name);
 211     pa_assert(e);
 212
 213     t = pa_tagstruct_new(NULL, 0);
 214     pa_tagstruct_putu8(t, e->version);
 215     pa_tagstruct_puts(t, e->description);
 216     pa_tagstruct_put_boolean(t, e->user_set_description);
 217     pa_tagstruct_puts(t, e->icon);
 218     for (uint8_t i=0; i<ROLE_MAX; ++i)
 219         pa_tagstruct_putu32(t, e->priority[i]);
 220
 221     key.data = (char *) name;
 222     key.size = strlen(name);
 223
 224     data.data = (void*)pa_tagstruct_data(t, &data.size);
 225
 226     r = (pa_database_set(u->database, &key, &data, TRUE) == 0);
 227
 228     pa_tagstruct_free(t);
 229
 230     return r;
 231 }
 232
 233 #ifdef ENABLE_LEGACY_DATABASE_ENTRY_FORMAT
 234
 235 #define LEGACY_ENTRY_VERSION 1
 236 static struct entry* legacy_entry_read(struct userdata *u, pa_datum *data) {
 237     struct legacy_entry {
 238         uint8_t version;
 239         char description[PA_NAME_MAX];
 240         pa_bool_t user_set_description;
 241         char icon[PA_NAME_MAX];
 242         role_indexes_t priority;
 243     } PA_GCC_PACKED;
 244     struct legacy_entry *le;
 245     struct entry *e;
 246
 247     pa_assert(u);
 248     pa_assert(data);
 249
 250     if (data->size != sizeof(struct legacy_entry)) {
 251         pa_log_debug("Size does not match.");
 252         return NULL;
 253     }
 254
 255     le = (struct legacy_entry*)data->data;
 256
 257     if (le->version != LEGACY_ENTRY_VERSION) {
 258         pa_log_debug("Version mismatch.");
 259         return NULL;
 260     }
 261
 262     if (!memchr(le->description, 0, sizeof(le->description))) {
 263         pa_log_warn("Description has missing NUL byte.");
 264         return NULL;
 265     }
 266
 267     if (!memchr(le->icon, 0, sizeof(le->icon))) {
 268         pa_log_warn("Icon has missing NUL byte.");
 269         return NULL;
 270     }
 271
 272     e = entry_new();
 273     e->description = pa_xstrdup(le->description);
 274     e->icon = pa_xstrdup(le->icon);
 275     return e;
 276 }
 277 #endif
 278
 279 static struct entry* entry_read(struct userdata *u, const char *name) {
 280     pa_datum key, data;
 281     struct entry *e = NULL;
 282     pa_tagstruct *t = NULL;
 283     const char *description, *icon;
 284
 285     pa_assert(u);
 286     pa_assert(name);
 287
 288     key.data = (char*) name;
 289     key.size = strlen(name);
 290
 291     pa_zero(data);
 292
 293     if (!pa_database_get(u->database, &key, &data))
 294         goto fail;
 295
 296     t = pa_tagstruct_new(data.data, data.size);
 297     e = entry_new();
 298
 299     if (pa_tagstruct_getu8(t, &e->version) < 0 ||
 300         e->version > ENTRY_VERSION ||
 301         pa_tagstruct_gets(t, &description) < 0 ||
 302         pa_tagstruct_get_boolean(t, &e->user_set_description) < 0 ||
 303         pa_tagstruct_gets(t, &icon) < 0) {
 304
 305         goto fail;
 306     }
 307
 308     e->description = pa_xstrdup(description);
 309     e->icon = pa_xstrdup(icon);
 310
 311     for (uint8_t i=0; i<ROLE_MAX; ++i) {
 312         if (pa_tagstruct_getu32(t, &e->priority[i]) < 0)
 313             goto fail;
 314     }
 315
 316     if (!pa_tagstruct_eof(t))
 317         goto fail;
 318
 319     pa_tagstruct_free(t);
 320     pa_datum_free(&data);
 321
 322     return e;
 323
 324 fail:
 325     pa_log_debug("Database contains invalid data for key: %s (probably pre-v1.0 data)", name);
 326
 327     if (e)
 328         entry_free(e);
 329     if (t)
 330         pa_tagstruct_free(t);
 331
 332 #ifdef ENABLE_LEGACY_DATABASE_ENTRY_FORMAT
 333     pa_log_debug("Attempting to load legacy (pre-v1.0) data for key: %s", name);
 334     if ((e = legacy_entry_read(u, &data))) {
 335         pa_log_debug("Success. Saving new format for key: %s", name);
 336         if (entry_write(u, name, e))
 337             trigger_save(u);
 338         pa_datum_free(&data);
 339         return e;
 340     } else
 341         pa_log_debug("Unable to load legacy (pre-v1.0) data for key: %s. Ignoring.", name);
 342 #endif
 343
 344     pa_datum_free(&data);
 345     return NULL;
 346 }
 347
 348 #ifdef DUMP_DATABASE
 349 static void dump_database_helper(struct userdata *u, uint32_t role_index, const char* human, pa_bool_t sink_mode) {
 350     pa_assert(u);
 351     pa_assert(human);
 352
 353     if (sink_mode) {
 354         pa_sink *s;
 355         if (PA_INVALID_INDEX != u->preferred_sinks[role_index] && (s = pa_idxset_get_by_index(u->core->sinks, u->preferred_sinks[role_index])))
 356             pa_log_debug("   %s %s (%s)", human, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION)), s->name);
 357         else
 358             pa_log_debug("   %s No sink specified", human);
 359     } else {
 360         pa_source *s;
 361         if (PA_INVALID_INDEX != u->preferred_sources[role_index] && (s = pa_idxset_get_by_index(u->core->sources, u->preferred_sources[role_index])))
 362             pa_log_debug("   %s %s (%s)", human, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION)), s->name);
 363         else
 364             pa_log_debug("   %s No source specified", human);
 365     }
 366 }
 367
 368 static void dump_database(struct userdata *u) {
 369     pa_datum key;
 370     pa_bool_t done;
 371
 372     pa_assert(u);
 373
 374     done = !pa_database_first(u->database, &key, NULL);
 375
 376     pa_log_debug("Dumping database");
 377     while (!done) {
 378         char *name;
 379         struct entry *e;
 380         pa_datum next_key;
 381
 382         done = !pa_database_next(u->database, &key, &next_key, NULL);
 383
 384         name = pa_xstrndup(key.data, key.size);
 385
 386         if ((e = entry_read(u, name))) {
 387             pa_log_debug(" Got entry: %s", name);
 388             pa_log_debug("  Description: %s", e->description);
 389             pa_log_debug("  Priorities: None:   %3u, Video: %3u, Music:  %3u, Game: %3u, Event: %3u",
 390                          e->priority[ROLE_NONE], e->priority[ROLE_VIDEO], e->priority[ROLE_MUSIC], e->priority[ROLE_GAME], e->priority[ROLE_EVENT]);
 391             pa_log_debug("              Phone:  %3u, Anim:  %3u, Prodtn: %3u, A11y: %3u",
 392                          e->priority[ROLE_PHONE], e->priority[ROLE_ANIMATION], e->priority[ROLE_PRODUCTION], e->priority[ROLE_A11Y]);
 393             entry_free(e);
 394         }
 395
 396         pa_xfree(name);
 397
 398         pa_datum_free(&key);
 399         key = next_key;
 400     }
 401
 402     if (u->do_routing) {
 403         pa_log_debug(" Highest priority devices per-role:");
 404
 405         pa_log_debug("  Sinks:");
 406         for (uint32_t role = ROLE_NONE; role < NUM_ROLES; ++role) {
 407             char name[13];
 408             uint32_t len = PA_MIN(12u, strlen(role_names[role]));
 409             strncpy(name, role_names[role], len);
 410             for (int i = len+1; i < 12; ++i) name[i] = ' ';
 411             name[len] = ':'; name[0] -= 32; name[12] = '\0';
 412             dump_database_helper(u, role, name, TRUE);
 413         }
 414
 415         pa_log_debug("  Sources:");
 416         for (uint32_t role = ROLE_NONE; role < NUM_ROLES; ++role) {
 417             char name[13];
 418             uint32_t len = PA_MIN(12u, strlen(role_names[role]));
 419             strncpy(name, role_names[role], len);
 420             for (int i = len+1; i < 12; ++i) name[i] = ' ';
 421             name[len] = ':'; name[0] -= 32; name[12] = '\0';
 422             dump_database_helper(u, role, name, FALSE);
 423         }
 424     }
 425
 426     pa_log_debug("Completed database dump");
 427 }
 428 #endif
 429
 430 static void notify_subscribers(struct userdata *u) {
 431
 432     pa_native_connection *c;
 433     uint32_t idx;
 434
 435     pa_assert(u);
 436
 437     for (c = pa_idxset_first(u->subscribed, &idx); c; c = pa_idxset_next(u->subscribed, &idx)) {
 438         pa_tagstruct *t;
 439
 440         t = pa_tagstruct_new(NULL, 0);
 441         pa_tagstruct_putu32(t, PA_COMMAND_EXTENSION);
 442         pa_tagstruct_putu32(t, 0);
 443         pa_tagstruct_putu32(t, u->module->index);
 444         pa_tagstruct_puts(t, u->module->name);
 445         pa_tagstruct_putu32(t, SUBCOMMAND_EVENT);
 446
 447         pa_pstream_send_tagstruct(pa_native_connection_get_pstream(c), t);
 448     }
 449 }
 450
 451 static pa_bool_t entries_equal(const struct entry *a, const struct entry *b) {
 452
 453     pa_assert(a);
 454     pa_assert(b);
 455
 456     if (!pa_streq(a->description, b->description)
 457         || a->user_set_description != b->user_set_description
 458         || !pa_streq(a->icon, b->icon))
 459         return FALSE;
 460
 461     for (int i=0; i < NUM_ROLES; ++i)
 462         if (a->priority[i] != b->priority[i])
 463             return FALSE;
 464
 465     return TRUE;
 466 }
 467
 468 static char *get_name(const char *key, const char *prefix) {
 469     char *t;
 470
 471     if (strncmp(key, prefix, strlen(prefix)))
 472         return NULL;
 473
 474     t = pa_xstrdup(key + strlen(prefix));
 475     return t;
 476 }
 477
 478 static inline struct entry *load_or_initialize_entry(struct userdata *u, struct entry *entry, const char *name, const char *prefix) {
 479     struct entry *old;
 480
 481     pa_assert(u);
 482     pa_assert(entry);
 483     pa_assert(name);
 484     pa_assert(prefix);
 485
 486     if ((old = entry_read(u, name))) {
 487         *entry = *old;
 488         entry->description = pa_xstrdup(old->description);
 489         entry->icon = pa_xstrdup(old->icon);
 490     } else {
 491         /* This is a new device, so make sure we write it's priority list correctly */
 492         role_indexes_t max_priority;
 493         pa_datum key;
 494         pa_bool_t done;
 495
 496         pa_zero(max_priority);
 497         done = !pa_database_first(u->database, &key, NULL);
 498
 499         /* Find all existing devices with the same prefix so we calculate the current max priority for each role */
 500         while (!done) {
 501             pa_datum next_key;
 502
 503             done = !pa_database_next(u->database, &key, &next_key, NULL);
 504
 505             if (key.size > strlen(prefix) && strncmp(key.data, prefix, strlen(prefix)) == 0) {
 506                 char *name2;
 507                 struct entry *e;
 508
 509                 name2 = pa_xstrndup(key.data, key.size);
 510
 511                 if ((e = entry_read(u, name2))) {
 512                     for (uint32_t i = 0; i < NUM_ROLES; ++i) {
 513                         max_priority[i] = PA_MAX(max_priority[i], e->priority[i]);
 514                     }
 515
 516                     entry_free(e);
 517                 }
 518
 519                 pa_xfree(name2);
 520             }
 521             pa_datum_free(&key);
 522             key = next_key;
 523         }
 524
 525         /* Actually initialise our entry now we've calculated it */
 526         for (uint32_t i = 0; i < NUM_ROLES; ++i) {
 527             entry->priority[i] = max_priority[i] + 1;
 528         }
 529         entry->user_set_description = FALSE;
 530     }
 531
 532     return old;
 533 }
 534
 535 static uint32_t get_role_index(const char* role) {
 536     pa_assert(role);
 537
 538     for (uint32_t i = ROLE_NONE; i < NUM_ROLES; ++i)
 539         if (strcmp(role, role_names[i]) == 0)
 540             return i;
 541
 542     return PA_INVALID_INDEX;
 543 }
 544
 545 static void update_highest_priority_device_indexes(struct userdata *u, const char *prefix, void *ignore_device) {
 546     role_indexes_t *indexes, highest_priority_available;
 547     pa_datum key;
 548     pa_bool_t done, sink_mode;
 549
 550     pa_assert(u);
 551     pa_assert(prefix);
 552
 553     sink_mode = (strcmp(prefix, "sink:") == 0);
 554
 555     if (sink_mode)
 556         indexes = &u->preferred_sinks;
 557     else
 558         indexes = &u->preferred_sources;
 559
 560     for (uint32_t i = 0; i < NUM_ROLES; ++i) {
 561         (*indexes)[i] = PA_INVALID_INDEX;
 562     }
 563     pa_zero(highest_priority_available);
 564
 565     done = !pa_database_first(u->database, &key, NULL);
 566
 567     /* Find all existing devices with the same prefix so we find the highest priority device for each role */
 568     while (!done) {
 569         pa_datum next_key;
 570
 571         done = !pa_database_next(u->database, &key, &next_key, NULL);
 572
 573         if (key.size > strlen(prefix) && strncmp(key.data, prefix, strlen(prefix)) == 0) {
 574             char *name, *device_name;
 575             struct entry *e;
 576
 577             name = pa_xstrndup(key.data, key.size);
 578             device_name = get_name(name, prefix);
 579
 580             if ((e = entry_read(u, name))) {
 581                 for (uint32_t i = 0; i < NUM_ROLES; ++i) {
 582                     if (!highest_priority_available[i] || e->priority[i] < highest_priority_available[i]) {
 583                         /* We've found a device with a higher priority than that we've currently got,
 584                            so see if it is currently available or not and update our list */
 585                         uint32_t idx;
 586                         pa_bool_t found = FALSE;
 587
 588                         if (sink_mode) {
 589                             pa_sink *sink;
 590
 591                             PA_IDXSET_FOREACH(sink, u->core->sinks, idx) {
 592                                 if ((pa_sink*) ignore_device == sink)
 593                                     continue;
 594                                 if (strcmp(sink->name, device_name) == 0) {
 595                                     found = TRUE;
 596                                     idx = sink->index; /* Is this needed? */
 597                                     break;
 598                                 }
 599                             }
 600                         } else {
 601                             pa_source *source;
 602
 603                             PA_IDXSET_FOREACH(source, u->core->sources, idx) {
 604                                 if ((pa_source*) ignore_device == source)
 605                                     continue;
 606                                 if (strcmp(source->name, device_name) == 0) {
 607                                     found = TRUE;
 608                                     idx = source->index; /* Is this needed? */
 609                                     break;
 610                                 }
 611                             }
 612                         }
 613                         if (found) {
 614                             highest_priority_available[i] = e->priority[i];
 615                             (*indexes)[i] = idx;
 616                         }
 617
 618                     }
 619                 }
 620
 621                 entry_free(e);
 622             }
 623
 624             pa_xfree(name);
 625             pa_xfree(device_name);
 626         }
 627
 628         pa_datum_free(&key);
 629         key = next_key;
 630     }
 631 }
 632
 633
 634 static void route_sink_input(struct userdata *u, pa_sink_input *si) {
 635     const char *role;
 636     uint32_t role_index, device_index;
 637     pa_sink *sink;
 638
 639     pa_assert(u);
 640     pa_assert(u->do_routing);
 641
 642     if (si->save_sink)
 643         return;
 644
 645     /* Skip this if it is already in the process of being moved anyway */
 646     if (!si->sink)
 647         return;
 648
 649     /* It might happen that a stream and a sink are set up at the
 650     same time, in which case we want to make sure we don't
 651     interfere with that */
 652     if (!PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(si)))
 653         return;
 654
 655     if (!(role = pa_proplist_gets(si->proplist, PA_PROP_MEDIA_ROLE)))
 656         role_index = get_role_index("none");
 657     else
 658         role_index = get_role_index(role);
 659
 660     if (PA_INVALID_INDEX == role_index)
 661         return;
 662
 663     device_index = u->preferred_sinks[role_index];
 664     if (PA_INVALID_INDEX == device_index)
 665         return;
 666
 667     if (!(sink = pa_idxset_get_by_index(u->core->sinks, device_index)))
 668         return;
 669
 670     if (si->sink != sink)
 671         pa_sink_input_move_to(si, sink, FALSE);
 672 }
 673
 674 static pa_hook_result_t route_sink_inputs(struct userdata *u, pa_sink *ignore_sink) {
 675     pa_sink_input *si;
 676     uint32_t idx;
 677
 678     pa_assert(u);
 679
 680     if (!u->do_routing)
 681         return PA_HOOK_OK;
 682
 683     update_highest_priority_device_indexes(u, "sink:", ignore_sink);
 684
 685     PA_IDXSET_FOREACH(si, u->core->sink_inputs, idx) {
 686         route_sink_input(u, si);
 687     }
 688
 689     return PA_HOOK_OK;
 690 }
 691
 692 static void route_source_output(struct userdata *u, pa_source_output *so) {
 693     const char *role;
 694     uint32_t role_index, device_index;
 695     pa_source *source;
 696
 697     pa_assert(u);
 698     pa_assert(u->do_routing);
 699
 700     if (so->save_source)
 701         return;
 702
 703     if (so->direct_on_input)
 704         return;
 705
 706     /* Skip this if it is already in the process of being moved anyway */
 707     if (!so->source)
 708         return;
 709
 710     /* It might happen that a stream and a source are set up at the
 711     same time, in which case we want to make sure we don't
 712     interfere with that */
 713     if (!PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(so)))
 714         return;
 715
 716     if (!(role = pa_proplist_gets(so->proplist, PA_PROP_MEDIA_ROLE)))
 717         role_index = get_role_index("none");
 718     else
 719         role_index = get_role_index(role);
 720
 721     if (PA_INVALID_INDEX == role_index)
 722         return;
 723
 724     device_index = u->preferred_sources[role_index];
 725     if (PA_INVALID_INDEX == device_index)
 726         return;
 727
 728     if (!(source = pa_idxset_get_by_index(u->core->sources, device_index)))
 729         return;
 730
 731     if (so->source != source)
 732         pa_source_output_move_to(so, source, FALSE);
 733 }
 734
 735 static pa_hook_result_t route_source_outputs(struct userdata *u, pa_source* ignore_source) {
 736     pa_source_output *so;
 737     uint32_t idx;
 738
 739     pa_assert(u);
 740
 741     if (!u->do_routing)
 742         return PA_HOOK_OK;
 743
 744     update_highest_priority_device_indexes(u, "source:", ignore_source);
 745
 746     PA_IDXSET_FOREACH(so, u->core->source_outputs, idx) {
 747         route_source_output(u, so);
 748     }
 749
 750     return PA_HOOK_OK;
 751 }
 752
 753 static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
 754     struct userdata *u = userdata;
 755     struct entry *entry, *old = NULL;
 756     char *name = NULL;
 757
 758     pa_assert(c);
 759     pa_assert(u);
 760
 761     if (t != (PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW) &&
 762         t != (PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE) &&
 763         t != (PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_NEW) &&
 764         t != (PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE) &&
 765
 766         /*t != (PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW) &&*/
 767         t != (PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE) &&
 768         /*t != (PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_NEW) &&*/
 769         t != (PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE))
 770         return;
 771
 772     entry = entry_new();
 773
 774     if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK_INPUT) {
 775         pa_sink_input *si;
 776
 777         if (!u->do_routing)
 778             return;
 779         if (!(si = pa_idxset_get_by_index(c->sink_inputs, idx)))
 780             return;
 781
 782         /* The role may change mid-stream, so we reroute */
 783         route_sink_input(u, si);
 784
 785         return;
 786     } else if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT) {
 787         pa_source_output *so;
 788
 789         if (!u->do_routing)
 790             return;
 791         if (!(so = pa_idxset_get_by_index(c->source_outputs, idx)))
 792             return;
 793
 794         /* The role may change mid-stream, so we reroute */
 795         route_source_output(u, so);
 796
 797         return;
 798     } else if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK) {
 799         pa_sink *sink;
 800
 801         if (!(sink = pa_idxset_get_by_index(c->sinks, idx)))
 802             return;
 803
 804         name = pa_sprintf_malloc("sink:%s", sink->name);
 805
 806         old = load_or_initialize_entry(u, entry, name, "sink:");
 807
 808         if (!entry->user_set_description) {
 809             pa_xfree(entry->description);
 810             entry->description = pa_xstrdup(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION));
 811         } else if (!pa_streq(entry->description, pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION))) {
 812             /* Warning: If two modules fight over the description, this could cause an infinite loop.
 813                by changing the description here, we retrigger this subscription callback. The only thing stopping us from
 814                looping is the fact that the string comparison will fail on the second iteration. If another module tries to manage
 815                the description, this will fail... */
 816             pa_sink_set_description(sink, entry->description);
 817         }
 818
 819         pa_xfree(entry->icon);
 820         entry->icon = pa_xstrdup(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_ICON_NAME));
 821
 822     } else if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE) {
 823         pa_source *source;
 824
 825         pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE);
 826
 827         if (!(source = pa_idxset_get_by_index(c->sources, idx)))
 828             return;
 829
 830         if (source->monitor_of)
 831             return;
 832
 833         name = pa_sprintf_malloc("source:%s", source->name);
 834
 835         old = load_or_initialize_entry(u, entry, name, "source:");
 836
 837         if (!entry->user_set_description) {
 838             pa_xfree(entry->description);
 839             entry->description = pa_xstrdup(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION));
 840         } else if (!pa_streq(entry->description, pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION))) {
 841             /* Warning: If two modules fight over the description, this could cause an infinite loop.
 842                by changing the description here, we retrigger this subscription callback. The only thing stopping us from
 843                looping is the fact that the string comparison will fail on the second iteration. If another module tries to manage
 844                the description, this will fail... */
 845             pa_source_set_description(source, entry->description);
 846         }
 847
 848         pa_xfree(entry->icon);
 849         entry->icon = pa_xstrdup(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_ICON_NAME));
 850     }
 851
 852     pa_assert(name);
 853
 854     if (old) {
 855
 856         if (entries_equal(old, entry)) {
 857             entry_free(old);
 858             entry_free(entry);
 859             pa_xfree(name);
 860
 861             return;
 862         }
 863
 864         entry_free(old);
 865     }
 866
 867     pa_log_info("Storing device %s.", name);
 868
 869     if (entry_write(u, name, entry))
 870         trigger_save(u);
 871     else
 872         pa_log_warn("Could not save device");;
 873
 874     entry_free(entry);
 875     pa_xfree(name);
 876 }
 877
 878 static pa_hook_result_t sink_new_hook_callback(pa_core *c, pa_sink_new_data *new_data, struct userdata *u) {
 879     char *name;
 880     struct entry *e;
 881
 882     pa_assert(c);
 883     pa_assert(new_data);
 884     pa_assert(u);
 885
 886     name = pa_sprintf_malloc("sink:%s", new_data->name);
 887
 888     if ((e = entry_read(u, name))) {
 889         if (e->user_set_description && strncmp(e->description, pa_proplist_gets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION), sizeof(e->description)) != 0) {
 890             pa_log_info("Restoring description for sink %s.", new_data->name);
 891             pa_proplist_sets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION, e->description);
 892         }
 893
 894         entry_free(e);
 895     }
 896
 897     pa_xfree(name);
 898
 899     return PA_HOOK_OK;
 900 }
 901
 902 static pa_hook_result_t source_new_hook_callback(pa_core *c, pa_source_new_data *new_data, struct userdata *u) {
 903     char *name;
 904     struct entry *e;
 905
 906     pa_assert(c);
 907     pa_assert(new_data);
 908     pa_assert(u);
 909
 910     name = pa_sprintf_malloc("source:%s", new_data->name);
 911
 912     if ((e = entry_read(u, name))) {
 913         if (e->user_set_description && strncmp(e->description, pa_proplist_gets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION), sizeof(e->description)) != 0) {
 914             /* NB, We cannot detect if we are a monitor here... this could mess things up a bit... */
 915             pa_log_info("Restoring description for source %s.", new_data->name);
 916             pa_proplist_sets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION, e->description);
 917         }
 918
 919         entry_free(e);
 920     }
 921
 922     pa_xfree(name);
 923
 924     return PA_HOOK_OK;
 925 }
 926
 927 static pa_hook_result_t sink_input_new_hook_callback(pa_core *c, pa_sink_input_new_data *new_data, struct userdata *u) {
 928     const char *role;
 929     uint32_t role_index;
 930
 931     pa_assert(c);
 932     pa_assert(new_data);
 933     pa_assert(u);
 934
 935     if (!u->do_routing)
 936         return PA_HOOK_OK;
 937
 938     if (new_data->sink)
 939         pa_log_debug("Not restoring device for stream because already set.");
 940     else {
 941         if (!(role = pa_proplist_gets(new_data->proplist, PA_PROP_MEDIA_ROLE)))
 942             role_index = get_role_index("none");
 943         else
 944             role_index = get_role_index(role);
 945
 946         if (PA_INVALID_INDEX != role_index) {
 947             uint32_t device_index;
 948
 949             device_index = u->preferred_sinks[role_index];
 950             if (PA_INVALID_INDEX != device_index) {
 951                 pa_sink *sink;
 952
 953                 if ((sink = pa_idxset_get_by_index(u->core->sinks, device_index))) {
 954                     if (!pa_sink_input_new_data_set_sink(new_data, sink, FALSE))
 955                         pa_log_debug("Not restoring device for stream because no supported format was found");
 956                 }
 957             }
 958         }
 959     }
 960
 961     return PA_HOOK_OK;
 962 }
 963
 964 static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_output_new_data *new_data, struct userdata *u) {
 965     const char *role;
 966     uint32_t role_index;
 967
 968     pa_assert(c);
 969     pa_assert(new_data);
 970     pa_assert(u);
 971
 972     if (!u->do_routing)
 973         return PA_HOOK_OK;
 974
 975     if (new_data->direct_on_input)
 976         return PA_HOOK_OK;
 977
 978     if (new_data->source)
 979         pa_log_debug("Not restoring device for stream because already set.");
 980     else {
 981         if (!(role = pa_proplist_gets(new_data->proplist, PA_PROP_MEDIA_ROLE)))
 982             role_index = get_role_index("none");
 983         else
 984             role_index = get_role_index(role);
 985
 986         if (PA_INVALID_INDEX != role_index) {
 987             uint32_t device_index;
 988
 989             device_index = u->preferred_sources[role_index];
 990             if (PA_INVALID_INDEX != device_index) {
 991                 pa_source *source;
 992
 993                 if ((source = pa_idxset_get_by_index(u->core->sources, device_index)))
 994                     if (!pa_source_output_new_data_set_source(new_data, source, FALSE))
 995                         pa_log_debug("Not restoring device for stream because no supported format was found");
 996             }
 997         }
 998     }
 999
1000     return PA_HOOK_OK;
1001 }
1002
1003
1004 static pa_hook_result_t sink_put_hook_callback(pa_core *c, PA_GCC_UNUSED pa_sink *sink, struct userdata *u) {
1005     pa_assert(c);
1006     pa_assert(u);
1007     pa_assert(u->core == c);
1008     pa_assert(u->on_hotplug);
1009
1010     notify_subscribers(u);
1011
1012     return route_sink_inputs(u, NULL);
1013 }
1014
1015 static pa_hook_result_t source_put_hook_callback(pa_core *c, PA_GCC_UNUSED pa_source *source, struct userdata *u) {
1016     pa_assert(c);
1017     pa_assert(u);
1018     pa_assert(u->core == c);
1019     pa_assert(u->on_hotplug);
1020
1021     notify_subscribers(u);
1022
1023     return route_source_outputs(u, NULL);
1024 }
1025
1026 static pa_hook_result_t sink_unlink_hook_callback(pa_core *c, pa_sink *sink, struct userdata *u) {
1027     pa_assert(c);
1028     pa_assert(sink);
1029     pa_assert(u);
1030     pa_assert(u->core == c);
1031     pa_assert(u->on_rescue);
1032
1033     /* There's no point in doing anything if the core is shut down anyway */
1034     if (c->state == PA_CORE_SHUTDOWN)
1035         return PA_HOOK_OK;
1036
1037     notify_subscribers(u);
1038
1039     return route_sink_inputs(u, sink);
1040 }
1041
1042 static pa_hook_result_t source_unlink_hook_callback(pa_core *c, pa_source *source, struct userdata *u) {
1043     pa_assert(c);
1044     pa_assert(source);
1045     pa_assert(u);
1046     pa_assert(u->core == c);
1047     pa_assert(u->on_rescue);
1048
1049     /* There's no point in doing anything if the core is shut down anyway */
1050     if (c->state == PA_CORE_SHUTDOWN)
1051         return PA_HOOK_OK;
1052
1053     notify_subscribers(u);
1054
1055     return route_source_outputs(u, source);
1056 }
1057
1058
1059 static void apply_entry(struct userdata *u, const char *name, struct entry *e) {
1060     uint32_t idx;
1061     char *n;
1062
1063     pa_assert(u);
1064     pa_assert(name);
1065     pa_assert(e);
1066
1067     if (!e->user_set_description)
1068         return;
1069
1070     if ((n = get_name(name, "sink:"))) {
1071         pa_sink *s;
1072         PA_IDXSET_FOREACH(s, u->core->sinks, idx) {
1073             if (!pa_streq(s->name, n)) {
1074                 continue;
1075             }
1076
1077             pa_log_info("Setting description for sink %s to '%s'", s->name, e->description);
1078             pa_sink_set_description(s, e->description);
1079         }
1080         pa_xfree(n);
1081     }
1082     else if ((n = get_name(name, "source:"))) {
1083         pa_source *s;
1084         PA_IDXSET_FOREACH(s, u->core->sources, idx) {
1085             if (!pa_streq(s->name, n)) {
1086                 continue;
1087             }
1088
1089             if (s->monitor_of) {
1090                 pa_log_warn("Cowardly refusing to set the description for monitor source %s.", s->name);
1091                 continue;
1092             }
1093
1094             pa_log_info("Setting description for source %s to '%s'", s->name, e->description);
1095             pa_source_set_description(s, e->description);
1096         }
1097         pa_xfree(n);
1098     }
1099 }
1100
1101
1102 #define EXT_VERSION 1
1103
1104 static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connection *c, uint32_t tag, pa_tagstruct *t) {
1105   struct userdata *u;
1106   uint32_t command;
1107   pa_tagstruct *reply = NULL;
1108
1109   pa_assert(p);
1110   pa_assert(m);
1111   pa_assert(c);
1112   pa_assert(t);
1113
1114   u = m->userdata;
1115
1116   if (pa_tagstruct_getu32(t, &command) < 0)
1117     goto fail;
1118
1119   reply = pa_tagstruct_new(NULL, 0);
1120   pa_tagstruct_putu32(reply, PA_COMMAND_REPLY);
1121   pa_tagstruct_putu32(reply, tag);
1122
1123   switch (command) {
1124     case SUBCOMMAND_TEST: {
1125       if (!pa_tagstruct_eof(t))
1126         goto fail;
1127
1128       pa_tagstruct_putu32(reply, EXT_VERSION);
1129       break;
1130     }
1131
1132     case SUBCOMMAND_READ: {
1133       pa_datum key;
1134       pa_bool_t done;
1135
1136       if (!pa_tagstruct_eof(t))
1137         goto fail;
1138
1139       done = !pa_database_first(u->database, &key, NULL);
1140
1141       while (!done) {
1142         pa_datum next_key;
1143         struct entry *e;
1144         char *name;
1145
1146         done = !pa_database_next(u->database, &key, &next_key, NULL);
1147
1148         name = pa_xstrndup(key.data, key.size);
1149         pa_datum_free(&key);
1150
1151         if ((e = entry_read(u, name))) {
1152             uint32_t idx;
1153             char *device_name;
1154             uint32_t found_index = PA_INVALID_INDEX;
1155
1156             if ((device_name = get_name(name, "sink:"))) {
1157                 pa_sink* s;
1158                 PA_IDXSET_FOREACH(s, u->core->sinks, idx) {
1159                     if (strcmp(s->name, device_name) == 0) {
1160                         found_index = s->index;
1161                         break;
1162                     }
1163                 }
1164                 pa_xfree(device_name);
1165             } else if ((device_name = get_name(name, "source:"))) {
1166                 pa_source* s;
1167                 PA_IDXSET_FOREACH(s, u->core->sources, idx) {
1168                     if (strcmp(s->name, device_name) == 0) {
1169                         found_index = s->index;
1170                         break;
1171                     }
1172                 }
1173                 pa_xfree(device_name);
1174             }
1175
1176             pa_tagstruct_puts(reply, name);
1177             pa_tagstruct_puts(reply, e->description);
1178             pa_tagstruct_puts(reply, e->icon);
1179             pa_tagstruct_putu32(reply, found_index);
1180             pa_tagstruct_putu32(reply, NUM_ROLES);
1181
1182             for (uint32_t i = ROLE_NONE; i < NUM_ROLES; ++i) {
1183                 pa_tagstruct_puts(reply, role_names[i]);
1184                 pa_tagstruct_putu32(reply, e->priority[i]);
1185             }
1186
1187             entry_free(e);
1188         }
1189
1190         pa_xfree(name);
1191
1192         key = next_key;
1193       }
1194
1195       break;
1196     }
1197
1198     case SUBCOMMAND_RENAME: {
1199
1200         struct entry *e;
1201         const char *device, *description;
1202
1203         if (pa_tagstruct_gets(t, &device) < 0 ||
1204           pa_tagstruct_gets(t, &description) < 0)
1205           goto fail;
1206
1207         if (!device || !*device || !description || !*description)
1208           goto fail;
1209
1210         if ((e = entry_read(u, device))) {
1211             pa_xfree(e->description);
1212             e->description = pa_xstrdup(description);
1213             e->user_set_description = TRUE;
1214
1215             if (entry_write(u, (char *)device, e)) {
1216                 apply_entry(u, device, e);
1217
1218                 trigger_save(u);
1219             }
1220             else
1221                 pa_log_warn("Could not save device");
1222
1223             entry_free(e);
1224         }
1225         else
1226             pa_log_warn("Could not rename device %s, no entry in database", device);
1227
1228       break;
1229     }
1230
1231     case SUBCOMMAND_DELETE:
1232
1233       while (!pa_tagstruct_eof(t)) {
1234         const char *name;
1235         pa_datum key;
1236
1237         if (pa_tagstruct_gets(t, &name) < 0)
1238           goto fail;
1239
1240         key.data = (char*) name;
1241         key.size = strlen(name);
1242
1243         /** @todo: Reindex the priorities */
1244         pa_database_unset(u->database, &key);
1245       }
1246
1247       trigger_save(u);
1248
1249       break;
1250
1251     case SUBCOMMAND_ROLE_DEVICE_PRIORITY_ROUTING: {
1252
1253         pa_bool_t enable;
1254
1255         if (pa_tagstruct_get_boolean(t, &enable) < 0)
1256             goto fail;
1257
1258         if ((u->do_routing = enable)) {
1259             /* Update our caches */
1260             update_highest_priority_device_indexes(u, "sink:", NULL);
1261             update_highest_priority_device_indexes(u, "source:", NULL);
1262         }
1263
1264         break;
1265     }
1266
1267     case SUBCOMMAND_REORDER: {
1268
1269         const char *role;
1270         struct entry *e;
1271         uint32_t role_index, n_devices;
1272         pa_datum key;
1273         pa_bool_t done, sink_mode = TRUE;
1274         struct device_t { uint32_t prio; char *device; };
1275         struct device_t *device;
1276         struct device_t **devices;
1277         uint32_t i, idx, offset;
1278         pa_hashmap *h;
1279         /*void *state;*/
1280         pa_bool_t first;
1281
1282         if (pa_tagstruct_gets(t, &role) < 0 ||
1283             pa_tagstruct_getu32(t, &n_devices) < 0 ||
1284             n_devices < 1)
1285             goto fail;
1286
1287         if (PA_INVALID_INDEX == (role_index = get_role_index(role)))
1288             goto fail;
1289
1290         /* Cycle through the devices given and make sure they exist */
1291         h = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1292         first = TRUE;
1293         idx = 0;
1294         for (i = 0; i < n_devices; ++i) {
1295             const char *s;
1296             if (pa_tagstruct_gets(t, &s) < 0) {
1297                 while ((device = pa_hashmap_steal_first(h))) {
1298                     pa_xfree(device->device);
1299                     pa_xfree(device);
1300                 }
1301
1302                 pa_hashmap_free(h, NULL, NULL);
1303                 pa_log_error("Protocol error on reorder");
1304                 goto fail;
1305             }
1306
1307             /* Ensure this is a valid entry */
1308             if (!(e = entry_read(u, s))) {
1309                 while ((device = pa_hashmap_steal_first(h))) {
1310                     pa_xfree(device->device);
1311                     pa_xfree(device);
1312                 }
1313
1314                 pa_hashmap_free(h, NULL, NULL);
1315                 pa_log_error("Client specified an unknown device in it's reorder list.");
1316                 goto fail;
1317             }
1318             entry_free(e);
1319
1320             if (first) {
1321                 first = FALSE;
1322                 sink_mode = (0 == strncmp("sink:", s, 5));
1323             } else if ((sink_mode && 0 != strncmp("sink:", s, 5)) || (!sink_mode && 0 != strncmp("source:", s, 7))) {
1324                 while ((device = pa_hashmap_steal_first(h))) {
1325                     pa_xfree(device->device);
1326                     pa_xfree(device);
1327                 }
1328
1329                 pa_hashmap_free(h, NULL, NULL);
1330                 pa_log_error("Attempted to reorder mixed devices (sinks and sources)");
1331                 goto fail;
1332             }
1333
1334             /* Add the device to our hashmap. If it's alredy in it, free it now and carry on */
1335             device = pa_xnew(struct device_t, 1);
1336             device->device = pa_xstrdup(s);
1337             if (pa_hashmap_put(h, device->device, device) == 0) {
1338                 device->prio = idx;
1339                 idx++;
1340             } else {
1341                 pa_xfree(device->device);
1342                 pa_xfree(device);
1343             }
1344         }
1345
1346         /*pa_log_debug("Hashmap contents (received from client)");
1347         PA_HASHMAP_FOREACH(device, h, state) {
1348             pa_log_debug("  - %s (%d)", device->device, device->prio);
1349         }*/
1350
1351         /* Now cycle through our list and add all the devices.
1352            This has the effect of addign in any in our DB,
1353            not specified in the device list (and thus will be
1354            tacked on at the end) */
1355         offset = idx;
1356         done = !pa_database_first(u->database, &key, NULL);
1357
1358         while (!done && idx < 256) {
1359             pa_datum next_key;
1360
1361             done = !pa_database_next(u->database, &key, &next_key, NULL);
1362
1363             device = pa_xnew(struct device_t, 1);
1364             device->device = pa_xstrndup(key.data, key.size);
1365             if ((sink_mode && 0 == strncmp("sink:", device->device, 5))
1366                 || (!sink_mode && 0 == strncmp("source:", device->device, 7))) {
1367
1368                 /* Add the device to our hashmap. If it's alredy in it, free it now and carry on */
1369                 if (pa_hashmap_put(h, device->device, device) == 0
1370                     && (e = entry_read(u, device->device))) {
1371                     /* We add offset on to the existing priorirty so that when we order, the
1372                        existing entries are always lower priority than the new ones. */
1373                     device->prio = (offset + e->priority[role_index]);
1374                     pa_xfree(e);
1375                 }
1376                 else {
1377                     pa_xfree(device->device);
1378                     pa_xfree(device);
1379                 }
1380             } else {
1381                 pa_xfree(device->device);
1382                 pa_xfree(device);
1383             }
1384
1385             pa_datum_free(&key);
1386
1387             key = next_key;
1388         }
1389
1390         /*pa_log_debug("Hashmap contents (combined with database)");
1391         PA_HASHMAP_FOREACH(device, h, state) {
1392             pa_log_debug("  - %s (%d)", device->device, device->prio);
1393         }*/
1394
1395         /* Now we put all the entries in a simple list for sorting it. */
1396         n_devices = pa_hashmap_size(h);
1397         devices = pa_xnew(struct device_t *,  n_devices);
1398         idx = 0;
1399         while ((device = pa_hashmap_steal_first(h))) {
1400             devices[idx++] = device;
1401         }
1402         pa_hashmap_free(h, NULL, NULL);
1403
1404         /* Simple bubble sort */
1405         for (i = 0; i < n_devices; ++i) {
1406             for (uint32_t j = i; j < n_devices; ++j) {
1407                 if (devices[i]->prio > devices[j]->prio) {
1408                     struct device_t *tmp;
1409                     tmp = devices[i];
1410                     devices[i] = devices[j];
1411                     devices[j] = tmp;
1412                 }
1413             }
1414         }
1415
1416         /*pa_log_debug("Sorted device list");
1417         for (i = 0; i < n_devices; ++i) {
1418             pa_log_debug("  - %s (%d)", devices[i]->device, devices[i]->prio);
1419         }*/
1420
1421         /* Go through in order and write the new entry and cleanup our own list */
1422         idx = 1;
1423         first = TRUE;
1424         for (i = 0; i < n_devices; ++i) {
1425             if ((e = entry_read(u, devices[i]->device))) {
1426                 if (e->priority[role_index] == idx)
1427                     idx++;
1428                 else {
1429                     e->priority[role_index] = idx;
1430
1431                     if (entry_write(u, (char *) devices[i]->device, e)) {
1432                         first = FALSE;
1433                         idx++;
1434                     }
1435                 }
1436
1437                 pa_xfree(e);
1438             }
1439             pa_xfree(devices[i]->device);
1440             pa_xfree(devices[i]);
1441         }
1442
1443         if (!first) {
1444             trigger_save(u);
1445
1446             if (sink_mode)
1447                 route_sink_inputs(u, NULL);
1448             else
1449                 route_source_outputs(u, NULL);
1450         }
1451
1452         break;
1453     }
1454
1455     case SUBCOMMAND_SUBSCRIBE: {
1456
1457       pa_bool_t enabled;
1458
1459       if (pa_tagstruct_get_boolean(t, &enabled) < 0 ||
1460         !pa_tagstruct_eof(t))
1461         goto fail;
1462
1463       if (enabled)
1464         pa_idxset_put(u->subscribed, c, NULL);
1465       else
1466         pa_idxset_remove_by_data(u->subscribed, c, NULL);
1467
1468       break;
1469     }
1470
1471     default:
1472       goto fail;
1473   }
1474
1475   pa_pstream_send_tagstruct(pa_native_connection_get_pstream(c), reply);
1476   return 0;
1477
1478   fail:
1479
1480   if (reply)
1481     pa_tagstruct_free(reply);
1482
1483   return -1;
1484 }
1485
1486 static pa_hook_result_t connection_unlink_hook_cb(pa_native_protocol *p, pa_native_connection *c, struct userdata *u) {
1487     pa_assert(p);
1488     pa_assert(c);
1489     pa_assert(u);
1490
1491     pa_idxset_remove_by_data(u->subscribed, c, NULL);
1492     return PA_HOOK_OK;
1493 }
1494
1495 struct prioritised_indexes {
1496     uint32_t index;
1497     int32_t priority;
1498 };
1499
1500 int pa__init(pa_module*m) {
1501     pa_modargs *ma = NULL;
1502     struct userdata *u;
1503     char *fname;
1504     pa_sink *sink;
1505     pa_source *source;
1506     uint32_t idx;
1507     pa_bool_t do_routing = FALSE, on_hotplug = TRUE, on_rescue = TRUE;
1508     uint32_t total_devices;
1509
1510     pa_assert(m);
1511
1512     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
1513         pa_log("Failed to parse module arguments");
1514         goto fail;
1515     }
1516
1517     if (pa_modargs_get_value_boolean(ma, "do_routing", &do_routing) < 0 ||
1518         pa_modargs_get_value_boolean(ma, "on_hotplug", &on_hotplug) < 0 ||
1519         pa_modargs_get_value_boolean(ma, "on_rescue", &on_rescue) < 0) {
1520         pa_log("on_hotplug= and on_rescue= expect boolean arguments");
1521         goto fail;
1522     }
1523
1524     m->userdata = u = pa_xnew0(struct userdata, 1);
1525     u->core = m->core;
1526     u->module = m;
1527     u->do_routing = do_routing;
1528     u->on_hotplug = on_hotplug;
1529     u->on_rescue = on_rescue;
1530     u->subscribed = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1531
1532     u->protocol = pa_native_protocol_get(m->core);
1533     pa_native_protocol_install_ext(u->protocol, m, extension_cb);
1534
1535     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);
1536
1537     u->subscription = pa_subscription_new(m->core, PA_SUBSCRIPTION_MASK_SINK|PA_SUBSCRIPTION_MASK_SOURCE|PA_SUBSCRIPTION_MASK_SINK_INPUT|PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT, subscribe_callback, u);
1538
1539     /* Used to handle device description management */
1540     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);
1541     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);
1542
1543     /* The following slots are used to deal with routing */
1544     /* A little bit later than module-stream-restore, but before module-intended-roles */
1545     u->sink_input_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], PA_HOOK_EARLY+5, (pa_hook_cb_t) sink_input_new_hook_callback, u);
1546     u->source_output_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_NEW], PA_HOOK_EARLY+5, (pa_hook_cb_t) source_output_new_hook_callback, u);
1547
1548     if (on_hotplug) {
1549         /* A little bit later than module-stream-restore, but before module-intended-roles */
1550         u->sink_put_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], PA_HOOK_LATE+5, (pa_hook_cb_t) sink_put_hook_callback, u);
1551         u->source_put_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PUT], PA_HOOK_LATE+5, (pa_hook_cb_t) source_put_hook_callback, u);
1552     }
1553
1554     if (on_rescue) {
1555         /* A little bit later than module-stream-restore, a little bit earlier than module-intended-roles, module-rescue-streams, ... */
1556         u->sink_unlink_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_UNLINK], PA_HOOK_LATE+5, (pa_hook_cb_t) sink_unlink_hook_callback, u);
1557         u->source_unlink_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], PA_HOOK_LATE+5, (pa_hook_cb_t) source_unlink_hook_callback, u);
1558     }
1559
1560     if (!(fname = pa_state_path("device-manager", TRUE)))
1561         goto fail;
1562
1563     if (!(u->database = pa_database_open(fname, TRUE))) {
1564         pa_log("Failed to open volume database '%s': %s", fname, pa_cstrerror(errno));
1565         pa_xfree(fname);
1566         goto fail;
1567     }
1568
1569     pa_log_info("Successfully opened database file '%s'.", fname);
1570     pa_xfree(fname);
1571
1572     /* Attempt to inject the devices into the list in priority order */
1573     total_devices = PA_MAX(pa_idxset_size(m->core->sinks), pa_idxset_size(m->core->sources));
1574     if (total_devices > 0 && total_devices < 128) {
1575         uint32_t i;
1576         struct prioritised_indexes p_i[128];
1577
1578         /* We cycle over all the available sinks so that they are added to our database if they are not in it yet */
1579         i = 0;
1580         PA_IDXSET_FOREACH(sink, m->core->sinks, idx) {
1581             pa_log_debug("Found sink index %u", sink->index);
1582             p_i[i  ].index = sink->index;
1583             p_i[i++].priority = sink->priority;
1584         }
1585         /* Bubble sort it (only really useful for first time creation) */
1586         if (i > 1)
1587           for (uint32_t j = 0; j < i; ++j)
1588               for (uint32_t k = 0; k < i; ++k)
1589                   if (p_i[j].priority > p_i[k].priority) {
1590                       struct prioritised_indexes tmp_pi = p_i[k];
1591                       p_i[k] = p_i[j];
1592                       p_i[j] = tmp_pi;
1593                   }
1594         /* Register it */
1595         for (uint32_t j = 0; j < i; ++j)
1596             subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW, p_i[j].index, u);
1597
1598
1599         /* We cycle over all the available sources so that they are added to our database if they are not in it yet */
1600         i = 0;
1601         PA_IDXSET_FOREACH(source, m->core->sources, idx) {
1602             p_i[i  ].index = source->index;
1603             p_i[i++].priority = source->priority;
1604         }
1605         /* Bubble sort it (only really useful for first time creation) */
1606         if (i > 1)
1607           for (uint32_t j = 0; j < i; ++j)
1608               for (uint32_t k = 0; k < i; ++k)
1609                   if (p_i[j].priority > p_i[k].priority) {
1610                       struct prioritised_indexes tmp_pi = p_i[k];
1611                       p_i[k] = p_i[j];
1612                       p_i[j] = tmp_pi;
1613                   }
1614         /* Register it */
1615         for (uint32_t j = 0; j < i; ++j)
1616             subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_NEW, p_i[j].index, u);
1617     }
1618     else if (total_devices > 0) {
1619         /* This user has a *lot* of devices... */
1620         PA_IDXSET_FOREACH(sink, m->core->sinks, idx)
1621             subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW, sink->index, u);
1622
1623         PA_IDXSET_FOREACH(source, m->core->sources, idx)
1624             subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_NEW, source->index, u);
1625     }
1626
1627     /* Perform the routing (if it's enabled) which will update our priority list cache too */
1628     for (uint32_t i = 0; i < NUM_ROLES; ++i) {
1629         u->preferred_sinks[i] = u->preferred_sources[i] = PA_INVALID_INDEX;
1630     }
1631
1632     route_sink_inputs(u, NULL);
1633     route_source_outputs(u, NULL);
1634
1635 #ifdef DUMP_DATABASE
1636     dump_database(u);
1637 #endif
1638
1639     pa_modargs_free(ma);
1640     return 0;
1641
1642 fail:
1643     pa__done(m);
1644
1645     if (ma)
1646         pa_modargs_free(ma);
1647
1648     return -1;
1649 }
1650
1651 void pa__done(pa_module*m) {
1652     struct userdata* u;
1653
1654     pa_assert(m);
1655
1656     if (!(u = m->userdata))
1657         return;
1658
1659     if (u->subscription)
1660         pa_subscription_free(u->subscription);
1661
1662     if (u->sink_new_hook_slot)
1663         pa_hook_slot_free(u->sink_new_hook_slot);
1664     if (u->source_new_hook_slot)
1665         pa_hook_slot_free(u->source_new_hook_slot);
1666
1667     if (u->sink_input_new_hook_slot)
1668         pa_hook_slot_free(u->sink_input_new_hook_slot);
1669     if (u->source_output_new_hook_slot)
1670         pa_hook_slot_free(u->source_output_new_hook_slot);
1671
1672     if (u->sink_put_hook_slot)
1673         pa_hook_slot_free(u->sink_put_hook_slot);
1674     if (u->source_put_hook_slot)
1675         pa_hook_slot_free(u->source_put_hook_slot);
1676
1677     if (u->sink_unlink_hook_slot)
1678         pa_hook_slot_free(u->sink_unlink_hook_slot);
1679     if (u->source_unlink_hook_slot)
1680         pa_hook_slot_free(u->source_unlink_hook_slot);
1681
1682     if (u->connection_unlink_hook_slot)
1683         pa_hook_slot_free(u->connection_unlink_hook_slot);
1684
1685     if (u->save_time_event)
1686         u->core->mainloop->time_free(u->save_time_event);
1687
1688     if (u->database)
1689         pa_database_close(u->database);
1690
1691     if (u->protocol) {
1692         pa_native_protocol_remove_ext(u->protocol, m);
1693         pa_native_protocol_unref(u->protocol);
1694     }
1695
1696     if (u->subscribed)
1697         pa_idxset_free(u->subscribed, NULL, NULL);
1698
1699     pa_xfree(u);
1700 }