xbmc/platform/linux/DBusMessage.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8 #include "DBusMessage.h"
   9
  10 #include "DBusUtil.h"
  11 #include "settings/AdvancedSettings.h"
  12 #include "utils/log.h"
  13
  14 CDBusMessage::CDBusMessage(const char *destination, const char *object, const char *interface, const char *method)
  15 {
  16   m_message.reset(dbus_message_new_method_call(destination, object, interface, method));
  17   if (!m_message)
  18   {
  19     // Fails only due to memory allocation failure
  20     throw std::runtime_error("dbus_message_new_method_call");
  21   }
  22   m_haveArgs = false;
  23
  24   CLog::Log(LOGDEBUG, LOGDBUS, "DBus: Creating message to {} on {} with interface {} and method {}",
  25             destination, object, interface, method);
  26 }
  27
  28 CDBusMessage::CDBusMessage(const std::string& destination, const std::string& object, const std::string& interface, const std::string& method)
  29 : CDBusMessage(destination.c_str(), object.c_str(), interface.c_str(), method.c_str())
  30 {
  31 }
  32
  33 void DBusMessageDeleter::operator()(DBusMessage* message) const
  34 {
  35   dbus_message_unref(message);
  36 }
  37
  38 void CDBusMessage::AppendObjectPath(const char *object)
  39 {
  40   AppendWithType(DBUS_TYPE_OBJECT_PATH, &object);
  41 }
  42
  43 template<>
  44 void CDBusMessage::AppendArgument<bool>(const bool arg)
  45 {
  46   // dbus_bool_t width might not match C++ bool width
  47   dbus_bool_t convArg = (arg == true);
  48   AppendWithType(DBUS_TYPE_BOOLEAN, &convArg);
  49 }
  50
  51 template<>
  52 void CDBusMessage::AppendArgument<std::string>(const std::string arg)
  53 {
  54   AppendArgument(arg.c_str());
  55 }
  56
  57 void CDBusMessage::AppendArgument(const char **arrayString, unsigned int length)
  58 {
  59   PrepareArgument();
  60   DBusMessageIter sub;
  61   if (!dbus_message_iter_open_container(&m_args, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &sub))
  62   {
  63     throw std::runtime_error("dbus_message_iter_open_container");
  64   }
  65
  66   for (unsigned int i = 0; i < length; i++)
  67   {
  68     if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &arrayString[i]))
  69     {
  70       throw std::runtime_error("dbus_message_iter_append_basic");
  71     }
  72   }
  73
  74   if (!dbus_message_iter_close_container(&m_args, &sub))
  75   {
  76     throw std::runtime_error("dbus_message_iter_close_container");
  77   }
  78 }
  79
  80 void CDBusMessage::AppendWithType(int type, const void* value)
  81 {
  82   PrepareArgument();
  83   if (!dbus_message_iter_append_basic(&m_args, type, value))
  84   {
  85     throw std::runtime_error("dbus_message_iter_append_basic");
  86   }
  87 }
  88
  89 DBusMessageIter * CDBusMessage::GetArgumentIter() {
  90   PrepareArgument();
  91   return &m_args;
  92 }
  93
  94 DBusMessage *CDBusMessage::SendSystem()
  95 {
  96   return Send(DBUS_BUS_SYSTEM);
  97 }
  98
  99 DBusMessage *CDBusMessage::SendSession()
 100 {
 101   return Send(DBUS_BUS_SESSION);
 102 }
 103
 104 DBusMessage *CDBusMessage::SendSystem(CDBusError& error)
 105 {
 106   return Send(DBUS_BUS_SYSTEM, error);
 107 }
 108
 109 DBusMessage *CDBusMessage::SendSession(CDBusError& error)
 110 {
 111   return Send(DBUS_BUS_SESSION, error);
 112 }
 113
 114 bool CDBusMessage::SendAsyncSystem()
 115 {
 116   return SendAsync(DBUS_BUS_SYSTEM);
 117 }
 118
 119 bool CDBusMessage::SendAsyncSession()
 120 {
 121   return SendAsync(DBUS_BUS_SESSION);
 122 }
 123
 124 DBusMessage *CDBusMessage::Send(DBusBusType type)
 125 {
 126   CDBusError error;
 127   CDBusConnection con;
 128   if (!con.Connect(type))
 129     return nullptr;
 130
 131   DBusMessage *returnMessage = Send(con, error);
 132
 133   if (error)
 134     error.Log();
 135
 136   return returnMessage;
 137 }
 138
 139 DBusMessage *CDBusMessage::Send(DBusBusType type, CDBusError& error)
 140 {
 141   CDBusConnection con;
 142   if (!con.Connect(type, error))
 143     return nullptr;
 144
 145   DBusMessage *returnMessage = Send(con, error);
 146
 147   return returnMessage;
 148 }
 149
 150 bool CDBusMessage::SendAsync(DBusBusType type)
 151 {
 152   CDBusConnection con;
 153   if (!con.Connect(type))
 154     return false;
 155
 156   return dbus_connection_send(con, m_message.get(), nullptr);
 157 }
 158
 159 DBusMessage *CDBusMessage::Send(DBusConnection *con, CDBusError& error)
 160 {
 161   m_reply.reset(dbus_connection_send_with_reply_and_block(con, m_message.get(), -1, error));
 162   return m_reply.get();
 163 }
 164
 165 void CDBusMessage::PrepareArgument()
 166 {
 167   if (!m_haveArgs)
 168     dbus_message_iter_init_append(m_message.get(), &m_args);
 169
 170   m_haveArgs = true;
 171 }
 172
 173 bool CDBusMessage::InitializeReplyIter(DBusMessageIter* iter)
 174 {
 175   if (!m_reply)
 176   {
 177     throw std::logic_error("Cannot get reply arguments of message that does not have reply");
 178   }
 179   if (!dbus_message_iter_init(m_reply.get(), iter))
 180   {
 181     CLog::Log(LOGWARNING, "Tried to obtain reply arguments from message that has zero arguments");
 182     return false;
 183   }
 184   return true;
 185 }
 186
 187 bool CDBusMessage::CheckTypeAndGetValue(DBusMessageIter* iter, int expectType, void* dest)
 188 {
 189   const int haveType = dbus_message_iter_get_arg_type(iter);
 190   if (haveType != expectType)
 191   {
 192     CLog::Log(LOGDEBUG, "DBus argument type mismatch: expected {}, got {}", expectType, haveType);
 193     return false;
 194   }
 195
 196   dbus_message_iter_get_basic(iter, dest);
 197   return true;
 198 }