dbus-1.0/dbus/dbus-connection.h

0001 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
0002 /* dbus-connection.h DBusConnection object
0003  *
0004  * Copyright (C) 2002, 2003  Red Hat Inc.
0005  *
0006  * Licensed under the Academic Free License version 2.1
0007  *
0008  * This program is free software; you can redistribute it and/or modify
0009  * it under the terms of the GNU General Public License as published by
0010  * the Free Software Foundation; either version 2 of the License, or
0011  * (at your option) any later version.
0012  *
0013  * This program is distributed in the hope that it will be useful,
0014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
0015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0016  * GNU General Public License for more details.
0017  *
0018  * You should have received a copy of the GNU General Public License
0019  * along with this program; if not, write to the Free Software
0020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
0021  *
0022  */
0023 #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION)
0024 #error "Only <dbus/dbus.h> can be included directly, this file may disappear or change contents."
0025 #endif
0026
0027 #ifndef DBUS_CONNECTION_H
0028 #define DBUS_CONNECTION_H
0029
0030 #include <dbus/dbus-errors.h>
0031 #include <dbus/dbus-macros.h>
0032 #include <dbus/dbus-memory.h>
0033 #include <dbus/dbus-message.h>
0034 #include <dbus/dbus-shared.h>
0035
0036 DBUS_BEGIN_DECLS
0037
0038 /**
0039  * @addtogroup DBusConnection
0040  * @{
0041  */
0042
0043 /* documented in dbus-watch.c */
0044 typedef struct DBusWatch DBusWatch;
0045 /* documented in dbus-timeout.c */
0046 typedef struct DBusTimeout DBusTimeout;
0047 /** Opaque type representing preallocated resources so a message can be sent without further memory allocation. */
0048 typedef struct DBusPreallocatedSend DBusPreallocatedSend;
0049 /** Opaque type representing a method call that has not yet received a reply. */
0050 typedef struct DBusPendingCall DBusPendingCall;
0051 /** Opaque type representing a connection to a remote application and associated incoming/outgoing message queues. */
0052 typedef struct DBusConnection DBusConnection;
0053 /** Set of functions that must be implemented to handle messages sent to a particular object path. */
0054 typedef struct DBusObjectPathVTable DBusObjectPathVTable;
0055
0056 /**
0057  * Indicates the status of a #DBusWatch.
0058  */
0059 typedef enum
0060 {
0061   DBUS_WATCH_READABLE = 1 << 0, /**< As in POLLIN */
0062   DBUS_WATCH_WRITABLE = 1 << 1, /**< As in POLLOUT */
0063   DBUS_WATCH_ERROR    = 1 << 2, /**< As in POLLERR (can't watch for
0064                                  *   this, but can be present in
0065                                  *   current state passed to
0066                                  *   dbus_watch_handle()).
0067                                  */
0068   DBUS_WATCH_HANGUP   = 1 << 3  /**< As in POLLHUP (can't watch for
0069                                  *   it, but can be present in current
0070                                  *   state passed to
0071                                  *   dbus_watch_handle()).
0072                                  */
0073   /* Internal to libdbus, there is also _DBUS_WATCH_NVAL in dbus-watch.h */
0074 } DBusWatchFlags;
0075
0076 /**
0077  * Indicates the status of incoming data on a #DBusConnection. This determines whether
0078  * dbus_connection_dispatch() needs to be called.
0079  */
0080 typedef enum
0081 {
0082   DBUS_DISPATCH_DATA_REMAINS,  /**< There is more data to potentially convert to messages. */
0083   DBUS_DISPATCH_COMPLETE,      /**< All currently available data has been processed. */
0084   DBUS_DISPATCH_NEED_MEMORY    /**< More memory is needed to continue. */
0085 } DBusDispatchStatus;
0086
0087 /** Called when libdbus needs a new watch to be monitored by the main
0088  * loop. Returns #FALSE if it lacks enough memory to add the
0089  * watch. Set by dbus_connection_set_watch_functions() or
0090  * dbus_server_set_watch_functions().
0091  */
0092 typedef dbus_bool_t (* DBusAddWatchFunction)       (DBusWatch      *watch,
0093                                                     void           *data);
0094 /** Called when dbus_watch_get_enabled() may return a different value
0095  *  than it did before.  Set by dbus_connection_set_watch_functions()
0096  *  or dbus_server_set_watch_functions().
0097  */
0098 typedef void        (* DBusWatchToggledFunction)   (DBusWatch      *watch,
0099                                                     void           *data);
0100 /** Called when libdbus no longer needs a watch to be monitored by the
0101  * main loop. Set by dbus_connection_set_watch_functions() or
0102  * dbus_server_set_watch_functions().
0103  */
0104 typedef void        (* DBusRemoveWatchFunction)    (DBusWatch      *watch,
0105                                                     void           *data);
0106 /** Called when libdbus needs a new timeout to be monitored by the main
0107  * loop. Returns #FALSE if it lacks enough memory to add the
0108  * watch. Set by dbus_connection_set_timeout_functions() or
0109  * dbus_server_set_timeout_functions().
0110  */
0111 typedef dbus_bool_t (* DBusAddTimeoutFunction)     (DBusTimeout    *timeout,
0112                                                     void           *data);
0113 /** Called when dbus_timeout_get_enabled() may return a different
0114  * value than it did before.
0115  * Set by dbus_connection_set_timeout_functions() or
0116  * dbus_server_set_timeout_functions().
0117  */
0118 typedef void        (* DBusTimeoutToggledFunction) (DBusTimeout    *timeout,
0119                                                     void           *data);
0120 /** Called when libdbus no longer needs a timeout to be monitored by the
0121  * main loop. Set by dbus_connection_set_timeout_functions() or
0122  * dbus_server_set_timeout_functions().
0123  */
0124 typedef void        (* DBusRemoveTimeoutFunction)  (DBusTimeout    *timeout,
0125                                                     void           *data);
0126 /** Called when the return value of dbus_connection_get_dispatch_status()
0127  * may have changed. Set with dbus_connection_set_dispatch_status_function().
0128  */
0129 typedef void        (* DBusDispatchStatusFunction) (DBusConnection *connection,
0130                                                     DBusDispatchStatus new_status,
0131                                                     void           *data);
0132 /**
0133  * Called when the main loop's thread should be notified that there's now work
0134  * to do. Set with dbus_connection_set_wakeup_main_function().
0135  */
0136 typedef void        (* DBusWakeupMainFunction)     (void           *data);
0137
0138 /**
0139  * Called during authentication to check whether the given UNIX user
0140  * ID is allowed to connect, if the client tried to auth as a UNIX
0141  * user ID. Normally on Windows this would never happen. Set with
0142  * dbus_connection_set_unix_user_function().
0143  */
0144 typedef dbus_bool_t (* DBusAllowUnixUserFunction)  (DBusConnection *connection,
0145                                                     unsigned long   uid,
0146                                                     void           *data);
0147
0148 /**
0149  * Called during authentication to check whether the given Windows user
0150  * ID is allowed to connect, if the client tried to auth as a Windows
0151  * user ID. Normally on UNIX this would never happen. Set with
0152  * dbus_connection_set_windows_user_function().
0153  */
0154 typedef dbus_bool_t (* DBusAllowWindowsUserFunction)  (DBusConnection *connection,
0155                                                        const char     *user_sid,
0156                                                        void           *data);
0157
0158
0159 /**
0160  * Called when a pending call now has a reply available. Set with
0161  * dbus_pending_call_set_notify().
0162  */
0163 typedef void (* DBusPendingCallNotifyFunction) (DBusPendingCall *pending,
0164                                                 void            *user_data);
0165
0166 /**
0167  * Called when a message needs to be handled. The result indicates whether or
0168  * not more handlers should be run. Set with dbus_connection_add_filter().
0169  */
0170 typedef DBusHandlerResult (* DBusHandleMessageFunction) (DBusConnection     *connection,
0171                                                          DBusMessage        *message,
0172                                                          void               *user_data);
0173 DBUS_EXPORT
0174 DBusConnection*    dbus_connection_open                         (const char                 *address,
0175                                                                  DBusError                  *error);
0176 DBUS_EXPORT
0177 DBusConnection*    dbus_connection_open_private                 (const char                 *address,
0178                                                                  DBusError                  *error);
0179 DBUS_EXPORT
0180 DBusConnection*    dbus_connection_ref                          (DBusConnection             *connection);
0181 DBUS_EXPORT
0182 void               dbus_connection_unref                        (DBusConnection             *connection);
0183 DBUS_EXPORT
0184 void               dbus_connection_close                        (DBusConnection             *connection);
0185 DBUS_EXPORT
0186 dbus_bool_t        dbus_connection_get_is_connected             (DBusConnection             *connection);
0187 DBUS_EXPORT
0188 dbus_bool_t        dbus_connection_get_is_authenticated         (DBusConnection             *connection);
0189 DBUS_EXPORT
0190 dbus_bool_t        dbus_connection_get_is_anonymous             (DBusConnection             *connection);
0191 DBUS_EXPORT
0192 char*              dbus_connection_get_server_id                (DBusConnection             *connection);
0193 DBUS_EXPORT
0194 dbus_bool_t        dbus_connection_can_send_type                (DBusConnection             *connection,
0195                                                                  int                         type);
0196
0197 DBUS_EXPORT
0198 void               dbus_connection_set_exit_on_disconnect       (DBusConnection             *connection,
0199                                                                  dbus_bool_t                 exit_on_disconnect);
0200 DBUS_EXPORT
0201 void               dbus_connection_flush                        (DBusConnection             *connection);
0202 DBUS_EXPORT
0203 dbus_bool_t        dbus_connection_read_write_dispatch          (DBusConnection             *connection,
0204                                                                  int                         timeout_milliseconds);
0205 DBUS_EXPORT
0206 dbus_bool_t        dbus_connection_read_write                   (DBusConnection             *connection,
0207                                                                  int                         timeout_milliseconds);
0208 DBUS_EXPORT
0209 DBusMessage*       dbus_connection_borrow_message               (DBusConnection             *connection);
0210 DBUS_EXPORT
0211 void               dbus_connection_return_message               (DBusConnection             *connection,
0212                                                                  DBusMessage                *message);
0213 DBUS_EXPORT
0214 void               dbus_connection_steal_borrowed_message       (DBusConnection             *connection,
0215                                                                  DBusMessage                *message);
0216 DBUS_EXPORT
0217 DBusMessage*       dbus_connection_pop_message                  (DBusConnection             *connection);
0218 DBUS_EXPORT
0219 DBusDispatchStatus dbus_connection_get_dispatch_status          (DBusConnection             *connection);
0220 DBUS_EXPORT
0221 DBusDispatchStatus dbus_connection_dispatch                     (DBusConnection             *connection);
0222 DBUS_EXPORT
0223 dbus_bool_t        dbus_connection_has_messages_to_send         (DBusConnection *connection);
0224 DBUS_EXPORT
0225 dbus_bool_t        dbus_connection_send                         (DBusConnection             *connection,
0226                                                                  DBusMessage                *message,
0227                                                                  dbus_uint32_t              *client_serial);
0228 DBUS_EXPORT
0229 dbus_bool_t        dbus_connection_send_with_reply              (DBusConnection             *connection,
0230                                                                  DBusMessage                *message,
0231                                                                  DBusPendingCall           **pending_return,
0232                                                                  int                         timeout_milliseconds);
0233 DBUS_EXPORT
0234 DBusMessage *      dbus_connection_send_with_reply_and_block    (DBusConnection             *connection,
0235                                                                  DBusMessage                *message,
0236                                                                  int                         timeout_milliseconds,
0237                                                                  DBusError                  *error);
0238 DBUS_EXPORT
0239 dbus_bool_t        dbus_connection_set_watch_functions          (DBusConnection             *connection,
0240                                                                  DBusAddWatchFunction        add_function,
0241                                                                  DBusRemoveWatchFunction     remove_function,
0242                                                                  DBusWatchToggledFunction    toggled_function,
0243                                                                  void                       *data,
0244                                                                  DBusFreeFunction            free_data_function);
0245 DBUS_EXPORT
0246 dbus_bool_t        dbus_connection_set_timeout_functions        (DBusConnection             *connection,
0247                                                                  DBusAddTimeoutFunction      add_function,
0248                                                                  DBusRemoveTimeoutFunction   remove_function,
0249                                                                  DBusTimeoutToggledFunction  toggled_function,
0250                                                                  void                       *data,
0251                                                                  DBusFreeFunction            free_data_function);
0252 DBUS_EXPORT
0253 void               dbus_connection_set_wakeup_main_function     (DBusConnection             *connection,
0254                                                                  DBusWakeupMainFunction      wakeup_main_function,
0255                                                                  void                       *data,
0256                                                                  DBusFreeFunction            free_data_function);
0257 DBUS_EXPORT
0258 void               dbus_connection_set_dispatch_status_function (DBusConnection             *connection,
0259                                                                  DBusDispatchStatusFunction  function,
0260                                                                  void                       *data,
0261                                                                  DBusFreeFunction            free_data_function);
0262 DBUS_EXPORT
0263 dbus_bool_t        dbus_connection_get_unix_user                (DBusConnection             *connection,
0264                                                                  unsigned long              *uid);
0265 DBUS_EXPORT
0266 dbus_bool_t        dbus_connection_get_unix_process_id          (DBusConnection             *connection,
0267                                                                  unsigned long              *pid);
0268 DBUS_EXPORT
0269 dbus_bool_t        dbus_connection_get_adt_audit_session_data   (DBusConnection             *connection,
0270                                                                  void                      **data,
0271                                                                  dbus_int32_t               *data_size);
0272 DBUS_EXPORT
0273 void               dbus_connection_set_unix_user_function       (DBusConnection             *connection,
0274                                                                  DBusAllowUnixUserFunction   function,
0275                                                                  void                       *data,
0276                                                                  DBusFreeFunction            free_data_function);
0277 DBUS_EXPORT
0278 dbus_bool_t        dbus_connection_get_windows_user             (DBusConnection             *connection,
0279                                                                  char                      **windows_sid_p);
0280 DBUS_EXPORT
0281 void               dbus_connection_set_windows_user_function    (DBusConnection             *connection,
0282                                                                  DBusAllowWindowsUserFunction function,
0283                                                                  void                       *data,
0284                                                                  DBusFreeFunction            free_data_function);
0285 DBUS_EXPORT
0286 void               dbus_connection_set_allow_anonymous          (DBusConnection             *connection,
0287                                                                  dbus_bool_t                 value);
0288 DBUS_EXPORT
0289 void               dbus_connection_set_route_peer_messages      (DBusConnection             *connection,
0290                                                                  dbus_bool_t                 value);
0291
0292
0293 /* Filters */
0294
0295 DBUS_EXPORT
0296 dbus_bool_t dbus_connection_add_filter    (DBusConnection            *connection,
0297                                            DBusHandleMessageFunction  function,
0298                                            void                      *user_data,
0299                                            DBusFreeFunction           free_data_function);
0300 DBUS_EXPORT
0301 void        dbus_connection_remove_filter (DBusConnection            *connection,
0302                                            DBusHandleMessageFunction  function,
0303                                            void                      *user_data);
0304
0305
0306 /* Other */
0307 DBUS_EXPORT
0308 dbus_bool_t dbus_connection_allocate_data_slot (dbus_int32_t     *slot_p);
0309 DBUS_EXPORT
0310 void        dbus_connection_free_data_slot     (dbus_int32_t     *slot_p);
0311 DBUS_EXPORT
0312 dbus_bool_t dbus_connection_set_data           (DBusConnection   *connection,
0313                                                 dbus_int32_t      slot,
0314                                                 void             *data,
0315                                                 DBusFreeFunction  free_data_func);
0316 DBUS_EXPORT
0317 void*       dbus_connection_get_data           (DBusConnection   *connection,
0318                                                 dbus_int32_t      slot);
0319
0320 DBUS_EXPORT
0321 void        dbus_connection_set_change_sigpipe (dbus_bool_t       will_modify_sigpipe);
0322
0323 DBUS_EXPORT
0324 void dbus_connection_set_max_message_size  (DBusConnection *connection,
0325                                             long            size);
0326 DBUS_EXPORT
0327 long dbus_connection_get_max_message_size  (DBusConnection *connection);
0328 DBUS_EXPORT
0329 void dbus_connection_set_max_received_size (DBusConnection *connection,
0330                                             long            size);
0331 DBUS_EXPORT
0332 long dbus_connection_get_max_received_size (DBusConnection *connection);
0333
0334 DBUS_EXPORT
0335 void dbus_connection_set_max_message_unix_fds (DBusConnection *connection,
0336                                                long            n);
0337 DBUS_EXPORT
0338 long dbus_connection_get_max_message_unix_fds (DBusConnection *connection);
0339 DBUS_EXPORT
0340 void dbus_connection_set_max_received_unix_fds(DBusConnection *connection,
0341                                                long            n);
0342 DBUS_EXPORT
0343 long dbus_connection_get_max_received_unix_fds(DBusConnection *connection);
0344
0345 DBUS_EXPORT
0346 long dbus_connection_get_outgoing_size     (DBusConnection *connection);
0347 DBUS_EXPORT
0348 long dbus_connection_get_outgoing_unix_fds (DBusConnection *connection);
0349
0350 DBUS_EXPORT
0351 DBusPreallocatedSend* dbus_connection_preallocate_send       (DBusConnection       *connection);
0352 DBUS_EXPORT
0353 void                  dbus_connection_free_preallocated_send (DBusConnection       *connection,
0354                                                               DBusPreallocatedSend *preallocated);
0355 DBUS_EXPORT
0356 void                  dbus_connection_send_preallocated      (DBusConnection       *connection,
0357                                                               DBusPreallocatedSend *preallocated,
0358                                                               DBusMessage          *message,
0359                                                               dbus_uint32_t        *client_serial);
0360
0361
0362 /* Object tree functionality */
0363
0364 /**
0365  * Called when a #DBusObjectPathVTable is unregistered (or its connection is freed).
0366  * Found in #DBusObjectPathVTable.
0367  */
0368 typedef void              (* DBusObjectPathUnregisterFunction) (DBusConnection  *connection,
0369                                                                 void            *user_data);
0370 /**
0371  * Called when a message is sent to a registered object path. Found in
0372  * #DBusObjectPathVTable which is registered with dbus_connection_register_object_path()
0373  * or dbus_connection_register_fallback().
0374  */
0375 typedef DBusHandlerResult (* DBusObjectPathMessageFunction)    (DBusConnection  *connection,
0376                                                                 DBusMessage     *message,
0377                                                                 void            *user_data);
0378
0379 /**
0380  * Virtual table that must be implemented to handle a portion of the
0381  * object path hierarchy. Attach the vtable to a particular path using
0382  * dbus_connection_register_object_path() or
0383  * dbus_connection_register_fallback().
0384  */
0385 struct DBusObjectPathVTable
0386 {
0387   DBusObjectPathUnregisterFunction   unregister_function; /**< Function to unregister this handler */
0388   DBusObjectPathMessageFunction      message_function; /**< Function to handle messages */
0389
0390   void (* dbus_internal_pad1) (void *); /**< Reserved for future expansion */
0391   void (* dbus_internal_pad2) (void *); /**< Reserved for future expansion */
0392   void (* dbus_internal_pad3) (void *); /**< Reserved for future expansion */
0393   void (* dbus_internal_pad4) (void *); /**< Reserved for future expansion */
0394 };
0395
0396 DBUS_EXPORT
0397 dbus_bool_t dbus_connection_try_register_object_path (DBusConnection              *connection,
0398                                                       const char                  *path,
0399                                                       const DBusObjectPathVTable  *vtable,
0400                                                       void                        *user_data,
0401                                                       DBusError                   *error);
0402
0403 DBUS_EXPORT
0404 dbus_bool_t dbus_connection_register_object_path   (DBusConnection              *connection,
0405                                                     const char                  *path,
0406                                                     const DBusObjectPathVTable  *vtable,
0407                                                     void                        *user_data);
0408
0409 DBUS_EXPORT
0410 dbus_bool_t dbus_connection_try_register_fallback (DBusConnection              *connection,
0411                                                    const char                  *path,
0412                                                    const DBusObjectPathVTable  *vtable,
0413                                                    void                        *user_data,
0414                                                    DBusError                   *error);
0415
0416 DBUS_EXPORT
0417 dbus_bool_t dbus_connection_register_fallback      (DBusConnection              *connection,
0418                                                     const char                  *path,
0419                                                     const DBusObjectPathVTable  *vtable,
0420                                                     void                        *user_data);
0421 DBUS_EXPORT
0422 dbus_bool_t dbus_connection_unregister_object_path (DBusConnection              *connection,
0423                                                     const char                  *path);
0424
0425 DBUS_EXPORT
0426 dbus_bool_t dbus_connection_get_object_path_data   (DBusConnection              *connection,
0427                                                     const char                  *path,
0428                                                     void                       **data_p);
0429
0430 DBUS_EXPORT
0431 dbus_bool_t dbus_connection_list_registered        (DBusConnection              *connection,
0432                                                     const char                  *parent_path,
0433                                                     char                      ***child_entries);
0434
0435 DBUS_EXPORT
0436 dbus_bool_t dbus_connection_get_unix_fd            (DBusConnection              *connection,
0437                                                     int                         *fd);
0438 DBUS_EXPORT
0439 dbus_bool_t dbus_connection_get_socket             (DBusConnection              *connection,
0440                                                     int                         *fd);
0441
0442 /**
0443  * Clear a variable or struct member that contains a #DBusConnection.
0444  * If it does not contain #NULL, the connection that was previously
0445  * there is unreferenced with dbus_connection_unref().
0446  *
0447  * For example, this function and the similar functions for
0448  * other reference-counted types can be used in code like this:
0449  *
0450  * @code
0451  * DBusConnection *conn = NULL;
0452  * struct { ...; DBusMessage *m; ... } *larger_structure = ...;
0453  *
0454  * ... code that might set conn or m to be non-NULL ...
0455  *
0456  * dbus_clear_connection (&conn);
0457  * dbus_clear_message (&larger_structure->m);
0458  * @endcode
0459  *
0460  * @param pointer_to_connection A pointer to a variable or struct member.
0461  * pointer_to_connection must not be #NULL, but *pointer_to_connection
0462  * may be #NULL.
0463  */
0464 static inline void
0465 dbus_clear_connection (DBusConnection **pointer_to_connection)
0466 {
0467   _dbus_clear_pointer_impl (DBusConnection, pointer_to_connection,
0468                             dbus_connection_unref);
0469 }
0470
0471 /** @} */
0472
0473
0474 /**
0475  * @addtogroup DBusWatch
0476  * @{
0477  */
0478
0479 #ifndef DBUS_DISABLE_DEPRECATED
0480 DBUS_EXPORT
0481 DBUS_DEPRECATED int dbus_watch_get_fd      (DBusWatch        *watch);
0482 #endif
0483
0484 DBUS_EXPORT
0485 int          dbus_watch_get_unix_fd (DBusWatch        *watch);
0486 DBUS_EXPORT
0487 int          dbus_watch_get_socket  (DBusWatch        *watch);
0488 DBUS_EXPORT
0489 unsigned int dbus_watch_get_flags   (DBusWatch        *watch);
0490 DBUS_EXPORT
0491 void*        dbus_watch_get_data    (DBusWatch        *watch);
0492 DBUS_EXPORT
0493 void         dbus_watch_set_data    (DBusWatch        *watch,
0494                                      void             *data,
0495                                      DBusFreeFunction  free_data_function);
0496 DBUS_EXPORT
0497 dbus_bool_t  dbus_watch_handle      (DBusWatch        *watch,
0498                                      unsigned int      flags);
0499 DBUS_EXPORT
0500 dbus_bool_t  dbus_watch_get_enabled (DBusWatch        *watch);
0501
0502 /** @} */
0503
0504 /**
0505  * @addtogroup DBusTimeout
0506  * @{
0507  */
0508
0509 DBUS_EXPORT
0510 int         dbus_timeout_get_interval (DBusTimeout      *timeout);
0511 DBUS_EXPORT
0512 void*       dbus_timeout_get_data     (DBusTimeout      *timeout);
0513 DBUS_EXPORT
0514 void        dbus_timeout_set_data     (DBusTimeout      *timeout,
0515                                        void             *data,
0516                                        DBusFreeFunction  free_data_function);
0517 DBUS_EXPORT
0518 dbus_bool_t dbus_timeout_handle       (DBusTimeout      *timeout);
0519 DBUS_EXPORT
0520 dbus_bool_t dbus_timeout_get_enabled  (DBusTimeout      *timeout);
0521
0522 /** @} */
0523
0524 DBUS_END_DECLS
0525
0526 #endif /* DBUS_CONNECTION_H */