Quelle  conf.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
//
// kselftest configuration helpers for the hw specific configuration
//
// Original author: Jaroslav Kysela <perex@perex.cz>
// Copyright (c) 2022 Red Hat Inc.

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <errno.h>
#include <assert.h>
#include <dirent.h>
#include <regex.h>
#include <sys/stat.h>

#include "../kselftest.h"
#include "alsa-local.h"

#define SYSFS_ROOT "/sys"

struct card_cfg_data *conf_cards;

static const char *alsa_config =
"ctl.hw {\n"
" @args [ CARD ]\n"
" @args.CARD.type string\n"
" type hw\n"
" card $CARD\n"
"}\n"
"pcm.hw {\n"
" @args [ CARD DEV SUBDEV ]\n"
" @args.CARD.type string\n"
" @args.DEV.type integer\n"
" @args.SUBDEV.type integer\n"
" type hw\n"
" card $CARD\n"
" device $DEV\n"
" subdevice $SUBDEV\n"
"}\n"
;

#ifdef SND_LIB_VER
#if SND_LIB_VERSION >= SND_LIB_VER(1, 2, 6)
#define LIB_HAS_LOAD_STRING
#endif
#endif

#ifndef LIB_HAS_LOAD_STRING
static int snd_config_load_string(snd_config_t **config, const char *s,
      size_t size)
{
 snd_input_t *input;
 snd_config_t *dst;
 int err;

 assert(config && s);
 if (size == 0)
  size = strlen(s);
 err = snd_input_buffer_open(&input, s, size);
 if (err < 0)
  return err;
 err = snd_config_top(&dst);
 if (err < 0) {
  snd_input_close(input);
  return err;
 }
 err = snd_config_load(dst, input);
 snd_input_close(input);
 if (err < 0) {
  snd_config_delete(dst);
  return err;
 }
 *config = dst;
 return 0;
}
#endif

snd_config_t *get_alsalib_config(void)
{
 snd_config_t *config;
 int err;

 err = snd_config_load_string(&config, alsa_config, strlen(alsa_config));
 if (err < 0) {
  ksft_print_msg("Unable to parse custom alsa-lib configuration: %s\n",
          snd_strerror(err));
  ksft_exit_fail();
 }
 return config;
}

static struct card_cfg_data *conf_data_by_card(int card, bool msg)
{
 struct card_cfg_data *conf;

 for (conf = conf_cards; conf; conf = conf->next) {
  if (conf->card == card) {
   if (msg)
    ksft_print_msg("using hw card config %s for card %d\n",
            conf->filename, card);
   return conf;
  }
 }
 return NULL;
}

static void dump_config_tree(snd_config_t *top)
{
 snd_output_t *out;
 int err;

 err = snd_output_stdio_attach(&out, stdout, 0);
 if (err < 0)
  ksft_exit_fail_msg("stdout attach\n");
 if (snd_config_save(top, out))
  ksft_exit_fail_msg("config save\n");
 snd_output_close(out);
}

snd_config_t *conf_load_from_file(const char *filename)
{
 snd_config_t *dst;
 snd_input_t *input;
 int err;

 err = snd_input_stdio_open(&input, filename, "r");
 if (err < 0)
  ksft_exit_fail_msg("Unable to parse filename %s\n", filename);
 err = snd_config_top(&dst);
 if (err < 0)
  ksft_exit_fail_msg("Out of memory\n");
 err = snd_config_load(dst, input);
 snd_input_close(input);
 if (err < 0)
  ksft_exit_fail_msg("Unable to parse filename %s\n", filename);
 return dst;
}

static char *sysfs_get(const char *sysfs_root, const char *id)
{
 char path[PATH_MAX], link[PATH_MAX + 1];
 struct stat sb;
 ssize_t len;
 char *e;
 int fd;

 if (id[0] == '/')
  id++;
 snprintf(path, sizeof(path), "%s/%s", sysfs_root, id);
 if (lstat(path, &sb) != 0)
  return NULL;
 if (S_ISLNK(sb.st_mode)) {
  len = readlink(path, link, sizeof(link) - 1);
  if (len <= 0) {
   ksft_exit_fail_msg("sysfs: cannot read link '%s': %s\n",
        path, strerror(errno));
   return NULL;
  }
  link[len] = '\0';
  e = strrchr(link, '/');
  if (e)
   return strdup(e + 1);
  return NULL;
 }
 if (S_ISDIR(sb.st_mode))
  return NULL;
 if ((sb.st_mode & S_IRUSR) == 0)
  return NULL;

 fd = open(path, O_RDONLY);
 if (fd < 0) {
  if (errno == ENOENT)
   return NULL;
  ksft_exit_fail_msg("sysfs: open failed for '%s': %s\n",
       path, strerror(errno));
 }
 len = read(fd, path, sizeof(path)-1);
 close(fd);
 if (len < 0)
  ksft_exit_fail_msg("sysfs: unable to read value '%s': %s\n",
       path, strerror(errno));
 while (len > 0 && path[len-1] == '\n')
  len--;
 path[len] = '\0';
 e = strdup(path);
 if (e == NULL)
  ksft_exit_fail_msg("Out of memory\n");
 return e;
}

static bool sysfs_match(const char *sysfs_root, snd_config_t *config)
{
 snd_config_t *node, *path_config, *regex_config;
 snd_config_iterator_t i, next;
 const char *path_string, *regex_string, *v;
 regex_t re;
 regmatch_t match[1];
 int iter = 0, ret;

 snd_config_for_each(i, next, config) {
  node = snd_config_iterator_entry(i);
  if (snd_config_search(node, "path", &path_config))
   ksft_exit_fail_msg("Missing path field in the sysfs block\n");
  if (snd_config_search(node, "regex", ®ex_config))
   ksft_exit_fail_msg("Missing regex field in the sysfs block\n");
  if (snd_config_get_string(path_config, &path_string))
   ksft_exit_fail_msg("Path field in the sysfs block is not a string\n");
  if (snd_config_get_string(regex_config, ®ex_string))
   ksft_exit_fail_msg("Regex field in the sysfs block is not a string\n");
  iter++;
  v = sysfs_get(sysfs_root, path_string);
  if (!v)
   return false;
  if (regcomp(&re, regex_string, REG_EXTENDED))
   ksft_exit_fail_msg("Wrong regex '%s'\n", regex_string);
  ret = regexec(&re, v, 1, match, 0);
  regfree(&re);
  if (ret)
   return false;
 }
 return iter > 0;
}

static void assign_card_config(int card, const char *sysfs_card_root)
{
 struct card_cfg_data *data;
 snd_config_t *sysfs_card_config;

 for (data = conf_cards; data; data = data->next) {
  snd_config_search(data->config, "sysfs", &sysfs_card_config);
  if (!sysfs_match(sysfs_card_root, sysfs_card_config))
   continue;

  data->card = card;
  break;
 }
}

static void assign_card_configs(void)
{
 char fn[128];
 int card;

 for (card = 0; card < 32; card++) {
  snprintf(fn, sizeof(fn), "%s/class/sound/card%d", SYSFS_ROOT, card);
  if (access(fn, R_OK) == 0)
   assign_card_config(card, fn);
 }
}

static int filename_filter(const struct dirent *dirent)
{
 size_t flen;

 if (dirent == NULL)
  return 0;
 if (dirent->d_type == DT_DIR)
  return 0;
 flen = strlen(dirent->d_name);
 if (flen <= 5)
  return 0;
 if (strncmp(&dirent->d_name[flen-5], ".conf", 5) == 0)
  return 1;
 return 0;
}

static bool match_config(const char *filename)
{
 struct card_cfg_data *data;
 snd_config_t *config, *sysfs_config, *card_config, *sysfs_card_config, *node;
 snd_config_iterator_t i, next;

 config = conf_load_from_file(filename);
 if (snd_config_search(config, "sysfs", &sysfs_config) ||
     snd_config_get_type(sysfs_config) != SND_CONFIG_TYPE_COMPOUND)
  ksft_exit_fail_msg("Missing global sysfs block in filename %s\n", filename);
 if (snd_config_search(config, "card", &card_config) ||
     snd_config_get_type(card_config) != SND_CONFIG_TYPE_COMPOUND)
  ksft_exit_fail_msg("Missing global card block in filename %s\n", filename);
 if (!sysfs_match(SYSFS_ROOT, sysfs_config))
  return false;
 snd_config_for_each(i, next, card_config) {
  node = snd_config_iterator_entry(i);
  if (snd_config_search(node, "sysfs", &sysfs_card_config) ||
      snd_config_get_type(sysfs_card_config) != SND_CONFIG_TYPE_COMPOUND)
   ksft_exit_fail_msg("Missing card sysfs block in filename %s\n", filename);

  data = malloc(sizeof(*data));
  if (!data)
   ksft_exit_fail_msg("Out of memory\n");
  data->filename = filename;
  data->config = node;
  data->card = -1;
  if (snd_config_get_id(node, &data->config_id))
   ksft_exit_fail_msg("snd_config_get_id failed for card\n");
  data->next = conf_cards;
  conf_cards = data;
 }
 return true;
}

void conf_load(void)
{
 const char *fn = "conf.d";
 struct dirent **namelist;
 int n, j;

 n = scandir(fn, &namelist, filename_filter, alphasort);
 if (n < 0)
  ksft_exit_fail_msg("scandir: %s\n", strerror(errno));
 for (j = 0; j < n; j++) {
  size_t sl = strlen(fn) + strlen(namelist[j]->d_name) + 2;
  char *filename = malloc(sl);
  if (filename == NULL)
   ksft_exit_fail_msg("Out of memory\n");
  sprintf(filename, "%s/%s", fn, namelist[j]->d_name);
  if (match_config(filename))
   filename = NULL;
  free(filename);
  free(namelist[j]);
 }
 free(namelist);

 assign_card_configs();
}

void conf_free(void)
{
 struct card_cfg_data *conf;

 while (conf_cards) {
  conf = conf_cards;
  conf_cards = conf->next;
  snd_config_delete(conf->config);
 }
}

snd_config_t *conf_by_card(int card)
{
 struct card_cfg_data *conf;

 conf = conf_data_by_card(card, true);
 if (conf)
  return conf->config;
 return NULL;
}

static int conf_get_by_keys(snd_config_t *root, const char *key1,
       const char *key2, snd_config_t **result)
{
 int ret;

 if (key1) {
  ret = snd_config_search(root, key1, &root);
  if (ret != -ENOENT && ret < 0)
   return ret;
 }
 if (key2)
  ret = snd_config_search(root, key2, &root);
 if (ret >= 0)
  *result = root;
 return ret;
}

snd_config_t *conf_get_subtree(snd_config_t *root, const char *key1, const char *key2)
{
 int ret;

 if (!root)
  return NULL;
 ret = conf_get_by_keys(root, key1, key2, &root);
 if (ret == -ENOENT)
  return NULL;
 if (ret < 0)
  ksft_exit_fail_msg("key '%s'.'%s' search error: %s\n", key1, key2, snd_strerror(ret));
 return root;
}

int conf_get_count(snd_config_t *root, const char *key1, const char *key2)
{
 snd_config_t *cfg;
 snd_config_iterator_t i, next;
 int count, ret;

 if (!root)
  return -1;
 ret = conf_get_by_keys(root, key1, key2, &cfg);
 if (ret == -ENOENT)
  return -1;
 if (ret < 0)
  ksft_exit_fail_msg("key '%s'.'%s' search error: %s\n", key1, key2, snd_strerror(ret));
 if (snd_config_get_type(cfg) != SND_CONFIG_TYPE_COMPOUND)
  ksft_exit_fail_msg("key '%s'.'%s' is not a compound\n", key1, key2);
 count = 0;
 snd_config_for_each(i, next, cfg)
  count++;
 return count;
}

const char *conf_get_string(snd_config_t *root, const char *key1, const char *key2, const char *def)
{
 snd_config_t *cfg;
 const char *s;
 int ret;

 if (!root)
  return def;
 ret = conf_get_by_keys(root, key1, key2, &cfg);
 if (ret == -ENOENT)
  return def;
 if (ret < 0)
  ksft_exit_fail_msg("key '%s'.'%s' search error: %s\n", key1, key2, snd_strerror(ret));
 if (snd_config_get_string(cfg, &s))
  ksft_exit_fail_msg("key '%s'.'%s' is not a string\n", key1, key2);
 return s;
}

long conf_get_long(snd_config_t *root, const char *key1, const char *key2, long def)
{
 snd_config_t *cfg;
 long l;
 int ret;

 if (!root)
  return def;
 ret = conf_get_by_keys(root, key1, key2, &cfg);
 if (ret == -ENOENT)
  return def;
 if (ret < 0)
  ksft_exit_fail_msg("key '%s'.'%s' search error: %s\n", key1, key2, snd_strerror(ret));
 if (snd_config_get_integer(cfg, &l))
  ksft_exit_fail_msg("key '%s'.'%s' is not an integer\n", key1, key2);
 return l;
}

int conf_get_bool(snd_config_t *root, const char *key1, const char *key2, int def)
{
 snd_config_t *cfg;
 int ret;

 if (!root)
  return def;
 ret = conf_get_by_keys(root, key1, key2, &cfg);
 if (ret == -ENOENT)
  return def;
 if (ret < 0)
  ksft_exit_fail_msg("key '%s'.'%s' search error: %s\n", key1, key2, snd_strerror(ret));
 ret = snd_config_get_bool(cfg);
 if (ret < 0)
  ksft_exit_fail_msg("key '%s'.'%s' is not an bool\n", key1, key2);
 return !!ret;
}

void conf_get_string_array(snd_config_t *root, const char *key1, const char *key2,
      const char **array, int array_size, const char *def)
{
 snd_config_t *cfg;
 char buf[16];
 int ret, index;

 ret = conf_get_by_keys(root, key1, key2, &cfg);
 if (ret == -ENOENT)
  cfg = NULL;
 else if (ret < 0)
  ksft_exit_fail_msg("key '%s'.'%s' search error: %s\n", key1, key2, snd_strerror(ret));
 for (index = 0; index < array_size; index++) {
  if (cfg == NULL) {
   array[index] = def;
  } else {
   sprintf(buf, "%i", index);
   array[index] = conf_get_string(cfg, buf, NULL, def);
  }
 }
}