daemon/studio_jack_conf.c

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