daemon/studio_jack_conf.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of the studio functionality
   9  * related to jack configuration
  10  **************************************************************************
  11  *
  12  * LADI Session Handler is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * LADI Session Handler is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  24  * or write to the Free Software Foundation, Inc.,
  25  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  26  */
  27
  28 #include "common.h"
  29
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34 #include <dirent.h>
  35 #include <expat.h>
  36
  37 #include "../jack_proxy.h"
  38 #include "../graph_proxy.h"
  39 #include "graph.h"
  40 #include "../dbus_constants.h"
  41 #include "control.h"
  42 #include "../catdup.h"
  43 #include "../dbus/error.h"
  44 #include "dirhelpers.h"
  45 #include "graph_dict.h"
  46 #include "escape.h"
  47 #include "studio_internal.h"
  48
  49 bool
  50 jack_conf_container_create(
  51   struct jack_conf_container ** container_ptr_ptr,
  52   const char * name)
  53 {
  54   struct jack_conf_container * container_ptr;
  55
  56   container_ptr = malloc(sizeof(struct jack_conf_container));
  57   if (container_ptr == NULL)
  58   {
  59     log_error("malloc() failed to allocate struct jack_conf_container");
  60     goto fail;
  61   }
  62
  63   container_ptr->name = strdup(name);
  64   if (container_ptr->name == NULL)
  65   {
  66     log_error("strdup() failed to duplicate \"%s\"", name);
  67     goto fail_free;
  68   }
  69
  70   INIT_LIST_HEAD(&container_ptr->children);
  71   container_ptr->children_leafs = false;
  72
  73   *container_ptr_ptr = container_ptr;
  74   return true;
  75
  76 fail_free:
  77   free(container_ptr);
  78
  79 fail:
  80   return false;
  81 }
  82
  83 bool
  84 jack_conf_parameter_create(
  85   struct jack_conf_parameter ** parameter_ptr_ptr,
  86   const char * name)
  87 {
  88   struct jack_conf_parameter * parameter_ptr;
  89
  90   parameter_ptr = malloc(sizeof(struct jack_conf_parameter));
  91   if (parameter_ptr == NULL)
  92   {
  93     log_error("malloc() failed to allocate struct jack_conf_parameter");
  94     goto fail;
  95   }
  96
  97   parameter_ptr->name = strdup(name);
  98   if (parameter_ptr->name == NULL)
  99   {
 100     log_error("strdup() failed to duplicate \"%s\"", name);
 101     goto fail_free;
 102   }
 103
 104   *parameter_ptr_ptr = parameter_ptr;
 105   return true;
 106
 107 fail_free:
 108   free(parameter_ptr);
 109
 110 fail:
 111   return false;
 112 }
 113
 114 void
 115 jack_conf_parameter_destroy(
 116   struct jack_conf_parameter * parameter_ptr)
 117 {
 118 #if 0
 119   log_info("jack_conf_parameter destroy");
 120
 121   switch (parameter_ptr->parameter.type)
 122   {
 123   case jack_boolean:
 124     log_info("%s value is %s (boolean)", parameter_ptr->name, parameter_ptr->parameter.value.boolean ? "true" : "false");
 125     break;
 126   case jack_string:
 127     log_info("%s value is %s (string)", parameter_ptr->name, parameter_ptr->parameter.value.string);
 128     break;
 129   case jack_byte:
 130     log_info("%s value is %u/%c (byte/char)", parameter_ptr->name, parameter_ptr->parameter.value.byte, (char)parameter_ptr->parameter.value.byte);
 131     break;
 132   case jack_uint32:
 133     log_info("%s value is %u (uint32)", parameter_ptr->name, (unsigned int)parameter_ptr->parameter.value.uint32);
 134     break;
 135   case jack_int32:
 136     log_info("%s value is %u (int32)", parameter_ptr->name, (signed int)parameter_ptr->parameter.value.int32);
 137     break;
 138   default:
 139     log_error("unknown jack parameter_ptr->parameter type %d (%s)", (int)parameter_ptr->parameter.type, parameter_ptr->name);
 140     break;
 141   }
 142 #endif
 143
 144   if (parameter_ptr->parameter.type == jack_string)
 145   {
 146     free(parameter_ptr->parameter.value.string);
 147   }
 148
 149   free(parameter_ptr->name);
 150   free(parameter_ptr);
 151 }
 152
 153 void
 154 jack_conf_container_destroy(
 155   struct jack_conf_container * container_ptr)
 156 {
 157   struct list_head * node_ptr;
 158
 159   //log_info("\"%s\" jack_conf_parameter destroy", container_ptr->name);
 160
 161   if (!container_ptr->children_leafs)
 162   {
 163     while (!list_empty(&container_ptr->children))
 164     {
 165       node_ptr = container_ptr->children.next;
 166       list_del(node_ptr);
 167       jack_conf_container_destroy(list_entry(node_ptr, struct jack_conf_container, siblings));
 168     }
 169   }
 170   else
 171   {
 172     while (!list_empty(&container_ptr->children))
 173     {
 174       node_ptr = container_ptr->children.next;
 175       list_del(node_ptr);
 176       jack_conf_parameter_destroy(list_entry(node_ptr, struct jack_conf_parameter, siblings));
 177     }
 178   }
 179
 180   free(container_ptr->name);
 181   free(container_ptr);
 182 }
 183
 184 #define context_ptr ((struct conf_callback_context *)context)
 185
 186 static
 187 bool
 188 conf_callback(
 189   void * context,
 190   bool leaf,
 191   const char * address,
 192   char * child)
 193 {
 194   char path[JACK_CONF_MAX_ADDRESS_SIZE];
 195   const char * component;
 196   char * dst;
 197   size_t len;
 198   bool is_set;
 199   struct jack_conf_container * parent_ptr;
 200   struct jack_conf_container * container_ptr;
 201   struct jack_conf_parameter * parameter_ptr;
 202
 203   parent_ptr = context_ptr->parent_ptr;
 204
 205   if (parent_ptr == NULL && strcmp(child, "drivers") == 0)
 206   {
 207     log_debug("ignoring drivers branch");
 208     return true;
 209   }
 210
 211   dst = path;
 212   component = address;
 213   while (*component != 0)
 214   {
 215     len = strlen(component);
 216     memcpy(dst, component, len);
 217     dst[len] = ':';
 218     component += len + 1;
 219     dst += len + 1;
 220   }
 221
 222   strcpy(dst, child);
 223
 224   /* address always is same buffer as the one supplied through context pointer */
 225   ASSERT(context_ptr->address == address);
 226   dst = (char *)component;
 227
 228   len = strlen(child) + 1;
 229   memcpy(dst, child, len);
 230   dst[len] = 0;
 231
 232   if (leaf)
 233   {
 234     log_debug("%s (leaf)", path);
 235
 236     if (parent_ptr == NULL)
 237     {
 238       log_error("jack conf parameters can't appear in root container");
 239       return false;
 240     }
 241
 242     if (!parent_ptr->children_leafs)
 243     {
 244       if (!list_empty(&parent_ptr->children))
 245       {
 246         log_error("jack conf parameters cant be mixed with containers at same hierarchy level");
 247         return false;
 248       }
 249
 250       parent_ptr->children_leafs = true;
 251     }
 252
 253     if (!jack_conf_parameter_create(&parameter_ptr, child))
 254     {
 255       log_error("jack_conf_parameter_create() failed");
 256       return false;
 257     }
 258
 259     if (!jack_proxy_get_parameter_value(context_ptr->address, &is_set, &parameter_ptr->parameter))
 260     {
 261       log_error("cannot get value of %s", path);
 262       return false;
 263     }
 264
 265     if (is_set)
 266     {
 267 #if 0
 268       switch (parameter_ptr->parameter.type)
 269       {
 270       case jack_boolean:
 271         log_info("%s value is %s (boolean)", path, parameter_ptr->parameter.value.boolean ? "true" : "false");
 272         break;
 273       case jack_string:
 274         log_info("%s value is %s (string)", path, parameter_ptr->parameter.value.string);
 275         break;
 276       case jack_byte:
 277         log_info("%s value is %u/%c (byte/char)", path, parameter_ptr->parameter.value.byte, (char)parameter_ptr->parameter.value.byte);
 278         break;
 279       case jack_uint32:
 280         log_info("%s value is %u (uint32)", path, (unsigned int)parameter_ptr->parameter.value.uint32);
 281         break;
 282       case jack_int32:
 283         log_info("%s value is %u (int32)", path, (signed int)parameter_ptr->parameter.value.int32);
 284         break;
 285       default:
 286         log_error("unknown jack parameter_ptr->parameter type %d (%s)", (int)parameter_ptr->parameter.type, path);
 287         jack_conf_parameter_destroy(parameter_ptr);
 288         return false;
 289       }
 290 #endif
 291
 292       parameter_ptr->parent_ptr = parent_ptr;
 293       memcpy(parameter_ptr->address, context_ptr->address, JACK_CONF_MAX_ADDRESS_SIZE);
 294       list_add_tail(&parameter_ptr->siblings, &parent_ptr->children);
 295       list_add_tail(&parameter_ptr->leaves, &g_studio.jack_params);
 296     }
 297     else
 298     {
 299       jack_conf_parameter_destroy(parameter_ptr);
 300     }
 301   }
 302   else
 303   {
 304     log_debug("%s (container)", path);
 305
 306     if (parent_ptr != NULL && parent_ptr->children_leafs)
 307     {
 308       log_error("jack conf containers cant be mixed with parameters at same hierarchy level");
 309       return false;
 310     }
 311
 312     if (!jack_conf_container_create(&container_ptr, child))
 313     {
 314       log_error("jack_conf_container_create() failed");
 315       return false;
 316     }
 317
 318     container_ptr->parent_ptr = parent_ptr;
 319
 320     if (parent_ptr == NULL)
 321     {
 322       list_add_tail(&container_ptr->siblings, &g_studio.jack_conf);
 323     }
 324     else
 325     {
 326       list_add_tail(&container_ptr->siblings, &parent_ptr->children);
 327     }
 328
 329     context_ptr->parent_ptr = container_ptr;
 330
 331     if (!jack_proxy_read_conf_container(context_ptr->address, context, conf_callback))
 332     {
 333       log_error("cannot read container %s", path);
 334       return false;
 335     }
 336
 337     context_ptr->parent_ptr = parent_ptr;
 338   }
 339
 340   *dst = 0;
 341
 342   return true;
 343 }
 344
 345 #undef context_ptr
 346
 347 void jack_conf_clear(void)
 348 {
 349   struct list_head * node_ptr;
 350
 351   INIT_LIST_HEAD(&g_studio.jack_params); /* we will destroy the leaves as part of tree destroy traversal */
 352   while (!list_empty(&g_studio.jack_conf))
 353   {
 354     node_ptr = g_studio.jack_conf.next;
 355     list_del(node_ptr);
 356     jack_conf_container_destroy(list_entry(node_ptr, struct jack_conf_container, siblings));
 357   }
 358
 359   g_studio.jack_conf_valid = false;
 360 }
 361
 362 bool studio_fetch_jack_settings(void)
 363 {
 364   struct conf_callback_context context;
 365
 366   jack_conf_clear();
 367
 368   context.address[0] = 0;
 369   context.container_ptr = &g_studio.jack_conf;
 370   context.parent_ptr = NULL;
 371
 372   if (!jack_proxy_read_conf_container(context.address, &context, conf_callback))
 373   {
 374     log_error("jack_proxy_read_conf_container() failed.");
 375     return false;
 376   }
 377
 378   return true;
 379 }