daemon/cmd_save_studio.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of the "save studio" command
   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 "common.h"
  28
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <fcntl.h>
  32 #include <unistd.h>
  33
  34 #include "escape.h"
  35 #include "studio_internal.h"
  36 #include "cmd.h"
  37
  38 struct save_context
  39 {
  40   int fd;
  41   const char * indent;
  42 };
  43
  44 #define STUDIO_HEADER_TEXT BASE_NAME " Studio configuration.\n"
  45
  46 bool
  47 write_string(int fd, const char * string)
  48 {
  49   size_t len;
  50
  51   len = strlen(string);
  52
  53   if (write(fd, string, len) != len)
  54   {
  55     log_error("write() failed to write config file.");
  56     return false;
  57   }
  58
  59   return true;
  60 }
  61
  62 bool
  63 write_jack_parameter(
  64   int fd,
  65   const char * indent,
  66   struct jack_conf_parameter * parameter_ptr)
  67 {
  68   const char * src;
  69   char * dst;
  70   char path[JACK_CONF_MAX_ADDRESS_SIZE * 3]; /* encode each char in three bytes (percent encoding) */
  71   const char * content;
  72   char valbuf[100];
  73
  74   /* compose the parameter path, percent-encode "bad" chars */
  75   src = parameter_ptr->address;
  76   dst = path;
  77   do
  78   {
  79     *dst++ = '/';
  80     escape(&src, &dst);
  81     src++;
  82   }
  83   while (*src != 0);
  84   *dst = 0;
  85
  86   if (!write_string(fd, indent))
  87   {
  88     return false;
  89   }
  90
  91   if (!write_string(fd, "<parameter path=\""))
  92   {
  93     return false;
  94   }
  95
  96   if (!write_string(fd, path))
  97   {
  98     return false;
  99   }
 100
 101   if (!write_string(fd, "\">"))
 102   {
 103     return false;
 104   }
 105
 106   switch (parameter_ptr->parameter.type)
 107   {
 108   case jack_boolean:
 109     content = parameter_ptr->parameter.value.boolean ? "true" : "false";
 110     log_debug("%s value is %s (boolean)", path, content);
 111     break;
 112   case jack_string:
 113     content = parameter_ptr->parameter.value.string;
 114     log_debug("%s value is %s (string)", path, content);
 115     break;
 116   case jack_byte:
 117     valbuf[0] = (char)parameter_ptr->parameter.value.byte;
 118     valbuf[1] = 0;
 119     content = valbuf;
 120     log_debug("%s value is %u/%c (byte/char)", path, parameter_ptr->parameter.value.byte, (char)parameter_ptr->parameter.value.byte);
 121     break;
 122   case jack_uint32:
 123     snprintf(valbuf, sizeof(valbuf), "%" PRIu32, parameter_ptr->parameter.value.uint32);
 124     content = valbuf;
 125     log_debug("%s value is %s (uint32)", path, content);
 126     break;
 127   case jack_int32:
 128     snprintf(valbuf, sizeof(valbuf), "%" PRIi32, parameter_ptr->parameter.value.int32);
 129     content = valbuf;
 130     log_debug("%s value is %s (int32)", path, content);
 131     break;
 132   default:
 133     log_error("unknown jack parameter_ptr->parameter type %d (%s)", (int)parameter_ptr->parameter.type, path);
 134     return false;
 135   }
 136
 137   if (!write_string(fd, content))
 138   {
 139     return false;
 140   }
 141
 142   if (!write_string(fd, "</parameter>\n"))
 143   {
 144     return false;
 145   }
 146
 147   return true;
 148 }
 149
 150 static
 151 bool
 152 write_dict_entry(
 153   void * context,
 154   const char * key,
 155   const char * value);
 156
 157 bool
 158 write_dict(
 159   int fd,
 160   const char * indent,
 161   ladish_dict_handle dict)
 162 {
 163   struct save_context context;
 164
 165   if (ladish_dict_is_empty(dict))
 166   {
 167     return true;
 168   }
 169
 170   if (!write_string(fd, indent))
 171   {
 172     return false;
 173   }
 174
 175   context.fd = fd;
 176   context.indent = indent;
 177
 178   if (!write_string(fd, "<dict>\n"))
 179   {
 180     return false;
 181   }
 182
 183   if (!ladish_dict_iterate(dict, &context, write_dict_entry))
 184   {
 185     return false;
 186   }
 187
 188   if (!write_string(fd, indent))
 189   {
 190     return false;
 191   }
 192
 193   if (!write_string(fd, "</dict>\n"))
 194   {
 195     return false;
 196   }
 197
 198   return true;
 199 }
 200
 201 #define fd (((struct save_context *)context)->fd)
 202 #define indent (((struct save_context *)context)->indent)
 203
 204 static
 205 bool
 206 write_dict_entry(
 207   void * context,
 208   const char * key,
 209   const char * value)
 210 {
 211   if (!write_string(fd, indent))
 212   {
 213     return false;
 214   }
 215
 216   if (!write_string(fd, "  <key name=\""))
 217   {
 218     return false;
 219   }
 220
 221   if (!write_string(fd, key))
 222   {
 223     return false;
 224   }
 225
 226   if (!write_string(fd, "\">"))
 227   {
 228     return false;
 229   }
 230
 231   if (!write_string(fd, value))
 232   {
 233     return false;
 234   }
 235
 236   if (!write_string(fd, "</key>\n"))
 237   {
 238     return false;
 239   }
 240
 241   return true;
 242 }
 243
 244 bool
 245 save_jack_client_begin(
 246   void * context,
 247   ladish_client_handle client_handle,
 248   const char * client_name,
 249   void ** client_iteration_context_ptr_ptr)
 250 {
 251   uuid_t uuid;
 252   char str[37];
 253
 254   ladish_client_get_uuid(client_handle, uuid);
 255   uuid_unparse(uuid, str);
 256
 257   log_info("saving jack client '%s' (%s)", client_name, str);
 258
 259   if (!write_string(fd, "      <client name=\""))
 260   {
 261     return false;
 262   }
 263
 264   if (!write_string(fd, client_name))
 265   {
 266     return false;
 267   }
 268
 269   if (!write_string(fd, "\" uuid=\""))
 270   {
 271     return false;
 272   }
 273
 274   if (!write_string(fd, str))
 275   {
 276     return false;
 277   }
 278
 279   if (!write_string(fd, "\">\n"))
 280   {
 281     return false;
 282   }
 283
 284   if (!write_string(fd, "        <ports>\n"))
 285   {
 286     return false;
 287   }
 288
 289   return true;
 290 }
 291
 292 bool
 293 save_jack_client_end(
 294   void * context,
 295   ladish_client_handle client_handle,
 296   const char * client_name,
 297   void * client_iteration_context_ptr)
 298 {
 299   if (!write_string(fd, "        </ports>\n"))
 300   {
 301     return false;
 302   }
 303
 304   if (!write_string(fd, "      </client>\n"))
 305   {
 306     return false;
 307   }
 308
 309   return true;
 310 }
 311
 312 bool
 313 save_jack_port(
 314   void * context,
 315   void * client_iteration_context_ptr,
 316   ladish_client_handle client_handle,
 317   const char * client_name,
 318   ladish_port_handle port_handle,
 319   const char * port_name,
 320   uint32_t port_type,
 321   uint32_t port_flags)
 322 {
 323   uuid_t uuid;
 324   char str[37];
 325
 326   ladish_port_get_uuid(port_handle, uuid);
 327   uuid_unparse(uuid, str);
 328
 329   log_info("saving jack port '%s':'%s' (%s)", client_name, port_name, str);
 330
 331   if (!write_string(fd, "          <port name=\""))
 332   {
 333     return false;
 334   }
 335
 336   if (!write_string(fd, port_name))
 337   {
 338     return false;
 339   }
 340
 341   if (!write_string(fd, "\" uuid=\""))
 342   {
 343     return false;
 344   }
 345
 346   if (!write_string(fd, str))
 347   {
 348     return false;
 349   }
 350
 351   if (!write_string(fd, "\" />\n"))
 352   {
 353     return false;
 354   }
 355
 356   return true;
 357 }
 358
 359 bool
 360 save_studio_client_begin(
 361   void * context,
 362   ladish_client_handle client_handle,
 363   const char * client_name,
 364   void ** client_iteration_context_ptr_ptr)
 365 {
 366   uuid_t uuid;
 367   char str[37];
 368
 369   ladish_client_get_uuid(client_handle, uuid);
 370   uuid_unparse(uuid, str);
 371
 372   log_info("saving studio client '%s' (%s)", client_name, str);
 373
 374   if (!write_string(fd, "    <client name=\""))
 375   {
 376     return false;
 377   }
 378
 379   if (!write_string(fd, client_name))
 380   {
 381     return false;
 382   }
 383
 384   if (!write_string(fd, "\" uuid=\""))
 385   {
 386     return false;
 387   }
 388
 389   if (!write_string(fd, str))
 390   {
 391     return false;
 392   }
 393
 394   if (!write_string(fd, "\">\n"))
 395   {
 396     return false;
 397   }
 398
 399   if (!write_string(fd, "      <ports>\n"))
 400   {
 401     return false;
 402   }
 403
 404   return true;
 405 }
 406
 407 bool
 408 save_studio_client_end(
 409   void * context,
 410   ladish_client_handle client_handle,
 411   const char * client_name,
 412   void * client_iteration_context_ptr)
 413 {
 414   if (!write_string(fd, "      </ports>\n"))
 415   {
 416     return false;
 417   }
 418
 419   if (!write_dict(fd, "      ", ladish_client_get_dict(client_handle)))
 420   {
 421     return false;
 422   }
 423
 424   if (!write_string(fd, "    </client>\n"))
 425   {
 426     return false;
 427   }
 428
 429   return true;
 430 }
 431
 432 bool
 433 save_studio_port(
 434   void * context,
 435   void * client_iteration_context_ptr,
 436   ladish_client_handle client_handle,
 437   const char * client_name,
 438   ladish_port_handle port_handle,
 439   const char * port_name,
 440   uint32_t port_type,
 441   uint32_t port_flags)
 442 {
 443   uuid_t uuid;
 444   char str[37];
 445   ladish_dict_handle dict;
 446
 447   ladish_port_get_uuid(port_handle, uuid);
 448   uuid_unparse(uuid, str);
 449
 450   log_info("saving studio port '%s':'%s' (%s)", client_name, port_name, str);
 451
 452   if (!write_string(fd, "        <port name=\""))
 453   {
 454     return false;
 455   }
 456
 457   if (!write_string(fd, port_name))
 458   {
 459     return false;
 460   }
 461
 462   if (!write_string(fd, "\" uuid=\""))
 463   {
 464     return false;
 465   }
 466
 467   if (!write_string(fd, str))
 468   {
 469     return false;
 470   }
 471
 472   dict = ladish_port_get_dict(port_handle);
 473   if (ladish_dict_is_empty(dict))
 474   {
 475     if (!write_string(fd, "\" />\n"))
 476     {
 477       return false;
 478     }
 479   }
 480   else
 481   {
 482     if (!write_string(fd, "\">\n"))
 483     {
 484       return false;
 485     }
 486
 487     if (!write_dict(fd, "          ", dict))
 488     {
 489       return false;
 490     }
 491
 492     if (!write_string(fd, "        </port>\n"))
 493     {
 494       return false;
 495     }
 496   }
 497
 498   return true;
 499 }
 500
 501 bool save_studio_connection(void * context, ladish_port_handle port1_handle, ladish_port_handle port2_handle, ladish_dict_handle dict)
 502 {
 503   uuid_t uuid;
 504   char str[37];
 505
 506   log_info("saving studio connection");
 507
 508   if (!write_string(fd, "    <connection port1=\""))
 509   {
 510     return false;
 511   }
 512
 513   ladish_port_get_uuid(port1_handle, uuid);
 514   uuid_unparse(uuid, str);
 515
 516   if (!write_string(fd, str))
 517   {
 518     return false;
 519   }
 520
 521   if (!write_string(fd, "\" port2=\""))
 522   {
 523     return false;
 524   }
 525
 526   ladish_port_get_uuid(port2_handle, uuid);
 527   uuid_unparse(uuid, str);
 528
 529   if (!write_string(fd, str))
 530   {
 531     return false;
 532   }
 533
 534   if (ladish_dict_is_empty(dict))
 535   {
 536     if (!write_string(fd, "\" />\n"))
 537     {
 538       return false;
 539     }
 540   }
 541   else
 542   {
 543     if (!write_string(fd, "\">\n"))
 544     {
 545       return false;
 546     }
 547
 548     if (!write_dict(fd, "      ", dict))
 549     {
 550       return false;
 551     }
 552
 553     if (!write_string(fd, "    </connection>\n"))
 554     {
 555       return false;
 556     }
 557   }
 558
 559   return true;
 560 }
 561
 562 bool save_studio_app(void * context, const char * name, bool running, const char * command, bool terminal, uint8_t level)
 563 {
 564   char buf[100];
 565   const char * unescaped_string;
 566   char * escaped_string;
 567   char * escaped_buffer;
 568   bool ret;
 569
 570   log_info("saving app: name='%s', %srunning, %s, level %u, commandline='%s'", name, running ? "" : "not ", terminal ? "terminal" : "shell", (unsigned int)level, command);
 571
 572   ret = false;
 573
 574   escaped_buffer = malloc(ladish_max(strlen(name), strlen(command)) * 3 + 1); /* encode each char in three bytes (percent encoding) */
 575   if (escaped_buffer == NULL)
 576   {
 577     log_error("malloc() failed.");
 578     goto exit;
 579   }
 580
 581   if (!write_string(fd, "    <application name=\""))
 582   {
 583     goto free_buffer;
 584   }
 585
 586   unescaped_string = name;
 587   escaped_string = escaped_buffer;
 588   escape(&unescaped_string, &escaped_string);
 589   *escaped_string = 0;
 590   if (!write_string(fd, escaped_buffer))
 591   {
 592     goto free_buffer;
 593   }
 594
 595   if (!write_string(fd, "\" terminal=\""))
 596   {
 597     goto free_buffer;
 598   }
 599
 600   if (!write_string(fd, terminal ? "true" : "false"))
 601   {
 602     goto free_buffer;
 603   }
 604
 605   if (!write_string(fd, "\" level=\""))
 606   {
 607     goto free_buffer;
 608   }
 609
 610   sprintf(buf, "%u", (unsigned int)level);
 611
 612   if (!write_string(fd, buf))
 613   {
 614     goto free_buffer;
 615   }
 616
 617   if (!write_string(fd, "\" autorun=\""))
 618   {
 619     goto free_buffer;
 620   }
 621
 622   if (!write_string(fd, running ? "true" : "false"))
 623   {
 624     goto free_buffer;
 625   }
 626
 627   if (!write_string(fd, "\">"))
 628   {
 629     goto free_buffer;
 630   }
 631
 632   unescaped_string = command;
 633   escaped_string = escaped_buffer;
 634   escape(&unescaped_string, &escaped_string);
 635   *escaped_string = 0;
 636   if (!write_string(fd, escaped_buffer))
 637   {
 638     goto free_buffer;
 639   }
 640
 641   if (!write_string(fd, "</application>\n"))
 642   {
 643     goto free_buffer;
 644   }
 645
 646   ret = true;
 647
 648 free_buffer:
 649   free(escaped_buffer);
 650
 651 exit:
 652   return ret;
 653 }
 654
 655 #undef indent
 656 #undef fd
 657
 658 struct ladish_command_save_studio
 659 {
 660   struct ladish_command command;
 661   char * studio_name;
 662 };
 663
 664 #define cmd_ptr ((struct ladish_command_save_studio *)command_context)
 665
 666 static bool run(void * command_context)
 667 {
 668   struct list_head * node_ptr;
 669   struct jack_conf_parameter * parameter_ptr;
 670   int fd;
 671   time_t timestamp;
 672   char timestamp_str[26];
 673   bool ret;
 674   char * filename;              /* filename */
 675   char * bak_filename;          /* filename of the backup file */
 676   char * old_filename;          /* filename where studio was persisted before save */
 677   struct stat st;
 678   struct save_context save_context;
 679
 680   ASSERT(cmd_ptr->command.state == LADISH_COMMAND_STATE_PENDING);
 681
 682   time(&timestamp);
 683   ctime_r(&timestamp, timestamp_str);
 684   timestamp_str[24] = 0;
 685
 686   ret = false;
 687
 688   if (!studio_is_started())
 689   {
 690     log_error("Cannot save not-started studio");
 691     goto exit;
 692   }
 693
 694   if (!studio_compose_filename(cmd_ptr->studio_name, &filename, &bak_filename))
 695   {
 696     log_error("failed to compose studio filename");
 697     goto exit;
 698   }
 699
 700   if (g_studio.filename == NULL)
 701   {
 702     /* saving studio for first time */
 703     g_studio.filename = filename;
 704     free(bak_filename);
 705     bak_filename = NULL;
 706     old_filename = NULL;
 707   }
 708   else if (strcmp(g_studio.filename, filename) == 0)
 709   {
 710     /* saving already persisted studio that was not renamed */
 711     old_filename = filename;
 712   }
 713   else if (strcmp(cmd_ptr->studio_name, g_studio.name) == 0)
 714   {
 715     /* saving renamed studio */
 716     old_filename = g_studio.filename;
 717     g_studio.filename = filename;
 718   }
 719   else
 720   {
 721     /* saving studio copy (save as) */
 722     old_filename = filename;
 723     g_studio.filename = filename;
 724   }
 725
 726   filename = NULL;
 727   ASSERT(g_studio.filename != NULL);
 728   ASSERT(g_studio.filename != bak_filename);
 729
 730   if (bak_filename != NULL)
 731   {
 732     ASSERT(old_filename != NULL);
 733
 734     if (stat(old_filename, &st) == 0) /* if old filename does not exist, rename with fail */
 735     {
 736       if (rename(old_filename, bak_filename) != 0)
 737       {
 738         log_error("rename(%s, %s) failed: %d (%s)", old_filename, bak_filename, errno, strerror(errno));
 739         goto free_filenames;
 740       }
 741     }
 742     else
 743     {
 744       /* mark that there is no backup file */
 745       free(bak_filename);
 746       bak_filename = NULL;
 747     }
 748   }
 749
 750   log_info("saving studio... (%s)", g_studio.filename);
 751
 752   fd = open(g_studio.filename, O_WRONLY | O_TRUNC | O_CREAT, 0700);
 753   if (fd == -1)
 754   {
 755     log_error("open(%s) failed: %d (%s)", g_studio.filename, errno, strerror(errno));
 756     goto rename_back;
 757   }
 758
 759   if (!write_string(fd, "<?xml version=\"1.0\"?>\n"))
 760   {
 761     goto close;
 762   }
 763
 764   if (!write_string(fd, "<!--\n"))
 765   {
 766     goto close;
 767   }
 768
 769   if (!write_string(fd, STUDIO_HEADER_TEXT))
 770   {
 771     goto close;
 772   }
 773
 774   if (!write_string(fd, "-->\n"))
 775   {
 776     goto close;
 777   }
 778
 779   if (!write_string(fd, "<!-- "))
 780   {
 781     goto close;
 782   }
 783
 784   if (!write_string(fd, timestamp_str))
 785   {
 786     goto close;
 787   }
 788
 789   if (!write_string(fd, " -->\n"))
 790   {
 791     goto close;
 792   }
 793
 794   if (!write_string(fd, "<studio>\n"))
 795   {
 796     goto close;
 797   }
 798
 799   if (!write_string(fd, "  <jack>\n"))
 800   {
 801     goto close;
 802   }
 803
 804   if (!write_string(fd, "    <conf>\n"))
 805   {
 806     goto close;
 807   }
 808
 809   list_for_each(node_ptr, &g_studio.jack_params)
 810   {
 811     parameter_ptr = list_entry(node_ptr, struct jack_conf_parameter, leaves);
 812
 813     if (!write_jack_parameter(fd, "      ", parameter_ptr))
 814     {
 815       goto close;
 816     }
 817   }
 818
 819   if (!write_string(fd, "    </conf>\n"))
 820   {
 821     goto close;
 822   }
 823
 824   if (!write_string(fd, "    <clients>\n"))
 825   {
 826     goto close;
 827   }
 828
 829   save_context.fd = fd;
 830
 831   if (!ladish_graph_iterate_nodes(g_studio.jack_graph, &save_context, save_jack_client_begin, save_jack_port, save_jack_client_end))
 832   {
 833     log_error("ladish_graph_iterate_nodes() failed");
 834     goto close;
 835   }
 836
 837   if (!write_string(fd, "    </clients>\n"))
 838   {
 839     goto close;
 840   }
 841
 842   if (!write_string(fd, "  </jack>\n"))
 843   {
 844     goto close;
 845   }
 846
 847   if (!write_string(fd, "  <clients>\n"))
 848   {
 849     goto close;
 850   }
 851
 852   if (!ladish_graph_iterate_nodes(g_studio.studio_graph, &save_context, save_studio_client_begin, save_studio_port, save_studio_client_end))
 853   {
 854     log_error("ladish_graph_iterate_nodes() failed");
 855     goto close;
 856   }
 857
 858   if (!write_string(fd, "  </clients>\n"))
 859   {
 860     goto close;
 861   }
 862
 863   if (!write_string(fd, "  <connections>\n"))
 864   {
 865     goto close;
 866   }
 867
 868   if (!ladish_graph_iterate_connections(g_studio.studio_graph, &save_context, save_studio_connection))
 869   {
 870     log_error("ladish_graph_iterate_connections() failed");
 871     goto close;
 872   }
 873
 874   if (!write_string(fd, "  </connections>\n"))
 875   {
 876     goto close;
 877   }
 878
 879   if (!write_string(fd, "  <applications>\n"))
 880   {
 881     goto close;
 882   }
 883
 884   if (!ladish_app_supervisor_enum(g_studio.app_supervisor, &save_context, save_studio_app))
 885   {
 886     goto close;
 887   }
 888
 889   if (!write_string(fd, "  </applications>\n"))
 890   {
 891     goto close;
 892   }
 893
 894   if (!write_dict(fd, "  ", ladish_graph_get_dict(g_studio.studio_graph)))
 895   {
 896     goto close;
 897   }
 898
 899   if (!write_string(fd, "</studio>\n"))
 900   {
 901     goto close;
 902   }
 903
 904   log_info("studio saved. (%s)", g_studio.filename);
 905   g_studio.persisted = true;
 906   g_studio.automatic = false;   /* even if it was automatic, it is not anymore because it is saved */
 907
 908   cmd_ptr->command.state = LADISH_COMMAND_STATE_DONE;
 909
 910   ret = true;
 911
 912   if (old_filename == g_studio.filename && strcmp(g_studio.name, cmd_ptr->studio_name) != 0)
 913   {
 914     free(g_studio.name);
 915     g_studio.name = cmd_ptr->studio_name;
 916     cmd_ptr->studio_name = NULL;
 917     emit_studio_renamed();
 918   }
 919
 920 close:
 921   close(fd);
 922
 923 rename_back:
 924   if (!ret && bak_filename != NULL)
 925   {
 926     /* save failed - try to rename the backup file back */
 927     ASSERT(old_filename != NULL);
 928     if (rename(bak_filename, old_filename) != 0)
 929     {
 930       log_error("rename(%s, %s) failed: %d (%s)", bak_filename, g_studio.filename, errno, strerror(errno));
 931     }
 932   }
 933
 934 free_filenames:
 935   if (bak_filename != NULL)
 936   {
 937     free(bak_filename);
 938   }
 939
 940   if (old_filename != NULL && old_filename != g_studio.filename)
 941   {
 942     free(old_filename);
 943   }
 944
 945   ASSERT(filename == NULL);
 946   ASSERT(g_studio.filename != NULL);
 947
 948 exit:
 949   return ret;
 950 }
 951
 952 static void destructor(void * command_context)
 953 {
 954   log_info("save studio command destructor");
 955   if (cmd_ptr->studio_name != NULL)
 956   {
 957     free(cmd_ptr->studio_name);
 958   }
 959 }
 960
 961 #undef cmd_ptr
 962
 963 bool ladish_command_save_studio(void * call_ptr, struct ladish_cqueue * queue_ptr, const char * new_studio_name)
 964 {
 965   struct ladish_command_save_studio * cmd_ptr;
 966   char * studio_name_dup;
 967
 968   studio_name_dup = strdup(new_studio_name);
 969   if (studio_name_dup == NULL)
 970   {
 971     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "strdup('%s') failed.", new_studio_name);
 972     goto fail;
 973   }
 974
 975   cmd_ptr = ladish_command_new(sizeof(struct ladish_command_save_studio));
 976   if (cmd_ptr == NULL)
 977   {
 978     log_error("ladish_command_new() failed.");
 979     goto fail_free_name;
 980   }
 981
 982   cmd_ptr->command.run = run;
 983   cmd_ptr->command.destructor = destructor;
 984   cmd_ptr->studio_name = studio_name_dup;
 985
 986   if (!ladish_cqueue_add_command(queue_ptr, &cmd_ptr->command))
 987   {
 988     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "ladish_cqueue_add_command() failed.");
 989     goto fail_destroy_command;
 990   }
 991
 992   return true;
 993
 994 fail_destroy_command:
 995   free(cmd_ptr);
 996 fail_free_name:
 997   free(studio_name_dup);
 998 fail:
 999   return false;
1000 }