]> git.sur5r.net Git - openldap/blobdiff - servers/slapd/back-tcl/tcl_modify.c
Fix cursor initialization, scope IDs
[openldap] / servers / slapd / back-tcl / tcl_modify.c
index d9d380157e56ee5b568d6c9f22234b4e09c3e68d..3a7462263b1a0e3eadcb3825285f0bab4f2468d3 100644 (file)
@@ -1,5 +1,5 @@
-/*
- * modify.c - tcl modify routines
+/* $OpenLDAP$ */
+/* modify.c - tcl modify routines
  *
  * Copyright 1999, Ben Collins <bcollins@debian.org>, All rights reserved.
  *
@@ -7,10 +7,6 @@
  * as authorized by the OpenLDAP Public License.  A copy of this
  * license is available at http://www.OpenLDAP.org/license.html or
  * in file LICENSE in the top-level directory of the distribution.
- *
- * $Id$
- *
- * $Log$
  */
 
 #include "portable.h"
 #include "slap.h"
 #include "tcl_back.h"
 
-int tcl_back_modify (
-       Backend * be,
-       Connection * conn,
+int
+tcl_back_modify (
        Operation * op,
-       char *dn,
-       LDAPModList * modlist
+       SlapReply * rs
 )
 {
-       char *command, *suf_tcl, *bp, *tcl_mods, *results;
-       int i, code, err = 0, len, bsize;
-       struct tclinfo *ti = (struct tclinfo *) be->be_private;
+       char *command, *bp, *tcl_mods, *results;
+       struct berval suf_tcl;
+       int i, code, len, bsize;
+       struct tclinfo *ti = (struct tclinfo *) op->o_bd->be_private;
+       Modifications *modlist = op->oq_modify.rs_modlist;
 
-       if (ti->ti_modify == NULL) {
-               send_ldap_result (conn, op, LDAP_UNWILLING_TO_PERFORM, NULL,
-                       "modify not implemented");
+       if (ti->ti_modify.bv_len == 0) {
+               send_ldap_error (op, rs, LDAP_UNWILLING_TO_PERFORM,
+                       "modify not implemented" );
                return (-1);
        }
 
-       for ( i = 0; be->be_suffix[i] != NULL; i++ )
-               ;
-       suf_tcl = Tcl_Merge(i, be->be_suffix);
+       if (tcl_merge_bvlist (op->o_bd->be_suffix, &suf_tcl) == NULL) {
+               send_ldap_error (op, rs, LDAP_OTHER, NULL);
+               return (-1);
+       }
 
-       tcl_mods = (char *) ch_malloc( BUFSIZ );
+       tcl_mods = (char *) ch_malloc (BUFSIZ);
        tcl_mods[0] = '\0';
        bsize = BUFSIZ;
        bp = tcl_mods;
 
-       for ( ; modlist != NULL; modlist = modlist->ml_next ) {
-               LDAPMod *mods = &modlist->ml_mod;
-               char *op = NULL;
+       for (; modlist != NULL; modlist = modlist->sml_next) {
+               Modification *mods = &modlist->sml_mod;
+               const struct berval 
+                       op_add = { sizeof("add") - 1, "add" },
+                       op_delete = { sizeof("delete") - 1, "delete" },
+                       op_replace = { sizeof("replace") - 1, "replace" },
+                       *op = NULL;
 
-               switch ( mods->mod_op & ~LDAP_MOD_BVALUES ) {
+               switch (mods->sm_op & ~LDAP_MOD_BVALUES) {
                case LDAP_MOD_ADD:
-                       op = "add";
+                       op = &op_add;
                        break;
                case LDAP_MOD_DELETE:
-                       op = "delete";
+                       op = &op_delete;
                        break;
                case LDAP_MOD_REPLACE:
-                       op = "replace";
+                       op = &op_replace;
                        break;
+               default:
+                       assert(0);
                }
 
-               len = strlen( mods->mod_type ) + strlen ( op ) + 7;
-               while ( bp + len - tcl_mods > bsize ) {
+               len = mods->sm_type.bv_len + op->bv_len + 7;
+               while (bp + len - tcl_mods > bsize) {
                        bsize += BUFSIZ;
-                       tcl_mods = (char *) ch_realloc( tcl_mods, bsize );
+                       tcl_mods = (char *) ch_realloc (tcl_mods, bsize);
                }
-               sprintf(bp, "{ {%s: %s} ", op, mods->mod_type);
+               sprintf (bp, "{ {%s: %s} ", op->bv_val, mods->sm_type.bv_val);
                bp += len;
-               fori = 0;
-                       mods->mod_bvalues != NULL && mods->mod_bvalues[i] != NULL;
-                       i++ )
-               {
-                       len = strlen( mods->mod_type ) + strlen (
-                               mods->mod_bvalues[i]->bv_val ) + 5 +
-                               (mods->mod_bvalues[i+1] == NULL ? 2 : 0);
-                       while ( bp + len - tcl_mods > bsize ) {
+               for (i = 0;
+                       mods->sm_bvalues != NULL && mods->sm_bvalues[i].bv_val
+                       != NULL;
+                       i++) {
+                       len = mods->sm_type.bv_len +
+                               mods->sm_bvalues[i].bv_len + 5 +
+                               (mods->sm_bvalues[i + 1].bv_val == NULL ? 2 : 0);
+                       while (bp + len - tcl_mods > bsize) {
                                bsize += BUFSIZ;
-                               tcl_mods = (char *) ch_realloc( tcl_mods, bsize );
+                               tcl_mods = (char *) ch_realloc (tcl_mods, bsize);
                        }
-                       sprintf(bp, "{%s: %s} %s", mods->mod_type,
-                       mods->mod_bvalues[i]->bv_val, mods->mod_bvalues[i+1] ==
-                       NULL ? "} " : "");
+                       sprintf (bp, "{%s: %s} %s", mods->sm_type.bv_val,
+                               mods->sm_bvalues[i].bv_val,
+                               mods->sm_bvalues[i + 1].bv_val ==
+                               NULL ? "} " : "");
                        bp += len;
                }
        }
 
-       command = (char *) ch_malloc (strlen(ti->ti_modify) + strlen(suf_tcl)
-               + strlen(dn) + strlen(tcl_mods) + 64);
+       command = (char *) ch_malloc (ti->ti_modify.bv_len + suf_tcl.bv_len
+               + op->o_req_dn.bv_len + strlen (tcl_mods) + 84);
        /* This space is simply for aesthetics--\  */
-       sprintf(command, "%s MODIFY {%ld} {%s} {%s} { %s}",
-               ti->ti_modify, op->o_msgid, suf_tcl, dn, tcl_mods);
-       Tcl_Free(suf_tcl);
-       free(tcl_mods);
+       sprintf (command, "%s MODIFY {%ld/%ld} {%s} {%s} { %s}",
+               ti->ti_modify.bv_val, op->o_connid, (long) op->o_msgid,
+               suf_tcl.bv_val, op->o_req_dn.bv_val, tcl_mods);
+       Tcl_Free (suf_tcl.bv_val);
+       free (tcl_mods);
 
-       ldap_pvt_thread_mutex_lock( &tcl_interpreter_mutex );
-       code = Tcl_GlobalEval(ti->ti_ii->interp, command);
-       results = (char *) strdup(ti->ti_ii->interp->result);
-       ldap_pvt_thread_mutex_unlock( &tcl_interpreter_mutex );
-       free(command);
+       ldap_pvt_thread_mutex_lock (&tcl_interpreter_mutex);
+       code = Tcl_GlobalEval (ti->ti_ii->interp, command);
+       results = (char *) ch_strdup (ti->ti_ii->interp->result);
+       ldap_pvt_thread_mutex_unlock (&tcl_interpreter_mutex);
+       free (command);
 
        if (code != TCL_OK) {
-               err = LDAP_OPERATIONS_ERROR;
-               Debug(LDAP_DEBUG_ANY, "tcl_modify_error: %s\n", results, 0, 0);
+               rs->sr_err = LDAP_OTHER;
+               Debug (LDAP_DEBUG_SHELL, "tcl_modify_error: %s\n", results,
+                       0, 0);
        } else {
-               interp_send_results ( be, conn, op, results, NULL, 0 );
+               interp_send_results (op, rs, results);
        }
 
-       if (err != LDAP_SUCCESS)
-               send_ldap_result (conn, op, err, NULL, "internal backend error");
+       if (rs->sr_err != LDAP_SUCCESS) {
+               rs->sr_text = "internal backend error";
+               send_ldap_result (op, rs);
+       }
 
-       return (0);
+       free (results);
+       return (rs->sr_err);
 }