Use public domain snprintf() implementation by Patrick Powell to avoid (9fd4ee5d) · Commits · CYBER - Cyber Security / TS 103 523 MSP / TLMSP / TLMSP OpenSSL

crypto/bio/b_print.c

+613 −1

Original line number	Diff line number	Diff line
		@@ -65,6 +65,9 @@
		#include "cryptlib.h"
		#include <openssl/bio.h>

		static void dopr (char buffer, size_t maxlen, const char format,
		va_list args);

		int BIO_printf (BIO *bio, ...)
		{
		va_list args;
		@@ -77,7 +80,7 @@ int BIO_printf (BIO *bio, ...)

		hugebuf[0]='\0';

		vsprintf(hugebuf,format,args);
		dopr(hugebuf, sizeof(hugebuf), format, args);

		ret=BIO_write(bio,hugebuf,strlen(hugebuf));

		@@ -85,3 +88,612 @@ int BIO_printf (BIO *bio, ...)
		return(ret);
		}

		/*
		* 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
		*/

		#include <string.h>
		#include <ctype.h>
		#include <sys/types.h>
		#include <stdarg.h>

		static void fmtstr (char buffer, size_t currlen, size_t maxlen,
		char *value, int flags, int min, int max);
		static void fmtint (char buffer, size_t currlen, size_t maxlen,
		long value, int base, int min, int max, int flags);
		static void fmtfp (char buffer, size_t currlen, size_t maxlen,
		long double fvalue, int min, int max, int flags);
		static void dopr_outch (char buffer, size_t currlen, size_t maxlen, char c );

		/*
		* dopr(): poor man's version of doprintf
		*/

		/* 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 char_to_int(p) (p - '0')
		#define MAX(p,q) ((p >= q) ? p : q)

		static void dopr (char buffer, size_t maxlen, const char format, va_list args)
		{
		char ch;
		long value;
		long double fvalue;
		char *strvalue;
		int min;
		int max;
		int state;
		int flags;
		int cflags;
		size_t currlen;

		state = DP_S_DEFAULT;
		currlen = flags = cflags = min = 0;
		max = -1;
		ch = *format++;

		while (state != DP_S_DONE)
		{
		if ((ch == '\0') \|\| (currlen >= maxlen))
		state = DP_S_DONE;

		switch(state)
		{
		case DP_S_DEFAULT:
		if (ch == '%')
		state = DP_S_FLAGS;
		else
		dopr_outch (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:
		/* Currently, we don't support Long Long, bummer */
		switch (ch)
		{
		case 'h':
		cflags = DP_C_SHORT;
		ch = *format++;
		break;
		case 'l':
		cflags = DP_C_LONG;
		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':
		if (cflags == DP_C_SHORT)
		value = va_arg (args, short int);
		else if (cflags == DP_C_LONG)
		value = va_arg (args, long int);
		else
		value = va_arg (args, int);
		fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
		break;
		case 'o':
		flags \|= DP_F_UNSIGNED;
		if (cflags == DP_C_SHORT)
		value = va_arg (args, unsigned short int);
		else if (cflags == DP_C_LONG)
		value = va_arg (args, unsigned long int);
		else
		value = va_arg (args, unsigned int);
		fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
		break;
		case 'u':
		flags \|= DP_F_UNSIGNED;
		if (cflags == DP_C_SHORT)
		value = va_arg (args, unsigned short int);
		else if (cflags == DP_C_LONG)
		value = va_arg (args, unsigned long int);
		else
		value = va_arg (args, unsigned int);
		fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
		break;
		case 'X':
		flags \|= DP_F_UP;
		case 'x':
		flags \|= DP_F_UNSIGNED;
		if (cflags == DP_C_SHORT)
		value = va_arg (args, unsigned short int);
		else if (cflags == DP_C_LONG)
		value = va_arg (args, unsigned long int);
		else
		value = va_arg (args, unsigned int);
		fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
		break;
		case 'f':
		if (cflags == DP_C_LDOUBLE)
		fvalue = va_arg (args, long double);
		else
		fvalue = va_arg (args, double);
		/* um, floating point? */
		fmtfp (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, long double);
		else
		fvalue = va_arg (args, double);
		break;
		case 'G':
		flags \|= DP_F_UP;
		case 'g':
		if (cflags == DP_C_LDOUBLE)
		fvalue = va_arg (args, long double);
		else
		fvalue = va_arg (args, double);
		break;
		case 'c':
		dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
		break;
		case 's':
		strvalue = va_arg (args, char *);
		if (max < 0)
		max = maxlen; /* ie, no max */
		fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
		break;
		case 'p':
		strvalue = va_arg (args, void *);
		fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
		break;
		case 'n':
		if (cflags == DP_C_SHORT)
		{
		short int *num;
		num = va_arg (args, short int *);
		*num = currlen;
		}
		else if (cflags == DP_C_LONG)
		{
		long int *num;
		num = va_arg (args, long int *);
		*num = currlen;
		}
		else
		{
		int *num;
		num = va_arg (args, int *);
		*num = currlen;
		}
		break;
		case '%':
		dopr_outch (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:
		/* hmm? */
		break; /* some picky compilers need this */
		}
		}
		if (currlen < maxlen - 1)
		buffer[currlen] = '\0';
		else
		buffer[maxlen - 1] = '\0';
		}

		static void fmtstr (char buffer, size_t currlen, size_t maxlen,
		char *value, int flags, int min, int max)
		{
		int padlen, strln; /* amount to pad */
		int cnt = 0;

		if (value == 0)
		{
		value = "<NULL>";
		}

		for (strln = 0; value[strln]; ++strln); /* strlen */
		padlen = min - strln;
		if (padlen < 0)
		padlen = 0;
		if (flags & DP_F_MINUS)
		padlen = -padlen; /* Left Justify */

		while ((padlen > 0) && (cnt < max))
		{
		dopr_outch (buffer, currlen, maxlen, ' ');
		--padlen;
		++cnt;
		}
		while (*value && (cnt < max))
		{
		dopr_outch (buffer, currlen, maxlen, *value++);
		++cnt;
		}
		while ((padlen < 0) && (cnt < max))
		{
		dopr_outch (buffer, currlen, maxlen, ' ');
		++padlen;
		++cnt;
		}
		}

		/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */

		static void fmtint (char buffer, size_t currlen, size_t maxlen,
		long value, int base, int min, int max, int flags)
		{
		int signvalue = 0;
		unsigned long uvalue;
		char convert[20];
		int place = 0;
		int spadlen = 0; /* amount to space pad */
		int zpadlen = 0; /* amount to zero pad */
		int caps = 0;

		if (max < 0)
		max = 0;

		uvalue = value;

		if(!(flags & DP_F_UNSIGNED))
		{
		if( value < 0 ) {
		signvalue = '-';
		uvalue = -value;
		}
		else
		if (flags & DP_F_PLUS) /* Do a sign (+/i) */
		signvalue = '+';
		else
		if (flags & DP_F_SPACE)
		signvalue = ' ';
		}

		if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */

		do {
		convert[place++] =
		(caps? "0123456789ABCDEF":"0123456789abcdef")
		[uvalue % (unsigned)base ];
		uvalue = (uvalue / (unsigned)base );
		} while(uvalue && (place < 20));
		if (place == 20) place--;
		convert[place] = 0;

		zpadlen = max - place;
		spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
		if (zpadlen < 0) zpadlen = 0;
		if (spadlen < 0) spadlen = 0;
		if (flags & DP_F_ZERO)
		{
		zpadlen = MAX(zpadlen, spadlen);
		spadlen = 0;
		}
		if (flags & DP_F_MINUS)
		spadlen = -spadlen; /* Left Justifty */

		#ifdef DEBUG_SNPRINTF
		dprint (1, (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
		zpadlen, spadlen, min, max, place));
		#endif

		/* Spaces */
		while (spadlen > 0)
		{
		dopr_outch (buffer, currlen, maxlen, ' ');
		--spadlen;
		}

		/* Sign */
		if (signvalue)
		dopr_outch (buffer, currlen, maxlen, signvalue);

		/* Zeros */
		if (zpadlen > 0)
		{
		while (zpadlen > 0)
		{
		dopr_outch (buffer, currlen, maxlen, '0');
		--zpadlen;
		}
		}

		/* Digits */
		while (place > 0)
		dopr_outch (buffer, currlen, maxlen, convert[--place]);

		/* Left Justified spaces */
		while (spadlen < 0) {
		dopr_outch (buffer, currlen, maxlen, ' ');
		++spadlen;
		}
		}

		static long double abs_val (long double value)
		{
		long double result = value;

		if (value < 0)
		result = -value;

		return result;
		}

		static long double pow10 (int exp)
		{
		long double result = 1;

		while (exp)
		{
		result *= 10;
		exp--;
		}

		return result;
		}

		static long round (long double value)
		{
		long intpart;

		intpart = value;
		value = value - intpart;
		if (value >= 0.5)
		intpart++;

		return intpart;
		}

		static void fmtfp (char buffer, size_t currlen, size_t maxlen,
		long double fvalue, int min, int max, int flags)
		{
		int signvalue = 0;
		long double ufvalue;
		char iconvert[20];
		char fconvert[20];
		int iplace = 0;
		int fplace = 0;
		int padlen = 0; /* amount to pad */
		int zpadlen = 0;
		int caps = 0;
		long intpart;
		long fracpart;

		/*
		* AIX manpage says the default is 0, but Solaris says the default
		* is 6, and sprintf on AIX defaults to 6
		*/
		if (max < 0)
		max = 6;

		ufvalue = abs_val (fvalue);

		if (fvalue < 0)
		signvalue = '-';
		else
		if (flags & DP_F_PLUS) /* Do a sign (+/i) */
		signvalue = '+';
		else
		if (flags & DP_F_SPACE)
		signvalue = ' ';

		#if 0
		if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
		#endif

		intpart = ufvalue;

		/*
		* Sorry, we only support 9 digits past the decimal because of our
		* conversion method
		*/
		if (max > 9)
		max = 9;

		/* We "cheat" by converting the fractional part to integer by
		* multiplying by a factor of 10
		*/
		fracpart = round ((pow10 (max)) * (ufvalue - intpart));

		if (fracpart >= pow10 (max))
		{
		intpart++;
		fracpart -= pow10 (max);
		}

		#ifdef DEBUG_SNPRINTF
		dprint (1, (debugfile, "fmtfp: %f =? %d.%d\n", fvalue, intpart, fracpart));
		#endif

		/* Convert integer part */
		do {
		iconvert[iplace++] =
		(caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10];
		intpart = (intpart / 10);
		} while(intpart && (iplace < 20));
		if (iplace == 20) iplace--;
		iconvert[iplace] = 0;

		/* Convert fractional part */
		do {
		fconvert[fplace++] =
		(caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
		fracpart = (fracpart / 10);
		} while(fracpart && (fplace < 20));
		if (fplace == 20) fplace--;
		fconvert[fplace] = 0;

		/* -1 for decimal point, another -1 if we are printing a sign */
		padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
		zpadlen = max - fplace;
		if (zpadlen < 0)
		zpadlen = 0;
		if (padlen < 0)
		padlen = 0;
		if (flags & DP_F_MINUS)
		padlen = -padlen; /* Left Justifty */

		if ((flags & DP_F_ZERO) && (padlen > 0))
		{
		if (signvalue)
		{
		dopr_outch (buffer, currlen, maxlen, signvalue);
		--padlen;
		signvalue = 0;
		}
		while (padlen > 0)
		{
		dopr_outch (buffer, currlen, maxlen, '0');
		--padlen;
		}
		}
		while (padlen > 0)
		{
		dopr_outch (buffer, currlen, maxlen, ' ');
		--padlen;
		}
		if (signvalue)
		dopr_outch (buffer, currlen, maxlen, signvalue);

		while (iplace > 0)
		dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);

		/*
		* Decimal point. This should probably use locale to find the correct
		* char to print out.
		*/
		dopr_outch (buffer, currlen, maxlen, '.');

		while (fplace > 0)
		dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);

		while (zpadlen > 0)
		{
		dopr_outch (buffer, currlen, maxlen, '0');
		--zpadlen;
		}

		while (padlen < 0)
		{
		dopr_outch (buffer, currlen, maxlen, ' ');
		++padlen;
		}
		}

		static void dopr_outch (char buffer, size_t currlen, size_t maxlen, char c)
		{
		if (*currlen < maxlen)
		buffer[(*currlen)++] = c;
		}