proxies/jack_proxy.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009,2010,2011,2012 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains helper functionality for accessing JACK through D-Bus
   9  **************************************************************************
  10  *
  11  * LADI Session Handler is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * LADI Session Handler is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  23  * or write to the Free Software Foundation, Inc.,
  24  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "jack_proxy.h"
  28
  29 jack_proxy_callback_server_started g_on_server_started;
  30 jack_proxy_callback_server_stopped g_on_server_stopped;
  31 jack_proxy_callback_server_appeared g_on_server_appeared;
  32 jack_proxy_callback_server_disappeared g_on_server_disappeared;
  33
  34 static
  35 void
  36 on_jack_server_started(
  37   void * UNUSED(context),
  38   DBusMessage * UNUSED(message_ptr))
  39 {
  40   log_debug("JACK server start signal received.");
  41   if (g_on_server_started != NULL)
  42   {
  43     g_on_server_started();
  44   }
  45 }
  46
  47 static
  48 void
  49 on_jack_server_stopped(
  50   void * UNUSED(context),
  51   DBusMessage * UNUSED(message_ptr))
  52 {
  53   log_debug("JACK server stop signal received.");
  54   if (g_on_server_stopped != NULL)
  55   {
  56     g_on_server_stopped();
  57   }
  58 }
  59
  60 static void on_jack_life_status_changed(bool appeared)
  61 {
  62   if (appeared)
  63   {
  64     log_debug("JACK serivce appeared");
  65     if (g_on_server_appeared != NULL)
  66     {
  67       g_on_server_appeared();
  68     }
  69   }
  70   else
  71   {
  72     log_debug("JACK serivce disappeared");
  73     if (g_on_server_disappeared != NULL)
  74     {
  75       g_on_server_disappeared();
  76     }
  77   }
  78 }
  79
  80 /* this must be static because it is referenced by the
  81  * dbus helper layer when hooks are active */
  82 static struct cdbus_signal_hook g_control_signal_hooks[] =
  83 {
  84   {"ServerStarted", on_jack_server_started},
  85   {"ServerStopped", on_jack_server_stopped},
  86   {NULL, NULL}
  87 };
  88
  89 bool
  90 jack_proxy_init(
  91   jack_proxy_callback_server_started server_started,
  92   jack_proxy_callback_server_stopped server_stopped,
  93   jack_proxy_callback_server_appeared server_appeared,
  94   jack_proxy_callback_server_disappeared server_disappeared)
  95 {
  96   g_on_server_started = server_started;
  97   g_on_server_stopped = server_stopped;
  98   g_on_server_appeared = server_appeared;
  99   g_on_server_disappeared = server_disappeared;
 100
 101   if (!cdbus_register_service_lifetime_hook(cdbus_g_dbus_connection, JACKDBUS_SERVICE_NAME, on_jack_life_status_changed))
 102   {
 103     log_error("dbus_register_service_lifetime_hook() failed for jackdbus service");
 104     return false;
 105   }
 106
 107   if (!cdbus_register_object_signal_hooks(
 108         cdbus_g_dbus_connection,
 109         JACKDBUS_SERVICE_NAME,
 110         JACKDBUS_OBJECT_PATH,
 111         JACKDBUS_IFACE_CONTROL,
 112         NULL,
 113         g_control_signal_hooks))
 114   {
 115     cdbus_unregister_service_lifetime_hook(cdbus_g_dbus_connection, JACKDBUS_SERVICE_NAME);
 116     log_error("dbus_register_object_signal_hooks() failed for jackdbus control interface");
 117     return false;
 118   }
 119
 120   {
 121     bool started;
 122
 123     if (jack_proxy_is_started(&started))
 124     {
 125       if (g_on_server_appeared != NULL)
 126       {
 127         g_on_server_appeared();
 128       }
 129
 130       if (g_on_server_started != NULL && started)
 131       {
 132         g_on_server_started();
 133       }
 134     }
 135   }
 136
 137   return true;
 138 }
 139
 140 void
 141 jack_proxy_uninit(
 142   void)
 143 {
 144   cdbus_unregister_object_signal_hooks(cdbus_g_dbus_connection, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL);
 145   cdbus_unregister_service_lifetime_hook(cdbus_g_dbus_connection, JACKDBUS_SERVICE_NAME);
 146 }
 147
 148 bool
 149 jack_proxy_is_started(
 150   bool * started_ptr)
 151 {
 152   dbus_bool_t started;
 153
 154   if (!cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "IsStarted", "", "b", &started))
 155   {
 156     return false;
 157   }
 158
 159   *started_ptr = started;
 160   return true;
 161 }
 162
 163 bool
 164 jack_proxy_connect_ports(
 165   uint64_t UNUSED(port1_id),
 166   uint64_t UNUSED(port2_id))
 167 {
 168   /* not implemented */
 169   return false;
 170 }
 171
 172 static
 173 bool
 174 add_address(
 175   DBusMessageIter * iter_ptr,
 176   const char * address)
 177 {
 178   DBusMessageIter array_iter;
 179   const char * component;
 180
 181   if (!dbus_message_iter_open_container(iter_ptr, DBUS_TYPE_ARRAY, "s", &array_iter))
 182   {
 183     log_error("dbus_message_iter_open_container() failed.");
 184     return false;
 185   }
 186
 187   if (address != NULL)
 188   {
 189     component = address;
 190     while (*component != 0)
 191     {
 192       if (!dbus_message_iter_append_basic(&array_iter, DBUS_TYPE_STRING, &component))
 193       {
 194         log_error("dbus_message_iter_append_basic() failed.");
 195         return false;
 196       }
 197
 198       component += strlen(component) + 1;
 199     }
 200   }
 201
 202   dbus_message_iter_close_container(iter_ptr, &array_iter);
 203
 204   return true;
 205 }
 206
 207 bool
 208 jack_proxy_read_conf_container(
 209   const char * address,
 210   void * callback_context,
 211   bool (* callback)(void * context, bool leaf, const char * address, char * child))
 212 {
 213   DBusMessage * request_ptr;
 214   DBusMessage * reply_ptr;
 215   DBusMessageIter top_iter;
 216   DBusMessageIter array_iter;
 217   const char * reply_signature;
 218   dbus_bool_t leaf;           /* Whether children are parameters (true) or containers (false) */
 219   char * child;
 220
 221   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "ReadContainer");
 222   if (request_ptr == NULL)
 223   {
 224     log_error("dbus_message_new_method_call() failed.");
 225     return false;
 226   }
 227
 228   dbus_message_iter_init_append(request_ptr, &top_iter);
 229
 230   if (!add_address(&top_iter, address))
 231   {
 232     dbus_message_unref(request_ptr);
 233     return false;
 234   }
 235
 236   reply_ptr = cdbus_call_raw(0, request_ptr);
 237   dbus_message_unref(request_ptr);
 238   if (reply_ptr == NULL)
 239   {
 240     return false;
 241   }
 242
 243   reply_signature = dbus_message_get_signature(reply_ptr);
 244
 245   if (strcmp(reply_signature, "bas") != 0)
 246   {
 247     log_error("ReadContainer() reply signature mismatch. '%s'", reply_signature);
 248     dbus_message_unref(reply_ptr);
 249     return false;
 250   }
 251
 252   dbus_message_iter_init(reply_ptr, &top_iter);
 253
 254   dbus_message_iter_get_basic(&top_iter, &leaf);
 255   dbus_message_iter_next(&top_iter);
 256
 257   dbus_message_iter_recurse(&top_iter, &array_iter);
 258
 259   while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
 260   {
 261     dbus_message_iter_get_basic(&array_iter, &child);
 262
 263     if (!callback(callback_context, leaf, address, child))
 264     {
 265       break;
 266     }
 267
 268     dbus_message_iter_next(&array_iter);
 269   }
 270
 271   dbus_message_unref(reply_ptr);
 272
 273   return true;
 274 }
 275
 276 bool
 277 get_variant(
 278   DBusMessageIter * iter_ptr,
 279   struct jack_parameter_variant * parameter_ptr)
 280 {
 281   DBusMessageIter variant_iter;
 282   int type;
 283   dbus_bool_t boolean;
 284   dbus_int32_t int32;
 285   dbus_uint32_t uint32;
 286   char * string;
 287
 288   dbus_message_iter_recurse(iter_ptr, &variant_iter);
 289   log_debug("variant signature: '%s'", dbus_message_iter_get_signature(&variant_iter));
 290
 291   type = dbus_message_iter_get_arg_type(&variant_iter);
 292   switch (type)
 293   {
 294   case DBUS_TYPE_INT32:
 295     dbus_message_iter_get_basic(&variant_iter, &int32);
 296     parameter_ptr->value.int32 = int32;
 297     parameter_ptr->type = jack_int32;
 298     return true;
 299   case DBUS_TYPE_UINT32:
 300     dbus_message_iter_get_basic(&variant_iter, &uint32);
 301     parameter_ptr->value.uint32 = uint32;
 302     parameter_ptr->type = jack_uint32;
 303     return true;
 304   case DBUS_TYPE_BYTE:
 305     dbus_message_iter_get_basic(&variant_iter, &parameter_ptr->value.byte);
 306     parameter_ptr->type = jack_byte;
 307     return true;
 308   case DBUS_TYPE_STRING:
 309     dbus_message_iter_get_basic(&variant_iter, &string);
 310     string = strdup(string);
 311     if (string == NULL)
 312     {
 313       log_error("strdup failed.");
 314       return false;
 315     }
 316
 317     parameter_ptr->value.string = string;
 318     parameter_ptr->type = jack_string;
 319     return true;
 320   case DBUS_TYPE_BOOLEAN:
 321     dbus_message_iter_get_basic(&variant_iter, &boolean);
 322     parameter_ptr->value.boolean = boolean;
 323     parameter_ptr->type = jack_boolean;
 324     return true;
 325   }
 326
 327   log_error("Unknown D-Bus parameter type %i", (int)type);
 328   return false;
 329 }
 330
 331 bool
 332 jack_proxy_get_parameter_value(
 333   const char * address,
 334   bool * is_set_ptr,
 335   struct jack_parameter_variant * parameter_ptr)
 336 {
 337   DBusMessage * request_ptr;
 338   DBusMessage * reply_ptr;
 339   DBusMessageIter top_iter;
 340   const char * reply_signature;
 341   dbus_bool_t is_set;
 342   struct jack_parameter_variant default_value;
 343
 344   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "GetParameterValue");
 345   if (request_ptr == NULL)
 346   {
 347     log_error("dbus_message_new_method_call() failed.");
 348     return false;
 349   }
 350
 351   dbus_message_iter_init_append(request_ptr, &top_iter);
 352
 353   if (!add_address(&top_iter, address))
 354   {
 355     dbus_message_unref(request_ptr);
 356     return false;
 357   }
 358
 359   reply_ptr = cdbus_call_raw(0, request_ptr);
 360   dbus_message_unref(request_ptr);
 361   if (reply_ptr == NULL)
 362   {
 363     return false;
 364   }
 365
 366   reply_signature = dbus_message_get_signature(reply_ptr);
 367
 368   if (strcmp(reply_signature, "bvv") != 0)
 369   {
 370     log_error("GetParameterValue() reply signature mismatch. '%s'", reply_signature);
 371     dbus_message_unref(reply_ptr);
 372     return false;
 373   }
 374
 375   dbus_message_iter_init(reply_ptr, &top_iter);
 376
 377   dbus_message_iter_get_basic(&top_iter, &is_set);
 378   dbus_message_iter_next(&top_iter);
 379
 380   if (!get_variant(&top_iter, &default_value))
 381   {
 382     dbus_message_unref(reply_ptr);
 383     return false;
 384   }
 385
 386   if (default_value.type == jack_string)
 387   {
 388     free(default_value.value.string);
 389   }
 390
 391   dbus_message_iter_next(&top_iter);
 392
 393   if (!get_variant(&top_iter, parameter_ptr))
 394   {
 395     dbus_message_unref(reply_ptr);
 396     return false;
 397   }
 398
 399   dbus_message_unref(reply_ptr);
 400
 401   *is_set_ptr = is_set;
 402
 403   return true;
 404 }
 405
 406 bool
 407 jack_proxy_set_parameter_value(
 408   const char * address,
 409   const struct jack_parameter_variant * parameter_ptr)
 410 {
 411   DBusMessage * request_ptr;
 412   DBusMessage * reply_ptr;
 413   DBusMessageIter top_iter;
 414   const char * reply_signature;
 415   int type;
 416   const void * value_ptr;
 417   dbus_bool_t boolean;
 418
 419   switch (parameter_ptr->type)
 420   {
 421   case jack_int32:
 422     type = DBUS_TYPE_INT32;
 423     value_ptr = &parameter_ptr->value.int32;
 424     break;
 425   case jack_uint32:
 426     type = DBUS_TYPE_UINT32;
 427     value_ptr = &parameter_ptr->value.uint32;
 428     break;
 429   case jack_byte:
 430     type = DBUS_TYPE_BYTE;
 431     value_ptr = &parameter_ptr->value.byte;
 432     break;
 433   case jack_string:
 434     type = DBUS_TYPE_STRING;
 435     value_ptr = &parameter_ptr->value.string;
 436     break;
 437   case jack_boolean:
 438     type = DBUS_TYPE_BOOLEAN;
 439     boolean = parameter_ptr->value.boolean;
 440     value_ptr = &boolean;
 441     break;
 442   default:
 443     log_error("Unknown jack parameter type %i", (int)parameter_ptr->type);
 444     return false;
 445   }
 446
 447   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "SetParameterValue");
 448   if (request_ptr == NULL)
 449   {
 450     log_error("dbus_message_new_method_call() failed.");
 451     return false;
 452   }
 453
 454   dbus_message_iter_init_append(request_ptr, &top_iter);
 455
 456   if (!add_address(&top_iter, address))
 457   {
 458     dbus_message_unref(request_ptr);
 459     return false;
 460   }
 461
 462   if (!cdbus_iter_append_variant(&top_iter, type, value_ptr))
 463   {
 464     dbus_message_unref(request_ptr);
 465     return false;
 466   }
 467
 468   reply_ptr = cdbus_call_raw(0, request_ptr);
 469   dbus_message_unref(request_ptr);
 470   if (reply_ptr == NULL)
 471   {
 472     return false;
 473   }
 474
 475   reply_signature = dbus_message_get_signature(reply_ptr);
 476
 477   dbus_message_unref(reply_ptr);
 478
 479   if (strcmp(reply_signature, "") != 0)
 480   {
 481     log_error("SetParameterValue() reply signature mismatch. '%s'", reply_signature);
 482     return false;
 483   }
 484
 485   return true;
 486 }
 487
 488 bool
 489 jack_proxy_reset_parameter_value(
 490   const char * address)
 491 {
 492   DBusMessage * request_ptr;
 493   DBusMessage * reply_ptr;
 494   DBusMessageIter top_iter;
 495   const char * reply_signature;
 496
 497   request_ptr = dbus_message_new_method_call(JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONFIGURE, "ResetParameterValue");
 498   if (request_ptr == NULL)
 499   {
 500     log_error("dbus_message_new_method_call() failed.");
 501     return false;
 502   }
 503
 504   dbus_message_iter_init_append(request_ptr, &top_iter);
 505
 506   if (!add_address(&top_iter, address))
 507   {
 508     dbus_message_unref(request_ptr);
 509     return false;
 510   }
 511
 512   reply_ptr = cdbus_call_raw(0, request_ptr);
 513   dbus_message_unref(request_ptr);
 514   if (reply_ptr == NULL)
 515   {
 516     return false;
 517   }
 518
 519   reply_signature = dbus_message_get_signature(reply_ptr);
 520
 521   dbus_message_unref(reply_ptr);
 522
 523   if (strcmp(reply_signature, "") != 0)
 524   {
 525     log_error("ResetParameterValue() reply signature mismatch. '%s'", reply_signature);
 526     return false;
 527   }
 528
 529   return true;
 530 }
 531
 532 bool jack_proxy_start_server(void)
 533 {
 534   return cdbus_call(7000, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "StartServer", "", "");
 535 }
 536
 537 bool jack_proxy_stop_server(void)
 538 {
 539   return cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "StopServer", "", "");
 540 }
 541
 542 bool jack_proxy_is_realtime(bool * realtime_ptr)
 543 {
 544   dbus_bool_t realtime;
 545
 546   if (!cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "IsStarted", "", "b", &realtime))
 547   {
 548     return false;
 549   }
 550
 551   *realtime_ptr = realtime;
 552   return true;
 553 }
 554
 555 bool jack_proxy_sample_rate(uint32_t * sample_rate_ptr)
 556 {
 557   return cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetSampleRate", "", "u", sample_rate_ptr);
 558 }
 559
 560 bool jack_proxy_get_xruns(uint32_t * xruns_ptr)
 561 {
 562   return cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetXruns", "", "u", xruns_ptr);
 563 }
 564
 565 bool jack_proxy_get_dsp_load(double * dsp_load_ptr)
 566 {
 567   return cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetLoad", "", "d", dsp_load_ptr);
 568 }
 569
 570 bool jack_proxy_get_buffer_size(uint32_t * size_ptr)
 571 {
 572   return cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "GetBufferSize", "", "u", size_ptr);
 573 }
 574
 575 bool jack_proxy_set_buffer_size(uint32_t size)
 576 {
 577   return cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "SetBufferSize", "u", &size, "");
 578 }
 579
 580 bool jack_proxy_reset_xruns(void)
 581 {
 582   return cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "ResetXruns", "", "");
 583 }
 584
 585 static
 586 bool
 587 reset_callback(
 588   void * context,
 589   bool leaf,
 590   const char * address,
 591   char * child)
 592 {
 593   const char * component;
 594   char * dst;
 595   size_t len;
 596
 597   component = address;
 598   while (*component != 0)
 599   {
 600     component += strlen(component) + 1;
 601   }
 602
 603   /* address always is same buffer as the one in the jack_reset_all_params() stack */
 604   dst = (char *)component;
 605
 606   len = strlen(child) + 1;
 607   memcpy(dst, child, len);
 608   dst[len] = 0;
 609
 610   if (leaf)
 611   {
 612     if (!jack_proxy_reset_parameter_value(address))
 613     {
 614       log_error("cannot reset value of parameter");
 615       return false;
 616     }
 617   }
 618   else
 619   {
 620     if (!jack_proxy_read_conf_container(address, context, reset_callback))
 621     {
 622       log_error("cannot read container");
 623       return false;
 624     }
 625   }
 626
 627   *dst = 0;
 628
 629   return true;
 630 }
 631
 632 bool jack_reset_all_params(void)
 633 {
 634   char address[1024] = "";
 635
 636   return jack_proxy_read_conf_container(address, NULL, reset_callback);
 637 }
 638
 639 struct jack_proxy_session_save_one_reply_cookie
 640 {
 641   void * context;
 642   void (* callback)(void * context, const char * commandline);
 643 };
 644
 645 #define cookie_ptr ((struct jack_proxy_session_save_one_reply_cookie *)void_cookie)
 646
 647 static void jack_proxy_session_save_one_handle_reply(void * UNUSED(context), void * void_cookie, DBusMessage * reply_ptr)
 648 {
 649   const char * reply_signature;
 650   DBusMessageIter top_iter;
 651   DBusMessageIter array_iter;
 652   DBusMessageIter struct_iter;
 653   const char * uuid;
 654   const char * client_name;
 655   const char * commandline;
 656   uint32_t flags;
 657
 658   if (reply_ptr == NULL)
 659   {
 660     cookie_ptr->callback(cookie_ptr->context, NULL);
 661     return;
 662   }
 663
 664   reply_signature = dbus_message_get_signature(reply_ptr);
 665
 666   if (strcmp(reply_signature, "a(sssu)") != 0)
 667   {
 668     log_error(JACKDBUS_IFACE_SESSMGR ".Notify() reply signature mismatch. '%s'", reply_signature);
 669     return;
 670   }
 671
 672   dbus_message_iter_init(reply_ptr, &top_iter);
 673
 674   commandline = NULL;
 675
 676   for (dbus_message_iter_recurse(&top_iter, &array_iter);
 677        dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID;
 678        dbus_message_iter_next(&array_iter))
 679   {
 680     if (commandline != NULL)
 681     {
 682       log_error(JACKDBUS_IFACE_SESSMGR ".Notify() save returned more than one command");
 683       return;
 684     }
 685
 686     dbus_message_iter_recurse(&array_iter, &struct_iter);
 687
 688     dbus_message_iter_get_basic(&struct_iter, &uuid);
 689     dbus_message_iter_next(&struct_iter);
 690
 691     dbus_message_iter_get_basic(&struct_iter, &client_name);
 692     dbus_message_iter_next(&struct_iter);
 693
 694     dbus_message_iter_get_basic(&struct_iter, &commandline);
 695     dbus_message_iter_next(&struct_iter);
 696
 697     ASSERT(commandline != NULL);
 698
 699     dbus_message_iter_get_basic(&struct_iter, &flags);
 700     dbus_message_iter_next(&struct_iter);
 701
 702     dbus_message_iter_next(&struct_iter);
 703   }
 704
 705   if (commandline == NULL)
 706   {
 707     log_error(JACKDBUS_IFACE_SESSMGR ".Notify() save returned no commands");
 708     return;
 709   }
 710
 711   cookie_ptr->callback(cookie_ptr->context, commandline);
 712 }
 713
 714 #undef cookie_ptr
 715
 716 bool
 717 jack_proxy_session_save_one(
 718   bool queue,
 719   const char * target,
 720   const char * path,
 721   void * callback_context,
 722   void (* completion_callback)(
 723     void * context,
 724     const char * commandline))
 725 {
 726   bool ret;
 727   dbus_bool_t dbus_bool;
 728   dbus_uint32_t type;
 729   DBusMessage * request_ptr;
 730   struct jack_proxy_session_save_one_reply_cookie cookie;
 731
 732   dbus_bool = queue;
 733   type = JACKDBUS_SESSION_NOTIFY_TYPE_SAVE;
 734
 735   request_ptr = cdbus_new_method_call_message(
 736     JACKDBUS_SERVICE_NAME,
 737     JACKDBUS_OBJECT_PATH,
 738     JACKDBUS_IFACE_SESSMGR,
 739     "Notify",
 740     "bsus",
 741     &dbus_bool,
 742     &target,
 743     &type,
 744     &path,
 745     NULL);
 746   if (request_ptr == NULL)
 747   {
 748     return false;
 749   }
 750
 751   cookie.context = callback_context;
 752   cookie.callback = completion_callback;
 753
 754   ret = cdbus_call_async(request_ptr, callback_context, &cookie, sizeof(cookie), jack_proxy_session_save_one_handle_reply);
 755
 756   dbus_message_unref(request_ptr);
 757
 758   return ret;
 759 }
 760
 761 bool
 762 jack_proxy_session_has_callback(
 763   const char * client,
 764   bool * has_callback_ptr)
 765 {
 766   dbus_bool_t has_callback;
 767
 768   if (!cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_SESSMGR, "HasSessionCallback", "s", &client, "b", &has_callback))
 769   {
 770     return false;
 771   }
 772
 773   *has_callback_ptr = has_callback;
 774   return true;
 775 }
 776
 777 bool jack_proxy_exit(void)
 778 {
 779   if (!cdbus_call(0, JACKDBUS_SERVICE_NAME, JACKDBUS_OBJECT_PATH, JACKDBUS_IFACE_CONTROL, "Exit", "", ""))
 780   {
 781     log_error("Exit() failed.");
 782     return false;
 783   }
 784
 785   return true;
 786 }