daemon/virtualizer.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009,2010,2011,2012 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of the graph virtualizer object
   9  **************************************************************************
  10  *
  11  * LADI Session Handler is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * LADI Session Handler is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  23  * or write to the Free Software Foundation, Inc.,
  24  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "virtualizer.h"
  28 #include "../dbus_constants.h"
  29 #include "../proxies/a2j_proxy.h"
  30 #include "../proxies/jmcore_proxy.h"
  31 #include "procfs.h"
  32 #include "app_supervisor.h"
  33 #include "studio_internal.h"
  34 #include "../common/catdup.h"
  35 #include "room.h"
  36 #include "studio.h"
  37 #include "../alsapid/alsapid.h"
  38
  39 struct virtualizer
  40 {
  41   graph_proxy_handle jack_graph_proxy;
  42   ladish_graph_handle jack_graph;
  43   uint64_t system_client_id;
  44   uint64_t system_midi_client_id;
  45   unsigned int our_clients_count;
  46 };
  47
  48 /* 47c1cd18-7b21-4389-bec4-6e0658e1d6b1 */
  49 UUID_DEFINE(g_system_capture_uuid,0x47,0xC1,0xCD,0x18,0x7B,0x21,0x43,0x89,0xBE,0xC4,0x6E,0x06,0x58,0xE1,0xD6,0xB1);
  50
  51 /* b2a0bb06-28d8-4bfe-956e-eb24378f9629 */
  52 UUID_DEFINE(g_system_playback_uuid,0xB2,0xA0,0xBB,0x06,0x28,0xD8,0x4B,0xFE,0x95,0x6E,0xEB,0x24,0x37,0x8F,0x96,0x29);
  53
  54 /* be23a242-e2b2-11de-b795-002618af5e42 */
  55 UUID_DEFINE(g_a2j_uuid,0xBE,0x23,0xA2,0x42,0xE2,0xB2,0x11,0xDE,0xB7,0x95,0x00,0x26,0x18,0xAF,0x5E,0x42);
  56
  57 struct app_find_context
  58 {
  59   pid_t pid;
  60   ladish_graph_handle graph;
  61   ladish_app_handle app;
  62 };
  63
  64 #define app_find_context_ptr ((struct app_find_context *)context)
  65
  66 static bool lookup_app_in_supervisor(void * context, ladish_graph_handle graph, ladish_app_supervisor_handle app_supervisor)
  67 {
  68   pid_t pid;
  69   ladish_app_handle app;
  70
  71   /* we stop iteration when app is found */
  72   ASSERT(app_find_context_ptr->app == NULL && app_find_context_ptr->graph == NULL);
  73
  74   //log_info("checking app supervisor \"%s\" for pid %llu", ladish_app_supervisor_get_name(app_supervisor), (unsigned long long)pid);
  75
  76   pid = app_find_context_ptr->pid;
  77   do
  78   {
  79     app = ladish_app_supervisor_find_app_by_pid(app_supervisor, pid);
  80     if (app != NULL)
  81       break;
  82
  83     pid = (pid_t)procfs_get_process_parent((unsigned long long)pid);
  84 #if 0
  85     if (pid != 0)
  86     {
  87       log_info("parent pid %llu", (unsigned long long)pid);
  88     }
  89 #endif
  90   }
  91   while (pid != 0);
  92
  93   if (app == NULL)
  94   {                            /* app not found in current supervisor */
  95     return true;               /* continue app supervisor iteration */
  96   }
  97
  98   app_find_context_ptr->app = app;
  99   app_find_context_ptr->graph = graph;
 100
 101   return false;               /* stop app supervisor iteration */
 102 }
 103
 104 #undef app_find_context_ptr
 105
 106 ladish_app_handle ladish_find_app_by_pid(pid_t pid, ladish_graph_handle * graph_ptr)
 107 {
 108   struct app_find_context context;
 109
 110   context.pid = pid;
 111   context.app = NULL;
 112   context.graph = NULL;
 113
 114   ladish_studio_iterate_virtual_graphs(&context, lookup_app_in_supervisor);
 115
 116   if (context.app == NULL)
 117   { /* app not found */
 118     ASSERT(context.graph == NULL);
 119     return NULL;
 120   }
 121
 122   ASSERT(context.graph != NULL);
 123   if (graph_ptr != NULL)
 124   {
 125     *graph_ptr = context.graph;
 126   }
 127
 128   return context.app;
 129 }
 130
 131 struct find_link_port_context
 132 {
 133   uuid_t uuid;
 134   uint64_t jack_id;
 135   ladish_port_handle port;
 136   ladish_graph_handle graph;
 137 };
 138
 139 #define find_link_port_context_ptr ((struct find_link_port_context *)context)
 140
 141 static
 142 bool
 143 find_link_port_vgraph_callback_by_uuid(
 144   void * context,
 145   ladish_graph_handle graph,
 146   ladish_app_supervisor_handle UNUSED(app_supervisor))
 147 {
 148   ladish_port_handle port;
 149
 150   port = ladish_graph_find_port_by_uuid(graph, find_link_port_context_ptr->uuid, true, NULL);
 151   if (port != NULL)
 152   {
 153     find_link_port_context_ptr->port = port;
 154     find_link_port_context_ptr->graph = graph;
 155     return false;
 156   }
 157
 158   return true;                  /* continue vgraph iteration */
 159 }
 160
 161 static
 162 bool
 163 find_link_port_vgraph_callback_by_jack_id(
 164   void * context,
 165   ladish_graph_handle graph,
 166   ladish_app_supervisor_handle UNUSED(app_supervisor))
 167 {
 168   ladish_port_handle port;
 169   bool room;
 170
 171   log_info("searching link port with jack id %"PRIu64" in graph %s", find_link_port_context_ptr->jack_id, ladish_graph_get_description(graph));
 172
 173   room = graph != g_studio.studio_graph;
 174
 175   port = ladish_graph_find_port_by_jack_id(graph, find_link_port_context_ptr->jack_id, room, !room);
 176   if (port != NULL)
 177   {
 178     find_link_port_context_ptr->port = port;
 179     find_link_port_context_ptr->graph = graph;
 180     return false;
 181   }
 182
 183   return true;                  /* continue vgraph iteration */
 184 }
 185
 186 #undef find_link_port_context_ptr
 187
 188 static
 189 ladish_graph_handle
 190 find_link_port_vgraph_by_uuid(
 191   struct virtualizer * UNUSED(virtualizer_ptr),
 192   const char * port_name,
 193   ladish_port_handle * port_ptr)
 194 {
 195   struct find_link_port_context context;
 196
 197   uuid_parse(port_name, context.uuid);
 198   context.graph = NULL;
 199   context.port = NULL;
 200
 201   ladish_studio_iterate_virtual_graphs(&context, find_link_port_vgraph_callback_by_uuid);
 202
 203   if (port_ptr != NULL && context.graph != NULL)
 204   {
 205     *port_ptr = context.port;
 206   }
 207
 208   return context.graph;
 209 }
 210
 211 static
 212 ladish_graph_handle
 213 find_link_port_vgraph_by_jack_id(
 214   struct virtualizer * UNUSED(virtualizer_ptr),
 215   uint64_t jack_id,
 216   ladish_port_handle * port_ptr)
 217 {
 218   struct find_link_port_context context;
 219
 220   context.jack_id = jack_id;
 221   context.graph = NULL;
 222   context.port = NULL;
 223
 224   ladish_studio_iterate_virtual_graphs(&context, find_link_port_vgraph_callback_by_jack_id);
 225
 226   if (port_ptr != NULL && context.graph != NULL)
 227   {
 228     *port_ptr = context.port;
 229   }
 230
 231   return context.graph;
 232 }
 233
 234 static
 235 bool
 236 lookup_port(
 237   struct virtualizer * virtualizer_ptr,
 238   uint64_t port_id,
 239   ladish_port_handle * port_ptr,
 240   ladish_graph_handle * vgraph_ptr)
 241 {
 242   ladish_port_handle port;
 243   ladish_graph_handle vgraph;
 244
 245   port = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port_id, true, true);
 246   if (port == NULL)
 247   {
 248     log_error("Unknown JACK port with id %"PRIu64" (dis)connected", port_id);
 249     return false;
 250   }
 251
 252   vgraph = ladish_port_get_vgraph(port);
 253   if (vgraph == NULL)
 254   {
 255     vgraph = find_link_port_vgraph_by_jack_id(virtualizer_ptr, port_id, NULL);
 256     if (vgraph == NULL)
 257     {
 258       log_error("Cannot find vgraph for (dis)connected jmcore port");
 259       return false;
 260     }
 261
 262     log_info("link port found in graph %s", ladish_graph_get_description(vgraph));
 263   }
 264
 265   *port_ptr = port;
 266   *vgraph_ptr = vgraph;
 267   return true;
 268 }
 269
 270 #define virtualizer_ptr ((struct virtualizer *)context)
 271
 272 static void clear(void * UNUSED(context))
 273 {
 274   log_info("clear");
 275 }
 276
 277 static void client_appeared(void * context, uint64_t id, const char * jack_name)
 278 {
 279   ladish_client_handle client;
 280   const char * a2j_name;
 281   bool is_a2j;
 282   ladish_app_handle app;
 283   uuid_t app_uuid;
 284   const char * name;
 285   pid_t pid;
 286   ladish_graph_handle graph;
 287   bool jmcore;
 288
 289   log_info("client_appeared(%"PRIu64", %s)", id, jack_name);
 290
 291   a2j_name = a2j_proxy_get_jack_client_name_cached();
 292   is_a2j = a2j_name != NULL && strcmp(a2j_name, jack_name) == 0;
 293
 294   name = jack_name;
 295   app = NULL;
 296   graph = NULL;
 297   jmcore = false;
 298
 299   if (!graph_proxy_get_client_pid(virtualizer_ptr->jack_graph_proxy, id, &pid))
 300   {
 301     log_info("client %"PRIu64" pid is unknown", id);
 302   }
 303   else
 304   {
 305     log_info("client pid is %"PRId64, (int64_t)pid);
 306
 307     if (pid != 0) /* skip internal clients that will match the pending clients in the graph, both have zero pid */
 308     {
 309       jmcore = pid == jmcore_proxy_get_pid_cached();
 310       if (jmcore)
 311       {
 312         log_info("jmcore client appeared");
 313       }
 314       else
 315       {
 316         app = ladish_find_app_by_pid(pid, &graph);
 317         if (app != NULL)
 318         {
 319           ladish_app_get_uuid(app, app_uuid);
 320           ASSERT(!uuid_is_null(app_uuid));
 321           name = ladish_app_get_name(app);
 322           log_info("app name is '%s'", name);
 323         }
 324       }
 325     }
 326   }
 327
 328   if (!jmcore)
 329   {
 330     if (is_a2j)
 331     {
 332       client = ladish_graph_find_client_by_uuid(virtualizer_ptr->jack_graph, g_a2j_uuid);
 333     }
 334     else
 335     {
 336       if (app != NULL)
 337       {
 338         client = ladish_graph_find_client_by_app(virtualizer_ptr->jack_graph, app_uuid);
 339         if (client == NULL)
 340         {
 341           log_info("Lookup by app uuid failed, attempting lookup by name '%s'", name);
 342           goto find_by_name;
 343         }
 344       }
 345       else
 346       {
 347       find_by_name:
 348         client = ladish_graph_find_client_by_name(virtualizer_ptr->jack_graph, name, true);
 349       }
 350     }
 351
 352     if (client != NULL)
 353     {
 354       log_info("found existing client");
 355       if (ladish_client_get_jack_id(client) != 0)
 356       {
 357         log_error("Ignoring client with duplicate name '%s' ('%s')", name, jack_name);
 358         goto exit;
 359       }
 360
 361       ladish_client_set_jack_name(client, jack_name);
 362
 363       ladish_client_set_jack_id(client, id);
 364       ladish_graph_show_client(virtualizer_ptr->jack_graph, client);
 365       goto done;
 366     }
 367   }
 368
 369   if (!ladish_client_create(is_a2j ? g_a2j_uuid : NULL, &client))
 370   {
 371     log_error("ladish_client_create() failed. Ignoring client %"PRIu64" (%s)", id, jack_name);
 372     goto exit;
 373   }
 374
 375   ladish_client_set_jack_id(client, id);
 376   ladish_client_set_jack_name(client, jack_name);
 377
 378   if (!ladish_graph_add_client(virtualizer_ptr->jack_graph, client, name, false))
 379   {
 380     log_error("ladish_graph_add_client() failed to add client %"PRIu64" (%s) to JACK graph", id, name);
 381     ladish_client_destroy(client);
 382     goto exit;
 383   }
 384
 385 done:
 386   if (strcmp(jack_name, "system") == 0)
 387   {
 388     virtualizer_ptr->system_client_id = id;
 389   }
 390
 391   if (strcmp(jack_name, "system_midi") == 0)
 392   {
 393     virtualizer_ptr->system_midi_client_id = id;
 394   }
 395
 396   if (app != NULL)
 397   {
 398     /* interlink client and app */
 399     ladish_app_add_pid(app, pid);
 400     ladish_client_set_pid(client, pid);
 401     ladish_client_set_app(client, app_uuid);
 402
 403     ASSERT(graph);
 404     ladish_client_set_vgraph(client, graph);
 405     virtualizer_ptr->our_clients_count++;
 406   }
 407   else if (jmcore)
 408   {
 409     ladish_client_set_pid(client, pid);
 410     ASSERT(ladish_client_get_vgraph(client) == NULL);
 411   }
 412   else
 413   {
 414     /* unknown and internal clients appear in the studio graph */
 415     ladish_client_set_vgraph(client, g_studio.studio_graph);
 416   }
 417
 418 exit:
 419   return;
 420 }
 421
 422 static void port_disappeared(void * context, uint64_t client_id, uint64_t port_id);
 423
 424 bool
 425 force_port_disappear(
 426   void * context,
 427   ladish_graph_handle UNUSED(graph_handle),
 428   bool hidden,
 429   ladish_client_handle client_handle,
 430   const char * client_name,
 431   ladish_port_handle port_handle,
 432   const char * port_name,
 433   uint32_t UNUSED(port_type),
 434   uint32_t UNUSED(port_flags))
 435 {
 436   uint64_t client_id;
 437   uint64_t port_id;
 438
 439   if (hidden)
 440   {
 441     return true;
 442   }
 443
 444   log_error("forcing disappear of port '%s':'%s'", client_name, port_name);
 445
 446   client_id = ladish_client_get_jack_id(client_handle);
 447   port_id = ladish_port_get_jack_id(port_handle);
 448   port_disappeared(context, client_id, port_id);
 449
 450   return true;
 451 }
 452
 453 static void client_disappeared(void * context, uint64_t id)
 454 {
 455   ladish_client_handle client;
 456   pid_t pid;
 457   uuid_t app_uuid;
 458   ladish_app_handle app;
 459   ladish_graph_handle vgraph;
 460
 461   log_info("client_disappeared(%"PRIu64")", id);
 462
 463   client = ladish_graph_find_client_by_jack_id(virtualizer_ptr->jack_graph, id);
 464   if (client == NULL)
 465   {
 466     log_error("Unknown JACK client with id %"PRIu64" disappeared", id);
 467     return;
 468   }
 469
 470   log_info("client disappeared: '%s'", ladish_graph_get_client_name(virtualizer_ptr->jack_graph, client));
 471
 472   /* This is a workaround for jack2/jackdbus bug. */
 473   ladish_graph_interate_client_ports(virtualizer_ptr->jack_graph, client, context, force_port_disappear);
 474
 475   vgraph = ladish_client_get_vgraph(client);
 476
 477   pid = ladish_client_get_pid(client);
 478   if (ladish_client_get_app(client, app_uuid))
 479   {
 480     virtualizer_ptr->our_clients_count--;
 481     app = ladish_studio_find_app_by_uuid(app_uuid);
 482     if (app != NULL)
 483     {
 484       ladish_app_del_pid(app, pid);
 485     }
 486     else
 487     {
 488       log_error("app of disappearing client %"PRIu64" not found. pid is %"PRIu64, id, (uint64_t)pid);
 489       ASSERT_NO_PASS;
 490     }
 491   }
 492
 493   if (id == virtualizer_ptr->system_client_id)
 494   {
 495     virtualizer_ptr->system_client_id = 0;
 496   }
 497
 498   if (id == virtualizer_ptr->system_midi_client_id)
 499   {
 500     virtualizer_ptr->system_midi_client_id = 0;
 501   }
 502
 503   if (vgraph != NULL && ladish_graph_is_persist(vgraph)) /* if client is supposed to be persisted */
 504   {
 505     ladish_client_set_jack_id(client, 0);
 506     ladish_graph_hide_client(virtualizer_ptr->jack_graph, client);
 507   }
 508   else
 509   {
 510     ladish_graph_remove_client(virtualizer_ptr->jack_graph, client);
 511     ladish_client_destroy(client);
 512     /* no need to clear vclient interlink because it either does not exist (vgraph is NULL) or
 513      * it will be destroyed before it is accessed (persist flag is cleared on room deletion) */
 514   }
 515 }
 516
 517 static
 518 void
 519 port_appeared(
 520   void * context,
 521   uint64_t client_id,
 522   uint64_t port_id,
 523   const char * real_jack_port_name,
 524   bool is_input,
 525   bool is_terminal,
 526   bool is_midi)
 527 {
 528   ladish_client_handle jack_client;
 529   ladish_client_handle vclient;
 530   ladish_port_handle port;
 531   uint32_t type;
 532   uint32_t flags;
 533   const char * jack_client_name;
 534   const char * vclient_name;
 535   bool is_a2j;
 536   uuid_t vclient_uuid;
 537   pid_t pid;
 538   ladish_app_handle app;
 539   bool has_app;
 540   uuid_t app_uuid;
 541   char * alsa_client_name;
 542   char * alsa_port_name;
 543   char * a2j_fake_jack_port_name;
 544   uint32_t alsa_client_id;
 545   const char * jack_port_name;
 546   const char * vport_name;
 547   ladish_graph_handle vgraph;
 548
 549   log_info("port_appeared(%"PRIu64", %"PRIu64", %s (%s, %s))", client_id, port_id, real_jack_port_name, is_input ? "in" : "out", is_midi ? "midi" : "audio");
 550
 551   alsa_client_name = NULL;
 552   alsa_port_name = NULL;
 553   a2j_fake_jack_port_name = NULL;
 554
 555   type = is_midi ? JACKDBUS_PORT_TYPE_MIDI : JACKDBUS_PORT_TYPE_AUDIO;
 556   flags = is_input ? JACKDBUS_PORT_FLAG_INPUT : JACKDBUS_PORT_FLAG_OUTPUT;
 557   if (is_terminal)
 558   {
 559     flags |= JACKDBUS_PORT_FLAG_TERMINAL;
 560   }
 561
 562   /********************/
 563   /* gather info about the appeared port */
 564
 565   jack_client = ladish_graph_find_client_by_jack_id(virtualizer_ptr->jack_graph, client_id);
 566   if (jack_client == NULL)
 567   {
 568     log_error("Port of unknown JACK client with id %"PRIu64" appeared", client_id);
 569     goto exit;
 570   }
 571
 572   pid = ladish_client_get_pid(jack_client);
 573   has_app = ladish_client_get_app(jack_client, app_uuid);
 574
 575   /* find the virtual graph that owns the app that owns the client that owns the appeared port */
 576   vgraph = ladish_client_get_vgraph(jack_client);
 577   if (vgraph == NULL)
 578   {
 579     vgraph = find_link_port_vgraph_by_uuid(virtualizer_ptr, real_jack_port_name, &port);
 580     if (vgraph == NULL)
 581     {
 582       log_error("Cannot find vgraph for appeared jmcore port '%s'", real_jack_port_name);
 583       goto exit;
 584     }
 585
 586     /* jmcore port appeared */
 587
 588     log_info("jmcore port appeared in vgraph %s", ladish_graph_get_description(vgraph));
 589
 590     if (!ladish_graph_add_port(virtualizer_ptr->jack_graph, jack_client, port, real_jack_port_name, type, flags, false))
 591     {
 592       log_error("ladish_graph_add_port() failed.");
 593       goto exit;
 594     }
 595
 596     if (vgraph == g_studio.studio_graph)
 597     {
 598       ladish_port_set_jack_id(port, port_id);
 599     }
 600     else
 601     {
 602       ladish_port_set_jack_id_room(port, port_id);
 603     }
 604
 605     vclient = ladish_graph_get_port_client(vgraph, port);
 606     if (vclient == NULL)
 607     {
 608       log_error("link port client not found in vgraph %s", ladish_graph_get_description(vgraph));
 609       ASSERT_NO_PASS;
 610       goto exit;
 611     }
 612
 613     ladish_graph_show_port(vgraph, port);
 614     goto exit;
 615   }
 616   else
 617   {
 618     //log_info("Port of virtual graph '%s'", ladish_graph_get_description(vgraph));
 619   }
 620
 621   jack_client_name = ladish_graph_get_client_name(virtualizer_ptr->jack_graph, jack_client);
 622
 623   is_a2j = ladish_virtualizer_is_a2j_client(jack_client);
 624   if (is_a2j)
 625   {
 626     log_info("a2j port appeared");
 627     if (!a2j_proxy_map_jack_port(real_jack_port_name, &alsa_client_name, &alsa_port_name, &alsa_client_id))
 628     {
 629       is_a2j = false;
 630       alsa_client_name = catdup("FAILED ", jack_client_name);
 631       if (alsa_client_name == NULL)
 632       {
 633         log_error("catdup failed to duplicate a2j jack client name after map failure");
 634         goto exit;
 635       }
 636
 637       alsa_port_name = strdup(real_jack_port_name);
 638       if (alsa_port_name == NULL)
 639       {
 640         log_error("catdup failed to duplicate a2j jack port name after map failure");
 641         free(alsa_client_name);
 642         goto exit;
 643       }
 644
 645       vclient_name = alsa_client_name;
 646     }
 647     else
 648     {
 649       log_info("a2j: '%s':'%s' (%"PRIu32")", alsa_client_name, alsa_port_name, alsa_client_id);
 650       vclient_name = alsa_client_name;
 651       if (alsapid_get_pid(alsa_client_id, &pid))
 652       {
 653         log_info("ALSA client pid is %lld", (long long)pid);
 654
 655         app = ladish_find_app_by_pid(pid, &vgraph);
 656         if (app != NULL)
 657         {
 658           ladish_app_get_uuid(app, app_uuid);
 659           ASSERT(!uuid_is_null(app_uuid));
 660           vclient_name = ladish_app_get_name(app);
 661           has_app = true;
 662           log_info("ALSA app name is '%s'", vclient_name);
 663           ladish_app_add_pid(app, pid);
 664         }
 665       }
 666       else
 667       {
 668         log_error("UNKNOWN ALSA client pid");
 669       }
 670     }
 671
 672     a2j_fake_jack_port_name = catdup4(vclient_name, is_input ? " (playback)" : " (capture)", ": ", alsa_port_name);
 673     if (a2j_fake_jack_port_name == NULL)
 674     {
 675       log_error("catdup4() failed");
 676       goto free_alsa_names;
 677     }
 678
 679     jack_port_name = a2j_fake_jack_port_name;
 680   }
 681   else
 682   {
 683     vclient_name = jack_client_name;
 684     jack_port_name = real_jack_port_name;
 685   }
 686
 687   /********************/
 688
 689   /* search (by name) the appeared port in jack graph
 690    * if found - show it in both graphs.
 691    * if not found - create new port and add it to the jack graph.
 692    * Then process to adding it to virtual graph */
 693
 694   port = ladish_graph_find_port_by_name(virtualizer_ptr->jack_graph, jack_client, jack_port_name, vgraph);
 695   if (port != NULL)
 696   {
 697     log_info("found existing port %p", port);
 698
 699     if (ladish_port_get_jack_id(port) != 0)
 700     {
 701       log_error("Ignoring duplicate JACK port '%s':'%s'", jack_client_name, jack_port_name);
 702       goto free_alsa_names;
 703     }
 704
 705     ladish_port_set_jack_id(port, port_id);
 706     ladish_graph_adjust_port(virtualizer_ptr->jack_graph, port, type, flags);
 707     ladish_graph_show_port(virtualizer_ptr->jack_graph, port);
 708
 709     vclient = ladish_graph_get_port_client(vgraph, port);
 710     if (vclient == NULL)
 711     {
 712       log_error("JACK port not found in virtual graph '%s'", ladish_graph_get_description(vgraph));
 713       ladish_graph_dump(g_studio.jack_graph);
 714       ladish_graph_dump(vgraph);
 715       ASSERT_NO_PASS;
 716       goto free_alsa_names;
 717     }
 718
 719     /* for normal ports, one can find the app_uuid through the jack client,
 720        but for a2j ports the jack client is shared between graphs */
 721     /* clients and ports can be reused if they were started externally then through ladish */
 722     if (has_app)
 723     {
 724       ladish_port_set_app(port, app_uuid);
 725       ladish_port_set_pid(port, pid);
 726       if (!ladish_client_has_app(vclient))
 727       {
 728         ladish_client_set_app(vclient, app_uuid);
 729       }
 730     }
 731
 732     ladish_dict_set(ladish_port_get_dict(port), URI_A2J_PORT, is_a2j ? "yes" : "no");
 733
 734     ladish_client_set_jack_id(vclient, client_id);
 735     ladish_graph_adjust_port(vgraph, port, type, flags);
 736     ladish_graph_show_port(vgraph, port);
 737     goto free_alsa_names;
 738   }
 739
 740   if (!ladish_port_create(NULL, false, &port))
 741   {
 742     log_error("ladish_port_create() failed.");
 743     goto free_alsa_names;
 744   }
 745
 746   /* set port jack id so invisible connections to/from it can be restored */
 747   ladish_port_set_jack_id(port, port_id);
 748
 749   /* for normal ports, one can find the vgraph and app_uuid through the jack client,
 750      but for a2j ports the jack client is shared between graphs */
 751   ladish_port_set_vgraph(port, vgraph);
 752   if (has_app)
 753   {
 754     ladish_port_set_app(port, app_uuid);
 755     ladish_port_set_pid(port, pid);
 756   }
 757
 758   ladish_dict_set(ladish_port_get_dict(port), URI_A2J_PORT, is_a2j ? "yes" : "no");
 759
 760   if (!ladish_graph_add_port(virtualizer_ptr->jack_graph, jack_client, port, jack_port_name, type, flags, false))
 761   {
 762     log_error("ladish_graph_add_port() failed.");
 763     ladish_port_destroy(port);
 764     goto free_alsa_names;
 765   }
 766
 767   /********************/
 768   /* find/create the virtual client where port will be added */
 769
 770   if (is_a2j)
 771   {
 772     vclient = ladish_graph_find_client_by_name(vgraph, vclient_name, false);
 773     if (vclient == NULL)
 774     {
 775       if (!ladish_client_create(NULL, &vclient))
 776       {
 777         log_error("ladish_client_create() failed.");
 778         goto free_alsa_names;
 779       }
 780
 781       if (has_app)
 782       {
 783         ladish_client_set_app(vclient, app_uuid);
 784       }
 785
 786       if (!ladish_graph_add_client(vgraph, vclient, vclient_name, false))
 787       {
 788         log_error("ladish_graph_add_client() failed.");
 789         ladish_client_destroy(vclient);
 790         goto free_alsa_names;
 791       }
 792     }
 793   }
 794   else if (client_id == virtualizer_ptr->system_client_id ||
 795            client_id == virtualizer_ptr->system_midi_client_id)
 796   {
 797     log_info("system client port appeared");
 798
 799     if (!is_input)
 800     { /* output capture port */
 801
 802       vclient = ladish_graph_find_client_by_uuid(vgraph, g_system_capture_uuid);
 803       if (vclient == NULL)
 804       {
 805         if (!ladish_client_create(g_system_capture_uuid, &vclient))
 806         {
 807           log_error("ladish_client_create() failed.");
 808           goto free_alsa_names;
 809         }
 810
 811         if (!ladish_graph_add_client(vgraph, vclient, "Hardware Capture", false))
 812         {
 813           log_error("ladish_graph_add_client() failed.");
 814           ladish_client_destroy(vclient);
 815           goto free_alsa_names;
 816         }
 817       }
 818     }
 819     else
 820     { /* input playback port */
 821       vclient = ladish_graph_find_client_by_uuid(vgraph, g_system_playback_uuid);
 822       if (vclient == NULL)
 823       {
 824         if (!ladish_client_create(g_system_playback_uuid, &vclient))
 825         {
 826           log_error("ladish_client_create() failed.");
 827           goto free_alsa_names;
 828         }
 829
 830         if (!ladish_graph_add_client(vgraph, vclient, "Hardware Playback", false))
 831         {
 832           ladish_client_destroy(vclient);
 833           goto free_alsa_names;
 834         }
 835       }
 836     }
 837   }
 838   else
 839   { /* non-system client */
 840     log_info("non-system client port appeared");
 841
 842     if (ladish_client_get_interlink(jack_client, vclient_uuid))
 843     {
 844       vclient = ladish_graph_find_client_by_uuid(vgraph, vclient_uuid);
 845       ASSERT(vclient != NULL);
 846     }
 847     else
 848     {
 849       if (has_app)
 850       {
 851         vclient = ladish_graph_find_client_by_app(vgraph, app_uuid);
 852         if (vclient == NULL)
 853         {
 854           log_info("Lookup by app uuid failed, attempting lookup by name '%s'", vclient_name);
 855           goto find_by_name;
 856         }
 857       }
 858       else
 859       {
 860       find_by_name:
 861         vclient = ladish_graph_find_client_by_name(vgraph, vclient_name, true);
 862       }
 863
 864       if (vclient == NULL)
 865       {
 866         log_info("creating new vclient");
 867         if (!ladish_client_create(NULL, &vclient))
 868         {
 869           log_error("ladish_client_create() failed.");
 870           goto free_alsa_names;
 871         }
 872
 873         ladish_client_interlink(vclient, jack_client);
 874
 875         if (has_app)
 876         {
 877           ladish_client_set_app(vclient, app_uuid);
 878         }
 879
 880         if (!ladish_graph_add_client(vgraph, vclient, vclient_name, false))
 881         {
 882           log_error("ladish_graph_add_client() failed to add client '%s' to virtual graph", jack_client_name);
 883           ladish_client_destroy(vclient);
 884           goto free_alsa_names;
 885         }
 886       }
 887       else
 888       {
 889         /* vclient exists but is not interlinked with vclient */
 890         /* this can happen when client is created because of a2j port appear */
 891         ladish_client_interlink(vclient, jack_client);
 892       }
 893     }
 894   }
 895
 896   /********************/
 897   /* add newly appeared port to the virtual graph */
 898
 899   if (is_a2j)
 900   {
 901     vport_name = alsa_port_name;
 902   }
 903   else
 904   {
 905     vport_name = jack_port_name;
 906   }
 907
 908   if (!ladish_graph_add_port(vgraph, vclient, port, vport_name, type, flags, false))
 909   {
 910     log_error("ladish_graph_add_port() failed.");
 911     goto free_alsa_names;
 912   }
 913
 914 free_alsa_names:
 915   free(a2j_fake_jack_port_name);
 916   free(alsa_client_name);
 917   free(alsa_port_name);
 918
 919 exit:
 920   return;
 921 }
 922
 923 static void maybe_clear_a2j_port_pid(ladish_graph_handle vgraph, ladish_client_handle jclient, ladish_port_handle port)
 924 {
 925   const char * opath;
 926   uuid_t app_uuid;
 927   ladish_app_handle app;
 928   ladish_app_supervisor_handle app_supervisor;
 929   pid_t pid;
 930
 931   if (ladish_virtualizer_is_a2j_client(jclient) && ladish_port_get_app(port, app_uuid))
 932   {
 933     pid = ladish_port_get_pid(port);
 934     opath = ladish_graph_get_opath(vgraph);
 935     log_info("releasing reference for pid %d of a2j port in %s", (int)pid, ladish_graph_get_description(vgraph));
 936     app_supervisor = ladish_studio_find_app_supervisor(opath);
 937     app = ladish_app_supervisor_find_app_by_uuid(app_supervisor, app_uuid);
 938     if (app != NULL && pid != 0)
 939     {
 940       ladish_app_del_pid(app, pid);
 941     }
 942   }
 943 }
 944
 945 static void port_disappeared(void * context, uint64_t client_id, uint64_t port_id)
 946 {
 947   ladish_client_handle jclient;
 948   ladish_client_handle vclient;
 949   ladish_port_handle port;
 950   ladish_graph_handle vgraph;
 951   bool jmcore;
 952
 953   log_info("port_disappeared(%"PRIu64", %"PRIu64")", client_id, port_id);
 954
 955   jclient = ladish_graph_find_client_by_jack_id(virtualizer_ptr->jack_graph, client_id);
 956   if (jclient == NULL)
 957   {
 958     log_error("Port of unknown JACK client with id %"PRIu64" disappeared", client_id);
 959     return;
 960   }
 961
 962   port = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port_id, true, true);
 963   if (port == NULL)
 964   {
 965     log_error("Unknown JACK port with id %"PRIu64" disappeared", port_id);
 966     return;
 967   }
 968
 969   /* find the virtual graph that owns the app that owns the client that owns the disappeared port */
 970   jmcore = false;
 971   vgraph = ladish_port_get_vgraph(port);
 972   if (vgraph == NULL)
 973   {
 974     vgraph = find_link_port_vgraph_by_uuid(virtualizer_ptr, ladish_graph_get_port_name(virtualizer_ptr->jack_graph, port), NULL);
 975     if (vgraph == NULL)
 976     {
 977       log_error("Cannot find vgraph for disappeared jmcore port");
 978       ASSERT_NO_PASS;
 979       return;
 980     }
 981
 982     jmcore = true;
 983     ladish_graph_remove_port_by_jack_id(virtualizer_ptr->jack_graph, port_id, true, true);
 984   }
 985   else
 986   {
 987     maybe_clear_a2j_port_pid(vgraph, jclient, port);
 988   }
 989
 990   ladish_port_set_pid(port, 0);
 991
 992   if (ladish_graph_is_persist(vgraph)) /* if port is supposed to be persisted */
 993   {
 994     if (!jmcore)
 995     {
 996       ladish_port_set_jack_id(port, 0);
 997       ladish_graph_hide_port(virtualizer_ptr->jack_graph, port);
 998     }
 999     if (vgraph != NULL)
1000     {
1001       ladish_graph_hide_port(vgraph, port);
1002       vclient = ladish_graph_get_port_client(vgraph, port);
1003       if (ladish_graph_client_looks_empty(vgraph, vclient))
1004       {
1005         ladish_graph_hide_client(vgraph, vclient);
1006       }
1007     }
1008   }
1009   else
1010   {
1011     if (!jmcore)
1012     {
1013       ladish_graph_remove_port(virtualizer_ptr->jack_graph, port);
1014     }
1015
1016     if (vgraph != NULL)
1017     {
1018       vclient = ladish_graph_remove_port(vgraph, port);
1019       if (vclient != NULL)
1020       {
1021         if (ladish_graph_client_is_empty(vgraph, vclient))
1022         {
1023           ladish_graph_remove_client(vgraph, vclient);
1024           ladish_client_clear_interlink(jclient);
1025         }
1026       }
1027     }
1028   }
1029 }
1030
1031 static
1032 void
1033 port_renamed(
1034   void * context,
1035   uint64_t client_id,
1036   uint64_t port_id,
1037   const char * old_port_name,
1038   const char * new_port_name)
1039 {
1040   ladish_port_handle port;
1041   ladish_graph_handle vgraph;
1042
1043   log_info("port_renamed(%"PRIu64":%"PRIu64", '%s', '%s')", client_id, port_id, old_port_name, new_port_name);
1044
1045   port = ladish_graph_find_port_by_jack_id(virtualizer_ptr->jack_graph, port_id, true, true);
1046   if (port == NULL)
1047   {
1048     log_error("Unknown JACK port with id %"PRIu64" was renamed", port_id);
1049     return;
1050   }
1051
1052   /* find the virtual graph that owns the app that owns the client that owns the renamed port */
1053   vgraph = ladish_port_get_vgraph(port);
1054
1055   if (!ladish_graph_rename_port(virtualizer_ptr->jack_graph, port, new_port_name))
1056   {
1057     log_error("renaming of port in jack graph failed");
1058   }
1059
1060   if (!ladish_graph_rename_port(vgraph, port, new_port_name))
1061   {
1062     log_error("renaming of port in virtual graph failed");
1063   }
1064 }
1065
1066 static bool ports_connect_request(void * context, ladish_graph_handle graph_handle, ladish_port_handle port1, ladish_port_handle port2)
1067 {
1068   uint64_t port1_id;
1069   uint64_t port2_id;
1070
1071   ASSERT(ladish_graph_get_opath(graph_handle)); /* studio or room virtual graph */
1072   log_info("virtualizer: ports connect request");
1073
1074   if (graph_handle == g_studio.studio_graph)
1075   {
1076     port1_id = ladish_port_get_jack_id(port1);
1077     port2_id = ladish_port_get_jack_id(port2);
1078   }
1079   else
1080   {
1081     port1_id = ladish_port_get_jack_id_room(port1);
1082     port2_id = ladish_port_get_jack_id_room(port2);
1083   }
1084
1085   return graph_proxy_connect_ports(virtualizer_ptr->jack_graph_proxy, port1_id, port2_id);
1086 }
1087
1088 static bool ports_disconnect_request(void * context, ladish_graph_handle graph_handle, uint64_t connection_id)
1089 {
1090   ladish_port_handle port1;
1091   ladish_port_handle port2;
1092   uint64_t port1_id;
1093   uint64_t port2_id;
1094
1095   ASSERT(ladish_graph_get_opath(graph_handle)); /* studio or room virtual graph */
1096   log_info("virtualizer: ports disconnect request");
1097
1098   if (!ladish_graph_get_connection_ports(graph_handle, connection_id, &port1, &port2))
1099   {
1100     log_error("cannot find ports that are disconnect-requested");
1101     ASSERT_NO_PASS;
1102     return false;
1103   }
1104
1105   if (graph_handle == g_studio.studio_graph)
1106   {
1107     port1_id = ladish_port_get_jack_id(port1);
1108     port2_id = ladish_port_get_jack_id(port2);
1109   }
1110   else
1111   {
1112     port1_id = ladish_port_get_jack_id_room(port1);
1113     port2_id = ladish_port_get_jack_id_room(port2);
1114   }
1115
1116   return graph_proxy_disconnect_ports(virtualizer_ptr->jack_graph_proxy, port1_id, port2_id);
1117 }
1118
1119 static void ports_connected(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id)
1120 {
1121   ladish_port_handle port1;
1122   ladish_port_handle port2;
1123   uint64_t connection_id;
1124   ladish_graph_handle vgraph1;
1125   ladish_graph_handle vgraph2;
1126
1127   log_info("ports_connected %"PRIu64":%"PRIu64" %"PRIu64":%"PRIu64"", client1_id, port1_id, client2_id, port2_id);
1128
1129   if (!lookup_port(virtualizer_ptr, port1_id, &port1, &vgraph1))
1130   {
1131     return;
1132   }
1133
1134   if (!lookup_port(virtualizer_ptr, port2_id, &port2, &vgraph2))
1135   {
1136     return;
1137   }
1138
1139   if (vgraph1 != vgraph2)
1140   {
1141     /* TODO */
1142     log_error("ignoring connection with endpoints in different vgraphs");
1143     return;
1144   }
1145
1146   ladish_graph_add_connection(virtualizer_ptr->jack_graph, port1, port2, false);
1147
1148   if (ladish_graph_find_connection(vgraph1, port1, port2, &connection_id))
1149   {
1150     log_info("showing hidden virtual connection");
1151     ladish_graph_show_connection(vgraph1, connection_id);
1152   }
1153   else
1154   {
1155     log_info("creating new virtual connection");
1156     ladish_graph_add_connection(vgraph1, port1, port2, false);
1157   }
1158 }
1159
1160 static void ports_disconnected(void * context, uint64_t client1_id, uint64_t port1_id, uint64_t client2_id, uint64_t port2_id)
1161 {
1162   ladish_port_handle port1;
1163   ladish_port_handle port2;
1164   uint64_t connection_id;
1165   ladish_graph_handle vgraph1;
1166   ladish_graph_handle vgraph2;
1167
1168   log_info("ports_disconnected %"PRIu64":%"PRIu64" %"PRIu64":%"PRIu64"", client1_id, port1_id, client2_id, port2_id);
1169
1170   if (!lookup_port(virtualizer_ptr, port1_id, &port1, &vgraph1))
1171   {
1172     return;
1173   }
1174
1175   if (!lookup_port(virtualizer_ptr, port2_id, &port2, &vgraph2))
1176   {
1177     return;
1178   }
1179
1180   if (vgraph1 != vgraph2)
1181   {
1182     /* TODO */
1183     log_error("ignoring connection with endpoints in different vgraphs");
1184     return;
1185   }
1186
1187   if (ladish_graph_find_connection(virtualizer_ptr->jack_graph, port1, port2, &connection_id))
1188   {
1189     ladish_graph_remove_connection(virtualizer_ptr->jack_graph, connection_id, true);
1190   }
1191   else
1192   {
1193     log_error("ports %"PRIu64":%"PRIu64" and %"PRIu64":%"PRIu64" are not connected in the JACK graph", client1_id, port1_id, client2_id, port2_id);
1194   }
1195
1196   if (ladish_graph_find_connection(vgraph1, port1, port2, &connection_id))
1197   {
1198     ladish_graph_remove_connection(vgraph1, connection_id, false);
1199   }
1200   else
1201   {
1202     log_error("ports %"PRIu64":%"PRIu64" and %"PRIu64":%"PRIu64" are not connected in the virtual graph", client1_id, port1_id, client2_id, port2_id);
1203   }
1204 }
1205
1206 #undef virtualizer_ptr
1207
1208 bool
1209 ladish_virtualizer_create(
1210   graph_proxy_handle jack_graph_proxy,
1211   ladish_graph_handle jack_graph,
1212   ladish_virtualizer_handle * handle_ptr)
1213 {
1214   struct virtualizer * virtualizer_ptr;
1215
1216   virtualizer_ptr = malloc(sizeof(struct virtualizer));
1217   if (virtualizer_ptr == NULL)
1218   {
1219     log_error("malloc() failed for struct virtualizer");
1220     return false;
1221   }
1222
1223   virtualizer_ptr->jack_graph_proxy = jack_graph_proxy;
1224   virtualizer_ptr->jack_graph = jack_graph;
1225   virtualizer_ptr->system_client_id = 0;
1226   virtualizer_ptr->system_midi_client_id = 0;
1227   virtualizer_ptr->our_clients_count = 0;
1228
1229   if (!graph_proxy_attach(
1230         jack_graph_proxy,
1231         virtualizer_ptr,
1232         clear,
1233         client_appeared,
1234         NULL,                   /* jackdbus does not have client rename functionality (yet) */
1235         client_disappeared,
1236         port_appeared,
1237         port_renamed,
1238         port_disappeared,
1239         ports_connected,
1240         ports_disconnected))
1241   {
1242     free(virtualizer_ptr);
1243     return false;
1244   }
1245
1246   *handle_ptr = (ladish_virtualizer_handle)virtualizer_ptr;
1247   return true;
1248 }
1249
1250 #define virtualizer_ptr ((struct virtualizer *)handle)
1251
1252 void
1253 ladish_virtualizer_set_graph_connection_handlers(
1254   ladish_virtualizer_handle handle,
1255   ladish_graph_handle graph)
1256 {
1257   ladish_graph_set_connection_handlers(graph, virtualizer_ptr, ports_connect_request, ports_disconnect_request);
1258 }
1259
1260 unsigned int
1261 ladish_virtualizer_get_our_clients_count(
1262   ladish_virtualizer_handle handle)
1263 {
1264   return virtualizer_ptr->our_clients_count;
1265 }
1266
1267 static bool app_has_a2j_ports(ladish_graph_handle jack_graph, const uuid_t app_uuid)
1268 {
1269   ladish_client_handle a2jclient;
1270
1271   a2jclient = ladish_graph_find_client_by_uuid(jack_graph, g_a2j_uuid);
1272   if (a2jclient == NULL)
1273   {
1274     return false;
1275   }
1276
1277   return ladish_graph_client_has_visible_app_port(jack_graph, a2jclient, app_uuid);
1278 }
1279
1280 bool
1281 ladish_virtualizer_is_hidden_app(
1282   ladish_graph_handle jack_graph,
1283   const uuid_t app_uuid,
1284   const char * app_name)
1285 {
1286   ladish_client_handle jclient;
1287   ladish_graph_handle vgraph;
1288   uuid_t vclient_uuid;
1289   ladish_client_handle vclient;
1290
1291   //ladish_graph_dump(g_studio.jack_graph);
1292
1293   if (app_has_a2j_ports(jack_graph, app_uuid))
1294   {
1295     log_info("app '%s' still has a2j ports", app_name);
1296     return false;
1297   }
1298
1299   jclient = ladish_graph_find_client_by_app(jack_graph, app_uuid);
1300   if (jclient == NULL)
1301   {
1302     log_info("App without JACK client is treated as hidden one");
1303     return true;
1304   }
1305
1306   ASSERT(!ladish_virtualizer_is_a2j_client(jclient)); /* a2j client has no app associated */
1307
1308   vgraph = ladish_client_get_vgraph(jclient);
1309   if (vgraph == NULL)
1310   {
1311     ASSERT_NO_PASS;
1312     return true;
1313   }
1314
1315   //ladish_graph_dump(vgraph);
1316
1317   if (!ladish_graph_client_looks_empty(jack_graph, jclient) ||
1318       !ladish_graph_client_is_hidden(jack_graph, jclient))
1319   {
1320     return false;
1321   }
1322
1323   if (!ladish_client_get_interlink(jclient, vclient_uuid))
1324   {
1325     if (ladish_graph_client_is_empty(jack_graph, jclient))
1326     {
1327       log_info("jack client of app '%s' has no interlinked vgraph client and no ports", app_name);
1328     }
1329     else
1330     {
1331       log_error("jack client of app '%s' has no interlinked vgraph client", app_name);
1332       ASSERT_NO_PASS;
1333     }
1334     return true;
1335   }
1336
1337   vclient = ladish_graph_find_client_by_uuid(vgraph, vclient_uuid);
1338   if (vclient == NULL)
1339   {
1340     ASSERT_NO_PASS;
1341     return true;
1342   }
1343
1344   if (!ladish_graph_client_looks_empty(vgraph, vclient))
1345   {
1346     return false;
1347   }
1348
1349   ASSERT(ladish_graph_client_is_hidden(vgraph, vclient)); /* vclients are automatically hidden when they start looking empty (on port disappear) */
1350   return true;
1351 }
1352
1353 struct app_remove_context
1354 {
1355   uuid_t app_uuid;
1356   const char * app_name;
1357 };
1358
1359 #define app_info_ptr ((struct app_remove_context *)context)
1360
1361 static
1362 bool
1363 remove_app_port(
1364   void * context,
1365   ladish_graph_handle graph_handle,
1366   bool UNUSED(hidden),
1367   void * UNUSED(client_iteration_context_ptr),
1368   ladish_client_handle UNUSED(client_handle),
1369   const char * client_name,
1370   ladish_port_handle port_handle,
1371   const char * port_name,
1372   uint32_t port_type,
1373   uint32_t port_flags)
1374 {
1375   ladish_graph_handle vgraph;
1376   ladish_client_handle vclient;
1377
1378   if (!ladish_port_belongs_to_app(port_handle, app_info_ptr->app_uuid))
1379   {
1380     return true;
1381   }
1382
1383   //log_info("removing port '%s':'%s' (JACK) of app '%s'", client_name, port_name, app_info_ptr->app_name);
1384
1385   vgraph = ladish_port_get_vgraph(port_handle);
1386   if (vgraph == NULL)
1387   {
1388     log_error("port '%s':'%s' of app '%s' has no vgraph", client_name, port_name, app_info_ptr->app_name);
1389     ASSERT_NO_PASS;
1390     return true;
1391   }
1392
1393   vclient = ladish_graph_get_port_client(vgraph, port_handle);
1394   if (vgraph == NULL)
1395   {
1396     log_error("app port '%s':'%s' not found in vgraph '%s'", client_name, port_name, ladish_graph_get_description(vgraph));
1397     ASSERT_NO_PASS;
1398     return true;
1399   }
1400
1401   log_info(
1402     "removing %s %s port %p of app '%s' ('%s':'%s' in %s)",
1403     port_type == JACKDBUS_PORT_TYPE_AUDIO ? "audio" : "midi",
1404     JACKDBUS_PORT_IS_INPUT(port_flags) ? "input" : "output",
1405     port_handle,
1406     app_info_ptr->app_name,
1407     ladish_graph_get_client_name(vgraph, vclient),
1408     ladish_graph_get_port_name(vgraph, port_handle),
1409     ladish_graph_get_description(vgraph));
1410
1411   ladish_graph_remove_port(graph_handle, port_handle);
1412   ladish_graph_remove_port(vgraph, port_handle);
1413
1414   return true;
1415 }
1416
1417 #undef app_info_ptr
1418
1419 void
1420 ladish_virtualizer_remove_app(
1421   ladish_graph_handle jack_graph,
1422   const uuid_t app_uuid,
1423   const char * app_name)
1424 {
1425   ladish_client_handle jclient;
1426   ladish_graph_handle vgraph;
1427   uuid_t vclient_uuid;
1428   ladish_client_handle vclient;
1429   bool is_empty;
1430   struct app_remove_context ctx;
1431
1432   //ladish_graph_dump(g_studio.jack_graph);
1433
1434   uuid_copy(ctx.app_uuid, app_uuid);
1435   ctx.app_name = app_name;
1436
1437   ladish_graph_iterate_nodes(jack_graph, &ctx, NULL, remove_app_port, NULL);
1438
1439   jclient = ladish_graph_find_client_by_app(jack_graph, app_uuid);
1440   if (jclient == NULL)
1441   {
1442     log_info("removing app without JACK client");
1443     return;
1444   }
1445
1446   ASSERT(!ladish_virtualizer_is_a2j_client(jclient)); /* a2j client has no app associated */
1447
1448   vgraph = ladish_client_get_vgraph(jclient);
1449   if (vgraph == NULL)
1450   {
1451     ASSERT_NO_PASS;
1452     return;
1453   }
1454
1455   //ladish_graph_dump(vgraph);
1456
1457   /* check whether the client is empty because this cannot
1458      be checked later because the client was removed
1459      (see where is_empty is used) */
1460   is_empty = ladish_graph_client_is_empty(jack_graph, jclient);
1461
1462   ladish_graph_remove_client(jack_graph, jclient);
1463
1464   if (!ladish_client_get_interlink(jclient, vclient_uuid))
1465   {
1466     if (is_empty)
1467     {
1468       /* jack client without ports and thus without vgraph client */
1469       return;
1470     }
1471
1472     log_error("jack client of app '%s' has no interlinked vgraph client", app_name);
1473     ladish_graph_dump(g_studio.jack_graph);
1474     ladish_graph_dump(vgraph);
1475     ASSERT_NO_PASS;
1476     return;
1477   }
1478
1479   vclient = ladish_graph_find_client_by_uuid(vgraph, vclient_uuid);
1480   if (vclient == NULL)
1481   {
1482     ASSERT_NO_PASS;
1483     return;
1484   }
1485
1486   ladish_graph_remove_client(vgraph, vclient);
1487   ladish_graph_dump(g_studio.jack_graph);
1488   ladish_graph_dump(vgraph);
1489 }
1490
1491 void
1492 ladish_virtualizer_destroy(
1493   ladish_virtualizer_handle handle)
1494 {
1495   log_info("ladish_virtualizer_destroy() called");
1496
1497   graph_proxy_detach((graph_proxy_handle)handle, virtualizer_ptr);
1498   free(virtualizer_ptr);
1499 }
1500
1501 #undef virtualizer_ptr
1502
1503 #define vgraph ((ladish_graph_handle)vgraph_context)
1504 void
1505 ladish_virtualizer_rename_app(
1506   void * vgraph_context,
1507   const uuid_t uuid,
1508   const char * UNUSED(old_name),
1509   const char * new_app_name)
1510 {
1511   ladish_client_handle client;
1512
1513   client = ladish_graph_find_client_by_app(vgraph, uuid);
1514   if (client != NULL)
1515   {
1516     ladish_graph_rename_client(vgraph, client, new_app_name);
1517   }
1518
1519   client = ladish_graph_find_client_by_app(g_studio.jack_graph, uuid);
1520   if (client != NULL)
1521   {
1522     ladish_graph_rename_client(g_studio.jack_graph, client, new_app_name);
1523   }
1524 }
1525 #undef vgraph
1526
1527 bool
1528 ladish_virtualizer_is_system_client(
1529   uuid_t uuid)
1530 {
1531   if (uuid_compare(uuid, g_system_capture_uuid) == 0)
1532   {
1533     return true;
1534   }
1535
1536   if (uuid_compare(uuid, g_system_playback_uuid) == 0)
1537   {
1538     return true;
1539   }
1540
1541   return false;
1542 }
1543
1544 bool ladish_virtualizer_is_a2j_client(ladish_client_handle jclient)
1545 {
1546   uuid_t jclient_uuid;
1547
1548   ladish_client_get_uuid(jclient, jclient_uuid);
1549   return uuid_compare(jclient_uuid, g_a2j_uuid) == 0;
1550 }
1551
1552 static
1553 bool
1554 move_capture_port_callback(
1555   void * context,
1556   ladish_graph_handle graph_handle,
1557   bool UNUSED(hidden),
1558   ladish_client_handle client_handle,
1559   const char * UNUSED(client_name),
1560   ladish_port_handle port_handle,
1561   const char * UNUSED(port_name),
1562   uint32_t UNUSED(port_type),
1563   uint32_t port_flags)
1564 {
1565   ASSERT(client_handle != context); /* source and destination clients must be differ */
1566
1567   if (JACKDBUS_PORT_IS_INPUT(port_flags))
1568   {
1569     ladish_graph_move_port(graph_handle, port_handle, context);
1570   }
1571
1572   return true;
1573 }
1574
1575 bool ladish_virtualizer_split_client(ladish_graph_handle vgraph, uint64_t client_id)
1576 {
1577   ladish_client_handle vclient1;
1578   ladish_client_handle vclient2;
1579   const char * name;
1580
1581   vclient1 = ladish_graph_find_client_by_id(vgraph, client_id);
1582   if (vclient1 == NULL)
1583   {
1584     log_error("Cannot find client %"PRIu64" in %s", client_id, ladish_graph_get_description(vgraph));
1585     return false;
1586   }
1587
1588   name = ladish_graph_get_client_name(vgraph, vclient1);
1589
1590   if (!ladish_client_create(NULL, &vclient2))
1591   {
1592     log_error("ladish_client_create() failed.");
1593     return false;
1594   }
1595
1596   ladish_client_interlink_copy(vclient2, vclient1);
1597   ladish_client_copy_app(vclient2, vclient1);
1598
1599   if (!ladish_graph_add_client(vgraph, vclient2, name, false))
1600   {
1601     log_error("ladish_graph_add_client() failed to add client '%s' to virtual graph", name);
1602     ladish_client_destroy(vclient2);
1603     return false;
1604   }
1605
1606   return ladish_graph_interate_client_ports(vgraph, vclient1, vclient2, move_capture_port_callback);
1607 }
1608
1609 static
1610 bool
1611 move_port_callback(
1612   void * context,
1613   ladish_graph_handle graph_handle,
1614   bool UNUSED(hidden),
1615   ladish_client_handle client_handle,
1616   const char * UNUSED(client_name),
1617   ladish_port_handle port_handle,
1618   const char * UNUSED(port_name),
1619   uint32_t UNUSED(port_type),
1620   uint32_t UNUSED(port_flags))
1621 {
1622   ASSERT(client_handle != context); /* source and destination clients must be differ */
1623   ladish_graph_move_port(graph_handle, port_handle, context);
1624   return true;
1625 }
1626
1627 bool
1628 ladish_virtualizer_join_clients(
1629   ladish_graph_handle vgraph,
1630   uint64_t client1_id,
1631   uint64_t client2_id)
1632 {
1633   ladish_client_handle vclient1;
1634   ladish_client_handle vclient2;
1635
1636   if (client1_id == client2_id)
1637   {
1638     log_error("Cannot join same client");
1639     return false;
1640   }
1641
1642   vclient1 = ladish_graph_find_client_by_id(vgraph, client1_id);
1643   if (vclient1 == NULL)
1644   {
1645     log_error("Cannot find client %"PRIu64" in %s", client1_id, ladish_graph_get_description(vgraph));
1646     return false;
1647   }
1648
1649   vclient2 = ladish_graph_find_client_by_id(vgraph, client2_id);
1650   if (vclient2 == NULL)
1651   {
1652     log_error("Cannot find client %"PRIu64" in %s", client2_id, ladish_graph_get_description(vgraph));
1653     return false;
1654   }
1655
1656   ladish_graph_interate_client_ports(vgraph, vclient2, vclient1, move_port_callback);
1657
1658   ladish_graph_remove_client(vgraph, vclient2);
1659
1660   return true;
1661 }