Diff for /servers/slapd/main.c between versions 1.198 and 1.198.2.17

version 1.198, 2004/12/04 18:41:58 version 1.198.2.17, 2005/11/26 23:54:48
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/servers/slapd/main.c,v 1.197 2004/11/20 00:27:03 ando Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/main.c,v 1.198.2.16 2005/11/14 18:06:08 kurt Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 1998-2004 The OpenLDAP Foundation.   * Copyright 1998-2005 The OpenLDAP Foundation.
  * All rights reserved.   * All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
Line 27 Line 27
   
 #include <stdio.h>  #include <stdio.h>
   
   #include <ac/ctype.h>
 #include <ac/socket.h>  #include <ac/socket.h>
 #include <ac/string.h>  #include <ac/string.h>
 #include <ac/time.h>  #include <ac/time.h>
Line 181  struct option_helper { Line 182  struct option_helper {
         const char      *oh_usage;          const char      *oh_usage;
 } option_helpers[] = {  } option_helpers[] = {
         { BER_BVC("slp"),       slapd_opt_slp,  NULL, "slp[={on|off}] enable/disable SLP" },          { BER_BVC("slp"),       slapd_opt_slp,  NULL, "slp[={on|off}] enable/disable SLP" },
         { BER_BVNULL }          { BER_BVNULL, 0, NULL, NULL }
 };  };
   
 static void  static void
Line 192  usage( char *name ) Line 193  usage( char *name )
         fprintf( stderr,          fprintf( stderr,
                 "\t-4\t\tIPv4 only\n"                  "\t-4\t\tIPv4 only\n"
                 "\t-6\t\tIPv6 only\n"                  "\t-6\t\tIPv6 only\n"
                 "\t-T {add|auth|cat|dn|index|passwd|test}\n"                  "\t-T {acl|add|auth|cat|dn|index|passwd|test}\n"
                 "\t\t\tRun in Tool mode\n"                  "\t\t\tRun in Tool mode\n"
                 "\t-c cookie\tSync cookie of consumer\n"                  "\t-c cookie\tSync cookie of consumer\n"
                 "\t-d level\tDebug level" "\n"                  "\t-d level\tDebug level" "\n"
                 "\t-f filename\tConfiguration file\n"                  "\t-f filename\tConfiguration file\n"
                   "\t-F dir\tConfiguration directory\n"
 #if defined(HAVE_SETUID) && defined(HAVE_SETGID)  #if defined(HAVE_SETUID) && defined(HAVE_SETGID)
                 "\t-g group\tGroup (id or name) to run as\n"                  "\t-g group\tGroup (id or name) to run as\n"
 #endif  #endif
Line 251  int main( int argc, char **argv ) Line 253  int main( int argc, char **argv )
         int g_argc = argc;          int g_argc = argc;
         char **g_argv = argv;          char **g_argv = argv;
   
 #ifdef HAVE_NT_SERVICE_MANAGER          char            *configfile = NULL;
         char            *configfile = ".\\slapd.conf";          char            *configdir = NULL;
 #else  
         char            *configfile = SLAPD_DEFAULT_CONFIGFILE;  
 #endif  
         char        *serverName;          char        *serverName;
         int         serverMode = SLAP_SERVER_MODE;          int         serverMode = SLAP_SERVER_MODE;
   
         struct berval cookie = BER_BVNULL;  
         struct sync_cookie *scp = NULL;          struct sync_cookie *scp = NULL;
         struct sync_cookie *scp_entry = NULL;          struct sync_cookie *scp_entry = NULL;
   
           char    *serverNamePrefix = "";
           size_t  l;
   
 #ifdef CSRIMALLOC  #ifdef CSRIMALLOC
         FILE *leakfile;          FILE *leakfile;
         if( ( leakfile = fopen( "slapd.leak", "w" )) == NULL ) {          if( ( leakfile = fopen( "slapd.leak", "w" )) == NULL ) {
                 leakfile = stderr;                  leakfile = stderr;
         }          }
 #endif  #endif
         char    *serverNamePrefix = "";  
         size_t  l;  
   
         slap_sl_mem_init();          slap_sl_mem_init();
   
           (void) ldap_pvt_thread_initialize();
   
         serverName = lutil_progname( "slapd", argc, argv );          serverName = lutil_progname( "slapd", argc, argv );
   
         if ( strcmp( serverName, "slapd" ) ) {          if ( strcmp( serverName, "slapd" ) ) {
Line 289  int main( int argc, char **argv ) Line 290  int main( int argc, char **argv )
         {          {
                 int *i;                  int *i;
                 char *newConfigFile;                  char *newConfigFile;
                   char *newConfigDir;
                 char *newUrls;                  char *newUrls;
                 char *regService = NULL;                  char *regService = NULL;
   
Line 320  int main( int argc, char **argv ) Line 322  int main( int argc, char **argv )
                         configfile = newConfigFile;                          configfile = newConfigFile;
                         Debug ( LDAP_DEBUG_ANY, "new config file from registry is: %s\n", configfile, 0, 0 );                          Debug ( LDAP_DEBUG_ANY, "new config file from registry is: %s\n", configfile, 0, 0 );
                 }                  }
   
                   newConfigDir = (char*)lutil_getRegParam( regService, "ConfigDir" );
                   if ( newConfigDir != NULL ) {
                           configdir = newConfigDir;
                           Debug ( LDAP_DEBUG_ANY, "new config dir from registry is: %s\n", configdir, 0, 0 );
                   }
         }          }
 #endif  #endif
   
         while ( (i = getopt( argc, argv,          while ( (i = getopt( argc, argv,
                              "c:d:f:h:n:o:s:StT:V"                               "c:d:f:F:h:n:o:s:tT:V"
 #if LDAP_PF_INET6  #if LDAP_PF_INET6
                                 "46"                                  "46"
 #endif  #endif
Line 356  int main( int argc, char **argv ) Line 364  int main( int argc, char **argv )
                 case 'c':       /* provide sync cookie, override if exist in replica */                  case 'c':       /* provide sync cookie, override if exist in replica */
                         scp = (struct sync_cookie *) ch_calloc( 1,                          scp = (struct sync_cookie *) ch_calloc( 1,
                                                                                 sizeof( struct sync_cookie ));                                                                                  sizeof( struct sync_cookie ));
                         ber_str2bv( optarg, strlen( optarg ), 1, &cookie );                          ber_str2bv( optarg, 0, 1, &scp->octet_str );
                         ber_bvarray_add( &scp->octet_str, &cookie );                          
                         slap_parse_sync_cookie( scp );                          /* This only parses out the rid at this point */
                           slap_parse_sync_cookie( scp, NULL );
   
                           if ( scp->rid == -1 ) {
                                   Debug( LDAP_DEBUG_ANY,
                                                   "main: invalid cookie \"%s\"\n",
                                                   optarg, 0, 0 );
                                   slap_sync_cookie_free( scp, 1 );
                                   goto destroy;
                           }
   
                         LDAP_STAILQ_FOREACH( scp_entry, &slap_sync_cookie, sc_next ) {                          LDAP_STAILQ_FOREACH( scp_entry, &slap_sync_cookie, sc_next ) {
                                 if ( scp->rid == scp_entry->rid ) {                                  if ( scp->rid == scp_entry->rid ) {
Line 375  int main( int argc, char **argv ) Line 392  int main( int argc, char **argv )
                 case 'd':       /* set debug level and 'do not detach' flag */                  case 'd':       /* set debug level and 'do not detach' flag */
                         no_detach = 1;                          no_detach = 1;
 #ifdef LDAP_DEBUG  #ifdef LDAP_DEBUG
                         slap_debug |= atoi( optarg );                          if ( optarg != NULL && optarg[ 0 ] != '-' && !isdigit( optarg[ 0 ] ) )
                           {
                                   int     level;
   
                                   if ( str2loglevel( optarg, &level ) ) {
                                           fprintf( stderr,
                                                   "unrecognized log level "
                                                   "\"%s\"\n", optarg );
                                           goto destroy;
                                   }
   
                                   slap_debug |= level;
                           } else {
                                   int     level;
   
                                   if ( lutil_atoix( &level, optarg, 0 ) != 0 ) {
                                           fprintf( stderr,
                                                   "unrecognized log level "
                                                   "\"%s\"\n", optarg );
                                           goto destroy;
                                   }
                                   slap_debug |= level;
                           }
 #else  #else
                         if ( atoi( optarg ) != 0 )                          if ( lutil_atoi( &level, optarg ) != 0 || level != 0 )
                                 fputs( "must compile with LDAP_DEBUG for debugging\n",                                  fputs( "must compile with LDAP_DEBUG for debugging\n",
                                        stderr );                                         stderr );
 #endif  #endif
Line 387  int main( int argc, char **argv ) Line 426  int main( int argc, char **argv )
                         configfile = ch_strdup( optarg );                          configfile = ch_strdup( optarg );
                         break;                          break;
   
                   case 'F':       /* use config dir */
                           configdir = ch_strdup( optarg );
                           break;
   
                 case 'o': {                  case 'o': {
                         char            *val = strchr( optarg, '=' );                          char            *val = strchr( optarg, '=' );
                         struct berval   opt;                          struct berval   opt;
Line 422  int main( int argc, char **argv ) Line 465  int main( int argc, char **argv )
                 }                  }
   
                 case 's':       /* set syslog level */                  case 's':       /* set syslog level */
                         ldap_syslog = atoi( optarg );                          if ( lutil_atoi( &ldap_syslog, optarg ) != 0 ) {
                                   fprintf( stderr, "unable to parse syslog level \"%s\"", optarg );
                                   goto destroy;
                           }
                         break;                          break;
   
 #ifdef LOG_LOCAL4  #ifdef LOG_LOCAL4
Line 499  unhandled_option:; Line 545  unhandled_option:;
                 }                  }
         }          }
   
         (void) ldap_pvt_thread_initialize();  
   
         ber_set_option(NULL, LBER_OPT_DEBUG_LEVEL, &slap_debug);          ber_set_option(NULL, LBER_OPT_DEBUG_LEVEL, &slap_debug);
         ldap_set_option(NULL, LDAP_OPT_DEBUG_LEVEL, &slap_debug);          ldap_set_option(NULL, LDAP_OPT_DEBUG_LEVEL, &slap_debug);
         ldif_debug = slap_debug;          ldif_debug = slap_debug;
Line 562  unhandled_option:; Line 606  unhandled_option:;
         lutil_passwd_init();          lutil_passwd_init();
         slap_op_init();          slap_op_init();
   
 #ifdef SLAPD_MODULES          rc = slap_init( serverMode, serverName );
         if ( module_init() != 0 ) {          if ( rc ) {
                 rc = 1;  
                 SERVICE_EXIT( ERROR_SERVICE_SPECIFIC_ERROR, 17 );  
                 goto destroy;  
         }  
 #endif  
   
         if ( slap_schema_init( ) != 0 ) {  
                 Debug( LDAP_DEBUG_ANY,  
                     "schema initialization error\n",  
                     0, 0, 0 );  
   
                 goto destroy;  
         }  
   
         if ( slap_init( serverMode, serverName ) != 0 ) {  
                 rc = 1;  
                 SERVICE_EXIT( ERROR_SERVICE_SPECIFIC_ERROR, 18 );                  SERVICE_EXIT( ERROR_SERVICE_SPECIFIC_ERROR, 18 );
                 goto destroy;                  goto destroy;
         }          }
   
         if ( slap_controls_init( ) != 0 ) {          if ( read_config( configfile, configdir ) != 0 ) {
                 Debug( LDAP_DEBUG_ANY,  
                     "controls initialization error\n",  
                     0, 0, 0 );  
   
                 goto destroy;  
         }  
   
 #ifdef HAVE_TLS  
         /* Library defaults to full certificate checking. This is correct when  
          * a client is verifying a server because all servers should have a  
          * valid cert. But few clients have valid certs, so we want our default  
          * to be no checking. The config file can override this as usual.  
          */  
         rc = 0;  
         (void) ldap_pvt_tls_set_option( NULL, LDAP_OPT_X_TLS_REQUIRE_CERT, &rc );  
 #endif  
   
 #ifdef LDAP_SLAPI  
         if ( slapi_int_initialize() != 0 ) {  
                 Debug( LDAP_DEBUG_ANY,  
                     "slapi initialization error\n",  
                     0, 0, 0 );  
   
                 goto destroy;  
         }  
 #endif /* LDAP_SLAPI */  
   
         if ( frontend_init() ) {  
                 goto destroy;  
         }  
   
         if ( overlay_init() ) {  
                 goto destroy;  
         }  
   
 #ifdef SLAP_DYNACL  
         if ( acl_init() ) {  
                 goto destroy;  
         }  
 #endif /* SLAP_DYNACL */  
   
         if ( read_config( configfile, 0 ) != 0 ) {  
                 rc = 1;                  rc = 1;
                 SERVICE_EXIT( ERROR_SERVICE_SPECIFIC_ERROR, 19 );                  SERVICE_EXIT( ERROR_SERVICE_SPECIFIC_ERROR, 19 );
   
Line 647  unhandled_option:; Line 633  unhandled_option:;
                 }                  }
         }          }
   
           if ( glue_sub_attach( ) != 0 ) {
                   Debug( LDAP_DEBUG_ANY,
                       "subordinate config error\n",
                       0, 0, 0 );
   
                   goto destroy;
           }
   
         if ( slap_schema_check( ) != 0 ) {          if ( slap_schema_check( ) != 0 ) {
                 Debug( LDAP_DEBUG_ANY,                  Debug( LDAP_DEBUG_ANY,
                     "schema prep error\n",                      "schema prep error\n",
Line 675  unhandled_option:; Line 669  unhandled_option:;
                 /* Force new ctx to be created */                  /* Force new ctx to be created */
                 ldap_pvt_tls_set_option( NULL, LDAP_OPT_X_TLS_CTX, NULL );                  ldap_pvt_tls_set_option( NULL, LDAP_OPT_X_TLS_CTX, NULL );
   
                 rc = ldap_pvt_tls_init_def_ctx();                  rc = ldap_pvt_tls_init_def_ctx( 1 );
                 if( rc != 0) {                  if( rc == 0 ) {
                           ldap_pvt_tls_get_option( NULL, LDAP_OPT_X_TLS_CTX, &slap_tls_ctx );
                           /* Restore previous ctx */
                           ldap_pvt_tls_set_option( NULL, LDAP_OPT_X_TLS_CTX, def_ctx );
                           load_extop( &slap_EXOP_START_TLS, 0, starttls_extop );
                   } else if ( rc != LDAP_NOT_SUPPORTED ) {
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                             "main: TLS init def ctx failed: %d\n",                              "main: TLS init def ctx failed: %d\n",
                             rc, 0, 0 );                              rc, 0, 0 );
Line 684  unhandled_option:; Line 683  unhandled_option:;
                         SERVICE_EXIT( ERROR_SERVICE_SPECIFIC_ERROR, 20 );                          SERVICE_EXIT( ERROR_SERVICE_SPECIFIC_ERROR, 20 );
                         goto destroy;                          goto destroy;
                 }                  }
                 /* Retrieve slapd's own ctx */  
                 ldap_pvt_tls_get_option( NULL, LDAP_OPT_X_TLS_CTX, &slap_tls_ctx );  
                 /* Restore previous ctx */  
                 ldap_pvt_tls_set_option( NULL, LDAP_OPT_X_TLS_CTX, def_ctx );  
         }          }
 #endif  #endif
   
Line 727  unhandled_option:; Line 722  unhandled_option:;
          */           */
         time( &starttime );          time( &starttime );
   
         if ( slap_startup( NULL )  != 0 ) {          if ( slap_startup( NULL ) != 0 ) {
                 rc = 1;                  rc = 1;
                 SERVICE_EXIT( ERROR_SERVICE_SPECIFIC_ERROR, 21 );                  SERVICE_EXIT( ERROR_SERVICE_SPECIFIC_ERROR, 21 );
                 goto shutdown;                  goto shutdown;
Line 735  unhandled_option:; Line 730  unhandled_option:;
   
         Debug( LDAP_DEBUG_ANY, "slapd starting\n", 0, 0, 0 );          Debug( LDAP_DEBUG_ANY, "slapd starting\n", 0, 0, 0 );
   
   
         if ( slapd_pid_file != NULL ) {          if ( slapd_pid_file != NULL ) {
                 FILE *fp = fopen( slapd_pid_file, "w" );                  FILE *fp = fopen( slapd_pid_file, "w" );
   
                 if( fp != NULL ) {                  if ( fp == NULL ) {
                         fprintf( fp, "%d\n", (int) getpid() );                          int save_errno = errno;
                         fclose( fp );  
   
                 } else {                          Debug( LDAP_DEBUG_ANY, "unable to open pid file "
                         free(slapd_pid_file);                                  "\"%s\": %d (%s)\n",
                                   slapd_pid_file,
                                   save_errno, strerror( save_errno ) );
   
                           free( slapd_pid_file );
                         slapd_pid_file = NULL;                          slapd_pid_file = NULL;
   
                           rc = 1;
                           goto shutdown;
                 }                  }
   
                   fprintf( fp, "%d\n", (int) getpid() );
                   fclose( fp );
         }          }
   
         if ( slapd_args_file != NULL ) {          if ( slapd_args_file != NULL ) {
                 FILE *fp = fopen( slapd_args_file, "w" );                  FILE *fp = fopen( slapd_args_file, "w" );
   
                 if( fp != NULL ) {                  if ( fp == NULL ) {
                         for ( i = 0; i < g_argc; i++ ) {                          int save_errno = errno;
                                 fprintf( fp, "%s ", g_argv[i] );  
                         }                          Debug( LDAP_DEBUG_ANY, "unable to open args file "
                         fprintf( fp, "\n" );                                  "\"%s\": %d (%s)\n",
                         fclose( fp );                                  slapd_args_file,
                 } else {                                  save_errno, strerror( save_errno ) );
                         free(slapd_args_file);  
                           free( slapd_args_file );
                         slapd_args_file = NULL;                          slapd_args_file = NULL;
   
                           rc = 1;
                           goto shutdown;
                 }                  }
   
                   for ( i = 0; i < g_argc; i++ ) {
                           fprintf( fp, "%s ", g_argv[i] );
                   }
                   fprintf( fp, "\n" );
                   fclose( fp );
         }          }
   
 #ifdef HAVE_NT_EVENT_LOG  #ifdef HAVE_NT_EVENT_LOG
         if (is_NT_Service)          if (is_NT_Service)
         lutil_LogStartedEvent( serverName, slap_debug, configfile, urls );          lutil_LogStartedEvent( serverName, slap_debug, configfile ?
                   configfile : SLAPD_DEFAULT_CONFIGFILE , urls );
 #endif  #endif
   
         rc = slapd_daemon();          rc = slapd_daemon();
Line 836  stop: Line 850  stop:
   
         config_destroy();          config_destroy();
   
           if ( configfile )
                   ch_free( configfile );
           if ( configdir )
                   ch_free( configdir );
           if ( urls )
                   ch_free( urls );
   
 #ifdef CSRIMALLOC  #ifdef CSRIMALLOC
         mal_dumpleaktrace( leakfile );          mal_dumpleaktrace( leakfile );
 #endif  #endif

Removed from v.1.198  
changed lines
  Added in v.1.198.2.17


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org