int rc;
        Entry *e = NULL;
        Attribute *a;
-       SlapReply rs = {REP_RESULT};
        slap_callback cb = {0};
 
        READ_STRING(fp,uidc);
                AttributeAssertion ava = ATTRIBUTEASSERTION_INIT;
                struct berval hostdn = BER_BVNULL;
                struct berval odn = op->o_ndn;
+               SlapReply rs = {REP_RESULT};
                op->o_dn = dn;
                op->o_ndn = dn;
                {
                                !BER_BVISEMPTY(&ni->ni_pam_defhost)) {
                                filter.bv_len = sizeof(fbuf);
                                filter.bv_val = fbuf;
-                               memset(&rs2, 0, sizeof(rs2));
-                               rs2.sr_type = REP_RESULT;
+                               rs_reinit(&rs2, REP_RESULT);
                                nssov_filter_byname(mi,0,&ni->ni_pam_defhost,&filter);
                                op->ors_filterstr = filter;
                                op->ors_filter = str2filter_x(op, filter.bv_val);
                !BER_BVISEMPTY(&ni->ni_pam_group_dn) &&
                ni->ni_pam_group_ad) {
                AttributeAssertion ava = ATTRIBUTEASSERTION_INIT;
+               SlapReply rs = {REP_RESULT};
                op->o_callback = &cb;
                cb.sc_response = slap_null_cb;
                op->o_tag = LDAP_REQ_COMPARE;
 
        struct berval   syncUUID_strrep = BER_BVNULL;
 
        SlapReply       rs_search = {REP_RESULT};
-       SlapReply       rs_delete = {REP_RESULT};
-       SlapReply       rs_add = {REP_RESULT};
-       SlapReply       rs_modify = {REP_RESULT};
        Filter f = {0};
        AttributeAssertion ava = ATTRIBUTEASSERTION_INIT;
        int rc = LDAP_SUCCESS;
                }
 retry_add:;
                if ( BER_BVISNULL( &dni.dn ) ) {
+                       SlapReply       rs_add = {REP_RESULT};
 
                        op->o_req_dn = entry->e_name;
                        op->o_req_ndn = entry->e_nname;
                        struct berval noldp, newp;
                        Modifications *mod, **modtail, **ml, *m2;
                        int i, got_replace = 0, just_rename = 0;
+                       SlapReply rs_modify = {REP_RESULT};
 
                        op->o_tag = LDAP_REQ_MODRDN;
                        dnRdn( &entry->e_name, &op->orr_newrdn );
                        }
                        op->o_bd = si->si_wbe;
 retry_modrdn:;
+                       rs_reinit( &rs_modify, REP_RESULT );
                        rc = op->o_bd->be_modrdn( op, &rs_modify );
 
                        /* NOTE: noSuchObject should result because the new superior
                                slap_queue_csn( op, syncCSN );
                }
                if ( dni.mods ) {
+                       SlapReply rs_modify = {REP_RESULT};
+
                        op->o_tag = LDAP_REQ_MODIFY;
                        op->orm_modlist = dni.mods;
                        op->orm_no_opattrs = 1;
                goto done;
        case LDAP_SYNC_DELETE :
                if ( !BER_BVISNULL( &dni.dn ) ) {
+                       SlapReply       rs_delete = {REP_RESULT};
                        op->o_req_dn = dni.dn;
                        op->o_req_ndn = dni.ndn;
                        op->o_tag = LDAP_REQ_DELETE;
                                        op->o_req_dn = pdn;
                                        op->o_req_ndn = pdn;
                                        op->o_callback = &cb;
+                                       rs_reinit( &rs_delete, REP_RESULT );
                                        op->o_bd->be_delete( op, &rs_delete );
                                } else {
                                        break;
 {
        Backend* be = op->o_bd;
        slap_callback   cb = { NULL };
-       SlapReply       rs_delete = {REP_RESULT};
        struct nonpresent_entry *np_list, *np_prev;
        int rc;
        AttributeName   an[2];
 
                np_list = LDAP_LIST_FIRST( &si->si_nonpresentlist );
                while ( np_list != NULL ) {
+                       SlapReply rs_delete = {REP_RESULT};
+
                        LDAP_LIST_REMOVE( np_list, npe_link );
                        np_prev = np_list;
                        np_list = LDAP_LIST_NEXT( np_list, npe_link );
                                        op->o_req_dn = pdn;
                                        op->o_req_ndn = pdn;
                                        op->o_callback = &cb;
+                                       rs_reinit( &rs_delete, REP_RESULT );
                                        /* give it a root privil ? */
                                        op->o_bd->be_delete( op, &rs_delete );
                                } else {
        struct berval dn = BER_BVNULL;
        struct berval ndn = BER_BVNULL;
        Entry   *glue;
-       SlapReply       rs_add = {REP_RESULT};
        struct berval   ptr, nptr;
        char            *comma;
 
        }
 
        while ( ndn.bv_val > e->e_nname.bv_val ) {
+               SlapReply       rs_add = {REP_RESULT};
+
                glue = entry_alloc();
                ber_dupbv( &glue->e_name, &dn );
                ber_dupbv( &glue->e_nname, &ndn );
                char txtbuf[SLAP_TEXT_BUFLEN];
                size_t textlen = sizeof txtbuf;
                Entry *e = slap_create_context_csn_entry( op->o_bd, NULL );
+               rs_reinit( &rs_modify, REP_RESULT );
                rc = slap_mods2entry( &mod, &e, 0, 1, &text, txtbuf, textlen);
                op->ora_e = e;
                rc = op->o_bd->be_add( op, &rs_modify );