alsa-utils/alsaucm/dump.c

649 lines
15 KiB
C
Raw Permalink Normal View History

/*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* Copyright (C) 2019 Red Hat Inc.
* Authors: Jaroslav Kysela <perex@perex.cz>
*/
#include <stdio.h>
#include <string.h>
#include <alsa/asoundlib.h>
#include <alsa/use-case.h>
#include "usecase.h"
#include "aconfig.h"
#include "version.h"
struct renderer {
int (*init)(struct renderer *r);
void (*done)(struct renderer *r);
int (*verb_begin)(struct renderer *r,
const char *verb,
const char *comment);
int (*verb_end)(struct renderer *r);
int (*device_block_begin)(struct renderer *r);
int (*device_block_end)(struct renderer *r);
int (*device_begin)(struct renderer *r,
const char *device,
const char *comment);
int (*device_end)(struct renderer *r);
int (*modifier_block_begin)(struct renderer *r);
int (*modifier_block_end)(struct renderer *r);
int (*modifier_begin)(struct renderer *r,
const char *device,
const char *comment);
int (*modifier_end)(struct renderer *r);
int (*supported_begin)(struct renderer *r);
int (*supported_value)(struct renderer *r, const char *value, int last);
int (*supported_end)(struct renderer *r);
int (*conflict_begin)(struct renderer *r);
int (*conflict_value)(struct renderer *r, const char *value, int last);
int (*conflict_end)(struct renderer *r);
int (*value_begin)(struct renderer *r);
int (*value_end)(struct renderer *r);
int (*value)(struct renderer *r, const char *ident, const char *value);
void *opaque;
};
/*
* Text renderer
*/
struct text {
char a[1];
};
static char *tesc(const char *s, char *buf, size_t buf_len)
{
char *dst = buf;
char c = '\0';
if (strchr(s, '"') || strchr(s, ' ') || strchr(s, '.')) {
*dst++ = c = '"';
buf_len--;
}
while (*s && buf_len > 2) {
if (*s == '"') {
if (buf_len > 3) {
*dst++ = '\\';
*dst++ = *s++;
buf_len -= 2;
continue;
} else {
break;
}
}
*dst++ = *s++;
}
if (c)
*dst++ = c;
*dst = '\0';
return buf;
}
#define ESC(s, esc) tesc((s), (esc), sizeof(esc))
static int text_verb_start(struct renderer *r, const char *verb, const char *comment)
{
char buf1[128], buf2[128];
printf("Verb.%s {\n", ESC(verb, buf1));
if (comment && comment[0])
printf("\tComment %s\n", ESC(comment, buf2));
return 0;
}
static int text_verb_end(struct renderer *r)
{
printf("}\n");
return 0;
}
static int text_2nd_level_begin(struct renderer *r,
const char *key,
const char *val,
const char *comment)
{
char buf1[128], buf2[128];
printf("\t%s.%s {\n", key, ESC(val, buf1));
if (comment && comment[0])
printf("\t\tComment %s\n", ESC(comment, buf2));
return 0;
}
static int text_2nd_level_end(struct renderer *r)
{
printf("\t}\n");
return 0;
}
static int text_2nd_level(struct renderer *r, const char *txt)
{
printf("\t\t%s", txt);
return 0;
}
static int text_3rd_level(struct renderer *r, const char *txt)
{
printf("\t\t\t%s", txt);
return 0;
}
static int text_dev_start(struct renderer *r, const char *dev, const char *comment)
{
return text_2nd_level_begin(r, "Device", dev, comment);
}
static int text_mod_start(struct renderer *r, const char *dev, const char *comment)
{
return text_2nd_level_begin(r, "Modifier", dev, comment);
}
static int text_supcon_start(struct renderer *r, const char *key)
{
if (text_2nd_level(r, key))
return 1;
printf(" [\n");
return 0;
}
static int text_supcon_value(struct renderer *r, const char *value, int last)
{
char buf[256];
ESC(value, buf);
if (!last && strlen(buf) < sizeof(buf) - 2)
strcat(buf, ",");
if (text_3rd_level(r, buf))
return 1;
printf("\n");
return 0;
}
static int text_supcon_end(struct renderer *r)
{
return text_2nd_level(r, "]\n");
}
static int text_sup_start(struct renderer *r)
{
return text_supcon_start(r, "SupportedDevices");
}
static int text_con_start(struct renderer *r)
{
return text_supcon_start(r, "ConflictingDevices");
}
static int text_value_begin(struct renderer *r)
{
return text_2nd_level(r, "Values {\n");
}
static int text_value_end(struct renderer *r)
{
return text_2nd_level(r, "}\n");
}
static int text_value(struct renderer *r, const char *ident, const char *value)
{
char buf1[256], buf2[256];
int err;
ESC(ident, buf1);
err = text_3rd_level(r, buf1);
if (err < 0)
return err;
ESC(value, buf2);
printf(" %s\n", buf2);
return 0;
}
static struct renderer text_renderer = {
.verb_begin = text_verb_start,
.verb_end = text_verb_end,
.device_begin = text_dev_start,
.device_end = text_2nd_level_end,
.modifier_begin = text_mod_start,
.modifier_end = text_2nd_level_end,
.supported_begin = text_sup_start,
.supported_value = text_supcon_value,
.supported_end = text_supcon_end,
.conflict_begin = text_con_start,
.conflict_value = text_supcon_value,
.conflict_end = text_supcon_end,
.value_begin = text_value_begin,
.value_end = text_value_end,
.value = text_value,
};
/*
* JSON renderer
*/
struct json {
int block[5];
};
static char *jesc(const char *s, char *buf, size_t buf_len)
{
char *dst = buf;
char c = '"';
*dst++ = c;
buf_len--;
while (*s && buf_len > 2) {
if (*s == '"') {
if (buf_len > 3) {
*dst++ = '\\';
*dst++ = *s++;
buf_len -= 2;
continue;
} else {
break;
}
}
*dst++ = *s++;
}
*dst++ = c;
*dst = '\0';
return buf;
}
#define JESC(s, esc) jesc((s), (esc), sizeof(esc))
static void json_block(struct renderer *r, int level, int last)
{
struct json *j = r->opaque;
printf((j->block[level] && !last) ? ",\n" : "\n");
j->block[level] = last ? 0 : 1;
}
static int json_init(struct renderer *r)
{
printf("{\n \"Verbs\": {");
return 0;
}
static void json_done(struct renderer *r)
{
json_block(r, 0, 1);
printf(" }\n}\n");
}
static int json_verb_start(struct renderer *r, const char *verb, const char *comment)
{
char buf[256];
json_block(r, 0, 0);
printf(" %s: {", JESC(verb, buf));
if (comment && comment[0]) {
json_block(r, 1, 0);
printf(" \"Comment\": %s", JESC(comment, buf));
}
return 0;
}
static int json_verb_end(struct renderer *r)
{
json_block(r, 1, 1);
printf(" }");
return 0;
}
static int json_2nd_level_block_end(struct renderer *r)
{
json_block(r, 2, 1);
printf(" }");
return 0;
}
static int json_2nd_level_begin(struct renderer *r,
const char *val,
const char *comment)
{
char buf[256];
json_block(r, 2, 0);
printf(" %s: {", JESC(val, buf));
if (comment && comment[0]) {
json_block(r, 3, 0);
printf(" \"Comment\": %s", JESC(comment, buf));
}
return 0;
}
static int json_2nd_level_end(struct renderer *r)
{
json_block(r, 3, 1);
printf(" }");
return 0;
}
static int json_2nd_level(struct renderer *r, const char *txt)
{
printf(" %s", txt);
return 0;
}
static int json_3rd_level(struct renderer *r, const char *txt)
{
printf(" %s", txt);
return 0;
}
static int json_dev_block_start(struct renderer *r)
{
json_block(r, 1, 0);
printf(" \"Devices\": {");
return 0;
}
static int json_mod_block_start(struct renderer *r)
{
json_block(r, 1, 0);
printf(" \"Modifiers\": {");
return 0;
}
static int json_supcon_start(struct renderer *r, const char *key)
{
json_block(r, 3, 0);
if (json_2nd_level(r, key))
return 1;
printf(": [");
return 0;
}
static int json_supcon_value(struct renderer *r, const char *value, int last)
{
char buf[256];
JESC(value, buf);
json_block(r, 4, 0);
return json_3rd_level(r, buf);
}
static int json_supcon_end(struct renderer *r)
{
json_block(r, 4, 1);
return json_2nd_level(r, "]");
}
static int json_sup_start(struct renderer *r)
{
return json_supcon_start(r, "\"SupportedDevices\"");
}
static int json_con_start(struct renderer *r)
{
return json_supcon_start(r, "\"ConflictingDevices\"");
}
static int json_value_begin(struct renderer *r)
{
json_block(r, 3, 0);
return json_2nd_level(r, "\"Values\": {");
}
static int json_value_end(struct renderer *r)
{
json_block(r, 4, 1);
return json_2nd_level(r, "}");
}
static int json_value(struct renderer *r, const char *ident, const char *value)
{
char buf[256];
int err;
json_block(r, 4, 0);
JESC(ident, buf);
err = json_3rd_level(r, buf);
if (err < 0)
return err;
JESC(value, buf);
printf(": %s", buf);
return 0;
}
static struct renderer json_renderer = {
.init = json_init,
.done = json_done,
.verb_begin = json_verb_start,
.verb_end = json_verb_end,
.device_block_begin = json_dev_block_start,
.device_block_end = json_2nd_level_block_end,
.device_begin = json_2nd_level_begin,
.device_end = json_2nd_level_end,
.modifier_block_begin = json_mod_block_start,
.modifier_block_end = json_2nd_level_block_end,
.modifier_begin = json_2nd_level_begin,
.modifier_end = json_2nd_level_end,
.supported_begin = json_sup_start,
.supported_value = json_supcon_value,
.supported_end = json_supcon_end,
.conflict_begin = json_con_start,
.conflict_value = json_supcon_value,
.conflict_end = json_supcon_end,
.value_begin = json_value_begin,
.value_end = json_value_end,
.value = json_value,
};
/*
* universal dump functions
*/
static int render_devlist(struct context *context,
struct renderer *render,
const char *verb,
const char *device,
const char *list,
int (*begin)(struct renderer *),
int (*value)(struct renderer *, const char *value, int last),
int (*end)(struct renderer *))
{
snd_use_case_mgr_t *uc_mgr = context->uc_mgr;
const char **dev_list;
char buf[256];
int err = 0, j, dev_num;
snprintf(buf, sizeof(buf), "%s/%s/%s", list, device, verb);
dev_num = snd_use_case_get_list(uc_mgr, buf, &dev_list);
if (dev_num < 0) {
fprintf(stderr, "%s: unable to get %s for verb '%s' for device '%s'\n",
context->command, list, verb, device);
return dev_num;
}
if (dev_num > 0) {
err = begin(render);
if (err < 0)
goto __err;
for (j = 0; j < dev_num; j++) {
err = value(render, dev_list[j], j + 1 == dev_num);
if (err < 0)
goto __err;
}
err = end(render);
}
__err:
snd_use_case_free_list(dev_list, dev_num);
return err;
}
static int render_values(struct context *context,
struct renderer *render,
const char *verb,
const char *device)
{
snd_use_case_mgr_t *uc_mgr = context->uc_mgr;
const char **list, *value;
char buf[256];
int err = 0, j, num;
snprintf(buf, sizeof(buf), "_identifiers/%s/%s", device, verb);
num = snd_use_case_get_list(uc_mgr, buf, &list);
if (num < 0) {
fprintf(stderr, "%s: unable to get _identifiers for verb '%s' for device '%s': %s\n",
context->command, verb, device, snd_strerror(num));
return num;
}
if (num == 0)
goto __err;
if (render->value_begin) {
err = render->value_begin(render);
if (err < 0)
goto __err;
}
for (j = 0; j < num; j++) {
snprintf(buf, sizeof(buf), "%s/%s/%s", list[j], device, verb);
err = snd_use_case_get(uc_mgr, buf, &value);
if (err < 0) {
fprintf(stderr, "%s: unable to get value '%s' for verb '%s' for device '%s': %s\n",
context->command, list[j], verb, device, snd_strerror(err));
goto __err;
}
err = render->value(render, list[j], value);
free((char *)value);
if (err < 0)
goto __err;
}
if (render->value_end)
err = render->value_end(render);
__err:
snd_use_case_free_list(list, num);
return err;
}
static int render_device(struct context *context,
struct renderer *render,
const char *verb,
const char *device)
{
int err;
err = render_devlist(context, render, verb, device,
"_supporteddevs",
render->supported_begin,
render->supported_value,
render->supported_end);
if (err < 0)
return err;
err = render_devlist(context, render, verb, device,
"_conflictingdevs",
render->conflict_begin,
render->conflict_value,
render->conflict_end);
if (err < 0)
return err;
return render_values(context, render, verb, device);
}
static void render(struct context *context, struct renderer *render)
{
snd_use_case_mgr_t *uc_mgr = context->uc_mgr;
int i, j, num, dev_num;
const char **list, **dev_list, *verb, *comment;
char buf[256];
num = snd_use_case_verb_list(uc_mgr, &list);
if (num < 0) {
fprintf(stderr, "%s: no verbs found\n", context->command);
return;
}
if (render->init && render->init(render))
goto __end;
for (i = 0; i < num; i += 2) {
/* verb */
verb = list[i + 0];
comment = list[i + 1];
if (render->verb_begin(render, verb, comment))
break;
/* devices */
snprintf(buf, sizeof(buf), "_devices/%s", verb);
dev_num = snd_use_case_get_list(uc_mgr, buf, &dev_list);
if (dev_num < 0) {
fprintf(stderr, "%s: unable to get devices for verb '%s'\n",
context->command, verb);
continue;
}
if (dev_num == 0)
goto __mods;
if (render->device_block_begin && render->device_block_begin(render)) {
snd_use_case_free_list(dev_list, dev_num);
goto __end;
}
for (j = 0; j < dev_num; j += 2) {
render->device_begin(render, dev_list[j + 0], dev_list[j + 1]);
if (render_device(context, render, verb, dev_list[j + 0])) {
snd_use_case_free_list(dev_list, dev_num);
goto __end;
}
render->device_end(render);
}
snd_use_case_free_list(dev_list, dev_num);
if (render->device_block_end && render->device_block_end(render))
goto __end;
__mods:
/* modifiers */
snprintf(buf, sizeof(buf), "_modifiers/%s", verb);
dev_num = snd_use_case_get_list(uc_mgr, buf, &dev_list);
if (dev_num < 0) {
fprintf(stderr, "%s: unable to get modifiers for verb '%s'\n",
context->command, verb);
continue;
}
if (dev_num == 0)
goto __verb_end;
if (render->modifier_block_begin && render->modifier_block_begin(render)) {
snd_use_case_free_list(dev_list, dev_num);
goto __end;
}
for (j = 0; j < dev_num; j += 2) {
render->modifier_begin(render, dev_list[j + 0], dev_list[j + 1]);
render->modifier_end(render);
}
snd_use_case_free_list(dev_list, dev_num);
if (render->modifier_block_end && render->modifier_block_end(render))
goto __end;
__verb_end:
/* end */
if (render->verb_end(render))
break;
}
if (render->done)
render->done(render);
__end:
snd_use_case_free_list(list, num);
}
void dump(struct context *context, const char *format)
{
struct renderer r;
struct text t;
struct json j;
r.opaque = NULL;
if (strcasecmp(format, "text") == 0 ||
strcasecmp(format, "txt") == 0) {
memset(&t, 0, sizeof(t));
r = text_renderer;
r.opaque = &t;
} else if (strcasecmp(format, "json") == 0) {
memset(&j, 0, sizeof(j));
r = json_renderer;
r.opaque = &j;
}
if (r.opaque != NULL) {
render(context, &r);
return;
}
fprintf(stderr, "%s: unknown dump format '%s'\n",
context->command, format);
}