dbus/method.c

   1 /*
   2  *   LASH
   3  *
   4  *   Copyright (C) 2008 Juuso Alasuutari <juuso.alasuutari@gmail.com>
   5  *   Copyright (C) 2008 Nedko Arnaudov
   6  *
   7  *   This program is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU General Public License as published by
   9  *   the Free Software Foundation; either version 2 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This program is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with this program; if not, write to the Free Software
  19  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "common/safety.h"
  23 #include "common/debug.h"
  24
  25 #include "dbus/method.h"
  26 #include "dbus/service.h"
  27
  28 /*
  29  * Construct a void method return.
  30  *
  31  * The operation can only fail due to lack of memory, in which case
  32  * there's no sense in trying to construct an error return. Instead,
  33  * call->reply will be set to NULL and handled in send_method_return().
  34  */
  35 void
  36 method_return_new_void(method_call_t *call)
  37 {
  38         if (!(call->reply = dbus_message_new_method_return(call->message))) {
  39                 lash_error("Ran out of memory trying to construct method return");
  40         }
  41 }
  42
  43 /*
  44  * Construct a method return which holds a single argument or, if
  45  * the type parameter is DBUS_TYPE_INVALID, no arguments at all
  46  * (a void message).
  47  *
  48  * The operation can only fail due to lack of memory, in which case
  49  * there's no sense in trying to construct an error return. Instead,
  50  * call->reply will be set to NULL and handled in send_method_return().
  51  */
  52 void
  53 method_return_new_single(method_call_t *call,
  54                          int            type,
  55                          const void    *arg)
  56 {
  57         if (!call || !arg) {
  58                 lash_error("Invalid arguments");
  59                 return;
  60         }
  61
  62         call->reply = dbus_message_new_method_return(call->message);
  63
  64         if (!call->reply)
  65                 goto fail_no_mem;
  66
  67         /* Void method return requested by caller. */
  68         // TODO: do we really need this?
  69         if (type == DBUS_TYPE_INVALID)
  70                 return;
  71
  72         /* Prevent crash on NULL input string. */
  73         if (type == DBUS_TYPE_STRING && !(*((const char **) arg)))
  74                 *((const char **) arg) = "";
  75
  76         DBusMessageIter iter;
  77
  78         dbus_message_iter_init_append(call->reply, &iter);
  79
  80         if (dbus_message_iter_append_basic(&iter, type, arg))
  81                 return;
  82
  83         dbus_message_unref(call->reply);
  84         call->reply = NULL;
  85
  86 fail_no_mem:
  87         lash_error("Ran out of memory trying to construct method return");
  88 }
  89
  90 void
  91 method_return_new_valist(method_call_t *call,
  92                          int            type,
  93                                         ...)
  94 {
  95         if (!call) {
  96                 lash_error("Call pointer is NULL");
  97                 return;
  98         }
  99
 100         if (type == DBUS_TYPE_INVALID) {
 101                 lash_error("No argument(s) supplied");
 102                 return;
 103         }
 104
 105         va_list argp;
 106
 107         call->reply = dbus_message_new_method_return(call->message);
 108         if (!call->reply)
 109                 goto fail_no_mem;
 110
 111         va_start(argp, type);
 112
 113         if (dbus_message_append_args_valist(call->reply, type, argp)) {
 114                 va_end(argp);
 115                 return;
 116         }
 117
 118         va_end(argp);
 119
 120         dbus_message_unref(call->reply);
 121         call->reply = NULL;
 122
 123 fail_no_mem:
 124         lash_error("Ran out of memory trying to construct method return");
 125 }
 126
 127 /*
 128  * Send a method call.
 129  */
 130 bool
 131 method_send(method_msg_t *call,
 132             bool          will_block)
 133 {
 134         if (!call->message) {
 135                 lash_error("Cannot send method call: Message is NULL");
 136                 return false;
 137         }
 138
 139         DBusPendingCall *pending = NULL;
 140         bool retval;
 141
 142         if (!dbus_connection_send_with_reply(call->service->connection,
 143                                              call->message, &pending, -1)) {
 144                 lash_error("Ran out of memory trying to queue "
 145                            "method call");
 146                 retval = false;
 147                 /* Never wait for a reply if sending failed */
 148                 will_block = false;
 149         } else {
 150                 if (pending)
 151                         dbus_pending_call_set_notify(pending,
 152                                                      call->return_handler,
 153                                                      call->context, NULL);
 154                 dbus_connection_flush(call->service->connection);
 155                 retval = true;
 156         }
 157
 158         dbus_message_unref(call->message);
 159         call->message = NULL;
 160
 161         if (will_block && pending) {
 162                 lash_debug("Blocking until a return arrives");
 163                 dbus_pending_call_block(pending);
 164         }
 165
 166         return retval;
 167 }
 168
 169 /*
 170  * Send a method return.
 171  *
 172  * If call->reply is NULL, i.e. a previous attempt to construct
 173  * a return has failed, attempt to send a void return.
 174  */
 175 void
 176 method_return_send(method_call_t *call)
 177 {
 178         if (call->reply) {
 179         retry_send:
 180                 if (!dbus_connection_send(call->connection, call->reply, NULL))
 181                         lash_error("Ran out of memory trying to queue "
 182                                    "method return");
 183                 else
 184                         dbus_connection_flush(call->connection);
 185
 186                 dbus_message_unref(call->reply);
 187                 call->reply = NULL;
 188         } else {
 189                 lash_debug("Message was NULL, trying to construct a void return");
 190
 191                 if ((call->reply = dbus_message_new_method_return(call->message))) {
 192                         lash_debug("Constructed a void return, trying to queue it");
 193                         goto retry_send;
 194                 } else {
 195                         lash_error("Failed to construct method return!");
 196                 }
 197         }
 198 }
 199
 200 bool
 201 method_return_verify(DBusMessage  *msg,
 202                      const char  **str)
 203 {
 204         if (!msg || dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_ERROR)
 205                 return true;
 206
 207         DBusError err;
 208         const char *ptr;
 209
 210         dbus_error_init(&err);
 211
 212         if (!dbus_message_get_args(msg, &err,
 213                                    DBUS_TYPE_STRING, &ptr,
 214                                    DBUS_TYPE_INVALID)) {
 215                 lash_error("Cannot read description from D-Bus error message: %s ",
 216                            err.message);
 217                 dbus_error_free(&err);
 218                 ptr = NULL;
 219         }
 220
 221         if (str)
 222                 *str = ptr;
 223
 224         return false;
 225 }
 226
 227 /*
 228  * Append a variant type to a D-Bus message.
 229  * Return false if something fails, true otherwise.
 230  */
 231 bool
 232 method_iter_append_variant(DBusMessageIter *iter,
 233                            int              type,
 234                            const void      *arg)
 235 {
 236         DBusMessageIter sub_iter;
 237         char s[2];
 238
 239         s[0] = (char) type;
 240         s[1] = '\0';
 241
 242         /* Open a variant container. */
 243         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 244                                               (const char *) s, &sub_iter))
 245                 return false;
 246
 247         /* Append the supplied value. */
 248         if (!dbus_message_iter_append_basic(&sub_iter, type, arg)) {
 249                 dbus_message_iter_close_container(iter, &sub_iter);
 250                 return false;
 251         }
 252
 253         /* Close the container. */
 254         if (!dbus_message_iter_close_container(iter, &sub_iter))
 255                 return false;
 256
 257         return true;
 258 }
 259
 260 static __inline__ bool
 261 method_iter_append_variant_raw(DBusMessageIter *iter,
 262                                const void      *buf,
 263                                int              len)
 264 {
 265         DBusMessageIter variant_iter, array_iter;
 266
 267         /* Open a variant container. */
 268         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 269                                               "ay", &variant_iter))
 270                 return false;
 271
 272         /* Open an array container. */
 273         if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
 274                                               "y", &array_iter))
 275                 goto fail;
 276
 277         /* Append the supplied data. */
 278         if (!dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE, buf, len)) {
 279                 dbus_message_iter_close_container(&variant_iter, &array_iter);
 280                 goto fail;
 281         }
 282
 283         /* Close the containers. */
 284         if (!dbus_message_iter_close_container(&variant_iter, &array_iter))
 285                 goto fail;
 286         else if (!dbus_message_iter_close_container(iter, &variant_iter))
 287                 return false;
 288
 289         return true;
 290
 291 fail:
 292         dbus_message_iter_close_container(iter, &variant_iter);
 293         return false;
 294 }
 295
 296 bool
 297 method_iter_append_dict_entry(DBusMessageIter *iter,
 298                               int              type,
 299                               const char      *key,
 300                               const void      *value,
 301                               int              length)
 302 {
 303         DBusMessageIter dict_iter;
 304
 305         if (!dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY,
 306                                               NULL, &dict_iter))
 307                 return false;
 308
 309         if (!dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &key))
 310                 goto fail;
 311
 312         if (type == '-') {
 313                 if (!method_iter_append_variant_raw(&dict_iter, value, length))
 314                         goto fail;
 315         } else if (!method_iter_append_variant(&dict_iter, type, value))
 316                 goto fail;
 317
 318         if (!dbus_message_iter_close_container(iter, &dict_iter))
 319                 return false;
 320
 321         return true;
 322
 323 fail:
 324         dbus_message_iter_close_container(iter, &dict_iter);
 325         return false;
 326 }
 327
 328 void
 329 method_default_handler(DBusPendingCall *pending,
 330                        void            *data)
 331 {
 332         DBusMessage *msg = dbus_pending_call_steal_reply(pending);
 333
 334         if (msg) {
 335                 const char *err_str;
 336
 337                 if (!method_return_verify(msg, &err_str))
 338                         lash_error("%s", err_str);
 339
 340                 dbus_message_unref(msg);
 341         } else
 342                 lash_error("Cannot get method return from pending call");
 343
 344         dbus_pending_call_unref(pending);
 345 }
 346
 347 bool
 348 method_call_init(method_msg_t                  *call,
 349                  service_t                     *service,
 350                  void                          *return_context,
 351                  DBusPendingCallNotifyFunction  return_handler,
 352                  const char                    *destination,
 353                  const char                    *path,
 354                  const char                    *interface,
 355                  const char                    *method)
 356 {
 357         if (!call || !service || !service->connection
 358             || !destination || !path || !method) {
 359                 lash_error("Invalid arguments");
 360                 return false;
 361         }
 362
 363         if (!interface)
 364                 interface = "";
 365
 366         call->message = dbus_message_new_method_call(destination, path,
 367                                                      interface, method);
 368         if (!call->message) {
 369                 lash_error("Ran out of memory trying to create "
 370                            "new method call");
 371                 return false;
 372         }
 373
 374         call->service = service;
 375         call->context = return_context;
 376         call->return_handler = return_handler;
 377
 378         if (!return_handler)
 379                 dbus_message_set_no_reply(call->message, true);
 380
 381         return true;
 382 }
 383
 384 bool
 385 method_call_new_void(service_t                     *service,
 386                      void                          *return_context,
 387                      DBusPendingCallNotifyFunction  return_handler,
 388                      bool                           will_block,
 389                      const char                    *destination,
 390                      const char                    *path,
 391                      const char                    *interface,
 392                      const char                    *method)
 393 {
 394         method_msg_t call;
 395
 396         if (method_call_init(&call, service, return_context, return_handler,
 397                              destination, path, interface, method))
 398                 return method_send(&call, will_block);
 399
 400         return false;
 401 }
 402
 403 bool
 404 method_call_new_single(service_t                     *service,
 405                        void                          *return_context,
 406                        DBusPendingCallNotifyFunction  return_handler,
 407                        bool                           will_block,
 408                        const char                    *destination,
 409                        const char                    *path,
 410                        const char                    *interface,
 411                        const char                    *method,
 412                        int                            type,
 413                        const void                    *arg)
 414 {
 415         if (type == DBUS_TYPE_INVALID || !arg) {
 416                 lash_error("No argument supplied");
 417                 return false;
 418         }
 419
 420         method_msg_t call;
 421         DBusMessageIter iter;
 422
 423         if (!method_call_init(&call, service, return_context, return_handler,
 424                               destination, path, interface, method))
 425                 return false;
 426
 427         dbus_message_iter_init_append(call.message, &iter);
 428
 429         if (dbus_message_iter_append_basic(&iter, type, arg)) {
 430                 return method_send(&call, will_block);
 431         }
 432
 433         lash_error("Ran out of memory trying to append method call argument");
 434
 435         dbus_message_unref(call.message);
 436         call.message = NULL;
 437
 438         return false;
 439 }
 440
 441 bool
 442 method_call_new_valist(service_t                     *service,
 443                        void                          *return_context,
 444                        DBusPendingCallNotifyFunction  return_handler,
 445                        bool                           will_block,
 446                        const char                    *destination,
 447                        const char                    *path,
 448                        const char                    *interface,
 449                        const char                    *method,
 450                        int                            type,
 451                                                        ...)
 452 {
 453         if (type == DBUS_TYPE_INVALID) {
 454                 lash_error("No argument(s) supplied");
 455                 return false;
 456         }
 457
 458         method_msg_t call;
 459         va_list argp;
 460
 461         if (!method_call_init(&call, service, return_context, return_handler,
 462                               destination, path, interface, method))
 463                 return false;
 464
 465         va_start(argp, type);
 466
 467         if (dbus_message_append_args_valist(call.message, type, argp)) {
 468                 va_end(argp);
 469                 return method_send(&call, will_block);
 470         }
 471
 472         va_end(argp);
 473
 474         lash_error("Ran out of memory trying to append "
 475                    "method call argument(s)");
 476
 477         dbus_message_unref(call.message);
 478         call.message = NULL;
 479
 480         return false;
 481 }
 482
 483 bool
 484 method_iter_get_args(DBusMessageIter *iter,
 485                                       ...)
 486 {
 487         if (!iter) {
 488                 lash_error("Iterator pointer is NULL");
 489                 return false;
 490         }
 491
 492         va_list argp;
 493         int expected_type, type, n = 0;
 494         void *ptr;
 495
 496         va_start(argp, iter);
 497
 498         while ((expected_type = va_arg(argp, int)) != DBUS_TYPE_INVALID) {
 499                 ptr = va_arg(argp, void *);
 500
 501                 if ((type = dbus_message_iter_get_arg_type(iter))
 502                     == DBUS_TYPE_INVALID) {
 503                         lash_error("Insufficient arguments");
 504                         va_end(argp);
 505                         return false;
 506                 }
 507
 508                 if (type != expected_type) {
 509                         lash_error("Invalid type for argument %i", n);
 510                         va_end(argp);
 511                         return false;
 512                 }
 513
 514                 if (ptr)
 515                         dbus_message_iter_get_basic(iter, ptr);
 516
 517                 dbus_message_iter_next(iter);
 518
 519                 ++n;
 520         }
 521
 522         va_end(argp);
 523
 524         return true;
 525 }
 526
 527 bool
 528 method_iter_get_dict_entry(DBusMessageIter  *iter,
 529                            const char      **key_ptr,
 530                            void             *value_ptr,
 531                            int              *type_ptr,
 532                            int              *size_ptr)
 533 {
 534         if (!iter || !key_ptr || !value_ptr || !type_ptr) {
 535                 lash_error("Invalid arguments");
 536                 return false;
 537         }
 538
 539         DBusMessageIter dict_iter, variant_iter;
 540
 541         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_DICT_ENTRY) {
 542                 lash_error("Iterator does not point to a dict entry container");
 543                 return false;
 544         }
 545
 546         dbus_message_iter_recurse(iter, &dict_iter);
 547
 548         if (dbus_message_iter_get_arg_type(&dict_iter) != DBUS_TYPE_STRING) {
 549                 lash_error("Cannot find key in dict entry container");
 550                 return false;
 551         }
 552
 553         dbus_message_iter_get_basic(&dict_iter, key_ptr);
 554
 555         if (!dbus_message_iter_next(&dict_iter)
 556             || dbus_message_iter_get_arg_type(&dict_iter) != DBUS_TYPE_VARIANT) {
 557                 lash_error("Cannot find variant container in dict entry");
 558                 return false;
 559         }
 560
 561         dbus_message_iter_recurse(&dict_iter, &variant_iter);
 562
 563         *type_ptr = dbus_message_iter_get_arg_type(&variant_iter);
 564         if (*type_ptr == DBUS_TYPE_INVALID) {
 565                 lash_error("Cannot find value in variant container");
 566                 return false;
 567         }
 568
 569         if (*type_ptr == DBUS_TYPE_ARRAY) {
 570                 DBusMessageIter array_iter;
 571                 int n;
 572
 573                 if (dbus_message_iter_get_element_type(&variant_iter)
 574                     != DBUS_TYPE_BYTE) {
 575                         lash_error("Dict entry value is a non-byte array");
 576                         return false;
 577                 }
 578                 *type_ptr = '-';
 579
 580                 dbus_message_iter_recurse(&variant_iter, &array_iter);
 581                 dbus_message_iter_get_fixed_array(&array_iter, value_ptr, &n);
 582
 583                 if (size_ptr)
 584                         *size_ptr = n;
 585         } else
 586                 dbus_message_iter_get_basic(&variant_iter, value_ptr);
 587
 588         return true;
 589 }
 590
 591 /* EOF */