test: epoc32/include/stdapis/dbus-1.0/dbus/dbus-connection.h@e1b950c65cb4

     1 /* -*- mode: C; c-file-style: "gnu" -*- */

     2 /* dbus-connection.h DBusConnection object

     3  *

     4  * Copyright (C) 2002, 2003  Red Hat Inc.

     5  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     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  * the Free Software Foundation; either version 2 of the License, or

    11  * (at your option) any later version.

    12  *

    13  * This program is distributed in the hope that it will be useful,

    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16  * GNU General Public License for more details.

    17  *

    18  * You should have received a copy of the GNU General Public License

    19  * along with this program; if not, write to the Free Software

    20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    21  *

    22  */

    23 #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION)

    24 #error "Only <dbus/dbus.h> can be included directly, this file may disappear or change contents."

    25 #endif

    27 #ifndef DBUS_CONNECTION_H

    28 #define DBUS_CONNECTION_H

    30 #include <dbus/dbus-errors.h>

    31 #include <dbus/dbus-memory.h>

    32 #include <dbus/dbus-message.h>

    33 #include <dbus/dbus-shared.h>

    35 DBUS_BEGIN_DECLS

    37 /**

    38  * @addtogroup DBusConnection

    39  * @{

    40  */

    42 /* documented in dbus-watch.c */

    43 typedef struct DBusWatch DBusWatch;

    44 /* documented in dbus-timeout.c */

    45 typedef struct DBusTimeout DBusTimeout;

    46 /** Opaque type representing preallocated resources so a message can be sent without further memory allocation. */

    47 typedef struct DBusPreallocatedSend DBusPreallocatedSend;

    48 /** Opaque type representing a method call that has not yet received a reply. */

    49 typedef struct DBusPendingCall DBusPendingCall;

    50 /** Opaque type representing a connection to a remote application and associated incoming/outgoing message queues. */

    51 typedef struct DBusConnection DBusConnection;

    52 /** Set of functions that must be implemented to handle messages sent to a particular object path. */

    53 typedef struct DBusObjectPathVTable DBusObjectPathVTable;

    55 /**

    56  * Indicates the status of a #DBusWatch.

    57  */

    58 typedef enum

    59 {

    60   DBUS_WATCH_READABLE = 1 << 0, /**< As in POLLIN */

    61   DBUS_WATCH_WRITABLE = 1 << 1, /**< As in POLLOUT */

    62   DBUS_WATCH_ERROR    = 1 << 2, /**< As in POLLERR (can't watch for

    63                                  *   this, but can be present in

    64                                  *   current state passed to

    65                                  *   dbus_watch_handle()).

    66                                  */

    67   DBUS_WATCH_HANGUP   = 1 << 3  /**< As in POLLHUP (can't watch for

    68                                  *   it, but can be present in current

    69                                  *   state passed to

    70                                  *   dbus_watch_handle()).

    71                                  */

    72 } DBusWatchFlags;

    74 /**

    75  * Indicates the status of incoming data on a #DBusConnection. This determines whether

    76  * dbus_connection_dispatch() needs to be called.

    77  */

    78 typedef enum

    79 {

    80   DBUS_DISPATCH_DATA_REMAINS,  /**< There is more data to potentially convert to messages. */

    81   DBUS_DISPATCH_COMPLETE,      /**< All currently available data has been processed. */

    82   DBUS_DISPATCH_NEED_MEMORY    /**< More memory is needed to continue. */

    83 } DBusDispatchStatus;

    85 /** Called when libdbus needs a new watch to be monitored by the main

    86  * loop. Returns #FALSE if it lacks enough memory to add the

    87  * watch. Set by dbus_connection_set_watch_functions() or

    88  * dbus_server_set_watch_functions().

    89  */

    90 typedef dbus_bool_t (* DBusAddWatchFunction)       (DBusWatch      *watch,

    91                                                     void           *data);

    92 /** Called when dbus_watch_get_enabled() may return a different value

    93  *  than it did before.  Set by dbus_connection_set_watch_functions()

    94  *  or dbus_server_set_watch_functions().

    95  */

    96 typedef void        (* DBusWatchToggledFunction)   (DBusWatch      *watch,

    97                                                     void           *data);

    98 /** Called when libdbus no longer needs a watch to be monitored by the

    99  * main loop. Set by dbus_connection_set_watch_functions() or

   100  * dbus_server_set_watch_functions().

   101  */

   102 typedef void        (* DBusRemoveWatchFunction)    (DBusWatch      *watch,

   103                                                     void           *data);

   104 /** Called when libdbus needs a new timeout to be monitored by the main

   105  * loop. Returns #FALSE if it lacks enough memory to add the

   106  * watch. Set by dbus_connection_set_timeout_functions() or

   107  * dbus_server_set_timeout_functions().

   108  */

   109 typedef dbus_bool_t (* DBusAddTimeoutFunction)     (DBusTimeout    *timeout,

   110                                                     void           *data);

   111 /** Called when dbus_timeout_get_enabled() may return a different

   112  * value than it did before.

   113  * Set by dbus_connection_set_timeout_functions() or

   114  * dbus_server_set_timeout_functions().

   115  */

   116 typedef void        (* DBusTimeoutToggledFunction) (DBusTimeout    *timeout,

   117                                                     void           *data);

   118 /** Called when libdbus no longer needs a timeout to be monitored by the

   119  * main loop. Set by dbus_connection_set_timeout_functions() or

   120  * dbus_server_set_timeout_functions().

   121  */

   122 typedef void        (* DBusRemoveTimeoutFunction)  (DBusTimeout    *timeout,

   123                                                     void           *data);

   124 /** Called when the return value of dbus_connection_get_dispatch_status()

   125  * may have changed. Set with dbus_connection_set_dispatch_status_function().

   126  */

   127 typedef void        (* DBusDispatchStatusFunction) (DBusConnection *connection,

   128                                                     DBusDispatchStatus new_status,

   129                                                     void           *data);

   130 /**

   131  * Called when the main loop's thread should be notified that there's now work

   132  * to do. Set with dbus_connection_set_wakeup_main_function().

   133  */

   134 typedef void        (* DBusWakeupMainFunction)     (void           *data);

   135 /**

   136  * Called during authentication on UNIX systems to check whether the given

   137  * user ID is allowed to connect. Never called on Windows. Set with

   138  * dbus_connection_set_unix_user_function().

   139  */

   140 typedef dbus_bool_t (* DBusAllowUnixUserFunction)  (DBusConnection *connection,

   141                                                     unsigned long   uid,

   142                                                     void           *data);

   143 /**

   144  * Called when a pending call now has a reply available. Set with

   145  * dbus_pending_call_set_notify().

   146  */

   147 typedef void (* DBusPendingCallNotifyFunction) (DBusPendingCall *pending,

   148                                                 void            *user_data);

   150 /**

   151  * Called when a message needs to be handled. The result indicates whether or

   152  * not more handlers should be run. Set with dbus_connection_add_filter().

   153  */

   154 typedef DBusHandlerResult (* DBusHandleMessageFunction) (DBusConnection     *connection,

   155                                                          DBusMessage        *message,

   156                                                          void               *user_data);

   158 #ifdef __SYMBIAN32__

   159 IMPORT_C

   160 #endif

   161 DBusConnection*    dbus_connection_open                         (const char                 *address,

   162                                                                  DBusError                  *error);

   163 #ifdef __SYMBIAN32__

   164 IMPORT_C

   165 #endif

   166 DBusConnection*    dbus_connection_open_private                 (const char                 *address,

   167                                                                  DBusError                  *error);

   168 #ifdef __SYMBIAN32__

   169 IMPORT_C

   170 #endif

   171 DBusConnection*    dbus_connection_ref                          (DBusConnection             *connection);

   172 #ifdef __SYMBIAN32__

   173 IMPORT_C

   174 #endif

   175 void               dbus_connection_unref                        (DBusConnection             *connection);

   176 #ifdef __SYMBIAN32__

   177 IMPORT_C

   178 #endif

   179 void               dbus_connection_close                        (DBusConnection             *connection);

   180 #ifdef __SYMBIAN32__

   181 IMPORT_C

   182 #endif

   183 dbus_bool_t        dbus_connection_get_is_connected             (DBusConnection             *connection);

   184 #ifdef __SYMBIAN32__

   185 IMPORT_C

   186 #endif

   187 dbus_bool_t        dbus_connection_get_is_authenticated         (DBusConnection             *connection);

   188 #ifdef __SYMBIAN32__

   189 IMPORT_C

   190 #endif

   191 void               dbus_connection_set_exit_on_disconnect       (DBusConnection             *connection,

   192                                                                  dbus_bool_t                 exit_on_disconnect);

   193 #ifdef __SYMBIAN32__

   194 IMPORT_C

   195 #endif

   196 void               dbus_connection_flush                        (DBusConnection             *connection);

   197 #ifdef __SYMBIAN32__

   198 IMPORT_C

   199 #endif

   200 dbus_bool_t        dbus_connection_read_write_dispatch          (DBusConnection             *connection,

   201                                                                  int                         timeout_milliseconds);

   202 #ifdef __SYMBIAN32__

   203 IMPORT_C

   204 #endif

   205 dbus_bool_t        dbus_connection_read_write                   (DBusConnection             *connection,

   206                                                                  int                         timeout_milliseconds);

   207 #ifdef __SYMBIAN32__

   208 IMPORT_C

   209 #endif

   210 DBusMessage*       dbus_connection_borrow_message               (DBusConnection             *connection);

   211 #ifdef __SYMBIAN32__

   212 IMPORT_C

   213 #endif

   214 void               dbus_connection_return_message               (DBusConnection             *connection,

   215                                                                  DBusMessage                *message);

   216 #ifdef __SYMBIAN32__

   217 IMPORT_C

   218 #endif

   219 void               dbus_connection_steal_borrowed_message       (DBusConnection             *connection,

   220                                                                  DBusMessage                *message);

   221 #ifdef __SYMBIAN32__

   222 IMPORT_C

   223 #endif

   224 DBusMessage*       dbus_connection_pop_message                  (DBusConnection             *connection);

   225 #ifdef __SYMBIAN32__

   226 IMPORT_C

   227 #endif

   228 DBusDispatchStatus dbus_connection_get_dispatch_status          (DBusConnection             *connection);

   229 #ifdef __SYMBIAN32__

   230 IMPORT_C

   231 #endif

   232 DBusDispatchStatus dbus_connection_dispatch                     (DBusConnection             *connection);

   233 #ifdef __SYMBIAN32__

   234 IMPORT_C

   235 #endif

   236 dbus_bool_t        dbus_connection_has_messages_to_send         (DBusConnection *connection);

   237 #ifdef __SYMBIAN32__

   238 IMPORT_C

   239 #endif

   240 dbus_bool_t        dbus_connection_send                         (DBusConnection             *connection,

   241                                                                  DBusMessage                *message,

   242                                                                  dbus_uint32_t              *client_serial);

   243 #ifdef __SYMBIAN32__

   244 IMPORT_C

   245 #endif

   246 dbus_bool_t        dbus_connection_send_with_reply              (DBusConnection             *connection,

   247                                                                  DBusMessage                *message,

   248                                                                  DBusPendingCall           **pending_return,

   249                                                                  int                         timeout_milliseconds);

   250 #ifdef __SYMBIAN32__

   251 IMPORT_C

   252 #endif

   253 DBusMessage *      dbus_connection_send_with_reply_and_block    (DBusConnection             *connection,

   254                                                                  DBusMessage                *message,

   255                                                                  int                         timeout_milliseconds,

   256                                                                  DBusError                  *error);

   257 #ifdef __SYMBIAN32__

   258 IMPORT_C

   259 #endif

   260 dbus_bool_t        dbus_connection_set_watch_functions          (DBusConnection             *connection,

   261                                                                  DBusAddWatchFunction        add_function,

   262                                                                  DBusRemoveWatchFunction     remove_function,

   263                                                                  DBusWatchToggledFunction    toggled_function,

   264                                                                  void                       *data,

   265                                                                  DBusFreeFunction            free_data_function);

   266 #ifdef __SYMBIAN32__

   267 IMPORT_C

   268 #endif

   269 dbus_bool_t        dbus_connection_set_timeout_functions        (DBusConnection             *connection,

   270                                                                  DBusAddTimeoutFunction      add_function,

   271                                                                  DBusRemoveTimeoutFunction   remove_function,

   272                                                                  DBusTimeoutToggledFunction  toggled_function,

   273                                                                  void                       *data,

   274                                                                  DBusFreeFunction            free_data_function);

   275 #ifdef __SYMBIAN32__

   276 IMPORT_C

   277 #endif

   278 void               dbus_connection_set_wakeup_main_function     (DBusConnection             *connection,

   279                                                                  DBusWakeupMainFunction      wakeup_main_function,

   280                                                                  void                       *data,

   281                                                                  DBusFreeFunction            free_data_function);

   282 #ifdef __SYMBIAN32__

   283 IMPORT_C

   284 #endif

   285 void               dbus_connection_set_dispatch_status_function (DBusConnection             *connection,

   286                                                                  DBusDispatchStatusFunction  function,

   287                                                                  void                       *data,

   288                                                                  DBusFreeFunction            free_data_function);

   289 #ifdef __SYMBIAN32__

   290 IMPORT_C

   291 #endif

   292 dbus_bool_t        dbus_connection_get_unix_user                (DBusConnection             *connection,

   293                                                                  unsigned long              *uid);

   294 #ifdef __SYMBIAN32__

   295 IMPORT_C

   296 #endif

   297 dbus_bool_t        dbus_connection_get_unix_process_id          (DBusConnection             *connection,

   298                                                                  unsigned long              *pid);

   299 #ifdef __SYMBIAN32__

   300 IMPORT_C

   301 #endif

   302 void               dbus_connection_set_unix_user_function       (DBusConnection             *connection,

   303                                                                  DBusAllowUnixUserFunction   function,

   304                                                                  void                       *data,

   305                                                                  DBusFreeFunction            free_data_function);

   306 #ifdef __SYMBIAN32__

   307 IMPORT_C

   308 #endif

   309 void               dbus_connection_set_route_peer_messages      (DBusConnection             *connection,

   310                                                                  dbus_bool_t                 value);

   313 /* Filters */

   315 #ifdef __SYMBIAN32__

   316 IMPORT_C

   317 #endif

   318 dbus_bool_t dbus_connection_add_filter    (DBusConnection            *connection,

   319                                            DBusHandleMessageFunction  function,

   320                                            void                      *user_data,

   321                                            DBusFreeFunction           free_data_function);

   322 #ifdef __SYMBIAN32__

   323 IMPORT_C

   324 #endif

   325 void        dbus_connection_remove_filter (DBusConnection            *connection,

   326                                            DBusHandleMessageFunction  function,

   327                                            void                      *user_data);

   330 /* Other */

   331 #ifdef __SYMBIAN32__

   332 IMPORT_C

   333 #endif

   334 dbus_bool_t dbus_connection_allocate_data_slot (dbus_int32_t     *slot_p);

   335 #ifdef __SYMBIAN32__

   336 IMPORT_C

   337 #endif

   338 void        dbus_connection_free_data_slot     (dbus_int32_t     *slot_p);

   339 #ifdef __SYMBIAN32__

   340 IMPORT_C

   341 #endif

   342 dbus_bool_t dbus_connection_set_data           (DBusConnection   *connection,

   343                                                 dbus_int32_t      slot,

   344                                                 void             *data,

   345                                                 DBusFreeFunction  free_data_func);

   346 #ifdef __SYMBIAN32__

   347 IMPORT_C

   348 #endif

   349 void*       dbus_connection_get_data           (DBusConnection   *connection,

   350                                                 dbus_int32_t      slot);

   352 #ifdef __SYMBIAN32__

   353 IMPORT_C

   354 #endif

   355 void        dbus_connection_set_change_sigpipe (dbus_bool_t       will_modify_sigpipe);

   357 #ifdef __SYMBIAN32__

   358 IMPORT_C

   359 #endif

   360 void dbus_connection_set_max_message_size  (DBusConnection *connection,

   361                                             long            size);

   362 #ifdef __SYMBIAN32__

   363 IMPORT_C

   364 #endif

   365 long dbus_connection_get_max_message_size  (DBusConnection *connection);

   366 #ifdef __SYMBIAN32__

   367 IMPORT_C

   368 #endif

   369 void dbus_connection_set_max_received_size (DBusConnection *connection,

   370                                             long            size);

   371 #ifdef __SYMBIAN32__

   372 IMPORT_C

   373 #endif

   374 long dbus_connection_get_max_received_size (DBusConnection *connection);

   375 #ifdef __SYMBIAN32__

   376 IMPORT_C

   377 #endif

   378 long dbus_connection_get_outgoing_size     (DBusConnection *connection);

   380 #ifdef __SYMBIAN32__

   381 IMPORT_C

   382 #endif

   383 DBusPreallocatedSend* dbus_connection_preallocate_send       (DBusConnection       *connection);

   384 #ifdef __SYMBIAN32__

   385 IMPORT_C

   386 #endif

   387 void                  dbus_connection_free_preallocated_send (DBusConnection       *connection,

   388                                                               DBusPreallocatedSend *preallocated);

   389 #ifdef __SYMBIAN32__

   390 IMPORT_C

   391 #endif

   392 void                  dbus_connection_send_preallocated      (DBusConnection       *connection,

   393                                                               DBusPreallocatedSend *preallocated,

   394                                                               DBusMessage          *message,

   395                                                               dbus_uint32_t        *client_serial);

   398 /* Object tree functionality */

   400 /**

   401  * Called when a #DBusObjectPathVTable is unregistered (or its connection is freed).

   402  * Found in #DBusObjectPathVTable.

   403  */

   404 typedef void              (* DBusObjectPathUnregisterFunction) (DBusConnection  *connection,

   405                                                                 void            *user_data);

   406 /**

   407  * Called when a message is sent to a registered object path. Found in

   408  * #DBusObjectPathVTable which is registered with dbus_connection_register_object_path()

   409  * or dbus_connection_register_fallback().

   410  */

   411 typedef DBusHandlerResult (* DBusObjectPathMessageFunction)    (DBusConnection  *connection,

   412                                                                 DBusMessage     *message,

   413                                                                 void            *user_data);

   415 /**

   416  * Virtual table that must be implemented to handle a portion of the

   417  * object path hierarchy. Attach the vtable to a particular path using

   418  * dbus_connection_register_object_path() or

   419  * dbus_connection_register_fallback().

   420  */

   421 struct DBusObjectPathVTable

   422 {

   423   DBusObjectPathUnregisterFunction   unregister_function; /**< Function to unregister this handler */

   424   DBusObjectPathMessageFunction      message_function; /**< Function to handle messages */

   426   void (* dbus_internal_pad1) (void *); /**< Reserved for future expansion */

   427   void (* dbus_internal_pad2) (void *); /**< Reserved for future expansion */

   428   void (* dbus_internal_pad3) (void *); /**< Reserved for future expansion */

   429   void (* dbus_internal_pad4) (void *); /**< Reserved for future expansion */

   430 };

   432 #ifdef __SYMBIAN32__

   433 IMPORT_C

   434 #endif

   435 dbus_bool_t dbus_connection_register_object_path   (DBusConnection              *connection,

   436                                                     const char                  *path,

   437                                                     const DBusObjectPathVTable  *vtable,

   438                                                     void                        *user_data);

   439 #ifdef __SYMBIAN32__

   440 IMPORT_C

   441 #endif

   442 dbus_bool_t dbus_connection_register_fallback      (DBusConnection              *connection,

   443                                                     const char                  *path,

   444                                                     const DBusObjectPathVTable  *vtable,

   445                                                     void                        *user_data);

   446 #ifdef __SYMBIAN32__

   447 IMPORT_C

   448 #endif

   449 dbus_bool_t dbus_connection_unregister_object_path (DBusConnection              *connection,

   450                                                     const char                  *path);

   452 #ifdef __SYMBIAN32__

   453 IMPORT_C

   454 #endif

   455 dbus_bool_t dbus_connection_get_object_path_data   (DBusConnection              *connection,

   456                                                     const char                  *path,

   457                                                     void                       **data_p);

   459 #ifdef __SYMBIAN32__

   460 IMPORT_C

   461 #endif

   462 dbus_bool_t dbus_connection_list_registered        (DBusConnection              *connection,

   463                                                     const char                  *parent_path,

   464                                                     char                      ***child_entries);

   466 #ifdef __SYMBIAN32__

   467 IMPORT_C

   468 #endif

   469 dbus_bool_t dbus_connection_get_unix_fd            (DBusConnection              *connection,

   470                                                     int                         *fd);

   471 #ifdef __SYMBIAN32__

   472 IMPORT_C

   473 #endif

   474 dbus_bool_t dbus_connection_get_socket             (DBusConnection              *connection,

   475                                                     int                         *fd);

   477 /** @} */

   480 /**

   481  * @addtogroup DBusWatch

   482  * @{

   483  */

   485 #ifdef __SYMBIAN32__

   486 IMPORT_C

   487 #endif

   488 int          dbus_watch_get_fd      (DBusWatch        *watch);

   489 #ifdef __SYMBIAN32__

   490 IMPORT_C

   491 #endif

   492 unsigned int dbus_watch_get_flags   (DBusWatch        *watch);

   493 #ifdef __SYMBIAN32__

   494 IMPORT_C

   495 #endif

   496 void*        dbus_watch_get_data    (DBusWatch        *watch);

   497 #ifdef __SYMBIAN32__

   498 IMPORT_C

   499 #endif

   500 void         dbus_watch_set_data    (DBusWatch        *watch,

   501                                      void             *data,

   502                                      DBusFreeFunction  free_data_function);

   503 #ifdef __SYMBIAN32__

   504 IMPORT_C

   505 #endif

   506 dbus_bool_t  dbus_watch_handle      (DBusWatch        *watch,

   507                                      unsigned int      flags);

   508 #ifdef __SYMBIAN32__

   509 IMPORT_C

   510 #endif

   511 dbus_bool_t  dbus_watch_get_enabled (DBusWatch        *watch);

   513 /** @} */

   515 /**

   516  * @addtogroup DBusTimeout

   517  * @{

   518  */

   520 #ifdef __SYMBIAN32__

   521 IMPORT_C

   522 #endif

   523 int         dbus_timeout_get_interval (DBusTimeout      *timeout);

   524 #ifdef __SYMBIAN32__

   525 IMPORT_C

   526 #endif

   527 void*       dbus_timeout_get_data     (DBusTimeout      *timeout);

   528 #ifdef __SYMBIAN32__

   529 IMPORT_C

   530 #endif

   531 void        dbus_timeout_set_data     (DBusTimeout      *timeout,

   532                                        void             *data,

   533                                        DBusFreeFunction  free_data_function);

   534 #ifdef __SYMBIAN32__

   535 IMPORT_C

   536 #endif

   537 dbus_bool_t dbus_timeout_handle       (DBusTimeout      *timeout);

   538 #ifdef __SYMBIAN32__

   539 IMPORT_C

   540 #endif

   541 dbus_bool_t dbus_timeout_get_enabled  (DBusTimeout      *timeout);

   543 /** @} */

   545 DBUS_END_DECLS

   547 #endif /* DBUS_CONNECTION_H */

author	William Roberts <williamr@symbian.org>
	Wed, 31 Mar 2010 12:27:01 +0100
branch	Symbian2
changeset 3	e1b950c65cb4
permissions	-rw-r--r--