jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
825 Commits
8 Branches
67MB
Tree: e44ab5b9ad
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e44ab5b9ad'
${ noResults }
jack2/linux/dbus/controller_iface_patchbay.c

7381 lines
220KB
Raw Blame History 

  1. /* -*- Mode: C ; c-basic-offset: 4 -*- */

  2. /*

  3.     Copyright (C) 2008 Nedko Arnaudov

  4.     Copyright (C) 2008 Juuso Alasuutari

  5. 

  6.     This program is free software; you can redistribute it and/or modify

  7.     it under the terms of the GNU General Public License as published by

  8.     the Free Software Foundation; either version 2 of the License.

  9. 

  10.     This program is distributed in the hope that it will be useful,

  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.     GNU General Public License for more details.

  14. 

  15.     You should have received a copy of the GNU General Public License

  16.     along with this program; if not, write to the Free Software

  17.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18. 

  19. */

  20. 

  21. #define _GNU_SOURCE            /* PTHREAD_MUTEX_RECURSIVE */

  22. 

  23. #include <stdint.h>

  24. #include <inttypes.h>

  25. #include <string.h>

  26. #include <stdio.h>

  27. #include <assert.h>

  28. #include <dbus/dbus.h>

  29. #include <pthread.h>

  30. 

  31. #include "jackdbus.h"

  32. #include "controller_internal.h"

  33. #include "list.h"

  34. 

  35. #define JACK_DBUS_IFACE_NAME "org.jackaudio.JackPatchbay"

  36. 

  37. /* FIXME: these need to be retrieved from common headers */

  38. #define JACK_CLIENT_NAME_SIZE 64

  39. #define JACK_PORT_NAME_SIZE 256

  40. 

  41. struct jack_graph

  42. {

  43.     uint64_t version;

  44.     struct list_head clients;

  45.     struct list_head ports;

  46.     struct list_head connections;

  47. };

  48. 

  49. struct jack_graph_client

  50. {

  51.     uint64_t id;

  52.     char * name;

  53.     int pid;

  54.     struct list_head siblings;

  55.     struct list_head ports;

  56. };

  57. 

  58. struct jack_graph_port

  59. {

  60.     uint64_t id;

  61.     char * name;

  62.     uint32_t flags;

  63.     uint32_t type;

  64.     struct list_head siblings_graph;

  65.     struct list_head siblings_client;

  66.     struct jack_graph_client * client;

  67. };

  68. 

  69. struct jack_graph_connection

  70. {

  71.     uint64_t id;

  72.     struct jack_graph_port * port1;

  73.     struct jack_graph_port * port2;

  74.     struct list_head siblings;

  75. };

  76. 

  77. struct jack_controller_patchbay

  78. {

  79.     pthread_mutex_t lock;

  80.     struct jack_graph graph;

  81.     uint64_t next_client_id;

  82.     uint64_t next_port_id;

  83.     uint64_t next_connection_id;

  84. };

  85. 

  86. void

  87. jack_controller_patchbay_send_signal_graph_changed(

  88.     dbus_uint64_t new_graph_version)

  89. {

  90. 

  91.     jack_dbus_send_signal(

  92.         JACK_CONTROLLER_OBJECT_PATH,

  93.         JACK_DBUS_IFACE_NAME,

  94.         "GraphChanged",

  95.         DBUS_TYPE_UINT64,

  96.         &new_graph_version,

  97.         DBUS_TYPE_INVALID);

  98. }

  99. 

  100. void

  101. jack_controller_patchbay_send_signal_client_appeared(

  102.     dbus_uint64_t new_graph_version,

  103.     dbus_uint64_t client_id,

  104.     const char * client_name)

  105. {

  106. 

  107.     jack_dbus_send_signal(

  108.         JACK_CONTROLLER_OBJECT_PATH,

  109.         JACK_DBUS_IFACE_NAME,

  110.         "ClientAppeared",

  111.         DBUS_TYPE_UINT64,

  112.         &new_graph_version,

  113.         DBUS_TYPE_UINT64,

  114.         &client_id,

  115.         DBUS_TYPE_STRING,

  116.         &client_name,

  117.         DBUS_TYPE_INVALID);

  118. }

  119. 

  120. void

  121. jack_controller_patchbay_send_signal_client_disappeared(

  122.     dbus_uint64_t new_graph_version,

  123.     dbus_uint64_t client_id,

  124.     const char * client_name)

  125. {

  126. 

  127.     jack_dbus_send_signal(

  128.         JACK_CONTROLLER_OBJECT_PATH,

  129.         JACK_DBUS_IFACE_NAME,

  130.         "ClientDisappeared",

  131.         DBUS_TYPE_UINT64,

  132.         &new_graph_version,

  133.         DBUS_TYPE_UINT64,

  134.         &client_id,

  135.         DBUS_TYPE_STRING,

  136.         &client_name,

  137.         DBUS_TYPE_INVALID);

  138. }

  139. 

  140. void

  141. jack_controller_patchbay_send_signal_port_appeared(

  142.     dbus_uint64_t new_graph_version,

  143.     dbus_uint64_t client_id,

  144.     const char * client_name,

  145.     dbus_uint64_t port_id,

  146.     const char * port_name,

  147.     dbus_uint32_t port_flags,

  148.     dbus_uint32_t port_type)

  149. {

  150. 

  151.     jack_dbus_send_signal(

  152.         JACK_CONTROLLER_OBJECT_PATH,

  153.         JACK_DBUS_IFACE_NAME,

  154.         "PortAppeared",

  155.         DBUS_TYPE_UINT64,

  156.         &new_graph_version,

  157.         DBUS_TYPE_UINT64,

  158.         &client_id,

  159.         DBUS_TYPE_STRING,

  160.         &client_name,

  161.         DBUS_TYPE_UINT64,

  162.         &port_id,

  163.         DBUS_TYPE_STRING,

  164.         &port_name,

  165.         DBUS_TYPE_UINT32,

  166.         &port_flags,

  167.         DBUS_TYPE_UINT32,

  168.         &port_type,

  169.         DBUS_TYPE_INVALID);

  170. }

  171. 

  172. void

  173. jack_controller_patchbay_send_signal_port_disappeared(

  174.     dbus_uint64_t new_graph_version,

  175.     dbus_uint64_t client_id,

  176.     const char * client_name,

  177.     dbus_uint64_t port_id,

  178.     const char * port_name)

  179. {

  180. 

  181.     jack_dbus_send_signal(

  182.         JACK_CONTROLLER_OBJECT_PATH,

  183.         JACK_DBUS_IFACE_NAME,

  184.         "PortDisappeared",

  185.         DBUS_TYPE_UINT64,

  186.         &new_graph_version,

  187.         DBUS_TYPE_UINT64,

  188.         &client_id,

  189.         DBUS_TYPE_STRING,

  190.         &client_name,

  191.         DBUS_TYPE_UINT64,

  192.         &port_id,

  193.         DBUS_TYPE_STRING,

  194.         &port_name,

  195.         DBUS_TYPE_INVALID);

  196. }

  197. 

  198. void

  199. jack_controller_patchbay_send_signal_ports_connected(

  200.     dbus_uint64_t new_graph_version,

  201.     dbus_uint64_t client1_id,

  202.     const char * client1_name,

  203.     dbus_uint64_t port1_id,

  204.     const char * port1_name,

  205.     dbus_uint64_t client2_id,

  206.     const char * client2_name,

  207.     dbus_uint64_t port2_id,

  208.     const char * port2_name,

  209.     dbus_uint64_t connection_id)

  210. {

  211. 

  212.     jack_dbus_send_signal(

  213.         JACK_CONTROLLER_OBJECT_PATH,

  214.         JACK_DBUS_IFACE_NAME,

  215.         "PortsConnected",

  216.         DBUS_TYPE_UINT64,

  217.         &new_graph_version,

  218.         DBUS_TYPE_UINT64,

  219.         &client1_id,

  220.         DBUS_TYPE_STRING,

  221.         &client1_name,

  222.         DBUS_TYPE_UINT64,

  223.         &port1_id,

  224.         DBUS_TYPE_STRING,

  225.         &port1_name,

  226.         DBUS_TYPE_UINT64,

  227.         &client2_id,

  228.         DBUS_TYPE_STRING,

  229.         &client2_name,

  230.         DBUS_TYPE_UINT64,

  231.         &port2_id,

  232.         DBUS_TYPE_STRING,

  233.         &port2_name,

  234.         DBUS_TYPE_UINT64,

  235.         &connection_id,

  236.         DBUS_TYPE_INVALID);

  237. }

  238. 

  239. void

  240. jack_controller_patchbay_send_signal_ports_disconnected(

  241.     dbus_uint64_t new_graph_version,

  242.     dbus_uint64_t client1_id,

  243.     const char * client1_name,

  244.     dbus_uint64_t port1_id,

  245.     const char * port1_name,

  246.     dbus_uint64_t client2_id,

  247.     const char * client2_name,

  248.     dbus_uint64_t port2_id,

  249.     const char * port2_name,

  250.     dbus_uint64_t connection_id)

  251. {

  252. 

  253.     jack_dbus_send_signal(

  254.         JACK_CONTROLLER_OBJECT_PATH,

  255.         JACK_DBUS_IFACE_NAME,

  256.         "PortsDisconnected",

  257.         DBUS_TYPE_UINT64,

  258.         &new_graph_version,

  259.         DBUS_TYPE_UINT64,

  260.         &client1_id,

  261.         DBUS_TYPE_STRING,

  262.         &client1_name,

  263.         DBUS_TYPE_UINT64,

  264.         &port1_id,

  265.         DBUS_TYPE_STRING,

  266.         &port1_name,

  267.         DBUS_TYPE_UINT64,

  268.         &client2_id,

  269.         DBUS_TYPE_STRING,

  270.         &client2_name,

  271.         DBUS_TYPE_UINT64,

  272.         &port2_id,

  273.         DBUS_TYPE_STRING,

  274.         &port2_name,

  275.         DBUS_TYPE_UINT64,

  276.         &connection_id,

  277.         DBUS_TYPE_INVALID);

  278. }

  279. 

  280. static

  281. struct jack_graph_client *

  282. jack_controller_patchbay_find_client(

  283.     struct jack_controller_patchbay *patchbay_ptr,

  284.     const char *client_name,    /* not '\0' terminated */

  285.     size_t client_name_len)     /* without terminating '\0' */

  286. {

  287.     struct list_head *node_ptr;

  288.     struct jack_graph_client *client_ptr;

  289. 

  290.     list_for_each(node_ptr, &patchbay_ptr->graph.clients)

  291.     {

  292.         client_ptr = list_entry(node_ptr, struct jack_graph_client, siblings);

  293.         if (strncmp(client_ptr->name, client_name, client_name_len) == 0)

  294.         {

  295.             return client_ptr;

  296.         }

  297.     }

  298. 

  299.     return NULL;

  300. }

  301. 

  302. static

  303. struct jack_graph_client *

  304. jack_controller_patchbay_find_client_by_id(

  305.     struct jack_controller_patchbay *patchbay_ptr,

  306.     uint64_t id)

  307. {

  308.     struct list_head *node_ptr;

  309.     struct jack_graph_client *client_ptr;

  310. 

  311.     list_for_each(node_ptr, &patchbay_ptr->graph.clients)

  312.     {

  313.         client_ptr = list_entry(node_ptr, struct jack_graph_client, siblings);

  314.         if (client_ptr->id == id)

  315.         {

  316.             return client_ptr;

  317.         }

  318.     }

  319. 

  320.     return NULL;

  321. }

  322. 

  323. static

  324. struct jack_graph_client *

  325. jack_controller_patchbay_create_client(

  326.     struct jack_controller_patchbay *patchbay_ptr,

  327.     const char *client_name,    /* not '\0' terminated */

  328.     size_t client_name_len)     /* without terminating '\0' */

  329. {

  330.     struct jack_graph_client * client_ptr;

  331. 

  332.     client_ptr = malloc(sizeof(struct jack_graph_client));

  333.     if (client_ptr == NULL)

  334.     {

  335.         jack_error("Memory allocation of jack_graph_client structure failed.");

  336.         goto fail;

  337.     }

  338. 

  339.     client_ptr->name = malloc(client_name_len + 1);

  340.     if (client_ptr->name == NULL)

  341.     {

  342.         jack_error("malloc() failed to allocate memory for client name.");

  343.         goto fail_free_client;

  344.     }

  345. 

  346.     memcpy(client_ptr->name, client_name, client_name_len);

  347.     client_ptr->name[client_name_len] = 0;

  348. 

  349.     client_ptr->pid = jack_get_client_pid(client_ptr->name);

  350.     jack_info("New client '%s' with PID %d", client_ptr->name, client_ptr->pid);

  351. 

  352.     client_ptr->id = patchbay_ptr->next_client_id++;

  353.     INIT_LIST_HEAD(&client_ptr->ports);

  354. 

  355. 

  356.     pthread_mutex_lock(&patchbay_ptr->lock);

  357.     list_add_tail(&client_ptr->siblings, &patchbay_ptr->graph.clients);

  358.     patchbay_ptr->graph.version++;

  359.     jack_controller_patchbay_send_signal_client_appeared(patchbay_ptr->graph.version, client_ptr->id, client_ptr->name);

  360.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  361.     pthread_mutex_unlock(&patchbay_ptr->lock);

  362. 

  363.     return client_ptr;

  364. 

  365. fail_free_client:

  366.     free(client_ptr);

  367. 

  368. fail:

  369.     return NULL;

  370. }

  371. 

  372. static

  373. void

  374. jack_controller_patchbay_destroy_client(

  375.     struct jack_controller_patchbay *patchbay_ptr,

  376.     struct jack_graph_client *client_ptr)

  377. {

  378.     pthread_mutex_lock(&patchbay_ptr->lock);

  379.     list_del(&client_ptr->siblings);

  380.     patchbay_ptr->graph.version++;

  381.     jack_controller_patchbay_send_signal_client_disappeared(patchbay_ptr->graph.version, client_ptr->id, client_ptr->name);

  382.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  383.     pthread_mutex_unlock(&patchbay_ptr->lock);

  384. 

  385.     free(client_ptr->name);

  386.     free(client_ptr);

  387. }

  388. 

  389. static

  390. void

  391. jack_controller_patchbay_destroy_client_by_name(

  392.     struct jack_controller_patchbay *patchbay_ptr,

  393.     const char *client_name)    /* '\0' terminated */

  394. {

  395.     struct jack_graph_client *client_ptr;

  396. 

  397.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, client_name, strlen(client_name));

  398.     if (client_ptr == NULL)

  399.     {

  400.         jack_error("Cannot destroy unknown client '%s'", client_name);

  401.         return;

  402.     }

  403. 

  404.     jack_controller_patchbay_destroy_client(patchbay_ptr, client_ptr);

  405. }

  406. 

  407. static

  408. void

  409. jack_controller_patchbay_new_port(

  410.     struct jack_controller_patchbay *patchbay_ptr,

  411.     const char *port_full_name,

  412.     uint32_t port_flags,

  413.     uint32_t port_type)

  414. {

  415.     struct jack_graph_client *client_ptr;

  416.     struct jack_graph_port *port_ptr;

  417.     const char *port_short_name;

  418.     size_t client_name_len;

  419. 

  420.     //jack_info("name: %s", port_full_name);

  421. 

  422.     port_short_name = strchr(port_full_name, ':');

  423.     if (port_short_name == NULL)

  424.     {

  425.         jack_error("port name '%s' does not contain ':' separator char", port_full_name);

  426.         return;

  427.     }

  428. 

  429.     port_short_name++;          /* skip ':' separator char */

  430. 

  431.     client_name_len = port_short_name - port_full_name - 1; /* without terminating '\0' */

  432. 

  433.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, port_full_name, client_name_len);

  434.     if (client_ptr == NULL)

  435.     {

  436.         client_ptr = jack_controller_patchbay_create_client(patchbay_ptr, port_full_name, client_name_len);

  437.         if (client_ptr == NULL)

  438.         {

  439.             jack_error("Creation of new jack_graph client failed.");

  440.             return;

  441.         }

  442.     }

  443. 

  444.     port_ptr = malloc(sizeof(struct jack_graph_port));

  445.     if (port_ptr == NULL)

  446.     {

  447.         jack_error("Memory allocation of jack_graph_port structure failed.");

  448.         return;

  449.     }

  450. 

  451.     port_ptr->name = strdup(port_short_name);

  452.     if (port_ptr->name == NULL)

  453.     {

  454.         jack_error("strdup() call for port name '%s' failed.", port_short_name);

  455.         free(port_ptr);

  456.         return;

  457.     }

  458. 

  459.     port_ptr->id = patchbay_ptr->next_port_id++;

  460.     port_ptr->flags = port_flags;

  461.     port_ptr->type = port_type;

  462.     port_ptr->client = client_ptr;

  463. 

  464.     pthread_mutex_lock(&patchbay_ptr->lock);

  465.     list_add_tail(&port_ptr->siblings_client, &client_ptr->ports);

  466.     list_add_tail(&port_ptr->siblings_graph, &patchbay_ptr->graph.ports);

  467.     patchbay_ptr->graph.version++;

  468.     jack_controller_patchbay_send_signal_port_appeared(

  469.         patchbay_ptr->graph.version,

  470.         client_ptr->id,

  471.         client_ptr->name,

  472.         port_ptr->id,

  473.         port_ptr->name,

  474.         port_ptr->flags,

  475.         port_ptr->type);

  476.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  477.     pthread_mutex_unlock(&patchbay_ptr->lock);

  478. }

  479. 

  480. static

  481. void

  482. jack_controller_patchbay_remove_port(

  483.     struct jack_controller_patchbay *patchbay_ptr,

  484.     struct jack_graph_port *port_ptr)

  485. {

  486.     pthread_mutex_lock(&patchbay_ptr->lock);

  487.     list_del(&port_ptr->siblings_client);

  488.     list_del(&port_ptr->siblings_graph);

  489.     patchbay_ptr->graph.version++;

  490.     jack_controller_patchbay_send_signal_port_disappeared(patchbay_ptr->graph.version, port_ptr->client->id, port_ptr->client->name, port_ptr->id, port_ptr->name);

  491.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  492.     pthread_mutex_unlock(&patchbay_ptr->lock);

  493. 

  494.     free(port_ptr->name);

  495.     free(port_ptr);

  496. }

  497. 

  498. static

  499. struct jack_graph_port *

  500. jack_controller_patchbay_find_port_by_id(

  501.     struct jack_controller_patchbay *patchbay_ptr,

  502.     uint64_t port_id)

  503. {

  504.     struct list_head *node_ptr;

  505.     struct jack_graph_port *port_ptr;

  506. 

  507.     list_for_each(node_ptr, &patchbay_ptr->graph.ports)

  508.     {

  509.         port_ptr = list_entry(node_ptr, struct jack_graph_port, siblings_graph);

  510.         if (port_ptr->id == port_id)

  511.         {

  512.             return port_ptr;

  513.         }

  514.     }

  515. 

  516.     return NULL;

  517. }

  518. 

  519. static

  520. struct jack_graph_port *

  521. jack_controller_patchbay_find_client_port_by_name(

  522.     struct jack_controller_patchbay *patchbay_ptr,

  523.     struct jack_graph_client *client_ptr,

  524.     const char *port_name)

  525. {

  526.     struct list_head *node_ptr;

  527.     struct jack_graph_port *port_ptr;

  528. 

  529.     list_for_each(node_ptr, &client_ptr->ports)

  530.     {

  531.         port_ptr = list_entry(node_ptr, struct jack_graph_port, siblings_client);

  532.         if (strcmp(port_ptr->name, port_name) == 0)

  533.         {

  534.             return port_ptr;

  535.         }

  536.     }

  537. 

  538.     return NULL;

  539. }

  540. 

  541. static

  542. struct jack_graph_port *

  543. jack_controller_patchbay_find_port_by_full_name(

  544.     struct jack_controller_patchbay *patchbay_ptr,

  545.     const char *port_full_name)

  546. {

  547.     const char *port_short_name;

  548.     size_t client_name_len;

  549.     struct jack_graph_client *client_ptr;

  550. 

  551.     //jack_info("name: %s", port_full_name);

  552. 

  553.     port_short_name = strchr(port_full_name, ':');

  554.     if (port_short_name == NULL)

  555.     {

  556.         jack_error("port name '%s' does not contain ':' separator char", port_full_name);

  557.         return NULL;

  558.     }

  559. 

  560.     port_short_name++;          /* skip ':' separator char */

  561. 

  562.     client_name_len = port_short_name - port_full_name - 1; /* without terminating '\0' */

  563. 

  564.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, port_full_name, client_name_len);

  565.     if (client_ptr == NULL)

  566.     {

  567.         jack_error("cannot find client of port '%s'", port_full_name);

  568.         return NULL;

  569.     }

  570. 

  571.     return jack_controller_patchbay_find_client_port_by_name(patchbay_ptr, client_ptr, port_short_name);

  572. }

  573. 

  574. static

  575. struct jack_graph_port *

  576. jack_controller_patchbay_find_port_by_names(

  577.     struct jack_controller_patchbay *patchbay_ptr,

  578.     const char *client_name,

  579.     const char *port_name)

  580. {

  581.     struct jack_graph_client *client_ptr;

  582. 

  583.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, client_name, strlen(client_name));

  584.     if (client_ptr == NULL)

  585.     {

  586.         jack_error("cannot find client '%s'", client_name);

  587.         return NULL;

  588.     }

  589. 

  590.     return jack_controller_patchbay_find_client_port_by_name(patchbay_ptr, client_ptr, port_name);

  591. }

  592. 

  593. static

  594. struct jack_graph_connection *

  595. jack_controller_patchbay_create_connection(

  596.     struct jack_controller_patchbay *patchbay_ptr,

  597.     struct jack_graph_port *port1_ptr,

  598.     struct jack_graph_port *port2_ptr)

  599. {

  600.     struct jack_graph_connection * connection_ptr;

  601. 

  602.     connection_ptr = malloc(sizeof(struct jack_graph_connection));

  603.     if (connection_ptr == NULL)

  604.     {

  605.         jack_error("Memory allocation of jack_graph_connection structure failed.");

  606.         return NULL;

  607.     }

  608. 

  609.     connection_ptr->id = patchbay_ptr->next_connection_id++;

  610.     connection_ptr->port1 = port1_ptr;

  611.     connection_ptr->port2 = port2_ptr;

  612. 

  613.     pthread_mutex_lock(&patchbay_ptr->lock);

  614.     list_add_tail(&connection_ptr->siblings, &patchbay_ptr->graph.connections);

  615.     patchbay_ptr->graph.version++;

  616.     jack_controller_patchbay_send_signal_ports_connected(

  617.         patchbay_ptr->graph.version,

  618.         port1_ptr->client->id,

  619.         port1_ptr->client->name,

  620.         port1_ptr->id,

  621.         port1_ptr->name,

  622.         port2_ptr->client->id,

  623.         port2_ptr->client->name,

  624.         port2_ptr->id,

  625.         port2_ptr->name,

  626.         connection_ptr->id);

  627.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  628.     pthread_mutex_unlock(&patchbay_ptr->lock);

  629. 

  630.     return connection_ptr;

  631. }

  632. 

  633. static

  634. void

  635. jack_controller_patchbay_destroy_connection(

  636.     struct jack_controller_patchbay *patchbay_ptr,

  637.     struct jack_graph_connection *connection_ptr)

  638. {

  639.     pthread_mutex_lock(&patchbay_ptr->lock);

  640.     list_del(&connection_ptr->siblings);

  641.     patchbay_ptr->graph.version++;

  642.     jack_controller_patchbay_send_signal_ports_disconnected(

  643.         patchbay_ptr->graph.version,

  644.         connection_ptr->port1->client->id,

  645.         connection_ptr->port1->client->name,

  646.         connection_ptr->port1->id,

  647.         connection_ptr->port1->name,

  648.         connection_ptr->port2->client->id,

  649.         connection_ptr->port2->client->name,

  650.         connection_ptr->port2->id,

  651.         connection_ptr->port2->name,

  652.         connection_ptr->id);

  653.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  654.     pthread_mutex_unlock(&patchbay_ptr->lock);

  655. 

  656.     free(connection_ptr);

  657. }

  658. 

  659. static

  660. struct jack_graph_connection *

  661. jack_controller_patchbay_find_connection(

  662.     struct jack_controller_patchbay *patchbay_ptr,

  663.     struct jack_graph_port *port1_ptr,

  664.     struct jack_graph_port *port2_ptr)

  665. {

  666.     struct list_head *node_ptr;

  667.     struct jack_graph_connection *connection_ptr;

  668. 

  669.     list_for_each(node_ptr, &patchbay_ptr->graph.connections)

  670.     {

  671.         connection_ptr = list_entry(node_ptr, struct jack_graph_connection, siblings);

  672.         if ((connection_ptr->port1 == port1_ptr &&

  673.              connection_ptr->port2 == port2_ptr) ||

  674.             (connection_ptr->port1 == port2_ptr &&

  675.              connection_ptr->port2 == port1_ptr))

  676.         {

  677.             return connection_ptr;

  678.         }

  679.     }

  680. 

  681.     return NULL;

  682. }

  683. 

  684. static

  685. struct jack_graph_connection *

  686. jack_controller_patchbay_find_connection_by_id(

  687.     struct jack_controller_patchbay *patchbay_ptr,

  688.     uint64_t connection_id)

  689. {

  690.     struct list_head *node_ptr;

  691.     struct jack_graph_connection *connection_ptr;

  692. 

  693.     list_for_each(node_ptr, &patchbay_ptr->graph.connections)

  694.     {

  695.         connection_ptr = list_entry(node_ptr, struct jack_graph_connection, siblings);

  696.         if (connection_ptr->id == connection_id)

  697.         {

  698.             return connection_ptr;

  699.         }

  700.     }

  701. 

  702.     return NULL;

  703. }

  704. 

  705. static

  706. bool

  707. jack_controller_patchbay_connect(

  708.     struct jack_dbus_method_call *dbus_call_ptr,

  709.     struct jack_controller *controller_ptr,

  710.     struct jack_graph_port *port1_ptr,

  711.     struct jack_graph_port *port2_ptr)

  712. {

  713.     int ret;

  714.     char port1_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  715.     char port2_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  716. 

  717.     sprintf(port1_name, "%s:%s", port1_ptr->client->name, port1_ptr->name);

  718.     sprintf(port2_name, "%s:%s", port2_ptr->client->name, port2_ptr->name);

  719. 

  720.     ret = jack_connect(controller_ptr->client, port1_name, port2_name);

  721.     if (ret != 0)

  722.     {

  723.         jack_dbus_error(dbus_call_ptr, JACK_DBUS_ERROR_GENERIC, "jack_connect() failed with %d", ret);

  724.         return false;

  725.     }

  726. 

  727.     return true;

  728. }

  729. 

  730. static

  731. bool

  732. jack_controller_patchbay_disconnect(

  733.     struct jack_dbus_method_call *dbus_call_ptr,

  734.     struct jack_controller *controller_ptr,

  735.     struct jack_graph_port *port1_ptr,

  736.     struct jack_graph_port *port2_ptr)

  737. {

  738.     int ret;

  739.     char port1_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  740.     char port2_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  741. 

  742.     sprintf(port1_name, "%s:%s", port1_ptr->client->name, port1_ptr->name);

  743.     sprintf(port2_name, "%s:%s", port2_ptr->client->name, port2_ptr->name);

  744. 

  745.     ret = jack_disconnect(controller_ptr->client, port1_name, port2_name);

  746.     if (ret != 0)

  747.     {

  748.         jack_dbus_error(dbus_call_ptr, JACK_DBUS_ERROR_GENERIC, "jack_connect() failed with %d", ret);

  749.         return false;

  750.     }

  751. 

  752.     return true;

  753. }

  754. 

  755. #define controller_ptr ((struct jack_controller *)call->context)

  756. #define patchbay_ptr ((struct jack_controller_patchbay *)controller_ptr->patchbay_context)

  757. 

  758. static

  759. void

  760. jack_controller_dbus_get_all_ports(

  761.     struct jack_dbus_method_call * call)

  762. {

  763.     struct list_head * client_node_ptr;

  764.     struct list_head * port_node_ptr;

  765.     struct jack_graph_client * client_ptr;

  766.     struct jack_graph_port * port_ptr;

  767.     DBusMessageIter iter, sub_iter;

  768.     char fullname[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  769.     char *fullname_var = fullname;

  770. 

  771.     if (!controller_ptr->started)

  772.     {

  773.         jack_dbus_error(

  774.             call,

  775.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  776.             "Can't execute this method with stopped JACK server");

  777.         return;

  778.     }

  779. 

  780.     call->reply = dbus_message_new_method_return (call->message);

  781.     if (!call->reply)

  782.     {

  783.         goto fail;

  784.     }

  785. 

  786.     dbus_message_iter_init_append (call->reply, &iter);

  787. 

  788.     if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &sub_iter))

  789.     {

  790.         goto fail_unref;

  791.     }

  792. 

  793.     pthread_mutex_lock(&patchbay_ptr->lock);

  794. 

  795.     list_for_each(client_node_ptr, &patchbay_ptr->graph.clients)

  796.     {

  797.         client_ptr = list_entry(client_node_ptr, struct jack_graph_client, siblings);

  798. 

  799.         list_for_each(port_node_ptr, &client_ptr->ports)

  800.         {

  801.             port_ptr = list_entry(port_node_ptr, struct jack_graph_port, siblings_client);

  802. 

  803.             jack_info("%s:%s", client_ptr->name, port_ptr->name);

  804.             sprintf(fullname, "%s:%s", client_ptr->name, port_ptr->name);

  805.             if (!dbus_message_iter_append_basic (&sub_iter, DBUS_TYPE_STRING, &fullname_var))

  806.             {

  807.                 pthread_mutex_unlock(&patchbay_ptr->lock);

  808.                 dbus_message_iter_close_container (&iter, &sub_iter);

  809.                 goto fail_unref;

  810.             }

  811.         }

  812.     }

  813. 

  814.     pthread_mutex_unlock(&patchbay_ptr->lock);

  815. 

  816.     if (!dbus_message_iter_close_container (&iter, &sub_iter))

  817.     {

  818.         goto fail_unref;

  819.     }

  820. 

  821.     return;

  822. 

  823. fail_unref:

  824.     dbus_message_unref (call->reply);

  825.     call->reply = NULL;

  826. 

  827. fail:

  828.     jack_error ("Ran out of memory trying to construct method return");

  829. }

  830. 

  831. static

  832. void

  833. jack_controller_dbus_get_graph(

  834.     struct jack_dbus_method_call * call)

  835. {

  836.     struct list_head * client_node_ptr;

  837.     struct list_head * port_node_ptr;

  838.     struct list_head * connection_node_ptr;

  839.     struct jack_graph_client * client_ptr;

  840.     struct jack_graph_port * port_ptr;

  841.     struct jack_graph_connection * connection_ptr;

  842.     DBusMessageIter iter;

  843.     DBusMessageIter clients_array_iter;

  844.     DBusMessageIter client_struct_iter;

  845.     DBusMessageIter ports_array_iter;

  846.     DBusMessageIter port_struct_iter;

  847.     dbus_uint64_t version;

  848.     DBusMessageIter connections_array_iter;

  849.     DBusMessageIter connection_struct_iter;

  850. 

  851.     if (!controller_ptr->started)

  852.     {

  853.         jack_dbus_error(

  854.             call,

  855.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  856.             "Can't execute this method with stopped JACK server");

  857.         return;

  858.     }

  859. 

  860.     if (!jack_dbus_get_method_args(call, DBUS_TYPE_UINT64, &version, DBUS_TYPE_INVALID))

  861.     {

  862.         /* The method call had invalid arguments meaning that

  863.          * jack_dbus_get_method_args() has constructed an error for us.

  864.          */

  865.         goto exit;

  866.     }

  867. 

  868.     //jack_info("Getting graph, know version is %" PRIu32, version);

  869. 

  870.     call->reply = dbus_message_new_method_return(call->message);

  871.     if (!call->reply)

  872.     {

  873.         jack_error("Ran out of memory trying to construct method return");

  874.         goto exit;

  875.     }

  876. 

  877.     dbus_message_iter_init_append (call->reply, &iter);

  878. 

  879.     pthread_mutex_lock(&patchbay_ptr->lock);

  880. 

  881.     if (version > patchbay_ptr->graph.version)

  882.     {

  883.         jack_dbus_error(

  884.             call,

  885.             JACK_DBUS_ERROR_INVALID_ARGS,

  886.             "known graph version %" PRIu64 " is newer than actual version %" PRIu64,

  887.             version,

  888.             patchbay_ptr->graph.version);

  889.         pthread_mutex_unlock(&patchbay_ptr->lock);

  890.         goto exit;

  891.     }

  892. 

  893.     if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT64, &patchbay_ptr->graph.version))

  894.     {

  895.         goto nomem_unlock;

  896.     }

  897. 

  898.     if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tsa(tsuu))", &clients_array_iter))

  899.     {

  900.         goto nomem_unlock;

  901.     }

  902. 

  903.     if (version < patchbay_ptr->graph.version)

  904.     {

  905.         list_for_each(client_node_ptr, &patchbay_ptr->graph.clients)

  906.         {

  907.             client_ptr = list_entry(client_node_ptr, struct jack_graph_client, siblings);

  908. 

  909.             if (!dbus_message_iter_open_container (&clients_array_iter, DBUS_TYPE_STRUCT, NULL, &client_struct_iter))

  910.             {

  911.                 goto nomem_close_clients_array;

  912.             }

  913. 

  914.             if (!dbus_message_iter_append_basic(&client_struct_iter, DBUS_TYPE_UINT64, &client_ptr->id))

  915.             {

  916.                 goto nomem_close_client_struct;

  917.             }

  918. 

  919.             if (!dbus_message_iter_append_basic(&client_struct_iter, DBUS_TYPE_STRING, &client_ptr->name))

  920.             {

  921.                 goto nomem_close_client_struct;

  922.             }

  923. 

  924.             if (!dbus_message_iter_open_container(&client_struct_iter, DBUS_TYPE_ARRAY, "(tsuu)", &ports_array_iter))

  925.             {

  926.                 goto nomem_close_client_struct;

  927.             }

  928. 

  929.             list_for_each(port_node_ptr, &client_ptr->ports)

  930.             {

  931.                 port_ptr = list_entry(port_node_ptr, struct jack_graph_port, siblings_client);

  932. 

  933.                 if (!dbus_message_iter_open_container(&ports_array_iter, DBUS_TYPE_STRUCT, NULL, &port_struct_iter))

  934.                 {

  935.                     goto nomem_close_ports_array;

  936.                 }

  937. 

  938.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT64, &port_ptr->id))

  939.                 {

  940.                     goto nomem_close_port_struct;

  941.                 }

  942. 

  943.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_STRING, &port_ptr->name))

  944.                 {

  945.                     goto nomem_close_port_struct;

  946.                 }

  947. 

  948.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT32, &port_ptr->flags))

  949.                 {

  950.                     goto nomem_close_port_struct;

  951.                 }

  952. 

  953.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT32, &port_ptr->type))

  954.                 {

  955.                     goto nomem_close_port_struct;

  956.                 }

  957. 

  958.                 if (!dbus_message_iter_close_container(&ports_array_iter, &port_struct_iter))

  959.                 {

  960.                     goto nomem_close_ports_array;

  961.                 }

  962.             }

  963. 

  964.             if (!dbus_message_iter_close_container(&client_struct_iter, &ports_array_iter))

  965.             {

  966.                 goto nomem_close_client_struct;

  967.             }

  968. 

  969.             if (!dbus_message_iter_close_container(&clients_array_iter, &client_struct_iter))

  970.             {

  971.                 goto nomem_close_clients_array;

  972.             }

  973.         }

  974.     }

  975. 

  976.     if (!dbus_message_iter_close_container(&iter, &clients_array_iter))

  977.     {

  978.         goto nomem_unlock;

  979.     }

  980. 

  981.     if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tstststst)", &connections_array_iter))

  982.     {

  983.         goto nomem_unlock;

  984.     }

  985. 

  986.     if (version < patchbay_ptr->graph.version)

  987.     {

  988.         list_for_each(connection_node_ptr, &patchbay_ptr->graph.connections)

  989.         {

  990.             connection_ptr = list_entry(connection_node_ptr, struct jack_graph_connection, siblings);

  991. 

  992.             if (!dbus_message_iter_open_container(&connections_array_iter, DBUS_TYPE_STRUCT, NULL, &connection_struct_iter))

  993.             {

  994.                 goto nomem_close_connections_array;

  995.             }

  996. 

  997.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port1->client->id))

  998.             {

  999.                 goto nomem_close_connection_struct;

  1000.             }

  1001. 

  1002.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port1->client->name))

  1003.             {

  1004.                 goto nomem_close_connection_struct;

  1005.             }

  1006. 

  1007.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port1->id))

  1008.             {

  1009.                 goto nomem_close_connection_struct;

  1010.             }

  1011. 

  1012.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port1->name))

  1013.             {

  1014.                 goto nomem_close_connection_struct;

  1015.             }

  1016. 

  1017.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port2->client->id))

  1018.             {

  1019.                 goto nomem_close_connection_struct;

  1020.             }

  1021. 

  1022.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port2->client->name))

  1023.             {

  1024.                 goto nomem_close_connection_struct;

  1025.             }

  1026. 

  1027.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port2->id))

  1028.             {

  1029.                 goto nomem_close_connection_struct;

  1030.             }

  1031. 

  1032.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port2->name))

  1033.             {

  1034.                 goto nomem_close_connection_struct;

  1035.             }

  1036. 

  1037.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->id))

  1038.             {

  1039.                 goto nomem_close_connection_struct;

  1040.             }

  1041. 

  1042.             if (!dbus_message_iter_close_container(&connections_array_iter, &connection_struct_iter))

  1043.             {

  1044.                 goto nomem_close_connections_array;

  1045.             }

  1046.         }

  1047.     }

  1048. 

  1049.     if (!dbus_message_iter_close_container(&iter, &connections_array_iter))

  1050.     {

  1051.         goto nomem_unlock;

  1052.     }

  1053. 

  1054.     pthread_mutex_unlock(&patchbay_ptr->lock);

  1055. 

  1056.     return;

  1057. 

  1058. nomem_close_connection_struct:

  1059.     dbus_message_iter_close_container(&connections_array_iter, &connection_struct_iter);

  1060. 

  1061. nomem_close_connections_array:

  1062.     dbus_message_iter_close_container(&iter, &connections_array_iter);

  1063.     goto nomem_unlock;

  1064. 

  1065. nomem_close_port_struct:

  1066.     dbus_message_iter_close_container(&ports_array_iter, &port_struct_iter);

  1067. 

  1068. nomem_close_ports_array:

  1069.     dbus_message_iter_close_container(&client_struct_iter, &ports_array_iter);

  1070. 

  1071. nomem_close_client_struct:

  1072.     dbus_message_iter_close_container(&clients_array_iter, &client_struct_iter);

  1073. 

  1074. nomem_close_clients_array:

  1075.     dbus_message_iter_close_container(&iter, &clients_array_iter);

  1076. 

  1077. nomem_unlock:

  1078.     pthread_mutex_unlock(&patchbay_ptr->lock);

  1079. 

  1080. //nomem:

  1081.     dbus_message_unref(call->reply);

  1082.     call->reply = NULL;

  1083.     jack_error("Ran out of memory trying to construct method return");

  1084. 

  1085. exit:

  1086.     return;

  1087. }

  1088. 

  1089. static

  1090. void

  1091. jack_controller_dbus_connect_ports_by_name(

  1092.     struct jack_dbus_method_call * call)

  1093. {

  1094.     const char * client1_name;

  1095.     const char * port1_name;

  1096.     const char * client2_name;

  1097.     const char * port2_name;

  1098.     struct jack_graph_port *port1_ptr;

  1099.     struct jack_graph_port *port2_ptr;

  1100. 

  1101. /*  jack_info("jack_controller_dbus_connect_ports_by_name() called."); */

  1102. 

  1103.     if (!controller_ptr->started)

  1104.     {

  1105.         jack_dbus_error(

  1106.             call,

  1107.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  1108.             "Can't execute this method with stopped JACK server");

  1109.         return;

  1110.     }

  1111. 

  1112.     if (!jack_dbus_get_method_args(

  1113.             call,

  1114.             DBUS_TYPE_STRING,

  1115.             &client1_name,

  1116.             DBUS_TYPE_STRING,

  1117.             &port1_name,

  1118.             DBUS_TYPE_STRING,

  1119.             &client2_name,

  1120.             DBUS_TYPE_STRING,

  1121.             &port2_name,

  1122.             DBUS_TYPE_INVALID))

  1123.     {

  1124.         /* The method call had invalid arguments meaning that

  1125.          * jack_dbus_get_method_args() has constructed an error for us.

  1126.          */

  1127.         return;

  1128.     }

  1129. 

  1130. /*  jack_info("connecting %s:%s and %s:%s", client1_name, port1_name, client2_name, port2_name); */

  1131. 

  1132.     pthread_mutex_lock(&patchbay_ptr->lock);

  1133. 

  1134.     port1_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client1_name, port1_name);

  1135.     if (port1_ptr == NULL)

  1136.     {

  1137.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client1_name, port1_name);

  1138.         goto unlock;

  1139.     }

  1140. 

  1141.     port2_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client2_name, port2_name);

  1142.     if (port2_ptr == NULL)

  1143.     {

  1144.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client2_name, port2_name);

  1145.         goto unlock;

  1146.     }

  1147. 

  1148.     if (!jack_controller_patchbay_connect(

  1149.             call,

  1150.             controller_ptr,

  1151.             port1_ptr,

  1152.             port2_ptr))

  1153.     {

  1154.         /* jack_controller_patchbay_connect() constructed error reply */

  1155.         goto unlock;

  1156.     }

  1157. 

  1158.     jack_dbus_construct_method_return_empty(call);

  1159. 

  1160. unlock:

  1161.     pthread_mutex_unlock(&patchbay_ptr->lock);

  1162. }

  1163. 

  1164. static

  1165. void

  1166. jack_controller_dbus_connect_ports_by_id(

  1167.     struct jack_dbus_method_call * call)

  1168. {

  1169.     dbus_uint64_t port1_id;

  1170.     dbus_uint64_t port2_id;

  1171.     struct jack_graph_port *port1_ptr;

  1172.     struct jack_graph_port *port2_ptr;

  1173. 

  1174. /*     jack_info("jack_controller_dbus_connect_ports_by_id() called."); */

  1175. 

  1176.     if (!controller_ptr->started)

  1177.     {

  1178.         jack_dbus_error(

  1179.             call,

  1180.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  1181.             "Can't execute this method with stopped JACK server");

  1182.         return;

  1183.     }

  1184. 

  1185.     if (!jack_dbus_get_method_args(

  1186.             call,

  1187.             DBUS_TYPE_UINT64,

  1188.             &port1_id,

  1189.             DBUS_TYPE_UINT64,

  1190.             &port2_id,

  1191.             DBUS_TYPE_INVALID))

  1192.     {

  1193.         /* The method call had invalid arguments meaning that

  1194.          * jack_dbus_get_method_args() has constructed an error for us.

  1195.          */

  1196.         return;

  1197.     }

  1198. 

  1199.     pthread_mutex_lock(&patchbay_ptr->lock);

  1200. 

  1201.     port1_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port1_id);

  1202.     if (port1_ptr == NULL)

  1203.     {

  1204.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port1_id);

  1205.         goto unlock;

  1206.     }

  1207. 

  1208.     port2_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port2_id);

  1209.     if (port2_ptr == NULL)

  1210.     {

  1211.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port2_id);

  1212.         goto unlock;

  1213.     }

  1214. 

  1215.     if (!jack_controller_patchbay_connect(

  1216.             call,

  1217.             controller_ptr,

  1218.             port1_ptr,

  1219.             port2_ptr))

  1220.     {

  1221.         /* jack_controller_patchbay_connect() constructed error reply */

  1222.         goto unlock;

  1223.     }

  1224. 

  1225.     jack_dbus_construct_method_return_empty(call);

  1226. 

  1227. unlock:

  1228.     pthread_mutex_unlock(&patchbay_ptr->lock);

  1229. }

  1230. 

  1231. static

  1232. void

  1233. jack_controller_dbus_disconnect_ports_by_name(

  1234.     struct jack_dbus_method_call * call)

  1235. {

  1236.     const char * client1_name;

  1237.     const char * port1_name;

  1238.     const char * client2_name;

  1239.     const char * port2_name;

  1240.     struct jack_graph_port *port1_ptr;

  1241.     struct jack_graph_port *port2_ptr;

  1242. 

  1243. /*  jack_info("jack_controller_dbus_disconnect_ports_by_name() called."); */

  1244. 

  1245.     if (!controller_ptr->started)

  1246.     {

  1247.         jack_dbus_error(

  1248.             call,

  1249.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  1250.             "Can't execute this method with stopped JACK server");

  1251.         return;

  1252.     }

  1253. 

  1254.     if (!jack_dbus_get_method_args(

  1255.             call,

  1256.             DBUS_TYPE_STRING,

  1257.             &client1_name,

  1258.             DBUS_TYPE_STRING,

  1259.             &port1_name,

  1260.             DBUS_TYPE_STRING,

  1261.             &client2_name,

  1262.             DBUS_TYPE_STRING,

  1263.             &port2_name,

  1264.             DBUS_TYPE_INVALID))

  1265.     {

  1266.         /* The method call had invalid arguments meaning that

  1267.          * jack_dbus_get_method_args() has constructed an error for us.

  1268.          */

  1269.         return;

  1270.     }

  1271. 

  1272. /*  jack_info("disconnecting %s:%s and %s:%s", client1_name, port1_name, client2_name, port2_name); */

  1273. 

  1274.     pthread_mutex_lock(&patchbay_ptr->lock);

  1275. 

  1276.     port1_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client1_name, port1_name);

  1277.     if (port1_ptr == NULL)

  1278.     {

  1279.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client1_name, port1_name);

  1280.         goto unlock;

  1281.     }

  1282. 

  1283.     port2_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client2_name, port2_name);

  1284.     if (port2_ptr == NULL)

  1285.     {

  1286.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client2_name, port2_name);

  1287.         goto unlock;

  1288.     }

  1289. 

  1290.     if (!jack_controller_patchbay_disconnect(

  1291.             call,

  1292.             controller_ptr,

  1293.             port1_ptr,

  1294.             port2_ptr))

  1295.     {

  1296.         /* jack_controller_patchbay_connect() constructed error reply */

  1297.         goto unlock;

  1298.     }

  1299. 

  1300.     jack_dbus_construct_method_return_empty(call);

  1301. 

  1302. unlock:

  1303.     pthread_mutex_unlock(&patchbay_ptr->lock);

  1304. }

  1305. 

  1306. static

  1307. void

  1308. jack_controller_dbus_disconnect_ports_by_id(

  1309.     struct jack_dbus_method_call * call)

  1310. {

  1311.     dbus_uint64_t port1_id;

  1312.     dbus_uint64_t port2_id;

  1313.     struct jack_graph_port *port1_ptr;

  1314.     struct jack_graph_port *port2_ptr;

  1315. 

  1316. /*     jack_info("jack_controller_dbus_disconnect_ports_by_id() called."); */

  1317. 

  1318.     if (!controller_ptr->started)

  1319.     {

  1320.         jack_dbus_error(

  1321.             call,

  1322.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  1323.             "Can't execute this method with stopped JACK server");

  1324.         return;

  1325.     }

  1326. 

  1327.     if (!jack_dbus_get_method_args(

  1328.             call,

  1329.             DBUS_TYPE_UINT64,

  1330.             &port1_id,

  1331.             DBUS_TYPE_UINT64,

  1332.             &port2_id,

  1333.             DBUS_TYPE_INVALID))

  1334.     {

  1335.         /* The method call had invalid arguments meaning that

  1336.          * jack_dbus_get_method_args() has constructed an error for us.

  1337.          */

  1338.         return;

  1339.     }

  1340. 

  1341.     pthread_mutex_lock(&patchbay_ptr->lock);

  1342. 

  1343.     port1_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port1_id);

  1344.     if (port1_ptr == NULL)

  1345.     {

  1346.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port1_id);

  1347.         return;

  1348.     }

  1349. 

  1350.     port2_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port2_id);

  1351.     if (port2_ptr == NULL)

  1352.     {

  1353.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port2_id);

  1354.         return;

  1355.     }

  1356. 

  1357.     if (!jack_controller_patchbay_disconnect(

  1358.             call,

  1359.             controller_ptr,

  1360.             port1_ptr,

  1361.             port2_ptr))

  1362.     {

  1363.         /* jack_controller_patchbay_connect() constructed error reply */

  1364.         goto unlock;

  1365.     }

  1366. 

  1367.     jack_dbus_construct_method_return_empty(call);

  1368. 

  1369. unlock:

  1370.     pthread_mutex_unlock(&patchbay_ptr->lock);

  1371. }

  1372. 

  1373. static

  1374. void

  1375. jack_controller_dbus_disconnect_ports_by_connection_id(

  1376.     struct jack_dbus_method_call * call)

  1377. {

  1378.     dbus_uint64_t connection_id;

  1379.     struct jack_graph_connection *connection_ptr;

  1380. 

  1381. /*     jack_info("jack_controller_dbus_disconnect_ports_by_id() called."); */

  1382. 

  1383.     if (!jack_dbus_get_method_args(

  1384.             call,

  1385.             DBUS_TYPE_UINT64,

  1386.             &connection_id,

  1387.             DBUS_TYPE_INVALID))

  1388.     {

  1389.         /* The method call had invalid arguments meaning that

  1390.          * jack_dbus_get_method_args() has constructed an error for us.

  1391.          */

  1392.         return;

  1393.     }

  1394. 

  1395.     pthread_mutex_lock(&patchbay_ptr->lock);

  1396. 

  1397.     connection_ptr = jack_controller_patchbay_find_connection_by_id(patchbay_ptr, connection_id);

  1398.     if (connection_ptr == NULL)

  1399.     {

  1400.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find connection %" PRIu64, connection_id);

  1401.         goto unlock;

  1402.     }

  1403. 

  1404.     if (!jack_controller_patchbay_disconnect(

  1405.             call,

  1406.             controller_ptr,

  1407.             connection_ptr->port1,

  1408.             connection_ptr->port2))

  1409.     {

  1410.         /* jack_controller_patchbay_connect() constructed error reply */

  1411.         goto unlock;

  1412.     }

  1413. 

  1414.     jack_dbus_construct_method_return_empty(call);

  1415. 

  1416. unlock:

  1417.     pthread_mutex_unlock(&patchbay_ptr->lock);

  1418. }

  1419. 

  1420. static

  1421. void

  1422. jack_controller_dbus_get_client_pid(

  1423.     struct jack_dbus_method_call * call)

  1424. {

  1425.     dbus_uint64_t client_id;

  1426.     struct jack_graph_client *client_ptr;

  1427.     message_arg_t arg;

  1428. 

  1429. /*     jack_info("jack_controller_dbus_get_client_pid() called."); */

  1430. 

  1431.     if (!jack_dbus_get_method_args(

  1432.             call,

  1433.             DBUS_TYPE_UINT64,

  1434.             &client_id,

  1435.             DBUS_TYPE_INVALID))

  1436.     {

  1437.         /* The method call had invalid arguments meaning that

  1438.          * jack_dbus_get_method_args() has constructed an error for us.

  1439.          */

  1440.         return;

  1441.     }

  1442. 

  1443.     pthread_mutex_lock(&patchbay_ptr->lock);

  1444. 

  1445.     client_ptr = jack_controller_patchbay_find_client_by_id(patchbay_ptr, client_id);

  1446.     if (client_ptr == NULL)

  1447.     {

  1448.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find client %" PRIu64, client_id);

  1449.         goto unlock;

  1450.     }

  1451. 

  1452.     arg.int64 = client_ptr->pid;

  1453. 

  1454.     jack_dbus_construct_method_return_single(call, DBUS_TYPE_INT64, arg);

  1455. 

  1456. unlock:

  1457.     pthread_mutex_unlock(&patchbay_ptr->lock);

  1458. }

  1459. 

  1460. #undef controller_ptr

  1461. #define controller_ptr ((struct jack_controller *)context)

  1462. 

  1463. static

  1464. int

  1465. jack_controller_graph_order_callback(

  1466.     void *context)

  1467. {

  1468.     const char **ports;

  1469.     int i;

  1470.     jack_port_t *port_ptr;

  1471.     

  1472.     if (patchbay_ptr->graph.version > 1)

  1473.     {

  1474.         /* we use this only for initial catchup */

  1475.         return 0;

  1476.     }

  1477.     

  1478.     ports = jack_get_ports(controller_ptr->client, NULL, NULL, 0);

  1479.     if (ports)

  1480.     {

  1481.         for (i = 0;  ports[i]; ++i)

  1482.         {

  1483.             jack_info("graph reorder: new port '%s'", ports[i]);

  1484.             port_ptr = jack_port_by_name(controller_ptr->client, ports[i]);;

  1485.             jack_controller_patchbay_new_port(patchbay_ptr, ports[i], jack_port_flags(port_ptr), jack_port_type_id(port_ptr));

  1486.         }

  1487. 

  1488.         free(ports);

  1489.     }

  1490. 

  1491.     if (patchbay_ptr->graph.version == 1)

  1492.     {

  1493.         /* we have empty initial graph, increment graph version,

  1494.            so we dont do jack_get_ports() again,

  1495.            on next next graph change */

  1496.         patchbay_ptr->graph.version++;

  1497.     }

  1498. 

  1499.     return 0;

  1500. }

  1501. 

  1502. void

  1503. jack_controller_client_registration_callback(

  1504.     const char *client_name,

  1505.     int created,

  1506.     void *context)

  1507. {

  1508.     if (created)

  1509.     {

  1510.         jack_log("client '%s' created", client_name);

  1511.         jack_controller_patchbay_create_client(patchbay_ptr, client_name, strlen(client_name));

  1512.     }

  1513.     else

  1514.     {

  1515.         jack_log("client '%s' destroyed", client_name);

  1516.         jack_controller_patchbay_destroy_client_by_name(patchbay_ptr, client_name);

  1517.     }

  1518. }

  1519. 

  1520. void

  1521. jack_controller_port_registration_callback(

  1522.     jack_port_id_t port_id,

  1523.     int created,

  1524.     void *context)

  1525. {

  1526.     jack_port_t *port_ptr;

  1527.     struct jack_graph_port *graph_port_ptr;

  1528.     const char *port_name;

  1529. 

  1530.     port_ptr = jack_port_by_id(controller_ptr->client, port_id);

  1531.     port_name = jack_port_name(port_ptr);

  1532. 

  1533.     if (created)

  1534.     {

  1535.         jack_log("port '%s' created", port_name);

  1536.         jack_controller_patchbay_new_port(patchbay_ptr, port_name, jack_port_flags(port_ptr), jack_port_type_id(port_ptr));

  1537.     }

  1538.     else

  1539.     {

  1540.         jack_log("port '%s' destroyed", port_name);

  1541.         graph_port_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port_name);

  1542.         if (graph_port_ptr == NULL)

  1543.         {

  1544.             jack_error("Failed to find port '%s' to destroy", port_name);

  1545.             return;

  1546.         }

  1547. 

  1548.         jack_controller_patchbay_remove_port(patchbay_ptr, graph_port_ptr);

  1549.     }

  1550. }

  1551. 

  1552. void

  1553. jack_controller_port_connect_callback(

  1554.     jack_port_id_t port1_id,

  1555.     jack_port_id_t port2_id,

  1556.     int connect,

  1557.     void *context)

  1558. {

  1559.     jack_port_t *port1;

  1560.     jack_port_t *port2;

  1561.     const char *port1_name;

  1562.     const char *port2_name;

  1563.     struct jack_graph_port *port1_ptr;

  1564.     struct jack_graph_port *port2_ptr;

  1565.     struct jack_graph_connection *connection_ptr;

  1566. 

  1567.     port1 = jack_port_by_id(controller_ptr->client, port1_id);

  1568.     port2 = jack_port_by_id(controller_ptr->client, port2_id);

  1569. 

  1570.     port1_name = jack_port_name(port1);

  1571.     port2_name = jack_port_name(port2);

  1572. 

  1573.     port1_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port1_name);

  1574.     if (port1_ptr == NULL)

  1575.     {

  1576.         jack_error("Failed to find port '%s' to [dis]connect", port1_name);

  1577.         return;

  1578.     }

  1579. 

  1580.     port2_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port2_name);

  1581.     if (port2_ptr == NULL)

  1582.     {

  1583.         jack_error("Failed to find port '%s' to [dis]connect", port2_name);

  1584.         return;

  1585.     }

  1586. 

  1587.     if (connect)

  1588.     {

  1589.         jack_info("Connecting '%s' to '%s'", port1_name, port2_name);

  1590.         connection_ptr = jack_controller_patchbay_find_connection(patchbay_ptr, port1_ptr, port2_ptr);

  1591.         if (connection_ptr != NULL)

  1592.         {

  1593.             jack_error("'%s' and '%s' are already connected", port1_name, port2_name);

  1594.             return;

  1595.         }

  1596. 

  1597.         jack_controller_patchbay_create_connection(patchbay_ptr, port1_ptr, port2_ptr);

  1598.     }

  1599.     else

  1600.     {

  1601.         jack_info("Disonnecting '%s' from '%s'", port1_name, port2_name);

  1602.         connection_ptr = jack_controller_patchbay_find_connection(patchbay_ptr, port1_ptr, port2_ptr);

  1603.         if (connection_ptr == NULL)

  1604.         {

  1605.             jack_error("Cannot find connection being removed");

  1606.             return;

  1607.         }

  1608. 

  1609.         jack_controller_patchbay_destroy_connection(patchbay_ptr, connection_ptr);

  1610.     }

  1611. }

  1612. 

  1613. #undef controller_ptr

  1614. 

  1615. void

  1616. jack_controller_patchbay_uninit(

  1617.     struct jack_controller * controller_ptr)

  1618. {

  1619.     struct jack_graph_client *client_ptr;

  1620.     struct jack_graph_port *port_ptr;

  1621. 

  1622. /*     jack_info("jack_controller_patchbay_uninit() called"); */

  1623. 

  1624.     while (!list_empty(&patchbay_ptr->graph.ports))

  1625.     {

  1626.         port_ptr = list_entry(patchbay_ptr->graph.ports.next, struct jack_graph_port, siblings_graph);

  1627.         jack_controller_patchbay_remove_port(patchbay_ptr, port_ptr);

  1628.     }

  1629. 

  1630.     while (!list_empty(&patchbay_ptr->graph.clients))

  1631.     {

  1632.         client_ptr = list_entry(patchbay_ptr->graph.clients.next, struct jack_graph_client, siblings);

  1633.         jack_controller_patchbay_destroy_client(patchbay_ptr, client_ptr);

  1634.     }

  1635. 

  1636.     pthread_mutex_destroy(&patchbay_ptr->lock);

  1637. }

  1638. 

  1639. #undef patchbay_ptr

  1640. 

  1641. bool

  1642. jack_controller_patchbay_init(

  1643.     struct jack_controller * controller_ptr)

  1644. {

  1645.     int ret;

  1646.     struct jack_controller_patchbay * patchbay_ptr;

  1647.     pthread_mutexattr_t attr;

  1648. 

  1649. /*     jack_info("jack_controller_patchbay_init() called"); */

  1650. 

  1651.     patchbay_ptr = malloc(sizeof(struct jack_controller_patchbay));

  1652.     if (patchbay_ptr == NULL)

  1653.     {

  1654.         jack_error("Memory allocation of jack_controller_patchbay structure failed.");

  1655.         goto fail;

  1656.     }

  1657. 

  1658.     ret = pthread_mutexattr_init(&attr);

  1659.     if (ret != 0)

  1660.     {

  1661.         goto fail;

  1662.     }

  1663. 

  1664.     ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

  1665.     if (ret != 0)

  1666.     {

  1667.         goto fail;

  1668.     }

  1669. 

  1670.     pthread_mutex_init(&patchbay_ptr->lock, &attr);

  1671.     INIT_LIST_HEAD(&patchbay_ptr->graph.clients);

  1672.     INIT_LIST_HEAD(&patchbay_ptr->graph.ports);

  1673.     INIT_LIST_HEAD(&patchbay_ptr->graph.connections);

  1674.     patchbay_ptr->graph.version = 1;

  1675.     patchbay_ptr->next_client_id = 1;

  1676.     patchbay_ptr->next_port_id = 1;

  1677.     patchbay_ptr->next_connection_id = 1;

  1678. 

  1679.     controller_ptr->patchbay_context = patchbay_ptr;

  1680. 

  1681.     ret = jack_set_graph_order_callback(controller_ptr->client, jack_controller_graph_order_callback, controller_ptr);

  1682.     if (ret != 0)

  1683.     {

  1684.         jack_error("jack_set_graph_order_callback() failed with error %d", ret);

  1685.         goto fail_uninit_mutex;

  1686.     }

  1687. 

  1688.     ret = jack_set_client_registration_callback(controller_ptr->client, jack_controller_client_registration_callback, controller_ptr);

  1689.     if (ret != 0)

  1690.     {

  1691.         jack_error("jack_set_client_registration_callback() failed with error %d", ret);

  1692.         goto fail_uninit_mutex;

  1693.     }

  1694. 

  1695.     ret = jack_set_port_registration_callback(controller_ptr->client, jack_controller_port_registration_callback, controller_ptr);

  1696.     if (ret != 0)

  1697.     {

  1698.         jack_error("jack_set_port_registration_callback() failed with error %d", ret);

  1699.         goto fail_uninit_mutex;

  1700.     }

  1701. 

  1702.     ret = jack_set_port_connect_callback(controller_ptr->client, jack_controller_port_connect_callback, controller_ptr);

  1703.     if (ret != 0)

  1704.     {

  1705.         jack_error("jack_set_port_connect_callback() failed with error %d", ret);

  1706.         goto fail_uninit_mutex;

  1707.     }

  1708. 

  1709.     return true;

  1710. 

  1711. fail_uninit_mutex:

  1712.     pthread_mutex_destroy(&patchbay_ptr->lock);

  1713. 

  1714. fail:

  1715.     return false;

  1716. }

  1717. 

  1718. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetAllPorts)

  1719.     JACK_DBUS_METHOD_ARGUMENT("ports_list", "as", true)

  1720. JACK_DBUS_METHOD_ARGUMENTS_END

  1721. 

  1722. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetGraph)

  1723.     JACK_DBUS_METHOD_ARGUMENT("known_graph_version", DBUS_TYPE_UINT64_AS_STRING, false)

  1724.     JACK_DBUS_METHOD_ARGUMENT("current_graph_version", DBUS_TYPE_UINT64_AS_STRING, true)

  1725.     JACK_DBUS_METHOD_ARGUMENT("clients_and_ports", "a(tsa(tsuu))", true)

  1726.     JACK_DBUS_METHOD_ARGUMENT("connections", "a(tstststst)", true)

  1727. JACK_DBUS_METHOD_ARGUMENTS_END

  1728. 

  1729. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(ConnectPortsByName)

  1730.     JACK_DBUS_METHOD_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING, false)

  1731.     JACK_DBUS_METHOD_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING, false)

  1732.     JACK_DBUS_METHOD_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING, false)

  1733.     JACK_DBUS_METHOD_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING, false)

  1734. JACK_DBUS_METHOD_ARGUMENTS_END

  1735. 

  1736. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(ConnectPortsByID)

  1737.     JACK_DBUS_METHOD_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING, false)

  1738.     JACK_DBUS_METHOD_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING, false)

  1739. JACK_DBUS_METHOD_ARGUMENTS_END

  1740. 

  1741. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByName)

  1742.     JACK_DBUS_METHOD_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING, false)

  1743.     JACK_DBUS_METHOD_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING, false)

  1744.     JACK_DBUS_METHOD_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING, false)

  1745.     JACK_DBUS_METHOD_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING, false)

  1746. JACK_DBUS_METHOD_ARGUMENTS_END

  1747. 

  1748. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByID)

  1749.     JACK_DBUS_METHOD_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING, false)

  1750.     JACK_DBUS_METHOD_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING, false)

  1751. JACK_DBUS_METHOD_ARGUMENTS_END

  1752. 

  1753. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByConnectionID)

  1754.     JACK_DBUS_METHOD_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING, false)

  1755. JACK_DBUS_METHOD_ARGUMENTS_END

  1756. 

  1757. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetClientPID)

  1758.     JACK_DBUS_METHOD_ARGUMENT("client_id", DBUS_TYPE_INT64_AS_STRING, false)

  1759. JACK_DBUS_METHOD_ARGUMENTS_END

  1760. 

  1761. JACK_DBUS_METHODS_BEGIN

  1762.     JACK_DBUS_METHOD_DESCRIBE(GetAllPorts, jack_controller_dbus_get_all_ports)

  1763.     JACK_DBUS_METHOD_DESCRIBE(GetGraph, jack_controller_dbus_get_graph)

  1764.     JACK_DBUS_METHOD_DESCRIBE(ConnectPortsByName, jack_controller_dbus_connect_ports_by_name)

  1765.     JACK_DBUS_METHOD_DESCRIBE(ConnectPortsByID, jack_controller_dbus_connect_ports_by_id)

  1766.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByName, jack_controller_dbus_disconnect_ports_by_name)

  1767.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByID, jack_controller_dbus_disconnect_ports_by_id)

  1768.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByConnectionID, jack_controller_dbus_disconnect_ports_by_connection_id)

  1769.     JACK_DBUS_METHOD_DESCRIBE(GetClientPID, jack_controller_dbus_get_client_pid)

  1770. JACK_DBUS_METHODS_END

  1771. 

  1772. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(GraphChanged)

  1773.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  1774. JACK_DBUS_SIGNAL_ARGUMENTS_END

  1775. 

  1776. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(ClientAppeared)

  1777.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  1778.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  1779.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  1780. JACK_DBUS_SIGNAL_ARGUMENTS_END

  1781. 

  1782. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(ClientDisappeared)

  1783.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  1784.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  1785.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  1786. JACK_DBUS_SIGNAL_ARGUMENTS_END

  1787. 

  1788. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortAppeared)

  1789.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  1790.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  1791.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  1792.     JACK_DBUS_SIGNAL_ARGUMENT("port_id", DBUS_TYPE_UINT64_AS_STRING)

  1793.     JACK_DBUS_SIGNAL_ARGUMENT("port_name", DBUS_TYPE_STRING_AS_STRING)

  1794.     JACK_DBUS_SIGNAL_ARGUMENT("port_flags", DBUS_TYPE_UINT32_AS_STRING)

  1795.     JACK_DBUS_SIGNAL_ARGUMENT("port_type", DBUS_TYPE_UINT32_AS_STRING)

  1796. JACK_DBUS_SIGNAL_ARGUMENTS_END

  1797. 

  1798. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortDisappeared)

  1799.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  1800.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  1801.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  1802.     JACK_DBUS_SIGNAL_ARGUMENT("port_id", DBUS_TYPE_UINT64_AS_STRING)

  1803.     JACK_DBUS_SIGNAL_ARGUMENT("port_name", DBUS_TYPE_STRING_AS_STRING)

  1804. JACK_DBUS_SIGNAL_ARGUMENTS_END

  1805. 

  1806. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortsConnected)

  1807.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  1808.     JACK_DBUS_SIGNAL_ARGUMENT("client1_id", DBUS_TYPE_UINT64_AS_STRING)

  1809.     JACK_DBUS_SIGNAL_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING)

  1810.     JACK_DBUS_SIGNAL_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING)

  1811.     JACK_DBUS_SIGNAL_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING)

  1812.     JACK_DBUS_SIGNAL_ARGUMENT("client2_id", DBUS_TYPE_UINT64_AS_STRING)

  1813.     JACK_DBUS_SIGNAL_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING)

  1814.     JACK_DBUS_SIGNAL_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING)

  1815.     JACK_DBUS_SIGNAL_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING)

  1816.     JACK_DBUS_SIGNAL_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING)

  1817. JACK_DBUS_SIGNAL_ARGUMENTS_END

  1818. 

  1819. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortsDisconnected)

  1820.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  1821.     JACK_DBUS_SIGNAL_ARGUMENT("client1_id", DBUS_TYPE_UINT64_AS_STRING)

  1822.     JACK_DBUS_SIGNAL_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING)

  1823.     JACK_DBUS_SIGNAL_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING)

  1824.     JACK_DBUS_SIGNAL_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING)

  1825.     JACK_DBUS_SIGNAL_ARGUMENT("client2_id", DBUS_TYPE_UINT64_AS_STRING)

  1826.     JACK_DBUS_SIGNAL_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING)

  1827.     JACK_DBUS_SIGNAL_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING)

  1828.     JACK_DBUS_SIGNAL_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING)

  1829.     JACK_DBUS_SIGNAL_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING)

  1830. JACK_DBUS_SIGNAL_ARGUMENTS_END

  1831. 

  1832. JACK_DBUS_SIGNALS_BEGIN

  1833.     JACK_DBUS_SIGNAL_DESCRIBE(GraphChanged)

  1834.     JACK_DBUS_SIGNAL_DESCRIBE(ClientAppeared)

  1835.     JACK_DBUS_SIGNAL_DESCRIBE(ClientDisappeared)

  1836.     JACK_DBUS_SIGNAL_DESCRIBE(PortAppeared)

  1837.     JACK_DBUS_SIGNAL_DESCRIBE(PortDisappeared)

  1838.     JACK_DBUS_SIGNAL_DESCRIBE(PortsConnected)

  1839.     JACK_DBUS_SIGNAL_DESCRIBE(PortsDisconnected)

  1840. JACK_DBUS_SIGNALS_END

  1841. 

  1842. JACK_DBUS_IFACE_BEGIN(g_jack_controller_iface_patchbay, JACK_DBUS_IFACE_NAME)

  1843.     JACK_DBUS_IFACE_EXPOSE_METHODS

  1844.     JACK_DBUS_IFACE_EXPOSE_SIGNALS

  1845. JACK_DBUS_IFACE_END

  1846. /* -*- Mode: C ; c-basic-offset: 4 -*- */

  1847. /*

  1848.     Copyright (C) 2008 Nedko Arnaudov

  1849.     Copyright (C) 2008 Juuso Alasuutari

  1850. 

  1851.     This program is free software; you can redistribute it and/or modify

  1852.     it under the terms of the GNU General Public License as published by

  1853.     the Free Software Foundation; either version 2 of the License.

  1854. 

  1855.     This program is distributed in the hope that it will be useful,

  1856.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  1857.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  1858.     GNU General Public License for more details.

  1859. 

  1860.     You should have received a copy of the GNU General Public License

  1861.     along with this program; if not, write to the Free Software

  1862.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  1863. 

  1864. */

  1865. 

  1866. #define _GNU_SOURCE            /* PTHREAD_MUTEX_RECURSIVE */

  1867. 

  1868. #include <stdint.h>

  1869. #include <inttypes.h>

  1870. #include <string.h>

  1871. #include <stdio.h>

  1872. #include <assert.h>

  1873. #include <dbus/dbus.h>

  1874. #include <pthread.h>

  1875. 

  1876. #include "jackdbus.h"

  1877. #include "controller_internal.h"

  1878. #include "list.h"

  1879. 

  1880. #define JACK_DBUS_IFACE_NAME "org.jackaudio.JackPatchbay"

  1881. 

  1882. /* FIXME: these need to be retrieved from common headers */

  1883. #define JACK_CLIENT_NAME_SIZE 64

  1884. #define JACK_PORT_NAME_SIZE 256

  1885. 

  1886. struct jack_graph

  1887. {

  1888.     uint64_t version;

  1889.     struct list_head clients;

  1890.     struct list_head ports;

  1891.     struct list_head connections;

  1892. };

  1893. 

  1894. struct jack_graph_client

  1895. {

  1896.     uint64_t id;

  1897.     char * name;

  1898.     int pid;

  1899.     struct list_head siblings;

  1900.     struct list_head ports;

  1901. };

  1902. 

  1903. struct jack_graph_port

  1904. {

  1905.     uint64_t id;

  1906.     char * name;

  1907.     uint32_t flags;

  1908.     uint32_t type;

  1909.     struct list_head siblings_graph;

  1910.     struct list_head siblings_client;

  1911.     struct jack_graph_client * client;

  1912. };

  1913. 

  1914. struct jack_graph_connection

  1915. {

  1916.     uint64_t id;

  1917.     struct jack_graph_port * port1;

  1918.     struct jack_graph_port * port2;

  1919.     struct list_head siblings;

  1920. };

  1921. 

  1922. struct jack_controller_patchbay

  1923. {

  1924.     pthread_mutex_t lock;

  1925.     struct jack_graph graph;

  1926.     uint64_t next_client_id;

  1927.     uint64_t next_port_id;

  1928.     uint64_t next_connection_id;

  1929. };

  1930. 

  1931. void

  1932. jack_controller_patchbay_send_signal_graph_changed(

  1933.     dbus_uint64_t new_graph_version)

  1934. {

  1935. 

  1936.     jack_dbus_send_signal(

  1937.         JACK_CONTROLLER_OBJECT_PATH,

  1938.         JACK_DBUS_IFACE_NAME,

  1939.         "GraphChanged",

  1940.         DBUS_TYPE_UINT64,

  1941.         &new_graph_version,

  1942.         DBUS_TYPE_INVALID);

  1943. }

  1944. 

  1945. void

  1946. jack_controller_patchbay_send_signal_client_appeared(

  1947.     dbus_uint64_t new_graph_version,

  1948.     dbus_uint64_t client_id,

  1949.     const char * client_name)

  1950. {

  1951. 

  1952.     jack_dbus_send_signal(

  1953.         JACK_CONTROLLER_OBJECT_PATH,

  1954.         JACK_DBUS_IFACE_NAME,

  1955.         "ClientAppeared",

  1956.         DBUS_TYPE_UINT64,

  1957.         &new_graph_version,

  1958.         DBUS_TYPE_UINT64,

  1959.         &client_id,

  1960.         DBUS_TYPE_STRING,

  1961.         &client_name,

  1962.         DBUS_TYPE_INVALID);

  1963. }

  1964. 

  1965. void

  1966. jack_controller_patchbay_send_signal_client_disappeared(

  1967.     dbus_uint64_t new_graph_version,

  1968.     dbus_uint64_t client_id,

  1969.     const char * client_name)

  1970. {

  1971. 

  1972.     jack_dbus_send_signal(

  1973.         JACK_CONTROLLER_OBJECT_PATH,

  1974.         JACK_DBUS_IFACE_NAME,

  1975.         "ClientDisappeared",

  1976.         DBUS_TYPE_UINT64,

  1977.         &new_graph_version,

  1978.         DBUS_TYPE_UINT64,

  1979.         &client_id,

  1980.         DBUS_TYPE_STRING,

  1981.         &client_name,

  1982.         DBUS_TYPE_INVALID);

  1983. }

  1984. 

  1985. void

  1986. jack_controller_patchbay_send_signal_port_appeared(

  1987.     dbus_uint64_t new_graph_version,

  1988.     dbus_uint64_t client_id,

  1989.     const char * client_name,

  1990.     dbus_uint64_t port_id,

  1991.     const char * port_name,

  1992.     dbus_uint32_t port_flags,

  1993.     dbus_uint32_t port_type)

  1994. {

  1995. 

  1996.     jack_dbus_send_signal(

  1997.         JACK_CONTROLLER_OBJECT_PATH,

  1998.         JACK_DBUS_IFACE_NAME,

  1999.         "PortAppeared",

  2000.         DBUS_TYPE_UINT64,

  2001.         &new_graph_version,

  2002.         DBUS_TYPE_UINT64,

  2003.         &client_id,

  2004.         DBUS_TYPE_STRING,

  2005.         &client_name,

  2006.         DBUS_TYPE_UINT64,

  2007.         &port_id,

  2008.         DBUS_TYPE_STRING,

  2009.         &port_name,

  2010.         DBUS_TYPE_UINT32,

  2011.         &port_flags,

  2012.         DBUS_TYPE_UINT32,

  2013.         &port_type,

  2014.         DBUS_TYPE_INVALID);

  2015. }

  2016. 

  2017. void

  2018. jack_controller_patchbay_send_signal_port_disappeared(

  2019.     dbus_uint64_t new_graph_version,

  2020.     dbus_uint64_t client_id,

  2021.     const char * client_name,

  2022.     dbus_uint64_t port_id,

  2023.     const char * port_name)

  2024. {

  2025. 

  2026.     jack_dbus_send_signal(

  2027.         JACK_CONTROLLER_OBJECT_PATH,

  2028.         JACK_DBUS_IFACE_NAME,

  2029.         "PortDisappeared",

  2030.         DBUS_TYPE_UINT64,

  2031.         &new_graph_version,

  2032.         DBUS_TYPE_UINT64,

  2033.         &client_id,

  2034.         DBUS_TYPE_STRING,

  2035.         &client_name,

  2036.         DBUS_TYPE_UINT64,

  2037.         &port_id,

  2038.         DBUS_TYPE_STRING,

  2039.         &port_name,

  2040.         DBUS_TYPE_INVALID);

  2041. }

  2042. 

  2043. void

  2044. jack_controller_patchbay_send_signal_ports_connected(

  2045.     dbus_uint64_t new_graph_version,

  2046.     dbus_uint64_t client1_id,

  2047.     const char * client1_name,

  2048.     dbus_uint64_t port1_id,

  2049.     const char * port1_name,

  2050.     dbus_uint64_t client2_id,

  2051.     const char * client2_name,

  2052.     dbus_uint64_t port2_id,

  2053.     const char * port2_name,

  2054.     dbus_uint64_t connection_id)

  2055. {

  2056. 

  2057.     jack_dbus_send_signal(

  2058.         JACK_CONTROLLER_OBJECT_PATH,

  2059.         JACK_DBUS_IFACE_NAME,

  2060.         "PortsConnected",

  2061.         DBUS_TYPE_UINT64,

  2062.         &new_graph_version,

  2063.         DBUS_TYPE_UINT64,

  2064.         &client1_id,

  2065.         DBUS_TYPE_STRING,

  2066.         &client1_name,

  2067.         DBUS_TYPE_UINT64,

  2068.         &port1_id,

  2069.         DBUS_TYPE_STRING,

  2070.         &port1_name,

  2071.         DBUS_TYPE_UINT64,

  2072.         &client2_id,

  2073.         DBUS_TYPE_STRING,

  2074.         &client2_name,

  2075.         DBUS_TYPE_UINT64,

  2076.         &port2_id,

  2077.         DBUS_TYPE_STRING,

  2078.         &port2_name,

  2079.         DBUS_TYPE_UINT64,

  2080.         &connection_id,

  2081.         DBUS_TYPE_INVALID);

  2082. }

  2083. 

  2084. void

  2085. jack_controller_patchbay_send_signal_ports_disconnected(

  2086.     dbus_uint64_t new_graph_version,

  2087.     dbus_uint64_t client1_id,

  2088.     const char * client1_name,

  2089.     dbus_uint64_t port1_id,

  2090.     const char * port1_name,

  2091.     dbus_uint64_t client2_id,

  2092.     const char * client2_name,

  2093.     dbus_uint64_t port2_id,

  2094.     const char * port2_name,

  2095.     dbus_uint64_t connection_id)

  2096. {

  2097. 

  2098.     jack_dbus_send_signal(

  2099.         JACK_CONTROLLER_OBJECT_PATH,

  2100.         JACK_DBUS_IFACE_NAME,

  2101.         "PortsDisconnected",

  2102.         DBUS_TYPE_UINT64,

  2103.         &new_graph_version,

  2104.         DBUS_TYPE_UINT64,

  2105.         &client1_id,

  2106.         DBUS_TYPE_STRING,

  2107.         &client1_name,

  2108.         DBUS_TYPE_UINT64,

  2109.         &port1_id,

  2110.         DBUS_TYPE_STRING,

  2111.         &port1_name,

  2112.         DBUS_TYPE_UINT64,

  2113.         &client2_id,

  2114.         DBUS_TYPE_STRING,

  2115.         &client2_name,

  2116.         DBUS_TYPE_UINT64,

  2117.         &port2_id,

  2118.         DBUS_TYPE_STRING,

  2119.         &port2_name,

  2120.         DBUS_TYPE_UINT64,

  2121.         &connection_id,

  2122.         DBUS_TYPE_INVALID);

  2123. }

  2124. 

  2125. static

  2126. struct jack_graph_client *

  2127. jack_controller_patchbay_find_client(

  2128.     struct jack_controller_patchbay *patchbay_ptr,

  2129.     const char *client_name,    /* not '\0' terminated */

  2130.     size_t client_name_len)     /* without terminating '\0' */

  2131. {

  2132.     struct list_head *node_ptr;

  2133.     struct jack_graph_client *client_ptr;

  2134. 

  2135.     list_for_each(node_ptr, &patchbay_ptr->graph.clients)

  2136.     {

  2137.         client_ptr = list_entry(node_ptr, struct jack_graph_client, siblings);

  2138.         if (strncmp(client_ptr->name, client_name, client_name_len) == 0)

  2139.         {

  2140.             return client_ptr;

  2141.         }

  2142.     }

  2143. 

  2144.     return NULL;

  2145. }

  2146. 

  2147. static

  2148. struct jack_graph_client *

  2149. jack_controller_patchbay_find_client_by_id(

  2150.     struct jack_controller_patchbay *patchbay_ptr,

  2151.     uint64_t id)

  2152. {

  2153.     struct list_head *node_ptr;

  2154.     struct jack_graph_client *client_ptr;

  2155. 

  2156.     list_for_each(node_ptr, &patchbay_ptr->graph.clients)

  2157.     {

  2158.         client_ptr = list_entry(node_ptr, struct jack_graph_client, siblings);

  2159.         if (client_ptr->id == id)

  2160.         {

  2161.             return client_ptr;

  2162.         }

  2163.     }

  2164. 

  2165.     return NULL;

  2166. }

  2167. 

  2168. static

  2169. struct jack_graph_client *

  2170. jack_controller_patchbay_create_client(

  2171.     struct jack_controller_patchbay *patchbay_ptr,

  2172.     const char *client_name,    /* not '\0' terminated */

  2173.     size_t client_name_len)     /* without terminating '\0' */

  2174. {

  2175.     struct jack_graph_client * client_ptr;

  2176. 

  2177.     client_ptr = malloc(sizeof(struct jack_graph_client));

  2178.     if (client_ptr == NULL)

  2179.     {

  2180.         jack_error("Memory allocation of jack_graph_client structure failed.");

  2181.         goto fail;

  2182.     }

  2183. 

  2184.     client_ptr->name = malloc(client_name_len + 1);

  2185.     if (client_ptr->name == NULL)

  2186.     {

  2187.         jack_error("malloc() failed to allocate memory for client name.");

  2188.         goto fail_free_client;

  2189.     }

  2190. 

  2191.     memcpy(client_ptr->name, client_name, client_name_len);

  2192.     client_ptr->name[client_name_len] = 0;

  2193. 

  2194.     client_ptr->pid = jack_get_client_pid(client_ptr->name);

  2195.     jack_info("New client '%s' with PID %d", client_ptr->name, client_ptr->pid);

  2196. 

  2197.     client_ptr->id = patchbay_ptr->next_client_id++;

  2198.     INIT_LIST_HEAD(&client_ptr->ports);

  2199. 

  2200. 

  2201.     pthread_mutex_lock(&patchbay_ptr->lock);

  2202.     list_add_tail(&client_ptr->siblings, &patchbay_ptr->graph.clients);

  2203.     patchbay_ptr->graph.version++;

  2204.     jack_controller_patchbay_send_signal_client_appeared(patchbay_ptr->graph.version, client_ptr->id, client_ptr->name);

  2205.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  2206.     pthread_mutex_unlock(&patchbay_ptr->lock);

  2207. 

  2208.     return client_ptr;

  2209. 

  2210. fail_free_client:

  2211.     free(client_ptr);

  2212. 

  2213. fail:

  2214.     return NULL;

  2215. }

  2216. 

  2217. static

  2218. void

  2219. jack_controller_patchbay_destroy_client(

  2220.     struct jack_controller_patchbay *patchbay_ptr,

  2221.     struct jack_graph_client *client_ptr)

  2222. {

  2223.     pthread_mutex_lock(&patchbay_ptr->lock);

  2224.     list_del(&client_ptr->siblings);

  2225.     patchbay_ptr->graph.version++;

  2226.     jack_controller_patchbay_send_signal_client_disappeared(patchbay_ptr->graph.version, client_ptr->id, client_ptr->name);

  2227.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  2228.     pthread_mutex_unlock(&patchbay_ptr->lock);

  2229. 

  2230.     free(client_ptr->name);

  2231.     free(client_ptr);

  2232. }

  2233. 

  2234. static

  2235. void

  2236. jack_controller_patchbay_destroy_client_by_name(

  2237.     struct jack_controller_patchbay *patchbay_ptr,

  2238.     const char *client_name)    /* '\0' terminated */

  2239. {

  2240.     struct jack_graph_client *client_ptr;

  2241. 

  2242.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, client_name, strlen(client_name));

  2243.     if (client_ptr == NULL)

  2244.     {

  2245.         jack_error("Cannot destroy unknown client '%s'", client_name);

  2246.         return;

  2247.     }

  2248. 

  2249.     jack_controller_patchbay_destroy_client(patchbay_ptr, client_ptr);

  2250. }

  2251. 

  2252. static

  2253. void

  2254. jack_controller_patchbay_new_port(

  2255.     struct jack_controller_patchbay *patchbay_ptr,

  2256.     const char *port_full_name,

  2257.     uint32_t port_flags,

  2258.     uint32_t port_type)

  2259. {

  2260.     struct jack_graph_client *client_ptr;

  2261.     struct jack_graph_port *port_ptr;

  2262.     const char *port_short_name;

  2263.     size_t client_name_len;

  2264. 

  2265.     //jack_info("name: %s", port_full_name);

  2266. 

  2267.     port_short_name = strchr(port_full_name, ':');

  2268.     if (port_short_name == NULL)

  2269.     {

  2270.         jack_error("port name '%s' does not contain ':' separator char", port_full_name);

  2271.         return;

  2272.     }

  2273. 

  2274.     port_short_name++;          /* skip ':' separator char */

  2275. 

  2276.     client_name_len = port_short_name - port_full_name - 1; /* without terminating '\0' */

  2277. 

  2278.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, port_full_name, client_name_len);

  2279.     if (client_ptr == NULL)

  2280.     {

  2281.         client_ptr = jack_controller_patchbay_create_client(patchbay_ptr, port_full_name, client_name_len);

  2282.         if (client_ptr == NULL)

  2283.         {

  2284.             jack_error("Creation of new jack_graph client failed.");

  2285.             return;

  2286.         }

  2287.     }

  2288. 

  2289.     port_ptr = malloc(sizeof(struct jack_graph_port));

  2290.     if (port_ptr == NULL)

  2291.     {

  2292.         jack_error("Memory allocation of jack_graph_port structure failed.");

  2293.         return;

  2294.     }

  2295. 

  2296.     port_ptr->name = strdup(port_short_name);

  2297.     if (port_ptr->name == NULL)

  2298.     {

  2299.         jack_error("strdup() call for port name '%s' failed.", port_short_name);

  2300.         free(port_ptr);

  2301.         return;

  2302.     }

  2303. 

  2304.     port_ptr->id = patchbay_ptr->next_port_id++;

  2305.     port_ptr->flags = port_flags;

  2306.     port_ptr->type = port_type;

  2307.     port_ptr->client = client_ptr;

  2308. 

  2309.     pthread_mutex_lock(&patchbay_ptr->lock);

  2310.     list_add_tail(&port_ptr->siblings_client, &client_ptr->ports);

  2311.     list_add_tail(&port_ptr->siblings_graph, &patchbay_ptr->graph.ports);

  2312.     patchbay_ptr->graph.version++;

  2313.     jack_controller_patchbay_send_signal_port_appeared(

  2314.         patchbay_ptr->graph.version,

  2315.         client_ptr->id,

  2316.         client_ptr->name,

  2317.         port_ptr->id,

  2318.         port_ptr->name,

  2319.         port_ptr->flags,

  2320.         port_ptr->type);

  2321.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  2322.     pthread_mutex_unlock(&patchbay_ptr->lock);

  2323. }

  2324. 

  2325. static

  2326. void

  2327. jack_controller_patchbay_remove_port(

  2328.     struct jack_controller_patchbay *patchbay_ptr,

  2329.     struct jack_graph_port *port_ptr)

  2330. {

  2331.     pthread_mutex_lock(&patchbay_ptr->lock);

  2332.     list_del(&port_ptr->siblings_client);

  2333.     list_del(&port_ptr->siblings_graph);

  2334.     patchbay_ptr->graph.version++;

  2335.     jack_controller_patchbay_send_signal_port_disappeared(patchbay_ptr->graph.version, port_ptr->client->id, port_ptr->client->name, port_ptr->id, port_ptr->name);

  2336.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  2337.     pthread_mutex_unlock(&patchbay_ptr->lock);

  2338. 

  2339.     free(port_ptr->name);

  2340.     free(port_ptr);

  2341. }

  2342. 

  2343. static

  2344. struct jack_graph_port *

  2345. jack_controller_patchbay_find_port_by_id(

  2346.     struct jack_controller_patchbay *patchbay_ptr,

  2347.     uint64_t port_id)

  2348. {

  2349.     struct list_head *node_ptr;

  2350.     struct jack_graph_port *port_ptr;

  2351. 

  2352.     list_for_each(node_ptr, &patchbay_ptr->graph.ports)

  2353.     {

  2354.         port_ptr = list_entry(node_ptr, struct jack_graph_port, siblings_graph);

  2355.         if (port_ptr->id == port_id)

  2356.         {

  2357.             return port_ptr;

  2358.         }

  2359.     }

  2360. 

  2361.     return NULL;

  2362. }

  2363. 

  2364. static

  2365. struct jack_graph_port *

  2366. jack_controller_patchbay_find_client_port_by_name(

  2367.     struct jack_controller_patchbay *patchbay_ptr,

  2368.     struct jack_graph_client *client_ptr,

  2369.     const char *port_name)

  2370. {

  2371.     struct list_head *node_ptr;

  2372.     struct jack_graph_port *port_ptr;

  2373. 

  2374.     list_for_each(node_ptr, &client_ptr->ports)

  2375.     {

  2376.         port_ptr = list_entry(node_ptr, struct jack_graph_port, siblings_client);

  2377.         if (strcmp(port_ptr->name, port_name) == 0)

  2378.         {

  2379.             return port_ptr;

  2380.         }

  2381.     }

  2382. 

  2383.     return NULL;

  2384. }

  2385. 

  2386. static

  2387. struct jack_graph_port *

  2388. jack_controller_patchbay_find_port_by_full_name(

  2389.     struct jack_controller_patchbay *patchbay_ptr,

  2390.     const char *port_full_name)

  2391. {

  2392.     const char *port_short_name;

  2393.     size_t client_name_len;

  2394.     struct jack_graph_client *client_ptr;

  2395. 

  2396.     //jack_info("name: %s", port_full_name);

  2397. 

  2398.     port_short_name = strchr(port_full_name, ':');

  2399.     if (port_short_name == NULL)

  2400.     {

  2401.         jack_error("port name '%s' does not contain ':' separator char", port_full_name);

  2402.         return NULL;

  2403.     }

  2404. 

  2405.     port_short_name++;          /* skip ':' separator char */

  2406. 

  2407.     client_name_len = port_short_name - port_full_name - 1; /* without terminating '\0' */

  2408. 

  2409.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, port_full_name, client_name_len);

  2410.     if (client_ptr == NULL)

  2411.     {

  2412.         jack_error("cannot find client of port '%s'", port_full_name);

  2413.         return NULL;

  2414.     }

  2415. 

  2416.     return jack_controller_patchbay_find_client_port_by_name(patchbay_ptr, client_ptr, port_short_name);

  2417. }

  2418. 

  2419. static

  2420. struct jack_graph_port *

  2421. jack_controller_patchbay_find_port_by_names(

  2422.     struct jack_controller_patchbay *patchbay_ptr,

  2423.     const char *client_name,

  2424.     const char *port_name)

  2425. {

  2426.     struct jack_graph_client *client_ptr;

  2427. 

  2428.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, client_name, strlen(client_name));

  2429.     if (client_ptr == NULL)

  2430.     {

  2431.         jack_error("cannot find client '%s'", client_name);

  2432.         return NULL;

  2433.     }

  2434. 

  2435.     return jack_controller_patchbay_find_client_port_by_name(patchbay_ptr, client_ptr, port_name);

  2436. }

  2437. 

  2438. static

  2439. struct jack_graph_connection *

  2440. jack_controller_patchbay_create_connection(

  2441.     struct jack_controller_patchbay *patchbay_ptr,

  2442.     struct jack_graph_port *port1_ptr,

  2443.     struct jack_graph_port *port2_ptr)

  2444. {

  2445.     struct jack_graph_connection * connection_ptr;

  2446. 

  2447.     connection_ptr = malloc(sizeof(struct jack_graph_connection));

  2448.     if (connection_ptr == NULL)

  2449.     {

  2450.         jack_error("Memory allocation of jack_graph_connection structure failed.");

  2451.         return NULL;

  2452.     }

  2453. 

  2454.     connection_ptr->id = patchbay_ptr->next_connection_id++;

  2455.     connection_ptr->port1 = port1_ptr;

  2456.     connection_ptr->port2 = port2_ptr;

  2457. 

  2458.     pthread_mutex_lock(&patchbay_ptr->lock);

  2459.     list_add_tail(&connection_ptr->siblings, &patchbay_ptr->graph.connections);

  2460.     patchbay_ptr->graph.version++;

  2461.     jack_controller_patchbay_send_signal_ports_connected(

  2462.         patchbay_ptr->graph.version,

  2463.         port1_ptr->client->id,

  2464.         port1_ptr->client->name,

  2465.         port1_ptr->id,

  2466.         port1_ptr->name,

  2467.         port2_ptr->client->id,

  2468.         port2_ptr->client->name,

  2469.         port2_ptr->id,

  2470.         port2_ptr->name,

  2471.         connection_ptr->id);

  2472.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  2473.     pthread_mutex_unlock(&patchbay_ptr->lock);

  2474. 

  2475.     return connection_ptr;

  2476. }

  2477. 

  2478. static

  2479. void

  2480. jack_controller_patchbay_destroy_connection(

  2481.     struct jack_controller_patchbay *patchbay_ptr,

  2482.     struct jack_graph_connection *connection_ptr)

  2483. {

  2484.     pthread_mutex_lock(&patchbay_ptr->lock);

  2485.     list_del(&connection_ptr->siblings);

  2486.     patchbay_ptr->graph.version++;

  2487.     jack_controller_patchbay_send_signal_ports_disconnected(

  2488.         patchbay_ptr->graph.version,

  2489.         connection_ptr->port1->client->id,

  2490.         connection_ptr->port1->client->name,

  2491.         connection_ptr->port1->id,

  2492.         connection_ptr->port1->name,

  2493.         connection_ptr->port2->client->id,

  2494.         connection_ptr->port2->client->name,

  2495.         connection_ptr->port2->id,

  2496.         connection_ptr->port2->name,

  2497.         connection_ptr->id);

  2498.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  2499.     pthread_mutex_unlock(&patchbay_ptr->lock);

  2500. 

  2501.     free(connection_ptr);

  2502. }

  2503. 

  2504. static

  2505. struct jack_graph_connection *

  2506. jack_controller_patchbay_find_connection(

  2507.     struct jack_controller_patchbay *patchbay_ptr,

  2508.     struct jack_graph_port *port1_ptr,

  2509.     struct jack_graph_port *port2_ptr)

  2510. {

  2511.     struct list_head *node_ptr;

  2512.     struct jack_graph_connection *connection_ptr;

  2513. 

  2514.     list_for_each(node_ptr, &patchbay_ptr->graph.connections)

  2515.     {

  2516.         connection_ptr = list_entry(node_ptr, struct jack_graph_connection, siblings);

  2517.         if ((connection_ptr->port1 == port1_ptr &&

  2518.              connection_ptr->port2 == port2_ptr) ||

  2519.             (connection_ptr->port1 == port2_ptr &&

  2520.              connection_ptr->port2 == port1_ptr))

  2521.         {

  2522.             return connection_ptr;

  2523.         }

  2524.     }

  2525. 

  2526.     return NULL;

  2527. }

  2528. 

  2529. static

  2530. struct jack_graph_connection *

  2531. jack_controller_patchbay_find_connection_by_id(

  2532.     struct jack_controller_patchbay *patchbay_ptr,

  2533.     uint64_t connection_id)

  2534. {

  2535.     struct list_head *node_ptr;

  2536.     struct jack_graph_connection *connection_ptr;

  2537. 

  2538.     list_for_each(node_ptr, &patchbay_ptr->graph.connections)

  2539.     {

  2540.         connection_ptr = list_entry(node_ptr, struct jack_graph_connection, siblings);

  2541.         if (connection_ptr->id == connection_id)

  2542.         {

  2543.             return connection_ptr;

  2544.         }

  2545.     }

  2546. 

  2547.     return NULL;

  2548. }

  2549. 

  2550. static

  2551. bool

  2552. jack_controller_patchbay_connect(

  2553.     struct jack_dbus_method_call *dbus_call_ptr,

  2554.     struct jack_controller *controller_ptr,

  2555.     struct jack_graph_port *port1_ptr,

  2556.     struct jack_graph_port *port2_ptr)

  2557. {

  2558.     int ret;

  2559.     char port1_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  2560.     char port2_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  2561. 

  2562.     sprintf(port1_name, "%s:%s", port1_ptr->client->name, port1_ptr->name);

  2563.     sprintf(port2_name, "%s:%s", port2_ptr->client->name, port2_ptr->name);

  2564. 

  2565.     ret = jack_connect(controller_ptr->client, port1_name, port2_name);

  2566.     if (ret != 0)

  2567.     {

  2568.         jack_dbus_error(dbus_call_ptr, JACK_DBUS_ERROR_GENERIC, "jack_connect() failed with %d", ret);

  2569.         return false;

  2570.     }

  2571. 

  2572.     return true;

  2573. }

  2574. 

  2575. static

  2576. bool

  2577. jack_controller_patchbay_disconnect(

  2578.     struct jack_dbus_method_call *dbus_call_ptr,

  2579.     struct jack_controller *controller_ptr,

  2580.     struct jack_graph_port *port1_ptr,

  2581.     struct jack_graph_port *port2_ptr)

  2582. {

  2583.     int ret;

  2584.     char port1_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  2585.     char port2_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  2586. 

  2587.     sprintf(port1_name, "%s:%s", port1_ptr->client->name, port1_ptr->name);

  2588.     sprintf(port2_name, "%s:%s", port2_ptr->client->name, port2_ptr->name);

  2589. 

  2590.     ret = jack_disconnect(controller_ptr->client, port1_name, port2_name);

  2591.     if (ret != 0)

  2592.     {

  2593.         jack_dbus_error(dbus_call_ptr, JACK_DBUS_ERROR_GENERIC, "jack_connect() failed with %d", ret);

  2594.         return false;

  2595.     }

  2596. 

  2597.     return true;

  2598. }

  2599. 

  2600. #define controller_ptr ((struct jack_controller *)call->context)

  2601. #define patchbay_ptr ((struct jack_controller_patchbay *)controller_ptr->patchbay_context)

  2602. 

  2603. static

  2604. void

  2605. jack_controller_dbus_get_all_ports(

  2606.     struct jack_dbus_method_call * call)

  2607. {

  2608.     struct list_head * client_node_ptr;

  2609.     struct list_head * port_node_ptr;

  2610.     struct jack_graph_client * client_ptr;

  2611.     struct jack_graph_port * port_ptr;

  2612.     DBusMessageIter iter, sub_iter;

  2613.     char fullname[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  2614.     char *fullname_var = fullname;

  2615. 

  2616.     if (!controller_ptr->started)

  2617.     {

  2618.         jack_dbus_error(

  2619.             call,

  2620.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  2621.             "Can't execute this method with stopped JACK server");

  2622.         return;

  2623.     }

  2624. 

  2625.     call->reply = dbus_message_new_method_return (call->message);

  2626.     if (!call->reply)

  2627.     {

  2628.         goto fail;

  2629.     }

  2630. 

  2631.     dbus_message_iter_init_append (call->reply, &iter);

  2632. 

  2633.     if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &sub_iter))

  2634.     {

  2635.         goto fail_unref;

  2636.     }

  2637. 

  2638.     pthread_mutex_lock(&patchbay_ptr->lock);

  2639. 

  2640.     list_for_each(client_node_ptr, &patchbay_ptr->graph.clients)

  2641.     {

  2642.         client_ptr = list_entry(client_node_ptr, struct jack_graph_client, siblings);

  2643. 

  2644.         list_for_each(port_node_ptr, &client_ptr->ports)

  2645.         {

  2646.             port_ptr = list_entry(port_node_ptr, struct jack_graph_port, siblings_client);

  2647. 

  2648.             jack_info("%s:%s", client_ptr->name, port_ptr->name);

  2649.             sprintf(fullname, "%s:%s", client_ptr->name, port_ptr->name);

  2650.             if (!dbus_message_iter_append_basic (&sub_iter, DBUS_TYPE_STRING, &fullname_var))

  2651.             {

  2652.                 pthread_mutex_unlock(&patchbay_ptr->lock);

  2653.                 dbus_message_iter_close_container (&iter, &sub_iter);

  2654.                 goto fail_unref;

  2655.             }

  2656.         }

  2657.     }

  2658. 

  2659.     pthread_mutex_unlock(&patchbay_ptr->lock);

  2660. 

  2661.     if (!dbus_message_iter_close_container (&iter, &sub_iter))

  2662.     {

  2663.         goto fail_unref;

  2664.     }

  2665. 

  2666.     return;

  2667. 

  2668. fail_unref:

  2669.     dbus_message_unref (call->reply);

  2670.     call->reply = NULL;

  2671. 

  2672. fail:

  2673.     jack_error ("Ran out of memory trying to construct method return");

  2674. }

  2675. 

  2676. static

  2677. void

  2678. jack_controller_dbus_get_graph(

  2679.     struct jack_dbus_method_call * call)

  2680. {

  2681.     struct list_head * client_node_ptr;

  2682.     struct list_head * port_node_ptr;

  2683.     struct list_head * connection_node_ptr;

  2684.     struct jack_graph_client * client_ptr;

  2685.     struct jack_graph_port * port_ptr;

  2686.     struct jack_graph_connection * connection_ptr;

  2687.     DBusMessageIter iter;

  2688.     DBusMessageIter clients_array_iter;

  2689.     DBusMessageIter client_struct_iter;

  2690.     DBusMessageIter ports_array_iter;

  2691.     DBusMessageIter port_struct_iter;

  2692.     dbus_uint64_t version;

  2693.     DBusMessageIter connections_array_iter;

  2694.     DBusMessageIter connection_struct_iter;

  2695. 

  2696.     if (!controller_ptr->started)

  2697.     {

  2698.         jack_dbus_error(

  2699.             call,

  2700.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  2701.             "Can't execute this method with stopped JACK server");

  2702.         return;

  2703.     }

  2704. 

  2705.     if (!jack_dbus_get_method_args(call, DBUS_TYPE_UINT64, &version, DBUS_TYPE_INVALID))

  2706.     {

  2707.         /* The method call had invalid arguments meaning that

  2708.          * jack_dbus_get_method_args() has constructed an error for us.

  2709.          */

  2710.         goto exit;

  2711.     }

  2712. 

  2713.     //jack_info("Getting graph, know version is %" PRIu32, version);

  2714. 

  2715.     call->reply = dbus_message_new_method_return(call->message);

  2716.     if (!call->reply)

  2717.     {

  2718.         jack_error("Ran out of memory trying to construct method return");

  2719.         goto exit;

  2720.     }

  2721. 

  2722.     dbus_message_iter_init_append (call->reply, &iter);

  2723. 

  2724.     pthread_mutex_lock(&patchbay_ptr->lock);

  2725. 

  2726.     if (version > patchbay_ptr->graph.version)

  2727.     {

  2728.         jack_dbus_error(

  2729.             call,

  2730.             JACK_DBUS_ERROR_INVALID_ARGS,

  2731.             "known graph version %" PRIu64 " is newer than actual version %" PRIu64,

  2732.             version,

  2733.             patchbay_ptr->graph.version);

  2734.         pthread_mutex_unlock(&patchbay_ptr->lock);

  2735.         goto exit;

  2736.     }

  2737. 

  2738.     if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT64, &patchbay_ptr->graph.version))

  2739.     {

  2740.         goto nomem_unlock;

  2741.     }

  2742. 

  2743.     if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tsa(tsuu))", &clients_array_iter))

  2744.     {

  2745.         goto nomem_unlock;

  2746.     }

  2747. 

  2748.     if (version < patchbay_ptr->graph.version)

  2749.     {

  2750.         list_for_each(client_node_ptr, &patchbay_ptr->graph.clients)

  2751.         {

  2752.             client_ptr = list_entry(client_node_ptr, struct jack_graph_client, siblings);

  2753. 

  2754.             if (!dbus_message_iter_open_container (&clients_array_iter, DBUS_TYPE_STRUCT, NULL, &client_struct_iter))

  2755.             {

  2756.                 goto nomem_close_clients_array;

  2757.             }

  2758. 

  2759.             if (!dbus_message_iter_append_basic(&client_struct_iter, DBUS_TYPE_UINT64, &client_ptr->id))

  2760.             {

  2761.                 goto nomem_close_client_struct;

  2762.             }

  2763. 

  2764.             if (!dbus_message_iter_append_basic(&client_struct_iter, DBUS_TYPE_STRING, &client_ptr->name))

  2765.             {

  2766.                 goto nomem_close_client_struct;

  2767.             }

  2768. 

  2769.             if (!dbus_message_iter_open_container(&client_struct_iter, DBUS_TYPE_ARRAY, "(tsuu)", &ports_array_iter))

  2770.             {

  2771.                 goto nomem_close_client_struct;

  2772.             }

  2773. 

  2774.             list_for_each(port_node_ptr, &client_ptr->ports)

  2775.             {

  2776.                 port_ptr = list_entry(port_node_ptr, struct jack_graph_port, siblings_client);

  2777. 

  2778.                 if (!dbus_message_iter_open_container(&ports_array_iter, DBUS_TYPE_STRUCT, NULL, &port_struct_iter))

  2779.                 {

  2780.                     goto nomem_close_ports_array;

  2781.                 }

  2782. 

  2783.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT64, &port_ptr->id))

  2784.                 {

  2785.                     goto nomem_close_port_struct;

  2786.                 }

  2787. 

  2788.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_STRING, &port_ptr->name))

  2789.                 {

  2790.                     goto nomem_close_port_struct;

  2791.                 }

  2792. 

  2793.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT32, &port_ptr->flags))

  2794.                 {

  2795.                     goto nomem_close_port_struct;

  2796.                 }

  2797. 

  2798.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT32, &port_ptr->type))

  2799.                 {

  2800.                     goto nomem_close_port_struct;

  2801.                 }

  2802. 

  2803.                 if (!dbus_message_iter_close_container(&ports_array_iter, &port_struct_iter))

  2804.                 {

  2805.                     goto nomem_close_ports_array;

  2806.                 }

  2807.             }

  2808. 

  2809.             if (!dbus_message_iter_close_container(&client_struct_iter, &ports_array_iter))

  2810.             {

  2811.                 goto nomem_close_client_struct;

  2812.             }

  2813. 

  2814.             if (!dbus_message_iter_close_container(&clients_array_iter, &client_struct_iter))

  2815.             {

  2816.                 goto nomem_close_clients_array;

  2817.             }

  2818.         }

  2819.     }

  2820. 

  2821.     if (!dbus_message_iter_close_container(&iter, &clients_array_iter))

  2822.     {

  2823.         goto nomem_unlock;

  2824.     }

  2825. 

  2826.     if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tstststst)", &connections_array_iter))

  2827.     {

  2828.         goto nomem_unlock;

  2829.     }

  2830. 

  2831.     if (version < patchbay_ptr->graph.version)

  2832.     {

  2833.         list_for_each(connection_node_ptr, &patchbay_ptr->graph.connections)

  2834.         {

  2835.             connection_ptr = list_entry(connection_node_ptr, struct jack_graph_connection, siblings);

  2836. 

  2837.             if (!dbus_message_iter_open_container(&connections_array_iter, DBUS_TYPE_STRUCT, NULL, &connection_struct_iter))

  2838.             {

  2839.                 goto nomem_close_connections_array;

  2840.             }

  2841. 

  2842.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port1->client->id))

  2843.             {

  2844.                 goto nomem_close_connection_struct;

  2845.             }

  2846. 

  2847.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port1->client->name))

  2848.             {

  2849.                 goto nomem_close_connection_struct;

  2850.             }

  2851. 

  2852.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port1->id))

  2853.             {

  2854.                 goto nomem_close_connection_struct;

  2855.             }

  2856. 

  2857.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port1->name))

  2858.             {

  2859.                 goto nomem_close_connection_struct;

  2860.             }

  2861. 

  2862.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port2->client->id))

  2863.             {

  2864.                 goto nomem_close_connection_struct;

  2865.             }

  2866. 

  2867.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port2->client->name))

  2868.             {

  2869.                 goto nomem_close_connection_struct;

  2870.             }

  2871. 

  2872.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port2->id))

  2873.             {

  2874.                 goto nomem_close_connection_struct;

  2875.             }

  2876. 

  2877.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port2->name))

  2878.             {

  2879.                 goto nomem_close_connection_struct;

  2880.             }

  2881. 

  2882.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->id))

  2883.             {

  2884.                 goto nomem_close_connection_struct;

  2885.             }

  2886. 

  2887.             if (!dbus_message_iter_close_container(&connections_array_iter, &connection_struct_iter))

  2888.             {

  2889.                 goto nomem_close_connections_array;

  2890.             }

  2891.         }

  2892.     }

  2893. 

  2894.     if (!dbus_message_iter_close_container(&iter, &connections_array_iter))

  2895.     {

  2896.         goto nomem_unlock;

  2897.     }

  2898. 

  2899.     pthread_mutex_unlock(&patchbay_ptr->lock);

  2900. 

  2901.     return;

  2902. 

  2903. nomem_close_connection_struct:

  2904.     dbus_message_iter_close_container(&connections_array_iter, &connection_struct_iter);

  2905. 

  2906. nomem_close_connections_array:

  2907.     dbus_message_iter_close_container(&iter, &connections_array_iter);

  2908.     goto nomem_unlock;

  2909. 

  2910. nomem_close_port_struct:

  2911.     dbus_message_iter_close_container(&ports_array_iter, &port_struct_iter);

  2912. 

  2913. nomem_close_ports_array:

  2914.     dbus_message_iter_close_container(&client_struct_iter, &ports_array_iter);

  2915. 

  2916. nomem_close_client_struct:

  2917.     dbus_message_iter_close_container(&clients_array_iter, &client_struct_iter);

  2918. 

  2919. nomem_close_clients_array:

  2920.     dbus_message_iter_close_container(&iter, &clients_array_iter);

  2921. 

  2922. nomem_unlock:

  2923.     pthread_mutex_unlock(&patchbay_ptr->lock);

  2924. 

  2925. //nomem:

  2926.     dbus_message_unref(call->reply);

  2927.     call->reply = NULL;

  2928.     jack_error("Ran out of memory trying to construct method return");

  2929. 

  2930. exit:

  2931.     return;

  2932. }

  2933. 

  2934. static

  2935. void

  2936. jack_controller_dbus_connect_ports_by_name(

  2937.     struct jack_dbus_method_call * call)

  2938. {

  2939.     const char * client1_name;

  2940.     const char * port1_name;

  2941.     const char * client2_name;

  2942.     const char * port2_name;

  2943.     struct jack_graph_port *port1_ptr;

  2944.     struct jack_graph_port *port2_ptr;

  2945. 

  2946. /*  jack_info("jack_controller_dbus_connect_ports_by_name() called."); */

  2947. 

  2948.     if (!controller_ptr->started)

  2949.     {

  2950.         jack_dbus_error(

  2951.             call,

  2952.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  2953.             "Can't execute this method with stopped JACK server");

  2954.         return;

  2955.     }

  2956. 

  2957.     if (!jack_dbus_get_method_args(

  2958.             call,

  2959.             DBUS_TYPE_STRING,

  2960.             &client1_name,

  2961.             DBUS_TYPE_STRING,

  2962.             &port1_name,

  2963.             DBUS_TYPE_STRING,

  2964.             &client2_name,

  2965.             DBUS_TYPE_STRING,

  2966.             &port2_name,

  2967.             DBUS_TYPE_INVALID))

  2968.     {

  2969.         /* The method call had invalid arguments meaning that

  2970.          * jack_dbus_get_method_args() has constructed an error for us.

  2971.          */

  2972.         return;

  2973.     }

  2974. 

  2975. /*  jack_info("connecting %s:%s and %s:%s", client1_name, port1_name, client2_name, port2_name); */

  2976. 

  2977.     pthread_mutex_lock(&patchbay_ptr->lock);

  2978. 

  2979.     port1_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client1_name, port1_name);

  2980.     if (port1_ptr == NULL)

  2981.     {

  2982.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client1_name, port1_name);

  2983.         goto unlock;

  2984.     }

  2985. 

  2986.     port2_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client2_name, port2_name);

  2987.     if (port2_ptr == NULL)

  2988.     {

  2989.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client2_name, port2_name);

  2990.         goto unlock;

  2991.     }

  2992. 

  2993.     if (!jack_controller_patchbay_connect(

  2994.             call,

  2995.             controller_ptr,

  2996.             port1_ptr,

  2997.             port2_ptr))

  2998.     {

  2999.         /* jack_controller_patchbay_connect() constructed error reply */

  3000.         goto unlock;

  3001.     }

  3002. 

  3003.     jack_dbus_construct_method_return_empty(call);

  3004. 

  3005. unlock:

  3006.     pthread_mutex_unlock(&patchbay_ptr->lock);

  3007. }

  3008. 

  3009. static

  3010. void

  3011. jack_controller_dbus_connect_ports_by_id(

  3012.     struct jack_dbus_method_call * call)

  3013. {

  3014.     dbus_uint64_t port1_id;

  3015.     dbus_uint64_t port2_id;

  3016.     struct jack_graph_port *port1_ptr;

  3017.     struct jack_graph_port *port2_ptr;

  3018. 

  3019. /*     jack_info("jack_controller_dbus_connect_ports_by_id() called."); */

  3020. 

  3021.     if (!controller_ptr->started)

  3022.     {

  3023.         jack_dbus_error(

  3024.             call,

  3025.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  3026.             "Can't execute this method with stopped JACK server");

  3027.         return;

  3028.     }

  3029. 

  3030.     if (!jack_dbus_get_method_args(

  3031.             call,

  3032.             DBUS_TYPE_UINT64,

  3033.             &port1_id,

  3034.             DBUS_TYPE_UINT64,

  3035.             &port2_id,

  3036.             DBUS_TYPE_INVALID))

  3037.     {

  3038.         /* The method call had invalid arguments meaning that

  3039.          * jack_dbus_get_method_args() has constructed an error for us.

  3040.          */

  3041.         return;

  3042.     }

  3043. 

  3044.     pthread_mutex_lock(&patchbay_ptr->lock);

  3045. 

  3046.     port1_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port1_id);

  3047.     if (port1_ptr == NULL)

  3048.     {

  3049.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port1_id);

  3050.         goto unlock;

  3051.     }

  3052. 

  3053.     port2_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port2_id);

  3054.     if (port2_ptr == NULL)

  3055.     {

  3056.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port2_id);

  3057.         goto unlock;

  3058.     }

  3059. 

  3060.     if (!jack_controller_patchbay_connect(

  3061.             call,

  3062.             controller_ptr,

  3063.             port1_ptr,

  3064.             port2_ptr))

  3065.     {

  3066.         /* jack_controller_patchbay_connect() constructed error reply */

  3067.         goto unlock;

  3068.     }

  3069. 

  3070.     jack_dbus_construct_method_return_empty(call);

  3071. 

  3072. unlock:

  3073.     pthread_mutex_unlock(&patchbay_ptr->lock);

  3074. }

  3075. 

  3076. static

  3077. void

  3078. jack_controller_dbus_disconnect_ports_by_name(

  3079.     struct jack_dbus_method_call * call)

  3080. {

  3081.     const char * client1_name;

  3082.     const char * port1_name;

  3083.     const char * client2_name;

  3084.     const char * port2_name;

  3085.     struct jack_graph_port *port1_ptr;

  3086.     struct jack_graph_port *port2_ptr;

  3087. 

  3088. /*  jack_info("jack_controller_dbus_disconnect_ports_by_name() called."); */

  3089. 

  3090.     if (!controller_ptr->started)

  3091.     {

  3092.         jack_dbus_error(

  3093.             call,

  3094.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  3095.             "Can't execute this method with stopped JACK server");

  3096.         return;

  3097.     }

  3098. 

  3099.     if (!jack_dbus_get_method_args(

  3100.             call,

  3101.             DBUS_TYPE_STRING,

  3102.             &client1_name,

  3103.             DBUS_TYPE_STRING,

  3104.             &port1_name,

  3105.             DBUS_TYPE_STRING,

  3106.             &client2_name,

  3107.             DBUS_TYPE_STRING,

  3108.             &port2_name,

  3109.             DBUS_TYPE_INVALID))

  3110.     {

  3111.         /* The method call had invalid arguments meaning that

  3112.          * jack_dbus_get_method_args() has constructed an error for us.

  3113.          */

  3114.         return;

  3115.     }

  3116. 

  3117. /*  jack_info("disconnecting %s:%s and %s:%s", client1_name, port1_name, client2_name, port2_name); */

  3118. 

  3119.     pthread_mutex_lock(&patchbay_ptr->lock);

  3120. 

  3121.     port1_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client1_name, port1_name);

  3122.     if (port1_ptr == NULL)

  3123.     {

  3124.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client1_name, port1_name);

  3125.         goto unlock;

  3126.     }

  3127. 

  3128.     port2_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client2_name, port2_name);

  3129.     if (port2_ptr == NULL)

  3130.     {

  3131.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client2_name, port2_name);

  3132.         goto unlock;

  3133.     }

  3134. 

  3135.     if (!jack_controller_patchbay_disconnect(

  3136.             call,

  3137.             controller_ptr,

  3138.             port1_ptr,

  3139.             port2_ptr))

  3140.     {

  3141.         /* jack_controller_patchbay_connect() constructed error reply */

  3142.         goto unlock;

  3143.     }

  3144. 

  3145.     jack_dbus_construct_method_return_empty(call);

  3146. 

  3147. unlock:

  3148.     pthread_mutex_unlock(&patchbay_ptr->lock);

  3149. }

  3150. 

  3151. static

  3152. void

  3153. jack_controller_dbus_disconnect_ports_by_id(

  3154.     struct jack_dbus_method_call * call)

  3155. {

  3156.     dbus_uint64_t port1_id;

  3157.     dbus_uint64_t port2_id;

  3158.     struct jack_graph_port *port1_ptr;

  3159.     struct jack_graph_port *port2_ptr;

  3160. 

  3161. /*     jack_info("jack_controller_dbus_disconnect_ports_by_id() called."); */

  3162. 

  3163.     if (!controller_ptr->started)

  3164.     {

  3165.         jack_dbus_error(

  3166.             call,

  3167.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  3168.             "Can't execute this method with stopped JACK server");

  3169.         return;

  3170.     }

  3171. 

  3172.     if (!jack_dbus_get_method_args(

  3173.             call,

  3174.             DBUS_TYPE_UINT64,

  3175.             &port1_id,

  3176.             DBUS_TYPE_UINT64,

  3177.             &port2_id,

  3178.             DBUS_TYPE_INVALID))

  3179.     {

  3180.         /* The method call had invalid arguments meaning that

  3181.          * jack_dbus_get_method_args() has constructed an error for us.

  3182.          */

  3183.         return;

  3184.     }

  3185. 

  3186.     pthread_mutex_lock(&patchbay_ptr->lock);

  3187. 

  3188.     port1_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port1_id);

  3189.     if (port1_ptr == NULL)

  3190.     {

  3191.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port1_id);

  3192.         return;

  3193.     }

  3194. 

  3195.     port2_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port2_id);

  3196.     if (port2_ptr == NULL)

  3197.     {

  3198.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port2_id);

  3199.         return;

  3200.     }

  3201. 

  3202.     if (!jack_controller_patchbay_disconnect(

  3203.             call,

  3204.             controller_ptr,

  3205.             port1_ptr,

  3206.             port2_ptr))

  3207.     {

  3208.         /* jack_controller_patchbay_connect() constructed error reply */

  3209.         goto unlock;

  3210.     }

  3211. 

  3212.     jack_dbus_construct_method_return_empty(call);

  3213. 

  3214. unlock:

  3215.     pthread_mutex_unlock(&patchbay_ptr->lock);

  3216. }

  3217. 

  3218. static

  3219. void

  3220. jack_controller_dbus_disconnect_ports_by_connection_id(

  3221.     struct jack_dbus_method_call * call)

  3222. {

  3223.     dbus_uint64_t connection_id;

  3224.     struct jack_graph_connection *connection_ptr;

  3225. 

  3226. /*     jack_info("jack_controller_dbus_disconnect_ports_by_id() called."); */

  3227. 

  3228.     if (!jack_dbus_get_method_args(

  3229.             call,

  3230.             DBUS_TYPE_UINT64,

  3231.             &connection_id,

  3232.             DBUS_TYPE_INVALID))

  3233.     {

  3234.         /* The method call had invalid arguments meaning that

  3235.          * jack_dbus_get_method_args() has constructed an error for us.

  3236.          */

  3237.         return;

  3238.     }

  3239. 

  3240.     pthread_mutex_lock(&patchbay_ptr->lock);

  3241. 

  3242.     connection_ptr = jack_controller_patchbay_find_connection_by_id(patchbay_ptr, connection_id);

  3243.     if (connection_ptr == NULL)

  3244.     {

  3245.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find connection %" PRIu64, connection_id);

  3246.         goto unlock;

  3247.     }

  3248. 

  3249.     if (!jack_controller_patchbay_disconnect(

  3250.             call,

  3251.             controller_ptr,

  3252.             connection_ptr->port1,

  3253.             connection_ptr->port2))

  3254.     {

  3255.         /* jack_controller_patchbay_connect() constructed error reply */

  3256.         goto unlock;

  3257.     }

  3258. 

  3259.     jack_dbus_construct_method_return_empty(call);

  3260. 

  3261. unlock:

  3262.     pthread_mutex_unlock(&patchbay_ptr->lock);

  3263. }

  3264. 

  3265. static

  3266. void

  3267. jack_controller_dbus_get_client_pid(

  3268.     struct jack_dbus_method_call * call)

  3269. {

  3270.     dbus_uint64_t client_id;

  3271.     struct jack_graph_client *client_ptr;

  3272.     message_arg_t arg;

  3273. 

  3274. /*     jack_info("jack_controller_dbus_get_client_pid() called."); */

  3275. 

  3276.     if (!jack_dbus_get_method_args(

  3277.             call,

  3278.             DBUS_TYPE_UINT64,

  3279.             &client_id,

  3280.             DBUS_TYPE_INVALID))

  3281.     {

  3282.         /* The method call had invalid arguments meaning that

  3283.          * jack_dbus_get_method_args() has constructed an error for us.

  3284.          */

  3285.         return;

  3286.     }

  3287. 

  3288.     pthread_mutex_lock(&patchbay_ptr->lock);

  3289. 

  3290.     client_ptr = jack_controller_patchbay_find_client_by_id(patchbay_ptr, client_id);

  3291.     if (client_ptr == NULL)

  3292.     {

  3293.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find client %" PRIu64, client_id);

  3294.         goto unlock;

  3295.     }

  3296. 

  3297.     arg.int64 = client_ptr->pid;

  3298. 

  3299.     jack_dbus_construct_method_return_single(call, DBUS_TYPE_INT64, arg);

  3300. 

  3301. unlock:

  3302.     pthread_mutex_unlock(&patchbay_ptr->lock);

  3303. }

  3304. 

  3305. #undef controller_ptr

  3306. #define controller_ptr ((struct jack_controller *)context)

  3307. 

  3308. static

  3309. int

  3310. jack_controller_graph_order_callback(

  3311.     void *context)

  3312. {

  3313.     const char **ports;

  3314.     int i;

  3315.     jack_port_t *port_ptr;

  3316.     

  3317.     if (patchbay_ptr->graph.version > 1)

  3318.     {

  3319.         /* we use this only for initial catchup */

  3320.         return 0;

  3321.     }

  3322.     

  3323.     ports = jack_get_ports(controller_ptr->client, NULL, NULL, 0);

  3324.     if (ports)

  3325.     {

  3326.         for (i = 0;  ports[i]; ++i)

  3327.         {

  3328.             jack_info("graph reorder: new port '%s'", ports[i]);

  3329.             port_ptr = jack_port_by_name(controller_ptr->client, ports[i]);;

  3330.             jack_controller_patchbay_new_port(patchbay_ptr, ports[i], jack_port_flags(port_ptr), jack_port_type_id(port_ptr));

  3331.         }

  3332. 

  3333.         free(ports);

  3334.     }

  3335. 

  3336.     if (patchbay_ptr->graph.version == 1)

  3337.     {

  3338.         /* we have empty initial graph, increment graph version,

  3339.            so we dont do jack_get_ports() again,

  3340.            on next next graph change */

  3341.         patchbay_ptr->graph.version++;

  3342.     }

  3343. 

  3344.     return 0;

  3345. }

  3346. 

  3347. void

  3348. jack_controller_client_registration_callback(

  3349.     const char *client_name,

  3350.     int created,

  3351.     void *context)

  3352. {

  3353.     if (created)

  3354.     {

  3355.         jack_log("client '%s' created", client_name);

  3356.         jack_controller_patchbay_create_client(patchbay_ptr, client_name, strlen(client_name));

  3357.     }

  3358.     else

  3359.     {

  3360.         jack_log("client '%s' destroyed", client_name);

  3361.         jack_controller_patchbay_destroy_client_by_name(patchbay_ptr, client_name);

  3362.     }

  3363. }

  3364. 

  3365. void

  3366. jack_controller_port_registration_callback(

  3367.     jack_port_id_t port_id,

  3368.     int created,

  3369.     void *context)

  3370. {

  3371.     jack_port_t *port_ptr;

  3372.     struct jack_graph_port *graph_port_ptr;

  3373.     const char *port_name;

  3374. 

  3375.     port_ptr = jack_port_by_id(controller_ptr->client, port_id);

  3376.     port_name = jack_port_name(port_ptr);

  3377. 

  3378.     if (created)

  3379.     {

  3380.         jack_log("port '%s' created", port_name);

  3381.         jack_controller_patchbay_new_port(patchbay_ptr, port_name, jack_port_flags(port_ptr), jack_port_type_id(port_ptr));

  3382.     }

  3383.     else

  3384.     {

  3385.         jack_log("port '%s' destroyed", port_name);

  3386.         graph_port_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port_name);

  3387.         if (graph_port_ptr == NULL)

  3388.         {

  3389.             jack_error("Failed to find port '%s' to destroy", port_name);

  3390.             return;

  3391.         }

  3392. 

  3393.         jack_controller_patchbay_remove_port(patchbay_ptr, graph_port_ptr);

  3394.     }

  3395. }

  3396. 

  3397. void

  3398. jack_controller_port_connect_callback(

  3399.     jack_port_id_t port1_id,

  3400.     jack_port_id_t port2_id,

  3401.     int connect,

  3402.     void *context)

  3403. {

  3404.     jack_port_t *port1;

  3405.     jack_port_t *port2;

  3406.     const char *port1_name;

  3407.     const char *port2_name;

  3408.     struct jack_graph_port *port1_ptr;

  3409.     struct jack_graph_port *port2_ptr;

  3410.     struct jack_graph_connection *connection_ptr;

  3411. 

  3412.     port1 = jack_port_by_id(controller_ptr->client, port1_id);

  3413.     port2 = jack_port_by_id(controller_ptr->client, port2_id);

  3414. 

  3415.     port1_name = jack_port_name(port1);

  3416.     port2_name = jack_port_name(port2);

  3417. 

  3418.     port1_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port1_name);

  3419.     if (port1_ptr == NULL)

  3420.     {

  3421.         jack_error("Failed to find port '%s' to [dis]connect", port1_name);

  3422.         return;

  3423.     }

  3424. 

  3425.     port2_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port2_name);

  3426.     if (port2_ptr == NULL)

  3427.     {

  3428.         jack_error("Failed to find port '%s' to [dis]connect", port2_name);

  3429.         return;

  3430.     }

  3431. 

  3432.     if (connect)

  3433.     {

  3434.         jack_info("Connecting '%s' to '%s'", port1_name, port2_name);

  3435.         connection_ptr = jack_controller_patchbay_find_connection(patchbay_ptr, port1_ptr, port2_ptr);

  3436.         if (connection_ptr != NULL)

  3437.         {

  3438.             jack_error("'%s' and '%s' are already connected", port1_name, port2_name);

  3439.             return;

  3440.         }

  3441. 

  3442.         jack_controller_patchbay_create_connection(patchbay_ptr, port1_ptr, port2_ptr);

  3443.     }

  3444.     else

  3445.     {

  3446.         jack_info("Disonnecting '%s' from '%s'", port1_name, port2_name);

  3447.         connection_ptr = jack_controller_patchbay_find_connection(patchbay_ptr, port1_ptr, port2_ptr);

  3448.         if (connection_ptr == NULL)

  3449.         {

  3450.             jack_error("Cannot find connection being removed");

  3451.             return;

  3452.         }

  3453. 

  3454.         jack_controller_patchbay_destroy_connection(patchbay_ptr, connection_ptr);

  3455.     }

  3456. }

  3457. 

  3458. #undef controller_ptr

  3459. 

  3460. void

  3461. jack_controller_patchbay_uninit(

  3462.     struct jack_controller * controller_ptr)

  3463. {

  3464.     struct jack_graph_client *client_ptr;

  3465.     struct jack_graph_port *port_ptr;

  3466. 

  3467. /*     jack_info("jack_controller_patchbay_uninit() called"); */

  3468. 

  3469.     while (!list_empty(&patchbay_ptr->graph.ports))

  3470.     {

  3471.         port_ptr = list_entry(patchbay_ptr->graph.ports.next, struct jack_graph_port, siblings_graph);

  3472.         jack_controller_patchbay_remove_port(patchbay_ptr, port_ptr);

  3473.     }

  3474. 

  3475.     while (!list_empty(&patchbay_ptr->graph.clients))

  3476.     {

  3477.         client_ptr = list_entry(patchbay_ptr->graph.clients.next, struct jack_graph_client, siblings);

  3478.         jack_controller_patchbay_destroy_client(patchbay_ptr, client_ptr);

  3479.     }

  3480. 

  3481.     pthread_mutex_destroy(&patchbay_ptr->lock);

  3482. }

  3483. 

  3484. #undef patchbay_ptr

  3485. 

  3486. bool

  3487. jack_controller_patchbay_init(

  3488.     struct jack_controller * controller_ptr)

  3489. {

  3490.     int ret;

  3491.     struct jack_controller_patchbay * patchbay_ptr;

  3492.     pthread_mutexattr_t attr;

  3493. 

  3494. /*     jack_info("jack_controller_patchbay_init() called"); */

  3495. 

  3496.     patchbay_ptr = malloc(sizeof(struct jack_controller_patchbay));

  3497.     if (patchbay_ptr == NULL)

  3498.     {

  3499.         jack_error("Memory allocation of jack_controller_patchbay structure failed.");

  3500.         goto fail;

  3501.     }

  3502. 

  3503.     ret = pthread_mutexattr_init(&attr);

  3504.     if (ret != 0)

  3505.     {

  3506.         goto fail;

  3507.     }

  3508. 

  3509.     ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

  3510.     if (ret != 0)

  3511.     {

  3512.         goto fail;

  3513.     }

  3514. 

  3515.     pthread_mutex_init(&patchbay_ptr->lock, &attr);

  3516.     INIT_LIST_HEAD(&patchbay_ptr->graph.clients);

  3517.     INIT_LIST_HEAD(&patchbay_ptr->graph.ports);

  3518.     INIT_LIST_HEAD(&patchbay_ptr->graph.connections);

  3519.     patchbay_ptr->graph.version = 1;

  3520.     patchbay_ptr->next_client_id = 1;

  3521.     patchbay_ptr->next_port_id = 1;

  3522.     patchbay_ptr->next_connection_id = 1;

  3523. 

  3524.     controller_ptr->patchbay_context = patchbay_ptr;

  3525. 

  3526.     ret = jack_set_graph_order_callback(controller_ptr->client, jack_controller_graph_order_callback, controller_ptr);

  3527.     if (ret != 0)

  3528.     {

  3529.         jack_error("jack_set_graph_order_callback() failed with error %d", ret);

  3530.         goto fail_uninit_mutex;

  3531.     }

  3532. 

  3533.     ret = jack_set_client_registration_callback(controller_ptr->client, jack_controller_client_registration_callback, controller_ptr);

  3534.     if (ret != 0)

  3535.     {

  3536.         jack_error("jack_set_client_registration_callback() failed with error %d", ret);

  3537.         goto fail_uninit_mutex;

  3538.     }

  3539. 

  3540.     ret = jack_set_port_registration_callback(controller_ptr->client, jack_controller_port_registration_callback, controller_ptr);

  3541.     if (ret != 0)

  3542.     {

  3543.         jack_error("jack_set_port_registration_callback() failed with error %d", ret);

  3544.         goto fail_uninit_mutex;

  3545.     }

  3546. 

  3547.     ret = jack_set_port_connect_callback(controller_ptr->client, jack_controller_port_connect_callback, controller_ptr);

  3548.     if (ret != 0)

  3549.     {

  3550.         jack_error("jack_set_port_connect_callback() failed with error %d", ret);

  3551.         goto fail_uninit_mutex;

  3552.     }

  3553. 

  3554.     return true;

  3555. 

  3556. fail_uninit_mutex:

  3557.     pthread_mutex_destroy(&patchbay_ptr->lock);

  3558. 

  3559. fail:

  3560.     return false;

  3561. }

  3562. 

  3563. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetAllPorts)

  3564.     JACK_DBUS_METHOD_ARGUMENT("ports_list", "as", true)

  3565. JACK_DBUS_METHOD_ARGUMENTS_END

  3566. 

  3567. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetGraph)

  3568.     JACK_DBUS_METHOD_ARGUMENT("known_graph_version", DBUS_TYPE_UINT64_AS_STRING, false)

  3569.     JACK_DBUS_METHOD_ARGUMENT("current_graph_version", DBUS_TYPE_UINT64_AS_STRING, true)

  3570.     JACK_DBUS_METHOD_ARGUMENT("clients_and_ports", "a(tsa(tsuu))", true)

  3571.     JACK_DBUS_METHOD_ARGUMENT("connections", "a(tstststst)", true)

  3572. JACK_DBUS_METHOD_ARGUMENTS_END

  3573. 

  3574. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(ConnectPortsByName)

  3575.     JACK_DBUS_METHOD_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING, false)

  3576.     JACK_DBUS_METHOD_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING, false)

  3577.     JACK_DBUS_METHOD_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING, false)

  3578.     JACK_DBUS_METHOD_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING, false)

  3579. JACK_DBUS_METHOD_ARGUMENTS_END

  3580. 

  3581. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(ConnectPortsByID)

  3582.     JACK_DBUS_METHOD_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING, false)

  3583.     JACK_DBUS_METHOD_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING, false)

  3584. JACK_DBUS_METHOD_ARGUMENTS_END

  3585. 

  3586. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByName)

  3587.     JACK_DBUS_METHOD_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING, false)

  3588.     JACK_DBUS_METHOD_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING, false)

  3589.     JACK_DBUS_METHOD_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING, false)

  3590.     JACK_DBUS_METHOD_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING, false)

  3591. JACK_DBUS_METHOD_ARGUMENTS_END

  3592. 

  3593. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByID)

  3594.     JACK_DBUS_METHOD_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING, false)

  3595.     JACK_DBUS_METHOD_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING, false)

  3596. JACK_DBUS_METHOD_ARGUMENTS_END

  3597. 

  3598. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByConnectionID)

  3599.     JACK_DBUS_METHOD_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING, false)

  3600. JACK_DBUS_METHOD_ARGUMENTS_END

  3601. 

  3602. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetClientPID)

  3603.     JACK_DBUS_METHOD_ARGUMENT("client_id", DBUS_TYPE_INT64_AS_STRING, false)

  3604. JACK_DBUS_METHOD_ARGUMENTS_END

  3605. 

  3606. JACK_DBUS_METHODS_BEGIN

  3607.     JACK_DBUS_METHOD_DESCRIBE(GetAllPorts, jack_controller_dbus_get_all_ports)

  3608.     JACK_DBUS_METHOD_DESCRIBE(GetGraph, jack_controller_dbus_get_graph)

  3609.     JACK_DBUS_METHOD_DESCRIBE(ConnectPortsByName, jack_controller_dbus_connect_ports_by_name)

  3610.     JACK_DBUS_METHOD_DESCRIBE(ConnectPortsByID, jack_controller_dbus_connect_ports_by_id)

  3611.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByName, jack_controller_dbus_disconnect_ports_by_name)

  3612.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByID, jack_controller_dbus_disconnect_ports_by_id)

  3613.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByConnectionID, jack_controller_dbus_disconnect_ports_by_connection_id)

  3614.     JACK_DBUS_METHOD_DESCRIBE(GetClientPID, jack_controller_dbus_get_client_pid)

  3615. JACK_DBUS_METHODS_END

  3616. 

  3617. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(GraphChanged)

  3618.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  3619. JACK_DBUS_SIGNAL_ARGUMENTS_END

  3620. 

  3621. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(ClientAppeared)

  3622.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  3623.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  3624.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  3625. JACK_DBUS_SIGNAL_ARGUMENTS_END

  3626. 

  3627. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(ClientDisappeared)

  3628.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  3629.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  3630.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  3631. JACK_DBUS_SIGNAL_ARGUMENTS_END

  3632. 

  3633. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortAppeared)

  3634.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  3635.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  3636.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  3637.     JACK_DBUS_SIGNAL_ARGUMENT("port_id", DBUS_TYPE_UINT64_AS_STRING)

  3638.     JACK_DBUS_SIGNAL_ARGUMENT("port_name", DBUS_TYPE_STRING_AS_STRING)

  3639.     JACK_DBUS_SIGNAL_ARGUMENT("port_flags", DBUS_TYPE_UINT32_AS_STRING)

  3640.     JACK_DBUS_SIGNAL_ARGUMENT("port_type", DBUS_TYPE_UINT32_AS_STRING)

  3641. JACK_DBUS_SIGNAL_ARGUMENTS_END

  3642. 

  3643. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortDisappeared)

  3644.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  3645.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  3646.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  3647.     JACK_DBUS_SIGNAL_ARGUMENT("port_id", DBUS_TYPE_UINT64_AS_STRING)

  3648.     JACK_DBUS_SIGNAL_ARGUMENT("port_name", DBUS_TYPE_STRING_AS_STRING)

  3649. JACK_DBUS_SIGNAL_ARGUMENTS_END

  3650. 

  3651. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortsConnected)

  3652.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  3653.     JACK_DBUS_SIGNAL_ARGUMENT("client1_id", DBUS_TYPE_UINT64_AS_STRING)

  3654.     JACK_DBUS_SIGNAL_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING)

  3655.     JACK_DBUS_SIGNAL_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING)

  3656.     JACK_DBUS_SIGNAL_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING)

  3657.     JACK_DBUS_SIGNAL_ARGUMENT("client2_id", DBUS_TYPE_UINT64_AS_STRING)

  3658.     JACK_DBUS_SIGNAL_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING)

  3659.     JACK_DBUS_SIGNAL_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING)

  3660.     JACK_DBUS_SIGNAL_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING)

  3661.     JACK_DBUS_SIGNAL_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING)

  3662. JACK_DBUS_SIGNAL_ARGUMENTS_END

  3663. 

  3664. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortsDisconnected)

  3665.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  3666.     JACK_DBUS_SIGNAL_ARGUMENT("client1_id", DBUS_TYPE_UINT64_AS_STRING)

  3667.     JACK_DBUS_SIGNAL_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING)

  3668.     JACK_DBUS_SIGNAL_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING)

  3669.     JACK_DBUS_SIGNAL_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING)

  3670.     JACK_DBUS_SIGNAL_ARGUMENT("client2_id", DBUS_TYPE_UINT64_AS_STRING)

  3671.     JACK_DBUS_SIGNAL_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING)

  3672.     JACK_DBUS_SIGNAL_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING)

  3673.     JACK_DBUS_SIGNAL_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING)

  3674.     JACK_DBUS_SIGNAL_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING)

  3675. JACK_DBUS_SIGNAL_ARGUMENTS_END

  3676. 

  3677. JACK_DBUS_SIGNALS_BEGIN

  3678.     JACK_DBUS_SIGNAL_DESCRIBE(GraphChanged)

  3679.     JACK_DBUS_SIGNAL_DESCRIBE(ClientAppeared)

  3680.     JACK_DBUS_SIGNAL_DESCRIBE(ClientDisappeared)

  3681.     JACK_DBUS_SIGNAL_DESCRIBE(PortAppeared)

  3682.     JACK_DBUS_SIGNAL_DESCRIBE(PortDisappeared)

  3683.     JACK_DBUS_SIGNAL_DESCRIBE(PortsConnected)

  3684.     JACK_DBUS_SIGNAL_DESCRIBE(PortsDisconnected)

  3685. JACK_DBUS_SIGNALS_END

  3686. 

  3687. JACK_DBUS_IFACE_BEGIN(g_jack_controller_iface_patchbay, JACK_DBUS_IFACE_NAME)

  3688.     JACK_DBUS_IFACE_EXPOSE_METHODS

  3689.     JACK_DBUS_IFACE_EXPOSE_SIGNALS

  3690. JACK_DBUS_IFACE_END

  3691. /* -*- Mode: C ; c-basic-offset: 4 -*- */

  3692. /*

  3693.     Copyright (C) 2008 Nedko Arnaudov

  3694.     Copyright (C) 2008 Juuso Alasuutari

  3695. 

  3696.     This program is free software; you can redistribute it and/or modify

  3697.     it under the terms of the GNU General Public License as published by

  3698.     the Free Software Foundation; either version 2 of the License.

  3699. 

  3700.     This program is distributed in the hope that it will be useful,

  3701.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  3702.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  3703.     GNU General Public License for more details.

  3704. 

  3705.     You should have received a copy of the GNU General Public License

  3706.     along with this program; if not, write to the Free Software

  3707.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  3708. 

  3709. */

  3710. 

  3711. #define _GNU_SOURCE            /* PTHREAD_MUTEX_RECURSIVE */

  3712. 

  3713. #include <stdint.h>

  3714. #include <inttypes.h>

  3715. #include <string.h>

  3716. #include <stdio.h>

  3717. #include <assert.h>

  3718. #include <dbus/dbus.h>

  3719. #include <pthread.h>

  3720. 

  3721. #include "jackdbus.h"

  3722. #include "controller_internal.h"

  3723. #include "list.h"

  3724. 

  3725. #define JACK_DBUS_IFACE_NAME "org.jackaudio.JackPatchbay"

  3726. 

  3727. /* FIXME: these need to be retrieved from common headers */

  3728. #define JACK_CLIENT_NAME_SIZE 64

  3729. #define JACK_PORT_NAME_SIZE 256

  3730. 

  3731. struct jack_graph

  3732. {

  3733.     uint64_t version;

  3734.     struct list_head clients;

  3735.     struct list_head ports;

  3736.     struct list_head connections;

  3737. };

  3738. 

  3739. struct jack_graph_client

  3740. {

  3741.     uint64_t id;

  3742.     char * name;

  3743.     int pid;

  3744.     struct list_head siblings;

  3745.     struct list_head ports;

  3746. };

  3747. 

  3748. struct jack_graph_port

  3749. {

  3750.     uint64_t id;

  3751.     char * name;

  3752.     uint32_t flags;

  3753.     uint32_t type;

  3754.     struct list_head siblings_graph;

  3755.     struct list_head siblings_client;

  3756.     struct jack_graph_client * client;

  3757. };

  3758. 

  3759. struct jack_graph_connection

  3760. {

  3761.     uint64_t id;

  3762.     struct jack_graph_port * port1;

  3763.     struct jack_graph_port * port2;

  3764.     struct list_head siblings;

  3765. };

  3766. 

  3767. struct jack_controller_patchbay

  3768. {

  3769.     pthread_mutex_t lock;

  3770.     struct jack_graph graph;

  3771.     uint64_t next_client_id;

  3772.     uint64_t next_port_id;

  3773.     uint64_t next_connection_id;

  3774. };

  3775. 

  3776. void

  3777. jack_controller_patchbay_send_signal_graph_changed(

  3778.     dbus_uint64_t new_graph_version)

  3779. {

  3780. 

  3781.     jack_dbus_send_signal(

  3782.         JACK_CONTROLLER_OBJECT_PATH,

  3783.         JACK_DBUS_IFACE_NAME,

  3784.         "GraphChanged",

  3785.         DBUS_TYPE_UINT64,

  3786.         &new_graph_version,

  3787.         DBUS_TYPE_INVALID);

  3788. }

  3789. 

  3790. void

  3791. jack_controller_patchbay_send_signal_client_appeared(

  3792.     dbus_uint64_t new_graph_version,

  3793.     dbus_uint64_t client_id,

  3794.     const char * client_name)

  3795. {

  3796. 

  3797.     jack_dbus_send_signal(

  3798.         JACK_CONTROLLER_OBJECT_PATH,

  3799.         JACK_DBUS_IFACE_NAME,

  3800.         "ClientAppeared",

  3801.         DBUS_TYPE_UINT64,

  3802.         &new_graph_version,

  3803.         DBUS_TYPE_UINT64,

  3804.         &client_id,

  3805.         DBUS_TYPE_STRING,

  3806.         &client_name,

  3807.         DBUS_TYPE_INVALID);

  3808. }

  3809. 

  3810. void

  3811. jack_controller_patchbay_send_signal_client_disappeared(

  3812.     dbus_uint64_t new_graph_version,

  3813.     dbus_uint64_t client_id,

  3814.     const char * client_name)

  3815. {

  3816. 

  3817.     jack_dbus_send_signal(

  3818.         JACK_CONTROLLER_OBJECT_PATH,

  3819.         JACK_DBUS_IFACE_NAME,

  3820.         "ClientDisappeared",

  3821.         DBUS_TYPE_UINT64,

  3822.         &new_graph_version,

  3823.         DBUS_TYPE_UINT64,

  3824.         &client_id,

  3825.         DBUS_TYPE_STRING,

  3826.         &client_name,

  3827.         DBUS_TYPE_INVALID);

  3828. }

  3829. 

  3830. void

  3831. jack_controller_patchbay_send_signal_port_appeared(

  3832.     dbus_uint64_t new_graph_version,

  3833.     dbus_uint64_t client_id,

  3834.     const char * client_name,

  3835.     dbus_uint64_t port_id,

  3836.     const char * port_name,

  3837.     dbus_uint32_t port_flags,

  3838.     dbus_uint32_t port_type)

  3839. {

  3840. 

  3841.     jack_dbus_send_signal(

  3842.         JACK_CONTROLLER_OBJECT_PATH,

  3843.         JACK_DBUS_IFACE_NAME,

  3844.         "PortAppeared",

  3845.         DBUS_TYPE_UINT64,

  3846.         &new_graph_version,

  3847.         DBUS_TYPE_UINT64,

  3848.         &client_id,

  3849.         DBUS_TYPE_STRING,

  3850.         &client_name,

  3851.         DBUS_TYPE_UINT64,

  3852.         &port_id,

  3853.         DBUS_TYPE_STRING,

  3854.         &port_name,

  3855.         DBUS_TYPE_UINT32,

  3856.         &port_flags,

  3857.         DBUS_TYPE_UINT32,

  3858.         &port_type,

  3859.         DBUS_TYPE_INVALID);

  3860. }

  3861. 

  3862. void

  3863. jack_controller_patchbay_send_signal_port_disappeared(

  3864.     dbus_uint64_t new_graph_version,

  3865.     dbus_uint64_t client_id,

  3866.     const char * client_name,

  3867.     dbus_uint64_t port_id,

  3868.     const char * port_name)

  3869. {

  3870. 

  3871.     jack_dbus_send_signal(

  3872.         JACK_CONTROLLER_OBJECT_PATH,

  3873.         JACK_DBUS_IFACE_NAME,

  3874.         "PortDisappeared",

  3875.         DBUS_TYPE_UINT64,

  3876.         &new_graph_version,

  3877.         DBUS_TYPE_UINT64,

  3878.         &client_id,

  3879.         DBUS_TYPE_STRING,

  3880.         &client_name,

  3881.         DBUS_TYPE_UINT64,

  3882.         &port_id,

  3883.         DBUS_TYPE_STRING,

  3884.         &port_name,

  3885.         DBUS_TYPE_INVALID);

  3886. }

  3887. 

  3888. void

  3889. jack_controller_patchbay_send_signal_ports_connected(

  3890.     dbus_uint64_t new_graph_version,

  3891.     dbus_uint64_t client1_id,

  3892.     const char * client1_name,

  3893.     dbus_uint64_t port1_id,

  3894.     const char * port1_name,

  3895.     dbus_uint64_t client2_id,

  3896.     const char * client2_name,

  3897.     dbus_uint64_t port2_id,

  3898.     const char * port2_name,

  3899.     dbus_uint64_t connection_id)

  3900. {

  3901. 

  3902.     jack_dbus_send_signal(

  3903.         JACK_CONTROLLER_OBJECT_PATH,

  3904.         JACK_DBUS_IFACE_NAME,

  3905.         "PortsConnected",

  3906.         DBUS_TYPE_UINT64,

  3907.         &new_graph_version,

  3908.         DBUS_TYPE_UINT64,

  3909.         &client1_id,

  3910.         DBUS_TYPE_STRING,

  3911.         &client1_name,

  3912.         DBUS_TYPE_UINT64,

  3913.         &port1_id,

  3914.         DBUS_TYPE_STRING,

  3915.         &port1_name,

  3916.         DBUS_TYPE_UINT64,

  3917.         &client2_id,

  3918.         DBUS_TYPE_STRING,

  3919.         &client2_name,

  3920.         DBUS_TYPE_UINT64,

  3921.         &port2_id,

  3922.         DBUS_TYPE_STRING,

  3923.         &port2_name,

  3924.         DBUS_TYPE_UINT64,

  3925.         &connection_id,

  3926.         DBUS_TYPE_INVALID);

  3927. }

  3928. 

  3929. void

  3930. jack_controller_patchbay_send_signal_ports_disconnected(

  3931.     dbus_uint64_t new_graph_version,

  3932.     dbus_uint64_t client1_id,

  3933.     const char * client1_name,

  3934.     dbus_uint64_t port1_id,

  3935.     const char * port1_name,

  3936.     dbus_uint64_t client2_id,

  3937.     const char * client2_name,

  3938.     dbus_uint64_t port2_id,

  3939.     const char * port2_name,

  3940.     dbus_uint64_t connection_id)

  3941. {

  3942. 

  3943.     jack_dbus_send_signal(

  3944.         JACK_CONTROLLER_OBJECT_PATH,

  3945.         JACK_DBUS_IFACE_NAME,

  3946.         "PortsDisconnected",

  3947.         DBUS_TYPE_UINT64,

  3948.         &new_graph_version,

  3949.         DBUS_TYPE_UINT64,

  3950.         &client1_id,

  3951.         DBUS_TYPE_STRING,

  3952.         &client1_name,

  3953.         DBUS_TYPE_UINT64,

  3954.         &port1_id,

  3955.         DBUS_TYPE_STRING,

  3956.         &port1_name,

  3957.         DBUS_TYPE_UINT64,

  3958.         &client2_id,

  3959.         DBUS_TYPE_STRING,

  3960.         &client2_name,

  3961.         DBUS_TYPE_UINT64,

  3962.         &port2_id,

  3963.         DBUS_TYPE_STRING,

  3964.         &port2_name,

  3965.         DBUS_TYPE_UINT64,

  3966.         &connection_id,

  3967.         DBUS_TYPE_INVALID);

  3968. }

  3969. 

  3970. static

  3971. struct jack_graph_client *

  3972. jack_controller_patchbay_find_client(

  3973.     struct jack_controller_patchbay *patchbay_ptr,

  3974.     const char *client_name,    /* not '\0' terminated */

  3975.     size_t client_name_len)     /* without terminating '\0' */

  3976. {

  3977.     struct list_head *node_ptr;

  3978.     struct jack_graph_client *client_ptr;

  3979. 

  3980.     list_for_each(node_ptr, &patchbay_ptr->graph.clients)

  3981.     {

  3982.         client_ptr = list_entry(node_ptr, struct jack_graph_client, siblings);

  3983.         if (strncmp(client_ptr->name, client_name, client_name_len) == 0)

  3984.         {

  3985.             return client_ptr;

  3986.         }

  3987.     }

  3988. 

  3989.     return NULL;

  3990. }

  3991. 

  3992. static

  3993. struct jack_graph_client *

  3994. jack_controller_patchbay_find_client_by_id(

  3995.     struct jack_controller_patchbay *patchbay_ptr,

  3996.     uint64_t id)

  3997. {

  3998.     struct list_head *node_ptr;

  3999.     struct jack_graph_client *client_ptr;

  4000. 

  4001.     list_for_each(node_ptr, &patchbay_ptr->graph.clients)

  4002.     {

  4003.         client_ptr = list_entry(node_ptr, struct jack_graph_client, siblings);

  4004.         if (client_ptr->id == id)

  4005.         {

  4006.             return client_ptr;

  4007.         }

  4008.     }

  4009. 

  4010.     return NULL;

  4011. }

  4012. 

  4013. static

  4014. struct jack_graph_client *

  4015. jack_controller_patchbay_create_client(

  4016.     struct jack_controller_patchbay *patchbay_ptr,

  4017.     const char *client_name,    /* not '\0' terminated */

  4018.     size_t client_name_len)     /* without terminating '\0' */

  4019. {

  4020.     struct jack_graph_client * client_ptr;

  4021. 

  4022.     client_ptr = malloc(sizeof(struct jack_graph_client));

  4023.     if (client_ptr == NULL)

  4024.     {

  4025.         jack_error("Memory allocation of jack_graph_client structure failed.");

  4026.         goto fail;

  4027.     }

  4028. 

  4029.     client_ptr->name = malloc(client_name_len + 1);

  4030.     if (client_ptr->name == NULL)

  4031.     {

  4032.         jack_error("malloc() failed to allocate memory for client name.");

  4033.         goto fail_free_client;

  4034.     }

  4035. 

  4036.     memcpy(client_ptr->name, client_name, client_name_len);

  4037.     client_ptr->name[client_name_len] = 0;

  4038. 

  4039.     client_ptr->pid = jack_get_client_pid(client_ptr->name);

  4040.     jack_info("New client '%s' with PID %d", client_ptr->name, client_ptr->pid);

  4041. 

  4042.     client_ptr->id = patchbay_ptr->next_client_id++;

  4043.     INIT_LIST_HEAD(&client_ptr->ports);

  4044. 

  4045. 

  4046.     pthread_mutex_lock(&patchbay_ptr->lock);

  4047.     list_add_tail(&client_ptr->siblings, &patchbay_ptr->graph.clients);

  4048.     patchbay_ptr->graph.version++;

  4049.     jack_controller_patchbay_send_signal_client_appeared(patchbay_ptr->graph.version, client_ptr->id, client_ptr->name);

  4050.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  4051.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4052. 

  4053.     return client_ptr;

  4054. 

  4055. fail_free_client:

  4056.     free(client_ptr);

  4057. 

  4058. fail:

  4059.     return NULL;

  4060. }

  4061. 

  4062. static

  4063. void

  4064. jack_controller_patchbay_destroy_client(

  4065.     struct jack_controller_patchbay *patchbay_ptr,

  4066.     struct jack_graph_client *client_ptr)

  4067. {

  4068.     pthread_mutex_lock(&patchbay_ptr->lock);

  4069.     list_del(&client_ptr->siblings);

  4070.     patchbay_ptr->graph.version++;

  4071.     jack_controller_patchbay_send_signal_client_disappeared(patchbay_ptr->graph.version, client_ptr->id, client_ptr->name);

  4072.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  4073.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4074. 

  4075.     free(client_ptr->name);

  4076.     free(client_ptr);

  4077. }

  4078. 

  4079. static

  4080. void

  4081. jack_controller_patchbay_destroy_client_by_name(

  4082.     struct jack_controller_patchbay *patchbay_ptr,

  4083.     const char *client_name)    /* '\0' terminated */

  4084. {

  4085.     struct jack_graph_client *client_ptr;

  4086. 

  4087.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, client_name, strlen(client_name));

  4088.     if (client_ptr == NULL)

  4089.     {

  4090.         jack_error("Cannot destroy unknown client '%s'", client_name);

  4091.         return;

  4092.     }

  4093. 

  4094.     jack_controller_patchbay_destroy_client(patchbay_ptr, client_ptr);

  4095. }

  4096. 

  4097. static

  4098. void

  4099. jack_controller_patchbay_new_port(

  4100.     struct jack_controller_patchbay *patchbay_ptr,

  4101.     const char *port_full_name,

  4102.     uint32_t port_flags,

  4103.     uint32_t port_type)

  4104. {

  4105.     struct jack_graph_client *client_ptr;

  4106.     struct jack_graph_port *port_ptr;

  4107.     const char *port_short_name;

  4108.     size_t client_name_len;

  4109. 

  4110.     //jack_info("name: %s", port_full_name);

  4111. 

  4112.     port_short_name = strchr(port_full_name, ':');

  4113.     if (port_short_name == NULL)

  4114.     {

  4115.         jack_error("port name '%s' does not contain ':' separator char", port_full_name);

  4116.         return;

  4117.     }

  4118. 

  4119.     port_short_name++;          /* skip ':' separator char */

  4120. 

  4121.     client_name_len = port_short_name - port_full_name - 1; /* without terminating '\0' */

  4122. 

  4123.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, port_full_name, client_name_len);

  4124.     if (client_ptr == NULL)

  4125.     {

  4126.         client_ptr = jack_controller_patchbay_create_client(patchbay_ptr, port_full_name, client_name_len);

  4127.         if (client_ptr == NULL)

  4128.         {

  4129.             jack_error("Creation of new jack_graph client failed.");

  4130.             return;

  4131.         }

  4132.     }

  4133. 

  4134.     port_ptr = malloc(sizeof(struct jack_graph_port));

  4135.     if (port_ptr == NULL)

  4136.     {

  4137.         jack_error("Memory allocation of jack_graph_port structure failed.");

  4138.         return;

  4139.     }

  4140. 

  4141.     port_ptr->name = strdup(port_short_name);

  4142.     if (port_ptr->name == NULL)

  4143.     {

  4144.         jack_error("strdup() call for port name '%s' failed.", port_short_name);

  4145.         free(port_ptr);

  4146.         return;

  4147.     }

  4148. 

  4149.     port_ptr->id = patchbay_ptr->next_port_id++;

  4150.     port_ptr->flags = port_flags;

  4151.     port_ptr->type = port_type;

  4152.     port_ptr->client = client_ptr;

  4153. 

  4154.     pthread_mutex_lock(&patchbay_ptr->lock);

  4155.     list_add_tail(&port_ptr->siblings_client, &client_ptr->ports);

  4156.     list_add_tail(&port_ptr->siblings_graph, &patchbay_ptr->graph.ports);

  4157.     patchbay_ptr->graph.version++;

  4158.     jack_controller_patchbay_send_signal_port_appeared(

  4159.         patchbay_ptr->graph.version,

  4160.         client_ptr->id,

  4161.         client_ptr->name,

  4162.         port_ptr->id,

  4163.         port_ptr->name,

  4164.         port_ptr->flags,

  4165.         port_ptr->type);

  4166.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  4167.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4168. }

  4169. 

  4170. static

  4171. void

  4172. jack_controller_patchbay_remove_port(

  4173.     struct jack_controller_patchbay *patchbay_ptr,

  4174.     struct jack_graph_port *port_ptr)

  4175. {

  4176.     pthread_mutex_lock(&patchbay_ptr->lock);

  4177.     list_del(&port_ptr->siblings_client);

  4178.     list_del(&port_ptr->siblings_graph);

  4179.     patchbay_ptr->graph.version++;

  4180.     jack_controller_patchbay_send_signal_port_disappeared(patchbay_ptr->graph.version, port_ptr->client->id, port_ptr->client->name, port_ptr->id, port_ptr->name);

  4181.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  4182.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4183. 

  4184.     free(port_ptr->name);

  4185.     free(port_ptr);

  4186. }

  4187. 

  4188. static

  4189. struct jack_graph_port *

  4190. jack_controller_patchbay_find_port_by_id(

  4191.     struct jack_controller_patchbay *patchbay_ptr,

  4192.     uint64_t port_id)

  4193. {

  4194.     struct list_head *node_ptr;

  4195.     struct jack_graph_port *port_ptr;

  4196. 

  4197.     list_for_each(node_ptr, &patchbay_ptr->graph.ports)

  4198.     {

  4199.         port_ptr = list_entry(node_ptr, struct jack_graph_port, siblings_graph);

  4200.         if (port_ptr->id == port_id)

  4201.         {

  4202.             return port_ptr;

  4203.         }

  4204.     }

  4205. 

  4206.     return NULL;

  4207. }

  4208. 

  4209. static

  4210. struct jack_graph_port *

  4211. jack_controller_patchbay_find_client_port_by_name(

  4212.     struct jack_controller_patchbay *patchbay_ptr,

  4213.     struct jack_graph_client *client_ptr,

  4214.     const char *port_name)

  4215. {

  4216.     struct list_head *node_ptr;

  4217.     struct jack_graph_port *port_ptr;

  4218. 

  4219.     list_for_each(node_ptr, &client_ptr->ports)

  4220.     {

  4221.         port_ptr = list_entry(node_ptr, struct jack_graph_port, siblings_client);

  4222.         if (strcmp(port_ptr->name, port_name) == 0)

  4223.         {

  4224.             return port_ptr;

  4225.         }

  4226.     }

  4227. 

  4228.     return NULL;

  4229. }

  4230. 

  4231. static

  4232. struct jack_graph_port *

  4233. jack_controller_patchbay_find_port_by_full_name(

  4234.     struct jack_controller_patchbay *patchbay_ptr,

  4235.     const char *port_full_name)

  4236. {

  4237.     const char *port_short_name;

  4238.     size_t client_name_len;

  4239.     struct jack_graph_client *client_ptr;

  4240. 

  4241.     //jack_info("name: %s", port_full_name);

  4242. 

  4243.     port_short_name = strchr(port_full_name, ':');

  4244.     if (port_short_name == NULL)

  4245.     {

  4246.         jack_error("port name '%s' does not contain ':' separator char", port_full_name);

  4247.         return NULL;

  4248.     }

  4249. 

  4250.     port_short_name++;          /* skip ':' separator char */

  4251. 

  4252.     client_name_len = port_short_name - port_full_name - 1; /* without terminating '\0' */

  4253. 

  4254.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, port_full_name, client_name_len);

  4255.     if (client_ptr == NULL)

  4256.     {

  4257.         jack_error("cannot find client of port '%s'", port_full_name);

  4258.         return NULL;

  4259.     }

  4260. 

  4261.     return jack_controller_patchbay_find_client_port_by_name(patchbay_ptr, client_ptr, port_short_name);

  4262. }

  4263. 

  4264. static

  4265. struct jack_graph_port *

  4266. jack_controller_patchbay_find_port_by_names(

  4267.     struct jack_controller_patchbay *patchbay_ptr,

  4268.     const char *client_name,

  4269.     const char *port_name)

  4270. {

  4271.     struct jack_graph_client *client_ptr;

  4272. 

  4273.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, client_name, strlen(client_name));

  4274.     if (client_ptr == NULL)

  4275.     {

  4276.         jack_error("cannot find client '%s'", client_name);

  4277.         return NULL;

  4278.     }

  4279. 

  4280.     return jack_controller_patchbay_find_client_port_by_name(patchbay_ptr, client_ptr, port_name);

  4281. }

  4282. 

  4283. static

  4284. struct jack_graph_connection *

  4285. jack_controller_patchbay_create_connection(

  4286.     struct jack_controller_patchbay *patchbay_ptr,

  4287.     struct jack_graph_port *port1_ptr,

  4288.     struct jack_graph_port *port2_ptr)

  4289. {

  4290.     struct jack_graph_connection * connection_ptr;

  4291. 

  4292.     connection_ptr = malloc(sizeof(struct jack_graph_connection));

  4293.     if (connection_ptr == NULL)

  4294.     {

  4295.         jack_error("Memory allocation of jack_graph_connection structure failed.");

  4296.         return NULL;

  4297.     }

  4298. 

  4299.     connection_ptr->id = patchbay_ptr->next_connection_id++;

  4300.     connection_ptr->port1 = port1_ptr;

  4301.     connection_ptr->port2 = port2_ptr;

  4302. 

  4303.     pthread_mutex_lock(&patchbay_ptr->lock);

  4304.     list_add_tail(&connection_ptr->siblings, &patchbay_ptr->graph.connections);

  4305.     patchbay_ptr->graph.version++;

  4306.     jack_controller_patchbay_send_signal_ports_connected(

  4307.         patchbay_ptr->graph.version,

  4308.         port1_ptr->client->id,

  4309.         port1_ptr->client->name,

  4310.         port1_ptr->id,

  4311.         port1_ptr->name,

  4312.         port2_ptr->client->id,

  4313.         port2_ptr->client->name,

  4314.         port2_ptr->id,

  4315.         port2_ptr->name,

  4316.         connection_ptr->id);

  4317.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  4318.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4319. 

  4320.     return connection_ptr;

  4321. }

  4322. 

  4323. static

  4324. void

  4325. jack_controller_patchbay_destroy_connection(

  4326.     struct jack_controller_patchbay *patchbay_ptr,

  4327.     struct jack_graph_connection *connection_ptr)

  4328. {

  4329.     pthread_mutex_lock(&patchbay_ptr->lock);

  4330.     list_del(&connection_ptr->siblings);

  4331.     patchbay_ptr->graph.version++;

  4332.     jack_controller_patchbay_send_signal_ports_disconnected(

  4333.         patchbay_ptr->graph.version,

  4334.         connection_ptr->port1->client->id,

  4335.         connection_ptr->port1->client->name,

  4336.         connection_ptr->port1->id,

  4337.         connection_ptr->port1->name,

  4338.         connection_ptr->port2->client->id,

  4339.         connection_ptr->port2->client->name,

  4340.         connection_ptr->port2->id,

  4341.         connection_ptr->port2->name,

  4342.         connection_ptr->id);

  4343.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  4344.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4345. 

  4346.     free(connection_ptr);

  4347. }

  4348. 

  4349. static

  4350. struct jack_graph_connection *

  4351. jack_controller_patchbay_find_connection(

  4352.     struct jack_controller_patchbay *patchbay_ptr,

  4353.     struct jack_graph_port *port1_ptr,

  4354.     struct jack_graph_port *port2_ptr)

  4355. {

  4356.     struct list_head *node_ptr;

  4357.     struct jack_graph_connection *connection_ptr;

  4358. 

  4359.     list_for_each(node_ptr, &patchbay_ptr->graph.connections)

  4360.     {

  4361.         connection_ptr = list_entry(node_ptr, struct jack_graph_connection, siblings);

  4362.         if ((connection_ptr->port1 == port1_ptr &&

  4363.              connection_ptr->port2 == port2_ptr) ||

  4364.             (connection_ptr->port1 == port2_ptr &&

  4365.              connection_ptr->port2 == port1_ptr))

  4366.         {

  4367.             return connection_ptr;

  4368.         }

  4369.     }

  4370. 

  4371.     return NULL;

  4372. }

  4373. 

  4374. static

  4375. struct jack_graph_connection *

  4376. jack_controller_patchbay_find_connection_by_id(

  4377.     struct jack_controller_patchbay *patchbay_ptr,

  4378.     uint64_t connection_id)

  4379. {

  4380.     struct list_head *node_ptr;

  4381.     struct jack_graph_connection *connection_ptr;

  4382. 

  4383.     list_for_each(node_ptr, &patchbay_ptr->graph.connections)

  4384.     {

  4385.         connection_ptr = list_entry(node_ptr, struct jack_graph_connection, siblings);

  4386.         if (connection_ptr->id == connection_id)

  4387.         {

  4388.             return connection_ptr;

  4389.         }

  4390.     }

  4391. 

  4392.     return NULL;

  4393. }

  4394. 

  4395. static

  4396. bool

  4397. jack_controller_patchbay_connect(

  4398.     struct jack_dbus_method_call *dbus_call_ptr,

  4399.     struct jack_controller *controller_ptr,

  4400.     struct jack_graph_port *port1_ptr,

  4401.     struct jack_graph_port *port2_ptr)

  4402. {

  4403.     int ret;

  4404.     char port1_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  4405.     char port2_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  4406. 

  4407.     sprintf(port1_name, "%s:%s", port1_ptr->client->name, port1_ptr->name);

  4408.     sprintf(port2_name, "%s:%s", port2_ptr->client->name, port2_ptr->name);

  4409. 

  4410.     ret = jack_connect(controller_ptr->client, port1_name, port2_name);

  4411.     if (ret != 0)

  4412.     {

  4413.         jack_dbus_error(dbus_call_ptr, JACK_DBUS_ERROR_GENERIC, "jack_connect() failed with %d", ret);

  4414.         return false;

  4415.     }

  4416. 

  4417.     return true;

  4418. }

  4419. 

  4420. static

  4421. bool

  4422. jack_controller_patchbay_disconnect(

  4423.     struct jack_dbus_method_call *dbus_call_ptr,

  4424.     struct jack_controller *controller_ptr,

  4425.     struct jack_graph_port *port1_ptr,

  4426.     struct jack_graph_port *port2_ptr)

  4427. {

  4428.     int ret;

  4429.     char port1_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  4430.     char port2_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  4431. 

  4432.     sprintf(port1_name, "%s:%s", port1_ptr->client->name, port1_ptr->name);

  4433.     sprintf(port2_name, "%s:%s", port2_ptr->client->name, port2_ptr->name);

  4434. 

  4435.     ret = jack_disconnect(controller_ptr->client, port1_name, port2_name);

  4436.     if (ret != 0)

  4437.     {

  4438.         jack_dbus_error(dbus_call_ptr, JACK_DBUS_ERROR_GENERIC, "jack_connect() failed with %d", ret);

  4439.         return false;

  4440.     }

  4441. 

  4442.     return true;

  4443. }

  4444. 

  4445. #define controller_ptr ((struct jack_controller *)call->context)

  4446. #define patchbay_ptr ((struct jack_controller_patchbay *)controller_ptr->patchbay_context)

  4447. 

  4448. static

  4449. void

  4450. jack_controller_dbus_get_all_ports(

  4451.     struct jack_dbus_method_call * call)

  4452. {

  4453.     struct list_head * client_node_ptr;

  4454.     struct list_head * port_node_ptr;

  4455.     struct jack_graph_client * client_ptr;

  4456.     struct jack_graph_port * port_ptr;

  4457.     DBusMessageIter iter, sub_iter;

  4458.     char fullname[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  4459.     char *fullname_var = fullname;

  4460. 

  4461.     if (!controller_ptr->started)

  4462.     {

  4463.         jack_dbus_error(

  4464.             call,

  4465.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  4466.             "Can't execute this method with stopped JACK server");

  4467.         return;

  4468.     }

  4469. 

  4470.     call->reply = dbus_message_new_method_return (call->message);

  4471.     if (!call->reply)

  4472.     {

  4473.         goto fail;

  4474.     }

  4475. 

  4476.     dbus_message_iter_init_append (call->reply, &iter);

  4477. 

  4478.     if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &sub_iter))

  4479.     {

  4480.         goto fail_unref;

  4481.     }

  4482. 

  4483.     pthread_mutex_lock(&patchbay_ptr->lock);

  4484. 

  4485.     list_for_each(client_node_ptr, &patchbay_ptr->graph.clients)

  4486.     {

  4487.         client_ptr = list_entry(client_node_ptr, struct jack_graph_client, siblings);

  4488. 

  4489.         list_for_each(port_node_ptr, &client_ptr->ports)

  4490.         {

  4491.             port_ptr = list_entry(port_node_ptr, struct jack_graph_port, siblings_client);

  4492. 

  4493.             jack_info("%s:%s", client_ptr->name, port_ptr->name);

  4494.             sprintf(fullname, "%s:%s", client_ptr->name, port_ptr->name);

  4495.             if (!dbus_message_iter_append_basic (&sub_iter, DBUS_TYPE_STRING, &fullname_var))

  4496.             {

  4497.                 pthread_mutex_unlock(&patchbay_ptr->lock);

  4498.                 dbus_message_iter_close_container (&iter, &sub_iter);

  4499.                 goto fail_unref;

  4500.             }

  4501.         }

  4502.     }

  4503. 

  4504.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4505. 

  4506.     if (!dbus_message_iter_close_container (&iter, &sub_iter))

  4507.     {

  4508.         goto fail_unref;

  4509.     }

  4510. 

  4511.     return;

  4512. 

  4513. fail_unref:

  4514.     dbus_message_unref (call->reply);

  4515.     call->reply = NULL;

  4516. 

  4517. fail:

  4518.     jack_error ("Ran out of memory trying to construct method return");

  4519. }

  4520. 

  4521. static

  4522. void

  4523. jack_controller_dbus_get_graph(

  4524.     struct jack_dbus_method_call * call)

  4525. {

  4526.     struct list_head * client_node_ptr;

  4527.     struct list_head * port_node_ptr;

  4528.     struct list_head * connection_node_ptr;

  4529.     struct jack_graph_client * client_ptr;

  4530.     struct jack_graph_port * port_ptr;

  4531.     struct jack_graph_connection * connection_ptr;

  4532.     DBusMessageIter iter;

  4533.     DBusMessageIter clients_array_iter;

  4534.     DBusMessageIter client_struct_iter;

  4535.     DBusMessageIter ports_array_iter;

  4536.     DBusMessageIter port_struct_iter;

  4537.     dbus_uint64_t version;

  4538.     DBusMessageIter connections_array_iter;

  4539.     DBusMessageIter connection_struct_iter;

  4540. 

  4541.     if (!controller_ptr->started)

  4542.     {

  4543.         jack_dbus_error(

  4544.             call,

  4545.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  4546.             "Can't execute this method with stopped JACK server");

  4547.         return;

  4548.     }

  4549. 

  4550.     if (!jack_dbus_get_method_args(call, DBUS_TYPE_UINT64, &version, DBUS_TYPE_INVALID))

  4551.     {

  4552.         /* The method call had invalid arguments meaning that

  4553.          * jack_dbus_get_method_args() has constructed an error for us.

  4554.          */

  4555.         goto exit;

  4556.     }

  4557. 

  4558.     //jack_info("Getting graph, know version is %" PRIu32, version);

  4559. 

  4560.     call->reply = dbus_message_new_method_return(call->message);

  4561.     if (!call->reply)

  4562.     {

  4563.         jack_error("Ran out of memory trying to construct method return");

  4564.         goto exit;

  4565.     }

  4566. 

  4567.     dbus_message_iter_init_append (call->reply, &iter);

  4568. 

  4569.     pthread_mutex_lock(&patchbay_ptr->lock);

  4570. 

  4571.     if (version > patchbay_ptr->graph.version)

  4572.     {

  4573.         jack_dbus_error(

  4574.             call,

  4575.             JACK_DBUS_ERROR_INVALID_ARGS,

  4576.             "known graph version %" PRIu64 " is newer than actual version %" PRIu64,

  4577.             version,

  4578.             patchbay_ptr->graph.version);

  4579.         pthread_mutex_unlock(&patchbay_ptr->lock);

  4580.         goto exit;

  4581.     }

  4582. 

  4583.     if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT64, &patchbay_ptr->graph.version))

  4584.     {

  4585.         goto nomem_unlock;

  4586.     }

  4587. 

  4588.     if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tsa(tsuu))", &clients_array_iter))

  4589.     {

  4590.         goto nomem_unlock;

  4591.     }

  4592. 

  4593.     if (version < patchbay_ptr->graph.version)

  4594.     {

  4595.         list_for_each(client_node_ptr, &patchbay_ptr->graph.clients)

  4596.         {

  4597.             client_ptr = list_entry(client_node_ptr, struct jack_graph_client, siblings);

  4598. 

  4599.             if (!dbus_message_iter_open_container (&clients_array_iter, DBUS_TYPE_STRUCT, NULL, &client_struct_iter))

  4600.             {

  4601.                 goto nomem_close_clients_array;

  4602.             }

  4603. 

  4604.             if (!dbus_message_iter_append_basic(&client_struct_iter, DBUS_TYPE_UINT64, &client_ptr->id))

  4605.             {

  4606.                 goto nomem_close_client_struct;

  4607.             }

  4608. 

  4609.             if (!dbus_message_iter_append_basic(&client_struct_iter, DBUS_TYPE_STRING, &client_ptr->name))

  4610.             {

  4611.                 goto nomem_close_client_struct;

  4612.             }

  4613. 

  4614.             if (!dbus_message_iter_open_container(&client_struct_iter, DBUS_TYPE_ARRAY, "(tsuu)", &ports_array_iter))

  4615.             {

  4616.                 goto nomem_close_client_struct;

  4617.             }

  4618. 

  4619.             list_for_each(port_node_ptr, &client_ptr->ports)

  4620.             {

  4621.                 port_ptr = list_entry(port_node_ptr, struct jack_graph_port, siblings_client);

  4622. 

  4623.                 if (!dbus_message_iter_open_container(&ports_array_iter, DBUS_TYPE_STRUCT, NULL, &port_struct_iter))

  4624.                 {

  4625.                     goto nomem_close_ports_array;

  4626.                 }

  4627. 

  4628.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT64, &port_ptr->id))

  4629.                 {

  4630.                     goto nomem_close_port_struct;

  4631.                 }

  4632. 

  4633.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_STRING, &port_ptr->name))

  4634.                 {

  4635.                     goto nomem_close_port_struct;

  4636.                 }

  4637. 

  4638.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT32, &port_ptr->flags))

  4639.                 {

  4640.                     goto nomem_close_port_struct;

  4641.                 }

  4642. 

  4643.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT32, &port_ptr->type))

  4644.                 {

  4645.                     goto nomem_close_port_struct;

  4646.                 }

  4647. 

  4648.                 if (!dbus_message_iter_close_container(&ports_array_iter, &port_struct_iter))

  4649.                 {

  4650.                     goto nomem_close_ports_array;

  4651.                 }

  4652.             }

  4653. 

  4654.             if (!dbus_message_iter_close_container(&client_struct_iter, &ports_array_iter))

  4655.             {

  4656.                 goto nomem_close_client_struct;

  4657.             }

  4658. 

  4659.             if (!dbus_message_iter_close_container(&clients_array_iter, &client_struct_iter))

  4660.             {

  4661.                 goto nomem_close_clients_array;

  4662.             }

  4663.         }

  4664.     }

  4665. 

  4666.     if (!dbus_message_iter_close_container(&iter, &clients_array_iter))

  4667.     {

  4668.         goto nomem_unlock;

  4669.     }

  4670. 

  4671.     if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tstststst)", &connections_array_iter))

  4672.     {

  4673.         goto nomem_unlock;

  4674.     }

  4675. 

  4676.     if (version < patchbay_ptr->graph.version)

  4677.     {

  4678.         list_for_each(connection_node_ptr, &patchbay_ptr->graph.connections)

  4679.         {

  4680.             connection_ptr = list_entry(connection_node_ptr, struct jack_graph_connection, siblings);

  4681. 

  4682.             if (!dbus_message_iter_open_container(&connections_array_iter, DBUS_TYPE_STRUCT, NULL, &connection_struct_iter))

  4683.             {

  4684.                 goto nomem_close_connections_array;

  4685.             }

  4686. 

  4687.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port1->client->id))

  4688.             {

  4689.                 goto nomem_close_connection_struct;

  4690.             }

  4691. 

  4692.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port1->client->name))

  4693.             {

  4694.                 goto nomem_close_connection_struct;

  4695.             }

  4696. 

  4697.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port1->id))

  4698.             {

  4699.                 goto nomem_close_connection_struct;

  4700.             }

  4701. 

  4702.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port1->name))

  4703.             {

  4704.                 goto nomem_close_connection_struct;

  4705.             }

  4706. 

  4707.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port2->client->id))

  4708.             {

  4709.                 goto nomem_close_connection_struct;

  4710.             }

  4711. 

  4712.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port2->client->name))

  4713.             {

  4714.                 goto nomem_close_connection_struct;

  4715.             }

  4716. 

  4717.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port2->id))

  4718.             {

  4719.                 goto nomem_close_connection_struct;

  4720.             }

  4721. 

  4722.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port2->name))

  4723.             {

  4724.                 goto nomem_close_connection_struct;

  4725.             }

  4726. 

  4727.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->id))

  4728.             {

  4729.                 goto nomem_close_connection_struct;

  4730.             }

  4731. 

  4732.             if (!dbus_message_iter_close_container(&connections_array_iter, &connection_struct_iter))

  4733.             {

  4734.                 goto nomem_close_connections_array;

  4735.             }

  4736.         }

  4737.     }

  4738. 

  4739.     if (!dbus_message_iter_close_container(&iter, &connections_array_iter))

  4740.     {

  4741.         goto nomem_unlock;

  4742.     }

  4743. 

  4744.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4745. 

  4746.     return;

  4747. 

  4748. nomem_close_connection_struct:

  4749.     dbus_message_iter_close_container(&connections_array_iter, &connection_struct_iter);

  4750. 

  4751. nomem_close_connections_array:

  4752.     dbus_message_iter_close_container(&iter, &connections_array_iter);

  4753.     goto nomem_unlock;

  4754. 

  4755. nomem_close_port_struct:

  4756.     dbus_message_iter_close_container(&ports_array_iter, &port_struct_iter);

  4757. 

  4758. nomem_close_ports_array:

  4759.     dbus_message_iter_close_container(&client_struct_iter, &ports_array_iter);

  4760. 

  4761. nomem_close_client_struct:

  4762.     dbus_message_iter_close_container(&clients_array_iter, &client_struct_iter);

  4763. 

  4764. nomem_close_clients_array:

  4765.     dbus_message_iter_close_container(&iter, &clients_array_iter);

  4766. 

  4767. nomem_unlock:

  4768.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4769. 

  4770. //nomem:

  4771.     dbus_message_unref(call->reply);

  4772.     call->reply = NULL;

  4773.     jack_error("Ran out of memory trying to construct method return");

  4774. 

  4775. exit:

  4776.     return;

  4777. }

  4778. 

  4779. static

  4780. void

  4781. jack_controller_dbus_connect_ports_by_name(

  4782.     struct jack_dbus_method_call * call)

  4783. {

  4784.     const char * client1_name;

  4785.     const char * port1_name;

  4786.     const char * client2_name;

  4787.     const char * port2_name;

  4788.     struct jack_graph_port *port1_ptr;

  4789.     struct jack_graph_port *port2_ptr;

  4790. 

  4791. /*  jack_info("jack_controller_dbus_connect_ports_by_name() called."); */

  4792. 

  4793.     if (!controller_ptr->started)

  4794.     {

  4795.         jack_dbus_error(

  4796.             call,

  4797.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  4798.             "Can't execute this method with stopped JACK server");

  4799.         return;

  4800.     }

  4801. 

  4802.     if (!jack_dbus_get_method_args(

  4803.             call,

  4804.             DBUS_TYPE_STRING,

  4805.             &client1_name,

  4806.             DBUS_TYPE_STRING,

  4807.             &port1_name,

  4808.             DBUS_TYPE_STRING,

  4809.             &client2_name,

  4810.             DBUS_TYPE_STRING,

  4811.             &port2_name,

  4812.             DBUS_TYPE_INVALID))

  4813.     {

  4814.         /* The method call had invalid arguments meaning that

  4815.          * jack_dbus_get_method_args() has constructed an error for us.

  4816.          */

  4817.         return;

  4818.     }

  4819. 

  4820. /*  jack_info("connecting %s:%s and %s:%s", client1_name, port1_name, client2_name, port2_name); */

  4821. 

  4822.     pthread_mutex_lock(&patchbay_ptr->lock);

  4823. 

  4824.     port1_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client1_name, port1_name);

  4825.     if (port1_ptr == NULL)

  4826.     {

  4827.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client1_name, port1_name);

  4828.         goto unlock;

  4829.     }

  4830. 

  4831.     port2_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client2_name, port2_name);

  4832.     if (port2_ptr == NULL)

  4833.     {

  4834.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client2_name, port2_name);

  4835.         goto unlock;

  4836.     }

  4837. 

  4838.     if (!jack_controller_patchbay_connect(

  4839.             call,

  4840.             controller_ptr,

  4841.             port1_ptr,

  4842.             port2_ptr))

  4843.     {

  4844.         /* jack_controller_patchbay_connect() constructed error reply */

  4845.         goto unlock;

  4846.     }

  4847. 

  4848.     jack_dbus_construct_method_return_empty(call);

  4849. 

  4850. unlock:

  4851.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4852. }

  4853. 

  4854. static

  4855. void

  4856. jack_controller_dbus_connect_ports_by_id(

  4857.     struct jack_dbus_method_call * call)

  4858. {

  4859.     dbus_uint64_t port1_id;

  4860.     dbus_uint64_t port2_id;

  4861.     struct jack_graph_port *port1_ptr;

  4862.     struct jack_graph_port *port2_ptr;

  4863. 

  4864. /*     jack_info("jack_controller_dbus_connect_ports_by_id() called."); */

  4865. 

  4866.     if (!controller_ptr->started)

  4867.     {

  4868.         jack_dbus_error(

  4869.             call,

  4870.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  4871.             "Can't execute this method with stopped JACK server");

  4872.         return;

  4873.     }

  4874. 

  4875.     if (!jack_dbus_get_method_args(

  4876.             call,

  4877.             DBUS_TYPE_UINT64,

  4878.             &port1_id,

  4879.             DBUS_TYPE_UINT64,

  4880.             &port2_id,

  4881.             DBUS_TYPE_INVALID))

  4882.     {

  4883.         /* The method call had invalid arguments meaning that

  4884.          * jack_dbus_get_method_args() has constructed an error for us.

  4885.          */

  4886.         return;

  4887.     }

  4888. 

  4889.     pthread_mutex_lock(&patchbay_ptr->lock);

  4890. 

  4891.     port1_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port1_id);

  4892.     if (port1_ptr == NULL)

  4893.     {

  4894.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port1_id);

  4895.         goto unlock;

  4896.     }

  4897. 

  4898.     port2_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port2_id);

  4899.     if (port2_ptr == NULL)

  4900.     {

  4901.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port2_id);

  4902.         goto unlock;

  4903.     }

  4904. 

  4905.     if (!jack_controller_patchbay_connect(

  4906.             call,

  4907.             controller_ptr,

  4908.             port1_ptr,

  4909.             port2_ptr))

  4910.     {

  4911.         /* jack_controller_patchbay_connect() constructed error reply */

  4912.         goto unlock;

  4913.     }

  4914. 

  4915.     jack_dbus_construct_method_return_empty(call);

  4916. 

  4917. unlock:

  4918.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4919. }

  4920. 

  4921. static

  4922. void

  4923. jack_controller_dbus_disconnect_ports_by_name(

  4924.     struct jack_dbus_method_call * call)

  4925. {

  4926.     const char * client1_name;

  4927.     const char * port1_name;

  4928.     const char * client2_name;

  4929.     const char * port2_name;

  4930.     struct jack_graph_port *port1_ptr;

  4931.     struct jack_graph_port *port2_ptr;

  4932. 

  4933. /*  jack_info("jack_controller_dbus_disconnect_ports_by_name() called."); */

  4934. 

  4935.     if (!controller_ptr->started)

  4936.     {

  4937.         jack_dbus_error(

  4938.             call,

  4939.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  4940.             "Can't execute this method with stopped JACK server");

  4941.         return;

  4942.     }

  4943. 

  4944.     if (!jack_dbus_get_method_args(

  4945.             call,

  4946.             DBUS_TYPE_STRING,

  4947.             &client1_name,

  4948.             DBUS_TYPE_STRING,

  4949.             &port1_name,

  4950.             DBUS_TYPE_STRING,

  4951.             &client2_name,

  4952.             DBUS_TYPE_STRING,

  4953.             &port2_name,

  4954.             DBUS_TYPE_INVALID))

  4955.     {

  4956.         /* The method call had invalid arguments meaning that

  4957.          * jack_dbus_get_method_args() has constructed an error for us.

  4958.          */

  4959.         return;

  4960.     }

  4961. 

  4962. /*  jack_info("disconnecting %s:%s and %s:%s", client1_name, port1_name, client2_name, port2_name); */

  4963. 

  4964.     pthread_mutex_lock(&patchbay_ptr->lock);

  4965. 

  4966.     port1_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client1_name, port1_name);

  4967.     if (port1_ptr == NULL)

  4968.     {

  4969.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client1_name, port1_name);

  4970.         goto unlock;

  4971.     }

  4972. 

  4973.     port2_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client2_name, port2_name);

  4974.     if (port2_ptr == NULL)

  4975.     {

  4976.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client2_name, port2_name);

  4977.         goto unlock;

  4978.     }

  4979. 

  4980.     if (!jack_controller_patchbay_disconnect(

  4981.             call,

  4982.             controller_ptr,

  4983.             port1_ptr,

  4984.             port2_ptr))

  4985.     {

  4986.         /* jack_controller_patchbay_connect() constructed error reply */

  4987.         goto unlock;

  4988.     }

  4989. 

  4990.     jack_dbus_construct_method_return_empty(call);

  4991. 

  4992. unlock:

  4993.     pthread_mutex_unlock(&patchbay_ptr->lock);

  4994. }

  4995. 

  4996. static

  4997. void

  4998. jack_controller_dbus_disconnect_ports_by_id(

  4999.     struct jack_dbus_method_call * call)

  5000. {

  5001.     dbus_uint64_t port1_id;

  5002.     dbus_uint64_t port2_id;

  5003.     struct jack_graph_port *port1_ptr;

  5004.     struct jack_graph_port *port2_ptr;

  5005. 

  5006. /*     jack_info("jack_controller_dbus_disconnect_ports_by_id() called."); */

  5007. 

  5008.     if (!controller_ptr->started)

  5009.     {

  5010.         jack_dbus_error(

  5011.             call,

  5012.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  5013.             "Can't execute this method with stopped JACK server");

  5014.         return;

  5015.     }

  5016. 

  5017.     if (!jack_dbus_get_method_args(

  5018.             call,

  5019.             DBUS_TYPE_UINT64,

  5020.             &port1_id,

  5021.             DBUS_TYPE_UINT64,

  5022.             &port2_id,

  5023.             DBUS_TYPE_INVALID))

  5024.     {

  5025.         /* The method call had invalid arguments meaning that

  5026.          * jack_dbus_get_method_args() has constructed an error for us.

  5027.          */

  5028.         return;

  5029.     }

  5030. 

  5031.     pthread_mutex_lock(&patchbay_ptr->lock);

  5032. 

  5033.     port1_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port1_id);

  5034.     if (port1_ptr == NULL)

  5035.     {

  5036.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port1_id);

  5037.         return;

  5038.     }

  5039. 

  5040.     port2_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port2_id);

  5041.     if (port2_ptr == NULL)

  5042.     {

  5043.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port2_id);

  5044.         return;

  5045.     }

  5046. 

  5047.     if (!jack_controller_patchbay_disconnect(

  5048.             call,

  5049.             controller_ptr,

  5050.             port1_ptr,

  5051.             port2_ptr))

  5052.     {

  5053.         /* jack_controller_patchbay_connect() constructed error reply */

  5054.         goto unlock;

  5055.     }

  5056. 

  5057.     jack_dbus_construct_method_return_empty(call);

  5058. 

  5059. unlock:

  5060.     pthread_mutex_unlock(&patchbay_ptr->lock);

  5061. }

  5062. 

  5063. static

  5064. void

  5065. jack_controller_dbus_disconnect_ports_by_connection_id(

  5066.     struct jack_dbus_method_call * call)

  5067. {

  5068.     dbus_uint64_t connection_id;

  5069.     struct jack_graph_connection *connection_ptr;

  5070. 

  5071. /*     jack_info("jack_controller_dbus_disconnect_ports_by_id() called."); */

  5072. 

  5073.     if (!jack_dbus_get_method_args(

  5074.             call,

  5075.             DBUS_TYPE_UINT64,

  5076.             &connection_id,

  5077.             DBUS_TYPE_INVALID))

  5078.     {

  5079.         /* The method call had invalid arguments meaning that

  5080.          * jack_dbus_get_method_args() has constructed an error for us.

  5081.          */

  5082.         return;

  5083.     }

  5084. 

  5085.     pthread_mutex_lock(&patchbay_ptr->lock);

  5086. 

  5087.     connection_ptr = jack_controller_patchbay_find_connection_by_id(patchbay_ptr, connection_id);

  5088.     if (connection_ptr == NULL)

  5089.     {

  5090.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find connection %" PRIu64, connection_id);

  5091.         goto unlock;

  5092.     }

  5093. 

  5094.     if (!jack_controller_patchbay_disconnect(

  5095.             call,

  5096.             controller_ptr,

  5097.             connection_ptr->port1,

  5098.             connection_ptr->port2))

  5099.     {

  5100.         /* jack_controller_patchbay_connect() constructed error reply */

  5101.         goto unlock;

  5102.     }

  5103. 

  5104.     jack_dbus_construct_method_return_empty(call);

  5105. 

  5106. unlock:

  5107.     pthread_mutex_unlock(&patchbay_ptr->lock);

  5108. }

  5109. 

  5110. static

  5111. void

  5112. jack_controller_dbus_get_client_pid(

  5113.     struct jack_dbus_method_call * call)

  5114. {

  5115.     dbus_uint64_t client_id;

  5116.     struct jack_graph_client *client_ptr;

  5117.     message_arg_t arg;

  5118. 

  5119. /*     jack_info("jack_controller_dbus_get_client_pid() called."); */

  5120. 

  5121.     if (!jack_dbus_get_method_args(

  5122.             call,

  5123.             DBUS_TYPE_UINT64,

  5124.             &client_id,

  5125.             DBUS_TYPE_INVALID))

  5126.     {

  5127.         /* The method call had invalid arguments meaning that

  5128.          * jack_dbus_get_method_args() has constructed an error for us.

  5129.          */

  5130.         return;

  5131.     }

  5132. 

  5133.     pthread_mutex_lock(&patchbay_ptr->lock);

  5134. 

  5135.     client_ptr = jack_controller_patchbay_find_client_by_id(patchbay_ptr, client_id);

  5136.     if (client_ptr == NULL)

  5137.     {

  5138.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find client %" PRIu64, client_id);

  5139.         goto unlock;

  5140.     }

  5141. 

  5142.     arg.int64 = client_ptr->pid;

  5143. 

  5144.     jack_dbus_construct_method_return_single(call, DBUS_TYPE_INT64, arg);

  5145. 

  5146. unlock:

  5147.     pthread_mutex_unlock(&patchbay_ptr->lock);

  5148. }

  5149. 

  5150. #undef controller_ptr

  5151. #define controller_ptr ((struct jack_controller *)context)

  5152. 

  5153. static

  5154. int

  5155. jack_controller_graph_order_callback(

  5156.     void *context)

  5157. {

  5158.     const char **ports;

  5159.     int i;

  5160.     jack_port_t *port_ptr;

  5161.     

  5162.     if (patchbay_ptr->graph.version > 1)

  5163.     {

  5164.         /* we use this only for initial catchup */

  5165.         return 0;

  5166.     }

  5167.     

  5168.     ports = jack_get_ports(controller_ptr->client, NULL, NULL, 0);

  5169.     if (ports)

  5170.     {

  5171.         for (i = 0;  ports[i]; ++i)

  5172.         {

  5173.             jack_info("graph reorder: new port '%s'", ports[i]);

  5174.             port_ptr = jack_port_by_name(controller_ptr->client, ports[i]);;

  5175.             jack_controller_patchbay_new_port(patchbay_ptr, ports[i], jack_port_flags(port_ptr), jack_port_type_id(port_ptr));

  5176.         }

  5177. 

  5178.         free(ports);

  5179.     }

  5180. 

  5181.     if (patchbay_ptr->graph.version == 1)

  5182.     {

  5183.         /* we have empty initial graph, increment graph version,

  5184.            so we dont do jack_get_ports() again,

  5185.            on next next graph change */

  5186.         patchbay_ptr->graph.version++;

  5187.     }

  5188. 

  5189.     return 0;

  5190. }

  5191. 

  5192. void

  5193. jack_controller_client_registration_callback(

  5194.     const char *client_name,

  5195.     int created,

  5196.     void *context)

  5197. {

  5198.     if (created)

  5199.     {

  5200.         jack_log("client '%s' created", client_name);

  5201.         jack_controller_patchbay_create_client(patchbay_ptr, client_name, strlen(client_name));

  5202.     }

  5203.     else

  5204.     {

  5205.         jack_log("client '%s' destroyed", client_name);

  5206.         jack_controller_patchbay_destroy_client_by_name(patchbay_ptr, client_name);

  5207.     }

  5208. }

  5209. 

  5210. void

  5211. jack_controller_port_registration_callback(

  5212.     jack_port_id_t port_id,

  5213.     int created,

  5214.     void *context)

  5215. {

  5216.     jack_port_t *port_ptr;

  5217.     struct jack_graph_port *graph_port_ptr;

  5218.     const char *port_name;

  5219. 

  5220.     port_ptr = jack_port_by_id(controller_ptr->client, port_id);

  5221.     port_name = jack_port_name(port_ptr);

  5222. 

  5223.     if (created)

  5224.     {

  5225.         jack_log("port '%s' created", port_name);

  5226.         jack_controller_patchbay_new_port(patchbay_ptr, port_name, jack_port_flags(port_ptr), jack_port_type_id(port_ptr));

  5227.     }

  5228.     else

  5229.     {

  5230.         jack_log("port '%s' destroyed", port_name);

  5231.         graph_port_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port_name);

  5232.         if (graph_port_ptr == NULL)

  5233.         {

  5234.             jack_error("Failed to find port '%s' to destroy", port_name);

  5235.             return;

  5236.         }

  5237. 

  5238.         jack_controller_patchbay_remove_port(patchbay_ptr, graph_port_ptr);

  5239.     }

  5240. }

  5241. 

  5242. void

  5243. jack_controller_port_connect_callback(

  5244.     jack_port_id_t port1_id,

  5245.     jack_port_id_t port2_id,

  5246.     int connect,

  5247.     void *context)

  5248. {

  5249.     jack_port_t *port1;

  5250.     jack_port_t *port2;

  5251.     const char *port1_name;

  5252.     const char *port2_name;

  5253.     struct jack_graph_port *port1_ptr;

  5254.     struct jack_graph_port *port2_ptr;

  5255.     struct jack_graph_connection *connection_ptr;

  5256. 

  5257.     port1 = jack_port_by_id(controller_ptr->client, port1_id);

  5258.     port2 = jack_port_by_id(controller_ptr->client, port2_id);

  5259. 

  5260.     port1_name = jack_port_name(port1);

  5261.     port2_name = jack_port_name(port2);

  5262. 

  5263.     port1_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port1_name);

  5264.     if (port1_ptr == NULL)

  5265.     {

  5266.         jack_error("Failed to find port '%s' to [dis]connect", port1_name);

  5267.         return;

  5268.     }

  5269. 

  5270.     port2_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port2_name);

  5271.     if (port2_ptr == NULL)

  5272.     {

  5273.         jack_error("Failed to find port '%s' to [dis]connect", port2_name);

  5274.         return;

  5275.     }

  5276. 

  5277.     if (connect)

  5278.     {

  5279.         jack_info("Connecting '%s' to '%s'", port1_name, port2_name);

  5280.         connection_ptr = jack_controller_patchbay_find_connection(patchbay_ptr, port1_ptr, port2_ptr);

  5281.         if (connection_ptr != NULL)

  5282.         {

  5283.             jack_error("'%s' and '%s' are already connected", port1_name, port2_name);

  5284.             return;

  5285.         }

  5286. 

  5287.         jack_controller_patchbay_create_connection(patchbay_ptr, port1_ptr, port2_ptr);

  5288.     }

  5289.     else

  5290.     {

  5291.         jack_info("Disonnecting '%s' from '%s'", port1_name, port2_name);

  5292.         connection_ptr = jack_controller_patchbay_find_connection(patchbay_ptr, port1_ptr, port2_ptr);

  5293.         if (connection_ptr == NULL)

  5294.         {

  5295.             jack_error("Cannot find connection being removed");

  5296.             return;

  5297.         }

  5298. 

  5299.         jack_controller_patchbay_destroy_connection(patchbay_ptr, connection_ptr);

  5300.     }

  5301. }

  5302. 

  5303. #undef controller_ptr

  5304. 

  5305. void

  5306. jack_controller_patchbay_uninit(

  5307.     struct jack_controller * controller_ptr)

  5308. {

  5309.     struct jack_graph_client *client_ptr;

  5310.     struct jack_graph_port *port_ptr;

  5311. 

  5312. /*     jack_info("jack_controller_patchbay_uninit() called"); */

  5313. 

  5314.     while (!list_empty(&patchbay_ptr->graph.ports))

  5315.     {

  5316.         port_ptr = list_entry(patchbay_ptr->graph.ports.next, struct jack_graph_port, siblings_graph);

  5317.         jack_controller_patchbay_remove_port(patchbay_ptr, port_ptr);

  5318.     }

  5319. 

  5320.     while (!list_empty(&patchbay_ptr->graph.clients))

  5321.     {

  5322.         client_ptr = list_entry(patchbay_ptr->graph.clients.next, struct jack_graph_client, siblings);

  5323.         jack_controller_patchbay_destroy_client(patchbay_ptr, client_ptr);

  5324.     }

  5325. 

  5326.     pthread_mutex_destroy(&patchbay_ptr->lock);

  5327. }

  5328. 

  5329. #undef patchbay_ptr

  5330. 

  5331. bool

  5332. jack_controller_patchbay_init(

  5333.     struct jack_controller * controller_ptr)

  5334. {

  5335.     int ret;

  5336.     struct jack_controller_patchbay * patchbay_ptr;

  5337.     pthread_mutexattr_t attr;

  5338. 

  5339. /*     jack_info("jack_controller_patchbay_init() called"); */

  5340. 

  5341.     patchbay_ptr = malloc(sizeof(struct jack_controller_patchbay));

  5342.     if (patchbay_ptr == NULL)

  5343.     {

  5344.         jack_error("Memory allocation of jack_controller_patchbay structure failed.");

  5345.         goto fail;

  5346.     }

  5347. 

  5348.     ret = pthread_mutexattr_init(&attr);

  5349.     if (ret != 0)

  5350.     {

  5351.         goto fail;

  5352.     }

  5353. 

  5354.     ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

  5355.     if (ret != 0)

  5356.     {

  5357.         goto fail;

  5358.     }

  5359. 

  5360.     pthread_mutex_init(&patchbay_ptr->lock, &attr);

  5361.     INIT_LIST_HEAD(&patchbay_ptr->graph.clients);

  5362.     INIT_LIST_HEAD(&patchbay_ptr->graph.ports);

  5363.     INIT_LIST_HEAD(&patchbay_ptr->graph.connections);

  5364.     patchbay_ptr->graph.version = 1;

  5365.     patchbay_ptr->next_client_id = 1;

  5366.     patchbay_ptr->next_port_id = 1;

  5367.     patchbay_ptr->next_connection_id = 1;

  5368. 

  5369.     controller_ptr->patchbay_context = patchbay_ptr;

  5370. 

  5371.     ret = jack_set_graph_order_callback(controller_ptr->client, jack_controller_graph_order_callback, controller_ptr);

  5372.     if (ret != 0)

  5373.     {

  5374.         jack_error("jack_set_graph_order_callback() failed with error %d", ret);

  5375.         goto fail_uninit_mutex;

  5376.     }

  5377. 

  5378.     ret = jack_set_client_registration_callback(controller_ptr->client, jack_controller_client_registration_callback, controller_ptr);

  5379.     if (ret != 0)

  5380.     {

  5381.         jack_error("jack_set_client_registration_callback() failed with error %d", ret);

  5382.         goto fail_uninit_mutex;

  5383.     }

  5384. 

  5385.     ret = jack_set_port_registration_callback(controller_ptr->client, jack_controller_port_registration_callback, controller_ptr);

  5386.     if (ret != 0)

  5387.     {

  5388.         jack_error("jack_set_port_registration_callback() failed with error %d", ret);

  5389.         goto fail_uninit_mutex;

  5390.     }

  5391. 

  5392.     ret = jack_set_port_connect_callback(controller_ptr->client, jack_controller_port_connect_callback, controller_ptr);

  5393.     if (ret != 0)

  5394.     {

  5395.         jack_error("jack_set_port_connect_callback() failed with error %d", ret);

  5396.         goto fail_uninit_mutex;

  5397.     }

  5398. 

  5399.     return true;

  5400. 

  5401. fail_uninit_mutex:

  5402.     pthread_mutex_destroy(&patchbay_ptr->lock);

  5403. 

  5404. fail:

  5405.     return false;

  5406. }

  5407. 

  5408. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetAllPorts)

  5409.     JACK_DBUS_METHOD_ARGUMENT("ports_list", "as", true)

  5410. JACK_DBUS_METHOD_ARGUMENTS_END

  5411. 

  5412. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetGraph)

  5413.     JACK_DBUS_METHOD_ARGUMENT("known_graph_version", DBUS_TYPE_UINT64_AS_STRING, false)

  5414.     JACK_DBUS_METHOD_ARGUMENT("current_graph_version", DBUS_TYPE_UINT64_AS_STRING, true)

  5415.     JACK_DBUS_METHOD_ARGUMENT("clients_and_ports", "a(tsa(tsuu))", true)

  5416.     JACK_DBUS_METHOD_ARGUMENT("connections", "a(tstststst)", true)

  5417. JACK_DBUS_METHOD_ARGUMENTS_END

  5418. 

  5419. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(ConnectPortsByName)

  5420.     JACK_DBUS_METHOD_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING, false)

  5421.     JACK_DBUS_METHOD_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING, false)

  5422.     JACK_DBUS_METHOD_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING, false)

  5423.     JACK_DBUS_METHOD_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING, false)

  5424. JACK_DBUS_METHOD_ARGUMENTS_END

  5425. 

  5426. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(ConnectPortsByID)

  5427.     JACK_DBUS_METHOD_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING, false)

  5428.     JACK_DBUS_METHOD_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING, false)

  5429. JACK_DBUS_METHOD_ARGUMENTS_END

  5430. 

  5431. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByName)

  5432.     JACK_DBUS_METHOD_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING, false)

  5433.     JACK_DBUS_METHOD_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING, false)

  5434.     JACK_DBUS_METHOD_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING, false)

  5435.     JACK_DBUS_METHOD_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING, false)

  5436. JACK_DBUS_METHOD_ARGUMENTS_END

  5437. 

  5438. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByID)

  5439.     JACK_DBUS_METHOD_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING, false)

  5440.     JACK_DBUS_METHOD_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING, false)

  5441. JACK_DBUS_METHOD_ARGUMENTS_END

  5442. 

  5443. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByConnectionID)

  5444.     JACK_DBUS_METHOD_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING, false)

  5445. JACK_DBUS_METHOD_ARGUMENTS_END

  5446. 

  5447. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetClientPID)

  5448.     JACK_DBUS_METHOD_ARGUMENT("client_id", DBUS_TYPE_INT64_AS_STRING, false)

  5449. JACK_DBUS_METHOD_ARGUMENTS_END

  5450. 

  5451. JACK_DBUS_METHODS_BEGIN

  5452.     JACK_DBUS_METHOD_DESCRIBE(GetAllPorts, jack_controller_dbus_get_all_ports)

  5453.     JACK_DBUS_METHOD_DESCRIBE(GetGraph, jack_controller_dbus_get_graph)

  5454.     JACK_DBUS_METHOD_DESCRIBE(ConnectPortsByName, jack_controller_dbus_connect_ports_by_name)

  5455.     JACK_DBUS_METHOD_DESCRIBE(ConnectPortsByID, jack_controller_dbus_connect_ports_by_id)

  5456.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByName, jack_controller_dbus_disconnect_ports_by_name)

  5457.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByID, jack_controller_dbus_disconnect_ports_by_id)

  5458.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByConnectionID, jack_controller_dbus_disconnect_ports_by_connection_id)

  5459.     JACK_DBUS_METHOD_DESCRIBE(GetClientPID, jack_controller_dbus_get_client_pid)

  5460. JACK_DBUS_METHODS_END

  5461. 

  5462. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(GraphChanged)

  5463.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  5464. JACK_DBUS_SIGNAL_ARGUMENTS_END

  5465. 

  5466. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(ClientAppeared)

  5467.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  5468.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  5469.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  5470. JACK_DBUS_SIGNAL_ARGUMENTS_END

  5471. 

  5472. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(ClientDisappeared)

  5473.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  5474.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  5475.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  5476. JACK_DBUS_SIGNAL_ARGUMENTS_END

  5477. 

  5478. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortAppeared)

  5479.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  5480.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  5481.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  5482.     JACK_DBUS_SIGNAL_ARGUMENT("port_id", DBUS_TYPE_UINT64_AS_STRING)

  5483.     JACK_DBUS_SIGNAL_ARGUMENT("port_name", DBUS_TYPE_STRING_AS_STRING)

  5484.     JACK_DBUS_SIGNAL_ARGUMENT("port_flags", DBUS_TYPE_UINT32_AS_STRING)

  5485.     JACK_DBUS_SIGNAL_ARGUMENT("port_type", DBUS_TYPE_UINT32_AS_STRING)

  5486. JACK_DBUS_SIGNAL_ARGUMENTS_END

  5487. 

  5488. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortDisappeared)

  5489.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  5490.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  5491.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  5492.     JACK_DBUS_SIGNAL_ARGUMENT("port_id", DBUS_TYPE_UINT64_AS_STRING)

  5493.     JACK_DBUS_SIGNAL_ARGUMENT("port_name", DBUS_TYPE_STRING_AS_STRING)

  5494. JACK_DBUS_SIGNAL_ARGUMENTS_END

  5495. 

  5496. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortsConnected)

  5497.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  5498.     JACK_DBUS_SIGNAL_ARGUMENT("client1_id", DBUS_TYPE_UINT64_AS_STRING)

  5499.     JACK_DBUS_SIGNAL_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING)

  5500.     JACK_DBUS_SIGNAL_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING)

  5501.     JACK_DBUS_SIGNAL_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING)

  5502.     JACK_DBUS_SIGNAL_ARGUMENT("client2_id", DBUS_TYPE_UINT64_AS_STRING)

  5503.     JACK_DBUS_SIGNAL_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING)

  5504.     JACK_DBUS_SIGNAL_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING)

  5505.     JACK_DBUS_SIGNAL_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING)

  5506.     JACK_DBUS_SIGNAL_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING)

  5507. JACK_DBUS_SIGNAL_ARGUMENTS_END

  5508. 

  5509. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortsDisconnected)

  5510.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  5511.     JACK_DBUS_SIGNAL_ARGUMENT("client1_id", DBUS_TYPE_UINT64_AS_STRING)

  5512.     JACK_DBUS_SIGNAL_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING)

  5513.     JACK_DBUS_SIGNAL_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING)

  5514.     JACK_DBUS_SIGNAL_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING)

  5515.     JACK_DBUS_SIGNAL_ARGUMENT("client2_id", DBUS_TYPE_UINT64_AS_STRING)

  5516.     JACK_DBUS_SIGNAL_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING)

  5517.     JACK_DBUS_SIGNAL_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING)

  5518.     JACK_DBUS_SIGNAL_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING)

  5519.     JACK_DBUS_SIGNAL_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING)

  5520. JACK_DBUS_SIGNAL_ARGUMENTS_END

  5521. 

  5522. JACK_DBUS_SIGNALS_BEGIN

  5523.     JACK_DBUS_SIGNAL_DESCRIBE(GraphChanged)

  5524.     JACK_DBUS_SIGNAL_DESCRIBE(ClientAppeared)

  5525.     JACK_DBUS_SIGNAL_DESCRIBE(ClientDisappeared)

  5526.     JACK_DBUS_SIGNAL_DESCRIBE(PortAppeared)

  5527.     JACK_DBUS_SIGNAL_DESCRIBE(PortDisappeared)

  5528.     JACK_DBUS_SIGNAL_DESCRIBE(PortsConnected)

  5529.     JACK_DBUS_SIGNAL_DESCRIBE(PortsDisconnected)

  5530. JACK_DBUS_SIGNALS_END

  5531. 

  5532. JACK_DBUS_IFACE_BEGIN(g_jack_controller_iface_patchbay, JACK_DBUS_IFACE_NAME)

  5533.     JACK_DBUS_IFACE_EXPOSE_METHODS

  5534.     JACK_DBUS_IFACE_EXPOSE_SIGNALS

  5535. JACK_DBUS_IFACE_END

  5536. /* -*- Mode: C ; c-basic-offset: 4 -*- */

  5537. /*

  5538.     Copyright (C) 2008 Nedko Arnaudov

  5539.     Copyright (C) 2008 Juuso Alasuutari

  5540. 

  5541.     This program is free software; you can redistribute it and/or modify

  5542.     it under the terms of the GNU General Public License as published by

  5543.     the Free Software Foundation; either version 2 of the License.

  5544. 

  5545.     This program is distributed in the hope that it will be useful,

  5546.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  5547.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  5548.     GNU General Public License for more details.

  5549. 

  5550.     You should have received a copy of the GNU General Public License

  5551.     along with this program; if not, write to the Free Software

  5552.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  5553. 

  5554. */

  5555. 

  5556. #define _GNU_SOURCE            /* PTHREAD_MUTEX_RECURSIVE */

  5557. 

  5558. #include <stdint.h>

  5559. #include <inttypes.h>

  5560. #include <string.h>

  5561. #include <stdio.h>

  5562. #include <assert.h>

  5563. #include <dbus/dbus.h>

  5564. #include <pthread.h>

  5565. 

  5566. #include "jackdbus.h"

  5567. #include "controller_internal.h"

  5568. #include "list.h"

  5569. 

  5570. #define JACK_DBUS_IFACE_NAME "org.jackaudio.JackPatchbay"

  5571. 

  5572. /* FIXME: these need to be retrieved from common headers */

  5573. #define JACK_CLIENT_NAME_SIZE 64

  5574. #define JACK_PORT_NAME_SIZE 256

  5575. 

  5576. struct jack_graph

  5577. {

  5578.     uint64_t version;

  5579.     struct list_head clients;

  5580.     struct list_head ports;

  5581.     struct list_head connections;

  5582. };

  5583. 

  5584. struct jack_graph_client

  5585. {

  5586.     uint64_t id;

  5587.     char * name;

  5588.     int pid;

  5589.     struct list_head siblings;

  5590.     struct list_head ports;

  5591. };

  5592. 

  5593. struct jack_graph_port

  5594. {

  5595.     uint64_t id;

  5596.     char * name;

  5597.     uint32_t flags;

  5598.     uint32_t type;

  5599.     struct list_head siblings_graph;

  5600.     struct list_head siblings_client;

  5601.     struct jack_graph_client * client;

  5602. };

  5603. 

  5604. struct jack_graph_connection

  5605. {

  5606.     uint64_t id;

  5607.     struct jack_graph_port * port1;

  5608.     struct jack_graph_port * port2;

  5609.     struct list_head siblings;

  5610. };

  5611. 

  5612. struct jack_controller_patchbay

  5613. {

  5614.     pthread_mutex_t lock;

  5615.     struct jack_graph graph;

  5616.     uint64_t next_client_id;

  5617.     uint64_t next_port_id;

  5618.     uint64_t next_connection_id;

  5619. };

  5620. 

  5621. void

  5622. jack_controller_patchbay_send_signal_graph_changed(

  5623.     dbus_uint64_t new_graph_version)

  5624. {

  5625. 

  5626.     jack_dbus_send_signal(

  5627.         JACK_CONTROLLER_OBJECT_PATH,

  5628.         JACK_DBUS_IFACE_NAME,

  5629.         "GraphChanged",

  5630.         DBUS_TYPE_UINT64,

  5631.         &new_graph_version,

  5632.         DBUS_TYPE_INVALID);

  5633. }

  5634. 

  5635. void

  5636. jack_controller_patchbay_send_signal_client_appeared(

  5637.     dbus_uint64_t new_graph_version,

  5638.     dbus_uint64_t client_id,

  5639.     const char * client_name)

  5640. {

  5641. 

  5642.     jack_dbus_send_signal(

  5643.         JACK_CONTROLLER_OBJECT_PATH,

  5644.         JACK_DBUS_IFACE_NAME,

  5645.         "ClientAppeared",

  5646.         DBUS_TYPE_UINT64,

  5647.         &new_graph_version,

  5648.         DBUS_TYPE_UINT64,

  5649.         &client_id,

  5650.         DBUS_TYPE_STRING,

  5651.         &client_name,

  5652.         DBUS_TYPE_INVALID);

  5653. }

  5654. 

  5655. void

  5656. jack_controller_patchbay_send_signal_client_disappeared(

  5657.     dbus_uint64_t new_graph_version,

  5658.     dbus_uint64_t client_id,

  5659.     const char * client_name)

  5660. {

  5661. 

  5662.     jack_dbus_send_signal(

  5663.         JACK_CONTROLLER_OBJECT_PATH,

  5664.         JACK_DBUS_IFACE_NAME,

  5665.         "ClientDisappeared",

  5666.         DBUS_TYPE_UINT64,

  5667.         &new_graph_version,

  5668.         DBUS_TYPE_UINT64,

  5669.         &client_id,

  5670.         DBUS_TYPE_STRING,

  5671.         &client_name,

  5672.         DBUS_TYPE_INVALID);

  5673. }

  5674. 

  5675. void

  5676. jack_controller_patchbay_send_signal_port_appeared(

  5677.     dbus_uint64_t new_graph_version,

  5678.     dbus_uint64_t client_id,

  5679.     const char * client_name,

  5680.     dbus_uint64_t port_id,

  5681.     const char * port_name,

  5682.     dbus_uint32_t port_flags,

  5683.     dbus_uint32_t port_type)

  5684. {

  5685. 

  5686.     jack_dbus_send_signal(

  5687.         JACK_CONTROLLER_OBJECT_PATH,

  5688.         JACK_DBUS_IFACE_NAME,

  5689.         "PortAppeared",

  5690.         DBUS_TYPE_UINT64,

  5691.         &new_graph_version,

  5692.         DBUS_TYPE_UINT64,

  5693.         &client_id,

  5694.         DBUS_TYPE_STRING,

  5695.         &client_name,

  5696.         DBUS_TYPE_UINT64,

  5697.         &port_id,

  5698.         DBUS_TYPE_STRING,

  5699.         &port_name,

  5700.         DBUS_TYPE_UINT32,

  5701.         &port_flags,

  5702.         DBUS_TYPE_UINT32,

  5703.         &port_type,

  5704.         DBUS_TYPE_INVALID);

  5705. }

  5706. 

  5707. void

  5708. jack_controller_patchbay_send_signal_port_disappeared(

  5709.     dbus_uint64_t new_graph_version,

  5710.     dbus_uint64_t client_id,

  5711.     const char * client_name,

  5712.     dbus_uint64_t port_id,

  5713.     const char * port_name)

  5714. {

  5715. 

  5716.     jack_dbus_send_signal(

  5717.         JACK_CONTROLLER_OBJECT_PATH,

  5718.         JACK_DBUS_IFACE_NAME,

  5719.         "PortDisappeared",

  5720.         DBUS_TYPE_UINT64,

  5721.         &new_graph_version,

  5722.         DBUS_TYPE_UINT64,

  5723.         &client_id,

  5724.         DBUS_TYPE_STRING,

  5725.         &client_name,

  5726.         DBUS_TYPE_UINT64,

  5727.         &port_id,

  5728.         DBUS_TYPE_STRING,

  5729.         &port_name,

  5730.         DBUS_TYPE_INVALID);

  5731. }

  5732. 

  5733. void

  5734. jack_controller_patchbay_send_signal_ports_connected(

  5735.     dbus_uint64_t new_graph_version,

  5736.     dbus_uint64_t client1_id,

  5737.     const char * client1_name,

  5738.     dbus_uint64_t port1_id,

  5739.     const char * port1_name,

  5740.     dbus_uint64_t client2_id,

  5741.     const char * client2_name,

  5742.     dbus_uint64_t port2_id,

  5743.     const char * port2_name,

  5744.     dbus_uint64_t connection_id)

  5745. {

  5746. 

  5747.     jack_dbus_send_signal(

  5748.         JACK_CONTROLLER_OBJECT_PATH,

  5749.         JACK_DBUS_IFACE_NAME,

  5750.         "PortsConnected",

  5751.         DBUS_TYPE_UINT64,

  5752.         &new_graph_version,

  5753.         DBUS_TYPE_UINT64,

  5754.         &client1_id,

  5755.         DBUS_TYPE_STRING,

  5756.         &client1_name,

  5757.         DBUS_TYPE_UINT64,

  5758.         &port1_id,

  5759.         DBUS_TYPE_STRING,

  5760.         &port1_name,

  5761.         DBUS_TYPE_UINT64,

  5762.         &client2_id,

  5763.         DBUS_TYPE_STRING,

  5764.         &client2_name,

  5765.         DBUS_TYPE_UINT64,

  5766.         &port2_id,

  5767.         DBUS_TYPE_STRING,

  5768.         &port2_name,

  5769.         DBUS_TYPE_UINT64,

  5770.         &connection_id,

  5771.         DBUS_TYPE_INVALID);

  5772. }

  5773. 

  5774. void

  5775. jack_controller_patchbay_send_signal_ports_disconnected(

  5776.     dbus_uint64_t new_graph_version,

  5777.     dbus_uint64_t client1_id,

  5778.     const char * client1_name,

  5779.     dbus_uint64_t port1_id,

  5780.     const char * port1_name,

  5781.     dbus_uint64_t client2_id,

  5782.     const char * client2_name,

  5783.     dbus_uint64_t port2_id,

  5784.     const char * port2_name,

  5785.     dbus_uint64_t connection_id)

  5786. {

  5787. 

  5788.     jack_dbus_send_signal(

  5789.         JACK_CONTROLLER_OBJECT_PATH,

  5790.         JACK_DBUS_IFACE_NAME,

  5791.         "PortsDisconnected",

  5792.         DBUS_TYPE_UINT64,

  5793.         &new_graph_version,

  5794.         DBUS_TYPE_UINT64,

  5795.         &client1_id,

  5796.         DBUS_TYPE_STRING,

  5797.         &client1_name,

  5798.         DBUS_TYPE_UINT64,

  5799.         &port1_id,

  5800.         DBUS_TYPE_STRING,

  5801.         &port1_name,

  5802.         DBUS_TYPE_UINT64,

  5803.         &client2_id,

  5804.         DBUS_TYPE_STRING,

  5805.         &client2_name,

  5806.         DBUS_TYPE_UINT64,

  5807.         &port2_id,

  5808.         DBUS_TYPE_STRING,

  5809.         &port2_name,

  5810.         DBUS_TYPE_UINT64,

  5811.         &connection_id,

  5812.         DBUS_TYPE_INVALID);

  5813. }

  5814. 

  5815. static

  5816. struct jack_graph_client *

  5817. jack_controller_patchbay_find_client(

  5818.     struct jack_controller_patchbay *patchbay_ptr,

  5819.     const char *client_name,    /* not '\0' terminated */

  5820.     size_t client_name_len)     /* without terminating '\0' */

  5821. {

  5822.     struct list_head *node_ptr;

  5823.     struct jack_graph_client *client_ptr;

  5824. 

  5825.     list_for_each(node_ptr, &patchbay_ptr->graph.clients)

  5826.     {

  5827.         client_ptr = list_entry(node_ptr, struct jack_graph_client, siblings);

  5828.         if (strncmp(client_ptr->name, client_name, client_name_len) == 0)

  5829.         {

  5830.             return client_ptr;

  5831.         }

  5832.     }

  5833. 

  5834.     return NULL;

  5835. }

  5836. 

  5837. static

  5838. struct jack_graph_client *

  5839. jack_controller_patchbay_find_client_by_id(

  5840.     struct jack_controller_patchbay *patchbay_ptr,

  5841.     uint64_t id)

  5842. {

  5843.     struct list_head *node_ptr;

  5844.     struct jack_graph_client *client_ptr;

  5845. 

  5846.     list_for_each(node_ptr, &patchbay_ptr->graph.clients)

  5847.     {

  5848.         client_ptr = list_entry(node_ptr, struct jack_graph_client, siblings);

  5849.         if (client_ptr->id == id)

  5850.         {

  5851.             return client_ptr;

  5852.         }

  5853.     }

  5854. 

  5855.     return NULL;

  5856. }

  5857. 

  5858. static

  5859. struct jack_graph_client *

  5860. jack_controller_patchbay_create_client(

  5861.     struct jack_controller_patchbay *patchbay_ptr,

  5862.     const char *client_name,    /* not '\0' terminated */

  5863.     size_t client_name_len)     /* without terminating '\0' */

  5864. {

  5865.     struct jack_graph_client * client_ptr;

  5866. 

  5867.     client_ptr = malloc(sizeof(struct jack_graph_client));

  5868.     if (client_ptr == NULL)

  5869.     {

  5870.         jack_error("Memory allocation of jack_graph_client structure failed.");

  5871.         goto fail;

  5872.     }

  5873. 

  5874.     client_ptr->name = malloc(client_name_len + 1);

  5875.     if (client_ptr->name == NULL)

  5876.     {

  5877.         jack_error("malloc() failed to allocate memory for client name.");

  5878.         goto fail_free_client;

  5879.     }

  5880. 

  5881.     memcpy(client_ptr->name, client_name, client_name_len);

  5882.     client_ptr->name[client_name_len] = 0;

  5883. 

  5884.     client_ptr->pid = jack_get_client_pid(client_ptr->name);

  5885.     jack_info("New client '%s' with PID %d", client_ptr->name, client_ptr->pid);

  5886. 

  5887.     client_ptr->id = patchbay_ptr->next_client_id++;

  5888.     INIT_LIST_HEAD(&client_ptr->ports);

  5889. 

  5890. 

  5891.     pthread_mutex_lock(&patchbay_ptr->lock);

  5892.     list_add_tail(&client_ptr->siblings, &patchbay_ptr->graph.clients);

  5893.     patchbay_ptr->graph.version++;

  5894.     jack_controller_patchbay_send_signal_client_appeared(patchbay_ptr->graph.version, client_ptr->id, client_ptr->name);

  5895.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  5896.     pthread_mutex_unlock(&patchbay_ptr->lock);

  5897. 

  5898.     return client_ptr;

  5899. 

  5900. fail_free_client:

  5901.     free(client_ptr);

  5902. 

  5903. fail:

  5904.     return NULL;

  5905. }

  5906. 

  5907. static

  5908. void

  5909. jack_controller_patchbay_destroy_client(

  5910.     struct jack_controller_patchbay *patchbay_ptr,

  5911.     struct jack_graph_client *client_ptr)

  5912. {

  5913.     pthread_mutex_lock(&patchbay_ptr->lock);

  5914.     list_del(&client_ptr->siblings);

  5915.     patchbay_ptr->graph.version++;

  5916.     jack_controller_patchbay_send_signal_client_disappeared(patchbay_ptr->graph.version, client_ptr->id, client_ptr->name);

  5917.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  5918.     pthread_mutex_unlock(&patchbay_ptr->lock);

  5919. 

  5920.     free(client_ptr->name);

  5921.     free(client_ptr);

  5922. }

  5923. 

  5924. static

  5925. void

  5926. jack_controller_patchbay_destroy_client_by_name(

  5927.     struct jack_controller_patchbay *patchbay_ptr,

  5928.     const char *client_name)    /* '\0' terminated */

  5929. {

  5930.     struct jack_graph_client *client_ptr;

  5931. 

  5932.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, client_name, strlen(client_name));

  5933.     if (client_ptr == NULL)

  5934.     {

  5935.         jack_error("Cannot destroy unknown client '%s'", client_name);

  5936.         return;

  5937.     }

  5938. 

  5939.     jack_controller_patchbay_destroy_client(patchbay_ptr, client_ptr);

  5940. }

  5941. 

  5942. static

  5943. void

  5944. jack_controller_patchbay_new_port(

  5945.     struct jack_controller_patchbay *patchbay_ptr,

  5946.     const char *port_full_name,

  5947.     uint32_t port_flags,

  5948.     uint32_t port_type)

  5949. {

  5950.     struct jack_graph_client *client_ptr;

  5951.     struct jack_graph_port *port_ptr;

  5952.     const char *port_short_name;

  5953.     size_t client_name_len;

  5954. 

  5955.     //jack_info("name: %s", port_full_name);

  5956. 

  5957.     port_short_name = strchr(port_full_name, ':');

  5958.     if (port_short_name == NULL)

  5959.     {

  5960.         jack_error("port name '%s' does not contain ':' separator char", port_full_name);

  5961.         return;

  5962.     }

  5963. 

  5964.     port_short_name++;          /* skip ':' separator char */

  5965. 

  5966.     client_name_len = port_short_name - port_full_name - 1; /* without terminating '\0' */

  5967. 

  5968.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, port_full_name, client_name_len);

  5969.     if (client_ptr == NULL)

  5970.     {

  5971.         client_ptr = jack_controller_patchbay_create_client(patchbay_ptr, port_full_name, client_name_len);

  5972.         if (client_ptr == NULL)

  5973.         {

  5974.             jack_error("Creation of new jack_graph client failed.");

  5975.             return;

  5976.         }

  5977.     }

  5978. 

  5979.     port_ptr = malloc(sizeof(struct jack_graph_port));

  5980.     if (port_ptr == NULL)

  5981.     {

  5982.         jack_error("Memory allocation of jack_graph_port structure failed.");

  5983.         return;

  5984.     }

  5985. 

  5986.     port_ptr->name = strdup(port_short_name);

  5987.     if (port_ptr->name == NULL)

  5988.     {

  5989.         jack_error("strdup() call for port name '%s' failed.", port_short_name);

  5990.         free(port_ptr);

  5991.         return;

  5992.     }

  5993. 

  5994.     port_ptr->id = patchbay_ptr->next_port_id++;

  5995.     port_ptr->flags = port_flags;

  5996.     port_ptr->type = port_type;

  5997.     port_ptr->client = client_ptr;

  5998. 

  5999.     pthread_mutex_lock(&patchbay_ptr->lock);

  6000.     list_add_tail(&port_ptr->siblings_client, &client_ptr->ports);

  6001.     list_add_tail(&port_ptr->siblings_graph, &patchbay_ptr->graph.ports);

  6002.     patchbay_ptr->graph.version++;

  6003.     jack_controller_patchbay_send_signal_port_appeared(

  6004.         patchbay_ptr->graph.version,

  6005.         client_ptr->id,

  6006.         client_ptr->name,

  6007.         port_ptr->id,

  6008.         port_ptr->name,

  6009.         port_ptr->flags,

  6010.         port_ptr->type);

  6011.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  6012.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6013. }

  6014. 

  6015. static

  6016. void

  6017. jack_controller_patchbay_remove_port(

  6018.     struct jack_controller_patchbay *patchbay_ptr,

  6019.     struct jack_graph_port *port_ptr)

  6020. {

  6021.     pthread_mutex_lock(&patchbay_ptr->lock);

  6022.     list_del(&port_ptr->siblings_client);

  6023.     list_del(&port_ptr->siblings_graph);

  6024.     patchbay_ptr->graph.version++;

  6025.     jack_controller_patchbay_send_signal_port_disappeared(patchbay_ptr->graph.version, port_ptr->client->id, port_ptr->client->name, port_ptr->id, port_ptr->name);

  6026.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  6027.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6028. 

  6029.     free(port_ptr->name);

  6030.     free(port_ptr);

  6031. }

  6032. 

  6033. static

  6034. struct jack_graph_port *

  6035. jack_controller_patchbay_find_port_by_id(

  6036.     struct jack_controller_patchbay *patchbay_ptr,

  6037.     uint64_t port_id)

  6038. {

  6039.     struct list_head *node_ptr;

  6040.     struct jack_graph_port *port_ptr;

  6041. 

  6042.     list_for_each(node_ptr, &patchbay_ptr->graph.ports)

  6043.     {

  6044.         port_ptr = list_entry(node_ptr, struct jack_graph_port, siblings_graph);

  6045.         if (port_ptr->id == port_id)

  6046.         {

  6047.             return port_ptr;

  6048.         }

  6049.     }

  6050. 

  6051.     return NULL;

  6052. }

  6053. 

  6054. static

  6055. struct jack_graph_port *

  6056. jack_controller_patchbay_find_client_port_by_name(

  6057.     struct jack_controller_patchbay *patchbay_ptr,

  6058.     struct jack_graph_client *client_ptr,

  6059.     const char *port_name)

  6060. {

  6061.     struct list_head *node_ptr;

  6062.     struct jack_graph_port *port_ptr;

  6063. 

  6064.     list_for_each(node_ptr, &client_ptr->ports)

  6065.     {

  6066.         port_ptr = list_entry(node_ptr, struct jack_graph_port, siblings_client);

  6067.         if (strcmp(port_ptr->name, port_name) == 0)

  6068.         {

  6069.             return port_ptr;

  6070.         }

  6071.     }

  6072. 

  6073.     return NULL;

  6074. }

  6075. 

  6076. static

  6077. struct jack_graph_port *

  6078. jack_controller_patchbay_find_port_by_full_name(

  6079.     struct jack_controller_patchbay *patchbay_ptr,

  6080.     const char *port_full_name)

  6081. {

  6082.     const char *port_short_name;

  6083.     size_t client_name_len;

  6084.     struct jack_graph_client *client_ptr;

  6085. 

  6086.     //jack_info("name: %s", port_full_name);

  6087. 

  6088.     port_short_name = strchr(port_full_name, ':');

  6089.     if (port_short_name == NULL)

  6090.     {

  6091.         jack_error("port name '%s' does not contain ':' separator char", port_full_name);

  6092.         return NULL;

  6093.     }

  6094. 

  6095.     port_short_name++;          /* skip ':' separator char */

  6096. 

  6097.     client_name_len = port_short_name - port_full_name - 1; /* without terminating '\0' */

  6098. 

  6099.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, port_full_name, client_name_len);

  6100.     if (client_ptr == NULL)

  6101.     {

  6102.         jack_error("cannot find client of port '%s'", port_full_name);

  6103.         return NULL;

  6104.     }

  6105. 

  6106.     return jack_controller_patchbay_find_client_port_by_name(patchbay_ptr, client_ptr, port_short_name);

  6107. }

  6108. 

  6109. static

  6110. struct jack_graph_port *

  6111. jack_controller_patchbay_find_port_by_names(

  6112.     struct jack_controller_patchbay *patchbay_ptr,

  6113.     const char *client_name,

  6114.     const char *port_name)

  6115. {

  6116.     struct jack_graph_client *client_ptr;

  6117. 

  6118.     client_ptr = jack_controller_patchbay_find_client(patchbay_ptr, client_name, strlen(client_name));

  6119.     if (client_ptr == NULL)

  6120.     {

  6121.         jack_error("cannot find client '%s'", client_name);

  6122.         return NULL;

  6123.     }

  6124. 

  6125.     return jack_controller_patchbay_find_client_port_by_name(patchbay_ptr, client_ptr, port_name);

  6126. }

  6127. 

  6128. static

  6129. struct jack_graph_connection *

  6130. jack_controller_patchbay_create_connection(

  6131.     struct jack_controller_patchbay *patchbay_ptr,

  6132.     struct jack_graph_port *port1_ptr,

  6133.     struct jack_graph_port *port2_ptr)

  6134. {

  6135.     struct jack_graph_connection * connection_ptr;

  6136. 

  6137.     connection_ptr = malloc(sizeof(struct jack_graph_connection));

  6138.     if (connection_ptr == NULL)

  6139.     {

  6140.         jack_error("Memory allocation of jack_graph_connection structure failed.");

  6141.         return NULL;

  6142.     }

  6143. 

  6144.     connection_ptr->id = patchbay_ptr->next_connection_id++;

  6145.     connection_ptr->port1 = port1_ptr;

  6146.     connection_ptr->port2 = port2_ptr;

  6147. 

  6148.     pthread_mutex_lock(&patchbay_ptr->lock);

  6149.     list_add_tail(&connection_ptr->siblings, &patchbay_ptr->graph.connections);

  6150.     patchbay_ptr->graph.version++;

  6151.     jack_controller_patchbay_send_signal_ports_connected(

  6152.         patchbay_ptr->graph.version,

  6153.         port1_ptr->client->id,

  6154.         port1_ptr->client->name,

  6155.         port1_ptr->id,

  6156.         port1_ptr->name,

  6157.         port2_ptr->client->id,

  6158.         port2_ptr->client->name,

  6159.         port2_ptr->id,

  6160.         port2_ptr->name,

  6161.         connection_ptr->id);

  6162.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  6163.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6164. 

  6165.     return connection_ptr;

  6166. }

  6167. 

  6168. static

  6169. void

  6170. jack_controller_patchbay_destroy_connection(

  6171.     struct jack_controller_patchbay *patchbay_ptr,

  6172.     struct jack_graph_connection *connection_ptr)

  6173. {

  6174.     pthread_mutex_lock(&patchbay_ptr->lock);

  6175.     list_del(&connection_ptr->siblings);

  6176.     patchbay_ptr->graph.version++;

  6177.     jack_controller_patchbay_send_signal_ports_disconnected(

  6178.         patchbay_ptr->graph.version,

  6179.         connection_ptr->port1->client->id,

  6180.         connection_ptr->port1->client->name,

  6181.         connection_ptr->port1->id,

  6182.         connection_ptr->port1->name,

  6183.         connection_ptr->port2->client->id,

  6184.         connection_ptr->port2->client->name,

  6185.         connection_ptr->port2->id,

  6186.         connection_ptr->port2->name,

  6187.         connection_ptr->id);

  6188.     jack_controller_patchbay_send_signal_graph_changed(patchbay_ptr->graph.version);

  6189.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6190. 

  6191.     free(connection_ptr);

  6192. }

  6193. 

  6194. static

  6195. struct jack_graph_connection *

  6196. jack_controller_patchbay_find_connection(

  6197.     struct jack_controller_patchbay *patchbay_ptr,

  6198.     struct jack_graph_port *port1_ptr,

  6199.     struct jack_graph_port *port2_ptr)

  6200. {

  6201.     struct list_head *node_ptr;

  6202.     struct jack_graph_connection *connection_ptr;

  6203. 

  6204.     list_for_each(node_ptr, &patchbay_ptr->graph.connections)

  6205.     {

  6206.         connection_ptr = list_entry(node_ptr, struct jack_graph_connection, siblings);

  6207.         if ((connection_ptr->port1 == port1_ptr &&

  6208.              connection_ptr->port2 == port2_ptr) ||

  6209.             (connection_ptr->port1 == port2_ptr &&

  6210.              connection_ptr->port2 == port1_ptr))

  6211.         {

  6212.             return connection_ptr;

  6213.         }

  6214.     }

  6215. 

  6216.     return NULL;

  6217. }

  6218. 

  6219. static

  6220. struct jack_graph_connection *

  6221. jack_controller_patchbay_find_connection_by_id(

  6222.     struct jack_controller_patchbay *patchbay_ptr,

  6223.     uint64_t connection_id)

  6224. {

  6225.     struct list_head *node_ptr;

  6226.     struct jack_graph_connection *connection_ptr;

  6227. 

  6228.     list_for_each(node_ptr, &patchbay_ptr->graph.connections)

  6229.     {

  6230.         connection_ptr = list_entry(node_ptr, struct jack_graph_connection, siblings);

  6231.         if (connection_ptr->id == connection_id)

  6232.         {

  6233.             return connection_ptr;

  6234.         }

  6235.     }

  6236. 

  6237.     return NULL;

  6238. }

  6239. 

  6240. static

  6241. bool

  6242. jack_controller_patchbay_connect(

  6243.     struct jack_dbus_method_call *dbus_call_ptr,

  6244.     struct jack_controller *controller_ptr,

  6245.     struct jack_graph_port *port1_ptr,

  6246.     struct jack_graph_port *port2_ptr)

  6247. {

  6248.     int ret;

  6249.     char port1_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  6250.     char port2_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  6251. 

  6252.     sprintf(port1_name, "%s:%s", port1_ptr->client->name, port1_ptr->name);

  6253.     sprintf(port2_name, "%s:%s", port2_ptr->client->name, port2_ptr->name);

  6254. 

  6255.     ret = jack_connect(controller_ptr->client, port1_name, port2_name);

  6256.     if (ret != 0)

  6257.     {

  6258.         jack_dbus_error(dbus_call_ptr, JACK_DBUS_ERROR_GENERIC, "jack_connect() failed with %d", ret);

  6259.         return false;

  6260.     }

  6261. 

  6262.     return true;

  6263. }

  6264. 

  6265. static

  6266. bool

  6267. jack_controller_patchbay_disconnect(

  6268.     struct jack_dbus_method_call *dbus_call_ptr,

  6269.     struct jack_controller *controller_ptr,

  6270.     struct jack_graph_port *port1_ptr,

  6271.     struct jack_graph_port *port2_ptr)

  6272. {

  6273.     int ret;

  6274.     char port1_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  6275.     char port2_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  6276. 

  6277.     sprintf(port1_name, "%s:%s", port1_ptr->client->name, port1_ptr->name);

  6278.     sprintf(port2_name, "%s:%s", port2_ptr->client->name, port2_ptr->name);

  6279. 

  6280.     ret = jack_disconnect(controller_ptr->client, port1_name, port2_name);

  6281.     if (ret != 0)

  6282.     {

  6283.         jack_dbus_error(dbus_call_ptr, JACK_DBUS_ERROR_GENERIC, "jack_connect() failed with %d", ret);

  6284.         return false;

  6285.     }

  6286. 

  6287.     return true;

  6288. }

  6289. 

  6290. #define controller_ptr ((struct jack_controller *)call->context)

  6291. #define patchbay_ptr ((struct jack_controller_patchbay *)controller_ptr->patchbay_context)

  6292. 

  6293. static

  6294. void

  6295. jack_controller_dbus_get_all_ports(

  6296.     struct jack_dbus_method_call * call)

  6297. {

  6298.     struct list_head * client_node_ptr;

  6299.     struct list_head * port_node_ptr;

  6300.     struct jack_graph_client * client_ptr;

  6301.     struct jack_graph_port * port_ptr;

  6302.     DBusMessageIter iter, sub_iter;

  6303.     char fullname[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];

  6304.     char *fullname_var = fullname;

  6305. 

  6306.     if (!controller_ptr->started)

  6307.     {

  6308.         jack_dbus_error(

  6309.             call,

  6310.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  6311.             "Can't execute this method with stopped JACK server");

  6312.         return;

  6313.     }

  6314. 

  6315.     call->reply = dbus_message_new_method_return (call->message);

  6316.     if (!call->reply)

  6317.     {

  6318.         goto fail;

  6319.     }

  6320. 

  6321.     dbus_message_iter_init_append (call->reply, &iter);

  6322. 

  6323.     if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &sub_iter))

  6324.     {

  6325.         goto fail_unref;

  6326.     }

  6327. 

  6328.     pthread_mutex_lock(&patchbay_ptr->lock);

  6329. 

  6330.     list_for_each(client_node_ptr, &patchbay_ptr->graph.clients)

  6331.     {

  6332.         client_ptr = list_entry(client_node_ptr, struct jack_graph_client, siblings);

  6333. 

  6334.         list_for_each(port_node_ptr, &client_ptr->ports)

  6335.         {

  6336.             port_ptr = list_entry(port_node_ptr, struct jack_graph_port, siblings_client);

  6337. 

  6338.             jack_info("%s:%s", client_ptr->name, port_ptr->name);

  6339.             sprintf(fullname, "%s:%s", client_ptr->name, port_ptr->name);

  6340.             if (!dbus_message_iter_append_basic (&sub_iter, DBUS_TYPE_STRING, &fullname_var))

  6341.             {

  6342.                 pthread_mutex_unlock(&patchbay_ptr->lock);

  6343.                 dbus_message_iter_close_container (&iter, &sub_iter);

  6344.                 goto fail_unref;

  6345.             }

  6346.         }

  6347.     }

  6348. 

  6349.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6350. 

  6351.     if (!dbus_message_iter_close_container (&iter, &sub_iter))

  6352.     {

  6353.         goto fail_unref;

  6354.     }

  6355. 

  6356.     return;

  6357. 

  6358. fail_unref:

  6359.     dbus_message_unref (call->reply);

  6360.     call->reply = NULL;

  6361. 

  6362. fail:

  6363.     jack_error ("Ran out of memory trying to construct method return");

  6364. }

  6365. 

  6366. static

  6367. void

  6368. jack_controller_dbus_get_graph(

  6369.     struct jack_dbus_method_call * call)

  6370. {

  6371.     struct list_head * client_node_ptr;

  6372.     struct list_head * port_node_ptr;

  6373.     struct list_head * connection_node_ptr;

  6374.     struct jack_graph_client * client_ptr;

  6375.     struct jack_graph_port * port_ptr;

  6376.     struct jack_graph_connection * connection_ptr;

  6377.     DBusMessageIter iter;

  6378.     DBusMessageIter clients_array_iter;

  6379.     DBusMessageIter client_struct_iter;

  6380.     DBusMessageIter ports_array_iter;

  6381.     DBusMessageIter port_struct_iter;

  6382.     dbus_uint64_t version;

  6383.     DBusMessageIter connections_array_iter;

  6384.     DBusMessageIter connection_struct_iter;

  6385. 

  6386.     if (!controller_ptr->started)

  6387.     {

  6388.         jack_dbus_error(

  6389.             call,

  6390.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  6391.             "Can't execute this method with stopped JACK server");

  6392.         return;

  6393.     }

  6394. 

  6395.     if (!jack_dbus_get_method_args(call, DBUS_TYPE_UINT64, &version, DBUS_TYPE_INVALID))

  6396.     {

  6397.         /* The method call had invalid arguments meaning that

  6398.          * jack_dbus_get_method_args() has constructed an error for us.

  6399.          */

  6400.         goto exit;

  6401.     }

  6402. 

  6403.     //jack_info("Getting graph, know version is %" PRIu32, version);

  6404. 

  6405.     call->reply = dbus_message_new_method_return(call->message);

  6406.     if (!call->reply)

  6407.     {

  6408.         jack_error("Ran out of memory trying to construct method return");

  6409.         goto exit;

  6410.     }

  6411. 

  6412.     dbus_message_iter_init_append (call->reply, &iter);

  6413. 

  6414.     pthread_mutex_lock(&patchbay_ptr->lock);

  6415. 

  6416.     if (version > patchbay_ptr->graph.version)

  6417.     {

  6418.         jack_dbus_error(

  6419.             call,

  6420.             JACK_DBUS_ERROR_INVALID_ARGS,

  6421.             "known graph version %" PRIu64 " is newer than actual version %" PRIu64,

  6422.             version,

  6423.             patchbay_ptr->graph.version);

  6424.         pthread_mutex_unlock(&patchbay_ptr->lock);

  6425.         goto exit;

  6426.     }

  6427. 

  6428.     if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT64, &patchbay_ptr->graph.version))

  6429.     {

  6430.         goto nomem_unlock;

  6431.     }

  6432. 

  6433.     if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tsa(tsuu))", &clients_array_iter))

  6434.     {

  6435.         goto nomem_unlock;

  6436.     }

  6437. 

  6438.     if (version < patchbay_ptr->graph.version)

  6439.     {

  6440.         list_for_each(client_node_ptr, &patchbay_ptr->graph.clients)

  6441.         {

  6442.             client_ptr = list_entry(client_node_ptr, struct jack_graph_client, siblings);

  6443. 

  6444.             if (!dbus_message_iter_open_container (&clients_array_iter, DBUS_TYPE_STRUCT, NULL, &client_struct_iter))

  6445.             {

  6446.                 goto nomem_close_clients_array;

  6447.             }

  6448. 

  6449.             if (!dbus_message_iter_append_basic(&client_struct_iter, DBUS_TYPE_UINT64, &client_ptr->id))

  6450.             {

  6451.                 goto nomem_close_client_struct;

  6452.             }

  6453. 

  6454.             if (!dbus_message_iter_append_basic(&client_struct_iter, DBUS_TYPE_STRING, &client_ptr->name))

  6455.             {

  6456.                 goto nomem_close_client_struct;

  6457.             }

  6458. 

  6459.             if (!dbus_message_iter_open_container(&client_struct_iter, DBUS_TYPE_ARRAY, "(tsuu)", &ports_array_iter))

  6460.             {

  6461.                 goto nomem_close_client_struct;

  6462.             }

  6463. 

  6464.             list_for_each(port_node_ptr, &client_ptr->ports)

  6465.             {

  6466.                 port_ptr = list_entry(port_node_ptr, struct jack_graph_port, siblings_client);

  6467. 

  6468.                 if (!dbus_message_iter_open_container(&ports_array_iter, DBUS_TYPE_STRUCT, NULL, &port_struct_iter))

  6469.                 {

  6470.                     goto nomem_close_ports_array;

  6471.                 }

  6472. 

  6473.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT64, &port_ptr->id))

  6474.                 {

  6475.                     goto nomem_close_port_struct;

  6476.                 }

  6477. 

  6478.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_STRING, &port_ptr->name))

  6479.                 {

  6480.                     goto nomem_close_port_struct;

  6481.                 }

  6482. 

  6483.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT32, &port_ptr->flags))

  6484.                 {

  6485.                     goto nomem_close_port_struct;

  6486.                 }

  6487. 

  6488.                 if (!dbus_message_iter_append_basic(&port_struct_iter, DBUS_TYPE_UINT32, &port_ptr->type))

  6489.                 {

  6490.                     goto nomem_close_port_struct;

  6491.                 }

  6492. 

  6493.                 if (!dbus_message_iter_close_container(&ports_array_iter, &port_struct_iter))

  6494.                 {

  6495.                     goto nomem_close_ports_array;

  6496.                 }

  6497.             }

  6498. 

  6499.             if (!dbus_message_iter_close_container(&client_struct_iter, &ports_array_iter))

  6500.             {

  6501.                 goto nomem_close_client_struct;

  6502.             }

  6503. 

  6504.             if (!dbus_message_iter_close_container(&clients_array_iter, &client_struct_iter))

  6505.             {

  6506.                 goto nomem_close_clients_array;

  6507.             }

  6508.         }

  6509.     }

  6510. 

  6511.     if (!dbus_message_iter_close_container(&iter, &clients_array_iter))

  6512.     {

  6513.         goto nomem_unlock;

  6514.     }

  6515. 

  6516.     if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tstststst)", &connections_array_iter))

  6517.     {

  6518.         goto nomem_unlock;

  6519.     }

  6520. 

  6521.     if (version < patchbay_ptr->graph.version)

  6522.     {

  6523.         list_for_each(connection_node_ptr, &patchbay_ptr->graph.connections)

  6524.         {

  6525.             connection_ptr = list_entry(connection_node_ptr, struct jack_graph_connection, siblings);

  6526. 

  6527.             if (!dbus_message_iter_open_container(&connections_array_iter, DBUS_TYPE_STRUCT, NULL, &connection_struct_iter))

  6528.             {

  6529.                 goto nomem_close_connections_array;

  6530.             }

  6531. 

  6532.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port1->client->id))

  6533.             {

  6534.                 goto nomem_close_connection_struct;

  6535.             }

  6536. 

  6537.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port1->client->name))

  6538.             {

  6539.                 goto nomem_close_connection_struct;

  6540.             }

  6541. 

  6542.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port1->id))

  6543.             {

  6544.                 goto nomem_close_connection_struct;

  6545.             }

  6546. 

  6547.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port1->name))

  6548.             {

  6549.                 goto nomem_close_connection_struct;

  6550.             }

  6551. 

  6552.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port2->client->id))

  6553.             {

  6554.                 goto nomem_close_connection_struct;

  6555.             }

  6556. 

  6557.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port2->client->name))

  6558.             {

  6559.                 goto nomem_close_connection_struct;

  6560.             }

  6561. 

  6562.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->port2->id))

  6563.             {

  6564.                 goto nomem_close_connection_struct;

  6565.             }

  6566. 

  6567.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_STRING, &connection_ptr->port2->name))

  6568.             {

  6569.                 goto nomem_close_connection_struct;

  6570.             }

  6571. 

  6572.             if (!dbus_message_iter_append_basic(&connection_struct_iter, DBUS_TYPE_UINT64, &connection_ptr->id))

  6573.             {

  6574.                 goto nomem_close_connection_struct;

  6575.             }

  6576. 

  6577.             if (!dbus_message_iter_close_container(&connections_array_iter, &connection_struct_iter))

  6578.             {

  6579.                 goto nomem_close_connections_array;

  6580.             }

  6581.         }

  6582.     }

  6583. 

  6584.     if (!dbus_message_iter_close_container(&iter, &connections_array_iter))

  6585.     {

  6586.         goto nomem_unlock;

  6587.     }

  6588. 

  6589.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6590. 

  6591.     return;

  6592. 

  6593. nomem_close_connection_struct:

  6594.     dbus_message_iter_close_container(&connections_array_iter, &connection_struct_iter);

  6595. 

  6596. nomem_close_connections_array:

  6597.     dbus_message_iter_close_container(&iter, &connections_array_iter);

  6598.     goto nomem_unlock;

  6599. 

  6600. nomem_close_port_struct:

  6601.     dbus_message_iter_close_container(&ports_array_iter, &port_struct_iter);

  6602. 

  6603. nomem_close_ports_array:

  6604.     dbus_message_iter_close_container(&client_struct_iter, &ports_array_iter);

  6605. 

  6606. nomem_close_client_struct:

  6607.     dbus_message_iter_close_container(&clients_array_iter, &client_struct_iter);

  6608. 

  6609. nomem_close_clients_array:

  6610.     dbus_message_iter_close_container(&iter, &clients_array_iter);

  6611. 

  6612. nomem_unlock:

  6613.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6614. 

  6615. //nomem:

  6616.     dbus_message_unref(call->reply);

  6617.     call->reply = NULL;

  6618.     jack_error("Ran out of memory trying to construct method return");

  6619. 

  6620. exit:

  6621.     return;

  6622. }

  6623. 

  6624. static

  6625. void

  6626. jack_controller_dbus_connect_ports_by_name(

  6627.     struct jack_dbus_method_call * call)

  6628. {

  6629.     const char * client1_name;

  6630.     const char * port1_name;

  6631.     const char * client2_name;

  6632.     const char * port2_name;

  6633.     struct jack_graph_port *port1_ptr;

  6634.     struct jack_graph_port *port2_ptr;

  6635. 

  6636. /*  jack_info("jack_controller_dbus_connect_ports_by_name() called."); */

  6637. 

  6638.     if (!controller_ptr->started)

  6639.     {

  6640.         jack_dbus_error(

  6641.             call,

  6642.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  6643.             "Can't execute this method with stopped JACK server");

  6644.         return;

  6645.     }

  6646. 

  6647.     if (!jack_dbus_get_method_args(

  6648.             call,

  6649.             DBUS_TYPE_STRING,

  6650.             &client1_name,

  6651.             DBUS_TYPE_STRING,

  6652.             &port1_name,

  6653.             DBUS_TYPE_STRING,

  6654.             &client2_name,

  6655.             DBUS_TYPE_STRING,

  6656.             &port2_name,

  6657.             DBUS_TYPE_INVALID))

  6658.     {

  6659.         /* The method call had invalid arguments meaning that

  6660.          * jack_dbus_get_method_args() has constructed an error for us.

  6661.          */

  6662.         return;

  6663.     }

  6664. 

  6665. /*  jack_info("connecting %s:%s and %s:%s", client1_name, port1_name, client2_name, port2_name); */

  6666. 

  6667.     pthread_mutex_lock(&patchbay_ptr->lock);

  6668. 

  6669.     port1_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client1_name, port1_name);

  6670.     if (port1_ptr == NULL)

  6671.     {

  6672.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client1_name, port1_name);

  6673.         goto unlock;

  6674.     }

  6675. 

  6676.     port2_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client2_name, port2_name);

  6677.     if (port2_ptr == NULL)

  6678.     {

  6679.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client2_name, port2_name);

  6680.         goto unlock;

  6681.     }

  6682. 

  6683.     if (!jack_controller_patchbay_connect(

  6684.             call,

  6685.             controller_ptr,

  6686.             port1_ptr,

  6687.             port2_ptr))

  6688.     {

  6689.         /* jack_controller_patchbay_connect() constructed error reply */

  6690.         goto unlock;

  6691.     }

  6692. 

  6693.     jack_dbus_construct_method_return_empty(call);

  6694. 

  6695. unlock:

  6696.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6697. }

  6698. 

  6699. static

  6700. void

  6701. jack_controller_dbus_connect_ports_by_id(

  6702.     struct jack_dbus_method_call * call)

  6703. {

  6704.     dbus_uint64_t port1_id;

  6705.     dbus_uint64_t port2_id;

  6706.     struct jack_graph_port *port1_ptr;

  6707.     struct jack_graph_port *port2_ptr;

  6708. 

  6709. /*     jack_info("jack_controller_dbus_connect_ports_by_id() called."); */

  6710. 

  6711.     if (!controller_ptr->started)

  6712.     {

  6713.         jack_dbus_error(

  6714.             call,

  6715.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  6716.             "Can't execute this method with stopped JACK server");

  6717.         return;

  6718.     }

  6719. 

  6720.     if (!jack_dbus_get_method_args(

  6721.             call,

  6722.             DBUS_TYPE_UINT64,

  6723.             &port1_id,

  6724.             DBUS_TYPE_UINT64,

  6725.             &port2_id,

  6726.             DBUS_TYPE_INVALID))

  6727.     {

  6728.         /* The method call had invalid arguments meaning that

  6729.          * jack_dbus_get_method_args() has constructed an error for us.

  6730.          */

  6731.         return;

  6732.     }

  6733. 

  6734.     pthread_mutex_lock(&patchbay_ptr->lock);

  6735. 

  6736.     port1_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port1_id);

  6737.     if (port1_ptr == NULL)

  6738.     {

  6739.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port1_id);

  6740.         goto unlock;

  6741.     }

  6742. 

  6743.     port2_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port2_id);

  6744.     if (port2_ptr == NULL)

  6745.     {

  6746.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port2_id);

  6747.         goto unlock;

  6748.     }

  6749. 

  6750.     if (!jack_controller_patchbay_connect(

  6751.             call,

  6752.             controller_ptr,

  6753.             port1_ptr,

  6754.             port2_ptr))

  6755.     {

  6756.         /* jack_controller_patchbay_connect() constructed error reply */

  6757.         goto unlock;

  6758.     }

  6759. 

  6760.     jack_dbus_construct_method_return_empty(call);

  6761. 

  6762. unlock:

  6763.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6764. }

  6765. 

  6766. static

  6767. void

  6768. jack_controller_dbus_disconnect_ports_by_name(

  6769.     struct jack_dbus_method_call * call)

  6770. {

  6771.     const char * client1_name;

  6772.     const char * port1_name;

  6773.     const char * client2_name;

  6774.     const char * port2_name;

  6775.     struct jack_graph_port *port1_ptr;

  6776.     struct jack_graph_port *port2_ptr;

  6777. 

  6778. /*  jack_info("jack_controller_dbus_disconnect_ports_by_name() called."); */

  6779. 

  6780.     if (!controller_ptr->started)

  6781.     {

  6782.         jack_dbus_error(

  6783.             call,

  6784.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  6785.             "Can't execute this method with stopped JACK server");

  6786.         return;

  6787.     }

  6788. 

  6789.     if (!jack_dbus_get_method_args(

  6790.             call,

  6791.             DBUS_TYPE_STRING,

  6792.             &client1_name,

  6793.             DBUS_TYPE_STRING,

  6794.             &port1_name,

  6795.             DBUS_TYPE_STRING,

  6796.             &client2_name,

  6797.             DBUS_TYPE_STRING,

  6798.             &port2_name,

  6799.             DBUS_TYPE_INVALID))

  6800.     {

  6801.         /* The method call had invalid arguments meaning that

  6802.          * jack_dbus_get_method_args() has constructed an error for us.

  6803.          */

  6804.         return;

  6805.     }

  6806. 

  6807. /*  jack_info("disconnecting %s:%s and %s:%s", client1_name, port1_name, client2_name, port2_name); */

  6808. 

  6809.     pthread_mutex_lock(&patchbay_ptr->lock);

  6810. 

  6811.     port1_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client1_name, port1_name);

  6812.     if (port1_ptr == NULL)

  6813.     {

  6814.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client1_name, port1_name);

  6815.         goto unlock;

  6816.     }

  6817. 

  6818.     port2_ptr = jack_controller_patchbay_find_port_by_names(patchbay_ptr, client2_name, port2_name);

  6819.     if (port2_ptr == NULL)

  6820.     {

  6821.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port '%s':'%s'", client2_name, port2_name);

  6822.         goto unlock;

  6823.     }

  6824. 

  6825.     if (!jack_controller_patchbay_disconnect(

  6826.             call,

  6827.             controller_ptr,

  6828.             port1_ptr,

  6829.             port2_ptr))

  6830.     {

  6831.         /* jack_controller_patchbay_connect() constructed error reply */

  6832.         goto unlock;

  6833.     }

  6834. 

  6835.     jack_dbus_construct_method_return_empty(call);

  6836. 

  6837. unlock:

  6838.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6839. }

  6840. 

  6841. static

  6842. void

  6843. jack_controller_dbus_disconnect_ports_by_id(

  6844.     struct jack_dbus_method_call * call)

  6845. {

  6846.     dbus_uint64_t port1_id;

  6847.     dbus_uint64_t port2_id;

  6848.     struct jack_graph_port *port1_ptr;

  6849.     struct jack_graph_port *port2_ptr;

  6850. 

  6851. /*     jack_info("jack_controller_dbus_disconnect_ports_by_id() called."); */

  6852. 

  6853.     if (!controller_ptr->started)

  6854.     {

  6855.         jack_dbus_error(

  6856.             call,

  6857.             JACK_DBUS_ERROR_SERVER_NOT_RUNNING,

  6858.             "Can't execute this method with stopped JACK server");

  6859.         return;

  6860.     }

  6861. 

  6862.     if (!jack_dbus_get_method_args(

  6863.             call,

  6864.             DBUS_TYPE_UINT64,

  6865.             &port1_id,

  6866.             DBUS_TYPE_UINT64,

  6867.             &port2_id,

  6868.             DBUS_TYPE_INVALID))

  6869.     {

  6870.         /* The method call had invalid arguments meaning that

  6871.          * jack_dbus_get_method_args() has constructed an error for us.

  6872.          */

  6873.         return;

  6874.     }

  6875. 

  6876.     pthread_mutex_lock(&patchbay_ptr->lock);

  6877. 

  6878.     port1_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port1_id);

  6879.     if (port1_ptr == NULL)

  6880.     {

  6881.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port1_id);

  6882.         return;

  6883.     }

  6884. 

  6885.     port2_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port2_id);

  6886.     if (port2_ptr == NULL)

  6887.     {

  6888.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port2_id);

  6889.         return;

  6890.     }

  6891. 

  6892.     if (!jack_controller_patchbay_disconnect(

  6893.             call,

  6894.             controller_ptr,

  6895.             port1_ptr,

  6896.             port2_ptr))

  6897.     {

  6898.         /* jack_controller_patchbay_connect() constructed error reply */

  6899.         goto unlock;

  6900.     }

  6901. 

  6902.     jack_dbus_construct_method_return_empty(call);

  6903. 

  6904. unlock:

  6905.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6906. }

  6907. 

  6908. static

  6909. void

  6910. jack_controller_dbus_disconnect_ports_by_connection_id(

  6911.     struct jack_dbus_method_call * call)

  6912. {

  6913.     dbus_uint64_t connection_id;

  6914.     struct jack_graph_connection *connection_ptr;

  6915. 

  6916. /*     jack_info("jack_controller_dbus_disconnect_ports_by_id() called."); */

  6917. 

  6918.     if (!jack_dbus_get_method_args(

  6919.             call,

  6920.             DBUS_TYPE_UINT64,

  6921.             &connection_id,

  6922.             DBUS_TYPE_INVALID))

  6923.     {

  6924.         /* The method call had invalid arguments meaning that

  6925.          * jack_dbus_get_method_args() has constructed an error for us.

  6926.          */

  6927.         return;

  6928.     }

  6929. 

  6930.     pthread_mutex_lock(&patchbay_ptr->lock);

  6931. 

  6932.     connection_ptr = jack_controller_patchbay_find_connection_by_id(patchbay_ptr, connection_id);

  6933.     if (connection_ptr == NULL)

  6934.     {

  6935.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find connection %" PRIu64, connection_id);

  6936.         goto unlock;

  6937.     }

  6938. 

  6939.     if (!jack_controller_patchbay_disconnect(

  6940.             call,

  6941.             controller_ptr,

  6942.             connection_ptr->port1,

  6943.             connection_ptr->port2))

  6944.     {

  6945.         /* jack_controller_patchbay_connect() constructed error reply */

  6946.         goto unlock;

  6947.     }

  6948. 

  6949.     jack_dbus_construct_method_return_empty(call);

  6950. 

  6951. unlock:

  6952.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6953. }

  6954. 

  6955. static

  6956. void

  6957. jack_controller_dbus_get_client_pid(

  6958.     struct jack_dbus_method_call * call)

  6959. {

  6960.     dbus_uint64_t client_id;

  6961.     struct jack_graph_client *client_ptr;

  6962.     message_arg_t arg;

  6963. 

  6964. /*     jack_info("jack_controller_dbus_get_client_pid() called."); */

  6965. 

  6966.     if (!jack_dbus_get_method_args(

  6967.             call,

  6968.             DBUS_TYPE_UINT64,

  6969.             &client_id,

  6970.             DBUS_TYPE_INVALID))

  6971.     {

  6972.         /* The method call had invalid arguments meaning that

  6973.          * jack_dbus_get_method_args() has constructed an error for us.

  6974.          */

  6975.         return;

  6976.     }

  6977. 

  6978.     pthread_mutex_lock(&patchbay_ptr->lock);

  6979. 

  6980.     client_ptr = jack_controller_patchbay_find_client_by_id(patchbay_ptr, client_id);

  6981.     if (client_ptr == NULL)

  6982.     {

  6983.         jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find client %" PRIu64, client_id);

  6984.         goto unlock;

  6985.     }

  6986. 

  6987.     arg.int64 = client_ptr->pid;

  6988. 

  6989.     jack_dbus_construct_method_return_single(call, DBUS_TYPE_INT64, arg);

  6990. 

  6991. unlock:

  6992.     pthread_mutex_unlock(&patchbay_ptr->lock);

  6993. }

  6994. 

  6995. #undef controller_ptr

  6996. #define controller_ptr ((struct jack_controller *)context)

  6997. 

  6998. static

  6999. int

  7000. jack_controller_graph_order_callback(

  7001.     void *context)

  7002. {

  7003.     const char **ports;

  7004.     int i;

  7005.     jack_port_t *port_ptr;

  7006.     

  7007.     if (patchbay_ptr->graph.version > 1)

  7008.     {

  7009.         /* we use this only for initial catchup */

  7010.         return 0;

  7011.     }

  7012.     

  7013.     ports = jack_get_ports(controller_ptr->client, NULL, NULL, 0);

  7014.     if (ports)

  7015.     {

  7016.         for (i = 0;  ports[i]; ++i)

  7017.         {

  7018.             jack_info("graph reorder: new port '%s'", ports[i]);

  7019.             port_ptr = jack_port_by_name(controller_ptr->client, ports[i]);;

  7020.             jack_controller_patchbay_new_port(patchbay_ptr, ports[i], jack_port_flags(port_ptr), jack_port_type_id(port_ptr));

  7021.         }

  7022. 

  7023.         free(ports);

  7024.     }

  7025. 

  7026.     if (patchbay_ptr->graph.version == 1)

  7027.     {

  7028.         /* we have empty initial graph, increment graph version,

  7029.            so we dont do jack_get_ports() again,

  7030.            on next next graph change */

  7031.         patchbay_ptr->graph.version++;

  7032.     }

  7033. 

  7034.     return 0;

  7035. }

  7036. 

  7037. void

  7038. jack_controller_client_registration_callback(

  7039.     const char *client_name,

  7040.     int created,

  7041.     void *context)

  7042. {

  7043.     if (created)

  7044.     {

  7045.         jack_log("client '%s' created", client_name);

  7046.         jack_controller_patchbay_create_client(patchbay_ptr, client_name, strlen(client_name));

  7047.     }

  7048.     else

  7049.     {

  7050.         jack_log("client '%s' destroyed", client_name);

  7051.         jack_controller_patchbay_destroy_client_by_name(patchbay_ptr, client_name);

  7052.     }

  7053. }

  7054. 

  7055. void

  7056. jack_controller_port_registration_callback(

  7057.     jack_port_id_t port_id,

  7058.     int created,

  7059.     void *context)

  7060. {

  7061.     jack_port_t *port_ptr;

  7062.     struct jack_graph_port *graph_port_ptr;

  7063.     const char *port_name;

  7064. 

  7065.     port_ptr = jack_port_by_id(controller_ptr->client, port_id);

  7066.     port_name = jack_port_name(port_ptr);

  7067. 

  7068.     if (created)

  7069.     {

  7070.         jack_log("port '%s' created", port_name);

  7071.         jack_controller_patchbay_new_port(patchbay_ptr, port_name, jack_port_flags(port_ptr), jack_port_type_id(port_ptr));

  7072.     }

  7073.     else

  7074.     {

  7075.         jack_log("port '%s' destroyed", port_name);

  7076.         graph_port_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port_name);

  7077.         if (graph_port_ptr == NULL)

  7078.         {

  7079.             jack_error("Failed to find port '%s' to destroy", port_name);

  7080.             return;

  7081.         }

  7082. 

  7083.         jack_controller_patchbay_remove_port(patchbay_ptr, graph_port_ptr);

  7084.     }

  7085. }

  7086. 

  7087. void

  7088. jack_controller_port_connect_callback(

  7089.     jack_port_id_t port1_id,

  7090.     jack_port_id_t port2_id,

  7091.     int connect,

  7092.     void *context)

  7093. {

  7094.     jack_port_t *port1;

  7095.     jack_port_t *port2;

  7096.     const char *port1_name;

  7097.     const char *port2_name;

  7098.     struct jack_graph_port *port1_ptr;

  7099.     struct jack_graph_port *port2_ptr;

  7100.     struct jack_graph_connection *connection_ptr;

  7101. 

  7102.     port1 = jack_port_by_id(controller_ptr->client, port1_id);

  7103.     port2 = jack_port_by_id(controller_ptr->client, port2_id);

  7104. 

  7105.     port1_name = jack_port_name(port1);

  7106.     port2_name = jack_port_name(port2);

  7107. 

  7108.     port1_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port1_name);

  7109.     if (port1_ptr == NULL)

  7110.     {

  7111.         jack_error("Failed to find port '%s' to [dis]connect", port1_name);

  7112.         return;

  7113.     }

  7114. 

  7115.     port2_ptr = jack_controller_patchbay_find_port_by_full_name(patchbay_ptr, port2_name);

  7116.     if (port2_ptr == NULL)

  7117.     {

  7118.         jack_error("Failed to find port '%s' to [dis]connect", port2_name);

  7119.         return;

  7120.     }

  7121. 

  7122.     if (connect)

  7123.     {

  7124.         jack_info("Connecting '%s' to '%s'", port1_name, port2_name);

  7125.         connection_ptr = jack_controller_patchbay_find_connection(patchbay_ptr, port1_ptr, port2_ptr);

  7126.         if (connection_ptr != NULL)

  7127.         {

  7128.             jack_error("'%s' and '%s' are already connected", port1_name, port2_name);

  7129.             return;

  7130.         }

  7131. 

  7132.         jack_controller_patchbay_create_connection(patchbay_ptr, port1_ptr, port2_ptr);

  7133.     }

  7134.     else

  7135.     {

  7136.         jack_info("Disonnecting '%s' from '%s'", port1_name, port2_name);

  7137.         connection_ptr = jack_controller_patchbay_find_connection(patchbay_ptr, port1_ptr, port2_ptr);

  7138.         if (connection_ptr == NULL)

  7139.         {

  7140.             jack_error("Cannot find connection being removed");

  7141.             return;

  7142.         }

  7143. 

  7144.         jack_controller_patchbay_destroy_connection(patchbay_ptr, connection_ptr);

  7145.     }

  7146. }

  7147. 

  7148. #undef controller_ptr

  7149. 

  7150. void

  7151. jack_controller_patchbay_uninit(

  7152.     struct jack_controller * controller_ptr)

  7153. {

  7154.     struct jack_graph_client *client_ptr;

  7155.     struct jack_graph_port *port_ptr;

  7156. 

  7157. /*     jack_info("jack_controller_patchbay_uninit() called"); */

  7158. 

  7159.     while (!list_empty(&patchbay_ptr->graph.ports))

  7160.     {

  7161.         port_ptr = list_entry(patchbay_ptr->graph.ports.next, struct jack_graph_port, siblings_graph);

  7162.         jack_controller_patchbay_remove_port(patchbay_ptr, port_ptr);

  7163.     }

  7164. 

  7165.     while (!list_empty(&patchbay_ptr->graph.clients))

  7166.     {

  7167.         client_ptr = list_entry(patchbay_ptr->graph.clients.next, struct jack_graph_client, siblings);

  7168.         jack_controller_patchbay_destroy_client(patchbay_ptr, client_ptr);

  7169.     }

  7170. 

  7171.     pthread_mutex_destroy(&patchbay_ptr->lock);

  7172. }

  7173. 

  7174. #undef patchbay_ptr

  7175. 

  7176. bool

  7177. jack_controller_patchbay_init(

  7178.     struct jack_controller * controller_ptr)

  7179. {

  7180.     int ret;

  7181.     struct jack_controller_patchbay * patchbay_ptr;

  7182.     pthread_mutexattr_t attr;

  7183. 

  7184. /*     jack_info("jack_controller_patchbay_init() called"); */

  7185. 

  7186.     patchbay_ptr = malloc(sizeof(struct jack_controller_patchbay));

  7187.     if (patchbay_ptr == NULL)

  7188.     {

  7189.         jack_error("Memory allocation of jack_controller_patchbay structure failed.");

  7190.         goto fail;

  7191.     }

  7192. 

  7193.     ret = pthread_mutexattr_init(&attr);

  7194.     if (ret != 0)

  7195.     {

  7196.         goto fail;

  7197.     }

  7198. 

  7199.     ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

  7200.     if (ret != 0)

  7201.     {

  7202.         goto fail;

  7203.     }

  7204. 

  7205.     pthread_mutex_init(&patchbay_ptr->lock, &attr);

  7206.     INIT_LIST_HEAD(&patchbay_ptr->graph.clients);

  7207.     INIT_LIST_HEAD(&patchbay_ptr->graph.ports);

  7208.     INIT_LIST_HEAD(&patchbay_ptr->graph.connections);

  7209.     patchbay_ptr->graph.version = 1;

  7210.     patchbay_ptr->next_client_id = 1;

  7211.     patchbay_ptr->next_port_id = 1;

  7212.     patchbay_ptr->next_connection_id = 1;

  7213. 

  7214.     controller_ptr->patchbay_context = patchbay_ptr;

  7215. 

  7216.     ret = jack_set_graph_order_callback(controller_ptr->client, jack_controller_graph_order_callback, controller_ptr);

  7217.     if (ret != 0)

  7218.     {

  7219.         jack_error("jack_set_graph_order_callback() failed with error %d", ret);

  7220.         goto fail_uninit_mutex;

  7221.     }

  7222. 

  7223.     ret = jack_set_client_registration_callback(controller_ptr->client, jack_controller_client_registration_callback, controller_ptr);

  7224.     if (ret != 0)

  7225.     {

  7226.         jack_error("jack_set_client_registration_callback() failed with error %d", ret);

  7227.         goto fail_uninit_mutex;

  7228.     }

  7229. 

  7230.     ret = jack_set_port_registration_callback(controller_ptr->client, jack_controller_port_registration_callback, controller_ptr);

  7231.     if (ret != 0)

  7232.     {

  7233.         jack_error("jack_set_port_registration_callback() failed with error %d", ret);

  7234.         goto fail_uninit_mutex;

  7235.     }

  7236. 

  7237.     ret = jack_set_port_connect_callback(controller_ptr->client, jack_controller_port_connect_callback, controller_ptr);

  7238.     if (ret != 0)

  7239.     {

  7240.         jack_error("jack_set_port_connect_callback() failed with error %d", ret);

  7241.         goto fail_uninit_mutex;

  7242.     }

  7243. 

  7244.     return true;

  7245. 

  7246. fail_uninit_mutex:

  7247.     pthread_mutex_destroy(&patchbay_ptr->lock);

  7248. 

  7249. fail:

  7250.     return false;

  7251. }

  7252. 

  7253. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetAllPorts)

  7254.     JACK_DBUS_METHOD_ARGUMENT("ports_list", "as", true)

  7255. JACK_DBUS_METHOD_ARGUMENTS_END

  7256. 

  7257. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetGraph)

  7258.     JACK_DBUS_METHOD_ARGUMENT("known_graph_version", DBUS_TYPE_UINT64_AS_STRING, false)

  7259.     JACK_DBUS_METHOD_ARGUMENT("current_graph_version", DBUS_TYPE_UINT64_AS_STRING, true)

  7260.     JACK_DBUS_METHOD_ARGUMENT("clients_and_ports", "a(tsa(tsuu))", true)

  7261.     JACK_DBUS_METHOD_ARGUMENT("connections", "a(tstststst)", true)

  7262. JACK_DBUS_METHOD_ARGUMENTS_END

  7263. 

  7264. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(ConnectPortsByName)

  7265.     JACK_DBUS_METHOD_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING, false)

  7266.     JACK_DBUS_METHOD_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING, false)

  7267.     JACK_DBUS_METHOD_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING, false)

  7268.     JACK_DBUS_METHOD_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING, false)

  7269. JACK_DBUS_METHOD_ARGUMENTS_END

  7270. 

  7271. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(ConnectPortsByID)

  7272.     JACK_DBUS_METHOD_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING, false)

  7273.     JACK_DBUS_METHOD_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING, false)

  7274. JACK_DBUS_METHOD_ARGUMENTS_END

  7275. 

  7276. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByName)

  7277.     JACK_DBUS_METHOD_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING, false)

  7278.     JACK_DBUS_METHOD_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING, false)

  7279.     JACK_DBUS_METHOD_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING, false)

  7280.     JACK_DBUS_METHOD_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING, false)

  7281. JACK_DBUS_METHOD_ARGUMENTS_END

  7282. 

  7283. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByID)

  7284.     JACK_DBUS_METHOD_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING, false)

  7285.     JACK_DBUS_METHOD_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING, false)

  7286. JACK_DBUS_METHOD_ARGUMENTS_END

  7287. 

  7288. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(DisconnectPortsByConnectionID)

  7289.     JACK_DBUS_METHOD_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING, false)

  7290. JACK_DBUS_METHOD_ARGUMENTS_END

  7291. 

  7292. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(GetClientPID)

  7293.     JACK_DBUS_METHOD_ARGUMENT("client_id", DBUS_TYPE_INT64_AS_STRING, false)

  7294. JACK_DBUS_METHOD_ARGUMENTS_END

  7295. 

  7296. JACK_DBUS_METHODS_BEGIN

  7297.     JACK_DBUS_METHOD_DESCRIBE(GetAllPorts, jack_controller_dbus_get_all_ports)

  7298.     JACK_DBUS_METHOD_DESCRIBE(GetGraph, jack_controller_dbus_get_graph)

  7299.     JACK_DBUS_METHOD_DESCRIBE(ConnectPortsByName, jack_controller_dbus_connect_ports_by_name)

  7300.     JACK_DBUS_METHOD_DESCRIBE(ConnectPortsByID, jack_controller_dbus_connect_ports_by_id)

  7301.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByName, jack_controller_dbus_disconnect_ports_by_name)

  7302.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByID, jack_controller_dbus_disconnect_ports_by_id)

  7303.     JACK_DBUS_METHOD_DESCRIBE(DisconnectPortsByConnectionID, jack_controller_dbus_disconnect_ports_by_connection_id)

  7304.     JACK_DBUS_METHOD_DESCRIBE(GetClientPID, jack_controller_dbus_get_client_pid)

  7305. JACK_DBUS_METHODS_END

  7306. 

  7307. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(GraphChanged)

  7308.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  7309. JACK_DBUS_SIGNAL_ARGUMENTS_END

  7310. 

  7311. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(ClientAppeared)

  7312.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  7313.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  7314.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  7315. JACK_DBUS_SIGNAL_ARGUMENTS_END

  7316. 

  7317. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(ClientDisappeared)

  7318.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  7319.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  7320.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  7321. JACK_DBUS_SIGNAL_ARGUMENTS_END

  7322. 

  7323. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortAppeared)

  7324.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  7325.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  7326.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  7327.     JACK_DBUS_SIGNAL_ARGUMENT("port_id", DBUS_TYPE_UINT64_AS_STRING)

  7328.     JACK_DBUS_SIGNAL_ARGUMENT("port_name", DBUS_TYPE_STRING_AS_STRING)

  7329.     JACK_DBUS_SIGNAL_ARGUMENT("port_flags", DBUS_TYPE_UINT32_AS_STRING)

  7330.     JACK_DBUS_SIGNAL_ARGUMENT("port_type", DBUS_TYPE_UINT32_AS_STRING)

  7331. JACK_DBUS_SIGNAL_ARGUMENTS_END

  7332. 

  7333. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortDisappeared)

  7334.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  7335.     JACK_DBUS_SIGNAL_ARGUMENT("client_id", DBUS_TYPE_UINT64_AS_STRING)

  7336.     JACK_DBUS_SIGNAL_ARGUMENT("client_name", DBUS_TYPE_STRING_AS_STRING)

  7337.     JACK_DBUS_SIGNAL_ARGUMENT("port_id", DBUS_TYPE_UINT64_AS_STRING)

  7338.     JACK_DBUS_SIGNAL_ARGUMENT("port_name", DBUS_TYPE_STRING_AS_STRING)

  7339. JACK_DBUS_SIGNAL_ARGUMENTS_END

  7340. 

  7341. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortsConnected)

  7342.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  7343.     JACK_DBUS_SIGNAL_ARGUMENT("client1_id", DBUS_TYPE_UINT64_AS_STRING)

  7344.     JACK_DBUS_SIGNAL_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING)

  7345.     JACK_DBUS_SIGNAL_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING)

  7346.     JACK_DBUS_SIGNAL_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING)

  7347.     JACK_DBUS_SIGNAL_ARGUMENT("client2_id", DBUS_TYPE_UINT64_AS_STRING)

  7348.     JACK_DBUS_SIGNAL_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING)

  7349.     JACK_DBUS_SIGNAL_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING)

  7350.     JACK_DBUS_SIGNAL_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING)

  7351.     JACK_DBUS_SIGNAL_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING)

  7352. JACK_DBUS_SIGNAL_ARGUMENTS_END

  7353. 

  7354. JACK_DBUS_SIGNAL_ARGUMENTS_BEGIN(PortsDisconnected)

  7355.     JACK_DBUS_SIGNAL_ARGUMENT("new_graph_version", DBUS_TYPE_UINT64_AS_STRING)

  7356.     JACK_DBUS_SIGNAL_ARGUMENT("client1_id", DBUS_TYPE_UINT64_AS_STRING)

  7357.     JACK_DBUS_SIGNAL_ARGUMENT("client1_name", DBUS_TYPE_STRING_AS_STRING)

  7358.     JACK_DBUS_SIGNAL_ARGUMENT("port1_id", DBUS_TYPE_UINT64_AS_STRING)

  7359.     JACK_DBUS_SIGNAL_ARGUMENT("port1_name", DBUS_TYPE_STRING_AS_STRING)

  7360.     JACK_DBUS_SIGNAL_ARGUMENT("client2_id", DBUS_TYPE_UINT64_AS_STRING)

  7361.     JACK_DBUS_SIGNAL_ARGUMENT("client2_name", DBUS_TYPE_STRING_AS_STRING)

  7362.     JACK_DBUS_SIGNAL_ARGUMENT("port2_id", DBUS_TYPE_UINT64_AS_STRING)

  7363.     JACK_DBUS_SIGNAL_ARGUMENT("port2_name", DBUS_TYPE_STRING_AS_STRING)

  7364.     JACK_DBUS_SIGNAL_ARGUMENT("connection_id", DBUS_TYPE_UINT64_AS_STRING)

  7365. JACK_DBUS_SIGNAL_ARGUMENTS_END

  7366. 

  7367. JACK_DBUS_SIGNALS_BEGIN

  7368.     JACK_DBUS_SIGNAL_DESCRIBE(GraphChanged)

  7369.     JACK_DBUS_SIGNAL_DESCRIBE(ClientAppeared)

  7370.     JACK_DBUS_SIGNAL_DESCRIBE(ClientDisappeared)

  7371.     JACK_DBUS_SIGNAL_DESCRIBE(PortAppeared)

  7372.     JACK_DBUS_SIGNAL_DESCRIBE(PortDisappeared)

  7373.     JACK_DBUS_SIGNAL_DESCRIBE(PortsConnected)

  7374.     JACK_DBUS_SIGNAL_DESCRIBE(PortsDisconnected)

  7375. JACK_DBUS_SIGNALS_END

  7376. 

  7377. JACK_DBUS_IFACE_BEGIN(g_jack_controller_iface_patchbay, JACK_DBUS_IFACE_NAME)

  7378.     JACK_DBUS_IFACE_EXPOSE_METHODS

  7379.     JACK_DBUS_IFACE_EXPOSE_SIGNALS

  7380. JACK_DBUS_IFACE_END