proxies/graph_proxy.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 graph object that is backed 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 "graph_proxy.h"
  28
  29 struct monitor
  30 {
  31   struct list_head siblings;
  32   void * context;
  33   void (* clear)(void * context);
  34   void (* client_appeared)(void * context, uint64_t id, const char * name);
  35   void (* client_disappeared)(void * context, uint64_t id);
  36   void (* port_appeared)(void * context, uint64_t client_id, uint64_t port_id, const char * port_name, bool is_input, bool is_terminal, bool is_midi);
  37   void (* port_renamed)(void * context, uint64_t client_id, uint64_t port_id, const char * old_port_name, const char * new_port_name);
  38   void (* port_disappeared)(void * context, uint64_t client_id, uint64_t port_id);
  39   void (* ports_connected)(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id);
  40   void (* ports_disconnected)(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id);
  41 };
  42
  43 struct graph
  44 {
  45   struct list_head monitors;
  46   char * service;
  47   char * object;
  48   uint64_t version;
  49   bool active;
  50   bool graph_dict_supported;
  51 };
  52
  53 static struct dbus_signal_hook g_signal_hooks[];
  54
  55 static void clear(struct graph * graph_ptr)
  56 {
  57   struct list_head * node_ptr;
  58   struct monitor * monitor_ptr;
  59
  60   list_for_each(node_ptr, &graph_ptr->monitors)
  61   {
  62     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
  63     monitor_ptr->clear(monitor_ptr->context);
  64   }
  65 }
  66
  67 static void client_appeared(struct graph * graph_ptr, uint64_t id, const char * name)
  68 {
  69   struct list_head * node_ptr;
  70   struct monitor * monitor_ptr;
  71
  72   list_for_each(node_ptr, &graph_ptr->monitors)
  73   {
  74     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
  75     monitor_ptr->client_appeared(monitor_ptr->context, id, name);
  76   }
  77 }
  78
  79 static void client_disappeared(struct graph * graph_ptr, uint64_t id)
  80 {
  81   struct list_head * node_ptr;
  82   struct monitor * monitor_ptr;
  83
  84   list_for_each(node_ptr, &graph_ptr->monitors)
  85   {
  86     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
  87     monitor_ptr->client_disappeared(monitor_ptr->context, id);
  88   }
  89 }
  90
  91 static
  92 void
  93 port_appeared(
  94   struct graph * graph_ptr,
  95   uint64_t client_id,
  96   uint64_t port_id,
  97   const char * port_name,
  98   uint32_t port_flags,
  99   uint32_t port_type)
 100 {
 101   struct list_head * node_ptr;
 102   struct monitor * monitor_ptr;
 103   bool is_input;
 104   bool is_terminal;
 105   bool is_midi;
 106
 107   if (port_type != JACKDBUS_PORT_TYPE_AUDIO && port_type != JACKDBUS_PORT_TYPE_MIDI)
 108   {
 109     log_error("Unknown JACK D-Bus port type %d", (unsigned int)port_type);
 110     return;
 111   }
 112
 113   is_input = port_flags & JACKDBUS_PORT_FLAG_INPUT;
 114   is_terminal = port_flags & JACKDBUS_PORT_FLAG_TERMINAL;
 115   is_midi = port_type == JACKDBUS_PORT_TYPE_MIDI;
 116
 117   list_for_each(node_ptr, &graph_ptr->monitors)
 118   {
 119     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 120     monitor_ptr->port_appeared(monitor_ptr->context, client_id, port_id, port_name, is_input, is_terminal, is_midi);
 121   }
 122 }
 123
 124 static
 125 void
 126 port_disappeared(
 127   struct graph * graph_ptr,
 128   uint64_t client_id,
 129   uint64_t port_id)
 130 {
 131   struct list_head * node_ptr;
 132   struct monitor * monitor_ptr;
 133
 134   list_for_each(node_ptr, &graph_ptr->monitors)
 135   {
 136     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 137     monitor_ptr->port_disappeared(monitor_ptr->context, client_id, port_id);
 138   }
 139 }
 140
 141 static
 142 void
 143 port_renamed(
 144   struct graph * graph_ptr,
 145   uint64_t client_id,
 146   uint64_t port_id,
 147   const char * old_port_name,
 148   const char * new_port_name)
 149 {
 150   struct list_head * node_ptr;
 151   struct monitor * monitor_ptr;
 152
 153   list_for_each(node_ptr, &graph_ptr->monitors)
 154   {
 155     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 156     monitor_ptr->port_renamed(monitor_ptr->context, client_id, port_id, old_port_name, new_port_name);
 157   }
 158 }
 159
 160 static
 161 void
 162 ports_connected(
 163   struct graph * graph_ptr,
 164   uint64_t client1_id,
 165   uint64_t port1_id,
 166   uint64_t client2_id,
 167   uint64_t port2_id)
 168 {
 169   struct list_head * node_ptr;
 170   struct monitor * monitor_ptr;
 171
 172   list_for_each(node_ptr, &graph_ptr->monitors)
 173   {
 174     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 175     monitor_ptr->ports_connected(monitor_ptr->context, client1_id, port1_id, client2_id, port2_id);
 176   }
 177 }
 178
 179 static
 180 void
 181 ports_disconnected(
 182   struct graph * graph_ptr,
 183   uint64_t client1_id,
 184   uint64_t port1_id,
 185   uint64_t client2_id,
 186   uint64_t port2_id)
 187 {
 188   struct list_head * node_ptr;
 189   struct monitor * monitor_ptr;
 190
 191   list_for_each(node_ptr, &graph_ptr->monitors)
 192   {
 193     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 194     monitor_ptr->ports_disconnected(monitor_ptr->context, client1_id, port1_id, client2_id, port2_id);
 195   }
 196 }
 197
 198 static void refresh_internal(struct graph * graph_ptr, bool force)
 199 {
 200   DBusMessage* reply_ptr;
 201   DBusMessageIter iter;
 202   dbus_uint64_t version;
 203   const char * reply_signature;
 204   DBusMessageIter clients_array_iter;
 205   DBusMessageIter client_struct_iter;
 206   DBusMessageIter ports_array_iter;
 207   DBusMessageIter port_struct_iter;
 208   DBusMessageIter connections_array_iter;
 209   DBusMessageIter connection_struct_iter;
 210   dbus_uint64_t client_id;
 211   const char *client_name;
 212   dbus_uint64_t port_id;
 213   const char *port_name;
 214   dbus_uint32_t port_flags;
 215   dbus_uint32_t port_type;
 216   dbus_uint64_t client2_id;
 217   const char *client2_name;
 218   dbus_uint64_t port2_id;
 219   const char *port2_name;
 220   dbus_uint64_t connection_id;
 221
 222   log_info("refresh_internal() called");
 223
 224   if (force)
 225   {
 226     version = 0; // workaround module split/join stupidity
 227   }
 228   else
 229   {
 230     version = graph_ptr->version;
 231   }
 232
 233   if (!dbus_call(graph_ptr->service, graph_ptr->object, JACKDBUS_IFACE_PATCHBAY, "GetGraph", "t", &version, NULL, &reply_ptr))
 234   {
 235     log_error("GetGraph() failed.");
 236     return;
 237   }
 238
 239   reply_signature = dbus_message_get_signature(reply_ptr);
 240
 241   if (strcmp(reply_signature, "ta(tsa(tsuu))a(tstststst)") != 0)
 242   {
 243     log_error("GetGraph() reply signature mismatch. '%s'", reply_signature);
 244     goto unref;
 245   }
 246
 247   dbus_message_iter_init(reply_ptr, &iter);
 248
 249   //log_info_msg("version " + (char)dbus_message_iter_get_arg_type(&iter));
 250   dbus_message_iter_get_basic(&iter, &version);
 251   dbus_message_iter_next(&iter);
 252
 253   if (!force && version <= graph_ptr->version)
 254   {
 255     goto unref;
 256   }
 257
 258   clear(graph_ptr);
 259
 260   //log_info("got new graph version %llu", (unsigned long long)version);
 261   graph_ptr->version = version;
 262
 263   //info_msg((std::string)"clients " + (char)dbus_message_iter_get_arg_type(&iter));
 264
 265   for (dbus_message_iter_recurse(&iter, &clients_array_iter);
 266        dbus_message_iter_get_arg_type(&clients_array_iter) != DBUS_TYPE_INVALID;
 267        dbus_message_iter_next(&clients_array_iter))
 268   {
 269     //info_msg((std::string)"a client " + (char)dbus_message_iter_get_arg_type(&clients_array_iter));
 270     dbus_message_iter_recurse(&clients_array_iter, &client_struct_iter);
 271
 272     dbus_message_iter_get_basic(&client_struct_iter, &client_id);
 273     dbus_message_iter_next(&client_struct_iter);
 274
 275     dbus_message_iter_get_basic(&client_struct_iter, &client_name);
 276     dbus_message_iter_next(&client_struct_iter);
 277
 278     //info_msg((std::string)"client '" + client_name + "'");
 279
 280     client_appeared(graph_ptr, client_id, client_name);
 281
 282     for (dbus_message_iter_recurse(&client_struct_iter, &ports_array_iter);
 283          dbus_message_iter_get_arg_type(&ports_array_iter) != DBUS_TYPE_INVALID;
 284          dbus_message_iter_next(&ports_array_iter))
 285     {
 286       //info_msg((std::string)"a port " + (char)dbus_message_iter_get_arg_type(&ports_array_iter));
 287       dbus_message_iter_recurse(&ports_array_iter, &port_struct_iter);
 288
 289       dbus_message_iter_get_basic(&port_struct_iter, &port_id);
 290       dbus_message_iter_next(&port_struct_iter);
 291
 292       dbus_message_iter_get_basic(&port_struct_iter, &port_name);
 293       dbus_message_iter_next(&port_struct_iter);
 294
 295       dbus_message_iter_get_basic(&port_struct_iter, &port_flags);
 296       dbus_message_iter_next(&port_struct_iter);
 297
 298       dbus_message_iter_get_basic(&port_struct_iter, &port_type);
 299       dbus_message_iter_next(&port_struct_iter);
 300
 301       //info_msg((std::string)"port: " + port_name);
 302
 303       port_appeared(graph_ptr, client_id, port_id, port_name, port_flags, port_type);
 304     }
 305
 306     dbus_message_iter_next(&client_struct_iter);
 307   }
 308
 309   dbus_message_iter_next(&iter);
 310
 311   for (dbus_message_iter_recurse(&iter, &connections_array_iter);
 312        dbus_message_iter_get_arg_type(&connections_array_iter) != DBUS_TYPE_INVALID;
 313        dbus_message_iter_next(&connections_array_iter))
 314   {
 315     //info_msg((std::string)"a connection " + (char)dbus_message_iter_get_arg_type(&connections_array_iter));
 316     dbus_message_iter_recurse(&connections_array_iter, &connection_struct_iter);
 317
 318     dbus_message_iter_get_basic(&connection_struct_iter, &client_id);
 319     dbus_message_iter_next(&connection_struct_iter);
 320
 321     dbus_message_iter_get_basic(&connection_struct_iter, &client_name);
 322     dbus_message_iter_next(&connection_struct_iter);
 323
 324     dbus_message_iter_get_basic(&connection_struct_iter, &port_id);
 325     dbus_message_iter_next(&connection_struct_iter);
 326
 327     dbus_message_iter_get_basic(&connection_struct_iter, &port_name);
 328     dbus_message_iter_next(&connection_struct_iter);
 329
 330     dbus_message_iter_get_basic(&connection_struct_iter, &client2_id);
 331     dbus_message_iter_next(&connection_struct_iter);
 332
 333     dbus_message_iter_get_basic(&connection_struct_iter, &client2_name);
 334     dbus_message_iter_next(&connection_struct_iter);
 335
 336     dbus_message_iter_get_basic(&connection_struct_iter, &port2_id);
 337     dbus_message_iter_next(&connection_struct_iter);
 338
 339     dbus_message_iter_get_basic(&connection_struct_iter, &port2_name);
 340     dbus_message_iter_next(&connection_struct_iter);
 341
 342     dbus_message_iter_get_basic(&connection_struct_iter, &connection_id);
 343     dbus_message_iter_next(&connection_struct_iter);
 344
 345     //info_msg(str(boost::format("connection(%llu) %s(%llu):%s(%llu) <-> %s(%llu):%s(%llu)") %
 346     //    connection_id %
 347     //    client_name %
 348     //    client_id %
 349     //    port_name %
 350     //    port_id %
 351     //    client2_name %
 352     //    client2_id %
 353     //    port2_name %
 354     //    port2_id));
 355
 356     ports_connected(graph_ptr, client_id, port_id, client2_id, port2_id);
 357   }
 358
 359 unref:
 360   dbus_message_unref(reply_ptr);
 361 }
 362
 363 bool
 364 graph_proxy_create(
 365   const char * service,
 366   const char * object,
 367   bool graph_dict_supported,
 368   graph_proxy_handle * graph_proxy_handle_ptr)
 369 {
 370   struct graph * graph_ptr;
 371
 372   graph_ptr = malloc(sizeof(struct graph));
 373   if (graph_ptr == NULL)
 374   {
 375     log_error("malloc() failed to allocate struct graph");
 376     goto fail;
 377   }
 378
 379   graph_ptr->service = strdup(service);
 380   if (graph_ptr->service == NULL)
 381   {
 382     log_error("strdup() failed too duplicate service name '%s'", service);
 383     goto free_graph;
 384   }
 385
 386   graph_ptr->object = strdup(object);
 387   if (graph_ptr->object == NULL)
 388   {
 389     log_error("strdup() failed too duplicate object name '%s'", object);
 390     goto free_service;
 391   }
 392
 393   INIT_LIST_HEAD(&graph_ptr->monitors);
 394
 395   graph_ptr->version = 0;
 396   graph_ptr->active = false;
 397
 398   graph_ptr->graph_dict_supported = graph_dict_supported;
 399
 400   *graph_proxy_handle_ptr = (graph_proxy_handle)graph_ptr;
 401
 402   return true;
 403
 404 free_service:
 405   free(graph_ptr->service);
 406
 407 free_graph:
 408   free(graph_ptr);
 409
 410 fail:
 411   return false;
 412 }
 413
 414 #define graph_ptr ((struct graph *)graph)
 415
 416 const char * graph_proxy_get_service(graph_proxy_handle graph)
 417 {
 418   return graph_ptr->service;
 419 }
 420
 421 const char * graph_proxy_get_object(graph_proxy_handle graph)
 422 {
 423   return graph_ptr->object;
 424 }
 425
 426 void
 427 graph_proxy_destroy(
 428   graph_proxy_handle graph)
 429 {
 430   ASSERT(list_empty(&graph_ptr->monitors));
 431
 432   if (graph_ptr->active)
 433   {
 434     dbus_unregister_object_signal_hooks(
 435       g_dbus_connection,
 436       graph_ptr->service,
 437       graph_ptr->object,
 438       JACKDBUS_IFACE_PATCHBAY);
 439   }
 440
 441   free(graph_ptr->object);
 442   free(graph_ptr->service);
 443   free(graph_ptr);
 444 }
 445
 446 bool
 447 graph_proxy_activate(
 448   graph_proxy_handle graph)
 449 {
 450   if (list_empty(&graph_ptr->monitors))
 451   {
 452     log_error("no monitors to activate");
 453     return false;
 454   }
 455
 456   if (graph_ptr->active)
 457   {
 458     log_error("graph already active");
 459     return false;
 460   }
 461
 462   if (!dbus_register_object_signal_hooks(
 463         g_dbus_connection,
 464         graph_ptr->service,
 465         graph_ptr->object,
 466         JACKDBUS_IFACE_PATCHBAY,
 467         graph_ptr,
 468         g_signal_hooks))
 469   {
 470     return false;
 471   }
 472
 473   graph_ptr->active = true;
 474
 475   refresh_internal(graph_ptr, true);
 476
 477   return true;
 478 }
 479
 480 bool
 481 graph_proxy_attach(
 482   graph_proxy_handle graph,
 483   void * context,
 484   void (* clear)(void * context),
 485   void (* client_appeared)(void * context, uint64_t id, const char * name),
 486   void (* client_disappeared)(void * context, uint64_t id),
 487   void (* port_appeared)(void * context, uint64_t client_id, uint64_t port_id, const char * port_name, bool is_input, bool is_terminal, bool is_midi),
 488   void (* port_renamed)(void * context, uint64_t client_id, uint64_t port_id, const char * old_port_name, const char * new_port_name),
 489   void (* port_disappeared)(void * context, uint64_t client_id, uint64_t port_id),
 490   void (* ports_connected)(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id),
 491   void (* ports_disconnected)(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id))
 492 {
 493   struct monitor * monitor_ptr;
 494
 495   if (graph_ptr->active)
 496   {
 497     return false;
 498   }
 499
 500   monitor_ptr = malloc(sizeof(struct monitor));
 501   if (monitor_ptr == NULL)
 502   {
 503     log_error("malloc() failed to allocate struct monitor");
 504     return false;
 505   }
 506
 507   monitor_ptr->context = context;
 508   monitor_ptr->clear = clear;
 509   monitor_ptr->client_appeared = client_appeared;
 510   monitor_ptr->client_disappeared = client_disappeared;
 511   monitor_ptr->port_appeared = port_appeared;
 512   monitor_ptr->port_renamed = port_renamed;
 513   monitor_ptr->port_disappeared = port_disappeared;
 514   monitor_ptr->ports_connected = ports_connected;
 515   monitor_ptr->ports_disconnected = ports_disconnected;
 516
 517   list_add_tail(&monitor_ptr->siblings, &graph_ptr->monitors);
 518
 519   return true;
 520 }
 521
 522 void
 523 graph_proxy_detach(
 524   graph_proxy_handle graph,
 525   void * context)
 526 {
 527   struct list_head * node_ptr;
 528   struct monitor * monitor_ptr;
 529
 530   list_for_each(node_ptr, &graph_ptr->monitors)
 531   {
 532     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 533     if (monitor_ptr->context == context)
 534     {
 535       list_del(&monitor_ptr->siblings);
 536       free(monitor_ptr);
 537       return;
 538     }
 539   }
 540
 541   ASSERT(false);
 542 }
 543
 544 void
 545 graph_proxy_connect_ports(
 546   graph_proxy_handle graph,
 547   uint64_t port1_id,
 548   uint64_t port2_id)
 549 {
 550   if (!dbus_call(graph_ptr->service, graph_ptr->object, JACKDBUS_IFACE_PATCHBAY, "ConnectPortsByID", "tt", &port1_id, &port2_id, ""))
 551   {
 552     log_error("ConnectPortsByID() failed.");
 553   }
 554 }
 555
 556 void
 557 graph_proxy_disconnect_ports(
 558   graph_proxy_handle graph,
 559   uint64_t port1_id,
 560   uint64_t port2_id)
 561 {
 562   if (!dbus_call(graph_ptr->service, graph_ptr->object, JACKDBUS_IFACE_PATCHBAY, "DisconnectPortsByID", "tt", &port1_id, &port2_id, ""))
 563   {
 564     log_error("DisconnectPortsByID() failed.");
 565   }
 566 }
 567
 568 static void on_client_appeared(void * graph, DBusMessage * message_ptr)
 569 {
 570   dbus_uint64_t new_graph_version;
 571   dbus_uint64_t client_id;
 572   const char * client_name;
 573
 574   if (!dbus_message_get_args(
 575         message_ptr,
 576         &g_dbus_error,
 577         DBUS_TYPE_UINT64, &new_graph_version,
 578         DBUS_TYPE_UINT64, &client_id,
 579         DBUS_TYPE_STRING, &client_name,
 580         DBUS_TYPE_INVALID))
 581   {
 582     log_error("dbus_message_get_args() failed to extract ClientAppeared signal arguments (%s)", g_dbus_error.message);
 583     dbus_error_free(&g_dbus_error);
 584     return;
 585   }
 586
 587   //log_info("ClientAppeared, %s(%llu), graph %llu", client_name, client_id, new_graph_version);
 588
 589   if (new_graph_version > graph_ptr->version)
 590   {
 591     //log_info("got new graph version %llu", (unsigned long long)new_graph_version);
 592     graph_ptr->version = new_graph_version;
 593     client_appeared(graph_ptr, client_id, client_name);
 594   }
 595 }
 596
 597 static void on_client_disappeared(void * graph, DBusMessage * message_ptr)
 598 {
 599   dbus_uint64_t new_graph_version;
 600   dbus_uint64_t client_id;
 601   const char * client_name;
 602
 603   if (!dbus_message_get_args(
 604         message_ptr,
 605         &g_dbus_error,
 606         DBUS_TYPE_UINT64, &new_graph_version,
 607         DBUS_TYPE_UINT64, &client_id,
 608         DBUS_TYPE_STRING, &client_name,
 609         DBUS_TYPE_INVALID))
 610   {
 611     log_error("dbus_message_get_args() failed to extract ClientDisappeared signal arguments (%s)", g_dbus_error.message);
 612     dbus_error_free(&g_dbus_error);
 613     return;
 614   }
 615
 616   //log_info("ClientDisappeared, %s(%llu)", client_name, client_id);
 617
 618   if (new_graph_version > graph_ptr->version)
 619   {
 620     //log_info("got new graph version %llu", (unsigned long long)new_graph_version);
 621     graph_ptr->version = new_graph_version;
 622     client_disappeared(graph_ptr, client_id);
 623   }
 624 }
 625
 626 static void on_port_appeared(void * graph, DBusMessage * message_ptr)
 627 {
 628   dbus_uint64_t new_graph_version;
 629   dbus_uint64_t client_id;
 630   const char * client_name;
 631   dbus_uint64_t port_id;
 632   const char * port_name;
 633   dbus_uint32_t port_flags;
 634   dbus_uint32_t port_type;
 635
 636   if (!dbus_message_get_args(
 637         message_ptr,
 638         &g_dbus_error,
 639         DBUS_TYPE_UINT64, &new_graph_version,
 640         DBUS_TYPE_UINT64, &client_id,
 641         DBUS_TYPE_STRING, &client_name,
 642         DBUS_TYPE_UINT64, &port_id,
 643         DBUS_TYPE_STRING, &port_name,
 644         DBUS_TYPE_UINT32, &port_flags,
 645         DBUS_TYPE_UINT32, &port_type,
 646         DBUS_TYPE_INVALID))
 647   {
 648     log_error("dbus_message_get_args() failed to extract PortAppeared signal arguments (%s)", g_dbus_error.message);
 649     dbus_error_free(&g_dbus_error);
 650     return;
 651   }
 652
 653   //me->info_msg(str(boost::format("PortAppeared, %s(%llu):%s(%llu), %lu, %lu") % client_name % client_id % port_name % port_id % port_flags % port_type));
 654
 655   if (new_graph_version > graph_ptr->version)
 656   {
 657     //log_info("got new graph version %llu", (unsigned long long)new_graph_version);
 658     graph_ptr->version = new_graph_version;
 659     port_appeared(graph_ptr, client_id, port_id, port_name, port_flags, port_type);
 660   }
 661 }
 662
 663 static void on_port_renamed(void * graph, DBusMessage * message_ptr)
 664 {
 665   dbus_uint64_t new_graph_version;
 666   dbus_uint64_t client_id;
 667   const char * client_name;
 668   dbus_uint64_t port_id;
 669   const char * old_port_name;
 670   const char * new_port_name;
 671
 672   if (!dbus_message_get_args(
 673         message_ptr,
 674         &g_dbus_error,
 675         DBUS_TYPE_UINT64, &new_graph_version,
 676         DBUS_TYPE_UINT64, &client_id,
 677         DBUS_TYPE_STRING, &client_name,
 678         DBUS_TYPE_UINT64, &port_id,
 679         DBUS_TYPE_STRING, &old_port_name,
 680         DBUS_TYPE_STRING, &new_port_name,
 681         DBUS_TYPE_INVALID))
 682   {
 683     log_error("dbus_message_get_args() failed to extract PortRenamed signal arguments (%s)", g_dbus_error.message);
 684     dbus_error_free(&g_dbus_error);
 685     return;
 686   }
 687
 688   if (new_graph_version > graph_ptr->version)
 689   {
 690     //log_info("got new graph version %llu", (unsigned long long)new_graph_version);
 691     graph_ptr->version = new_graph_version;
 692     port_renamed(graph_ptr, client_id, port_id, old_port_name, new_port_name);
 693   }
 694 }
 695
 696 static void on_port_disappeared(void * graph, DBusMessage * message_ptr)
 697 {
 698   dbus_uint64_t new_graph_version;
 699   dbus_uint64_t client_id;
 700   const char * client_name;
 701   dbus_uint64_t port_id;
 702   const char * port_name;
 703
 704   if (!dbus_message_get_args(
 705         message_ptr,
 706         &g_dbus_error,
 707         DBUS_TYPE_UINT64, &new_graph_version,
 708         DBUS_TYPE_UINT64, &client_id,
 709         DBUS_TYPE_STRING, &client_name,
 710         DBUS_TYPE_UINT64, &port_id,
 711         DBUS_TYPE_STRING, &port_name,
 712         DBUS_TYPE_INVALID))
 713   {
 714     log_error("dbus_message_get_args() failed to extract PortDisappeared signal arguments (%s)", g_dbus_error.message);
 715     dbus_error_free(&g_dbus_error);
 716     return;
 717   }
 718
 719   //me->info_msg(str(boost::format("PortDisappeared, %s(%llu):%s(%llu)") % client_name % client_id % port_name % port_id));
 720
 721   if (new_graph_version > graph_ptr->version)
 722   {
 723     //log_info("got new graph version %llu", (unsigned long long)new_graph_version);
 724     graph_ptr->version = new_graph_version;
 725     port_disappeared(graph_ptr, client_id, port_id);
 726   }
 727 }
 728
 729 static void on_ports_connected(void * graph, DBusMessage * message_ptr)
 730 {
 731   dbus_uint64_t new_graph_version;
 732   dbus_uint64_t client_id;
 733   const char * client_name;
 734   dbus_uint64_t port_id;
 735   const char * port_name;
 736   dbus_uint64_t client2_id;
 737   const char * client2_name;
 738   dbus_uint64_t port2_id;
 739   const char * port2_name;
 740   dbus_uint64_t connection_id;
 741
 742   if (!dbus_message_get_args(
 743         message_ptr,
 744         &g_dbus_error,
 745         DBUS_TYPE_UINT64, &new_graph_version,
 746         DBUS_TYPE_UINT64, &client_id,
 747         DBUS_TYPE_STRING, &client_name,
 748         DBUS_TYPE_UINT64, &port_id,
 749         DBUS_TYPE_STRING, &port_name,
 750         DBUS_TYPE_UINT64, &client2_id,
 751         DBUS_TYPE_STRING, &client2_name,
 752         DBUS_TYPE_UINT64, &port2_id,
 753         DBUS_TYPE_STRING, &port2_name,
 754         DBUS_TYPE_UINT64, &connection_id,
 755         DBUS_TYPE_INVALID))
 756   {
 757     log_error("dbus_message_get_args() failed to extract PortsConnected signal arguments (%s)", g_dbus_error.message);
 758     dbus_error_free(&g_dbus_error);
 759     return;
 760   }
 761
 762   if (new_graph_version > graph_ptr->version)
 763   {
 764     //log_info("got new graph version %llu", (unsigned long long)new_graph_version);
 765     graph_ptr->version = new_graph_version;
 766     ports_connected(graph_ptr, client_id, port_id, client2_id, port2_id);
 767   }
 768 }
 769
 770 static void on_ports_disconnected(void * graph, DBusMessage * message_ptr)
 771 {
 772   dbus_uint64_t new_graph_version;
 773   dbus_uint64_t client_id;
 774   const char * client_name;
 775   dbus_uint64_t port_id;
 776   const char * port_name;
 777   dbus_uint64_t client2_id;
 778   const char * client2_name;
 779   dbus_uint64_t port2_id;
 780   const char * port2_name;
 781   dbus_uint64_t connection_id;
 782
 783   if (!dbus_message_get_args(
 784         message_ptr,
 785         &g_dbus_error,
 786         DBUS_TYPE_UINT64, &new_graph_version,
 787         DBUS_TYPE_UINT64, &client_id,
 788         DBUS_TYPE_STRING, &client_name,
 789         DBUS_TYPE_UINT64, &port_id,
 790         DBUS_TYPE_STRING, &port_name,
 791         DBUS_TYPE_UINT64, &client2_id,
 792         DBUS_TYPE_STRING, &client2_name,
 793         DBUS_TYPE_UINT64, &port2_id,
 794         DBUS_TYPE_STRING, &port2_name,
 795         DBUS_TYPE_UINT64, &connection_id,
 796         DBUS_TYPE_INVALID))
 797   {
 798     log_error("dbus_message_get_args() failed to extract PortsConnected signal arguments (%s)", g_dbus_error.message);
 799     dbus_error_free(&g_dbus_error);
 800     return;
 801   }
 802
 803   if (new_graph_version > graph_ptr->version)
 804   {
 805     //log_info("got new graph version %llu", (unsigned long long)new_graph_version);
 806     graph_ptr->version = new_graph_version;
 807     ports_disconnected(graph_ptr, client_id, port_id, client2_id, port2_id);
 808   }
 809 }
 810
 811 bool
 812 graph_proxy_dict_entry_set(
 813   graph_proxy_handle graph,
 814   uint32_t object_type,
 815   uint64_t object_id,
 816   const char * key,
 817   const char * value)
 818 {
 819   if (!graph_ptr->graph_dict_supported)
 820   {
 821     return false;
 822   }
 823
 824   if (!dbus_call(graph_ptr->service, graph_ptr->object, IFACE_GRAPH_DICT, "Set", "utss", &object_type, &object_id, &key, &value, ""))
 825   {
 826     log_error(IFACE_GRAPH_DICT ".Set() failed.");
 827     return false;
 828   }
 829
 830   return true;
 831 }
 832
 833 bool
 834 graph_proxy_dict_entry_get(
 835   graph_proxy_handle graph,
 836   uint32_t object_type,
 837   uint64_t object_id,
 838   const char * key,
 839   char ** value_ptr_ptr)
 840 {
 841   DBusMessage * reply_ptr;
 842   const char * reply_signature;
 843   DBusMessageIter iter;
 844   const char * cvalue_ptr;
 845   char * value_ptr;
 846
 847   if (!graph_ptr->graph_dict_supported)
 848   {
 849     return false;
 850   }
 851
 852   if (!dbus_call(graph_ptr->service, graph_ptr->object, IFACE_GRAPH_DICT, "Get", "uts", &object_type, &object_id, &key, NULL, &reply_ptr))
 853   {
 854     log_error(IFACE_GRAPH_DICT ".Get() failed.");
 855     return false;
 856   }
 857
 858   reply_signature = dbus_message_get_signature(reply_ptr);
 859
 860   if (strcmp(reply_signature, "s") != 0)
 861   {
 862     log_error("reply signature is '%s' but expected signature is 's'", reply_signature);
 863     dbus_message_unref(reply_ptr);
 864     return false;
 865   }
 866
 867   dbus_message_iter_init(reply_ptr, &iter);
 868   dbus_message_iter_get_basic(&iter, &cvalue_ptr);
 869   value_ptr = strdup(cvalue_ptr);
 870   dbus_message_unref(reply_ptr);
 871   if (value_ptr == NULL)
 872   {
 873     log_error("strdup() failed for dict value");
 874     return false;
 875   }
 876   *value_ptr_ptr = value_ptr;
 877   return true;
 878 }
 879
 880 bool
 881 graph_proxy_dict_entry_drop(
 882   graph_proxy_handle graph,
 883   uint32_t object_type,
 884   uint64_t object_id,
 885   const char * key)
 886 {
 887   if (!graph_ptr->graph_dict_supported)
 888   {
 889     return false;
 890   }
 891
 892   if (!dbus_call(graph_ptr->service, graph_ptr->object, IFACE_GRAPH_DICT, "Drop", "uts", &object_type, &object_id, &key, ""))
 893   {
 894     log_error(IFACE_GRAPH_DICT ".Drop() failed.");
 895     return false;
 896   }
 897
 898   return true;
 899 }
 900
 901 bool graph_proxy_get_client_pid(graph_proxy_handle graph, uint64_t client_id, int64_t * pid_ptr)
 902 {
 903   if (!dbus_call(graph_ptr->service, graph_ptr->object, JACKDBUS_IFACE_PATCHBAY, "GetClientPID", "t", &client_id, "x", pid_ptr))
 904   {
 905     log_error("GetClientPID() failed.");
 906     return false;
 907   }
 908
 909   return true;
 910 }
 911
 912 /* this must be static because it is referenced by the
 913  * dbus helper layer when hooks are active */
 914 static struct dbus_signal_hook g_signal_hooks[] =
 915 {
 916   {"ClientAppeared", on_client_appeared},
 917   {"ClientDisappeared", on_client_disappeared},
 918   {"PortAppeared", on_port_appeared},
 919   {"PortRenamed", on_port_renamed},
 920   {"PortDisappeared", on_port_disappeared},
 921   {"PortsConnected", on_ports_connected},
 922   {"PortsDisconnected", on_ports_disconnected},
 923   {NULL, NULL}
 924 };