]> git.sur5r.net Git - openldap/blob - servers/slurpd/st.c
Don't defer abandon due to pending
[openldap] / servers / slurpd / st.c
1 /* $OpenLDAP$ */
2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
3  *
4  * Copyright 1998-2004 The OpenLDAP Foundation.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted only as authorized by the OpenLDAP
9  * Public License.
10  *
11  * A copy of this license is available in file LICENSE in the
12  * top-level directory of the distribution or, alternatively, at
13  * <http://www.OpenLDAP.org/license.html>.
14  */
15 /* Portions Copyright (c) 1996 Regents of the University of Michigan.
16  * All rights reserved.
17  *
18  * Redistribution and use in source and binary forms are permitted
19  * provided that this notice is preserved and that due credit is given
20  * to the University of Michigan at Ann Arbor. The name of the University
21  * may not be used to endorse or promote products derived from this
22  * software without specific prior written permission. This software
23  * is provided ``as is'' without express or implied warranty.
24  */
25 /* ACKNOWLEDGEMENTS:
26  * This work was originally developed by the University of Michigan
27  * (as part of U-MICH LDAP).
28  */
29
30
31 /*
32  * st.c - routines for managing the status structure, and for reading and
33  * writing status information to disk.
34  */
35
36 #include "portable.h"
37
38 #include <stdio.h>
39
40 #include <ac/stdlib.h>
41 #include <ac/string.h>
42 #include <ac/unistd.h>
43
44 #include "slurp.h"
45 #include "globals.h"
46
47 /*
48  * Add information about replica host specified by Ri to list
49  * of hosts.
50  */
51 static Stel *
52 St_add(
53     St  *st,
54     Ri  *ri
55 )
56 {
57     int ind;
58
59     if ( st == NULL || ri == NULL ) {
60         return NULL;
61     }
62
63     /* Serialize access to the St struct */
64     ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
65
66     st->st_nreplicas++;
67     ind = st->st_nreplicas - 1;
68     st->st_data = ( Stel ** ) ch_realloc( st->st_data, 
69             ( st->st_nreplicas * sizeof( Stel * )));
70     if ( st->st_data == NULL ) {
71         ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
72         return NULL;
73     }
74     st->st_data[ ind ]  = ( Stel * ) ch_malloc( sizeof( Stel ) );
75     if ( st->st_data[ ind ] == NULL ) {
76         ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
77         return NULL;
78     }
79
80     st->st_data[ ind ]->hostname = strdup( ri->ri_hostname );
81     st->st_data[ ind ]->port = ri->ri_port;
82     st->st_data[ ind ]->last = 0; 
83     st->st_data[ ind ]->seq = 0;
84
85     ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
86     return st->st_data[ ind ];
87 }
88
89
90
91 /*
92  * Write the contents of an St to disk.
93  */
94 static int
95 St_write (
96     St  *st
97 )
98 {
99     int         rc;
100     Stel        *stel;
101     int         i;
102
103     if ( st == NULL ) {
104         return -1;
105     }
106     ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
107     if ( st->st_fp == NULL ) {
108         /* Open file */
109         if (( rc = acquire_lock( sglob->slurpd_status_file, &(st->st_fp),
110                 &(st->st_lfp))) < 0 ) {
111             if ( !st->st_err_logged ) {
112 #ifdef NEW_LOGGING
113                 LDAP_LOG ( SLURPD, ERR, "St_write: "
114                         "Error: cannot open status file \"%s\":%s\n",
115                         sglob->slurpd_status_file, sys_errlist[ errno ], 0 );
116 #else
117                 Debug( LDAP_DEBUG_ANY,
118                         "Error: cannot open status file \"%s\": %s\n",
119                         sglob->slurpd_status_file, sys_errlist[ errno ], 0 );
120 #endif
121                 st->st_err_logged = 1;
122                 ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
123                 return -1;
124             }
125         } else {
126             st->st_err_logged = 0;
127         }
128     }
129
130     /* Write data to the file */
131     truncate( sglob->slurpd_status_file, 0L );
132     fseek( st->st_fp, 0L, 0 );
133     for ( i = 0; i < st->st_nreplicas; i++ ) {
134         stel = st->st_data[ i ];
135         fprintf( st->st_fp, "%s:%d:%ld:%d\n",
136                 stel->hostname, stel->port,
137                 (long) stel->last, stel->seq );
138     }
139     fflush( st->st_fp );
140
141     ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
142
143     return 0;
144 }
145     
146
147
148
149 /*
150  * Update the entry for a given host.
151  */
152 static int
153 St_update(
154     St          *st,
155     Stel        *stel,
156     Re          *re
157 )
158 {
159     if ( stel == NULL || re == NULL ) {
160         return -1;
161     }
162
163     ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
164     stel->last = re->re_timestamp;
165     stel->seq = re->re_seq;
166     ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
167     return 0;
168 }
169
170
171
172
173 /*
174  * Read status information from disk file.
175  */
176 static int
177 St_read(
178     St  *st
179 )
180 {
181     FILE        *fp;
182     FILE        *lfp;
183     char        buf[ 255 ];
184     int         i;
185     int         rc;
186     char        *hostname, *port, *timestamp, *seq, *p, *t;
187     int         found;
188
189     if ( st == NULL ) {
190         return -1;
191     }
192     ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
193     if ( access( sglob->slurpd_status_file, F_OK ) < 0 ) {
194         /*
195          * File doesn't exist, so create it and return.
196          */
197         if (( fp = fopen( sglob->slurpd_status_file, "w" )) == NULL ) {
198 #ifdef NEW_LOGGING
199                 LDAP_LOG ( SLURPD, ERR, "St_write: "
200                         "Error: cannot create status file \"%s\"\n",
201                     sglob->slurpd_status_file, 0, 0 );
202 #else
203             Debug( LDAP_DEBUG_ANY, "Error: cannot create status file \"%s\"\n",
204                     sglob->slurpd_status_file, 0, 0 );
205 #endif
206             ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
207             return -1;
208         }
209         (void) fclose( fp );
210         ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
211 #ifdef NEW_LOGGING
212         LDAP_LOG ( SLURPD, DETAIL1, "St_write: "
213                 "No status file found, defaulting values\n", 0, 0, 0 );
214 #else
215         Debug( LDAP_DEBUG_ARGS, "No status file found, defaulting values\n",
216                 0, 0, 0 );
217 #endif
218         return 0;
219     }
220     if (( rc = acquire_lock( sglob->slurpd_status_file, &fp, &lfp)) < 0 ) {
221         ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
222         return 0;
223     }
224     while ( fgets( buf, sizeof( buf ), fp ) != NULL ) {
225         p = buf;
226         hostname = p;
227         if (( t = strchr( p, ':' )) == NULL ) {
228             goto bad;
229         }
230         *t++ = '\0';
231         p = t;
232         port = p;
233         if (( t = strchr( p, ':' )) == NULL ) {
234             goto bad;
235         }
236         *t++ = '\0';
237         p = t;
238         timestamp = p;
239         if (( t = strchr( p, ':' )) == NULL ) {
240             goto bad;
241         }
242         *t++ = '\0';
243         seq = t;
244         if (( t = strchr( seq, '\n' )) != NULL ) {
245             *t = '\0';
246         }
247
248         found = 0;
249         for ( i = 0; i < sglob->st->st_nreplicas; i++ ) {
250             if ( !strcmp( hostname, sglob->st->st_data[ i ]->hostname ) &&
251                     atoi( port ) == sglob->st->st_data[ i ]->port ) {
252                 found = 1;
253                 sglob->st->st_data[ i ]->last = atol( timestamp );
254                 sglob->st->st_data[ i ]->seq = atoi( seq );
255                 break;
256             }
257         }
258         if ( found ) {
259             char tbuf[ 255 ];
260             sprintf( tbuf, "%s:%s (timestamp %s.%s)", hostname, port,
261                     timestamp, seq );
262 #ifdef NEW_LOGGING
263                 LDAP_LOG ( SLURPD, DETAIL1, "St_write: "
264                         "Retrieved state information for %s\n", tbuf, 0, 0 );
265 #else
266             Debug( LDAP_DEBUG_ARGS,
267                     "Retrieved state information for %s\n", tbuf, 0, 0 );
268 #endif
269         } else {
270 #ifdef NEW_LOGGING
271                 LDAP_LOG ( SLURPD, WARNING, "St_write: "
272                         "Warning: saved state for %s:%s, not a known replica\n", 
273                         hostname, port, 0 );
274 #else
275             Debug(  LDAP_DEBUG_ANY,
276                     "Warning: saved state for %s:%s, not a known replica\n",
277                     hostname, port, 0 );
278 #endif
279         }
280     }
281     (void) relinquish_lock( sglob->slurpd_status_file, fp, lfp);
282     ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
283     return 0;
284
285 bad:
286     (void) relinquish_lock( sglob->slurpd_status_file, fp, lfp);
287     ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
288     return -1;
289 }
290     
291
292
293
294 /*
295  * Lock an St struct.
296  */
297 static int
298 St_lock(
299     St *st
300 )
301 {
302     return( ldap_pvt_thread_mutex_lock( &st->st_mutex ));
303 }
304
305
306
307
308 /*
309  * Lock an St struct.
310  */
311 static int
312 St_unlock(
313     St *st
314 )
315 {
316     return( ldap_pvt_thread_mutex_unlock( &st->st_mutex ));
317 }
318
319
320
321
322 /*
323  * Allocate and initialize an St struct.
324  */
325 int
326 St_init(
327     St **st
328 )
329 {
330     if ( st == NULL ) {
331         return -1;
332     }
333
334     (*st) = (St *) malloc( sizeof( St ));
335     if ( *st == NULL ) {
336         return -1;
337     }
338
339     ldap_pvt_thread_mutex_init( &((*st)->st_mutex) );
340     (*st)->st_data = NULL;
341     (*st)->st_fp = NULL;
342     (*st)->st_lfp = NULL;
343     (*st)->st_nreplicas = 0;
344     (*st)->st_err_logged = 0;
345     (*st)->st_update = St_update;
346     (*st)->st_add = St_add;
347     (*st)->st_write = St_write;
348     (*st)->st_read = St_read;
349     (*st)->st_lock = St_lock;
350     (*st)->st_unlock = St_unlock;
351     return 0;
352 }
353