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 #define cmd_ptr ((struct ladish_command *)command_context)
 659
 660 static bool run(void * command_context)
 661 {
 662   struct list_head * node_ptr;
 663   struct jack_conf_parameter * parameter_ptr;
 664   int fd;
 665   time_t timestamp;
 666   char timestamp_str[26];
 667   bool ret;
 668   char * filename;              /* filename */
 669   char * bak_filename;          /* filename of the backup file */
 670   char * old_filename;          /* filename where studio was persisted before save */
 671   struct stat st;
 672   struct save_context save_context;
 673
 674   ASSERT(cmd_ptr->state == LADISH_COMMAND_STATE_PENDING);
 675
 676   time(&timestamp);
 677   ctime_r(&timestamp, timestamp_str);
 678   timestamp_str[24] = 0;
 679
 680   ret = false;
 681
 682   if (!studio_is_started())
 683   {
 684     log_error("Cannot save not-started studio");
 685     goto exit;
 686   }
 687
 688   if (!studio_compose_filename(g_studio.name, &filename, &bak_filename))
 689   {
 690     log_error("failed to compose studio filename");
 691     goto exit;
 692   }
 693
 694   if (g_studio.filename == NULL)
 695   {
 696     /* saving studio for first time */
 697     g_studio.filename = filename;
 698     free(bak_filename);
 699     bak_filename = NULL;
 700     old_filename = NULL;
 701   }
 702   else if (strcmp(g_studio.filename, filename) == 0)
 703   {
 704     /* saving already persisted studio that was not renamed */
 705     old_filename = filename;
 706   }
 707   else
 708   {
 709     /* saving renamed studio */
 710     old_filename = g_studio.filename;
 711     g_studio.filename = filename;
 712   }
 713
 714   filename = NULL;
 715   ASSERT(g_studio.filename != NULL);
 716   ASSERT(g_studio.filename != old_filename);
 717   ASSERT(g_studio.filename != bak_filename);
 718
 719   if (bak_filename != NULL)
 720   {
 721     ASSERT(old_filename != NULL);
 722
 723     if (stat(old_filename, &st) == 0) /* if old filename does not exist, rename with fail */
 724     {
 725       if (rename(old_filename, bak_filename) != 0)
 726       {
 727         log_error("rename(%s, %s) failed: %d (%s)", old_filename, bak_filename, errno, strerror(errno));
 728         goto free_filenames;
 729       }
 730     }
 731     else
 732     {
 733       /* mark that there is no backup file */
 734       free(bak_filename);
 735       bak_filename = NULL;
 736     }
 737   }
 738
 739   log_info("saving studio... (%s)", g_studio.filename);
 740
 741   fd = open(g_studio.filename, O_WRONLY | O_TRUNC | O_CREAT, 0700);
 742   if (fd == -1)
 743   {
 744     log_error("open(%s) failed: %d (%s)", g_studio.filename, errno, strerror(errno));
 745     goto rename_back;
 746   }
 747
 748   if (!write_string(fd, "<?xml version=\"1.0\"?>\n"))
 749   {
 750     goto close;
 751   }
 752
 753   if (!write_string(fd, "<!--\n"))
 754   {
 755     goto close;
 756   }
 757
 758   if (!write_string(fd, STUDIO_HEADER_TEXT))
 759   {
 760     goto close;
 761   }
 762
 763   if (!write_string(fd, "-->\n"))
 764   {
 765     goto close;
 766   }
 767
 768   if (!write_string(fd, "<!-- "))
 769   {
 770     goto close;
 771   }
 772
 773   if (!write_string(fd, timestamp_str))
 774   {
 775     goto close;
 776   }
 777
 778   if (!write_string(fd, " -->\n"))
 779   {
 780     goto close;
 781   }
 782
 783   if (!write_string(fd, "<studio>\n"))
 784   {
 785     goto close;
 786   }
 787
 788   if (!write_string(fd, "  <jack>\n"))
 789   {
 790     goto close;
 791   }
 792
 793   if (!write_string(fd, "    <conf>\n"))
 794   {
 795     goto close;
 796   }
 797
 798   list_for_each(node_ptr, &g_studio.jack_params)
 799   {
 800     parameter_ptr = list_entry(node_ptr, struct jack_conf_parameter, leaves);
 801
 802     if (!write_jack_parameter(fd, "      ", parameter_ptr))
 803     {
 804       goto close;
 805     }
 806   }
 807
 808   if (!write_string(fd, "    </conf>\n"))
 809   {
 810     goto close;
 811   }
 812
 813   if (!write_string(fd, "    <clients>\n"))
 814   {
 815     goto close;
 816   }
 817
 818   save_context.fd = fd;
 819
 820   if (!ladish_graph_iterate_nodes(g_studio.jack_graph, &save_context, save_jack_client_begin, save_jack_port, save_jack_client_end))
 821   {
 822     log_error("ladish_graph_iterate_nodes() failed");
 823     goto close;
 824   }
 825
 826   if (!write_string(fd, "    </clients>\n"))
 827   {
 828     goto close;
 829   }
 830
 831   if (!write_string(fd, "  </jack>\n"))
 832   {
 833     goto close;
 834   }
 835
 836   if (!write_string(fd, "  <clients>\n"))
 837   {
 838     goto close;
 839   }
 840
 841   if (!ladish_graph_iterate_nodes(g_studio.studio_graph, &save_context, save_studio_client_begin, save_studio_port, save_studio_client_end))
 842   {
 843     log_error("ladish_graph_iterate_nodes() failed");
 844     goto close;
 845   }
 846
 847   if (!write_string(fd, "  </clients>\n"))
 848   {
 849     goto close;
 850   }
 851
 852   if (!write_string(fd, "  <connections>\n"))
 853   {
 854     goto close;
 855   }
 856
 857   if (!ladish_graph_iterate_connections(g_studio.studio_graph, &save_context, save_studio_connection))
 858   {
 859     log_error("ladish_graph_iterate_connections() failed");
 860     goto close;
 861   }
 862
 863   if (!write_string(fd, "  </connections>\n"))
 864   {
 865     goto close;
 866   }
 867
 868   if (!write_string(fd, "  <applications>\n"))
 869   {
 870     goto close;
 871   }
 872
 873   if (!ladish_app_supervisor_enum(g_studio.app_supervisor, &save_context, save_studio_app))
 874   {
 875     goto close;
 876   }
 877
 878   if (!write_string(fd, "  </applications>\n"))
 879   {
 880     goto close;
 881   }
 882
 883   if (!write_dict(fd, "  ", ladish_graph_get_dict(g_studio.studio_graph)))
 884   {
 885     goto close;
 886   }
 887
 888   if (!write_string(fd, "</studio>\n"))
 889   {
 890     goto close;
 891   }
 892
 893   log_info("studio saved. (%s)", g_studio.filename);
 894   g_studio.persisted = true;
 895   g_studio.automatic = false;   /* even if it was automatic, it is not anymore because it is saved */
 896
 897   cmd_ptr->state = LADISH_COMMAND_STATE_DONE;
 898
 899   ret = true;
 900
 901 close:
 902   close(fd);
 903
 904 rename_back:
 905   if (!ret && bak_filename != NULL)
 906   {
 907     /* save failed - try to rename the backup file back */
 908     if (rename(bak_filename, g_studio.filename) != 0)
 909     {
 910       log_error("rename(%s, %s) failed: %d (%s)", bak_filename, g_studio.filename, errno, strerror(errno));
 911     }
 912   }
 913
 914 free_filenames:
 915   if (bak_filename != NULL)
 916   {
 917     free(bak_filename);
 918   }
 919
 920   if (old_filename != NULL)
 921   {
 922     free(old_filename);
 923   }
 924
 925   ASSERT(filename == NULL);
 926   ASSERT(g_studio.filename != NULL);
 927
 928 exit:
 929   return ret;
 930 }
 931
 932 #undef cmd_ptr
 933
 934 bool ladish_command_save_studio(void * call_ptr, struct ladish_cqueue * queue_ptr)
 935 {
 936   struct ladish_command * cmd_ptr;
 937
 938   cmd_ptr = ladish_command_new(sizeof(struct ladish_command));
 939   if (cmd_ptr == NULL)
 940   {
 941     log_error("ladish_command_new() failed.");
 942     goto fail;
 943   }
 944
 945   cmd_ptr->run = run;
 946
 947   if (!ladish_cqueue_add_command(queue_ptr, cmd_ptr))
 948   {
 949     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "ladish_cqueue_add_command() failed.");
 950     goto fail_destroy_command;
 951   }
 952
 953   return true;
 954
 955 fail_destroy_command:
 956   free(cmd_ptr);
 957
 958 fail:
 959   return false;
 960 }