/* crypto/bio/b_print.c *//* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * * This package is an SSL implementation written * by Eric Young (eay@cryptsoft.com). * The implementation was written so as to conform with Netscapes SSL. *  * This library is free for commercial and non-commercial use as long as * the following conditions are aheared to.  The following conditions * apply to all code found in this distribution, be it the RC4, RSA, * lhash, DES, etc., code; not just the SSL code.  The SSL documentation * included with this distribution is covered by the same copyright terms * except that the holder is Tim Hudson (tjh@cryptsoft.com). *  * Copyright remains Eric Young's, and as such any Copyright notices in * the code are not to be removed. * If this package is used in a product, Eric Young should be given attribution * as the author of the parts of the library used. * This can be in the form of a textual message at program startup or * in documentation (online or textual) provided with the package. *  * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software *    must display the following acknowledgement: *    "This product includes cryptographic software written by *     Eric Young (eay@cryptsoft.com)" *    The word 'cryptographic' can be left out if the rouines from the library *    being used are not cryptographic related :-). * 4. If you include any Windows specific code (or a derivative thereof) from  *    the apps directory (application code) you must include an acknowledgement: *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" *  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. *  * The licence and distribution terms for any publically available version or * derivative of this code cannot be changed.  i.e. this code cannot simply be * copied and put under another distribution licence * [including the GNU Public Licence.] *//* disable assert() unless BIO_DEBUG has been defined */#ifndef BIO_DEBUG# ifndef NDEBUG#  define NDEBUG# endif#endif/*  * Stolen from tjh's ssl/ssl_trc.c stuff. */#include <stdio.h>#include <string.h>#include <ctype.h>#include <assert.h>#include <limits.h>#include "cryptlib.h"#ifndef NO_SYS_TYPES_H#include <sys/types.h>#endif#include <openssl/bn.h>         /* To get BN_LLONG properly defined */#include <openssl/bio.h>#if defined(BN_LLONG) || defined(SIXTY_FOUR_BIT)# ifndef HAVE_LONG_LONG#  define HAVE_LONG_LONG 1# endif#endif/***************************************************************************//* * Copyright Patrick Powell 1995 * This code is based on code written by Patrick Powell <papowell@astart.com> * It may be used for any purpose as long as this notice remains intact * on all source code distributions. *//* * This code contains numerious changes and enhancements which were * made by lots of contributors over the last years to Patrick Powell's * original code: * * o Patrick Powell <papowell@astart.com>      (1995) * o Brandon Long <blong@fiction.net>          (1996, for Mutt) * o Thomas Roessler <roessler@guug.de>        (1998, for Mutt) * o Michael Elkins <me@cs.hmc.edu>            (1998, for Mutt) * o Andrew Tridgell <tridge@samba.org>        (1998, for Samba) * o Luke Mewburn <lukem@netbsd.org>           (1999, for LukemFTP) * o Ralf S. Engelschall <rse@engelschall.com> (1999, for Pth) * o ...                                       (for OpenSSL) */#ifdef HAVE_LONG_DOUBLE#define LDOUBLE long double#else#define LDOUBLE double#endif#if HAVE_LONG_LONG# if defined(OPENSSL_SYS_WIN32) && !defined(__GNUC__)# define LLONG __int64# else# define LLONG long long# endif#else#define LLONG long#endifstatic void fmtstr     (char **, char **, size_t *, size_t *,			const char *, int, int, int);static void fmtint     (char **, char **, size_t *, size_t *,			LLONG, int, int, int, int);static void fmtfp      (char **, char **, size_t *, size_t *,			LDOUBLE, int, int, int);static void doapr_outch (char **, char **, size_t *, size_t *, int);static void _dopr(char **sbuffer, char **buffer,		  size_t *maxlen, size_t *retlen, int *truncated,		  const char *format, va_list args);/* format read states */#define DP_S_DEFAULT    0#define DP_S_FLAGS      1#define DP_S_MIN        2#define DP_S_DOT        3#define DP_S_MAX        4#define DP_S_MOD        5#define DP_S_CONV       6#define DP_S_DONE       7/* format flags - Bits */#define DP_F_MINUS      (1 << 0)#define DP_F_PLUS       (1 << 1)#define DP_F_SPACE      (1 << 2)#define DP_F_NUM        (1 << 3)#define DP_F_ZERO       (1 << 4)#define DP_F_UP         (1 << 5)#define DP_F_UNSIGNED   (1 << 6)/* conversion flags */#define DP_C_SHORT      1#define DP_C_LONG       2#define DP_C_LDOUBLE    3#define DP_C_LLONG      4/* some handy macros */#define char_to_int(p) (p - '0')#define OSSL_MAX(p,q) ((p >= q) ? p : q)static void_dopr(    char **sbuffer,    char **buffer,    size_t *maxlen,    size_t *retlen,    int *truncated,    const char *format,    va_list args){    char ch;    LLONG value;    LDOUBLE fvalue;    char *strvalue;    int min;    int max;    int state;    int flags;    int cflags;    size_t currlen;    state = DP_S_DEFAULT;    flags = currlen = cflags = min = 0;    max = -1;    ch = *format++;    while (state != DP_S_DONE) {        if (ch == '\0' || (buffer == NULL && currlen >= *maxlen))            state = DP_S_DONE;        switch (state) {        case DP_S_DEFAULT:            if (ch == '%')                state = DP_S_FLAGS;            else                doapr_outch(sbuffer,buffer, &currlen, maxlen, ch);            ch = *format++;            break;        case DP_S_FLAGS:            switch (ch) {            case '-':                flags |= DP_F_MINUS;                ch = *format++;                break;            case '+':                flags |= DP_F_PLUS;                ch = *format++;                break;            case ' ':                flags |= DP_F_SPACE;                ch = *format++;                break;            case '#':                flags |= DP_F_NUM;                ch = *format++;                break;            case '0':                flags |= DP_F_ZERO;                ch = *format++;                break;            default:                state = DP_S_MIN;                break;            }            break;        case DP_S_MIN:            if (isdigit((unsigned char)ch)) {                min = 10 * min + char_to_int(ch);                ch = *format++;            } else if (ch == '*') {                min = va_arg(args, int);                ch = *format++;                state = DP_S_DOT;            } else                state = DP_S_DOT;            break;        case DP_S_DOT:            if (ch == '.') {                state = DP_S_MAX;                ch = *format++;            } else                state = DP_S_MOD;            break;        case DP_S_MAX:            if (isdigit((unsigned char)ch)) {                if (max < 0)                    max = 0;                max = 10 * max + char_to_int(ch);                ch = *format++;            } else if (ch == '*') {                max = va_arg(args, int);                ch = *format++;                state = DP_S_MOD;            } else                state = DP_S_MOD;            break;        case DP_S_MOD:            switch (ch) {            case 'h':                cflags = DP_C_SHORT;                ch = *format++;                break;            case 'l':                if (*format == 'l') {                    cflags = DP_C_LLONG;                    format++;                } else                    cflags = DP_C_LONG;                ch = *format++;                break;            case 'q':                cflags = DP_C_LLONG;                ch = *format++;                break;            case 'L':                cflags = DP_C_LDOUBLE;                ch = *format++;                break;            default:                break;            }            state = DP_S_CONV;            break;        case DP_S_CONV:            switch (ch) {            case 'd':            case 'i':                switch (cflags) {                case DP_C_SHORT:                    value = (short int)va_arg(args, int);                    break;                case DP_C_LONG:                    value = va_arg(args, long int);                    break;                case DP_C_LLONG:                    value = va_arg(args, LLONG);                    break;                default:                    value = va_arg(args, int);                    break;                }                fmtint(sbuffer, buffer, &currlen, maxlen,                       value, 10, min, max, flags);                break;            case 'X':                flags |= DP_F_UP;                /* FALLTHROUGH */            case 'x':            case 'o':            case 'u':                flags |= DP_F_UNSIGNED;                switch (cflags) {                case DP_C_SHORT:                    value = (unsigned short int)va_arg(args, unsigned int);                    break;                case DP_C_LONG:                    value = (LLONG) va_arg(args,                        unsigned long int);                    break;                case DP_C_LLONG:                    value = va_arg(args, unsigned LLONG);                    break;                default:                    value = (LLONG) va_arg(args,                        unsigned int);                    break;                }                fmtint(sbuffer, buffer, &currlen, maxlen, value,                       ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),                       min, max, flags);                break;            case 'f':                if (cflags == DP_C_LDOUBLE)                    fvalue = va_arg(args, LDOUBLE);                else                    fvalue = va_arg(args, double);                fmtfp(sbuffer, buffer, &currlen, maxlen,                      fvalue, min, max, flags);                break;            case 'E':                flags |= DP_F_UP;            case 'e':                if (cflags == DP_C_LDOUBLE)                    fvalue = va_arg(args, LDOUBLE);                else                    fvalue = va_arg(args, double);                break;            case 'G':                flags |= DP_F_UP;            case 'g':                if (cflags == DP_C_LDOUBLE)                    fvalue = va_arg(args, LDOUBLE);                else                    fvalue = va_arg(args, double);                break;            case 'c':                doapr_outch(sbuffer, buffer, &currlen, maxlen,                    va_arg(args, int));                break;            case 's':                strvalue = va_arg(args, char *);                if (max < 0) {		    if (buffer)			max = INT_MAX;		    else			max = *maxlen;		}                fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue,                       flags, min, max);                break;            case 'p':                value = (long)va_arg(args, void *);                fmtint(sbuffer, buffer, &currlen, maxlen,                    value, 16, min, max, flags|DP_F_NUM);                break;            case 'n': /* XXX */                if (cflags == DP_C_SHORT) {                    short int *num;                    num = va_arg(args, short int *);                    *num = currlen;                } else if (cflags == DP_C_LONG) { /* XXX */                    long int *num;                    num = va_arg(args, long int *);                    *num = (long int) currlen;                } else if (cflags == DP_C_LLONG) { /* XXX */                    LLONG *num;                    num = va_arg(args, LLONG *);                    *num = (LLONG) currlen;                } else {                    int    *num;                    num = va_arg(args, int *);                    *num = currlen;                }                break;            case '%':                doapr_outch(sbuffer, buffer, &currlen, maxlen, ch);                break;            case 'w':                /* not supported yet, treat as next char */                ch = *format++;                break;            default:                /* unknown, skip */                break;            }            ch = *format++;            state = DP_S_DEFAULT;            flags = cflags = min = 0;            max = -1;            break;        case DP_S_DONE:            break;        default:            break;        }