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