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 <dbus/dbus.h>
  28 #include <stdlib.h>
  29 #include <assert.h>
  30
  31 #include "common.h"
  32 #include "graph_proxy.h"
  33 #include "common/klist.h"
  34 #include "common/debug.h"
  35 #include "dbus/helpers.h"
  36 #include "dbus_constants.h"
  37
  38 #define JACKDBUS_PORT_FLAG_INPUT         0x00000001
  39 #define JACKDBUS_PORT_FLAG_OUTPUT        0x00000002
  40 #define JACKDBUS_PORT_FLAG_PHYSICAL      0x00000004
  41 #define JACKDBUS_PORT_FLAG_CAN_MONITOR   0x00000008
  42 #define JACKDBUS_PORT_FLAG_TERMINAL      0x00000010
  43
  44 #define JACKDBUS_PORT_TYPE_AUDIO    0
  45 #define JACKDBUS_PORT_TYPE_MIDI     1
  46
  47 struct monitor
  48 {
  49   struct list_head siblings;
  50   void * context;
  51   void (* clear)(void * context);
  52   void (* client_appeared)(void * context, uint64_t id, const char * name);
  53   void (* client_disappeared)(void * context, uint64_t id);
  54   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);
  55   void (* port_disappeared)(void * context, uint64_t client_id, uint64_t port_id);
  56   void (* ports_connected)(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id);
  57   void (* ports_disconnected)(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id);
  58 };
  59
  60 struct graph
  61 {
  62   struct list_head monitors;
  63   char * service;
  64   char * object;
  65   uint64_t version;
  66   bool active;
  67 };
  68
  69 static DBusHandlerResult message_hook(DBusConnection *, DBusMessage *, void *);
  70
  71 static const char * g_signals[] =
  72 {
  73   "ClientAppeared",
  74   "ClientDisappeared",
  75   "PortAppeared",
  76   "PortDisappeared",
  77   "PortsConnected",
  78   "PortsDisconnected",
  79   NULL
  80 };
  81
  82 static void clear(struct graph * graph_ptr)
  83 {
  84   struct list_head * node_ptr;
  85   struct monitor * monitor_ptr;
  86
  87   list_for_each(node_ptr, &graph_ptr->monitors)
  88   {
  89     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
  90     monitor_ptr->clear(monitor_ptr->context);
  91   }
  92 }
  93
  94 static void client_appeared(struct graph * graph_ptr, uint64_t id, const char * name)
  95 {
  96   struct list_head * node_ptr;
  97   struct monitor * monitor_ptr;
  98
  99   list_for_each(node_ptr, &graph_ptr->monitors)
 100   {
 101     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 102     monitor_ptr->client_appeared(monitor_ptr->context, id, name);
 103   }
 104 }
 105
 106 static void client_disappeared(struct graph * graph_ptr, uint64_t id)
 107 {
 108   struct list_head * node_ptr;
 109   struct monitor * monitor_ptr;
 110
 111   list_for_each(node_ptr, &graph_ptr->monitors)
 112   {
 113     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 114     monitor_ptr->client_disappeared(monitor_ptr->context, id);
 115   }
 116 }
 117
 118 static
 119 void
 120 port_appeared(
 121   struct graph * graph_ptr,
 122   uint64_t client_id,
 123   uint64_t port_id,
 124   const char * port_name,
 125   uint32_t port_flags,
 126   uint32_t port_type)
 127 {
 128   struct list_head * node_ptr;
 129   struct monitor * monitor_ptr;
 130   bool is_input;
 131   bool is_terminal;
 132   bool is_midi;
 133
 134   if (port_type != JACKDBUS_PORT_TYPE_AUDIO && port_type != JACKDBUS_PORT_TYPE_MIDI)
 135   {
 136     lash_error("Unknown JACK D-Bus port type %d", (unsigned int)port_type);
 137     return;
 138   }
 139
 140   is_input = port_flags & JACKDBUS_PORT_FLAG_INPUT;
 141   is_terminal = port_flags & JACKDBUS_PORT_FLAG_TERMINAL;
 142   is_midi = port_type == JACKDBUS_PORT_TYPE_MIDI;
 143
 144   list_for_each(node_ptr, &graph_ptr->monitors)
 145   {
 146     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 147     monitor_ptr->port_appeared(monitor_ptr->context, client_id, port_id, port_name, is_input, is_terminal, is_midi);
 148   }
 149 }
 150
 151 static
 152 void
 153 port_disappeared(
 154   struct graph * graph_ptr,
 155   uint64_t client_id,
 156   uint64_t port_id)
 157 {
 158   struct list_head * node_ptr;
 159   struct monitor * monitor_ptr;
 160
 161   list_for_each(node_ptr, &graph_ptr->monitors)
 162   {
 163     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 164     monitor_ptr->port_disappeared(monitor_ptr->context, client_id, port_id);
 165   }
 166 }
 167
 168 static
 169 void
 170 ports_connected(
 171   struct graph * graph_ptr,
 172   uint64_t client1_id,
 173   uint64_t port1_id,
 174   uint64_t client2_id,
 175   uint64_t port2_id)
 176 {
 177   struct list_head * node_ptr;
 178   struct monitor * monitor_ptr;
 179
 180   list_for_each(node_ptr, &graph_ptr->monitors)
 181   {
 182     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 183     monitor_ptr->ports_connected(monitor_ptr->context, client1_id, port1_id, client2_id, port2_id);
 184   }
 185 }
 186
 187 static
 188 void
 189 ports_disconnected(
 190   struct graph * graph_ptr,
 191   uint64_t client1_id,
 192   uint64_t port1_id,
 193   uint64_t client2_id,
 194   uint64_t port2_id)
 195 {
 196   struct list_head * node_ptr;
 197   struct monitor * monitor_ptr;
 198
 199   list_for_each(node_ptr, &graph_ptr->monitors)
 200   {
 201     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 202     monitor_ptr->ports_disconnected(monitor_ptr->context, client1_id, port1_id, client2_id, port2_id);
 203   }
 204 }
 205
 206 static void refresh_internal(struct graph * graph_ptr, bool force)
 207 {
 208   DBusMessage* reply_ptr;
 209   DBusMessageIter iter;
 210   dbus_uint64_t version;
 211   const char * reply_signature;
 212   DBusMessageIter clients_array_iter;
 213   DBusMessageIter client_struct_iter;
 214   DBusMessageIter ports_array_iter;
 215   DBusMessageIter port_struct_iter;
 216   DBusMessageIter connections_array_iter;
 217   DBusMessageIter connection_struct_iter;
 218   dbus_uint64_t client_id;
 219   const char *client_name;
 220   dbus_uint64_t port_id;
 221   const char *port_name;
 222   dbus_uint32_t port_flags;
 223   dbus_uint32_t port_type;
 224   dbus_uint64_t client2_id;
 225   const char *client2_name;
 226   dbus_uint64_t port2_id;
 227   const char *port2_name;
 228   dbus_uint64_t connection_id;
 229
 230   lash_info("refresh_internal() called");
 231
 232   if (force)
 233   {
 234     version = 0; // workaround module split/join stupidity
 235   }
 236   else
 237   {
 238     version = graph_ptr->version;
 239   }
 240
 241   if (!dbus_call_simple(graph_ptr->service, graph_ptr->object, JACKDBUS_IFACE_PATCHBAY, "GetGraph", "t", &version, NULL, &reply_ptr))
 242   {
 243     lash_error("GetGraph() failed.");
 244     return;
 245   }
 246
 247   reply_signature = dbus_message_get_signature(reply_ptr);
 248
 249   if (strcmp(reply_signature, "ta(tsa(tsuu))a(tstststst)") != 0)
 250   {
 251     lash_error("GetGraph() reply signature mismatch. '%s'", reply_signature);
 252     goto unref;
 253   }
 254
 255   dbus_message_iter_init(reply_ptr, &iter);
 256
 257   //info_msg((std::string)"version " + (char)dbus_message_iter_get_arg_type(&iter));
 258   dbus_message_iter_get_basic(&iter, &version);
 259   dbus_message_iter_next(&iter);
 260
 261   if (!force && version <= graph_ptr->version)
 262   {
 263     goto unref;
 264   }
 265
 266   clear(graph_ptr);
 267
 268   //info_msg(str(boost::format("got new graph version %llu") % version));
 269   graph_ptr->version = version;
 270
 271   //info_msg((std::string)"clients " + (char)dbus_message_iter_get_arg_type(&iter));
 272
 273   for (dbus_message_iter_recurse(&iter, &clients_array_iter);
 274        dbus_message_iter_get_arg_type(&clients_array_iter) != DBUS_TYPE_INVALID;
 275        dbus_message_iter_next(&clients_array_iter))
 276   {
 277     //info_msg((std::string)"a client " + (char)dbus_message_iter_get_arg_type(&clients_array_iter));
 278     dbus_message_iter_recurse(&clients_array_iter, &client_struct_iter);
 279
 280     dbus_message_iter_get_basic(&client_struct_iter, &client_id);
 281     dbus_message_iter_next(&client_struct_iter);
 282
 283     dbus_message_iter_get_basic(&client_struct_iter, &client_name);
 284     dbus_message_iter_next(&client_struct_iter);
 285
 286     //info_msg((std::string)"client '" + client_name + "'");
 287
 288     client_appeared(graph_ptr, client_id, client_name);
 289
 290     for (dbus_message_iter_recurse(&client_struct_iter, &ports_array_iter);
 291          dbus_message_iter_get_arg_type(&ports_array_iter) != DBUS_TYPE_INVALID;
 292          dbus_message_iter_next(&ports_array_iter))
 293     {
 294       //info_msg((std::string)"a port " + (char)dbus_message_iter_get_arg_type(&ports_array_iter));
 295       dbus_message_iter_recurse(&ports_array_iter, &port_struct_iter);
 296
 297       dbus_message_iter_get_basic(&port_struct_iter, &port_id);
 298       dbus_message_iter_next(&port_struct_iter);
 299
 300       dbus_message_iter_get_basic(&port_struct_iter, &port_name);
 301       dbus_message_iter_next(&port_struct_iter);
 302
 303       dbus_message_iter_get_basic(&port_struct_iter, &port_flags);
 304       dbus_message_iter_next(&port_struct_iter);
 305
 306       dbus_message_iter_get_basic(&port_struct_iter, &port_type);
 307       dbus_message_iter_next(&port_struct_iter);
 308
 309       //info_msg((std::string)"port: " + port_name);
 310
 311       port_appeared(graph_ptr, client_id, port_id, port_name, port_flags, port_type);
 312     }
 313
 314     dbus_message_iter_next(&client_struct_iter);
 315   }
 316
 317   dbus_message_iter_next(&iter);
 318
 319   for (dbus_message_iter_recurse(&iter, &connections_array_iter);
 320        dbus_message_iter_get_arg_type(&connections_array_iter) != DBUS_TYPE_INVALID;
 321        dbus_message_iter_next(&connections_array_iter))
 322   {
 323     //info_msg((std::string)"a connection " + (char)dbus_message_iter_get_arg_type(&connections_array_iter));
 324     dbus_message_iter_recurse(&connections_array_iter, &connection_struct_iter);
 325
 326     dbus_message_iter_get_basic(&connection_struct_iter, &client_id);
 327     dbus_message_iter_next(&connection_struct_iter);
 328
 329     dbus_message_iter_get_basic(&connection_struct_iter, &client_name);
 330     dbus_message_iter_next(&connection_struct_iter);
 331
 332     dbus_message_iter_get_basic(&connection_struct_iter, &port_id);
 333     dbus_message_iter_next(&connection_struct_iter);
 334
 335     dbus_message_iter_get_basic(&connection_struct_iter, &port_name);
 336     dbus_message_iter_next(&connection_struct_iter);
 337
 338     dbus_message_iter_get_basic(&connection_struct_iter, &client2_id);
 339     dbus_message_iter_next(&connection_struct_iter);
 340
 341     dbus_message_iter_get_basic(&connection_struct_iter, &client2_name);
 342     dbus_message_iter_next(&connection_struct_iter);
 343
 344     dbus_message_iter_get_basic(&connection_struct_iter, &port2_id);
 345     dbus_message_iter_next(&connection_struct_iter);
 346
 347     dbus_message_iter_get_basic(&connection_struct_iter, &port2_name);
 348     dbus_message_iter_next(&connection_struct_iter);
 349
 350     dbus_message_iter_get_basic(&connection_struct_iter, &connection_id);
 351     dbus_message_iter_next(&connection_struct_iter);
 352
 353     //info_msg(str(boost::format("connection(%llu) %s(%llu):%s(%llu) <-> %s(%llu):%s(%llu)") %
 354     //    connection_id %
 355     //    client_name %
 356     //    client_id %
 357     //    port_name %
 358     //    port_id %
 359     //    client2_name %
 360     //    client2_id %
 361     //    port2_name %
 362     //    port2_id));
 363
 364     ports_connected(graph_ptr, client_id, port_id, client2_id, port2_id);
 365   }
 366
 367 unref:
 368   dbus_message_unref(reply_ptr);
 369 }
 370
 371 bool
 372 graph_create(
 373   const char * service,
 374   const char * object,
 375   graph_handle * graph_handle_ptr)
 376 {
 377   struct graph * graph_ptr;
 378
 379   graph_ptr = malloc(sizeof(struct graph));
 380   if (graph_ptr == NULL)
 381   {
 382     lash_error("malloc() failed to allocate struct graph");
 383     goto fail;
 384   }
 385
 386   graph_ptr->service = strdup(service);
 387   if (graph_ptr->service == NULL)
 388   {
 389     lash_error("strdup() failed too duplicate service name '%s'", service);
 390     goto free_graph;
 391   }
 392
 393   graph_ptr->object = strdup(object);
 394   if (graph_ptr->object == NULL)
 395   {
 396     lash_error("strdup() failed too duplicate object name '%s'", object);
 397     goto free_service;
 398   }
 399
 400   INIT_LIST_HEAD(&graph_ptr->monitors);
 401
 402   graph_ptr->version = 0;
 403   graph_ptr->active = false;
 404
 405   *graph_handle_ptr = (graph_handle)graph_ptr;
 406
 407   return true;
 408
 409 free_service:
 410   free(graph_ptr->service);
 411
 412 free_graph:
 413   free(graph_ptr);
 414
 415 fail:
 416   return false;
 417 }
 418
 419 #define graph_ptr ((struct graph *)graph)
 420
 421 void
 422 graph_destroy(
 423   graph_handle graph)
 424 {
 425   assert(list_empty(&graph_ptr->monitors));
 426
 427   if (graph_ptr->active)
 428   {
 429     dbus_unregister_object_signal_handler(
 430       g_dbus_connection,
 431       graph_ptr->service,
 432       graph_ptr->object,
 433       JACKDBUS_IFACE_PATCHBAY,
 434       g_signals,
 435       message_hook,
 436       graph_ptr);
 437   }
 438
 439   free(graph_ptr->object);
 440   free(graph_ptr->service);
 441   free(graph_ptr);
 442 }
 443
 444 bool
 445 graph_activate(
 446   graph_handle graph)
 447 {
 448   if (list_empty(&graph_ptr->monitors))
 449   {
 450     lash_error("no monitors to activate");
 451     return false;
 452   }
 453
 454   if (graph_ptr->active)
 455   {
 456     lash_error("graph already active");
 457     return false;
 458   }
 459
 460   if (!dbus_register_object_signal_handler(
 461         g_dbus_connection,
 462         graph_ptr->service,
 463         graph_ptr->object,
 464         JACKDBUS_IFACE_PATCHBAY,
 465         g_signals,
 466         message_hook,
 467         graph_ptr))
 468   {
 469     return false;
 470   }
 471
 472   graph_ptr->active = true;
 473
 474   refresh_internal(graph_ptr, true);
 475
 476   return true;
 477 }
 478
 479 bool
 480 graph_attach(
 481   graph_handle graph,
 482   void * context,
 483   void (* clear)(void * context),
 484   void (* client_appeared)(void * context, uint64_t id, const char * name),
 485   void (* client_disappeared)(void * context, uint64_t id),
 486   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),
 487   void (* port_disappeared)(void * context, uint64_t client_id, uint64_t port_id),
 488   void (* ports_connected)(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id),
 489   void (* ports_disconnected)(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id))
 490 {
 491   struct monitor * monitor_ptr;
 492
 493   if (graph_ptr->active)
 494   {
 495     return false;
 496   }
 497
 498   monitor_ptr = malloc(sizeof(struct monitor));
 499   if (monitor_ptr == NULL)
 500   {
 501     lash_error("malloc() failed to allocate struct monitor");
 502     return false;
 503   }
 504
 505   monitor_ptr->context = context;
 506   monitor_ptr->clear = clear;
 507   monitor_ptr->client_appeared = client_appeared;
 508   monitor_ptr->client_disappeared = client_disappeared;
 509   monitor_ptr->port_appeared = port_appeared;
 510   monitor_ptr->port_disappeared = port_disappeared;
 511   monitor_ptr->ports_connected = ports_connected;
 512   monitor_ptr->ports_disconnected = ports_disconnected;
 513
 514   list_add_tail(&monitor_ptr->siblings, &graph_ptr->monitors);
 515
 516   return true;
 517 }
 518
 519 void
 520 graph_detach(
 521   graph_handle graph,
 522   void * context)
 523 {
 524   struct list_head * node_ptr;
 525   struct monitor * monitor_ptr;
 526
 527   list_for_each(node_ptr, &graph_ptr->monitors)
 528   {
 529     monitor_ptr = list_entry(node_ptr, struct monitor, siblings);
 530     if (monitor_ptr->context == context)
 531     {
 532       list_del(&monitor_ptr->siblings);
 533       free(monitor_ptr);
 534       return;
 535     }
 536   }
 537
 538   assert(false);
 539 }
 540
 541 void
 542 graph_connect_ports(
 543   graph_handle graph,
 544   uint64_t port1_id,
 545   uint64_t port2_id)
 546 {
 547   if (!dbus_call_simple(graph_ptr->service, graph_ptr->object, JACKDBUS_IFACE_PATCHBAY, "ConnectPortsByID", "tt", &port1_id, &port2_id, ""))
 548   {
 549     lash_error("ConnectPortsByID() failed.");
 550   }
 551 }
 552
 553 void
 554 graph_disconnect_ports(
 555   graph_handle graph,
 556   uint64_t port1_id,
 557   uint64_t port2_id)
 558 {
 559   if (!dbus_call_simple(graph_ptr->service, graph_ptr->object, JACKDBUS_IFACE_PATCHBAY, "DisconnectPortsByID", "tt", &port1_id, &port2_id, ""))
 560   {
 561     lash_error("DisconnectPortsByID() failed.");
 562   }
 563 }
 564
 565 static
 566 DBusHandlerResult
 567 message_hook(
 568   DBusConnection * connection,
 569   DBusMessage * message,
 570   void * graph)
 571 {
 572   const char * object_path;
 573   dbus_uint64_t new_graph_version;
 574   dbus_uint64_t client_id;
 575   const char *client_name;
 576   dbus_uint64_t port_id;
 577   const char *port_name;
 578   dbus_uint32_t port_flags;
 579   dbus_uint32_t port_type;
 580   dbus_uint64_t client2_id;
 581   const char *client2_name;
 582   dbus_uint64_t port2_id;
 583   const char *port2_name;
 584   dbus_uint64_t connection_id;
 585
 586   object_path = dbus_message_get_path(message);
 587   if (object_path == NULL || strcmp(object_path, graph_ptr->object) != 0)
 588   {
 589     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 590   }
 591
 592   if (dbus_message_is_signal(message, JACKDBUS_IFACE_PATCHBAY, "ClientAppeared"))
 593   {
 594     if (!dbus_message_get_args(
 595           message,
 596           &g_dbus_error,
 597           DBUS_TYPE_UINT64, &new_graph_version,
 598           DBUS_TYPE_UINT64, &client_id,
 599           DBUS_TYPE_STRING, &client_name,
 600           DBUS_TYPE_INVALID))
 601     {
 602       lash_error("dbus_message_get_args() failed to extract ClientAppeared signal arguments (%s)", g_dbus_error.message);
 603       dbus_error_free(&g_dbus_error);
 604       return DBUS_HANDLER_RESULT_HANDLED;
 605     }
 606
 607     //lash_info("ClientAppeared, %s(%llu)", client_name, client_id);
 608
 609     client_appeared(graph_ptr, client_id, client_name);
 610
 611     return DBUS_HANDLER_RESULT_HANDLED;
 612   }
 613
 614   if (dbus_message_is_signal(message, JACKDBUS_IFACE_PATCHBAY, "ClientDisappeared"))
 615   {
 616     if (!dbus_message_get_args(
 617           message,
 618           &g_dbus_error,
 619           DBUS_TYPE_UINT64, &new_graph_version,
 620           DBUS_TYPE_UINT64, &client_id,
 621           DBUS_TYPE_STRING, &client_name,
 622           DBUS_TYPE_INVALID))
 623     {
 624       lash_error("dbus_message_get_args() failed to extract ClientDisappeared signal arguments (%s)", g_dbus_error.message);
 625       dbus_error_free(&g_dbus_error);
 626       return DBUS_HANDLER_RESULT_HANDLED;
 627     }
 628
 629     //lash_info("ClientDisappeared, %s(%llu)", client_name, client_id);
 630
 631     client_disappeared(graph_ptr, client_id);
 632
 633     return DBUS_HANDLER_RESULT_HANDLED;
 634   }
 635
 636   if (dbus_message_is_signal(message, JACKDBUS_IFACE_PATCHBAY, "PortAppeared"))
 637   {
 638     if (!dbus_message_get_args(
 639           message,
 640           &g_dbus_error,
 641           DBUS_TYPE_UINT64, &new_graph_version,
 642           DBUS_TYPE_UINT64, &client_id,
 643           DBUS_TYPE_STRING, &client_name,
 644           DBUS_TYPE_UINT64, &port_id,
 645           DBUS_TYPE_STRING, &port_name,
 646           DBUS_TYPE_UINT32, &port_flags,
 647           DBUS_TYPE_UINT32, &port_type,
 648           DBUS_TYPE_INVALID))
 649     {
 650       lash_error("dbus_message_get_args() failed to extract PortAppeared signal arguments (%s)", g_dbus_error.message);
 651       dbus_error_free(&g_dbus_error);
 652       return DBUS_HANDLER_RESULT_HANDLED;
 653     }
 654
 655     //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));
 656
 657     port_appeared(graph_ptr, client_id, port_id, port_name, port_flags, port_type);
 658
 659     return DBUS_HANDLER_RESULT_HANDLED;
 660   }
 661
 662   if (dbus_message_is_signal(message, JACKDBUS_IFACE_PATCHBAY, "PortDisappeared"))
 663   {
 664     if (!dbus_message_get_args(
 665           message,
 666           &g_dbus_error,
 667           DBUS_TYPE_UINT64, &new_graph_version,
 668           DBUS_TYPE_UINT64, &client_id,
 669           DBUS_TYPE_STRING, &client_name,
 670           DBUS_TYPE_UINT64, &port_id,
 671           DBUS_TYPE_STRING, &port_name,
 672           DBUS_TYPE_INVALID))
 673     {
 674       lash_error("dbus_message_get_args() failed to extract PortDisappeared signal arguments (%s)", g_dbus_error.message);
 675       dbus_error_free(&g_dbus_error);
 676       return DBUS_HANDLER_RESULT_HANDLED;
 677     }
 678
 679     //me->info_msg(str(boost::format("PortDisappeared, %s(%llu):%s(%llu)") % client_name % client_id % port_name % port_id));
 680
 681     port_disappeared(graph_ptr, client_id, port_id);
 682
 683     return DBUS_HANDLER_RESULT_HANDLED;
 684   }
 685
 686   if (dbus_message_is_signal(message, JACKDBUS_IFACE_PATCHBAY, "PortsConnected"))
 687   {
 688     if (!dbus_message_get_args(
 689           message,
 690           &g_dbus_error,
 691           DBUS_TYPE_UINT64, &new_graph_version,
 692           DBUS_TYPE_UINT64, &client_id,
 693           DBUS_TYPE_STRING, &client_name,
 694           DBUS_TYPE_UINT64, &port_id,
 695           DBUS_TYPE_STRING, &port_name,
 696           DBUS_TYPE_UINT64, &client2_id,
 697           DBUS_TYPE_STRING, &client2_name,
 698           DBUS_TYPE_UINT64, &port2_id,
 699           DBUS_TYPE_STRING, &port2_name,
 700           DBUS_TYPE_UINT64, &connection_id,
 701           DBUS_TYPE_INVALID))
 702     {
 703       lash_error("dbus_message_get_args() failed to extract PortsConnected signal arguments (%s)", g_dbus_error.message);
 704       dbus_error_free(&g_dbus_error);
 705       return DBUS_HANDLER_RESULT_HANDLED;
 706     }
 707
 708     ports_connected(graph_ptr, client_id, port_id, client2_id, port2_id);
 709
 710     return DBUS_HANDLER_RESULT_HANDLED;
 711   }
 712
 713   if (dbus_message_is_signal(message, JACKDBUS_IFACE_PATCHBAY, "PortsDisconnected"))
 714   {
 715     if (!dbus_message_get_args(
 716           message,
 717           &g_dbus_error,
 718           DBUS_TYPE_UINT64, &new_graph_version,
 719           DBUS_TYPE_UINT64, &client_id,
 720           DBUS_TYPE_STRING, &client_name,
 721           DBUS_TYPE_UINT64, &port_id,
 722           DBUS_TYPE_STRING, &port_name,
 723           DBUS_TYPE_UINT64, &client2_id,
 724           DBUS_TYPE_STRING, &client2_name,
 725           DBUS_TYPE_UINT64, &port2_id,
 726           DBUS_TYPE_STRING, &port2_name,
 727           DBUS_TYPE_UINT64, &connection_id,
 728           DBUS_TYPE_INVALID))
 729     {
 730       lash_error("dbus_message_get_args() failed to extract PortsConnected signal arguments (%s)", g_dbus_error.message);
 731       dbus_error_free(&g_dbus_error);
 732       return DBUS_HANDLER_RESULT_HANDLED;
 733     }
 734
 735     ports_disconnected(graph_ptr, client_id, port_id, client2_id, port2_id);
 736
 737     return DBUS_HANDLER_RESULT_HANDLED;
 738   }
 739
 740   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 741 }