ITS#6915 fix op timestamps

[openldap] / clients / tools / common.c

diff --git a/clients/tools/common.c b/clients/tools/common.c
index 2177c652d980a32ae548165e03177212ba8e571f..262631e4cad1ca904c684786ff9fc4d33cdadbe9 100644 (file)
--- a/clients/tools/common.c
+++ b/clients/tools/common.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2010 The OpenLDAP Foundation.
+ * Copyright 1998-2011 The OpenLDAP Foundation.
  * Portions Copyright 2003 Kurt D. Zeilenga.
  * Portions Copyright 2003 IBM Corporation.
  * All rights reserved.
@@ -120,14 +120,13 @@ static int        chainingContinuation = -1;
 #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
 #ifdef LDAP_CONTROL_X_SESSION_TRACKING
 static int     sessionTracking = 0;
+static char    *sessionTrackingName;
 struct berval  stValue;
 #endif /* LDAP_CONTROL_X_SESSION_TRACKING */
 ber_int_t vlvPos;
 ber_int_t vlvCount;
 struct berval *vlvContext;
-#ifdef LDAP_CONTROL_AUTHZID_REQUEST
 static int     bauthzid;
-#endif /* LDAP_CONTROL_AUTHZID_REQUEST */
 
 LDAPControl    *unknown_ctrls = NULL;
 int            unknown_ctrls_num = 0;
@@ -207,6 +206,9 @@ st_value( LDAP *ld, struct berval *value )
                }
        }
 
+       if ( sessionTrackingName != NULL ) {
+               ber_str2bv( sessionTrackingName , 0, 0, &id );
+       } else
 #ifdef HAVE_CYRUS_SASL
        if ( sasl_authz_id != NULL ) {
                ber_str2bv( sasl_authz_id, 0, 0, &id );
@@ -264,21 +266,67 @@ tool_destroy( void )
 
        if ( pr_cookie.bv_val != NULL ) {
                ber_memfree( pr_cookie.bv_val );
-               pr_cookie.bv_val = NULL;
-               pr_cookie.bv_len = 0;
+               BER_BVZERO( &pr_cookie );
        }
 
        if ( binddn != NULL ) {
                ber_memfree( binddn );
+               binddn = NULL;
        }
 
        if ( passwd.bv_val != NULL ) {
                ber_memfree( passwd.bv_val );
+               BER_BVZERO( &passwd );
        }
 
+#ifdef HAVE_CYRUS_SASL
+       if ( sasl_mech != NULL ) {
+               ber_memfree( sasl_mech );
+               sasl_mech = NULL;
+       }
+#endif /* HAVE_CYRUS_SASL */
+
        if ( infile != NULL ) {
                ber_memfree( infile );
+               infile = NULL;
        }
+
+       if ( assertion ) {
+               ber_memfree( assertion );
+               assertion = NULL;
+       }
+
+       if ( authzid ) {
+               ber_memfree( authzid );
+               authzid = NULL;
+       }
+
+       if ( proxydn ) {
+               ber_memfree( proxydn );
+               proxydn = NULL;
+       }
+
+       if ( preread_attrs ) {
+               ber_memfree( preread_attrs );
+               preread_attrs = NULL;
+       }
+
+       if ( postread_attrs ) {
+               ber_memfree( postread_attrs );
+               postread_attrs = NULL;
+       }
+
+#ifdef LDAP_CONTROL_X_SESSION_TRACKING
+       if ( !BER_BVISNULL( &stValue ) ) {
+               ber_memfree( stValue.bv_val );
+               BER_BVZERO( &stValue );
+       }
+
+       if ( sessionTrackingName ) {
+               ber_memfree( sessionTrackingName );
+               sessionTrackingName = NULL;
+       }
+#endif /* LDAP_CONTROL_X_SESSION_TRACKING */
 }
 
 void
@@ -311,7 +359,7 @@ N_("             [!]postread[=<attrs>]  (RFC 4527; comma-separated attr list)\n"
 N_("             [!]preread[=<attrs>]   (RFC 4527; comma-separated attr list)\n")
 N_("             [!]relax\n")
 #ifdef LDAP_CONTROL_X_SESSION_TRACKING
-N_("             [!]sessiontracking\n")
+N_("             [!]sessiontracking[=<username>]\n")
 #endif /* LDAP_CONTROL_X_SESSION_TRACKING */
 N_("             abandon, cancel, ignore (SIGINT sends abandon/cancel,\n"
    "             or ignores response; if critical, doesn't wait for SIGINT.\n"
@@ -348,6 +396,8 @@ NULL
                        fputs( _(*cpp), stderr );
                }
        }
+
+       tool_destroy();
 }
 
 void tool_perror(
@@ -439,7 +489,7 @@ tool_args( int argc, char **argv )
                                assertctl = 1 + crit;
 
                                assert( assertion == NULL );
-                               assertion = cvalue;
+                               assertion = ber_strdup( cvalue );
 
                        } else if ( strcasecmp( control, "authzid" ) == 0 ) {
                                if( authzid != NULL ) {
@@ -466,7 +516,7 @@ tool_args( int argc, char **argv )
                                }
 
                                assert( authzid == NULL );
-                               authzid = cvalue;
+                               authzid = ber_strdup( cvalue );
 
 #ifdef LDAP_CONTROL_OBSOLETE_PROXY_AUTHZ
                        } else if ( strcasecmp( control, "proxydn" ) == 0 ) {
@@ -492,10 +542,9 @@ tool_args( int argc, char **argv )
                                }
 
                                assert( proxydn == NULL );
-                               proxydn = cvalue;
+                               proxydn = ber_strdup( cvalue );
 #endif /* LDAP_CONTROL_OBSOLETE_PROXY_AUTHZ */
 
-#ifdef LDAP_CONTROL_AUTHZID_REQUEST
                        } else if ( strcasecmp( control, "bauthzid" ) == 0 ) {
                                if( bauthzid ) {
                                        fprintf( stderr, "bauthzid control previously specified\n");
@@ -505,8 +554,7 @@ tool_args( int argc, char **argv )
                                        fprintf( stderr, "bauthzid: no control value expected\n" );
                                        usage();
                                }
-                               bauthzid = crit ? 2 : 1;
-#endif
+                               bauthzid = 1 + crit;
 
                        } else if ( ( strcasecmp( control, "relax" ) == 0 ) ||
                                ( strcasecmp( control, "manageDIT" ) == 0 ) )
@@ -575,7 +623,7 @@ tool_args( int argc, char **argv )
                                }
 
                                preread = 1 + crit;
-                               preread_attrs = cvalue;
+                               preread_attrs = ber_strdup( cvalue );
 
                        } else if ( strcasecmp( control, "postread" ) == 0 ) {
                                if( postread ) {
@@ -584,7 +632,7 @@ tool_args( int argc, char **argv )
                                }
 
                                postread = 1 + crit;
-                               postread_attrs = cvalue;
+                               postread_attrs = ber_strdup( cvalue );
 
 #ifdef LDAP_CONTROL_X_CHAINING_BEHAVIOR
                        } else if ( strcasecmp( control, "chaining" ) == 0 ) {
@@ -637,6 +685,22 @@ tool_args( int argc, char **argv )
                                }
 #endif /* LDAP_CONTROL_X_CHAINING_BEHAVIOR */
 
+#ifdef LDAP_CONTROL_X_SESSION_TRACKING
+                       } else if ( strcasecmp( control, "sessiontracking" ) == 0 ) {
+                               if ( sessionTracking ) {
+                                       fprintf( stderr, "%s: session tracking can be only specified once\n", prog );
+                                       exit( EXIT_FAILURE );
+                               }
+                               sessionTracking = 1;
+                               if ( crit ) {
+                                       fprintf( stderr, "sessiontracking: critical flag not allowed\n" );
+                                       usage();
+                               }
+                               if ( cvalue ) {
+                                       sessionTrackingName = ber_strdup( cvalue );
+                               }
+#endif /* LDAP_CONTROL_X_SESSION_TRACKING */
+
                        /* this shouldn't go here, really; but it's a feature... */
                        } else if ( strcasecmp( control, "abandon" ) == 0 ) {
                                abcan = Intr_Abandon;
@@ -656,15 +720,6 @@ tool_args( int argc, char **argv )
                                        gotintr = abcan;
                                }
 
-#ifdef LDAP_CONTROL_X_SESSION_TRACKING
-                       } else if ( strcasecmp( control, "sessiontracking" ) == 0 ) {
-                               if ( sessionTracking ) {
-                                       fprintf( stderr, "%s: session tracking can be only specified once\n", prog );
-                                       exit( EXIT_FAILURE );
-                               }
-                               sessionTracking = 1;
-#endif /* LDAP_CONTROL_X_SESSION_TRACKING */
-
                        } else if ( tool_is_oid( control ) ) {
                                LDAPControl     *tmpctrls, ctrl;
 
@@ -686,6 +741,8 @@ tool_args( int argc, char **argv )
                                }
                                unknown_ctrls = tmpctrls;
                                ctrl.ldctl_oid = control;
+                               /* don't free it */
+                               control = NULL;
                                ctrl.ldctl_value.bv_val = NULL;
                                ctrl.ldctl_value.bv_len = 0;
                                ctrl.ldctl_iscritical = crit;
@@ -720,6 +777,10 @@ tool_args( int argc, char **argv )
                                        control );
                                usage();
                        }
+                       if ( control ) {
+                               ber_memfree( control );  
+                               control = NULL;
+                       }
                        break;
                case 'f':       /* read from file */
                        if( infile != NULL ) {
@@ -1136,6 +1197,12 @@ tool_args( int argc, char **argv )
                }
 #endif
        }
+
+       if ( ( pw_file || want_bindpw ) && !BER_BVISNULL( &passwd ) ) {
+               fprintf( stderr, "%s: -%c incompatible with -w\n",
+                       prog, ( pw_file ? 'y' : 'W' ) );
+               exit( EXIT_FAILURE );
+       }
 }
 
 
@@ -1416,7 +1483,6 @@ tool_bind( LDAP *ld )
        }
 #endif
 
-#ifdef LDAP_CONTROL_AUTHZID_REQUEST
        if ( bauthzid ) {
                LDAPControl c;
 
@@ -1428,19 +1494,18 @@ tool_bind( LDAP *ld )
                sctrls[nsctrls] = &sctrl[nsctrls];
                sctrls[++nsctrls] = NULL;
        }
-#endif /* LDAP_CONTROL_AUTHZID_REQUEST */
 
 #ifdef LDAP_CONTROL_X_SESSION_TRACKING
        if ( sessionTracking ) {
                LDAPControl c;
 
-               if (stValue.bv_val == NULL && st_value( ld, &stValue ) ) {
+               if ( BER_BVISNULL( &stValue) && st_value( ld, &stValue ) ) {
                        exit( EXIT_FAILURE );
                }
 
                c.ldctl_oid = LDAP_CONTROL_X_SESSION_TRACKING;
                c.ldctl_iscritical = 0;
-               ber_dupbv( &c.ldctl_value, &stValue );
+               c.ldctl_value = stValue;
 
                sctrl[nsctrls] = c;
                sctrls[nsctrls] = &sctrl[nsctrls];
@@ -1588,7 +1653,6 @@ tool_bind( LDAP *ld )
        }
 #endif
 
-#ifdef LDAP_CONTROL_AUTHZID_REQUEST
        if ( ctrls && bauthzid ) {
                LDAPControl *ctrl;
                
@@ -1601,7 +1665,6 @@ tool_bind( LDAP *ld )
                        tool_print_ctrls( ld, ctmp );
                }
        }
-#endif /* LDAP_CONTROL_AUTHZID_REQUEST */
 
        if ( ctrls ) {
                ldap_controls_free( ctrls );
@@ -1867,13 +1930,13 @@ tool_server_controls( LDAP *ld, LDAPControl *extra_c, int count )
 
 #ifdef LDAP_CONTROL_X_SESSION_TRACKING
        if ( sessionTracking ) {
-               if ( stValue.bv_val == NULL && st_value( ld, &stValue ) ) {
+               if ( BER_BVISNULL( &stValue ) && st_value( ld, &stValue ) ) {
                        exit( EXIT_FAILURE );
                }
 
                c[i].ldctl_oid = LDAP_CONTROL_X_SESSION_TRACKING;
                c[i].ldctl_iscritical = 0;
-               ber_dupbv( &c[i].ldctl_value, &stValue );
+               c[i].ldctl_value = stValue;
 
                ctrls[i] = &c[i];
                i++;
@@ -1953,6 +2016,7 @@ print_prepostread( LDAP *ld, LDAPControl *ctrl, struct berval *what)
                while ( ber_scanf( ber, "{m" /*}*/, &bv ) != LBER_ERROR ) {
                        int             i;
                        BerVarray       vals = NULL;
+                       char            *str = NULL;
 
                        if ( ber_scanf( ber, "[W]", &vals ) == LBER_ERROR ||
                                vals == NULL )
@@ -1960,14 +2024,25 @@ print_prepostread( LDAP *ld, LDAPControl *ctrl, struct berval *what)
                                /* error? */
                                return 1;
                        }
+
+                       if ( ldif ) {
+                               char *ptr;
+
+                               str = malloc( bv.bv_len + STRLENOF(": ") + 1 );
+
+                               ptr = str;
+                               ptr = lutil_strncopy( ptr, bv.bv_val, bv.bv_len );
+                               ptr = lutil_strcopy( ptr, ": " );
+                       }
                
                        for ( i = 0; vals[ i ].bv_val != NULL; i++ ) {
                                tool_write_ldif(
                                        ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
-                                       bv.bv_val, vals[ i ].bv_val, vals[ i ].bv_len );
+                                       ldif ? str : bv.bv_val, vals[ i ].bv_val, vals[ i ].bv_len );
                        }
 
                        ber_bvarray_free( vals );
+                       if ( str ) free( str );
                }
        }
 
@@ -2047,7 +2122,8 @@ print_paged_results( LDAP *ld, LDAPControl *ctrl )
                }
 
                tool_write_ldif( ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
-                       "pagedresults", buf, ptr - buf );
+                       ldif ? "pagedresults: " : "pagedresults",
+                       buf, ptr - buf );
        }
 
        return 0;
@@ -2067,7 +2143,7 @@ print_sss( LDAP *ld, LDAPControl *ctrl )
                        err, ldap_err2string(err), attr ? " " : "", attr ? attr : "" );
 
                tool_write_ldif( ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
-                       "sortResult", buf, rc );
+                       ldif ? "sortResult: " : "sortResult", buf, rc );
        }
 
        return rc;
@@ -2107,7 +2183,7 @@ print_vlv( LDAP *ld, LDAPControl *ctrl )
                        ber_memfree( bv.bv_val );
 
                tool_write_ldif( ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
-                       "vlvResult", buf, rc );
+                       ldif ? "vlvResult" : "vlvResult", buf, rc );
        }
 
        return rc;
@@ -2241,13 +2317,17 @@ print_whatfailed( LDAP *ld, LDAPControl *ctrl )
 static int
 print_authzid( LDAP *ld, LDAPControl *ctrl )
 {
-    if (ctrl->ldctl_value.bv_len) {
-           tool_write_ldif( ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
-                   "authzid", ctrl->ldctl_value.bv_val,  ctrl->ldctl_value.bv_len );
+       if ( ctrl->ldctl_value.bv_len ) {
+               tool_write_ldif( ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
+                       ldif ? "authzid: " : "authzid",
+               ctrl->ldctl_value.bv_val, ctrl->ldctl_value.bv_len );
        } else {
-           tool_write_ldif( ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
-                   "authzid", "anonymous",  sizeof("anonymous")-1);
+               tool_write_ldif( ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
+                       ldif ? "authzid: " : "authzid",
+                       "anonymous",  STRLENOF("anonymous") );
        }
+
+       return 0;
 }
 #endif
 
@@ -2281,7 +2361,7 @@ print_ppolicy( LDAP *ld, LDAPControl *ctrl )
                }
 
                tool_write_ldif( ldif ? LDIF_PUT_COMMENT : LDIF_PUT_VALUE,
-                       "ppolicy", buf, ptr - buf );
+                       ldif ? "ppolicy: " : "ppolicy", buf, ptr - buf );
        }
 
        return rc;