23 #ifndef DBUS_SERVER_PROTECTED_H 
   24 #define DBUS_SERVER_PROTECTED_H 
   26 #include <dbus/dbus-internals.h> 
   27 #include <dbus/dbus-threads-internal.h> 
   28 #include <dbus/dbus-server.h> 
   29 #include <dbus/dbus-address.h> 
   30 #include <dbus/dbus-timeout.h> 
   31 #include <dbus/dbus-watch.h> 
   32 #include <dbus/dbus-resources.h> 
   33 #include <dbus/dbus-dataslot.h> 
   34 #include <dbus/dbus-string.h> 
   89 #ifndef DBUS_DISABLE_CHECKS 
   99 void        _dbus_server_disconnect_unlocked (
DBusServer        *server);
 
  122   DBUS_SERVER_LISTEN_NOT_HANDLED, 
 
  123   DBUS_SERVER_LISTEN_OK,          
 
  124   DBUS_SERVER_LISTEN_BAD_ADDRESS, 
 
  125   DBUS_SERVER_LISTEN_DID_NOT_CONNECT, 
 
  126   DBUS_SERVER_LISTEN_ADDRESS_ALREADY_USED 
 
  127 } DBusServerListenResult;
 
  133 #ifdef DBUS_ENABLE_VERBOSE_MODE 
  134 void _dbus_server_trace_ref (
DBusServer *server,
 
  139 #define _dbus_server_trace_ref(s,o,n,w) \ 
  147 #ifdef DBUS_DISABLE_CHECKS 
  148 #define TOOK_LOCK_CHECK(server) 
  149 #define RELEASING_LOCK_CHECK(server) 
  150 #define HAVE_LOCK_CHECK(server) 
  152 #define TOOK_LOCK_CHECK(server) do {                \ 
  153     _dbus_assert (!(server)->have_server_lock); \ 
  154     (server)->have_server_lock = TRUE;          \ 
  156 #define RELEASING_LOCK_CHECK(server) do {            \ 
  157     _dbus_assert ((server)->have_server_lock);   \ 
  158     (server)->have_server_lock = FALSE;          \ 
  160 #define HAVE_LOCK_CHECK(server)        _dbus_assert ((server)->have_server_lock) 
  164 #define TRACE_LOCKS 0 
  166 #define SERVER_LOCK(server)   do {                                              \ 
  167     if (TRACE_LOCKS) { _dbus_verbose ("LOCK\n"); }   \ 
  168     _dbus_rmutex_lock ((server)->mutex);                                        \ 
  169     TOOK_LOCK_CHECK (server);                                                   \ 
  172 #define SERVER_UNLOCK(server) do {                                                      \ 
  173     if (TRACE_LOCKS) { _dbus_verbose ("UNLOCK\n");  }        \ 
  174     RELEASING_LOCK_CHECK (server);                                                      \ 
  175     _dbus_rmutex_unlock ((server)->mutex);                                              \ 
  
dbus_bool_t _dbus_server_init_base(DBusServer *server, const DBusServerVTable *vtable, const DBusString *address, DBusError *error)
Initializes the members of the DBusServer base class.
DBusTimeoutList implementation details.
void _dbus_server_remove_watch(DBusServer *server, DBusWatch *watch)
Removes a watch previously added with _dbus_server_remove_watch().
dbus_bool_t _dbus_server_add_timeout(DBusServer *server, DBusTimeout *timeout)
Adds a timeout for this server, chaining out to application-provided timeout handlers.
const DBusServerVTable * vtable
Virtual methods for this instance.
void(* finalize)(DBusServer *server)
The finalize method must free the server.
void(* DBusFreeFunction)(void *memory)
Implementation of DBusWatch.
DBusServerListenResult _dbus_server_listen_platform_specific(DBusAddressEntry *entry, DBusServer **server_p, DBusError *error)
Tries to interpret the address entry in a platform-specific way, creating a platform-specific server ...
char ** auth_mechanisms
Array of allowed authentication mechanisms.
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...
dbus_bool_t _dbus_server_add_watch(DBusServer *server, DBusWatch *watch)
Adds a watch for this server, chaining out to application-provided watch handlers.
DBusAtomic refcount
Reference count.
DBusNewConnectionFunction new_connection_function
Callback to invoke when a new connection is created.
DBusWatchList * watches
Our watches.
dbus_bool_t published_address
flag which indicates that server has published its bus address.
char * address
Address this server is listening on.
Internals of DBusTimeout.
Internals of DBusAddressEntry.
DBusTimeoutList * timeouts
Our timeouts.
DBusRMutex * mutex
Lock on the server object.
DBUS_PRIVATE_EXPORT void _dbus_server_toggle_all_watches(DBusServer *server, dbus_bool_t enabled)
Toggles all watch and notifies app via server's DBusWatchToggledFunction if available.
void(* DBusNewConnectionFunction)(DBusServer *server, DBusConnection *new_connection, void *data)
Called when a new connection to the server is available.
DBusFreeFunction new_connection_free_data_function
Callback to invoke to free new_connection_data when server is finalized or data is replaced.
DBusWatchList implementation details.
void _dbus_server_toggle_timeout(DBusServer *server, DBusTimeout *timeout, dbus_bool_t enabled)
Toggles a timeout and notifies app via server's DBusTimeoutToggledFunction if available.
An atomic integer safe to increment or decrement from multiple threads.
Virtual table to be implemented by all server "subclasses".
DBusDataSlotList slot_list
Data stored by allocated integer ID.
Object representing an exception.
DBusString guid_hex
Hex-encoded version of GUID.
DBusGUID guid
Globally unique ID of server.
DBUS_PRIVATE_EXPORT void _dbus_server_unref_unlocked(DBusServer *server)
Like dbus_server_unref() but does not acquire the lock (must already be held)
unsigned int have_server_lock
Does someone have the server mutex locked.
void _dbus_server_remove_timeout(DBusServer *server, DBusTimeout *timeout)
Removes a timeout previously added with _dbus_server_add_timeout().
void _dbus_server_finalize_base(DBusServer *server)
Finalizes the members of the DBusServer base class.
int max_connections
Max number of connections allowed at once.
void * new_connection_data
Data for new connection callback.
Data structure that stores the actual user data set at a given slot.
DBUS_PRIVATE_EXPORT void _dbus_server_ref_unlocked(DBusServer *server)
Like dbus_server_ref() but does not acquire the lock (must already be held)
void(* disconnect)(DBusServer *server)
Disconnect this server.
unsigned int disconnected
TRUE if we are disconnected.
dbus_uint32_t dbus_bool_t