git.sur5r.net Git - openldap/blob - servers/slapd/init.c

   1 /* init.c - initialize various things */
   2
   3 #include "portable.h"
   4
   5 #include <stdio.h>
   6
   7 #include <ac/socket.h>
   8 #include <ac/string.h>
   9 #include <ac/time.h>
  10
  11 #include "slap.h"
  12
  13 /*
  14  * read-only global variables or variables only written by the listener
  15  * thread (after they are initialized) - no need to protect them with a mutex.
  16  */
  17 int             slap_debug = 0;
  18
  19 #ifdef LDAP_DEBUG
  20 int             ldap_syslog = LDAP_DEBUG_STATS;
  21 #else
  22 int             ldap_syslog;
  23 #endif
  24
  25 int             ldap_syslog_level = LOG_DEBUG;
  26 char            *default_referral;
  27 int             g_argc;
  28 char            **g_argv;
  29
  30 /*
  31  * global variables that need mutex protection
  32  */
  33 int                             active_threads;
  34 ldap_pvt_thread_mutex_t active_threads_mutex;
  35 ldap_pvt_thread_cond_t  active_threads_cond;
  36
  37 ldap_pvt_thread_mutex_t gmtime_mutex;
  38 #ifdef SLAPD_CRYPT
  39 ldap_pvt_thread_mutex_t crypt_mutex;
  40 #endif
  41
  42 int                             num_conns;
  43 long                    ops_initiated;
  44 long                    ops_completed;
  45 ldap_pvt_thread_mutex_t ops_mutex;
  46
  47 long                    num_entries_sent;
  48 long                    num_bytes_sent;
  49 ldap_pvt_thread_mutex_t num_sent_mutex;
  50 /*
  51  * these mutexes must be used when calling the entry2str()
  52  * routine since it returns a pointer to static data.
  53  */
  54 ldap_pvt_thread_mutex_t entry2str_mutex;
  55 ldap_pvt_thread_mutex_t replog_mutex;
  56
  57 static char* slap_name;
  58 int slapMode = SLAP_UNDEFINED_MODE;
  59
  60 static time_t                   currenttime;
  61 static ldap_pvt_thread_mutex_t  currenttime_mutex;
  62
  63 int
  64 slap_init( int mode, char *name )
  65 {
  66         int rc;
  67
  68         if( slapMode != SLAP_UNDEFINED_MODE ) {
  69                 Debug( LDAP_DEBUG_ANY,
  70                  "%s init: init called twice (old=%d, new=%d)\n",
  71                  name, slapMode, mode );
  72                 return 1;
  73         }
  74
  75         slapMode = mode;
  76
  77         switch ( slapMode ) {
  78
  79                 case SLAP_SERVER_MODE:
  80                 case SLAP_TOOL_MODE:
  81 #ifdef SLAPD_BDB2
  82                 case SLAP_TIMEDSERVER_MODE:
  83                 case SLAP_TOOLID_MODE:
  84 #endif
  85
  86                         Debug( LDAP_DEBUG_TRACE,
  87                                 "%s init: initiated %s.\n",
  88                                 name, mode == SLAP_TOOL_MODE ? "tool" : "server", 0 );
  89
  90                         slap_name = name;
  91
  92                         (void) ldap_pvt_thread_initialize();
  93
  94                         ldap_pvt_thread_mutex_init( &active_threads_mutex );
  95                         ldap_pvt_thread_cond_init( &active_threads_cond );
  96
  97                         ldap_pvt_thread_mutex_init( &currenttime_mutex );
  98                         ldap_pvt_thread_mutex_init( &entry2str_mutex );
  99                         ldap_pvt_thread_mutex_init( &replog_mutex );
 100                         ldap_pvt_thread_mutex_init( &ops_mutex );
 101                         ldap_pvt_thread_mutex_init( &num_sent_mutex );
 102
 103                         ldap_pvt_thread_mutex_init( &gmtime_mutex );
 104 #ifdef SLAPD_CRYPT
 105                         ldap_pvt_thread_mutex_init( &crypt_mutex );
 106 #endif
 107
 108                         rc = backend_init();
 109                         break;
 110
 111                 default:
 112                         Debug( LDAP_DEBUG_ANY,
 113                                 "%s init: undefined mode (%d).\n", name, mode, 0 );
 114                         rc = 1;
 115                         break;
 116         }
 117
 118         return rc;
 119 }
 120
 121 int slap_startup(int dbnum)
 122 {
 123         int rc;
 124
 125         Debug( LDAP_DEBUG_TRACE,
 126                 "%s startup: initiated.\n",
 127                 slap_name, 0, 0 );
 128
 129         rc = backend_startup(dbnum);
 130
 131         return rc;
 132 }
 133
 134 int slap_shutdown(int dbnum)
 135 {
 136         int rc;
 137
 138         Debug( LDAP_DEBUG_TRACE,
 139                 "%s shutdown: initiated\n",
 140                 slap_name, 0, 0 );
 141
 142         /* let backends do whatever cleanup they need to do */
 143         rc = backend_shutdown(dbnum);
 144
 145         return rc;
 146 }
 147
 148 int slap_destroy(void)
 149 {
 150         int rc;
 151
 152         Debug( LDAP_DEBUG_TRACE,
 153                 "%s shutdown: freeing system resources.\n",
 154                 slap_name, 0, 0 );
 155
 156         rc = backend_destroy();
 157
 158         /* should destory the above mutex */
 159         return rc;
 160 }
 161
 162 /* should create a utils.c for these */
 163
 164 void slap_set_time(void)
 165 {
 166         ldap_pvt_thread_mutex_lock( &currenttime_mutex );
 167         time( &currenttime );
 168         ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
 169 }
 170
 171 time_t slap_get_time(void)
 172 {
 173         time_t t;
 174         ldap_pvt_thread_mutex_lock( &currenttime_mutex );
 175         t = currenttime;
 176         ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
 177         return t;
 178 }