]> git.sur5r.net Git - openldap/commitdiff
misc syncrepl cleanup/fixes
authorPierangelo Masarati <ando@openldap.org>
Sun, 26 Sep 2004 23:00:35 +0000 (23:00 +0000)
committerPierangelo Masarati <ando@openldap.org>
Sun, 26 Sep 2004 23:00:35 +0000 (23:00 +0000)
servers/slapd/config.c
servers/slapd/syncrepl.c

index d44ad0005ff4b83960b6a77cd3e88310ca879800..c7884bca29b0b6baf0c581713e550f42d7fca491 100644 (file)
@@ -2326,48 +2326,54 @@ add_syncrepl(
        }
 }
 
+/* NOTE: used & documented in slapd.conf(5) */
 #define IDSTR                  "rid"
 #define PROVIDERSTR            "provider"
-#define SUFFIXSTR              "suffix"
+#define TYPESTR                        "type"
+#define INTERVALSTR            "interval"
+#define SEARCHBASESTR          "searchbase"
+#define FILTERSTR              "filter"
+#define SCOPESTR               "scope"
+#define ATTRSSTR               "attrs"
+#define ATTRSONLYSTR           "attrsonly"
+#define SLIMITSTR              "sizelimit"
+#define TLIMITSTR              "timelimit"
+#define SCHEMASTR              "schemachecking"
 #define UPDATEDNSTR            "updatedn"
 #define BINDMETHSTR            "bindmethod"
-#define SIMPLESTR              "simple"
-#define SASLSTR                        "sasl"
+#define SIMPLESTR                      "simple"
+#define SASLSTR                                "sasl"
 #define BINDDNSTR              "binddn"
-#define CREDSTR                        "credentials"
-#define OLDAUTHCSTR            "bindprincipal"
+#define SASLMECHSTR            "saslmech"
 #define AUTHCSTR               "authcID"
 #define AUTHZSTR               "authzID"
-#define SRVTABSTR              "srvtab"
-#define SASLMECHSTR            "saslmech"
+#define CREDSTR                        "credentials"
 #define REALMSTR               "realm"
 #define SECPROPSSTR            "secprops"
-#define STARTTLSSTR            "starttls"
-#define CRITICALSTR            "critical"
 
-#define SCHEMASTR              "schemachecking"
-#define FILTERSTR              "filter"
-#define SEARCHBASESTR  "searchbase"
-#define SCOPESTR               "scope"
-#define ATTRSSTR               "attrs"
+/* FIXME: undocumented */
+#define OLDAUTHCSTR            "bindprincipal"
+#define STARTTLSSTR            "starttls"
+#define CRITICALSTR                    "critical"
 #define EXATTRSSTR             "exattrs"
-#define ATTRSONLYSTR   "attrsonly"
-#define TYPESTR                        "type"
-#define INTERVALSTR            "interval"
+#define MANAGEDSAITSTR         "manageDSAit"
+#define RETRYSTR               "retry"
+
+/* FIXME: unused */
 #define LASTMODSTR             "lastmod"
-#define LMREQSTR               "req"
 #define LMGENSTR               "gen"
 #define LMNOSTR                        "no"
-#define MANAGEDSAITSTR "manageDSAit"
-#define SLIMITSTR              "sizelimit"
-#define TLIMITSTR              "timelimit"
-
-#define RETRYSTR               "retry"
+#define LMREQSTR               "req"
+#define SRVTABSTR              "srvtab"
+#define SUFFIXSTR              "suffix"
 
+/* mandatory */
 #define GOT_ID                 0x0001
-#define GOT_PROVIDER   0x0002
+#define GOT_PROVIDER           0x0002
 #define GOT_METHOD             0x0004
-#define GOT_ALL                        0x0007
+
+/* check */
+#define GOT_ALL                        (GOT_ID|GOT_PROVIDER|GOT_METHOD)
 
 static int
 parse_syncrepl_line(
@@ -2382,10 +2388,12 @@ parse_syncrepl_line(
        int     nr_attr = 0;
 
        for ( i = 1; i < cargc; i++ ) {
-               if ( !strncasecmp( cargv[ i ], IDSTR, sizeof( IDSTR ) - 1 )) {
+               if ( !strncasecmp( cargv[ i ], IDSTR "=",
+                                       STRLENOF( IDSTR "=" ) ) )
+               {
                        int tmp;
                        /* '\0' string terminator accounts for '=' */
-                       val = cargv[ i ] + sizeof( IDSTR );
+                       val = cargv[ i ] + STRLENOF( IDSTR "=" );
                        tmp= atoi( val );
                        if ( tmp >= 1000 || tmp < 0 ) {
                                fprintf( stderr, "Error: parse_syncrepl_line: "
@@ -2394,9 +2402,10 @@ parse_syncrepl_line(
                        }
                        si->si_rid = tmp;
                        gots |= GOT_ID;
-               } else if ( !strncasecmp( cargv[ i ], PROVIDERSTR,
-                                       sizeof( PROVIDERSTR ) - 1 )) {
-                       val = cargv[ i ] + sizeof( PROVIDERSTR );
+               } else if ( !strncasecmp( cargv[ i ], PROVIDERSTR "=",
+                                       STRLENOF( PROVIDERSTR "=" ) ) )
+               {
+                       val = cargv[ i ] + STRLENOF( PROVIDERSTR "=" );
                        si->si_provideruri = ch_strdup( val );
                        si->si_provideruri_bv = (BerVarray)
                                ch_calloc( 2, sizeof( struct berval ));
@@ -2405,27 +2414,28 @@ parse_syncrepl_line(
                        si->si_provideruri_bv[1].bv_len = 0;
                        si->si_provideruri_bv[1].bv_val = NULL;
                        gots |= GOT_PROVIDER;
-               } else if ( !strncasecmp( cargv[ i ], STARTTLSSTR,
-                       sizeof(STARTTLSSTR) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], STARTTLSSTR "=",
+                                       STRLENOF(STARTTLSSTR "=") ) )
                {
-                       val = cargv[ i ] + sizeof( STARTTLSSTR );
+                       val = cargv[ i ] + STRLENOF( STARTTLSSTR "=" );
                        if( !strcasecmp( val, CRITICALSTR ) ) {
                                si->si_tls = SYNCINFO_TLS_CRITICAL;
                        } else {
                                si->si_tls = SYNCINFO_TLS_ON;
                        }
-               } else if ( !strncasecmp( cargv[ i ],
-                       UPDATEDNSTR, sizeof( UPDATEDNSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], UPDATEDNSTR "=",
+                                       STRLENOF( UPDATEDNSTR "=" ) ) )
                {
-                       struct berval updatedn = {0, NULL};
-                       val = cargv[ i ] + sizeof( UPDATEDNSTR );
+                       struct berval updatedn = BER_BVNULL;
+
+                       val = cargv[ i ] + STRLENOF( UPDATEDNSTR "=" );
                        ber_str2bv( val, 0, 0, &updatedn );
                        ch_free( si->si_updatedn.bv_val );
                        dnNormalize( 0, NULL, NULL, &updatedn, &si->si_updatedn, NULL );
-               } else if ( !strncasecmp( cargv[ i ], BINDMETHSTR,
-                               sizeof( BINDMETHSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], BINDMETHSTR "=",
+                               STRLENOF( BINDMETHSTR "=" ) ) )
                {
-                       val = cargv[ i ] + sizeof( BINDMETHSTR );
+                       val = cargv[ i ] + STRLENOF( BINDMETHSTR "=" );
                        if ( !strcasecmp( val, SIMPLESTR )) {
                                si->si_bindmethod = LDAP_AUTH_SIMPLE;
                                gots |= GOT_METHOD;
@@ -2441,47 +2451,55 @@ parse_syncrepl_line(
                        } else {
                                si->si_bindmethod = -1;
                        }
-               } else if ( !strncasecmp( cargv[ i ],
-                               BINDDNSTR, sizeof( BINDDNSTR ) - 1 ) ) {
-                       val = cargv[ i ] + sizeof( BINDDNSTR );
+               } else if ( !strncasecmp( cargv[ i ], BINDDNSTR "=",
+                                       STRLENOF( BINDDNSTR "=" ) ) )
+               {
+                       val = cargv[ i ] + STRLENOF( BINDDNSTR "=" );
                        si->si_binddn = ch_strdup( val );
-               } else if ( !strncasecmp( cargv[ i ],
-                               CREDSTR, sizeof( CREDSTR ) - 1 ) ) {
-                       val = cargv[ i ] + sizeof( CREDSTR );
+               } else if ( !strncasecmp( cargv[ i ], CREDSTR "=",
+                                       STRLENOF( CREDSTR "=" ) ) )
+               {
+                       val = cargv[ i ] + STRLENOF( CREDSTR "=" );
                        si->si_passwd = ch_strdup( val );
-               } else if ( !strncasecmp( cargv[ i ],
-                               SASLMECHSTR, sizeof( SASLMECHSTR ) - 1 ) ) {
-                       val = cargv[ i ] + sizeof( SASLMECHSTR );
+               } else if ( !strncasecmp( cargv[ i ], SASLMECHSTR "=",
+                                       STRLENOF( SASLMECHSTR "=" ) ) )
+               {
+                       val = cargv[ i ] + STRLENOF( SASLMECHSTR "=" );
                        si->si_saslmech = ch_strdup( val );
-               } else if ( !strncasecmp( cargv[ i ],
-                               SECPROPSSTR, sizeof( SECPROPSSTR ) - 1 ) ) {
-                       val = cargv[ i ] + sizeof( SECPROPSSTR );
+               } else if ( !strncasecmp( cargv[ i ], SECPROPSSTR "=",
+                                       STRLENOF( SECPROPSSTR "=" ) ) )
+               {
+                       val = cargv[ i ] + STRLENOF( SECPROPSSTR "=" );
                        si->si_secprops = ch_strdup( val );
-               } else if ( !strncasecmp( cargv[ i ],
-                               REALMSTR, sizeof( REALMSTR ) - 1 ) ) {
-                       val = cargv[ i ] + sizeof( REALMSTR );
+               } else if ( !strncasecmp( cargv[ i ], REALMSTR "=",
+                                       STRLENOF( REALMSTR "=" ) ) )
+               {
+                       val = cargv[ i ] + STRLENOF( REALMSTR "=" );
                        si->si_realm = ch_strdup( val );
-               } else if ( !strncasecmp( cargv[ i ],
-                               AUTHCSTR, sizeof( AUTHCSTR ) - 1 ) ) {
-                       val = cargv[ i ] + sizeof( AUTHCSTR );
+               } else if ( !strncasecmp( cargv[ i ], AUTHCSTR "=",
+                                       STRLENOF( AUTHCSTR "=" ) ) )
+               {
+                       val = cargv[ i ] + STRLENOF( AUTHCSTR "=" );
                        if ( si->si_authcId )
                                ch_free( si->si_authcId );
                        si->si_authcId = ch_strdup( val );
-               } else if ( !strncasecmp( cargv[ i ],
-                               OLDAUTHCSTR, sizeof( OLDAUTHCSTR ) - 1 ) ) {
+               } else if ( !strncasecmp( cargv[ i ], OLDAUTHCSTR "=",
+                                       STRLENOF( OLDAUTHCSTR "=" ) ) ) 
+               {
                        /* Old authcID is provided for some backwards compatibility */
-                       val = cargv[ i ] + sizeof( OLDAUTHCSTR );
+                       val = cargv[ i ] + STRLENOF( OLDAUTHCSTR "=" );
                        if ( si->si_authcId )
                                ch_free( si->si_authcId );
                        si->si_authcId = ch_strdup( val );
-               } else if ( !strncasecmp( cargv[ i ],
-                               AUTHZSTR, sizeof( AUTHZSTR ) - 1 ) ) {
-                       val = cargv[ i ] + sizeof( AUTHZSTR );
+               } else if ( !strncasecmp( cargv[ i ], AUTHZSTR "=",
+                                       STRLENOF( AUTHZSTR "=" ) ) )
+               {
+                       val = cargv[ i ] + STRLENOF( AUTHZSTR "=" );
                        si->si_authzId = ch_strdup( val );
-               } else if ( !strncasecmp( cargv[ i ],
-                               SCHEMASTR, sizeof( SCHEMASTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], SCHEMASTR "=",
+                                       STRLENOF( SCHEMASTR "=" ) ) )
                {
-                       val = cargv[ i ] + sizeof( SCHEMASTR );
+                       val = cargv[ i ] + STRLENOF( SCHEMASTR "=" );
                        if ( !strncasecmp( val, "on", STRLENOF( "on" ) )) {
                                si->si_schemachecking = 1;
                        } else if ( !strncasecmp( val, "off", STRLENOF( "off" ) ) ) {
@@ -2489,16 +2507,16 @@ parse_syncrepl_line(
                        } else {
                                si->si_schemachecking = 1;
                        }
-               } else if ( !strncasecmp( cargv[ i ],
-                       FILTERSTR, sizeof( FILTERSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], FILTERSTR "=",
+                                       STRLENOF( FILTERSTR "=" ) ) )
                {
-                       val = cargv[ i ] + sizeof( FILTERSTR );
+                       val = cargv[ i ] + STRLENOF( FILTERSTR "=" );
                        ber_str2bv( val, 0, 1, &si->si_filterstr );
-               } else if ( !strncasecmp( cargv[ i ],
-                       SEARCHBASESTR, sizeof( SEARCHBASESTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], SEARCHBASESTR "=",
+                                       STRLENOF( SEARCHBASESTR "=" ) ) )
                {
                        struct berval bv;
-                       val = cargv[ i ] + sizeof( SEARCHBASESTR );
+                       val = cargv[ i ] + STRLENOF( SEARCHBASESTR "=" );
                        if ( si->si_base.bv_val ) {
                                ch_free( si->si_base.bv_val );
                        }
@@ -2507,10 +2525,10 @@ parse_syncrepl_line(
                                fprintf( stderr, "Invalid base DN \"%s\"\n", val );
                                return 1;
                        }
-               } else if ( !strncasecmp( cargv[ i ],
-                       SCOPESTR, sizeof( SCOPESTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], SCOPESTR "=",
+                                       STRLENOF( SCOPESTR "=" ) ) )
                {
-                       val = cargv[ i ] + sizeof( SCOPESTR );
+                       val = cargv[ i ] + STRLENOF( SCOPESTR "=" );
                        if ( !strncasecmp( val, "base", STRLENOF( "base" ) )) {
                                si->si_scope = LDAP_SCOPE_BASE;
                        } else if ( !strncasecmp( val, "one", STRLENOF( "one" ) )) {
@@ -2528,19 +2546,18 @@ parse_syncrepl_line(
                                        "unknown scope \"%s\"\n", val);
                                return 1;
                        }
-               } else if ( !strncasecmp( cargv[ i ],
-                       ATTRSONLYSTR, sizeof( ATTRSONLYSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], ATTRSONLYSTR "=",
+                                       STRLENOF( ATTRSONLYSTR "=" ) ) )
                {
                        si->si_attrsonly = 1;
-               } else if ( !strncasecmp( cargv[ i ],
-                       ATTRSSTR, sizeof( ATTRSSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], ATTRSSTR "=",
+                                       STRLENOF( ATTRSSTR "=" ) ) )
                {
-                       val = cargv[ i ] + sizeof( ATTRSSTR );
-                       if ( !strncasecmp( val, ":include:", STRLENOF(":include:") )) {
+                       val = cargv[ i ] + STRLENOF( ATTRSSTR "=" );
+                       if ( !strncasecmp( val, ":include:", STRLENOF(":include:") ) ) {
                                char *attr_fname;
                                attr_fname = ch_strdup( val + STRLENOF(":include:") );
-                               si->si_anlist = file2anlist(
-                                                               si->si_anlist, attr_fname, " ,\t" );
+                               si->si_anlist = file2anlist( si->si_anlist, attr_fname, " ,\t" );
                                if ( si->si_anlist == NULL ) {
                                        ch_free( attr_fname );
                                        return -1;
@@ -2551,8 +2568,9 @@ parse_syncrepl_line(
                                char delimstr[] = " ,\t";
                                str = ch_strdup( val );
                                for ( s = ldap_pvt_strtok( str, delimstr, &next );
-                                         s != NULL;
-                                         s = ldap_pvt_strtok( NULL, delimstr, &next )) {
+                                               s != NULL;
+                                               s = ldap_pvt_strtok( NULL, delimstr, &next ) )
+                               {
                                        if ( strlen(s) == 1 && *s == '*' ) {
                                                si->si_allattrs = 1;
                                                *(val + ( s - str )) = delimstr[0];
@@ -2568,10 +2586,10 @@ parse_syncrepl_line(
                                        return -1;
                                }
                        }
-               } else if ( !strncasecmp( cargv[ i ],
-                       EXATTRSSTR, sizeof( EXATTRSSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], EXATTRSSTR "=",
+                                       STRLENOF( EXATTRSSTR "=" ) ) )
                {
-                       val = cargv[ i ] + sizeof( EXATTRSSTR );
+                       val = cargv[ i ] + STRLENOF( EXATTRSSTR "=" );
                        if ( !strncasecmp( val, ":include:", STRLENOF(":include:") )) {
                                char *attr_fname;
                                attr_fname = ch_strdup( val + STRLENOF(":include:") );
@@ -2589,14 +2607,16 @@ parse_syncrepl_line(
                                        return -1;
                                }
                        }
-               } else if ( !strncasecmp( cargv[ i ],
-                       TYPESTR, sizeof( TYPESTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], TYPESTR "=",
+                                       STRLENOF( TYPESTR "=" ) ) )
                {
-                       val = cargv[ i ] + sizeof( TYPESTR );
-                       if ( !strncasecmp( val, "refreshOnly", STRLENOF("refreshOnly") )) {
+                       val = cargv[ i ] + STRLENOF( TYPESTR "=" );
+                       if ( !strncasecmp( val, "refreshOnly",
+                                               STRLENOF("refreshOnly") ))
+                       {
                                si->si_type = LDAP_SYNC_REFRESH_ONLY;
                        } else if ( !strncasecmp( val, "refreshAndPersist",
-                               STRLENOF("refreshAndPersist") ))
+                                               STRLENOF("refreshAndPersist") ))
                        {
                                si->si_type = LDAP_SYNC_REFRESH_AND_PERSIST;
                                si->si_interval = 60;
@@ -2605,10 +2625,10 @@ parse_syncrepl_line(
                                        "unknown sync type \"%s\"\n", val);
                                return 1;
                        }
-               } else if ( !strncasecmp( cargv[ i ],
-                       INTERVALSTR, sizeof( INTERVALSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], INTERVALSTR "=",
+                                       STRLENOF( INTERVALSTR "=" ) ) )
                {
-                       val = cargv[ i ] + sizeof( INTERVALSTR );
+                       val = cargv[ i ] + STRLENOF( INTERVALSTR "=" );
                        if ( si->si_type == LDAP_SYNC_REFRESH_AND_PERSIST ) {
                                si->si_interval = 0;
                        } else {
@@ -2659,14 +2679,14 @@ parse_syncrepl_line(
                                        (long) si->si_interval);
                                return 1;
                        }
-               } else if ( !strncasecmp( cargv[ i ],
-                       RETRYSTR, sizeof( RETRYSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], RETRYSTR "=",
+                                       STRLENOF( RETRYSTR "=" ) ) )
                {
                        char *str;
                        char **retry_list;
                        int j, k, n;
 
-                       val = cargv[ i ] + sizeof( RETRYSTR );
+                       val = cargv[ i ] + STRLENOF( RETRYSTR "=" );
                        retry_list = (char **) ch_calloc( 1, sizeof( char * ));
                        retry_list[0] = NULL;
 
@@ -2706,20 +2726,20 @@ parse_syncrepl_line(
                                ch_free( retry_list[k] );
                        }
                        ch_free( retry_list );
-               } else if ( !strncasecmp( cargv[ i ],
-                       MANAGEDSAITSTR, sizeof( MANAGEDSAITSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], MANAGEDSAITSTR "=",
+                                       STRLENOF( MANAGEDSAITSTR "=" ) ) )
                {
-                       val = cargv[ i ] + sizeof( MANAGEDSAITSTR );
+                       val = cargv[ i ] + STRLENOF( MANAGEDSAITSTR "=" );
                        si->si_manageDSAit = atoi( val );
-               } else if ( !strncasecmp( cargv[ i ],
-                       SLIMITSTR, sizeof( SLIMITSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], SLIMITSTR "=",
+                                       STRLENOF( SLIMITSTR "=") ) )
                {
-                       val = cargv[ i ] + sizeof( SLIMITSTR );
+                       val = cargv[ i ] + STRLENOF( SLIMITSTR "=" );
                        si->si_slimit = atoi( val );
-               } else if ( !strncasecmp( cargv[ i ],
-                       TLIMITSTR, sizeof( TLIMITSTR ) - 1 ) )
+               } else if ( !strncasecmp( cargv[ i ], TLIMITSTR "=",
+                                       STRLENOF( TLIMITSTR "=" ) ) )
                {
-                       val = cargv[ i ] + sizeof( TLIMITSTR );
+                       val = cargv[ i ] + STRLENOF( TLIMITSTR "=" );
                        si->si_tlimit = atoi( val );
                } else {
                        fprintf( stderr, "Error: parse_syncrepl_line: "
index 696101ab649e5b38882cdd0dcf36e1c6f853a4bf..9cfebf2442d33a4b4cff79e48406464ebe2390f7 100644 (file)
@@ -68,7 +68,6 @@ init_syncrepl(syncinfo_t *si)
                attrs = anlist2attrs( si->si_anlist );
 
        if ( attrs ) {
-
                if ( si->si_allattrs ) {
                        i = 0;
                        while ( attrs[i] ) {
@@ -82,9 +81,10 @@ init_syncrepl(syncinfo_t *si)
                                        i++;
                                }
                        }
-                       attrs = ( char ** ) ch_realloc( attrs, (i + 2)*sizeof( char * ));
+                       attrs = ( char ** ) ch_realloc( attrs, (i + 2)*sizeof( char * ) );
                        attrs[i] = ch_strdup("*");
                        attrs[i + 1] = NULL;
+
                } else if ( si->si_allopattrs ) {
                        i = 0;
                        while ( attrs[i] ) {
@@ -98,7 +98,7 @@ init_syncrepl(syncinfo_t *si)
                                        i++;
                                }
                        }
-                       attrs = ( char ** ) ch_realloc( attrs, (i + 2)*sizeof( char * ));
+                       attrs = ( char ** ) ch_realloc( attrs, (i + 2)*sizeof( char * ) );
                        attrs[i] = ch_strdup("+");
                        attrs[i + 1] = NULL;
                }
@@ -133,10 +133,31 @@ init_syncrepl(syncinfo_t *si)
                }
 
        } else {
-               attrs = ( char ** ) ch_realloc( attrs, 3 * sizeof( char * ));
+               attrs = ( char ** ) ch_malloc( ( si->si_allattrs + si->si_allopattrs + 1 ) * sizeof( char * ) );
                if ( attrs == NULL ) {
-                       Debug( LDAP_DEBUG_ANY, "out of memory\n", 0,0,0 );
+                       Debug( LDAP_DEBUG_ANY, "out of memory\n", 0, 0, 0 );
                }
+               
+               /* 
+                * FIXME: currently, if "attrs=*" is specified,
+                * it is silently turned into "attrs=* +";
+                * unless this behavior is intended, the #unifdef'd
+                * code fixes the problem.  However, this breaks
+                * the syncrepl tests (at least
+                * test019-syncreplication-cascade), so the consumers'
+                * slapd-conf need be modified with "attrs=* +"
+                * to fix them.  Comments?
+                */
+#if 0
+               i = 0;
+               if ( si->si_allattrs ) {
+                       attrs[i++] = ch_strdup( "*" );
+               }
+               if ( si->si_allopattrs ) {
+                       attrs[i++] = ch_strdup( "+" );
+               }
+               attrs[i] = NULL;
+#endif
                attrs[0] = ch_strdup( "*" );
                attrs[1] = ch_strdup( "+" );
                attrs[2] = NULL;
@@ -146,9 +167,7 @@ init_syncrepl(syncinfo_t *si)
 
        exattrs = anlist2attrs( si->si_exanlist );
 
-
        if ( exattrs ) {
-
                for ( n = 0; exattrs[n] != NULL; n++ ) ;
 
                for ( i = 0; sync_descs[i] != NULL; i++ ) {
@@ -212,7 +231,7 @@ ldap_sync_search(
        ber_set_option( ber, LBER_OPT_BER_MEMCTX, &ctx );
 
        if ( si->si_syncCookie.octet_str &&
-               si->si_syncCookie.octet_str[0].bv_val )
+               !BER_BVISNULL( &si->si_syncCookie.octet_str[0] ) )
        {
                ber_printf( ber, "{eO}",
                        abs(si->si_type),
@@ -380,7 +399,7 @@ do_syncrep1(
        /* get syncrepl cookie of shadow replica from subentry */
        assert( si->si_rid < 1000 );
        syncrepl_cn_bv.bv_val = syncrepl_cbuf;
-       syncrepl_cn_bv.bv_len = snprintf(syncrepl_cbuf, sizeof(syncrepl_cbuf),
+       syncrepl_cn_bv.bv_len = snprintf( syncrepl_cbuf, sizeof(syncrepl_cbuf),
                CN_STR "syncrepl%ld", si->si_rid );
        build_new_dn( &op->o_req_ndn, psub, &syncrepl_cn_bv, op->o_tmpmemctx );
        op->o_req_dn = op->o_req_ndn;
@@ -407,7 +426,7 @@ do_syncrep1(
                if ( !cookie ) {
                        /* no stored cookie */
                        if ( sc->ctxcsn == NULL ||
-                                sc->ctxcsn->bv_val == NULL ) {
+                                BER_BVISNULL( sc->ctxcsn ) ) {
                                /* if cmdline cookie does not have ctxcsn */
                                /* component, set it to an initial value */
                                slap_init_sync_cookie_ctxcsn( sc );
@@ -567,6 +586,9 @@ do_syncrep2(
                                ldap_get_entry_controls( si->si_ld, msg, &rctrls );
                                /* we can't work without the control */
                                if ( !rctrls ) {
+                                       Debug( LDAP_DEBUG_ANY, "do_syncrep2 : "
+                                               "got search entry without "
+                                               "control\n", 0, 0, 0 );
                                        rc = -1;
                                        goto done;
                                }
@@ -575,21 +597,23 @@ do_syncrep2(
                                ber_scanf( ber, "{em" /*"}"*/, &syncstate, &syncUUID );
                                if ( ber_peek_tag( ber, &len ) == LDAP_TAG_SYNC_COOKIE ) {
                                        ber_scanf( ber, /*"{"*/ "m}", &cookie );
-                                       if ( cookie.bv_val ) {
+                                       if ( !BER_BVISNULL( &cookie ) ) {
                                                struct berval tmp_bv;
                                                ber_dupbv( &tmp_bv, &cookie );
                                                ber_bvarray_add( &syncCookie.octet_str, &tmp_bv );
                                        }
                                        if ( syncCookie.octet_str &&
-                                                       syncCookie.octet_str[0].bv_val )
+                                                       !BER_BVISNULL( &syncCookie.octet_str[0] ) )
+                                       {
                                                slap_parse_sync_cookie( &syncCookie );
+                                       }
                                }
                                if ( syncrepl_message_to_entry( si, op, msg,
                                        &modlist, &entry, syncstate ) == LDAP_SUCCESS ) {
                                        rc_efree = syncrepl_entry( si, op, entry, modlist,
                                                syncstate, &syncUUID, &syncCookie_req );
                                        if ( syncCookie.octet_str &&
-                                               syncCookie.octet_str[0].bv_val )
+                                               !BER_BVISNULL( &syncCookie.octet_str[0] ) )
                                        {
                                                syncrepl_updateCookie( si, op, psub, &syncCookie );
                                        }
@@ -619,13 +643,13 @@ do_syncrep2(
                                        ber_scanf( ber, "{" /*"}"*/);
                                        if ( ber_peek_tag( ber, &len ) == LDAP_TAG_SYNC_COOKIE ) {
                                                ber_scanf( ber, "m", &cookie );
-                                               if ( cookie.bv_val ) {
+                                               if ( !BER_BVISNULL( &cookie ) ) {
                                                        struct berval tmp_bv;
                                                        ber_dupbv( &tmp_bv, &cookie );
                                                        ber_bvarray_add( &syncCookie.octet_str, &tmp_bv);
                                                }
                                                if ( syncCookie.octet_str &&
-                                                       syncCookie.octet_str[0].bv_val )
+                                                       !BER_BVISNULL( &syncCookie.octet_str[0] ) )
                                                {
                                                        slap_parse_sync_cookie( &syncCookie );
                                                }
@@ -647,7 +671,7 @@ do_syncrep2(
                                                &syncCookie_req.ctxcsn[0], &syncCookie.ctxcsn[0],
                                                &text );
                                }
-                               if ( syncCookie.octet_str && syncCookie.octet_str->bv_val &&
+                               if ( syncCookie.octet_str && !BER_BVISNULL( syncCookie.octet_str ) &&
                                        match < 0 && err == LDAP_SUCCESS )
                                {
                                        syncrepl_updateCookie( si, op, psub, &syncCookie );
@@ -694,14 +718,14 @@ do_syncrep2(
                                                if ( ber_peek_tag( ber, &len ) == LDAP_TAG_SYNC_COOKIE )
                                                {
                                                        ber_scanf( ber, "m", &cookie );
-                                                       if ( cookie.bv_val ) {
+                                                       if ( !BER_BVISNULL( &cookie ) ) {
                                                                struct berval tmp_bv;
                                                                ber_dupbv( &tmp_bv, &cookie );
                                                                ber_bvarray_add( &syncCookie.octet_str,
                                                                        &tmp_bv);
                                                        }
                                                        if ( syncCookie.octet_str &&
-                                                               syncCookie.octet_str[0].bv_val )
+                                                               !BER_BVISNULL( &syncCookie.octet_str[0] ) )
                                                        {
                                                                slap_parse_sync_cookie( &syncCookie );
                                                        }
@@ -719,14 +743,14 @@ do_syncrep2(
                                                        LDAP_TAG_SYNC_COOKIE )
                                                {
                                                        ber_scanf( ber, "m", &cookie );
-                                                       if ( cookie.bv_val ) {
+                                                       if ( !BER_BVISNULL( &cookie ) ) {
                                                                struct berval tmp_bv;
                                                                ber_dupbv( &tmp_bv, &cookie );
                                                                ber_bvarray_add( &syncCookie.octet_str,
                                                                        &tmp_bv );
                                                        }
                                                        if ( syncCookie.octet_str &&
-                                                               syncCookie.octet_str[0].bv_val )
+                                                                       !BER_BVISNULL( &syncCookie.octet_str[0] ) )
                                                        {
                                                                slap_parse_sync_cookie( &syncCookie );
                                                        }
@@ -738,7 +762,7 @@ do_syncrep2(
                                                }
                                                ber_scanf( ber, "[W]", &syncUUIDs );
                                                ber_scanf( ber, /*"{"*/ "}" );
-                                               for ( i = 0; syncUUIDs[i].bv_val; i++ ) {
+                                               for ( i = 0; !BER_BVISNULL( &syncUUIDs[i] ); i++ ) {
                                                        struct berval *syncuuid_bv;
                                                        syncuuid_bv = ber_dupbv( NULL, &syncUUIDs[i] );
                                                        slap_sl_free( syncUUIDs[i].bv_val,op->o_tmpmemctx );
@@ -769,7 +793,7 @@ do_syncrep2(
                                                        &syncCookie.ctxcsn[0], &text );
                                        }
 
-                                       if ( syncCookie.ctxcsn && syncCookie.ctxcsn[0].bv_val &&
+                                       if ( syncCookie.ctxcsn && !BER_BVISNULL( &syncCookie.ctxcsn[0] ) &&
                                                match < 0 )
                                        {
                                                syncrepl_updateCookie( si, op, psub, &syncCookie);
@@ -1036,7 +1060,7 @@ syncrepl_message_to_entry(
 
        while ( ber_remaining( ber ) ) {
                if ( (ber_scanf( ber, "{mW}", &tmp.sml_type, &tmp.sml_values ) ==
-                       LBER_ERROR ) || ( tmp.sml_type.bv_val == NULL ))
+                       LBER_ERROR ) || BER_BVISNULL( &tmp.sml_type ) )
                {
                        break;
                }
@@ -1162,15 +1186,15 @@ syncrepl_entry(
        f.f_choice = LDAP_FILTER_EQUALITY;
        f.f_ava = &ava;
        ava.aa_desc = slap_schema.si_ad_entryUUID;
-       slap_uuidstr_from_normalized( &syncUUID_strrep, syncUUID, op->o_tmpmemctx );
+       (void)slap_uuidstr_from_normalized( &syncUUID_strrep, syncUUID, op->o_tmpmemctx );
        ava.aa_value = *syncUUID;
        op->ors_filter = &f;
 
-       op->ors_filterstr.bv_len = (sizeof("entryUUID=")-1) + syncUUID->bv_len;
+       op->ors_filterstr.bv_len = STRLENOF( "entryUUID=" ) + syncUUID->bv_len;
        op->ors_filterstr.bv_val = (char *) slap_sl_malloc(
                op->ors_filterstr.bv_len + 1, op->o_tmpmemctx ); 
-       AC_MEMCPY( op->ors_filterstr.bv_val, "entryUUID=", sizeof("entryUUID=")-1 );
-       AC_MEMCPY( &op->ors_filterstr.bv_val[sizeof("entryUUID=")-1],
+       AC_MEMCPY( op->ors_filterstr.bv_val, "entryUUID=", STRLENOF( "entryUUID=" ) );
+       AC_MEMCPY( &op->ors_filterstr.bv_val[STRLENOF( "entryUUID=" )],
                syncUUID->bv_val, syncUUID->bv_len );
        op->ors_filterstr.bv_val[op->ors_filterstr.bv_len] = '\0';
 
@@ -1193,20 +1217,21 @@ syncrepl_entry(
        cb.sc_response = dn_callback;
        cb.sc_private = si;
 
-       si->si_syncUUID_ndn.bv_val = NULL;
+       BER_BVZERO( &si->si_syncUUID_ndn );
 
        if ( limits_check( op, &rs_search ) == 0 ) {
                rc = be->be_search( op, &rs_search );
        }
 
-       if ( op->ors_filterstr.bv_val ) {
+       if ( !BER_BVISNULL( &op->ors_filterstr ) ) {
                slap_sl_free( op->ors_filterstr.bv_val, op->o_tmpmemctx );
        }
 
        cb.sc_response = null_callback;
        cb.sc_private = si;
 
-       if ( rs_search.sr_err == LDAP_SUCCESS && si->si_syncUUID_ndn.bv_val ) {
+       if ( rs_search.sr_err == LDAP_SUCCESS && !BER_BVISNULL( &si->si_syncUUID_ndn ) )
+       {
                char *subseq_ptr;
 
                if ( syncstate != LDAP_SYNC_DELETE ) {
@@ -1214,7 +1239,7 @@ syncrepl_entry(
                }
 
                ber_dupbv( &op->o_sync_csn, syncCookie_req->ctxcsn );
-               if ( op->o_sync_csn.bv_val ) {
+               if ( !BER_BVISNULL( &op->o_sync_csn ) ) {
                        subseq_ptr = strstr( op->o_sync_csn.bv_val, "#0000" );
                        subseq_ptr += 4;
                        *subseq_ptr = '1';
@@ -1350,12 +1375,13 @@ syncrepl_entry(
 
 done :
 
-       if ( syncUUID_strrep.bv_val ) {
+       if ( !BER_BVISNULL( &syncUUID_strrep ) ) {
                slap_sl_free( syncUUID_strrep.bv_val, op->o_tmpmemctx );
+               BER_BVZERO( &syncUUID_strrep );
        }
-       if ( si->si_syncUUID_ndn.bv_val ) {
+       if ( !BER_BVISNULL( &si->si_syncUUID_ndn ) ) {
                ch_free( si->si_syncUUID_ndn.bv_val );
-               si->si_syncUUID_ndn.bv_val = NULL;
+               BER_BVZERO( &si->si_syncUUID_ndn );
        }
        return ret;
 }
@@ -1505,8 +1531,8 @@ syncrepl_del_nonpresent(
 
                        ber_bvfree( np_prev->npe_name );
                        ber_bvfree( np_prev->npe_nname );
-                       op->o_req_dn.bv_val = NULL;
-                       op->o_req_ndn.bv_val = NULL;
+                       BER_BVZERO( &op->o_req_dn );
+                       BER_BVZERO( &op->o_req_ndn );
                        ch_free( np_prev );
                }
        }
@@ -1540,8 +1566,8 @@ syncrepl_add_glue(
        ndn = e->e_nname;
 
        /* count RDNs in suffix */
-       if ( be->be_nsuffix[0].bv_len ) {
-               for (i=0, ptr=be->be_nsuffix[0].bv_val; ptr; ptr=strchr( ptr, ',' )) {
+       if ( !BER_BVISEMPTY( &be->be_nsuffix[0] ) ) {
+               for ( i = 0, ptr = be->be_nsuffix[0].bv_val; ptr; ptr = strchr( ptr, ',' ) ) {
                        ptr++;
                        i++;
                }
@@ -1553,7 +1579,7 @@ syncrepl_add_glue(
 
        /* Start with BE suffix */
        for ( i = 0, ptr = NULL; i < suffrdns; i++ ) {
-               comma = strrchr(dn.bv_val, ',');
+               comma = strrchr( dn.bv_val, ',' );
                if ( ptr ) *ptr = ',';
                if ( comma ) *comma = '\0';
                ptr = comma;
@@ -1766,7 +1792,7 @@ syncrepl_updateCookie(
        ber_dupbv( &e->e_name, &slap_syncrepl_dn_bv );
        ber_dupbv( &e->e_nname, &slap_syncrepl_dn_bv );
 
-       if ( slap_syncrepl_dn_bv.bv_val ) {
+       if ( !BER_BVISNULL( &slap_syncrepl_dn_bv ) ) {
                slap_sl_free( slap_syncrepl_dn_bv.bv_val, op->o_tmpmemctx );
        }
 
@@ -1827,13 +1853,13 @@ update_cookie_retry:
 
 done :
 
-       if ( cnbva[0].bv_val ) {
+       if ( !BER_BVISNULL( &cnbva[0] ) ) {
                ch_free( cnbva[0].bv_val );
-               cnbva[0].bv_val = NULL;
+               BER_BVZERO( &cnbva[0] );
        }
-       if ( scbva[0].bv_val ) {
+       if ( !BER_BVISNULL( &scbva[0] ) ) {
                ch_free( scbva[0].bv_val );
-               scbva[0].bv_val = NULL;
+               BER_BVZERO( &scbva[0] );
        }
 
        if ( mlnext->sml_next ) {
@@ -1881,16 +1907,18 @@ dn_callback(
        syncinfo_t *si = op->o_callback->sc_private;
 
        if ( rs->sr_type == REP_SEARCH ) {
-               if ( si->si_syncUUID_ndn.bv_val != NULL ) {
+               if ( !BER_BVISNULL( &si->si_syncUUID_ndn ) ) {
                        Debug( LDAP_DEBUG_ANY,
-                               "dn_callback : consistency error - entryUUID is not unique\n", 0, 0, 0 );
+                               "dn_callback : consistency error - "
+                               "entryUUID is not unique\n", 0, 0, 0 );
                } else {
                        ber_dupbv_x( &si->si_syncUUID_ndn, &rs->sr_entry->e_nname, NULL );
                }
        } else if ( rs->sr_type == REP_RESULT ) {
                if ( rs->sr_err == LDAP_SIZELIMIT_EXCEEDED ) {
                        Debug( LDAP_DEBUG_ANY,
-                               "dn_callback : consistency error - entryUUID is not unique\n", 0, 0, 0 );
+                               "dn_callback : consistency error - "
+                               "entryUUID is not unique\n", 0, 0, 0 );
                }
        }
 
@@ -1980,8 +2008,7 @@ slap_create_syncrepl_entry(
                        context_csn, NULL );
        }
 
-       bv.bv_val = "{}";
-       bv.bv_len = sizeof("{}")-1;
+       BER_BVSTR( &bv, "{}" );
        attr_merge_one( e, slap_schema.si_ad_subtreeSpecification, &bv, NULL );
 
        build_new_dn( &e->e_name, &be->be_nsuffix[0], rdn, NULL );
@@ -2011,8 +2038,12 @@ slap_uuidstr_from_normalized(
 
        new->bv_len = 36;
 
-       if (( new->bv_val = slap_sl_malloc( new->bv_len + 1, ctx )) == NULL) {
-               if ( !uuidstr ) slap_sl_free( new, ctx );
+       if ( ( new->bv_val = slap_sl_malloc( new->bv_len + 1, ctx ) ) == NULL ) {
+               if ( !uuidstr ) {
+                       slap_sl_free( new, ctx );
+               } else {
+                       BER_BVZERO( uuidstr );
+               }
                return NULL;
        }
 
@@ -2052,11 +2083,13 @@ syncuuid_cmp( const void* v_uuid1, const void* v_uuid2 )
 }
 
 static void
-avl_ber_bvfree( void *bv )
+avl_ber_bvfree( void *v_bv )
 {
-       if( bv == NULL ) return;
-       if ( ((struct berval *)bv)->bv_val != NULL ) {
-               ch_free( ((struct berval *)bv)->bv_val );
+       struct berval   *bv = (struct berval *)v_bv;
+       
+       if( v_bv == NULL ) return;
+       if ( !BER_BVISNULL( bv ) ) {
+               ch_free( bv->bv_val );
        }
        ch_free( (char *) bv );
 }