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