daemon/app_supervisor.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009, 2010 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of app supervisor 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 "config.h"  /* Get _GNU_SOURCE defenition first to have some GNU extension available */
  28
  29 #include <sys/types.h>
  30 #include <signal.h>
  31
  32 #include "app_supervisor.h"
  33 #include "../dbus/error.h"
  34 #include "../dbus_constants.h"
  35 #include "loader.h"
  36 #include "studio_internal.h"
  37 #include "../proxies/notify_proxy.h"
  38
  39 struct ladish_app
  40 {
  41   struct list_head siblings;
  42   uint64_t id;
  43   uuid_t uuid;
  44   char * name;
  45   char * commandline;
  46   bool terminal;
  47   uint8_t level;
  48   pid_t pid;
  49   pid_t firstborn_pid;
  50   bool zombie;                  /* if true, remove when stopped */
  51   bool autorun;
  52   unsigned int state;
  53 };
  54
  55 struct ladish_app_supervisor
  56 {
  57   char * name;
  58   char * opath;
  59   char * dir;
  60   uint64_t version;
  61   uint64_t next_id;
  62   struct list_head applist;
  63   void * on_app_renamed_context;
  64   ladish_app_supervisor_on_app_renamed_callback on_app_renamed;
  65 };
  66
  67 bool
  68 ladish_app_supervisor_create(
  69   ladish_app_supervisor_handle * supervisor_handle_ptr,
  70   const char * opath,
  71   const char * name,
  72   void * context,
  73   ladish_app_supervisor_on_app_renamed_callback on_app_renamed)
  74 {
  75   struct ladish_app_supervisor * supervisor_ptr;
  76
  77   supervisor_ptr = malloc(sizeof(struct ladish_app_supervisor));
  78   if (supervisor_ptr == NULL)
  79   {
  80     log_error("malloc() failed to allocate struct ladish_app_supervisor");
  81     return false;
  82   }
  83
  84   supervisor_ptr->opath = strdup(opath);
  85   if (supervisor_ptr->opath == NULL)
  86   {
  87     log_error("strdup() failed for app supervisor opath");
  88     free(supervisor_ptr);
  89     return false;
  90   }
  91
  92   supervisor_ptr->name = strdup(name);
  93   if (supervisor_ptr->name == NULL)
  94   {
  95     log_error("strdup() failed for app supervisor name");
  96     free(supervisor_ptr->opath);
  97     free(supervisor_ptr);
  98     return false;
  99   }
 100
 101   supervisor_ptr->dir = NULL;
 102
 103   supervisor_ptr->version = 0;
 104   supervisor_ptr->next_id = 1;
 105
 106   INIT_LIST_HEAD(&supervisor_ptr->applist);
 107
 108   supervisor_ptr->on_app_renamed_context = context;
 109   supervisor_ptr->on_app_renamed = on_app_renamed;
 110
 111   *supervisor_handle_ptr = (ladish_app_supervisor_handle)supervisor_ptr;
 112
 113   return true;
 114 }
 115
 116 struct ladish_app * ladish_app_supervisor_find_app_by_id_internal(struct ladish_app_supervisor * supervisor_ptr, uint64_t id)
 117 {
 118   struct list_head * node_ptr;
 119   struct ladish_app * app_ptr;
 120
 121   list_for_each(node_ptr, &supervisor_ptr->applist)
 122   {
 123     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 124     if (app_ptr->id == id)
 125     {
 126       return app_ptr;
 127     }
 128   }
 129
 130   return NULL;
 131 }
 132
 133 void remove_app_internal(struct ladish_app_supervisor * supervisor_ptr, struct ladish_app * app_ptr)
 134 {
 135   ASSERT(app_ptr->pid == 0);    /* Removing not-stoped app? Zombies will make a rebellion! */
 136
 137   list_del(&app_ptr->siblings);
 138
 139   supervisor_ptr->version++;
 140
 141   dbus_signal_emit(
 142     g_dbus_connection,
 143     supervisor_ptr->opath,
 144     IFACE_APP_SUPERVISOR,
 145     "AppRemoved",
 146     "tt",
 147     &supervisor_ptr->version,
 148     &app_ptr->id);
 149
 150   free(app_ptr->name);
 151   free(app_ptr->commandline);
 152   free(app_ptr);
 153 }
 154
 155 void emit_app_state_changed(struct ladish_app_supervisor * supervisor_ptr, struct ladish_app * app_ptr)
 156 {
 157   dbus_bool_t running;
 158   dbus_bool_t terminal;
 159
 160   running = app_ptr->pid != 0;
 161   terminal = app_ptr->terminal;
 162
 163   supervisor_ptr->version++;
 164
 165   dbus_signal_emit(
 166     g_dbus_connection,
 167     supervisor_ptr->opath,
 168     IFACE_APP_SUPERVISOR,
 169     "AppStateChanged",
 170     "ttsbby",
 171     &supervisor_ptr->version,
 172     &app_ptr->id,
 173     &app_ptr->name,
 174     &running,
 175     &terminal,
 176     &app_ptr->level);
 177 }
 178
 179 #define supervisor_ptr ((struct ladish_app_supervisor *)supervisor_handle)
 180
 181 const char * ladish_app_supervisor_get_opath(ladish_app_supervisor_handle supervisor_handle)
 182 {
 183   return supervisor_ptr->opath;
 184 }
 185
 186 ladish_app_handle ladish_app_supervisor_find_app_by_name(ladish_app_supervisor_handle supervisor_handle, const char * name)
 187 {
 188   struct list_head * node_ptr;
 189   struct ladish_app * app_ptr;
 190
 191   list_for_each(node_ptr, &supervisor_ptr->applist)
 192   {
 193     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 194     if (strcmp(app_ptr->name, name) == 0)
 195     {
 196       return (ladish_app_handle)app_ptr;
 197     }
 198   }
 199
 200   return NULL;
 201 }
 202
 203 ladish_app_handle ladish_app_supervisor_find_app_by_id(ladish_app_supervisor_handle supervisor_handle, uint64_t id)
 204 {
 205   return (ladish_app_handle)ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
 206 }
 207
 208 ladish_app_handle ladish_app_supervisor_find_app_by_pid(ladish_app_supervisor_handle supervisor_handle, pid_t pid)
 209 {
 210   struct list_head * node_ptr;
 211   struct ladish_app * app_ptr;
 212
 213   list_for_each(node_ptr, &supervisor_ptr->applist)
 214   {
 215     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 216     if (app_ptr->pid == pid)
 217     {
 218       //log_info("app \"%s\" found by pid %llu", app_ptr->name, (unsigned long long)pid);
 219       return (ladish_app_handle)app_ptr;
 220     }
 221   }
 222
 223   return NULL;
 224 }
 225
 226 ladish_app_handle
 227 ladish_app_supervisor_add(
 228   ladish_app_supervisor_handle supervisor_handle,
 229   const char * name,
 230   bool autorun,
 231   const char * command,
 232   bool terminal,
 233   uint8_t level)
 234 {
 235   struct ladish_app * app_ptr;
 236   dbus_bool_t running;
 237
 238   app_ptr = malloc(sizeof(struct ladish_app));
 239   if (app_ptr == NULL)
 240   {
 241     log_error("malloc of struct ladish_app failed");
 242     return NULL;
 243   }
 244
 245   app_ptr->name = strdup(name);
 246   if (app_ptr->name == NULL)
 247   {
 248     log_error("strdup() failed for app name");
 249     free(app_ptr);
 250     return NULL;
 251   }
 252
 253   app_ptr->commandline = strdup(command);
 254   if (app_ptr->commandline == NULL)
 255   {
 256     log_error("strdup() failed for app commandline");
 257     free(app_ptr->name);
 258     free(app_ptr);
 259     return NULL;
 260   }
 261
 262   app_ptr->terminal = terminal;
 263   app_ptr->level = level;
 264   app_ptr->pid = 0;
 265   app_ptr->firstborn_pid = 0;
 266
 267   app_ptr->id = supervisor_ptr->next_id++;
 268   uuid_generate(app_ptr->uuid);
 269   app_ptr->zombie = false;
 270   app_ptr->state = LADISH_APP_STATE_STOPPED;
 271   app_ptr->autorun = autorun;
 272   list_add_tail(&app_ptr->siblings, &supervisor_ptr->applist);
 273
 274   supervisor_ptr->version++;
 275
 276   running = false;
 277   dbus_signal_emit(
 278     g_dbus_connection,
 279     supervisor_ptr->opath,
 280     IFACE_APP_SUPERVISOR,
 281     "AppAdded",
 282     "ttsbby",
 283     &supervisor_ptr->version,
 284     &app_ptr->id,
 285     &app_ptr->name,
 286     &running,
 287     &terminal,
 288     &app_ptr->level);
 289
 290   return (ladish_app_handle)app_ptr;
 291 }
 292
 293 static void ladish_app_send_signal(struct ladish_app * app_ptr, int sig, bool prefer_firstborn)
 294 {
 295   pid_t pid;
 296   const char * signal_name;
 297
 298   ASSERT(app_ptr->state = LADISH_APP_STATE_STARTED);
 299   if (app_ptr->pid <= 0)
 300   {
 301     ASSERT_NO_PASS;
 302     return;
 303   }
 304
 305   if (prefer_firstborn && app_ptr->firstborn_pid != 0)
 306   {
 307     pid = app_ptr->firstborn_pid;
 308   }
 309   else
 310   {
 311     pid = app_ptr->pid;
 312   }
 313
 314   switch (sig)
 315   {
 316   case SIGTERM:
 317     signal_name = "SIGTERM";
 318     break;
 319   case SIGKILL:
 320     signal_name = "SIGKILL";
 321     break;
 322   case SIGUSR1:
 323     signal_name = "SIGUSR1";
 324     break;
 325   default:
 326     signal_name = strsignal(sig);
 327     if (signal_name == NULL)
 328     {
 329       signal_name = "unknown";
 330     }
 331   }
 332
 333   log_info("sending signal %d (%s) to '%s' with pid %u", sig, signal_name, app_ptr->name, (unsigned int)pid);
 334
 335   kill(pid, sig);
 336 }
 337
 338 bool ladish_app_supervisor_clear(ladish_app_supervisor_handle supervisor_handle)
 339 {
 340   struct list_head * node_ptr;
 341   struct list_head * safe_node_ptr;
 342   struct ladish_app * app_ptr;
 343   bool lifeless;
 344
 345   if (supervisor_ptr->dir != NULL)
 346   {
 347     free(supervisor_ptr->dir);
 348     supervisor_ptr->dir = NULL;
 349   }
 350
 351   lifeless = true;
 352
 353   list_for_each_safe(node_ptr, safe_node_ptr, &supervisor_ptr->applist)
 354   {
 355     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 356     if (app_ptr->pid != 0)
 357     {
 358       log_info("terminating '%s'...", app_ptr->name);
 359       ladish_app_send_signal(app_ptr, SIGTERM, false);
 360       app_ptr->zombie = true;
 361       app_ptr->state = LADISH_APP_STATE_STOPPING;
 362       lifeless = false;
 363     }
 364     else
 365     {
 366       log_info("removing '%s'", app_ptr->name);
 367       remove_app_internal(supervisor_ptr, app_ptr);
 368     }
 369   }
 370
 371   return lifeless;
 372 }
 373
 374 void ladish_app_supervisor_destroy(ladish_app_supervisor_handle supervisor_handle)
 375 {
 376   ladish_app_supervisor_clear(supervisor_handle);
 377   free(supervisor_ptr->name);
 378   free(supervisor_ptr->opath);
 379   free(supervisor_ptr);
 380 }
 381
 382 bool
 383 ladish_app_supervisor_set_directory(
 384   ladish_app_supervisor_handle supervisor_handle,
 385   const char * dir)
 386 {
 387   char * dup;
 388
 389   dup = strdup(dir);
 390   if (dup == NULL)
 391   {
 392     log_error("strdup(\"%s\") failed", dir);
 393     return false;
 394   }
 395
 396   if (supervisor_ptr->dir != NULL)
 397   {
 398     free(supervisor_ptr->dir);
 399   }
 400
 401   supervisor_ptr->dir = dup;
 402
 403   return true;
 404 }
 405
 406 bool ladish_app_supervisor_child_exit(ladish_app_supervisor_handle supervisor_handle, pid_t pid)
 407 {
 408   struct list_head * node_ptr;
 409   struct ladish_app * app_ptr;
 410
 411   list_for_each(node_ptr, &supervisor_ptr->applist)
 412   {
 413     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 414     if (app_ptr->pid == pid)
 415     {
 416       log_info("exit of child '%s' detected.", app_ptr->name);
 417
 418       app_ptr->pid = 0;
 419       app_ptr->firstborn_pid = 0;
 420       if (app_ptr->zombie)
 421       {
 422         remove_app_internal(supervisor_ptr, app_ptr);
 423       }
 424       else
 425       {
 426         if (app_ptr->state == LADISH_APP_STATE_STARTED)
 427         {
 428           ladish_notify_simple(LADISH_NOTIFY_URGENCY_HIGH, "App terminated unexpectedly", app_ptr->name);
 429         }
 430
 431         app_ptr->state = LADISH_APP_STATE_STOPPED;
 432
 433         emit_app_state_changed(supervisor_ptr, app_ptr);
 434       }
 435
 436       return true;
 437     }
 438   }
 439
 440   return false;
 441 }
 442
 443 bool
 444 ladish_app_supervisor_enum(
 445   ladish_app_supervisor_handle supervisor_handle,
 446   void * context,
 447   ladish_app_supervisor_enum_callback callback)
 448 {
 449   struct list_head * node_ptr;
 450   struct ladish_app * app_ptr;
 451
 452   list_for_each(node_ptr, &supervisor_ptr->applist)
 453   {
 454     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 455
 456     if (!callback(context, app_ptr->name, app_ptr->pid != 0, app_ptr->commandline, app_ptr->terminal, app_ptr->level, app_ptr->pid, app_ptr->uuid))
 457     {
 458       return false;
 459     }
 460   }
 461
 462   return true;
 463 }
 464
 465 static inline void ladish_app_save_L1_internal(struct ladish_app * app_ptr)
 466 {
 467   if (app_ptr->level == 1)
 468   {
 469     ladish_app_send_signal(app_ptr, SIGUSR1, true);
 470   }
 471 }
 472
 473 #define app_ptr ((struct ladish_app *)app_handle)
 474
 475 bool ladish_app_supervisor_start_app(ladish_app_supervisor_handle supervisor_handle, ladish_app_handle app_handle)
 476 {
 477   app_ptr->zombie = false;
 478
 479   ASSERT(app_ptr->pid == 0);
 480
 481   if (!loader_execute(
 482         supervisor_ptr->name,
 483         app_ptr->name,
 484         supervisor_ptr->dir != NULL ? supervisor_ptr->dir : "/",
 485         app_ptr->terminal,
 486         app_ptr->commandline,
 487         &app_ptr->pid))
 488   {
 489     return false;
 490   }
 491
 492   ASSERT(app_ptr->pid != 0);
 493   app_ptr->state = LADISH_APP_STATE_STARTED;
 494
 495   emit_app_state_changed(supervisor_ptr, app_ptr);
 496   return true;
 497 }
 498
 499 void ladish_app_supervisor_remove_app(ladish_app_supervisor_handle supervisor_handle, ladish_app_handle app_handle)
 500 {
 501   remove_app_internal(supervisor_ptr, app_ptr);
 502 }
 503
 504 unsigned int ladish_app_get_state(ladish_app_handle app_handle)
 505 {
 506   return app_ptr->state;
 507 }
 508
 509 bool ladish_app_is_running(ladish_app_handle app_handle)
 510 {
 511   return app_ptr->pid != 0;
 512 }
 513
 514 const char * ladish_app_get_name(ladish_app_handle app_handle)
 515 {
 516   return app_ptr->name;
 517 }
 518
 519 void ladish_app_get_uuid(ladish_app_handle app_handle, uuid_t uuid)
 520 {
 521   uuid_copy(uuid, app_ptr->uuid);
 522 }
 523
 524 void ladish_app_stop(ladish_app_handle app_handle)
 525 {
 526   ladish_app_send_signal(app_ptr, SIGTERM, false);
 527   app_ptr->state = LADISH_APP_STATE_STOPPING;
 528 }
 529
 530 void ladish_app_kill(ladish_app_handle app_handle)
 531 {
 532   ladish_app_send_signal(app_ptr, SIGKILL, false);
 533   app_ptr->state = LADISH_APP_STATE_KILL;
 534 }
 535
 536 void ladish_app_save_L1(ladish_app_handle app_handle)
 537 {
 538   ladish_app_save_L1_internal(app_ptr);
 539 }
 540
 541 void ladish_app_add_pid(ladish_app_handle app_handle, pid_t pid)
 542 {
 543   if (app_ptr->pid == 0)
 544   {
 545     log_error("Associating pid with stopped app does not make sense");
 546     ASSERT_NO_PASS;
 547     return;
 548   }
 549
 550   if (pid <= 1)                 /* catch -1, 0 and 1 */
 551   {
 552     log_error("Refusing domination by ignoring pid %d", (int)pid);
 553     ASSERT_NO_PASS;
 554     return;
 555   }
 556
 557   if (app_ptr->pid == pid)
 558   { /* The top level process that is already known */
 559     return;
 560   }
 561
 562   if (app_ptr->firstborn_pid != 0)
 563   { /* Ignore non-first children */
 564     return;
 565   }
 566
 567   log_info("First grandchild with pid %u", (unsigned int)pid);
 568   app_ptr->firstborn_pid = pid;
 569 }
 570
 571 #undef app_ptr
 572
 573 void ladish_app_supervisor_autorun(ladish_app_supervisor_handle supervisor_handle)
 574 {
 575   struct list_head * node_ptr;
 576   struct ladish_app * app_ptr;
 577
 578   list_for_each(node_ptr, &supervisor_ptr->applist)
 579   {
 580     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 581
 582     if (!app_ptr->autorun)
 583     {
 584       continue;
 585     }
 586
 587     app_ptr->autorun = false;
 588
 589     log_info("autorun('%s', %s, '%s') called", app_ptr->name, app_ptr->terminal ? "terminal" : "shell", app_ptr->commandline);
 590
 591     if (!ladish_app_supervisor_start_app((ladish_app_supervisor_handle)supervisor_ptr, (ladish_app_handle)app_ptr))
 592     {
 593       log_error("Execution of '%s' failed",  app_ptr->commandline);
 594       return;
 595     }
 596   }
 597 }
 598
 599 void ladish_app_supervisor_stop(ladish_app_supervisor_handle supervisor_handle)
 600 {
 601   struct list_head * node_ptr;
 602   struct ladish_app * app_ptr;
 603
 604   list_for_each(node_ptr, &supervisor_ptr->applist)
 605   {
 606     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 607     if (app_ptr->pid != 0)
 608     {
 609       log_info("terminating '%s'...", app_ptr->name);
 610       ladish_app_send_signal(app_ptr, SIGTERM, false);
 611       app_ptr->autorun = true;
 612       app_ptr->state = LADISH_APP_STATE_STOPPING;
 613     }
 614   }
 615 }
 616
 617 void ladish_app_supervisor_save_L1(ladish_app_supervisor_handle supervisor_handle)
 618 {
 619   struct list_head * node_ptr;
 620   struct ladish_app * app_ptr;
 621
 622   list_for_each(node_ptr, &supervisor_ptr->applist)
 623   {
 624     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 625     if (app_ptr->state != LADISH_APP_STATE_STARTED)
 626     {
 627       continue;
 628     }
 629
 630     if (app_ptr->pid == 0)
 631     {
 632       ASSERT_NO_PASS;
 633       continue;
 634     }
 635
 636     ladish_app_save_L1_internal(app_ptr);
 637   }
 638 }
 639
 640 const char * ladish_app_supervisor_get_name(ladish_app_supervisor_handle supervisor_handle)
 641 {
 642   return supervisor_ptr->name;
 643 }
 644
 645 unsigned int ladish_app_supervisor_get_running_app_count(ladish_app_supervisor_handle supervisor_handle)
 646 {
 647   struct list_head * node_ptr;
 648   struct ladish_app * app_ptr;
 649   unsigned int counter;
 650
 651   counter = 0;
 652   list_for_each(node_ptr, &supervisor_ptr->applist)
 653   {
 654     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 655     if (app_ptr->pid != 0)
 656     {
 657       counter++;
 658     }
 659   }
 660
 661   return counter;
 662 }
 663
 664 bool ladish_app_supervisor_has_apps(ladish_app_supervisor_handle supervisor_handle)
 665 {
 666   return !list_empty(&supervisor_ptr->applist);
 667 }
 668
 669 #undef supervisor_ptr
 670
 671 /**********************************************************************************/
 672 /*                                D-Bus methods                                   */
 673 /**********************************************************************************/
 674
 675 #define supervisor_ptr ((struct ladish_app_supervisor *)call_ptr->iface_context)
 676
 677 static void get_all(struct dbus_method_call * call_ptr)
 678 {
 679   DBusMessageIter iter, array_iter, struct_iter;
 680   struct list_head * node_ptr;
 681   struct ladish_app * app_ptr;
 682   dbus_bool_t running;
 683   dbus_bool_t terminal;
 684
 685   //log_info("get_all called");
 686
 687   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 688   if (call_ptr->reply == NULL)
 689   {
 690     goto fail;
 691   }
 692
 693   dbus_message_iter_init_append(call_ptr->reply, &iter);
 694
 695   if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT64, &supervisor_ptr->version))
 696   {
 697     goto fail_unref;
 698   }
 699
 700   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(tsbby)", &array_iter))
 701   {
 702     goto fail_unref;
 703   }
 704
 705   list_for_each(node_ptr, &supervisor_ptr->applist)
 706   {
 707     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 708
 709     log_info("app '%s' (%llu)", app_ptr->name, (unsigned long long)app_ptr->id);
 710
 711     if (!dbus_message_iter_open_container (&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter))
 712     {
 713       goto fail_unref;
 714     }
 715
 716     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_UINT64, &app_ptr->id))
 717     {
 718       goto fail_unref;
 719     }
 720
 721     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &app_ptr->name))
 722     {
 723       goto fail_unref;
 724     }
 725
 726     running = app_ptr->pid != 0;
 727     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_BOOLEAN, &running))
 728     {
 729       goto fail_unref;
 730     }
 731
 732     terminal = app_ptr->terminal;
 733     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_BOOLEAN, &terminal))
 734     {
 735       goto fail_unref;
 736     }
 737
 738     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_BYTE, &app_ptr->level))
 739     {
 740       goto fail_unref;
 741     }
 742
 743     if (!dbus_message_iter_close_container(&array_iter, &struct_iter))
 744     {
 745       goto fail_unref;
 746     }
 747   }
 748
 749   if (!dbus_message_iter_close_container(&iter, &array_iter))
 750   {
 751     goto fail_unref;
 752   }
 753
 754   return;
 755
 756 fail_unref:
 757   dbus_message_unref(call_ptr->reply);
 758   call_ptr->reply = NULL;
 759
 760 fail:
 761   log_error("Ran out of memory trying to construct method return");
 762 }
 763
 764 static void run_custom(struct dbus_method_call * call_ptr)
 765 {
 766   dbus_bool_t terminal;
 767   const char * commandline;
 768   const char * name;
 769   uint8_t level;
 770
 771   if (!dbus_message_get_args(
 772         call_ptr->message,
 773         &g_dbus_error,
 774         DBUS_TYPE_BOOLEAN, &terminal,
 775         DBUS_TYPE_STRING, &commandline,
 776         DBUS_TYPE_STRING, &name,
 777         DBUS_TYPE_BYTE, &level,
 778         DBUS_TYPE_INVALID))
 779   {
 780     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 781     dbus_error_free(&g_dbus_error);
 782     return;
 783   }
 784
 785   log_info("run_custom('%s', %s, '%s', %"PRIu8") called", name, terminal ? "terminal" : "shell", commandline, level);
 786
 787   if (level != 0 && level != 1)
 788   {
 789     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "invalid level %"PRIu8, level);
 790     return;
 791   }
 792
 793   if (ladish_command_new_app(
 794         call_ptr,
 795         ladish_studio_get_cmd_queue(),
 796         supervisor_ptr->opath,
 797         terminal,
 798         commandline,
 799         name,
 800         level))
 801   {
 802     method_return_new_void(call_ptr);
 803   }
 804 }
 805
 806 static void start_app(struct dbus_method_call * call_ptr)
 807 {
 808   uint64_t id;
 809
 810   if (!dbus_message_get_args(
 811         call_ptr->message,
 812         &g_dbus_error,
 813         DBUS_TYPE_UINT64, &id,
 814         DBUS_TYPE_INVALID))
 815   {
 816     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 817     dbus_error_free(&g_dbus_error);
 818     return;
 819   }
 820
 821   if (ladish_command_change_app_state(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id, LADISH_APP_STATE_STARTED))
 822   {
 823     method_return_new_void(call_ptr);
 824   }
 825 }
 826
 827 static void stop_app(struct dbus_method_call * call_ptr)
 828 {
 829   uint64_t id;
 830
 831   if (!dbus_message_get_args(
 832         call_ptr->message,
 833         &g_dbus_error,
 834         DBUS_TYPE_UINT64, &id,
 835         DBUS_TYPE_INVALID))
 836   {
 837     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 838     dbus_error_free(&g_dbus_error);
 839     return;
 840   }
 841
 842   if (ladish_command_change_app_state(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id, LADISH_APP_STATE_STOPPED))
 843   {
 844     method_return_new_void(call_ptr);
 845   }
 846 }
 847
 848 static void kill_app(struct dbus_method_call * call_ptr)
 849 {
 850   uint64_t id;
 851
 852   if (!dbus_message_get_args(
 853         call_ptr->message,
 854         &g_dbus_error,
 855         DBUS_TYPE_UINT64, &id,
 856         DBUS_TYPE_INVALID))
 857   {
 858     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 859     dbus_error_free(&g_dbus_error);
 860     return;
 861   }
 862
 863   if (ladish_command_change_app_state(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id, LADISH_APP_STATE_KILL))
 864   {
 865     method_return_new_void(call_ptr);
 866   }
 867 }
 868
 869 static void get_app_properties(struct dbus_method_call * call_ptr)
 870 {
 871   uint64_t id;
 872   struct ladish_app * app_ptr;
 873   dbus_bool_t running;
 874   dbus_bool_t terminal;
 875
 876   if (!dbus_message_get_args(
 877         call_ptr->message,
 878         &g_dbus_error,
 879         DBUS_TYPE_UINT64, &id,
 880         DBUS_TYPE_INVALID))
 881   {
 882     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 883     dbus_error_free(&g_dbus_error);
 884     return;
 885   }
 886
 887   app_ptr = ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
 888   if (app_ptr == NULL)
 889   {
 890     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "App with ID %"PRIu64" not found", id);
 891     return;
 892   }
 893
 894   running = app_ptr->pid != 0;
 895   terminal = app_ptr->terminal;
 896
 897   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
 898   if (call_ptr->reply == NULL)
 899   {
 900     goto fail;
 901   }
 902
 903   if (!dbus_message_append_args(
 904         call_ptr->reply,
 905         DBUS_TYPE_STRING, &app_ptr->name,
 906         DBUS_TYPE_STRING, &app_ptr->commandline,
 907         DBUS_TYPE_BOOLEAN, &running,
 908         DBUS_TYPE_BOOLEAN, &terminal,
 909         DBUS_TYPE_BYTE, &app_ptr->level,
 910         DBUS_TYPE_INVALID))
 911   {
 912     goto fail_unref;
 913   }
 914
 915   return;
 916
 917 fail_unref:
 918   dbus_message_unref(call_ptr->reply);
 919   call_ptr->reply = NULL;
 920
 921 fail:
 922   log_error("Ran out of memory trying to construct method return");
 923 }
 924
 925 static void set_app_properties(struct dbus_method_call * call_ptr)
 926 {
 927   uint64_t id;
 928   dbus_bool_t terminal;
 929   const char * name;
 930   const char * commandline;
 931   uint8_t level;
 932   struct ladish_app * app_ptr;
 933   char * name_buffer;
 934   char * commandline_buffer;
 935
 936   if (!dbus_message_get_args(
 937         call_ptr->message,
 938         &g_dbus_error,
 939         DBUS_TYPE_UINT64, &id,
 940         DBUS_TYPE_STRING, &name,
 941         DBUS_TYPE_STRING, &commandline,
 942         DBUS_TYPE_BOOLEAN, &terminal,
 943         DBUS_TYPE_BYTE, &level,
 944         DBUS_TYPE_INVALID))
 945   {
 946     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
 947     dbus_error_free(&g_dbus_error);
 948     return;
 949   }
 950
 951   app_ptr = ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
 952   if (app_ptr == NULL)
 953   {
 954     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "App with ID %"PRIu64" not found", id);
 955     return;
 956   }
 957
 958   if (app_ptr->pid != 0 && strcmp(commandline, app_ptr->commandline) != 0)
 959   {
 960     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "Cannot change commandline when app is running. '%s' -> '%s'", app_ptr->commandline, commandline);
 961     return;
 962   }
 963
 964   if (app_ptr->pid != 0 && ((app_ptr->terminal && !terminal) || (!app_ptr->terminal && terminal)))
 965   {
 966     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "Cannot change whether to run in terminal when app is running");
 967     return;
 968   }
 969
 970   if (app_ptr->pid != 0 && app_ptr->level != level)
 971   {
 972     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "Cannot change app level when app is running");
 973     return;
 974   }
 975
 976   if (strcmp(commandline, app_ptr->commandline) != 0)
 977   {
 978     commandline_buffer = strdup(commandline);
 979     if (commandline_buffer == NULL)
 980     {
 981       lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "strdup() failed for app commandline");
 982       return;
 983     }
 984   }
 985   else
 986   {
 987     commandline_buffer = NULL;
 988   }
 989
 990   if (strcmp(name, app_ptr->name) != 0)
 991   {
 992     name_buffer = strdup(name);
 993     if (name_buffer == NULL)
 994     {
 995       lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "strdup() failed for app nam");
 996       if (commandline_buffer != NULL)
 997       {
 998         free(commandline_buffer);
 999       }
1000       return;
1001     }
1002   }
1003   else
1004   {
1005     name_buffer = NULL;
1006   }
1007
1008   if (name_buffer != NULL)
1009   {
1010     supervisor_ptr->on_app_renamed(supervisor_ptr->on_app_renamed_context, app_ptr->uuid, app_ptr->name, name_buffer);
1011     free(app_ptr->name);
1012     app_ptr->name = name_buffer;
1013   }
1014
1015   if (commandline_buffer != NULL)
1016   {
1017     free(app_ptr->commandline);
1018     app_ptr->commandline = commandline_buffer;
1019   }
1020
1021   app_ptr->level = level;
1022   app_ptr->terminal = terminal;
1023
1024   emit_app_state_changed(supervisor_ptr, app_ptr);
1025
1026   method_return_new_void(call_ptr);
1027 }
1028
1029 static void remove_app(struct dbus_method_call * call_ptr)
1030 {
1031   uint64_t id;
1032
1033   if (!dbus_message_get_args(
1034         call_ptr->message,
1035         &g_dbus_error,
1036         DBUS_TYPE_UINT64, &id,
1037         DBUS_TYPE_INVALID))
1038   {
1039     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1040     dbus_error_free(&g_dbus_error);
1041     return;
1042   }
1043
1044   if (ladish_command_remove_app(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id))
1045   {
1046     method_return_new_void(call_ptr);
1047   }
1048 }
1049
1050 static void is_app_running(struct dbus_method_call * call_ptr)
1051 {
1052   uint64_t id;
1053   struct ladish_app * app_ptr;
1054   dbus_bool_t running;
1055
1056   if (!dbus_message_get_args(
1057         call_ptr->message,
1058         &g_dbus_error,
1059         DBUS_TYPE_UINT64, &id,
1060         DBUS_TYPE_INVALID))
1061   {
1062     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
1063     dbus_error_free(&g_dbus_error);
1064     return;
1065   }
1066
1067   app_ptr = ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
1068   if (app_ptr == NULL)
1069   {
1070     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "App with ID %"PRIu64" not found", id);
1071     return;
1072   }
1073
1074   running = app_ptr->pid != 0;
1075
1076   method_return_new_single(call_ptr, DBUS_TYPE_BOOLEAN, &running);
1077 }
1078
1079 #undef supervisor_ptr
1080
1081 METHOD_ARGS_BEGIN(GetAll, "Get list of apps")
1082   METHOD_ARG_DESCRIBE_OUT("list_version", DBUS_TYPE_UINT64_AS_STRING, "Version of the list")
1083   METHOD_ARG_DESCRIBE_OUT("apps_list", "a(tsbby)", "List of apps")
1084 METHOD_ARGS_END
1085
1086 METHOD_ARGS_BEGIN(RunCustom, "Start application by supplying commandline")
1087   METHOD_ARG_DESCRIBE_IN("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1088   METHOD_ARG_DESCRIBE_IN("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1089   METHOD_ARG_DESCRIBE_IN("name", DBUS_TYPE_STRING_AS_STRING, "Name")
1090   METHOD_ARG_DESCRIBE_IN("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1091 METHOD_ARGS_END
1092
1093 METHOD_ARGS_BEGIN(StartApp, "Start application")
1094   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1095 METHOD_ARGS_END
1096
1097 METHOD_ARGS_BEGIN(StopApp, "Stop application")
1098   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1099 METHOD_ARGS_END
1100
1101 METHOD_ARGS_BEGIN(KillApp, "Kill application")
1102   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1103 METHOD_ARGS_END
1104
1105 METHOD_ARGS_BEGIN(RemoveApp, "Remove application")
1106   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1107 METHOD_ARGS_END
1108
1109 METHOD_ARGS_BEGIN(GetAppProperties, "Get properties of an application")
1110   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1111   METHOD_ARG_DESCRIBE_OUT("name", DBUS_TYPE_STRING_AS_STRING, "")
1112   METHOD_ARG_DESCRIBE_OUT("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1113   METHOD_ARG_DESCRIBE_OUT("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1114   METHOD_ARG_DESCRIBE_OUT("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1115   METHOD_ARG_DESCRIBE_OUT("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1116 METHOD_ARGS_END
1117
1118 METHOD_ARGS_BEGIN(SetAppProperties, "Set properties of an application")
1119   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1120   METHOD_ARG_DESCRIBE_IN("name", DBUS_TYPE_STRING_AS_STRING, "")
1121   METHOD_ARG_DESCRIBE_IN("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1122   METHOD_ARG_DESCRIBE_IN("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1123   METHOD_ARG_DESCRIBE_IN("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1124 METHOD_ARGS_END
1125
1126 METHOD_ARGS_BEGIN(IsAppRunning, "Check whether application is running")
1127   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1128   METHOD_ARG_DESCRIBE_OUT("running", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether app is running")
1129 METHOD_ARGS_END
1130
1131
1132 METHODS_BEGIN
1133   METHOD_DESCRIBE(GetAll, get_all)                      /* sync */
1134   METHOD_DESCRIBE(RunCustom, run_custom)                /* async */
1135   METHOD_DESCRIBE(StartApp, start_app)                  /* async */
1136   METHOD_DESCRIBE(StopApp, stop_app)                    /* async */
1137   METHOD_DESCRIBE(KillApp, kill_app)                    /* async */
1138   METHOD_DESCRIBE(GetAppProperties, get_app_properties) /* sync */
1139   METHOD_DESCRIBE(SetAppProperties, set_app_properties) /* sync */
1140   METHOD_DESCRIBE(RemoveApp, remove_app)                /* sync */
1141   METHOD_DESCRIBE(IsAppRunning, is_app_running)         /* sync */
1142 METHODS_END
1143
1144 SIGNAL_ARGS_BEGIN(AppAdded, "")
1145   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1146   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1147   SIGNAL_ARG_DESCRIBE("name", DBUS_TYPE_STRING_AS_STRING, "")
1148   SIGNAL_ARG_DESCRIBE("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1149   SIGNAL_ARG_DESCRIBE("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1150   SIGNAL_ARG_DESCRIBE("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1151 SIGNAL_ARGS_END
1152
1153 SIGNAL_ARGS_BEGIN(AppRemoved, "")
1154   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1155   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1156 SIGNAL_ARGS_END
1157
1158 SIGNAL_ARGS_BEGIN(AppStateChanged, "")
1159   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1160   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1161   SIGNAL_ARG_DESCRIBE("name", DBUS_TYPE_STRING_AS_STRING, "")
1162   SIGNAL_ARG_DESCRIBE("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1163   SIGNAL_ARG_DESCRIBE("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1164   SIGNAL_ARG_DESCRIBE("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1165 SIGNAL_ARGS_END
1166
1167 SIGNALS_BEGIN
1168   SIGNAL_DESCRIBE(AppAdded)
1169   SIGNAL_DESCRIBE(AppRemoved)
1170   SIGNAL_DESCRIBE(AppStateChanged)
1171 SIGNALS_END
1172
1173 INTERFACE_BEGIN(g_iface_app_supervisor, IFACE_APP_SUPERVISOR)
1174   INTERFACE_DEFAULT_HANDLER
1175   INTERFACE_EXPOSE_METHODS
1176   INTERFACE_EXPOSE_SIGNALS
1177 INTERFACE_END