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