daemon/save.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2010 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation save releated helper functions
   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 <unistd.h>
  28
  29 #include "save.h"
  30 #include "escape.h"
  31 #include "studio.h"
  32
  33 bool ladish_write_string(int fd, const char * string)
  34 {
  35   size_t len;
  36   ssize_t ret;
  37
  38   len = strlen(string);
  39
  40   ret = write(fd, string, len);
  41   if (ret == -1)
  42   {
  43     log_error("write(%d, \"%s\", %zu) failed to write config file: %d (%s)", fd, string, len, errno, strerror(errno));
  44     return false;
  45   }
  46   if ((size_t)ret != len)
  47   {
  48     log_error("write() wrote wrong byte count to config file (%zd != %zu).", ret, len);
  49     return false;
  50   }
  51
  52   return true;
  53 }
  54
  55 bool ladish_write_indented_string(int fd, int indent, const char * string)
  56 {
  57   ASSERT(indent >= 0);
  58   while (indent--)
  59   {
  60     if (!ladish_write_string(fd, LADISH_XML_BASE_INDENT))
  61     {
  62       return false;
  63     }
  64   }
  65
  66   if (!ladish_write_string(fd, string))
  67   {
  68     return false;
  69   }
  70
  71   return true;
  72 }
  73
  74 #define fd (((struct ladish_write_context *)context)->fd)
  75 #define indent (((struct ladish_write_context *)context)->indent)
  76
  77 static
  78 bool
  79 write_dict_entry(
  80   void * context,
  81   const char * key,
  82   const char * value)
  83 {
  84   if (!ladish_write_indented_string(fd, indent, "<key name=\""))
  85   {
  86     return false;
  87   }
  88
  89   if (!ladish_write_string(fd, key))
  90   {
  91     return false;
  92   }
  93
  94   if (!ladish_write_string(fd, "\">"))
  95   {
  96     return false;
  97   }
  98
  99   if (!ladish_write_string(fd, value))
 100   {
 101     return false;
 102   }
 103
 104   if (!ladish_write_string(fd, "</key>\n"))
 105   {
 106     return false;
 107   }
 108
 109   return true;
 110 }
 111
 112 static
 113 bool
 114 ladish_save_vgraph_client_begin(
 115   void * context,
 116   ladish_graph_handle graph,
 117   ladish_client_handle client_handle,
 118   const char * client_name,
 119   void ** client_iteration_context_ptr_ptr)
 120 {
 121   uuid_t uuid;
 122   char str[37];
 123
 124   ladish_client_get_uuid(client_handle, uuid);
 125   uuid_unparse(uuid, str);
 126
 127   log_info("saving vgraph client '%s' (%s)", client_name, str);
 128
 129   if (!ladish_write_indented_string(fd, indent, "<client name=\""))
 130   {
 131     return false;
 132   }
 133
 134   if (!ladish_write_string(fd, client_name))
 135   {
 136     return false;
 137   }
 138
 139   if (!ladish_write_string(fd, "\" uuid=\""))
 140   {
 141     return false;
 142   }
 143
 144   if (!ladish_write_string(fd, str))
 145   {
 146     return false;
 147   }
 148
 149   if (!ladish_write_string(fd, "\">\n"))
 150   {
 151     return false;
 152   }
 153
 154   if (!ladish_write_indented_string(fd, indent + 1, "<ports>\n"))
 155   {
 156     return false;
 157   }
 158
 159   return true;
 160 }
 161
 162 static
 163 bool
 164 ladish_save_vgraph_client_end(
 165   void * context,
 166   ladish_graph_handle graph,
 167   ladish_client_handle client_handle,
 168   const char * client_name,
 169   void * client_iteration_context_ptr)
 170 {
 171   if (!ladish_write_indented_string(fd, indent + 1, "</ports>\n"))
 172   {
 173     return false;
 174   }
 175
 176   if (!ladish_write_dict(fd, indent + 1, ladish_client_get_dict(client_handle)))
 177   {
 178     return false;
 179   }
 180
 181   if (!ladish_write_indented_string(fd, indent, "</client>\n"))
 182   {
 183     return false;
 184   }
 185
 186   return true;
 187 }
 188
 189 static bool ladish_get_vgraph_port_uuids(ladish_graph_handle vgraph, ladish_port_handle port, uuid_t uuid, uuid_t link_uuid)
 190 {
 191   bool link;
 192
 193   if (vgraph != ladish_studio_get_studio_graph())
 194   {
 195     link = false;               /* room ports are saved using their fixed uuids */
 196   }
 197   else
 198   {
 199     link = ladish_port_is_link(port);
 200     if (link)
 201     {
 202       /* get the generated port uuid that is used for identification in the virtual graph */
 203       ladish_graph_get_port_uuid(vgraph, port, uuid);
 204     }
 205   }
 206
 207   if (!link || link_uuid != NULL)
 208   {
 209     /* get the real port uuid that is same in both room and studio graphs */
 210     ladish_port_get_uuid(port, link ? link_uuid : uuid);
 211   }
 212
 213   return link;
 214 }
 215
 216 static
 217 bool
 218 ladish_save_vgraph_port(
 219   void * context,
 220   ladish_graph_handle graph,
 221   void * client_iteration_context_ptr,
 222   ladish_client_handle client_handle,
 223   const char * client_name,
 224   ladish_port_handle port_handle,
 225   const char * port_name,
 226   uint32_t port_type,
 227   uint32_t port_flags)
 228 {
 229   uuid_t uuid;
 230   bool link;
 231   uuid_t link_uuid;
 232   char str[37];
 233   char link_str[37];
 234   ladish_dict_handle dict;
 235
 236   link = ladish_get_vgraph_port_uuids(graph, port_handle, uuid, link_uuid);
 237   uuid_unparse(uuid, str);
 238   if (link)
 239   {
 240     uuid_unparse(link_uuid, link_str);
 241     log_info("saving vgraph link port '%s':'%s' (%s link=%s)", client_name, port_name, str, link_str);
 242   }
 243   else
 244   {
 245     log_info("saving vgraph port '%s':'%s' (%s)", client_name, port_name, str);
 246   }
 247
 248   if (!ladish_write_indented_string(fd, indent + 2, "<port name=\""))
 249   {
 250     return false;
 251   }
 252
 253   if (!ladish_write_string(fd, port_name))
 254   {
 255     return false;
 256   }
 257
 258   if (!ladish_write_string(fd, "\" uuid=\""))
 259   {
 260     return false;
 261   }
 262
 263   if (!ladish_write_string(fd, str))
 264   {
 265     return false;
 266   }
 267
 268   if (link)
 269   {
 270     if (!ladish_write_string(fd, "\" link_uuid=\""))
 271     {
 272       return false;
 273     }
 274
 275     if (!ladish_write_string(fd, link_str))
 276     {
 277       return false;
 278     }
 279   }
 280
 281   dict = ladish_port_get_dict(port_handle);
 282   if (ladish_dict_is_empty(dict))
 283   {
 284     if (!ladish_write_string(fd, "\" />\n"))
 285     {
 286       return false;
 287     }
 288   }
 289   else
 290   {
 291     if (!ladish_write_string(fd, "\">\n"))
 292     {
 293       return false;
 294     }
 295
 296     if (!ladish_write_dict(fd, indent + 3, dict))
 297     {
 298       return false;
 299     }
 300
 301     if (!ladish_write_indented_string(fd, indent + 2, "</port>\n"))
 302     {
 303       return false;
 304     }
 305   }
 306
 307   return true;
 308 }
 309
 310 static
 311 bool
 312 ladish_save_vgraph_connection(
 313   void * context,
 314   ladish_graph_handle graph,
 315   ladish_port_handle port1_handle,
 316   ladish_port_handle port2_handle,
 317   ladish_dict_handle dict)
 318 {
 319   uuid_t uuid;
 320   char str[37];
 321
 322   log_info("saving vgraph connection");
 323
 324   if (!ladish_write_indented_string(fd, indent, "<connection port1=\""))
 325   {
 326     return false;
 327   }
 328
 329   ladish_get_vgraph_port_uuids(graph, port1_handle, uuid, NULL);
 330   uuid_unparse(uuid, str);
 331
 332   if (!ladish_write_string(fd, str))
 333   {
 334     return false;
 335   }
 336
 337   if (!ladish_write_string(fd, "\" port2=\""))
 338   {
 339     return false;
 340   }
 341
 342   ladish_get_vgraph_port_uuids(graph, port2_handle, uuid, NULL);
 343   uuid_unparse(uuid, str);
 344
 345   if (!ladish_write_string(fd, str))
 346   {
 347     return false;
 348   }
 349
 350   if (ladish_dict_is_empty(dict))
 351   {
 352     if (!ladish_write_string(fd, "\" />\n"))
 353     {
 354       return false;
 355     }
 356   }
 357   else
 358   {
 359     if (!ladish_write_string(fd, "\">\n"))
 360     {
 361       return false;
 362     }
 363
 364     if (!ladish_write_dict(fd, indent + 1, dict))
 365     {
 366       return false;
 367     }
 368
 369     if (!ladish_write_indented_string(fd, indent, "</connection>\n"))
 370     {
 371       return false;
 372     }
 373   }
 374
 375   return true;
 376 }
 377
 378 static
 379 bool
 380 ladish_save_app(
 381   void * context,
 382   const char * name,
 383   bool running,
 384   const char * command,
 385   bool terminal,
 386   uint8_t level,
 387   pid_t pid,
 388   const uuid_t uuid)
 389 {
 390   char buf[100];
 391   const char * unescaped_string;
 392   char * escaped_string;
 393   char * escaped_buffer;
 394   bool ret;
 395
 396   log_info("saving app: name='%s', %srunning, %s, level %u, commandline='%s'", name, running ? "" : "not ", terminal ? "terminal" : "shell", (unsigned int)level, command);
 397
 398   ret = false;
 399
 400   escaped_buffer = malloc(ladish_max(strlen(name), strlen(command)) * 3 + 1); /* encode each char in three bytes (percent encoding) */
 401   if (escaped_buffer == NULL)
 402   {
 403     log_error("malloc() failed.");
 404     goto exit;
 405   }
 406
 407   if (!ladish_write_indented_string(fd, indent, "<application name=\""))
 408   {
 409     goto free_buffer;
 410   }
 411
 412   unescaped_string = name;
 413   escaped_string = escaped_buffer;
 414   escape(&unescaped_string, &escaped_string);
 415   *escaped_string = 0;
 416   if (!ladish_write_string(fd, escaped_buffer))
 417   {
 418     goto free_buffer;
 419   }
 420
 421   if (!ladish_write_string(fd, "\" terminal=\""))
 422   {
 423     goto free_buffer;
 424   }
 425
 426   if (!ladish_write_string(fd, terminal ? "true" : "false"))
 427   {
 428     goto free_buffer;
 429   }
 430
 431   if (!ladish_write_string(fd, "\" level=\""))
 432   {
 433     goto free_buffer;
 434   }
 435
 436   sprintf(buf, "%u", (unsigned int)level);
 437
 438   if (!ladish_write_string(fd, buf))
 439   {
 440     goto free_buffer;
 441   }
 442
 443   if (!ladish_write_string(fd, "\" autorun=\""))
 444   {
 445     goto free_buffer;
 446   }
 447
 448   if (!ladish_write_string(fd, running ? "true" : "false"))
 449   {
 450     goto free_buffer;
 451   }
 452
 453   if (!ladish_write_string(fd, "\">"))
 454   {
 455     goto free_buffer;
 456   }
 457
 458   unescaped_string = command;
 459   escaped_string = escaped_buffer;
 460   escape(&unescaped_string, &escaped_string);
 461   *escaped_string = 0;
 462   if (!ladish_write_string(fd, escaped_buffer))
 463   {
 464     goto free_buffer;
 465   }
 466
 467   if (!ladish_write_string(fd, "</application>\n"))
 468   {
 469     goto free_buffer;
 470   }
 471
 472   ret = true;
 473
 474 free_buffer:
 475   free(escaped_buffer);
 476
 477 exit:
 478   return ret;
 479 }
 480
 481 static
 482 bool
 483 ladish_write_room_port(
 484   void * context,
 485   ladish_port_handle port,
 486   const char * name,
 487   uint32_t type,
 488   uint32_t flags)
 489 {
 490   uuid_t uuid;
 491   char str[37];
 492   bool midi;
 493   const char * type_str;
 494   bool playback;
 495   const char * direction_str;
 496   ladish_dict_handle dict;
 497
 498   ladish_port_get_uuid(port, uuid);
 499   uuid_unparse(uuid, str);
 500
 501   playback = (flags & JACKDBUS_PORT_FLAG_INPUT) != 0;
 502   ASSERT(playback || (flags & JACKDBUS_PORT_FLAG_OUTPUT) != 0); /* playback or capture */
 503   ASSERT(!(playback && (flags & JACKDBUS_PORT_FLAG_OUTPUT) != 0)); /* but not both */
 504   direction_str = playback ? "playback" : "capture";
 505
 506   midi = type == JACKDBUS_PORT_TYPE_MIDI;
 507   ASSERT(midi || type == JACKDBUS_PORT_TYPE_AUDIO); /* midi or audio */
 508   ASSERT(!(midi && type == JACKDBUS_PORT_TYPE_AUDIO)); /* but not both */
 509   type_str = midi ? "midi" : "audio";
 510
 511   log_info("saving room %s %s port '%s' (%s)", direction_str, type_str, name, str);
 512
 513   if (!ladish_write_indented_string(fd, indent, "<port name=\""))
 514   {
 515     return false;
 516   }
 517
 518   if (!ladish_write_string(fd, name))
 519   {
 520     return false;
 521   }
 522
 523   if (!ladish_write_string(fd, "\" uuid=\""))
 524   {
 525     return false;
 526   }
 527
 528   if (!ladish_write_string(fd, str))
 529   {
 530     return false;
 531   }
 532
 533   if (!ladish_write_string(fd, "\" type=\""))
 534   {
 535     return false;
 536   }
 537
 538   if (!ladish_write_string(fd, type_str))
 539   {
 540     return false;
 541   }
 542
 543   if (!ladish_write_string(fd, "\" direction=\""))
 544   {
 545     return false;
 546   }
 547
 548   if (!ladish_write_string(fd, direction_str))
 549   {
 550     return false;
 551   }
 552
 553   dict = ladish_port_get_dict(port);
 554   if (ladish_dict_is_empty(dict))
 555   {
 556     if (!ladish_write_string(fd, "\" />\n"))
 557     {
 558       return false;
 559     }
 560   }
 561   else
 562   {
 563     if (!ladish_write_string(fd, "\">\n"))
 564     {
 565       return false;
 566     }
 567
 568     if (!ladish_write_dict(fd, indent + 1, dict))
 569     {
 570       return false;
 571     }
 572
 573     if (!ladish_write_indented_string(fd, indent, "</port>\n"))
 574     {
 575       return false;
 576     }
 577   }
 578
 579   return true;
 580 }
 581
 582 static
 583 bool
 584 ladish_save_jack_client_begin(
 585   void * context,
 586   ladish_graph_handle graph_handle,
 587   ladish_client_handle client_handle,
 588   const char * client_name,
 589   void ** client_iteration_context_ptr_ptr)
 590 {
 591   uuid_t uuid;
 592   char str[37];
 593
 594   ladish_client_get_uuid(client_handle, uuid);
 595   uuid_unparse(uuid, str);
 596
 597   log_info("saving jack client '%s' (%s)", client_name, str);
 598
 599   if (!ladish_write_indented_string(fd, indent, "<client name=\""))
 600   {
 601     return false;
 602   }
 603
 604   if (!ladish_write_string(fd, client_name))
 605   {
 606     return false;
 607   }
 608
 609   if (!ladish_write_string(fd, "\" uuid=\""))
 610   {
 611     return false;
 612   }
 613
 614   if (!ladish_write_string(fd, str))
 615   {
 616     return false;
 617   }
 618
 619   if (!ladish_write_string(fd, "\">\n"))
 620   {
 621     return false;
 622   }
 623
 624   if (!ladish_write_indented_string(fd, indent + 1, "<ports>\n"))
 625   {
 626     return false;
 627   }
 628
 629   return true;
 630 }
 631
 632 static
 633 bool
 634 ladish_save_jack_client_end(
 635   void * context,
 636   ladish_graph_handle graph_handle,
 637   ladish_client_handle client_handle,
 638   const char * client_name,
 639   void * client_iteration_context_ptr)
 640 {
 641   if (!ladish_write_indented_string(fd, indent + 1, "</ports>\n"))
 642   {
 643     return false;
 644   }
 645
 646   if (!ladish_write_indented_string(fd, indent, "</client>\n"))
 647   {
 648     return false;
 649   }
 650
 651   return true;
 652 }
 653
 654 static
 655 bool
 656 ladish_save_jack_port(
 657   void * context,
 658   ladish_graph_handle graph_handle,
 659   void * client_iteration_context_ptr,
 660   ladish_client_handle client_handle,
 661   const char * client_name,
 662   ladish_port_handle port_handle,
 663   const char * port_name,
 664   uint32_t port_type,
 665   uint32_t port_flags)
 666 {
 667   uuid_t uuid;
 668   char str[37];
 669
 670   ladish_port_get_uuid(port_handle, uuid);
 671   uuid_unparse(uuid, str);
 672
 673   log_info("saving jack port '%s':'%s' (%s)", client_name, port_name, str);
 674
 675   if (!ladish_write_indented_string(fd, indent + 2, "<port name=\""))
 676   {
 677     return false;
 678   }
 679
 680   if (!ladish_write_string(fd, port_name))
 681   {
 682     return false;
 683   }
 684
 685   if (!ladish_write_string(fd, "\" uuid=\""))
 686   {
 687     return false;
 688   }
 689
 690   if (!ladish_write_string(fd, str))
 691   {
 692     return false;
 693   }
 694
 695   if (!ladish_write_string(fd, "\" />\n"))
 696   {
 697     return false;
 698   }
 699
 700   return true;
 701 }
 702
 703 #undef indent
 704 #undef fd
 705
 706 bool ladish_write_dict(int fd, int indent, ladish_dict_handle dict)
 707 {
 708   struct ladish_write_context context;
 709
 710   if (ladish_dict_is_empty(dict))
 711   {
 712     return true;
 713   }
 714
 715   context.fd = fd;
 716   context.indent = indent + 1;
 717
 718   if (!ladish_write_indented_string(fd, indent, "<dict>\n"))
 719   {
 720     return false;
 721   }
 722
 723   if (!ladish_dict_iterate(dict, &context, write_dict_entry))
 724   {
 725     return false;
 726   }
 727
 728   if (!ladish_write_indented_string(fd, indent, "</dict>\n"))
 729   {
 730     return false;
 731   }
 732
 733   return true;
 734 }
 735
 736 bool ladish_write_vgraph(int fd, int indent, ladish_graph_handle vgraph, ladish_app_supervisor_handle app_supervisor)
 737 {
 738   struct ladish_write_context context;
 739
 740   context.fd = fd;
 741   context.indent = indent + 1;
 742
 743   if (!ladish_write_indented_string(fd, indent, "<clients>\n"))
 744   {
 745     return false;
 746   }
 747
 748   if (!ladish_graph_iterate_nodes(
 749         vgraph,
 750         true,
 751         NULL,
 752         &context,
 753         ladish_save_vgraph_client_begin,
 754         ladish_save_vgraph_port,
 755         ladish_save_vgraph_client_end))
 756   {
 757     log_error("ladish_graph_iterate_nodes() failed");
 758     return false;
 759   }
 760
 761   if (!ladish_write_indented_string(fd, indent, "</clients>\n"))
 762   {
 763     return false;
 764   }
 765
 766   if (!ladish_write_indented_string(fd, indent, "<connections>\n"))
 767   {
 768     return false;
 769   }
 770
 771   if (!ladish_graph_iterate_connections(vgraph, true, &context, ladish_save_vgraph_connection))
 772   {
 773     log_error("ladish_graph_iterate_connections() failed");
 774     return false;
 775   }
 776
 777   if (!ladish_write_indented_string(fd, indent, "</connections>\n"))
 778   {
 779     return false;
 780   }
 781
 782   if (!ladish_write_indented_string(fd, indent, "<applications>\n"))
 783   {
 784     return false;
 785   }
 786
 787   if (!ladish_app_supervisor_enum(app_supervisor, &context, ladish_save_app))
 788   {
 789     return false;
 790   }
 791
 792   if (!ladish_write_indented_string(fd, indent, "</applications>\n"))
 793   {
 794     return false;
 795   }
 796
 797   return true;
 798 }
 799
 800 bool ladish_write_room_link_ports(int fd, int indent, ladish_room_handle room)
 801 {
 802   struct ladish_write_context context;
 803
 804   context.fd = fd;
 805   context.indent = indent;
 806
 807   if (!ladish_room_iterate_link_ports(room, &context, ladish_write_room_port))
 808   {
 809     log_error("ladish_room_iterate_link_ports() failed");
 810     return false;
 811   }
 812
 813   return true;
 814 }
 815
 816 bool ladish_write_jgraph(int fd, int indent, ladish_graph_handle vgraph)
 817 {
 818   struct ladish_write_context context;
 819
 820   if (!ladish_write_indented_string(fd, indent, "<clients>\n"))
 821   {
 822     return false;
 823   }
 824
 825   context.fd = fd;
 826   context.indent = indent + 1;
 827
 828   if (!ladish_graph_iterate_nodes(
 829         ladish_studio_get_jack_graph(),
 830         true,
 831         vgraph,
 832         &context,
 833         ladish_save_jack_client_begin,
 834         ladish_save_jack_port,
 835         ladish_save_jack_client_end))
 836   {
 837     log_error("ladish_graph_iterate_nodes() failed");
 838     return false;
 839   }
 840
 841   if (!ladish_write_indented_string(fd, indent, "</clients>\n"))
 842   {
 843     return false;
 844   }
 845
 846   return true;
 847 }