dbus/xml_libxml.c

   1 /* -*- Mode: C ; c-basic-offset: 4 -*- */
   2 /*
   3     Copyright (C) 2007,2008 Nedko Arnaudov
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #if defined(HAVE_CONFIG_H)
  21 #include "config.h"
  22 #endif
  23
  24 #include <stdbool.h>
  25 #include <string.h>
  26 #include <dbus/dbus.h>
  27
  28 #include <libxml/xmlwriter.h>
  29 #include <libxml/parser.h>
  30 #include <libxml/xpath.h>
  31
  32 #include <jack/driver.h>
  33 #include <jack/engine.h>
  34 #include "controller_internal.h"
  35 #include "dbus.h"
  36
  37 /* XPath expression used for engine options selection */
  38 #define XPATH_ENGINE_OPTIONS_EXPRESSION "/jack/engine/option"
  39
  40 /* XPath expression used for drivers selection */
  41 #define XPATH_DRIVERS_EXPRESSION "/jack/drivers/driver"
  42
  43 /* XPath expression used for driver options selection */
  44 #define XPATH_DRIVER_OPTIONS_EXPRESSION "/jack/drivers/driver[@name = '%s']/option"
  45
  46 bool
  47 jack_controller_settings_init()
  48 {
  49     /*
  50      * this initialize the library and check potential ABI mismatches
  51      * between the version it was compiled for and the actual shared
  52      * library used.
  53      */
  54     LIBXML_TEST_VERSION;
  55
  56     return true;
  57 }
  58
  59 void
  60 jack_controller_settings_uninit()
  61 {
  62 }
  63
  64 #define writer ((xmlTextWriterPtr)context)
  65
  66 bool
  67 jack_controller_settings_write_option(
  68     void *context,
  69     const char *name,
  70     const char *content,
  71     void *dbus_call_context_ptr)
  72 {
  73     if (xmlTextWriterStartElement(writer, BAD_CAST "option") == -1)
  74     {
  75         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterStartElement() failed.");
  76         return false;
  77     }
  78
  79     if (xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST name) == -1)
  80     {
  81         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterWriteAttribute() failed.");
  82         return false;
  83     }
  84
  85     if (xmlTextWriterWriteString(writer, BAD_CAST content) == -1)
  86     {
  87         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterWriteString() failed.");
  88         return false;
  89     }
  90
  91     if (xmlTextWriterEndElement(writer) == -1)
  92     {
  93         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterEndElement() failed.");
  94         return false;
  95     }
  96
  97     return true;
  98 }
  99
 100 #undef writer
 101
 102 bool
 103 jack_controller_settings_write_engine(
 104     struct jack_controller * controller_ptr,
 105     xmlTextWriterPtr writer,
 106     void *dbus_call_context_ptr)
 107 {
 108 /*  jack_info("engine settings begin"); */
 109
 110 /*  if (xmlTextWriterWriteComment(writer, BAD_CAST "engine parameters") == -1) */
 111 /*  { */
 112 /*      jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterWriteComment() failed."); */
 113 /*      return false; */
 114 /*  } */
 115
 116     if (xmlTextWriterStartElement(writer, BAD_CAST "engine") == -1)
 117     {
 118         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterStartElement() failed.");
 119         return false;
 120     }
 121
 122     if (!jack_controller_settings_save_engine_options(writer, controller_ptr, dbus_call_context_ptr))
 123     {
 124         return false;
 125     }
 126
 127     if (xmlTextWriterEndElement(writer) == -1)
 128     {
 129         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterEndElement() failed.");
 130         return false;
 131     }
 132
 133 /*  jack_info("engine settings end"); */
 134     return true;
 135 }
 136
 137 bool
 138 jack_controller_settings_write_driver(
 139     struct jack_controller * controller_ptr,
 140     xmlTextWriterPtr writer,
 141     jackctl_driver driver,
 142     void *dbus_call_context_ptr)
 143 {
 144 /*  if (xmlTextWriterWriteComment(writer, BAD_CAST "driver parameters") == -1) */
 145 /*  { */
 146 /*      jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterWriteComment() failed."); */
 147 /*      return false; */
 148 /*  } */
 149
 150     if (xmlTextWriterStartElement(writer, BAD_CAST "driver") == -1)
 151     {
 152         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterStartElement() failed.");
 153         return false;
 154     }
 155
 156     if (xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST jackctl_driver_get_name(driver)) == -1)
 157     {
 158         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterWriteAttribute() failed.");
 159         return false;
 160     }
 161
 162     if (!jack_controller_settings_save_driver_options(writer, driver, dbus_call_context_ptr))
 163     {
 164         return false;
 165     }
 166
 167     if (xmlTextWriterEndElement(writer) == -1)
 168     {
 169         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterEndElement() failed.");
 170         return false;
 171     }
 172
 173     return true;
 174 }
 175
 176 bool
 177 jack_controller_settings_write_drivers(
 178     struct jack_controller * controller_ptr,
 179     xmlTextWriterPtr writer,
 180     void *dbus_call_context_ptr)
 181 {
 182     const JSList * node_ptr;
 183     jackctl_driver driver;
 184
 185     if (xmlTextWriterStartElement(writer, BAD_CAST "drivers") == -1)
 186     {
 187         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterStartElement() failed.");
 188         return false;
 189     }
 190
 191     node_ptr = jackctl_server_get_drivers_list(controller_ptr->server);
 192
 193     while (node_ptr != NULL)
 194     {
 195         driver = (jackctl_driver)node_ptr->data;
 196
 197         if (!jack_controller_settings_write_driver(
 198                 controller_ptr,
 199                 writer,
 200                 driver,
 201                 dbus_call_context_ptr))
 202         {
 203             return false;
 204         }
 205
 206         node_ptr = jack_slist_next(node_ptr);
 207     }
 208
 209     if (xmlTextWriterEndElement(writer) == -1)
 210     {
 211         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterEndElement() failed.");
 212         return false;
 213     }
 214
 215     return true;
 216 }
 217
 218 bool
 219 jack_controller_settings_write_internal(
 220     struct jack_controller * controller_ptr,
 221     xmlTextWriterPtr writer,
 222     jackctl_internal internal,
 223     void *dbus_call_context_ptr)
 224 {
 225 /*  if (xmlTextWriterWriteComment(writer, BAD_CAST "driver parameters") == -1) */
 226 /*  { */
 227 /*      jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterWriteComment() failed."); */
 228 /*      return false; */
 229 /*  } */
 230
 231     if (xmlTextWriterStartElement(writer, BAD_CAST "internal") == -1)
 232     {
 233         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterStartElement() failed.");
 234         return false;
 235     }
 236
 237     if (xmlTextWriterWriteAttribute(writer, BAD_CAST "name", BAD_CAST jackctl_internal_get_name(driver)) == -1)
 238     {
 239         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterWriteAttribute() failed.");
 240         return false;
 241     }
 242
 243     if (!jack_controller_settings_save_internal_options(writer, internal, dbus_call_context_ptr))
 244     {
 245         return false;
 246     }
 247
 248     if (xmlTextWriterEndElement(writer) == -1)
 249     {
 250         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterEndElement() failed.");
 251         return false;
 252     }
 253
 254     return true;
 255 }
 256
 257 bool
 258 jack_controller_settings_write_internals(
 259     struct jack_controller * controller_ptr,
 260     xmlTextWriterPtr writer,
 261     void *dbus_call_context_ptr)
 262 {
 263     const JSList * node_ptr;
 264     jackctl_driver internal;
 265
 266     if (xmlTextWriterStartElement(writer, BAD_CAST "internals") == -1)
 267     {
 268         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterStartElement() failed.");
 269         return false;
 270     }
 271
 272     node_ptr = jackctl_server_get_internals_list(controller_ptr->server);
 273
 274     while (node_ptr != NULL)
 275     {
 276         internal = (jackctl_internal)node_ptr->data;
 277
 278         if (!jack_controller_settings_write_internal(
 279                 controller_ptr,
 280                 writer,
 281                 internal,
 282                 dbus_call_context_ptr))
 283         {
 284             return false;
 285         }
 286
 287         node_ptr = jack_slist_next(node_ptr);
 288     }
 289
 290     if (xmlTextWriterEndElement(writer) == -1)
 291     {
 292         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterEndElement() failed.");
 293         return false;
 294     }
 295
 296     return true;
 297 }
 298
 299 bool
 300 jack_controller_settings_save(
 301     struct jack_controller * controller_ptr,
 302     void *dbus_call_context_ptr)
 303 {
 304     xmlTextWriterPtr writer;
 305     char *filename;
 306     size_t conf_len;
 307     bool ret;
 308     time_t timestamp;
 309     char timestamp_str[28];
 310
 311     time(&timestamp);
 312     timestamp_str[0] = ' ';
 313     ctime_r(&timestamp, timestamp_str + 1);
 314     timestamp_str[25] = ' ';
 315
 316     ret = false;
 317
 318     conf_len = strlen(JACKDBUS_CONF);
 319
 320     filename = malloc(g_jackdbus_dir_len + conf_len + 1);
 321     if (filename == NULL)
 322     {
 323         jack_error("Out of memory.");
 324         goto fail;
 325     }
 326
 327     memcpy(filename, g_jackdbus_dir, g_jackdbus_dir_len);
 328     memcpy(filename + g_jackdbus_dir_len, JACKDBUS_CONF, conf_len);
 329     filename[g_jackdbus_dir_len + conf_len] = 0;
 330
 331     jack_info("saving settings to \"%s\"", filename);
 332
 333     writer = xmlNewTextWriterFilename(filename, 0);
 334     if (writer == NULL)
 335     {
 336         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Error creating the xml writer.");
 337         goto fail_free_filename;
 338     }
 339
 340     if (xmlTextWriterSetIndent(writer, 1) == -1)
 341     {
 342         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterSetIndent() failed.");
 343         goto fail_free_writter;
 344     }
 345
 346     if (xmlTextWriterStartDocument(writer, NULL, NULL, NULL) == -1)
 347     {
 348         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterStartDocument() failed.");
 349         goto fail_free_writter;
 350     }
 351
 352     if (xmlTextWriterWriteComment(writer, BAD_CAST "\n" JACK_CONF_HEADER_TEXT) == -1)
 353     {
 354         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterWriteComment() failed.");
 355         goto fail_free_writter;
 356     }
 357
 358     if (xmlTextWriterWriteComment(writer, BAD_CAST timestamp_str) == -1)
 359     {
 360         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterWriteComment() failed.");
 361         goto fail_free_writter;
 362     }
 363
 364     if (xmlTextWriterStartElement(writer, BAD_CAST "jack") == -1)
 365     {
 366         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterStartElement() failed.");
 367         goto fail_free_writter;
 368     }
 369
 370     if (!jack_controller_settings_write_engine(controller_ptr, writer, dbus_call_context_ptr))
 371     {
 372         goto fail_free_writter;
 373     }
 374
 375     if (!jack_controller_settings_write_drivers(controller_ptr, writer, dbus_call_context_ptr))
 376     {
 377         goto fail_free_writter;
 378     }
 379
 380     if (!jack_controller_settings_write_internals(controller_ptr, writer, dbus_call_context_ptr))
 381     {
 382         goto fail_free_writter;
 383     }
 384
 385     if (xmlTextWriterEndElement(writer) == -1)
 386     {
 387         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterStartElement() failed.");
 388         goto fail_free_writter;
 389     }
 390
 391     if (xmlTextWriterEndDocument(writer) == -1)
 392     {
 393         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "xmlTextWriterEndDocument() failed.");
 394         goto fail_free_writter;
 395     }
 396
 397     ret = true;
 398
 399 fail_free_writter:
 400     xmlFreeTextWriter(writer);
 401
 402 fail_free_filename:
 403     free(filename);
 404
 405 fail:
 406     return ret;
 407 }
 408
 409 void
 410 jack_controller_settings_read_engine(
 411     struct jack_controller * controller_ptr,
 412     xmlXPathContextPtr xpath_ctx_ptr)
 413 {
 414     xmlXPathObjectPtr xpath_obj_ptr;
 415     xmlBufferPtr content_buffer_ptr;
 416     int i;
 417     const char *option_name;
 418     const char *option_value;
 419
 420     /* Evaluate xpath expression */
 421     xpath_obj_ptr = xmlXPathEvalExpression((const xmlChar *)XPATH_ENGINE_OPTIONS_EXPRESSION, xpath_ctx_ptr);
 422     if (xpath_obj_ptr == NULL)
 423     {
 424         jack_error("Unable to evaluate XPath expression \"%s\"", XPATH_ENGINE_OPTIONS_EXPRESSION);
 425         goto exit;
 426     }
 427
 428     if (xpath_obj_ptr->nodesetval == NULL || xpath_obj_ptr->nodesetval->nodeNr == 0)
 429     {
 430         jack_error("XPath \"%s\" evaluation returned no data", XPATH_ENGINE_OPTIONS_EXPRESSION);
 431         goto free_xpath_obj;
 432     }
 433
 434     content_buffer_ptr = xmlBufferCreate();
 435     if (content_buffer_ptr == NULL)
 436     {
 437         jack_error("xmlBufferCreate() failed.");
 438         goto free_xpath_obj;
 439     }
 440
 441     for (i = 0 ; i < xpath_obj_ptr->nodesetval->nodeNr ; i++)
 442     {
 443         //jack_info("engine option \"%s\" at index %d", xmlGetProp(xpath_obj_ptr->nodesetval->nodeTab[i], BAD_CAST "name"), i);
 444
 445         if (xmlNodeBufGetContent(content_buffer_ptr, xpath_obj_ptr->nodesetval->nodeTab[i]) == -1)
 446         {
 447             jack_error("xmlNodeBufGetContent() failed.");
 448             goto next_option;
 449         }
 450
 451         option_name = (const char *)xmlGetProp(xpath_obj_ptr->nodesetval->nodeTab[i], BAD_CAST "name");
 452         option_value = (const char *)xmlBufferContent(content_buffer_ptr);
 453
 454         jack_controller_settings_set_engine_option(controller_ptr, option_name, option_value);
 455
 456     next_option:
 457         xmlBufferEmpty(content_buffer_ptr);
 458     }
 459
 460 //free_buffer:
 461     xmlBufferFree(content_buffer_ptr);
 462
 463 free_xpath_obj:
 464     xmlXPathFreeObject(xpath_obj_ptr);
 465
 466 exit:
 467     return;
 468 }
 469
 470 void
 471 jack_controller_settings_read_driver(
 472     struct jack_controller * controller_ptr,
 473     xmlXPathContextPtr xpath_ctx_ptr,
 474     jackctl_driver driver)
 475 {
 476     char *xpath;
 477     size_t xpath_len;
 478     xmlXPathObjectPtr xpath_obj_ptr;
 479     xmlBufferPtr content_buffer_ptr;
 480     int i;
 481     const char *option_name;
 482     const char *option_value;
 483     const char *driver_name;
 484
 485     driver_name = jackctl_driver_get_name(driver);
 486
 487     jack_info("reading options for driver \"%s\"", driver_name);
 488
 489     xpath_len = snprintf(NULL, 0, XPATH_DRIVER_OPTIONS_EXPRESSION, driver_name);
 490
 491     xpath = malloc(xpath_len);
 492     if (xpath == NULL)
 493     {
 494         jack_error("Out of memory.");
 495         goto exit;
 496     }
 497
 498     snprintf(xpath, xpath_len, XPATH_DRIVER_OPTIONS_EXPRESSION, driver_name);
 499
 500     //jack_info("xpath = \"%s\"", xpath);
 501
 502     /* Evaluate xpath expression */
 503     xpath_obj_ptr = xmlXPathEvalExpression((const xmlChar *)xpath, xpath_ctx_ptr);
 504     if (xpath_obj_ptr == NULL)
 505     {
 506         jack_error("Unable to evaluate XPath expression \"%s\"", xpath);
 507         goto free_xpath;
 508     }
 509
 510     if (xpath_obj_ptr->nodesetval == NULL || xpath_obj_ptr->nodesetval->nodeNr == 0)
 511     {
 512         //jack_info("XPath \"%s\" evaluation returned no data", xpath);
 513         goto free_xpath_obj;
 514     }
 515
 516     content_buffer_ptr = xmlBufferCreate();
 517     if (content_buffer_ptr == NULL)
 518     {
 519         jack_error("xmlBufferCreate() failed.");
 520         goto free_xpath_obj;
 521     }
 522
 523     for (i = 0 ; i < xpath_obj_ptr->nodesetval->nodeNr ; i++)
 524     {
 525         //jack_info("driver option \"%s\" at index %d", xmlGetProp(xpath_obj_ptr->nodesetval->nodeTab[i], BAD_CAST "name"), i);
 526
 527         if (xmlNodeBufGetContent(content_buffer_ptr, xpath_obj_ptr->nodesetval->nodeTab[i]) == -1)
 528         {
 529             jack_error("xmlNodeBufGetContent() failed.");
 530             goto next_option;
 531         }
 532
 533         option_name = (const char *)xmlGetProp(xpath_obj_ptr->nodesetval->nodeTab[i], BAD_CAST "name");
 534         option_value = (const char *)xmlBufferContent(content_buffer_ptr);
 535
 536         jack_controller_settings_set_driver_option(driver, option_name, option_value);
 537
 538     next_option:
 539         xmlBufferEmpty(content_buffer_ptr);
 540     }
 541
 542 //free_buffer:
 543     xmlBufferFree(content_buffer_ptr);
 544
 545 free_xpath_obj:
 546     xmlXPathFreeObject(xpath_obj_ptr);
 547
 548 free_xpath:
 549     free(xpath);
 550
 551 exit:
 552     return;
 553 }
 554
 555 void
 556 jack_controller_settings_read_internal(
 557     struct jack_controller * controller_ptr,
 558     xmlXPathContextPtr xpath_ctx_ptr,
 559     jackctl_internal internal)
 560 {
 561     char *xpath;
 562     size_t xpath_len;
 563     xmlXPathObjectPtr xpath_obj_ptr;
 564     xmlBufferPtr content_buffer_ptr;
 565     int i;
 566     const char *option_name;
 567     const char *option_value;
 568     const char *internal_name;
 569
 570     internal_name = jackctl_internal_get_name(internal);
 571
 572     jack_info("reading options for internal \"%s\"", internal_name);
 573
 574     xpath_len = snprintf(NULL, 0, XPATH_DRIVER_OPTIONS_EXPRESSION, internal_name);
 575
 576     xpath = malloc(xpath_len);
 577     if (xpath == NULL)
 578     {
 579         jack_error("Out of memory.");
 580         goto exit;
 581     }
 582
 583     snprintf(xpath, xpath_len, XPATH_DRIVER_OPTIONS_EXPRESSION, internal_name);
 584
 585     //jack_info("xpath = \"%s\"", xpath);
 586
 587     /* Evaluate xpath expression */
 588     xpath_obj_ptr = xmlXPathEvalExpression((const xmlChar *)xpath, xpath_ctx_ptr);
 589     if (xpath_obj_ptr == NULL)
 590     {
 591         jack_error("Unable to evaluate XPath expression \"%s\"", xpath);
 592         goto free_xpath;
 593     }
 594
 595     if (xpath_obj_ptr->nodesetval == NULL || xpath_obj_ptr->nodesetval->nodeNr == 0)
 596     {
 597         //jack_info("XPath \"%s\" evaluation returned no data", xpath);
 598         goto free_xpath_obj;
 599     }
 600
 601     content_buffer_ptr = xmlBufferCreate();
 602     if (content_buffer_ptr == NULL)
 603     {
 604         jack_error("xmlBufferCreate() failed.");
 605         goto free_xpath_obj;
 606     }
 607
 608     for (i = 0 ; i < xpath_obj_ptr->nodesetval->nodeNr ; i++)
 609     {
 610         //jack_info("driver option \"%s\" at index %d", xmlGetProp(xpath_obj_ptr->nodesetval->nodeTab[i], BAD_CAST "name"), i);
 611
 612         if (xmlNodeBufGetContent(content_buffer_ptr, xpath_obj_ptr->nodesetval->nodeTab[i]) == -1)
 613         {
 614             jack_error("xmlNodeBufGetContent() failed.");
 615             goto next_option;
 616         }
 617
 618         option_name = (const char *)xmlGetProp(xpath_obj_ptr->nodesetval->nodeTab[i], BAD_CAST "name");
 619         option_value = (const char *)xmlBufferContent(content_buffer_ptr);
 620
 621         jack_controller_settings_set_internal_option(internal, option_name, option_value);
 622
 623     next_option:
 624         xmlBufferEmpty(content_buffer_ptr);
 625     }
 626
 627 //free_buffer:
 628     xmlBufferFree(content_buffer_ptr);
 629
 630 free_xpath_obj:
 631     xmlXPathFreeObject(xpath_obj_ptr);
 632
 633 free_xpath:
 634     free(xpath);
 635
 636 exit:
 637     return;
 638 }
 639
 640 void
 641 jack_controller_settings_read_drivers(
 642     struct jack_controller * controller_ptr,
 643     xmlXPathContextPtr xpath_ctx_ptr)
 644 {
 645     xmlXPathObjectPtr xpath_obj_ptr;
 646     int i;
 647     const char *driver_name;
 648     jackctl_driver driver;
 649
 650     /* Evaluate xpath expression */
 651     xpath_obj_ptr = xmlXPathEvalExpression((const xmlChar *)XPATH_DRIVERS_EXPRESSION, xpath_ctx_ptr);
 652     if (xpath_obj_ptr == NULL)
 653     {
 654         jack_error("Unable to evaluate XPath expression \"%s\"", XPATH_DRIVERS_EXPRESSION);
 655         goto exit;
 656     }
 657
 658     if (xpath_obj_ptr->nodesetval == NULL || xpath_obj_ptr->nodesetval->nodeNr == 0)
 659     {
 660         jack_error("XPath \"%s\" evaluation returned no data", XPATH_DRIVERS_EXPRESSION);
 661         goto free_xpath_obj;
 662     }
 663
 664     for (i = 0 ; i < xpath_obj_ptr->nodesetval->nodeNr ; i++)
 665     {
 666         driver_name = (const char *)xmlGetProp(xpath_obj_ptr->nodesetval->nodeTab[i], BAD_CAST "name");
 667
 668         driver = jack_controller_find_driver(controller_ptr->server, driver_name);
 669         if (driver == NULL)
 670         {
 671             jack_error("ignoring settings for unknown driver \"%s\"", driver_name);
 672         }
 673         else
 674         {
 675             jack_info("setting for driver \"%s\" found", driver_name);
 676
 677             jack_controller_settings_read_driver(controller_ptr, xpath_ctx_ptr, driver);
 678         }
 679     }
 680
 681 free_xpath_obj:
 682     xmlXPathFreeObject(xpath_obj_ptr);
 683
 684 exit:
 685     return;
 686 }
 687
 688 void
 689 jack_controller_settings_read_internals(
 690     struct jack_controller * controller_ptr,
 691     xmlXPathContextPtr xpath_ctx_ptr)
 692 {
 693     xmlXPathObjectPtr xpath_obj_ptr;
 694     int i;
 695     const char *internal_name;
 696     jackctl_internal internal;
 697
 698     /* Evaluate xpath expression */
 699     xpath_obj_ptr = xmlXPathEvalExpression((const xmlChar *)XPATH_DRIVERS_EXPRESSION, xpath_ctx_ptr);
 700     if (xpath_obj_ptr == NULL)
 701     {
 702         jack_error("Unable to evaluate XPath expression \"%s\"", XPATH_DRIVERS_EXPRESSION);
 703         goto exit;
 704     }
 705
 706     if (xpath_obj_ptr->nodesetval == NULL || xpath_obj_ptr->nodesetval->nodeNr == 0)
 707     {
 708         jack_error("XPath \"%s\" evaluation returned no data", XPATH_DRIVERS_EXPRESSION);
 709         goto free_xpath_obj;
 710     }
 711
 712     for (i = 0 ; i < xpath_obj_ptr->nodesetval->nodeNr ; i++)
 713     {
 714         internal_name = (const char *)xmlGetProp(xpath_obj_ptr->nodesetval->nodeTab[i], BAD_CAST "name");
 715
 716         driver = jack_controller_find_internal(controller_ptr->server, driver_name);
 717         if (driver == NULL)
 718         {
 719             jack_error("ignoring settings for unknown internal \"%s\"", internal_name);
 720         }
 721         else
 722         {
 723             jack_info("setting for internal \"%s\" found", internal_name);
 724
 725             jack_controller_settings_read_internal(controller_ptr, xpath_ctx_ptr, driver);
 726         }
 727     }
 728
 729 free_xpath_obj:
 730     xmlXPathFreeObject(xpath_obj_ptr);
 731
 732 exit:
 733     return;
 734 }
 735
 736
 737 void
 738 jack_controller_settings_load(
 739     struct jack_controller * controller_ptr)
 740 {
 741     char *filename;
 742     size_t conf_len;
 743     xmlDocPtr doc_ptr;
 744     xmlXPathContextPtr xpath_ctx_ptr;
 745
 746     conf_len = strlen(JACKDBUS_CONF);
 747
 748     filename = malloc(g_jackdbus_dir_len + conf_len + 1);
 749     if (filename == NULL)
 750     {
 751         jack_error("Out of memory.");
 752         goto exit;
 753     }
 754
 755     memcpy(filename, g_jackdbus_dir, g_jackdbus_dir_len);
 756     memcpy(filename + g_jackdbus_dir_len, JACKDBUS_CONF, conf_len);
 757     filename[g_jackdbus_dir_len + conf_len] = 0;
 758
 759     jack_info("loading settings from \"%s\"", filename);
 760
 761     doc_ptr = xmlParseFile(filename);
 762     if (doc_ptr == NULL)
 763     {
 764         jack_error("Failed to parse \"%s\"", filename);
 765         goto free_filename;
 766     }
 767
 768     /* Create xpath evaluation context */
 769     xpath_ctx_ptr = xmlXPathNewContext(doc_ptr);
 770     if (xpath_ctx_ptr == NULL)
 771     {
 772         jack_error("Unable to create new XPath context");
 773         goto free_doc;
 774     }
 775
 776     jack_controller_settings_read_engine(controller_ptr, xpath_ctx_ptr);
 777     jack_controller_settings_read_drivers(controller_ptr, xpath_ctx_ptr);
 778     jack_controller_settings_read_internals(controller_ptr, xpath_ctx_ptr);
 779
 780     xmlXPathFreeContext(xpath_ctx_ptr);
 781
 782 free_doc:
 783     xmlFreeDoc(doc_ptr);
 784
 785 free_filename:
 786     free(filename);
 787
 788 exit:
 789     return;
 790 }
 791
 792 void
 793 jack_controller_settings_save_auto(
 794     struct jack_controller * controller_ptr)
 795 {
 796     jack_controller_settings_save(controller_ptr, NULL);
 797 }