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

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2003 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 #define ber_log_check(errlvl, loglvl)   ((errlvl) & (loglvl))
  18
  19 BER_LOG_FN ber_int_log_proc = NULL;
  20
  21 /*
  22  * We don't just set ber_pvt_err_file to stderr here, because in NT,
  23  * stderr is a symbol imported from a DLL. As such, the compiler
  24  * doesn't recognize the symbol as having a constant address. Thus
  25  * we set ber_pvt_err_file to stderr later, when it first gets
  26  * referenced.
  27  */
  28 FILE *ber_pvt_err_file = NULL;
  29
  30 /*
  31  * ber errno
  32  */
  33 BER_ERRNO_FN ber_int_errno_fn = NULL;
  34
  35 int * ber_errno_addr(void)
  36 {
  37         static int ber_int_errno = LBER_ERROR_NONE;
  38
  39         if( ber_int_errno_fn ) {
  40                 return (*ber_int_errno_fn)();
  41         }
  42
  43         return &ber_int_errno;
  44 }
  45
  46 /*
  47  * Print stuff
  48  */
  49 void ber_error_print( LDAP_CONST char *data )
  50 {
  51         assert( data != NULL );
  52
  53         if (!ber_pvt_err_file) ber_pvt_err_file = stderr;
  54
  55         fputs( data, ber_pvt_err_file );
  56
  57         /* Print to both streams */
  58         if (ber_pvt_err_file != stderr) {
  59                 fputs( data, stderr );
  60                 fflush( stderr );
  61         }
  62
  63         fflush( ber_pvt_err_file );
  64 }
  65
  66 BER_LOG_PRINT_FN ber_pvt_log_print = ber_error_print;
  67
  68 /*
  69  * lber log
  70  */
  71
  72 int ber_pvt_log_output(
  73         const char *subsystem,
  74         int level,
  75         const char *fmt,
  76         ... )
  77 {
  78         char buf[ 1024 ];
  79         va_list vl;
  80         va_start( vl, fmt );
  81
  82         if ( ber_int_log_proc != NULL )
  83         {
  84                 ber_int_log_proc( ber_pvt_err_file, subsystem, level, fmt, vl );
  85         }
  86         else
  87         {
  88             int level;
  89             ber_get_option( NULL, LBER_OPT_BER_DEBUG, &level );
  90             buf[sizeof(buf) - 1] = '\0';
  91             vsnprintf( buf, sizeof(buf)-1, fmt, vl );
  92             if ( ber_log_check( LDAP_DEBUG_BER, level ) )
  93                 (*ber_pvt_log_print)( buf );
  94         }
  95         va_end(vl);
  96
  97         return 1;
  98 }
  99
 100 int ber_pvt_log_printf( int errlvl, int loglvl, const char *fmt, ... )
 101 {
 102         char buf[ 1024 ];
 103         va_list ap;
 104
 105         assert( fmt != NULL );
 106
 107         if ( !ber_log_check( errlvl, loglvl )) {
 108                 return 0;
 109         }
 110
 111         va_start( ap, fmt );
 112
 113         buf[sizeof(buf) - 1] = '\0';
 114         vsnprintf( buf, sizeof(buf)-1, fmt, ap );
 115
 116         va_end(ap);
 117
 118         (*ber_pvt_log_print)( buf );
 119         return 1;
 120 }
 121
 122 #if 0
 123 static int ber_log_puts(int errlvl, int loglvl, char *buf)
 124 {
 125         assert( buf != NULL );
 126
 127         if ( !ber_log_check( errlvl, loglvl )) {
 128                 return 0;
 129         }
 130
 131         (*ber_pvt_log_print)( buf );
 132         return 1;
 133 }
 134 #endif
 135
 136 /*
 137  * Print arbitrary stuff, for debugging.
 138  */
 139
 140 int
 141 ber_log_bprint(int errlvl,
 142         int loglvl,
 143         const char *data,
 144         ber_len_t len )
 145 {
 146         assert( data != NULL );
 147
 148         if ( !ber_log_check( errlvl, loglvl )) {
 149                 return 0;
 150         }
 151
 152         ber_bprint(data, len);
 153         return 1;
 154 }
 155
 156 void
 157 ber_bprint(
 158         LDAP_CONST char *data,
 159         ber_len_t len )
 160 {
 161         static const char       hexdig[] = "0123456789abcdef";
 162 #define BP_OFFSET 9
 163 #define BP_GRAPH 60
 164 #define BP_LEN  80
 165         char    line[ BP_LEN ];
 166         ber_len_t i;
 167
 168         assert( data != NULL );
 169
 170         /* in case len is zero */
 171         line[0] = '\n';
 172         line[1] = '\0';
 173
 174         for ( i = 0 ; i < len ; i++ ) {
 175                 int n = i % 16;
 176                 unsigned off;
 177
 178                 if( !n ) {
 179                         if( i ) (*ber_pvt_log_print)( line );
 180                         memset( line, ' ', sizeof(line)-2 );
 181                         line[sizeof(line)-2] = '\n';
 182                         line[sizeof(line)-1] = '\0';
 183
 184                         off = i % 0x0ffffU;
 185
 186                         line[ 2 ] = hexdig[ 0x0f & (off >> 12) ];
 187                         line[ 3 ] = hexdig[ 0x0f & (off >>  8) ];
 188                         line[ 4 ] = hexdig[ 0x0f & (off >>  4) ];
 189                         line[ 5 ] = hexdig[ 0x0f & off ];
 190                         line[ 6 ] = ':';
 191                 }
 192
 193                 off = BP_OFFSET + n*3 + ((n >= 8)?1:0);
 194                 line[ off   ] = hexdig[ 0x0f & ( data[i] >> 4 ) ];
 195                 line[ off+1 ] = hexdig[ 0x0f & data[i] ];
 196
 197                 off = BP_GRAPH + n + ((n >= 8)?1:0);
 198
 199                 if ( isprint( (unsigned char) data[i] )) {
 200                         line[ BP_GRAPH + n ] = data[i];
 201                 } else {
 202                         line[ BP_GRAPH + n ] = '.';
 203                 }
 204         }
 205
 206         (*ber_pvt_log_print)( line );
 207 }
 208
 209 #ifdef NEW_LOGGING
 210 int ber_output_dump(
 211         const char *subsys,
 212         int level,
 213         BerElement *ber,
 214         int inout )
 215 {
 216     static const char   hexdig[] = "0123456789abcdef";
 217     char buf[132];
 218     ber_len_t len;
 219     char        line[ BP_LEN ];
 220     ber_len_t i;
 221     char *data = ber->ber_ptr;
 222
 223     if ( inout == 1 ) {
 224         len = ber_pvt_ber_remaining(ber);
 225     } else {
 226         len = ber_pvt_ber_write(ber);
 227     }
 228
 229     sprintf( buf, "ber_dump: buf=0x%08lx ptr=0x%08lx end=0x%08lx len=%ld\n",
 230              (long) ber->ber_buf,
 231              (long) ber->ber_ptr,
 232              (long) ber->ber_end,
 233              (long) len );
 234
 235     (void) ber_pvt_log_output( subsys, level, "%s", buf );
 236
 237 #define BP_OFFSET 9
 238 #define BP_GRAPH 60
 239 #define BP_LEN  80
 240
 241     assert( data != NULL );
 242
 243     /* in case len is zero */
 244     line[0] = '\n';
 245     line[1] = '\0';
 246
 247     for ( i = 0 ; i < len ; i++ ) {
 248         int n = i % 16;
 249         unsigned off;
 250
 251         if( !n ) {
 252             if( i ) {
 253                                 (void) ber_pvt_log_output( subsys, level, "%s", line );
 254                         }
 255             memset( line, ' ', sizeof(line)-2 );
 256             line[sizeof(line)-2] = '\n';
 257             line[sizeof(line)-1] = '\0';
 258
 259             off = i % 0x0ffffU;
 260
 261             line[ 2 ] = hexdig[ 0x0f & (off >> 12) ];
 262             line[ 3 ] = hexdig[ 0x0f & (off >>  8) ];
 263             line[ 4 ] = hexdig[ 0x0f & (off >>  4) ];
 264             line[ 5 ] = hexdig[ 0x0f & off ];
 265             line[ 6 ] = ':';
 266         }
 267
 268         off = BP_OFFSET + n*3 + ((n >= 8)?1:0);
 269         line[ off   ] = hexdig[ 0x0f & ( data[i] >> 4 ) ];
 270         line[ off+1 ] = hexdig[ 0x0f & data[i] ];
 271
 272         off = BP_GRAPH + n + ((n >= 8)?1:0);
 273
 274         if ( isprint( (unsigned char) data[i] )) {
 275             line[ BP_GRAPH + n ] = data[i];
 276         } else {
 277             line[ BP_GRAPH + n ] = '.';
 278         }
 279     }
 280
 281     return ber_pvt_log_output( subsys, level, "%s", line );
 282 }
 283 #endif
 284
 285 int
 286 ber_log_dump(
 287         int errlvl,
 288         int loglvl,
 289         BerElement *ber,
 290         int inout )
 291 {
 292         assert( ber != NULL );
 293         assert( LBER_VALID( ber ) );
 294
 295         if ( !ber_log_check( errlvl, loglvl )) {
 296                 return 0;
 297         }
 298
 299         ber_dump(ber, inout);
 300         return 1;
 301 }
 302
 303 void
 304 ber_dump(
 305         BerElement *ber,
 306         int inout )
 307 {
 308         char buf[132];
 309         ber_len_t len;
 310
 311         assert( ber != NULL );
 312         assert( LBER_VALID( ber ) );
 313
 314         if ( inout == 1 ) {
 315                 len = ber_pvt_ber_remaining(ber);
 316         } else {
 317                 len = ber_pvt_ber_write(ber);
 318         }
 319
 320         sprintf( buf, "ber_dump: buf=0x%08lx ptr=0x%08lx end=0x%08lx len=%ld\n",
 321             (long) ber->ber_buf,
 322                 (long) ber->ber_ptr,
 323                 (long) ber->ber_end,
 324                 (long) len );
 325
 326         (void) (*ber_pvt_log_print)( buf );
 327
 328         ber_bprint( ber->ber_ptr, len );
 329 }
 330
 331 int
 332 ber_log_sos_dump(
 333         int errlvl,
 334         int loglvl,
 335         Seqorset *sos )
 336 {
 337         assert( sos != NULL );
 338
 339         if ( !ber_log_check( errlvl, loglvl )) {
 340                 return 0;
 341         }
 342
 343         ber_sos_dump( sos );
 344         return 1;
 345 }
 346
 347 void
 348 ber_sos_dump(
 349         Seqorset *sos )
 350 {
 351         char buf[132];
 352
 353         assert( sos != NULL );
 354
 355         (*ber_pvt_log_print)( "*** sos dump ***\n" );
 356
 357         while ( sos != NULL ) {
 358                 sprintf( buf, "ber_sos_dump: clen %ld first 0x%lx ptr 0x%lx\n",
 359                     (long) sos->sos_clen,
 360                         (long) sos->sos_first,
 361                         (long) sos->sos_ptr );
 362                 (*ber_pvt_log_print)( buf );
 363
 364                 sprintf( buf, "              current len %ld contents:\n",
 365                     (long) (sos->sos_ptr - sos->sos_first) );
 366                 (*ber_pvt_log_print)( buf );
 367
 368                 ber_bprint( sos->sos_first, sos->sos_ptr - sos->sos_first );
 369
 370                 sos = sos->sos_next;
 371         }
 372
 373         (*ber_pvt_log_print)( "*** end dump ***\n" );
 374 }