git.sur5r.net Git - openldap/blob - servers/slurpd/st.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  * st.c - routines for managing the status structure, and for reading and
  17  * writing status information to disk.
  18  */
  19
  20 #include "portable.h"
  21
  22 #include <stdio.h>
  23
  24 #include <ac/stdlib.h>
  25 #include <ac/string.h>
  26 #include <ac/unistd.h>
  27
  28 #include "slurp.h"
  29 #include "globals.h"
  30
  31 /*
  32  * Add information about replica host specified by Ri to list
  33  * of hosts.
  34  */
  35 static Stel *
  36 St_add(
  37     St  *st,
  38     Ri  *ri
  39 )
  40 {
  41     int ind;
  42
  43     if ( st == NULL || ri == NULL ) {
  44         return NULL;
  45     }
  46
  47     /* Serialize access to the St struct */
  48     ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
  49
  50     st->st_nreplicas++;
  51     ind = st->st_nreplicas - 1;
  52     st->st_data = ( Stel ** ) ch_realloc( st->st_data,
  53             ( st->st_nreplicas * sizeof( Stel * )));
  54     if ( st->st_data == NULL ) {
  55         ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
  56         return NULL;
  57     }
  58     st->st_data[ ind ]  = ( Stel * ) ch_malloc( sizeof( Stel ) );
  59     if ( st->st_data[ ind ] == NULL ) {
  60         ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
  61         return NULL;
  62     }
  63
  64     st->st_data[ ind ]->hostname = strdup( ri->ri_hostname );
  65     st->st_data[ ind ]->port = ri->ri_port;
  66     memset( st->st_data[ ind ]->last, 0, sizeof( st->st_data[ ind ]->last ));
  67     st->st_data[ ind ]->seq = 0;
  68
  69     ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
  70     return st->st_data[ ind ];
  71 }
  72
  73
  74
  75 /*
  76  * Write the contents of an St to disk.
  77  */
  78 static int
  79 St_write (
  80     St  *st
  81 )
  82 {
  83     int         rc;
  84     Stel        *stel;
  85     int         i;
  86
  87     if ( st == NULL ) {
  88         return -1;
  89     }
  90     ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
  91     if ( st->st_fp == NULL ) {
  92         /* Open file */
  93         if (( rc = acquire_lock( sglob->slurpd_status_file, &(st->st_fp),
  94                 &(st->st_lfp))) < 0 ) {
  95             if ( !st->st_err_logged ) {
  96                 Debug( LDAP_DEBUG_ANY,
  97                         "Error: cannot open status file \"%s\": %s\n",
  98                         sglob->slurpd_status_file, sys_errlist[ errno ], 0 );
  99                 st->st_err_logged = 1;
 100                 ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
 101                 return -1;
 102             }
 103         } else {
 104             st->st_err_logged = 0;
 105         }
 106     }
 107
 108     /* Write data to the file */
 109     truncate( sglob->slurpd_status_file, 0L );
 110     fseek( st->st_fp, 0L, 0 );
 111     for ( i = 0; i < st->st_nreplicas; i++ ) {
 112         stel = st->st_data[ i ];
 113         fprintf( st->st_fp, "%s:%d:%s:%d\n", stel->hostname, stel->port,
 114                 stel->last, stel->seq );
 115     }
 116     fflush( st->st_fp );
 117
 118     ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
 119
 120     return 0;
 121 }
 122
 123
 124
 125
 126 /*
 127  * Update the entry for a given host.
 128  */
 129 static int
 130 St_update(
 131     St          *st,
 132     Stel        *stel,
 133     Re          *re
 134 )
 135 {
 136     if ( stel == NULL || re == NULL ) {
 137         return -1;
 138     }
 139
 140     ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
 141     strcpy( stel->last, re->re_timestamp );
 142     stel->seq = re->re_seq;
 143     ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
 144     return 0;
 145 }
 146
 147
 148
 149
 150 /*
 151  * Read status information from disk file.
 152  */
 153 static int
 154 St_read(
 155     St  *st
 156 )
 157 {
 158     FILE        *fp;
 159     FILE        *lfp;
 160     char        buf[ 255 ];
 161     int         i;
 162     int         rc;
 163     char        *hostname, *port, *timestamp, *seq, *p, *t;
 164     int         found;
 165
 166     if ( st == NULL ) {
 167         return -1;
 168     }
 169     ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
 170     if ( access( sglob->slurpd_status_file, F_OK ) < 0 ) {
 171         /*
 172          * File doesn't exist, so create it and return.
 173          */
 174         if (( fp = fopen( sglob->slurpd_status_file, "w" )) == NULL ) {
 175             Debug( LDAP_DEBUG_ANY, "Error: cannot create status file \"%s\"\n",
 176                     sglob->slurpd_status_file, 0, 0 );
 177             ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
 178             return -1;
 179         }
 180         (void) fclose( fp );
 181         ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
 182         Debug( LDAP_DEBUG_ARGS, "No status file found, defaulting values\n",
 183                 0, 0, 0 );
 184         return 0;
 185     }
 186     if (( rc = acquire_lock( sglob->slurpd_status_file, &fp, &lfp)) < 0 ) {
 187         ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
 188         return 0;
 189     }
 190     while ( fgets( buf, sizeof( buf ), fp ) != NULL ) {
 191         p = buf;
 192         hostname = p;
 193         if (( t = strchr( p, ':' )) == NULL ) {
 194             goto bad;
 195         }
 196         *t++ = '\0';
 197         p = t;
 198         port = p;
 199         if (( t = strchr( p, ':' )) == NULL ) {
 200             goto bad;
 201         }
 202         *t++ = '\0';
 203         p = t;
 204         timestamp = p;
 205         if (( t = strchr( p, ':' )) == NULL ) {
 206             goto bad;
 207         }
 208         *t++ = '\0';
 209         seq = t;
 210         if (( t = strchr( seq, '\n' )) != NULL ) {
 211             *t = '\0';
 212         }
 213
 214         found = 0;
 215         for ( i = 0; i < sglob->st->st_nreplicas; i++ ) {
 216             if ( !strcmp( hostname, sglob->st->st_data[ i ]->hostname ) &&
 217                     atoi( port ) == sglob->st->st_data[ i ]->port ) {
 218                 found = 1;
 219                 strcpy( sglob->st->st_data[ i ]->last, timestamp );
 220                 sglob->st->st_data[ i ]->seq = atoi( seq );
 221                 break;
 222             }
 223         }
 224         if ( found ) {
 225             char tbuf[ 255 ];
 226             sprintf( tbuf, "%s:%s (timestamp %s.%s)", hostname, port,
 227                     timestamp, seq );
 228             Debug( LDAP_DEBUG_ARGS,
 229                     "Retrieved state information for %s\n", tbuf, 0, 0 );
 230         } else {
 231             Debug(  LDAP_DEBUG_ANY,
 232                     "Warning: saved state for %s:%s, not a known replica\n",
 233                     hostname, port, 0 );
 234         }
 235     }
 236     (void) relinquish_lock( sglob->slurpd_status_file, fp, lfp);
 237     ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
 238     return 0;
 239
 240 bad:
 241     (void) relinquish_lock( sglob->slurpd_status_file, fp, lfp);
 242     ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
 243     return -1;
 244 }
 245
 246
 247
 248
 249 /*
 250  * Lock an St struct.
 251  */
 252 static int
 253 St_lock(
 254     St *st
 255 )
 256 {
 257     return( ldap_pvt_thread_mutex_lock( &st->st_mutex ));
 258 }
 259
 260
 261
 262
 263 /*
 264  * Lock an St struct.
 265  */
 266 static int
 267 St_unlock(
 268     St *st
 269 )
 270 {
 271     return( ldap_pvt_thread_mutex_unlock( &st->st_mutex ));
 272 }
 273
 274
 275
 276
 277 /*
 278  * Allocate and initialize an St struct.
 279  */
 280 int
 281 St_init(
 282     St **st
 283 )
 284 {
 285     if ( st == NULL ) {
 286         return -1;
 287     }
 288
 289     (*st) = (St *) malloc( sizeof( St ));
 290     if ( *st == NULL ) {
 291         return -1;
 292     }
 293
 294     ldap_pvt_thread_mutex_init( &((*st)->st_mutex) );
 295     (*st)->st_data = NULL;
 296     (*st)->st_fp = NULL;
 297     (*st)->st_lfp = NULL;
 298     (*st)->st_nreplicas = 0;
 299     (*st)->st_err_logged = 0;
 300     (*st)->st_update = St_update;
 301     (*st)->st_add = St_add;
 302     (*st)->st_write = St_write;
 303     (*st)->st_read = St_read;
 304     (*st)->st_lock = St_lock;
 305     (*st)->st_unlock = St_unlock;
 306     return 0;
 307 }
 308