_dbus_bindings/message-impl.h

   1 /* Implementation of D-Bus Message and subclasses (but see message-get-args.h
   2  * and message-append.h for unserialization and serialization code).
   3  *
   4  * Copyright (C) 2006 Collabora Ltd.
   5  *
   6  * Licensed under the Academic Free License version 2.1
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  *
  24  */
  25
  26 #ifdef USING_DBG
  27 static void _dbg_dump_message(DBusMessage *message)
  28 {
  29     const char *s;
  30     fprintf(stderr, "DBusMessage at %p\n", message);
  31
  32     s = dbus_message_get_destination(message);
  33     if (!s) s = "(null)";
  34     fprintf(stderr, "\tdestination %s\n", s);
  35
  36     s = dbus_message_get_interface(message);
  37     if (!s) s = "(null)";
  38     fprintf(stderr, "\tinterface %s\n", s);
  39
  40     s = dbus_message_get_member(message);
  41     if (!s) s = "(null)";
  42     fprintf(stderr, "\tmember %s\n", s);
  43
  44     s = dbus_message_get_path(message);
  45     if (!s) s = "(null)";
  46     fprintf(stderr, "\tpath %s\n", s);
  47 }
  48 #   define DBG_DUMP_MESSAGE(x) _dbg_dump_message(x)
  49 #else
  50 #   define DBG_DUMP_MESSAGE(x) do {} while(0)
  51 #endif
  52
  53 static PyTypeObject MessageType, SignalMessageType, ErrorMessageType;
  54 static PyTypeObject MethodReturnMessageType, MethodCallMessageType;
  55
  56 static inline int Message_Check (PyObject *o)
  57 {
  58     return (o->ob_type == &MessageType)
  59             || PyObject_IsInstance(o, (PyObject *)&MessageType);
  60 }
  61
  62 typedef struct {
  63     PyObject_HEAD
  64     DBusMessage *msg;
  65 } Message;
  66
  67 PyDoc_STRVAR(Message_tp_doc,
  68 "A message to be sent or received over a D-Bus Connection.\n");
  69
  70 static void Message_tp_dealloc (Message *self)
  71 {
  72     if (self->msg) {
  73         dbus_message_unref (self->msg);
  74     }
  75     self->ob_type->tp_free ((PyObject *)self);
  76 }
  77
  78 static PyObject *
  79 Message_tp_new (PyTypeObject *type, PyObject *args, PyObject *kwargs)
  80 {
  81     Message *self;
  82
  83     self = (Message *)type->tp_alloc (type, 0);
  84     if (!self) return NULL;
  85     self->msg = NULL;
  86     return (PyObject *)self;
  87 }
  88
  89 PyDoc_STRVAR(MethodCallMessage_tp_doc, "A method-call message.\n\n"
  90 "MethodCallMessage(destination: str or None, path: str,\n"
  91 "                  interface: str or None, method: str)\n");
  92 static int
  93 MethodCallMessage_tp_init (Message *self, PyObject *args, PyObject *kwargs)
  94 {
  95     const char *destination, *path, *interface, *method;
  96     static char *kwlist[] = {"destination", "path", "interface", "method", NULL};
  97
  98     if (!PyArg_ParseTupleAndKeywords (args, kwargs, "zszs:__init__", kwlist,
  99                                       &destination, &path, &interface,
 100                                       &method)) {
 101         return -1;
 102     }
 103     if (destination && !_validate_bus_name(destination, 1, 1)) return -1;
 104     if (!_validate_object_path(path)) return -1;
 105     if (interface && !_validate_interface_name(interface)) return -1;
 106     if (!_validate_member_name(method)) return -1;
 107     if (self->msg) {
 108         dbus_message_unref (self->msg);
 109         self->msg = NULL;
 110     }
 111     self->msg = dbus_message_new_method_call (destination, path, interface,
 112                                               method);
 113     if (!self->msg) {
 114         PyErr_NoMemory();
 115         return -1;
 116     }
 117     return 0;
 118 }
 119
 120 PyDoc_STRVAR(MethodReturnMessage_tp_doc, "A method-return message.\n\n"
 121 "MethodReturnMessage(method_call: MethodCallMessage)\n");
 122 static int
 123 MethodReturnMessage_tp_init (Message *self, PyObject *args, PyObject *kwargs)
 124 {
 125     Message *other;
 126     static char *kwlist[] = {"method_call", NULL};
 127
 128     if (!PyArg_ParseTupleAndKeywords (args, kwargs, "O!:__init__", kwlist,
 129                                       &MessageType, &other)) {
 130         return -1;
 131     }
 132     if (self->msg) {
 133         dbus_message_unref (self->msg);
 134         self->msg = NULL;
 135     }
 136     self->msg = dbus_message_new_method_return (other->msg);
 137     if (!self->msg) {
 138         PyErr_NoMemory();
 139         return -1;
 140     }
 141     return 0;
 142 }
 143
 144 PyDoc_STRVAR(SignalMessage_tp_doc, "A signal message.\n\n"
 145 "SignalMessage(path: str, interface: str, method: str)\n");
 146 static int
 147 SignalMessage_tp_init (Message *self, PyObject *args, PyObject *kwargs)
 148 {
 149     const char *path, *interface, *name;
 150     static char *kwlist[] = {"path", "interface", "name", NULL};
 151
 152     if (!PyArg_ParseTupleAndKeywords (args, kwargs, "sss:__init__", kwlist,
 153                                     &path, &interface, &name)) {
 154       return -1;
 155     }
 156     if (!_validate_object_path(path)) return -1;
 157     if (!_validate_interface_name(interface)) return -1;
 158     if (!_validate_member_name(name)) return -1;
 159     if (self->msg) {
 160         dbus_message_unref (self->msg);
 161         self->msg = NULL;
 162     }
 163     self->msg = dbus_message_new_signal (path, interface, name);
 164     if (!self->msg) {
 165         PyErr_NoMemory();
 166         return -1;
 167     }
 168     return 0;
 169 }
 170
 171 PyDoc_STRVAR(ErrorMessage_tp_doc, "An error message.\n\n"
 172 "ErrorMessage(reply_to: Message, error_name: str,\n"
 173 "             error_message: str or None)\n");
 174 static int
 175 ErrorMessage_tp_init (Message *self, PyObject *args, PyObject *kwargs)
 176 {
 177     Message *reply_to;
 178     const char *error_name, *error_message;
 179     static char *kwlist[] = {"reply_to", "error_name", "error_message", NULL};
 180
 181     if (!PyArg_ParseTupleAndKeywords (args, kwargs, "O!sz:__init__", kwlist,
 182                                       &MessageType, &reply_to, &error_name,
 183                                       &error_message)) {
 184         return -1;
 185     }
 186     if (!_validate_error_name(error_name)) return -1;
 187     if (self->msg) {
 188         dbus_message_unref (self->msg);
 189         self->msg = NULL;
 190     }
 191     self->msg = dbus_message_new_error (reply_to->msg, error_name, error_message);
 192     if (!self->msg) {
 193         PyErr_NoMemory();
 194         return -1;
 195     }
 196     return 0;
 197 }
 198
 199 static DBusMessage *
 200 Message_BorrowDBusMessage (PyObject *msg)
 201 {
 202     if (!Message_Check (msg)) {
 203         PyErr_SetString (PyExc_TypeError,
 204                        "A _dbus_bindings.Message instance is required");
 205         return NULL;
 206     }
 207     if (!((Message *)msg)->msg) {
 208         DBusException_UnusableMessage();
 209         return NULL;
 210     }
 211     return ((Message *)msg)->msg;
 212 }
 213
 214 static PyObject *
 215 Message_ConsumeDBusMessage (DBusMessage *msg)
 216 {
 217     PyTypeObject *type;
 218     Message *self;
 219
 220     switch (dbus_message_get_type (msg)) {
 221     case DBUS_MESSAGE_TYPE_METHOD_CALL:
 222         type = &MethodCallMessageType;
 223         break;
 224     case DBUS_MESSAGE_TYPE_METHOD_RETURN:
 225         type = &MethodReturnMessageType;
 226         break;
 227     case DBUS_MESSAGE_TYPE_ERROR:
 228         type = &ErrorMessageType;
 229         break;
 230     case DBUS_MESSAGE_TYPE_SIGNAL:
 231         type = &SignalMessageType;
 232         break;
 233     default:
 234         type = &MessageType;
 235     }
 236
 237     self = (Message *)(type->tp_new) (type, empty_tuple, NULL);
 238     if (!self) {
 239         dbus_message_unref(msg);
 240         return NULL;
 241     }
 242     self->msg = msg;
 243     return (PyObject *)self;
 244 }
 245
 246 PyDoc_STRVAR(Message_copy__doc__,
 247 "message.copy() -> Message (or subclass)\n"
 248 "Deep-copy the message, resetting the serial number to zero.\n");
 249 static PyObject *
 250 Message_copy (Message *self, PyObject *args)
 251 {
 252     DBusMessage *msg;
 253     if (!self->msg) return DBusException_UnusableMessage();
 254     msg = dbus_message_copy(self->msg);
 255     if (!msg) return PyErr_NoMemory();
 256     return Message_ConsumeDBusMessage(msg);
 257 }
 258
 259 PyDoc_STRVAR(Message_get_auto_start__doc__,
 260 "message.get_auto_start() -> bool\n"
 261 "Return true if this message will cause an owner for the destination name\n"
 262 "to be auto-started.\n");
 263 static PyObject *
 264 Message_get_auto_start (Message *self, PyObject *unused)
 265 {
 266     if (!self->msg) return DBusException_UnusableMessage();
 267     return PyBool_FromLong (dbus_message_get_auto_start (self->msg));
 268 }
 269
 270 PyDoc_STRVAR(Message_set_auto_start__doc__,
 271 "message.set_auto_start(bool) -> None\n"
 272 "Set whether this message will cause an owner for the destination name\n"
 273 "to be auto-started.\n");
 274 static PyObject *
 275 Message_set_auto_start (Message *self, PyObject *args)
 276 {
 277     int value;
 278     if (!PyArg_ParseTuple (args, "i", &value)) return NULL;
 279     if (!self->msg) return DBusException_UnusableMessage();
 280     dbus_message_set_auto_start (self->msg, value ? TRUE : FALSE);
 281     Py_INCREF(Py_None);
 282     return Py_None;
 283 }
 284
 285 PyDoc_STRVAR(Message_get_no_reply__doc__,
 286 "message.get_no_reply() -> bool\n"
 287 "Return true if this message need not be replied to.\n");
 288 static PyObject *
 289 Message_get_no_reply (Message *self, PyObject *unused)
 290 {
 291     if (!self->msg) return DBusException_UnusableMessage();
 292     return PyBool_FromLong (dbus_message_get_no_reply (self->msg));
 293 }
 294
 295 PyDoc_STRVAR(Message_set_no_reply__doc__,
 296 "message.set_no_reply(bool) -> None\n"
 297 "Set whether no reply to this message is required.\n");
 298 static PyObject *
 299 Message_set_no_reply (Message *self, PyObject *args)
 300 {
 301     int value;
 302     if (!PyArg_ParseTuple (args, "i", &value)) return NULL;
 303     if (!self->msg) return DBusException_UnusableMessage();
 304     dbus_message_set_no_reply (self->msg, value ? TRUE : FALSE);
 305     Py_RETURN_NONE;
 306 }
 307
 308 PyDoc_STRVAR(Message_get_reply_serial__doc__,
 309 "message.get_reply_serial() -> long\n"
 310 "Returns the serial that the message is a reply to or 0 if none.\n");
 311 static PyObject *
 312 Message_get_reply_serial (Message *self, PyObject *unused)
 313 {
 314     if (!self->msg) return DBusException_UnusableMessage();
 315     return PyLong_FromUnsignedLong (dbus_message_get_reply_serial (self->msg));
 316 }
 317
 318 PyDoc_STRVAR(Message_set_reply_serial__doc__,
 319 "message.set_reply_serial(bool) -> None\n"
 320 "Set the serial that this message is a reply to.\n");
 321 static PyObject *
 322 Message_set_reply_serial (Message *self, PyObject *args)
 323 {
 324     dbus_uint32_t value;
 325
 326     if (!PyArg_ParseTuple (args, "k", &value)) return NULL;
 327     if (!self->msg) return DBusException_UnusableMessage();
 328     if (!dbus_message_set_reply_serial (self->msg, value)) {
 329         return PyErr_NoMemory();
 330     }
 331     Py_INCREF(Py_None);
 332     return Py_None;
 333 }
 334
 335 PyDoc_STRVAR(Message_get_type__doc__,
 336 "message.get_type() -> int\n\n"
 337 "Returns the type of the message.\n");
 338 static PyObject *
 339 Message_get_type (Message *self, PyObject *unused)
 340 {
 341     if (!self->msg) return DBusException_UnusableMessage();
 342     return PyInt_FromLong (dbus_message_get_type (self->msg));
 343 }
 344
 345 PyDoc_STRVAR(Message_get_serial__doc__,
 346 "message.get_serial() -> long\n"
 347 "Returns the serial of a message or 0 if none has been specified.\n"
 348 "\n"
 349 "The message's serial number is provided by the application sending the\n"
 350 "message and is used to identify replies to this message. All messages\n"
 351 "received on a connection will have a serial, but messages you haven't\n"
 352 "sent yet may return 0.\n");
 353 static PyObject *
 354 Message_get_serial (Message *self, PyObject *unused)
 355 {
 356     if (!self->msg) return DBusException_UnusableMessage();
 357     return PyLong_FromUnsignedLong (dbus_message_get_serial (self->msg));
 358 }
 359
 360 PyDoc_STRVAR(Message_is_method_call__doc__,
 361 "is_method_call(interface: str, member: str) -> bool");
 362 static PyObject *
 363 Message_is_method_call (Message *self, PyObject *args)
 364 {
 365     const char *interface, *method;
 366
 367     if (!PyArg_ParseTuple(args, "ss:is_method_call", &interface, &method)) {
 368         return NULL;
 369     }
 370     if (!self->msg) return DBusException_UnusableMessage();
 371     return PyBool_FromLong (dbus_message_is_method_call (self->msg, interface,
 372                                                          method));
 373 }
 374
 375 PyDoc_STRVAR(Message_is_error__doc__,
 376 "is_error(error: str) -> bool");
 377 static PyObject *
 378 Message_is_error (Message *self, PyObject *args)
 379 {
 380     const char *error_name;
 381
 382     if (!PyArg_ParseTuple(args, "s:is_error", &error_name)) {
 383         return NULL;
 384     }
 385     if (!self->msg) return DBusException_UnusableMessage();
 386     return PyBool_FromLong (dbus_message_is_error (self->msg, error_name));
 387 }
 388
 389 PyDoc_STRVAR(Message_is_signal__doc__,
 390 "is_signal(interface: str, member: str) -> bool");
 391 static PyObject *
 392 Message_is_signal (Message *self, PyObject *args)
 393 {
 394     const char *interface, *signal_name;
 395
 396     if (!PyArg_ParseTuple(args, "ss:is_signal", &interface, &signal_name)) {
 397         return NULL;
 398     }
 399     if (!self->msg) return DBusException_UnusableMessage();
 400     return PyBool_FromLong (dbus_message_is_signal (self->msg, interface,
 401                                                     signal_name));
 402 }
 403
 404 PyDoc_STRVAR(Message_get_member__doc__,
 405 "get_member() -> str or None");
 406 static PyObject *
 407 Message_get_member (Message *self, PyObject *unused)
 408 {
 409     const char *c_str;
 410
 411     if (!self->msg) return DBusException_UnusableMessage();
 412     c_str = dbus_message_get_member (self->msg);
 413     if (!c_str) {
 414         Py_RETURN_NONE;
 415     }
 416     return PyString_FromString(c_str);
 417 }
 418
 419 PyDoc_STRVAR(Message_has_member__doc__,
 420 "has_member(name: str or None) -> bool");
 421 static PyObject *
 422 Message_has_member (Message *self, PyObject *args)
 423 {
 424     const char *name;
 425
 426     if (!PyArg_ParseTuple(args, "z:has_member", &name)) {
 427         return NULL;
 428     }
 429     if (!self->msg) return DBusException_UnusableMessage();
 430     return PyBool_FromLong (dbus_message_has_member(self->msg, name));
 431 }
 432
 433 PyDoc_STRVAR(Message_set_member__doc__,
 434 "set_member(unique_name: str or None)");
 435 static PyObject *
 436 Message_set_member (Message *self, PyObject *args)
 437 {
 438     const char *name;
 439
 440     if (!PyArg_ParseTuple(args, "z:set_member", &name)) {
 441         return NULL;
 442     }
 443     if (!self->msg) return DBusException_UnusableMessage();
 444     if (!_validate_member_name(name)) return NULL;
 445     if (!dbus_message_set_member (self->msg, name)) return PyErr_NoMemory();
 446     Py_RETURN_NONE;
 447 }
 448
 449 PyDoc_STRVAR(Message_get_path__doc__,
 450 "get_path() -> ObjectPath or None\n\n"
 451 "Return the message's destination object path (if it's a method call) or\n"
 452 "source object path (if it's a method reply or a signal) or None (if it\n"
 453 "has no path).\n");
 454 static PyObject *
 455 Message_get_path (Message *self, PyObject *unused)
 456 {
 457     const char *c_str;
 458
 459     if (!self->msg) return DBusException_UnusableMessage();
 460     c_str = dbus_message_get_path (self->msg);
 461     if (!c_str) {
 462         Py_RETURN_NONE;
 463     }
 464     return PyObject_CallFunction((PyObject *)&ObjectPathType, "(s)", c_str);
 465 }
 466
 467 PyDoc_STRVAR(Message_get_path_decomposed__doc__,
 468 "get_path_decomposed() -> list of str, or None\n\n"
 469 "Return a list of path components (e.g. /foo/bar -> ['foo','bar'], / -> [])\n"
 470 "or None if the message has no associated path.\n");
 471 static PyObject *
 472 Message_get_path_decomposed (Message *self, PyObject *unused)
 473 {
 474     char **paths, **ptr;
 475     PyObject *ret = PyList_New(0);
 476
 477     if (!ret) return NULL;
 478     if (!self->msg) {
 479         Py_DECREF (ret);
 480         return DBusException_UnusableMessage ();
 481     }
 482     if (!dbus_message_get_path_decomposed (self->msg, &paths)) {
 483         Py_DECREF (ret);
 484         return PyErr_NoMemory ();
 485     }
 486     if (!paths) {
 487         Py_DECREF(ret);
 488         Py_RETURN_NONE;
 489     }
 490     for (ptr = paths; *ptr; ptr++) {
 491         PyObject *str = PyString_FromString (*ptr);
 492
 493         if (!str) {
 494             Py_DECREF (ret);
 495             ret = NULL;
 496             break;
 497         }
 498         if (PyList_Append (ret, str) < 0) {
 499             Py_DECREF (ret);
 500             ret = NULL;
 501             break;
 502         }
 503         Py_DECREF (str);
 504         str = NULL;
 505     }
 506     dbus_free_string_array (paths);
 507     return ret;
 508 }
 509
 510 PyDoc_STRVAR(Message_has_path__doc__,
 511 "has_path(name: str or None) -> bool");
 512 static PyObject *
 513 Message_has_path (Message *self, PyObject *args)
 514 {
 515     const char *name;
 516
 517     if (!PyArg_ParseTuple(args, "z:has_path", &name)) {
 518         return NULL;
 519     }
 520     if (!self->msg) return DBusException_UnusableMessage();
 521     return PyBool_FromLong (dbus_message_has_path(self->msg, name));
 522 }
 523
 524 PyDoc_STRVAR(Message_set_path__doc__,
 525 "set_path(name: str or None)");
 526 static PyObject *
 527 Message_set_path (Message *self, PyObject *args)
 528 {
 529     const char *name;
 530
 531     if (!PyArg_ParseTuple(args, "z:set_path", &name)) return NULL;
 532     if (!self->msg) return DBusException_UnusableMessage();
 533     if (!dbus_message_has_path(self->msg, name)) return PyErr_NoMemory();
 534     Py_RETURN_NONE;
 535 }
 536
 537 PyDoc_STRVAR(Message_get_signature__doc__,
 538 "get_signature() -> Signature or None");
 539 static PyObject *
 540 Message_get_signature (Message *self, PyObject *unused)
 541 {
 542     const char *c_str;
 543
 544     if (!self->msg) return DBusException_UnusableMessage();
 545     c_str = dbus_message_get_signature (self->msg);
 546     if (!c_str) {
 547         return PyObject_CallFunction((PyObject *)&SignatureType, "(s)", "");
 548     }
 549     return PyObject_CallFunction((PyObject *)&SignatureType, "(s)", c_str);
 550 }
 551
 552 PyDoc_STRVAR(Message_has_signature__doc__,
 553 "has_signature(signature: str) -> bool");
 554 static PyObject *
 555 Message_has_signature (Message *self, PyObject *args)
 556 {
 557     const char *name;
 558
 559     if (!PyArg_ParseTuple(args, "s:has_signature", &name)) {
 560         return NULL;
 561     }
 562     if (!self->msg) return DBusException_UnusableMessage();
 563     return PyBool_FromLong (dbus_message_has_signature (self->msg, name));
 564 }
 565
 566 PyDoc_STRVAR(Message_get_sender__doc__,
 567 "get_sender() -> str or None\n\n"
 568 "Return the message's sender unique name, or None if none.\n");
 569 static PyObject *
 570 Message_get_sender (Message *self, PyObject *unused)
 571 {
 572     const char *c_str;
 573
 574     if (!self->msg) return DBusException_UnusableMessage();
 575     c_str = dbus_message_get_sender (self->msg);
 576     if (!c_str) {
 577         Py_RETURN_NONE;
 578     }
 579     return PyString_FromString(c_str);
 580 }
 581
 582 PyDoc_STRVAR(Message_has_sender__doc__,
 583 "has_sender(unique_name: str) -> bool");
 584 static PyObject *
 585 Message_has_sender (Message *self, PyObject *args)
 586 {
 587   const char *name;
 588
 589   if (!PyArg_ParseTuple(args, "s:has_sender", &name)) {
 590       return NULL;
 591   }
 592   if (!self->msg) return DBusException_UnusableMessage();
 593   return PyBool_FromLong (dbus_message_has_sender (self->msg, name));
 594 }
 595
 596 PyDoc_STRVAR(Message_set_sender__doc__,
 597 "set_sender(unique_name: str or None)");
 598 static PyObject *
 599 Message_set_sender (Message *self, PyObject *args)
 600 {
 601     const char *name;
 602
 603     if (!PyArg_ParseTuple(args, "z:set_sender", &name)) {
 604         return NULL;
 605     }
 606     if (!self->msg) return DBusException_UnusableMessage();
 607     if (!_validate_bus_name(name, 1, 0)) return NULL;
 608     if (!dbus_message_set_sender (self->msg, name)) return PyErr_NoMemory();
 609     Py_RETURN_NONE;
 610 }
 611
 612 PyDoc_STRVAR(Message_get_destination__doc__,
 613 "get_destination() -> str or None\n\n"
 614 "Return the message's destination bus name, or None if none.\n");
 615 static PyObject *
 616 Message_get_destination(Message *self, PyObject *unused)
 617 {
 618     const char *c_str;
 619
 620     if (!self->msg) return DBusException_UnusableMessage();
 621     c_str = dbus_message_get_destination(self->msg);
 622     if (!c_str) {
 623         Py_RETURN_NONE;
 624     }
 625     return PyString_FromString(c_str);
 626 }
 627
 628 PyDoc_STRVAR(Message_has_destination__doc__,
 629 "has_destination(bus_name: str) -> bool");
 630 static PyObject *
 631 Message_has_destination (Message *self, PyObject *args)
 632 {
 633     const char *name;
 634
 635     if (!PyArg_ParseTuple(args, "s:has_destination", &name)) {
 636         return NULL;
 637     }
 638     if (!self->msg) return DBusException_UnusableMessage();
 639     return PyBool_FromLong (dbus_message_has_destination (self->msg, name));
 640 }
 641
 642 PyDoc_STRVAR(Message_set_destination__doc__,
 643 "set_destination(bus_name: str or None)");
 644 static PyObject *
 645 Message_set_destination (Message *self, PyObject *args)
 646 {
 647     const char *name;
 648
 649     if (!PyArg_ParseTuple(args, "z:set_destination", &name)) {
 650         return NULL;
 651     }
 652     if (!self->msg) return DBusException_UnusableMessage();
 653     if (!_validate_bus_name(name, 1, 1)) return NULL;
 654     if (!dbus_message_set_destination (self->msg, name)) return PyErr_NoMemory();
 655     Py_RETURN_NONE;
 656 }
 657
 658 PyDoc_STRVAR(Message_get_interface__doc__,
 659 "get_interface() -> str or None");
 660 static PyObject *
 661 Message_get_interface (Message *self, PyObject *unused)
 662 {
 663     const char *c_str;
 664
 665     if (!self->msg) return DBusException_UnusableMessage();
 666     c_str = dbus_message_get_interface (self->msg);
 667     if (!c_str) {
 668         Py_RETURN_NONE;
 669     }
 670     return PyString_FromString(c_str);
 671 }
 672
 673 PyDoc_STRVAR(Message_has_interface__doc__,
 674 "has_interface(interface: str or None) -> bool");
 675 static PyObject *
 676 Message_has_interface(Message *self, PyObject *args)
 677 {
 678     const char *name;
 679
 680     if (!PyArg_ParseTuple(args, "z:has_interface", &name)) {
 681         return NULL;
 682     }
 683     if (!self->msg) return DBusException_UnusableMessage();
 684     return PyBool_FromLong(dbus_message_has_interface (self->msg, name));
 685 }
 686
 687 PyDoc_STRVAR(Message_set_interface__doc__,
 688 "set_interface(name: str or None)");
 689 static PyObject *
 690 Message_set_interface (Message *self, PyObject *args)
 691 {
 692     const char *name;
 693
 694     if (!PyArg_ParseTuple(args, "z:set_interface", &name)) {
 695         return NULL;
 696     }
 697     if (!self->msg) return DBusException_UnusableMessage();
 698     if (!_validate_interface_name(name)) return NULL;
 699     if (!dbus_message_set_interface (self->msg, name)) return PyErr_NoMemory();
 700     Py_RETURN_NONE;
 701 }
 702
 703 PyDoc_STRVAR(Message_get_error_name__doc__,
 704 "get_error_name() -> str or None");
 705 static PyObject *
 706 Message_get_error_name (Message *self, PyObject *unused)
 707 {
 708     const char *c_str;
 709
 710     if (!self->msg) return DBusException_UnusableMessage();
 711     c_str = dbus_message_get_error_name (self->msg);
 712     if (!c_str) {
 713         Py_RETURN_NONE;
 714     }
 715     return PyString_FromString(c_str);
 716 }
 717
 718 PyDoc_STRVAR(Message_set_error_name__doc__,
 719 "set_error_name(name: str or None)");
 720 static PyObject *
 721 Message_set_error_name(Message *self, PyObject *args)
 722 {
 723     const char *name;
 724
 725     if (!PyArg_ParseTuple(args, "z:set_error_name", &name)) {
 726         return NULL;
 727     }
 728     if (!self->msg) return DBusException_UnusableMessage();
 729     if (!_validate_error_name(name)) return NULL;
 730     if (!dbus_message_set_error_name(self->msg, name)) return PyErr_NoMemory();
 731     Py_RETURN_NONE;
 732 }
 733
 734 #include "message-append-impl.h"
 735 #include "message-get-args-impl.h"
 736
 737 static PyMethodDef Message_tp_methods[] = {
 738     {"copy", (PyCFunction)Message_copy,
 739       METH_NOARGS, Message_copy__doc__},
 740     {"is_method_call", (PyCFunction)Message_is_method_call,
 741       METH_VARARGS, Message_is_method_call__doc__},
 742     {"is_signal", (PyCFunction)Message_is_signal,
 743       METH_VARARGS, Message_is_signal__doc__},
 744     {"is_error", (PyCFunction)Message_is_error,
 745       METH_VARARGS, Message_is_error__doc__},
 746
 747     {"get_args_list", (PyCFunction)Message_get_args_list,
 748       METH_VARARGS|METH_KEYWORDS, Message_get_args_list__doc__},
 749     {"guess_signature", (PyCFunction)Message_guess_signature,
 750       METH_VARARGS|METH_STATIC, Message_guess_signature__doc__},
 751     {"append", (PyCFunction)Message_append,
 752       METH_VARARGS|METH_KEYWORDS, Message_append__doc__},
 753
 754     {"get_auto_start", (PyCFunction)Message_get_auto_start,
 755       METH_NOARGS, Message_get_auto_start__doc__},
 756     {"set_auto_start", (PyCFunction)Message_set_auto_start,
 757       METH_VARARGS, Message_set_auto_start__doc__},
 758     {"get_destination", (PyCFunction)Message_get_destination,
 759       METH_NOARGS, Message_get_destination__doc__},
 760     {"set_destination", (PyCFunction)Message_set_destination,
 761       METH_VARARGS, Message_set_destination__doc__},
 762     {"has_destination", (PyCFunction)Message_has_destination,
 763       METH_VARARGS, Message_has_destination__doc__},
 764     {"get_error_name", (PyCFunction)Message_get_error_name,
 765       METH_NOARGS, Message_get_error_name__doc__},
 766     {"set_error_name", (PyCFunction)Message_set_error_name,
 767       METH_VARARGS, Message_set_error_name__doc__},
 768     {"get_interface", (PyCFunction)Message_get_interface,
 769       METH_NOARGS, Message_get_interface__doc__},
 770     {"set_interface", (PyCFunction)Message_set_interface,
 771       METH_VARARGS, Message_set_interface__doc__},
 772     {"has_interface", (PyCFunction)Message_has_interface,
 773       METH_VARARGS, Message_has_interface__doc__},
 774     {"get_member", (PyCFunction)Message_get_member,
 775       METH_NOARGS, Message_get_member__doc__},
 776     {"set_member", (PyCFunction)Message_set_member,
 777       METH_VARARGS, Message_set_member__doc__},
 778     {"has_member", (PyCFunction)Message_has_member,
 779       METH_VARARGS, Message_has_member__doc__},
 780     {"get_path", (PyCFunction)Message_get_path,
 781       METH_NOARGS, Message_get_path__doc__},
 782     {"get_path_decomposed", (PyCFunction)Message_get_path_decomposed,
 783       METH_NOARGS, Message_get_path_decomposed__doc__},
 784     {"set_path", (PyCFunction)Message_set_path,
 785       METH_VARARGS, Message_set_path__doc__},
 786     {"has_path", (PyCFunction)Message_has_path,
 787       METH_VARARGS, Message_has_path__doc__},
 788     {"get_no_reply", (PyCFunction)Message_get_no_reply,
 789       METH_NOARGS, Message_get_no_reply__doc__},
 790     {"set_no_reply", (PyCFunction)Message_set_no_reply,
 791       METH_VARARGS, Message_set_no_reply__doc__},
 792     {"get_reply_serial", (PyCFunction)Message_get_reply_serial,
 793       METH_NOARGS, Message_get_reply_serial__doc__},
 794     {"set_reply_serial", (PyCFunction)Message_set_reply_serial,
 795       METH_VARARGS, Message_set_reply_serial__doc__},
 796     {"get_sender", (PyCFunction)Message_get_sender,
 797       METH_NOARGS, Message_get_sender__doc__},
 798     {"set_sender", (PyCFunction)Message_set_sender,
 799       METH_VARARGS, Message_set_sender__doc__},
 800     {"has_sender", (PyCFunction)Message_has_sender,
 801       METH_VARARGS, Message_has_sender__doc__},
 802     {"get_serial", (PyCFunction)Message_get_serial,
 803       METH_NOARGS, Message_get_serial__doc__},
 804     {"get_signature", (PyCFunction)Message_get_signature,
 805       METH_NOARGS, Message_get_signature__doc__},
 806     {"has_signature", (PyCFunction)Message_has_signature,
 807       METH_VARARGS, Message_has_signature__doc__},
 808     {"get_type", (PyCFunction)Message_get_type,
 809       METH_NOARGS, Message_get_type__doc__},
 810     {NULL, NULL, 0, NULL}
 811 };
 812
 813 static PyTypeObject MessageType = {
 814     PyObject_HEAD_INIT(NULL)
 815     0,                         /*ob_size*/
 816     "_dbus_bindings.Message",   /*tp_name*/
 817     sizeof(Message),     /*tp_basicsize*/
 818     0,                         /*tp_itemsize*/
 819     (destructor)Message_tp_dealloc, /*tp_dealloc*/
 820     0,                         /*tp_print*/
 821     0,                         /*tp_getattr*/
 822     0,                         /*tp_setattr*/
 823     0,                         /*tp_compare*/
 824     0,                         /*tp_repr*/
 825     0,                         /*tp_as_number*/
 826     0,                         /*tp_as_sequence*/
 827     0,                         /*tp_as_mapping*/
 828     0,                         /*tp_hash */
 829     0,                         /*tp_call*/
 830     0,                         /*tp_str*/
 831     0,                         /*tp_getattro*/
 832     0,                         /*tp_setattro*/
 833     0,                         /*tp_as_buffer*/
 834     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 835     Message_tp_doc,            /* tp_doc */
 836     0,                         /* tp_traverse */
 837     0,                         /* tp_clear */
 838     0,                         /* tp_richcompare */
 839     0,                         /* tp_weaklistoffset */
 840     0,                         /* tp_iter */
 841     0,                         /* tp_iternext */
 842     Message_tp_methods,        /* tp_methods */
 843     0,                         /* tp_members */
 844     0,                         /* tp_getset */
 845     0,                         /* tp_base */
 846     0,                         /* tp_dict */
 847     0,                         /* tp_descr_get */
 848     0,                         /* tp_descr_set */
 849     0,                         /* tp_dictoffset */
 850     0,                         /* tp_init */
 851     0,                         /* tp_alloc */
 852     Message_tp_new,            /* tp_new */
 853 };
 854
 855 static PyTypeObject MethodCallMessageType = {
 856     PyObject_HEAD_INIT(NULL)
 857     0,                         /*ob_size*/
 858     "_dbus_bindings.MethodCallMessage",  /*tp_name*/
 859     0,                         /*tp_basicsize*/
 860     0,                         /*tp_itemsize*/
 861     0,                         /*tp_dealloc*/
 862     0,                         /*tp_print*/
 863     0,                         /*tp_getattr*/
 864     0,                         /*tp_setattr*/
 865     0,                         /*tp_compare*/
 866     0,                         /*tp_repr*/
 867     0,                         /*tp_as_number*/
 868     0,                         /*tp_as_sequence*/
 869     0,                         /*tp_as_mapping*/
 870     0,                         /*tp_hash */
 871     0,                         /*tp_call*/
 872     0,                         /*tp_str*/
 873     0,                         /*tp_getattro*/
 874     0,                         /*tp_setattro*/
 875     0,                         /*tp_as_buffer*/
 876     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 877     MethodCallMessage_tp_doc,  /* tp_doc */
 878     0,                         /* tp_traverse */
 879     0,                         /* tp_clear */
 880     0,                         /* tp_richcompare */
 881     0,                         /* tp_weaklistoffset */
 882     0,                         /* tp_iter */
 883     0,                         /* tp_iternext */
 884     0,                         /* tp_methods */
 885     0,                         /* tp_members */
 886     0,                         /* tp_getset */
 887     DEFERRED_ADDRESS(&MessageType),   /* tp_base */
 888     0,                         /* tp_dict */
 889     0,                         /* tp_descr_get */
 890     0,                         /* tp_descr_set */
 891     0,                         /* tp_dictoffset */
 892     (initproc)MethodCallMessage_tp_init,    /* tp_init */
 893     0,                         /* tp_alloc */
 894     0,                         /* tp_new */
 895 };
 896
 897 static PyTypeObject MethodReturnMessageType = {
 898     PyObject_HEAD_INIT(NULL)
 899     0,                         /*ob_size*/
 900     "_dbus_bindings.MethodReturnMessage",  /*tp_name*/
 901     0,                         /*tp_basicsize*/
 902     0,                         /*tp_itemsize*/
 903     0,                         /*tp_dealloc*/
 904     0,                         /*tp_print*/
 905     0,                         /*tp_getattr*/
 906     0,                         /*tp_setattr*/
 907     0,                         /*tp_compare*/
 908     0,                         /*tp_repr*/
 909     0,                         /*tp_as_number*/
 910     0,                         /*tp_as_sequence*/
 911     0,                         /*tp_as_mapping*/
 912     0,                         /*tp_hash */
 913     0,                         /*tp_call*/
 914     0,                         /*tp_str*/
 915     0,                         /*tp_getattro*/
 916     0,                         /*tp_setattro*/
 917     0,                         /*tp_as_buffer*/
 918     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 919     MethodReturnMessage_tp_doc,  /* tp_doc */
 920     0,                         /* tp_traverse */
 921     0,                         /* tp_clear */
 922     0,                         /* tp_richcompare */
 923     0,                         /* tp_weaklistoffset */
 924     0,                         /* tp_iter */
 925     0,                         /* tp_iternext */
 926     0,                         /* tp_methods */
 927     0,                         /* tp_members */
 928     0,                         /* tp_getset */
 929     DEFERRED_ADDRESS(&MessageType),   /* tp_base */
 930     0,                         /* tp_dict */
 931     0,                         /* tp_descr_get */
 932     0,                         /* tp_descr_set */
 933     0,                         /* tp_dictoffset */
 934     (initproc)MethodReturnMessage_tp_init,    /* tp_init */
 935     0,                         /* tp_alloc */
 936     0,                         /* tp_new */
 937 };
 938
 939 static PyTypeObject SignalMessageType = {
 940     PyObject_HEAD_INIT(NULL)
 941     0,                         /*ob_size*/
 942     "_dbus_bindings.SignalMessage",  /*tp_name*/
 943     0,                         /*tp_basicsize*/
 944     0,                         /*tp_itemsize*/
 945     0,                         /*tp_dealloc*/
 946     0,                         /*tp_print*/
 947     0,                         /*tp_getattr*/
 948     0,                         /*tp_setattr*/
 949     0,                         /*tp_compare*/
 950     0,                         /*tp_repr*/
 951     0,                         /*tp_as_number*/
 952     0,                         /*tp_as_sequence*/
 953     0,                         /*tp_as_mapping*/
 954     0,                         /*tp_hash */
 955     0,                         /*tp_call*/
 956     0,                         /*tp_str*/
 957     0,                         /*tp_getattro*/
 958     0,                         /*tp_setattro*/
 959     0,                         /*tp_as_buffer*/
 960     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 961     SignalMessage_tp_doc,  /* tp_doc */
 962     0,                         /* tp_traverse */
 963     0,                         /* tp_clear */
 964     0,                         /* tp_richcompare */
 965     0,                         /* tp_weaklistoffset */
 966     0,                         /* tp_iter */
 967     0,                         /* tp_iternext */
 968     0,                         /* tp_methods */
 969     0,                         /* tp_members */
 970     0,                         /* tp_getset */
 971     DEFERRED_ADDRESS(&MessageType),   /* tp_base */
 972     0,                         /* tp_dict */
 973     0,                         /* tp_descr_get */
 974     0,                         /* tp_descr_set */
 975     0,                         /* tp_dictoffset */
 976     (initproc)SignalMessage_tp_init,    /* tp_init */
 977     0,                         /* tp_alloc */
 978     0,                         /* tp_new */
 979 };
 980
 981 static PyTypeObject ErrorMessageType = {
 982     PyObject_HEAD_INIT(NULL)
 983     0,                         /*ob_size*/
 984     "_dbus_bindings.ErrorMessage",  /*tp_name*/
 985     0,                         /*tp_basicsize*/
 986     0,                         /*tp_itemsize*/
 987     0,                         /*tp_dealloc*/
 988     0,                         /*tp_print*/
 989     0,                         /*tp_getattr*/
 990     0,                         /*tp_setattr*/
 991     0,                         /*tp_compare*/
 992     0,                         /*tp_repr*/
 993     0,                         /*tp_as_number*/
 994     0,                         /*tp_as_sequence*/
 995     0,                         /*tp_as_mapping*/
 996     0,                         /*tp_hash */
 997     0,                         /*tp_call*/
 998     0,                         /*tp_str*/
 999     0,                         /*tp_getattro*/
1000     0,                         /*tp_setattro*/
1001     0,                         /*tp_as_buffer*/
1002     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1003     ErrorMessage_tp_doc,  /* tp_doc */
1004     0,                         /* tp_traverse */
1005     0,                         /* tp_clear */
1006     0,                         /* tp_richcompare */
1007     0,                         /* tp_weaklistoffset */
1008     0,                         /* tp_iter */
1009     0,                         /* tp_iternext */
1010     0,                         /* tp_methods */
1011     0,                         /* tp_members */
1012     0,                         /* tp_getset */
1013     DEFERRED_ADDRESS(&MessageType),   /* tp_base */
1014     0,                         /* tp_dict */
1015     0,                         /* tp_descr_get */
1016     0,                         /* tp_descr_set */
1017     0,                         /* tp_dictoffset */
1018     (initproc)ErrorMessage_tp_init,    /* tp_init */
1019     0,                         /* tp_alloc */
1020     0,                         /* tp_new */
1021 };
1022
1023 static inline int
1024 init_message_types(void)
1025 {
1026     if (PyType_Ready(&MessageType) < 0) return 0;
1027
1028     MethodCallMessageType.tp_base = &MessageType;
1029     if (PyType_Ready(&MethodCallMessageType) < 0) return 0;
1030
1031     MethodReturnMessageType.tp_base = &MessageType;
1032     if (PyType_Ready(&MethodReturnMessageType) < 0) return 0;
1033
1034     SignalMessageType.tp_base = &MessageType;
1035     if (PyType_Ready(&SignalMessageType) < 0) return 0;
1036
1037     ErrorMessageType.tp_base = &MessageType;
1038     if (PyType_Ready(&ErrorMessageType) < 0) return 0;
1039
1040     return 1;
1041 }
1042
1043 static inline int
1044 insert_message_types(PyObject *this_module)
1045 {
1046     if (PyModule_AddObject(this_module, "Message",
1047                          (PyObject *)&MessageType) < 0) return 0;
1048
1049     if (PyModule_AddObject(this_module, "MethodCallMessage",
1050                          (PyObject *)&MethodCallMessageType) < 0) return 0;
1051
1052     if (PyModule_AddObject(this_module, "MethodReturnMessage",
1053                          (PyObject *)&MethodReturnMessageType) < 0) return 0;
1054
1055     if (PyModule_AddObject(this_module, "ErrorMessage",
1056                          (PyObject *)&ErrorMessageType) < 0) return 0;
1057
1058     if (PyModule_AddObject(this_module, "SignalMessage",
1059                          (PyObject *)&SignalMessageType) < 0) return 0;
1060
1061     return 1;
1062 }
1063
1064 /* vim:set ft=c cino< sw=4 sts=4 et: */