Attachment #7512 for bug #40189

View | Details | Raw Unified | Return to bug 40189 | Differences between
Collapse All | Expand All




# define LLONG long
#endif

static int fmtstr(char **, char **, size_t *, size_t *,
                  const char *, int, int, int);
static int fmtint(char **, char **, size_t *, size_t *,
                  LLONG, int, int, int, int);
static int fmtfp(char **, char **, size_t *, size_t *,
                 LDOUBLE, int, int, int);
static int doapr_outch(char **, char **, size_t *, size_t *, int);
static int _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 char_to_int(p) (p - '0')
#define OSSL_MAX(p,q) ((p >= q) ? p : q)

static int
_dopr(char **sbuffer,
      char **buffer,
      size_t *maxlen,

            if (ch == '%')
                state = DP_S_FLAGS;
            else
                if(!doapr_outch(sbuffer, buffer, &currlen, maxlen, ch))
                    return 0;
            ch = *format++;
            break;
        case DP_S_FLAGS:

                    value = va_arg(args, int);
                    break;
                }
                if (!fmtint(sbuffer, buffer, &currlen, maxlen, value, 10, min,
                            max, flags))
                    return 0;
                break;
            case 'X':
                flags |= DP_F_UP;

                    value = (LLONG) va_arg(args, unsigned int);
                    break;
                }
                if (!fmtint(sbuffer, buffer, &currlen, maxlen, value,
                            ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),
                            min, max, flags))
                    return 0;
                break;
            case 'f':
                if (cflags == DP_C_LDOUBLE)
                    fvalue = va_arg(args, LDOUBLE);
                else
                    fvalue = va_arg(args, double);
                if (!fmtfp(sbuffer, buffer, &currlen, maxlen, fvalue, min, max,
                           flags))
                    return 0;
                break;
            case 'E':
                flags |= DP_F_UP;

                    fvalue = va_arg(args, double);
                break;
            case 'c':
                if(!doapr_outch(sbuffer, buffer, &currlen, maxlen,
                            va_arg(args, int)))
                    return 0;
                break;
            case 's':
                strvalue = va_arg(args, char *);

                    else
                        max = *maxlen;
                }
                if (!fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue,
                            flags, min, max))
                    return 0;
                break;
            case 'p':
                value = (long)va_arg(args, void *);
                if (!fmtint(sbuffer, buffer, &currlen, maxlen,
                            value, 16, min, max, flags | DP_F_NUM))
                    return 0;
                break;
            case 'n':          /* XXX */
                if (cflags == DP_C_SHORT) {

                }
                break;
            case '%':
                if(!doapr_outch(sbuffer, buffer, &currlen, maxlen, ch))
                    return 0;
                break;
            case 'w':
                /* not supported yet, treat as next char */

    *truncated = (currlen > *maxlen - 1);
    if (*truncated)
        currlen = *maxlen - 1;
    if(!doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0'))
        return 0;
    *retlen = currlen - 1;
    return 1;
}

static int
fmtstr(char **sbuffer,
       char **buffer,
       size_t *currlen,
       size_t *maxlen, const char *value, int flags, int min, int max)
{
    int padlen;
    size_t strln;
    int cnt = 0;

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

    strln = strlen(value);
    if (strln > INT_MAX)
        strln = INT_MAX;

    padlen = min - strln;
    if (min < 0 || padlen < 0)
        padlen = 0;
    if (flags & DP_F_MINUS)
        padlen = -padlen;

    while ((padlen > 0) && (cnt < max)) {
        if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
            return 0;
        --padlen;
        ++cnt;
    }
    while (*value && (cnt < max)) {
        if(!doapr_outch(sbuffer, buffer, currlen, maxlen, *value++))
            return 0;
        ++cnt;
    }
    while ((padlen < 0) && (cnt < max)) {
        if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
            return 0;
        ++padlen;
        ++cnt;
    }
    return 1;
}

static int
fmtint(char **sbuffer,
       char **buffer,
       size_t *currlen,


    /* spaces */
    while (spadlen > 0) {
        if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
            return 0;
        --spadlen;
    }

    /* sign */
    if (signvalue)
        if(!doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
            return 0;

    /* prefix */
    while (*prefix) {
        if(!doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix))
            return 0;
        prefix++;
    }

    /* zeros */
    if (zpadlen > 0) {
        while (zpadlen > 0) {
            if(!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
                return 0;
            --zpadlen;
        }
    }
    /* digits */
    while (place > 0) {
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]))
            return 0;
    }

    /* left justified spaces */
    while (spadlen < 0) {
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
            return 0;
        ++spadlen;
    }
    return 1;
}

static LDOUBLE abs_val(LDOUBLE value)

    return intpart;
}

static int
fmtfp(char **sbuffer,
      char **buffer,
      size_t *currlen,


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

    while (iplace > 0) {
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]))
            return 0;
    }

    /*
     * Decimal point. This should probably use locale to find the correct
     * char to print out.
     */
    if (max > 0 || (flags & DP_F_NUM)) {
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '.'))
            return 0;

        while (fplace > 0) {
            if(!doapr_outch(sbuffer, buffer, currlen, maxlen,
                            fconvert[--fplace]))
                return 0;
        }
    }
    while (zpadlen > 0) {
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
            return 0;
        --zpadlen;
    }

    while (padlen < 0) {
        if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
            return 0;
        ++padlen;
    }
    return 1;
}

#define BUFFER_INC  1024

static int
doapr_outch(char **sbuffer,
            char **buffer, size_t *currlen, size_t *maxlen, int c)
{

    assert(*currlen <= *maxlen);

    if (buffer && *currlen == *maxlen) {
        if (*maxlen > INT_MAX - BUFFER_INC)
            return 0;

        *maxlen += BUFFER_INC;
        if (*buffer == NULL) {
            *buffer = OPENSSL_malloc(*maxlen);
            if (*buffer == NULL)
                return 0;
                return;
            }
            if (*currlen > 0) {
                assert(*sbuffer != NULL);
                memcpy(*buffer, *sbuffer, *currlen);
            }
            *sbuffer = NULL;
        } else {
            char *tmpbuf;
            tmpbuf = OPENSSL_realloc(*buffer, *maxlen);
            if (tmpbuf == NULL)
                return 0;
            *buffer = tmpbuf;
        }
    }


            (*buffer)[(*currlen)++] = (char)c;
    }

    return 1;
}

/***************************************************************************/


    dynbuf = NULL;
    CRYPTO_push_info("doapr()");
    if (!_dopr(&hugebufp, &dynbuf, &hugebufsize, &retlen, &ignored, format,
                args)) {
        OPENSSL_free(dynbuf);
        return -1;
    }
    if (dynbuf) {
        ret = BIO_write(bio, dynbuf, (int)retlen);
        OPENSSL_free(dynbuf);

    size_t retlen;
    int truncated;

    if(!_dopr(&buf, NULL, &n, &retlen, &truncated, format, args))
        return -1;

    if (truncated)
        /*

Return to bug 40189

Lines 125-140 Link Here

(-)a/crypto/bio/b_print.c (-71 / +116 lines)
125	# define LLONG long	125	# define LLONG long
126	#endif	126	#endif
127		127
128	static void fmtstr(char , char , size_t , size_t ,	128	static int fmtstr(char , char , size_t , size_t ,
129	const char *, int, int, int);	129	const char *, int, int, int);
130	static void fmtint(char , char , size_t , size_t ,	130	static int fmtint(char , char , size_t , size_t ,
131	LLONG, int, int, int, int);	131	LLONG, int, int, int, int);
132	static void fmtfp(char , char , size_t , size_t ,	132	static int fmtfp(char , char , size_t , size_t ,
133	LDOUBLE, int, int, int);	133	LDOUBLE, int, int, int);
134	static void doapr_outch(char , char , size_t , size_t , int);	134	static int doapr_outch(char , char , size_t , size_t , int);
135	static void _dopr(char sbuffer, char buffer,	135	static int _dopr(char sbuffer, char buffer,
136	size_t maxlen, size_t retlen, int *truncated,	136	size_t maxlen, size_t retlen, int *truncated,
137	const char *format, va_list args);	137	const char *format, va_list args);
138		138
139	/* format read states */	139	/* format read states */
140	#define DP_S_DEFAULT 0	140	#define DP_S_DEFAULT 0
Lines 165-171 static void _dopr(char sbuffer, char buffer, Link Here
165	#define char_to_int(p) (p - '0')	165	#define char_to_int(p) (p - '0')
166	#define OSSL_MAX(p,q) ((p >= q) ? p : q)	166	#define OSSL_MAX(p,q) ((p >= q) ? p : q)
167		167
168	static void	168	static int
169	_dopr(char **sbuffer,	169	_dopr(char **sbuffer,
170	char **buffer,	170	char **buffer,
171	size_t *maxlen,	171	size_t *maxlen,
Lines 196-202 _dopr(char **sbuffer, Link Here
196	if (ch == '%')	196	if (ch == '%')
197	state = DP_S_FLAGS;	197	state = DP_S_FLAGS;
198	else	198	else
199	doapr_outch(sbuffer, buffer, &currlen, maxlen, ch);	199	if(!doapr_outch(sbuffer, buffer, &currlen, maxlen, ch))
		200	return 0;
200	ch = *format++;	201	ch = *format++;
201	break;	202	break;
202	case DP_S_FLAGS:	203	case DP_S_FLAGS:
Lines 302-309 _dopr(char **sbuffer, Link Here
302	value = va_arg(args, int);	303	value = va_arg(args, int);
303	break;	304	break;
304	}	305	}
305	fmtint(sbuffer, buffer, &currlen, maxlen,	306	if (!fmtint(sbuffer, buffer, &currlen, maxlen, value, 10, min,
306	value, 10, min, max, flags);	307	max, flags))
		308	return 0;
307	break;	309	break;
308	case 'X':	310	case 'X':
309	flags \|= DP_F_UP;	311	flags \|= DP_F_UP;
Lines 326-342 _dopr(char **sbuffer, Link Here
326	value = (LLONG) va_arg(args, unsigned int);	328	value = (LLONG) va_arg(args, unsigned int);
327	break;	329	break;
328	}	330	}
329	fmtint(sbuffer, buffer, &currlen, maxlen, value,	331	if (!fmtint(sbuffer, buffer, &currlen, maxlen, value,
330	ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),	332	ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),
331	min, max, flags);	333	min, max, flags))
		334	return 0;
332	break;	335	break;
333	case 'f':	336	case 'f':
334	if (cflags == DP_C_LDOUBLE)	337	if (cflags == DP_C_LDOUBLE)
335	fvalue = va_arg(args, LDOUBLE);	338	fvalue = va_arg(args, LDOUBLE);
336	else	339	else
337	fvalue = va_arg(args, double);	340	fvalue = va_arg(args, double);
338	fmtfp(sbuffer, buffer, &currlen, maxlen,	341	if (!fmtfp(sbuffer, buffer, &currlen, maxlen, fvalue, min, max,
339	fvalue, min, max, flags);	342	flags))
		343	return 0;
340	break;	344	break;
341	case 'E':	345	case 'E':
342	flags \|= DP_F_UP;	346	flags \|= DP_F_UP;
Lines 355-362 _dopr(char **sbuffer, Link Here
355	fvalue = va_arg(args, double);	359	fvalue = va_arg(args, double);
356	break;	360	break;
357	case 'c':	361	case 'c':
358	doapr_outch(sbuffer, buffer, &currlen, maxlen,	362	if(!doapr_outch(sbuffer, buffer, &currlen, maxlen,
359	va_arg(args, int));	363	va_arg(args, int)))
		364	return 0;
360	break;	365	break;
361	case 's':	366	case 's':
362	strvalue = va_arg(args, char *);	367	strvalue = va_arg(args, char *);
Lines 366-378 _dopr(char **sbuffer, Link Here
366	else	371	else
367	max = *maxlen;	372	max = *maxlen;
368	}	373	}
369	fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue,	374	if (!fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue,
370	flags, min, max);	375	flags, min, max))
		376	return 0;
371	break;	377	break;
372	case 'p':	378	case 'p':
373	value = (long)va_arg(args, void *);	379	value = (long)va_arg(args, void *);
374	fmtint(sbuffer, buffer, &currlen, maxlen,	380	if (!fmtint(sbuffer, buffer, &currlen, maxlen,
375	value, 16, min, max, flags \| DP_F_NUM);	381	value, 16, min, max, flags \| DP_F_NUM))
		382	return 0;
376	break;	383	break;
377	case 'n': /* XXX */	384	case 'n': /* XXX */
378	if (cflags == DP_C_SHORT) {	385	if (cflags == DP_C_SHORT) {
Lines 394-400 _dopr(char **sbuffer, Link Here
394	}	401	}
395	break;	402	break;
396	case '%':	403	case '%':
397	doapr_outch(sbuffer, buffer, &currlen, maxlen, ch);	404	if(!doapr_outch(sbuffer, buffer, &currlen, maxlen, ch))
		405	return 0;
398	break;	406	break;
399	case 'w':	407	case 'w':
400	/* not supported yet, treat as next char */	408	/* not supported yet, treat as next char */
Lines 418-463 _dopr(char **sbuffer, Link Here
418	truncated = (currlen > maxlen - 1);	426	truncated = (currlen > maxlen - 1);
419	if (*truncated)	427	if (*truncated)
420	currlen = *maxlen - 1;	428	currlen = *maxlen - 1;
421	doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0');	429	if(!doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0'))
		430	return 0;
422	*retlen = currlen - 1;	431	*retlen = currlen - 1;
423	return;	432	return 1;
424	}	433	}
425		434
426	static void	435	static int
427	fmtstr(char **sbuffer,	436	fmtstr(char **sbuffer,
428	char **buffer,	437	char **buffer,
429	size_t *currlen,	438	size_t *currlen,
430	size_t maxlen, const char value, int flags, int min, int max)	439	size_t maxlen, const char value, int flags, int min, int max)
431	{	440	{
432	int padlen, strln;	441	int padlen;
		442	size_t strln;
433	int cnt = 0;	443	int cnt = 0;
434		444
435	if (value == 0)	445	if (value == 0)
436	value = "<NULL>";	446	value = "<NULL>";
437	for (strln = 0; value[strln]; ++strln) ;	447
		448	strln = strlen(value);
		449	if (strln > INT_MAX)
		450	strln = INT_MAX;
		451
438	padlen = min - strln;	452	padlen = min - strln;
439	if (padlen < 0)	453	if (min < 0 \|\| padlen < 0)
440	padlen = 0;	454	padlen = 0;
441	if (flags & DP_F_MINUS)	455	if (flags & DP_F_MINUS)
442	padlen = -padlen;	456	padlen = -padlen;
443		457
444	while ((padlen > 0) && (cnt < max)) {	458	while ((padlen > 0) && (cnt < max)) {
445	doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');	459	if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
		460	return 0;
446	--padlen;	461	--padlen;
447	++cnt;	462	++cnt;
448	}	463	}
449	while (*value && (cnt < max)) {	464	while (*value && (cnt < max)) {
450	doapr_outch(sbuffer, buffer, currlen, maxlen, *value++);	465	if(!doapr_outch(sbuffer, buffer, currlen, maxlen, *value++))
		466	return 0;
451	++cnt;	467	++cnt;
452	}	468	}
453	while ((padlen < 0) && (cnt < max)) {	469	while ((padlen < 0) && (cnt < max)) {
454	doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');	470	if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
		471	return 0;
455	++padlen;	472	++padlen;
456	++cnt;	473	++cnt;
457	}	474	}
		475	return 1;
458	}	476	}
459		477
460	static void	478	static int
461	fmtint(char **sbuffer,	479	fmtint(char **sbuffer,
462	char **buffer,	480	char **buffer,
463	size_t *currlen,	481	size_t *currlen,
Lines 517-553 fmtint(char **sbuffer, Link Here
517		535
518	/* spaces */	536	/* spaces */
519	while (spadlen > 0) {	537	while (spadlen > 0) {
520	doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');	538	if(!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
		539	return 0;
521	--spadlen;	540	--spadlen;
522	}	541	}
523		542
524	/* sign */	543	/* sign */
525	if (signvalue)	544	if (signvalue)
526	doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);	545	if(!doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
		546	return 0;
527		547
528	/* prefix */	548	/* prefix */
529	while (*prefix) {	549	while (*prefix) {
530	doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix);	550	if(!doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix))
		551	return 0;
531	prefix++;	552	prefix++;
532	}	553	}
533		554
534	/* zeros */	555	/* zeros */
535	if (zpadlen > 0) {	556	if (zpadlen > 0) {
536	while (zpadlen > 0) {	557	while (zpadlen > 0) {
537	doapr_outch(sbuffer, buffer, currlen, maxlen, '0');	558	if(!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
		559	return 0;
538	--zpadlen;	560	--zpadlen;
539	}	561	}
540	}	562	}
541	/* digits */	563	/* digits */
542	while (place > 0)	564	while (place > 0) {
543	doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]);	565	if (!doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]))
		566	return 0;
		567	}
544		568
545	/* left justified spaces */	569	/* left justified spaces */
546	while (spadlen < 0) {	570	while (spadlen < 0) {
547	doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');	571	if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
		572	return 0;
548	++spadlen;	573	++spadlen;
549	}	574	}
550	return;	575	return 1;
551	}	576	}
552		577
553	static LDOUBLE abs_val(LDOUBLE value)	578	static LDOUBLE abs_val(LDOUBLE value)
Lines 578-584 static long roundv(LDOUBLE value) Link Here
578	return intpart;	603	return intpart;
579	}	604	}
580		605
581	static void	606	static int
582	fmtfp(char **sbuffer,	607	fmtfp(char **sbuffer,
583	char **buffer,	608	char **buffer,
584	size_t *currlen,	609	size_t *currlen,
Lines 657-703 fmtfp(char **sbuffer, Link Here
657		682
658	if ((flags & DP_F_ZERO) && (padlen > 0)) {	683	if ((flags & DP_F_ZERO) && (padlen > 0)) {
659	if (signvalue) {	684	if (signvalue) {
660	doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);	685	if (!doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
		686	return 0;
661	--padlen;	687	--padlen;
662	signvalue = 0;	688	signvalue = 0;
663	}	689	}
664	while (padlen > 0) {	690	while (padlen > 0) {
665	doapr_outch(sbuffer, buffer, currlen, maxlen, '0');	691	if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
		692	return 0;
666	--padlen;	693	--padlen;
667	}	694	}
668	}	695	}
669	while (padlen > 0) {	696	while (padlen > 0) {
670	doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');	697	if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
		698	return 0;
671	--padlen;	699	--padlen;
672	}	700	}
673	if (signvalue)	701	if (signvalue && !doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue))
674	doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);	702	return 0;
675		703
676	while (iplace > 0)	704	while (iplace > 0) {
677	doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]);	705	if (!doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]))
		706	return 0;
		707	}
678		708
679	/*	709	/*
680	* Decimal point. This should probably use locale to find the correct	710	* Decimal point. This should probably use locale to find the correct
681	* char to print out.	711	* char to print out.
682	*/	712	*/
683	if (max > 0 \|\| (flags & DP_F_NUM)) {	713	if (max > 0 \|\| (flags & DP_F_NUM)) {
684	doapr_outch(sbuffer, buffer, currlen, maxlen, '.');	714	if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '.'))
		715	return 0;
685		716
686	while (fplace > 0)	717	while (fplace > 0) {
687	doapr_outch(sbuffer, buffer, currlen, maxlen, fconvert[--fplace]);	718	if(!doapr_outch(sbuffer, buffer, currlen, maxlen,
		719	fconvert[--fplace]))
		720	return 0;
		721	}
688	}	722	}
689	while (zpadlen > 0) {	723	while (zpadlen > 0) {
690	doapr_outch(sbuffer, buffer, currlen, maxlen, '0');	724	if (!doapr_outch(sbuffer, buffer, currlen, maxlen, '0'))
		725	return 0;
691	--zpadlen;	726	--zpadlen;
692	}	727	}
693		728
694	while (padlen < 0) {	729	while (padlen < 0) {
695	doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');	730	if (!doapr_outch(sbuffer, buffer, currlen, maxlen, ' '))
		731	return 0;
696	++padlen;	732	++padlen;
697	}	733	}
		734	return 1;
698	}	735	}
699		736
700	static void	737	#define BUFFER_INC 1024
		738
		739	static int
701	doapr_outch(char **sbuffer,	740	doapr_outch(char **sbuffer,
702	char *buffer, size_t currlen, size_t *maxlen, int c)	741	char *buffer, size_t currlen, size_t *maxlen, int c)
703	{	742	{
Lines 708-731 doapr_outch(char **sbuffer, Link Here
708	assert(currlen <= maxlen);	747	assert(currlen <= maxlen);
709		748
710	if (buffer && currlen == maxlen) {	749	if (buffer && currlen == maxlen) {
711	*maxlen += 1024;	750	if (*maxlen > INT_MAX - BUFFER_INC)
		751	return 0;
		752
		753	*maxlen += BUFFER_INC;
712	if (*buffer == NULL) {	754	if (*buffer == NULL) {
713	buffer = OPENSSL_malloc(maxlen);	755	buffer = OPENSSL_malloc(maxlen);
714	if (!*buffer) {	756	if (*buffer == NULL)
715	/* Panic! Can't really do anything sensible. Just return */	757	return 0;
716	return;
717	}
718	if (*currlen > 0) {	758	if (*currlen > 0) {
719	assert(*sbuffer != NULL);	759	assert(*sbuffer != NULL);
720	memcpy(buffer, sbuffer, *currlen);	760	memcpy(buffer, sbuffer, *currlen);
721	}	761	}
722	*sbuffer = NULL;	762	*sbuffer = NULL;
723	} else {	763	} else {
724	buffer = OPENSSL_realloc(buffer, *maxlen);	764	char *tmpbuf;
725	if (!*buffer) {	765	tmpbuf = OPENSSL_realloc(buffer, maxlen);
726	/* Panic! Can't really do anything sensible. Just return */	766	if (tmpbuf == NULL)
727	return;	767	return 0;
728	}	768	*buffer = tmpbuf;
729	}	769	}
730	}	770	}
731		771
Lines 736-742 doapr_outch(char **sbuffer, Link Here
736	(buffer)[(currlen)++] = (char)c;	776	(buffer)[(currlen)++] = (char)c;
737	}	777	}
738		778
739	return;	779	return 1;
740	}	780	}
741		781
742	/***************************************************************************/	782	/***************************************************************************/
Lines 768-774 int BIO_vprintf(BIO bio, const char format, va_list args) Link Here
768		808
769	dynbuf = NULL;	809	dynbuf = NULL;
770	CRYPTO_push_info("doapr()");	810	CRYPTO_push_info("doapr()");
771	_dopr(&hugebufp, &dynbuf, &hugebufsize, &retlen, &ignored, format, args);	811	if (!_dopr(&hugebufp, &dynbuf, &hugebufsize, &retlen, &ignored, format,
		812	args)) {
		813	OPENSSL_free(dynbuf);
		814	return -1;
		815	}
772	if (dynbuf) {	816	if (dynbuf) {
773	ret = BIO_write(bio, dynbuf, (int)retlen);	817	ret = BIO_write(bio, dynbuf, (int)retlen);
774	OPENSSL_free(dynbuf);	818	OPENSSL_free(dynbuf);
Lines 803-809 int BIO_vsnprintf(char buf, size_t n, const char format, va_list args) Link Here
803	size_t retlen;	847	size_t retlen;
804	int truncated;	848	int truncated;
805		849
806	_dopr(&buf, NULL, &n, &retlen, &truncated, format, args);	850	if(!_dopr(&buf, NULL, &n, &retlen, &truncated, format, args))
		851	return -1;
807		852
808	if (truncated)	853	if (truncated)
809	/*	854	/*