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