src/persistence_client_library_dbus_service.c

   1 /******************************************************************************
   2  * Project         Persistency
   3  * (c) copyright   2012
   4  * Company         XS Embedded GmbH
   5  *****************************************************************************/
   6 /******************************************************************************
   7  * This Source Code Form is subject to the terms of the
   8  * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed
   9  * with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  10 ******************************************************************************/
  11  /**
  12  * @file           persistence_client_library_dbus_service.c
  13  * @ingroup        Persistence client library
  14  * @author         Ingo Huerner
  15  * @brief          Implementation of the persistence client library dbus service.
  16  * @see
  17  */
  18
  19
  20 #include "persistence_client_library_dbus_service.h"
  21 #include "persistence_client_library_lc_interface.h"
  22 #include "persistence_client_library_pas_interface.h"
  23 #include "../include_protected/persistence_client_library_data_organization.h"
  24
  25 #include <stdio.h>
  26 #include <errno.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <stdlib.h>
  30
  31
  32 pthread_mutex_t gDbusInitializedMtx  = PTHREAD_MUTEX_INITIALIZER;
  33 pthread_cond_t  gDbusInitializedCond = PTHREAD_COND_INITIALIZER;
  34
  35 typedef enum EDBusObjectType
  36 {
  37    OT_NONE = 0,
  38    OT_WATCH,
  39    OT_TIMEOUT
  40 } tDBusObjectType;
  41
  42
  43 typedef struct SObjectEntry
  44 {
  45    tDBusObjectType objtype; /** libdbus' object */
  46    union
  47    {
  48       DBusWatch * watch;      /** watch "object" */
  49       DBusTimeout * timeout;  /** timeout "object" */
  50    };
  51 } tObjectEntry;
  52
  53
  54
  55 /// polling structure
  56 typedef struct SPollInfo
  57 {
  58    int nfds;
  59    struct pollfd fds[10];
  60    tObjectEntry objects[10];
  61 } tPollInfo;
  62
  63
  64 /// polling information
  65 static tPollInfo gPollInfo;
  66
  67 /// dbus connection
  68 DBusConnection* gDbusConn = NULL;
  69
  70
  71 DBusConnection* get_dbus_connection(void)
  72 {
  73    return gDbusConn;
  74 }
  75
  76 //------------------------------------------------------------------------
  77 // debugging only until "correct" exit of main loop is possible!!!!!
  78 //------------------------------------------------------------------------
  79 #include "signal.h"
  80 static int endLoop = 0;
  81
  82 void sigHandler(int signo)
  83 {
  84    endLoop = 1;
  85 }
  86 //------------------------------------------------------------------------
  87
  88
  89
  90 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
  91
  92
  93 /* function to unregister ojbect path message handler */
  94 static void unregisterMessageHandler(DBusConnection *connection, void *user_data)
  95 {
  96    printf("unregisterObjectPath\n");
  97 }
  98
  99 /* catches messages not directed to any registered object path ("garbage collector") */
 100 static DBusHandlerResult handleObjectPathMessageFallback(DBusConnection * connection, DBusMessage * message, void * user_data)
 101 {
 102    DBusHandlerResult result = DBUS_HANDLER_RESULT_HANDLED;
 103
 104    printf("handleObjectPathMessageFallback Object: '%s' -> Interface: '%s' -> Message: '%s'\n",
 105           dbus_message_get_sender(message), dbus_message_get_interface(message), dbus_message_get_member(message) );
 106
 107    // org.genivi.persistence.admin  S I G N A L
 108    if((0==strcmp("org.genivi.persistence.admin", dbus_message_get_interface(message))))
 109    {
 110       printf("checkPersAdminSignalInterface '%s' -> '%s'\n", dbus_message_get_interface(message), dbus_message_get_member(message));
 111       if(dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL)
 112       {
 113          printf("  checkPersAdminSignal signal\n");
 114          if((0==strcmp("PersistenceModeChanged", dbus_message_get_member(message))))
 115          {
 116             printf("  checkPersAdminSignal message\n");
 117             // to do handle signal
 118             result = signal_persModeChange(connection, message);
 119          }
 120          else
 121          {
 122             printf("handleObjectPathMessageFallback -> unknown signal '%s'\n", dbus_message_get_interface(message));
 123          }
 124       }
 125    }
 126    // org.genivi.persistence.admin  S I G N A L
 127    else if((0==strcmp("org.genivi.persistence.adminconsumer", dbus_message_get_interface(message))))
 128    {
 129       printf("checkPersAdminconsumerSignalInterface '%s' -> '%s'\n", dbus_message_get_interface(message), dbus_message_get_member(message));
 130       if(dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL)
 131       {
 132          if((0==strcmp("PersistenceValueChanged", dbus_message_get_member(message))))
 133          {
 134             DBusError error;
 135             DBusMessage *reply;
 136             dbus_error_init (&error);
 137             char* ldbid;
 138             char* user_no;
 139             char* seat_no;
 140
 141             printf("PersistenceValueChanged signal\n");
 142             // to do handle signal
 143             pclNotification_s notifyStruct;
 144             notifyStruct.pclKeyNotify_Status = pclNotifyStatus_changed;
 145
 146             if (!dbus_message_get_args (message, &error, DBUS_TYPE_STRING, &notifyStruct.resource_id,
 147                                                          DBUS_TYPE_STRING, &ldbid,
 148                                                          DBUS_TYPE_STRING, &user_no,
 149                                                          DBUS_TYPE_STRING, &seat_no,
 150                                                          DBUS_TYPE_INVALID))
 151             {
 152                reply = dbus_message_new_error(message, error.name, error.message);
 153
 154                if (reply == 0)
 155                {
 156                   //DLT_LOG(mgrContext, DLT_LOG_ERROR, DLT_STRING("DBus No memory"));
 157                   printf("DBus No memory\n");
 158                }
 159
 160                if (!dbus_connection_send(connection, reply, 0))
 161                {
 162                   //DLT_LOG(mgrContext, DLT_LOG_ERROR, DLT_STRING("DBus No memory"));
 163                   printf("DBus No memory\n");
 164                }
 165
 166                result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;;
 167                dbus_message_unref(reply);
 168             }
 169             else
 170             {
 171                notifyStruct.ldbid       = atoi(ldbid);
 172                notifyStruct.user_no     = atoi(user_no);
 173                notifyStruct.seat_no     = atoi(seat_no);
 174
 175                // call the registered callback function
 176                gChangeNotifyCallback(&notifyStruct);
 177
 178                result = DBUS_HANDLER_RESULT_HANDLED;
 179             }
 180             dbus_connection_flush(connection);
 181          }
 182       }
 183    }
 184    // org.genivi.persistence.admin  P R O P E R T Y
 185    else  if((0==strcmp("org.freedesktop.DBus.Properties", dbus_message_get_interface(message))))
 186    {
 187       if(dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL)
 188       {
 189          if((0==strcmp("EggDBusChanged", dbus_message_get_member(message))))
 190          {
 191             DBusMessageIter array;
 192             DBusMessageIter dict;
 193             DBusMessageIter variant;
 194
 195             char* dictString = NULL;
 196             int value = 0;
 197
 198             dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, 0, &dict);
 199             dbus_message_iter_get_basic(&dict, &dictString);
 200
 201             dbus_message_iter_open_container(&dict,DBUS_TYPE_VARIANT, NULL, &variant);
 202             dbus_message_iter_get_basic(&dict, &value);
 203
 204             dbus_message_iter_close_container(&dict, &variant);
 205             dbus_message_iter_close_container(&array, &dict);
 206
 207             printf("handleObjectPathMessageFallback ==> value: %d \n", value);
 208             // to do handle signal
 209             result = DBUS_HANDLER_RESULT_HANDLED;
 210          }
 211          else
 212          {
 213             printf("handleObjectPathMessageFallback -> unknown property '%s'\n", dbus_message_get_interface(message));
 214          }
 215       }
 216       else
 217       {
 218          printf("handleObjectPathMessageFallback -> not a signal '%s'\n", dbus_message_get_member(message));
 219       }
 220    }
 221
 222    return result;
 223 }
 224
 225
 226
 227 static void  unregisterObjectPathFallback(DBusConnection *connection, void *user_data)
 228 {
 229    printf("unregisterObjectPathFallback\n");
 230 }
 231
 232
 233
 234 void* run_mainloop(void* dataPtr)
 235 {
 236    // persistence admin message
 237    static const struct DBusObjectPathVTable vtablePersAdmin
 238       = {unregisterMessageHandler, checkPersAdminMsg, NULL, };
 239
 240    // lifecycle message
 241    static const struct DBusObjectPathVTable vtableLifecycle
 242       = {unregisterMessageHandler, checkLifecycleMsg, NULL, };
 243
 244    // fallback
 245    static const struct DBusObjectPathVTable vtableFallback
 246       = {unregisterObjectPathFallback, handleObjectPathMessageFallback, NULL, };
 247
 248    // setup the dbus
 249    mainLoop(vtablePersAdmin, vtableLifecycle, vtableFallback, dataPtr);
 250
 251    printf("Exit dbus main loop!!!!\n");
 252
 253    return NULL;
 254 }
 255
 256
 257
 258 int setup_dbus_mainloop(void)
 259 {
 260    int rval = 0;
 261    pthread_t thread;
 262    DBusError err;
 263    const char *pAddress = getenv("PERS_CLIENT_DBUS_ADDRESS");
 264
 265    // enable locking of data structures in the D-Bus library for multi threading.
 266    dbus_threads_init_default();
 267
 268    dbus_error_init(&err);
 269
 270    // Connect to the bus and check for errors
 271    if(pAddress != NULL)
 272    {
 273       printf("Use specific dbus address: %s\n !", pAddress);
 274       gDbusConn = dbus_connection_open(pAddress, &err);
 275
 276       if(gDbusConn != NULL)
 277       {
 278          if(!dbus_bus_register(gDbusConn, &err))
 279          {
 280             printf("dbus_bus_register() Error %s\n", err.message);
 281             dbus_error_free (&err);
 282             return -1;
 283          }
 284          else
 285          {
 286             printf("Registered connection successfully !\n");
 287          }
 288       }
 289       else
 290       {
 291          printf("dbus_connection_open() Error %s\n",err.message);
 292          dbus_error_free(&err);
 293       }
 294    }
 295    else
 296    {
 297       printf("Use default dbus bus (DBUS_BUS_SYSTEM) !!!!!!\n");
 298       gDbusConn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
 299    }
 300
 301    // wain until dbus main loop has been setup and running
 302    pthread_mutex_lock(&gDbusInitializedMtx);
 303
 304    // create here the dbus connection and pass to main loop
 305    rval = pthread_create(&thread, NULL, run_mainloop, gDbusConn);
 306    if(rval)
 307    {
 308      fprintf(stderr, "Server: - ERROR! pthread_create( run_mainloop ) returned: %d\n", rval);
 309    }
 310
 311    // wait for condition variable
 312    pthread_cond_wait(&gDbusInitializedCond, &gDbusInitializedMtx);
 313
 314    pthread_mutex_unlock(&gDbusInitializedMtx);
 315    return rval;
 316 }
 317
 318
 319
 320
 321
 322 static dbus_bool_t addWatch(DBusWatch *watch, void *data)
 323 {
 324    dbus_bool_t result = FALSE;
 325
 326    //fprintf(stderr, "addWatch called @%08x flags: %08x enabled: %c\n", (unsigned int)watch, dbus_watch_get_flags(watch), TRUE==dbus_watch_get_enabled(watch)?'x':'-');
 327
 328    if (ARRAY_SIZE(gPollInfo.fds)>gPollInfo.nfds)
 329    {
 330       int flags = dbus_watch_get_flags(watch);
 331
 332       tObjectEntry * const pEntry = &gPollInfo.objects[gPollInfo.nfds];
 333       pEntry->objtype = OT_WATCH;
 334       pEntry->watch = watch;
 335
 336       gPollInfo.fds[gPollInfo.nfds].fd = dbus_watch_get_unix_fd(watch);
 337
 338       if (TRUE==dbus_watch_get_enabled(watch))
 339       {
 340          if (flags&DBUS_WATCH_READABLE)
 341          {
 342             gPollInfo.fds[gPollInfo.nfds].events |= POLLIN;
 343          }
 344          if (flags&DBUS_WATCH_WRITABLE)
 345          {
 346             gPollInfo.fds[gPollInfo.nfds].events |= POLLOUT;
 347          }
 348
 349          ++gPollInfo.nfds;
 350       }
 351
 352       result = TRUE;
 353    }
 354
 355    return result;
 356 }
 357
 358
 359
 360 static void removeWatch(DBusWatch *watch, void *data)
 361 {
 362    printf("removeWatch called @0x%08x\n", (int)watch);
 363 }
 364
 365
 366
 367 static void watchToggled(DBusWatch *watch, void *data)
 368 {
 369    printf("watchToggled called @0x%08x\n", (int)watch);
 370 }
 371
 372
 373
 374 static dbus_bool_t addTimeout(DBusTimeout *timeout, void *data)
 375 {
 376    dbus_bool_t ret = FALSE;
 377
 378    if (ARRAY_SIZE(gPollInfo.fds)>gPollInfo.nfds)
 379    {
 380       const int interval = dbus_timeout_get_interval(timeout);
 381       if ((0<interval)&&(TRUE==dbus_timeout_get_enabled(timeout)))
 382       {
 383          const int tfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
 384          if (-1!=tfd)
 385          {
 386             const struct itimerspec its = { .it_value= {interval/1000, interval%1000} };
 387             if (-1!=timerfd_settime(tfd, 0, &its, NULL))
 388             {
 389                tObjectEntry * const pEntry = &gPollInfo.objects[gPollInfo.nfds];
 390                pEntry->objtype = OT_TIMEOUT;
 391                pEntry->timeout = timeout;
 392                gPollInfo.fds[gPollInfo.nfds].fd = tfd;
 393                gPollInfo.fds[gPollInfo.nfds].events |= POLLIN;
 394                ++gPollInfo.nfds;
 395                ret = TRUE;
 396             }
 397             else
 398             {
 399                fprintf(stderr, "timerfd_settime() failed %d '%s'\n", errno, strerror(errno));
 400             }
 401          }
 402          else
 403          {
 404             fprintf(stderr, "timerfd_create() failed %d '%s'\n", errno, strerror(errno));
 405          }
 406       }
 407    }
 408    else
 409    {
 410       fprintf(stderr, "cannot create another fd to be poll()'ed\n");
 411    }
 412
 413    return ret;
 414 }
 415
 416
 417
 418 static void removeTimeout(DBusTimeout *timeout, void *data)
 419 {
 420
 421    int i = gPollInfo.nfds;
 422    while ((0<i--)&&(timeout!=gPollInfo.objects[i].timeout));
 423
 424    if (0<i)
 425    {
 426       if (-1==close(gPollInfo.fds[i].fd))
 427       {
 428          fprintf(stderr, "close() timerfd #%d failed %d '%s'\n", gPollInfo.fds[i].fd, errno, strerror(errno));
 429       }
 430
 431       --gPollInfo.nfds;
 432       while (gPollInfo.nfds>i)
 433       {
 434          gPollInfo.fds[i] = gPollInfo.fds[i+1];
 435          gPollInfo.objects[i] = gPollInfo.objects[i+1];
 436          ++i;
 437       }
 438
 439       gPollInfo.fds[gPollInfo.nfds].fd = -1;
 440       gPollInfo.objects[gPollInfo.nfds].objtype = OT_NONE;
 441    }
 442 }
 443
 444
 445
 446 /** callback for libdbus' when timeout changed */
 447 static void timeoutToggled(DBusTimeout *timeout, void *data)
 448 {
 449    int i = gPollInfo.nfds;
 450    while ((0<i--)&&(timeout!=gPollInfo.objects[i].timeout));
 451    fprintf(stderr, "timeoutToggled @%x %c %dms @%d [%d]\n", (int)timeout, dbus_timeout_get_enabled(timeout)?'x':'-', dbus_timeout_get_interval(timeout), i, gPollInfo.nfds);
 452    if (0<i)
 453    {
 454       const int interval = (TRUE==dbus_timeout_get_enabled(timeout))?dbus_timeout_get_interval(timeout):0;
 455       const struct itimerspec its = { .it_value= {interval/1000, interval%1000} };
 456       if (-1!=timerfd_settime(gPollInfo.fds[i].fd, 0, &its, NULL))
 457       {
 458          fprintf(stderr, "timerfd_settime() %d failed %d '%s'\n", interval, errno, strerror(errno));
 459       }
 460    }
 461 }
 462
 463
 464
 465 int mainLoop(DBusObjectPathVTable vtable, DBusObjectPathVTable vtable2,
 466              DBusObjectPathVTable vtableFallback, void* userData)
 467 {
 468    DBusError err;
 469    // lock mutex to make sure dbus main loop is running
 470    pthread_mutex_lock(&gDbusInitializedMtx);
 471
 472    signal(SIGTERM, sigHandler);
 473    signal(SIGQUIT, sigHandler);
 474    signal(SIGINT,  sigHandler);
 475
 476    DBusConnection* conn = (DBusConnection*)userData;
 477    dbus_error_init(&err);
 478
 479    if (dbus_error_is_set(&err))
 480    {
 481       printf("Connection Error (%s)\n", err.message);
 482       dbus_error_free(&err);
 483    }
 484    else if (NULL != conn)
 485    {
 486       dbus_connection_set_exit_on_disconnect (conn, FALSE);
 487       //printf("connected as '%s'\n", dbus_bus_get_unique_name(conn));
 488       if (-1 == (gEfds = eventfd(0, 0)))
 489       {
 490          printf("eventfd() failed w/ errno %d\n", errno);
 491       }
 492       else
 493       {
 494          int ret;
 495          int bContinue = 0;
 496          memset(&gPollInfo, 0 , sizeof(gPollInfo));
 497
 498          gPollInfo.nfds = 1;
 499          gPollInfo.fds[0].fd = gEfds;
 500          gPollInfo.fds[0].events = POLLIN;
 501
 502          dbus_bus_add_match(conn, "type='signal',interface='org.genivi.persistence.admin',member='PersistenceModeChanged',path='/org/genivi/persistence/admin'", &err);
 503
 504          // register for messages
 505          if (   (TRUE==dbus_connection_register_object_path(conn, "/org/genivi/persistence/adminconsumer", &vtable, userData))
 506              && (TRUE==dbus_connection_register_object_path(conn, "/org/genivi/NodeStateManager/LifeCycleConsumer", &vtable2, userData))
 507              && (TRUE==dbus_connection_register_fallback(conn, "/", &vtableFallback, userData)) )
 508          {
 509             if(   (TRUE!=dbus_connection_set_watch_functions(conn, addWatch, removeWatch, watchToggled, NULL, NULL))
 510                || (TRUE!=dbus_connection_set_timeout_functions(conn, addTimeout, removeTimeout, timeoutToggled, NULL, NULL)) )
 511             {
 512                printf("dbus_connection_set_watch_functions() failed\n");
 513             }
 514             else
 515             {
 516                pthread_cond_signal(&gDbusInitializedCond);
 517                pthread_mutex_unlock(&gDbusInitializedMtx);
 518                do
 519                {
 520                   bContinue = 0; /* assume error */
 521
 522                   while (DBUS_DISPATCH_DATA_REMAINS==dbus_connection_dispatch(conn));
 523
 524                   while ((-1==(ret=poll(gPollInfo.fds, gPollInfo.nfds, -1)))&&(EINTR==errno));
 525
 526                   if (0>ret)
 527                   {
 528                      fprintf(stderr, "poll() failed w/ errno %d\n", errno);
 529                   }
 530                   else if (0==ret)
 531                   {
 532                      /* poll time-out */
 533                   }
 534                   else
 535                   {
 536                      int i;
 537
 538                      for (i=0; gPollInfo.nfds>i; ++i)
 539                      {
 540                         /* anything to do */
 541                         if (0!=gPollInfo.fds[i].revents)
 542                         {
 543                            //fprintf(stderr, "\t[%d] revents 0x%04x\n", i, gPollInfo.fds[i].revents);
 544
 545                            if (OT_TIMEOUT==gPollInfo.objects[i].objtype)
 546                            {
 547                               /* time-out occured */
 548                               unsigned long long nExpCount = 0;
 549                               if ((ssize_t)sizeof(nExpCount)!=read(gPollInfo.fds[i].fd, &nExpCount, sizeof(nExpCount)))
 550                               {
 551                                  fprintf(stderr, "read failed!?\n");
 552                               }
 553                               fprintf(stderr, "timeout %x #%d!\n", (int)gPollInfo.objects[i].timeout, (int)nExpCount);
 554                               if (FALSE==dbus_timeout_handle(gPollInfo.objects[i].timeout))
 555                               {
 556                                  fprintf(stderr, "dbus_timeout_handle() failed!?\n");
 557                               }
 558                               bContinue = TRUE;
 559                            }
 560                            else if (gPollInfo.fds[i].fd==gEfds)
 561                            {
 562                               /* internal command */
 563                               if (0!=(gPollInfo.fds[i].revents & POLLIN))
 564                               {
 565                                  uint16_t buf[64];
 566                                  bContinue = TRUE;
 567                                  while ((-1==(ret=read(gPollInfo.fds[i].fd, buf, 64)))&&(EINTR==errno));
 568                                  if (0>ret)
 569                                  {
 570                                     printf("read() failed w/ errno %d | %s\n", errno, strerror(errno));
 571                                  }
 572                                  else if (ret != -1)
 573                                  {
 574                                     switch (buf[0])
 575                                     {
 576                                        case CMD_PAS_BLOCK_AND_WRITE_BACK:
 577                                           process_block_and_write_data_back((buf[2]), buf[1]);
 578                                           break;
 579                                        case CMD_LC_PREPARE_SHUTDOWN:
 580                                           process_prepare_shutdown((buf[2]), buf[1]);
 581                                           break;
 582                                        case CMD_QUIT:
 583                                           bContinue = FALSE;
 584                                           break;
 585                                        default:
 586                                           printf("command %d not handled!\n", buf[0]);
 587                                           break;
 588                                     }
 589                                  }
 590                               }
 591                            }
 592                            else
 593                            {
 594                               int flags = 0;
 595                               if (0!=(gPollInfo.fds[i].revents & POLLIN))
 596                               {
 597                                  flags |= DBUS_WATCH_READABLE;
 598                               }
 599                               if (0!=(gPollInfo.fds[i].revents & POLLOUT))
 600                               {
 601                                  flags |= DBUS_WATCH_WRITABLE;
 602                               }
 603                               if (0!=(gPollInfo.fds[i].revents & POLLERR))
 604                               {
 605                                  flags |= DBUS_WATCH_ERROR;
 606                               }
 607                               if (0!=(gPollInfo.fds[i].revents & POLLHUP))
 608                               {
 609                                  flags |= DBUS_WATCH_HANGUP;
 610                               }
 611
 612                               bContinue = dbus_watch_handle(gPollInfo.objects[i].watch, flags);
 613                            }
 614                         }
 615                      }
 616                   }
 617                   if(endLoop == 1)
 618                      break;
 619                }
 620                while (0!=bContinue);
 621             }
 622             dbus_connection_unregister_object_path(conn, "/org/genivi/persistence/adminconsumer");
 623             dbus_connection_unregister_object_path(conn, "/org/genivi/NodeStateManager/LifeCycleConsumer");
 624             dbus_connection_unregister_object_path(conn, "/");
 625          }
 626          close(gEfds);
 627       }
 628       dbus_connection_unref(conn);
 629       dbus_shutdown();
 630    }
 631
 632    pthread_cond_signal(&gDbusInitializedCond);
 633    pthread_mutex_unlock(&gDbusInitializedMtx);
 634    return 0;
 635 }
 636