开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 系统编程 > 查看源码
dbus-connection.h
资源名称：rootfs-7-9.tar.gz　[点击查看]
上传用户：detong
上传日期：2022-06-22
资源大小：20675k
文件大小：24k
源码类别：

系统编程

开发平台：

Unix_Linux

dbus-connection.h：源码内容
  1. /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
  2. /* dbus-connection.h DBusConnection object
  3.  *
  4.  * Copyright (C) 2002, 2003  Red Hat Inc.
  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.  * 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);
  136. /**
  137.  * Called during authentication to check whether the given UNIX user
  138.  * ID is allowed to connect, if the client tried to auth as a UNIX
  139.  * user ID. Normally on Windows this would never happen. Set with
  140.  * dbus_connection_set_unix_user_function().
  141.  */ 
  142. typedef dbus_bool_t (* DBusAllowUnixUserFunction)  (DBusConnection *connection,
  143.                                                     unsigned long   uid,
  144.                                                     void           *data);
  146. /**
  147.  * Called during authentication to check whether the given Windows user
  148.  * ID is allowed to connect, if the client tried to auth as a Windows
  149.  * user ID. Normally on UNIX this would never happen. Set with
  150.  * dbus_connection_set_windows_user_function().
  151.  */ 
  152. typedef dbus_bool_t (* DBusAllowWindowsUserFunction)  (DBusConnection *connection,
  153.                                                        const char     *user_sid,
  154.                                                        void           *data);
  157. /**
  158.  * Called when a pending call now has a reply available. Set with
  159.  * dbus_pending_call_set_notify().
  160.  */
  161. typedef void (* DBusPendingCallNotifyFunction) (DBusPendingCall *pending,
  162.                                                 void            *user_data);
  164. /**
  165.  * Called when a message needs to be handled. The result indicates whether or
  166.  * not more handlers should be run. Set with dbus_connection_add_filter().
  167.  */
  168. typedef DBusHandlerResult (* DBusHandleMessageFunction) (DBusConnection     *connection,
  169.                                                          DBusMessage        *message,
  170.                                                          void               *user_data);
  172. DBusConnection*    dbus_connection_open                         (const char                 *address,
  173.                                                                  DBusError                  *error);
  174. DBusConnection*    dbus_connection_open_private                 (const char                 *address,
  175.                                                                  DBusError                  *error);
  176. DBusConnection*    dbus_connection_ref                          (DBusConnection             *connection);
  177. void               dbus_connection_unref                        (DBusConnection             *connection);
  178. void               dbus_connection_close                        (DBusConnection             *connection);
  179. dbus_bool_t        dbus_connection_get_is_connected             (DBusConnection             *connection);
  180. dbus_bool_t        dbus_connection_get_is_authenticated         (DBusConnection             *connection);
  181. dbus_bool_t        dbus_connection_get_is_anonymous             (DBusConnection             *connection);
  182. char*              dbus_connection_get_server_id                (DBusConnection             *connection);
  183. void               dbus_connection_set_exit_on_disconnect       (DBusConnection             *connection,
  184.                                                                  dbus_bool_t                 exit_on_disconnect);
  185. void               dbus_connection_flush                        (DBusConnection             *connection);
  186. dbus_bool_t        dbus_connection_read_write_dispatch          (DBusConnection             *connection,
  187.                                                                  int                         timeout_milliseconds);
  188. dbus_bool_t        dbus_connection_read_write                   (DBusConnection             *connection,
  189.                                                                  int                         timeout_milliseconds);
  190. DBusMessage*       dbus_connection_borrow_message               (DBusConnection             *connection);
  191. void               dbus_connection_return_message               (DBusConnection             *connection,
  192.                                                                  DBusMessage                *message);
  193. void               dbus_connection_steal_borrowed_message       (DBusConnection             *connection,
  194.                                                                  DBusMessage                *message);
  195. DBusMessage*       dbus_connection_pop_message                  (DBusConnection             *connection);
  196. DBusDispatchStatus dbus_connection_get_dispatch_status          (DBusConnection             *connection);
  197. DBusDispatchStatus dbus_connection_dispatch                     (DBusConnection             *connection);
  198. dbus_bool_t        dbus_connection_has_messages_to_send         (DBusConnection *connection);
  199. dbus_bool_t        dbus_connection_send                         (DBusConnection             *connection,
  200.                                                                  DBusMessage                *message,
  201.                                                                  dbus_uint32_t              *client_serial);
  202. dbus_bool_t        dbus_connection_send_with_reply              (DBusConnection             *connection,
  203.                                                                  DBusMessage                *message,
  204.                                                                  DBusPendingCall           **pending_return,
  205.                                                                  int                         timeout_milliseconds);
  206. DBusMessage *      dbus_connection_send_with_reply_and_block    (DBusConnection             *connection,
  207.                                                                  DBusMessage                *message,
  208.                                                                  int                         timeout_milliseconds,
  209.                                                                  DBusError                  *error);
  210. dbus_bool_t        dbus_connection_set_watch_functions          (DBusConnection             *connection,
  211.                                                                  DBusAddWatchFunction        add_function,
  212.                                                                  DBusRemoveWatchFunction     remove_function,
  213.                                                                  DBusWatchToggledFunction    toggled_function,
  214.                                                                  void                       *data,
  215.                                                                  DBusFreeFunction            free_data_function);
  216. dbus_bool_t        dbus_connection_set_timeout_functions        (DBusConnection             *connection,
  217.                                                                  DBusAddTimeoutFunction      add_function,
  218.                                                                  DBusRemoveTimeoutFunction   remove_function,
  219.                                                                  DBusTimeoutToggledFunction  toggled_function,
  220.                                                                  void                       *data,
  221.                                                                  DBusFreeFunction            free_data_function);
  222. void               dbus_connection_set_wakeup_main_function     (DBusConnection             *connection,
  223.                                                                  DBusWakeupMainFunction      wakeup_main_function,
  224.                                                                  void                       *data,
  225.                                                                  DBusFreeFunction            free_data_function);
  226. void               dbus_connection_set_dispatch_status_function (DBusConnection             *connection,
  227.                                                                  DBusDispatchStatusFunction  function,
  228.                                                                  void                       *data,
  229.                                                                  DBusFreeFunction            free_data_function);
  230. dbus_bool_t        dbus_connection_get_unix_user                (DBusConnection             *connection,
  231.                                                                  unsigned long              *uid);
  232. dbus_bool_t        dbus_connection_get_unix_process_id          (DBusConnection             *connection,
  233.                                                                  unsigned long              *pid);
  234. dbus_bool_t        dbus_connection_get_adt_audit_session_data   (DBusConnection             *connection,
  235.                                                                  void                      **data,
  236.                                                                  dbus_int32_t               *data_size);
  237. void               dbus_connection_set_unix_user_function       (DBusConnection             *connection,
  238.                                                                  DBusAllowUnixUserFunction   function,
  239.                                                                  void                       *data,
  240.                                                                  DBusFreeFunction            free_data_function);
  241. dbus_bool_t        dbus_connection_get_windows_user             (DBusConnection             *connection,
  242.                                                                  char                      **windows_sid_p); 
  243. void               dbus_connection_set_windows_user_function    (DBusConnection             *connection,
  244.                                                                  DBusAllowWindowsUserFunction function,
  245.                                                                  void                       *data,
  246.                                                                  DBusFreeFunction            free_data_function);
  247. void               dbus_connection_set_allow_anonymous          (DBusConnection             *connection,
  248.                                                                  dbus_bool_t                 value);
  249. void               dbus_connection_set_route_peer_messages      (DBusConnection             *connection,
  250.                                                                  dbus_bool_t                 value);
  253. /* Filters */
  255. dbus_bool_t dbus_connection_add_filter    (DBusConnection            *connection,
  256.                                            DBusHandleMessageFunction  function,
  257.                                            void                      *user_data,
  258.                                            DBusFreeFunction           free_data_function);
  259. void        dbus_connection_remove_filter (DBusConnection            *connection,
  260.                                            DBusHandleMessageFunction  function,
  261.                                            void                      *user_data);
  264. /* Other */
  265. dbus_bool_t dbus_connection_allocate_data_slot (dbus_int32_t     *slot_p);
  266. void        dbus_connection_free_data_slot     (dbus_int32_t     *slot_p);
  267. dbus_bool_t dbus_connection_set_data           (DBusConnection   *connection,
  268.                                                 dbus_int32_t      slot,
  269.                                                 void             *data,
  270.                                                 DBusFreeFunction  free_data_func);
  271. void*       dbus_connection_get_data           (DBusConnection   *connection,
  272.                                                 dbus_int32_t      slot);
  274. void        dbus_connection_set_change_sigpipe (dbus_bool_t       will_modify_sigpipe); 
  276. void dbus_connection_set_max_message_size  (DBusConnection *connection,
  277.                                             long            size);
  278. long dbus_connection_get_max_message_size  (DBusConnection *connection);
  279. void dbus_connection_set_max_received_size (DBusConnection *connection,
  280.                                             long            size);
  281. long dbus_connection_get_max_received_size (DBusConnection *connection);
  282. long dbus_connection_get_outgoing_size     (DBusConnection *connection);
  284. DBusPreallocatedSend* dbus_connection_preallocate_send       (DBusConnection       *connection);
  285. void                  dbus_connection_free_preallocated_send (DBusConnection       *connection,
  286.                                                               DBusPreallocatedSend *preallocated);
  287. void                  dbus_connection_send_preallocated      (DBusConnection       *connection,
  288.                                                               DBusPreallocatedSend *preallocated,
  289.                                                               DBusMessage          *message,
  290.                                                               dbus_uint32_t        *client_serial);
  293. /* Object tree functionality */
  295. /**
  296.  * Called when a #DBusObjectPathVTable is unregistered (or its connection is freed).
  297.  * Found in #DBusObjectPathVTable.
  298.  */
  299. typedef void              (* DBusObjectPathUnregisterFunction) (DBusConnection  *connection,
  300.                                                                 void            *user_data);
  301. /**
  302.  * Called when a message is sent to a registered object path. Found in
  303.  * #DBusObjectPathVTable which is registered with dbus_connection_register_object_path()
  304.  * or dbus_connection_register_fallback().
  305.  */
  306. typedef DBusHandlerResult (* DBusObjectPathMessageFunction)    (DBusConnection  *connection,
  307.                                                                 DBusMessage     *message,
  308.                                                                 void            *user_data);
  310. /**
  311.  * Virtual table that must be implemented to handle a portion of the
  312.  * object path hierarchy. Attach the vtable to a particular path using
  313.  * dbus_connection_register_object_path() or
  314.  * dbus_connection_register_fallback().
  315.  */
  316. struct DBusObjectPathVTable
  317. {
  318.   DBusObjectPathUnregisterFunction   unregister_function; /**< Function to unregister this handler */
  319.   DBusObjectPathMessageFunction      message_function; /**< Function to handle messages */
  320.   
  321.   void (* dbus_internal_pad1) (void *); /**< Reserved for future expansion */
  322.   void (* dbus_internal_pad2) (void *); /**< Reserved for future expansion */
  323.   void (* dbus_internal_pad3) (void *); /**< Reserved for future expansion */
  324.   void (* dbus_internal_pad4) (void *); /**< Reserved for future expansion */
  325. };
  327. dbus_bool_t dbus_connection_try_register_object_path (DBusConnection              *connection,
  328.                                                       const char                  *path,
  329.                                                       const DBusObjectPathVTable  *vtable,
  330.                                                       void                        *user_data,
  331.                                                       DBusError                   *error);
  333. dbus_bool_t dbus_connection_register_object_path   (DBusConnection              *connection,
  334.                                                     const char                  *path,
  335.                                                     const DBusObjectPathVTable  *vtable,
  336.                                                     void                        *user_data);
  338. dbus_bool_t dbus_connection_try_register_fallback (DBusConnection              *connection,
  339.                                                    const char                  *path,
  340.                                                    const DBusObjectPathVTable  *vtable,
  341.                                                    void                        *user_data,
  342.                                                    DBusError                   *error);
  344. dbus_bool_t dbus_connection_register_fallback      (DBusConnection              *connection,
  345.                                                     const char                  *path,
  346.                                                     const DBusObjectPathVTable  *vtable,
  347.                                                     void                        *user_data);
  348. dbus_bool_t dbus_connection_unregister_object_path (DBusConnection              *connection,
  349.                                                     const char                  *path);
  351. dbus_bool_t dbus_connection_get_object_path_data   (DBusConnection              *connection,
  352.                                                     const char                  *path,
  353.                                                     void                       **data_p);
  355. dbus_bool_t dbus_connection_list_registered        (DBusConnection              *connection,
  356.                                                     const char                  *parent_path,
  357.                                                     char                      ***child_entries);
  359. dbus_bool_t dbus_connection_get_unix_fd            (DBusConnection              *connection,
  360.                                                     int                         *fd);
  361. dbus_bool_t dbus_connection_get_socket             (DBusConnection              *connection,
  362.                                                     int                         *fd);
  364. /** @} */
  367. /**
  368.  * @addtogroup DBusWatch
  369.  * @{
  370.  */
  372. #ifndef DBUS_DISABLE_DEPRECATED
  373. DBUS_DEPRECATED int dbus_watch_get_fd      (DBusWatch        *watch);
  374. #endif
  376. int          dbus_watch_get_unix_fd (DBusWatch        *watch);
  377. int          dbus_watch_get_socket  (DBusWatch        *watch);
  378. unsigned int dbus_watch_get_flags   (DBusWatch        *watch);
  379. void*        dbus_watch_get_data    (DBusWatch        *watch);
  380. void         dbus_watch_set_data    (DBusWatch        *watch,
  381.                                      void             *data,
  382.                                      DBusFreeFunction  free_data_function);
  383. dbus_bool_t  dbus_watch_handle      (DBusWatch        *watch,
  384.                                      unsigned int      flags);
  385. dbus_bool_t  dbus_watch_get_enabled (DBusWatch        *watch);
  387. /** @} */
  389. /**
  390.  * @addtogroup DBusTimeout
  391.  * @{
  392.  */
  394. int         dbus_timeout_get_interval (DBusTimeout      *timeout);
  395. void*       dbus_timeout_get_data     (DBusTimeout      *timeout);
  396. void        dbus_timeout_set_data     (DBusTimeout      *timeout,
  397.                                        void             *data,
  398.                                        DBusFreeFunction  free_data_function);
  399. dbus_bool_t dbus_timeout_handle       (DBusTimeout      *timeout);
  400. dbus_bool_t dbus_timeout_get_enabled  (DBusTimeout      *timeout);
  402. /** @} */
  404. DBUS_END_DECLS
  406. #endif /* DBUS_CONNECTION_H */