dbus/xml.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 <stdint.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <dbus/dbus.h>
  29
  30 #include "controller_internal.h"
  31
  32 void
  33 jack_controller_settings_set_bool_option(
  34     const char *value_str,
  35     int *value_ptr)
  36 {
  37     if (strcmp(value_str, "true") == 0)
  38     {
  39         *value_ptr = true;
  40     }
  41     else if (strcmp(value_str, "false") == 0)
  42     {
  43         *value_ptr = false;
  44     }
  45     else
  46     {
  47         jack_error("ignoring unknown bool value \"%s\"", value_str);
  48     }
  49 }
  50
  51 void
  52 jack_controller_settings_set_sint_option(
  53     const char *value_str,
  54     int *value_ptr)
  55 {
  56     *value_ptr = atoi(value_str);
  57 }
  58
  59 void
  60 jack_controller_settings_set_uint_option(
  61     const char *value_str,
  62     unsigned int *value_ptr)
  63 {
  64     *value_ptr = strtoul(value_str, NULL, 10);
  65 }
  66
  67 void
  68 jack_controller_settings_set_char_option(
  69     const char *value_str,
  70     char *value_ptr)
  71 {
  72     if (value_str[0] == 0 || value_str[1] != 0)
  73     {
  74         jack_error("invalid char option value \"%s\"", value_str);
  75         return;
  76     }
  77
  78     *value_ptr = *value_str;
  79 }
  80
  81 void
  82 jack_controller_settings_set_string_option(
  83     const char *value_str,
  84     char *value_ptr,
  85     size_t max_size)
  86 {
  87     size_t size;
  88
  89     size = strlen(value_str);
  90
  91     if (size >= max_size)
  92     {
  93         jack_error("string option value \"%s\" is too long, max is %u chars (including terminating zero)", value_str, (unsigned int)max_size);
  94         return;
  95     }
  96
  97     strcpy(value_ptr, value_str);
  98 }
  99
 100 void
 101 jack_controller_settings_set_driver_option(
 102     jackctl_driver_t *driver,
 103     const char *option_name,
 104     const char *option_value)
 105 {
 106     jackctl_parameter_t *parameter;
 107     jackctl_param_type_t type;
 108     int value_int = 0;
 109     unsigned int value_uint = 0;
 110     union jackctl_parameter_value value;
 111
 112     jack_info("setting driver option \"%s\" to value \"%s\"", option_name, option_value);
 113
 114     parameter = jack_controller_find_parameter(jackctl_driver_get_parameters(driver), option_name);
 115     if (parameter == NULL)
 116     {
 117         jack_error(
 118             "Unknown parameter \"%s\" of driver \"%s\"",
 119             option_name,
 120             jackctl_driver_get_name(driver));
 121         return;
 122     }
 123
 124     type = jackctl_parameter_get_type(parameter);
 125
 126     switch (type)
 127     {
 128     case JackParamInt:
 129         jack_controller_settings_set_sint_option(option_value, &value_int);
 130         value.i = value_int;
 131         break;
 132     case JackParamUInt:
 133         jack_controller_settings_set_uint_option(option_value, &value_uint);
 134         value.ui = value_uint;
 135         break;
 136     case JackParamChar:
 137         jack_controller_settings_set_char_option(option_value, &value.c);
 138         break;
 139     case JackParamString:
 140         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));
 141         break;
 142     case JackParamBool:
 143         jack_controller_settings_set_bool_option(option_value, &value_int);
 144         value.i = value_int;
 145         break;
 146     default:
 147         jack_error("Parameter \"%s\" of driver \"%s\" is of unknown type %d",
 148                jackctl_parameter_get_name(parameter),
 149                jackctl_driver_get_name(driver),
 150                type);
 151     }
 152
 153     jackctl_parameter_set_value(parameter, &value);
 154 }
 155
 156 void
 157 jack_controller_settings_set_internal_option(
 158     jackctl_internal_t *internal,
 159     const char *option_name,
 160     const char *option_value)
 161 {
 162     jackctl_parameter_t *parameter;
 163     jackctl_param_type_t type;
 164     int value_int = 0;
 165     unsigned int value_uint = 0;
 166     union jackctl_parameter_value value;
 167
 168     jack_info("setting internal option \"%s\" to value \"%s\"", option_name, option_value);
 169
 170     parameter = jack_controller_find_parameter(jackctl_internal_get_parameters(internal), option_name);
 171     if (parameter == NULL)
 172     {
 173         jack_error(
 174             "Unknown parameter \"%s\" of internal \"%s\"",
 175             option_name,
 176             jackctl_internal_get_name(internal));
 177         return;
 178     }
 179
 180     type = jackctl_parameter_get_type(parameter);
 181
 182     switch (type)
 183     {
 184     case JackParamInt:
 185         jack_controller_settings_set_sint_option(option_value, &value_int);
 186         value.i = value_int;
 187         break;
 188     case JackParamUInt:
 189         jack_controller_settings_set_uint_option(option_value, &value_uint);
 190         value.ui = value_uint;
 191         break;
 192     case JackParamChar:
 193         jack_controller_settings_set_char_option(option_value, &value.c);
 194         break;
 195     case JackParamString:
 196         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));
 197         break;
 198     case JackParamBool:
 199         jack_controller_settings_set_bool_option(option_value, &value_int);
 200         value.i = value_int;
 201         break;
 202     default:
 203         jack_error("Parameter \"%s\" of internal \"%s\" is of unknown type %d",
 204                jackctl_parameter_get_name(parameter),
 205                jackctl_internal_get_name(internal),
 206                type);
 207     }
 208
 209     jackctl_parameter_set_value(parameter, &value);
 210 }
 211
 212 void
 213 jack_controller_settings_set_engine_option(
 214     struct jack_controller *controller_ptr,
 215     const char *option_name,
 216     const char *option_value)
 217 {
 218     jackctl_parameter_t *parameter;
 219     jackctl_param_type_t type;
 220     int value_int = 0;
 221     unsigned int value_uint = 0;
 222     union jackctl_parameter_value value;
 223
 224     jack_info("setting engine option \"%s\" to value \"%s\"", option_name, option_value);
 225
 226     if (strcmp(option_name, "driver") == 0)
 227     {
 228         if (!jack_controller_select_driver(controller_ptr, option_value))
 229         {
 230             jack_error("unknown driver '%s'", option_value);
 231         }
 232
 233         return;
 234     }
 235
 236     parameter = jack_controller_find_parameter(jackctl_server_get_parameters(controller_ptr->server), option_name);
 237     if (parameter == NULL)
 238     {
 239         jack_error(
 240             "Unknown engine parameter \"%s\"",
 241             option_name);
 242         return;
 243     }
 244
 245     type = jackctl_parameter_get_type(parameter);
 246
 247     switch (type)
 248     {
 249     case JackParamInt:
 250         jack_controller_settings_set_sint_option(option_value, &value_int);
 251         value.i = value_int;
 252         break;
 253     case JackParamUInt:
 254         jack_controller_settings_set_uint_option(option_value, &value_uint);
 255         value.ui = value_uint;
 256         break;
 257     case JackParamChar:
 258         jack_controller_settings_set_char_option(option_value, &value.c);
 259         break;
 260     case JackParamString:
 261         jack_controller_settings_set_string_option(option_value, value.str, sizeof(value.str));
 262         break;
 263     case JackParamBool:
 264         jack_controller_settings_set_bool_option(option_value, &value_int);
 265         value.i = value_int;
 266         break;
 267     default:
 268         jack_error("Engine parameter \"%s\" is of unknown type %d",
 269                jackctl_parameter_get_name(parameter),
 270                type);
 271     }
 272
 273     jackctl_parameter_set_value(parameter, &value);
 274 }
 275
 276 static
 277 bool
 278 jack_controller_settings_save_options(
 279     void *context,
 280     const JSList * parameters_list,
 281     void *dbus_call_context_ptr)
 282 {
 283     jackctl_parameter_t *parameter;
 284     jackctl_param_type_t type;
 285     union jackctl_parameter_value value;
 286     const char * name;
 287     char value_str[50];
 288
 289     while (parameters_list != NULL)
 290     {
 291         parameter = (jackctl_parameter_t *)parameters_list->data;
 292
 293         if (jackctl_parameter_is_set(parameter))
 294         {
 295             type = jackctl_parameter_get_type(parameter);
 296             value = jackctl_parameter_get_value(parameter);
 297             name = jackctl_parameter_get_name(parameter);
 298
 299             switch (type)
 300             {
 301             case JackParamInt:
 302                 sprintf(value_str, "%d", (int)value.i);
 303                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))
 304                 {
 305                     return false;
 306                 }
 307                 break;
 308             case JackParamUInt:
 309                 sprintf(value_str, "%u", (unsigned int)value.ui);
 310                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))
 311                 {
 312                     return false;
 313                 }
 314                 break;
 315             case JackParamChar:
 316                 sprintf(value_str, "%c", (char)value.c);
 317                 if (!jack_controller_settings_write_option(context, name, value_str, dbus_call_context_ptr))
 318                 {
 319                     return false;
 320                 }
 321                 break;
 322             case JackParamString:
 323                 if (!jack_controller_settings_write_option(context, name, value.str, dbus_call_context_ptr))
 324                 {
 325                     return false;
 326                 }
 327                 break;
 328             case JackParamBool:
 329                 if (!jack_controller_settings_write_option(context, name, value.b ? "true" : "false", dbus_call_context_ptr))
 330                 {
 331                     return false;
 332                 }
 333                 break;
 334             default:
 335                 jack_error("parameter of unknown type %d", type);
 336             }
 337         }
 338
 339         parameters_list = jack_slist_next(parameters_list);
 340     }
 341
 342     return true;
 343 }
 344
 345 bool
 346 jack_controller_settings_save_engine_options(
 347     void *context,
 348     struct jack_controller *controller_ptr,
 349     void *dbus_call_context_ptr)
 350 {
 351     if (controller_ptr->driver != NULL)
 352     {
 353         if (!jack_controller_settings_write_option(
 354                 context,
 355                 "driver",
 356                 jackctl_driver_get_name(controller_ptr->driver),
 357                 dbus_call_context_ptr))
 358         {
 359             return false;
 360         }
 361     }
 362
 363     return jack_controller_settings_save_options(context, jackctl_server_get_parameters(controller_ptr->server), dbus_call_context_ptr);
 364 }
 365
 366 bool
 367 jack_controller_settings_save_driver_options(
 368     void *context,
 369     jackctl_driver_t *driver,
 370     void *dbus_call_context_ptr)
 371 {
 372     return jack_controller_settings_save_options(context, jackctl_driver_get_parameters(driver), dbus_call_context_ptr);
 373 }
 374
 375 bool
 376 jack_controller_settings_save_internal_options(
 377     void *context,
 378     jackctl_internal_t *internal,
 379     void *dbus_call_context_ptr)
 380 {
 381     return jack_controller_settings_save_options(context, jackctl_internal_get_parameters(internal), dbus_call_context_ptr);
 382 }