proxies/app_supervisor_proxy.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 code that interfaces
   9  * app supervisor object through D-Bus
  10  **************************************************************************
  11  *
  12  * LADI Session Handler is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * LADI Session Handler is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  24  * or write to the Free Software Foundation, Inc.,
  25  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  26  */
  27
  28 #include "app_supervisor_proxy.h"
  29
  30 struct ladish_app_supervisor_proxy
  31 {
  32   char * service;
  33   char * object;
  34   uint64_t version;
  35
  36   void * context;
  37   void (* app_added)(void * context, uint64_t id, const char * name, bool running, bool terminal, const char * level);
  38   void (* app_state_changed)(void * context, uint64_t id, const char * name, bool running, bool terminal, const char * level);
  39   void (* app_removed)(void * context, uint64_t id);
  40 };
  41
  42 #define proxy_ptr ((struct ladish_app_supervisor_proxy *)context)
  43
  44 static void on_app_added(void * context, DBusMessage * message_ptr)
  45 {
  46   uint64_t new_list_version;
  47   uint64_t id;
  48   const char * name;
  49   dbus_bool_t running;
  50   dbus_bool_t terminal;
  51   const char * level;
  52
  53   if (!dbus_message_get_args(
  54         message_ptr,
  55         &cdbus_g_dbus_error,
  56         DBUS_TYPE_UINT64, &new_list_version,
  57         DBUS_TYPE_UINT64, &id,
  58         DBUS_TYPE_STRING, &name,
  59         DBUS_TYPE_BOOLEAN, &running,
  60         DBUS_TYPE_BOOLEAN, &terminal,
  61         DBUS_TYPE_STRING, &level,
  62         DBUS_TYPE_INVALID))
  63   {
  64     log_error("dbus_message_get_args() failed to extract AppAdded2 signal arguments (%s)", cdbus_g_dbus_error.message);
  65     dbus_error_free(&cdbus_g_dbus_error);
  66     return;
  67   }
  68
  69   //log_info("AppAdded2 signal received. id=%"PRIu64", name='%s', %srunning, %s, level '%s'", id, name, running ? "" : "not ", terminal ? "terminal" : "shell", level);
  70
  71   if (new_list_version <= proxy_ptr->version)
  72   {
  73     log_info("Ignoring signal for older version of the app list");
  74   }
  75   else
  76   {
  77     //log_info("got new list version %llu", (unsigned long long)version);
  78     proxy_ptr->version = new_list_version;
  79
  80     level = ladish_map_app_level_constant(level);
  81     if (level != NULL)
  82     {
  83       proxy_ptr->app_added(proxy_ptr->context, id, name, running, terminal, level);
  84     }
  85     else
  86     {
  87       log_error("Ignoring app added signal for '%s' because of invalid app level value", name);
  88     }
  89   }
  90 }
  91
  92 static void on_app_removed(void * context, DBusMessage * message_ptr)
  93 {
  94   uint64_t new_list_version;
  95   uint64_t id;
  96
  97   if (!dbus_message_get_args(
  98         message_ptr,
  99         &cdbus_g_dbus_error,
 100         DBUS_TYPE_UINT64, &new_list_version,
 101         DBUS_TYPE_UINT64, &id,
 102         DBUS_TYPE_INVALID))
 103   {
 104     log_error("dbus_message_get_args() failed to extract AppRemoved signal arguments (%s)", cdbus_g_dbus_error.message);
 105     dbus_error_free(&cdbus_g_dbus_error);
 106     return;
 107   }
 108
 109   //log_info("AppRemoved signal received, id=%"PRIu64, id);
 110   if (new_list_version <= proxy_ptr->version)
 111   {
 112     log_info("Ignoring signal for older version of the app list");
 113   }
 114   else
 115   {
 116     //log_info("got new list version %llu", (unsigned long long)version);
 117     proxy_ptr->version = new_list_version;
 118     proxy_ptr->app_removed(proxy_ptr->context, id);
 119   }
 120 }
 121
 122 static void on_app_state_changed(void * context, DBusMessage * message_ptr)
 123 {
 124   uint64_t new_list_version;
 125   uint64_t id;
 126   const char * name;
 127   dbus_bool_t running;
 128   dbus_bool_t terminal;
 129   const char * level;
 130
 131   if (!dbus_message_get_args(
 132         message_ptr,
 133         &cdbus_g_dbus_error,
 134         DBUS_TYPE_UINT64, &new_list_version,
 135         DBUS_TYPE_UINT64, &id,
 136         DBUS_TYPE_STRING, &name,
 137         DBUS_TYPE_BOOLEAN, &running,
 138         DBUS_TYPE_BOOLEAN, &terminal,
 139         DBUS_TYPE_STRING, &level,
 140         DBUS_TYPE_INVALID))
 141   {
 142     log_error("dbus_message_get_args() failed to extract AppStateChanged2 signal arguments (%s)", cdbus_g_dbus_error.message);
 143     dbus_error_free(&cdbus_g_dbus_error);
 144     return;
 145   }
 146
 147   //log_info("AppStateChanged2 signal received");
 148   //log_info("AppRemoved signal received, id=%"PRIu64, id);
 149   if (new_list_version <= proxy_ptr->version)
 150   {
 151     log_info("Ignoring signal for older version of the app list");
 152   }
 153   else
 154   {
 155     //log_info("got new list version %llu", (unsigned long long)version);
 156     proxy_ptr->version = new_list_version;
 157
 158     level = ladish_map_app_level_constant(level);
 159     if (level != NULL)
 160     {
 161       proxy_ptr->app_state_changed(proxy_ptr->context, id, name, running, terminal, level);
 162     }
 163     else
 164     {
 165       log_error("Ignoring app state changed signal for '%s' because of invalid app level value", name);
 166     }
 167   }
 168 }
 169
 170 #undef proxy_ptr
 171
 172 /* this must be static because it is referenced by the
 173  * dbus helper layer when hooks are active */
 174 static struct cdbus_signal_hook g_signal_hooks[] =
 175 {
 176   {"AppAdded2", on_app_added},
 177   {"AppRemoved", on_app_removed},
 178   {"AppStateChanged2", on_app_state_changed},
 179   {NULL, NULL}
 180 };
 181
 182 static void refresh_internal(struct ladish_app_supervisor_proxy * proxy_ptr, bool force)
 183 {
 184   DBusMessage* reply_ptr;
 185   DBusMessageIter iter;
 186   dbus_uint64_t version;
 187   const char * reply_signature;
 188   DBusMessageIter array_iter;
 189   DBusMessageIter struct_iter;
 190   uint64_t id;
 191   const char * name;
 192   dbus_bool_t running;
 193   dbus_bool_t terminal;
 194   const char * level;
 195
 196   log_info("refresh_internal() called");
 197
 198   version = proxy_ptr->version;
 199
 200   if (!cdbus_call(0, proxy_ptr->service, proxy_ptr->object, IFACE_APP_SUPERVISOR, "GetAll2", "t", &version, NULL, &reply_ptr))
 201   {
 202     log_error("GetAll2() failed.");
 203     return;
 204   }
 205
 206   reply_signature = dbus_message_get_signature(reply_ptr);
 207
 208   if (strcmp(reply_signature, "ta(tsbbs)") != 0)
 209   {
 210     log_error("GetAll2() reply signature mismatch. '%s'", reply_signature);
 211     goto unref;
 212   }
 213
 214   dbus_message_iter_init(reply_ptr, &iter);
 215
 216   //log_info_msg("version " + (char)dbus_message_iter_get_arg_type(&iter));
 217   dbus_message_iter_get_basic(&iter, &version);
 218   dbus_message_iter_next(&iter);
 219
 220   if (!force && version <= proxy_ptr->version)
 221   {
 222     goto unref;
 223   }
 224
 225   //log_info("got new list version %llu", (unsigned long long)version);
 226   proxy_ptr->version = version;
 227
 228   for (dbus_message_iter_recurse(&iter, &array_iter);
 229        dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID;
 230        dbus_message_iter_next(&array_iter))
 231   {
 232     dbus_message_iter_recurse(&array_iter, &struct_iter);
 233
 234     dbus_message_iter_get_basic(&struct_iter, &id);
 235     dbus_message_iter_next(&struct_iter);
 236
 237     dbus_message_iter_get_basic(&struct_iter, &name);
 238     dbus_message_iter_next(&struct_iter);
 239
 240     dbus_message_iter_get_basic(&struct_iter, &running);
 241     dbus_message_iter_next(&struct_iter);
 242
 243     dbus_message_iter_get_basic(&struct_iter, &terminal);
 244     dbus_message_iter_next(&struct_iter);
 245
 246     dbus_message_iter_get_basic(&struct_iter, &level);
 247     dbus_message_iter_next(&struct_iter);
 248
 249     level = ladish_map_app_level_constant(level);
 250     if (level != NULL)
 251     {
 252       //log_info("App id=%"PRIu64", name='%s', %srunning, %s, level '%s'", id, name, running ? "" : "not ", terminal ? "terminal" : "shell", level);
 253       proxy_ptr->app_added(proxy_ptr->context, id, name, running, terminal, level);
 254     }
 255     else
 256     {
 257       log_error("Ignoring app '%s' because of invalid app level value", name);
 258     }
 259
 260     dbus_message_iter_next(&struct_iter);
 261   }
 262
 263 unref:
 264   dbus_message_unref(reply_ptr);
 265 }
 266
 267 bool
 268 ladish_app_supervisor_proxy_create(
 269   const char * service,
 270   const char * object,
 271   void * context,
 272   void (* app_added)(void * context, uint64_t id, const char * name, bool running, bool terminal, const char * level),
 273   void (* app_state_changed)(void * context, uint64_t id, const char * name, bool running, bool terminal, const char * level),
 274   void (* app_removed)(void * context, uint64_t id),
 275   ladish_app_supervisor_proxy_handle * handle_ptr)
 276 {
 277   struct ladish_app_supervisor_proxy * proxy_ptr;
 278
 279   proxy_ptr = malloc(sizeof(struct ladish_app_supervisor_proxy));
 280   if (proxy_ptr == NULL)
 281   {
 282     log_error("malloc() failed to allocate struct proxy");
 283     goto fail;
 284   }
 285
 286   proxy_ptr->service = strdup(service);
 287   if (proxy_ptr->service == NULL)
 288   {
 289     log_error("strdup() failed too duplicate service name '%s'", service);
 290     goto free_proxy;
 291   }
 292
 293   proxy_ptr->object = strdup(object);
 294   if (proxy_ptr->object == NULL)
 295   {
 296     log_error("strdup() failed too duplicate object name '%s'", object);
 297     goto free_service;
 298   }
 299
 300   proxy_ptr->version = 0;
 301
 302   proxy_ptr->context = context;
 303   proxy_ptr->app_added = app_added;
 304   proxy_ptr->app_state_changed = app_state_changed;
 305   proxy_ptr->app_removed = app_removed;
 306
 307   if (!cdbus_register_object_signal_hooks(
 308         cdbus_g_dbus_connection,
 309         proxy_ptr->service,
 310         proxy_ptr->object,
 311         IFACE_APP_SUPERVISOR,
 312         proxy_ptr,
 313         g_signal_hooks))
 314   {
 315     log_error("dbus_register_object_signal_hooks() failed for app supervisor");
 316     goto free_object;
 317   }
 318
 319   refresh_internal(proxy_ptr, true);
 320
 321   *handle_ptr = (ladish_app_supervisor_proxy_handle)proxy_ptr;
 322
 323   return true;
 324
 325 free_object:
 326   free(proxy_ptr->object);
 327 free_service:
 328   free(proxy_ptr->service);
 329 free_proxy:
 330   free(proxy_ptr);
 331 fail:
 332   return false;
 333 }
 334
 335 #define proxy_ptr ((struct ladish_app_supervisor_proxy *)proxy)
 336
 337 void ladish_app_supervisor_proxy_destroy(ladish_app_supervisor_proxy_handle proxy)
 338 {
 339   cdbus_unregister_object_signal_hooks(cdbus_g_dbus_connection, proxy_ptr->service, proxy_ptr->object, IFACE_APP_SUPERVISOR);
 340
 341   free(proxy_ptr->object);
 342   free(proxy_ptr->service);
 343   free(proxy_ptr);
 344 }
 345
 346 bool
 347 ladish_app_supervisor_proxy_run_custom(
 348   ladish_app_supervisor_proxy_handle proxy,
 349   const char * command,
 350   const char * name,
 351   bool run_in_terminal,
 352   const char * level)
 353 {
 354   dbus_bool_t terminal;
 355
 356   terminal = run_in_terminal;
 357
 358   if (!cdbus_call(0, proxy_ptr->service, proxy_ptr->object, IFACE_APP_SUPERVISOR, "RunCustom2", "bsss", &terminal, &command, &name, &level, ""))
 359   {
 360     log_error("RunCustom2() failed.");
 361     return false;
 362   }
 363
 364   return true;
 365 }
 366
 367 bool ladish_app_supervisor_proxy_start_app(ladish_app_supervisor_proxy_handle proxy, uint64_t id)
 368 {
 369   if (!cdbus_call(0, proxy_ptr->service, proxy_ptr->object, IFACE_APP_SUPERVISOR, "StartApp", "t", &id, ""))
 370   {
 371     log_error("StartApp() failed.");
 372     return false;
 373   }
 374
 375   return true;
 376 }
 377
 378 bool ladish_app_supervisor_proxy_stop_app(ladish_app_supervisor_proxy_handle proxy, uint64_t id)
 379 {
 380   if (!cdbus_call(0, proxy_ptr->service, proxy_ptr->object, IFACE_APP_SUPERVISOR, "StopApp", "t", &id, ""))
 381   {
 382     log_error("StopApp() failed.");
 383     return false;
 384   }
 385
 386   return true;
 387 }
 388
 389 bool ladish_app_supervisor_proxy_kill_app(ladish_app_supervisor_proxy_handle proxy, uint64_t id)
 390 {
 391   if (!cdbus_call(0, proxy_ptr->service, proxy_ptr->object, IFACE_APP_SUPERVISOR, "KillApp", "t", &id, ""))
 392   {
 393     log_error("KillApp() failed.");
 394     return false;
 395   }
 396
 397   return true;
 398 }
 399
 400 bool ladish_app_supervisor_proxy_remove_app(ladish_app_supervisor_proxy_handle proxy, uint64_t id)
 401 {
 402   if (!cdbus_call(0, proxy_ptr->service, proxy_ptr->object, IFACE_APP_SUPERVISOR, "RemoveApp", "t", &id, ""))
 403   {
 404     log_error("RemoveApp() failed.");
 405     return false;
 406   }
 407
 408   return true;
 409 }
 410
 411 bool
 412 ladish_app_supervisor_get_app_properties(
 413   ladish_app_supervisor_proxy_handle proxy,
 414   uint64_t id,
 415   char ** name_ptr_ptr,
 416   char ** command_ptr_ptr,
 417   bool * running_ptr,
 418   bool * terminal_ptr,
 419   const char ** level_ptr)
 420 {
 421   DBusMessage * reply_ptr;
 422   const char * name;
 423   const char * commandline;
 424   dbus_bool_t running;
 425   dbus_bool_t terminal;
 426   const char * level;
 427   char * name_buffer;
 428   char * commandline_buffer;
 429
 430   if (!cdbus_call(0, proxy_ptr->service, proxy_ptr->object, IFACE_APP_SUPERVISOR, "GetAppProperties2", "t", &id, NULL, &reply_ptr))
 431   {
 432     log_error("GetAppProperties2() failed.");
 433     return false;
 434   }
 435
 436   if (!dbus_message_get_args(
 437         reply_ptr,
 438         &cdbus_g_dbus_error,
 439         DBUS_TYPE_STRING, &name,
 440         DBUS_TYPE_STRING, &commandline,
 441         DBUS_TYPE_BOOLEAN, &running,
 442         DBUS_TYPE_BOOLEAN, &terminal,
 443         DBUS_TYPE_STRING, &level,
 444         DBUS_TYPE_INVALID))
 445   {
 446     dbus_message_unref(reply_ptr);
 447     dbus_error_free(&cdbus_g_dbus_error);
 448     log_error("decoding reply of GetAppProperties failed.");
 449     return false;
 450   }
 451
 452   level = ladish_map_app_level_constant(level);
 453   if (level == NULL)
 454   {
 455     dbus_message_unref(reply_ptr);
 456     log_error("decoding reply of GetAppProperties failed.");
 457     return false;
 458   }
 459
 460   name_buffer = strdup(name);
 461   if (name_buffer == NULL)
 462   {
 463     log_error("strdup() for app name failed.");
 464     dbus_message_unref(reply_ptr);
 465     return false;
 466   }
 467
 468   commandline_buffer = strdup(commandline);
 469   if (commandline_buffer == NULL)
 470   {
 471     log_error("strdup() for app commandline failed.");
 472     free(name_buffer);
 473     dbus_message_unref(reply_ptr);
 474     return false;
 475   }
 476
 477   *name_ptr_ptr = name_buffer;
 478   *command_ptr_ptr = commandline_buffer;
 479   *running_ptr = running;
 480   *terminal_ptr = terminal;
 481   *level_ptr = level;
 482
 483   dbus_message_unref(reply_ptr);
 484
 485   return true;
 486 }
 487
 488 bool
 489 ladish_app_supervisor_set_app_properties(
 490   ladish_app_supervisor_proxy_handle proxy,
 491   uint64_t id,
 492   const char * name,
 493   const char * command,
 494   bool run_in_terminal,
 495   const char * level)
 496 {
 497   dbus_bool_t terminal;
 498
 499   terminal = run_in_terminal;
 500
 501   if (!cdbus_call(
 502         0,
 503         proxy_ptr->service,
 504         proxy_ptr->object,
 505         IFACE_APP_SUPERVISOR,
 506         "SetAppProperties2",
 507         "tssbs",
 508         &id,
 509         &name,
 510         &command,
 511         &terminal,
 512         &level,
 513         ""))
 514   {
 515     log_error("SetAppProperties2() failed.");
 516     return false;
 517   }
 518
 519   return true;
 520 }
 521
 522 #undef proxy_ptr