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 "studio_internal.h"
  38
  39 bool
  40 jack_conf_container_create(
  41   struct jack_conf_container ** container_ptr_ptr,
  42   const char * name)
  43 {
  44   struct jack_conf_container * container_ptr;
  45
  46   container_ptr = malloc(sizeof(struct jack_conf_container));
  47   if (container_ptr == NULL)
  48   {
  49     log_error("malloc() failed to allocate struct jack_conf_container");
  50     goto fail;
  51   }
  52
  53   container_ptr->name = strdup(name);
  54   if (container_ptr->name == NULL)
  55   {
  56     log_error("strdup() failed to duplicate \"%s\"", name);
  57     goto fail_free;
  58   }
  59
  60   INIT_LIST_HEAD(&container_ptr->children);
  61   container_ptr->children_leafs = false;
  62
  63   *container_ptr_ptr = container_ptr;
  64   return true;
  65
  66 fail_free:
  67   free(container_ptr);
  68
  69 fail:
  70   return false;
  71 }
  72
  73 bool
  74 jack_conf_parameter_create(
  75   struct jack_conf_parameter ** parameter_ptr_ptr,
  76   const char * name)
  77 {
  78   struct jack_conf_parameter * parameter_ptr;
  79
  80   parameter_ptr = malloc(sizeof(struct jack_conf_parameter));
  81   if (parameter_ptr == NULL)
  82   {
  83     log_error("malloc() failed to allocate struct jack_conf_parameter");
  84     goto fail;
  85   }
  86
  87   parameter_ptr->name = strdup(name);
  88   if (parameter_ptr->name == NULL)
  89   {
  90     log_error("strdup() failed to duplicate \"%s\"", name);
  91     goto fail_free;
  92   }
  93
  94   *parameter_ptr_ptr = parameter_ptr;
  95   return true;
  96
  97 fail_free:
  98   free(parameter_ptr);
  99
 100 fail:
 101   return false;
 102 }
 103
 104 void
 105 jack_conf_parameter_destroy(
 106   struct jack_conf_parameter * parameter_ptr)
 107 {
 108 #if 0
 109   log_info("jack_conf_parameter destroy");
 110
 111   switch (parameter_ptr->parameter.type)
 112   {
 113   case jack_boolean:
 114     log_info("%s value is %s (boolean)", parameter_ptr->name, parameter_ptr->parameter.value.boolean ? "true" : "false");
 115     break;
 116   case jack_string:
 117     log_info("%s value is %s (string)", parameter_ptr->name, parameter_ptr->parameter.value.string);
 118     break;
 119   case jack_byte:
 120     log_info("%s value is %u/%c (byte/char)", parameter_ptr->name, parameter_ptr->parameter.value.byte, (char)parameter_ptr->parameter.value.byte);
 121     break;
 122   case jack_uint32:
 123     log_info("%s value is %u (uint32)", parameter_ptr->name, (unsigned int)parameter_ptr->parameter.value.uint32);
 124     break;
 125   case jack_int32:
 126     log_info("%s value is %u (int32)", parameter_ptr->name, (signed int)parameter_ptr->parameter.value.int32);
 127     break;
 128   default:
 129     log_error("unknown jack parameter_ptr->parameter type %d (%s)", (int)parameter_ptr->parameter.type, parameter_ptr->name);
 130     break;
 131   }
 132 #endif
 133
 134   if (parameter_ptr->parameter.type == jack_string)
 135   {
 136     free(parameter_ptr->parameter.value.string);
 137   }
 138
 139   free(parameter_ptr->name);
 140   free(parameter_ptr);
 141 }
 142
 143 void
 144 jack_conf_container_destroy(
 145   struct jack_conf_container * container_ptr)
 146 {
 147   struct list_head * node_ptr;
 148
 149   //log_info("\"%s\" jack_conf_parameter destroy", container_ptr->name);
 150
 151   if (!container_ptr->children_leafs)
 152   {
 153     while (!list_empty(&container_ptr->children))
 154     {
 155       node_ptr = container_ptr->children.next;
 156       list_del(node_ptr);
 157       jack_conf_container_destroy(list_entry(node_ptr, struct jack_conf_container, siblings));
 158     }
 159   }
 160   else
 161   {
 162     while (!list_empty(&container_ptr->children))
 163     {
 164       node_ptr = container_ptr->children.next;
 165       list_del(node_ptr);
 166       jack_conf_parameter_destroy(list_entry(node_ptr, struct jack_conf_parameter, siblings));
 167     }
 168   }
 169
 170   free(container_ptr->name);
 171   free(container_ptr);
 172 }
 173
 174 #define context_ptr ((struct conf_callback_context *)context)
 175
 176 static
 177 bool
 178 conf_callback(
 179   void * context,
 180   bool leaf,
 181   const char * address,
 182   char * child)
 183 {
 184   char path[JACK_CONF_MAX_ADDRESS_SIZE];
 185   const char * component;
 186   char * dst;
 187   size_t len;
 188   bool is_set;
 189   struct jack_conf_container * parent_ptr;
 190   struct jack_conf_container * container_ptr;
 191   struct jack_conf_parameter * parameter_ptr;
 192
 193   parent_ptr = context_ptr->parent_ptr;
 194
 195   if (parent_ptr == NULL && strcmp(child, "drivers") == 0)
 196   {
 197     log_debug("ignoring drivers branch");
 198     return true;
 199   }
 200
 201   dst = path;
 202   component = address;
 203   while (*component != 0)
 204   {
 205     len = strlen(component);
 206     memcpy(dst, component, len);
 207     dst[len] = ':';
 208     component += len + 1;
 209     dst += len + 1;
 210   }
 211
 212   strcpy(dst, child);
 213
 214   /* address always is same buffer as the one supplied through context pointer */
 215   ASSERT(context_ptr->address == address);
 216   dst = (char *)component;
 217
 218   len = strlen(child) + 1;
 219   memcpy(dst, child, len);
 220   dst[len] = 0;
 221
 222   if (leaf)
 223   {
 224     log_debug("%s (leaf)", path);
 225
 226     if (parent_ptr == NULL)
 227     {
 228       log_error("jack conf parameters can't appear in root container");
 229       return false;
 230     }
 231
 232     if (!parent_ptr->children_leafs)
 233     {
 234       if (!list_empty(&parent_ptr->children))
 235       {
 236         log_error("jack conf parameters cant be mixed with containers at same hierarchy level");
 237         return false;
 238       }
 239
 240       parent_ptr->children_leafs = true;
 241     }
 242
 243     if (!jack_conf_parameter_create(&parameter_ptr, child))
 244     {
 245       log_error("jack_conf_parameter_create() failed");
 246       return false;
 247     }
 248
 249     if (!jack_proxy_get_parameter_value(context_ptr->address, &is_set, &parameter_ptr->parameter))
 250     {
 251       log_error("cannot get value of %s", path);
 252       return false;
 253     }
 254
 255     if (is_set)
 256     {
 257 #if 0
 258       switch (parameter_ptr->parameter.type)
 259       {
 260       case jack_boolean:
 261         log_info("%s value is %s (boolean)", path, parameter_ptr->parameter.value.boolean ? "true" : "false");
 262         break;
 263       case jack_string:
 264         log_info("%s value is %s (string)", path, parameter_ptr->parameter.value.string);
 265         break;
 266       case jack_byte:
 267         log_info("%s value is %u/%c (byte/char)", path, parameter_ptr->parameter.value.byte, (char)parameter_ptr->parameter.value.byte);
 268         break;
 269       case jack_uint32:
 270         log_info("%s value is %u (uint32)", path, (unsigned int)parameter_ptr->parameter.value.uint32);
 271         break;
 272       case jack_int32:
 273         log_info("%s value is %u (int32)", path, (signed int)parameter_ptr->parameter.value.int32);
 274         break;
 275       default:
 276         log_error("unknown jack parameter_ptr->parameter type %d (%s)", (int)parameter_ptr->parameter.type, path);
 277         jack_conf_parameter_destroy(parameter_ptr);
 278         return false;
 279       }
 280 #endif
 281
 282       parameter_ptr->parent_ptr = parent_ptr;
 283       memcpy(parameter_ptr->address, context_ptr->address, JACK_CONF_MAX_ADDRESS_SIZE);
 284       list_add_tail(&parameter_ptr->siblings, &parent_ptr->children);
 285       list_add_tail(&parameter_ptr->leaves, &g_studio.jack_params);
 286     }
 287     else
 288     {
 289       jack_conf_parameter_destroy(parameter_ptr);
 290     }
 291   }
 292   else
 293   {
 294     log_debug("%s (container)", path);
 295
 296     if (parent_ptr != NULL && parent_ptr->children_leafs)
 297     {
 298       log_error("jack conf containers cant be mixed with parameters at same hierarchy level");
 299       return false;
 300     }
 301
 302     if (!jack_conf_container_create(&container_ptr, child))
 303     {
 304       log_error("jack_conf_container_create() failed");
 305       return false;
 306     }
 307
 308     container_ptr->parent_ptr = parent_ptr;
 309
 310     if (parent_ptr == NULL)
 311     {
 312       list_add_tail(&container_ptr->siblings, &g_studio.jack_conf);
 313     }
 314     else
 315     {
 316       list_add_tail(&container_ptr->siblings, &parent_ptr->children);
 317     }
 318
 319     context_ptr->parent_ptr = container_ptr;
 320
 321     if (!jack_proxy_read_conf_container(context_ptr->address, context, conf_callback))
 322     {
 323       log_error("cannot read container %s", path);
 324       return false;
 325     }
 326
 327     context_ptr->parent_ptr = parent_ptr;
 328   }
 329
 330   *dst = 0;
 331
 332   return true;
 333 }
 334
 335 #undef context_ptr
 336
 337 void jack_conf_clear(void)
 338 {
 339   struct list_head * node_ptr;
 340
 341   INIT_LIST_HEAD(&g_studio.jack_params); /* we will destroy the leaves as part of tree destroy traversal */
 342   while (!list_empty(&g_studio.jack_conf))
 343   {
 344     node_ptr = g_studio.jack_conf.next;
 345     list_del(node_ptr);
 346     jack_conf_container_destroy(list_entry(node_ptr, struct jack_conf_container, siblings));
 347   }
 348
 349   g_studio.jack_conf_valid = false;
 350 }
 351
 352 bool studio_fetch_jack_settings(void)
 353 {
 354   struct conf_callback_context context;
 355
 356   jack_conf_clear();
 357
 358   context.address[0] = 0;
 359   context.container_ptr = &g_studio.jack_conf;
 360   context.parent_ptr = NULL;
 361
 362   if (!jack_proxy_read_conf_container(context.address, &context, conf_callback))
 363   {
 364     log_error("jack_proxy_read_conf_container() failed.");
 365     return false;
 366   }
 367
 368   return true;
 369 }