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

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