git.sur5r.net Git - openldap/blob - servers/slurpd/sanity.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright (c) 1996 Regents of the University of Michigan.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms are permitted
   7  * provided that this notice is preserved and that due credit is given
   8  * to the University of Michigan at Ann Arbor. The name of the University
   9  * may not be used to endorse or promote products derived from this
  10  * software without specific prior written permission. This software
  11  * is provided ``as is'' without express or implied warranty.
  12  */
  13
  14
  15 /*
  16  * sanity.c - perform sanity checks on the environment at startup time,
  17  * and report any errors before we disassociate from the controlling tty,
  18  * start up our threads, and do other stuff which makes it hard to give
  19  * feedback to the users.
  20  */
  21
  22 #include "portable.h"
  23
  24 #include <stdio.h>
  25
  26 #include <ac/unistd.h>
  27 #include <ac/string.h>
  28
  29 #include "slurp.h"
  30 #include "globals.h"
  31
  32 #define FC_DIRBAD       1
  33 #define FC_DIRUNREAD    2
  34 #define FC_DIRUNWRITE   4
  35 #define FC_FILEBAD      8
  36 #define FC_FILEUNREAD   16
  37 #define FC_FILEUNWRITE  32
  38
  39
  40 /*
  41  * Forward declarations
  42  */
  43 static unsigned int filecheck LDAP_P(( char * ));
  44
  45
  46
  47 /*
  48  * Take a look around to catch any fatal errors.  For example, make sure the
  49  * destination directory for our working files exists, check that all
  50  * pathnames make sense, and so on.  Returns 0 is everything's ok,
  51  # -1 if there's something wrong which will keep us from functioning
  52  * correctly.
  53  *
  54  * We do all these checks at startup so we can print a reasonable error
  55  * message on stderr before we disassociate from the controlling tty.  This
  56  * keeps some fatal error messages from "disappearing" into syslog.
  57  */
  58
  59 int
  60 sanity( void )
  61 {
  62     int err = 0;
  63     int rc;
  64
  65     /*
  66      * Are there any replicas listed in the slapd config file?
  67      */
  68     if ( sglob->replicas == NULL ) {
  69         fprintf( stderr, "No replicas in slapd config file \"%s\"!\n",
  70             sglob->slapd_configfile );
  71         err++;
  72     }
  73
  74     /*
  75      * Make sure the directory housing the slapd replogfile exists, and
  76      * that the slapd replogfile is readable, if it exists.
  77      */
  78     if ( sglob->slapd_replogfile == NULL ) {
  79         fprintf( stderr, "Fatal error: no \"replogfile\" directive given\n" );
  80         err++;
  81     } else {
  82         rc = filecheck( sglob->slapd_replogfile );
  83         if ( rc & FC_DIRBAD ) {
  84             fprintf( stderr, "Error: %s: directory does not exist\n",
  85                     sglob->slapd_replogfile );
  86             err++;
  87         } else if ( rc & FC_DIRUNREAD ) {
  88             fprintf( stderr, "Error: %s: directory not readable\n",
  89                     sglob->slapd_replogfile );
  90             err++;
  91         } else if (!( rc & FC_FILEBAD) && ( rc & FC_FILEUNREAD )) {
  92             fprintf( stderr, "Error: %s: file not readable\n",
  93                     sglob->slapd_replogfile );
  94             err++;
  95         }
  96     }
  97
  98     /*
  99      * Make sure the directory for the slurpd replogfile is there, and
 100      * that the slurpd replogfile is readable and writable, if it exists.
 101      */
 102     if ( sglob->slurpd_replogfile == NULL ) {
 103         fprintf( stderr, "Fatal error: no \"replogfile\" directive given\n" );
 104         err++;
 105     } else {
 106         rc = filecheck( sglob->slurpd_replogfile );
 107         if ( rc & FC_DIRBAD ) {
 108             fprintf( stderr, "Error: %s: directory does not exist\n",
 109                     sglob->slurpd_replogfile );
 110             err++;
 111         } else if ( rc & FC_DIRUNREAD ) {
 112             fprintf( stderr, "Error: %s: directory not readable\n",
 113                     sglob->slurpd_replogfile );
 114             err++;
 115         } else if ( !( rc & FC_FILEBAD ) && ( rc & FC_FILEUNREAD )) {
 116             fprintf( stderr, "Error: %s: file not readable\n",
 117                     sglob->slurpd_replogfile );
 118             err++;
 119         } else if ( !( rc & FC_FILEBAD ) && ( rc & FC_FILEUNWRITE )) {
 120             fprintf( stderr, "Error: %s: file not writeable\n",
 121                     sglob->slurpd_replogfile );
 122             err++;
 123         }
 124     }
 125
 126     /*
 127      * Make sure that the directory for the slurpd status file is there, and
 128      * that the slurpd status file is writable, if it exists.
 129      */
 130     rc = filecheck( sglob->slurpd_status_file );
 131     if ( rc & FC_DIRBAD ) {
 132         fprintf( stderr, "Error: %s: directory does not exist\n",
 133                 sglob->slurpd_status_file );
 134         err++;
 135     } else if ( rc & FC_DIRUNREAD ) {
 136         fprintf( stderr, "Error: %s: directory not readable\n",
 137                 sglob->slurpd_status_file );
 138         err++;
 139     } else if ( !( rc & FC_FILEBAD ) && ( rc & FC_FILEUNREAD )) {
 140         fprintf( stderr, "Error: %s: file not readable\n",
 141                 sglob->slurpd_status_file );
 142         err++;
 143     } else if ( !( rc & FC_FILEBAD ) && ( rc & FC_FILEUNWRITE )) {
 144         fprintf( stderr, "Error: %s: file not writeable\n",
 145                 sglob->slurpd_status_file );
 146         err++;
 147     }
 148
 149     return ( err == 0 ? 0 : -1 );
 150 }
 151
 152
 153
 154 /*
 155  * Check for the existence of the file and directory leading to the file.
 156  * Returns a bitmask which is the logical OR of the following flags:
 157  *
 158  *  FC_DIRBAD:          directory containing "f" does not exist.
 159  *  FC_DIRUNREAD:       directory containing "f" exists but is not readable.
 160  *  FC_DIRUNWRITE:      directory containing "f" exists but is not writable.
 161  *  FC_FILEBAD:         "f" does not exist.
 162  *  FC_FILEUNREAD:      "f" exists but is unreadable.
 163  *  FC_FILEUNWRITE:     "f" exists but is unwritable.
 164  *
 165  * The calling routine is responsible for determining which, if any, of
 166  * the returned flags is a problem for a particular file.
 167  */
 168 static unsigned int
 169 filecheck(
 170     char        *f
 171 )
 172 {
 173     char                dir[ MAXPATHLEN ];
 174     char                *p;
 175     unsigned int        ret = 0;
 176
 177     strcpy( dir, sglob->slapd_replogfile );
 178     p = strrchr( dir, '/' );
 179     if ( p != NULL ) {
 180         *p = '\0';
 181     }
 182     if ( access( dir, F_OK ) < 0 ) {
 183         ret |= FC_DIRBAD;
 184     }
 185     if ( access( dir, R_OK ) < 0 ) {
 186         ret |= FC_DIRUNREAD;
 187     }
 188     if ( access( dir, W_OK ) < 0 ) {
 189         ret |= FC_DIRUNWRITE;
 190     }
 191     if ( access( f, F_OK ) < 0 ) {
 192         ret |= FC_FILEBAD;
 193     }
 194     if ( access( f, R_OK ) < 0 ) {
 195         ret |= FC_FILEUNREAD;
 196     }
 197     if ( access( f, W_OK ) < 0 ) {
 198         ret |= FC_FILEUNWRITE;
 199     }
 200
 201     return ret;
 202 }