daemon/app_supervisor.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009, 2010, 2011 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 <sys/stat.h>
  31 #include <signal.h>
  32 #include <unistd.h>
  33
  34 #include "app_supervisor.h"
  35 #include "../dbus/error.h"
  36 #include "../dbus_constants.h"
  37 #include "loader.h"
  38 #include "studio_internal.h"
  39 #include "../proxies/notify_proxy.h"
  40 #include "../proxies/lash_client_proxy.h"
  41 #include "../common/catdup.h"
  42 #include "../common/dirhelpers.h"
  43
  44 struct ladish_app
  45 {
  46   struct list_head siblings;
  47   uint64_t id;
  48   uuid_t uuid;
  49   char * name;
  50   char * commandline;
  51   bool terminal;
  52   char level[MAX_LEVEL_CHARCOUNT];
  53   pid_t pid;
  54   pid_t pgrp;
  55   pid_t firstborn_pid;
  56   pid_t firstborn_pgrp;
  57   int firstborn_refcount;
  58   bool zombie;                  /* if true, remove when stopped */
  59   bool autorun;
  60   unsigned int state;
  61   char * dbus_name;
  62   struct ladish_app_supervisor * supervisor;
  63 };
  64
  65 struct ladish_app_supervisor
  66 {
  67   char * name;
  68   char * opath;
  69   char * dir;
  70   char * project_name;
  71   uint64_t version;
  72   uint64_t next_id;
  73   struct list_head applist;
  74   void * on_app_renamed_context;
  75   ladish_app_supervisor_on_app_renamed_callback on_app_renamed;
  76 };
  77
  78 bool ladish_check_app_level_validity(const char * level, size_t * len_ptr)
  79 {
  80   size_t len;
  81   len = strlen(level);
  82   if (len >= MAX_LEVEL_CHARCOUNT)
  83   {
  84     return false;
  85   }
  86
  87   if (strcmp(level, LADISH_APP_LEVEL_0) != 0 &&
  88       strcmp(level, LADISH_APP_LEVEL_1) != 0&&
  89       strcmp(level, LADISH_APP_LEVEL_LASH) != 0)
  90   {
  91     return false;
  92   }
  93
  94   if (len_ptr != NULL)
  95   {
  96     *len_ptr = len;
  97   }
  98
  99   return true;
 100 }
 101
 102 static int ladish_level_string_to_integer(const char * level)
 103 {
 104   if (strcmp(level, LADISH_APP_LEVEL_0) == 0)
 105   {
 106     return 0;
 107   }
 108   else if (strcmp(level, LADISH_APP_LEVEL_1) == 0)
 109   {
 110     return 1;
 111   }
 112   else if (strcmp(level, LADISH_APP_LEVEL_LASH) == 0 ||
 113            strcmp(level, LADISH_APP_LEVEL_JACKSESSION) == 0)
 114   {
 115     return 2;
 116   }
 117
 118   ASSERT_NO_PASS;
 119   return 255;
 120 }
 121
 122 bool
 123 ladish_app_supervisor_create(
 124   ladish_app_supervisor_handle * supervisor_handle_ptr,
 125   const char * opath,
 126   const char * name,
 127   void * context,
 128   ladish_app_supervisor_on_app_renamed_callback on_app_renamed)
 129 {
 130   struct ladish_app_supervisor * supervisor_ptr;
 131
 132   supervisor_ptr = malloc(sizeof(struct ladish_app_supervisor));
 133   if (supervisor_ptr == NULL)
 134   {
 135     log_error("malloc() failed to allocate struct ladish_app_supervisor");
 136     return false;
 137   }
 138
 139   supervisor_ptr->opath = strdup(opath);
 140   if (supervisor_ptr->opath == NULL)
 141   {
 142     log_error("strdup() failed for app supervisor opath");
 143     free(supervisor_ptr);
 144     return false;
 145   }
 146
 147   supervisor_ptr->name = strdup(name);
 148   if (supervisor_ptr->name == NULL)
 149   {
 150     log_error("strdup() failed for app supervisor name");
 151     free(supervisor_ptr->opath);
 152     free(supervisor_ptr);
 153     return false;
 154   }
 155
 156   supervisor_ptr->dir = NULL;
 157   supervisor_ptr->project_name = NULL;
 158
 159   supervisor_ptr->version = 0;
 160   supervisor_ptr->next_id = 1;
 161
 162   INIT_LIST_HEAD(&supervisor_ptr->applist);
 163
 164   supervisor_ptr->on_app_renamed_context = context;
 165   supervisor_ptr->on_app_renamed = on_app_renamed;
 166
 167   *supervisor_handle_ptr = (ladish_app_supervisor_handle)supervisor_ptr;
 168
 169   return true;
 170 }
 171
 172 struct ladish_app * ladish_app_supervisor_find_app_by_id_internal(struct ladish_app_supervisor * supervisor_ptr, uint64_t id)
 173 {
 174   struct list_head * node_ptr;
 175   struct ladish_app * app_ptr;
 176
 177   list_for_each(node_ptr, &supervisor_ptr->applist)
 178   {
 179     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 180     if (app_ptr->id == id)
 181     {
 182       return app_ptr;
 183     }
 184   }
 185
 186   return NULL;
 187 }
 188
 189 void remove_app_internal(struct ladish_app_supervisor * supervisor_ptr, struct ladish_app * app_ptr)
 190 {
 191   ASSERT(app_ptr->pid == 0);    /* Removing not-stoped app? Zombies will make a rebellion! */
 192
 193   list_del(&app_ptr->siblings);
 194
 195   supervisor_ptr->version++;
 196
 197   dbus_signal_emit(
 198     cdbus_g_dbus_connection,
 199     supervisor_ptr->opath,
 200     IFACE_APP_SUPERVISOR,
 201     "AppRemoved",
 202     "tt",
 203     &supervisor_ptr->version,
 204     &app_ptr->id);
 205
 206   free(app_ptr->dbus_name);
 207   free(app_ptr->name);
 208   free(app_ptr->commandline);
 209   free(app_ptr);
 210 }
 211
 212 void emit_app_state_changed(struct ladish_app_supervisor * supervisor_ptr, struct ladish_app * app_ptr)
 213 {
 214   dbus_bool_t running;
 215   dbus_bool_t terminal;
 216   const char * level_str;
 217   uint8_t level_byte;
 218
 219   running = app_ptr->pid != 0;
 220   terminal = app_ptr->terminal;
 221   level_str = app_ptr->level;
 222   level_byte = ladish_level_string_to_integer(app_ptr->level);
 223
 224   supervisor_ptr->version++;
 225
 226   dbus_signal_emit(
 227     cdbus_g_dbus_connection,
 228     supervisor_ptr->opath,
 229     IFACE_APP_SUPERVISOR,
 230     "AppStateChanged",
 231     "ttsbby",
 232     &supervisor_ptr->version,
 233     &app_ptr->id,
 234     &app_ptr->name,
 235     &running,
 236     &terminal,
 237     &level_byte);
 238
 239   dbus_signal_emit(
 240     cdbus_g_dbus_connection,
 241     supervisor_ptr->opath,
 242     IFACE_APP_SUPERVISOR,
 243     "AppStateChanged2",
 244     "ttsbbs",
 245     &supervisor_ptr->version,
 246     &app_ptr->id,
 247     &app_ptr->name,
 248     &running,
 249     &terminal,
 250     &level_str);
 251 }
 252
 253 #define supervisor_ptr ((struct ladish_app_supervisor *)supervisor_handle)
 254
 255 const char * ladish_app_supervisor_get_opath(ladish_app_supervisor_handle supervisor_handle)
 256 {
 257   return supervisor_ptr->opath;
 258 }
 259
 260 ladish_app_handle ladish_app_supervisor_find_app_by_name(ladish_app_supervisor_handle supervisor_handle, const char * name)
 261 {
 262   struct list_head * node_ptr;
 263   struct ladish_app * app_ptr;
 264
 265   list_for_each(node_ptr, &supervisor_ptr->applist)
 266   {
 267     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 268     if (strcmp(app_ptr->name, name) == 0)
 269     {
 270       return (ladish_app_handle)app_ptr;
 271     }
 272   }
 273
 274   return NULL;
 275 }
 276
 277 ladish_app_handle ladish_app_supervisor_find_app_by_id(ladish_app_supervisor_handle supervisor_handle, uint64_t id)
 278 {
 279   return (ladish_app_handle)ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
 280 }
 281
 282 ladish_app_handle ladish_app_supervisor_find_app_by_pid(ladish_app_supervisor_handle supervisor_handle, pid_t pid)
 283 {
 284   struct list_head * node_ptr;
 285   struct ladish_app * app_ptr;
 286
 287   list_for_each(node_ptr, &supervisor_ptr->applist)
 288   {
 289     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 290     if (app_ptr->pid == pid)
 291     {
 292       //log_info("app \"%s\" found by pid %llu", app_ptr->name, (unsigned long long)pid);
 293       return (ladish_app_handle)app_ptr;
 294     }
 295   }
 296
 297   return NULL;
 298 }
 299
 300 ladish_app_handle ladish_app_supervisor_find_app_by_uuid(ladish_app_supervisor_handle supervisor_handle, const uuid_t uuid)
 301 {
 302   struct list_head * node_ptr;
 303   struct ladish_app * app_ptr;
 304
 305   list_for_each(node_ptr, &supervisor_ptr->applist)
 306   {
 307     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 308     if (uuid_compare(app_ptr->uuid, uuid) == 0)
 309     {
 310       return (ladish_app_handle)app_ptr;
 311     }
 312   }
 313
 314   return NULL;
 315 }
 316
 317 ladish_app_handle
 318 ladish_app_supervisor_add(
 319   ladish_app_supervisor_handle supervisor_handle,
 320   const char * name,
 321   uuid_t uuid,
 322   bool autorun,
 323   const char * command,
 324   bool terminal,
 325   const char * level)
 326 {
 327   struct ladish_app * app_ptr;
 328   dbus_bool_t running;
 329   dbus_bool_t dbus_terminal;
 330   size_t len;
 331   uint8_t level_byte;
 332
 333   if (!ladish_check_app_level_validity(level, &len))
 334   {
 335     log_error("invalid level '%s'", level);
 336     return NULL;
 337   }
 338
 339   app_ptr = malloc(sizeof(struct ladish_app));
 340   if (app_ptr == NULL)
 341   {
 342     log_error("malloc of struct ladish_app failed");
 343     return NULL;
 344   }
 345
 346   app_ptr->name = strdup(name);
 347   if (app_ptr->name == NULL)
 348   {
 349     log_error("strdup() failed for app name");
 350     free(app_ptr);
 351     return NULL;
 352   }
 353
 354   app_ptr->commandline = strdup(command);
 355   if (app_ptr->commandline == NULL)
 356   {
 357     log_error("strdup() failed for app commandline");
 358     free(app_ptr->name);
 359     free(app_ptr);
 360     return NULL;
 361   }
 362
 363   app_ptr->dbus_name = NULL;
 364
 365   app_ptr->terminal = terminal;
 366   memcpy(app_ptr->level, level, len + 1);
 367   app_ptr->pid = 0;
 368   app_ptr->pgrp = 0;
 369   app_ptr->firstborn_pid = 0;
 370   app_ptr->firstborn_pgrp = 0;
 371   app_ptr->firstborn_refcount = 0;
 372
 373   app_ptr->id = supervisor_ptr->next_id++;
 374   if (uuid == NULL || uuid_is_null(uuid))
 375   {
 376     uuid_generate(app_ptr->uuid);
 377   }
 378   else
 379   {
 380     uuid_copy(app_ptr->uuid, uuid);
 381   }
 382
 383   app_ptr->zombie = false;
 384   app_ptr->state = LADISH_APP_STATE_STOPPED;
 385   app_ptr->autorun = autorun;
 386   app_ptr->supervisor = supervisor_ptr;
 387   list_add_tail(&app_ptr->siblings, &supervisor_ptr->applist);
 388
 389   supervisor_ptr->version++;
 390
 391   running = false;
 392   dbus_terminal = terminal;
 393   level = app_ptr->level;
 394   level_byte = ladish_level_string_to_integer(app_ptr->level);
 395   dbus_signal_emit(
 396     cdbus_g_dbus_connection,
 397     supervisor_ptr->opath,
 398     IFACE_APP_SUPERVISOR,
 399     "AppAdded",
 400     "ttsbby",
 401     &supervisor_ptr->version,
 402     &app_ptr->id,
 403     &app_ptr->name,
 404     &running,
 405     &dbus_terminal,
 406     &level_byte);
 407   dbus_signal_emit(
 408     cdbus_g_dbus_connection,
 409     supervisor_ptr->opath,
 410     IFACE_APP_SUPERVISOR,
 411     "AppAdded2",
 412     "ttsbbs",
 413     &supervisor_ptr->version,
 414     &app_ptr->id,
 415     &app_ptr->name,
 416     &running,
 417     &dbus_terminal,
 418     &level);
 419
 420   return (ladish_app_handle)app_ptr;
 421 }
 422
 423 static void ladish_app_send_signal(struct ladish_app * app_ptr, int sig, bool prefer_firstborn)
 424 {
 425   pid_t pid;
 426   const char * signal_name;
 427
 428   ASSERT(app_ptr->state = LADISH_APP_STATE_STARTED);
 429
 430   switch (sig)
 431   {
 432   case SIGTERM:
 433     signal_name = "SIGTERM";
 434     break;
 435   case SIGKILL:
 436     signal_name = "SIGKILL";
 437     break;
 438   case SIGUSR1:
 439     signal_name = "SIGUSR1";
 440     break;
 441   default:
 442     signal_name = strsignal(sig);
 443     if (signal_name == NULL)
 444     {
 445       signal_name = "unknown";
 446     }
 447   }
 448
 449   if (app_ptr->pid == 0)
 450   {
 451     log_error("not sending signal %d (%s) to app '%s' because its pid is %d", sig, signal_name, app_ptr->name, (int)app_ptr->pid);
 452     ASSERT_NO_PASS;
 453     return;
 454   }
 455
 456   switch (sig)
 457   {
 458   case SIGKILL:
 459   case SIGTERM:
 460     if (app_ptr->pgrp == 0)
 461     {
 462       app_ptr->pgrp = getpgid(app_ptr->pid);
 463       if (app_ptr->pgrp == -1)
 464       {
 465         app_ptr->pgrp = 0;
 466         if (errno != ESRCH)
 467         {
 468           log_error("getpgid(%u) failed. %s (%d)", (unsigned int)app_ptr->pid, strerror(errno), errno);
 469         }
 470       }
 471     }
 472
 473     if (app_ptr->firstborn_pid != 0)
 474     {
 475       app_ptr->firstborn_pgrp = getpgid(app_ptr->firstborn_pid);
 476       if (app_ptr->firstborn_pgrp == -1)
 477       {
 478         app_ptr->firstborn_pgrp = 0;
 479         if (errno != ESRCH)
 480         {
 481           log_error("getpgid(%u) failed (firstborn). %s (%d)", (unsigned int)app_ptr->firstborn_pid, strerror(errno), errno);
 482         }
 483       }
 484     }
 485
 486     if (app_ptr->pgrp != 0)
 487     {
 488       log_info("sending signal %d (%s) to pgrp %u ('%s')", sig, signal_name, (unsigned int)app_ptr->pgrp, app_ptr->name);
 489
 490       if (app_ptr->pgrp <= 1)
 491       {
 492         ASSERT_NO_PASS;
 493         return;
 494       }
 495
 496       killpg(app_ptr->pgrp, sig);
 497
 498       if (app_ptr->firstborn_pid != 0)
 499       {
 500         if (app_ptr->firstborn_pgrp != 0)
 501         {
 502           if (app_ptr->firstborn_pgrp <= 1)
 503           {
 504             ASSERT_NO_PASS;
 505             return;
 506           }
 507
 508           if (app_ptr->firstborn_pgrp != app_ptr->pgrp)
 509           {
 510             log_info("sending signal %d (%s) to firstborn pgrp %u ('%s')", sig, signal_name, (unsigned int)app_ptr->firstborn_pgrp, app_ptr->name);
 511
 512             killpg(app_ptr->firstborn_pgrp, sig);
 513           }
 514           return;
 515         }
 516         /* fall through to sending signal to pid */
 517       }
 518       else
 519       {
 520         return;
 521       }
 522     }
 523     /* fall through to sending signal to pid */
 524   default:
 525     if (app_ptr->pid <= 1)
 526     {
 527       ASSERT_NO_PASS;
 528       return;
 529     }
 530
 531     if (prefer_firstborn && app_ptr->firstborn_pid != 0)
 532     {
 533       pid = app_ptr->firstborn_pid;
 534     }
 535     else
 536     {
 537       pid = app_ptr->pid;
 538     }
 539
 540     if (pid <= 1)
 541     {
 542       ASSERT_NO_PASS;
 543       return;
 544     }
 545
 546     log_info("sending signal %d (%s) to '%s' with pid %u", sig, signal_name, app_ptr->name, (unsigned int)pid);
 547     kill(pid, sig);
 548   }
 549 }
 550
 551 static inline void ladish_app_initiate_lash_save(struct ladish_app * app_ptr, const char * base_dir)
 552 {
 553   char * app_dir;
 554   char uuid_str[37];
 555
 556   if (base_dir == NULL)
 557   {
 558     log_error("Cannot initiate LASH save because base dir is unknown");
 559     ASSERT_NO_PASS;
 560     goto exit;
 561   }
 562
 563   uuid_unparse(app_ptr->uuid, uuid_str);
 564   app_dir = catdup3(base_dir, "/lash_apps/", uuid_str);
 565   if (app_dir == NULL)
 566   {
 567     log_error("Cannot initiate LASH save because of memory allocation failure.");
 568     goto exit;
 569   }
 570
 571   if (!ensure_dir_exist(app_dir, S_IRWXU | S_IRWXG | S_IRWXO))
 572   {
 573     goto free;
 574   }
 575
 576   if (lash_client_proxy_save(app_ptr->dbus_name, app_dir))
 577   {
 578     log_info("LASH Save into '%s' initiated for '%s' with D-Bus name '%s'", app_dir, app_ptr->name, app_ptr->dbus_name);
 579   }
 580
 581 free:
 582   free(app_dir);
 583 exit:
 584   return;
 585 }
 586
 587 static inline void ladish_app_initiate_lash_restore(struct ladish_app * app_ptr, const char * base_dir)
 588 {
 589   char * app_dir;
 590   char uuid_str[37];
 591   struct st;
 592
 593   if (base_dir == NULL)
 594   {
 595     log_error("Cannot initiate LASH restore because base dir is unknown");
 596     ASSERT_NO_PASS;
 597     goto exit;
 598   }
 599
 600   uuid_unparse(app_ptr->uuid, uuid_str);
 601   app_dir = catdup3(base_dir, "/lash_apps/", uuid_str);
 602   if (app_dir == NULL)
 603   {
 604     log_error("Cannot initiate LASH restore because of memory allocation failure.");
 605     goto exit;
 606   }
 607
 608   if (!check_dir_exists(app_dir))
 609   {
 610     log_info("Not initiating LASH restore because of app directory '%s' does not exist.", app_dir);
 611     goto free;
 612   }
 613
 614   if (lash_client_proxy_restore(app_ptr->dbus_name, app_dir))
 615   {
 616     log_info("LASH Save from '%s' initiated for '%s' with D-Bus name '%s'", app_dir, app_ptr->name, app_ptr->dbus_name);
 617   }
 618
 619 free:
 620   free(app_dir);
 621 exit:
 622   return;
 623 }
 624
 625 static inline void ladish_app_initiate_save(struct ladish_app * app_ptr)
 626 {
 627   if (strcmp(app_ptr->level, LADISH_APP_LEVEL_LASH) == 0 &&
 628       app_ptr->dbus_name != NULL)
 629   {
 630     ladish_app_initiate_lash_save(app_ptr, app_ptr->supervisor->dir != NULL ? app_ptr->supervisor->dir : g_base_dir);
 631   }
 632   else if (strcmp(app_ptr->level, LADISH_APP_LEVEL_1) == 0)
 633   {
 634     ladish_app_send_signal(app_ptr, SIGUSR1, true);
 635   }
 636 }
 637
 638 static inline void ladish_app_initiate_stop(struct ladish_app * app_ptr)
 639 {
 640   if (strcmp(app_ptr->level, LADISH_APP_LEVEL_LASH) == 0 &&
 641       app_ptr->dbus_name != NULL &&
 642       lash_client_proxy_quit(app_ptr->dbus_name))
 643   {
 644     log_info("LASH Quit initiated for '%s' with D-Bus name '%s'", app_ptr->name, app_ptr->dbus_name);
 645   }
 646   else
 647   {
 648     ladish_app_send_signal(app_ptr, SIGTERM, false);
 649   }
 650
 651   app_ptr->state = LADISH_APP_STATE_STOPPING;
 652 }
 653
 654 bool ladish_app_supervisor_clear(ladish_app_supervisor_handle supervisor_handle)
 655 {
 656   struct list_head * node_ptr;
 657   struct list_head * safe_node_ptr;
 658   struct ladish_app * app_ptr;
 659   bool lifeless;
 660
 661   free(supervisor_ptr->dir);
 662   supervisor_ptr->dir = NULL;
 663
 664   free(supervisor_ptr->project_name);
 665   supervisor_ptr->project_name = NULL;
 666
 667   lifeless = true;
 668
 669   list_for_each_safe(node_ptr, safe_node_ptr, &supervisor_ptr->applist)
 670   {
 671     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 672     if (app_ptr->pid != 0)
 673     {
 674       log_info("terminating '%s'...", app_ptr->name);
 675       ladish_app_initiate_stop(app_ptr);
 676       app_ptr->zombie = true;
 677       lifeless = false;
 678     }
 679     else
 680     {
 681       log_info("removing '%s'", app_ptr->name);
 682       remove_app_internal(supervisor_ptr, app_ptr);
 683     }
 684   }
 685
 686   return lifeless;
 687 }
 688
 689 void ladish_app_supervisor_destroy(ladish_app_supervisor_handle supervisor_handle)
 690 {
 691   ladish_app_supervisor_clear(supervisor_handle);
 692   free(supervisor_ptr->name);
 693   free(supervisor_ptr->opath);
 694   free(supervisor_ptr);
 695 }
 696
 697 bool
 698 ladish_app_supervisor_set_directory(
 699   ladish_app_supervisor_handle supervisor_handle,
 700   const char * dir)
 701 {
 702   char * dup;
 703
 704   dup = strdup(dir);
 705   if (dup == NULL)
 706   {
 707     log_error("strdup(\"%s\") failed", dir);
 708     return false;
 709   }
 710
 711   if (supervisor_ptr->dir != NULL)
 712   {
 713     free(supervisor_ptr->dir);
 714   }
 715
 716   supervisor_ptr->dir = dup;
 717
 718   return true;
 719 }
 720
 721 bool
 722 ladish_app_supervisor_set_project_name(
 723   ladish_app_supervisor_handle supervisor_handle,
 724   const char * project_name)
 725 {
 726   char * dup;
 727
 728   if (project_name != NULL)
 729   {
 730     dup = strdup(project_name);
 731     if (dup == NULL)
 732     {
 733       log_error("strdup(\"%s\") failed", project_name);
 734       return false;
 735     }
 736   }
 737   else
 738   {
 739     dup = NULL;
 740   }
 741
 742   free(supervisor_ptr->project_name);
 743   supervisor_ptr->project_name = dup;
 744
 745   return true;
 746 }
 747
 748 bool ladish_app_supervisor_child_exit(ladish_app_supervisor_handle supervisor_handle, pid_t pid)
 749 {
 750   struct list_head * node_ptr;
 751   struct ladish_app * app_ptr;
 752
 753   list_for_each(node_ptr, &supervisor_ptr->applist)
 754   {
 755     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 756     if (app_ptr->pid == pid)
 757     {
 758       log_info("exit of child '%s' detected.", app_ptr->name);
 759
 760       app_ptr->pid = 0;
 761       app_ptr->pgrp = 0;
 762       /* firstborn pid and pgrp is not reset here because it is refcounted
 763          and managed independently through the add/del_pid() methods */
 764
 765       if (app_ptr->zombie)
 766       {
 767         remove_app_internal(supervisor_ptr, app_ptr);
 768       }
 769       else
 770       {
 771         if (app_ptr->state == LADISH_APP_STATE_STARTED)
 772         {
 773           ladish_notify_simple(LADISH_NOTIFY_URGENCY_HIGH, "App terminated unexpectedly", app_ptr->name);
 774         }
 775
 776         app_ptr->state = LADISH_APP_STATE_STOPPED;
 777
 778         emit_app_state_changed(supervisor_ptr, app_ptr);
 779       }
 780
 781       return true;
 782     }
 783   }
 784
 785   return false;
 786 }
 787
 788 bool
 789 ladish_app_supervisor_enum(
 790   ladish_app_supervisor_handle supervisor_handle,
 791   void * context,
 792   ladish_app_supervisor_enum_callback callback)
 793 {
 794   struct list_head * node_ptr;
 795   struct ladish_app * app_ptr;
 796
 797   list_for_each(node_ptr, &supervisor_ptr->applist)
 798   {
 799     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 800
 801     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))
 802     {
 803       return false;
 804     }
 805   }
 806
 807   return true;
 808 }
 809
 810 #define app_ptr ((struct ladish_app *)app_handle)
 811
 812 bool ladish_app_supervisor_start_app(ladish_app_supervisor_handle supervisor_handle, ladish_app_handle app_handle)
 813 {
 814   app_ptr->zombie = false;
 815
 816   ASSERT(app_ptr->pid == 0);
 817
 818   if (!loader_execute(
 819         supervisor_ptr->name,
 820         supervisor_ptr->project_name,
 821         app_ptr->name,
 822         supervisor_ptr->dir != NULL ? supervisor_ptr->dir : "/",
 823         app_ptr->terminal,
 824         app_ptr->commandline,
 825         &app_ptr->pid))
 826   {
 827     return false;
 828   }
 829
 830   ASSERT(app_ptr->pid != 0);
 831   app_ptr->state = LADISH_APP_STATE_STARTED;
 832
 833   emit_app_state_changed(supervisor_ptr, app_ptr);
 834   return true;
 835 }
 836
 837 void ladish_app_supervisor_remove_app(ladish_app_supervisor_handle supervisor_handle, ladish_app_handle app_handle)
 838 {
 839   remove_app_internal(supervisor_ptr, app_ptr);
 840 }
 841
 842 unsigned int ladish_app_get_state(ladish_app_handle app_handle)
 843 {
 844   return app_ptr->state;
 845 }
 846
 847 bool ladish_app_is_running(ladish_app_handle app_handle)
 848 {
 849   return app_ptr->pid != 0;
 850 }
 851
 852 const char * ladish_app_get_name(ladish_app_handle app_handle)
 853 {
 854   return app_ptr->name;
 855 }
 856
 857 void ladish_app_get_uuid(ladish_app_handle app_handle, uuid_t uuid)
 858 {
 859   uuid_copy(uuid, app_ptr->uuid);
 860 }
 861
 862 void ladish_app_stop(ladish_app_handle app_handle)
 863 {
 864   ladish_app_initiate_stop(app_ptr);
 865 }
 866
 867 void ladish_app_kill(ladish_app_handle app_handle)
 868 {
 869   ladish_app_send_signal(app_ptr, SIGKILL, false);
 870   app_ptr->state = LADISH_APP_STATE_KILL;
 871 }
 872
 873 void ladish_app_save(ladish_app_handle app_handle)
 874 {
 875   ladish_app_initiate_save(app_ptr);
 876 }
 877
 878 void ladish_app_restore(ladish_app_handle app_handle)
 879 {
 880   if (strcmp(app_ptr->level, LADISH_APP_LEVEL_LASH) == 0 &&
 881       app_ptr->dbus_name != NULL)
 882   {
 883     ladish_app_initiate_lash_restore(app_ptr, app_ptr->supervisor->dir != NULL ? app_ptr->supervisor->dir : g_base_dir);
 884   }
 885 }
 886
 887 void ladish_app_add_pid(ladish_app_handle app_handle, pid_t pid)
 888 {
 889   if (app_ptr->pid == 0)
 890   {
 891     log_error("Associating pid with stopped app does not make sense");
 892     ASSERT_NO_PASS;
 893     return;
 894   }
 895
 896   if (pid <= 1)                 /* catch -1, 0 and 1 */
 897   {
 898     log_error("Refusing domination by ignoring pid %d", (int)pid);
 899     ASSERT_NO_PASS;
 900     return;
 901   }
 902
 903   if (app_ptr->pid == pid)
 904   { /* The top level process that is already known */
 905     return;
 906   }
 907
 908   if (app_ptr->firstborn_pid != 0)
 909   { /* Ignore non-first children */
 910     if (app_ptr->firstborn_pid == pid)
 911     {
 912       app_ptr->firstborn_refcount++;
 913     }
 914     return;
 915   }
 916
 917   log_info("First grandchild with pid %u", (unsigned int)pid);
 918   app_ptr->firstborn_pid = pid;
 919   ASSERT(app_ptr->firstborn_refcount == 0);
 920   app_ptr->firstborn_refcount = 1;
 921 }
 922
 923 void ladish_app_del_pid(ladish_app_handle app_handle, pid_t pid)
 924 {
 925   if (app_ptr->firstborn_pid != 0 && app_ptr->firstborn_pid == pid)
 926   {
 927     ASSERT(app_ptr->firstborn_refcount > 0);
 928     app_ptr->firstborn_refcount--;
 929     if (app_ptr->firstborn_refcount > 0)
 930     {
 931       return;
 932     }
 933     log_info("First grandchild with pid %u has gone", (unsigned int)pid);
 934     app_ptr->firstborn_pid = 0;
 935     app_ptr->firstborn_pgrp = 0;
 936     app_ptr->firstborn_refcount = 0;
 937   }
 938 }
 939
 940 bool ladish_app_set_dbus_name(ladish_app_handle app_handle, const char * name)
 941 {
 942   char * dup;
 943
 944   dup = strdup(name);
 945   if (dup == NULL)
 946   {
 947     log_error("strdup() failed for app dbus name");
 948     return false;
 949   }
 950
 951   free(app_ptr->dbus_name);
 952   app_ptr->dbus_name = dup;
 953   return true;
 954 }
 955
 956 #undef app_ptr
 957
 958 void ladish_app_supervisor_autorun(ladish_app_supervisor_handle supervisor_handle)
 959 {
 960   struct list_head * node_ptr;
 961   struct ladish_app * app_ptr;
 962
 963   list_for_each(node_ptr, &supervisor_ptr->applist)
 964   {
 965     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 966
 967     if (!app_ptr->autorun)
 968     {
 969       continue;
 970     }
 971
 972     app_ptr->autorun = false;
 973
 974     log_info("autorun('%s', %s, '%s') called", app_ptr->name, app_ptr->terminal ? "terminal" : "shell", app_ptr->commandline);
 975
 976     if (!ladish_app_supervisor_start_app((ladish_app_supervisor_handle)supervisor_ptr, (ladish_app_handle)app_ptr))
 977     {
 978       log_error("Execution of '%s' failed",  app_ptr->commandline);
 979       return;
 980     }
 981   }
 982 }
 983
 984 void ladish_app_supervisor_stop(ladish_app_supervisor_handle supervisor_handle)
 985 {
 986   struct list_head * node_ptr;
 987   struct ladish_app * app_ptr;
 988
 989   list_for_each(node_ptr, &supervisor_ptr->applist)
 990   {
 991     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
 992     if (app_ptr->pid != 0)
 993     {
 994       log_info("terminating '%s'...", app_ptr->name);
 995       app_ptr->autorun = true;
 996       ladish_app_initiate_stop(app_ptr);
 997     }
 998   }
 999 }
1000
1001 void ladish_app_supervisor_save(ladish_app_supervisor_handle supervisor_handle)
1002 {
1003   struct list_head * node_ptr;
1004   struct ladish_app * app_ptr;
1005
1006   list_for_each(node_ptr, &supervisor_ptr->applist)
1007   {
1008     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
1009     if (app_ptr->state != LADISH_APP_STATE_STARTED)
1010     {
1011       continue;
1012     }
1013
1014     if (app_ptr->pid == 0)
1015     {
1016       ASSERT_NO_PASS;
1017       continue;
1018     }
1019
1020     ladish_app_initiate_save(app_ptr);
1021   }
1022 }
1023
1024 const char * ladish_app_supervisor_get_name(ladish_app_supervisor_handle supervisor_handle)
1025 {
1026   return supervisor_ptr->name;
1027 }
1028
1029 unsigned int ladish_app_supervisor_get_running_app_count(ladish_app_supervisor_handle supervisor_handle)
1030 {
1031   struct list_head * node_ptr;
1032   struct ladish_app * app_ptr;
1033   unsigned int counter;
1034
1035   counter = 0;
1036   list_for_each(node_ptr, &supervisor_ptr->applist)
1037   {
1038     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
1039     if (app_ptr->pid != 0)
1040     {
1041       counter++;
1042     }
1043   }
1044
1045   return counter;
1046 }
1047
1048 bool ladish_app_supervisor_has_apps(ladish_app_supervisor_handle supervisor_handle)
1049 {
1050   return !list_empty(&supervisor_ptr->applist);
1051 }
1052
1053 void ladish_app_supervisor_dump(ladish_app_supervisor_handle supervisor_handle)
1054 {
1055   struct list_head * node_ptr;
1056   struct ladish_app * app_ptr;
1057   char uuid_str[37];
1058
1059   list_for_each(node_ptr, &supervisor_ptr->applist)
1060   {
1061     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
1062     uuid_unparse(app_ptr->uuid, uuid_str);
1063     log_info("app '%s' with commandline '%s'", app_ptr->name, app_ptr->commandline);
1064     log_info("  %s", uuid_str);
1065     log_info("  %s, %s, level '%s'", app_ptr->terminal ? "terminal" : "shell", app_ptr->autorun ? "autorun" : "stopped", app_ptr->level, app_ptr->commandline);
1066   }
1067 }
1068
1069 #undef supervisor_ptr
1070
1071 /**********************************************************************************/
1072 /*                                D-Bus methods                                   */
1073 /**********************************************************************************/
1074
1075 #define supervisor_ptr ((struct ladish_app_supervisor *)call_ptr->iface_context)
1076
1077 static void get_version(struct dbus_method_call * call_ptr)
1078 {
1079   uint32_t version;
1080
1081   version = 1;
1082
1083   method_return_new_single(call_ptr, DBUS_TYPE_UINT32, &version);
1084 }
1085
1086 static void get_all_multiversion(struct dbus_method_call * call_ptr, int version)
1087 {
1088   DBusMessageIter iter, array_iter, struct_iter;
1089   struct list_head * node_ptr;
1090   struct ladish_app * app_ptr;
1091   dbus_bool_t running;
1092   dbus_bool_t terminal;
1093   const char * level_str;
1094   uint8_t level_byte;
1095
1096   //log_info("get_all called");
1097
1098   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
1099   if (call_ptr->reply == NULL)
1100   {
1101     goto fail;
1102   }
1103
1104   dbus_message_iter_init_append(call_ptr->reply, &iter);
1105
1106   if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT64, &supervisor_ptr->version))
1107   {
1108     goto fail_unref;
1109   }
1110
1111   if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, version == 1 ? "(tsbby)" : "(tsbbs)", &array_iter))
1112   {
1113     goto fail_unref;
1114   }
1115
1116   list_for_each(node_ptr, &supervisor_ptr->applist)
1117   {
1118     app_ptr = list_entry(node_ptr, struct ladish_app, siblings);
1119
1120     log_info("app '%s' (%llu)", app_ptr->name, (unsigned long long)app_ptr->id);
1121
1122     if (!dbus_message_iter_open_container (&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter))
1123     {
1124       goto fail_unref;
1125     }
1126
1127     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_UINT64, &app_ptr->id))
1128     {
1129       goto fail_unref;
1130     }
1131
1132     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &app_ptr->name))
1133     {
1134       goto fail_unref;
1135     }
1136
1137     running = app_ptr->pid != 0;
1138     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_BOOLEAN, &running))
1139     {
1140       goto fail_unref;
1141     }
1142
1143     terminal = app_ptr->terminal;
1144     if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_BOOLEAN, &terminal))
1145     {
1146       goto fail_unref;
1147     }
1148
1149     if (version == 1)
1150     {
1151       level_byte = ladish_level_string_to_integer(app_ptr->level);
1152       if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_BYTE, &level_byte))
1153       {
1154         goto fail_unref;
1155       }
1156     }
1157     else
1158     {
1159       ASSERT(version == 2);
1160
1161       level_str = app_ptr->level;
1162       if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &level_str))
1163       {
1164         goto fail_unref;
1165       }
1166     }
1167
1168     if (!dbus_message_iter_close_container(&array_iter, &struct_iter))
1169     {
1170       goto fail_unref;
1171     }
1172   }
1173
1174   if (!dbus_message_iter_close_container(&iter, &array_iter))
1175   {
1176     goto fail_unref;
1177   }
1178
1179   return;
1180
1181 fail_unref:
1182   dbus_message_unref(call_ptr->reply);
1183   call_ptr->reply = NULL;
1184
1185 fail:
1186   log_error("Ran out of memory trying to construct method return");
1187 }
1188
1189 static void get_all1(struct dbus_method_call * call_ptr)
1190 {
1191   get_all_multiversion(call_ptr, 1);
1192 }
1193
1194 static void get_all2(struct dbus_method_call * call_ptr)
1195 {
1196   get_all_multiversion(call_ptr, 2);
1197 }
1198
1199 static void run_custom1(struct dbus_method_call * call_ptr)
1200 {
1201   dbus_bool_t terminal;
1202   const char * commandline;
1203   const char * name;
1204   uint8_t level;
1205
1206   if (!dbus_message_get_args(
1207         call_ptr->message,
1208         &cdbus_g_dbus_error,
1209         DBUS_TYPE_BOOLEAN, &terminal,
1210         DBUS_TYPE_STRING, &commandline,
1211         DBUS_TYPE_STRING, &name,
1212         DBUS_TYPE_BYTE, &level,
1213         DBUS_TYPE_INVALID))
1214   {
1215     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1216     dbus_error_free(&cdbus_g_dbus_error);
1217     return;
1218   }
1219
1220   log_info("%s('%s', %s, '%s', %"PRIu8") called", call_ptr->method_name, name, terminal ? "terminal" : "shell", commandline, level);
1221
1222   if (level > 1)
1223   {
1224     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "invalid integer level %"PRIu8, level);
1225     return;
1226   }
1227
1228   if (ladish_command_new_app(
1229         call_ptr,
1230         ladish_studio_get_cmd_queue(),
1231         supervisor_ptr->opath,
1232         terminal,
1233         commandline,
1234         name,
1235         level == 0 ? LADISH_APP_LEVEL_0 : LADISH_APP_LEVEL_1))
1236   {
1237     method_return_new_void(call_ptr);
1238   }
1239 }
1240
1241 static void run_custom2(struct dbus_method_call * call_ptr)
1242 {
1243   dbus_bool_t terminal;
1244   const char * commandline;
1245   const char * name;
1246   const char * level;
1247
1248   if (!dbus_message_get_args(
1249         call_ptr->message,
1250         &cdbus_g_dbus_error,
1251         DBUS_TYPE_BOOLEAN, &terminal,
1252         DBUS_TYPE_STRING, &commandline,
1253         DBUS_TYPE_STRING, &name,
1254         DBUS_TYPE_STRING, &level,
1255         DBUS_TYPE_INVALID))
1256   {
1257     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1258     dbus_error_free(&cdbus_g_dbus_error);
1259     return;
1260   }
1261
1262   log_info("%s('%s', %s, '%s', '%s') called", call_ptr->method_name, name, terminal ? "terminal" : "shell", commandline, level);
1263
1264   if (!ladish_check_app_level_validity(level, NULL))
1265   {
1266     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "invalid level '%s'", level);
1267     return;
1268   }
1269
1270   if (ladish_command_new_app(
1271         call_ptr,
1272         ladish_studio_get_cmd_queue(),
1273         supervisor_ptr->opath,
1274         terminal,
1275         commandline,
1276         name,
1277         level))
1278   {
1279     method_return_new_void(call_ptr);
1280   }
1281 }
1282
1283 static void start_app(struct dbus_method_call * call_ptr)
1284 {
1285   uint64_t id;
1286
1287   if (!dbus_message_get_args(
1288         call_ptr->message,
1289         &cdbus_g_dbus_error,
1290         DBUS_TYPE_UINT64, &id,
1291         DBUS_TYPE_INVALID))
1292   {
1293     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1294     dbus_error_free(&cdbus_g_dbus_error);
1295     return;
1296   }
1297
1298   if (ladish_command_change_app_state(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id, LADISH_APP_STATE_STARTED))
1299   {
1300     method_return_new_void(call_ptr);
1301   }
1302 }
1303
1304 static void stop_app(struct dbus_method_call * call_ptr)
1305 {
1306   uint64_t id;
1307
1308   if (!dbus_message_get_args(
1309         call_ptr->message,
1310         &cdbus_g_dbus_error,
1311         DBUS_TYPE_UINT64, &id,
1312         DBUS_TYPE_INVALID))
1313   {
1314     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1315     dbus_error_free(&cdbus_g_dbus_error);
1316     return;
1317   }
1318
1319   if (ladish_command_change_app_state(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id, LADISH_APP_STATE_STOPPED))
1320   {
1321     method_return_new_void(call_ptr);
1322   }
1323 }
1324
1325 static void kill_app(struct dbus_method_call * call_ptr)
1326 {
1327   uint64_t id;
1328
1329   if (!dbus_message_get_args(
1330         call_ptr->message,
1331         &cdbus_g_dbus_error,
1332         DBUS_TYPE_UINT64, &id,
1333         DBUS_TYPE_INVALID))
1334   {
1335     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1336     dbus_error_free(&cdbus_g_dbus_error);
1337     return;
1338   }
1339
1340   if (ladish_command_change_app_state(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id, LADISH_APP_STATE_KILL))
1341   {
1342     method_return_new_void(call_ptr);
1343   }
1344 }
1345
1346 static void get_app_properties_multiversion(struct dbus_method_call * call_ptr, int version)
1347 {
1348   uint64_t id;
1349   struct ladish_app * app_ptr;
1350   dbus_bool_t running;
1351   dbus_bool_t terminal;
1352   const char * level_str;
1353   uint8_t level_byte;
1354   int level_type;
1355   void * level_ptr;
1356
1357   if (!dbus_message_get_args(
1358         call_ptr->message,
1359         &cdbus_g_dbus_error,
1360         DBUS_TYPE_UINT64, &id,
1361         DBUS_TYPE_INVALID))
1362   {
1363     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1364     dbus_error_free(&cdbus_g_dbus_error);
1365     return;
1366   }
1367
1368   app_ptr = ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
1369   if (app_ptr == NULL)
1370   {
1371     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "App with ID %"PRIu64" not found", id);
1372     return;
1373   }
1374
1375   running = app_ptr->pid != 0;
1376   terminal = app_ptr->terminal;
1377   if (version == 1)
1378   {
1379     level_byte = ladish_level_string_to_integer(app_ptr->level);
1380     level_type = DBUS_TYPE_BYTE;
1381     level_ptr = &level_byte;
1382   }
1383   else
1384   {
1385     ASSERT(version == 2);
1386     level_str = app_ptr->level;
1387     level_type = DBUS_TYPE_STRING;
1388     level_ptr = &level_str;
1389   }
1390
1391   call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
1392   if (call_ptr->reply == NULL)
1393   {
1394     goto fail;
1395   }
1396
1397   if (!dbus_message_append_args(
1398         call_ptr->reply,
1399         DBUS_TYPE_STRING, &app_ptr->name,
1400         DBUS_TYPE_STRING, &app_ptr->commandline,
1401         DBUS_TYPE_BOOLEAN, &running,
1402         DBUS_TYPE_BOOLEAN, &terminal,
1403         level_type, level_ptr,
1404         DBUS_TYPE_INVALID))
1405   {
1406     goto fail_unref;
1407   }
1408
1409   return;
1410
1411 fail_unref:
1412   dbus_message_unref(call_ptr->reply);
1413   call_ptr->reply = NULL;
1414
1415 fail:
1416   log_error("Ran out of memory trying to construct method return");
1417 }
1418
1419 static void get_app_properties1(struct dbus_method_call * call_ptr)
1420 {
1421   get_app_properties_multiversion(call_ptr, 1);
1422 }
1423
1424 static void get_app_properties2(struct dbus_method_call * call_ptr)
1425 {
1426   get_app_properties_multiversion(call_ptr, 2);
1427 }
1428
1429 static void set_app_properties_multiversion(struct dbus_method_call * call_ptr, int version)
1430 {
1431   uint64_t id;
1432   dbus_bool_t terminal;
1433   const char * name;
1434   const char * commandline;
1435   const char * level_str;
1436   uint8_t level_byte;
1437   int level_type;
1438   void * level_ptr;
1439   struct ladish_app * app_ptr;
1440   char * name_buffer;
1441   char * commandline_buffer;
1442   size_t len;
1443
1444   if (version == 1)
1445   {
1446     level_type = DBUS_TYPE_BYTE;
1447     level_ptr = &level_byte;
1448   }
1449   else
1450   {
1451     ASSERT(version == 2);
1452     level_type = DBUS_TYPE_STRING;
1453     level_ptr = &level_str;
1454   }
1455
1456   if (!dbus_message_get_args(
1457         call_ptr->message,
1458         &cdbus_g_dbus_error,
1459         DBUS_TYPE_UINT64, &id,
1460         DBUS_TYPE_STRING, &name,
1461         DBUS_TYPE_STRING, &commandline,
1462         DBUS_TYPE_BOOLEAN, &terminal,
1463         level_type, level_ptr,
1464         DBUS_TYPE_INVALID))
1465   {
1466     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1467     dbus_error_free(&cdbus_g_dbus_error);
1468     return;
1469   }
1470
1471   if (version == 1)
1472   {
1473     if (level_byte > 1)
1474     {
1475       lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "invalid integer level %"PRIu8, level_byte);
1476       return;
1477     }
1478
1479     level_str = level_byte == 0 ? LADISH_APP_LEVEL_0 : LADISH_APP_LEVEL_1;
1480     len = strlen(level_str);
1481   }
1482   else
1483   {
1484     ASSERT(version == 2);
1485     if (!ladish_check_app_level_validity(level_str, &len))
1486     {
1487       lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "invalid level '%s'", level_str);
1488       return;
1489     }
1490   }
1491
1492   app_ptr = ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
1493   if (app_ptr == NULL)
1494   {
1495     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "App with ID %"PRIu64" not found", id);
1496     return;
1497   }
1498
1499   if (app_ptr->pid != 0 && strcmp(commandline, app_ptr->commandline) != 0)
1500   {
1501     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "Cannot change commandline when app is running. '%s' -> '%s'", app_ptr->commandline, commandline);
1502     return;
1503   }
1504
1505   if (app_ptr->pid != 0 && ((app_ptr->terminal && !terminal) || (!app_ptr->terminal && terminal)))
1506   {
1507     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "Cannot change whether to run in terminal when app is running");
1508     return;
1509   }
1510
1511   if (app_ptr->pid != 0 && strcmp(app_ptr->level, level_str) != 0)
1512   {
1513     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "Cannot change app level when app is running");
1514     return;
1515   }
1516
1517   if (strcmp(commandline, app_ptr->commandline) != 0)
1518   {
1519     commandline_buffer = strdup(commandline);
1520     if (commandline_buffer == NULL)
1521     {
1522       lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "strdup() failed for app commandline");
1523       return;
1524     }
1525   }
1526   else
1527   {
1528     commandline_buffer = NULL;
1529   }
1530
1531   if (strcmp(name, app_ptr->name) != 0)
1532   {
1533     name_buffer = strdup(name);
1534     if (name_buffer == NULL)
1535     {
1536       lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "strdup() failed for app nam");
1537       if (commandline_buffer != NULL)
1538       {
1539         free(commandline_buffer);
1540       }
1541       return;
1542     }
1543   }
1544   else
1545   {
1546     name_buffer = NULL;
1547   }
1548
1549   if (name_buffer != NULL)
1550   {
1551     supervisor_ptr->on_app_renamed(supervisor_ptr->on_app_renamed_context, app_ptr->uuid, app_ptr->name, name_buffer);
1552     free(app_ptr->name);
1553     app_ptr->name = name_buffer;
1554   }
1555
1556   if (commandline_buffer != NULL)
1557   {
1558     free(app_ptr->commandline);
1559     app_ptr->commandline = commandline_buffer;
1560   }
1561
1562   memcpy(app_ptr->level, level_str, len + 1);
1563   app_ptr->terminal = terminal;
1564
1565   emit_app_state_changed(supervisor_ptr, app_ptr);
1566
1567   method_return_new_void(call_ptr);
1568 }
1569
1570 static void set_app_properties1(struct dbus_method_call * call_ptr)
1571 {
1572   set_app_properties_multiversion(call_ptr, 1);
1573 }
1574
1575 static void set_app_properties2(struct dbus_method_call * call_ptr)
1576 {
1577   set_app_properties_multiversion(call_ptr, 2);
1578 }
1579
1580
1581 static void remove_app(struct dbus_method_call * call_ptr)
1582 {
1583   uint64_t id;
1584
1585   if (!dbus_message_get_args(
1586         call_ptr->message,
1587         &cdbus_g_dbus_error,
1588         DBUS_TYPE_UINT64, &id,
1589         DBUS_TYPE_INVALID))
1590   {
1591     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1592     dbus_error_free(&cdbus_g_dbus_error);
1593     return;
1594   }
1595
1596   if (ladish_command_remove_app(call_ptr, ladish_studio_get_cmd_queue(), supervisor_ptr->opath, id))
1597   {
1598     method_return_new_void(call_ptr);
1599   }
1600 }
1601
1602 static void is_app_running(struct dbus_method_call * call_ptr)
1603 {
1604   uint64_t id;
1605   struct ladish_app * app_ptr;
1606   dbus_bool_t running;
1607
1608   if (!dbus_message_get_args(
1609         call_ptr->message,
1610         &cdbus_g_dbus_error,
1611         DBUS_TYPE_UINT64, &id,
1612         DBUS_TYPE_INVALID))
1613   {
1614     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, cdbus_g_dbus_error.message);
1615     dbus_error_free(&cdbus_g_dbus_error);
1616     return;
1617   }
1618
1619   app_ptr = ladish_app_supervisor_find_app_by_id_internal(supervisor_ptr, id);
1620   if (app_ptr == NULL)
1621   {
1622     lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "App with ID %"PRIu64" not found", id);
1623     return;
1624   }
1625
1626   running = app_ptr->pid != 0;
1627
1628   method_return_new_single(call_ptr, DBUS_TYPE_BOOLEAN, &running);
1629 }
1630
1631 #undef supervisor_ptr
1632
1633 METHOD_ARGS_BEGIN(GetInterfaceVersion, "Get version of this D-Bus interface")
1634   METHOD_ARG_DESCRIBE_OUT("running", DBUS_TYPE_UINT32_AS_STRING, "Interface version")
1635 METHOD_ARGS_END
1636
1637 METHOD_ARGS_BEGIN(GetAll, "Get list of apps")
1638   METHOD_ARG_DESCRIBE_OUT("list_version", DBUS_TYPE_UINT64_AS_STRING, "Version of the list")
1639   METHOD_ARG_DESCRIBE_OUT("apps_list", "a(tsbby)", "List of apps")
1640 METHOD_ARGS_END
1641
1642 METHOD_ARGS_BEGIN(GetAll2, "Get list of apps")
1643   METHOD_ARG_DESCRIBE_OUT("list_version", DBUS_TYPE_UINT64_AS_STRING, "Version of the list")
1644   METHOD_ARG_DESCRIBE_OUT("apps_list", "a(tsbbs)", "List of apps")
1645 METHOD_ARGS_END
1646
1647 METHOD_ARGS_BEGIN(RunCustom, "Start application by supplying commandline")
1648   METHOD_ARG_DESCRIBE_IN("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1649   METHOD_ARG_DESCRIBE_IN("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1650   METHOD_ARG_DESCRIBE_IN("name", DBUS_TYPE_STRING_AS_STRING, "Name")
1651   METHOD_ARG_DESCRIBE_IN("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1652 METHOD_ARGS_END
1653
1654 METHOD_ARGS_BEGIN(RunCustom2, "Start application by supplying commandline")
1655   METHOD_ARG_DESCRIBE_IN("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1656   METHOD_ARG_DESCRIBE_IN("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1657   METHOD_ARG_DESCRIBE_IN("name", DBUS_TYPE_STRING_AS_STRING, "Name")
1658   METHOD_ARG_DESCRIBE_IN("level", DBUS_TYPE_STRING_AS_STRING, "Level")
1659 METHOD_ARGS_END
1660
1661 METHOD_ARGS_BEGIN(StartApp, "Start application")
1662   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1663 METHOD_ARGS_END
1664
1665 METHOD_ARGS_BEGIN(StopApp, "Stop application")
1666   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1667 METHOD_ARGS_END
1668
1669 METHOD_ARGS_BEGIN(KillApp, "Kill application")
1670   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1671 METHOD_ARGS_END
1672
1673 METHOD_ARGS_BEGIN(RemoveApp, "Remove application")
1674   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1675 METHOD_ARGS_END
1676
1677 METHOD_ARGS_BEGIN(GetAppProperties, "Get properties of an application")
1678   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1679   METHOD_ARG_DESCRIBE_OUT("name", DBUS_TYPE_STRING_AS_STRING, "")
1680   METHOD_ARG_DESCRIBE_OUT("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1681   METHOD_ARG_DESCRIBE_OUT("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1682   METHOD_ARG_DESCRIBE_OUT("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1683   METHOD_ARG_DESCRIBE_OUT("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1684 METHOD_ARGS_END
1685
1686 METHOD_ARGS_BEGIN(GetAppProperties2, "Get properties of an application")
1687   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1688   METHOD_ARG_DESCRIBE_OUT("name", DBUS_TYPE_STRING_AS_STRING, "")
1689   METHOD_ARG_DESCRIBE_OUT("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1690   METHOD_ARG_DESCRIBE_OUT("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1691   METHOD_ARG_DESCRIBE_OUT("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1692   METHOD_ARG_DESCRIBE_OUT("level", DBUS_TYPE_STRING_AS_STRING, "Level")
1693 METHOD_ARGS_END
1694
1695 METHOD_ARGS_BEGIN(SetAppProperties, "Set properties of an application")
1696   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1697   METHOD_ARG_DESCRIBE_IN("name", DBUS_TYPE_STRING_AS_STRING, "")
1698   METHOD_ARG_DESCRIBE_IN("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1699   METHOD_ARG_DESCRIBE_IN("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1700   METHOD_ARG_DESCRIBE_IN("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1701 METHOD_ARGS_END
1702
1703 METHOD_ARGS_BEGIN(SetAppProperties2, "Set properties of an application")
1704   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1705   METHOD_ARG_DESCRIBE_IN("name", DBUS_TYPE_STRING_AS_STRING, "")
1706   METHOD_ARG_DESCRIBE_IN("commandline", DBUS_TYPE_STRING_AS_STRING, "Commandline")
1707   METHOD_ARG_DESCRIBE_IN("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1708   METHOD_ARG_DESCRIBE_IN("level", DBUS_TYPE_STRING_AS_STRING, "Level")
1709 METHOD_ARGS_END
1710
1711 METHOD_ARGS_BEGIN(IsAppRunning, "Check whether application is running")
1712   METHOD_ARG_DESCRIBE_IN("id", DBUS_TYPE_UINT64_AS_STRING, "id of app")
1713   METHOD_ARG_DESCRIBE_OUT("running", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether app is running")
1714 METHOD_ARGS_END
1715
1716
1717 METHODS_BEGIN
1718   METHOD_DESCRIBE(GetInterfaceVersion, get_version)     /* sync */
1719   METHOD_DESCRIBE(GetAll, get_all1)                     /* sync */
1720   METHOD_DESCRIBE(GetAll2, get_all2)                    /* sync */
1721   METHOD_DESCRIBE(RunCustom, run_custom1)               /* async */
1722   METHOD_DESCRIBE(RunCustom2, run_custom2)              /* async */
1723   METHOD_DESCRIBE(StartApp, start_app)                  /* async */
1724   METHOD_DESCRIBE(StopApp, stop_app)                    /* async */
1725   METHOD_DESCRIBE(KillApp, kill_app)                    /* async */
1726   METHOD_DESCRIBE(GetAppProperties, get_app_properties1)  /* sync */
1727   METHOD_DESCRIBE(GetAppProperties2, get_app_properties2) /* sync */
1728   METHOD_DESCRIBE(SetAppProperties, set_app_properties1)  /* sync */
1729   METHOD_DESCRIBE(SetAppProperties2, set_app_properties2) /* sync */
1730   METHOD_DESCRIBE(RemoveApp, remove_app)                /* sync */
1731   METHOD_DESCRIBE(IsAppRunning, is_app_running)         /* sync */
1732 METHODS_END
1733
1734 SIGNAL_ARGS_BEGIN(AppAdded, "")
1735   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1736   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1737   SIGNAL_ARG_DESCRIBE("name", DBUS_TYPE_STRING_AS_STRING, "")
1738   SIGNAL_ARG_DESCRIBE("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1739   SIGNAL_ARG_DESCRIBE("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1740   SIGNAL_ARG_DESCRIBE("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1741 SIGNAL_ARGS_END
1742
1743 SIGNAL_ARGS_BEGIN(AppAdded2, "")
1744   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1745   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1746   SIGNAL_ARG_DESCRIBE("name", DBUS_TYPE_STRING_AS_STRING, "")
1747   SIGNAL_ARG_DESCRIBE("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1748   SIGNAL_ARG_DESCRIBE("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1749   SIGNAL_ARG_DESCRIBE("level", DBUS_TYPE_STRING_AS_STRING, "Level")
1750 SIGNAL_ARGS_END
1751
1752 SIGNAL_ARGS_BEGIN(AppRemoved, "")
1753   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1754   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1755 SIGNAL_ARGS_END
1756
1757 SIGNAL_ARGS_BEGIN(AppStateChanged, "")
1758   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1759   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1760   SIGNAL_ARG_DESCRIBE("name", DBUS_TYPE_STRING_AS_STRING, "")
1761   SIGNAL_ARG_DESCRIBE("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1762   SIGNAL_ARG_DESCRIBE("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1763   SIGNAL_ARG_DESCRIBE("level", DBUS_TYPE_BYTE_AS_STRING, "Level")
1764 SIGNAL_ARGS_END
1765
1766 SIGNAL_ARGS_BEGIN(AppStateChanged2, "")
1767   SIGNAL_ARG_DESCRIBE("new_list_version", DBUS_TYPE_UINT64_AS_STRING, "")
1768   SIGNAL_ARG_DESCRIBE("id", DBUS_TYPE_UINT64_AS_STRING, "")
1769   SIGNAL_ARG_DESCRIBE("name", DBUS_TYPE_STRING_AS_STRING, "")
1770   SIGNAL_ARG_DESCRIBE("running", DBUS_TYPE_BOOLEAN_AS_STRING, "")
1771   SIGNAL_ARG_DESCRIBE("terminal", DBUS_TYPE_BOOLEAN_AS_STRING, "Whether to run in terminal")
1772   SIGNAL_ARG_DESCRIBE("level", DBUS_TYPE_STRING_AS_STRING, "Level")
1773 SIGNAL_ARGS_END
1774
1775 SIGNALS_BEGIN
1776   SIGNAL_DESCRIBE(AppAdded)
1777   SIGNAL_DESCRIBE(AppAdded2)
1778   SIGNAL_DESCRIBE(AppRemoved)
1779   SIGNAL_DESCRIBE(AppStateChanged)
1780   SIGNAL_DESCRIBE(AppStateChanged2)
1781 SIGNALS_END
1782
1783 INTERFACE_BEGIN(g_iface_app_supervisor, IFACE_APP_SUPERVISOR)
1784   INTERFACE_DEFAULT_HANDLER
1785   INTERFACE_EXPOSE_METHODS
1786   INTERFACE_EXPOSE_SIGNALS
1787 INTERFACE_END