src/pulsecore/cli-command.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <errno.h>
  31 #include <unistd.h>
  32 #include <ltdl.h>
  33 #include <sys/stat.h>
  34 #include <dirent.h>
  35 #include <time.h>
  36
  37 #include <pulse/xmalloc.h>
  38 #include <pulse/error.h>
  39
  40 #include <pulsecore/module.h>
  41 #include <pulsecore/sink.h>
  42 #include <pulsecore/source.h>
  43 #include <pulsecore/client.h>
  44 #include <pulsecore/sink-input.h>
  45 #include <pulsecore/source-output.h>
  46 #include <pulsecore/tokenizer.h>
  47 #include <pulsecore/strbuf.h>
  48 #include <pulsecore/namereg.h>
  49 #include <pulsecore/cli-text.h>
  50 #include <pulsecore/core-scache.h>
  51 #include <pulsecore/sound-file.h>
  52 #include <pulsecore/play-memchunk.h>
  53 #include <pulsecore/sound-file-stream.h>
  54 #include <pulsecore/shared.h>
  55 #include <pulsecore/core-util.h>
  56 #include <pulsecore/core-error.h>
  57 #include <pulsecore/modinfo.h>
  58 #include <pulsecore/dynarray.h>
  59
  60 #include "cli-command.h"
  61
  62 struct command {
  63     const char *name;
  64     int (*proc) (pa_core *c, pa_tokenizer*t, pa_strbuf *buf, pa_bool_t *fail);
  65     const char *help;
  66     unsigned args;
  67 };
  68
  69 #define META_INCLUDE ".include"
  70 #define META_FAIL ".fail"
  71 #define META_NOFAIL ".nofail"
  72 #define META_IFEXISTS ".ifexists"
  73 #define META_ELSE ".else"
  74 #define META_ENDIF ".endif"
  75
  76 enum {
  77     IFSTATE_NONE = -1,
  78     IFSTATE_FALSE = 0,
  79     IFSTATE_TRUE = 1,
  80 };
  81
  82 /* Prototypes for all available commands */
  83 static int pa_cli_command_exit(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  84 static int pa_cli_command_help(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  85 static int pa_cli_command_modules(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  86 static int pa_cli_command_clients(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  87 static int pa_cli_command_cards(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  88 static int pa_cli_command_sinks(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  89 static int pa_cli_command_sources(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  90 static int pa_cli_command_sink_inputs(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  91 static int pa_cli_command_source_outputs(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  92 static int pa_cli_command_stat(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  93 static int pa_cli_command_info(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  94 static int pa_cli_command_load(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  95 static int pa_cli_command_unload(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  96 static int pa_cli_command_describe(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  97 static int pa_cli_command_sink_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  98 static int pa_cli_command_sink_input_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
  99 static int pa_cli_command_source_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 100 static int pa_cli_command_sink_mute(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 101 static int pa_cli_command_source_mute(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 102 static int pa_cli_command_sink_input_mute(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 103 static int pa_cli_command_sink_default(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 104 static int pa_cli_command_source_default(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 105 static int pa_cli_command_kill_client(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 106 static int pa_cli_command_kill_sink_input(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 107 static int pa_cli_command_kill_source_output(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 108 static int pa_cli_command_scache_play(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 109 static int pa_cli_command_scache_remove(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 110 static int pa_cli_command_scache_list(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 111 static int pa_cli_command_scache_load(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 112 static int pa_cli_command_scache_load_dir(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 113 static int pa_cli_command_play_file(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 114 static int pa_cli_command_dump(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 115 static int pa_cli_command_list_shared_props(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 116 static int pa_cli_command_move_sink_input(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 117 static int pa_cli_command_move_source_output(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 118 static int pa_cli_command_vacuum(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 119 static int pa_cli_command_suspend_sink(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 120 static int pa_cli_command_suspend_source(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 121 static int pa_cli_command_suspend(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 122 static int pa_cli_command_log_level(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 123 static int pa_cli_command_log_meta(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 124 static int pa_cli_command_log_time(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 125 static int pa_cli_command_log_backtrace(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 126 static int pa_cli_command_update_sink_proplist(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 127 static int pa_cli_command_update_source_proplist(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 128 static int pa_cli_command_update_sink_input_proplist(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 129 static int pa_cli_command_update_source_output_proplist(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 130 static int pa_cli_command_card_profile(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 131 static int pa_cli_command_sink_port(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 132 static int pa_cli_command_source_port(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 133 static int pa_cli_command_dump_volumes(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail);
 134
 135 /* A method table for all available commands */
 136
 137 static const struct command commands[] = {
 138     { "exit",                    pa_cli_command_exit,               "Terminate the daemon",         1 },
 139     { "help",                    pa_cli_command_help,               "Show this help",               1 },
 140     { "list-modules",            pa_cli_command_modules,            "List loaded modules",          1 },
 141     { "list-sinks",              pa_cli_command_sinks,              "List loaded sinks",            1 },
 142     { "list-sources",            pa_cli_command_sources,            "List loaded sources",          1 },
 143     { "list-clients",            pa_cli_command_clients,            "List loaded clients",          1 },
 144     { "list-sink-inputs",        pa_cli_command_sink_inputs,        "List sink inputs",             1 },
 145     { "list-source-outputs",     pa_cli_command_source_outputs,     "List source outputs",          1 },
 146     { "list-cards",              pa_cli_command_cards,              "List cards",                   1 },
 147     { "stat",                    pa_cli_command_stat,               "Show memory block statistics", 1 },
 148     { "info",                    pa_cli_command_info,               "Show comprehensive status",    1 },
 149     { "ls",                      pa_cli_command_info,               NULL,                           1 },
 150     { "list",                    pa_cli_command_info,               NULL,                           1 },
 151     { "load-module",             pa_cli_command_load,               "Load a module (args: name, arguments)", 3},
 152     { "unload-module",           pa_cli_command_unload,             "Unload a module (args: index)", 2},
 153     { "describe-module",         pa_cli_command_describe,           "Describe a module (arg: name)", 2},
 154     { "set-sink-volume",         pa_cli_command_sink_volume,        "Set the volume of a sink (args: index|name, volume)", 3},
 155     { "set-sink-input-volume",   pa_cli_command_sink_input_volume,  "Set the volume of a sink input (args: index, volume)", 3},
 156     { "set-source-volume",       pa_cli_command_source_volume,      "Set the volume of a source (args: index|name, volume)", 3},
 157     { "set-sink-mute",           pa_cli_command_sink_mute,          "Set the mute switch of a sink (args: index|name, bool)", 3},
 158     { "set-sink-input-mute",     pa_cli_command_sink_input_mute,    "Set the mute switch of a sink input (args: index, bool)", 3},
 159     { "set-source-mute",         pa_cli_command_source_mute,        "Set the mute switch of a source (args: index|name, bool)", 3},
 160     { "update-sink-proplist",    pa_cli_command_update_sink_proplist, "Update the properties of a sink (args: index|name, properties)", 3},
 161     { "update-source-proplist",  pa_cli_command_update_source_proplist, "Update the properties of a source (args: index|name, properties)", 3},
 162     { "update-sink-input-proplist", pa_cli_command_update_sink_input_proplist, "Update the properties of a sink input (args: index, properties)", 3},
 163     { "update-source-output-proplist", pa_cli_command_update_source_output_proplist, "Update the properties of a source_output (args: index, properties)", 3},
 164     { "set-default-sink",        pa_cli_command_sink_default,       "Set the default sink (args: index|name)", 2},
 165     { "set-default-source",      pa_cli_command_source_default,     "Set the default source (args: index|name)", 2},
 166     { "kill-client",             pa_cli_command_kill_client,        "Kill a client (args: index)", 2},
 167     { "kill-sink-input",         pa_cli_command_kill_sink_input,    "Kill a sink input (args: index)", 2},
 168     { "kill-source-output",      pa_cli_command_kill_source_output, "Kill a source output (args: index)", 2},
 169     { "list-samples",            pa_cli_command_scache_list,        "List all entries in the sample cache", 1},
 170     { "play-sample",             pa_cli_command_scache_play,        "Play a sample from the sample cache (args: name, sink|index)", 3},
 171     { "remove-sample",           pa_cli_command_scache_remove,      "Remove a sample from the sample cache (args: name)", 2},
 172     { "load-sample",             pa_cli_command_scache_load,        "Load a sound file into the sample cache (args: name, filename)", 3},
 173     { "load-sample-lazy",        pa_cli_command_scache_load,        "Lazily load a sound file into the sample cache (args: name, filename)", 3},
 174     { "load-sample-dir-lazy",    pa_cli_command_scache_load_dir,    "Lazily load all files in a directory into the sample cache (args: pathname)", 2},
 175     { "play-file",               pa_cli_command_play_file,          "Play a sound file (args: filename, sink|index)", 3},
 176     { "dump",                    pa_cli_command_dump,               "Dump daemon configuration", 1},
 177     { "shared",                  pa_cli_command_list_shared_props,  NULL, 1},
 178     { "move-sink-input",         pa_cli_command_move_sink_input,    "Move sink input to another sink (args: index, sink)", 3},
 179     { "move-source-output",      pa_cli_command_move_source_output, "Move source output to another source (args: index, source)", 3},
 180     { "vacuum",                  pa_cli_command_vacuum,             NULL, 1},
 181     { "suspend-sink",            pa_cli_command_suspend_sink,       "Suspend sink (args: index|name, bool)", 3},
 182     { "suspend-source",          pa_cli_command_suspend_source,     "Suspend source (args: index|name, bool)", 3},
 183     { "suspend",                 pa_cli_command_suspend,            "Suspend all sinks and all sources (args: bool)", 2},
 184     { "set-card-profile",        pa_cli_command_card_profile,       "Change the profile of a card (args: index, name)", 3},
 185     { "set-sink-port",           pa_cli_command_sink_port,          "Change the port of a sink (args: index, name)", 3},
 186     { "set-source-port",         pa_cli_command_source_port,        "Change the port of a source (args: index, name)", 3},
 187     { "set-log-level",           pa_cli_command_log_level,          "Change the log level (args: numeric level)", 2},
 188     { "set-log-meta",            pa_cli_command_log_meta,           "Show source code location in log messages (args: bool)", 2},
 189     { "set-log-time",            pa_cli_command_log_time,           "Show timestamps in log messages (args: bool)", 2},
 190     { "set-log-backtrace",       pa_cli_command_log_backtrace,      "Show backtrace in log messages (args: frames)", 2},
 191     { "dump-volumes",            pa_cli_command_dump_volumes,       NULL, 1 },
 192     { NULL, NULL, NULL, 0 }
 193 };
 194
 195 static const char whitespace[] = " \t\n\r";
 196 static const char linebreak[] = "\n\r";
 197
 198 static uint32_t parse_index(const char *n) {
 199     uint32_t idx;
 200
 201     if (pa_atou(n, &idx) < 0)
 202         return (uint32_t) PA_IDXSET_INVALID;
 203
 204     return idx;
 205 }
 206
 207 static int pa_cli_command_exit(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 208     pa_core_assert_ref(c);
 209     pa_assert(t);
 210     pa_assert(buf);
 211     pa_assert(fail);
 212
 213     if (pa_core_exit(c, FALSE, 0) < 0)
 214         pa_strbuf_puts(buf, "Not allowed to terminate daemon.\n");
 215
 216     return 0;
 217 }
 218
 219 static int pa_cli_command_help(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 220     const struct command*command;
 221
 222     pa_core_assert_ref(c);
 223     pa_assert(t);
 224     pa_assert(buf);
 225     pa_assert(fail);
 226
 227     pa_strbuf_puts(buf, "Available commands:\n");
 228
 229     for (command = commands; command->name; command++)
 230         if (command->help)
 231             pa_strbuf_printf(buf, "    %-25s %s\n", command->name, command->help);
 232     return 0;
 233 }
 234
 235 static int pa_cli_command_modules(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 236     char *s;
 237
 238     pa_core_assert_ref(c);
 239     pa_assert(t);
 240     pa_assert(buf);
 241     pa_assert(fail);
 242
 243     pa_assert_se(s = pa_module_list_to_string(c));
 244     pa_strbuf_puts(buf, s);
 245     pa_xfree(s);
 246     return 0;
 247 }
 248
 249 static int pa_cli_command_clients(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 250     char *s;
 251
 252     pa_core_assert_ref(c);
 253     pa_assert(t);
 254     pa_assert(buf);
 255     pa_assert(fail);
 256
 257     pa_assert_se(s = pa_client_list_to_string(c));
 258     pa_strbuf_puts(buf, s);
 259     pa_xfree(s);
 260     return 0;
 261 }
 262
 263 static int pa_cli_command_cards(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 264     char *s;
 265
 266     pa_core_assert_ref(c);
 267     pa_assert(t);
 268     pa_assert(buf);
 269     pa_assert(fail);
 270
 271     pa_assert_se(s = pa_card_list_to_string(c));
 272     pa_strbuf_puts(buf, s);
 273     pa_xfree(s);
 274     return 0;
 275 }
 276
 277 static int pa_cli_command_sinks(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 278     char *s;
 279
 280     pa_core_assert_ref(c);
 281     pa_assert(t);
 282     pa_assert(buf);
 283     pa_assert(fail);
 284
 285     pa_assert_se(s = pa_sink_list_to_string(c));
 286     pa_strbuf_puts(buf, s);
 287     pa_xfree(s);
 288     return 0;
 289 }
 290
 291 static int pa_cli_command_sources(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 292     char *s;
 293
 294     pa_core_assert_ref(c);
 295     pa_assert(t);
 296     pa_assert(buf);
 297     pa_assert(fail);
 298
 299     pa_assert_se(s = pa_source_list_to_string(c));
 300     pa_strbuf_puts(buf, s);
 301     pa_xfree(s);
 302     return 0;
 303 }
 304
 305 static int pa_cli_command_sink_inputs(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 306     char *s;
 307
 308     pa_core_assert_ref(c);
 309     pa_assert(t);
 310     pa_assert(buf);
 311     pa_assert(fail);
 312
 313     pa_assert_se(s = pa_sink_input_list_to_string(c));
 314     pa_strbuf_puts(buf, s);
 315     pa_xfree(s);
 316     return 0;
 317 }
 318
 319 static int pa_cli_command_source_outputs(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 320     char *s;
 321
 322     pa_core_assert_ref(c);
 323     pa_assert(t);
 324     pa_assert(buf);
 325     pa_assert(fail);
 326
 327     pa_assert_se(s = pa_source_output_list_to_string(c));
 328     pa_strbuf_puts(buf, s);
 329     pa_xfree(s);
 330     return 0;
 331 }
 332
 333 static int pa_cli_command_stat(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 334     char ss[PA_SAMPLE_SPEC_SNPRINT_MAX];
 335     char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
 336     char bytes[PA_BYTES_SNPRINT_MAX];
 337     const pa_mempool_stat *mstat;
 338     unsigned k;
 339     pa_sink *def_sink;
 340     pa_source *def_source;
 341
 342     static const char* const type_table[PA_MEMBLOCK_TYPE_MAX] = {
 343         [PA_MEMBLOCK_POOL] = "POOL",
 344         [PA_MEMBLOCK_POOL_EXTERNAL] = "POOL_EXTERNAL",
 345         [PA_MEMBLOCK_APPENDED] = "APPENDED",
 346         [PA_MEMBLOCK_USER] = "USER",
 347         [PA_MEMBLOCK_FIXED] = "FIXED",
 348         [PA_MEMBLOCK_IMPORTED] = "IMPORTED",
 349     };
 350
 351     pa_core_assert_ref(c);
 352     pa_assert(t);
 353     pa_assert(buf);
 354     pa_assert(fail);
 355
 356     mstat = pa_mempool_get_stat(c->mempool);
 357
 358     pa_strbuf_printf(buf, "Memory blocks currently allocated: %u, size: %s.\n",
 359                      (unsigned) pa_atomic_load(&mstat->n_allocated),
 360                      pa_bytes_snprint(bytes, sizeof(bytes), (unsigned) pa_atomic_load(&mstat->allocated_size)));
 361
 362     pa_strbuf_printf(buf, "Memory blocks allocated during the whole lifetime: %u, size: %s.\n",
 363                      (unsigned) pa_atomic_load(&mstat->n_accumulated),
 364                      pa_bytes_snprint(bytes, sizeof(bytes), (unsigned) pa_atomic_load(&mstat->accumulated_size)));
 365
 366     pa_strbuf_printf(buf, "Memory blocks imported from other processes: %u, size: %s.\n",
 367                      (unsigned) pa_atomic_load(&mstat->n_imported),
 368                      pa_bytes_snprint(bytes, sizeof(bytes), (unsigned) pa_atomic_load(&mstat->imported_size)));
 369
 370     pa_strbuf_printf(buf, "Memory blocks exported to other processes: %u, size: %s.\n",
 371                      (unsigned) pa_atomic_load(&mstat->n_exported),
 372                      pa_bytes_snprint(bytes, sizeof(bytes), (unsigned) pa_atomic_load(&mstat->exported_size)));
 373
 374     pa_strbuf_printf(buf, "Total sample cache size: %s.\n",
 375                      pa_bytes_snprint(bytes, sizeof(bytes), (unsigned) pa_scache_total_size(c)));
 376
 377     pa_strbuf_printf(buf, "Default sample spec: %s\n",
 378                      pa_sample_spec_snprint(ss, sizeof(ss), &c->default_sample_spec));
 379
 380     pa_strbuf_printf(buf, "Default channel map: %s\n",
 381                      pa_channel_map_snprint(cm, sizeof(cm), &c->default_channel_map));
 382
 383     def_sink = pa_namereg_get_default_sink(c);
 384     def_source = pa_namereg_get_default_source(c);
 385     pa_strbuf_printf(buf, "Default sink name: %s\n"
 386                      "Default source name: %s\n",
 387                      def_sink ? def_sink->name : "none",
 388                      def_source ? def_source->name : "none");
 389
 390     for (k = 0; k < PA_MEMBLOCK_TYPE_MAX; k++)
 391         pa_strbuf_printf(buf,
 392                          "Memory blocks of type %s: %u allocated/%u accumulated.\n",
 393                          type_table[k],
 394                          (unsigned) pa_atomic_load(&mstat->n_allocated_by_type[k]),
 395                          (unsigned) pa_atomic_load(&mstat->n_accumulated_by_type[k]));
 396
 397     return 0;
 398 }
 399
 400 static int pa_cli_command_info(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 401     pa_core_assert_ref(c);
 402     pa_assert(t);
 403     pa_assert(buf);
 404     pa_assert(fail);
 405
 406     pa_cli_command_stat(c, t, buf, fail);
 407     pa_cli_command_modules(c, t, buf, fail);
 408     pa_cli_command_sinks(c, t, buf, fail);
 409     pa_cli_command_sources(c, t, buf, fail);
 410     pa_cli_command_clients(c, t, buf, fail);
 411     pa_cli_command_cards(c, t, buf, fail);
 412     pa_cli_command_sink_inputs(c, t, buf, fail);
 413     pa_cli_command_source_outputs(c, t, buf, fail);
 414     pa_cli_command_scache_list(c, t, buf, fail);
 415     return 0;
 416 }
 417
 418 static int pa_cli_command_load(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 419     const char *name;
 420
 421     pa_core_assert_ref(c);
 422     pa_assert(t);
 423     pa_assert(buf);
 424     pa_assert(fail);
 425
 426     if (!(name = pa_tokenizer_get(t, 1))) {
 427         pa_strbuf_puts(buf, "You need to specify the module name and optionally arguments.\n");
 428         return -1;
 429     }
 430
 431     if (!pa_module_load(c, name,  pa_tokenizer_get(t, 2))) {
 432         pa_strbuf_puts(buf, "Module load failed.\n");
 433         return -1;
 434     }
 435
 436     return 0;
 437 }
 438
 439 static int pa_cli_command_unload(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 440     pa_module *m;
 441     uint32_t idx;
 442     const char *i;
 443     char *e;
 444
 445     pa_core_assert_ref(c);
 446     pa_assert(t);
 447     pa_assert(buf);
 448     pa_assert(fail);
 449
 450     if (!(i = pa_tokenizer_get(t, 1))) {
 451         pa_strbuf_puts(buf, "You need to specify the module index.\n");
 452         return -1;
 453     }
 454
 455     idx = (uint32_t) strtoul(i, &e, 10);
 456     if (*e || !(m = pa_idxset_get_by_index(c->modules, idx))) {
 457         pa_strbuf_puts(buf, "Invalid module index.\n");
 458         return -1;
 459     }
 460
 461     pa_module_unload_request(m, FALSE);
 462     return 0;
 463 }
 464
 465 static int pa_cli_command_describe(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 466     const char *name;
 467     pa_modinfo *i;
 468
 469     pa_core_assert_ref(c);
 470     pa_assert(t);
 471     pa_assert(buf);
 472     pa_assert(fail);
 473
 474     if (!(name = pa_tokenizer_get(t, 1))) {
 475         pa_strbuf_puts(buf, "You need to specify the module name.\n");
 476         return -1;
 477     }
 478
 479     if ((i = pa_modinfo_get_by_name(name))) {
 480
 481         pa_strbuf_printf(buf, "Name: %s\n", name);
 482
 483         if (!i->description && !i->version && !i->author && !i->usage)
 484             pa_strbuf_printf(buf, "No module information available\n");
 485         else {
 486             if (i->version)
 487                 pa_strbuf_printf(buf, "Version: %s\n", i->version);
 488             if (i->description)
 489                 pa_strbuf_printf(buf, "Description: %s\n", i->description);
 490             if (i->author)
 491                 pa_strbuf_printf(buf, "Author: %s\n", i->author);
 492             if (i->usage)
 493                 pa_strbuf_printf(buf, "Usage: %s\n", i->usage);
 494             pa_strbuf_printf(buf, "Load Once: %s\n", pa_yes_no(i->load_once));
 495             if (i->deprecated)
 496                 pa_strbuf_printf(buf, "Warning, deprecated: %s\n", i->deprecated);
 497         }
 498
 499         pa_modinfo_free(i);
 500     } else
 501         pa_strbuf_puts(buf, "Failed to open module.\n");
 502
 503     return 0;
 504 }
 505
 506 static int pa_cli_command_sink_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 507     const char *n, *v;
 508     pa_sink *sink;
 509     uint32_t volume;
 510     pa_cvolume cvolume;
 511
 512     pa_core_assert_ref(c);
 513     pa_assert(t);
 514     pa_assert(buf);
 515     pa_assert(fail);
 516
 517     if (!(n = pa_tokenizer_get(t, 1))) {
 518         pa_strbuf_puts(buf, "You need to specify a sink either by its name or its index.\n");
 519         return -1;
 520     }
 521
 522     if (!(v = pa_tokenizer_get(t, 2))) {
 523         pa_strbuf_puts(buf, "You need to specify a volume >= 0. (0 is muted, 0x10000 is normal volume)\n");
 524         return -1;
 525     }
 526
 527     if (pa_atou(v, &volume) < 0) {
 528         pa_strbuf_puts(buf, "Failed to parse volume.\n");
 529         return -1;
 530     }
 531
 532     if (!PA_VOLUME_IS_VALID(volume)) {
 533         pa_strbuf_puts(buf, "Volume outside permissible range.\n");
 534         return -1;
 535     }
 536
 537     if (!(sink = pa_namereg_get(c, n, PA_NAMEREG_SINK))) {
 538         pa_strbuf_puts(buf, "No sink found by this name or index.\n");
 539         return -1;
 540     }
 541
 542     pa_cvolume_set(&cvolume, 1, volume);
 543     pa_sink_set_volume(sink, &cvolume, TRUE, TRUE);
 544     return 0;
 545 }
 546
 547 static int pa_cli_command_sink_input_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 548     const char *n, *v;
 549     pa_sink_input *si;
 550     pa_volume_t volume;
 551     pa_cvolume cvolume;
 552     uint32_t idx;
 553
 554     pa_core_assert_ref(c);
 555     pa_assert(t);
 556     pa_assert(buf);
 557     pa_assert(fail);
 558
 559     if (!(n = pa_tokenizer_get(t, 1))) {
 560         pa_strbuf_puts(buf, "You need to specify a sink input by its index.\n");
 561         return -1;
 562     }
 563
 564     if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
 565         pa_strbuf_puts(buf, "Failed to parse index.\n");
 566         return -1;
 567     }
 568
 569     if (!(v = pa_tokenizer_get(t, 2))) {
 570         pa_strbuf_puts(buf, "You need to specify a volume >= 0. (0 is muted, 0x10000 is normal volume)\n");
 571         return -1;
 572     }
 573
 574     if (pa_atou(v, &volume) < 0) {
 575         pa_strbuf_puts(buf, "Failed to parse volume.\n");
 576         return -1;
 577     }
 578
 579     if (!PA_VOLUME_IS_VALID(volume)) {
 580         pa_strbuf_puts(buf, "Volume outside permissible range.\n");
 581         return -1;
 582     }
 583
 584     if (!(si = pa_idxset_get_by_index(c->sink_inputs, idx))) {
 585         pa_strbuf_puts(buf, "No sink input found with this index.\n");
 586         return -1;
 587     }
 588
 589     if (!si->volume_writable) {
 590         pa_strbuf_puts(buf, "This sink input's volume can't be changed.\n");
 591         return -1;
 592     }
 593
 594     pa_cvolume_set(&cvolume, 1, volume);
 595     pa_sink_input_set_volume(si, &cvolume, TRUE, TRUE);
 596     return 0;
 597 }
 598
 599 static int pa_cli_command_source_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 600     const char *n, *v;
 601     pa_source *source;
 602     uint32_t volume;
 603     pa_cvolume cvolume;
 604
 605     pa_core_assert_ref(c);
 606     pa_assert(t);
 607     pa_assert(buf);
 608     pa_assert(fail);
 609
 610     if (!(n = pa_tokenizer_get(t, 1))) {
 611         pa_strbuf_puts(buf, "You need to specify a source either by its name or its index.\n");
 612         return -1;
 613     }
 614
 615     if (!(v = pa_tokenizer_get(t, 2))) {
 616         pa_strbuf_puts(buf, "You need to specify a volume >= 0. (0 is muted, 0x10000 is normal volume)\n");
 617         return -1;
 618     }
 619
 620     if (pa_atou(v, &volume) < 0) {
 621         pa_strbuf_puts(buf, "Failed to parse volume.\n");
 622         return -1;
 623     }
 624
 625     if (!PA_VOLUME_IS_VALID(volume)) {
 626         pa_strbuf_puts(buf, "Volume outside permissible range.\n");
 627         return -1;
 628     }
 629
 630     if (!(source = pa_namereg_get(c, n, PA_NAMEREG_SOURCE))) {
 631         pa_strbuf_puts(buf, "No source found by this name or index.\n");
 632         return -1;
 633     }
 634
 635     pa_cvolume_set(&cvolume, 1, volume);
 636     pa_source_set_volume(source, &cvolume, TRUE, TRUE);
 637     return 0;
 638 }
 639
 640 static int pa_cli_command_sink_mute(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 641     const char *n, *m;
 642     pa_sink *sink;
 643     int mute;
 644
 645     pa_core_assert_ref(c);
 646     pa_assert(t);
 647     pa_assert(buf);
 648     pa_assert(fail);
 649
 650     if (!(n = pa_tokenizer_get(t, 1))) {
 651         pa_strbuf_puts(buf, "You need to specify a sink either by its name or its index.\n");
 652         return -1;
 653     }
 654
 655     if (!(m = pa_tokenizer_get(t, 2))) {
 656         pa_strbuf_puts(buf, "You need to specify a mute switch setting (0/1).\n");
 657         return -1;
 658     }
 659
 660     if ((mute = pa_parse_boolean(m)) < 0) {
 661         pa_strbuf_puts(buf, "Failed to parse mute switch.\n");
 662         return -1;
 663     }
 664
 665     if (!(sink = pa_namereg_get(c, n, PA_NAMEREG_SINK))) {
 666         pa_strbuf_puts(buf, "No sink found by this name or index.\n");
 667         return -1;
 668     }
 669
 670     pa_sink_set_mute(sink, mute, TRUE);
 671     return 0;
 672 }
 673
 674 static int pa_cli_command_source_mute(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 675     const char *n, *m;
 676     pa_source *source;
 677     int mute;
 678
 679     pa_core_assert_ref(c);
 680     pa_assert(t);
 681     pa_assert(buf);
 682     pa_assert(fail);
 683
 684     if (!(n = pa_tokenizer_get(t, 1))) {
 685         pa_strbuf_puts(buf, "You need to specify a source either by its name or its index.\n");
 686         return -1;
 687     }
 688
 689     if (!(m = pa_tokenizer_get(t, 2))) {
 690         pa_strbuf_puts(buf, "You need to specify a mute switch setting (0/1).\n");
 691         return -1;
 692     }
 693
 694     if ((mute = pa_parse_boolean(m)) < 0) {
 695         pa_strbuf_puts(buf, "Failed to parse mute switch.\n");
 696         return -1;
 697     }
 698
 699     if (!(source = pa_namereg_get(c, n, PA_NAMEREG_SOURCE))) {
 700         pa_strbuf_puts(buf, "No sink found by this name or index.\n");
 701         return -1;
 702     }
 703
 704     pa_source_set_mute(source, mute, TRUE);
 705     return 0;
 706 }
 707
 708 static int pa_cli_command_update_sink_proplist(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 709     const char *n, *s;
 710     pa_sink *sink;
 711     pa_proplist *p;
 712
 713     pa_core_assert_ref(c);
 714     pa_assert(t);
 715     pa_assert(buf);
 716     pa_assert(fail);
 717
 718     if (!(n = pa_tokenizer_get(t, 1))) {
 719         pa_strbuf_puts(buf, "You need to specify a sink either by its name or its index.\n");
 720         return -1;
 721     }
 722
 723     if (!(s = pa_tokenizer_get(t, 2))) {
 724         pa_strbuf_puts(buf, "You need to specify a \"key=value\" argument.\n");
 725         return -1;
 726     }
 727
 728     if (!(sink = pa_namereg_get(c, n, PA_NAMEREG_SINK))) {
 729         pa_strbuf_puts(buf, "No sink found by this name or index.\n");
 730         return -1;
 731     }
 732
 733     if (!(p = pa_proplist_from_string(s))) {
 734         pa_strbuf_puts(buf, "Failed to parse proplist.\n");
 735         return -1;
 736     }
 737
 738     pa_sink_update_proplist(sink, PA_UPDATE_REPLACE, p);
 739
 740     pa_proplist_free(p);
 741
 742     return 0;
 743 }
 744
 745 static int pa_cli_command_update_source_proplist(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 746     const char *n, *s;
 747     pa_source *source;
 748     pa_proplist *p;
 749
 750     pa_core_assert_ref(c);
 751     pa_assert(t);
 752     pa_assert(buf);
 753     pa_assert(fail);
 754
 755     if (!(n = pa_tokenizer_get(t, 1))) {
 756         pa_strbuf_puts(buf, "You need to specify a source either by its name or its index.\n");
 757         return -1;
 758     }
 759
 760     if (!(s = pa_tokenizer_get(t, 2))) {
 761         pa_strbuf_puts(buf, "You need to specify a \"key=value\" argument.\n");
 762         return -1;
 763     }
 764
 765     if (!(source = pa_namereg_get(c, n, PA_NAMEREG_SOURCE))) {
 766         pa_strbuf_puts(buf, "No source found by this name or index.\n");
 767         return -1;
 768     }
 769
 770     if (!(p = pa_proplist_from_string(s))) {
 771         pa_strbuf_puts(buf, "Failed to parse proplist.\n");
 772         return -1;
 773     }
 774
 775     pa_source_update_proplist(source, PA_UPDATE_REPLACE, p);
 776
 777     pa_proplist_free(p);
 778
 779     return 0;
 780 }
 781
 782 static int pa_cli_command_update_sink_input_proplist(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 783     const char *n, *s;
 784     pa_sink_input *si;
 785     uint32_t idx;
 786     pa_proplist *p;
 787
 788     pa_core_assert_ref(c);
 789     pa_assert(t);
 790     pa_assert(buf);
 791     pa_assert(fail);
 792
 793     if (!(n = pa_tokenizer_get(t, 1))) {
 794         pa_strbuf_puts(buf, "You need to specify a sink input either by index.\n");
 795         return -1;
 796     }
 797
 798     if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
 799         pa_strbuf_puts(buf, "Failed to parse index.\n");
 800         return -1;
 801     }
 802
 803     if (!(s = pa_tokenizer_get(t, 2))) {
 804         pa_strbuf_puts(buf, "You need to specify a \"key=value\" argument.\n");
 805         return -1;
 806     }
 807
 808     if (!(si = pa_idxset_get_by_index(c->sink_inputs, (uint32_t) idx))) {
 809         pa_strbuf_puts(buf, "No sink input found with this index.\n");
 810         return -1;
 811     }
 812
 813     if (!(p = pa_proplist_from_string(s))) {
 814         pa_strbuf_puts(buf, "Failed to parse proplist.\n");
 815         return -1;
 816     }
 817
 818     pa_sink_input_update_proplist(si, PA_UPDATE_REPLACE, p);
 819
 820     pa_proplist_free(p);
 821
 822     return 0;
 823 }
 824
 825 static int pa_cli_command_update_source_output_proplist(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 826     const char *n, *s;
 827     pa_source_output *so;
 828     uint32_t idx;
 829     pa_proplist *p;
 830
 831     pa_core_assert_ref(c);
 832     pa_assert(t);
 833     pa_assert(buf);
 834     pa_assert(fail);
 835
 836     if (!(n = pa_tokenizer_get(t, 1))) {
 837         pa_strbuf_puts(buf, "You need to specify a source output by its index.\n");
 838         return -1;
 839     }
 840
 841     if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
 842         pa_strbuf_puts(buf, "Failed to parse index.\n");
 843         return -1;
 844     }
 845
 846     if (!(s = pa_tokenizer_get(t, 2))) {
 847         pa_strbuf_puts(buf, "You need to specify a \"key=value\" argument.\n");
 848         return -1;
 849     }
 850
 851     if (!(so = pa_idxset_get_by_index(c->source_outputs, (uint32_t) idx))) {
 852         pa_strbuf_puts(buf, "No source output found with this index.\n");
 853         return -1;
 854     }
 855
 856     if (!(p = pa_proplist_from_string(s))) {
 857         pa_strbuf_puts(buf, "Failed to parse proplist.\n");
 858         return -1;
 859     }
 860
 861     pa_source_output_update_proplist(so, PA_UPDATE_REPLACE, p);
 862
 863     pa_proplist_free(p);
 864
 865     return 0;
 866 }
 867
 868 static int pa_cli_command_sink_input_mute(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 869     const char *n, *v;
 870     pa_sink_input *si;
 871     uint32_t idx;
 872     int mute;
 873
 874     pa_core_assert_ref(c);
 875     pa_assert(t);
 876     pa_assert(buf);
 877     pa_assert(fail);
 878
 879     if (!(n = pa_tokenizer_get(t, 1))) {
 880         pa_strbuf_puts(buf, "You need to specify a sink input by its index.\n");
 881         return -1;
 882     }
 883
 884     if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
 885         pa_strbuf_puts(buf, "Failed to parse index.\n");
 886         return -1;
 887     }
 888
 889     if (!(v = pa_tokenizer_get(t, 2))) {
 890         pa_strbuf_puts(buf, "You need to specify a mute switch setting (0/1).\n");
 891         return -1;
 892     }
 893
 894     if ((mute = pa_parse_boolean(v)) < 0) {
 895         pa_strbuf_puts(buf, "Failed to parse mute switch.\n");
 896         return -1;
 897     }
 898
 899     if (!(si = pa_idxset_get_by_index(c->sink_inputs, (uint32_t) idx))) {
 900         pa_strbuf_puts(buf, "No sink input found with this index.\n");
 901         return -1;
 902     }
 903
 904     pa_sink_input_set_mute(si, mute, TRUE);
 905     return 0;
 906 }
 907
 908 static int pa_cli_command_sink_default(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 909     const char *n;
 910     pa_sink *s;
 911
 912     pa_core_assert_ref(c);
 913     pa_assert(t);
 914     pa_assert(buf);
 915     pa_assert(fail);
 916
 917     if (!(n = pa_tokenizer_get(t, 1))) {
 918         pa_strbuf_puts(buf, "You need to specify a sink either by its name or its index.\n");
 919         return -1;
 920     }
 921
 922     if ((s = pa_namereg_get(c, n, PA_NAMEREG_SINK)))
 923         pa_namereg_set_default_sink(c, s);
 924     else
 925         pa_strbuf_printf(buf, "Sink %s does not exist.\n", n);
 926
 927     return 0;
 928 }
 929
 930 static int pa_cli_command_source_default(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 931     const char *n;
 932     pa_source *s;
 933
 934     pa_core_assert_ref(c);
 935     pa_assert(t);
 936     pa_assert(buf);
 937     pa_assert(fail);
 938
 939     if (!(n = pa_tokenizer_get(t, 1))) {
 940         pa_strbuf_puts(buf, "You need to specify a source either by its name or its index.\n");
 941         return -1;
 942     }
 943
 944     if ((s = pa_namereg_get(c, n, PA_NAMEREG_SOURCE)))
 945         pa_namereg_set_default_source(c, s);
 946     else
 947         pa_strbuf_printf(buf, "Source %s does not exist.\n", n);
 948     return 0;
 949 }
 950
 951 static int pa_cli_command_kill_client(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 952     const char *n;
 953     pa_client *client;
 954     uint32_t idx;
 955
 956     pa_core_assert_ref(c);
 957     pa_assert(t);
 958     pa_assert(buf);
 959     pa_assert(fail);
 960
 961     if (!(n = pa_tokenizer_get(t, 1))) {
 962         pa_strbuf_puts(buf, "You need to specify a client by its index.\n");
 963         return -1;
 964     }
 965
 966     if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
 967         pa_strbuf_puts(buf, "Failed to parse index.\n");
 968         return -1;
 969     }
 970
 971     if (!(client = pa_idxset_get_by_index(c->clients, idx))) {
 972         pa_strbuf_puts(buf, "No client found by this index.\n");
 973         return -1;
 974     }
 975
 976     pa_client_kill(client);
 977     return 0;
 978 }
 979
 980 static int pa_cli_command_kill_sink_input(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
 981     const char *n;
 982     pa_sink_input *sink_input;
 983     uint32_t idx;
 984
 985     pa_core_assert_ref(c);
 986     pa_assert(t);
 987     pa_assert(buf);
 988     pa_assert(fail);
 989
 990     if (!(n = pa_tokenizer_get(t, 1))) {
 991         pa_strbuf_puts(buf, "You need to specify a sink input by its index.\n");
 992         return -1;
 993     }
 994
 995     if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
 996         pa_strbuf_puts(buf, "Failed to parse index.\n");
 997         return -1;
 998     }
 999
1000     if (!(sink_input = pa_idxset_get_by_index(c->sink_inputs, idx))) {
1001         pa_strbuf_puts(buf, "No sink input found by this index.\n");
1002         return -1;
1003     }
1004
1005     pa_sink_input_kill(sink_input);
1006     return 0;
1007 }
1008
1009 static int pa_cli_command_kill_source_output(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1010     const char *n;
1011     pa_source_output *source_output;
1012     uint32_t idx;
1013
1014     pa_core_assert_ref(c);
1015     pa_assert(t);
1016     pa_assert(buf);
1017     pa_assert(fail);
1018
1019     if (!(n = pa_tokenizer_get(t, 1))) {
1020         pa_strbuf_puts(buf, "You need to specify a source output by its index.\n");
1021         return -1;
1022     }
1023
1024     if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
1025         pa_strbuf_puts(buf, "Failed to parse index.\n");
1026         return -1;
1027     }
1028
1029     if (!(source_output = pa_idxset_get_by_index(c->source_outputs, idx))) {
1030         pa_strbuf_puts(buf, "No source output found by this index.\n");
1031         return -1;
1032     }
1033
1034     pa_source_output_kill(source_output);
1035     return 0;
1036 }
1037
1038 static int pa_cli_command_scache_list(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1039     char *s;
1040
1041     pa_core_assert_ref(c);
1042     pa_assert(t);
1043     pa_assert(buf);
1044     pa_assert(fail);
1045
1046     pa_assert_se(s = pa_scache_list_to_string(c));
1047     pa_strbuf_puts(buf, s);
1048     pa_xfree(s);
1049
1050     return 0;
1051 }
1052
1053 static int pa_cli_command_scache_play(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1054     const char *n, *sink_name;
1055     pa_sink *sink;
1056     uint32_t idx;
1057
1058     pa_core_assert_ref(c);
1059     pa_assert(t);
1060     pa_assert(buf);
1061     pa_assert(fail);
1062
1063     if (!(n = pa_tokenizer_get(t, 1)) || !(sink_name = pa_tokenizer_get(t, 2))) {
1064         pa_strbuf_puts(buf, "You need to specify a sample name and a sink name.\n");
1065         return -1;
1066     }
1067
1068     if (!(sink = pa_namereg_get(c, sink_name, PA_NAMEREG_SINK))) {
1069         pa_strbuf_puts(buf, "No sink by that name.\n");
1070         return -1;
1071     }
1072
1073     if (pa_scache_play_item(c, n, sink, PA_VOLUME_NORM, NULL, &idx) < 0) {
1074         pa_strbuf_puts(buf, "Failed to play sample.\n");
1075         return -1;
1076     }
1077
1078     pa_strbuf_printf(buf, "Playing on sink input #%i\n", idx);
1079
1080     return 0;
1081 }
1082
1083 static int pa_cli_command_scache_remove(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1084     const char *n;
1085
1086     pa_core_assert_ref(c);
1087     pa_assert(t);
1088     pa_assert(buf);
1089     pa_assert(fail);
1090
1091     if (!(n = pa_tokenizer_get(t, 1))) {
1092         pa_strbuf_puts(buf, "You need to specify a sample name.\n");
1093         return -1;
1094     }
1095
1096     if (pa_scache_remove_item(c, n) < 0) {
1097         pa_strbuf_puts(buf, "Failed to remove sample.\n");
1098         return -1;
1099     }
1100
1101     return 0;
1102 }
1103
1104 static int pa_cli_command_scache_load(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1105     const char *fname, *n;
1106     int r;
1107
1108     pa_core_assert_ref(c);
1109     pa_assert(t);
1110     pa_assert(buf);
1111     pa_assert(fail);
1112
1113     if (!(fname = pa_tokenizer_get(t, 2)) || !(n = pa_tokenizer_get(t, 1))) {
1114         pa_strbuf_puts(buf, "You need to specify a file name and a sample name.\n");
1115         return -1;
1116     }
1117
1118     if (strstr(pa_tokenizer_get(t, 0), "lazy"))
1119         r = pa_scache_add_file_lazy(c, n, fname, NULL);
1120     else
1121         r = pa_scache_add_file(c, n, fname, NULL);
1122
1123     if (r < 0)
1124         pa_strbuf_puts(buf, "Failed to load sound file.\n");
1125
1126     return 0;
1127 }
1128
1129 static int pa_cli_command_scache_load_dir(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1130     const char *pname;
1131
1132     pa_core_assert_ref(c);
1133     pa_assert(t);
1134     pa_assert(buf);
1135     pa_assert(fail);
1136
1137     if (!(pname = pa_tokenizer_get(t, 1))) {
1138         pa_strbuf_puts(buf, "You need to specify a path name.\n");
1139         return -1;
1140     }
1141
1142     if (pa_scache_add_directory_lazy(c, pname) < 0) {
1143         pa_strbuf_puts(buf, "Failed to load directory.\n");
1144         return -1;
1145     }
1146
1147     return 0;
1148 }
1149
1150 static int pa_cli_command_play_file(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1151     const char *fname, *sink_name;
1152     pa_sink *sink;
1153
1154     pa_core_assert_ref(c);
1155     pa_assert(t);
1156     pa_assert(buf);
1157     pa_assert(fail);
1158
1159     if (!(fname = pa_tokenizer_get(t, 1)) || !(sink_name = pa_tokenizer_get(t, 2))) {
1160         pa_strbuf_puts(buf, "You need to specify a file name and a sink name.\n");
1161         return -1;
1162     }
1163
1164     if (!(sink = pa_namereg_get(c, sink_name, PA_NAMEREG_SINK))) {
1165         pa_strbuf_puts(buf, "No sink by that name.\n");
1166         return -1;
1167     }
1168
1169
1170     return pa_play_file(sink, fname, NULL);
1171 }
1172
1173 static int pa_cli_command_list_shared_props(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1174     pa_core_assert_ref(c);
1175     pa_assert(t);
1176     pa_assert(buf);
1177     pa_assert(fail);
1178
1179     pa_shared_dump(c, buf);
1180     return 0;
1181 }
1182
1183 static int pa_cli_command_vacuum(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1184     pa_core_assert_ref(c);
1185     pa_assert(t);
1186     pa_assert(buf);
1187     pa_assert(fail);
1188
1189     pa_mempool_vacuum(c->mempool);
1190
1191     return 0;
1192 }
1193
1194 static int pa_cli_command_move_sink_input(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1195     const char *n, *k;
1196     pa_sink_input *si;
1197     pa_sink *sink;
1198     uint32_t idx;
1199
1200     pa_core_assert_ref(c);
1201     pa_assert(t);
1202     pa_assert(buf);
1203     pa_assert(fail);
1204
1205     if (!(n = pa_tokenizer_get(t, 1))) {
1206         pa_strbuf_puts(buf, "You need to specify a sink input by its index.\n");
1207         return -1;
1208     }
1209
1210     if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
1211         pa_strbuf_puts(buf, "Failed to parse index.\n");
1212         return -1;
1213     }
1214
1215     if (!(k = pa_tokenizer_get(t, 2))) {
1216         pa_strbuf_puts(buf, "You need to specify a sink.\n");
1217         return -1;
1218     }
1219
1220     if (!(si = pa_idxset_get_by_index(c->sink_inputs, (uint32_t) idx))) {
1221         pa_strbuf_puts(buf, "No sink input found with this index.\n");
1222         return -1;
1223     }
1224
1225     if (!(sink = pa_namereg_get(c, k, PA_NAMEREG_SINK))) {
1226         pa_strbuf_puts(buf, "No sink found by this name or index.\n");
1227         return -1;
1228     }
1229
1230     if (pa_sink_input_move_to(si, sink, TRUE) < 0) {
1231         pa_strbuf_puts(buf, "Moved failed.\n");
1232         return -1;
1233     }
1234     return 0;
1235 }
1236
1237 static int pa_cli_command_move_source_output(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1238     const char *n, *k;
1239     pa_source_output *so;
1240     pa_source *source;
1241     uint32_t idx;
1242
1243     pa_core_assert_ref(c);
1244     pa_assert(t);
1245     pa_assert(buf);
1246     pa_assert(fail);
1247
1248     if (!(n = pa_tokenizer_get(t, 1))) {
1249         pa_strbuf_puts(buf, "You need to specify a source output by its index.\n");
1250         return -1;
1251     }
1252
1253     if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
1254         pa_strbuf_puts(buf, "Failed to parse index.\n");
1255         return -1;
1256     }
1257
1258     if (!(k = pa_tokenizer_get(t, 2))) {
1259         pa_strbuf_puts(buf, "You need to specify a source.\n");
1260         return -1;
1261     }
1262
1263     if (!(so = pa_idxset_get_by_index(c->source_outputs, (uint32_t) idx))) {
1264         pa_strbuf_puts(buf, "No source output found with this index.\n");
1265         return -1;
1266     }
1267
1268     if (!(source = pa_namereg_get(c, k, PA_NAMEREG_SOURCE))) {
1269         pa_strbuf_puts(buf, "No source found by this name or index.\n");
1270         return -1;
1271     }
1272
1273     if (pa_source_output_move_to(so, source, TRUE) < 0) {
1274         pa_strbuf_puts(buf, "Moved failed.\n");
1275         return -1;
1276     }
1277     return 0;
1278 }
1279
1280 static int pa_cli_command_suspend_sink(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1281     const char *n, *m;
1282     pa_sink *sink;
1283     int suspend, r;
1284
1285     pa_core_assert_ref(c);
1286     pa_assert(t);
1287     pa_assert(buf);
1288     pa_assert(fail);
1289
1290     if (!(n = pa_tokenizer_get(t, 1))) {
1291         pa_strbuf_puts(buf, "You need to specify a sink either by its name or its index.\n");
1292         return -1;
1293     }
1294
1295     if (!(m = pa_tokenizer_get(t, 2))) {
1296         pa_strbuf_puts(buf, "You need to specify a suspend switch setting (0/1).\n");
1297         return -1;
1298     }
1299
1300     if ((suspend = pa_parse_boolean(m)) < 0) {
1301         pa_strbuf_puts(buf, "Failed to parse suspend switch.\n");
1302         return -1;
1303     }
1304
1305     if (!(sink = pa_namereg_get(c, n, PA_NAMEREG_SINK))) {
1306         pa_strbuf_puts(buf, "No sink found by this name or index.\n");
1307         return -1;
1308     }
1309
1310     if ((r = pa_sink_suspend(sink, suspend, PA_SUSPEND_USER)) < 0)
1311         pa_strbuf_printf(buf, "Failed to resume/suspend sink: %s\n", pa_strerror(r));
1312
1313     return 0;
1314 }
1315
1316 static int pa_cli_command_suspend_source(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1317     const char *n, *m;
1318     pa_source *source;
1319     int suspend, r;
1320
1321     pa_core_assert_ref(c);
1322     pa_assert(t);
1323     pa_assert(buf);
1324     pa_assert(fail);
1325
1326     if (!(n = pa_tokenizer_get(t, 1))) {
1327         pa_strbuf_puts(buf, "You need to specify a source either by its name or its index.\n");
1328         return -1;
1329     }
1330
1331     if (!(m = pa_tokenizer_get(t, 2))) {
1332         pa_strbuf_puts(buf, "You need to specify a suspend switch setting (0/1).\n");
1333         return -1;
1334     }
1335
1336     if ((suspend = pa_parse_boolean(m)) < 0) {
1337         pa_strbuf_puts(buf, "Failed to parse suspend switch.\n");
1338         return -1;
1339     }
1340
1341     if (!(source = pa_namereg_get(c, n, PA_NAMEREG_SOURCE))) {
1342         pa_strbuf_puts(buf, "No source found by this name or index.\n");
1343         return -1;
1344     }
1345
1346     if ((r = pa_source_suspend(source, suspend, PA_SUSPEND_USER)) < 0)
1347         pa_strbuf_printf(buf, "Failed to resume/suspend source: %s\n", pa_strerror(r));
1348
1349     return 0;
1350 }
1351
1352 static int pa_cli_command_suspend(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1353     const char *m;
1354     int suspend, r;
1355
1356     pa_core_assert_ref(c);
1357     pa_assert(t);
1358     pa_assert(buf);
1359     pa_assert(fail);
1360
1361     if (!(m = pa_tokenizer_get(t, 1))) {
1362         pa_strbuf_puts(buf, "You need to specify a suspend switch setting (0/1).\n");
1363         return -1;
1364     }
1365
1366     if ((suspend = pa_parse_boolean(m)) < 0) {
1367         pa_strbuf_puts(buf, "Failed to parse suspend switch.\n");
1368         return -1;
1369     }
1370
1371     if ((r = pa_sink_suspend_all(c, suspend, PA_SUSPEND_USER)) < 0)
1372         pa_strbuf_printf(buf, "Failed to resume/suspend all sinks: %s\n", pa_strerror(r));
1373
1374     if ((r = pa_source_suspend_all(c, suspend, PA_SUSPEND_USER)) < 0)
1375         pa_strbuf_printf(buf, "Failed to resume/suspend all sources: %s\n", pa_strerror(r));
1376
1377     return 0;
1378 }
1379
1380 static int pa_cli_command_log_level(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1381     const char *m;
1382     uint32_t level;
1383
1384     pa_core_assert_ref(c);
1385     pa_assert(t);
1386     pa_assert(buf);
1387     pa_assert(fail);
1388
1389     if (!(m = pa_tokenizer_get(t, 1))) {
1390         pa_strbuf_puts(buf, "You need to specify a log level (0..4).\n");
1391         return -1;
1392     }
1393
1394     if (pa_atou(m, &level) < 0 || level >= PA_LOG_LEVEL_MAX) {
1395         pa_strbuf_puts(buf, "Failed to parse log level.\n");
1396         return -1;
1397     }
1398
1399     pa_log_set_level(level);
1400
1401     return 0;
1402 }
1403
1404 static int pa_cli_command_log_meta(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1405     const char *m;
1406     pa_bool_t b;
1407
1408     pa_core_assert_ref(c);
1409     pa_assert(t);
1410     pa_assert(buf);
1411     pa_assert(fail);
1412
1413     if (!(m = pa_tokenizer_get(t, 1))) {
1414         pa_strbuf_puts(buf, "You need to specify a boolean.\n");
1415         return -1;
1416     }
1417
1418     if ((b = pa_parse_boolean(m)) < 0) {
1419         pa_strbuf_puts(buf, "Failed to parse log meta switch.\n");
1420         return -1;
1421     }
1422
1423     pa_log_set_flags(PA_LOG_PRINT_META, b ? PA_LOG_SET : PA_LOG_UNSET);
1424
1425     return 0;
1426 }
1427
1428 static int pa_cli_command_log_time(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1429     const char *m;
1430     pa_bool_t b;
1431
1432     pa_core_assert_ref(c);
1433     pa_assert(t);
1434     pa_assert(buf);
1435     pa_assert(fail);
1436
1437     if (!(m = pa_tokenizer_get(t, 1))) {
1438         pa_strbuf_puts(buf, "You need to specify a boolean.\n");
1439         return -1;
1440     }
1441
1442     if ((b = pa_parse_boolean(m)) < 0) {
1443         pa_strbuf_puts(buf, "Failed to parse log meta switch.\n");
1444         return -1;
1445     }
1446
1447     pa_log_set_flags(PA_LOG_PRINT_TIME, b ? PA_LOG_SET : PA_LOG_UNSET);
1448
1449     return 0;
1450 }
1451
1452 static int pa_cli_command_log_backtrace(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1453     const char *m;
1454     uint32_t nframes;
1455
1456     pa_core_assert_ref(c);
1457     pa_assert(t);
1458     pa_assert(buf);
1459     pa_assert(fail);
1460
1461     if (!(m = pa_tokenizer_get(t, 1))) {
1462         pa_strbuf_puts(buf, "You need to specify a backtrace level.\n");
1463         return -1;
1464     }
1465
1466     if (pa_atou(m, &nframes) < 0 || nframes >= 1000) {
1467         pa_strbuf_puts(buf, "Failed to parse backtrace level.\n");
1468         return -1;
1469     }
1470
1471     pa_log_set_show_backtrace(nframes);
1472
1473     return 0;
1474 }
1475
1476 static int pa_cli_command_card_profile(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1477     const char *n, *p;
1478     pa_card *card;
1479
1480     pa_core_assert_ref(c);
1481     pa_assert(t);
1482     pa_assert(buf);
1483     pa_assert(fail);
1484
1485     if (!(n = pa_tokenizer_get(t, 1))) {
1486         pa_strbuf_puts(buf, "You need to specify a card either by its name or its index.\n");
1487         return -1;
1488     }
1489
1490     if (!(p = pa_tokenizer_get(t, 2))) {
1491         pa_strbuf_puts(buf, "You need to specify a profile by its name.\n");
1492         return -1;
1493     }
1494
1495     if (!(card = pa_namereg_get(c, n, PA_NAMEREG_CARD))) {
1496         pa_strbuf_puts(buf, "No card found by this name or index.\n");
1497         return -1;
1498     }
1499
1500     if (pa_card_set_profile(card, p, TRUE) < 0) {
1501         pa_strbuf_printf(buf, "Failed to set card profile to '%s'.\n", p);
1502         return -1;
1503     }
1504
1505     return 0;
1506 }
1507
1508 static int pa_cli_command_sink_port(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1509     const char *n, *p;
1510     pa_sink *sink;
1511
1512     pa_core_assert_ref(c);
1513     pa_assert(t);
1514     pa_assert(buf);
1515     pa_assert(fail);
1516
1517     if (!(n = pa_tokenizer_get(t, 1))) {
1518         pa_strbuf_puts(buf, "You need to specify a sink either by its name or its index.\n");
1519         return -1;
1520     }
1521
1522     if (!(p = pa_tokenizer_get(t, 2))) {
1523         pa_strbuf_puts(buf, "You need to specify a profile by its name.\n");
1524         return -1;
1525     }
1526
1527     if (!(sink = pa_namereg_get(c, n, PA_NAMEREG_SINK))) {
1528         pa_strbuf_puts(buf, "No sink found by this name or index.\n");
1529         return -1;
1530     }
1531
1532     if (pa_sink_set_port(sink, p, TRUE) < 0) {
1533         pa_strbuf_printf(buf, "Failed to set sink port to '%s'.\n", p);
1534         return -1;
1535     }
1536
1537     return 0;
1538 }
1539
1540 static int pa_cli_command_source_port(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1541     const char *n, *p;
1542     pa_source *source;
1543
1544     pa_core_assert_ref(c);
1545     pa_assert(t);
1546     pa_assert(buf);
1547     pa_assert(fail);
1548
1549     if (!(n = pa_tokenizer_get(t, 1))) {
1550         pa_strbuf_puts(buf, "You need to specify a source either by its name or its index.\n");
1551         return -1;
1552     }
1553
1554     if (!(p = pa_tokenizer_get(t, 2))) {
1555         pa_strbuf_puts(buf, "You need to specify a profile by its name.\n");
1556         return -1;
1557     }
1558
1559     if (!(source = pa_namereg_get(c, n, PA_NAMEREG_SOURCE))) {
1560         pa_strbuf_puts(buf, "No source found by this name or index.\n");
1561         return -1;
1562     }
1563
1564     if (pa_source_set_port(source, p, TRUE) < 0) {
1565         pa_strbuf_printf(buf, "Failed to set source port to '%s'.\n", p);
1566         return -1;
1567     }
1568
1569     return 0;
1570 }
1571
1572 static int pa_cli_command_dump(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1573     pa_module *m;
1574     pa_sink *sink;
1575     pa_source *source;
1576     pa_card *card;
1577     pa_bool_t nl;
1578     uint32_t idx;
1579     time_t now;
1580 #ifdef HAVE_CTIME_R
1581     char txt[256];
1582 #endif
1583
1584     pa_core_assert_ref(c);
1585     pa_assert(t);
1586     pa_assert(buf);
1587     pa_assert(fail);
1588
1589     time(&now);
1590
1591 #ifdef HAVE_CTIME_R
1592     pa_strbuf_printf(buf, "### Configuration dump generated at %s\n", ctime_r(&now, txt));
1593 #else
1594     pa_strbuf_printf(buf, "### Configuration dump generated at %s\n", ctime(&now));
1595 #endif
1596
1597     PA_IDXSET_FOREACH(m, c->modules, idx) {
1598
1599         pa_strbuf_printf(buf, "load-module %s", m->name);
1600
1601         if (m->argument)
1602             pa_strbuf_printf(buf, " %s", m->argument);
1603
1604         pa_strbuf_puts(buf, "\n");
1605     }
1606
1607     nl = FALSE;
1608     PA_IDXSET_FOREACH(sink, c->sinks, idx) {
1609
1610         if (!nl) {
1611             pa_strbuf_puts(buf, "\n");
1612             nl = TRUE;
1613         }
1614
1615         pa_strbuf_printf(buf, "set-sink-volume %s 0x%03x\n", sink->name, pa_cvolume_max(pa_sink_get_volume(sink, FALSE)));
1616         pa_strbuf_printf(buf, "set-sink-mute %s %s\n", sink->name, pa_yes_no(pa_sink_get_mute(sink, FALSE)));
1617         pa_strbuf_printf(buf, "suspend-sink %s %s\n", sink->name, pa_yes_no(pa_sink_get_state(sink) == PA_SINK_SUSPENDED));
1618     }
1619
1620     nl = FALSE;
1621     PA_IDXSET_FOREACH(source, c->sources, idx) {
1622
1623         if (!nl) {
1624             pa_strbuf_puts(buf, "\n");
1625             nl = TRUE;
1626         }
1627
1628         pa_strbuf_printf(buf, "set-source-volume %s 0x%03x\n", source->name, pa_cvolume_max(pa_source_get_volume(source, FALSE)));
1629         pa_strbuf_printf(buf, "set-source-mute %s %s\n", source->name, pa_yes_no(pa_source_get_mute(source, FALSE)));
1630         pa_strbuf_printf(buf, "suspend-source %s %s\n", source->name, pa_yes_no(pa_source_get_state(source) == PA_SOURCE_SUSPENDED));
1631     }
1632
1633     nl = FALSE;
1634     PA_IDXSET_FOREACH(card, c->cards, idx) {
1635
1636         if (!nl) {
1637             pa_strbuf_puts(buf, "\n");
1638             nl = TRUE;
1639         }
1640
1641         if (card->active_profile)
1642             pa_strbuf_printf(buf, "set-card-profile %s %s\n", card->name, card->active_profile->name);
1643     }
1644
1645     nl = FALSE;
1646     if ((sink = pa_namereg_get_default_sink(c))) {
1647         if (!nl) {
1648             pa_strbuf_puts(buf, "\n");
1649             nl = TRUE;
1650         }
1651
1652         pa_strbuf_printf(buf, "set-default-sink %s\n", sink->name);
1653     }
1654
1655     if ((source = pa_namereg_get_default_source(c))) {
1656         if (!nl)
1657             pa_strbuf_puts(buf, "\n");
1658
1659         pa_strbuf_printf(buf, "set-default-source %s\n", source->name);
1660     }
1661
1662     pa_strbuf_puts(buf, "\n### EOF\n");
1663
1664     return 0;
1665 }
1666
1667 static int pa_cli_command_dump_volumes(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) {
1668     pa_sink *s;
1669     pa_source *so;
1670     pa_sink_input *i;
1671     pa_source_output *o;
1672     uint32_t s_idx, i_idx;
1673     char v_str[PA_CVOLUME_SNPRINT_MAX];
1674
1675     pa_core_assert_ref(c);
1676     pa_assert(t);
1677     pa_assert(buf);
1678     pa_assert(fail);
1679
1680     PA_IDXSET_FOREACH(s, c->sinks, s_idx) {
1681         pa_strbuf_printf(buf, "Sink %d: ", s_idx);
1682         pa_strbuf_printf(buf, "reference = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &s->reference_volume));
1683         pa_strbuf_printf(buf, "real = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &s->real_volume));
1684         pa_strbuf_printf(buf, "soft = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &s->soft_volume));
1685         pa_strbuf_printf(buf, "current_hw = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &s->thread_info.current_hw_volume));
1686         pa_strbuf_printf(buf, "save = %s\n", pa_yes_no(s->save_volume));
1687
1688         PA_IDXSET_FOREACH(i, s->inputs, i_idx) {
1689             pa_strbuf_printf(buf, "\tInput %d: ", i_idx);
1690             pa_strbuf_printf(buf, "volume = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &i->volume));
1691             pa_strbuf_printf(buf, "reference_ratio = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &i->reference_ratio));
1692             pa_strbuf_printf(buf, "real_ratio = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &i->real_ratio));
1693             pa_strbuf_printf(buf, "soft = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &i->soft_volume));
1694             pa_strbuf_printf(buf, "volume_factor = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &i->volume_factor));
1695             pa_strbuf_printf(buf, "volume_factor_sink = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &i->volume_factor_sink));
1696             pa_strbuf_printf(buf, "save = %s\n", pa_yes_no(i->save_volume));
1697         }
1698     }
1699
1700     PA_IDXSET_FOREACH(so, c->sources, s_idx) {
1701         pa_strbuf_printf(buf, "Source %d: ", s_idx);
1702         pa_strbuf_printf(buf, "reference = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &so->reference_volume));
1703         pa_strbuf_printf(buf, "real = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &so->real_volume));
1704         pa_strbuf_printf(buf, "soft = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &so->soft_volume));
1705         pa_strbuf_printf(buf, "current_hw = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &so->thread_info.current_hw_volume));
1706         pa_strbuf_printf(buf, "save = %s\n", pa_yes_no(so->save_volume));
1707
1708         PA_IDXSET_FOREACH(o, so->outputs, i_idx) {
1709             pa_strbuf_printf(buf, "\tOutput %d: ", i_idx);
1710             pa_strbuf_printf(buf, "volume = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &o->volume));
1711             pa_strbuf_printf(buf, "reference_ratio = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &o->reference_ratio));
1712             pa_strbuf_printf(buf, "real_ratio = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &o->real_ratio));
1713             pa_strbuf_printf(buf, "soft = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &o->soft_volume));
1714             pa_strbuf_printf(buf, "volume_factor = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &o->volume_factor));
1715             pa_strbuf_printf(buf, "volume_factor_source = %s, ", pa_cvolume_snprint(v_str, sizeof(v_str), &o->volume_factor_source));
1716             pa_strbuf_printf(buf, "save = %s\n", pa_yes_no(o->save_volume));
1717         }
1718     }
1719
1720     return 0;
1721 }
1722
1723 int pa_cli_command_execute_line_stateful(pa_core *c, const char *s, pa_strbuf *buf, pa_bool_t *fail, int *ifstate) {
1724     const char *cs;
1725
1726     pa_assert(c);
1727     pa_assert(s);
1728     pa_assert(buf);
1729
1730     cs = s+strspn(s, whitespace);
1731
1732     if (*cs == '#' || !*cs)
1733         return 0;
1734     else if (*cs == '.') {
1735         if (!strcmp(cs, META_ELSE)) {
1736             if (!ifstate || *ifstate == IFSTATE_NONE) {
1737                 pa_strbuf_printf(buf, "Meta command %s is not valid in this context\n", cs);
1738                 return -1;
1739             } else if (*ifstate == IFSTATE_TRUE)
1740                 *ifstate = IFSTATE_FALSE;
1741             else
1742                 *ifstate = IFSTATE_TRUE;
1743             return 0;
1744         } else if (!strcmp(cs, META_ENDIF)) {
1745             if (!ifstate || *ifstate == IFSTATE_NONE) {
1746                 pa_strbuf_printf(buf, "Meta command %s is not valid in this context\n", cs);
1747                 return -1;
1748             } else
1749                 *ifstate = IFSTATE_NONE;
1750             return 0;
1751         }
1752         if (ifstate && *ifstate == IFSTATE_FALSE)
1753             return 0;
1754         if (!strcmp(cs, META_FAIL))
1755             *fail = TRUE;
1756         else if (!strcmp(cs, META_NOFAIL))
1757             *fail = FALSE;
1758         else {
1759             size_t l;
1760             l = strcspn(cs, whitespace);
1761
1762             if (l == sizeof(META_INCLUDE)-1 && !strncmp(cs, META_INCLUDE, l)) {
1763                 struct stat st;
1764                 const char *filename = cs+l+strspn(cs+l, whitespace);
1765
1766                 if (stat(filename, &st) < 0) {
1767                     pa_log_warn("stat('%s'): %s", filename, pa_cstrerror(errno));
1768                     if (*fail)
1769                         return -1;
1770                 } else {
1771                     if (S_ISDIR(st.st_mode)) {
1772                         DIR *d;
1773
1774                         if (!(d = opendir(filename))) {
1775                             pa_log_warn("Failed to read '%s': %s", filename, pa_cstrerror(errno));
1776                             if (*fail)
1777                                 return -1;
1778                         } else {
1779                             unsigned i, count;
1780                             char **sorted_files;
1781                             struct dirent *de;
1782                             pa_bool_t failed = FALSE;
1783                             pa_dynarray *files = pa_dynarray_new();
1784
1785                             while ((de = readdir(d))) {
1786                                 char *extn;
1787                                 size_t flen = strlen(de->d_name);
1788
1789                                 if (flen < 4)
1790                                     continue;
1791
1792                                 extn = &de->d_name[flen-3];
1793                                 if (strncmp(extn, ".pa", 3) == 0)
1794                                     pa_dynarray_append(files, pa_sprintf_malloc("%s" PA_PATH_SEP "%s", filename, de->d_name));
1795                             }
1796
1797                             closedir(d);
1798
1799                             count = pa_dynarray_size(files);
1800                             sorted_files = pa_xnew(char*, count);
1801                             for (i = 0; i < count; ++i)
1802                                 sorted_files[i] = pa_dynarray_get(files, i);
1803                             pa_dynarray_free(files, NULL);
1804
1805                             for (i = 0; i < count; ++i) {
1806                                 for (unsigned j = 0; j < count; ++j) {
1807                                     if (strcmp(sorted_files[i], sorted_files[j]) < 0) {
1808                                         char *tmp = sorted_files[i];
1809                                         sorted_files[i] = sorted_files[j];
1810                                         sorted_files[j] = tmp;
1811                                     }
1812                                 }
1813                             }
1814
1815                             for (i = 0; i < count; ++i) {
1816                                 if (!failed) {
1817                                     if (pa_cli_command_execute_file(c, sorted_files[i], buf, fail) < 0 && *fail)
1818                                         failed = TRUE;
1819                                 }
1820
1821                                 pa_xfree(sorted_files[i]);
1822                             }
1823                             pa_xfree(sorted_files);
1824                             if (failed)
1825                                 return -1;
1826                         }
1827                     } else if (pa_cli_command_execute_file(c, filename, buf, fail) < 0 && *fail) {
1828                         return -1;
1829                     }
1830                 }
1831             } else if (l == sizeof(META_IFEXISTS)-1 && !strncmp(cs, META_IFEXISTS, l)) {
1832                 if (!ifstate) {
1833                     pa_strbuf_printf(buf, "Meta command %s is not valid in this context\n", cs);
1834                     return -1;
1835                 } else if (*ifstate != IFSTATE_NONE) {
1836                     pa_strbuf_printf(buf, "Nested %s commands not supported\n", cs);
1837                     return -1;
1838                 } else {
1839                     const char *filename = cs+l+strspn(cs+l, whitespace);
1840
1841                     /* Search DL_SEARCH_PATH unless the filename is absolute */
1842                     if (filename[0] == PA_PATH_SEP_CHAR) {
1843
1844                         *ifstate = access(filename, F_OK) == 0 ? IFSTATE_TRUE : IFSTATE_FALSE;
1845                         pa_log_debug("Checking for existence of '%s': %s", filename, *ifstate == IFSTATE_TRUE ? "success" : "failure");
1846
1847                     } else {
1848                         const char *paths, *state = NULL;
1849                         char *p;
1850
1851                         if (!(paths = lt_dlgetsearchpath()))
1852                             return -1;
1853
1854                         while ((p = pa_split(paths, ":", &state))) {
1855                             char *pathname;
1856
1857                             pathname = pa_sprintf_malloc("%s" PA_PATH_SEP "%s", p, filename);
1858                             pa_xfree(p);
1859
1860                             *ifstate = access(pathname, F_OK) == 0 ? IFSTATE_TRUE : IFSTATE_FALSE;
1861                             pa_log_debug("Checking for existence of '%s': %s", pathname, *ifstate == IFSTATE_TRUE ? "success" : "failure");
1862
1863                             pa_xfree(pathname);
1864
1865                             if (*ifstate == IFSTATE_TRUE)
1866                                 break;
1867                         }
1868                     }
1869
1870                 }
1871             } else {
1872                 pa_strbuf_printf(buf, "Invalid meta command: %s\n", cs);
1873                 if (*fail) return -1;
1874             }
1875         }
1876     } else {
1877         const struct command*command;
1878         int unknown = 1;
1879         size_t l;
1880
1881         if (ifstate && *ifstate == IFSTATE_FALSE)
1882             return 0;
1883
1884         l = strcspn(cs, whitespace);
1885
1886         for (command = commands; command->name; command++)
1887             if (strlen(command->name) == l && !strncmp(cs, command->name, l)) {
1888                 int ret;
1889                 pa_tokenizer *t = pa_tokenizer_new(cs, command->args);
1890                 pa_assert(t);
1891                 ret = command->proc(c, t, buf, fail);
1892                 pa_tokenizer_free(t);
1893                 unknown = 0;
1894
1895                 if (ret < 0 && *fail)
1896                     return -1;
1897
1898                 break;
1899             }
1900
1901         if (unknown) {
1902             pa_strbuf_printf(buf, "Unknown command: %s\n", cs);
1903             if (*fail)
1904                 return -1;
1905         }
1906     }
1907
1908     return 0;
1909 }
1910
1911 int pa_cli_command_execute_line(pa_core *c, const char *s, pa_strbuf *buf, pa_bool_t *fail) {
1912     return pa_cli_command_execute_line_stateful(c, s, buf, fail, NULL);
1913 }
1914
1915 int pa_cli_command_execute_file_stream(pa_core *c, FILE *f, pa_strbuf *buf, pa_bool_t *fail) {
1916     char line[2048];
1917     int ifstate = IFSTATE_NONE;
1918     int ret = -1;
1919     pa_bool_t _fail = TRUE;
1920
1921     pa_assert(c);
1922     pa_assert(f);
1923     pa_assert(buf);
1924
1925     if (!fail)
1926         fail = &_fail;
1927
1928     while (fgets(line, sizeof(line), f)) {
1929         pa_strip_nl(line);
1930
1931         if (pa_cli_command_execute_line_stateful(c, line, buf, fail, &ifstate) < 0 && *fail)
1932             goto fail;
1933     }
1934
1935     ret = 0;
1936
1937 fail:
1938
1939     return ret;
1940 }
1941
1942 int pa_cli_command_execute_file(pa_core *c, const char *fn, pa_strbuf *buf, pa_bool_t *fail) {
1943     FILE *f = NULL;
1944     int ret = -1;
1945     pa_bool_t _fail = TRUE;
1946
1947     pa_assert(c);
1948     pa_assert(fn);
1949     pa_assert(buf);
1950
1951     if (!fail)
1952         fail = &_fail;
1953
1954     if (!(f = pa_fopen_cloexec(fn, "r"))) {
1955         pa_strbuf_printf(buf, "open('%s') failed: %s\n", fn, pa_cstrerror(errno));
1956         if (!*fail)
1957             ret = 0;
1958         goto fail;
1959     }
1960
1961     pa_log_debug("Parsing script '%s'", fn);
1962     ret = pa_cli_command_execute_file_stream(c, f, buf, fail);
1963
1964 fail:
1965     if (f)
1966         fclose(f);
1967
1968     return ret;
1969 }
1970
1971 int pa_cli_command_execute(pa_core *c, const char *s, pa_strbuf *buf, pa_bool_t *fail) {
1972     const char *p;
1973     int ifstate = IFSTATE_NONE;
1974     pa_bool_t _fail = TRUE;
1975
1976     pa_assert(c);
1977     pa_assert(s);
1978     pa_assert(buf);
1979
1980     if (!fail)
1981         fail = &_fail;
1982
1983     p = s;
1984     while (*p) {
1985         size_t l = strcspn(p, linebreak);
1986         char *line = pa_xstrndup(p, l);
1987
1988         if (pa_cli_command_execute_line_stateful(c, line, buf, fail, &ifstate) < 0 && *fail) {
1989             pa_xfree(line);
1990             return -1;
1991         }
1992         pa_xfree(line);
1993
1994         p += l;
1995         p += strspn(p, linebreak);
1996     }
1997
1998     return 0;
1999 }