/* $OpenLDAP: pkg/ldap/libraries/liblber/bprint.c,v 1.55.2.3 2007/01/02 21:43:48 kurt Exp $ */ /* This work is part of OpenLDAP Software . * * Copyright 1998-2007 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * A copy of this license is available in the file LICENSE in the * top-level directory of the distribution or, alternatively, at * . */ /* * Copyright (c) 1991 Regents of the University of Michigan. * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that this notice is preserved and that due credit is given * to the University of Michigan at Ann Arbor. The name of the University * may not be used to endorse or promote products derived from this * software without specific prior written permission. This software * is provided ``as is'' without express or implied warranty. */ /* ACKNOWLEDGEMENTS: * This work was originally developed by the University of Michigan * (as part of U-MICH LDAP). */ #include "portable.h" #include #include #include #include #include "lber-int.h" #define ber_log_check(errlvl, loglvl) ((errlvl) & (loglvl)) BER_LOG_FN ber_int_log_proc = NULL; /* * We don't just set ber_pvt_err_file to stderr here, because in NT, * stderr is a symbol imported from a DLL. As such, the compiler * doesn't recognize the symbol as having a constant address. Thus * we set ber_pvt_err_file to stderr later, when it first gets * referenced. */ FILE *ber_pvt_err_file = NULL; /* * ber errno */ BER_ERRNO_FN ber_int_errno_fn = NULL; int * ber_errno_addr(void) { static int ber_int_errno = LBER_ERROR_NONE; if( ber_int_errno_fn ) { return (*ber_int_errno_fn)(); } return &ber_int_errno; } /* * Print stuff */ void ber_error_print( LDAP_CONST char *data ) { assert( data != NULL ); if (!ber_pvt_err_file) ber_pvt_err_file = stderr; fputs( data, ber_pvt_err_file ); /* Print to both streams */ if (ber_pvt_err_file != stderr) { fputs( data, stderr ); fflush( stderr ); } fflush( ber_pvt_err_file ); } BER_LOG_PRINT_FN ber_pvt_log_print = ber_error_print; /* * lber log */ int ber_pvt_log_output( const char *subsystem, int level, const char *fmt, ... ) { char buf[1024]; va_list vl; va_start( vl, fmt ); if ( ber_int_log_proc != NULL ) { ber_int_log_proc( ber_pvt_err_file, subsystem, level, fmt, vl ); } else { int level; ber_get_option( NULL, LBER_OPT_BER_DEBUG, &level ); buf[sizeof(buf) - 1] = '\0'; vsnprintf( buf, sizeof(buf)-1, fmt, vl ); if ( ber_log_check( LDAP_DEBUG_BER, level ) ) { (*ber_pvt_log_print)( buf ); } } va_end(vl); return 1; } int ber_pvt_log_printf( int errlvl, int loglvl, const char *fmt, ... ) { char buf[1024]; va_list ap; assert( fmt != NULL ); if ( !ber_log_check( errlvl, loglvl )) { return 0; } va_start( ap, fmt ); buf[sizeof(buf) - 1] = '\0'; vsnprintf( buf, sizeof(buf)-1, fmt, ap ); va_end(ap); (*ber_pvt_log_print)( buf ); return 1; } #if 0 static int ber_log_puts(int errlvl, int loglvl, char *buf) { assert( buf != NULL ); if ( !ber_log_check( errlvl, loglvl )) { return 0; } (*ber_pvt_log_print)( buf ); return 1; } #endif /* * Print arbitrary stuff, for debugging. */ int ber_log_bprint(int errlvl, int loglvl, const char *data, ber_len_t len ) { assert( data != NULL ); if ( !ber_log_check( errlvl, loglvl )) { return 0; } ber_bprint(data, len); return 1; } void ber_bprint( LDAP_CONST char *data, ber_len_t len ) { static const char hexdig[] = "0123456789abcdef"; #define BP_OFFSET 9 #define BP_GRAPH 60 #define BP_LEN 80 char line[BP_LEN]; ber_len_t i; assert( data != NULL ); /* in case len is zero */ line[0] = '\n'; line[1] = '\0'; for ( i = 0 ; i < len ; i++ ) { int n = i % 16; unsigned off; if( !n ) { if( i ) (*ber_pvt_log_print)( line ); memset( line, ' ', sizeof(line)-2 ); line[sizeof(line)-2] = '\n'; line[sizeof(line)-1] = '\0'; off = i % 0x0ffffU; line[2] = hexdig[0x0f & (off >> 12)]; line[3] = hexdig[0x0f & (off >> 8)]; line[4] = hexdig[0x0f & (off >> 4)]; line[5] = hexdig[0x0f & off]; line[6] = ':'; } off = BP_OFFSET + n*3 + ((n >= 8)?1:0); line[off] = hexdig[0x0f & ( data[i] >> 4 )]; line[off+1] = hexdig[0x0f & data[i]]; off = BP_GRAPH + n + ((n >= 8)?1:0); if ( isprint( (unsigned char) data[i] )) { line[BP_GRAPH + n] = data[i]; } else { line[BP_GRAPH + n] = '.'; } } (*ber_pvt_log_print)( line ); } int ber_log_dump( int errlvl, int loglvl, BerElement *ber, int inout ) { assert( ber != NULL ); assert( LBER_VALID( ber ) ); if ( !ber_log_check( errlvl, loglvl )) { return 0; } ber_dump(ber, inout); return 1; } void ber_dump( BerElement *ber, int inout ) { char buf[132]; ber_len_t len; assert( ber != NULL ); assert( LBER_VALID( ber ) ); if ( inout == 1 ) { len = ber_pvt_ber_remaining(ber); } else { len = ber_pvt_ber_write(ber); } sprintf( buf, "ber_dump: buf=0x%08lx ptr=0x%08lx end=0x%08lx len=%ld\n", (long) ber->ber_buf, (long) ber->ber_ptr, (long) ber->ber_end, (long) len ); (void) (*ber_pvt_log_print)( buf ); ber_bprint( ber->ber_ptr, len ); } int ber_log_sos_dump( int errlvl, int loglvl, Seqorset *sos ) { assert( sos != NULL ); if ( !ber_log_check( errlvl, loglvl )) { return 0; } ber_sos_dump( sos ); return 1; } void ber_sos_dump( Seqorset *sos ) { char buf[132]; assert( sos != NULL ); (*ber_pvt_log_print)( "*** sos dump ***\n" ); while ( sos != NULL ) { sprintf( buf, "ber_sos_dump: clen %ld first 0x%lx ptr 0x%lx\n", (long) sos->sos_clen, (long) sos->sos_first, (long) sos->sos_ptr ); (*ber_pvt_log_print)( buf ); sprintf( buf, " current len %ld contents:\n", (long) (sos->sos_ptr - sos->sos_first) ); (*ber_pvt_log_print)( buf ); ber_bprint( sos->sos_first, sos->sos_ptr - sos->sos_first ); sos = sos->sos_next; } (*ber_pvt_log_print)( "*** end dump ***\n" ); }