git.sur5r.net Git - openldap/blob - libraries/liblber/bprint.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6
   7 #include "portable.h"
   8
   9 #include <stdio.h>
  10
  11 #include <ac/ctype.h>
  12 #include <ac/stdarg.h>
  13 #include <ac/string.h>
  14
  15 #include "lber-int.h"
  16
  17 /*
  18  * We don't just set ber_pvt_err_file to stderr here, because in NT,
  19  * stderr is a symbol imported from a DLL. As such, the compiler
  20  * doesn't recognize the symbol as having a constant address. Thus
  21  * we set ber_pvt_err_file to stderr later, when it first gets
  22  * referenced.
  23  */
  24 FILE *ber_pvt_err_file = NULL;
  25
  26 /*
  27  * ber errno
  28  */
  29 BER_ERRNO_FN ber_int_errno_fn = NULL;
  30
  31 int * ber_errno_addr(void)
  32 {
  33         static int ber_int_errno = LBER_ERROR_NONE;
  34
  35         if( ber_int_errno_fn ) {
  36                 return (*ber_int_errno_fn)();
  37         }
  38
  39         return &ber_int_errno;
  40 }
  41
  42 /*
  43  * Print stuff
  44  */
  45 void ber_error_print( LDAP_CONST char *data )
  46 {
  47         assert( data != NULL );
  48
  49         if (!ber_pvt_err_file) ber_pvt_err_file = stderr;
  50
  51         fputs( data, ber_pvt_err_file );
  52
  53         /* Print to both streams */
  54         if (ber_pvt_err_file != stderr) {
  55                 fputs( data, stderr );
  56                 fflush( stderr );
  57         }
  58
  59         fflush( ber_pvt_err_file );
  60 }
  61
  62 BER_LOG_PRINT_FN ber_pvt_log_print = ber_error_print;
  63
  64 /*
  65  * lber log
  66  */
  67
  68 static int ber_log_check( int errlvl, int loglvl )
  69 {
  70         return errlvl & loglvl ? 1 : 0;
  71 }
  72
  73 int ber_pvt_log_printf( int errlvl, int loglvl, const char *fmt, ... )
  74 {
  75         char buf[ 1024 ];
  76         va_list ap;
  77
  78         assert( fmt != NULL );
  79
  80         if ( !ber_log_check( errlvl, loglvl )) {
  81                 return 0;
  82         }
  83
  84         va_start( ap, fmt );
  85
  86 #ifdef HAVE_VSNPRINTF
  87         buf[sizeof(buf) - 1] = '\0';
  88         vsnprintf( buf, sizeof(buf)-1, fmt, ap );
  89 #elif HAVE_VSPRINTF
  90         vsprintf( buf, fmt, ap ); /* hope it's not too long */
  91 #else
  92         /* use doprnt() */
  93 #error "vsprintf() required."
  94 #endif
  95
  96         va_end(ap);
  97
  98         (*ber_pvt_log_print)( buf );
  99         return 1;
 100 }
 101
 102 #if 0
 103 static int ber_log_puts(int errlvl, int loglvl, char *buf)
 104 {
 105         assert( buf != NULL );
 106
 107         if ( !ber_log_check( errlvl, loglvl )) {
 108                 return 0;
 109         }
 110
 111         (*ber_pvt_log_print)( buf );
 112         return 1;
 113 }
 114 #endif
 115
 116 /*
 117  * Print arbitrary stuff, for debugging.
 118  */
 119
 120 int
 121 ber_log_bprint(int errlvl,
 122         int loglvl,
 123         const char *data,
 124         ber_len_t len )
 125 {
 126         assert( data != NULL );
 127
 128         if ( !ber_log_check( errlvl, loglvl )) {
 129                 return 0;
 130         }
 131
 132         ber_bprint(data, len);
 133         return 1;
 134 }
 135
 136 void
 137 ber_bprint(
 138         LDAP_CONST char *data,
 139         ber_len_t len )
 140 {
 141         static const char       hexdig[] = "0123456789abcdef";
 142 #define BP_OFFSET 9
 143 #define BP_GRAPH 60
 144 #define BP_LEN  80
 145         char    line[ BP_LEN ];
 146         ber_len_t i;
 147
 148         assert( data != NULL );
 149
 150         /* in case len is zero */
 151         line[0] = '\n';
 152         line[1] = '\0';
 153
 154         for ( i = 0 ; i < len ; i++ ) {
 155                 int n = i % 16;
 156                 unsigned off;
 157
 158                 if( !n ) {
 159                         if( i ) (*ber_pvt_log_print)( line );
 160                         memset( line, ' ', sizeof(line)-2 );
 161                         line[sizeof(line)-2] = '\n';
 162                         line[sizeof(line)-1] = '\0';
 163
 164                         off = i % 0x0ffffU;
 165
 166                         line[ 2 ] = hexdig[ 0x0f & (off >> 12) ];
 167                         line[ 3 ] = hexdig[ 0x0f & (off >>  8) ];
 168                         line[ 4 ] = hexdig[ 0x0f & (off >>  4) ];
 169                         line[ 5 ] = hexdig[ 0x0f & off ];
 170                         line[ 6 ] = ':';
 171                 }
 172
 173                 off = BP_OFFSET + n*3 + ((n >= 8)?1:0);
 174                 line[ off   ] = hexdig[ 0x0f & ( data[i] >> 4 ) ];
 175                 line[ off+1 ] = hexdig[ 0x0f & data[i] ];
 176
 177                 off = BP_GRAPH + n + ((n >= 8)?1:0);
 178
 179                 if ( isprint( data[i] )) {
 180                         line[ BP_GRAPH + n ] = data[i];
 181                 } else {
 182                         line[ BP_GRAPH + n ] = '.';
 183                 }
 184         }
 185
 186         (*ber_pvt_log_print)( line );
 187 }
 188
 189 int
 190 ber_log_dump(
 191         int errlvl,
 192         int loglvl,
 193         BerElement *ber,
 194         int inout )
 195 {
 196         assert( ber != NULL );
 197         assert( BER_VALID( ber ) );
 198
 199         if ( !ber_log_check( errlvl, loglvl )) {
 200                 return 0;
 201         }
 202
 203         ber_dump(ber, inout);
 204         return 1;
 205 }
 206
 207 void
 208 ber_dump(
 209         BerElement *ber,
 210         int inout )
 211 {
 212         char buf[132];
 213         ber_len_t len;
 214
 215         assert( ber != NULL );
 216         assert( BER_VALID( ber ) );
 217
 218         if ( inout == 1 ) {
 219                 len = ber_pvt_ber_remaining(ber);
 220         } else {
 221                 len = ber_pvt_ber_write(ber);
 222         }
 223
 224         sprintf( buf, "ber_dump: buf=0x%08lx ptr=0x%08lx end=0x%08lx len=%ld\n",
 225             (long) ber->ber_buf,
 226                 (long) ber->ber_ptr,
 227                 (long) ber->ber_end,
 228                 (long) len );
 229
 230         (*ber_pvt_log_print)( buf );
 231
 232         ber_bprint( ber->ber_ptr, len );
 233 }
 234
 235 int
 236 ber_log_sos_dump(
 237         int errlvl,
 238         int loglvl,
 239         Seqorset *sos )
 240 {
 241         assert( sos != NULL );
 242
 243         if ( !ber_log_check( errlvl, loglvl )) {
 244                 return 0;
 245         }
 246
 247         ber_sos_dump( sos );
 248         return 1;
 249 }
 250
 251 void
 252 ber_sos_dump(
 253         Seqorset *sos )
 254 {
 255         char buf[132];
 256
 257         assert( sos != NULL );
 258
 259         (*ber_pvt_log_print)( "*** sos dump ***\n" );
 260
 261         while ( sos != NULL ) {
 262                 sprintf( buf, "ber_sos_dump: clen %ld first 0x%lx ptr 0x%lx\n",
 263                     (long) sos->sos_clen,
 264                         (long) sos->sos_first,
 265                         (long) sos->sos_ptr );
 266                 (*ber_pvt_log_print)( buf );
 267
 268                 sprintf( buf, "              current len %ld contents:\n",
 269                     (long) (sos->sos_ptr - sos->sos_first) );
 270                 (*ber_pvt_log_print)( buf );
 271
 272                 ber_bprint( sos->sos_first, sos->sos_ptr - sos->sos_first );
 273
 274                 sos = sos->sos_next;
 275         }
 276
 277         (*ber_pvt_log_print)( "*** end dump ***\n" );
 278 }