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

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2002 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 #ifdef HAVE_VSNPRINTF
  91             buf[sizeof(buf) - 1] = '\0';
  92             vsnprintf( buf, sizeof(buf)-1, fmt, vl );
  93 #elif HAVE_VSPRINTF
  94             vsprintf( buf, fmt, vl ); /* hope it's not too long */
  95 #else
  96                 /* use doprnt() */
  97 #error "vsprintf() required.";
  98 #endif
  99             if ( ber_log_check( LDAP_DEBUG_BER, level ) )
 100                 (*ber_pvt_log_print)( buf );
 101         }
 102         va_end(vl);
 103
 104         return 1;
 105 }
 106
 107 int ber_pvt_log_printf( int errlvl, int loglvl, const char *fmt, ... )
 108 {
 109         char buf[ 1024 ];
 110         va_list ap;
 111
 112         assert( fmt != NULL );
 113
 114         if ( !ber_log_check( errlvl, loglvl )) {
 115                 return 0;
 116         }
 117
 118         va_start( ap, fmt );
 119
 120 #ifdef HAVE_VSNPRINTF
 121         buf[sizeof(buf) - 1] = '\0';
 122         vsnprintf( buf, sizeof(buf)-1, fmt, ap );
 123 #elif HAVE_VSPRINTF
 124         vsprintf( buf, fmt, ap ); /* hope it's not too long */
 125 #else
 126         /* use doprnt() */
 127 #error "vsprintf() required."
 128 #endif
 129
 130         va_end(ap);
 131
 132         (*ber_pvt_log_print)( buf );
 133         return 1;
 134 }
 135
 136 #if 0
 137 static int ber_log_puts(int errlvl, int loglvl, char *buf)
 138 {
 139         assert( buf != NULL );
 140
 141         if ( !ber_log_check( errlvl, loglvl )) {
 142                 return 0;
 143         }
 144
 145         (*ber_pvt_log_print)( buf );
 146         return 1;
 147 }
 148 #endif
 149
 150 /*
 151  * Print arbitrary stuff, for debugging.
 152  */
 153
 154 int
 155 ber_log_bprint(int errlvl,
 156         int loglvl,
 157         const char *data,
 158         ber_len_t len )
 159 {
 160         assert( data != NULL );
 161
 162         if ( !ber_log_check( errlvl, loglvl )) {
 163                 return 0;
 164         }
 165
 166         ber_bprint(data, len);
 167         return 1;
 168 }
 169
 170 void
 171 ber_bprint(
 172         LDAP_CONST char *data,
 173         ber_len_t len )
 174 {
 175         static const char       hexdig[] = "0123456789abcdef";
 176 #define BP_OFFSET 9
 177 #define BP_GRAPH 60
 178 #define BP_LEN  80
 179         char    line[ BP_LEN ];
 180         ber_len_t i;
 181
 182         assert( data != NULL );
 183
 184         /* in case len is zero */
 185         line[0] = '\n';
 186         line[1] = '\0';
 187
 188         for ( i = 0 ; i < len ; i++ ) {
 189                 int n = i % 16;
 190                 unsigned off;
 191
 192                 if( !n ) {
 193                         if( i ) (*ber_pvt_log_print)( line );
 194                         memset( line, ' ', sizeof(line)-2 );
 195                         line[sizeof(line)-2] = '\n';
 196                         line[sizeof(line)-1] = '\0';
 197
 198                         off = i % 0x0ffffU;
 199
 200                         line[ 2 ] = hexdig[ 0x0f & (off >> 12) ];
 201                         line[ 3 ] = hexdig[ 0x0f & (off >>  8) ];
 202                         line[ 4 ] = hexdig[ 0x0f & (off >>  4) ];
 203                         line[ 5 ] = hexdig[ 0x0f & off ];
 204                         line[ 6 ] = ':';
 205                 }
 206
 207                 off = BP_OFFSET + n*3 + ((n >= 8)?1:0);
 208                 line[ off   ] = hexdig[ 0x0f & ( data[i] >> 4 ) ];
 209                 line[ off+1 ] = hexdig[ 0x0f & data[i] ];
 210
 211                 off = BP_GRAPH + n + ((n >= 8)?1:0);
 212
 213                 if ( isprint( data[i] )) {
 214                         line[ BP_GRAPH + n ] = data[i];
 215                 } else {
 216                         line[ BP_GRAPH + n ] = '.';
 217                 }
 218         }
 219
 220         (*ber_pvt_log_print)( line );
 221 }
 222
 223 #ifdef NEW_LOGGING
 224 int ber_output_dump(
 225         const char *subsys,
 226         int level,
 227         BerElement *ber,
 228         int inout )
 229 {
 230     static const char   hexdig[] = "0123456789abcdef";
 231     char buf[132];
 232     ber_len_t len;
 233     char        line[ BP_LEN ];
 234     ber_len_t i;
 235     char *data = ber->ber_ptr;
 236
 237     if ( inout == 1 ) {
 238         len = ber_pvt_ber_remaining(ber);
 239     } else {
 240         len = ber_pvt_ber_write(ber);
 241     }
 242
 243     sprintf( buf, "ber_dump: buf=0x%08lx ptr=0x%08lx end=0x%08lx len=%ld\n",
 244              (long) ber->ber_buf,
 245              (long) ber->ber_ptr,
 246              (long) ber->ber_end,
 247              (long) len );
 248
 249     (void) ber_pvt_log_output( subsys, level, "%s", buf );
 250
 251 #define BP_OFFSET 9
 252 #define BP_GRAPH 60
 253 #define BP_LEN  80
 254
 255     assert( data != NULL );
 256
 257     /* in case len is zero */
 258     line[0] = '\n';
 259     line[1] = '\0';
 260
 261     for ( i = 0 ; i < len ; i++ ) {
 262         int n = i % 16;
 263         unsigned off;
 264
 265         if( !n ) {
 266             if( i ) {
 267                                 (void) ber_pvt_log_output( subsys, level, "%s", line );
 268                         }
 269             memset( line, ' ', sizeof(line)-2 );
 270             line[sizeof(line)-2] = '\n';
 271             line[sizeof(line)-1] = '\0';
 272
 273             off = i % 0x0ffffU;
 274
 275             line[ 2 ] = hexdig[ 0x0f & (off >> 12) ];
 276             line[ 3 ] = hexdig[ 0x0f & (off >>  8) ];
 277             line[ 4 ] = hexdig[ 0x0f & (off >>  4) ];
 278             line[ 5 ] = hexdig[ 0x0f & off ];
 279             line[ 6 ] = ':';
 280         }
 281
 282         off = BP_OFFSET + n*3 + ((n >= 8)?1:0);
 283         line[ off   ] = hexdig[ 0x0f & ( data[i] >> 4 ) ];
 284         line[ off+1 ] = hexdig[ 0x0f & data[i] ];
 285
 286         off = BP_GRAPH + n + ((n >= 8)?1:0);
 287
 288         if ( isprint( data[i] )) {
 289             line[ BP_GRAPH + n ] = data[i];
 290         } else {
 291             line[ BP_GRAPH + n ] = '.';
 292         }
 293     }
 294
 295     return ber_pvt_log_output( subsys, level, "%s", line );
 296 }
 297 #endif
 298
 299 int
 300 ber_log_dump(
 301         int errlvl,
 302         int loglvl,
 303         BerElement *ber,
 304         int inout )
 305 {
 306         assert( ber != NULL );
 307         assert( LBER_VALID( ber ) );
 308
 309         if ( !ber_log_check( errlvl, loglvl )) {
 310                 return 0;
 311         }
 312
 313         ber_dump(ber, inout);
 314         return 1;
 315 }
 316
 317 void
 318 ber_dump(
 319         BerElement *ber,
 320         int inout )
 321 {
 322         char buf[132];
 323         ber_len_t len;
 324
 325         assert( ber != NULL );
 326         assert( LBER_VALID( ber ) );
 327
 328         if ( inout == 1 ) {
 329                 len = ber_pvt_ber_remaining(ber);
 330         } else {
 331                 len = ber_pvt_ber_write(ber);
 332         }
 333
 334         sprintf( buf, "ber_dump: buf=0x%08lx ptr=0x%08lx end=0x%08lx len=%ld\n",
 335             (long) ber->ber_buf,
 336                 (long) ber->ber_ptr,
 337                 (long) ber->ber_end,
 338                 (long) len );
 339
 340         (void) (*ber_pvt_log_print)( buf );
 341
 342         ber_bprint( ber->ber_ptr, len );
 343 }
 344
 345 int
 346 ber_log_sos_dump(
 347         int errlvl,
 348         int loglvl,
 349         Seqorset *sos )
 350 {
 351         assert( sos != NULL );
 352
 353         if ( !ber_log_check( errlvl, loglvl )) {
 354                 return 0;
 355         }
 356
 357         ber_sos_dump( sos );
 358         return 1;
 359 }
 360
 361 void
 362 ber_sos_dump(
 363         Seqorset *sos )
 364 {
 365         char buf[132];
 366
 367         assert( sos != NULL );
 368
 369         (*ber_pvt_log_print)( "*** sos dump ***\n" );
 370
 371         while ( sos != NULL ) {
 372                 sprintf( buf, "ber_sos_dump: clen %ld first 0x%lx ptr 0x%lx\n",
 373                     (long) sos->sos_clen,
 374                         (long) sos->sos_first,
 375                         (long) sos->sos_ptr );
 376                 (*ber_pvt_log_print)( buf );
 377
 378                 sprintf( buf, "              current len %ld contents:\n",
 379                     (long) (sos->sos_ptr - sos->sos_first) );
 380                 (*ber_pvt_log_print)( buf );
 381
 382                 ber_bprint( sos->sos_first, sos->sos_ptr - sos->sos_first );
 383
 384                 sos = sos->sos_next;
 385         }
 386
 387         (*ber_pvt_log_print)( "*** end dump ***\n" );
 388 }