2 * Copyright (c) 1996 Regents of the University of Michigan.
5 * Redistribution and use in source and binary forms are permitted
6 * provided that this notice is preserved and that due credit is given
7 * to the University of Michigan at Ann Arbor. The name of the University
8 * may not be used to endorse or promote products derived from this
9 * software without specific prior written permission. This software
10 * is provided ``as is'' without express or implied warranty.
14 * re.c - routines which deal with Re (Replication entry) structures.
15 * An Re struct is an in-core representation of one replication to
16 * be performed, along with member functions which are called by other
17 * routines. The Re struct is defined in slurp.h.
23 #include <sys/types.h>
24 #include <sys/socket.h>
26 #include "../slapd/slap.h"
31 extern char *str_getline( char **next );
32 extern void ch_free( char *p );
34 #ifndef SYSERRLIST_IN_STDIO
35 extern char *sys_errlist[];
36 #endif /* SYSERRLIST_IN_STDIO
38 /* Forward references */
39 static Rh *get_repl_hosts( char *, int *, char ** );
40 static int gettype( char * );
41 static int getchangetype( char *);
42 static int Re_parse( Re *re, char *replbuf );
43 static void Re_dump( Re *re, FILE *fp );
44 static void warn_unknown_replica( char *, int port );
46 /* Globals, scoped within this file */
47 static int nur = 0; /* Number of unknown replicas */
48 static Rh *ur = NULL; /* array of unknown replica names */
52 * Return the next Re in a linked list.
59 return(( re == NULL ) ? NULL : re->re_next );
80 if ( re->re_refcnt > 0 ) {
81 Debug( LDAP_DEBUG_ANY,
82 "Warning: freeing re (dn: %s) with nonzero refcnt\n",
85 #if !defined( THREAD_SUNOS4_LWP )
86 /* This seems to have problems under SunOS lwp */
87 pthread_mutex_destroy( &re->re_mutex );
88 #endif /* THREAD_SUNOS4_LWP */
89 ch_free( re->re_timestamp );
90 if (( rh = re->re_replicas ) != NULL ) {
91 for ( i = 0; rh[ i ].rh_hostname != NULL; i++ ) {
92 free( rh[ i ].rh_hostname );
97 if (( mi = re->re_mods ) != NULL ) {
98 for ( i = 0; mi[ i ].mi_type != NULL; i++ ) {
99 free( mi[ i ].mi_type );
100 ch_free( mi[ i ].mi_val );
111 * Read a buffer of data from a replication log file and fill in
112 * an (already allocated) Re.
118 #define GOT_CHANGETYPE 4
119 #define GOT_ALL ( GOT_DN | GOT_TIME | GOT_CHANGETYPE )
136 Debug( LDAP_DEBUG_ANY, "Re_parse: error: re is NULL\n", 0, 0, 0 );
139 if ( replbuf == NULL ) {
140 Debug( LDAP_DEBUG_ANY, "Re_parse: error: replbuf is NULL\n", 0, 0, 0 );
145 nml = 0; /* number of modification information entries */
148 re->re_replicas = get_repl_hosts( replbuf, &nreplicas, &rp );
149 re->re_refcnt = sglob->num_replicas;
152 if (( state == GOT_ALL ) || ( buf = str_getline( &rp )) == NULL ) {
156 * If we're processing a rejection log, then the first line
157 * of each replication record will begin with "ERROR" - just
160 if ( strncmp( buf, ERROR_STR, strlen( ERROR_STR )) == 0 ) {
163 buflen = ( long ) strlen( buf );
164 if ( str_parse_line( buf, &type, &value, &len ) < 0 ) {
165 Debug( LDAP_DEBUG_ANY,
166 "Error: Re_parse: malformed replog file\n",
170 switch ( gettype( type )) {
172 re->re_changetype = getchangetype( value );
173 state |= GOT_CHANGETYPE;
176 if (( p = strchr( value, '.' )) != NULL ) {
177 /* there was a sequence number */
180 re->re_timestamp = strdup( value );
181 if ( p != NULL && isdigit( *p )) {
182 re->re_seq = atoi( p );
187 re->re_dn = strdup( value );
191 if ( !( state == GOT_ALL )) {
192 Debug( LDAP_DEBUG_ANY,
193 "Error: Re_parse: bad type <%s>\n",
200 if ( state != GOT_ALL ) {
201 Debug( LDAP_DEBUG_ANY,
202 "Error: Re_parse: malformed replog file\n",
208 if (( buf = str_getline( &rp )) == NULL ) {
211 buflen = ( long ) strlen( buf );
212 if (( buflen == 1 ) && ( buf[ 0 ] == '-' )) {
216 if ( str_parse_line( buf, &type, &value, &len ) < 0 ) {
217 Debug( LDAP_DEBUG_ANY,
218 "Error: malformed replog line \"%s\"\n",
223 re->re_mods = ( Mi *) ch_realloc( (char *) re->re_mods,
224 sizeof( Mi ) * ( nml + 2 ));
225 re->re_mods[ nml ].mi_type = strdup( type );
226 if ( value != NULL ) {
227 re->re_mods[ nml ].mi_val = strdup( value );
228 re->re_mods[ nml ].mi_len = len;
230 re->re_mods[ nml ].mi_val = NULL;
231 re->re_mods[ nml ].mi_len = 0;
233 re->re_mods[ nml + 1 ].mi_type = NULL;
234 re->re_mods[ nml + 1 ].mi_val = NULL;
243 * Extract the replication hosts from a repl buf. Check to be sure that
244 * each replica host and port number are ones we know about (that is, they're
245 * in the slapd config file we read at startup). Without that information
246 * from the config file, we won't have the appropriate credentials to
247 * make modifications. If there are any unknown replica names, don't
248 * add them the the Re struct. Instead, log a warning message.
257 char buf[ LINE_WIDTH + 1 ];
258 char *type, *value, *line, *p;
265 if ( replbuf == NULL ) {
272 * Get the host names of the replicas
277 /* If this is a reject log, we need to skip over the ERROR: line */
278 if ( !strncmp( *r_rp, ERROR_STR, strlen( ERROR_STR ))) {
279 line = str_getline( r_rp );
280 if ( line == NULL ) {
284 if ( strncasecmp( *r_rp, "replica:", 7 )) {
287 line = str_getline( r_rp );
288 if ( line == NULL ) {
291 if ( str_parse_line( line, &type, &value, &len ) < 0 ) {
295 if (( p = strchr( value, ':' )) != NULL ) {
303 /* Verify that we've heard of this replica before */
305 for ( i = 0; i < sglob->num_replicas; i++ ) {
306 if ( strcmp( sglob->replicas[ i ]->ri_hostname, value )) {
309 if ( sglob->replicas[ i ]->ri_port == port ) {
315 warn_unknown_replica( value, port );
319 rh = (Rh *) ch_realloc((char *) rh, ( nreplicas + 2 ) * sizeof( Rh ));
321 Debug( LDAP_DEBUG_ANY, "Out of memory in get_repl_hosts\n",
325 rh[ nreplicas ].rh_hostname = strdup( value );
326 rh[ nreplicas ].rh_port = port;
330 if ( nreplicas == 0 ) {
334 rh[ nreplicas ].rh_hostname = NULL;
335 *r_nreplicas = nreplicas;
345 * Convert "type" to an int.
352 if ( !strcmp( type, T_CHANGETYPESTR )) {
353 return( T_CHANGETYPE );
355 if ( !strcmp( type, T_TIMESTR )) {
358 if ( !strcmp( type, T_DNSTR )) {
367 * Convert "changetype" to an int.
374 if ( !strcmp( changetype, T_ADDCTSTR )) {
377 if ( !strcmp( changetype, T_MODIFYCTSTR )) {
378 return( T_MODIFYCT );
380 if ( !strcmp( changetype, T_DELETECTSTR )) {
381 return( T_DELETECT );
383 if ( !strcmp( changetype, T_MODRDNCTSTR )) {
384 return( T_MODRDNCT );
393 * Find the first line which is not a "replica:" line in buf.
394 * Returns a pointer to the line. Returns NULL if there are
395 * only "replica:" lines in buf.
404 if ( strncasecmp( p, "replica:", 8 )) {
407 while (( *p != '\0' ) && ( *p != '\n' )) {
422 * For debugging purposes: dump the contents of a replication entry.
423 * to the given stream.
435 Debug( LDAP_DEBUG_TRACE, "Re_dump: re is NULL\n", 0, 0, 0 );
438 fprintf( fp, "Re_dump: ******\n" );
439 fprintf( fp, "re_refcnt: %d\n", re->re_refcnt );
440 fprintf( fp, "re_timestamp: %s\n", re->re_timestamp );
441 fprintf( fp, "re_seq: %d\n", re->re_seq );
442 for ( i = 0; re->re_replicas && re->re_replicas[ i ].rh_hostname != NULL;
444 fprintf( fp, "re_replicas[%d]: %s:%d\n",
445 i, re->re_replicas[ i ].rh_hostname,
446 re->re_replicas[ i ].rh_port );
448 fprintf( fp, "re_dn: %s\n", re->re_dn );
449 switch ( re->re_changetype ) {
451 fprintf( fp, "re_changetype: add\n" );
454 fprintf( fp, "re_changetype: modify\n" );
457 fprintf( fp, "re_changetype: delete\n" );
460 fprintf( fp, "re_changetype: modrdn\n" );
463 fprintf( fp, "re_changetype: (unknown, type = %d\n",
466 if ( re->re_mods == NULL ) {
467 fprintf( fp, "re_mods: (none)\n" );
470 fprintf( fp, "re_mods:\n" );
471 for ( i = 0; mi[ i ].mi_type != NULL; i++ ) {
472 fprintf( fp, " %s, \"%s\", (%d bytes)\n",
474 mi[ i ].mi_val == NULL ? "(null)" : mi[ i ].mi_val,
483 * Given an Ri, an Re, and a file pointer, write a replication record to
484 * the file pointer. If ri is NULL, then include all replicas in the
485 * output. If ri is non-NULL, then only include a single "replica:" line
486 * (used when writing rejection records). Returns 0 on success, -1
487 * on failure. Note that Re_write will not write anything out if the
501 if ( re == NULL || fp == NULL ) {
502 Debug( LDAP_DEBUG_ANY, "Internal error: Re_write: NULL argument\n",
507 if ( re->re_refcnt < 1 ) {
508 return 0; /* this is not an error */
511 if ( ri != NULL ) { /* write a single "replica:" line */
512 if ( fprintf( fp, "replica: %s:%d\n", ri->ri_hostname,
513 ri->ri_port ) < 0 ) {
517 } else { /* write multiple "replica:" lines */
518 for ( i = 0; re->re_replicas[ i ].rh_hostname != NULL; i++ ) {
519 if ( fprintf( fp, "replica: %s:%d\n",
520 re->re_replicas[ i ].rh_hostname,
521 re->re_replicas[ i ].rh_port ) < 0 ) {
527 if ( fprintf( fp, "time: %s.%d\n", re->re_timestamp, re->re_seq ) < 0 ) {
531 if ( fprintf( fp, "dn: %s\n", re->re_dn ) < 0 ) {
535 if ( fprintf( fp, "changetype: " ) < 0 ) {
539 switch ( re->re_changetype ) {
553 s = "IllegalModifyType!!!";
555 if ( fprintf( fp, "%s\n", s ) < 0 ) {
559 for ( i = 0; (( re->re_mods != NULL ) &&
560 ( re->re_mods[ i ].mi_type != NULL )); i++ ) {
561 if ( !strcmp( re->re_mods[ i ].mi_type, T_MODSEPSTR )) {
562 if ( fprintf( fp, "%s\n", T_MODSEPSTR ) < 0 ) {
568 obuf = ldif_type_and_value( re->re_mods[ i ].mi_type,
569 re->re_mods[ i ].mi_val ? re->re_mods[ i ].mi_val : "",
570 re->re_mods[ i ].mi_len );
571 if ( fputs( obuf, fp ) < 0 ) {
580 if ( fprintf( fp, "\n" ) < 0 ) {
584 if ( fflush( fp ) != 0 ) {
590 Debug( LDAP_DEBUG_ANY, "Error while writing: %s\n",
591 sys_errlist[ errno ], 0, 0 );
600 * Decrement the refcnt. Locking handled internally.
616 * Get the refcnt. Locking handled internally.
636 * Lock this replication entry
643 return( pthread_mutex_lock( &re->re_mutex ));
650 * Unlock this replication entry
657 return( pthread_mutex_unlock( &re->re_mutex ));
664 * Instantiate and initialize an Re.
672 (*re) = (Re *) malloc( sizeof( Re ));
677 /* Fill in the member function pointers */
678 (*re)->re_free = Re_free;
679 (*re)->re_getnext = Re_getnext;
680 (*re)->re_parse = Re_parse;
681 (*re)->re_write = Re_write;
682 (*re)->re_dump = Re_dump;
683 (*re)->re_lock = Re_lock;
684 (*re)->re_unlock = Re_unlock;
685 (*re)->re_decrefcnt = Re_decrefcnt;
686 (*re)->re_getrefcnt = Re_getrefcnt;
688 /* Initialize private data */
689 (*re)->re_refcnt = sglob->num_replicas;
690 (*re)->re_timestamp = NULL;
691 (*re)->re_replicas = NULL;
693 (*re)->re_changetype = 0;
695 (*re)->re_mods = NULL;
696 (*re)->re_next = NULL;
698 pthread_mutex_init( &((*re)->re_mutex), pthread_mutexattr_default );
706 * Given a host and port, generate a warning message iff we haven't already
707 * generated a message for this host:port combination.
710 warn_unknown_replica(
718 for ( i = 0; i < nur; i++ ) {
719 if ( strcmp( ur[ i ].rh_hostname, host )) {
722 if ( ur[ i ].rh_port == port ) {
728 Debug( LDAP_DEBUG_ANY,
729 "Warning: unknown replica %s:%d found in replication log\n",
732 ur = (Rh *) ch_realloc( (char *) ur, ( nur * sizeof( Rh )));
733 ur[ nur - 1 ].rh_hostname = strdup( host );
734 ur[ nur - 1 ].rh_port = port;