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