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

   1 /*
   2  * Copyright (c) 1996 Regents of the University of Michigan.
   3  * All rights reserved.
   4  *
   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.
  11  */
  12
  13 /*
  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.
  18  */
  19
  20
  21 #include "portable.h"
  22
  23 #include <stdio.h>
  24
  25 #include <ac/errno.h>
  26 #include <ac/socket.h>
  27 #include <ac/string.h>
  28
  29 #include "../slapd/slap.h"
  30 #include "slurp.h"
  31 #include "globals.h"
  32
  33 /* externs */
  34 extern char *str_getline LDAP_P(( char **next ));
  35 extern void ch_free LDAP_P(( char *p ));
  36
  37 /* Forward references */
  38 static Rh       *get_repl_hosts LDAP_P(( char *, int *, char ** ));
  39 static int      gettype LDAP_P(( char * ));
  40 static int      getchangetype LDAP_P(( char * ));
  41 static int      Re_parse LDAP_P(( Re *re, char *replbuf ));
  42 static void     Re_dump LDAP_P(( Re *re, FILE *fp ));
  43 static void     warn_unknown_replica LDAP_P(( char *, int port ));
  44
  45 /* Globals, scoped within this file */
  46 static int      nur = 0;        /* Number of unknown replicas */
  47 static Rh       *ur = NULL;     /* array of unknown replica names */
  48
  49
  50 /*
  51  * Return the next Re in a linked list.
  52  */
  53 static Re *
  54 Re_getnext(
  55     Re  *re
  56 )
  57 {
  58     return(( re == NULL ) ? NULL :  re->re_next );
  59 }
  60
  61
  62
  63
  64 /*
  65  * Free an Re
  66  */
  67 static int
  68 Re_free(
  69     Re  *re
  70 )
  71 {
  72     Rh  *rh;
  73     Mi  *mi;
  74     int i;
  75
  76     if ( re == NULL ) {
  77         return 0;
  78     }
  79     if ( re->re_refcnt > 0 ) {
  80         Debug( LDAP_DEBUG_ANY,
  81                 "Warning: freeing re (dn: %s) with nonzero refcnt\n",
  82                 re->re_dn, 0, 0 );
  83     }
  84 #if !defined( HAVE_LWP )
  85     /* This seems to have problems under SunOS lwp */
  86     pthread_mutex_destroy( &re->re_mutex );
  87 #endif /* HAVE_LWP */
  88     ch_free( re->re_timestamp );
  89     if (( rh = re->re_replicas ) != NULL ) {
  90         for ( i = 0; rh[ i ].rh_hostname != NULL; i++ ) {
  91             free( rh[ i ].rh_hostname );
  92         }
  93         free( rh );
  94     }
  95     ch_free( re->re_dn );
  96     if (( mi = re->re_mods ) != NULL ) {
  97         for ( i = 0; mi[ i ].mi_type != NULL; i++ ) {
  98             free( mi[ i ].mi_type );
  99             ch_free( mi[ i ].mi_val );
 100         }
 101         free( mi );
 102     }
 103     free( re );
 104 }
 105
 106
 107
 108
 109 /*
 110  * Read a buffer of data from a replication log file and fill in
 111  * an (already allocated) Re.
 112  */
 113
 114 #define BEGIN           0
 115 #define GOT_DN          1
 116 #define GOT_TIME        2
 117 #define GOT_CHANGETYPE  4
 118 #define GOT_ALL         ( GOT_DN | GOT_TIME | GOT_CHANGETYPE )
 119
 120 static int
 121 Re_parse(
 122     Re          *re,
 123     char        *replbuf
 124 )
 125 {
 126     int                 state;
 127     int                 nml;
 128     char                *buf, *rp, *p;
 129     long                buflen;
 130     char                *type, *value;
 131     int                 len;
 132     int                 nreplicas;
 133
 134     if ( re == NULL ) {
 135         Debug( LDAP_DEBUG_ANY, "Re_parse: error: re is NULL\n", 0, 0, 0 );
 136         return -1;
 137     }
 138     if ( replbuf == NULL ) {
 139         Debug( LDAP_DEBUG_ANY, "Re_parse: error: replbuf is NULL\n", 0, 0, 0 );
 140         return -1;
 141     }
 142
 143     state = BEGIN;
 144     nml = 0;    /* number of modification information entries */
 145     rp = replbuf;
 146
 147     re->re_replicas = get_repl_hosts( replbuf, &nreplicas, &rp );
 148     re->re_refcnt = sglob->num_replicas;
 149
 150     for (;;) {
 151         if (( state == GOT_ALL ) || ( buf = str_getline( &rp )) == NULL ) {
 152             break;
 153         }
 154         /*
 155          * If we're processing a rejection log, then the first line
 156          * of each replication record will begin with "ERROR" - just
 157          * ignore it.
 158          */
 159         if ( strncmp( buf, ERROR_STR, strlen( ERROR_STR )) == 0 ) {
 160             continue;
 161         }
 162         buflen = ( long ) strlen( buf );
 163         if ( str_parse_line( buf, &type, &value, &len ) < 0 ) {
 164             Debug( LDAP_DEBUG_ANY,
 165                     "Error: Re_parse: malformed replog file\n",
 166                     0, 0, 0 );
 167             return -1;
 168         }
 169         switch ( gettype( type )) {
 170         case T_CHANGETYPE:
 171             re->re_changetype = getchangetype( value );
 172             state |= GOT_CHANGETYPE;
 173             break;
 174         case T_TIME:
 175             if (( p = strchr( value, '.' )) != NULL ) {
 176                 /* there was a sequence number */
 177                 *p++ = '\0';
 178             }
 179             re->re_timestamp = strdup( value );
 180             if ( p != NULL && isdigit( *p )) {
 181                 re->re_seq = atoi( p );
 182             }
 183             state |= GOT_TIME;
 184             break;
 185         case T_DN:
 186             re->re_dn = ch_malloc( len + 1 );
 187                 memcpy( re->re_dn, value, len );
 188                 re->re_dn[ len ]='\0';
 189             state |= GOT_DN;
 190             break;
 191         default:
 192             if ( !( state == GOT_ALL )) {
 193                 Debug( LDAP_DEBUG_ANY,
 194                         "Error: Re_parse: bad type <%s>\n",
 195                         type, 0, 0 );
 196                 return -1;
 197             }
 198         }
 199     }
 200
 201     if ( state != GOT_ALL ) {
 202         Debug( LDAP_DEBUG_ANY,
 203                 "Error: Re_parse: malformed replog file\n",
 204                 0, 0, 0 );
 205         return -1;
 206     }
 207
 208     for (;;) {
 209         if (( buf = str_getline( &rp )) == NULL ) {
 210             break;
 211         }
 212         buflen = ( long ) strlen( buf );
 213         if (( buflen == 1 ) && ( buf[ 0 ] == '-' )) {
 214             type = "-";
 215             value = NULL;
 216         } else {
 217             if ( str_parse_line( buf, &type, &value, &len ) < 0 ) {
 218                 Debug( LDAP_DEBUG_ANY,
 219                         "Error: malformed replog line \"%s\"\n",
 220                         buf, 0, 0 );
 221                 return -1;
 222             }
 223         }
 224         re->re_mods = ( Mi  *) ch_realloc( (char *) re->re_mods,
 225             sizeof( Mi ) * ( nml + 2 ));
 226         re->re_mods[ nml ].mi_type = strdup( type );
 227         if ( value != NULL ) {
 228             re->re_mods[ nml ].mi_val = ch_malloc( len + 1 );
 229                 memcpy( re->re_mods[ nml ].mi_val, value, len );
 230                 re->re_mods[ nml ].mi_val[ len ] = '\0';
 231             re->re_mods[ nml ].mi_len = len;
 232         } else {
 233             re->re_mods[ nml ].mi_val = NULL;
 234             re->re_mods[ nml ].mi_len = 0;
 235         }
 236         re->re_mods[ nml + 1 ].mi_type = NULL;
 237         re->re_mods[ nml + 1 ].mi_val = NULL;
 238         nml++;
 239     }
 240     return 0;
 241 }
 242
 243
 244
 245 /*
 246  * Extract the replication hosts from a repl buf.  Check to be sure that
 247  * each replica host and port number are ones we know about (that is, they're
 248  * in the slapd config file we read at startup).  Without that information
 249  * from the config file, we won't have the appropriate credentials to
 250  * make modifications.  If there are any unknown replica names, don't
 251  * add them the the Re struct.  Instead, log a warning message.
 252  */
 253 static Rh *
 254 get_repl_hosts(
 255     char        *replbuf,
 256     int         *r_nreplicas,
 257     char        **r_rp
 258 )
 259 {
 260     char                buf[ LINE_WIDTH + 1 ];
 261     char                *type, *value, *line, *p;
 262     Rh                  *rh = NULL;
 263     int                 nreplicas, len;
 264     int                 port;
 265     int                 repl_ok;
 266     int                 i;
 267
 268     if ( replbuf == NULL ) {
 269         return( NULL );
 270     }
 271
 272     nreplicas = 0;
 273
 274     /*
 275      * Get the host names of the replicas
 276      */
 277     *r_nreplicas = 0;
 278     *r_rp = replbuf;
 279     for (;;) {
 280         /* If this is a reject log, we need to skip over the ERROR: line */
 281         if ( !strncmp( *r_rp, ERROR_STR, strlen( ERROR_STR ))) {
 282             line = str_getline( r_rp );
 283             if ( line == NULL ) {
 284                 break;
 285             }
 286         }
 287         if ( strncasecmp( *r_rp, "replica:", 7 )) {
 288             break;
 289         }
 290         line = str_getline( r_rp );
 291         if ( line == NULL ) {
 292             break;
 293         }
 294         if ( str_parse_line( line, &type, &value, &len ) < 0 ) {
 295             return( NULL );
 296         }
 297         port = LDAP_PORT;
 298         if (( p = strchr( value, ':' )) != NULL ) {
 299             *p = '\0';
 300             p++;
 301             if ( *p != '\0' ) {
 302                 port = atoi( p );
 303             }
 304         }
 305
 306         /* Verify that we've heard of this replica before */
 307         repl_ok = 0;
 308         for ( i = 0; i < sglob->num_replicas; i++ ) {
 309             if ( strcmp( sglob->replicas[ i ]->ri_hostname, value )) {
 310                 continue;
 311             }
 312             if ( sglob->replicas[ i ]->ri_port == port ) {
 313                 repl_ok = 1;
 314                 break;
 315             }
 316         }
 317         if ( !repl_ok ) {
 318             warn_unknown_replica( value, port );
 319             continue;
 320         }
 321
 322         rh = (Rh *) ch_realloc((char *) rh, ( nreplicas + 2 ) * sizeof( Rh ));
 323         if ( rh == NULL ) {
 324             Debug( LDAP_DEBUG_ANY, "Out of memory in get_repl_hosts\n",
 325                     0, 0, 0 );
 326             return NULL;
 327         }
 328         rh[ nreplicas ].rh_hostname = strdup( value );
 329         rh[ nreplicas ].rh_port = port;
 330         nreplicas++;
 331     }
 332
 333     if ( nreplicas == 0 ) {
 334         return( NULL );
 335     }
 336
 337     rh[ nreplicas ].rh_hostname = NULL;
 338     *r_nreplicas = nreplicas;
 339
 340     return( rh );
 341 }
 342
 343
 344
 345
 346
 347 /*
 348  * Convert "type" to an int.
 349  */
 350 static int
 351 gettype(
 352     char        *type
 353 )
 354 {
 355     if ( !strcmp( type, T_CHANGETYPESTR )) {
 356         return( T_CHANGETYPE );
 357     }
 358     if ( !strcmp( type, T_TIMESTR )) {
 359         return( T_TIME );
 360     }
 361     if ( !strcmp( type, T_DNSTR )) {
 362         return( T_DN );
 363     }
 364     return( T_ERR );
 365 }
 366
 367
 368
 369 /*
 370  * Convert "changetype" to an int.
 371  */
 372 static int
 373 getchangetype(
 374     char        *changetype
 375 )
 376 {
 377     if ( !strcmp( changetype, T_ADDCTSTR )) {
 378         return( T_ADDCT );
 379     }
 380     if ( !strcmp( changetype, T_MODIFYCTSTR )) {
 381         return( T_MODIFYCT );
 382     }
 383     if ( !strcmp( changetype, T_DELETECTSTR )) {
 384         return( T_DELETECT );
 385     }
 386     if ( !strcmp( changetype, T_MODRDNCTSTR )) {
 387         return( T_MODRDNCT );
 388     }
 389     return( T_ERR );
 390 }
 391
 392
 393
 394
 395 /*
 396  * Find the first line which is not a "replica:" line in buf.
 397  * Returns a pointer to the line.  Returns NULL if there are
 398  * only "replica:" lines in buf.
 399  */
 400 static char *
 401 skip_replica_lines(
 402     char        *buf
 403 )
 404 {
 405     char *p = buf;
 406     for (;;) {
 407         if ( strncasecmp( p, "replica:", 8 )) {
 408             return( p );
 409         }
 410         while (( *p != '\0' )  && ( *p != '\n' )) {
 411             p++;
 412         }
 413         if ( *p == '\0' ) {
 414             return ( NULL );
 415         } else {
 416             p++;
 417         }
 418     }
 419 }
 420
 421
 422
 423
 424 /*
 425  * For debugging purposes: dump the contents of a replication entry.
 426  * to the given stream.
 427  */
 428 static void
 429 Re_dump(
 430     Re          *re,
 431     FILE        *fp
 432 )
 433 {
 434     int i;
 435     Mi *mi;
 436
 437     if ( re == NULL ) {
 438         Debug( LDAP_DEBUG_TRACE, "Re_dump: re is NULL\n", 0, 0, 0 );
 439         return;
 440     }
 441     fprintf( fp, "Re_dump: ******\n" );
 442     fprintf( fp, "re_refcnt: %d\n", re->re_refcnt );
 443     fprintf( fp, "re_timestamp: %s\n", re->re_timestamp );
 444     fprintf( fp, "re_seq: %d\n", re->re_seq );
 445     for ( i = 0; re->re_replicas && re->re_replicas[ i ].rh_hostname != NULL;
 446                 i++ ) {
 447         fprintf( fp, "re_replicas[%d]: %s:%d\n",
 448                 i, re->re_replicas[ i ].rh_hostname,
 449                 re->re_replicas[ i ].rh_port );
 450     }
 451     fprintf( fp, "re_dn: %s\n", re->re_dn );
 452     switch ( re->re_changetype ) {
 453     case T_ADDCT:
 454         fprintf( fp, "re_changetype: add\n" );
 455         break;
 456     case T_MODIFYCT:
 457         fprintf( fp, "re_changetype: modify\n" );
 458         break;
 459     case T_DELETECT:
 460         fprintf( fp, "re_changetype: delete\n" );
 461         break;
 462     case T_MODRDNCT:
 463         fprintf( fp, "re_changetype: modrdn\n" );
 464         break;
 465     default:
 466         fprintf( fp, "re_changetype: (unknown, type = %d\n",
 467                 re->re_changetype );
 468     }
 469     if ( re->re_mods == NULL ) {
 470         fprintf( fp, "re_mods: (none)\n" );
 471     } else {
 472         mi = re->re_mods;
 473         fprintf( fp, "re_mods:\n" );
 474         for ( i = 0; mi[ i ].mi_type != NULL; i++ ) {
 475             fprintf( fp, "  %s, \"%s\", (%d bytes)\n",
 476                     mi[ i ].mi_type,
 477                     mi[ i ].mi_val == NULL ?  "(null)" : mi[ i ].mi_val,
 478                     mi[ i ].mi_len );
 479         }
 480     }
 481     return;
 482 }
 483
 484
 485 /*
 486  * Given an Ri, an Re, and a file pointer, write a replication record to
 487  * the file pointer.  If ri is NULL, then include all replicas in the
 488  * output.  If ri is non-NULL, then only include a single "replica:" line
 489  * (used when writing rejection records).  Returns 0 on success, -1
 490  * on failure.  Note that Re_write will not write anything out if the
 491  * refcnt is zero.
 492  */
 493 static int
 494 Re_write(
 495     Ri          *ri,
 496     Re          *re,
 497     FILE        *fp )
 498 {
 499     int         i;
 500     char        *s;
 501     int         rc = 0;
 502     Rh          *rh;
 503
 504     if ( re == NULL || fp == NULL ) {
 505         Debug( LDAP_DEBUG_ANY, "Internal error: Re_write: NULL argument\n",
 506                 0, 0, 0 );
 507         return -1;
 508     }
 509
 510     if ( re->re_refcnt < 1 ) {
 511         return 0;               /* this is not an error */
 512     }
 513
 514     if ( ri != NULL ) {         /* write a single "replica:" line */
 515         if ( fprintf( fp, "replica: %s:%d\n", ri->ri_hostname,
 516                 ri->ri_port ) < 0 ) {
 517             rc = -1;
 518             goto bad;
 519         }
 520     } else {                    /* write multiple "replica:" lines */
 521         for ( i = 0; re->re_replicas[ i ].rh_hostname != NULL; i++ ) {
 522             if ( fprintf( fp, "replica: %s:%d\n",
 523                     re->re_replicas[ i ].rh_hostname,
 524                     re->re_replicas[ i ].rh_port ) < 0 ) {
 525                 rc = -1;
 526                 goto bad;
 527             }
 528         }
 529     }
 530     if ( fprintf( fp, "time: %s.%d\n", re->re_timestamp, re->re_seq ) < 0 ) {
 531         rc = -1;
 532         goto bad;
 533     }
 534     if ( fprintf( fp, "dn: %s\n", re->re_dn ) < 0 ) {
 535         rc = -1;
 536         goto bad;
 537     }
 538     if ( fprintf( fp, "changetype: " ) < 0 ) {
 539         rc = -1;
 540         goto bad;
 541     }
 542     switch ( re->re_changetype ) {
 543     case T_ADDCT:
 544         s = T_ADDCTSTR;
 545         break;
 546     case T_MODIFYCT:
 547         s = T_MODIFYCTSTR;
 548         break;
 549     case T_DELETECT:
 550         s = T_DELETECTSTR;
 551         break;
 552     case T_MODRDNCT:
 553         s = T_MODRDNCTSTR;
 554         break;
 555     default:
 556         s = "IllegalModifyType!!!";
 557     }
 558     if ( fprintf( fp, "%s\n", s ) < 0 ) {
 559         rc = -1;
 560         goto bad;
 561     }
 562     for ( i = 0; (( re->re_mods != NULL ) &&
 563             ( re->re_mods[ i ].mi_type != NULL )); i++ ) {
 564         if ( !strcmp( re->re_mods[ i ].mi_type, T_MODSEPSTR )) {
 565             if ( fprintf( fp, "%s\n", T_MODSEPSTR ) < 0 ) {
 566                 rc = -1;
 567                 goto bad;
 568             }
 569         } else {
 570             char *obuf;
 571             obuf = ldif_type_and_value( re->re_mods[ i ].mi_type,
 572                     re->re_mods[ i ].mi_val ? re->re_mods[ i ].mi_val : "",
 573                     re->re_mods[ i ].mi_len );
 574             if ( fputs( obuf, fp ) < 0 ) {
 575                 rc = -1;
 576                 free( obuf );
 577                 goto bad;
 578             } else {
 579                 free( obuf );
 580             }
 581         }
 582     }
 583     if ( fprintf( fp, "\n" ) < 0 ) {
 584         rc = -1;
 585         goto bad;
 586     }
 587     if ( fflush( fp ) != 0 ) {
 588         rc = -1;
 589         goto bad;
 590     }
 591 bad:
 592     if ( rc != 0 ) {
 593         Debug( LDAP_DEBUG_ANY, "Error while writing: %s\n",
 594                 sys_errlist[ errno ], 0, 0 );
 595     }
 596     return rc;
 597 }
 598
 599
 600
 601
 602 /*
 603  * Decrement the refcnt.  Locking handled internally.
 604  */
 605 static int
 606 Re_decrefcnt(
 607     Re  *re
 608 )
 609 {
 610     re->re_lock( re );
 611     re->re_refcnt--;
 612     re->re_unlock( re );
 613     return 0;
 614 }
 615
 616
 617
 618 /*
 619  * Get the refcnt.  Locking handled internally.
 620  */
 621 static int
 622 Re_getrefcnt(
 623     Re  *re
 624 )
 625 {
 626     int ret;
 627
 628     re->re_lock( re );
 629     ret = re->re_refcnt;
 630     re->re_unlock( re );
 631     return ret;
 632 }
 633
 634
 635
 636
 637
 638 /*
 639  * Lock this replication entry
 640  */
 641 static int
 642 Re_lock(
 643     Re  *re
 644 )
 645 {
 646     return( pthread_mutex_lock( &re->re_mutex ));
 647 }
 648
 649
 650
 651
 652 /*
 653  * Unlock this replication entry
 654  */
 655 static int
 656 Re_unlock(
 657     Re  *re
 658 )
 659 {
 660     return( pthread_mutex_unlock( &re->re_mutex ));
 661 }
 662
 663
 664
 665
 666 /*
 667  * Instantiate and initialize an Re.
 668  */
 669 int
 670 Re_init(
 671     Re **re
 672 )
 673 {
 674     /* Instantiate */
 675     (*re) = (Re *) malloc( sizeof( Re ));
 676     if ( *re == NULL ) {
 677         return -1;
 678     }
 679
 680     /* Fill in the member function pointers */
 681     (*re)->re_free = Re_free;
 682     (*re)->re_getnext = Re_getnext;
 683     (*re)->re_parse = Re_parse;
 684     (*re)->re_write = Re_write;
 685     (*re)->re_dump = Re_dump;
 686     (*re)->re_lock = Re_lock;
 687     (*re)->re_unlock = Re_unlock;
 688     (*re)->re_decrefcnt = Re_decrefcnt;
 689     (*re)->re_getrefcnt = Re_getrefcnt;
 690
 691     /* Initialize private data */
 692    (*re)->re_refcnt = sglob->num_replicas;
 693    (*re)->re_timestamp = NULL;
 694    (*re)->re_replicas = NULL;
 695    (*re)->re_dn = NULL;
 696    (*re)->re_changetype = 0;
 697    (*re)->re_seq = 0;
 698    (*re)->re_mods = NULL;
 699    (*re)->re_next = NULL;
 700
 701    pthread_mutex_init( &((*re)->re_mutex), pthread_mutexattr_default );
 702    return 0;
 703 }
 704
 705
 706
 707
 708 /*
 709  * Given a host and port, generate a warning message iff we haven't already
 710  * generated a message for this host:port combination.
 711  */
 712 static void
 713 warn_unknown_replica(
 714     char        *host,
 715     int         port
 716 )
 717 {
 718     int found = 0;
 719     int i;
 720
 721     for ( i = 0; i < nur; i++ ) {
 722         if ( strcmp( ur[ i ].rh_hostname, host )) {
 723             continue;
 724         }
 725         if ( ur[ i ].rh_port == port ) {
 726             found = 1;
 727             break;
 728         }
 729     }
 730     if ( !found ) {
 731         Debug( LDAP_DEBUG_ANY,
 732                 "Warning: unknown replica %s:%d found in replication log\n",
 733                 host, port, 0 );
 734         nur++;
 735         ur = (Rh *) ch_realloc( (char *) ur, ( nur * sizeof( Rh )));
 736         ur[ nur - 1 ].rh_hostname = strdup( host );
 737         ur[ nur - 1 ].rh_port = port;
 738     }
 739 }