libraries/liblber/bprint.c

/*        $NetBSD: bprint.c,v 1.3 2021/08/14 16:14:55 christos Exp $  */

/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
 *
 * Copyright 1998-2021 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
 * <http://www.OpenLDAP.org/license.html>.
 */
/*
 * 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 <sys/cdefs.h>
__RCSID("$NetBSD: bprint.c,v 1.3 2021/08/14 16:14:55 christos Exp $");

#include "portable.h"

#include <stdio.h>

#include <ac/ctype.h>
#include <ac/stdarg.h>
#include <ac/string.h>

#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=%p ptr=%p end=%p len=%ld\n",
                    ber->ber_buf,
                    ber->ber_ptr,
                    ber->ber_end,
                    (long) len );

          (void) (*ber_pvt_log_print)( buf );

          ber_bprint( ber->ber_ptr, len );
}

typedef struct seqorset Seqorset;

/* Exists for binary compatibility with OpenLDAP 2.4.17-- */
int
ber_log_sos_dump(
          int errlvl,
          int loglvl,
          Seqorset *sos )
{
          return 0;
}

/* Exists for binary compatibility with OpenLDAP 2.4.17-- */
void
ber_sos_dump(
          Seqorset *sos )
{
}