LayerManagerPlugins/Communicators/DBUSCommunicator/src/DBUSMessageHandler.cpp

   1
   2 #include "DBUSMessageHandler.h"
   3 #include "DBUSConfiguration.h"
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include "Log.h"
   7
   8 DBUSMessageHandler::DBUSMessageHandler()
   9 : m_MessageIter()
  10 , m_pReply(0)
  11 , m_serial(0)
  12 , m_pConnection(0)
  13 {
  14     dbus_error_init(&m_err);
  15
  16     // connect to the bus and check for errors
  17     char* useSessionBus = getenv("LM_USE_SESSION_BUS");
  18     if ( NULL != useSessionBus && strcmp(useSessionBus,"enable") == 0 )
  19     {
  20         LOG_INFO("DBUSMessageHandler", "Using Session Bus");
  21         m_pConnection = dbus_bus_get(DBUS_BUS_SESSION, &m_err);
  22     }
  23     else
  24     {
  25         LOG_INFO("DBUSMessageHandler", "Using System Bus");
  26         m_pConnection = dbus_bus_get(DBUS_BUS_SYSTEM, &m_err);
  27     }
  28
  29     if (dbus_error_is_set(&m_err))
  30     {
  31         LOG_ERROR("DBUSMessageHandler","Connection error");
  32         dbus_error_free(&m_err);
  33     }
  34
  35     if (NULL == m_pConnection)
  36     {
  37         LOG_ERROR("DBUSMessageHandler","Connection is null");
  38         exit(1);
  39     }
  40
  41     int ret = dbus_bus_request_name(m_pConnection, DBUS_SERVICE_PREFIX, DBUS_NAME_FLAG_REPLACE_EXISTING, &m_err);
  42
  43     if (dbus_error_is_set(&m_err))
  44     {
  45         LOG_ERROR("DBUSMessageHandler", "Name Error "<< m_err.message);
  46         dbus_error_free(&m_err);
  47     }
  48
  49     if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret)
  50     {
  51         LOG_ERROR("DBUSMessageHandler", "Not Primary Owner "<< ret);
  52         exit(1);
  53     }
  54 }
  55
  56 DBUSMessageHandler::~DBUSMessageHandler()
  57 {
  58     DBusError err;
  59     dbus_error_init(&err);
  60     bool errorset = dbus_error_is_set(&err);
  61     if (errorset)
  62     {
  63         LOG_ERROR("DBUSMessageHandler","there was an dbus error");
  64     }
  65     dbus_connection_unregister_object_path(m_pConnection,DBUS_SERVICE_OBJECT_PATH);
  66
  67     LOG_INFO("DBUSMessageHandler","Ask about owner name");
  68     dbus_bus_name_has_owner(m_pConnection, DBUS_SERVICE_PREFIX, &err);
  69     errorset = dbus_error_is_set(&err);
  70     if (errorset)
  71     {
  72         LOG_ERROR("DBUSMessageHandler","there was an dbus error");
  73     }
  74     dbus_error_init(&err);
  75     dbus_bus_release_name(m_pConnection, DBUS_SERVICE_PREFIX, &err);
  76 }
  77
  78 bool DBUSMessageHandler::registerMessageFilter(  DBusHandleMessageFunction fMessageFunc,
  79                                                  void* comInstance )
  80 {
  81     bool result = true;
  82     if ( !dbus_connection_add_filter ( m_pConnection , fMessageFunc, comInstance, NULL) )
  83     {
  84         result = false;
  85     }
  86     return result;
  87 }
  88
  89 void DBUSMessageHandler::unregisterMessageFilter(  DBusHandleMessageFunction fMessageFunc,
  90                                                  void* comInstance )
  91 {
  92     dbus_connection_remove_filter ( m_pConnection , fMessageFunc, comInstance);
  93 }
  94
  95 bool DBUSMessageHandler::registerPathFunction(  DBusObjectPathMessageFunction fMessageFunc,
  96                                                 DBusObjectPathUnregisterFunction fUnregisterFunc,
  97                                                 void* comInstance)
  98 {
  99     bool result = true;
 100     m_objectPathVTable.unregister_function = fUnregisterFunc;
 101     m_objectPathVTable.message_function = fMessageFunc;
 102
 103     if (!dbus_connection_register_object_path(m_pConnection,DBUS_SERVICE_OBJECT_PATH,&m_objectPathVTable, comInstance) )
 104     {
 105         result = false;
 106     }
 107     return result;
 108 }
 109
 110 void DBUSMessageHandler::initReceive(DBusMessage* msg)
 111 {
 112     LOG_DEBUG("DBUSMessageHandler","Message " << dbus_message_get_member(msg) << " was sent by " << dbus_message_get_sender(msg) );
 113     if (!dbus_message_iter_init(msg, &m_MessageIter))
 114     {
 115         LOG_ERROR("DBUSMessageHandler", "Message has no arguments!");
 116     }
 117 }
 118
 119 void DBUSMessageHandler::initReply(DBusMessage* msg)
 120 {
 121     // create a reply from the message
 122     m_pReply = dbus_message_new_method_return(msg);
 123     dbus_message_iter_init_append(m_pReply, &m_MessageIter);
 124 }
 125
 126 void DBUSMessageHandler::closeReply()
 127 {
 128     // send the reply && flush the connection
 129     if (!dbus_connection_send(m_pConnection, m_pReply, &m_serial))
 130     {
 131         LOG_ERROR("DBUSMessageHandler", "Out Of Memory!");
 132         exit(1);
 133     }
 134     LOG_DEBUG("DBUSMessageHandler", "sending reply");
 135     dbus_connection_flush(m_pConnection);
 136
 137     // free the reply
 138     dbus_message_unref(m_pReply);
 139     m_pReply = NULL;
 140 }
 141
 142 void DBUSMessageHandler::ReplyError(DBusMessage* msg, const char* errorname, const char* errorMsg)
 143 {
 144     m_pReply = dbus_message_new_error(msg, errorname, errorMsg);
 145     // send the reply && flush the connection
 146     if (!dbus_connection_send(m_pConnection, m_pReply, &m_serial))
 147     {
 148         LOG_ERROR("DBUSMessageHandler", "Out Of Memory!");
 149         exit(1);
 150     }
 151     LOG_INFO("DBUSMessageHandler", "sending reply with error");
 152     dbus_connection_flush(m_pConnection);
 153
 154     // free the reply
 155     dbus_message_unref(m_pReply);
 156     m_pReply = NULL;
 157 }
 158
 159 char* DBUSMessageHandler::getString()
 160 {
 161     char* param;
 162
 163     if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&m_MessageIter))
 164     {
 165         LOG_ERROR("DBUSMessageHandler", "Argument is not string!");
 166     }
 167     else
 168     {
 169         dbus_message_iter_get_basic(&m_MessageIter, &param);
 170         dbus_message_iter_next(&m_MessageIter);
 171     }
 172     return param;
 173 }
 174
 175 dbus_bool_t DBUSMessageHandler::getBool()
 176 {
 177     dbus_bool_t boolparam;
 178
 179     if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&m_MessageIter))
 180     {
 181         LOG_ERROR("DBUSMessageHandler", "Argument is not bool!");
 182     }
 183     else
 184     {
 185         dbus_message_iter_get_basic(&m_MessageIter, &boolparam);
 186         dbus_message_iter_next(&m_MessageIter);
 187     }
 188     return boolparam;
 189 }
 190
 191 char DBUSMessageHandler::getByte()
 192 {
 193     char param;
 194
 195     if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&m_MessageIter))
 196     {
 197         LOG_ERROR("DBUSMessageHandler", "Argument is not byte!");
 198     }
 199     else
 200     {
 201         dbus_message_iter_get_basic(&m_MessageIter, &param);
 202         dbus_message_iter_next(&m_MessageIter);
 203     }
 204     return param;
 205 }
 206
 207 dbus_uint32_t DBUSMessageHandler::getUInt()
 208 {
 209     dbus_uint32_t param;
 210
 211     if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&m_MessageIter))
 212     {
 213         LOG_ERROR("DBUSMessageHandler", "Argument is not uint32!");
 214     }
 215     else
 216     {
 217         dbus_message_iter_get_basic(&m_MessageIter, &param);
 218         dbus_message_iter_next(&m_MessageIter);
 219     }
 220     return param;
 221 }
 222
 223 double DBUSMessageHandler::getDouble()
 224 {
 225     double param;
 226
 227     if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&m_MessageIter))
 228     {
 229         LOG_ERROR("DBUSMessageHandler","Argument is not double!");
 230     }
 231     else
 232     {
 233         dbus_message_iter_get_basic(&m_MessageIter, &param);
 234         dbus_message_iter_next(&m_MessageIter);
 235     }
 236     return param;
 237 }
 238
 239 void DBUSMessageHandler::getArrayOfUInt(int* pLength, unsigned int** ppArray)
 240 {
 241     if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&m_MessageIter))
 242     {
 243         LOG_ERROR("DBUSMessageHandler","Argument is not an array!");
 244         return;
 245     }
 246
 247     DBusMessageIter arrayIter;
 248     dbus_message_iter_recurse(&m_MessageIter, &arrayIter);
 249
 250     uint* localArray;
 251     dbus_message_iter_get_fixed_array(&arrayIter, &localArray, pLength);
 252
 253     *ppArray = new uint[*pLength];
 254     for (int i = 0; i < *pLength; i++)
 255     {
 256         (*ppArray)[i] = localArray[i];
 257     }
 258 }
 259
 260 void DBUSMessageHandler::getArrayOfString(std::vector<std::string>* stringVector)
 261 {
 262     if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&m_MessageIter))
 263     {
 264         LOG_ERROR("DBUSMessageHandler", "Argument is not an array!");
 265         return;
 266     }
 267
 268     DBusMessageIter arrayIter;
 269     dbus_message_iter_recurse(&m_MessageIter, &arrayIter);
 270     bool hasNext = true;
 271     while (hasNext)
 272     {
 273         if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&arrayIter))
 274         {
 275             LOG_ERROR("DBUSMessageHandler", "Argument is not an string!");
 276         }
 277         char* param;
 278         dbus_message_iter_get_basic(&arrayIter, &param);
 279
 280         stringVector->push_back(std::string(param));
 281
 282         if (dbus_message_iter_has_next(&arrayIter))
 283         {
 284             dbus_message_iter_next(&arrayIter);
 285         }
 286         else
 287         {
 288             hasNext = false;
 289         }
 290     }
 291 }
 292
 293 void DBUSMessageHandler::appendBool(dbus_bool_t toAppend)
 294 {
 295     if (!dbus_message_iter_append_basic(&m_MessageIter, DBUS_TYPE_BOOLEAN, &toAppend))
 296     {
 297         LOG_ERROR("DBUSMessageHandler", "Out Of Memory!");
 298         exit(1);
 299     }
 300 }
 301
 302 void DBUSMessageHandler::appendUInt(dbus_uint32_t toAppend)
 303 {
 304     if (!dbus_message_iter_append_basic(&m_MessageIter, DBUS_TYPE_UINT32, &toAppend))
 305     {
 306         LOG_ERROR("DBUSMessageHandler", "Out Of Memory!");
 307         exit(1);
 308     }
 309 }
 310
 311 void DBUSMessageHandler::appendDouble(double toAppend)
 312 {
 313     if (!dbus_message_iter_append_basic(&m_MessageIter, DBUS_TYPE_DOUBLE, &toAppend))
 314     {
 315         LOG_ERROR("DBUSMessageHandler", "Out Of Memory!");
 316         exit(1);
 317     }
 318 }
 319
 320 void DBUSMessageHandler::appendByte(char toAppend)
 321 {
 322     if (!dbus_message_iter_append_basic(&m_MessageIter, DBUS_TYPE_BYTE, &toAppend))
 323     {
 324         LOG_ERROR("DBUSMessageHandler", "Out Of Memory!");
 325         exit(1);
 326     }
 327 }
 328
 329 void DBUSMessageHandler::appendArrayOfUInt(unsigned int length, unsigned int *IDs)
 330 {
 331     DBusMessageIter arrayIter;
 332     dbus_message_iter_open_container(&m_MessageIter, DBUS_TYPE_ARRAY, "u", &arrayIter);
 333     for(unsigned int i = 0; i < length; i++)
 334     {
 335         dbus_message_iter_append_basic(&arrayIter, DBUS_TYPE_UINT32, &IDs[i]);
 336     }
 337     dbus_message_iter_close_container(&m_MessageIter, &arrayIter);
 338 }