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

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