daemon/graph.c

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