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