Resolves: bug 454030

Bug Description: Need to address 64-bit compiler warnings - again
Reviewed by: nhosoi (Thanks!)
Fix Description: This patch cleans up most of the other remaining compiler warnings.  I compiled the directory server code with these flags on RHEL5 x86_64: -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m64 -mtune=generic
I also enabled argument/format match checking for most of the commonly used varadic functions.  Most of the problems I found fell into these categories:
1) Too many or not enough arguments e.g. most everything that uses or did use LDAPDebug had extra 0,0 arguments.  If they had been switched to use slapi_log_error, I removed the extra arguments - for those places still using LDAPDebug, I introduced more macros to handle the number of arguments, since C macros cannot be varadic.
2) When using NSPR formatting functions, we have to use %llu or %lld for 64-bit values, even on 64-bit systems.  However, for regular system formatting functions, we have to use %ld or %lu.  I introduced two new macros NSPRIu64 and NSPRI64 to handle cases where we are passing explicit 64-bit values to NSPR formatting functions, so that we can use the regular PRIu64 and PRI64 macros for regular system formatting functions.  I also made sure we used NSPRI* only with NSPR functions, and used PRI* only with system functions.
3) use %lu for size_t and %ld for time_t
I did find a few "real" errors, places that the code was doing something definitely not right:
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/plugins/acl/aclinit.c_sec4
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/plugins/acl/acllas.c_sec17
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/plugins/http/http_impl.c_sec1
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/plugins/memberof/memberof.c_sec1
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/plugins/pam_passthru/pam_ptimpl.c_sec1
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/plugins/replication/cl5_api.c_sec5
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/plugins/replication/cl5_clcache.c_sec2
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/plugins/replication/replutil.c_sec1
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/slapd/libglobs.c_sec1
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/slapd/back-ldbm/dbverify.c_sec2
https://bugzilla.redhat.com/attachment.cgi?id=325774&action=diff#ldapserver/ldap/servers/slapd/back-ldbm/ldif2ldbm.c_sec3
This is why it's important to use this compiler checking, and why it's important to fix compiler warnings, if for no other reason than the sheer noise from so many warnings can mask real errors.
Platforms tested: RHEL5
Flag Day: no
Doc impact: no

ldap/include/ldaplog.h

@@ -73,9 +73,15 @@ extern "C" {
 /* Disable by default */
 #define LDAPDebug( level, fmt, arg1, arg2, arg3 )
 #define LDAPDebugLevelIsSet( level ) (0)
+#define LDAPDebug0Args( level, fmt )
+#define LDAPDebug1Arg( level, fmt, arg )
+#define LDAPDebug2Args( level, fmt, arg1, arg2 )
 
 #ifdef LDAP_DEBUG
 #  undef LDAPDebug
+#  undef LDAPDebug0Args
+#  undef LDAPDebug1Arg
+#  undef LDAPDebug2Args
 #  undef LDAPDebugLevelIsSet
 
 /* SLAPD_LOGGING should not be on for WINSOCK (16-bit Windows) */
@@ -90,6 +96,24 @@ extern "C" {
 		        slapd_log_error_proc( NULL, fmt, arg1, arg2, arg3 ); \
 	    } \
        }
+#      define LDAPDebug0Args( level, fmt )	\
+       { \
+		if ( *module_ldap_debug & level ) { \
+		        slapd_log_error_proc( NULL, fmt ); \
+	    } \
+       }
+#      define LDAPDebug1Arg( level, fmt, arg )      \
+       { \
+		if ( *module_ldap_debug & level ) { \
+		        slapd_log_error_proc( NULL, fmt, arg ); \
+	    } \
+       }
+#      define LDAPDebug2Args( level, fmt, arg1, arg2 )    \
+       { \
+		if ( *module_ldap_debug & level ) { \
+		        slapd_log_error_proc( NULL, fmt, arg1, arg2 ); \
+	    } \
+       }
 #      define LDAPDebugLevelIsSet( level ) (0 != (*module_ldap_debug & level))
 #    else /* Not _WIN32 */
        extern int	slapd_ldap_debug;
@@ -99,6 +123,24 @@ extern "C" {
 		        slapd_log_error_proc( NULL, fmt, arg1, arg2, arg3 ); \
 	    } \
        }
+#      define LDAPDebug0Args( level, fmt )	\
+       { \
+		if ( slapd_ldap_debug & level ) { \
+		        slapd_log_error_proc( NULL, fmt ); \
+	    } \
+       }
+#      define LDAPDebug1Arg( level, fmt, arg )      \
+       { \
+		if ( slapd_ldap_debug & level ) { \
+		        slapd_log_error_proc( NULL, fmt, arg ); \
+	    } \
+       }
+#      define LDAPDebug2Args( level, fmt, arg1, arg2 )    \
+       { \
+		if ( slapd_ldap_debug & level ) { \
+		        slapd_log_error_proc( NULL, fmt, arg1, arg2 ); \
+	    } \
+       }
 #      define LDAPDebugLevelIsSet( level ) (0 != (slapd_ldap_debug & level))
 #    endif /* Win32 */
 #  else /* no SLAPD_LOGGING */
@@ -110,6 +152,24 @@ extern "C" {
 			PR_snprintf( msg, sizeof(msg), fmt, arg1, arg2, arg3 ); \
 			ber_err_print( msg ); \
 		}
+#    define LDAPDebug0Args( level, fmt ) \
+		if ( slapd_ldap_debug & level ) { \
+			char msg[256]; \
+			PR_snprintf( msg, sizeof(msg), fmt ); \
+			ber_err_print( msg ); \
+		}
+#    define LDAPDebug1Arg( level, fmt, arg )  \
+		if ( slapd_ldap_debug & level ) { \
+			char msg[256]; \
+			PR_snprintf( msg, sizeof(msg), fmt, arg );  \
+			ber_err_print( msg ); \
+		}
+#    define LDAPDebug2Args( level, fmt, arg1, arg2 ) \
+		if ( slapd_ldap_debug & level ) { \
+			char msg[256]; \
+			PR_snprintf( msg, sizeof(msg), fmt, arg1, arg2 );    \
+			ber_err_print( msg ); \
+		}
 #    define LDAPDebugLevelIsSet( level )	(0 != (slapd_ldap_debug & level))
 #  endif /* SLAPD_LOGGING */
 #endif /* LDAP_DEBUG */

ldap/servers/plugins/acl/acl.c

@@ -297,7 +297,7 @@ acl_access_allowed(
 
 		 if (  !privateBackend && (be_readonly ||  slapi_config_get_readonly () )){
 			slapi_log_error	(loglevel, plugin_name,
-				"conn=%" PRIu64 " op=%d (main): Deny %s on entry(%s)"
+				"conn=%" NSPRIu64 " op=%d (main): Deny %s on entry(%s)"
 				": readonly backend\n",
 				 op->o_connid, op->o_opid,
 				acl_access2str(access),
@@ -310,7 +310,7 @@ acl_access_allowed(
 	TNF_PROBE_0_DEBUG(acl_skipaccess_start,"ACL","");
 	if (  acl_skip_access_check ( pb, e )) {
 		slapi_log_error	(loglevel,	plugin_name,
-				"conn=%" PRIu64 " op=%d (main): Allow %s on entry(%s)"
+				"conn=%" NSPRIu64 " op=%d (main): Allow %s on entry(%s)"
 				": root user\n",
 				op->o_connid, op->o_opid,
 				acl_access2str(access),
@@ -438,7 +438,7 @@ acl_access_allowed(
 		TNF_PROBE_0_DEBUG(acl_entry_first_touch_start,"ACL","");
 
 		slapi_log_error(loglevel, plugin_name,
-			"#### conn=%" PRIu64 " op=%d binddn=\"%s\"\n",
+			"#### conn=%" NSPRIu64 " op=%d binddn=\"%s\"\n",
 			op->o_connid, op->o_opid, clientDn);
 		aclpb->aclpb_stat_total_entries++;
 
@@ -504,7 +504,7 @@ acl_access_allowed(
                                                  
 		if (rv < 0) {
 			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-	    	  		"Unable to set the Slapi_Entry in the Plist\n",0,0,0);
+	    	  		"Unable to set the Slapi_Entry in the Plist\n");
 			ret_val = LDAP_OPERATIONS_ERROR;
 			goto cleanup_and_ret;
 		}
@@ -570,7 +570,7 @@ acl_access_allowed(
 
 	slapi_log_error( SLAPI_LOG_ACL, plugin_name,
 		   "Processed attr:%s for entry:%s\n", attr ? attr : "NULL",
-		   ACL_ESCAPE_STRING_WITH_PUNCTUATION ( n_edn, ebuf), 0);
+		   ACL_ESCAPE_STRING_WITH_PUNCTUATION ( n_edn, ebuf));
 
 	/*
 	** Now evaluate the rights. 
@@ -755,7 +755,7 @@ static void print_access_control_summary( char *source, int ret_val, char *clien
 										null_user);
 
 				slapi_log_error(loglevel, plugin_name, 
-		"conn=%" PRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
+		"conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
 		": %s\n",
 				op->o_connid, op->o_opid,
 				source,
@@ -768,7 +768,7 @@ static void print_access_control_summary( char *source, int ret_val, char *clien
 		} else {
 					proxy_user = null_user;
 					slapi_log_error(loglevel, plugin_name, 
-		"conn=%" PRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
+		"conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to proxy (%s)"
 		": %s\n",
 				op->o_connid, op->o_opid,
 				source,
@@ -781,7 +781,7 @@ static void print_access_control_summary( char *source, int ret_val, char *clien
 		}
 	} else{
 		slapi_log_error(loglevel, plugin_name, 
-			"conn=%" PRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to %s"
+			"conn=%" NSPRIu64 " op=%d (%s): %s %s on entry(%s).attr(%s) to %s"
 			": %s\n",
 				op->o_connid, op->o_opid,
 				source,
@@ -1150,7 +1150,7 @@ acl_read_access_allowed_on_attr (
 		slapi_log_error (SLAPI_LOG_ACL, plugin_name, 
 			  "Root access (%s) allowed on entry(%s)\n",
 			   acl_access2str(access), 
-			   ACL_ESCAPE_STRING_WITH_PUNCTUATION (n_edn, ebuf), 0);
+			   ACL_ESCAPE_STRING_WITH_PUNCTUATION (n_edn, ebuf));
 		TNF_PROBE_1_DEBUG(acl_read_access_allowed_on_attr_end ,"ACL","",
 							tnf_string,skip_aclcheck,"");
 
@@ -1219,7 +1219,7 @@ acl_read_access_allowed_on_attr (
 	if (aclpb->aclpb_state & ACLPB_ATTR_STAR_MATCHED) {
 		slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
 		 	  "STAR Access allowed on attr:%s; entry:%s \n",
-		 	   attr, ACL_ESCAPE_STRING_WITH_PUNCTUATION (n_edn, ebuf), 0);
+		 	   attr, ACL_ESCAPE_STRING_WITH_PUNCTUATION (n_edn, ebuf));
 		decision_reason.reason =
 						ACL_REASON_EVALCONTEXT_CACHED_ATTR_STAR_ALLOW;
 		ret_val = LDAP_SUCCESS;
@@ -1575,7 +1575,7 @@ acl_modified (Slapi_PBlock *pb, int optype, char *n_dn, void *change)
 		*/
 		if ( group_change )  {
 			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
-			"Group Change: Invalidating entire UserGroup Cache\n",
+			"Group Change: Invalidating entire UserGroup Cache %s\n",
 			ACL_ESCAPE_STRING_WITH_PUNCTUATION(n_dn, ebuf));
 			aclg_regen_group_signature();
 			if (  (optype == SLAPI_OPERATION_MODIFY) || (optype == SLAPI_OPERATION_DELETE ) ) {
@@ -1753,7 +1753,7 @@ acl_modified (Slapi_PBlock *pb, int optype, char *n_dn, void *change)
 		new_RDN = (char*) change;
 		slapi_log_error (SLAPI_LOG_ACL, plugin_name, 
 			   "acl_modified (MODRDN %s => \"%s\"\n", 
-			   ACL_ESCAPE_STRING_WITH_PUNCTUATION (n_dn, ebuf), new_RDN, 0);
+			   ACL_ESCAPE_STRING_WITH_PUNCTUATION (n_dn, ebuf), new_RDN);
 
 		/* compute new_DN: */
 		parent_DN = slapi_dn_parent (n_dn);
@@ -1921,7 +1921,7 @@ acl__scan_for_acis(Acl_PBlock *aclpb, int *err)
 	aclpb->aclpb_num_allow_handles = allow_handle;
 
 	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "Num of ALLOW Handles:%d, DENY handles:%d\n", 
-		  aclpb->aclpb_num_allow_handles, aclpb->aclpb_num_deny_handles, 0);
+		  aclpb->aclpb_num_allow_handles, aclpb->aclpb_num_deny_handles);
 
 	TNF_PROBE_0_DEBUG(acl__scan_for_acis_end,"ACL","");
 
@@ -2057,8 +2057,7 @@ acl__resource_match_aci( Acl_PBlock *aclpb, aci_t *aci, int skip_attrEval, int *
 			dn_matched = ACL_FALSE;
 			if(rv == ACL_ERR) {
 				slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-					"acl__resource_match_aci:pattern err\n",
-					 0,0,0);
+					"acl__resource_match_aci:pattern err\n");
 				matches = ACL_FALSE;
 				goto acl__resource_match_aci_EXIT;	
 			}
@@ -2770,7 +2769,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, char **right, char ** map_generic,
 					if (access & SLAPI_ACL_SEARCH) {
 						if ( result & ACLPB_CACHE_SEARCH_RES_DENY){
 							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-						           "DENY:Found SEARCH DENY in cache\n",0,0,0);
+						           "DENY:Found SEARCH DENY in cache\n");
 							__acl_set_aclIndex_inResult ( aclpb, access, index );
 							result_reason->deciding_aci = aci;
 							result_reason->reason = ACL_REASON_RESULT_CACHED_DENY;
@@ -2780,7 +2779,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, char **right, char ** map_generic,
 						} else if ((result & ACLPB_CACHE_SEARCH_RES_SKIP) ||
 							   (result & ACLPB_CACHE_SEARCH_RES_ALLOW)) { 
 					  	    slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-							     "DENY:Found SEARCH SKIP in cache\n",0,0,0);
+							     "DENY:Found SEARCH SKIP in cache\n");
 							skip_eval = 1;
 							break;
 						} else {
@@ -2789,7 +2788,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, char **right, char ** map_generic,
 					} else {	/* must be READ */
 						if (result & ACLPB_CACHE_READ_RES_DENY) {
 							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-								  "DENY:Found READ DENY in cache\n",0,0,0);
+								  "DENY:Found READ DENY in cache\n");
 							__acl_set_aclIndex_inResult ( aclpb, access, index );
 							result_reason->deciding_aci = aci;
 							result_reason->reason = ACL_REASON_RESULT_CACHED_DENY;
@@ -2798,7 +2797,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, char **right, char ** map_generic,
 							return ACL_RES_DENY;
 						} else if ( result & ACLPB_CACHE_READ_RES_SKIP) {
 							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-								  "DENY:Found READ SKIP in cache\n",0,0,0);
+								  "DENY:Found READ SKIP in cache\n");
 							skip_eval = 1;
 							break;
 						} else {
@@ -2816,8 +2815,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, char **right, char ** map_generic,
 		rv = ACL_EvalSetACL(NULL, acleval, aci->aci_handle);
 		if ( rv < 0) {
 			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
-				"acl__TestRights:Unable to set the DENY acllist\n", 
-				0,0,0);
+				"acl__TestRights:Unable to set the DENY acllist\n");
 			continue;
 		}
 		/* 
@@ -2831,7 +2829,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, char **right, char ** map_generic,
 						&deny_generic,
 						&acl_tag, &expr_num);
 
-		slapi_log_error( SLAPI_LOG_ACL, plugin_name, "Processed:%d DENY handles Result:%d\n",index, rights_rv,0);
+		slapi_log_error( SLAPI_LOG_ACL, plugin_name, "Processed:%d DENY handles Result:%d\n",index, rights_rv);
 
 		if (rights_rv   == ACL_RES_FAIL) {
 				result_reason->deciding_aci = aci;
@@ -2989,7 +2987,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, char **right, char ** map_generic,
 							return ACL_RES_ALLOW;
 						} else if ( result & ACLPB_CACHE_SEARCH_RES_SKIP) {
 							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-							   "Found SEARCH SKIP in cache\n",0,0,0);
+							   "Found SEARCH SKIP in cache\n");
 							skip_eval = 1;
 							break;
 						} else {
@@ -2999,7 +2997,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, char **right, char ** map_generic,
 					} else {
 						if ( result & ACLPB_CACHE_READ_RES_ALLOW) {
 							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-							   "Found READ ALLOW in cache\n",0,0,0);
+							   "Found READ ALLOW in cache\n");
 							__acl_set_aclIndex_inResult ( aclpb, access, index );
 							result_reason->deciding_aci = aci;
 							result_reason->reason = ACL_REASON_RESULT_CACHED_ALLOW;
@@ -3008,7 +3006,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, char **right, char ** map_generic,
 							return ACL_RES_ALLOW;
 						} else if ( result & ACLPB_CACHE_READ_RES_SKIP) {
 							slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-							   "Found READ SKIP in cache\n",0,0,0);
+							   "Found READ SKIP in cache\n");
 							skip_eval = 1;
 							break;
 						} else {
@@ -3027,8 +3025,7 @@ acl__TestRights(Acl_PBlock *aclpb,int access, char **right, char ** map_generic,
 		rv = ACL_EvalSetACL(NULL, acleval, aci->aci_handle);
 		if ( rv < 0) {
 			slapi_log_error(SLAPI_LOG_FATAL, plugin_name,
-				"acl__TestRights:Unable to set the acllist\n", 
-				0,0,0);
+				"acl__TestRights:Unable to set the acllist\n");
 			continue;
 		}
 		/* 
@@ -3172,7 +3169,7 @@ acl_match_substring ( Slapi_Filter *f, char *str, int exact_match)
 		/* 2 * in case every char is special */
 		if (p + 2 * strlen ( initial ) > end) {
 			slapi_log_error (SLAPI_LOG_ACL, plugin_name, 
-				"not enough pattern space\n", 0, 0, 0);
+				"not enough pattern space\n");
 
 			return (ACL_ERR);
 		}
@@ -3190,7 +3187,7 @@ acl_match_substring ( Slapi_Filter *f, char *str, int exact_match)
 			/* ".*" + value */
 			if (p + 2 * strlen ( any[i]) + 2 > end) {
 				slapi_log_error (SLAPI_LOG_ACL, plugin_name,
-					"not enough pattern space\n", 0, 0, 0);
+					"not enough pattern space\n");
 				return (ACL_ERR);
 			}
 
@@ -3206,7 +3203,7 @@ acl_match_substring ( Slapi_Filter *f, char *str, int exact_match)
 		/* ".*" + value */
 		if (p + 2 * strlen ( final ) + 2 > end) {
 			slapi_log_error (SLAPI_LOG_ACL, plugin_name, 
-				"not enough pattern space\n", 0, 0, 0);
+				"not enough pattern space\n");
 			return (ACL_ERR);
 		}
 	
@@ -3240,7 +3237,7 @@ acl_match_substring ( Slapi_Filter *f, char *str, int exact_match)
 	slapd_re_lock();
 	if ((p = slapd_re_comp (pat)) != 0) {
 		slapi_log_error (SLAPI_LOG_ACL, plugin_name, 
-			"acl_match_substring:re_comp failed (%s)\n", p, 0, 0);
+			"acl_match_substring:re_comp failed (%s)\n", p);
 		slapd_re_unlock();
 		return (ACL_ERR);
 	}
@@ -3368,11 +3365,11 @@ acl__attr_cached_result (struct acl_pblock *aclpb, char *attr, int access )
 	if (aclpb->aclpb_state & ACLPB_HAS_ACLCB_EVALCONTEXT ) {
 		c_evalContext = &aclpb->aclpb_prev_opEval_context;
 		slapi_log_error ( SLAPI_LOG_ACL, plugin_name, 
-			    "acl__attr_cached_result:Using Context: ACLPB_ACLCB\n", 0,0,0 );
+			    "acl__attr_cached_result:Using Context: ACLPB_ACLCB\n" );
 	} else {
 		c_evalContext = &aclpb->aclpb_prev_entryEval_context;
 		slapi_log_error ( SLAPI_LOG_ACL, plugin_name, 
-			    "acl__attr_cached_result:Using Context: ACLPB_PREV\n", 0,0,0 );
+			    "acl__attr_cached_result:Using Context: ACLPB_PREV\n" );
 	}
 
 	if ( attr == NULL ) {

ldap/servers/plugins/acl/acl_ext.c

@@ -800,14 +800,14 @@ acl__done_aclpb ( struct acl_pblock *aclpb )
 	if ( aclpb->aclpb_res_type & ~ACLPB_RESTYPE_ALL ) {
 		slapi_log_error( SLAPI_LOG_FATAL, plugin_name, 
 			   "The aclpb res_type value (%d) has exceeded. Limit is (%d)\n",
-				aclpb->aclpb_res_type, ACLPB_RESTYPE_ALL, 0 );
+				aclpb->aclpb_res_type, ACLPB_RESTYPE_ALL );
 		dump_aclpb_info = 1;
 	}
 
 	if ( dump_aclpb_info ) {
 		const char *ndn;
 		slapi_log_error ( SLAPI_LOG_FATAL, plugin_name,
-							"ACLPB value is:%p\n", aclpb, 0,0 );
+							"ACLPB value is:%p\n", aclpb );
 	
 		ndn = slapi_sdn_get_ndn ( aclpb->aclpb_curr_entry_sdn );	
 		slapi_log_error ( SLAPI_LOG_FATAL, plugin_name, "curr_entry:%p  num_entries:%d curr_dn:%p\n", 

ldap/servers/plugins/acl/aclanom.c

@@ -147,7 +147,7 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 	/* We have a new signature now */
 	a_profile->anom_signature =  acl_get_aclsignature();
 
-	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "GENERATING ANOM USER PROFILE\n", 0,0,0);
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "GENERATING ANOM USER PROFILE\n");
 	/*
 	** Go thru the ACL list and find all the ACLs  which apply to the 
 	** anonymous user i.e anyone. we can generate a profile for that.
@@ -173,7 +173,7 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 			  (aci->aci_type & ACI_CONTAIN_NOT_GROUPDN)	||
 				(aci->aci_type & ACI_CONTAIN_NOT_ROLEDN)) ){
 			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-				"CANCELLING ANOM USER PROFILE BECAUSE OF DENY RULE\n", 0,0,0);
+				"CANCELLING ANOM USER PROFILE BECAUSE OF DENY RULE\n");
 			goto cleanup;
 		}
 
@@ -191,7 +191,7 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 		*/
 		if ( aci->aci_ruleType & ~ACI_USERDN_RULE ){
 			slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-				"CANCELLING ANOM USER PROFILE BECAUSE OF COMPLEX RULE\n", 0,0,0);
+				"CANCELLING ANOM USER PROFILE BECAUSE OF COMPLEX RULE\n");
 			goto cleanup;
 		}
 
@@ -211,7 +211,7 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 			} else {
 				/* clean up before leaving */
 				slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-					"CANCELLING ANOM USER PROFILE 1\n", 0,0,0);
+					"CANCELLING ANOM USER PROFILE 1\n");
 				goto cleanup;
 			}
 
@@ -221,7 +221,7 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 		a_numacl = a_profile->anom_numacls++;
 
 		if ( a_profile->anom_numacls == ACL_ANOM_MAX_ACL ) {
-			slapi_log_error(SLAPI_LOG_ACL, plugin_name, "CANCELLING ANOM USER PROFILE 2\n", 0,0,0);
+			slapi_log_error(SLAPI_LOG_ACL, plugin_name, "CANCELLING ANOM USER PROFILE 2\n");
 			goto cleanup;
 		}
 
@@ -269,7 +269,7 @@ aclanom_gen_anomProfile (acl_lock_flag_t lock_flag)
 				/* clean up before leaving */
 				__aclanom__del_profile ();
 				slapi_log_error(SLAPI_LOG_ACL, plugin_name, 
-					"CANCELLING ANOM USER PROFILE 3\n", 0,0,0);
+					"CANCELLING ANOM USER PROFILE 3\n");
 				goto cleanup;
 			}
 
@@ -543,14 +543,14 @@ aclanom_match_profile (Slapi_PBlock *pb, struct acl_pblock *aclpb, Slapi_Entry *
 			aci_ndn = slapi_sdn_get_ndn (acl_anom_profile->anom_targetinfo[i].anom_target);
 
 			slapi_log_error(loglevel, plugin_name, 
-				"conn=%" PRIu64 " op=%d: Allow access on entry(%s).attr(%s) to anonymous: acidn=\"%s\"\n",
+				"conn=%" NSPRIu64 " op=%d: Allow access on entry(%s).attr(%s) to anonymous: acidn=\"%s\"\n",
 				op->o_connid, op->o_opid,
 				escape_string_with_punctuation(ndn, ebuf),
 				attr ? attr:"NULL",
 				escape_string_with_punctuation(aci_ndn, ebuf));
 		} else {
 			slapi_log_error(loglevel, plugin_name,
-				"conn=%" PRIu64 " op=%d: Deny access on entry(%s).attr(%s) to anonymous\n",
+				"conn=%" NSPRIu64 " op=%d: Deny access on entry(%s).attr(%s) to anonymous\n",
 		op->o_connid, op->o_opid,
                 escape_string_with_punctuation(ndn, ebuf), attr ? attr:"NULL" );
 		}

ldap/servers/plugins/acl/aclgroup.c

@@ -124,7 +124,7 @@ aclg_init_userGroup ( struct acl_pblock *aclpb, const char *n_dn , int got_lock
 			
 			if ( !u_group->aclug_refcnt ) {
 				slapi_log_error( SLAPI_LOG_ACL, plugin_name, 
-					"In traversal group deallocation\n", 0,0,0 );
+					"In traversal group deallocation\n" );
 				__aclg__delete_userGroup (u_group);								
 			}			
 		} else {
@@ -164,7 +164,7 @@ aclg_init_userGroup ( struct acl_pblock *aclpb, const char *n_dn , int got_lock
 			if ( u_group == aclUserGroups->aclg_last )
 				aclUserGroups->aclg_last = p_group;
 		}
-		slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl_init_userGroup: found in cache for dn:%s\n", n_dn,0,0);
+		slapi_log_error(SLAPI_LOG_ACL, plugin_name, "acl_init_userGroup: found in cache for dn:%s\n", n_dn);
 	}
 	if (!got_lock ) ACLG_ULOCK_GROUPCACHE_WRITE ();
 }
@@ -291,7 +291,7 @@ aclg_get_usersGroup ( struct acl_pblock *aclpb , char *n_dn)
 	 * That's fine as the invalid one will be deallocated when done.
 	 */
 
-	slapi_log_error( SLAPI_LOG_ACL, plugin_name, "ALLOCATING GROUP FOR:%s\n", n_dn,0,0 );
+	slapi_log_error( SLAPI_LOG_ACL, plugin_name, "ALLOCATING GROUP FOR:%s\n", n_dn );
 	u_group = ( aclUserGroup * ) slapi_ch_calloc ( 1, sizeof ( aclUserGroup ) );
 	
 	u_group->aclug_refcnt = 1;
@@ -385,7 +385,7 @@ __aclg__delete_userGroup ( aclUserGroup *u_group )
 	 * be in a condemned state and later deleted.
 	 */
 	
-	slapi_log_error( SLAPI_LOG_ACL, plugin_name, "DEALLOCATING GROUP FOR:%s\n", u_group->aclug_ndn,0,0 );
+	slapi_log_error( SLAPI_LOG_ACL, plugin_name, "DEALLOCATING GROUP FOR:%s\n", u_group->aclug_ndn );
 
 	slapi_ch_free ( (void **) &u_group->aclug_ndn );
 

ldap/servers/plugins/acl/aclinit.c

@@ -86,7 +86,7 @@ aclinit_main()
 	/* Initialize the LIBACCESS ACL library */
 	if (ACL_Init() != 0) {
 		slapi_log_error(SLAPI_LOG_FATAL, plugin_name,
-			 "ACL Library Initialization failed\n",0,0,0);
+			 "ACL Library Initialization failed\n");
 		return 1;
 	}
 	
@@ -240,7 +240,7 @@ aclinit_search_and_update_aci ( int thisbeonly, const Slapi_DN *base,
 
 	if ( thisbeonly && be_name == NULL) {
 		slapi_log_error ( SLAPI_LOG_FATAL, plugin_name, 
-						"Error: This  be_name must be specified.\n", 0, 0, 0);
+						"Error: This  be_name must be specified.\n");
 		return -1;
 	}
 
@@ -387,7 +387,7 @@ __aclinit_handler ( Slapi_Entry *e, void *callback_data)
 							slapi_log_error ( SLAPI_LOG_FATAL, plugin_name, 
 									  "Error: This  (%s) ACL will not be considered for evaluation"
 									  " because of syntax errors.\n", 
-									  attrValue->bv_val ? attrValue->bv_val: "NULL", 0, 0);
+									  attrValue->bv_val ? attrValue->bv_val: "NULL");
 							call_back_data->retCode = rv;
 						}				
 					i= slapi_attr_next_value( attr, i, &sval );
@@ -409,7 +409,7 @@ __aclinit_handler ( Slapi_Entry *e, void *callback_data)
 					/* We got an error; Log it  and then march along */
 					slapi_log_error ( SLAPI_LOG_FATAL, plugin_name, 
 									  "Error: ACls not deleted from %s\n",
-										e_sdn, 0, 0);
+                                      slapi_sdn_get_dn(e_sdn));
 					call_back_data->retCode = rv;
 				}
 				if ( call_back_data->lock_flag == DO_TAKE_ACLCACHE_WRITELOCK) {
@@ -458,14 +458,14 @@ __aclinit__RegisterAttributes(void)
 	if (rv < 0) {
 		acl_print_acllib_err(&errp, NULL);
 		slapi_log_error(SLAPI_LOG_FATAL, plugin_name, 
-			  "Unable to Register the methods\n", 0,0,0);
+			  "Unable to Register the methods\n");
 		return ACL_ERR;
 	}
 	rv = ACL_MethodSetDefault (&errp,  methodinfo);
 	if (rv < 0) {
 		acl_print_acllib_err(&errp, NULL);
 		slapi_log_error(SLAPI_LOG_FATAL, plugin_name, 
-			  "Unable to Set the default method\n", 0,0,0);
+			  "Unable to Set the default method\n");
 		return ACL_ERR;
 	}
         rv = ACL_AttrGetterRegister(&errp, ACL_ATTR_IP, DS_LASIpGetter,
@@ -473,7 +473,7 @@ __aclinit__RegisterAttributes(void)
 	if (rv < 0) {
 		acl_print_acllib_err(&errp, NULL);
 		slapi_log_error(SLAPI_LOG_FATAL, plugin_name, 
-			  "Unable to Register Attr ip\n", 0,0,0);
+			  "Unable to Register Attr ip\n");
 		return ACL_ERR;
 	}
         rv = ACL_AttrGetterRegister(&errp, ACL_ATTR_DNS, DS_LASDnsGetter,
@@ -481,7 +481,7 @@ __aclinit__RegisterAttributes(void)
 	if (rv < 0) {
 		acl_print_acllib_err(&errp, NULL);
 		slapi_log_error(SLAPI_LOG_FATAL, plugin_name, 
-			  "Unable to Register Attr dns\n", 0,0,0);
+			  "Unable to Register Attr dns\n");
 		return ACL_ERR;
 	}
 	return ACL_OK;
@@ -512,59 +512,59 @@ __aclinit__RegisterLases(void)
 	if (ACL_LasRegister(NULL, DS_LAS_USER, (LASEvalFunc_t) DS_LASUserEval, 
 				(LASFlushFunc_t) NULL) <  0) {
 		slapi_log_error (SLAPI_LOG_FATAL, plugin_name,
-				"Unable to register USER Las\n",0,0,0);
+				"Unable to register USER Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_GROUP, (LASEvalFunc_t) DS_LASGroupEval, 
 				(LASFlushFunc_t) NULL) <  0) {
 		slapi_log_error (SLAPI_LOG_FATAL, plugin_name,
-				"Unable to register GROUP Las\n",0,0,0);
+				"Unable to register GROUP Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_GROUPDN, (LASEvalFunc_t)DS_LASGroupDnEval, 
 				(LASFlushFunc_t)NULL) < 0) {
 		slapi_log_error (SLAPI_LOG_FATAL, plugin_name,
-				"Unable to register GROUPDN Las\n",0,0,0);
+				"Unable to register GROUPDN Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_ROLEDN, (LASEvalFunc_t)DS_LASRoleDnEval, 
 				(LASFlushFunc_t)NULL) < 0) {
 		slapi_log_error (SLAPI_LOG_FATAL, plugin_name,
-				"Unable to register ROLEDN Las\n",0,0,0);
+				"Unable to register ROLEDN Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_USERDN, (LASEvalFunc_t)DS_LASUserDnEval, 
 				(LASFlushFunc_t)NULL) < 0) {
 		slapi_log_error (SLAPI_LOG_FATAL, plugin_name,
-				"Unable to register USERDN Las\n",0,0,0);
+				"Unable to register USERDN Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_USERDNATTR, 
 				(LASEvalFunc_t)DS_LASUserDnAttrEval, 
 				(LASFlushFunc_t)NULL) < 0) {
 		slapi_log_error (SLAPI_LOG_FATAL, plugin_name,
-				"Unable to register USERDNATTR Las\n",0,0,0);
+				"Unable to register USERDNATTR Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_AUTHMETHOD, 
 				(LASEvalFunc_t)DS_LASAuthMethodEval, 
 				(LASFlushFunc_t)NULL) < 0) {
 		slapi_log_error (SLAPI_LOG_FATAL, plugin_name,
-			"Unable to register CLIENTAUTHTYPE Las\n",0,0,0);
+			"Unable to register CLIENTAUTHTYPE Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_GROUPDNATTR,
 				(LASEvalFunc_t)DS_LASGroupDnAttrEval,
 				(LASFlushFunc_t)NULL) < 0) {
 		slapi_log_error (SLAPI_LOG_FATAL, plugin_name,
-				"Unable to register GROUPDNATTR Las\n",0,0,0);
+				"Unable to register GROUPDNATTR Las\n");
 		return ACL_ERR;
 	}
 	if (ACL_LasRegister(NULL, DS_LAS_USERATTR,
 				(LASEvalFunc_t)DS_LASUserAttrEval,
 				(LASFlushFunc_t)NULL) < 0) {
 		slapi_log_error (SLAPI_LOG_FATAL, plugin_name,
-				"Unable to register USERATTR Las\n",0,0,0);
+				"Unable to register USERATTR Las\n");
 		return ACL_ERR;
 	}
 	return ACL_OK;

ldap/servers/plugins/acl/acllas.c

@@ -293,7 +293,7 @@ DS_LASIpGetter(NSErr_t *errp, PList_t subject, PList_t resource, PList_t
 	if ( rv != LAS_EVAL_TRUE  || ( NULL == aclpb )) {
 		acl_print_acllib_err(errp, NULL);
 		slapi_log_error( SLAPI_LOG_ACL, plugin_name,
-			"DS_LASIpGetter:Unable to get the ACLPB(%d)\n", rv,0,0);
+			"DS_LASIpGetter:Unable to get the ACLPB(%d)\n", rv);
 		return LAS_EVAL_FAIL;
 	}
 
@@ -346,7 +346,7 @@ DS_LASDnsGetter(NSErr_t *errp, PList_t subject, PList_t resource, PList_t
 	if ( rv != LAS_EVAL_TRUE  || ( NULL == aclpb )) {
 		acl_print_acllib_err(errp, NULL);
 		slapi_log_error( SLAPI_LOG_ACL, plugin_name,
-			"DS_LASDnsGetter:Unable to get the ACLPB(%d)\n", rv,0,0);
+			"DS_LASDnsGetter:Unable to get the ACLPB(%d)\n", rv);
 		return LAS_EVAL_FAIL;
 	}
 	
@@ -424,7 +424,7 @@ DS_LASUserEval(NSErr_t *errp, char *attr_name, CmpOp_t comparator,
 		PList_t global_auth)
 {
 	slapi_log_error(SLAPI_LOG_FATAL, plugin_name, 
-			"User LAS is not supported in the ACL\n",0,0,0);
+			"User LAS is not supported in the ACL\n");
 
 	return LAS_EVAL_INVALID;
 }
@@ -436,7 +436,7 @@ DS_LASGroupEval(NSErr_t *errp, char *attr_name, CmpOp_t comparator,
 		PList_t global_auth)
 {
 	slapi_log_error(SLAPI_LOG_FATAL, plugin_name, 
-			"Group LAS is not supported in the ACL\n",0,0,0);
+			"Group LAS is not supported in the ACL\n");
 
 	return LAS_EVAL_INVALID;
 }
@@ -542,7 +542,7 @@ DS_LASUserDnEval(NSErr_t *errp, char *attr_name, CmpOp_t comparator,
 			char ebuf[ BUFSIZ ];
 			slapi_log_error(SLAPI_LOG_FATAL, plugin_name,
 			 	"DS_LASUserDnEval:Syntax error(%s)\n", 
-				 escape_string_with_punctuation( user, ebuf  ), 0,0);
+				 escape_string_with_punctuation( user, ebuf  ));
 			return LAS_EVAL_FAIL;
 		}
 
@@ -671,7 +671,7 @@ DS_LASUserDnEval(NSErr_t *errp, char *attr_name, CmpOp_t comparator,
 				if (rc == ACL_ERR) {
 			   		slapi_log_error( SLAPI_LOG_ACL, plugin_name, 
 			    			"DS_LASUserDnEval:Error in matching patteren(%s)\n",
-			     			user,0,0);
+			     			user);
 				}
 				slapi_filter_free(f,1);
 			} else {
@@ -793,7 +793,7 @@ DS_LASGroupDnEval(NSErr_t *errp, char *attr_name, CmpOp_t comparator,
 			char ebuf[ BUFSIZ ];
 			slapi_log_error(SLAPI_LOG_FATAL, plugin_name,
 				  "DS_LASGroupDnEval:Syntax error(%s)\n",
-				   escape_string_with_punctuation( groupName, ebuf ),0,0);
+				   escape_string_with_punctuation( groupName, ebuf ));
 		}
 	
 		/* Now we have the starting point of the "groupdn" */
@@ -1013,7 +1013,7 @@ DS_LASRoleDnEval(NSErr_t *errp, char *attr_name, CmpOp_t comparator,
 			char ebuf[ BUFSIZ ];
 			slapi_log_error(SLAPI_LOG_FATAL, plugin_name,
 				  "DS_LASRoleDnEval:Syntax error(%s)\n",
-				   escape_string_with_punctuation( role, ebuf ),0,0);
+				   escape_string_with_punctuation( role, ebuf ));
 		}
 	
 		/* Now we have the starting point of the "roledn" */
@@ -1244,7 +1244,7 @@ DS_LASUserDnAttrEval(NSErr_t *errp, char *attr_name, CmpOp_t comparator,
 		return LAS_EVAL_FAIL;
 	}
 
-	slapi_log_error( SLAPI_LOG_ACL, plugin_name,"Attr:%s\n" , attrName, 0,0);
+	slapi_log_error( SLAPI_LOG_ACL, plugin_name,"Attr:%s\n" , attrName);
 	matched = ACL_FALSE;
 	for (i=0; i < numOflevels; i++) {
 		if ( levels[i] == 0 ) {
@@ -1602,7 +1602,7 @@ acllas__user_ismember_of_group( struct acl_pblock *aclpb,
 	*/
 	if ( (u_group = aclg_get_usersGroup ( aclpb , clientDN )) == NULL) {
 		 slapi_log_error( SLAPI_LOG_ACL, plugin_name,
-			"Failed to find/allocate a usergroup--aborting evaluation\n", 0, 0);
+			"Failed to find/allocate a usergroup--aborting evaluation\n");
 		return(ACL_DONT_KNOW);
 	}
 
@@ -1748,7 +1748,7 @@ eval_another_member:
 	if ((nesting_level > max_nestlevel)) {
 		 slapi_log_error( SLAPI_LOG_ACL, plugin_name,
 			"GroupEval:Member not found within the allowed nesting level (Allowed:%d Looked at:%d)\n", 
-			max_nestlevel, nesting_level, 0);
+			max_nestlevel, nesting_level);
 
 		result = ACL_DONT_KNOW; /* don't try to cache info based on this result */
 		goto free_and_return;
@@ -1759,7 +1759,7 @@ eval_another_member:
 			max_memberlimit != -1 ) {
 		slapi_log_error( SLAPI_LOG_ACL, plugin_name, 
 			"GroupEval:Looked at too many entries:(%d, %d)\n",
-				info.c_idx, info.lu_idx,0);
+				info.c_idx, info.lu_idx);
 		result = ACL_DONT_KNOW; /* don't try to cache info based on this result */
 		goto free_and_return;
 	}
@@ -2203,7 +2203,7 @@ DS_LASGroupDnAttrEval(NSErr_t *errp, char *attr_name, CmpOp_t comparator,
 			LDAP_UTF8DEC(ptr);
 		}
 
-		slapi_log_error( SLAPI_LOG_ACL, plugin_name,"Attr:%s\n" , attrName, 0,0);
+		slapi_log_error( SLAPI_LOG_ACL, plugin_name,"Attr:%s\n" , attrName);
 
 		/* See if we have a  parent[2].attr" rule */
 		if ( (ptr = strstr(attrName, "parent[")) != NULL) {
@@ -2229,7 +2229,7 @@ DS_LASGroupDnAttrEval(NSErr_t *errp, char *attr_name, CmpOp_t comparator,
 						*/
 						slapi_log_error( SLAPI_LOG_FATAL, plugin_name, 
 						"DS_LASGroupDnattr: Exceeded the ATTR LIMIT:%d: Ignoring extra levels\n",
-						ACLLAS_MAX_LEVELS,0,0);
+						ACLLAS_MAX_LEVELS);
 					}
 				} else {
 					/* Must be the attr name. We can goof of by 
@@ -2445,7 +2445,7 @@ acllas__eval_memberGroupDnAttr (char *attrName, Slapi_Entry *e,
 
 	if ( (u_group = aclg_get_usersGroup ( aclpb , n_clientdn )) == NULL) {
 		slapi_log_error( SLAPI_LOG_ACL, plugin_name,
-			"Failed to find/allocate a usergroup--aborting evaluation\n", 0, 0);
+			"Failed to find/allocate a usergroup--aborting evaluation\n");
 		slapi_ch_free ( (void **)&s_str );
 		return(ACL_DONT_KNOW);
 	}
@@ -2544,7 +2544,7 @@ acllas__eval_memberGroupDnAttr (char *attrName, Slapi_Entry *e,
 
 			if (tt == info.lu_idx) {
 				slapi_log_error( SLAPI_LOG_ACL, plugin_name, "currDn:(%s) \n\tNO MEMBER ADDED\n", 
-								ACL_ESCAPE_STRING_WITH_PUNCTUATION (curMemberDn, ebuf) , 0,0);
+								ACL_ESCAPE_STRING_WITH_PUNCTUATION (curMemberDn, ebuf));
 			} else {
 				for (i=tt; i < info.lu_idx; i++)
 					slapi_log_error( SLAPI_LOG_ACL, plugin_name, 
@@ -2597,7 +2597,7 @@ acllas__eval_memberGroupDnAttr (char *attrName, Slapi_Entry *e,
 	for (j=0; j < u_group->aclug_numof_member_group; j++)
 		slapi_log_error( SLAPI_LOG_ACL, plugin_name, 
 				"acllas__eval_memberGroupDnAttr:GROUP[%d] IN CACHE:%s\n", 
-					j, ACL_ESCAPE_STRING_WITH_PUNCTUATION (u_group->aclug_member_groups[j], ebuf),0);
+					j, ACL_ESCAPE_STRING_WITH_PUNCTUATION (u_group->aclug_member_groups[j], ebuf));
 
 	matched = ACL_FALSE;
 	slapi_entry_attr_find( e, groupattr, &attr);
@@ -3060,7 +3060,7 @@ acllas__client_match_URL (struct acl_pblock *aclpb, char *n_clientdn, char *url
 
 	if ( NULL == aclpb->aclpb_client_entry ) {
 		slapi_log_error (  SLAPI_LOG_ACL, plugin_name, 
-			"DS_LASUserAttrEval: Unable to get client's entry\n",0,0,0);
+			"DS_LASUserAttrEval: Unable to get client's entry\n");
 		return ACL_FALSE;
 	}
 
@@ -3224,7 +3224,7 @@ __acllas_setup ( NSErr_t *errp, char *attr_name, CmpOp_t comparator,
 					(void **)&linfo->authType, NULL)) < 0) {
 		acl_print_acllib_err(errp, NULL);
 		slapi_log_error( SLAPI_LOG_ACL, plugin_name, 
-		          "%s:Unable to get the auth type(%d)\n", rc);
+		          "%s:Unable to get the auth type(%d)\n", lasName, rc);
 		return LAS_EVAL_FAIL;
 	}
 	return 0;	
@@ -3273,7 +3273,7 @@ static int acllas__user_has_role( struct acl_pblock *aclpb,
 
 	if ( NULL == aclpb->aclpb_client_entry ) {
 		slapi_log_error (  SLAPI_LOG_ACL, plugin_name, 
-			"acllas__user_has_role: Unable to get client's entry\n",0,0,0);
+			"acllas__user_has_role: Unable to get client's entry\n");
 		return ACL_FALSE;
 	}
 

ldap/servers/plugins/acl/aclparse.c

@@ -394,8 +394,7 @@ __aclp__parse_aci (char 	*str, aci_t  *aci_item)
 			if (aci_item->target) {
 				/* There is something already. ERROR */
 				slapi_log_error(SLAPI_LOG_ACL, plugin_name,
-					 "Multiple targets in the ACL syntax\n",
-					 0,0,0);
+					 "Multiple targets in the ACL syntax\n");
 				slapi_filter_free(f, 1);
 				return(ACL_SYNTAX_ERR);
 			}  else {
@@ -404,8 +403,7 @@ __aclp__parse_aci (char 	*str, aci_t  *aci_item)
 		} else if ( type & ACI_TARGET_FILTER) {
 			if (aci_item->targetFilter) {
 				slapi_log_error(SLAPI_LOG_ACL, plugin_name,
-				       "Multiple target Filters in the ACL Syntax\n",
-					0,0,0);
+				       "Multiple target Filters in the ACL Syntax\n");
 				slapi_filter_free(f, 1);
 				return(ACL_SYNTAX_ERR);
 			} else {
@@ -418,7 +416,7 @@ __aclp__parse_aci (char 	*str, aci_t  *aci_item)
 			slapi_log_error(SLAPI_LOG_ACL, plugin_name,
 				       "Unknown keyword at \"%s\"\n Expecting"
 						" \"target\", \"targetattr\", \"targetfilter\", \"targattrfilters\""						
-						" or \"version\"\n", str, 0, 0);
+						" or \"version\"\n", str);
 			return(ACL_SYNTAX_ERR);
 	}/* switch() */
 
@@ -491,7 +489,7 @@ __aclp__sanity_check_acltxt (aci_t *aci_item, char *str)
 	if ((newstr = __aclp__normalize_acltxt (aci_item,  str )) == NULL) {
 		return ACL_SYNTAX_ERR;
 	}
-	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "Normalized String:%s\n", newstr, 0,0);
+	slapi_log_error(SLAPI_LOG_ACL, plugin_name, "Normalized String:%s\n", newstr);
 
 	/* check for acl syntax error */ 
 	if ((handle = (ACLListHandle_t *) ACL_ParseString(&errp, 
@@ -1313,7 +1311,7 @@ __aclp__init_targetattr (aci_t *aci, char *attr_val)
 	
 				if (f == NULL)  {
                    	slapi_log_error(SLAPI_LOG_FATAL, plugin_name,
-					  "__aclp__init_targetattr:Unable to generate filter (%s)\n", lineptr,0,0);
+					  "__aclp__init_targetattr:Unable to generate filter (%s)\n", lineptr);
 				} else {
 					attr->u.attr_filter = f;
 				}
@@ -1882,7 +1880,7 @@ static int __acl_init_targetattrfilter( Targetattrfilter *attrfilter,
 		/* No :, syntax error */
   		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
                                 "Bad targetattrfilter %s:%s\n",
-                                str,"Expecting \":\"",0);
+                                str,"Expecting \":\"");
 
 		return(ACL_SYNTAX_ERR);
 	}
@@ -1895,8 +1893,7 @@ static int __acl_init_targetattrfilter( Targetattrfilter *attrfilter,
     
 	if ( *s == '\0' ) {
 		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
-                                "No attribute name in targattrfilters\n",
-                                 0,0);
+                                "No attribute name in targattrfilters\n");
 		return(ACL_SYNTAX_ERR);
 	}
 
@@ -1914,7 +1911,7 @@ static int __acl_init_targetattrfilter( Targetattrfilter *attrfilter,
 	if ((f = slapi_str2filter(tmp_ptr)) == NULL) {
   		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
                                 "Bad targetattr filter for attribute %s:%s\n",
-                                attrfilter->attr_str,tmp_ptr,0);
+                                attrfilter->attr_str,tmp_ptr);
         slapi_ch_free( (void **) &attrfilter->attr_str);
 		slapi_ch_free( (void **) &tmp_ptr);		
 		return(ACL_SYNTAX_ERR);
@@ -1929,7 +1926,7 @@ static int __acl_init_targetattrfilter( Targetattrfilter *attrfilter,
 				SLAPI_FILTER_SCAN_NOMORE) {
   		slapi_log_error(SLAPI_LOG_ACL, plugin_name,
               "Exactly one attribute type per filter allowed in targattrfilters (%s)\n",
-				attrfilter->attr_str, 0);
+				attrfilter->attr_str);
         slapi_ch_free( (void **) &attrfilter->attr_str);
 		slapi_ch_free( (void **) &tmp_ptr);		
 		slapi_filter_free( f, 1 );

ldap/servers/plugins/acl/aclplugin.c

@@ -125,7 +125,7 @@ acl_preopInit (Slapi_PBlock *pb)
 #endif
 
 
-        slapi_log_error( SLAPI_LOG_PLUGIN, plugin_name, "<= acl_preop_Init %d\n", rc, 0, 0 );
+        slapi_log_error( SLAPI_LOG_PLUGIN, plugin_name, "<= acl_preop_Init %d\n", rc );
         return( rc );
 }
 
@@ -299,7 +299,7 @@ acl_init( Slapi_PBlock *pb )
 {
         int     rc =0;
 
-        slapi_log_error( SLAPI_LOG_PLUGIN, plugin_name, "=> acl_init\n", 0, 0, 0 );
+        slapi_log_error( SLAPI_LOG_PLUGIN, plugin_name, "=> acl_init\n" );
 
         if  ( 0 != acl_init_ext() ) {
 		    slapi_log_error ( SLAPI_LOG_FATAL, plugin_name,
@@ -326,7 +326,7 @@ acl_init( Slapi_PBlock *pb )
         rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_ACL_MODS_UPDATE,
             (void *) acl_modified );
 
-        slapi_log_error( SLAPI_LOG_PLUGIN, plugin_name, "<= acl_init %d\n", rc, 0, 0 );
+        slapi_log_error( SLAPI_LOG_PLUGIN, plugin_name, "<= acl_init %d\n", rc);
         return( rc );
 }
 

ldap/servers/plugins/acl/aclutil.c

@@ -106,7 +106,7 @@ acl_print_acllib_err (NSErr_t *errp , char * str)
 
 	if (msgbuf)
 		slapi_log_error(SLAPI_LOG_ACL, plugin_name,"ACL LIB ERR:(%s)(%s)\n", 
-				msgbuf, str ? str: "NULL",0); 
+				msgbuf, str ? str: "NULL"); 
 }
 void
 aclutil_print_aci (aci_t *aci_item, char *type)
@@ -120,7 +120,7 @@ aclutil_print_aci (aci_t *aci_item, char *type)
 	if (!aci_item) {
 		
 		slapi_log_error (SLAPI_LOG_ACL, plugin_name,
-			"acl__print_aci: Null item\n",0,0,0);
+			"acl__print_aci: Null item\n");
 		return;
 	}
 
@@ -463,21 +463,21 @@ aclutil_print_resource( struct acl_pblock *aclpb, char *right , char *attr, char
 	if ( ! slapi_is_loglevel_set ( SLAPI_LOG_ACL ) )
 		return;
 
-	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    ************ RESOURCE INFO STARTS *********\n",0,0,0);
+	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    ************ RESOURCE INFO STARTS *********\n");
 	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    Client DN: %s\n", 
-		   clientdn ? escape_string_with_punctuation (clientdn, str) : "NULL", 0,0);
+		   clientdn ? escape_string_with_punctuation (clientdn, str) : "NULL");
 	aclutil__access_str (aclpb->aclpb_access, str);
     aclutil__typestr (aclpb->aclpb_res_type, &str[strlen(str)]);
 	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    resource type:%d(%s)\n",
-		   aclpb->aclpb_res_type, str, 0);
+		   aclpb->aclpb_res_type, str);
 
 	dn = slapi_sdn_get_dn ( aclpb->aclpb_curr_entry_sdn );
 	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    Slapi_Entry DN: %s\n", 
-		   dn ? escape_string_with_punctuation ( dn , str) : "NULL",0,0);
+		   dn ? escape_string_with_punctuation ( dn , str) : "NULL");
 
-	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    ATTR: %s\n", attr ? attr : "NULL",0,0);
-	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    rights:%s\n", right ? right: "NULL",0,0);
-	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    ************ RESOURCE INFO ENDS   *********\n",0,0,0);
+	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    ATTR: %s\n", attr ? attr : "NULL");
+	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    rights:%s\n", right ? right: "NULL");
+	slapi_log_error (SLAPI_LOG_ACL, plugin_name, "    ************ RESOURCE INFO ENDS   *********\n");
 }
 /*
  * The input string contains a rule like

ldap/servers/plugins/chainingdb/cb_conn_stateless.c

@@ -287,7 +287,7 @@ int cb_get_connection(cb_conn_pool * pool, LDAP ** lld, cb_outgoing_conn ** cc,s
 			        conn->refcount < maxconcurrency)){
 			        if (cb_debug_on()) {
                 			slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-                        		"<= cb_get_connection server found conn 0x%x to use)\n", conn );
+                        		"<= cb_get_connection server found conn 0x%p to use)\n", conn );
 				}
 				goto unlock_and_return;         /* found one */
 			  }
@@ -298,7 +298,7 @@ int cb_get_connection(cb_conn_pool * pool, LDAP ** lld, cb_outgoing_conn ** cc,s
         	for ( conn = pool->conn.conn_list; conn != NULL; conn = conn->next ) {
 			if (cb_debug_on()) {
                 		slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-                        		"list: conn 0x%x status %d refcount %d\n", conn, 
+                        		"list: conn 0x%p status %d refcount %lu\n", conn, 
 					conn->status, conn->refcount );
 			}
 
@@ -306,7 +306,7 @@ int cb_get_connection(cb_conn_pool * pool, LDAP ** lld, cb_outgoing_conn ** cc,s
                     		&& conn->refcount < maxconcurrency ) {
 				if (cb_debug_on()) {
                 			slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-                        		"<= cb_get_connection server found conn 0x%x to use)\n", conn );
+                        		"<= cb_get_connection server found conn 0x%p to use)\n", conn );
 				}
                 		goto unlock_and_return;         /* found one */
             		}
@@ -365,8 +365,7 @@ int cb_get_connection(cb_conn_pool * pool, LDAP ** lld, cb_outgoing_conn ** cc,s
 				{
 					if (cb_debug_on()) {
                                			slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-                                       		"Internal credentials decoding error\n.",
-                                       		0, 0, 0);
+                                       		"Internal credentials decoding error\n.");
 					}
 					rc = LDAP_LOCAL_ERROR;
 					goto unlock_and_return;
@@ -463,7 +462,7 @@ int cb_get_connection(cb_conn_pool * pool, LDAP ** lld, cb_outgoing_conn ** cc,s
 				
 			if (cb_debug_on()) {
                       	slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-                    		"<= cb_get_connection added new conn 0x%x, "
+                    		"<= cb_get_connection added new conn 0x%p, "
                     		"conn count now %d\n", conn->ld, pool->conn.conn_list_count );
 			}
             		goto unlock_and_return;             /* got a new one */
@@ -489,7 +488,7 @@ unlock_and_return:
 		*cc=conn;
 		if (cb_debug_on()) {
   		slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-                "<== cb_get_connection ld=0x%x (concurrency now %d)\n",*lld, conn->refcount );
+                "<== cb_get_connection ld=0x%p (concurrency now %lu)\n",*lld, conn->refcount );
 		}
 
     	} else {
@@ -542,14 +541,14 @@ void cb_release_op_connection(cb_conn_pool* pool, LDAP *lld, int dispose) {
 
 	if ( conn == NULL ) {               /* ld not found -- unexpected */
         	slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-                "==> cb_release_op_connection ld=0x%x not found\n", lld );
+                "==> cb_release_op_connection ld=0x%p not found\n", lld );
     	} else {
 
         	--conn->refcount;
 
 		if (cb_debug_on()) {
                 	slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-                        	"release conn 0x%x status %d refcount after release %d\n", conn,
+                        	"release conn 0x%p status %d refcount after release %lu\n", conn,
                                         conn->status, conn->refcount );
                 }
 
@@ -632,7 +631,7 @@ static void cb_check_for_stale_connections(cb_conn_pool * pool) {
 				if ( conn->refcount == 0 ) {
 					if (cb_debug_on()) {
                         			slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-							"cb_check_for_stale_connections: conn 0x%x idle and stale\n",conn);
+							"cb_check_for_stale_connections: conn 0x%p idle and stale\n",conn);
 					}
                                		--pool->conn.conn_list_count;
 					if (connprev == NULL) {
@@ -653,7 +652,7 @@ static void cb_check_for_stale_connections(cb_conn_pool * pool) {
 				}
                         	if (cb_debug_on()) {
                         	        slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-                       		                "cb_check_for_stale_connections: conn 0x%x stale\n",conn);
+                       		                "cb_check_for_stale_connections: conn 0x%p stale\n",conn);
                         	}
 			}
 			connprev = conn ;
@@ -677,7 +676,7 @@ static void cb_check_for_stale_connections(cb_conn_pool * pool) {
 
 				if (cb_debug_on()) {
                         		slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-						"cb_check_for_stale_connections: conn 0x%x idle and stale\n",conn);
+						"cb_check_for_stale_connections: conn 0x%p idle and stale\n",conn);
 				}
                                 --pool->conn.conn_list_count;
 				conn_next=conn->next;
@@ -693,7 +692,7 @@ static void cb_check_for_stale_connections(cb_conn_pool * pool) {
 			}
                         if (cb_debug_on()) {
                                 slapi_log_error( SLAPI_LOG_PLUGIN, CB_PLUGIN_SUBSYSTEM,
-                                        "cb_check_for_stale_connections: conn 0x%x stale\n",conn);
+                                        "cb_check_for_stale_connections: conn 0x%p stale\n",conn);
                         }
 		}
                 connprev = conn;

ldap/servers/plugins/dna/dna.c

@@ -59,14 +59,6 @@
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
 
-/* NSPR uses the print macros a bit differently than ANSI C.  We
- * need to use ll for a 64-bit integer, even when a long is 64-bit.
- */
-#undef PRIu64
-#define PRIu64  "llu"
-#undef PRI64
-#define PRI64   "ll"
-
 #else
 #error Need to define portable format macros such as PRIu64
 #endif /* HAVE_INTTYPES_H */
@@ -703,7 +695,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> dn [%s]\n", entry->dn, 0, 0);
+                    "----------> dn [%s]\n", entry->dn);
 
     value = slapi_entry_attr_get_charptr(e, DNA_TYPE);
     if (value) {
@@ -718,7 +710,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%s]\n", DNA_TYPE, entry->type, 0, 0);
+                    "----------> %s [%s]\n", DNA_TYPE, entry->type);
 
     value = slapi_entry_attr_get_charptr(e, DNA_NEXTVAL);
     if (value) {
@@ -734,8 +726,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%" PRIu64 "]\n", DNA_NEXTVAL, entry->nextval, 0,
-                    0);
+                    "----------> %s [%" NSPRIu64 "]\n", DNA_NEXTVAL, entry->nextval);
 
     value = slapi_entry_attr_get_charptr(e, DNA_PREFIX);
     if (value && value[0]) {
@@ -749,7 +740,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%s]\n", DNA_PREFIX, entry->prefix, 0, 0);
+                    "----------> %s [%s]\n", DNA_PREFIX, entry->prefix);
 
     /* Set the default interval to 1 */
     entry->interval = 1;
@@ -762,7 +753,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%" PRIu64 "]\n", DNA_INTERVAL, entry->interval, 0, 0);
+                    "----------> %s [%" NSPRIu64 "]\n", DNA_INTERVAL, entry->interval);
 #endif
 
     value = slapi_entry_attr_get_charptr(e, DNA_GENERATE);
@@ -771,8 +762,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%s]\n", DNA_GENERATE, entry->generate,
-                    0, 0);
+                    "----------> %s [%s]\n", DNA_GENERATE, entry->generate);
 
     value = slapi_entry_attr_get_charptr(e, DNA_FILTER);
     if (value) {
@@ -794,7 +784,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%s]\n", DNA_FILTER, value, 0, 0);
+                    "----------> %s [%s]\n", DNA_FILTER, value);
 
     value = slapi_entry_attr_get_charptr(e, DNA_SCOPE);
     if (value) {
@@ -811,7 +801,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%s]\n", DNA_SCOPE, entry->scope, 0, 0);
+                    "----------> %s [%s]\n", DNA_SCOPE, entry->scope);
 
     /* optional, if not specified set -1  which is converted to the max unisgnee
      * value */
@@ -824,7 +814,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%llu]\n", DNA_MAXVAL, entry->maxval, 0, 0);
+                    "----------> %s [%" NSPRIu64 "]\n", DNA_MAXVAL, entry->maxval);
 
     value = slapi_entry_attr_get_charptr(e, DNA_SHARED_CFG_DN);
     if (value) {
@@ -862,7 +852,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
 
         slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
                         "----------> %s [%s]\n", DNA_SHARED_CFG_DN,
-                        entry->shared_cfg_base, 0, 0);
+                        entry->shared_cfg_base);
     }
 
     value = slapi_entry_attr_get_charptr(e, DNA_THRESHOLD);
@@ -870,7 +860,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
         entry->threshold = strtoull(value, 0, 0);
 
         slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                        "----------> %s [%" PRIu64 "]\n", DNA_THRESHOLD, value, 0, 0);
+                        "----------> %s [%" NSPRIu64 "]\n", DNA_THRESHOLD, value);
 
         slapi_ch_free_string(&value);
     } else {
@@ -878,7 +868,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%llu]\n", DNA_THRESHOLD, entry->threshold, 0, 0);
+                    "----------> %s [%" NSPRIu64 "]\n", DNA_THRESHOLD, entry->threshold);
 
     value = slapi_entry_attr_get_charptr(e, DNA_RANGE_REQUEST_TIMEOUT);
     if (value) {
@@ -889,8 +879,8 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
     }
 
     slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                    "----------> %s [%llu]\n", DNA_RANGE_REQUEST_TIMEOUT,
-                    entry->timeout, 0, 0);
+                    "----------> %s [%" NSPRIu64 "]\n", DNA_RANGE_REQUEST_TIMEOUT,
+                    entry->timeout);
 
     value = slapi_entry_attr_get_charptr(e, DNA_NEXT_RANGE);
     if (value) {
@@ -995,7 +985,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
                 slapi_log_error(SLAPI_LOG_CONFIG,
                                 DNA_PLUGIN_SUBSYSTEM,
                                 "store [%s] before [%s] \n", entry->scope,
-                                config_entry->scope, 0);
+                                config_entry->scope);
                 entry_added = 1;
                 break;
             }
@@ -1007,8 +997,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
                 /* add to tail */
                 PR_INSERT_BEFORE(&(entry->list), list);
                 slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                                "store [%s] at tail\n", entry->scope, 0,
-                                0);
+                                "store [%s] at tail\n", entry->scope);
                 entry_added = 1;
                 break;
             }
@@ -1017,7 +1006,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
         /* first entry */
         PR_INSERT_LINK(&(entry->list), dna_global_config);
         slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                        "store [%s] at head \n", entry->scope, 0, 0);
+                        "store [%s] at head \n", entry->scope);
         entry_added = 1;
     }
 
@@ -1027,7 +1016,7 @@ dna_parse_config_entry(Slapi_Entry * e, int apply)
         if ((apply != 0) && (entry != NULL)) {
             slapi_log_error(SLAPI_LOG_FATAL, DNA_PLUGIN_SUBSYSTEM,
                             "dna_parse_config_entry: Invalid config entry "
-                            "[%s] skipped\n", entry->dn, 0, 0);
+                            "[%s] skipped\n", entry->dn);
         }
         dna_free_config_entry(&entry);
     } else {
@@ -1050,7 +1039,7 @@ dna_free_config_entry(struct configEntry ** entry)
 
     if (e->dn) {
         slapi_log_error(SLAPI_LOG_CONFIG, DNA_PLUGIN_SUBSYSTEM,
-                        "freeing config entry [%s]\n", e->dn, 0, 0);
+                        "freeing config entry [%s]\n", e->dn);
         slapi_ch_free_string(&e->dn);
     }
 
@@ -1355,8 +1344,8 @@ dna_notice_allocation(struct configEntry *config_entry, PRUint64 new,
      * don't need to do this if we already have a next range on deck. */
     if ((config_entry->next_range_lower == 0) && (config_entry->remaining <= config_entry->threshold)) {
         slapi_log_error(SLAPI_LOG_FATAL, DNA_PLUGIN_SUBSYSTEM,
-                        "dna_notice_allocation: Passed threshold of %" PRIu64 " remaining values "
-                        "for range %s. (%" PRIu64 " values remain)\n",
+                        "dna_notice_allocation: Passed threshold of %" NSPRIu64 " remaining values "
+                        "for range %s. (%" NSPRIu64 " values remain)\n",
                         config_entry->threshold, config_entry->dn, config_entry->remaining);
         /* Only attempt to fix maxval if the fix flag is set. */
         if (fix != 0) {
@@ -1784,7 +1773,7 @@ dna_first_free_value(struct configEntry *config_entry,
     if (prefix) {
         /* The 7 below is for all of the filter characters "(&(=))"
          * plus the trailing \0.  The 20 is for the maximum string
-         * representation of a " PRIu64 ". */
+         * representation of a " NSPRIu64 ". */
         filterlen = strlen(config_entry->filter) +
                                  strlen(prefix) + strlen(type)
                                  + 7 + 20;
@@ -1802,7 +1791,7 @@ dna_first_free_value(struct configEntry *config_entry,
             return LDAP_OPERATIONS_ERROR;
         }
 
-        filter = slapi_ch_smprintf("(&%s(&(%s>=%" PRIu64 ")(%s<=%" PRIu64 ")))",
+        filter = slapi_ch_smprintf("(&%s(&(%s>=%" NSPRIu64 ")(%s<=%" NSPRIu64 ")))",
                                    config_entry->filter,
                                    type, tmpval,
                                    type, config_entry->maxval);
@@ -1985,7 +1974,7 @@ static int dna_get_next_value(struct configEntry *config_entry,
      * of our current range */
     if (nextval <= (config_entry->maxval + config_entry->interval)) {
         /* try to set the new next value in the config entry */
-        snprintf(next_value, sizeof(next_value),"%" PRIu64, nextval);
+        PR_snprintf(next_value, sizeof(next_value),"%" NSPRIu64, nextval);
 
         /* set up our replace modify operation */
         replace_val[0] = next_value;
@@ -2015,7 +2004,7 @@ static int dna_get_next_value(struct configEntry *config_entry,
 
     if (LDAP_SUCCESS == ret) {
         slapi_ch_free_string(next_value_ret);
-        *next_value_ret = slapi_ch_smprintf("%" PRIu64, setval);
+        *next_value_ret = slapi_ch_smprintf("%" NSPRIu64, setval);
         if (NULL == *next_value_ret) {
             ret = LDAP_OPERATIONS_ERROR;
             goto done;
@@ -2062,7 +2051,7 @@ dna_update_shared_config(struct configEntry * config_entry)
 
         /* We store the number of remaining assigned values
          * in the shared config entry. */
-        snprintf(remaining_vals, sizeof(remaining_vals),"%" PRIu64, config_entry->remaining);
+        PR_snprintf(remaining_vals, sizeof(remaining_vals),"%" NSPRIu64, config_entry->remaining);
 
         /* set up our replace modify operation */
         replace_val[0] = remaining_vals;
@@ -2147,7 +2136,7 @@ dna_update_next_range(struct configEntry *config_entry,
     int ret = 0;
 
     /* Try to set the new next range in the config entry. */
-    snprintf(nextrange_value, sizeof(nextrange_value), "%" PRIu64 "-%" PRIu64,
+    PR_snprintf(nextrange_value, sizeof(nextrange_value), "%" NSPRIu64 "-%" NSPRIu64,
              lower, upper);
 
     /* set up our replace modify operation */
@@ -2216,8 +2205,8 @@ dna_activate_next_range(struct configEntry *config_entry)
     int ret = 0;
 
     /* Setup the modify operation for the config entry */
-    snprintf(maxval_val, sizeof(maxval_val),"%" PRIu64, config_entry->next_range_upper);
-    snprintf(nextval_val, sizeof(nextval_val),"%" PRIu64, config_entry->next_range_lower);
+    PR_snprintf(maxval_val, sizeof(maxval_val),"%" NSPRIu64, config_entry->next_range_upper);
+    PR_snprintf(nextval_val, sizeof(nextval_val),"%" NSPRIu64, config_entry->next_range_lower);
 
     maxval_vals[0] = maxval_val;
     maxval_vals[1] = 0;
@@ -2855,8 +2844,8 @@ static int dna_extend_exop(Slapi_PBlock *pb)
         char highstr[16];
 
         /* Create the exop response */
-        snprintf(lowstr, sizeof(lowstr), "%" PRIu64, lower);
-        snprintf(highstr, sizeof(highstr), "%" PRIu64, upper);
+        PR_snprintf(lowstr, sizeof(lowstr), "%" NSPRIu64, lower);
+        PR_snprintf(highstr, sizeof(highstr), "%" NSPRIu64, upper);
         range_low.bv_val = lowstr;
         range_low.bv_len = strlen(range_low.bv_val);
         range_high.bv_val = highstr;
@@ -2889,7 +2878,7 @@ static int dna_extend_exop(Slapi_PBlock *pb)
         ber_bvfree(respdata);
 
         slapi_log_error(SLAPI_LOG_PLUGIN, DNA_PLUGIN_SUBSYSTEM,
-                        "dna_extend_exop: Released range %" PRIu64 "-%" PRIu64 ".\n",
+                        "dna_extend_exop: Released range %" NSPRIu64 "-%" NSPRIu64 ".\n",
                         lower, upper);
     }
 
@@ -3031,7 +3020,7 @@ dna_release_range(char *range_dn, PRUint64 *lower, PRUint64 *upper)
                 *lower = *upper - release + 1;
 
                 /* try to set the new maxval in the config entry */
-                snprintf(max_value, sizeof(max_value),"%" PRIu64, (*lower - 1));
+                PR_snprintf(max_value, sizeof(max_value),"%" NSPRIu64, (*lower - 1));
 
                 /* set up our replace modify operation */
                 replace_val[0] = max_value;

ldap/servers/plugins/http/http_impl.c

@@ -666,7 +666,7 @@ static int nssReinitializationRequired()
 			slapi_log_error( SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
 				"nssReinitializationRequired: vendor is not Fedora \n");
 			slapi_log_error( SLAPI_LOG_PLUGIN, HTTP_PLUGIN_SUBSYSTEM,
-				"or version is earlier than 6.0\n", value);
+				"or version [%s] is earlier than 6.0\n", value?value:"NULL");
 			nssReinitializationRequired = 1;
 			slapi_free_search_results_internal(resultpb);
 			slapi_pblock_destroy(resultpb);

ldap/servers/plugins/memberof/memberof.c

@@ -1071,10 +1071,14 @@ int memberof_modop_one_replace_r(Slapi_PBlock *pb, MemberOfConfig *config,
 		 */
 		if (0 == memberof_compare(config, &this_dn_val, &to_dn_val))
 		{
+			const char *strval = "NULL";
+			if (this_dn_val) {
+				strval = slapi_value_get_string(this_dn_val);
+			}
 			slapi_log_error( SLAPI_LOG_PLUGIN,
 				MEMBEROF_PLUGIN_SUBSYSTEM,
 				"memberof_modop_one_replace_r: not processing memberOf "
-				"operations on self entry: %s\n", this_dn_val);
+				"operations on self entry: %s\n", strval);
 			goto bail;
 		}
 

ldap/servers/plugins/pam_passthru/pam_ptimpl.c

@@ -377,7 +377,7 @@ done:
 	delete_my_str_buf(&pam_id);
 
 	if ((retcode == LDAP_SUCCESS) && (rc != PAM_SUCCESS)) {
-		errmsg = PR_smprintf("Unknown PAM error [%d] for user id [%d], bind DN [%s]",
+		errmsg = PR_smprintf("Unknown PAM error [%d] for user id [%s], bind DN [%s]",
 							 rc, pam_id.str, escape_string(binddn, buf));
 		retcode = LDAP_OPERATIONS_ERROR;
 	}

ldap/servers/plugins/passthru/ptconn.c

@@ -248,7 +248,7 @@ unlock_and_return:
 	++conn->ptconn_usecount;
 	*ldp = conn->ptconn_ld;
 	slapi_log_error( SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
-		"<= passthru_get_connection ld=0x%x (concurrency now %d)\n",
+		"<= passthru_get_connection ld=0x%p (concurrency now %d)\n",
 		*ldp, conn->ptconn_usecount );
     } else {
 	slapi_log_error( SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
@@ -295,7 +295,7 @@ passthru_release_connection( PassThruServer *srvr, LDAP *ld, int dispose )
 
     if ( conn == NULL ) {		/* ld not found -- unexpected */
 	slapi_log_error( SLAPI_LOG_PLUGIN, PASSTHRU_PLUGIN_SUBSYSTEM,
-		"=> passthru_release_connection ld=0x%x not found\n", ld );
+		"=> passthru_release_connection ld=0x%p not found\n", ld );
     } else {
 	PASSTHRU_ASSERT( conn->ptconn_usecount > 0 );
 	--conn->ptconn_usecount;

ldap/servers/plugins/presence/presence.c

@@ -198,7 +198,7 @@ typedef struct _defs _ConfigEntry;
 
 static vattr_sp_handle *_VattrHandle	= NULL;
 static void *_PluginID					= NULL;
-static void *_PluginDN					= NULL;
+static char *_PluginDN					= NULL;
 static PLHashTable *_IdVattrMapTable	= NULL;
 static PLHashTable *_IdConfigMapTable	= NULL;
 static void **_HttpAPI					= NULL;
@@ -281,12 +281,12 @@ void * getPluginID()
 	return _PluginID;
 }
 
-void setPluginDN(void *pluginDN)
+void setPluginDN(char *pluginDN)
 {
 	_PluginDN = pluginDN;
 }
 
-void * getPluginDN()
+char * getPluginDN()
 {
 	return _PluginDN;
 }

ldap/servers/plugins/replication/cl5_api.c

@@ -3626,6 +3626,7 @@ static int _cl5CheckGuardian ()
 	{
 		PR_snprintf (plVersion, VERSION_SIZE, "%s/%d.%d/%s\n", 
 				BDB_IMPL, DB_VERSION_MAJOR, DB_VERSION_MINOR, BDB_REPLPLUGIN);
+        dbVersion[0] = '\0';
 		rc = _cl5ReadGuardian (dbVersion);
 
 		if (rc != CL5_SUCCESS || strcasecmp (plVersion, dbVersion) != 0)
@@ -4954,7 +4955,7 @@ static int _cl5Operation2LDIF (const slapi_operation_parameters *op, const char
 									 break;	
 		
 		default:					 slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, 
-									"_cl5Operation2LDIF: invalid operation type - %d\n", op->operation_type);
+									"_cl5Operation2LDIF: invalid operation type - %lu\n", op->operation_type);
 
 									 return CL5_BAD_FORMAT;
 	}
@@ -5131,7 +5132,7 @@ _cl5LDIF2Operation (char *ldifEntry, slapi_operation_parameters *op, char **repl
 												break;	
 
 				default:						slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, 
-																"_cl5LDIF2Operation: invalid operation type - %d\n", 
+																"_cl5LDIF2Operation: invalid operation type - %lu\n", 
 																 op->operation_type);
 												return CL5_BAD_FORMAT;
 			}
@@ -5375,7 +5376,7 @@ static int _cl5GetFirstEntry (Object *obj, CL5Entry *entry, void **iterator, DB_
 		if (rc != 0)
 		{
 			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name_cl, 
-				"_cl5GetFirstOperation: failed to format entry\n", rc);
+				"_cl5GetFirstOperation: failed to format entry: %d\n", rc);
 			goto done;
 		}
 
@@ -5466,7 +5467,7 @@ static int _cl5GetNextEntry (CL5Entry *entry, void *iterator)
 		if (rc != 0)
 		{
 			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name_cl, 
-				"_cl5GetNextEntry: failed to format entry\n", rc);
+				"_cl5GetNextEntry: failed to format entry: %d\n", rc);
 		}
 
 		return rc;
@@ -6659,7 +6660,7 @@ static int _cl5CopyDBFiles (const char *srcDir, const char *destDir, Object **re
 			object_release (obj);
 			slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, 
 							"_cl5CopyDBFiles: failed to copy %s from %s to %s\n", 
-							file, srcDir, destDir);
+							file->name, srcDir, destDir);
 			return CL5_SYSTEM_ERROR;
 		}
 
@@ -6892,7 +6893,7 @@ cl5_diskspace_is_available()
         if (fsiz < NO_DISK_SPACE)
         {
             slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl,
-                "cl5_diskspace_is_available: No enough diskspace for changelog: (%u bytes free)\n", fsiz);
+                "cl5_diskspace_is_available: No enough diskspace for changelog: (%lu bytes free)\n", fsiz);
             rval = 0;
         }
         else if (fsiz > MIN_DISK_SPACE)

ldap/servers/plugins/replication/cl5_clcache.c

@@ -645,7 +645,7 @@ clcache_skip_change ( CLC_Buffer *buf )
 		/* Skip helper entry (ENTRY_COUNT, PURGE_RUV and so on) */
 		if ( cl5HelperEntry ( NULL, buf->buf_current_csn ) == PR_TRUE ) {
 			slapi_log_error ( SLAPI_LOG_REPL, buf->buf_agmt_name,
-				"Skip helper entry type=%d\n", csn_get_time( buf->buf_current_csn ));
+				"Skip helper entry type=%ld\n", csn_get_time( buf->buf_current_csn ));
 			break;
 		}
 
@@ -922,7 +922,7 @@ clcache_cursor_get ( DBC *cursor, CLC_Buffer *buf, int flag )
 								 &( buf->buf_data ),
 							 	 buf->buf_load_flag | flag );
 			slapi_log_error ( SLAPI_LOG_REPL, buf->buf_agmt_name,
-				"clcache: (%d | %d) %s reallocated and retry returns %d\n", buf->buf_load_flag, flag, buf->buf_key.data, rc );
+				"clcache: (%d | %d) buf key len %d reallocated and retry returns %d\n", buf->buf_load_flag, flag, buf->buf_key.size, rc );
 		}
 	}
 

ldap/servers/plugins/replication/cl5_config.c

@@ -890,7 +890,7 @@ static void changelog5_extract_config(Slapi_Entry* entry, changelog5Config *conf
 		if (theSize < CL5_MIN_NB_LOCK)
 		{
 			slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, 
-				"Warning: Changelog %s value is too low (%d). Set to minimal value instead (%d)\n",
+				"Warning: Changelog %s value is too low (%ld). Set to minimal value instead (%d)\n",
 				CONFIG_CHANGELOG_NB_LOCK, theSize, CL5_MIN_NB_LOCK);
 			config->dbconfig.nb_lock_config = CL5_MIN_NB_LOCK;
 		} 

ldap/servers/plugins/replication/repl5_agmt.c

@@ -192,19 +192,19 @@ agmt_is_valid(Repl_Agmt *ra)
 	if (ra->timeout < 0)
 	{
 		slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "Replication agreement \"%s\" "
-			"is malformed: invalid timeout %d.\n", slapi_sdn_get_dn(ra->dn), ra->timeout);
+			"is malformed: invalid timeout %ld.\n", slapi_sdn_get_dn(ra->dn), ra->timeout);
 		return_value = 0;
 	}
 	if (ra->busywaittime < 0)
 	{
 		slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "Replication agreement \"%s\" "
-			"is malformed: invalid busy wait time %d.\n", slapi_sdn_get_dn(ra->dn), ra->busywaittime);
+			"is malformed: invalid busy wait time %ld.\n", slapi_sdn_get_dn(ra->dn), ra->busywaittime);
 		return_value = 0;
 	}
 	if (ra->pausetime < 0)
 	{
 		slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "Replication agreement \"%s\" "
-			"is malformed: invalid pausetime %d.\n", slapi_sdn_get_dn(ra->dn), ra->pausetime);
+			"is malformed: invalid pausetime %ld.\n", slapi_sdn_get_dn(ra->dn), ra->pausetime);
 		return_value = 0;
 	}
 	return return_value;

ldap/servers/plugins/replication/repl5_connection.c

@@ -54,6 +54,7 @@ replica locked. Seems like right thing to do.
 #include "repl5.h"
 #include "ldappr.h"
 #include "ldap-extension.h"
+#include "nss.h"
 
 typedef struct repl_connection
 {
@@ -1701,6 +1702,6 @@ repl5_debug_timeout_callback(time_t when, void *arg)
 	config_set_errorlog_level("nsslapd-errorlog-level", buf, msg, 1);
 
 	slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, 
-		"repl5_debug_timeout_callback: set debug level to %d at %d\n",
+		"repl5_debug_timeout_callback: set debug level to %d at %ld\n",
 		s_debug_level, when);
 }

ldap/servers/plugins/replication/repl5_inc_protocol.c

@@ -464,7 +464,7 @@ repl5_inc_waitfor_async_results(result_data *rd)
 		/* Are we caught up ? */
 		slapi_log_error(SLAPI_LOG_REPL, NULL,
 					"repl5_inc_waitfor_async_results: %d %d\n",
-					rd->last_message_id_received, rd->last_message_id_sent, 0);
+					rd->last_message_id_received, rd->last_message_id_sent);
 		if (rd->last_message_id_received >= rd->last_message_id_sent) 
 		{
 			/* If so then we're done */
@@ -481,7 +481,7 @@ repl5_inc_waitfor_async_results(result_data *rd)
 			/* Log a warning */
 			slapi_log_error(SLAPI_LOG_FATAL, NULL,
 					"repl5_inc_waitfor_async_results timed out waiting for responses: %d %d\n",
-					rd->last_message_id_received, rd->last_message_id_sent, 0);
+					rd->last_message_id_received, rd->last_message_id_sent);
 			done = 1;
 		}
 	}
@@ -966,7 +966,7 @@ repl5_inc_run(Private_Repl_Protocol *prp)
 		next_fire_time = backoff_step(prp_priv->backoff);
 		/* And go back to sleep */
 		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
-				"%s: Replication session backing off for %d seconds\n",
+				"%s: Replication session backing off for %ld seconds\n",
 				agmt_get_long_name(prp->agmt),
 				next_fire_time - now);
 
@@ -1448,7 +1448,7 @@ replay_update(Private_Repl_Protocol *prp, slapi_operation_parameters *op, int *m
 			break;
 		default:
 			slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "%s: replay_update: Unknown "
-				"operation type %d found in changelog - skipping change.\n",
+				"operation type %lu found in changelog - skipping change.\n",
 				agmt_get_long_name(prp->agmt), op->operation_type);
 		}
 

ldap/servers/plugins/replication/repl5_init.c

@@ -193,7 +193,7 @@ get_repl_session_id (Slapi_PBlock *pb, char *idstr, CSN **csn)
 		/* Avoid "Connection is NULL and hence cannot access SLAPI_CONN_ID" */
 		if (opid) {
 			slapi_pblock_get (pb, SLAPI_CONN_ID, &connid);
-			PR_snprintf (idstr, REPL_SESSION_ID_SIZE, "conn=%" PRIu64 " op=%d", connid, opid);
+			PR_snprintf (idstr, REPL_SESSION_ID_SIZE, "conn=%" NSPRIu64 " op=%d", connid, opid);
 		}
 
 		slapi_pblock_get ( pb, SLAPI_OPERATION, &op );

ldap/servers/plugins/replication/repl5_plugins.c

@@ -1015,7 +1015,7 @@ write_changelog_and_ruv (Slapi_PBlock *pb)
 			    /* ONREPL - log error */
         		slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,
 					"write_changelog_and_ruv: can't add a change for "
-					"%s (uniqid: %s, optype: %u) to changelog csn %s\n",
+					"%s (uniqid: %s, optype: %lu) to changelog csn %s\n",
 					op_params->target_address.dn,
 					op_params->target_address.uniqueid,
 					op_params->operation_type,

ldap/servers/plugins/replication/repl5_replica.c

@@ -421,7 +421,7 @@ replica_get_exclusive_access(Replica *r, PRBool *isInc, PRUint64 connid, int opi
 			*isInc = (r->repl_state_flags & REPLICA_INCREMENTAL_IN_PROGRESS);
 
 		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
-				"conn=%" PRIu64 " op=%d repl=\"%s\": "
+				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
 				"Replica in use locking_purl=%s\n",
 				connid, opid,
 				escape_string(slapi_sdn_get_dn(r->repl_root),ebuf),
@@ -435,7 +435,7 @@ replica_get_exclusive_access(Replica *r, PRBool *isInc, PRUint64 connid, int opi
 	else
 	{
         slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
-						"conn=%" PRIu64 " op=%d repl=\"%s\": Acquired replica\n",
+						"conn=%" NSPRIu64 " op=%d repl=\"%s\": Acquired replica\n",
 						connid, opid,
 						escape_string(slapi_sdn_get_dn(r->repl_root),ebuf));
 		r->repl_state_flags |= REPLICA_IN_USE;
@@ -476,13 +476,13 @@ replica_relinquish_exclusive_access(Replica *r, PRUint64 connid, int opid)
 	if (!(r->repl_state_flags & REPLICA_IN_USE))
 	{
         slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
-					"conn=%" PRIu64 " op=%d repl=\"%s\": "
+					"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
 					"Replica not in use\n",
 					connid, opid,
 					escape_string(slapi_sdn_get_dn(r->repl_root),ebuf));
 	} else {
 		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, 
-					"conn=%" PRIu64 " op=%d repl=\"%s\": "
+					"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
 					"Released replica\n",
 					connid, opid,
 					escape_string(slapi_sdn_get_dn(r->repl_root),ebuf));
@@ -1111,7 +1111,7 @@ replica_dump(Replica *r)
                     _replica_type_as_string (r));    	
     slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\treplica id: %d\n", r->repl_rid);
     slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\tflags: %d\n", r->repl_flags);
-    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\tstate flags: %d\n", r->repl_state_flags);
+    slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\tstate flags: %lu\n", r->repl_state_flags);
 	if (r->updatedn_list)
 		updatedn_list = replica_updatedn_list_to_string(r->updatedn_list, "\n\t\t");
     slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name, "\tupdate dn: %s\n",
@@ -2522,15 +2522,15 @@ _replica_reap_tombstones(void *arg)
 		{
 			slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,
 							"_replica_reap_tombstones: failed when searching for "
-							"tombstones in replica %s: %s. Will try again in %d "
+							"tombstones in replica %s: %s. Will try again in %ld "
 							"seconds.\n", escape_string(slapi_sdn_get_dn(replica->repl_root),ebuf),
 							ldap_err2string(oprc), replica->tombstone_reap_interval);
 		}
 		else
 		{
 			slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
-							"_replica_reap_tombstones: purged %d of %d tombstones "
-							"in replica %s. Will try again in %d "
+							"_replica_reap_tombstones: purged %ld of %ld tombstones "
+							"in replica %s. Will try again in %ld "
 							"seconds.\n", cb_data.num_purged_entries, cb_data.num_entries,
 							escape_string(slapi_sdn_get_dn(replica->repl_root),ebuf),
 							replica->tombstone_reap_interval);
@@ -3020,7 +3020,7 @@ replica_set_tombstone_reap_interval (Replica *r, long interval)
 		slapi_ch_free ((void**)&repl_name);
 		found = slapi_eq_cancel (r->repl_eqcxt_tr);
 		slapi_log_error (SLAPI_LOG_REPL, NULL,
-			"tombstone_reap event (interval=%d) was %s\n",
+			"tombstone_reap event (interval=%ld) was %s\n",
 			r->tombstone_reap_interval, (found ? "cancelled" : "not found"));
 		r->repl_eqcxt_tr = NULL;
 	}
@@ -3032,7 +3032,7 @@ replica_set_tombstone_reap_interval (Replica *r, long interval)
 											current_time() + r->tombstone_reap_interval,
 											1000 * r->tombstone_reap_interval);
 		slapi_log_error (SLAPI_LOG_REPL, NULL,
-			"tombstone_reap event (interval=%d) was %s\n",
+			"tombstone_reap event (interval=%ld) was %s\n",
 			r->tombstone_reap_interval, (r->repl_eqcxt_tr ? "scheduled" : "not scheduled successfully"));
 	}
 	PR_Unlock(r->repl_lock);

ldap/servers/plugins/replication/repl5_tot_protocol.c

@@ -122,8 +122,7 @@ repl5_tot_log_operation_failure(int ldap_error, char* ldap_error_string, const c
                 slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,
 						"%s: Received error %d: %s for total update operation\n",
 						agreement_name,
-						ldap_error, ldap_error_string ? ldap_error_string : "NULL",
-						0);
+						ldap_error, ldap_error_string ? ldap_error_string : "NULL");
 }
 
 /* Thread that collects results from async operations sent to the consumer */
@@ -285,7 +284,7 @@ repl5_tot_waitfor_async_results(callback_data *cb_data)
 		/* Are we caught up ? */
 		slapi_log_error(SLAPI_LOG_REPL, NULL,
 					"repl5_tot_waitfor_async_results: %d %d\n",
-					cb_data->last_message_id_received, cb_data->last_message_id_sent, 0);
+					cb_data->last_message_id_received, cb_data->last_message_id_sent);
 		if (cb_data->last_message_id_received >= cb_data->last_message_id_sent) 
 		{
 			/* If so then we're done */
@@ -302,7 +301,7 @@ repl5_tot_waitfor_async_results(callback_data *cb_data)
 			/* Log a warning */
 			slapi_log_error(SLAPI_LOG_FATAL, NULL,
 					"repl5_tot_waitfor_async_results timed out waiting for responses: %d %d\n",
-					cb_data->last_message_id_received, cb_data->last_message_id_sent, 0);
+					cb_data->last_message_id_received, cb_data->last_message_id_sent);
 			done = 1;
 		}
 	}
@@ -474,7 +473,7 @@ repl5_tot_run(Private_Repl_Protocol *prp)
 		agmt_set_last_init_status(prp->agmt, rc, 0, "Total update aborted");
     } else {
 		slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "Finished total update of replica "
-						"\"%s\". Sent %d entries.\n", agmt_get_long_name(prp->agmt), cb_data.num_entries);
+						"\"%s\". Sent %lu entries.\n", agmt_get_long_name(prp->agmt), cb_data.num_entries);
 		agmt_set_last_init_status(prp->agmt, 0, 0, "Total update succeeded");
 	}
 
@@ -692,7 +691,7 @@ int send_entry (Slapi_Entry *e, void *cb_data)
 	*last_busyp = now;
 
 	slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,
-		"Replica \"%s\" is busy. Waiting %ds while"
+		"Replica \"%s\" is busy. Waiting %lds while"
 		" it finishes processing its current import queue\n", 
 		agmt_get_long_name(prp->agmt), *sleep_on_busyp);
 		DS_Sleep(PR_SecondsToInterval(*sleep_on_busyp));

ldap/servers/plugins/replication/repl5_total.c

@@ -881,7 +881,7 @@ multimaster_extop_NSDS50ReplicationEntry(Slapi_PBlock  *pb)
 		   const char *dn = slapi_entry_get_dn_const(e);
 		   slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
 						   "Error %d: could not import entry dn %s "
-						   "for total update operation conn=%" PRIu64 " op=%d\n",
+						   "for total update operation conn=%" NSPRIu64 " op=%d\n",
 						   rc, dn, connid, opid);
 		   rc = -1;
 	   }
@@ -891,7 +891,7 @@ multimaster_extop_NSDS50ReplicationEntry(Slapi_PBlock  *pb)
 	{
 		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
 						"Error %d: could not decode the total update extop "
-						"for total update operation conn=%" PRIu64 " op=%d\n",
+						"for total update operation conn=%" NSPRIu64 " op=%d\n",
 						rc, connid, opid);
 	}
    

ldap/servers/plugins/replication/repl_connext.c

@@ -101,7 +101,7 @@ void consumer_connection_extension_destructor (void *ext, void *object, void *pa
 					slapi_pblock_get(pb, SLAPI_CONN_ID, &connid);
 					slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
 									"Aborting total update in progress for replicated "
-									"area %s connid=%" PRIu64 "\n", slapi_sdn_get_dn(repl_root_sdn),
+									"area %s connid=%" NSPRIu64 "\n", slapi_sdn_get_dn(repl_root_sdn),
 									connid);
 					slapi_stop_bulk_import(pb);
 				}

ldap/servers/plugins/replication/repl_extop.c

@@ -605,7 +605,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 		/* Stash info that this is an incremental update session */
 		connext->repl_protocol_version = REPL_PROTOCOL_50_INCREMENTAL;
 		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
-			"conn=%" PRIu64 " op=%d repl=\"%s\": Begin incremental protocol\n",
+			"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin incremental protocol\n",
 			connid, opid, repl_root);
 		isInc = PR_TRUE;
 	}
@@ -617,7 +617,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 			connext->repl_protocol_version = REPL_PROTOCOL_50_TOTALUPDATE;
 		}
 		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
-				"conn=%" PRIu64 " op=%d repl=\"%s\": Begin total protocol\n",
+				"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin total protocol\n",
 				connid, opid, repl_root);
 		isInc = PR_FALSE;
 	}
@@ -626,7 +626,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 		/* Stash info that this is an incremental update session */
 		connext->repl_protocol_version = REPL_PROTOCOL_50_INCREMENTAL;
 		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
-			"conn=%" PRIu64 " op=%d repl=\"%s\": Begin 7.1 incremental protocol\n",
+			"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin 7.1 incremental protocol\n",
 			connid, opid, repl_root);
 		isInc = PR_TRUE;
 	}
@@ -638,7 +638,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 			connext->repl_protocol_version = REPL_PROTOCOL_71_TOTALUPDATE;
 		}
 		slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
-				"conn=%" PRIu64 " op=%d repl=\"%s\": Begin 7.1 total protocol\n",
+				"conn=%" NSPRIu64 " op=%d repl=\"%s\": Begin 7.1 total protocol\n",
 				connid, opid, repl_root);
 		isInc = PR_FALSE;
 	}
@@ -660,7 +660,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 	if (replica_is_being_configured(repl_root))
 	{
         slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
-				"conn=%" PRIu64 " op=%d replica=\"%s\": "
+				"conn=%" NSPRIu64 " op=%d replica=\"%s\": "
 				"Replica is being configured: try again later\n",
 				connid, opid, repl_root);
 		response = NSDS50_REPL_REPLICA_BUSY;
@@ -713,7 +713,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 				{
 					response = NSDS50_REPL_EXCESSIVE_CLOCK_SKEW;
 					slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name,
-									"conn=%" PRIu64 " op=%d repl=\"%s\": "
+									"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
 									"Excessive clock skew from supplier RUV\n",
 									connid, opid, repl_root);
 					goto send_response;
@@ -749,7 +749,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 
 	if (check_replica_id_uniqueness(replica, supplier_ruv) != 0){
         slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
-				"conn=%" PRIu64 " op=%d repl=\"%s\": "
+				"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
 				"Replica has same replicaID %d as supplier\n",
 				connid, opid, repl_root, replica_get_rid(replica));
 		response = NSDS50_REPL_REPLICAID_ERROR;
@@ -762,7 +762,7 @@ multimaster_extop_StartNSDS50ReplicationRequest(Slapi_PBlock *pb)
 	 * the session's conn id and op id to identify the the supplier.
 	 */
 	/* junkrc = ruv_get_first_id_and_purl(supplier_ruv, &junkrid, &locking_purl); */
-	PR_snprintf(locking_session, sizeof(locking_session), "conn=%" PRIu64 " id=%d", connid, opid);
+	PR_snprintf(locking_session, sizeof(locking_session), "conn=%" NSPRIu64 " id=%d", connid, opid);
 	locking_purl = &locking_session[0];
 	if (replica_get_exclusive_access(replica, &isInc, connid, opid,
 									 locking_purl,
@@ -878,7 +878,7 @@ send_response:
 		}
 
         slapi_log_error (resp_log_level, repl_plugin_name,
-			"conn=%" PRIu64 " op=%d replica=\"%s\": "
+			"conn=%" NSPRIu64 " op=%d replica=\"%s\": "
 			"Unable to acquire replica: error: %s%s\n",
 			connid, opid,
 			(replica ? slapi_sdn_get_dn(replica_get_root(replica)) : "unknown"),
@@ -902,7 +902,7 @@ send_response:
 	slapi_pblock_set(pb, SLAPI_EXT_OP_RET_OID, REPL_NSDS50_REPLICATION_RESPONSE_OID);
 	slapi_pblock_set(pb, SLAPI_EXT_OP_RET_VALUE, resp_bval);
 	slapi_log_error(SLAPI_LOG_REPL, repl_plugin_name,
-					"conn=%" PRIu64 " op=%d repl=\"%s\": "
+					"conn=%" NSPRIu64 " op=%d repl=\"%s\": "
 					"StartNSDS50ReplicationRequest: response=%d rc=%d\n",
 					connid, opid, repl_root,
 					response, rc);

ldap/servers/plugins/replication/replutil.c

@@ -236,7 +236,7 @@ int copyfile(char* source, char * destination, int overwrite, int mode)
 		{
 			/* means error */
 			slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, 
-						"copyfile: failed to write to destination file %s\n");
+						"copyfile: failed to write to destination file %s\n", destination);
 			return_value = -1;
 			break;
 		}
@@ -822,7 +822,9 @@ repl_chain_on_update(Slapi_PBlock *pb, Slapi_DN * target_dn,
 	int repl_op = 0;
 	int local_backend = -1; /* index of local backend */
 	int chaining_backend = -1; /* index of chain backend */
+#ifdef DEBUG_CHAIN_ON_UPDATE
 	int is_internal = 0;
+#endif
 	PRBool local_online = PR_FALSE; /* true if the local db is online */
 	int ii;
 	int opid;

ldap/servers/plugins/replication/windows_connection.c

@@ -55,6 +55,7 @@ replica locked. Seems like right thing to do.
 #include "windowsrepl.h"
 #include "ldappr.h"
 #include "slap.h"
+#include "nss.h"
 
 typedef struct repl_connection
 {
@@ -880,7 +881,7 @@ Slapi_Entry * windows_conn_get_search_result(Repl_Connection *conn)
 					ldap_controls_free(returned_controls);
 				}
 				if (windows_private_dirsync_has_more(conn->agmt)) {
-					slapi_log_error(SLAPI_LOG_REPL, windows_repl_plugin_name,"received hasmore from dirsync\n", 0);
+					slapi_log_error(SLAPI_LOG_REPL, windows_repl_plugin_name,"received hasmore from dirsync\n");
 				}
 			} 
 			break;
@@ -1900,7 +1901,7 @@ repl5_debug_timeout_callback(time_t when, void *arg)
 	config_set_errorlog_level("nsslapd-errorlog-level", buf, msg, 1);
 
 	slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, 
-		"repl5_debug_timeout_callback: set debug level to %d at %d\n",
+		"repl5_debug_timeout_callback: set debug level to %d at %ld\n",
 		s_debug_level, when);
 
 	LDAPDebug( LDAP_DEBUG_TRACE, "<= repl5_debug_timeout_callback\n", 0, 0, 0 );

ldap/servers/plugins/replication/windows_inc_protocol.c

@@ -162,18 +162,18 @@ static Slapi_Eq_Context dirsync;
 static void
 windows_inc_delete(Private_Repl_Protocol **prpp)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_inc_delete\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_inc_delete\n" );
 	/* First, stop the protocol if it isn't already stopped */
 	/* Then, delete all resources used by the protocol */
 	slapi_eq_cancel(dirsync); 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_inc_delete\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_inc_delete\n" );
 }
 
 /* helper function */
 void
 w_set_pause_and_busy_time(long *pausetime, long *busywaittime)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> w_set_pause_and_busy_time\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> w_set_pause_and_busy_time\n" );
   /* If neither are set, set busy time to its default */
   if (!*pausetime && !*busywaittime)
     {
@@ -210,7 +210,7 @@ w_set_pause_and_busy_time(long *pausetime, long *busywaittime)
        */
       *pausetime = *busywaittime + 1;
     }
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= w_set_pause_and_busy_time\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= w_set_pause_and_busy_time\n" );
 }
 
 /*
@@ -286,7 +286,7 @@ windows_inc_run(Private_Repl_Protocol *prp)
  
 	PRBool run_dirsync = PR_FALSE;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_inc_run\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_inc_run\n" );
 
 	prp->stopped = 0;
 	prp->terminate = 0;
@@ -685,7 +685,7 @@ windows_inc_run(Private_Repl_Protocol *prp)
 						next_fire_time = backoff_step(prp_priv->backoff);
 						/* And go back to sleep */
 						slapi_log_error(SLAPI_LOG_REPL, windows_repl_plugin_name,
-								"%s: Replication session backing off for %d seconds\n",
+								"%s: Replication session backing off for %ld seconds\n",
 								agmt_get_long_name(prp->agmt),
 								next_fire_time - now);
 
@@ -991,7 +991,7 @@ windows_inc_run(Private_Repl_Protocol *prp)
   conn_cancel_linger(prp->conn);
   /* ... and disconnect, if currently connected */
   conn_disconnect(prp->conn);
-  LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_inc_run\n", 0, 0, 0 );
+  LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_inc_run\n" );
 }
 
 
@@ -1002,7 +1002,7 @@ windows_inc_run(Private_Repl_Protocol *prp)
 static void
 protocol_sleep(Private_Repl_Protocol *prp, PRIntervalTime duration)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> protocol_sleep\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> protocol_sleep\n" );
 	PR_ASSERT(NULL != prp);
 	PR_Lock(prp->lock);
     /* we should not go to sleep if there are events available to be processed.
@@ -1016,7 +1016,7 @@ protocol_sleep(Private_Repl_Protocol *prp, PRIntervalTime duration)
 			agmt_get_long_name(prp->agmt), prp->eventbits);
     }
 	PR_Unlock(prp->lock);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= protocol_sleep\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= protocol_sleep\n" );
 }
 
 
@@ -1029,13 +1029,13 @@ protocol_sleep(Private_Repl_Protocol *prp, PRIntervalTime duration)
 static void
 event_notify(Private_Repl_Protocol *prp, PRUint32 event)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> event_notify\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> event_notify\n" );
 	PR_ASSERT(NULL != prp);
 	PR_Lock(prp->lock);
 	prp->eventbits |= event;
 	PR_NotifyCondVar(prp->cvar);
 	PR_Unlock(prp->lock);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= event_notify\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= event_notify\n" );
 }
 
 
@@ -1048,26 +1048,26 @@ event_occurred(Private_Repl_Protocol *prp, PRUint32 event)
 {
 	PRUint32 return_value;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> event_occurred\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> event_occurred\n" );
 
 	PR_ASSERT(NULL != prp);
 	PR_Lock(prp->lock);
 	return_value = (prp->eventbits & event);
 	prp->eventbits &= ~event; /* Clear event */
 	PR_Unlock(prp->lock);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= event_occurred\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= event_occurred\n" );
 	return return_value;
 }
 
 static void
 reset_events (Private_Repl_Protocol *prp)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> reset_events\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> reset_events\n" );
 	PR_ASSERT(NULL != prp);
 	PR_Lock(prp->lock);
 	prp->eventbits = 0;
 	PR_Unlock(prp->lock);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= reset_events\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= reset_events\n" );
 }
 
 
@@ -1075,8 +1075,8 @@ reset_events (Private_Repl_Protocol *prp)
 static PRBool
 is_dummy_operation (const slapi_operation_parameters *op)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> is_dummy_operation\n", 0, 0, 0 );
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= is_dummy_operation\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> is_dummy_operation\n" );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= is_dummy_operation\n" );
     return (strcmp (op->target_address.uniqueid, START_ITERATION_ENTRY_UNIQUEID) == 0);
 }
 
@@ -1085,7 +1085,7 @@ is_dummy_operation (const slapi_operation_parameters *op)
 void
 w_cl5_operation_parameters_done (struct slapi_operation_parameters *sop)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> w_cl5_operation_parameters_done\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> w_cl5_operation_parameters_done\n" );
 	if(sop!=NULL) {
 		switch(sop->operation_type) 
 		{
@@ -1120,7 +1120,7 @@ w_cl5_operation_parameters_done (struct slapi_operation_parameters *sop)
 		}
 	}
 	operation_parameters_done(sop);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= w_cl5_operation_parameters_done\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= w_cl5_operation_parameters_done\n" );
 }
 
 
@@ -1147,7 +1147,7 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 	RUV *current_ruv = ruv_dup(remote_update_vector);
 	CSN *mincsn = NULL;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> send_updates\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> send_updates\n" );
 
 	*num_changes_sent = 0;
 
@@ -1445,7 +1445,7 @@ send_updates(Private_Repl_Protocol *prp, RUV *remote_update_vector, PRUint32 *nu
 		agmt_set_consumer_ruv(prp->agmt,current_ruv);
 		ruv_destroy(&current_ruv);
 	}
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= send_updates\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= send_updates\n" );
 	return return_value;
 }
 
@@ -1462,7 +1462,7 @@ windows_inc_stop(Private_Repl_Protocol *prp)
 	PRIntervalTime start, maxwait, now;
 	int seconds = 1200;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_inc_stop\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_inc_stop\n" );
 
 	maxwait = PR_SecondsToInterval(seconds);
 	prp->terminate = 1;
@@ -1490,7 +1490,7 @@ windows_inc_stop(Private_Repl_Protocol *prp)
 				agmt_get_long_name(prp->agmt),
 				PR_IntervalToSeconds(now-start));
 	}
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_inc_stop\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_inc_stop\n" );
 	return return_value;
 }
 
@@ -1501,9 +1501,9 @@ windows_inc_status(Private_Repl_Protocol *prp)
 {
 	int return_value = 0;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_inc_status\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_inc_status\n" );
 	
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_inc_status\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_inc_status\n" );
 
 	return return_value;
 }
@@ -1513,43 +1513,43 @@ windows_inc_status(Private_Repl_Protocol *prp)
 static void
 windows_inc_notify_update(Private_Repl_Protocol *prp)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_inc_notify_update\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_inc_notify_update\n" );
 	event_notify(prp, EVENT_TRIGGERING_CRITERIA_MET);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_inc_notify_update\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_inc_notify_update\n" );
 }
 
 
 static void
 windows_inc_update_now(Private_Repl_Protocol *prp)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_inc_update_now\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_inc_update_now\n" );
 	event_notify(prp, EVENT_REPLICATE_NOW);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_inc_update_now\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_inc_update_now\n" );
 }
 
 
 static void
 windows_inc_notify_agmt_changed(Private_Repl_Protocol *prp)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_inc_notify_agmt_changed\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_inc_notify_agmt_changed\n" );
 	event_notify(prp, EVENT_AGMT_CHANGED);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_inc_notify_agmt_changed\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_inc_notify_agmt_changed\n" );
 }
 
 static void 
 windows_inc_notify_window_opened (Private_Repl_Protocol *prp)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_inc_notify_window_opened\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_inc_notify_window_opened\n" );
     event_notify(prp, EVENT_WINDOW_OPENED);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_inc_notify_window_opened\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_inc_notify_window_opened\n" );
 }
 
 static void 
 windows_inc_notify_window_closed (Private_Repl_Protocol *prp)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_inc_notify_window_closed\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_inc_notify_window_closed\n" );
     event_notify(prp, EVENT_WINDOW_CLOSED);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_inc_notify_window_closed\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_inc_notify_window_closed\n" );
 }
 
 
@@ -1559,7 +1559,7 @@ Windows_Inc_Protocol_new(Repl_Protocol *rp)
 	windows_inc_private *rip = NULL;
 	Private_Repl_Protocol *prp = (Private_Repl_Protocol *)slapi_ch_malloc(sizeof(Private_Repl_Protocol));
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> Windows_Inc_Protocol_new\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> Windows_Inc_Protocol_new\n" );
 
 	prp->delete = windows_inc_delete;
 	prp->run = windows_inc_run;
@@ -1592,13 +1592,13 @@ Windows_Inc_Protocol_new(Repl_Protocol *rp)
 	prp->private = (void *)rip;
     prp->replica_acquired = PR_FALSE;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= Windows_Inc_Protocol_new\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= Windows_Inc_Protocol_new\n" );
 
 	return prp;
 
 loser:
 	windows_inc_delete(&prp);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= Windows_Inc_Protocol_new (loser)\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= Windows_Inc_Protocol_new (loser)\n" );
 	return NULL;
 }
 
@@ -1610,12 +1610,12 @@ windows_inc_backoff_expired(time_t timer_fire_time, void *arg)
 {
 	Private_Repl_Protocol *prp = (Private_Repl_Protocol *)arg;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_inc_backoff_expired\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_inc_backoff_expired\n" );
 
 	PR_ASSERT(NULL != prp);
 	event_notify(prp, EVENT_BACKOFF_EXPIRED);
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_inc_backoff_expired\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_inc_backoff_expired\n" );
 }
 
 
@@ -1641,7 +1641,7 @@ windows_examine_update_vector(Private_Repl_Protocol *prp, RUV *remote_ruv)
 {
 	int return_value;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_examine_update_vector\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_examine_update_vector\n" );
 
 	PR_ASSERT(NULL != prp);
 	if (NULL == prp)
@@ -1682,7 +1682,7 @@ windows_examine_update_vector(Private_Repl_Protocol *prp, RUV *remote_ruv)
 		slapi_ch_free((void**)&remote_gen);
 		slapi_ch_free((void**)&local_gen);
 	}
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_examine_update_vector\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_examine_update_vector\n" );
 	return return_value;
 }
 
@@ -1707,8 +1707,8 @@ acquire2name (int code)
 static const char* 
 state2name (int state)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> state2name\n", 0, 0, 0 );
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= state2name\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> state2name\n" );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= state2name\n" );
     switch (state)
     {
         case STATE_START:                       return "start";
@@ -1729,8 +1729,8 @@ state2name (int state)
 static const char* 
 event2name (int event)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> event2name\n", 0, 0, 0 );
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= event2name\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> event2name\n" );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= event2name\n" );
     switch (event)
     {
         case EVENT_WINDOW_OPENED:           return "update_window_opened";
@@ -1749,11 +1749,11 @@ event2name (int event)
 static void 
 periodic_dirsync(time_t when, void *arg)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> periodic_dirsync\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> periodic_dirsync\n" );
 
 	slapi_log_error(SLAPI_LOG_REPL, windows_repl_plugin_name,
 			"Running Dirsync \n");
 
 	event_notify( (Private_Repl_Protocol*) arg, EVENT_RUN_DIRSYNC);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= periodic_dirsync\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= periodic_dirsync\n" );
 }

ldap/servers/plugins/replication/windows_private.c

@@ -196,7 +196,7 @@ Dirsync_Private* windows_private_new()
 {
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_new\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_new\n" );
 
 	dp = (Dirsync_Private *)slapi_ch_calloc(sizeof(Dirsync_Private),1);
 
@@ -204,7 +204,7 @@ Dirsync_Private* windows_private_new()
 	dp->directory_filter = NULL;
 	dp->deleted_filter = NULL;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_new\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_new\n" );
 	return dp;
 
 }
@@ -213,7 +213,7 @@ void windows_agreement_delete(Repl_Agmt *ra)
 {
 
 	Dirsync_Private *dp = (Dirsync_Private *) agmt_get_priv(ra);
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_delete\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_delete\n" );
 
 	PR_ASSERT(dp  != NULL);
 	
@@ -229,7 +229,7 @@ void windows_agreement_delete(Repl_Agmt *ra)
 	dp->api_cookie = NULL;
 	slapi_ch_free((void **)dp);
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_delete\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_delete\n" );
 
 }
 
@@ -237,14 +237,14 @@ int windows_private_get_isnt4(const Repl_Agmt *ra)
 {
 		Dirsync_Private *dp;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_get_isnt4\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_get_isnt4\n" );
 
         PR_ASSERT(ra);
 
 		dp = (Dirsync_Private *) agmt_get_priv(ra);
 		PR_ASSERT (dp);
 		
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_get_isnt4\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_get_isnt4\n" );
 	
 		return dp->isnt4;	
 }
@@ -253,7 +253,7 @@ void windows_private_set_isnt4(const Repl_Agmt *ra, int isit)
 {
 		Dirsync_Private *dp;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_set_isnt4\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_set_isnt4\n" );
 
         PR_ASSERT(ra);
 
@@ -262,21 +262,21 @@ void windows_private_set_isnt4(const Repl_Agmt *ra, int isit)
 
 		dp->isnt4 = isit;
 		
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_set_isnt4\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_set_isnt4\n" );
 }
 
 int windows_private_get_iswin2k3(const Repl_Agmt *ra)
 {
 		Dirsync_Private *dp;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_get_iswin2k3\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_get_iswin2k3\n" );
 
 	PR_ASSERT(ra);
 
 		dp = (Dirsync_Private *) agmt_get_priv(ra);
 		PR_ASSERT (dp);
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_get_iswin2k3\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_get_iswin2k3\n" );
 
 		return dp->iswin2k3;
 }
@@ -285,7 +285,7 @@ void windows_private_set_iswin2k3(const Repl_Agmt *ra, int isit)
 {
 		Dirsync_Private *dp;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_set_iswin2k3\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_set_iswin2k3\n" );
 
 	PR_ASSERT(ra);
 
@@ -294,7 +294,7 @@ void windows_private_set_iswin2k3(const Repl_Agmt *ra, int isit)
 
 		dp->iswin2k3 = isit;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_set_iswin2k3\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_set_iswin2k3\n" );
 }
 
 /* Returns a copy of the Slapi_Filter pointer.  The caller should not free it */
@@ -302,7 +302,7 @@ Slapi_Filter* windows_private_get_directory_filter(const Repl_Agmt *ra)
 {
 		Dirsync_Private *dp;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_get_directory_filter\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_get_directory_filter\n" );
 
 	PR_ASSERT(ra);
 
@@ -316,7 +316,7 @@ Slapi_Filter* windows_private_get_directory_filter(const Repl_Agmt *ra)
 			slapi_ch_free_string(&string_filter);
 		}
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_get_directory_filter\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_get_directory_filter\n" );
 
 		return dp->directory_filter;
 }
@@ -326,7 +326,7 @@ Slapi_Filter* windows_private_get_deleted_filter(const Repl_Agmt *ra)
 {
 		Dirsync_Private *dp;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_get_deleted_filter\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_get_deleted_filter\n" );
 
 	PR_ASSERT(ra);
 
@@ -340,7 +340,7 @@ Slapi_Filter* windows_private_get_deleted_filter(const Repl_Agmt *ra)
 			slapi_ch_free_string(&string_filter);
 		}
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_get_deleted_filter\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_get_deleted_filter\n" );
 
 		return dp->deleted_filter;
 }
@@ -350,14 +350,14 @@ const Slapi_DN* windows_private_get_windows_subtree (const Repl_Agmt *ra)
 {
 		Dirsync_Private *dp;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_get_windows_subtree\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_get_windows_subtree\n" );
 
         PR_ASSERT(ra);
 
 		dp = (Dirsync_Private *) agmt_get_priv(ra);
 		PR_ASSERT (dp);
 		
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_get_windows_subtree\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_get_windows_subtree\n" );
 	
 		return dp->windows_subtree;	
 }
@@ -367,14 +367,14 @@ windows_private_get_windows_domain(const Repl_Agmt *ra)
 {
 		Dirsync_Private *dp;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_get_windows_domain\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_get_windows_domain\n" );
 
         PR_ASSERT(ra);
 
 		dp = (Dirsync_Private *) agmt_get_priv(ra);
 		PR_ASSERT (dp);
 		
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_get_windows_domain\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_get_windows_domain\n" );
 	
 		return dp->windows_domain;	
 }
@@ -384,7 +384,7 @@ windows_private_set_windows_domain(const Repl_Agmt *ra, char *domain)
 {
 		Dirsync_Private *dp;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_set_windows_domain\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_set_windows_domain\n" );
 
         PR_ASSERT(ra);
 
@@ -393,7 +393,7 @@ windows_private_set_windows_domain(const Repl_Agmt *ra, char *domain)
 
 		dp->windows_domain = domain;
 		
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_set_windows_domain\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_set_windows_domain\n" );
 	}
 
 /* Returns a copy of the Slapi_DN pointer, no need to free it */
@@ -401,14 +401,14 @@ const Slapi_DN* windows_private_get_directory_subtree (const Repl_Agmt *ra)
 {
 		Dirsync_Private *dp;
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_get_directory_replarea\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_get_directory_replarea\n" );
 
         PR_ASSERT(ra);
 
 		dp = (Dirsync_Private *) agmt_get_priv(ra);
 		PR_ASSERT (dp);
 
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_get_directory_replarea\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_get_directory_replarea\n" );
 	
 		return dp->directory_subtree; 
 }
@@ -419,7 +419,7 @@ void windows_private_set_windows_subtree (const Repl_Agmt *ra,Slapi_DN* sdn )
 
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_set_windows_replarea\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_set_windows_replarea\n" );
 
 	PR_ASSERT(ra);
 	PR_ASSERT(sdn);
@@ -430,7 +430,7 @@ void windows_private_set_windows_subtree (const Repl_Agmt *ra,Slapi_DN* sdn )
 	slapi_sdn_free(&dp->windows_subtree);
 	dp->windows_subtree = sdn;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_set_windows_replarea\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_set_windows_replarea\n" );
 }
 
 /* Takes a copy of the sdn passed in */
@@ -439,7 +439,7 @@ void windows_private_set_directory_subtree (const Repl_Agmt *ra,Slapi_DN* sdn )
 
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_set_directory_replarea\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_set_directory_replarea\n" );
 
 	PR_ASSERT(ra);
 	PR_ASSERT(sdn);
@@ -450,20 +450,20 @@ void windows_private_set_directory_subtree (const Repl_Agmt *ra,Slapi_DN* sdn )
 	slapi_sdn_free(&dp->directory_subtree);
 	dp->directory_subtree = sdn;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_set_directory_replarea\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_set_directory_replarea\n" );
 }
 
 PRBool windows_private_create_users(const Repl_Agmt *ra)
 {
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_create_users\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_create_users\n" );
 
 	PR_ASSERT(ra);
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
 	PR_ASSERT (dp);
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_create_users\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_create_users\n" );
 
 	return dp->create_users_from_dirsync;
 
@@ -474,7 +474,7 @@ void windows_private_set_create_users(const Repl_Agmt *ra, PRBool value)
 {
 	Dirsync_Private *dp;
 	
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_set_create_users\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_set_create_users\n" );
 
 	PR_ASSERT(ra);
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
@@ -482,7 +482,7 @@ void windows_private_set_create_users(const Repl_Agmt *ra, PRBool value)
 
 	dp->create_users_from_dirsync = value;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_set_create_users\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_set_create_users\n" );
 
 }
 
@@ -490,13 +490,13 @@ PRBool windows_private_create_groups(const Repl_Agmt *ra)
 {
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_create_groups\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_create_groups\n" );
 
 	PR_ASSERT(ra);
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
 	PR_ASSERT (dp);
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_create_groups\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_create_groups\n" );
 
 	return dp->create_groups_from_dirsync;
 
@@ -507,7 +507,7 @@ void windows_private_set_create_groups(const Repl_Agmt *ra, PRBool value)
 {
 	Dirsync_Private *dp;
 	
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_set_create_groups\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_set_create_groups\n" );
 
 	PR_ASSERT(ra);
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
@@ -515,7 +515,7 @@ void windows_private_set_create_groups(const Repl_Agmt *ra, PRBool value)
 
 	dp->create_groups_from_dirsync = value;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_set_create_groups\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_set_create_groups\n" );
 
 }
 
@@ -533,7 +533,7 @@ LDAPControl* windows_private_dirsync_control(const Repl_Agmt *ra)
 	Dirsync_Private *dp;
 	char iscritical = PR_TRUE;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_dirsync_control\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_dirsync_control\n" );
 	
 	PR_ASSERT(ra);
 	
@@ -551,7 +551,7 @@ LDAPControl* windows_private_dirsync_control(const Repl_Agmt *ra)
 
 	ber_free(ber,1);
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_dirsync_control\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_dirsync_control\n" );
 
 
 	return control;
@@ -578,7 +578,7 @@ void windows_private_update_dirsync_control(const Repl_Agmt *ra,LDAPControl **co
 	int return_value = LDAP_SUCCESS;
 #endif
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_update_dirsync_control\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_update_dirsync_control\n" );
 
     PR_ASSERT(ra);
 
@@ -636,9 +636,9 @@ choke:
 	}
 
 #ifdef FOR_DEBUGGING
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_update_dirsync_control: rc=%d\n", return_value, 0, 0 );
+	LDAPDebug1Arg( LDAP_DEBUG_TRACE, "<= windows_private_update_dirsync_control: rc=%d\n", return_value);
 #else
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_update_dirsync_control\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_update_dirsync_control\n" );
 #endif
 }
 
@@ -646,14 +646,14 @@ PRBool windows_private_dirsync_has_more(const Repl_Agmt *ra)
 {
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_dirsync_has_more\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_dirsync_has_more\n" );
 
 	PR_ASSERT(ra);
 
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
 	PR_ASSERT (dp);
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_dirsync_has_more\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_dirsync_has_more\n" );
 
 	return dp->dirsync_cookie_has_more;
 
@@ -663,7 +663,7 @@ void windows_private_null_dirsync_cookie(const Repl_Agmt *ra)
 {
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_null_dirsync_control\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_null_dirsync_control\n" );
 
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
 	PR_ASSERT (dp);
@@ -672,7 +672,7 @@ void windows_private_null_dirsync_cookie(const Repl_Agmt *ra)
 	slapi_ch_free_string(&dp->dirsync_cookie);
 	dp->dirsync_cookie = NULL;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_null_dirsync_control\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_null_dirsync_control\n" );
 }
 
 static 
@@ -703,7 +703,7 @@ windows_private_save_dirsync_cookie(const Repl_Agmt *ra)
 
     
   
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_save_dirsync_cookie\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_save_dirsync_cookie\n" );
 	PR_ASSERT(ra);
 
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
@@ -736,7 +736,7 @@ windows_private_save_dirsync_cookie(const Repl_Agmt *ra)
 	slapi_mods_free(&mods);
 	slapi_sdn_free(&sdn);
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_save_dirsync_cookie\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_save_dirsync_cookie\n" );
 	return rc;
 }
 
@@ -753,7 +753,7 @@ int windows_private_load_dirsync_cookie(const Repl_Agmt *ra)
 	Slapi_Entry *entry = NULL;
 	Slapi_Attr *attr = NULL;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_load_dirsync_cookie\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_load_dirsync_cookie\n" );
 	PR_ASSERT(ra);
 
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
@@ -803,7 +803,7 @@ int windows_private_load_dirsync_cookie(const Repl_Agmt *ra)
 	slapi_sdn_free( &sdn);
 	slapi_pblock_destroy (pb);
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_load_dirsync_cookie\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_load_dirsync_cookie\n" );
 
 	return rc;
 }
@@ -813,12 +813,12 @@ Slapi_Entry *windows_private_get_raw_entry(const Repl_Agmt *ra)
 {
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_get_raw_entry\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_get_raw_entry\n" );
 
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
 	PR_ASSERT (dp);
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_get_raw_entry\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_get_raw_entry\n" );
 
 	return dp->raw_entry;
 }
@@ -828,7 +828,7 @@ void windows_private_set_raw_entry(const Repl_Agmt *ra, Slapi_Entry *e)
 {
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_set_raw_entry\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_set_raw_entry\n" );
 
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
 	PR_ASSERT (dp);
@@ -836,19 +836,19 @@ void windows_private_set_raw_entry(const Repl_Agmt *ra, Slapi_Entry *e)
 	slapi_entry_free(dp->raw_entry);
 	dp->raw_entry = e;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_set_raw_entry\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_set_raw_entry\n" );
 }
 
 void *windows_private_get_api_cookie(const Repl_Agmt *ra)
 {
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_get_api_cookie\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_get_api_cookie\n" );
 
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
 	PR_ASSERT (dp);
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_get_api_cookie\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_get_api_cookie\n" );
 
 	return dp->api_cookie;
 }
@@ -857,13 +857,13 @@ void windows_private_set_api_cookie(Repl_Agmt *ra, void *api_cookie)
 {
 	Dirsync_Private *dp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_private_set_api_cookie\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_private_set_api_cookie\n" );
 
 	dp = (Dirsync_Private *) agmt_get_priv(ra);
 	PR_ASSERT (dp);
 	dp->api_cookie = api_cookie;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_private_set_api_cookie\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_private_set_api_cookie\n" );
 }
 
 /* an array of function pointers */
@@ -875,7 +875,7 @@ windows_plugin_init(Repl_Agmt *ra)
     void *cookie = NULL;
     winsync_plugin_init_cb initfunc = NULL;
 
-	LDAPDebug( LDAP_DEBUG_PLUGIN, "--> windows_plugin_init_start -- begin\n",0,0,0);
+	LDAPDebug0Args( LDAP_DEBUG_PLUGIN, "--> windows_plugin_init_start -- begin\n");
 
     /* if the function pointer array is null, get the functions - we will
        call init once per replication agreement, but will only grab the
@@ -884,9 +884,9 @@ windows_plugin_init(Repl_Agmt *ra)
        (slapi_apib_get_interface(WINSYNC_v1_0_GUID, &_WinSyncAPI) ||
         (NULL == _WinSyncAPI)))
 	{
-        LDAPDebug( LDAP_DEBUG_PLUGIN,
+        LDAPDebug1Arg( LDAP_DEBUG_PLUGIN,
                    "<-- windows_plugin_init_start -- no windows plugin API registered for GUID [%s] -- end\n",
-                   WINSYNC_v1_0_GUID,0,0);
+                   WINSYNC_v1_0_GUID);
         return;
 	}
 
@@ -897,7 +897,7 @@ windows_plugin_init(Repl_Agmt *ra)
     }
     windows_private_set_api_cookie(ra, cookie);
 
-	LDAPDebug( LDAP_DEBUG_PLUGIN, "<-- windows_plugin_init_start -- end\n",0,0,0);
+	LDAPDebug0Args( LDAP_DEBUG_PLUGIN, "<-- windows_plugin_init_start -- end\n");
     return;
 }
 

ldap/servers/plugins/replication/windows_protocol_util.c

@@ -1287,7 +1287,7 @@ windows_replay_update(Private_Repl_Protocol *prp, slapi_operation_parameters *op
 			break;
 		default:
 			slapi_log_error(SLAPI_LOG_FATAL, windows_repl_plugin_name, "%s: replay_update: Unknown "
-				"operation type %d found in changelog - skipping change.\n",
+				"operation type %lu found in changelog - skipping change.\n",
 				agmt_get_long_name(prp->agmt), op->operation_type);
 		}
 		if (password) 
@@ -3878,7 +3878,7 @@ windows_process_dirsync_entry(Private_Repl_Protocol *prp,Slapi_Entry *e, int is_
 				/* We should have been able to map the DN, so this is an error */
 				slapi_log_error(SLAPI_LOG_REPL, windows_repl_plugin_name,
 								"%s: windows_process_dirsync_entry: failed to map "
-								"inbound entry %s - rc is %d dn is [%d].\n",
+								"inbound entry %s - rc is %d dn is [%s].\n",
 								agmt_get_long_name(prp->agmt),
 								slapi_sdn_get_dn(slapi_entry_get_sdn_const(e)),
 								rc,

ldap/servers/plugins/replication/windows_tot_protocol.c

@@ -109,7 +109,7 @@ windows_tot_run(Private_Repl_Protocol *prp)
 	char **attrs = NULL;
 	LDAPControl **server_controls = NULL;
 	
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_tot_run\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_tot_run\n" );
 	
 	PR_ASSERT(NULL != prp);
 
@@ -218,7 +218,7 @@ windows_tot_run(Private_Repl_Protocol *prp)
 		agmt_set_last_init_status(prp->agmt, rc, 0, "Total update aborted");
     } else {
 		slapi_log_error(SLAPI_LOG_FATAL, windows_repl_plugin_name, "Finished total update of replica "
-						"\"%s\". Sent %d entries.\n", agmt_get_long_name(prp->agmt), cb_data.num_entries);
+						"\"%s\". Sent %lu entries.\n", agmt_get_long_name(prp->agmt), cb_data.num_entries);
 		agmt_set_last_init_status(prp->agmt, 0, 0, "Total update succeeded");
 		/* Now update our consumer RUV for this agreement.
 		 * This ensures that future incrememental updates work.
@@ -244,7 +244,7 @@ done:
 	}
 	
 	prp->stopped = 1;
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_tot_run\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_tot_run\n" );
 }
 
 static int
@@ -254,7 +254,7 @@ windows_tot_stop(Private_Repl_Protocol *prp)
 	int seconds = 600;
 	PRIntervalTime start, maxwait, now;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_tot_stop\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_tot_stop\n" );
 
 	prp->terminate = 1;
 	maxwait = PR_SecondsToInterval(seconds);
@@ -280,7 +280,7 @@ windows_tot_stop(Private_Repl_Protocol *prp)
 		return_value = 0;
 	}
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_tot_stop\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_tot_stop\n" );
 
 	return return_value;
 }
@@ -291,8 +291,8 @@ static int
 windows_tot_status(Private_Repl_Protocol *prp)
 {
 	int return_value = 0;
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_tot_status\n", 0, 0, 0 );
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_tot_status\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_tot_status\n" );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_tot_status\n" );
 	return return_value;
 }
 
@@ -301,8 +301,8 @@ windows_tot_status(Private_Repl_Protocol *prp)
 static void
 windows_tot_noop(Private_Repl_Protocol *prp)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_tot_noop\n", 0, 0, 0 );
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_tot_noop\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_tot_noop\n" );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_tot_noop\n" );
 	/* noop */
 }
 
@@ -313,7 +313,7 @@ Windows_Tot_Protocol_new(Repl_Protocol *rp)
 	windows_tot_private *rip = NULL;
 	Private_Repl_Protocol *prp = (Private_Repl_Protocol *)slapi_ch_malloc(sizeof(Private_Repl_Protocol));
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> Windows_Tot_Protocol_new\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> Windows_Tot_Protocol_new\n" );
 
 	prp->delete = windows_tot_delete;
 	prp->run = windows_tot_run;
@@ -342,28 +342,28 @@ Windows_Tot_Protocol_new(Repl_Protocol *rp)
 	rip->rp = rp;
 	prp->private = (void *)rip;
     prp->replica_acquired = PR_FALSE;
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= Windows_Tot_Protocol_new\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= Windows_Tot_Protocol_new\n" );
 	return prp;
 loser:
 	windows_tot_delete(&prp);
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= Windows_Tot_Protocol_new - loser\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= Windows_Tot_Protocol_new - loser\n" );
 	return NULL;
 }
 
 static void
 windows_tot_delete(Private_Repl_Protocol **prp)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> windows_tot_delete\n", 0, 0, 0 );
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= windows_tot_delete\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> windows_tot_delete\n" );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= windows_tot_delete\n" );
 }
 
 static 
 void get_result (int rc, void *cb_data)
 {
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> get_result\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> get_result\n" );
     PR_ASSERT (cb_data);
     ((callback_data*)cb_data)->rc = rc;
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= get_result\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= get_result\n" );
 }
 
 static 
@@ -373,7 +373,7 @@ int send_entry (Slapi_Entry *e, void *cb_data)
     Private_Repl_Protocol *prp;
 	unsigned long *num_entriesp;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "=> send_entry\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "=> send_entry\n" );
 
     PR_ASSERT (cb_data);
 
@@ -386,13 +386,13 @@ int send_entry (Slapi_Entry *e, void *cb_data)
         conn_disconnect(prp->conn);
         prp->stopped = 1;
 		((callback_data*)cb_data)->rc = -1;
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= send_entry\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= send_entry\n" );
 		return -1;    
     }
 
     /* skip ruv tombstone - not relvant to Active Directory */
     if (is_ruv_tombstone_entry (e)) {
-		LDAPDebug( LDAP_DEBUG_TRACE, "<= send_entry\n", 0, 0, 0 );
+		LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= send_entry\n" );
         return 0;
 	}
 
@@ -401,7 +401,7 @@ int send_entry (Slapi_Entry *e, void *cb_data)
 	
 	(*num_entriesp)++;
 
-	LDAPDebug( LDAP_DEBUG_TRACE, "<= send_entry\n", 0, 0, 0 );
+	LDAPDebug0Args( LDAP_DEBUG_TRACE, "<= send_entry\n" );
 
 	if (CONN_OPERATION_SUCCESS == rc) {
 		return 0;

ldap/servers/plugins/retrocl/retrocl.c

@@ -221,8 +221,8 @@ static int retrocl_select_backend(void)
     operation_free(&op,NULL);
 
     if (err != LDAP_SUCCESS || be == NULL || be == defbackend_get_backend()) {
-        LDAPDebug(LDAP_DEBUG_TRACE,"Mapping tree select failed (%d) %s.\n",
-		  err,errbuf,0);
+        LDAPDebug2Args(LDAP_DEBUG_TRACE,"Mapping tree select failed (%d) %s.\n",
+		  err,errbuf);
 	
 	/* could not find the backend for cn=changelog, either because
 	 * it doesn't exist
@@ -307,7 +307,7 @@ static int retrocl_start (Slapi_PBlock *pb)
       if (rc == 0) {
 	retrocl_init_trimming();
       } else {
-	LDAPDebug(LDAP_DEBUG_TRACE,"Couldnt find backend, not trimming retro changelog (%d).\n",rc,0,0);
+	LDAPDebug1Arg(LDAP_DEBUG_TRACE,"Couldnt find backend, not trimming retro changelog (%d).\n",rc);
       }
     }
    

ldap/servers/plugins/retrocl/retrocl_cn.c

@@ -181,7 +181,7 @@ int retrocl_get_changenumbers(void)
 
     retrocl_internal_cn = cr.cr_cnum;
     
-    slapi_log_error(SLAPI_LOG_PLUGIN,"retrocl","Got changenumbers %d and %d\n",
+    slapi_log_error(SLAPI_LOG_PLUGIN,"retrocl","Got changenumbers %lu and %lu\n",
 		    retrocl_first_cn,
 		    retrocl_internal_cn);
 
@@ -379,7 +379,7 @@ int retrocl_update_lastchangenumber(void)
 
 
     retrocl_internal_cn = cr.cr_cnum;
-    slapi_log_error(SLAPI_LOG_PLUGIN,"retrocl","Refetched last changenumber =  %d \n",
+    slapi_log_error(SLAPI_LOG_PLUGIN,"retrocl","Refetched last changenumber =  %lu \n",
             retrocl_internal_cn);
 
     slapi_ch_free(( void **) &cr.cr_time );

ldap/servers/plugins/retrocl/retrocl_po.c

@@ -179,7 +179,7 @@ write_replog_db(
    
     PR_ASSERT( changenum > 0UL );
     slapi_log_error( SLAPI_LOG_PLUGIN, RETROCL_PLUGIN_NAME,
-	    "write_replog_db: write change record %d for dn: \"%s\"\n", 
+	    "write_replog_db: write change record %lu for dn: \"%s\"\n", 
 	    changenum, ( dn == NULL ) ? "NULL" : dn );
 
     /* Construct the dn of this change record */
@@ -271,7 +271,7 @@ write_replog_db(
 	if ( 0 != rc ) {
 	    slapi_log_error( SLAPI_LOG_FATAL, RETROCL_PLUGIN_NAME,
 			     "replog: an error occured while adding change "
-			     "number %d, dn = %s: %s. \n",
+			     "number %lu, dn = %s: %s. \n",
 			     changenum, edn, ldap_err2string( rc ));
 	    retrocl_release_changenumber();
 	} else {
@@ -484,27 +484,24 @@ int retrocl_postob (Slapi_PBlock *pb,int optype)
     (void)slapi_pblock_get( pb, SLAPI_BACKEND, &be );
     
     if (slapi_be_logchanges(be) == 0) {
-        LDAPDebug(LDAP_DEBUG_TRACE,"not applying change if not logging\n",
-		  0,0,0);
+        LDAPDebug0Args(LDAP_DEBUG_TRACE,"not applying change if not logging\n");
 	return 0;
     }
     
     if (retrocl_be_changelog == NULL || be == retrocl_be_changelog) {
-        LDAPDebug(LDAP_DEBUG_TRACE,"not applying change if no/cl be\n",0,0,0);
+        LDAPDebug0Args(LDAP_DEBUG_TRACE,"not applying change if no/cl be\n");
 	return 0;
     }
 
     slapi_pblock_get(pb, SLAPI_RESULT_CODE, &rc);
 
     if (rc != LDAP_SUCCESS) {
-        LDAPDebug(LDAP_DEBUG_TRACE,"not applying change if op failed %d\n",rc,
-		  0,0);
+        LDAPDebug1Arg(LDAP_DEBUG_TRACE,"not applying change if op failed %d\n",rc);
 	return 0;
     }
 
     if (slapi_op_abandoned(pb)) {
-        LDAPDebug(LDAP_DEBUG_PLUGIN,"not applying change if op abandoned\n",
-		  0,0,0);
+        LDAPDebug0Args(LDAP_DEBUG_PLUGIN,"not applying change if op abandoned\n");
 	return 0;
     }
 
@@ -519,12 +516,12 @@ int retrocl_postob (Slapi_PBlock *pb,int optype)
     slapi_pblock_get( pb, SLAPI_OPERATION, &op );
 
     if (op == NULL) {
-        LDAPDebug(LDAP_DEBUG_TRACE,"not applying change if no op\n",0,0,0);
+        LDAPDebug0Args(LDAP_DEBUG_TRACE,"not applying change if no op\n");
         return 0;
     }
 
 	if (operation_is_flag_set(op, OP_FLAG_TOMBSTONE_ENTRY)){
-        LDAPDebug(LDAP_DEBUG_TRACE,"not applying change for nsTombstone entries\n",0,0,0);
+        LDAPDebug0Args(LDAP_DEBUG_TRACE,"not applying change for nsTombstone entries\n");
         return 0;
 	}
 	

ldap/servers/plugins/retrocl/retrocl_trim.c

@@ -119,7 +119,7 @@ delete_changerecord( changeNumber cnum )
     
     if ( delrc != LDAP_SUCCESS ) {
 	slapi_log_error( SLAPI_LOG_FATAL, RETROCL_PLUGIN_NAME, "delete_changerecord: could not delete "
-		"change record %d\n", cnum );
+		"change record %lu\n", cnum );
     } else {
 	slapi_log_error( SLAPI_LOG_PLUGIN, RETROCL_PLUGIN_NAME,
 		"delete_changerecord: deleted changelog entry \"%s\"\n", dnbuf);
@@ -312,7 +312,7 @@ static int trim_changelog(void)
 	    }
 	}
     } else {
-       LDAPDebug(LDAP_DEBUG_PLUGIN, "not yet time to trim: %d < (%d+%d)\n",
+       LDAPDebug(LDAP_DEBUG_PLUGIN, "not yet time to trim: %ld < (%d+%d)\n",
 		 now,lt,(CHANGELOGDB_TRIM_INTERVAL/1000));
     }
     PR_Lock( ts.ts_s_trim_mutex );
@@ -366,7 +366,7 @@ void retrocl_housekeeping ( time_t cur_time, void *noarg )
     int			ldrc;
 
     if (retrocl_be_changelog == NULL) {
-        LDAPDebug(LDAP_DEBUG_TRACE,"not housekeeping if no cl be\n",0,0,0);
+        LDAPDebug0Args(LDAP_DEBUG_TRACE,"not housekeeping if no cl be\n");
 	return;
     }
 
@@ -391,7 +391,7 @@ void retrocl_housekeeping ( time_t cur_time, void *noarg )
 		 */
 		first_time = retrocl_getchangetime( SLAPI_SEQ_FIRST, &ldrc );
 		LDAPDebug(LDAP_DEBUG_PLUGIN,
-			  "cltrim: ldrc=%d, first_time=%d, cur_time=%d\n",
+			  "cltrim: ldrc=%d, first_time=%ld, cur_time=%ld\n",
 			  ldrc,first_time,cur_time);
 		if ( LDAP_SUCCESS == ldrc && first_time > (time_t) 0L &&
 		     first_time + ts.ts_c_max_age < cur_time ) {
@@ -399,7 +399,7 @@ void retrocl_housekeeping ( time_t cur_time, void *noarg )
 		}
 	}
 	if ( must_trim ) {
-	    LDAPDebug(LDAP_DEBUG_TRACE,"changelog about to create thread\n",0,0,0);
+	    LDAPDebug0Args(LDAP_DEBUG_TRACE,"changelog about to create thread\n");
 	    /* Start a thread to trim the changelog */
 	    ts.ts_s_trimming = 1;
 	    if ( PR_CreateThread( PR_USER_THREAD,
@@ -409,8 +409,8 @@ void retrocl_housekeeping ( time_t cur_time, void *noarg )
 		slapi_log_error( SLAPI_LOG_FATAL, RETROCL_PLUGIN_NAME, "unable to create changelog trimming thread\n" );
 	    }
 	} else {
-	    LDAPDebug(LDAP_DEBUG_PLUGIN,
-		      "changelog does not need to be trimmed\n",0,0,0);
+	    LDAPDebug0Args(LDAP_DEBUG_PLUGIN,
+		      "changelog does not need to be trimmed\n");
 	}
     }
     PR_Unlock( ts.ts_s_trim_mutex );
@@ -491,7 +491,7 @@ void retrocl_init_trimming (void)
     cl_maxage = retrocl_get_config_str(CONFIG_CHANGELOG_MAXAGE_ATTRIBUTE);
     
     if (cl_maxage == NULL) {
-      LDAPDebug(LDAP_DEBUG_TRACE,"No maxage, not trimming retro changelog.\n",0,0,0);
+      LDAPDebug0Args(LDAP_DEBUG_TRACE,"No maxage, not trimming retro changelog.\n");
       return;
     }
     ageval = age_str2time (cl_maxage);

ldap/servers/plugins/roles/roles_cache.c

@@ -559,7 +559,7 @@ static void roles_cache_trigger_update_role(char *dn, Slapi_Entry *roles_entry,
 	current_role = roles_list;
 
 	slapi_log_error( SLAPI_LOG_PLUGIN, 
-					ROLES_PLUGIN_SUBSYSTEM, "--> roles_cache_trigger_update_role: %x \n", roles_list);
+					ROLES_PLUGIN_SUBSYSTEM, "--> roles_cache_trigger_update_role: %p \n", roles_list);
 
 	/* Go through all the roles list and trigger the associated structure */
 		
@@ -593,7 +593,7 @@ static void roles_cache_trigger_update_role(char *dn, Slapi_Entry *roles_entry,
 
 	PR_RWLock_Unlock(global_lock);
 
-	slapi_log_error( SLAPI_LOG_PLUGIN, ROLES_PLUGIN_SUBSYSTEM, "<-- roles_cache_trigger_update_role: %x \n", roles_list);
+	slapi_log_error( SLAPI_LOG_PLUGIN, ROLES_PLUGIN_SUBSYSTEM, "<-- roles_cache_trigger_update_role: %p \n", roles_list);
 }
 
 /* roles_cache_update
@@ -1066,14 +1066,14 @@ static int roles_cache_create_role_under(roles_cache_def** roles_cache_suffix, S
 	role_object *new_role = NULL; 
 
     slapi_log_error(SLAPI_LOG_PLUGIN,
-                    ROLES_PLUGIN_SUBSYSTEM, "--> roles_cache_create_role_under: %s - %x\n",
+                    ROLES_PLUGIN_SUBSYSTEM, "--> roles_cache_create_role_under: %s - %p\n",
                     slapi_sdn_get_dn((*roles_cache_suffix)->suffix_dn),
                     (*roles_cache_suffix)->avl_tree);
 
 	rc = roles_cache_create_object_from_entry(entry,&new_role,0);
 	slapi_log_error(SLAPI_LOG_PLUGIN, 
 					ROLES_PLUGIN_SUBSYSTEM, 
-					"roles_cache_create_role_under: create node for entry %s - rc: %d SUFFIX: %x\n", 
+					"roles_cache_create_role_under: create node for entry %s - rc: %d SUFFIX: %p\n", 
 					slapi_entry_get_dn_const(entry), rc, (*roles_cache_suffix)->avl_tree);
 
 	if ( (rc == 0) && new_role) 
@@ -1081,7 +1081,7 @@ static int roles_cache_create_role_under(roles_cache_def** roles_cache_suffix, S
 		/* Add to the tree where avl_data is a role_object struct */
 		rc = roles_cache_insert_object(&((*roles_cache_suffix)->avl_tree),new_role);  
 		slapi_log_error(SLAPI_LOG_PLUGIN, 
-						ROLES_PLUGIN_SUBSYSTEM, "roles_cache_create_role_under:%s in tree %x rc: %d\n", 
+						ROLES_PLUGIN_SUBSYSTEM, "roles_cache_create_role_under:%s in tree %p rc: %d\n", 
 						(char*)slapi_sdn_get_ndn(new_role->dn),
 						(*roles_cache_suffix)->avl_tree, rc);
 	}
@@ -1351,7 +1351,7 @@ static int roles_cache_insert_object(Avlnode **tree, role_object *object)
 {
 
 	slapi_log_error(SLAPI_LOG_PLUGIN, 
-					ROLES_PLUGIN_SUBSYSTEM, "roles_cache_insert_object: %s in tree %x\n", 
+					ROLES_PLUGIN_SUBSYSTEM, "roles_cache_insert_object: %s in tree %p\n", 
 					(char*)slapi_sdn_get_ndn(object->dn),
 					*tree);
 	return (avl_insert(tree, (caddr_t)object, roles_cache_node_cmp, avl_dup_error));
@@ -1381,7 +1381,7 @@ static int roles_cache_node_nested_cmp( caddr_t d1, caddr_t d2 )
 static int roles_cache_insert_object_nested(Avlnode **tree, role_object_nested *object)
 {
 	slapi_log_error(SLAPI_LOG_PLUGIN, 
-					ROLES_PLUGIN_SUBSYSTEM, "roles_cache_insert_object_nested: %s in tree %x: \n", 
+					ROLES_PLUGIN_SUBSYSTEM, "roles_cache_insert_object_nested: %s in tree %p: \n", 
 					(char*)slapi_sdn_get_ndn(object->dn), *tree);
 
 	return (avl_insert(tree, (caddr_t)object, roles_cache_node_nested_cmp, avl_dup_error));
@@ -2106,7 +2106,7 @@ static int roles_cache_dump( caddr_t data, caddr_t arg )
     role_object *this_role = (role_object*)data;
  
 	slapi_log_error(SLAPI_LOG_PLUGIN, 
-					ROLES_PLUGIN_SUBSYSTEM, "roles_cache_dump: %x - %s - %x\n", 
+					ROLES_PLUGIN_SUBSYSTEM, "roles_cache_dump: %p - %s - %p\n", 
 					this_role, (char*)slapi_sdn_get_ndn(this_role->dn), this_role->avl_tree);
 	
     return 0;

ldap/servers/slapd/abandon.c

@@ -153,15 +153,15 @@ do_abandon( Slapi_PBlock *pb )
 	}
 
 	if ( NULL == o ) {
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d ABANDON"
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d ABANDON"
 			" targetop=NOTFOUND msgid=%d\n",
 			pb->pb_conn->c_connid, pb->pb_op->o_opid, id );
 	} else if ( suppressed_by_plugin ) {
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64"  op=%d ABANDON"
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d ABANDON"
 			" targetop=SUPPRESSED-BY-PLUGIN msgid=%d\n",
 			pb->pb_conn->c_connid, pb->pb_op->o_opid, id );
 	} else {
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d ABANDON"
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d ABANDON"
 			" targetop=%d msgid=%d nentries=%d etime=%ld\n",
 			pb->pb_conn->c_connid, pb->pb_op->o_opid, o->o_opid, id,
 			o->o_results.r.r_search.nentries, current_time() - o->o_time );

ldap/servers/slapd/add.c

@@ -166,7 +166,7 @@ do_add( Slapi_PBlock *pb )
 			if (( rc = slapi_entry_add_values( e, normtype, vals ))
 				!= LDAP_SUCCESS ) {
 				slapi_log_access( LDAP_DEBUG_STATS, 
-					"conn=%" PRIu64 " op=%d ADD dn=\"%s\", add values for type %s failed\n",
+					"conn=%" NSPRIu64 " op=%d ADD dn=\"%s\", add values for type %s failed\n",
 					pb->pb_conn->c_connid, operation->o_opid, 
 					escape_string( slapi_entry_get_dn_const(e), ebuf ), normtype );
 				send_ldap_result( pb, rc, NULL, NULL, 0, NULL );
@@ -432,7 +432,7 @@ static void op_shared_add (Slapi_PBlock *pb)
 	{
 		if ( !internal_op )
 		{
-			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d ADD dn=\"%s\"\n",
+			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d ADD dn=\"%s\"\n",
 							 pb->pb_conn->c_connid, 
 							 operation->o_opid,
 							 escape_string(slapi_entry_get_dn_const(e), ebuf));

ldap/servers/slapd/auth.c

@@ -391,7 +391,7 @@ handle_bad_certificate (void* clientData, PRFileDesc *prfd)
     char* subject = subject_of (clientCert);
     char* issuer  = issuer_of  (clientCert);
     slapi_log_access( LDAP_DEBUG_STATS,
-	       "conn=%" PRIu64 " " SLAPI_COMPONENT_NAME_NSPR " error %i (%s); unauthenticated client %s; issuer %s\n",
+	       "conn=%" NSPRIu64 " " SLAPI_COMPONENT_NAME_NSPR " error %i (%s); unauthenticated client %s; issuer %s\n",
 	       conn->c_connid, errorCode, slapd_pr_strerror(errorCode),
 	       subject ? escape_string( subject, sbuf ) : "NULL",
 	       issuer  ? escape_string( issuer,  ibuf ) : "NULL" );
@@ -425,7 +425,7 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
 	if ( (slapd_ssl_getChannelInfo (prfd, &channelInfo, sizeof(channelInfo))) != SECSuccess ) {
 		PRErrorCode errorCode = PR_GetError();
 		slapi_log_access (LDAP_DEBUG_STATS,
-			"conn=%" PRIu64 " SSL failed to obtain channel info; "
+			"conn=%" NSPRIu64 " SSL failed to obtain channel info; "
 			SLAPI_COMPONENT_NAME_NSPR " error %i (%s)\n",
 			conn->c_connid, errorCode, slapd_pr_strerror(errorCode));
 		return;
@@ -434,7 +434,7 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
 			!= SECSuccess) {
 		PRErrorCode errorCode = PR_GetError();
 		slapi_log_access (LDAP_DEBUG_STATS,
-			"conn=%" PRIu64 " SSL failed to obtain cipher info; "
+			"conn=%" NSPRIu64 " SSL failed to obtain cipher info; "
 			SLAPI_COMPONENT_NAME_NSPR " error %i (%s)\n",
 			conn->c_connid, errorCode, slapd_pr_strerror(errorCode));
 		return;
@@ -455,13 +455,13 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
     }
 
     if (config_get_SSLclientAuth() == SLAPD_SSLCLIENTAUTH_OFF ) {
-		slapi_log_access (LDAP_DEBUG_STATS, "conn=%" PRIu64 " SSL %i-bit %s\n",
+		slapi_log_access (LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " SSL %i-bit %s\n",
 		   		conn->c_connid, keySize, cipher ? cipher : "NULL" );
 		slapi_ch_free_string(&cipher);
 		return;
     } 
     if (clientCert == NULL) {
-	slapi_log_access (LDAP_DEBUG_STATS, "conn=%" PRIu64 " SSL %i-bit %s\n",
+	slapi_log_access (LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " SSL %i-bit %s\n",
 		   conn->c_connid, keySize, cipher ? cipher : "NULL" );
     } else {
 	char* subject = subject_of (clientCert);
@@ -469,7 +469,7 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
 	    char* issuer  = issuer_of (clientCert);
 	    char sbuf[ BUFSIZ ], ibuf[ BUFSIZ ];
 	    slapi_log_access( LDAP_DEBUG_STATS,
-		       "conn=%" PRIu64 " SSL %i-bit %s; client %s; issuer %s\n",
+		       "conn=%" NSPRIu64 " SSL %i-bit %s; client %s; issuer %s\n",
 		       conn->c_connid, keySize, cipher ? cipher : "NULL",
 		       subject ? escape_string( subject, sbuf ) : "NULL",
 		       issuer  ? escape_string( issuer,  ibuf ) : "NULL");
@@ -507,11 +507,11 @@ handle_handshake_done (PRFileDesc *prfd, void* clientData)
 
     if (clientDN != NULL) {
         char ebuf[ BUFSIZ ];
-        slapi_log_access (LDAP_DEBUG_STATS, "conn=%" PRIu64 " SSL client bound as %s\n",
+        slapi_log_access (LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " SSL client bound as %s\n",
     	       conn->c_connid, escape_string( clientDN, ebuf ));
     } else if (clientCert != NULL) {
         slapi_log_access (LDAP_DEBUG_STATS,
-		"conn=%" PRIu64 " SSL failed to map client certificate to LDAP DN (%s)\n",
+		"conn=%" NSPRIu64 " SSL failed to map client certificate to LDAP DN (%s)\n",
     	       conn->c_connid, extraErrorMsg );
     }
 

ldap/servers/slapd/back-ldbm/dbverify.c

@@ -66,7 +66,7 @@ dbverify_ext( ldbm_instance *inst, int verbose )
     {
         slapi_log_error(SLAPI_LOG_FATAL, "DB verify",
                         "db path too long: %s/%s\n",
-                         inst->inst_parent_dir_name, inst->inst_dir_name, 0);
+                         inst->inst_parent_dir_name, inst->inst_dir_name);
         return 1;
     }
     tmplen = strlen(dbdir);
@@ -99,8 +99,8 @@ dbverify_ext( ldbm_instance *inst, int verbose )
         if (sizeof(direntry->name) + 2 > filelen)
         {
             slapi_log_error(SLAPI_LOG_FATAL, "DB verify",
-                                        "db path too long: %s/%s%s\n",
-                                         dbdir, direntry->name, 0);
+                                        "db path too long: %s/%s\n",
+                                         dbdir, direntry->name);
             continue;
         }
         PR_snprintf(filep, filelen, "/%s", direntry->name);

ldap/servers/slapd/back-ldbm/ldbm_delete.c

@@ -93,7 +93,7 @@ ldbm_back_delete( Slapi_PBlock *pb )
 	
 	if (pb->pb_conn)
 	{
-		slapi_log_error (SLAPI_LOG_TRACE, "ldbm_back_delete", "enter conn=%" PRIu64 " op=%d\n", pb->pb_conn->c_connid, operation->o_opid);
+		slapi_log_error (SLAPI_LOG_TRACE, "ldbm_back_delete", "enter conn=%" NSPRIu64 " op=%d\n", pb->pb_conn->c_connid, operation->o_opid);
 	}
 
 	is_fixup_operation = operation_is_flag_set(operation, OP_FLAG_REPL_FIXUP);
@@ -666,7 +666,7 @@ diskfull_return:
 	slapi_ch_free_string(&e_uniqueid);
 	if (pb->pb_conn)
 	{
-		slapi_log_error (SLAPI_LOG_TRACE, "ldbm_back_delete", "leave conn=%" PRIu64 " op=%d\n", pb->pb_conn->c_connid, operation->o_opid);
+		slapi_log_error (SLAPI_LOG_TRACE, "ldbm_back_delete", "leave conn=%" NSPRIu64 " op=%d\n", pb->pb_conn->c_connid, operation->o_opid);
 	}
 	return rc;
 }

ldap/servers/slapd/back-ldbm/ldbm_modrdn.c

@@ -117,7 +117,7 @@ ldbm_back_modrdn( Slapi_PBlock *pb )
 
 	if (pb->pb_conn)
 	{
-		slapi_log_error (SLAPI_LOG_TRACE, "ldbm_back_modrdn", "enter conn=%" PRIu64 " op=%d\n", pb->pb_conn->c_connid, operation->o_opid);
+		slapi_log_error (SLAPI_LOG_TRACE, "ldbm_back_modrdn", "enter conn=%" NSPRIu64 " op=%d\n", pb->pb_conn->c_connid, operation->o_opid);
 	}
 
 	inst = (ldbm_instance *) be->be_instance_info;
@@ -862,7 +862,7 @@ common_return:
     slapi_pblock_set( pb, SLAPI_ENTRY_POST_OP, postentry );
 	if (pb->pb_conn)
 	{
-		slapi_log_error (SLAPI_LOG_TRACE, "ldbm_back_modrdn", "leave conn=%" PRIu64 " op=%d\n", pb->pb_conn->c_connid, operation->o_opid);
+		slapi_log_error (SLAPI_LOG_TRACE, "ldbm_back_modrdn", "leave conn=%" NSPRIu64 " op=%d\n", pb->pb_conn->c_connid, operation->o_opid);
 	}
 	return retval;
 }

ldap/servers/slapd/back-ldbm/ldif2ldbm.c

@@ -679,7 +679,7 @@ static IDList *ldbm_fetch_subtrees(backend *be, char **include, int *err)
     /* for each subtree spec... */
     for (i = 0; include[i]; i++) {
         IDList *idl = NULL;
-        char *suffix = slapi_sdn_get_ndn(*be->be_suffix);
+        const char *suffix = slapi_sdn_get_ndn(*be->be_suffix);
         char *parentdn = slapi_ch_strdup(suffix);
         char *nextdn = NULL;
         int matched = 0;
@@ -695,7 +695,7 @@ static IDList *ldbm_fetch_subtrees(backend *be, char **include, int *err)
         while (NULL != parentdn &&
                NULL != (nextdn = slapi_dn_parent( parentdn ))) {
             slapi_ch_free_string( &parentdn );
-            if (0 == slapi_utf8casecmp(nextdn, include[i])) {
+            if (0 == slapi_UTF8CASECMP(nextdn, include[i])) {
                 issubsuffix = 1; /* suffix of be is a subsuffix of include[i] */
                 break;
             }
@@ -719,7 +719,7 @@ static IDList *ldbm_fetch_subtrees(backend *be, char **include, int *err)
         while (NULL != parentdn &&
                NULL != (nextdn = slapi_dn_parent( parentdn ))) {
             slapi_ch_free_string( &parentdn );
-            if (0 == slapi_utf8casecmp(nextdn, suffix)) {
+            if (0 == slapi_UTF8CASECMP(nextdn, (char *)suffix)) {
                 matched = 1;
                 break;
             }
@@ -2458,7 +2458,7 @@ int upgradedb_delete_indices_4cmd(ldbm_instance *inst)
                                                 inst_dir, MAXPATHLEN);
 
     slapi_log_error(SLAPI_LOG_TRACE, "upgrade DB",
-                    "upgradedb_delete_indices_4cmd: %s\n");
+                    "upgradedb_delete_indices_4cmd: %s\n", inst_dir);
     dirhandle = PR_OpenDir(inst_dirp);
     if (!dirhandle)
     {

ldap/servers/slapd/back-ldbm/misc.c

@@ -81,7 +81,7 @@ void ldbm_log_access_message(Slapi_PBlock *pblock,char *string)
         return;
     }
     operation_id = operation->o_opid;
-    slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d %s\n",connection_id, operation_id,string);
+    slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d %s\n",connection_id, operation_id,string);
 }
 
 int return_on_disk_full(struct ldbminfo  *li)

ldap/servers/slapd/bind.c

@@ -694,25 +694,25 @@ log_bind_access (
 
     if (method == LDAP_AUTH_SASL && saslmech && msg) {
         slapi_log_access( LDAP_DEBUG_STATS, 
-                          "conn=%" PRIu64 " op=%d BIND dn=\"%s\" "
+                          "conn=%" NSPRIu64 " op=%d BIND dn=\"%s\" "
                           "method=sasl version=%d mech=%s, %s\n",
                           pb->pb_conn->c_connid, pb->pb_op->o_opid, edn, 
                           version, saslmech, msg );
     } else if (method == LDAP_AUTH_SASL && saslmech) {
         slapi_log_access( LDAP_DEBUG_STATS, 
-                          "conn=%" PRIu64 " op=%d BIND dn=\"%s\" "
+                          "conn=%" NSPRIu64 " op=%d BIND dn=\"%s\" "
                           "method=sasl version=%d mech=%s\n",
                           pb->pb_conn->c_connid, pb->pb_op->o_opid, edn, 
                           version, saslmech );
     } else if (msg) {
         slapi_log_access( LDAP_DEBUG_STATS, 
-                          "conn=%" PRIu64 " op=%d BIND dn=\"%s\" "
+                          "conn=%" NSPRIu64 " op=%d BIND dn=\"%s\" "
                           "method=%d version=%d, %s\n",
                           pb->pb_conn->c_connid, pb->pb_op->o_opid, edn, 
                           method, version, msg );
     } else {
         slapi_log_access( LDAP_DEBUG_STATS, 
-                          "conn=%" PRIu64 " op=%d BIND dn=\"%s\" "
+                          "conn=%" NSPRIu64 " op=%d BIND dn=\"%s\" "
                           "method=%d version=%d\n",
                           pb->pb_conn->c_connid, pb->pb_op->o_opid, edn, 
                           method, version );

ldap/servers/slapd/compare.c

@@ -122,7 +122,7 @@ do_compare( Slapi_PBlock *pb )
 	    dn, ava.ava_type, 0 );
 
 	slapi_log_access( LDAP_DEBUG_STATS,
-	    "conn=%" PRIu64 " op=%d CMP dn=\"%s\" attr=\"%s\"\n",
+	    "conn=%" NSPRIu64 " op=%d CMP dn=\"%s\" attr=\"%s\"\n",
 	    pb->pb_conn->c_connid, pb->pb_op->o_opid,
 	    escape_string( dn, ebuf ), ava.ava_type );
 

ldap/servers/slapd/config.c

@@ -126,7 +126,7 @@ entry_has_attr_and_value(Slapi_Entry *e, const char *attrname,
 						slapi_log_error( SLAPI_LOG_FATAL, "bootstrap config",
 								"Ignoring extremely large value for"
 								" configuration attribute %s"
-								" (length=%d, value=%40.40s...)\n",
+								" (length=%ld, value=%40.40s...)\n",
 								attrname, len, s );
 						retval = 0;	/* value is too large: ignore it */
 					}

ldap/servers/slapd/connection.c

@@ -352,7 +352,7 @@ connection_reset(Connection* conn, int ns, PRNetAddr * from, int fromLen, int is
 
     /* log useful stuff to our access log */
     slapi_log_access( LDAP_DEBUG_STATS,
-	    "conn=%" PRIu64 " fd=%d slot=%d %sconnection from %s to %s\n",
+	    "conn=%" NSPRIu64 " fd=%d slot=%d %sconnection from %s to %s\n",
 	    conn->c_connid, conn->c_sd, ns, pTmp, str_ip, str_destip );
 
     /* initialize the remaining connection fields */
@@ -452,7 +452,7 @@ connection_need_new_password(const Connection *conn, const Operation *op, Slapi_
 		op->o_tag != LDAP_REQ_ABANDON )
 	{
 		slapi_add_pwd_control ( pb, LDAP_CONTROL_PWEXPIRED, 0);	
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d %s\n",
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d %s\n",
            	pb->pb_conn->c_connid, pb->pb_op->o_opid, 
 			"need new password" );
 		send_ldap_result( pb, LDAP_UNWILLING_TO_PERFORM, 
@@ -522,7 +522,7 @@ connection_dispatch_operation(Connection *conn, Operation *op, Slapi_PBlock *pb)
 		{
 			ret = setsockopt(conn->c_sd,IPPROTO_TCP,TCP_CORK,&i,sizeof(i));
 			if (ret < 0) {
-				LDAPDebug(LDAP_DEBUG_ANY, "Failed to set TCP_CORK on connection %" PRIu64 "\n",conn->c_connid, 0, 0);
+				LDAPDebug(LDAP_DEBUG_ANY, "Failed to set TCP_CORK on connection %" NSPRIu64 "\n",conn->c_connid, 0, 0);
 			}
 		}
 #endif
@@ -536,7 +536,7 @@ connection_dispatch_operation(Connection *conn, Operation *op, Slapi_PBlock *pb)
 		{
 			ret = setsockopt(conn->c_sd,IPPROTO_TCP,TCP_CORK,&i,sizeof(i));
 			if (ret < 0) {
-				LDAPDebug(LDAP_DEBUG_ANY, "Failed to clear TCP_CORK on connection %" PRIu64 "\n",conn->c_connid, 0, 0);
+				LDAPDebug(LDAP_DEBUG_ANY, "Failed to clear TCP_CORK on connection %" NSPRIu64 "\n",conn->c_connid, 0, 0);
 			}
 		}
 	}
@@ -562,7 +562,7 @@ connection_dispatch_operation(Connection *conn, Operation *op, Slapi_PBlock *pb)
 
 	default:
 		LDAPDebug( LDAP_DEBUG_ANY,
-		    "ignoring unknown LDAP request (conn=%" PRIu64 ", tag=0x%lx)\n",
+		    "ignoring unknown LDAP request (conn=%" NSPRIu64 ", tag=0x%lx)\n",
 		    conn->c_connid, op->o_tag, 0 );
 		break;
 	}
@@ -574,7 +574,7 @@ int connection_release_nolock (Connection *conn)
     if (conn->c_refcnt <= 0)
     {
         slapi_log_error(SLAPI_LOG_FATAL, "connection",
-		                "conn=%" PRIu64 " fd=%d Attempt to release connection that is not aquired\n",
+		                "conn=%" NSPRIu64 " fd=%d Attempt to release connection that is not aquired\n",
 			            conn->c_connid, conn->c_sd);
         PR_ASSERT (PR_FALSE);
         return -1;
@@ -595,7 +595,7 @@ int connection_acquire_nolock (Connection *conn)
     {
 	/* This may happen while other threads are still working on this connection */
         slapi_log_error(SLAPI_LOG_FATAL, "connection",
-		                "conn=%" PRIu64 " fd=%d Attempt to acquire connection in the closing state\n",
+		                "conn=%" NSPRIu64 " fd=%d Attempt to acquire connection in the closing state\n",
 			            conn->c_connid, conn->c_sd);
         return -1;
     }
@@ -773,7 +773,7 @@ static int handle_read_data(Connection *conn,Operation **op,
 	/* if connection is closing */
 	if (return_value != 0) {
 	    LDAPDebug(LDAP_DEBUG_CONNS,
-		      "handle_read_data returns as conn %" PRIu64 " closing, fd=%d\n",
+		      "handle_read_data returns as conn %" NSPRIu64 " closing, fd=%d\n",
 		      conn->c_connid,conn->c_sd,0);
 	    return return_value;
 	}
@@ -836,7 +836,7 @@ static int process_operation(Connection *conn, Operation *op)
 		!= LDAP_TAG_MSGID ) {
 		/* log, close and send error */
 		LDAPDebug( LDAP_DEBUG_ANY,
-			"conn=%" PRIu64 " unable to read tag for incoming request\n", conn->c_connid, 0, 0 );
+			"conn=%" NSPRIu64 " unable to read tag for incoming request\n", conn->c_connid, 0, 0 );
 		return_value = -1;
 		goto done;
 	}
@@ -848,7 +848,7 @@ static int process_operation(Connection *conn, Operation *op)
 	  case LDAP_TAG_LDAPDN: /* optional username, for CLDAP */
 		/* log, close and send error */
 		LDAPDebug( LDAP_DEBUG_ANY,
-			"conn=%" PRIu64 " ber_peek_tag returns 0x%lx\n", conn->c_connid, tag, 0 );
+			"conn=%" NSPRIu64 " ber_peek_tag returns 0x%lx\n", conn->c_connid, tag, 0 );
 		return_value = -1;
 		goto done;
 	  default:
@@ -979,7 +979,7 @@ static int connection_operation_new(Connection *conn, Operation **ppOp)
 	PR_Lock( conn->c_mutex );
 	if (connection_is_active_nolock(conn) == 0) {
 	    LDAPDebug(LDAP_DEBUG_CONNS,
-		      "not creating a new operation when conn %" PRIu64 " closing\n",
+		      "not creating a new operation when conn %" NSPRIu64 " closing\n",
 		      conn->c_connid,0,0);
 	    PR_Unlock( conn->c_mutex );
 	    return -1;
@@ -1071,7 +1071,7 @@ static int read_the_data(Connection *conn, int *process_op, int *defer_io, int *
 				So, we toss it away ! */
 				if (LBER_OVERFLOW == tag) {
 					slapi_log_error( SLAPI_LOG_FATAL, "connection",
-						"conn=%" PRIu64 " fd=%d The length of BER Element was too long.\n",
+						"conn=%" NSPRIu64 " fd=%d The length of BER Element was too long.\n",
 						conn->c_connid, conn->c_sd );
 				}
 				PR_Lock( conn->c_mutex );
@@ -1108,7 +1108,7 @@ static int read_the_data(Connection *conn, int *process_op, int *defer_io, int *
 				 * We received a non-LDAP message.  Log and close connection.
 				 */
 				LDAPDebug( LDAP_DEBUG_ANY,
-					"conn=%" PRIu64 " received a non-LDAP message"
+					"conn=%" NSPRIu64 " received a non-LDAP message"
 					" (tag 0x%lx, expected 0x%lx)\n",
 					conn->c_connid, tag, LDAP_TAG_MESSAGE );
 				PR_Lock( conn->c_mutex );
@@ -1126,7 +1126,7 @@ static int read_the_data(Connection *conn, int *process_op, int *defer_io, int *
 		if (Bytes_Scanned != Bytes_Read) {
 		        if (connection_increment_reference(conn) == -1) {
 			    LDAPDebug(LDAP_DEBUG_CONNS,
-				      "could not acquire lock in issue_new_read as conn %" PRIu64 " closing fd=%d\n",
+				      "could not acquire lock in issue_new_read as conn %" NSPRIu64 " closing fd=%d\n",
 				      conn->c_connid,conn->c_sd,0); 
 			    /* XXX how to handle this error? */
 			    /* MAB: 25 Jan 01: let's try like this and pray this won't leak... */
@@ -1148,7 +1148,7 @@ static int read_the_data(Connection *conn, int *process_op, int *defer_io, int *
 					 */
 					connection_decrement_reference(conn);
 					LDAPDebug(LDAP_DEBUG_CONNS,
-						  "push_back_data failed: closing conn %" PRIu64 " fd=%d\n",
+						  "push_back_data failed: closing conn %" NSPRIu64 " fd=%d\n",
 						  conn->c_connid,conn->c_sd,0); 
 				}
 			} else {
@@ -1246,7 +1246,7 @@ int issue_new_read(Connection *conn)
 
 	if (connection_increment_reference(conn) == -1) {
 	    LDAPDebug(LDAP_DEBUG_CONNS,
-		      "could not acquire lock in issue_new_read as conn %" PRIu64 " closing fd=%d\n",
+		      "could not acquire lock in issue_new_read as conn %" NSPRIu64 " closing fd=%d\n",
 		      conn->c_connid,conn->c_sd,0); 
 	    /* This means that the connection is closing */
 	    return -1;
@@ -1408,7 +1408,7 @@ int connection_activity(Connection *conn)
 	   be decremented in wait_for_new_work(). */
 	if (connection_acquire_nolock (conn) == -1) {
 	    LDAPDebug(LDAP_DEBUG_CONNS,
-		      "could not acquire lock in connection_activity as conn %" PRIu64 " closing fd=%d\n",
+		      "could not acquire lock in connection_activity as conn %" NSPRIu64 " closing fd=%d\n",
 		      conn->c_connid,conn->c_sd,0); 
 	    /* XXX how to handle this error? */
 	    /* MAB: 25 Jan 01: let's return on error and pray this won't leak */
@@ -1644,7 +1644,7 @@ get_next_from_buffer( void *buffer, size_t buffer_size, ber_len_t *lenp,
 		syserr = errno;
 		/* Bad stuff happened, like the client sent us some junk */
 		LDAPDebug( LDAP_DEBUG_CONNS,
-			"ber_get_next failed for connection %" PRIu64 "\n", conn->c_connid, 0, 0 );
+			"ber_get_next failed for connection %" NSPRIu64 "\n", conn->c_connid, 0, 0 );
 		/* reset private buffer */
 		conn->c_private->c_buffer_bytes = conn->c_private->c_buffer_offset = 0;
 
@@ -1713,7 +1713,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
 		ret = sasl_io_setup(conn);
 		if (ret) {
 			LDAPDebug( LDAP_DEBUG_ANY,
-				"conn=%" PRIu64 " unable to enable SASL I/O\n", conn->c_connid, 0, 0 );
+				"conn=%" NSPRIu64 " unable to enable SASL I/O\n", conn->c_connid, 0, 0 );
 				disconnect_server( conn, conn->c_connid, -1, SLAPD_DISCONNECT_BAD_BER_TAG, EPROTO );
 			return CONN_DONE;
 		}
@@ -1774,7 +1774,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
 					} else {
 						/* Otherwise we loop, unless we exceeded the ioblock timeout */
 						if (waits_done > ioblocktimeout_waits) {
-							LDAPDebug( LDAP_DEBUG_CONNS,"ioblock timeout expired on connection %" PRIu64 "\n", conn->c_connid, 0, 0 );
+							LDAPDebug( LDAP_DEBUG_CONNS,"ioblock timeout expired on connection %" NSPRIu64 "\n", conn->c_connid, 0, 0 );
 							disconnect_server( conn, conn->c_connid, -1,
 									SLAPD_DISCONNECT_IO_TIMEOUT, 0 );
 							return CONN_DONE;
@@ -1794,7 +1794,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
 					err = PR_GetError();
 					syserr = PR_GetOSError();
 					LDAPDebug( LDAP_DEBUG_ANY,
-						"PR_Poll for connection %" PRIu64 " returns %d (%s)\n", conn->c_connid, err, slapd_pr_strerror( err ) );
+						"PR_Poll for connection %" NSPRIu64 " returns %d (%s)\n", conn->c_connid, err, slapd_pr_strerror( err ) );
 					/* If this happens we should close the connection */
 					disconnect_server( conn, conn->c_connid, -1, err, syserr );
 					return CONN_DONE;
@@ -1803,7 +1803,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
 				/* Some other error, typically meaning bad stuff */
 					syserr = PR_GetOSError();
 					LDAPDebug( LDAP_DEBUG_CONNS,
-						"PR_Recv for connection %" PRIu64 " returns %d (%s)\n", conn->c_connid, err, slapd_pr_strerror( err ) );
+						"PR_Recv for connection %" NSPRIu64 " returns %d (%s)\n", conn->c_connid, err, slapd_pr_strerror( err ) );
 					/* If this happens we should close the connection */
 					disconnect_server( conn, conn->c_connid, -1, err, syserr );
 					return CONN_DONE;
@@ -1835,7 +1835,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
 		 * We received a non-LDAP message.  Log and close connection.
 		 */
 		LDAPDebug( LDAP_DEBUG_ANY,
-			"conn=%" PRIu64 " received a non-LDAP message (tag 0x%lx, expected 0x%lx)\n",
+			"conn=%" NSPRIu64 " received a non-LDAP message (tag 0x%lx, expected 0x%lx)\n",
 			conn->c_connid, *tag, LDAP_TAG_MESSAGE );
 		disconnect_server( conn, conn->c_connid, -1,
 			SLAPD_DISCONNECT_BAD_BER_TAG, EPROTO );
@@ -1846,7 +1846,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
 		!= LDAP_TAG_MSGID ) {
 		/* log, close and send error */
 		LDAPDebug( LDAP_DEBUG_ANY,
-			"conn=%" PRIu64 " unable to read tag for incoming request\n", conn->c_connid, 0, 0 );
+			"conn=%" NSPRIu64 " unable to read tag for incoming request\n", conn->c_connid, 0, 0 );
 		disconnect_server( conn, conn->c_connid, -1, SLAPD_DISCONNECT_BAD_BER_TAG, EPROTO );
 		return CONN_DONE;
 	}
@@ -1863,7 +1863,7 @@ int connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, i
 	  case LDAP_TAG_LDAPDN: /* optional username, for CLDAP */
 		/* log, close and send error */
 		LDAPDebug( LDAP_DEBUG_ANY,
-			"conn=%" PRIu64 " ber_peek_tag returns 0x%lx\n", conn->c_connid, *tag, 0 );
+			"conn=%" NSPRIu64 " ber_peek_tag returns 0x%lx\n", conn->c_connid, *tag, 0 );
 		disconnect_server( conn, conn->c_connid, -1, SLAPD_DISCONNECT_BER_PEEK, EPROTO );
 		return CONN_DONE;
 	  default:
@@ -1900,7 +1900,7 @@ void connection_check_activity_level(Connection *conn)
 	/* update the last checked time */
 	conn->c_private->previous_count_check_time = current_time();
 	PR_Unlock( conn->c_mutex );
-	LDAPDebug(LDAP_DEBUG_CONNS,"conn %" PRIu64 " activity level = %d\n",conn->c_connid,delta_count,0); 
+	LDAPDebug(LDAP_DEBUG_CONNS,"conn %" NSPRIu64 " activity level = %d\n",conn->c_connid,delta_count,0); 
 }
 
 typedef struct table_iterate_info_struct {
@@ -1955,7 +1955,7 @@ void connection_enter_leave_turbo(Connection *conn, int *new_turbo_flag)
 	} else {
 	  double activet = 0.0;
 	  connection_find_our_rank(conn,&connection_count, &our_rank);
-	  LDAPDebug(LDAP_DEBUG_CONNS,"conn %" PRIu64 " turbo rank = %d out of %d conns\n",conn->c_connid,our_rank,connection_count); 
+	  LDAPDebug(LDAP_DEBUG_CONNS,"conn %" NSPRIu64 " turbo rank = %d out of %d conns\n",conn->c_connid,our_rank,connection_count); 
 	  activet = (double)g_get_active_threadcnt();
 	  threshold_rank = (int)(activet * ((double)CONN_TURBO_PERCENTILE / 100.0));
 
@@ -1997,9 +1997,9 @@ void connection_enter_leave_turbo(Connection *conn, int *new_turbo_flag)
 	PR_Unlock(conn->c_mutex);
 	if (current_mode != new_mode) {
 		if (current_mode) {
-			LDAPDebug(LDAP_DEBUG_CONNS,"conn %" PRIu64 " leaving turbo mode\n",conn->c_connid,0,0); 
+			LDAPDebug(LDAP_DEBUG_CONNS,"conn %" NSPRIu64 " leaving turbo mode\n",conn->c_connid,0,0); 
 		} else {
-			LDAPDebug(LDAP_DEBUG_CONNS,"conn %" PRIu64 " entering turbo mode\n",conn->c_connid,0,0); 
+			LDAPDebug(LDAP_DEBUG_CONNS,"conn %" NSPRIu64 " entering turbo mode\n",conn->c_connid,0,0); 
 		}
 	}
 	*new_turbo_flag = new_mode;
@@ -2090,7 +2090,7 @@ connection_threadmain()
 		/* turn off turbo mode immediately if any pb waiting in global queue */
 		if (thread_turbo_flag && (counter > 0)) {
 			thread_turbo_flag = 0;
-			LDAPDebug(LDAP_DEBUG_CONNS,"conn %" PRIu64 " leaving turbo mode\n",conn->c_connid,0,0); 
+			LDAPDebug(LDAP_DEBUG_CONNS,"conn %" NSPRIu64 " leaving turbo mode\n",conn->c_connid,0,0); 
 		}
 #endif
 		
@@ -2233,7 +2233,7 @@ connection_activity(Connection *conn)
 
 	if (connection_acquire_nolock (conn) == -1) {
 	    LDAPDebug(LDAP_DEBUG_CONNS,
-		      "could not acquire lock in connection_activity as conn %" PRIu64 " closing fd=%d\n",
+		      "could not acquire lock in connection_activity as conn %" NSPRIu64 " closing fd=%d\n",
 		      conn->c_connid,conn->c_sd,0); 
 	    /* XXX how to handle this error? */
 	    /* MAB: 25 Jan 01: let's return on error and pray this won't leak */
@@ -2385,7 +2385,7 @@ connection_remove_operation( Connection *conn, Operation *op )
 
 	if ( *tmp == NULL )
 	{
-		LDAPDebug( LDAP_DEBUG_ANY, "connection_remove_operation: can't find op %d for conn %" PRIu64 "\n",
+		LDAPDebug( LDAP_DEBUG_ANY, "connection_remove_operation: can't find op %d for conn %" NSPRIu64 "\n",
 		    (int)op->o_msgid, conn->c_connid, 0 );
 	}
 	else
@@ -2496,13 +2496,13 @@ log_ber_too_big_error(const Connection *conn, ber_len_t ber_len,
 	}
 	if (0 == ber_len) {
 		slapi_log_error( SLAPI_LOG_FATAL, "connection",
-			"conn=%" PRIu64 " fd=%d Incoming BER Element was too long, max allowable"
+			"conn=%" NSPRIu64 " fd=%d Incoming BER Element was too long, max allowable"
 			" is %u bytes. Change the nsslapd-maxbersize attribute in"
 			" cn=config to increase.\n",
 			conn->c_connid, conn->c_sd, maxbersize );
 	} else {
 		slapi_log_error( SLAPI_LOG_FATAL, "connection",
-			"conn=%" PRIu64 " fd=%d Incoming BER Element was %u bytes, max allowable"
+			"conn=%" NSPRIu64 " fd=%d Incoming BER Element was %u bytes, max allowable"
 			" is %u bytes. Change the nsslapd-maxbersize attribute in"
 			" cn=config to increase.\n",
 			conn->c_connid, conn->c_sd, ber_len, maxbersize );
@@ -2555,13 +2555,13 @@ disconnect_server_nomutex( Connection *conn, PRUint64 opconnid, int opid, PRErro
 	 */
 	if (error && (EPIPE != error) ) {
 	    slapi_log_access( LDAP_DEBUG_STATS,
-		  "conn=%" PRIu64 " op=%d fd=%d closed error %d (%s) - %s\n",
+		  "conn=%" NSPRIu64 " op=%d fd=%d closed error %d (%s) - %s\n",
 		  conn->c_connid, opid, conn->c_sd, error,
 		  slapd_system_strerror(error),
 		  slapd_pr_strerror(reason));
 	} else {
 	    slapi_log_access( LDAP_DEBUG_STATS,
-		  "conn=%" PRIu64 " op=%d fd=%d closed - %s\n",
+		  "conn=%" NSPRIu64 " op=%d fd=%d closed - %s\n",
 		  conn->c_connid, opid, conn->c_sd,
 		  slapd_pr_strerror(reason));
 	}

ldap/servers/slapd/conntable.c

@@ -444,22 +444,22 @@ connection_table_as_entry(Connection_Table *ct, Slapi_Entry *e)
 		PR_Unlock( ct->c[i].c_mutex );
 	}
 
-	sprintf( buf, "%d", nconns );
+	PR_snprintf( buf, sizeof(buf), "%d", nconns );
 	val.bv_val = buf;
 	val.bv_len = strlen( buf );
 	attrlist_replace( &e->e_attrs, "currentconnections", vals );
 
-	sprintf( buf, "%" PRIu64, slapi_counter_get_value(num_conns));
+	PR_snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(num_conns));
 	val.bv_val = buf;
 	val.bv_len = strlen( buf );
 	attrlist_replace( &e->e_attrs, "totalconnections", vals );
 
-	sprintf( buf, "%d", (ct!=NULL?ct->size:0) );
+	PR_snprintf( buf, sizeof(buf), "%d", (ct!=NULL?ct->size:0) );
 	val.bv_val = buf;
 	val.bv_len = strlen( buf );
 	attrlist_replace( &e->e_attrs, "dtablesize", vals );
 
-	sprintf( buf, "%d", nreadwaiters );
+	PR_snprintf( buf, sizeof(buf), "%d", nreadwaiters );
 	val.bv_val = buf;
 	val.bv_len = strlen( buf );
 	attrlist_replace( &e->e_attrs, "readwaiters", vals );

ldap/servers/slapd/daemon.c

@@ -1496,7 +1496,7 @@ handle_pr_read_ready(Connection_Table *ct, PRIntn num_poll)
 						 * trying to acquire a closing connection
 						 */
 						LDAPDebug (LDAP_DEBUG_ANY,
-							"connection_activity: abandoning conn %" PRIu64 " as fd=%d is already closing\n",
+							"connection_activity: abandoning conn %" NSPRIu64 " as fd=%d is already closing\n",
 							c->c_connid,c->c_sd,0); 
 						/* The call disconnect_server should do nothing,
 						 * as the connection c should be already set to CLOSING */

ldap/servers/slapd/delete.c

@@ -257,7 +257,7 @@ static void op_shared_delete (Slapi_PBlock *pb)
 	{
 		if (!internal_op )
 		{
-			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d DEL dn=\"%s\"\n",
+			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d DEL dn=\"%s\"\n",
 							pb->pb_conn->c_connid, 
 							pb->pb_op->o_opid,
 							escape_string(dn, ebuf));

ldap/servers/slapd/entry.c

@@ -1360,7 +1360,7 @@ entry2str_internal( Slapi_Entry *e, int *len, int entry2str_ctrl )
     if ( (size_t)(ecur - ebuf + 1) > elen )
     {
         slapi_log_error (SLAPI_LOG_FATAL, NULL,
-            "entry2str_internal: array boundary wrote: bufsize=%d wrote=%d\n",
+            "entry2str_internal: array boundary wrote: bufsize=%ld wrote=%ld\n",
             elen, (ecur - ebuf + 1));
     }
 

ldap/servers/slapd/extendop.c

@@ -267,14 +267,14 @@ do_extended( Slapi_PBlock *pb )
 	if ( NULL == ( name = extended_op_oid2string( extoid ))) {
 		LDAPDebug( LDAP_DEBUG_ARGS, "do_extended: oid (%s)\n", extoid, 0, 0 );
 
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d EXT oid=\"%s\"\n",
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d EXT oid=\"%s\"\n",
 				pb->pb_conn->c_connid, pb->pb_op->o_opid, extoid );
 	} else {
 		LDAPDebug( LDAP_DEBUG_ARGS, "do_extended: oid (%s-%s)\n",
 				extoid, name, 0 );
 
 		slapi_log_access( LDAP_DEBUG_STATS,
-			"conn=%" PRIu64 " op=%d EXT oid=\"%s\" name=\"%s\"\n",
+			"conn=%" NSPRIu64 " op=%d EXT oid=\"%s\" name=\"%s\"\n",
 			pb->pb_conn->c_connid, pb->pb_op->o_opid, extoid, name );
 	}
 

ldap/servers/slapd/libglobs.c

@@ -2793,7 +2793,7 @@ config_set_conntablesize( const char *attrname, char *value, char *errorbuf, int
   if ( *endp != '\0' || errno == ERANGE || nValue < 1 || nValue > maxVal ) {
 	PR_snprintf ( errorbuf, SLAPI_DSE_RETURNTEXT_SIZE, "%s: invalid value \"%s\", connection table "
 			"size must range from 1 to %d (the current process maxdescriptors limit).  "
-			"Server will use a setting of %d.", attrname, value, maxVal );
+			"Server will use a setting of %d.", attrname, value, maxVal, maxVal );
         if ( nValue > maxVal) {
             nValue = maxVal;
             retVal = LDAP_UNWILLING_TO_PERFORM;

ldap/servers/slapd/modify.c

@@ -575,7 +575,7 @@ static void op_shared_modify (Slapi_PBlock *pb, int pw_change, char *old_pw)
 	{ 
 		if ( !internal_op )
 		{
-			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d MOD dn=\"%s\"\n",
+			slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d MOD dn=\"%s\"\n",
 							 pb->pb_conn->c_connid, 
 							 pb->pb_op->o_opid,
 							 escape_string(slapi_sdn_get_dn(&sdn), ebuf));
@@ -956,7 +956,7 @@ static int op_shared_allow_pw_change (Slapi_PBlock *pb, LDAPMod *mod, char **old
 
 			if (operation_is_flag_set(operation,OP_FLAG_ACTION_LOG_ACCESS))
 			{
-				slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d MOD dn=\"%s\", %s\n",
+				slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d MOD dn=\"%s\", %s\n",
 	    						 pb->pb_conn->c_connid, pb->pb_op->o_opid,
 	    						 escape_string(slapi_sdn_get_dn(&sdn), ebuf), 
 								 "user is not allowed to change password");
@@ -976,7 +976,7 @@ static int op_shared_allow_pw_change (Slapi_PBlock *pb, LDAPMod *mod, char **old
 		{
 			if ( !internal_op )
 			{
-				slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d MOD dn=\"%s\", %s\n",
+				slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d MOD dn=\"%s\", %s\n",
 								 pb->pb_conn->c_connid, 
 								 pb->pb_op->o_opid,
 								 escape_string(slapi_sdn_get_dn(&sdn), ebuf), 
@@ -1011,7 +1011,7 @@ static int op_shared_allow_pw_change (Slapi_PBlock *pb, LDAPMod *mod, char **old
 				{
 					if ( !internal_op )
 					{
-						slapi_log_access(LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d MOD dn=\"%s\", %s\n",
+						slapi_log_access(LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d MOD dn=\"%s\", %s\n",
 										 pb->pb_conn->c_connid, 
 										 pb->pb_op->o_opid,
 										 escape_string(slapi_sdn_get_dn(&sdn), ebuf), "invalid password syntax");

ldap/servers/slapd/modrdn.c

@@ -351,7 +351,7 @@ op_shared_rename(Slapi_PBlock *pb, int passin_args)
 		if ( !internal_op )
 		{
 			slapi_log_access(LDAP_DEBUG_STATS,
-					 "conn=%" PRIu64 " op=%d MODRDN dn=\"%s\" newrdn=\"%s\" newsuperior=\"%s\"\n",
+					 "conn=%" NSPRIu64 " op=%d MODRDN dn=\"%s\" newrdn=\"%s\" newsuperior=\"%s\"\n",
 					 pb->pb_conn->c_connid, 
 					 pb->pb_op->o_opid,
 					 escape_string(dn, dnbuf),
@@ -374,7 +374,7 @@ op_shared_rename(Slapi_PBlock *pb, int passin_args)
 	if ((rdns = ldap_explode_rdn(newrdn, 0)) == NULL) 
 	{
 		slapi_log_error(SLAPI_LOG_FATAL, NULL, 
-				 "conn=%" PRIu64 " op=%d MODRDN invalid new RDN (\"%s\")\n",
+				 "conn=%" NSPRIu64 " op=%d MODRDN invalid new RDN (\"%s\")\n",
 				 pb->pb_conn->c_connid,
 				 pb->pb_op->o_opid,
 				 (NULL == newrdn) ? "(null)" : newrdn);
@@ -391,7 +391,7 @@ op_shared_rename(Slapi_PBlock *pb, int passin_args)
 	{
 		LDAPDebug(LDAP_DEBUG_ARGS, "ldap_explode_dn of newSuperior failed\n", 0, 0, 0);
 		slapi_log_error(SLAPI_LOG_FATAL, NULL,
-				 "conn=%" PRIu64 " op=%d MODRDN invalid new superior (\"%s\")",
+				 "conn=%" NSPRIu64 " op=%d MODRDN invalid new superior (\"%s\")",
 				 pb->pb_conn->c_connid,
 				 pb->pb_op->o_opid,
 				 (NULL == newsuperior) ? "(null)" : newsuperiorbuf);

ldap/servers/slapd/monitor.c

@@ -75,7 +75,6 @@ monitor_info(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter, int *ret
 	struct tm		utm;
 	Slapi_Backend		*be;
 	char			*cookie;
-	PRUint32		len;
 
 	vals[0] = &val;
 	vals[1] = NULL;
@@ -86,31 +85,26 @@ monitor_info(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter, int *ret
 	attrlist_replace( &e->e_attrs, "version", vals );
 	slapi_ch_free( (void **) &val.bv_val );
 
-	sprintf( buf, "%d", g_get_active_threadcnt() );
+	val.bv_len = PR_snprintf( buf, sizeof(buf), "%d", g_get_active_threadcnt() );
 	val.bv_val = buf;
-	val.bv_len = strlen( buf );
 	attrlist_replace( &e->e_attrs, "threads", vals );
 
 	connection_table_as_entry(the_connection_table, e);
 
-	sprintf( buf, "%" PRIu64, slapi_counter_get_value(ops_initiated) );
+	val.bv_len = PR_snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(ops_initiated) );
 	val.bv_val = buf;
-	val.bv_len = strlen( buf );
 	attrlist_replace( &e->e_attrs, "opsinitiated", vals );
 
-	sprintf( buf, "%" PRIu64, slapi_counter_get_value(ops_completed) );
+	val.bv_len = PR_snprintf( buf, sizeof(buf), "%" NSPRIu64, slapi_counter_get_value(ops_completed) );
 	val.bv_val = buf;
-	val.bv_len = strlen( buf );
 	attrlist_replace( &e->e_attrs, "opscompleted", vals );
 
-	len = PR_snprintf ( buf, BUFSIZ, "%" PRIu64, g_get_num_entries_sent() );
+	val.bv_len = PR_snprintf ( buf, sizeof(buf), "%" NSPRIu64, g_get_num_entries_sent() );
 	val.bv_val = buf;
-	val.bv_len = ( unsigned long ) len;
 	attrlist_replace( &e->e_attrs, "entriessent", vals );
 
-	len = PR_snprintf ( buf, BUFSIZ, "%" PRIu64, g_get_num_bytes_sent() );
+	val.bv_len = PR_snprintf ( buf, sizeof(buf), "%" NSPRIu64, g_get_num_bytes_sent() );
 	val.bv_val = buf;
-	val.bv_len = ( unsigned long ) len;
 	attrlist_replace( &e->e_attrs, "bytessent", vals );
 
 #ifdef _WIN32
@@ -141,15 +135,13 @@ monitor_info(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter, int *ret
 	val.bv_len = strlen( buf );
 	attrlist_replace( &e->e_attrs, "starttime", vals );
 
-	sprintf( buf, "%d", be_nbackends_public() );
+	val.bv_len = PR_snprintf( buf, sizeof(buf), "%d", be_nbackends_public() );
 	val.bv_val = buf;
-	val.bv_len = strlen( buf );
 	attrlist_replace( &e->e_attrs, "nbackends", vals );
 
 #ifdef THREAD_SUNOS5_LWP
-	sprintf( buf, "%d", thr_getconcurrency() );
+	val.bv_len = PR_snprintf( buf, sizeof(buf), "%d", thr_getconcurrency() );
 	val.bv_val = buf;
-	val.bv_len = strlen( buf );
 	attrlist_replace( &e->e_attrs, "concurrency", vals );
 #endif
 

ldap/servers/slapd/opshared.c

@@ -230,7 +230,7 @@ op_shared_search (Slapi_PBlock *pb, int send_result)
   {
       char *fmtstr;
         
-#define SLAPD_SEARCH_FMTSTR_BASE "conn=%" PRIu64 " op=%d SRCH base=\"%s\" scope=%d "
+#define SLAPD_SEARCH_FMTSTR_BASE "conn=%" NSPRIu64 " op=%d SRCH base=\"%s\" scope=%d "
 #define SLAPD_SEARCH_FMTSTR_BASE_INT "conn=%s op=%d SRCH base=\"%s\" scope=%d "
 #define SLAPD_SEARCH_FMTSTR_REMAINDER " attrs=%s%s\n"
 
@@ -1329,7 +1329,7 @@ static int  send_results (Slapi_PBlock *pb, int send_result, int * nentries)
 void op_shared_log_error_access (Slapi_PBlock *pb, const char *type, const char *dn, const char *msg)
 {
 	char ebuf[BUFSIZ];
-	slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d %s dn=\"%s\", %s\n",
+	slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d %s dn=\"%s\", %s\n",
 		              ( pb->pb_conn ? pb->pb_conn->c_connid : 0), 
 					  ( pb->pb_op ? pb->pb_op->o_opid : 0), 
 					  type, 

ldap/servers/slapd/psearch.c

@@ -305,7 +305,7 @@ ps_send_results( void *arg )
 
 	if (conn_acq_flag) {
 		slapi_log_error(SLAPI_LOG_CONNS, "Persistent Search",
-						"conn=%" PRIu64 " op=%d Could not acquire the connection - psearch aborted\n",
+						"conn=%" NSPRIu64 " op=%d Could not acquire the connection - psearch aborted\n",
 						ps->ps_pblock->pb_conn->c_connid, ps->ps_pblock->pb_op->o_opid);
 	}
 
@@ -315,7 +315,7 @@ ps_send_results( void *arg )
 	/* Check for an abandoned operation */
 	if ( ps->ps_pblock->pb_op == NULL || slapi_op_abandoned( ps->ps_pblock ) ) {
 		slapi_log_error(SLAPI_LOG_CONNS, "Persistent Search",
-						"conn=%" PRIu64 " op=%d The operation has been abandoned\n",
+						"conn=%" NSPRIu64 " op=%d The operation has been abandoned\n",
 						ps->ps_pblock->pb_conn->c_connid, ps->ps_pblock->pb_op->o_opid);
 	    break;
 	}
@@ -373,7 +373,7 @@ ps_send_results( void *arg )
 										 ectrls, attrs, attrsonly );
 			if (rc) {
 				slapi_log_error(SLAPI_LOG_CONNS, "Persistent Search",
-								"conn=%" PRIu64 " op=%d Error %d sending entry %s with op status %d\n",
+								"conn=%" NSPRIu64 " op=%d Error %d sending entry %s with op status %d\n",
 								ps->ps_pblock->pb_conn->c_connid, ps->ps_pblock->pb_op->o_opid,
 								rc, slapi_entry_get_dn_const(ec), ps->ps_pblock->pb_op->o_status);
 			}
@@ -421,7 +421,7 @@ ps_send_results( void *arg )
     PR_Lock( ps->ps_pblock->pb_conn->c_mutex );
 
 	slapi_log_error(SLAPI_LOG_CONNS, "Persistent Search",
-					"conn=%" PRIu64 " op=%d Releasing the connection and operation\n",
+					"conn=%" NSPRIu64 " op=%d Releasing the connection and operation\n",
 					ps->ps_pblock->pb_conn->c_connid, ps->ps_pblock->pb_op->o_opid);
     /* Delete this op from the connection's list */
     connection_remove_operation( ps->ps_pblock->pb_conn, ps->ps_pblock->pb_op );
@@ -557,7 +557,7 @@ ps_service_persistent_searches( Slapi_Entry *e, Slapi_Entry *eprev, ber_int_t ch
 		}
 
 		slapi_log_error(SLAPI_LOG_CONNS, "Persistent Search",
-						"conn=%" PRIu64 " op=%d entry %s with chgtype %d "
+						"conn=%" NSPRIu64 " op=%d entry %s with chgtype %d "
 						"matches the ps changetype %d\n",
 						ps->ps_pblock->pb_conn->c_connid, ps->ps_pblock->pb_op->o_opid,
 						edn, chgtype, ps->ps_changetypes);

ldap/servers/slapd/result.c

@@ -1641,7 +1641,7 @@ log_result( Slapi_PBlock *pb, Operation *op, int err, ber_tag_t tag,
             PR_snprintf(etime, ETIME_BUFSIZ, "%f", 
                         (PRFloat64)delta/PR_TicksPerSecond());
         } else {
-            PR_snprintf(etime, ETIME_BUFSIZ, "%d", current_time() - op->o_time);
+            PR_snprintf(etime, ETIME_BUFSIZ, "%ld", current_time() - op->o_time);
         }
 
 	if ( 0 == pb->pb_operation_notes ) {
@@ -1672,7 +1672,7 @@ log_result( Slapi_PBlock *pb, Operation *op, int err, ber_tag_t tag,
 			if ( !internal_op )
 			{
 				slapi_log_access( LDAP_DEBUG_STATS,
-								  "conn=%" PRIu64 " op=%d RESULT err=%d"
+								  "conn=%" NSPRIu64 " op=%d RESULT err=%d"
 								  " tag=%u nentries=%d etime=%s%s%s"
 								  ", SASL bind in progress\n",
 								  op->o_connid, 
@@ -1704,7 +1704,7 @@ log_result( Slapi_PBlock *pb, Operation *op, int err, ber_tag_t tag,
 			if ( !internal_op )
 			{
 				slapi_log_access( LDAP_DEBUG_STATS,
-								  "conn=%" PRIu64 " op=%d RESULT err=%d"
+								  "conn=%" NSPRIu64 " op=%d RESULT err=%d"
 								  " tag=%u nentries=%d etime=%s%s%s"
 								  " dn=\"%s\"\n",
 								  op->o_connid, 
@@ -1730,7 +1730,7 @@ log_result( Slapi_PBlock *pb, Operation *op, int err, ber_tag_t tag,
 			if ( !internal_op )
 			{
 				slapi_log_access( LDAP_DEBUG_STATS,
-								  "conn=%" PRIu64 " op=%d RESULT err=%d"
+								  "conn=%" NSPRIu64 " op=%d RESULT err=%d"
 								  " tag=%u nentries=%d etime=%s%s%s\n",
 								  op->o_connid, 
 								  op->o_opid,
@@ -1763,7 +1763,7 @@ log_entry( Operation *op, Slapi_Entry *e )
 
 	if ( !internal_op )
 	{
-		slapi_log_access( LDAP_DEBUG_STATS2, "conn=%" PRIu64 " op=%d ENTRY dn=\"%s\"\n",
+		slapi_log_access( LDAP_DEBUG_STATS2, "conn=%" NSPRIu64 " op=%d ENTRY dn=\"%s\"\n",
 			op->o_connid, op->o_opid,
 			escape_string( slapi_entry_get_dn_const(e), ebuf ));
 	}
@@ -1788,7 +1788,7 @@ log_referral( Operation *op )
 
 	if ( !internal_op )
 	{
-		slapi_log_access( LDAP_DEBUG_STATS2, "conn=%" PRIu64 " op=%d REFERRAL\n",
+		slapi_log_access( LDAP_DEBUG_STATS2, "conn=%" NSPRIu64 " op=%d REFERRAL\n",
 			op->o_connid, op->o_opid );
 	}
 	else

ldap/servers/slapd/sasl_io.c

@@ -82,7 +82,7 @@ sasl_io_enable(Connection *c)
     int ret = 0;
 
     LDAPDebug( LDAP_DEBUG_CONNS,
-                "sasl_io_enable for connection %" PRIu64 "\n", c->c_connid, 0, 0 );
+                "sasl_io_enable for connection %" NSPRIu64 "\n", c->c_connid, 0, 0 );
     /* Flag that we should enable SASL I/O for the next read operation on this connection */
     c->c_enable_sasl_io = 1;
     
@@ -108,7 +108,7 @@ sasl_io_setup(Connection *c)
     sasl_io_private *sp = (sasl_io_private*) slapi_ch_calloc(1, sizeof(sasl_io_private));
 
     LDAPDebug( LDAP_DEBUG_CONNS,
-                "sasl_io_setup for connection %" PRIu64 "\n", c->c_connid, 0, 0 );
+                "sasl_io_setup for connection %" NSPRIu64 "\n", c->c_connid, 0, 0 );
     /* Get the current functions and store them for later */
     real_iofns->lbextiofn_size = LBER_X_EXTIO_FNS_SIZE;
     ber_sockbuf_get_option( c->c_sb, LBER_SOCKBUF_OPT_EXT_IO_FNS, real_iofns );
@@ -142,7 +142,7 @@ sasl_io_cleanup(Connection *c)
     sasl_io_private *sp = c->c_sasl_io_private;
     if (sp) {
         LDAPDebug( LDAP_DEBUG_CONNS,
-                "sasl_io_cleanup for connection %" PRIu64 "\n", c->c_connid, 0, 0 );
+                "sasl_io_cleanup for connection %" NSPRIu64 "\n", c->c_connid, 0, 0 );
         /* Free the buffers */
         slapi_ch_free((void**)&(sp->encrypted_buffer));
         slapi_ch_free((void**)&(sp->decrypted_buffer));
@@ -204,7 +204,7 @@ sasl_io_start_packet(Connection *c, PRInt32 *err)
     }
     if (ret != 0 && ret < sizeof(buffer)) {
         LDAPDebug( LDAP_DEBUG_ANY,
-            "failed to read sasl packet length on connection %" PRIu64 "\n", c->c_connid, 0, 0 );
+            "failed to read sasl packet length on connection %" NSPRIu64 "\n", c->c_connid, 0, 0 );
         return -1;
         
     }
@@ -215,7 +215,7 @@ sasl_io_start_packet(Connection *c, PRInt32 *err)
         packet_length += 4;
 
         LDAPDebug( LDAP_DEBUG_CONNS,
-            "read sasl packet length %ld on connection %" PRIu64 "\n", packet_length, c->c_connid, 0 );
+            "read sasl packet length %ld on connection %" NSPRIu64 "\n", packet_length, c->c_connid, 0 );
 
         /* Check if the packet length is larger than our max allowed.  A
          * setting of -1 means that we allow any size SASL IO packet. */
@@ -270,7 +270,7 @@ sasl_recv_connection(Connection *c, char *buffer, size_t count,PRInt32 *err)
 
     *err = 0;
     LDAPDebug( LDAP_DEBUG_CONNS,
-                "sasl_recv_connection for connection %" PRIu64 "\n", c->c_connid, 0, 0 );
+                "sasl_recv_connection for connection %" NSPRIu64 "\n", c->c_connid, 0, 0 );
     /* Do we have decrypted data buffered from 'before' ? */
     bytes_in_buffer = sp->decrypted_buffer_count - sp->decrypted_buffer_offset;
     if (0 == bytes_in_buffer) {
@@ -297,12 +297,12 @@ sasl_recv_connection(Connection *c, char *buffer, size_t count,PRInt32 *err)
             const char *output_buffer = NULL;
             unsigned int output_length = 0;
             LDAPDebug( LDAP_DEBUG_CONNS,
-            "sasl_recv_connection finished reading packet for connection %" PRIu64 "\n", c->c_connid, 0, 0 );
+            "sasl_recv_connection finished reading packet for connection %" NSPRIu64 "\n", c->c_connid, 0, 0 );
             /* Now decode it */
             ret = sasl_decode(c->c_sasl_conn,sp->encrypted_buffer,sp->encrypted_buffer_count,&output_buffer,&output_length);
             if (SASL_OK == ret) {
                 LDAPDebug( LDAP_DEBUG_CONNS,
-                "sasl_recv_connection decoded packet length %d for connection %" PRIu64 "\n", output_length, c->c_connid, 0 );
+                "sasl_recv_connection decoded packet length %d for connection %" NSPRIu64 "\n", output_length, c->c_connid, 0 );
                 if (output_length) {
                     sasl_io_resize_decrypted_buffer(sp,output_length);
                     memcpy(sp->decrypted_buffer,output_buffer,output_length);
@@ -313,7 +313,7 @@ sasl_recv_connection(Connection *c, char *buffer, size_t count,PRInt32 *err)
                 }
             } else {
                 LDAPDebug( LDAP_DEBUG_ANY,
-                "sasl_recv_connection failed to decode packet for connection %" PRIu64 "\n", c->c_connid, 0, 0 );
+                "sasl_recv_connection failed to decode packet for connection %" NSPRIu64 "\n", c->c_connid, 0, 0 );
             }
         }
     }

ldap/servers/slapd/search.c

@@ -384,7 +384,7 @@ static void log_search_access (Slapi_PBlock *pb, const char *base, int scope, co
 {
 	char ebuf[BUFSIZ];
 	slapi_log_access(LDAP_DEBUG_STATS,
-					 "conn=%" PRIu64 " op=%d SRCH base=\"%s\" scope=%d filter=\"%s\", %s\n",
+					 "conn=%" NSPRIu64 " op=%d SRCH base=\"%s\" scope=%d filter=\"%s\", %s\n",
 					 pb->pb_conn->c_connid, pb->pb_op->o_opid, 
 					 escape_string(base, ebuf), scope, fstr, msg ? msg : "");
 

ldap/servers/slapd/slap.h

@@ -121,14 +121,6 @@ void *dlsym(void *a, char *b);
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
 
-/* NSPR uses the print macros a bit differently than ANSI C.  We
- * need to use ll for a 64-bit integer, even when a long is 64-bit.
- */
-#undef PRIu64
-#define PRIu64	"llu"
-#undef PRI64
-#define PRI64	"ll"
-
 #else
 #error Need to define portable format macros such as PRIu64
 #endif /* HAVE_INTTYPES_H */

ldap/servers/slapd/slapi-plugin.h

@@ -52,6 +52,37 @@ extern "C" {
 
 #include "prtypes.h"
 #include "ldap.h"
+#include "prprf.h"
+NSPR_API(PRUint32) PR_snprintf(char *out, PRUint32 outlen, const char *fmt, ...)
+#ifdef __GNUC__ 
+        __attribute__ ((format (printf, 3, 4)));
+#else
+        ;
+#endif
+NSPR_API(char*) PR_smprintf(const char *fmt, ...)
+#ifdef __GNUC__ 
+        __attribute__ ((format (printf, 1, 2)));
+#else
+        ;
+#endif
+NSPR_API(char*) PR_sprintf_append(char *last, const char *fmt, ...)
+#ifdef __GNUC__ 
+        __attribute__ ((format (printf, 2, 3)));
+#else
+        ;
+#endif
+NSPR_API(PRUint32) PR_fprintf(struct PRFileDesc* fd, const char *fmt, ...)
+#ifdef __GNUC__ 
+        __attribute__ ((format (printf, 2, 3)));
+#else
+        ;
+#endif
+
+/* NSPR uses the print macros a bit differently than ANSI C.  We
+ * need to use ll for a 64-bit integer, even when a long is 64-bit.
+ */
+#define NSPRIu64	"llu"
+#define NSPRI64	"ll"
 
 /*
  * The slapi_attr_get_flags() routine returns a bitmap that contains one or
@@ -1041,7 +1072,13 @@ int slapi_register_plugin( const char *plugintype, int enabled,
 /*
  * logging
  */
-int slapi_log_error( int severity, char *subsystem, char *fmt, ... );
+int slapi_log_error( int severity, char *subsystem, char *fmt, ... )
+#ifdef __GNUC__ 
+        __attribute__ ((format (printf, 3, 4)));
+#else
+        ;
+#endif
+
 /* allowed values for the "severity" parameter */
 #define SLAPI_LOG_FATAL          	0
 #define SLAPI_LOG_TRACE			1

ldap/servers/slapd/snmp_collator.c

@@ -765,7 +765,7 @@ static void
 add_counter_to_value(Slapi_Entry *e, const char *type, PRUint64 countervalue)
 {
 	char value[40];
-	sprintf(value,"%" PRIu64, countervalue);
+	PR_snprintf(value,sizeof(value),"%" NSPRIu64, countervalue);
 	slapi_entry_attr_set_charptr( e, type, value);
 }
 

ldap/servers/slapd/ssl.c

@@ -166,7 +166,7 @@ char ** getSupportedCiphers()
 		cipher_names = (char **) slapi_ch_calloc ((number_of_ciphers +1 ) , sizeof(char *));
 		for (i = 0 ; _conf_ciphers[i].name != NULL; i++ ) {
 			SSL_GetCipherSuiteInfo((PRUint16)_conf_ciphers[i].num,&info,sizeof(info));
-			cipher_names[i] = PR_smprintf("%s%s%s%s%s%s%s%s%d\0",_conf_ciphers[i].version,sep,_conf_ciphers[i].name,sep,info.symCipherName,sep,info.macAlgorithmName,sep,info.symKeyBits);
+			cipher_names[i] = PR_smprintf("%s%s%s%s%s%s%s%s%d",_conf_ciphers[i].version,sep,_conf_ciphers[i].name,sep,info.symCipherName,sep,info.macAlgorithmName,sep,info.symKeyBits);
 		}
 		cipher_names[i] = NULL;
 	}

ldap/servers/slapd/unbind.c

@@ -79,7 +79,7 @@ do_unbind( Slapi_PBlock *pb )
 	 *	UnBindRequest ::= NULL
 	 */
 	if ( ber_get_null( ber ) == LBER_ERROR ) {
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d UNBIND,"
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d UNBIND,"
 				" decoding error: UnBindRequest not null\n",
 				pb->pb_conn->c_connid, operation->o_opid );
 		/* LDAPv3 does not allow a response to an unbind... so just return. */
@@ -92,7 +92,7 @@ do_unbind( Slapi_PBlock *pb )
 	 * pass them to the backend.
 	 */
 	if ( (err = get_ldapmessage_controls( pb, ber, NULL )) != 0 ) {
-		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d UNBIND,"
+		slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d UNBIND,"
 				" error processing controls - error %d (%s)\n",
 				pb->pb_conn->c_connid, operation->o_opid,
 				err, ldap_err2string( err ));
@@ -107,7 +107,7 @@ do_unbind( Slapi_PBlock *pb )
 
 	/* ONREPL - plugins should be called and passed bind dn and, possibly, other data */
 
-	slapi_log_access( LDAP_DEBUG_STATS, "conn=%" PRIu64 " op=%d UNBIND\n",
+	slapi_log_access( LDAP_DEBUG_STATS, "conn=%" NSPRIu64 " op=%d UNBIND\n",
 	    pb->pb_conn->c_connid, operation->o_opid );
 
 	/* pass the unbind to all backends */

ldap/servers/slapd/util.c

@@ -1161,7 +1161,7 @@ slapi_ldap_bind(
 	    } else if (rc == 0) { /* timeout */
 		rc = LDAP_TIMEOUT;
 		slapi_log_error(SLAPI_LOG_FATAL, "slapi_ldap_bind",
-				"Error: timeout after [%d.%d] seconds reading "
+				"Error: timeout after [%ld.%ld] seconds reading "
 				"bind response for [%s] mech [%s]\n",
 				timeout ? timeout->tv_sec : 0,
 				timeout ? timeout->tv_usec : 0,