daemon/graph.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2008, 2009, 2010 Nedko Arnaudov <nedko@arnaudov.name>
   6  * Copyright (C) 2008 Juuso Alasuutari
   7  *
   8  **************************************************************************
   9  * This file contains implementation of the D-Bus patchbay interface helpers
  10  **************************************************************************
  11  *
  12  * LADI Session Handler is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * LADI Session Handler is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  24  * or write to the Free Software Foundation, Inc.,
  25  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  26  */
  27
  28 #include "common.h"
  29 #include "graph.h"
  30 #include "../dbus/error.h"
  31 #include "../dbus_constants.h"
  32
  33 struct ladish_graph_port
  34 {
  35   struct list_head siblings_client;
  36   struct list_head siblings_graph;
  37   struct ladish_graph_client * client_ptr;
  38   char * name;
  39   uint32_t type;
  40   uint32_t flags;
  41   uint64_t id;
  42   ladish_port_handle port;
  43   bool hidden;
  44   bool link;
  45   uuid_t link_uuid_override;
  46 };
  47
  48 struct ladish_graph_client
  49 {
  50   struct list_head siblings;
  51   char * name;
  52   uint64_t id;
  53   ladish_client_handle client;
  54   struct list_head ports;
  55   bool hidden;
  56 };
  57
  58 struct ladish_graph_connection
  59 {
  60   struct list_head siblings;
  61   uint64_t id;
  62   bool hidden;
  63   struct ladish_graph_port * port1_ptr;
  64   struct ladish_graph_port * port2_ptr;
  65   ladish_dict_handle dict;
  66   bool changing;
  67 };
  68
  69 struct ladish_graph
  70 {
  71   char * opath;
  72   ladish_dict_handle dict;
  73   struct list_head clients;
  74   struct list_head ports;
  75   struct list_head connections;
  76   uint64_t graph_version;
  77   uint64_t next_client_id;
  78   uint64_t next_port_id;
  79   uint64_t next_connection_id;
  80   bool persist;
  81
  82   void * context;
  83   ladish_graph_connect_request_handler connect_handler;
  84   ladish_graph_disconnect_request_handler disconnect_handler;
  85 };
  86
  87 static struct ladish_graph_port * ladish_graph_find_port_by_id_internal(struct ladish_graph * graph_ptr, uint64_t port_id)
  88 {
  89   struct list_head * node_ptr;
  90   struct ladish_graph_port * port_ptr;
  91
  92   list_for_each(node_ptr, &graph_ptr->ports)
  93   {
  94     port_ptr = list_entry(node_ptr, struct ladish_graph_port, siblings_graph);
  95     if (port_ptr->id == port_id)
  96     {
  97       return port_ptr;
  98     }
  99   }
 100
 101   return NULL;
 102 }
 103
 104 static struct ladish_graph_port *
 105 ladish_graph_find_port_by_uuid_internal(
 106   struct ladish_graph * graph_ptr,
 107   const uuid_t uuid,
 108   bool use_link_override_uuids)
 109 {
 110   struct list_head * node_ptr;
 111   struct ladish_graph_port * port_ptr;
 112   uuid_t current_uuid;
 113   /* char uuid1_str[37]; */
 114   /* char uuid2_str[37]; */
 115
 116   /* log_info("searching by uuid for port in graph %s", ladish_graph_get_description((ladish_graph_handle)graph_ptr)); */
 117   /* uuid_unparse(uuid, uuid1_str); */
 118
 119   list_for_each(node_ptr, &graph_ptr->ports)
 120   {
 121     port_ptr = list_entry(node_ptr, struct ladish_graph_port, siblings_graph);
 122
 123     /* if (port_ptr->link) */
 124     /* { */
 125     /*   uuid_unparse(port_ptr->link_uuid_override, uuid2_str); */
 126     /*   log_info("comparing link uuid %s with %s", uuid2_str, uuid1_str); */
 127     /* } */
 128
 129     if (use_link_override_uuids && port_ptr->link && uuid_compare(port_ptr->link_uuid_override, uuid) == 0)
 130     {
 131       /* log_info("found port %p of client '%s'", port_ptr->port, port_ptr->client_ptr->name); */
 132       return port_ptr;
 133     }
 134
 135     ladish_port_get_uuid(port_ptr->port, current_uuid);
 136     /* uuid_unparse(current_uuid, uuid2_str); */
 137     /* log_info("comparing port uuid %s with %s", uuid2_str, uuid1_str); */
 138     if (uuid_compare(current_uuid, uuid) == 0)
 139     {
 140       return port_ptr;
 141     }
 142   }
 143
 144   return NULL;
 145 }
 146
 147 static struct ladish_graph_connection * ladish_graph_find_connection_by_id(struct ladish_graph * graph_ptr, uint64_t connection_id)
 148 {
 149   struct list_head * node_ptr;
 150   struct ladish_graph_connection * connection_ptr;
 151
 152   list_for_each(node_ptr, &graph_ptr->connections)
 153   {
 154     connection_ptr = list_entry(node_ptr, struct ladish_graph_connection, siblings);
 155     if (connection_ptr->id == connection_id)
 156     {
 157       return connection_ptr;
 158     }
 159   }
 160
 161   return NULL;
 162 }
 163
 164 static
 165 struct ladish_graph_connection *
 166 ladish_graph_find_connection_by_ports(
 167   struct ladish_graph * graph_ptr,
 168   struct ladish_graph_port * port1_ptr,
 169   struct ladish_graph_port * port2_ptr)
 170 {
 171   struct list_head * node_ptr;
 172   struct ladish_graph_connection * connection_ptr;
 173
 174   list_for_each(node_ptr, &graph_ptr->connections)
 175   {
 176     connection_ptr = list_entry(node_ptr, struct ladish_graph_connection, siblings);
 177     if ((connection_ptr->port1_ptr == port1_ptr && connection_ptr->port2_ptr == port2_ptr) ||
 178         (connection_ptr->port1_ptr == port2_ptr && connection_ptr->port2_ptr == port1_ptr))
 179     {
 180       return connection_ptr;
 181     }
 182   }
 183
 184   return NULL;
 185 }
 186
 187 #define graph_ptr ((struct ladish_graph *)call_ptr->iface_context)
 188
 189 static void get_all_ports(struct dbus_method_call * call_ptr)
 190 {
 191   DBusMessageIter iter, sub_iter;
 192
 193   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 194   if (call_ptr->reply == NULL)
 195   {
 196     goto fail;
 197   }
 198
 199   dbus_message_iter_init_append(call_ptr->reply, &iter);
 200
 201   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub_iter))
 202   {
 203     goto fail_unref;
 204   }
 205
 206   if (!dbus_message_iter_close_container(&iter, &sub_iter))
 207   {
 208     goto fail_unref;
 209   }
 210
 211   return;
 212
 213 fail_unref:
 214   dbus_message_unref(call_ptr->reply);
 215   call_ptr->reply = NULL;
 216
 217 fail:
 218   log_error("Ran out of memory trying to construct method return");
 219 }
 220
 221 static void get_graph(struct dbus_method_call * call_ptr)
 222 {
 223   dbus_uint64_t known_version;
 224   dbus_uint64_t current_version;
 225   DBusMessageIter iter;
 226   DBusMessageIter clients_array_iter;
 227   DBusMessageIter connections_array_iter;
 228   DBusMessageIter client_struct_iter;
 229   struct list_head * client_node_ptr;
 230   struct ladish_graph_client * client_ptr;
 231   DBusMessageIter ports_array_iter;
 232   struct list_head * port_node_ptr;
 233   struct ladish_graph_port * port_ptr;
 234   DBusMessageIter port_struct_iter;
 235   struct list_head * connection_node_ptr;
 236   struct ladish_graph_connection * connection_ptr;
 237   DBusMessageIter connection_struct_iter;
 238
 239   //log_info("get_graph() called");
 240
 241   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_UINT64, &known_version, DBUS_TYPE_INVALID))
 242   {
 243     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 244     dbus_error_free(&g_dbus_error);
 245     return;
 246   }
 247
 248   //log_info("Getting graph, known version is %" PRIu64, known_version);
 249
 250   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 251   if (call_ptr->reply == NULL)
 252   {
 253     log_error("Ran out of memory trying to construct method return");
 254     goto exit;
 255   }
 256
 257   dbus_message_iter_init_append(call_ptr->reply, &iter);
 258
 259   current_version = graph_ptr->graph_version;
 260   if (known_version > current_version)
 261   {
 262     lash_dbus_error(
 263       call_ptr,
 264       LASH_DBUS_ERROR_INVALID_ARGS,
 265       "known graph version %" PRIu64 " is newer than actual version %" PRIu64,
 266       known_version,
 267       current_version);
 268     goto exit;
 269   }
 270
 271   if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT64, &current_version))
 272   {
 273     goto nomem;
 274   }
 275
 276   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tsa(tsuu))", &clients_array_iter))
 277   {
 278     goto nomem;
 279   }
 280
 281   if (known_version < current_version)
 282   {
 283     list_for_each(client_node_ptr, &graph_ptr->clients)
 284     {
 285       client_ptr = list_entry(client_node_ptr, struct ladish_graph_client, siblings);
 286
 287       if (client_ptr->hidden)
 288       {
 289         continue;
 290       }
 291
 292       if (!dbus_message_iter_open_container (&clients_array_iter, DBUS_TYPE_STRUCT, NULL, &client_struct_iter))
 293       {
 294         goto nomem_close_clients_array;
 295       }
 296
 297       if (!dbus_message_iter_append_basic(&client_struct_iter, DBUS_TYPE_UINT64, &client_ptr->id))
 298       {
 299         goto nomem_close_client_struct;
 300       }
 301
 302       log_info("client '%s' (%llu)", client_ptr->name, (unsigned long long)client_ptr->id);
 303       if (!dbus_message_iter_append_basic(&client_struct_iter, DBUS_TYPE_STRING, &client_ptr->name))
 304       {
 305         goto nomem_close_client_struct;
 306       }
 307
 308       if (!dbus_message_iter_open_container(&client_struct_iter, DBUS_TYPE_ARRAY, "(tsuu)", &ports_array_iter))
 309       {
 310         goto nomem_close_client_struct;
 311       }
 312
 313       list_for_each(port_node_ptr, &client_ptr->ports)
 314       {
 315         port_ptr = list_entry(port_node_ptr, struct ladish_graph_port, siblings_client);
 316
 317         if (port_ptr->hidden)
 318         {
 319           continue;
 320         }
 321
 322         if (!dbus_message_iter_open_container(&ports_array_iter, DBUS_TYPE_STRUCT, NULL, &port_struct_iter))
 323         {
 324           goto nomem_close_ports_array;
 325         }
 326
 327         if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT64, &port_ptr->id))
 328         {
 329           goto nomem_close_port_struct;
 330         }
 331
 332         if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_STRING, &port_ptr->name))
 333         {
 334           goto nomem_close_port_struct;
 335         }
 336
 337         if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT32, &port_ptr->flags))
 338         {
 339           goto nomem_close_port_struct;
 340         }
 341
 342         if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT32, &port_ptr->type))
 343         {
 344           goto nomem_close_port_struct;
 345         }
 346
 347         if (!dbus_message_iter_close_container(&ports_array_iter, &port_struct_iter))
 348         {
 349           goto nomem_close_ports_array;
 350         }
 351       }
 352
 353       if (!dbus_message_iter_close_container(&client_struct_iter, &ports_array_iter))
 354       {
 355         goto nomem_close_client_struct;
 356       }
 357
 358       if (!dbus_message_iter_close_container(&clients_array_iter, &client_struct_iter))
 359       {
 360         goto nomem_close_clients_array;
 361       }
 362     }
 363   }
 364
 365   if (!dbus_message_iter_close_container(&iter, &clients_array_iter))
 366   {
 367     goto nomem;
 368   }
 369
 370   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tstststst)", &connections_array_iter))
 371   {
 372     goto nomem;
 373   }
 374
 375   if (known_version < current_version)
 376   {
 377     list_for_each(connection_node_ptr, &graph_ptr->connections)
 378     {
 379       connection_ptr = list_entry(connection_node_ptr, struct ladish_graph_connection, siblings);
 380
 381       if (connection_ptr->hidden)
 382       {
 383         continue;
 384       }
 385
 386       if (!dbus_message_iter_open_container(&connections_array_iter, DBUS_TYPE_STRUCT, NULL, &connection_struct_iter))
 387       {
 388         goto nomem_close_connections_array;
 389       }
 390
 391       if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port1_ptr->client_ptr->id))
 392       {
 393         goto nomem_close_connection_struct;
 394       }
 395
 396       if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port1_ptr->client_ptr->name))
 397       {
 398         goto nomem_close_connection_struct;
 399       }
 400
 401       if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port1_ptr->id))
 402       {
 403         goto nomem_close_connection_struct;
 404       }
 405
 406       if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port1_ptr->name))
 407       {
 408         goto nomem_close_connection_struct;
 409       }
 410
 411       if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port2_ptr->client_ptr->id))
 412       {
 413         goto nomem_close_connection_struct;
 414       }
 415
 416       if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port2_ptr->client_ptr->name))
 417       {
 418         goto nomem_close_connection_struct;
 419       }
 420
 421       if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port2_ptr->id))
 422       {
 423         goto nomem_close_connection_struct;
 424       }
 425
 426       if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port2_ptr->name))
 427       {
 428         goto nomem_close_connection_struct;
 429       }
 430
 431       if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->id))
 432       {
 433         goto nomem_close_connection_struct;
 434       }
 435
 436       if (!dbus_message_iter_close_container(&connections_array_iter, &connection_struct_iter))
 437       {
 438         goto nomem_close_connections_array;
 439       }
 440     }
 441   }
 442
 443   if (!dbus_message_iter_close_container(&iter, &connections_array_iter))
 444   {
 445     goto nomem;
 446   }
 447
 448   return;
 449
 450 nomem_close_connection_struct:
 451   dbus_message_iter_close_container(&connections_array_iter, &connection_struct_iter);
 452
 453 nomem_close_connections_array:
 454   dbus_message_iter_close_container(&iter, &connections_array_iter);
 455   goto nomem;
 456
 457 nomem_close_port_struct:
 458   dbus_message_iter_close_container(&ports_array_iter, &port_struct_iter);
 459
 460 nomem_close_ports_array:
 461   dbus_message_iter_close_container(&client_struct_iter, &ports_array_iter);
 462
 463 nomem_close_client_struct:
 464   dbus_message_iter_close_container(&clients_array_iter, &client_struct_iter);
 465
 466 nomem_close_clients_array:
 467   dbus_message_iter_close_container(&iter, &clients_array_iter);
 468
 469 nomem:
 470   dbus_message_unref(call_ptr->reply);
 471   call_ptr->reply = NULL;
 472   log_error("Ran out of memory trying to construct method return");
 473
 474 exit:
 475   return;
 476 }
 477
 478 static void connect_ports_by_name(struct dbus_method_call * call_ptr)
 479 {
 480   log_info("connect_ports_by_name() called.");
 481   lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "connect by name is not implemented yet");
 482 }
 483
 484 static void connect_ports_by_id(struct dbus_method_call * call_ptr)
 485 {
 486   dbus_uint64_t port1_id;
 487   dbus_uint64_t port2_id;
 488   struct ladish_graph_port * port1_ptr;
 489   struct ladish_graph_port * port2_ptr;
 490
 491   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_UINT64, &port1_id, DBUS_TYPE_UINT64, &port2_id, DBUS_TYPE_INVALID))
 492   {
 493     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s", call_ptr->method_name, g_dbus_error.message);
 494     dbus_error_free(&g_dbus_error);
 495     return;
 496   }
 497
 498   log_info("connect_ports_by_id(%"PRIu64",%"PRIu64") called.", port1_id, port2_id);
 499
 500   if (graph_ptr->connect_handler == NULL)
 501   {
 502     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "connect requests on graph %s cannot be handlined", graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
 503     return;
 504   }
 505
 506   port1_ptr = ladish_graph_find_port_by_id_internal(graph_ptr, port1_id);
 507   if (port1_ptr == NULL)
 508   {
 509     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Cannot connect unknown port with id %"PRIu64, port1_id);
 510     return;
 511   }
 512
 513   port2_ptr = ladish_graph_find_port_by_id_internal(graph_ptr, port2_id);
 514   if (port2_ptr == NULL)
 515   {
 516     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Cannot connect unknown port with id %"PRIu64, port2_id);
 517     return;
 518   }
 519
 520   log_info("connecting '%s':'%s' to '%s':'%s'", port1_ptr->client_ptr->name, port1_ptr->name, port2_ptr->client_ptr->name, port2_ptr->name);
 521
 522   if (graph_ptr->connect_handler(graph_ptr->context, (ladish_graph_handle)graph_ptr, port1_ptr->port, port2_ptr->port))
 523   {
 524     method_return_new_void(call_ptr);
 525   }
 526   else
 527   {
 528     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "connect failed");
 529   }
 530 }
 531
 532 static void disconnect_ports(struct dbus_method_call * call_ptr, struct ladish_graph_connection * connection_ptr)
 533 {
 534   log_info(
 535     "disconnecting '%s':'%s' from '%s':'%s'",
 536     connection_ptr->port1_ptr->client_ptr->name,
 537     connection_ptr->port1_ptr->name,
 538     connection_ptr->port2_ptr->client_ptr->name,
 539     connection_ptr->port2_ptr->name);
 540
 541   connection_ptr->changing = true;
 542   if (graph_ptr->disconnect_handler(graph_ptr->context, (ladish_graph_handle)graph_ptr, connection_ptr->id))
 543   {
 544     method_return_new_void(call_ptr);
 545   }
 546   else
 547   {
 548     connection_ptr->changing = false;
 549     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "disconnect failed");
 550   }
 551 }
 552
 553 static void disconnect_ports_by_name(struct dbus_method_call * call_ptr)
 554 {
 555   log_info("disconnect_ports_by_name() called.");
 556   lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "disconnect by name is not implemented yet");
 557 }
 558
 559 static void disconnect_ports_by_id(struct dbus_method_call * call_ptr)
 560 {
 561   dbus_uint64_t port1_id;
 562   dbus_uint64_t port2_id;
 563   struct ladish_graph_port * port1_ptr;
 564   struct ladish_graph_port * port2_ptr;
 565   struct ladish_graph_connection * connection_ptr;
 566
 567   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_UINT64, &port1_id, DBUS_TYPE_UINT64, &port2_id, DBUS_TYPE_INVALID))
 568   {
 569     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s", call_ptr->method_name, g_dbus_error.message);
 570     dbus_error_free(&g_dbus_error);
 571     return;
 572   }
 573
 574   log_info("disconnect_ports_by_id(%"PRIu64",%"PRIu64") called.", port1_id, port2_id);
 575
 576   if (graph_ptr->disconnect_handler == NULL)
 577   {
 578     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "disconnect requests on graph %s cannot be handlined", graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
 579     return;
 580   }
 581
 582   port1_ptr = ladish_graph_find_port_by_id_internal(graph_ptr, port1_id);
 583   if (port1_ptr == NULL)
 584   {
 585     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Cannot disconnect unknown port with id %"PRIu64, port1_id);
 586     return;
 587   }
 588
 589   port2_ptr = ladish_graph_find_port_by_id_internal(graph_ptr, port2_id);
 590   if (port2_ptr == NULL)
 591   {
 592     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Cannot disconnect unknown port with id %"PRIu64, port2_id);
 593     return;
 594   }
 595
 596   connection_ptr = ladish_graph_find_connection_by_ports(graph_ptr, port1_ptr, port2_ptr);
 597   if (connection_ptr == NULL)
 598   {
 599     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Cannot disconnect not connected ports %"PRIu64" and %"PRIu64, port1_id, port2_id);
 600     return;
 601   }
 602
 603   disconnect_ports(call_ptr, connection_ptr);
 604 }
 605
 606 static void disconnect_ports_by_connection_id(struct dbus_method_call * call_ptr)
 607 {
 608   dbus_uint64_t connection_id;
 609   struct ladish_graph_connection * connection_ptr;
 610
 611   if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_UINT64, &connection_id, DBUS_TYPE_INVALID))
 612   {
 613     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s", call_ptr->method_name, g_dbus_error.message);
 614     dbus_error_free(&g_dbus_error);
 615     return;
 616   }
 617
 618   log_info("disconnect_ports_by_connection_id(%"PRIu64") called.", connection_id);
 619
 620   connection_ptr = ladish_graph_find_connection_by_id(graph_ptr, connection_id);
 621   if (connection_ptr == NULL)
 622   {
 623     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Cannot find connection with id %"PRIu64, connection_id);
 624     return;
 625   }
 626
 627   disconnect_ports(call_ptr, connection_ptr);
 628 }
 629
 630 static void get_client_pid(struct dbus_method_call * call_ptr)
 631 {
 632   int64_t pid = 0;
 633   method_return_new_single(call_ptr, DBUS_TYPE_INT64, &pid);
 634 }
 635
 636 #undef graph_ptr
 637
 638 bool ladish_graph_create(ladish_graph_handle * graph_handle_ptr, const char * opath)
 639 {
 640   struct ladish_graph * graph_ptr;
 641
 642   graph_ptr = malloc(sizeof(struct ladish_graph));
 643   if (graph_ptr == NULL)
 644   {
 645     log_error("malloc() failed to allocate struct graph_implementator");
 646     return false;
 647   }
 648
 649   if (opath != NULL)
 650   {
 651     graph_ptr->opath = strdup(opath);
 652     if (graph_ptr->opath == NULL)
 653     {
 654       log_error("strdup() failed for graph opath");
 655       free(graph_ptr);
 656       return false;
 657     }
 658   }
 659   else
 660   {
 661     graph_ptr->opath = NULL;
 662   }
 663
 664   if (!ladish_dict_create(&graph_ptr->dict))
 665   {
 666     log_error("ladish_dict_create() failed for graph");
 667     if (graph_ptr->opath != NULL)
 668     {
 669       free(graph_ptr->opath);
 670     }
 671     free(graph_ptr);
 672     return false;
 673   }
 674
 675   INIT_LIST_HEAD(&graph_ptr->clients);
 676   INIT_LIST_HEAD(&graph_ptr->ports);
 677   INIT_LIST_HEAD(&graph_ptr->connections);
 678
 679   graph_ptr->graph_version = 1;
 680   graph_ptr->next_client_id = 1;
 681   graph_ptr->next_port_id = 1;
 682   graph_ptr->next_connection_id = 1;
 683
 684   graph_ptr->context = NULL;
 685   graph_ptr->connect_handler = NULL;
 686   graph_ptr->disconnect_handler = NULL;
 687
 688   graph_ptr->persist = true;
 689
 690   *graph_handle_ptr = (ladish_graph_handle)graph_ptr;
 691   return true;
 692 }
 693
 694 static
 695 struct ladish_graph_client *
 696 ladish_graph_find_client(
 697   struct ladish_graph * graph_ptr,
 698   ladish_client_handle client)
 699 {
 700   struct list_head * node_ptr;
 701   struct ladish_graph_client * client_ptr;
 702
 703   list_for_each(node_ptr, &graph_ptr->clients)
 704   {
 705     client_ptr = list_entry(node_ptr, struct ladish_graph_client, siblings);
 706     if (client_ptr->client == client)
 707     {
 708       return client_ptr;
 709     }
 710   }
 711
 712   return NULL;
 713 }
 714
 715 static
 716 struct ladish_graph_port *
 717 ladish_graph_find_port(
 718   struct ladish_graph * graph_ptr,
 719   ladish_port_handle port)
 720 {
 721   struct list_head * node_ptr;
 722   struct ladish_graph_port * port_ptr;
 723
 724   //log_info("searching port %p", port);
 725
 726   list_for_each(node_ptr, &graph_ptr->ports)
 727   {
 728     port_ptr = list_entry(node_ptr, struct ladish_graph_port, siblings_graph);
 729     //log_info("checking port %s:%s, %p", port_ptr->client_ptr->name, port_ptr->name, port_ptr->port);
 730     if (port_ptr->port == port)
 731     {
 732       return port_ptr;
 733     }
 734   }
 735
 736   return NULL;
 737 }
 738
 739 static
 740 struct ladish_graph_port *
 741 ladish_graph_find_port_by_jack_id_internal(
 742   struct ladish_graph * graph_ptr,
 743   uint64_t port_id,
 744   bool room,
 745   bool studio)
 746 {
 747   struct list_head * node_ptr;
 748   struct ladish_graph_port * port_ptr;
 749
 750   ASSERT(room || studio);
 751
 752   list_for_each(node_ptr, &graph_ptr->ports)
 753   {
 754     port_ptr = list_entry(node_ptr, struct ladish_graph_port, siblings_graph);
 755     //log_info("checking jack port id of port %s:%s, %p", port_ptr->client_ptr->name, port_ptr->name, port_ptr->port);
 756     if ((studio && ladish_port_get_jack_id(port_ptr->port) == port_id) ||
 757         (room && port_ptr->link && ladish_port_get_jack_id_room(port_ptr->port) == port_id))
 758     {
 759       //log_info("found");
 760       return port_ptr;
 761     }
 762   }
 763
 764   return NULL;
 765 }
 766
 767 #if 0
 768 static
 769 struct ladish_graph_port *
 770 ladish_graph_find_client_port(
 771   struct ladish_graph * graph_ptr,
 772   struct ladish_graph_client * client_ptr,
 773   ladish_port_handle port)
 774 {
 775   struct list_head * node_ptr;
 776   struct ladish_graph_port * port_ptr;
 777
 778   list_for_each(node_ptr, &client_ptr->ports)
 779   {
 780     port_ptr = list_entry(node_ptr, struct ladish_graph_port, siblings_client);
 781     if (port_ptr->port == port)
 782     {
 783       return port_ptr;
 784     }
 785   }
 786
 787   return NULL;
 788 }
 789 #endif
 790
 791 static void ladish_graph_hide_connection_internal(struct ladish_graph * graph_ptr, struct ladish_graph_connection * connection_ptr)
 792 {
 793   ASSERT(!connection_ptr->hidden);
 794   connection_ptr->hidden = true;
 795   graph_ptr->graph_version++;
 796
 797   if (graph_ptr->opath != NULL)
 798   {
 799     dbus_signal_emit(
 800       g_dbus_connection,
 801       graph_ptr->opath,
 802       JACKDBUS_IFACE_PATCHBAY,
 803       "PortsDisconnected",
 804       "ttstststst",
 805       &graph_ptr->graph_version,
 806       &connection_ptr->port1_ptr->client_ptr->id,
 807       &connection_ptr->port1_ptr->client_ptr->name,
 808       &connection_ptr->port1_ptr->id,
 809       &connection_ptr->port1_ptr->name,
 810       &connection_ptr->port2_ptr->client_ptr->id,
 811       &connection_ptr->port2_ptr->client_ptr->name,
 812       &connection_ptr->port2_ptr->id,
 813       &connection_ptr->port2_ptr->name,
 814       &connection_ptr->id);
 815   }
 816 }
 817
 818 static void ladish_graph_show_port_internal(struct ladish_graph * graph_ptr, struct ladish_graph_port * port_ptr)
 819 {
 820   if (port_ptr->client_ptr->hidden)
 821   {
 822     port_ptr->client_ptr->hidden = false;
 823     graph_ptr->graph_version++;
 824     if (graph_ptr->opath != NULL)
 825     {
 826       dbus_signal_emit(
 827         g_dbus_connection,
 828         graph_ptr->opath,
 829         JACKDBUS_IFACE_PATCHBAY,
 830         "ClientAppeared",
 831         "tts",
 832         &graph_ptr->graph_version,
 833         &port_ptr->client_ptr->id,
 834         &port_ptr->client_ptr->name);
 835     }
 836   }
 837
 838   ASSERT(port_ptr->hidden);
 839   port_ptr->hidden = false;
 840   graph_ptr->graph_version++;
 841   if (graph_ptr->opath != NULL)
 842   {
 843     dbus_signal_emit(
 844       g_dbus_connection,
 845       graph_ptr->opath,
 846       JACKDBUS_IFACE_PATCHBAY,
 847       "PortAppeared",
 848       "ttstsuu",
 849       &graph_ptr->graph_version,
 850       &port_ptr->client_ptr->id,
 851       &port_ptr->client_ptr->name,
 852       &port_ptr->id,
 853       &port_ptr->name,
 854       &port_ptr->flags,
 855       &port_ptr->type);
 856
 857     ladish_try_connect_hidden_connections((ladish_graph_handle)graph_ptr);
 858   }
 859 }
 860
 861 static void ladish_graph_hide_port_internal(struct ladish_graph * graph_ptr, struct ladish_graph_port * port_ptr)
 862 {
 863   ASSERT(!port_ptr->hidden);
 864   port_ptr->hidden = true;
 865   graph_ptr->graph_version++;
 866
 867   if (graph_ptr->opath != NULL)
 868   {
 869     dbus_signal_emit(
 870       g_dbus_connection,
 871       graph_ptr->opath,
 872       JACKDBUS_IFACE_PATCHBAY,
 873       "PortDisappeared",
 874       "ttsts",
 875       &graph_ptr->graph_version,
 876       &port_ptr->client_ptr->id,
 877       &port_ptr->client_ptr->name,
 878       &port_ptr->id,
 879       &port_ptr->name);
 880   }
 881 }
 882
 883 static void ladish_graph_hide_client_internal(struct ladish_graph * graph_ptr, struct ladish_graph_client * client_ptr)
 884 {
 885   ASSERT(!client_ptr->hidden);
 886   client_ptr->hidden = true;
 887   graph_ptr->graph_version++;
 888
 889   if (graph_ptr->opath != NULL)
 890   {
 891     dbus_signal_emit(
 892       g_dbus_connection,
 893       graph_ptr->opath,
 894       JACKDBUS_IFACE_PATCHBAY,
 895       "ClientDisappeared",
 896       "tts",
 897       &graph_ptr->graph_version,
 898       &client_ptr->id,
 899       &client_ptr->name);
 900   }
 901 }
 902
 903 static void ladish_hide_connections(struct ladish_graph * graph_ptr, struct ladish_graph_port * port_ptr)
 904 {
 905   struct list_head * node_ptr;
 906   struct ladish_graph_connection * connection_ptr;
 907
 908   log_info("hidding connections of port %"PRIu64, port_ptr->id);
 909
 910   ASSERT(graph_ptr->opath != NULL);
 911
 912   list_for_each(node_ptr, &graph_ptr->connections)
 913   {
 914     connection_ptr = list_entry(node_ptr, struct ladish_graph_connection, siblings);
 915     if (!connection_ptr->hidden && (connection_ptr->port1_ptr == port_ptr || connection_ptr->port2_ptr == port_ptr))
 916     {
 917       log_info("hidding connection between ports %"PRIu64" and %"PRIu64, connection_ptr->port1_ptr->id, connection_ptr->port2_ptr->id);
 918       ladish_graph_hide_connection_internal(graph_ptr, connection_ptr);
 919     }
 920   }
 921 }
 922
 923 static void ladish_graph_remove_connection_internal(struct ladish_graph * graph_ptr, struct ladish_graph_connection * connection_ptr)
 924 {
 925   list_del(&connection_ptr->siblings);
 926   graph_ptr->graph_version++;
 927
 928   if (!connection_ptr->hidden && graph_ptr->opath != NULL)
 929   {
 930     dbus_signal_emit(
 931       g_dbus_connection,
 932       graph_ptr->opath,
 933       JACKDBUS_IFACE_PATCHBAY,
 934       "PortsDisconnected",
 935       "ttstststst",
 936       &graph_ptr->graph_version,
 937       &connection_ptr->port1_ptr->client_ptr->id,
 938       &connection_ptr->port1_ptr->client_ptr->name,
 939       &connection_ptr->port1_ptr->id,
 940       &connection_ptr->port1_ptr->name,
 941       &connection_ptr->port2_ptr->client_ptr->id,
 942       &connection_ptr->port2_ptr->client_ptr->name,
 943       &connection_ptr->port2_ptr->id,
 944       &connection_ptr->port2_ptr->name,
 945       &connection_ptr->id);
 946   }
 947
 948   ladish_dict_destroy(connection_ptr->dict);
 949   free(connection_ptr);
 950 }
 951
 952 static void ladish_graph_remove_port_connections(struct ladish_graph * graph_ptr, struct ladish_graph_port * port_ptr)
 953 {
 954   struct list_head * node_ptr;
 955   struct list_head * temp_node_ptr;
 956   struct ladish_graph_connection * connection_ptr;
 957
 958   list_for_each_safe(node_ptr, temp_node_ptr, &graph_ptr->connections)
 959   {
 960     connection_ptr = list_entry(node_ptr, struct ladish_graph_connection, siblings);
 961     if (connection_ptr->port1_ptr == port_ptr || connection_ptr->port2_ptr == port_ptr)
 962     {
 963       log_info("removing connection between ports %"PRIu64" and %"PRIu64, connection_ptr->port1_ptr->id, connection_ptr->port2_ptr->id);
 964       ladish_graph_remove_connection_internal(graph_ptr, connection_ptr);
 965     }
 966   }
 967 }
 968
 969 static
 970 void
 971 ladish_graph_remove_port_internal(
 972   struct ladish_graph * graph_ptr,
 973   struct ladish_graph_client * client_ptr,
 974   struct ladish_graph_port * port_ptr)
 975 {
 976   ladish_graph_remove_port_connections(graph_ptr, port_ptr);
 977
 978   ladish_port_del_ref(port_ptr->port);
 979
 980   list_del(&port_ptr->siblings_client);
 981   list_del(&port_ptr->siblings_graph);
 982
 983   log_info("removing port '%s':'%s' (%"PRIu64":%"PRIu64") from graph %s", client_ptr->name, port_ptr->name, client_ptr->id, port_ptr->id, graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
 984   if (graph_ptr->opath != NULL && !port_ptr->hidden)
 985   {
 986     dbus_signal_emit(
 987       g_dbus_connection,
 988       graph_ptr->opath,
 989       JACKDBUS_IFACE_PATCHBAY,
 990       "PortDisappeared",
 991       "ttsts",
 992       &graph_ptr->graph_version,
 993       &client_ptr->id,
 994       &client_ptr->name,
 995       &port_ptr->id,
 996       &port_ptr->name);
 997   }
 998
 999   free(port_ptr->name);
1000   free(port_ptr);
1001 }
1002
1003 static
1004 void
1005 ladish_graph_remove_client_internal(
1006   struct ladish_graph * graph_ptr,
1007   struct ladish_graph_client * client_ptr,
1008   bool destroy_client,
1009   ladish_graph_simple_port_callback port_callback)
1010 {
1011   struct ladish_graph_port * port_ptr;
1012
1013   while (!list_empty(&client_ptr->ports))
1014   {
1015     port_ptr = list_entry(client_ptr->ports.next, struct ladish_graph_port, siblings_client);
1016     if (port_callback != NULL)
1017     {
1018       port_callback(port_ptr->port);
1019     }
1020     ladish_graph_remove_port_internal(graph_ptr, client_ptr, port_ptr);
1021   }
1022
1023   graph_ptr->graph_version++;
1024   list_del(&client_ptr->siblings);
1025   log_info("removing client '%s' (%"PRIu64") from graph %s", client_ptr->name, client_ptr->id, graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
1026   if (graph_ptr->opath != NULL && !client_ptr->hidden)
1027   {
1028     dbus_signal_emit(
1029       g_dbus_connection,
1030       graph_ptr->opath,
1031       JACKDBUS_IFACE_PATCHBAY,
1032       "ClientDisappeared",
1033       "tts",
1034       &graph_ptr->graph_version,
1035       &client_ptr->id,
1036       &client_ptr->name);
1037   }
1038
1039   free(client_ptr->name);
1040
1041   if (destroy_client)
1042   {
1043     ladish_client_destroy(client_ptr->client);
1044   }
1045
1046   free(client_ptr);
1047 }
1048
1049 bool ladish_graph_client_looks_empty_internal(struct ladish_graph * graph_ptr, struct ladish_graph_client * client_ptr)
1050 {
1051   struct list_head * node_ptr;
1052   struct ladish_graph_port * port_ptr;
1053
1054   list_for_each(node_ptr, &client_ptr->ports)
1055   {
1056     port_ptr = list_entry(node_ptr, struct ladish_graph_port, siblings_client);
1057     if (!port_ptr->hidden)
1058     {
1059       //log_info("port '%s' is visible, client '%s' does not look empty", port_ptr->name, client_ptr->name);
1060       return false;
1061     }
1062     else
1063     {
1064       //log_info("port '%s' is invisible", port_ptr->name);
1065     }
1066   }
1067
1068   //log_info("client '%s' looks empty in graph %s", client_ptr->name, graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
1069   return true;
1070 }
1071
1072 #define graph_ptr ((struct ladish_graph *)graph_handle)
1073
1074 void ladish_graph_destroy(ladish_graph_handle graph_handle)
1075 {
1076   ladish_graph_clear(graph_handle, NULL);
1077   ladish_dict_destroy(graph_ptr->dict);
1078   if (graph_ptr->opath != NULL)
1079   {
1080     free(graph_ptr->opath);
1081   }
1082   free(graph_ptr);
1083 }
1084
1085 const char * ladish_graph_get_opath(ladish_graph_handle graph_handle)
1086 {
1087   return graph_ptr->opath;
1088 }
1089
1090 const char * ladish_graph_get_description(ladish_graph_handle graph_handle)
1091 {
1092   return graph_ptr->opath != NULL ? graph_ptr->opath : "JACK";
1093 }
1094
1095 void
1096 ladish_graph_set_connection_handlers(
1097   ladish_graph_handle graph_handle,
1098   void * graph_context,
1099   ladish_graph_connect_request_handler connect_handler,
1100   ladish_graph_disconnect_request_handler disconnect_handler)
1101 {
1102   log_info("setting connection handlers for graph '%s'", graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
1103   graph_ptr->context = graph_context;
1104   graph_ptr->connect_handler = connect_handler;
1105   graph_ptr->disconnect_handler = disconnect_handler;
1106 }
1107
1108 void ladish_graph_clear(ladish_graph_handle graph_handle, ladish_graph_simple_port_callback port_callback)
1109 {
1110   struct ladish_graph_client * client_ptr;
1111   struct ladish_graph_connection * connection_ptr;
1112
1113   log_info("ladish_graph_clear() called for graph '%s'", graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
1114
1115   while (!list_empty(&graph_ptr->connections))
1116   {
1117     connection_ptr = list_entry(graph_ptr->connections.next, struct ladish_graph_connection, siblings);
1118     ladish_graph_remove_connection_internal(graph_ptr, connection_ptr);
1119   }
1120
1121   while (!list_empty(&graph_ptr->clients))
1122   {
1123     client_ptr = list_entry(graph_ptr->clients.next, struct ladish_graph_client, siblings);
1124     ladish_graph_remove_client_internal(graph_ptr, client_ptr, true, port_callback);
1125   }
1126 }
1127
1128 void * ladish_graph_get_dbus_context(ladish_graph_handle graph_handle)
1129 {
1130   return graph_handle;
1131 }
1132
1133 ladish_dict_handle ladish_graph_get_dict(ladish_graph_handle graph_handle)
1134 {
1135   return graph_ptr->dict;
1136 }
1137
1138 void ladish_graph_show_connection(ladish_graph_handle graph_handle, uint64_t connection_id)
1139 {
1140   struct ladish_graph_connection * connection_ptr;
1141
1142   log_info("ladish_graph_show_connection() called.");
1143
1144   connection_ptr = ladish_graph_find_connection_by_id(graph_ptr, connection_id);
1145   if (connection_ptr == NULL)
1146   {
1147     ASSERT_NO_PASS;
1148     return;
1149   }
1150
1151   ASSERT(graph_ptr->opath != NULL);
1152   ASSERT(connection_ptr->hidden);
1153   connection_ptr->hidden = false;
1154   connection_ptr->changing = false;
1155   graph_ptr->graph_version++;
1156
1157   dbus_signal_emit(
1158     g_dbus_connection,
1159     graph_ptr->opath,
1160     JACKDBUS_IFACE_PATCHBAY,
1161     "PortsConnected",
1162     "ttstststst",
1163     &graph_ptr->graph_version,
1164     &connection_ptr->port1_ptr->client_ptr->id,
1165     &connection_ptr->port1_ptr->client_ptr->name,
1166     &connection_ptr->port1_ptr->id,
1167     &connection_ptr->port1_ptr->name,
1168     &connection_ptr->port2_ptr->client_ptr->id,
1169     &connection_ptr->port2_ptr->client_ptr->name,
1170     &connection_ptr->port2_ptr->id,
1171     &connection_ptr->port2_ptr->name,
1172     &connection_ptr->id);
1173 }
1174
1175 void ladish_graph_show_port(ladish_graph_handle graph_handle, ladish_port_handle port_handle)
1176 {
1177   struct ladish_graph_port * port_ptr;
1178
1179   //log_info("ladish_graph_show_port() called.");
1180
1181   port_ptr = ladish_graph_find_port(graph_ptr, port_handle);
1182   if (port_ptr == NULL)
1183   {
1184     ASSERT_NO_PASS;
1185     return;
1186   }
1187
1188   //log_info("port '%s' is %s", port_ptr->name, port_ptr->hidden ? "invisible" : "visible");
1189
1190   ladish_graph_show_port_internal(graph_ptr, port_ptr);
1191 }
1192
1193 void ladish_graph_hide_port(ladish_graph_handle graph_handle, ladish_port_handle port_handle)
1194 {
1195   struct ladish_graph_port * port_ptr;
1196
1197   log_info("ladish_graph_hide_port() called.");
1198
1199   port_ptr = ladish_graph_find_port(graph_ptr, port_handle);
1200   if (port_ptr == NULL)
1201   {
1202     ASSERT_NO_PASS;
1203     return;
1204   }
1205
1206   log_info("Hidding port %"PRIu64, port_ptr->id);
1207
1208   ASSERT(!port_ptr->hidden);
1209
1210   if (graph_ptr->opath != NULL)
1211   {
1212     ladish_hide_connections(graph_ptr, port_ptr);
1213   }
1214
1215   ladish_graph_hide_port_internal(graph_ptr, port_ptr);
1216 }
1217
1218 void ladish_graph_hide_client(ladish_graph_handle graph_handle, ladish_client_handle client_handle)
1219 {
1220   struct ladish_graph_client * client_ptr;
1221
1222   log_info("ladish_graph_hide_client() called.");
1223
1224   client_ptr = ladish_graph_find_client(graph_ptr, client_handle);
1225   if (client_ptr == NULL)
1226   {
1227     ASSERT_NO_PASS;
1228     return;
1229   }
1230
1231   ladish_graph_hide_client_internal(graph_ptr, client_ptr);
1232 }
1233
1234 void ladish_graph_show_client(ladish_graph_handle graph_handle, ladish_client_handle client_handle)
1235 {
1236   struct ladish_graph_client * client_ptr;
1237
1238   log_info("ladish_graph_show_client() called.");
1239
1240   client_ptr = ladish_graph_find_client(graph_ptr, client_handle);
1241   if (client_ptr == NULL)
1242   {
1243     ASSERT_NO_PASS;
1244     return;
1245   }
1246
1247   ASSERT(client_ptr->hidden);
1248   client_ptr->hidden = false;
1249   graph_ptr->graph_version++;
1250
1251   if (graph_ptr->opath != NULL)
1252   {
1253     dbus_signal_emit(
1254       g_dbus_connection,
1255       graph_ptr->opath,
1256       JACKDBUS_IFACE_PATCHBAY,
1257       "ClientAppeared",
1258       "tts",
1259       &graph_ptr->graph_version,
1260       &client_ptr->id,
1261       &client_ptr->name);
1262   }
1263 }
1264
1265 void ladish_graph_adjust_port(ladish_graph_handle graph_handle, ladish_port_handle port_handle, uint32_t type, uint32_t flags)
1266 {
1267   struct ladish_graph_port * port_ptr;
1268
1269   //log_info("ladish_graph_adjust_port() called.");
1270
1271   port_ptr = ladish_graph_find_port(graph_ptr, port_handle);
1272   if (port_ptr == NULL)
1273   {
1274     ASSERT_NO_PASS;
1275     return;
1276   }
1277
1278   port_ptr->type = type;
1279   port_ptr->flags = flags;
1280 }
1281
1282 bool ladish_graph_add_client(ladish_graph_handle graph_handle, ladish_client_handle client_handle, const char * name, bool hidden)
1283 {
1284   struct ladish_graph_client * client_ptr;
1285
1286   log_info("adding client '%s' (%p) to graph %s", name, client_handle, graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
1287
1288   client_ptr = malloc(sizeof(struct ladish_graph_client));
1289   if (client_ptr == NULL)
1290   {
1291     log_error("malloc() failed for struct ladish_graph_client");
1292     return false;
1293   }
1294
1295   client_ptr->name = strdup(name);
1296   if (client_ptr->name == NULL)
1297   {
1298     log_error("strdup() failed for graph client name");
1299     free(client_ptr);
1300     return false;
1301   }
1302
1303   client_ptr->id = graph_ptr->next_client_id++;
1304   client_ptr->client = client_handle;
1305   client_ptr->hidden = hidden;
1306   graph_ptr->graph_version++;
1307
1308   INIT_LIST_HEAD(&client_ptr->ports);
1309
1310   list_add_tail(&client_ptr->siblings, &graph_ptr->clients);
1311
1312   if (!hidden && graph_ptr->opath != NULL)
1313   {
1314     dbus_signal_emit(
1315       g_dbus_connection,
1316       graph_ptr->opath,
1317       JACKDBUS_IFACE_PATCHBAY,
1318       "ClientAppeared",
1319       "tts",
1320       &graph_ptr->graph_version,
1321       &client_ptr->id,
1322       &client_ptr->name);
1323   }
1324
1325   return true;
1326 }
1327
1328 void
1329 ladish_graph_remove_client(
1330   ladish_graph_handle graph_handle,
1331   ladish_client_handle client_handle)
1332 {
1333   struct ladish_graph_client * client_ptr;
1334
1335   log_info("ladish_graph_remove_client() called.");
1336
1337   client_ptr = ladish_graph_find_client(graph_ptr, client_handle);
1338   if (client_ptr != NULL)
1339   {
1340     ladish_graph_remove_client_internal(graph_ptr, client_ptr, false, NULL);
1341   }
1342   else
1343   {
1344     ASSERT_NO_PASS;
1345   }
1346 }
1347
1348 bool
1349 ladish_graph_add_port(
1350   ladish_graph_handle graph_handle,
1351   ladish_client_handle client_handle,
1352   ladish_port_handle port_handle,
1353   const char * name,
1354   uint32_t type,
1355   uint32_t flags,
1356   bool hidden)
1357 {
1358   struct ladish_graph_client * client_ptr;
1359   struct ladish_graph_port * port_ptr;
1360
1361   client_ptr = ladish_graph_find_client(graph_ptr, client_handle);
1362   if (client_ptr == NULL)
1363   {
1364     log_error("cannot find client to add port to. graph is %s", graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
1365     ASSERT_NO_PASS;
1366     return false;
1367   }
1368
1369   log_info("adding port '%s' (%p) to client '%s' in graph %s", name, port_handle, client_ptr->name, graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
1370
1371   port_ptr = malloc(sizeof(struct ladish_graph_port));
1372   if (port_ptr == NULL)
1373   {
1374     log_error("malloc() failed for struct ladish_graph_port");
1375     return false;
1376   }
1377
1378   port_ptr->name = strdup(name);
1379   if (port_ptr->name == NULL)
1380   {
1381     log_error("strdup() failed for graph port name");
1382     free(port_ptr);
1383     return false;
1384   }
1385
1386   port_ptr->type = type;
1387   port_ptr->flags = flags;
1388
1389   port_ptr->id = graph_ptr->next_port_id++;
1390   port_ptr->port = port_handle;
1391   ladish_port_add_ref(port_ptr->port);
1392   port_ptr->hidden = true;
1393
1394   port_ptr->link = ladish_port_is_link(port_handle);
1395   if (port_ptr->link)
1396   {
1397     uuid_generate(port_ptr->link_uuid_override);
1398   }
1399
1400   port_ptr->client_ptr = client_ptr;
1401   list_add_tail(&port_ptr->siblings_client, &client_ptr->ports);
1402   list_add_tail(&port_ptr->siblings_graph, &graph_ptr->ports);
1403
1404   if (!hidden)
1405   {
1406     ladish_graph_show_port_internal(graph_ptr, port_ptr);
1407   }
1408
1409   return true;
1410 }
1411
1412 uint64_t
1413 ladish_graph_add_connection(
1414   ladish_graph_handle graph_handle,
1415   ladish_port_handle port1_handle,
1416   ladish_port_handle port2_handle,
1417   bool hidden)
1418 {
1419   struct ladish_graph_port * port1_ptr;
1420   struct ladish_graph_port * port2_ptr;
1421   struct ladish_graph_connection * connection_ptr;
1422
1423   port1_ptr = ladish_graph_find_port(graph_ptr, port1_handle);
1424   ASSERT(port1_ptr != NULL);
1425   port2_ptr = ladish_graph_find_port(graph_ptr, port2_handle);
1426   ASSERT(port2_ptr != NULL);
1427
1428   connection_ptr = malloc(sizeof(struct ladish_graph_connection));
1429   if (connection_ptr == NULL)
1430   {
1431     log_error("malloc() failed for struct ladish_graph_connection");
1432     return 0;
1433   }
1434
1435   if (!ladish_dict_create(&connection_ptr->dict))
1436   {
1437     log_error("ladish_dict_create() failed for connection");
1438     free(connection_ptr);
1439     return 0;
1440   }
1441
1442   connection_ptr->id = graph_ptr->next_connection_id++;
1443   connection_ptr->port1_ptr = port1_ptr;
1444   connection_ptr->port2_ptr = port2_ptr;
1445   connection_ptr->hidden = hidden;
1446   connection_ptr->changing = false;
1447   graph_ptr->graph_version++;
1448
1449   list_add_tail(&connection_ptr->siblings, &graph_ptr->connections);
1450
1451   /* log_info( */
1452   /*   "new connection %"PRIu64" between '%s':'%s' and '%s':'%s'", */
1453   /*   connection_ptr->id, */
1454   /*   port1_ptr->client_ptr->name, */
1455   /*   port1_ptr->name, */
1456   /*   port2_ptr->client_ptr->name, */
1457   /*   port2_ptr->name); */
1458
1459   if (!hidden && graph_ptr->opath != NULL)
1460   {
1461     dbus_signal_emit(
1462       g_dbus_connection,
1463       graph_ptr->opath,
1464       JACKDBUS_IFACE_PATCHBAY,
1465       "PortsConnected",
1466       "ttstststst",
1467       &graph_ptr->graph_version,
1468       &port1_ptr->client_ptr->id,
1469       &port1_ptr->client_ptr->name,
1470       &port1_ptr->id,
1471       &port1_ptr->name,
1472       &port2_ptr->client_ptr->id,
1473       &port2_ptr->client_ptr->name,
1474       &port2_ptr->id,
1475       &port2_ptr->name,
1476       &connection_ptr->id);
1477   }
1478
1479   return connection_ptr->id;
1480 }
1481
1482 void
1483 ladish_graph_remove_connection(
1484   ladish_graph_handle graph_handle,
1485   uint64_t connection_id,
1486   bool force)
1487 {
1488   struct ladish_graph_connection * connection_ptr;
1489
1490   connection_ptr = ladish_graph_find_connection_by_id(graph_ptr, connection_id);
1491   if (connection_ptr == NULL)
1492   {
1493     ASSERT_NO_PASS;
1494     return;
1495   }
1496
1497   if (force || connection_ptr->changing || !graph_ptr->persist)
1498   {
1499     /* log_info( */
1500     /*   "removing connection '%s':'%s' - '%s':'%s'", */
1501     /*   connection_ptr->port1_ptr->client_ptr->name, */
1502     /*   connection_ptr->port1_ptr->name, */
1503     /*   connection_ptr->port2_ptr->client_ptr->name, */
1504     /*   connection_ptr->port2_ptr->name); */
1505
1506     ladish_graph_remove_connection_internal(graph_ptr, connection_ptr);
1507   }
1508   else
1509   {
1510     /* log_info( */
1511     /*   "hiding connection '%s':'%s' - '%s':'%s'", */
1512     /*   connection_ptr->port1_ptr->client_ptr->name, */
1513     /*   connection_ptr->port1_ptr->name, */
1514     /*   connection_ptr->port2_ptr->client_ptr->name, */
1515     /*   connection_ptr->port2_ptr->name); */
1516
1517     ladish_graph_hide_connection_internal(graph_ptr, connection_ptr);
1518   }
1519 }
1520
1521 bool
1522 ladish_graph_get_connection_ports(
1523   ladish_graph_handle graph_handle,
1524   uint64_t connection_id,
1525   ladish_port_handle * port1_handle_ptr,
1526   ladish_port_handle * port2_handle_ptr)
1527 {
1528   struct ladish_graph_connection * connection_ptr;
1529
1530   connection_ptr = ladish_graph_find_connection_by_id(graph_ptr, connection_id);
1531   if (connection_ptr == NULL)
1532   {
1533     return false;
1534   }
1535
1536   *port1_handle_ptr = connection_ptr->port1_ptr->port;
1537   *port2_handle_ptr = connection_ptr->port2_ptr->port;
1538
1539   return true;
1540 }
1541
1542 ladish_dict_handle ladish_graph_get_connection_dict(ladish_graph_handle graph_handle, uint64_t connection_id)
1543 {
1544   struct ladish_graph_connection * connection_ptr;
1545
1546   connection_ptr = ladish_graph_find_connection_by_id(graph_ptr, connection_id);
1547   if (connection_ptr == NULL)
1548   {
1549     return NULL;
1550   }
1551
1552   return connection_ptr->dict;
1553 }
1554
1555 bool
1556 ladish_graph_find_connection(
1557   ladish_graph_handle graph_handle,
1558   ladish_port_handle port1_handle,
1559   ladish_port_handle port2_handle,
1560   uint64_t * connection_id_ptr)
1561 {
1562   struct ladish_graph_port * port1_ptr;
1563   struct ladish_graph_port * port2_ptr;
1564   struct ladish_graph_connection * connection_ptr;
1565
1566   port1_ptr = ladish_graph_find_port(graph_ptr, port1_handle);
1567   if (port1_ptr == NULL)
1568   {
1569     return false;
1570   }
1571
1572   port2_ptr = ladish_graph_find_port(graph_ptr, port2_handle);
1573   if (port1_ptr == NULL)
1574   {
1575     return false;
1576   }
1577
1578   connection_ptr = ladish_graph_find_connection_by_ports(graph_ptr, port1_ptr, port2_ptr);
1579   if (connection_ptr == NULL)
1580   {
1581     return false;
1582   }
1583
1584   *connection_id_ptr = connection_ptr->id;
1585
1586   return true;
1587 }
1588
1589 ladish_client_handle ladish_graph_find_client_by_name(ladish_graph_handle graph_handle, const char * name, bool appless)
1590 {
1591   struct list_head * node_ptr;
1592   struct ladish_graph_client * client_ptr;
1593
1594   list_for_each(node_ptr, &graph_ptr->clients)
1595   {
1596     client_ptr = list_entry(node_ptr, struct ladish_graph_client, siblings);
1597     if (strcmp(client_ptr->name, name) == 0 &&
1598         (!appless || !ladish_client_has_app(client_ptr->client))) /* if appless is true, then an appless client is being searched */
1599     {
1600       return client_ptr->client;
1601     }
1602   }
1603
1604   return NULL;
1605 }
1606
1607 ladish_client_handle ladish_graph_find_client_by_app(ladish_graph_handle graph_handle, const uuid_t app_uuid)
1608 {
1609   struct list_head * node_ptr;
1610   struct ladish_graph_client * client_ptr;
1611   uuid_t current_uuid;
1612
1613   list_for_each(node_ptr, &graph_ptr->clients)
1614   {
1615     client_ptr = list_entry(node_ptr, struct ladish_graph_client, siblings);
1616     ladish_client_get_app(client_ptr->client, current_uuid);
1617     if (uuid_compare(current_uuid, app_uuid) == 0)
1618     {
1619       return client_ptr->client;
1620     }
1621   }
1622
1623   return NULL;
1624 }
1625
1626 ladish_port_handle ladish_graph_find_port_by_name(ladish_graph_handle graph_handle, ladish_client_handle client_handle, const char * name)
1627 {
1628   struct ladish_graph_client * client_ptr;
1629   struct list_head * node_ptr;
1630   struct ladish_graph_port * port_ptr;
1631
1632   client_ptr = ladish_graph_find_client(graph_ptr, client_handle);
1633   if (client_ptr != NULL)
1634   {
1635     list_for_each(node_ptr, &client_ptr->ports)
1636     {
1637       port_ptr = list_entry(node_ptr, struct ladish_graph_port, siblings_client);
1638       if (strcmp(port_ptr->name, name) == 0)
1639       {
1640         return port_ptr->port;
1641       }
1642     }
1643   }
1644   else
1645   {
1646     ASSERT_NO_PASS;
1647   }
1648
1649   return NULL;
1650 }
1651
1652 ladish_client_handle ladish_graph_find_client_by_uuid(ladish_graph_handle graph_handle, const uuid_t uuid)
1653 {
1654   struct list_head * node_ptr;
1655   struct ladish_graph_client * client_ptr;
1656   uuid_t current_uuid;
1657
1658   list_for_each(node_ptr, &graph_ptr->clients)
1659   {
1660     client_ptr = list_entry(node_ptr, struct ladish_graph_client, siblings);
1661     ladish_client_get_uuid(client_ptr->client, current_uuid);
1662     if (uuid_compare(current_uuid, uuid) == 0)
1663     {
1664       return client_ptr->client;
1665     }
1666   }
1667
1668   return NULL;
1669 }
1670
1671 ladish_port_handle ladish_graph_find_port_by_uuid(ladish_graph_handle graph_handle, const uuid_t uuid, bool use_link_override_uuids)
1672 {
1673   struct ladish_graph_port * port_ptr;
1674
1675   port_ptr = ladish_graph_find_port_by_uuid_internal(graph_ptr, uuid, use_link_override_uuids);
1676   if (port_ptr != NULL)
1677   {
1678     return port_ptr->port;
1679   }
1680
1681   return NULL;
1682 }
1683
1684 ladish_client_handle ladish_graph_get_port_client(ladish_graph_handle graph_handle, ladish_port_handle port_handle)
1685 {
1686   struct ladish_graph_port * port_ptr;
1687
1688   port_ptr = ladish_graph_find_port(graph_ptr, port_handle);
1689   if (port_ptr == NULL)
1690   {
1691     return NULL;
1692   }
1693
1694   return port_ptr->client_ptr->client;
1695 }
1696
1697 bool ladish_graph_is_port_present(ladish_graph_handle graph_handle, ladish_port_handle port_handle)
1698 {
1699   return ladish_graph_find_port(graph_ptr, port_handle) != NULL;
1700 }
1701
1702 ladish_client_handle ladish_graph_find_client_by_id(ladish_graph_handle graph_handle, uint64_t client_id)
1703 {
1704   struct list_head * node_ptr;
1705   struct ladish_graph_client * client_ptr;
1706
1707   list_for_each(node_ptr, &graph_ptr->clients)
1708   {
1709     client_ptr = list_entry(node_ptr, struct ladish_graph_client, siblings);
1710     if (client_ptr->id == client_id)
1711     {
1712       return client_ptr->client;
1713     }
1714   }
1715
1716   return NULL;
1717 }
1718
1719 ladish_port_handle ladish_graph_find_port_by_id(ladish_graph_handle graph_handle, uint64_t port_id)
1720 {
1721   struct ladish_graph_port * port_ptr;
1722
1723   port_ptr = ladish_graph_find_port_by_id_internal(graph_ptr, port_id);
1724   if (port_ptr == NULL)
1725   {
1726     return NULL;
1727   }
1728
1729   return port_ptr->port;
1730 }
1731
1732 ladish_client_handle ladish_graph_find_client_by_jack_id(ladish_graph_handle graph_handle, uint64_t client_id)
1733 {
1734   struct list_head * node_ptr;
1735   struct ladish_graph_client * client_ptr;
1736
1737   list_for_each(node_ptr, &graph_ptr->clients)
1738   {
1739     client_ptr = list_entry(node_ptr, struct ladish_graph_client, siblings);
1740     if (ladish_client_get_jack_id(client_ptr->client) == client_id)
1741     {
1742       return client_ptr->client;
1743     }
1744   }
1745
1746   return NULL;
1747 }
1748
1749 ladish_port_handle ladish_graph_find_port_by_jack_id(ladish_graph_handle graph_handle, uint64_t port_id, bool room, bool studio)
1750 {
1751   struct ladish_graph_port * port_ptr;
1752
1753   port_ptr = ladish_graph_find_port_by_jack_id_internal(graph_ptr, port_id, room, studio);
1754   if (port_ptr == NULL)
1755   {
1756     return NULL;
1757   }
1758
1759   return port_ptr->port;
1760 }
1761
1762 ladish_client_handle
1763 ladish_graph_remove_port(
1764   ladish_graph_handle graph_handle,
1765   ladish_port_handle port)
1766 {
1767   struct ladish_graph_port * port_ptr;
1768   ladish_client_handle client;
1769
1770   port_ptr = ladish_graph_find_port(graph_ptr, port);
1771   if (port_ptr == NULL)
1772   {
1773     return NULL;
1774   }
1775
1776   client = port_ptr->client_ptr->client;
1777   ladish_graph_remove_port_internal(graph_ptr, port_ptr->client_ptr, port_ptr);
1778   return client;
1779 }
1780
1781 ladish_client_handle
1782 ladish_graph_remove_port_by_jack_id(
1783   ladish_graph_handle graph_handle,
1784   uint64_t jack_port_id,
1785   bool room,
1786   bool studio)
1787 {
1788   struct ladish_graph_port * port_ptr;
1789   ladish_client_handle client;
1790
1791   port_ptr = ladish_graph_find_port_by_jack_id_internal(graph_ptr, jack_port_id, room, studio);
1792   if (port_ptr == NULL)
1793   {
1794     return NULL;
1795   }
1796
1797   client = port_ptr->client_ptr->client;
1798   ladish_graph_remove_port_internal(graph_ptr, port_ptr->client_ptr, port_ptr);
1799   return client;
1800 }
1801
1802 bool
1803 ladish_graph_rename_client(
1804   ladish_graph_handle graph_handle,
1805   ladish_client_handle client_handle,
1806   const char * new_client_name)
1807 {
1808   char * name;
1809   struct ladish_graph_client * client_ptr;
1810   char * old_name;
1811
1812   name = strdup(new_client_name);
1813   if (name == NULL)
1814   {
1815     log_error("strdup('%s') failed.", new_client_name);
1816     return false;
1817   }
1818
1819   client_ptr = ladish_graph_find_client(graph_ptr, client_handle);
1820   if (client_ptr == NULL)
1821   {
1822     free(name);
1823     ASSERT_NO_PASS;
1824     return false;
1825   }
1826
1827   old_name = client_ptr->name;
1828   client_ptr->name = name;
1829
1830   graph_ptr->graph_version++;
1831
1832   if (!client_ptr->hidden && graph_ptr->opath != NULL)
1833   {
1834     dbus_signal_emit(
1835       g_dbus_connection,
1836       graph_ptr->opath,
1837       JACKDBUS_IFACE_PATCHBAY,
1838       "ClientRenamed",
1839       "ttss",
1840       &graph_ptr->graph_version,
1841       &client_ptr->id,
1842       &old_name,
1843       &client_ptr->name);
1844   }
1845
1846   free(old_name);
1847
1848   return true;
1849 }
1850
1851 bool
1852 ladish_graph_rename_port(
1853   ladish_graph_handle graph_handle,
1854   ladish_port_handle port_handle,
1855   const char * new_port_name)
1856 {
1857   char * name;
1858   struct ladish_graph_port * port_ptr;
1859   char * old_name;
1860
1861   name = strdup(new_port_name);
1862   if (name == NULL)
1863   {
1864     log_error("strdup('%s') failed.", new_port_name);
1865     return false;
1866   }
1867
1868   port_ptr = ladish_graph_find_port(graph_ptr, port_handle);
1869   if (port_ptr == NULL)
1870   {
1871     ASSERT_NO_PASS;
1872     free(name);
1873     return false;
1874   }
1875
1876   old_name = port_ptr->name;
1877   port_ptr->name = name;
1878
1879   graph_ptr->graph_version++;
1880
1881   if (!port_ptr->hidden && graph_ptr->opath != NULL)
1882   {
1883     dbus_signal_emit(
1884       g_dbus_connection,
1885       graph_ptr->opath,
1886       JACKDBUS_IFACE_PATCHBAY,
1887       "PortRenamed",
1888       "ttstss",
1889       &graph_ptr->graph_version,
1890       &port_ptr->client_ptr->id,
1891       &port_ptr->client_ptr->name,
1892       &port_ptr->id,
1893       &old_name,
1894       &port_ptr->name);
1895   }
1896
1897   free(old_name);
1898
1899   return true;
1900 }
1901
1902 const char * ladish_graph_get_client_name(ladish_graph_handle graph_handle, ladish_client_handle client_handle)
1903 {
1904   struct ladish_graph_client * client_ptr;
1905
1906   client_ptr = ladish_graph_find_client(graph_ptr, client_handle);
1907   if (client_ptr != NULL)
1908   {
1909       return client_ptr->name;
1910   }
1911
1912   ASSERT_NO_PASS;
1913   return NULL;
1914 }
1915
1916 bool ladish_graph_client_is_empty(ladish_graph_handle graph_handle, ladish_client_handle client_handle)
1917 {
1918   struct ladish_graph_client * client_ptr;
1919
1920   client_ptr = ladish_graph_find_client(graph_ptr, client_handle);
1921   if (client_ptr != NULL)
1922   {
1923     return list_empty(&client_ptr->ports);
1924   }
1925
1926   ASSERT_NO_PASS;
1927   return true;
1928 }
1929
1930 bool ladish_graph_client_looks_empty(ladish_graph_handle graph_handle, ladish_client_handle client_handle)
1931 {
1932   struct ladish_graph_client * client_ptr;
1933
1934   client_ptr = ladish_graph_find_client(graph_ptr, client_handle);
1935   if (client_ptr == NULL)
1936   {
1937     ASSERT_NO_PASS;
1938     return true;
1939   }
1940
1941   if (ladish_graph_client_looks_empty_internal(graph_ptr, client_ptr))
1942   {
1943     //log_info("client '%s' looks empty in graph %s", client_ptr->name, graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
1944     return true;
1945   }
1946
1947   return false;
1948 }
1949
1950 bool ladish_graph_client_is_hidden(ladish_graph_handle graph_handle, ladish_client_handle client_handle)
1951 {
1952   struct ladish_graph_client * client_ptr;
1953
1954   client_ptr = ladish_graph_find_client(graph_ptr, client_handle);
1955   if (client_ptr != NULL)
1956   {
1957     return client_ptr->hidden;
1958   }
1959
1960   ASSERT_NO_PASS;
1961   return true;
1962 }
1963
1964 void ladish_try_connect_hidden_connections(ladish_graph_handle graph_handle)
1965 {
1966   struct list_head * node_ptr;
1967   struct ladish_graph_connection * connection_ptr;
1968
1969   if (!list_empty(&graph_ptr->connections) && graph_ptr->connect_handler == NULL)
1970   {
1971     ASSERT_NO_PASS;
1972     return;
1973   }
1974
1975   ASSERT(graph_ptr->opath != NULL);
1976
1977   list_for_each(node_ptr, &graph_ptr->connections)
1978   {
1979     connection_ptr = list_entry(node_ptr, struct ladish_graph_connection, siblings);
1980     log_debug(
1981       "checking connection (%s, %s) '%s':'%s' (%s) to '%s':'%s' (%s)",
1982       connection_ptr->hidden ? "hidden" : "visible",
1983       connection_ptr->changing ? "changing" : "not changing",
1984       connection_ptr->port1_ptr->client_ptr->name,
1985       connection_ptr->port1_ptr->name,
1986       connection_ptr->port1_ptr->hidden ? "hidden" : "visible",
1987       connection_ptr->port2_ptr->client_ptr->name,
1988       connection_ptr->port2_ptr->name,
1989       connection_ptr->port2_ptr->hidden ? "hidden" : "visible");
1990     if (connection_ptr->hidden &&
1991         !connection_ptr->changing &&
1992         !connection_ptr->port1_ptr->hidden &&
1993         !connection_ptr->port2_ptr->hidden)
1994     {
1995       log_info(
1996         "auto connecting '%s':'%s' to '%s':'%s'",
1997         connection_ptr->port1_ptr->client_ptr->name,
1998         connection_ptr->port1_ptr->name,
1999         connection_ptr->port2_ptr->client_ptr->name,
2000         connection_ptr->port2_ptr->name);
2001
2002       connection_ptr->changing = true;
2003       if (!graph_ptr->connect_handler(graph_ptr->context, graph_handle, connection_ptr->port1_ptr->port, connection_ptr->port2_ptr->port))
2004       {
2005         connection_ptr->changing = false;
2006         log_error("auto connect failed.");
2007       }
2008     }
2009   }
2010 }
2011
2012 void ladish_graph_hide_non_virtual(ladish_graph_handle graph_handle)
2013 {
2014   struct list_head * node_ptr;
2015   struct ladish_graph_connection * connection_ptr;
2016   struct ladish_graph_port * port_ptr;
2017   struct ladish_graph_client * client_ptr;
2018
2019   log_info("hiding everything in graph %s", graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
2020
2021   list_for_each(node_ptr, &graph_ptr->connections)
2022   {
2023     connection_ptr = list_entry(node_ptr, struct ladish_graph_connection, siblings);
2024     if (!connection_ptr->hidden &&
2025         (ladish_client_get_jack_id(connection_ptr->port1_ptr->client_ptr->client) != 0 ||
2026          ladish_client_get_jack_id(connection_ptr->port2_ptr->client_ptr->client) != 0))
2027     {
2028       log_debug("hidding connection between ports %"PRIu64" and %"PRIu64, connection_ptr->port1_ptr->id, connection_ptr->port2_ptr->id);
2029       ladish_graph_hide_connection_internal(graph_ptr, connection_ptr);
2030     }
2031   }
2032
2033   list_for_each(node_ptr, &graph_ptr->ports)
2034   {
2035     port_ptr = list_entry(node_ptr, struct ladish_graph_port, siblings_graph);
2036     if (!port_ptr->hidden && ladish_client_get_jack_id(port_ptr->client_ptr->client) != 0)
2037     {
2038       ladish_port_set_jack_id(port_ptr->port, 0);
2039       ladish_graph_hide_port_internal(graph_ptr, port_ptr);
2040     }
2041   }
2042
2043   list_for_each(node_ptr, &graph_ptr->clients)
2044   {
2045     client_ptr = list_entry(node_ptr, struct ladish_graph_client, siblings);
2046     if (!client_ptr->hidden && ladish_client_get_jack_id(client_ptr->client) != 0)
2047     {
2048       ladish_client_set_jack_id(client_ptr->client, 0);
2049       ladish_graph_hide_client_internal(graph_ptr, client_ptr);
2050     }
2051   }
2052 }
2053
2054 void ladish_graph_get_port_uuid(ladish_graph_handle graph_handle, ladish_port_handle port, uuid_t uuid_ptr)
2055 {
2056   struct ladish_graph_port * port_ptr;
2057
2058   port_ptr = ladish_graph_find_port(graph_ptr, port);
2059   ASSERT(port_ptr != NULL);
2060   ASSERT(port_ptr->link);
2061
2062   uuid_copy(uuid_ptr, port_ptr->link_uuid_override);
2063 }
2064
2065 const char * ladish_graph_get_port_name(ladish_graph_handle graph_handle, ladish_port_handle port)
2066 {
2067   struct ladish_graph_port * port_ptr;
2068
2069   port_ptr = ladish_graph_find_port(graph_ptr, port);
2070   ASSERT(port_ptr != NULL);
2071
2072   return port_ptr->name;
2073 }
2074
2075 void ladish_graph_set_link_port_override_uuid(ladish_graph_handle graph_handle, const uuid_t uuid, const uuid_t override_uuid)
2076 {
2077   struct ladish_graph_port * port_ptr;
2078
2079   port_ptr = ladish_graph_find_port_by_uuid_internal(graph_ptr, uuid, false);
2080   ASSERT(ladish_port_is_link(port_ptr->port));
2081   uuid_copy(port_ptr->link_uuid_override, override_uuid);
2082 }
2083
2084 bool
2085 ladish_graph_iterate_nodes(
2086   ladish_graph_handle graph_handle,
2087   bool skip_hidden,
2088   void * vgraph_filter,
2089   void * callback_context,
2090   bool
2091   (* client_begin_callback)(
2092     void * context,
2093     ladish_graph_handle graph_handle,
2094     ladish_client_handle client_handle,
2095     const char * client_name,
2096     void ** client_iteration_context_ptr_ptr),
2097   bool
2098   (* port_callback)(
2099     void * context,
2100     ladish_graph_handle graph_handle,
2101     void * client_iteration_context_ptr,
2102     ladish_client_handle client_handle,
2103     const char * client_name,
2104     ladish_port_handle port_handle,
2105     const char * port_name,
2106     uint32_t port_type,
2107     uint32_t port_flags),
2108   bool
2109   (* client_end_callback)(
2110     void * context,
2111     ladish_graph_handle graph_handle,
2112     ladish_client_handle client_handle,
2113     const char * client_name,
2114     void * client_iteration_context_ptr))
2115 {
2116   struct list_head * client_node_ptr;
2117   struct ladish_graph_client * client_ptr;
2118   void * client_context;
2119   struct list_head * port_node_ptr;
2120   struct ladish_graph_port * port_ptr;
2121   void * vgraph;
2122
2123   list_for_each(client_node_ptr, &graph_ptr->clients)
2124   {
2125     client_ptr = list_entry(client_node_ptr, struct ladish_graph_client, siblings);
2126
2127     if (skip_hidden && client_ptr->hidden)
2128     {
2129       continue;
2130     }
2131
2132     if (vgraph_filter != NULL)
2133     {
2134       vgraph = ladish_client_get_vgraph(client_ptr->client);
2135       if (vgraph != vgraph_filter)
2136       {
2137         continue;
2138       }
2139     }
2140
2141     if (client_begin_callback != NULL)
2142     {
2143       if (!client_begin_callback(callback_context, graph_handle, client_ptr->client, client_ptr->name, &client_context))
2144       {
2145         return false;
2146       }
2147     }
2148     else
2149     {
2150       client_context = NULL;
2151     }
2152
2153     if (port_callback == NULL)
2154     {
2155       continue;
2156     }
2157
2158     list_for_each(port_node_ptr, &client_ptr->ports)
2159     {
2160       port_ptr = list_entry(port_node_ptr, struct ladish_graph_port, siblings_client);
2161
2162       if (skip_hidden && port_ptr->hidden)
2163       {
2164         continue;
2165       }
2166
2167       if (!port_callback(
2168             callback_context,
2169             graph_handle,
2170             client_context,
2171             client_ptr->client,
2172             client_ptr->name,
2173             port_ptr->port,
2174             port_ptr->name,
2175             port_ptr->type,
2176             port_ptr->flags))
2177       {
2178         return false;
2179       }
2180     }
2181
2182     if (client_end_callback != NULL)
2183     {
2184       if (!client_end_callback(callback_context, graph_handle, client_ptr->client, client_ptr->name, &client_context))
2185       {
2186         return false;
2187       }
2188     }
2189   }
2190
2191   return true;
2192 }
2193
2194 bool
2195 ladish_graph_iterate_connections(
2196   ladish_graph_handle graph_handle,
2197   bool skip_hidden,
2198   void * callback_context,
2199   bool (* callback)(
2200     void * context,
2201     ladish_graph_handle graph_handle,
2202     ladish_port_handle port1_handle,
2203     ladish_port_handle port2_handle,
2204     ladish_dict_handle dict))
2205 {
2206   struct list_head * node_ptr;
2207   struct ladish_graph_connection * connection_ptr;
2208
2209   list_for_each(node_ptr, &graph_ptr->connections)
2210   {
2211     connection_ptr = list_entry(node_ptr, struct ladish_graph_connection, siblings);
2212
2213     if (skip_hidden && connection_ptr->hidden)
2214     {
2215       continue;
2216     }
2217
2218     if (!callback(callback_context, graph_handle, connection_ptr->port1_ptr->port, connection_ptr->port2_ptr->port, connection_ptr->dict))
2219     {
2220       return false;
2221     }
2222   }
2223
2224   return true;
2225 }
2226
2227 static
2228 bool
2229 dump_dict_entry(
2230   void * context,
2231   const char * key,
2232   const char * value)
2233 {
2234   log_info("%s  key '%s' with value '%s'", (const char *)context, key, value);
2235   return true;
2236 }
2237
2238 static
2239 void
2240 dump_dict(
2241   const char * indent,
2242   ladish_dict_handle dict)
2243 {
2244   if (ladish_dict_is_empty(dict))
2245   {
2246     return;
2247   }
2248
2249   log_info("%sdict:", indent);
2250   ladish_dict_iterate(dict, (void *)indent, dump_dict_entry);
2251 }
2252
2253 void ladish_graph_dump(ladish_graph_handle graph_handle)
2254 {
2255   struct list_head * client_node_ptr;
2256   struct ladish_graph_client * client_ptr;
2257   struct list_head * port_node_ptr;
2258   struct ladish_graph_port * port_ptr;
2259   struct list_head * connection_node_ptr;
2260   struct ladish_graph_connection * connection_ptr;
2261   uuid_t uuid;
2262   char uuid_str[37];
2263
2264   log_info("graph %s", graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
2265   log_info("  version %"PRIu64, graph_ptr->graph_version);
2266   log_info("  persist: %s", graph_ptr->persist ? "yes" : "no");
2267   dump_dict("  ", graph_ptr->dict);
2268   log_info("  clients:");
2269   list_for_each(client_node_ptr, &graph_ptr->clients)
2270   {
2271     client_ptr = list_entry(client_node_ptr, struct ladish_graph_client, siblings);
2272     log_info("    %s client '%s', id=%"PRIu64", ptr=%p%", client_ptr->hidden ? "invisible" : "visible", client_ptr->name, client_ptr->id, client_ptr->client);
2273     ladish_client_get_uuid(client_ptr->client, uuid);
2274     uuid_unparse(uuid, uuid_str);
2275     log_info("    uuid=%s", uuid_str);
2276     if (ladish_client_get_interlink(client_ptr->client, uuid))
2277     {
2278       uuid_unparse(uuid, uuid_str);
2279       log_info("    interlink=%s", uuid_str);
2280     }
2281     else
2282     {
2283       log_info("    no interlink");
2284     }
2285     dump_dict("      ", ladish_client_get_dict(client_ptr->client));
2286     log_info("      ports:");
2287     list_for_each(port_node_ptr, &client_ptr->ports)
2288     {
2289       port_ptr = list_entry(port_node_ptr, struct ladish_graph_port, siblings_client);
2290
2291       ladish_port_get_uuid(port_ptr->port, uuid);
2292       uuid_unparse(uuid, uuid_str);
2293
2294       log_info("        %s port '%s', uuid=%s, id=%"PRIu64", type=0x%"PRIX32", flags=0x%"PRIX32", ptr=%p", port_ptr->hidden ? "invisible" : "visible", port_ptr->name, uuid_str, port_ptr->id, port_ptr->type, port_ptr->flags, port_ptr->port);
2295       dump_dict("        ", ladish_port_get_dict(port_ptr->port));
2296     }
2297   }
2298   log_info("  connections:");
2299   list_for_each(connection_node_ptr, &graph_ptr->connections)
2300   {
2301     connection_ptr = list_entry(connection_node_ptr, struct ladish_graph_connection, siblings);
2302
2303     log_info(
2304       "    %s connection '%s':'%s' - '%s':'%s'%s",
2305       connection_ptr->hidden ? "invisible" : "visible",
2306       connection_ptr->port1_ptr->client_ptr->name,
2307       connection_ptr->port1_ptr->name,
2308       connection_ptr->port2_ptr->client_ptr->name,
2309       connection_ptr->port2_ptr->name,
2310       connection_ptr->changing ? " [changing]" : "");
2311     dump_dict("      ", connection_ptr->dict);
2312   }
2313 }
2314
2315 void ladish_graph_clear_persist(ladish_graph_handle graph_handle)
2316 {
2317   log_info("Clearing persist flag for graph", graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
2318   graph_ptr->persist = false;
2319 }
2320
2321 void ladish_graph_set_persist(ladish_graph_handle graph_handle)
2322 {
2323   log_info("Setting persist flag for graph", graph_ptr->opath != NULL ? graph_ptr->opath : "JACK");
2324   graph_ptr->persist = true;
2325 }
2326
2327 bool ladish_graph_is_persist(ladish_graph_handle graph_handle)
2328 {
2329   return graph_ptr->persist;
2330 }
2331
2332 bool ladish_graph_looks_empty(ladish_graph_handle graph_handle)
2333 {
2334   struct list_head * node_ptr;
2335   struct ladish_graph_connection * connection_ptr;
2336   struct ladish_graph_client * client_ptr;
2337
2338   list_for_each(node_ptr, &graph_ptr->connections)
2339   {
2340     connection_ptr = list_entry(node_ptr, struct ladish_graph_connection, siblings);
2341
2342     if (!connection_ptr->hidden)
2343     {
2344       return false;
2345     }
2346   }
2347
2348   list_for_each(node_ptr, &graph_ptr->clients)
2349   {
2350     client_ptr = list_entry(node_ptr, struct ladish_graph_client, siblings);
2351     if (!ladish_graph_client_looks_empty_internal(graph_ptr, client_ptr))
2352     {
2353       return false;
2354     }
2355   }
2356
2357   return true;
2358 }
2359
2360 #undef graph_ptr
2361 #define graph_ptr ((struct ladish_graph *)context)
2362
2363 static
2364 bool
2365 ladish_graph_copy_client_begin_callback(
2366   void * context,
2367   ladish_graph_handle graph_handle,
2368   ladish_client_handle client_handle,
2369   const char * client_name,
2370   void ** client_iteration_context_ptr_ptr)
2371 {
2372   ladish_client_handle copy;
2373
2374   if (!ladish_client_create_copy(client_handle, &copy))
2375   {
2376     return false;
2377   }
2378
2379   if (!ladish_graph_add_client(context, copy, client_name, false))
2380   {
2381     ladish_client_destroy(copy);
2382     return false;
2383   }
2384
2385   *client_iteration_context_ptr_ptr = copy;
2386
2387   return true;
2388 }
2389
2390 static
2391 bool
2392 ladish_graph_copy_port_callback(
2393   void * context,
2394   ladish_graph_handle graph_handle,
2395   void * client_iteration_context_ptr,
2396   ladish_client_handle client_handle,
2397   const char * client_name,
2398   ladish_port_handle port_handle,
2399   const char * port_name,
2400   uint32_t port_type,
2401   uint32_t port_flags)
2402 {
2403   ladish_port_handle copy;
2404
2405   if (!ladish_port_create_copy(port_handle, &copy))
2406   {
2407     return false;
2408   }
2409
2410   if (!ladish_graph_add_port(context, client_iteration_context_ptr, copy, port_name, port_type, port_flags, true))
2411   {
2412     ladish_port_destroy(copy);
2413     return false;
2414   }
2415
2416   return true;
2417 }
2418
2419 #undef graph_ptr
2420
2421 bool ladish_graph_copy(ladish_graph_handle src, ladish_graph_handle dest, bool skip_hidden)
2422 {
2423   return ladish_graph_iterate_nodes(
2424     src,
2425     skip_hidden,
2426     NULL,
2427     dest,
2428     ladish_graph_copy_client_begin_callback,
2429     ladish_graph_copy_port_callback,
2430     NULL);
2431 }
2432
2433 METHOD_ARGS_BEGIN(GetAllPorts, "Get all ports")
2434   METHOD_ARG_DESCRIBE_IN("ports_list", "as", "List of all ports")
2435 METHOD_ARGS_END
2436
2437 METHOD_ARGS_BEGIN(GetGraph, "Get whole graph")
2438 METHOD_ARG_DESCRIBE_IN("known_graph_version", DBUS_TYPE_UINT64_AS_STRING, "Known graph version")
2439   METHOD_ARG_DESCRIBE_OUT("current_graph_version", DBUS_TYPE_UINT64_AS_STRING, "Current graph version")
2440   METHOD_ARG_DESCRIBE_OUT("clients_and_ports", "a(tsa(tsuu))", "Clients and their ports")
2441   METHOD_ARG_DESCRIBE_OUT("connections", "a(tstststst)", "Connections array")
2442 METHOD_ARGS_END
2443
2444 METHOD_ARGS_BEGIN(ConnectPortsByName, "Connect ports")
2445   METHOD_ARG_DESCRIBE_IN("client1_name", DBUS_TYPE_STRING_AS_STRING, "name first port client")
2446   METHOD_ARG_DESCRIBE_IN("port1_name", DBUS_TYPE_STRING_AS_STRING, "name of first port")
2447   METHOD_ARG_DESCRIBE_IN("client2_name", DBUS_TYPE_STRING_AS_STRING, "name second port client")
2448   METHOD_ARG_DESCRIBE_IN("port2_name", DBUS_TYPE_STRING_AS_STRING, "name of second port")
2449 METHOD_ARGS_END
2450
2451 METHOD_ARGS_BEGIN(ConnectPortsByID, "Connect ports")
2452   METHOD_ARG_DESCRIBE_IN("port1_id", DBUS_TYPE_UINT64_AS_STRING, "id of first port")
2453   METHOD_ARG_DESCRIBE_IN("port2_id", DBUS_TYPE_UINT64_AS_STRING, "if of second port")
2454 METHOD_ARGS_END
2455
2456 METHOD_ARGS_BEGIN(DisconnectPortsByName, "Disconnect ports")
2457   METHOD_ARG_DESCRIBE_IN("client1_name", DBUS_TYPE_STRING_AS_STRING, "name first port client")
2458   METHOD_ARG_DESCRIBE_IN("port1_name", DBUS_TYPE_STRING_AS_STRING, "name of first port")
2459   METHOD_ARG_DESCRIBE_IN("client2_name", DBUS_TYPE_STRING_AS_STRING, "name second port client")
2460   METHOD_ARG_DESCRIBE_IN("port2_name", DBUS_TYPE_STRING_AS_STRING, "name of second port")
2461 METHOD_ARGS_END
2462
2463 METHOD_ARGS_BEGIN(DisconnectPortsByID, "Disconnect ports")
2464   METHOD_ARG_DESCRIBE_IN("port1_id", DBUS_TYPE_UINT64_AS_STRING, "id of first port")
2465   METHOD_ARG_DESCRIBE_IN("port2_id", DBUS_TYPE_UINT64_AS_STRING, "if of second port")
2466 METHOD_ARGS_END
2467
2468 METHOD_ARGS_BEGIN(DisconnectPortsByConnectionID, "Disconnect ports")
2469   METHOD_ARG_DESCRIBE_IN("connection_id", DBUS_TYPE_UINT64_AS_STRING, "id of connection to disconnect")
2470 METHOD_ARGS_END
2471
2472 METHOD_ARGS_BEGIN(GetClientPID, "get process id of client")
2473   METHOD_ARG_DESCRIBE_IN("client_id", DBUS_TYPE_UINT64_AS_STRING, "id of client")
2474   METHOD_ARG_DESCRIBE_OUT("process_id", DBUS_TYPE_INT64_AS_STRING, "pid of client")
2475 METHOD_ARGS_END
2476
2477 METHODS_BEGIN
2478   METHOD_DESCRIBE(GetAllPorts, get_all_ports)
2479   METHOD_DESCRIBE(GetGraph, get_graph)
2480   METHOD_DESCRIBE(ConnectPortsByName, connect_ports_by_name)
2481   METHOD_DESCRIBE(ConnectPortsByID, connect_ports_by_id)
2482   METHOD_DESCRIBE(DisconnectPortsByName, disconnect_ports_by_name)
2483   METHOD_DESCRIBE(DisconnectPortsByID, disconnect_ports_by_id)
2484   METHOD_DESCRIBE(DisconnectPortsByConnectionID, disconnect_ports_by_connection_id)
2485   METHOD_DESCRIBE(GetClientPID, get_client_pid)
2486 METHODS_END
2487
2488 SIGNAL_ARGS_BEGIN(GraphChanged, "")
2489   SIGNAL_ARG_DESCRIBE("new_graph_version", DBUS_TYPE_UINT64_AS_STRING, "")
2490 SIGNAL_ARGS_END
2491
2492 SIGNAL_ARGS_BEGIN(ClientAppeared, "")
2493   SIGNAL_ARG_DESCRIBE("new_graph_version", DBUS_TYPE_UINT64_AS_STRING, "")
2494   SIGNAL_ARG_DESCRIBE("client_id", DBUS_TYPE_UINT64_AS_STRING, "")
2495   SIGNAL_ARG_DESCRIBE("client_name", DBUS_TYPE_STRING_AS_STRING, "")
2496 SIGNAL_ARGS_END
2497
2498 SIGNAL_ARGS_BEGIN(ClientDisappeared, "")
2499   SIGNAL_ARG_DESCRIBE("new_graph_version", DBUS_TYPE_UINT64_AS_STRING, "")
2500   SIGNAL_ARG_DESCRIBE("client_id", DBUS_TYPE_UINT64_AS_STRING, "")
2501   SIGNAL_ARG_DESCRIBE("client_name", DBUS_TYPE_STRING_AS_STRING, "")
2502 SIGNAL_ARGS_END
2503
2504 SIGNAL_ARGS_BEGIN(PortAppeared, "")
2505   SIGNAL_ARG_DESCRIBE("new_graph_version", DBUS_TYPE_UINT64_AS_STRING, "")
2506   SIGNAL_ARG_DESCRIBE("client_id", DBUS_TYPE_UINT64_AS_STRING, "")
2507   SIGNAL_ARG_DESCRIBE("client_name", DBUS_TYPE_STRING_AS_STRING, "")
2508   SIGNAL_ARG_DESCRIBE("port_id", DBUS_TYPE_UINT64_AS_STRING, "")
2509   SIGNAL_ARG_DESCRIBE("port_name", DBUS_TYPE_STRING_AS_STRING, "")
2510   SIGNAL_ARG_DESCRIBE("port_flags", DBUS_TYPE_UINT32_AS_STRING, "")
2511   SIGNAL_ARG_DESCRIBE("port_type", DBUS_TYPE_UINT32_AS_STRING, "")
2512 SIGNAL_ARGS_END
2513
2514 SIGNAL_ARGS_BEGIN(PortDisappeared, "")
2515   SIGNAL_ARG_DESCRIBE("new_graph_version", DBUS_TYPE_UINT64_AS_STRING, "")
2516   SIGNAL_ARG_DESCRIBE("client_id", DBUS_TYPE_UINT64_AS_STRING, "")
2517   SIGNAL_ARG_DESCRIBE("client_name", DBUS_TYPE_STRING_AS_STRING, "")
2518   SIGNAL_ARG_DESCRIBE("port_id", DBUS_TYPE_UINT64_AS_STRING, "")
2519   SIGNAL_ARG_DESCRIBE("port_name", DBUS_TYPE_STRING_AS_STRING, "")
2520 SIGNAL_ARGS_END
2521
2522 SIGNAL_ARGS_BEGIN(PortsConnected, "")
2523   SIGNAL_ARG_DESCRIBE("new_graph_version", DBUS_TYPE_UINT64_AS_STRING, "")
2524   SIGNAL_ARG_DESCRIBE("client1_id", DBUS_TYPE_UINT64_AS_STRING, "")
2525   SIGNAL_ARG_DESCRIBE("client1_name", DBUS_TYPE_STRING_AS_STRING, "")
2526   SIGNAL_ARG_DESCRIBE("port1_id", DBUS_TYPE_UINT64_AS_STRING, "")
2527   SIGNAL_ARG_DESCRIBE("port1_name", DBUS_TYPE_STRING_AS_STRING, "")
2528   SIGNAL_ARG_DESCRIBE("client2_id", DBUS_TYPE_UINT64_AS_STRING, "")
2529   SIGNAL_ARG_DESCRIBE("client2_name", DBUS_TYPE_STRING_AS_STRING, "")
2530   SIGNAL_ARG_DESCRIBE("port2_id", DBUS_TYPE_UINT64_AS_STRING, "")
2531   SIGNAL_ARG_DESCRIBE("port2_name", DBUS_TYPE_STRING_AS_STRING, "")
2532   SIGNAL_ARG_DESCRIBE("connection_id", DBUS_TYPE_UINT64_AS_STRING, "")
2533 SIGNAL_ARGS_END
2534
2535 SIGNAL_ARGS_BEGIN(PortsDisconnected, "")
2536   SIGNAL_ARG_DESCRIBE("new_graph_version", DBUS_TYPE_UINT64_AS_STRING, "")
2537   SIGNAL_ARG_DESCRIBE("client1_id", DBUS_TYPE_UINT64_AS_STRING, "")
2538   SIGNAL_ARG_DESCRIBE("client1_name", DBUS_TYPE_STRING_AS_STRING, "")
2539   SIGNAL_ARG_DESCRIBE("port1_id", DBUS_TYPE_UINT64_AS_STRING, "")
2540   SIGNAL_ARG_DESCRIBE("port1_name", DBUS_TYPE_STRING_AS_STRING, "")
2541   SIGNAL_ARG_DESCRIBE("client2_id", DBUS_TYPE_UINT64_AS_STRING, "")
2542   SIGNAL_ARG_DESCRIBE("client2_name", DBUS_TYPE_STRING_AS_STRING, "")
2543   SIGNAL_ARG_DESCRIBE("port2_id", DBUS_TYPE_UINT64_AS_STRING, "")
2544   SIGNAL_ARG_DESCRIBE("port2_name", DBUS_TYPE_STRING_AS_STRING, "")
2545   SIGNAL_ARG_DESCRIBE("connection_id", DBUS_TYPE_UINT64_AS_STRING, "")
2546 SIGNAL_ARGS_END
2547
2548 SIGNALS_BEGIN
2549   SIGNAL_DESCRIBE(GraphChanged)
2550   SIGNAL_DESCRIBE(ClientAppeared)
2551   SIGNAL_DESCRIBE(ClientDisappeared)
2552   SIGNAL_DESCRIBE(PortAppeared)
2553   SIGNAL_DESCRIBE(PortDisappeared)
2554   SIGNAL_DESCRIBE(PortsConnected)
2555   SIGNAL_DESCRIBE(PortsDisconnected)
2556 SIGNALS_END
2557
2558 INTERFACE_BEGIN(g_interface_patchbay, JACKDBUS_IFACE_PATCHBAY)
2559   INTERFACE_DEFAULT_HANDLER
2560   INTERFACE_EXPOSE_METHODS
2561   INTERFACE_EXPOSE_SIGNALS
2562 INTERFACE_END