daemon/graph.c

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