1: /* -*- mode: C; c-file-style: "gnu" -*- */
    2: /* dbus-server-protected.h Used by subclasses of DBusServer object (internal to D-Bus implementation)
    3:  *
    4:  * Copyright (C) 2002  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: #ifndef DBUS_SERVER_PROTECTED_H
   24: #define DBUS_SERVER_PROTECTED_H
   25: 
   26: #include <config.h>
   27: #include <dbus/dbus-internals.h>
   28: #include <dbus/dbus-threads-internal.h>
   29: #include <dbus/dbus-server.h>
   30: #include <dbus/dbus-address.h>
   31: #include <dbus/dbus-timeout.h>
   32: #include <dbus/dbus-watch.h>
   33: #include <dbus/dbus-resources.h>
   34: #include <dbus/dbus-dataslot.h>
   35: #include <dbus/dbus-string.h>
   36: 
   37: DBUS_BEGIN_DECLS
   38: 
   39: typedef struct DBusServerVTable DBusServerVTable;
   40: 
   41: /**
   42:  * Virtual table to be implemented by all server "subclasses"
   43:  */
   44: struct DBusServerVTable
   45: {
   46:   void        (* finalize)      (DBusServer *server);
   47:   /**< The finalize method must free the server. */
   48:   
   49:   void        (* disconnect)    (DBusServer *server);
   50:   /**< Disconnect this server. */
   51: };
   52: 
   53: /**
   54:  * Internals of DBusServer object
   55:  */
   56: struct DBusServer
   57: {
   58:   DBusAtomic refcount;                        /**< Reference count. */
   59:   const DBusServerVTable *vtable;             /**< Virtual methods for this instance. */
   60:   DBusMutex *mutex;                           /**< Lock on the server object */
   61: 
   62:   DBusGUID guid;                              /**< Globally unique ID of server */
   63: 
   64:   DBusString guid_hex;                        /**< Hex-encoded version of GUID */
   65:   
   66:   DBusWatchList *watches;                     /**< Our watches */
   67:   DBusTimeoutList *timeouts;                  /**< Our timeouts */  
   68: 
   69:   char *address;                              /**< Address this server is listening on. */
   70:   
   71:   int max_connections;                        /**< Max number of connections allowed at once. */
   72: 
   73:   DBusDataSlotList slot_list;   /**< Data stored by allocated integer ID */
   74:   
   75:   DBusNewConnectionFunction  new_connection_function;
   76:   /**< Callback to invoke when a new connection is created. */
   77:   void *new_connection_data;
   78:   /**< Data for new connection callback */
   79:   DBusFreeFunction new_connection_free_data_function;
   80:   /**< Callback to invoke to free new_connection_data
   81:    * when server is finalized or data is replaced.
   82:    */
   83: 
   84:   char **auth_mechanisms; /**< Array of allowed authentication mechanisms */
   85:   
   86:   unsigned int disconnected : 1;              /**< TRUE if we are disconnected. */
   87: 
   88: #ifndef DBUS_DISABLE_CHECKS
   89:   unsigned int have_server_lock : 1; /**< Does someone have the server mutex locked */
   90: #endif
   91: };
   92: 
   93: dbus_bool_t _dbus_server_init_base      (DBusServer             *server,
   94:                                          const DBusServerVTable *vtable,
   95:                                          const DBusString       *address);
   96: void        _dbus_server_finalize_base  (DBusServer             *server);
   97: dbus_bool_t _dbus_server_add_watch      (DBusServer             *server,
   98:                                          DBusWatch              *watch);
   99: void        _dbus_server_remove_watch   (DBusServer             *server,
  100:                                          DBusWatch              *watch);
  101: void        _dbus_server_toggle_watch   (DBusServer             *server,
  102:                                          DBusWatch              *watch,
  103:                                          dbus_bool_t             enabled);
  104: dbus_bool_t _dbus_server_add_timeout    (DBusServer             *server,
  105:                                          DBusTimeout            *timeout);
  106: void        _dbus_server_remove_timeout (DBusServer             *server,
  107:                                          DBusTimeout            *timeout);
  108: void        _dbus_server_toggle_timeout (DBusServer             *server,
  109:                                          DBusTimeout            *timeout,
  110:                                          dbus_bool_t             enabled);
  111: 
  112: void        _dbus_server_ref_unlocked   (DBusServer             *server);
  113: void        _dbus_server_unref_unlocked (DBusServer             *server);
  114: 
  115: typedef enum
  116: {
  117:   DBUS_SERVER_LISTEN_NOT_HANDLED, /**< we aren't in charge of this address type */
  118:   DBUS_SERVER_LISTEN_OK,          /**< we set up the listen */
  119:   DBUS_SERVER_LISTEN_BAD_ADDRESS, /**< malformed address */
  120:   DBUS_SERVER_LISTEN_DID_NOT_CONNECT /**< well-formed address but failed to set it up */
  121: } DBusServerListenResult;
  122: 
  123: DBusServerListenResult _dbus_server_listen_platform_specific (DBusAddressEntry  *entry,
  124:                                                               DBusServer       **server_p,
  125:                                                               DBusError         *error);
  126: 
  127: #ifdef DBUS_DISABLE_CHECKS
  128: #define TOOK_LOCK_CHECK(server)
  129: #define RELEASING_LOCK_CHECK(server)
  130: #define HAVE_LOCK_CHECK(server)
  131: #else
  132: #define TOOK_LOCK_CHECK(server) do {                \
  133:     _dbus_assert (!(server)->have_server_lock); \
  134:     (server)->have_server_lock = TRUE;          \
  135:   } while (0)
  136: #define RELEASING_LOCK_CHECK(server) do {            \
  137:     _dbus_assert ((server)->have_server_lock);   \
  138:     (server)->have_server_lock = FALSE;          \
  139:   } while (0)
  140: #define HAVE_LOCK_CHECK(server)        _dbus_assert ((server)->have_server_lock)
  141: /* A "DO_NOT_HAVE_LOCK_CHECK" is impossible since we need the lock to check the flag */
  142: #endif
  143: 
  144: #define TRACE_LOCKS 0
  145: 
  146: #define SERVER_LOCK(server)   do {                                              \
  147:     if (TRACE_LOCKS) { _dbus_verbose ("  LOCK: %s\n", _DBUS_FUNCTION_NAME); }   \
  148:     _dbus_mutex_lock ((server)->mutex);                                          \
  149:     TOOK_LOCK_CHECK (server);                                                   \
  150:   } while (0)
  151: 
  152: #define SERVER_UNLOCK(server) do {                                                      \
  153:     if (TRACE_LOCKS) { _dbus_verbose ("  UNLOCK: %s\n", _DBUS_FUNCTION_NAME);  }        \
  154:     RELEASING_LOCK_CHECK (server);                                                      \
  155:     _dbus_mutex_unlock ((server)->mutex);                                                \
  156:   } while (0)
  157: 
  158: DBUS_END_DECLS
  159: 
  160: #endif /* DBUS_SERVER_PROTECTED_H */