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

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