summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/bio/b_print.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/bio/b_print.c')
-rw-r--r--src/lib/libcrypto/bio/b_print.c1149
1 files changed, 558 insertions, 591 deletions
diff --git a/src/lib/libcrypto/bio/b_print.c b/src/lib/libcrypto/bio/b_print.c
index 143a7cfefa..b3b0d45ee6 100644
--- a/src/lib/libcrypto/bio/b_print.c
+++ b/src/lib/libcrypto/bio/b_print.c
@@ -125,16 +125,15 @@
125#define LLONG long 125#define LLONG long
126#endif 126#endif
127 127
128static void fmtstr (char **, char **, size_t *, size_t *, 128static void fmtstr(char **, char **, size_t *, size_t *, const char *,
129 const char *, int, int, int); 129 int, int, int);
130static void fmtint (char **, char **, size_t *, size_t *, 130static void fmtint(char **, char **, size_t *, size_t *, LLONG, int,
131 LLONG, int, int, int, int); 131 int, int, int);
132static void fmtfp (char **, char **, size_t *, size_t *, 132static void fmtfp(char **, char **, size_t *, size_t *, LDOUBLE,
133 LDOUBLE, int, int, int); 133 int, int, int);
134static void doapr_outch (char **, char **, size_t *, size_t *, int); 134static void doapr_outch(char **, char **, size_t *, size_t *, int);
135static void _dopr(char **sbuffer, char **buffer, 135static void _dopr(char **sbuffer, char **buffer, size_t *maxlen,
136 size_t *maxlen, size_t *retlen, int *truncated, 136 size_t *retlen, int *truncated, const char *format, va_list args);
137 const char *format, va_list args);
138 137
139/* format read states */ 138/* format read states */
140#define DP_S_DEFAULT 0 139#define DP_S_DEFAULT 0
@@ -166,607 +165,576 @@ static void _dopr(char **sbuffer, char **buffer,
166#define OSSL_MAX(p,q) ((p >= q) ? p : q) 165#define OSSL_MAX(p,q) ((p >= q) ? p : q)
167 166
168static void 167static void
169_dopr( 168_dopr(char **sbuffer, char **buffer, size_t *maxlen, size_t *retlen,
170 char **sbuffer, 169 int *truncated, const char *format, va_list args)
171 char **buffer,
172 size_t *maxlen,
173 size_t *retlen,
174 int *truncated,
175 const char *format,
176 va_list args)
177{ 170{
178 char ch; 171 char ch;
179 LLONG value; 172 LLONG value;
180 LDOUBLE fvalue; 173 LDOUBLE fvalue;
181 char *strvalue; 174 char *strvalue;
182 int min; 175 int min;
183 int max; 176 int max;
184 int state; 177 int state;
185 int flags; 178 int flags;
186 int cflags; 179 int cflags;
187 size_t currlen; 180 size_t currlen;
188 181
189 state = DP_S_DEFAULT; 182 state = DP_S_DEFAULT;
190 flags = currlen = cflags = min = 0; 183 flags = currlen = cflags = min = 0;
191 max = -1; 184 max = -1;
192 ch = *format++; 185 ch = *format++;
193 186
194 while (state != DP_S_DONE) { 187 while (state != DP_S_DONE) {
195 if (ch == '\0' || (buffer == NULL && currlen >= *maxlen)) 188 if (ch == '\0' || (buffer == NULL && currlen >= *maxlen))
196 state = DP_S_DONE; 189 state = DP_S_DONE;
197 190
198 switch (state) { 191 switch (state) {
199 case DP_S_DEFAULT: 192 case DP_S_DEFAULT:
200 if (ch == '%') 193 if (ch == '%')
201 state = DP_S_FLAGS; 194 state = DP_S_FLAGS;
202 else 195 else
203 doapr_outch(sbuffer,buffer, &currlen, maxlen, ch); 196 doapr_outch(sbuffer, buffer, &currlen, maxlen, ch);
204 ch = *format++; 197 ch = *format++;
205 break; 198 break;
206 case DP_S_FLAGS: 199 case DP_S_FLAGS:
207 switch (ch) { 200 switch (ch) {
208 case '-': 201 case '-':
209 flags |= DP_F_MINUS; 202 flags |= DP_F_MINUS;
210 ch = *format++; 203 ch = *format++;
211 break; 204 break;
212 case '+': 205 case '+':
213 flags |= DP_F_PLUS; 206 flags |= DP_F_PLUS;
214 ch = *format++; 207 ch = *format++;
215 break; 208 break;
216 case ' ': 209 case ' ':
217 flags |= DP_F_SPACE; 210 flags |= DP_F_SPACE;
218 ch = *format++; 211 ch = *format++;
219 break; 212 break;
220 case '#': 213 case '#':
221 flags |= DP_F_NUM; 214 flags |= DP_F_NUM;
222 ch = *format++; 215 ch = *format++;
223 break; 216 break;
224 case '0': 217 case '0':
225 flags |= DP_F_ZERO; 218 flags |= DP_F_ZERO;
226 ch = *format++; 219 ch = *format++;
227 break; 220 break;
228 default: 221 default:
229 state = DP_S_MIN; 222 state = DP_S_MIN;
230 break; 223 break;
231 } 224 }
232 break; 225 break;
233 case DP_S_MIN: 226 case DP_S_MIN:
234 if (isdigit((unsigned char)ch)) { 227 if (isdigit((unsigned char)ch)) {
235 min = 10 * min + char_to_int(ch); 228 min = 10 * min + char_to_int(ch);
236 ch = *format++; 229 ch = *format++;
237 } else if (ch == '*') { 230 } else if (ch == '*') {
238 min = va_arg(args, int); 231 min = va_arg(args, int);
239 ch = *format++; 232 ch = *format++;
240 state = DP_S_DOT; 233 state = DP_S_DOT;
241 } else 234 } else
242 state = DP_S_DOT; 235 state = DP_S_DOT;
243 break; 236 break;
244 case DP_S_DOT: 237 case DP_S_DOT:
245 if (ch == '.') { 238 if (ch == '.') {
246 state = DP_S_MAX; 239 state = DP_S_MAX;
247 ch = *format++; 240 ch = *format++;
248 } else 241 } else
249 state = DP_S_MOD; 242 state = DP_S_MOD;
250 break; 243 break;
251 case DP_S_MAX: 244 case DP_S_MAX:
252 if (isdigit((unsigned char)ch)) { 245 if (isdigit((unsigned char)ch)) {
253 if (max < 0) 246 if (max < 0)
254 max = 0; 247 max = 0;
255 max = 10 * max + char_to_int(ch); 248 max = 10 * max + char_to_int(ch);
256 ch = *format++; 249 ch = *format++;
257 } else if (ch == '*') { 250 } else if (ch == '*') {
258 max = va_arg(args, int); 251 max = va_arg(args, int);
259 ch = *format++; 252 ch = *format++;
260 state = DP_S_MOD; 253 state = DP_S_MOD;
261 } else 254 } else
262 state = DP_S_MOD; 255 state = DP_S_MOD;
263 break; 256 break;
264 case DP_S_MOD: 257 case DP_S_MOD:
265 switch (ch) { 258 switch (ch) {
266 case 'h': 259 case 'h':
267 cflags = DP_C_SHORT; 260 cflags = DP_C_SHORT;
268 ch = *format++; 261 ch = *format++;
269 break; 262 break;
270 case 'l': 263 case 'l':
271 if (*format == 'l') { 264 if (*format == 'l') {
272 cflags = DP_C_LLONG; 265 cflags = DP_C_LLONG;
273 format++; 266 format++;
274 } else 267 } else
275 cflags = DP_C_LONG; 268 cflags = DP_C_LONG;
276 ch = *format++; 269 ch = *format++;
277 break; 270 break;
278 case 'q': 271 case 'q':
279 cflags = DP_C_LLONG; 272 cflags = DP_C_LLONG;
280 ch = *format++; 273 ch = *format++;
281 break; 274 break;
282 case 'L': 275 case 'L':
283 cflags = DP_C_LDOUBLE; 276 cflags = DP_C_LDOUBLE;
284 ch = *format++; 277 ch = *format++;
285 break; 278 break;
286 default: 279 default:
287 break; 280 break;
288 } 281 }
289 state = DP_S_CONV; 282 state = DP_S_CONV;
290 break; 283 break;
291 case DP_S_CONV: 284 case DP_S_CONV:
292 switch (ch) { 285 switch (ch) {
293 case 'd': 286 case 'd':
294 case 'i': 287 case 'i':
295 switch (cflags) { 288 switch (cflags) {
296 case DP_C_SHORT: 289 case DP_C_SHORT:
297 value = (short int)va_arg(args, int); 290 value = (short int)va_arg(args, int);
298 break; 291 break;
299 case DP_C_LONG: 292 case DP_C_LONG:
300 value = va_arg(args, long int); 293 value = va_arg(args, long int);
301 break; 294 break;
302 case DP_C_LLONG: 295 case DP_C_LLONG:
303 value = va_arg(args, LLONG); 296 value = va_arg(args, LLONG);
304 break; 297 break;
305 default: 298 default:
306 value = va_arg(args, int); 299 value = va_arg(args, int);
307 break; 300 break;
308 } 301 }
309 fmtint(sbuffer, buffer, &currlen, maxlen, 302 fmtint(sbuffer, buffer, &currlen, maxlen,
310 value, 10, min, max, flags); 303 value, 10, min, max, flags);
311 break; 304 break;
312 case 'X': 305 case 'X':
313 flags |= DP_F_UP; 306 flags |= DP_F_UP;
314 /* FALLTHROUGH */ 307 /* FALLTHROUGH */
315 case 'x': 308 case 'x':
316 case 'o': 309 case 'o':
317 case 'u': 310 case 'u':
318 flags |= DP_F_UNSIGNED; 311 flags |= DP_F_UNSIGNED;
319 switch (cflags) { 312 switch (cflags) {
320 case DP_C_SHORT: 313 case DP_C_SHORT:
321 value = (unsigned short int)va_arg(args, unsigned int); 314 value = (unsigned short int)va_arg(
322 break; 315 args, unsigned int);
323 case DP_C_LONG: 316 break;
324 value = (LLONG) va_arg(args, 317 case DP_C_LONG:
325 unsigned long int); 318 value = (LLONG)va_arg(args,
326 break; 319 unsigned long int);
327 case DP_C_LLONG: 320 break;
328 value = va_arg(args, unsigned LLONG); 321 case DP_C_LLONG:
329 break; 322 value = va_arg(args, unsigned LLONG);
330 default: 323 break;
331 value = (LLONG) va_arg(args, 324 default:
332 unsigned int); 325 value = (LLONG)va_arg(args,
333 break; 326 unsigned int);
334 } 327 break;
335 fmtint(sbuffer, buffer, &currlen, maxlen, value, 328 }
336 ch == 'o' ? 8 : (ch == 'u' ? 10 : 16), 329 fmtint(sbuffer, buffer, &currlen, maxlen, value,
337 min, max, flags); 330 ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),
338 break; 331 min, max, flags);
339 case 'f': 332 break;
340 if (cflags == DP_C_LDOUBLE) 333 case 'f':
341 fvalue = va_arg(args, LDOUBLE); 334 if (cflags == DP_C_LDOUBLE)
342 else 335 fvalue = va_arg(args, LDOUBLE);
343 fvalue = va_arg(args, double); 336 else
344 fmtfp(sbuffer, buffer, &currlen, maxlen, 337 fvalue = va_arg(args, double);
345 fvalue, min, max, flags); 338 fmtfp(sbuffer, buffer, &currlen, maxlen,
346 break; 339 fvalue, min, max, flags);
347 case 'E': 340 break;
348 flags |= DP_F_UP; 341 case 'E':
349 case 'e': 342 flags |= DP_F_UP;
350 if (cflags == DP_C_LDOUBLE) 343 case 'e':
351 fvalue = va_arg(args, LDOUBLE); 344 if (cflags == DP_C_LDOUBLE)
352 else 345 fvalue = va_arg(args, LDOUBLE);
353 fvalue = va_arg(args, double); 346 else
354 break; 347 fvalue = va_arg(args, double);
355 case 'G': 348 break;
356 flags |= DP_F_UP; 349 case 'G':
357 case 'g': 350 flags |= DP_F_UP;
358 if (cflags == DP_C_LDOUBLE) 351 case 'g':
359 fvalue = va_arg(args, LDOUBLE); 352 if (cflags == DP_C_LDOUBLE)
360 else 353 fvalue = va_arg(args, LDOUBLE);
361 fvalue = va_arg(args, double); 354 else
362 break; 355 fvalue = va_arg(args, double);
363 case 'c': 356 break;
364 doapr_outch(sbuffer, buffer, &currlen, maxlen, 357 case 'c':
365 va_arg(args, int)); 358 doapr_outch(sbuffer, buffer, &currlen, maxlen,
366 break; 359 va_arg(args, int));
367 case 's': 360 break;
368 strvalue = va_arg(args, char *); 361 case 's':
369 if (max < 0) { 362 strvalue = va_arg(args, char *);
370 if (buffer) 363 if (max < 0) {
371 max = INT_MAX; 364 if (buffer)
372 else 365 max = INT_MAX;
373 max = *maxlen; 366 else
367 max = *maxlen;
368 }
369 fmtstr(sbuffer, buffer, &currlen, maxlen,
370 strvalue, flags, min, max);
371 break;
372 case 'p':
373 value = (long)va_arg(args, void *);
374 fmtint(sbuffer, buffer, &currlen, maxlen,
375 value, 16, min, max, flags|DP_F_NUM);
376 break;
377 case 'n': /* XXX */
378 if (cflags == DP_C_SHORT) {
379 short int *num;
380 num = va_arg(args, short int *);
381 *num = currlen;
382 } else if (cflags == DP_C_LONG) { /* XXX */
383 long int *num;
384 num = va_arg(args, long int *);
385 *num = (long int) currlen;
386 } else if (cflags == DP_C_LLONG) { /* XXX */
387 LLONG *num;
388 num = va_arg(args, LLONG *);
389 *num = (LLONG) currlen;
390 } else {
391 int *num;
392 num = va_arg(args, int *);
393 *num = currlen;
394 }
395 break;
396 case '%':
397 doapr_outch(sbuffer, buffer, &currlen, maxlen, ch);
398 break;
399 case 'w':
400 /* not supported yet, treat as next char */
401 ch = *format++;
402 break;
403 default:
404 /* unknown, skip */
405 break;
406 }
407 ch = *format++;
408 state = DP_S_DEFAULT;
409 flags = cflags = min = 0;
410 max = -1;
411 break;
412 case DP_S_DONE:
413 break;
414 default:
415 break;
374 } 416 }
375 fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue, 417 }
376 flags, min, max); 418 *truncated = (currlen > *maxlen - 1);
377 break; 419 if (*truncated)
378 case 'p': 420 currlen = *maxlen - 1;
379 value = (long)va_arg(args, void *); 421 doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0');
380 fmtint(sbuffer, buffer, &currlen, maxlen, 422 *retlen = currlen - 1;
381 value, 16, min, max, flags|DP_F_NUM); 423 return;
382 break;
383 case 'n': /* XXX */
384 if (cflags == DP_C_SHORT) {
385 short int *num;
386 num = va_arg(args, short int *);
387 *num = currlen;
388 } else if (cflags == DP_C_LONG) { /* XXX */
389 long int *num;
390 num = va_arg(args, long int *);
391 *num = (long int) currlen;
392 } else if (cflags == DP_C_LLONG) { /* XXX */
393 LLONG *num;
394 num = va_arg(args, LLONG *);
395 *num = (LLONG) currlen;
396 } else {
397 int *num;
398 num = va_arg(args, int *);
399 *num = currlen;
400 }
401 break;
402 case '%':
403 doapr_outch(sbuffer, buffer, &currlen, maxlen, ch);
404 break;
405 case 'w':
406 /* not supported yet, treat as next char */
407 ch = *format++;
408 break;
409 default:
410 /* unknown, skip */
411 break;
412 }
413 ch = *format++;
414 state = DP_S_DEFAULT;
415 flags = cflags = min = 0;
416 max = -1;
417 break;
418 case DP_S_DONE:
419 break;
420 default:
421 break;
422 }
423 }
424 *truncated = (currlen > *maxlen - 1);
425 if (*truncated)
426 currlen = *maxlen - 1;
427 doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0');
428 *retlen = currlen - 1;
429 return;
430} 424}
431 425
432static void 426static void
433fmtstr( 427fmtstr(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen,
434 char **sbuffer, 428 const char *value, int flags, int min, int max)
435 char **buffer,
436 size_t *currlen,
437 size_t *maxlen,
438 const char *value,
439 int flags,
440 int min,
441 int max)
442{ 429{
443 int padlen, strln; 430 int padlen, strln;
444 int cnt = 0; 431 int cnt = 0;
445 432
446 if (value == 0) 433 if (value == 0)
447 value = "<NULL>"; 434 value = "<NULL>";
448 for (strln = 0; value[strln]; ++strln) 435 for (strln = 0; value[strln]; ++strln)
449 ; 436 ;
450 padlen = min - strln; 437 padlen = min - strln;
451 if (padlen < 0) 438 if (padlen < 0)
452 padlen = 0; 439 padlen = 0;
453 if (flags & DP_F_MINUS) 440 if (flags & DP_F_MINUS)
454 padlen = -padlen; 441 padlen = -padlen;
455 442
456 while ((padlen > 0) && (cnt < max)) { 443 while ((padlen > 0) && (cnt < max)) {
457 doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); 444 doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
458 --padlen; 445 --padlen;
459 ++cnt; 446 ++cnt;
460 } 447 }
461 while (*value && (cnt < max)) { 448 while (*value && (cnt < max)) {
462 doapr_outch(sbuffer, buffer, currlen, maxlen, *value++); 449 doapr_outch(sbuffer, buffer, currlen, maxlen, *value++);
463 ++cnt; 450 ++cnt;
464 } 451 }
465 while ((padlen < 0) && (cnt < max)) { 452 while ((padlen < 0) && (cnt < max)) {
466 doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); 453 doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
467 ++padlen; 454 ++padlen;
468 ++cnt; 455 ++cnt;
469 } 456 }
470} 457}
471 458
472static void 459static void
473fmtint( 460fmtint(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen,
474 char **sbuffer, 461 LLONG value, int base, int min, int max, int flags)
475 char **buffer,
476 size_t *currlen,
477 size_t *maxlen,
478 LLONG value,
479 int base,
480 int min,
481 int max,
482 int flags)
483{ 462{
484 int signvalue = 0; 463 int signvalue = 0;
485 const char *prefix = ""; 464 const char *prefix = "";
486 unsigned LLONG uvalue; 465 unsigned LLONG uvalue;
487 char convert[DECIMAL_SIZE(value)+3]; 466 char convert[DECIMAL_SIZE(value) + 3];
488 int place = 0; 467 int place = 0;
489 int spadlen = 0; 468 int spadlen = 0;
490 int zpadlen = 0; 469 int zpadlen = 0;
491 int caps = 0; 470 int caps = 0;
492 471
493 if (max < 0) 472 if (max < 0)
494 max = 0; 473 max = 0;
495 uvalue = value; 474 uvalue = value;
496 if (!(flags & DP_F_UNSIGNED)) { 475 if (!(flags & DP_F_UNSIGNED)) {
497 if (value < 0) { 476 if (value < 0) {
498 signvalue = '-'; 477 signvalue = '-';
499 uvalue = -value; 478 uvalue = -value;
500 } else if (flags & DP_F_PLUS) 479 } else if (flags & DP_F_PLUS)
501 signvalue = '+'; 480 signvalue = '+';
502 else if (flags & DP_F_SPACE) 481 else if (flags & DP_F_SPACE)
503 signvalue = ' '; 482 signvalue = ' ';
504 } 483 }
505 if (flags & DP_F_NUM) { 484 if (flags & DP_F_NUM) {
506 if (base == 8) prefix = "0"; 485 if (base == 8)
507 if (base == 16) prefix = "0x"; 486 prefix = "0";
508 } 487 if (base == 16)
509 if (flags & DP_F_UP) 488 prefix = "0x";
510 caps = 1; 489 }
511 do { 490 if (flags & DP_F_UP)
512 convert[place++] = 491 caps = 1;
513 (caps ? "0123456789ABCDEF" : "0123456789abcdef") 492 do {
514 [uvalue % (unsigned) base]; 493 convert[place++] = (caps ? "0123456789ABCDEF" :
515 uvalue = (uvalue / (unsigned) base); 494 "0123456789abcdef")[uvalue % (unsigned) base];
516 } while (uvalue && (place < (int)sizeof(convert))); 495 uvalue = (uvalue / (unsigned) base);
517 if (place == sizeof(convert)) 496 } while (uvalue && (place < (int)sizeof(convert)));
518 place--; 497 if (place == sizeof(convert))
519 convert[place] = 0; 498 place--;
520 499 convert[place] = 0;
521 zpadlen = max - place; 500
522 spadlen = min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - strlen(prefix); 501 zpadlen = max - place;
523 if (zpadlen < 0) 502 spadlen = min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) -
524 zpadlen = 0; 503 strlen(prefix);
525 if (spadlen < 0) 504 if (zpadlen < 0)
526 spadlen = 0; 505 zpadlen = 0;
527 if (flags & DP_F_ZERO) { 506 if (spadlen < 0)
528 zpadlen = OSSL_MAX(zpadlen, spadlen); 507 spadlen = 0;
529 spadlen = 0; 508 if (flags & DP_F_ZERO) {
530 } 509 zpadlen = OSSL_MAX(zpadlen, spadlen);
531 if (flags & DP_F_MINUS) 510 spadlen = 0;
532 spadlen = -spadlen; 511 }
533 512 if (flags & DP_F_MINUS)
534 /* spaces */ 513 spadlen = -spadlen;
535 while (spadlen > 0) { 514
536 doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); 515 /* spaces */
537 --spadlen; 516 while (spadlen > 0) {
538 } 517 doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
539 518 --spadlen;
540 /* sign */ 519 }
541 if (signvalue) 520
542 doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); 521 /* sign */
543 522 if (signvalue)
544 /* prefix */ 523 doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);
545 while (*prefix) { 524
546 doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix); 525 /* prefix */
547 prefix++; 526 while (*prefix) {
548 } 527 doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix);
549 528 prefix++;
550 /* zeros */ 529 }
551 if (zpadlen > 0) { 530
552 while (zpadlen > 0) { 531 /* zeros */
553 doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); 532 if (zpadlen > 0) {
554 --zpadlen; 533 while (zpadlen > 0) {
555 } 534 doapr_outch(sbuffer, buffer, currlen, maxlen, '0');
556 } 535 --zpadlen;
557 /* digits */ 536 }
558 while (place > 0) 537 }
559 doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]); 538 /* digits */
560 539 while (place > 0)
561 /* left justified spaces */ 540 doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]);
562 while (spadlen < 0) { 541
563 doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); 542 /* left justified spaces */
564 ++spadlen; 543 while (spadlen < 0) {
565 } 544 doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
566 return; 545 ++spadlen;
546 }
547 return;
567} 548}
568 549
569static LDOUBLE 550static LDOUBLE
570abs_val(LDOUBLE value) 551abs_val(LDOUBLE value)
571{ 552{
572 LDOUBLE result = value; 553 LDOUBLE result = value;
573 if (value < 0) 554 if (value < 0)
574 result = -value; 555 result = -value;
575 return result; 556 return result;
576} 557}
577 558
578static LDOUBLE 559static LDOUBLE
579pow_10(int in_exp) 560pow_10(int in_exp)
580{ 561{
581 LDOUBLE result = 1; 562 LDOUBLE result = 1;
582 while (in_exp) { 563 while (in_exp) {
583 result *= 10; 564 result *= 10;
584 in_exp--; 565 in_exp--;
585 } 566 }
586 return result; 567 return result;
587} 568}
588 569
589static long 570static long
590roundv(LDOUBLE value) 571roundv(LDOUBLE value)
591{ 572{
592 long intpart; 573 long intpart;
593 intpart = (long) value; 574 intpart = (long) value;
594 value = value - intpart; 575 value = value - intpart;
595 if (value >= 0.5) 576 if (value >= 0.5)
596 intpart++; 577 intpart++;
597 return intpart; 578 return intpart;
598} 579}
599 580
600static void 581static void
601fmtfp( 582fmtfp(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen,
602 char **sbuffer, 583 LDOUBLE fvalue, int min, int max, int flags)
603 char **buffer,
604 size_t *currlen,
605 size_t *maxlen,
606 LDOUBLE fvalue,
607 int min,
608 int max,
609 int flags)
610{ 584{
611 int signvalue = 0; 585 int signvalue = 0;
612 LDOUBLE ufvalue; 586 LDOUBLE ufvalue;
613 char iconvert[20]; 587 char iconvert[20];
614 char fconvert[20]; 588 char fconvert[20];
615 int iplace = 0; 589 int iplace = 0;
616 int fplace = 0; 590 int fplace = 0;
617 int padlen = 0; 591 int padlen = 0;
618 int zpadlen = 0; 592 int zpadlen = 0;
619 int caps = 0; 593 int caps = 0;
620 long intpart; 594 long intpart;
621 long fracpart; 595 long fracpart;
622 long max10; 596 long max10;
623 597
624 if (max < 0) 598 if (max < 0)
625 max = 6; 599 max = 6;
626 ufvalue = abs_val(fvalue); 600 ufvalue = abs_val(fvalue);
627 if (fvalue < 0) 601 if (fvalue < 0)
628 signvalue = '-'; 602 signvalue = '-';
629 else if (flags & DP_F_PLUS) 603 else if (flags & DP_F_PLUS)
630 signvalue = '+'; 604 signvalue = '+';
631 else if (flags & DP_F_SPACE) 605 else if (flags & DP_F_SPACE)
632 signvalue = ' '; 606 signvalue = ' ';
633 607
634 intpart = (long)ufvalue; 608 intpart = (long)ufvalue;
635 609
636 /* sorry, we only support 9 digits past the decimal because of our 610 /* sorry, we only support 9 digits past the decimal because of our
637 conversion method */ 611 conversion method */
638 if (max > 9) 612 if (max > 9)
639 max = 9; 613 max = 9;
640 614
641 /* we "cheat" by converting the fractional part to integer by 615 /* we "cheat" by converting the fractional part to integer by
642 multiplying by a factor of 10 */ 616 multiplying by a factor of 10 */
643 max10 = roundv(pow_10(max)); 617 max10 = roundv(pow_10(max));
644 fracpart = roundv(pow_10(max) * (ufvalue - intpart)); 618 fracpart = roundv(pow_10(max) * (ufvalue - intpart));
645 619
646 if (fracpart >= max10) { 620 if (fracpart >= max10) {
647 intpart++; 621 intpart++;
648 fracpart -= max10; 622 fracpart -= max10;
649 } 623 }
650 624
651 /* convert integer part */ 625 /* convert integer part */
652 do { 626 do {
653 iconvert[iplace++] = 627 iconvert[iplace++] = (caps ? "0123456789ABCDEF" :
654 (caps ? "0123456789ABCDEF" 628 "0123456789abcdef")[intpart % 10];
655 : "0123456789abcdef")[intpart % 10]; 629 intpart = (intpart / 10);
656 intpart = (intpart / 10); 630 } while (intpart && (iplace < (int)sizeof(iconvert)));
657 } while (intpart && (iplace < (int)sizeof(iconvert))); 631 if (iplace == sizeof iconvert)
658 if (iplace == sizeof iconvert) 632 iplace--;
659 iplace--; 633 iconvert[iplace] = 0;
660 iconvert[iplace] = 0; 634
661 635 /* convert fractional part */
662 /* convert fractional part */ 636 do {
663 do { 637 fconvert[fplace++] = (caps ? "0123456789ABCDEF" :
664 fconvert[fplace++] = 638 "0123456789abcdef")[fracpart % 10];
665 (caps ? "0123456789ABCDEF" 639 fracpart = (fracpart / 10);
666 : "0123456789abcdef")[fracpart % 10]; 640 } while (fplace < max);
667 fracpart = (fracpart / 10); 641 if (fplace == sizeof fconvert)
668 } while (fplace < max); 642 fplace--;
669 if (fplace == sizeof fconvert) 643 fconvert[fplace] = 0;
670 fplace--; 644
671 fconvert[fplace] = 0; 645 /* -1 for decimal point, another -1 if we are printing a sign */
672 646 padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
673 /* -1 for decimal point, another -1 if we are printing a sign */ 647 zpadlen = max - fplace;
674 padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 648 if (zpadlen < 0)
675 zpadlen = max - fplace; 649 zpadlen = 0;
676 if (zpadlen < 0) 650 if (padlen < 0)
677 zpadlen = 0; 651 padlen = 0;
678 if (padlen < 0) 652 if (flags & DP_F_MINUS)
679 padlen = 0; 653 padlen = -padlen;
680 if (flags & DP_F_MINUS) 654
681 padlen = -padlen; 655 if ((flags & DP_F_ZERO) && (padlen > 0)) {
682 656 if (signvalue) {
683 if ((flags & DP_F_ZERO) && (padlen > 0)) { 657 doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);
684 if (signvalue) { 658 --padlen;
685 doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); 659 signvalue = 0;
686 --padlen; 660 }
687 signvalue = 0; 661 while (padlen > 0) {
688 } 662 doapr_outch(sbuffer, buffer, currlen, maxlen, '0');
689 while (padlen > 0) { 663 --padlen;
690 doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); 664 }
691 --padlen; 665 }
692 } 666 while (padlen > 0) {
693 } 667 doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
694 while (padlen > 0) { 668 --padlen;
695 doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); 669 }
696 --padlen; 670 if (signvalue)
697 } 671 doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);
698 if (signvalue) 672
699 doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); 673 while (iplace > 0)
700 674 doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]);
701 while (iplace > 0) 675
702 doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]); 676 /*
703 677 * Decimal point. This should probably use locale to find the correct
704 /* 678 * char to print out.
705 * Decimal point. This should probably use locale to find the correct 679 */
706 * char to print out. 680 if (max > 0 || (flags & DP_F_NUM)) {
707 */ 681 doapr_outch(sbuffer, buffer, currlen, maxlen, '.');
708 if (max > 0 || (flags & DP_F_NUM)) { 682
709 doapr_outch(sbuffer, buffer, currlen, maxlen, '.'); 683 while (fplace > 0)
710 684 doapr_outch(sbuffer, buffer, currlen, maxlen, fconvert[--fplace]);
711 while (fplace > 0) 685 }
712 doapr_outch(sbuffer, buffer, currlen, maxlen, fconvert[--fplace]); 686 while (zpadlen > 0) {
713 } 687 doapr_outch(sbuffer, buffer, currlen, maxlen, '0');
714 while (zpadlen > 0) { 688 --zpadlen;
715 doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); 689 }
716 --zpadlen; 690
717 } 691 while (padlen < 0) {
718 692 doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
719 while (padlen < 0) { 693 ++padlen;
720 doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); 694 }
721 ++padlen;
722 }
723} 695}
724 696
725static void 697static void
726doapr_outch( 698doapr_outch(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen,
727 char **sbuffer,
728 char **buffer,
729 size_t *currlen,
730 size_t *maxlen,
731 int c) 699 int c)
732{ 700{
733 /* If we haven't at least one buffer, someone has doe a big booboo */ 701 /* If we haven't at least one buffer, someone has doe a big booboo */
734 assert(*sbuffer != NULL || buffer != NULL); 702 assert(*sbuffer != NULL || buffer != NULL);
735 703
736 if (buffer) { 704 if (buffer) {
737 while (*currlen >= *maxlen) { 705 while (*currlen >= *maxlen) {
738 if (*buffer == NULL) { 706 if (*buffer == NULL) {
739 if (*maxlen == 0) 707 if (*maxlen == 0)
740 *maxlen = 1024; 708 *maxlen = 1024;
741 *buffer = OPENSSL_malloc(*maxlen); 709 *buffer = OPENSSL_malloc(*maxlen);
742 if (*currlen > 0) { 710 if (*currlen > 0) {
743 assert(*sbuffer != NULL); 711 assert(*sbuffer != NULL);
744 memcpy(*buffer, *sbuffer, *currlen); 712 memcpy(*buffer, *sbuffer, *currlen);
713 }
714 *sbuffer = NULL;
715 } else {
716 *maxlen += 1024;
717 *buffer = OPENSSL_realloc(*buffer, *maxlen);
718 }
745 } 719 }
746 *sbuffer = NULL; 720 /* What to do if *buffer is NULL? */
747 } else { 721 assert(*sbuffer != NULL || *buffer != NULL);
748 *maxlen += 1024;
749 *buffer = OPENSSL_realloc(*buffer, *maxlen);
750 }
751 } 722 }
752 /* What to do if *buffer is NULL? */
753 assert(*sbuffer != NULL || *buffer != NULL);
754 }
755 723
756 if (*currlen < *maxlen) { 724 if (*currlen < *maxlen) {
757 if (*sbuffer) 725 if (*sbuffer)
758 (*sbuffer)[(*currlen)++] = (char)c; 726 (*sbuffer)[(*currlen)++] = (char)c;
759 else 727 else
760 (*buffer)[(*currlen)++] = (char)c; 728 (*buffer)[(*currlen)++] = (char)c;
761 } 729 }
762 730
763 return; 731 return;
764} 732}
765 733
766/***************************************************************************/ 734/***************************************************************************/
767 735
768int BIO_printf (BIO *bio, const char *format, ...) 736int BIO_printf (BIO *bio, const char *format, ...)
769 { 737{
770 va_list args; 738 va_list args;
771 int ret; 739 int ret;
772 740
@@ -775,15 +743,15 @@ int BIO_printf (BIO *bio, const char *format, ...)
775 ret = BIO_vprintf(bio, format, args); 743 ret = BIO_vprintf(bio, format, args);
776 744
777 va_end(args); 745 va_end(args);
778 return(ret); 746 return (ret);
779 } 747}
780 748
781int BIO_vprintf (BIO *bio, const char *format, va_list args) 749int BIO_vprintf (BIO *bio, const char *format, va_list args)
782 { 750{
783 int ret; 751 int ret;
784 size_t retlen; 752 size_t retlen;
785 char hugebuf[1024*2]; /* Was previously 10k, which is unreasonable 753 char hugebuf[1024*2]; /* Was previously 10k, which is unreasonable
786 in small-stack environments, like threads 754 in small - stack environments, like threads
787 or DOS programs. */ 755 or DOS programs. */
788 char *hugebufp = hugebuf; 756 char *hugebufp = hugebuf;
789 size_t hugebufsize = sizeof(hugebuf); 757 size_t hugebufsize = sizeof(hugebuf);
@@ -792,27 +760,25 @@ int BIO_vprintf (BIO *bio, const char *format, va_list args)
792 760
793 dynbuf = NULL; 761 dynbuf = NULL;
794 CRYPTO_push_info("doapr()"); 762 CRYPTO_push_info("doapr()");
795 _dopr(&hugebufp, &dynbuf, &hugebufsize, 763 _dopr(&hugebufp, &dynbuf, &hugebufsize, &retlen, &ignored,
796 &retlen, &ignored, format, args); 764 format, args);
797 if (dynbuf) 765 if (dynbuf) {
798 { 766 ret = BIO_write(bio, dynbuf, (int)retlen);
799 ret=BIO_write(bio, dynbuf, (int)retlen);
800 OPENSSL_free(dynbuf); 767 OPENSSL_free(dynbuf);
801 } 768 } else {
802 else 769 ret = BIO_write(bio, hugebuf, (int)retlen);
803 {
804 ret=BIO_write(bio, hugebuf, (int)retlen);
805 }
806 CRYPTO_pop_info();
807 return(ret);
808 } 770 }
771 CRYPTO_pop_info();
772 return (ret);
773}
809 774
810/* As snprintf is not available everywhere, we provide our own implementation. 775/* As snprintf is not available everywhere, we provide our own implementation.
811 * This function has nothing to do with BIOs, but it's closely related 776 * This function has nothing to do with BIOs, but it's closely related
812 * to BIO_printf, and we need *some* name prefix ... 777 * to BIO_printf, and we need *some* name prefix ...
813 * (XXX the function should be renamed, but to what?) */ 778 * (XXX the function should be renamed, but to what?) */
814int BIO_snprintf(char *buf, size_t n, const char *format, ...) 779int
815 { 780BIO_snprintf(char *buf, size_t n, const char *format, ...)
781{
816 va_list args; 782 va_list args;
817 int ret; 783 int ret;
818 784
@@ -821,11 +787,12 @@ int BIO_snprintf(char *buf, size_t n, const char *format, ...)
821 ret = BIO_vsnprintf(buf, n, format, args); 787 ret = BIO_vsnprintf(buf, n, format, args);
822 788
823 va_end(args); 789 va_end(args);
824 return(ret); 790 return (ret);
825 } 791}
826 792
827int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) 793int
828 { 794BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
795{
829 size_t retlen; 796 size_t retlen;
830 int truncated; 797 int truncated;
831 798
@@ -839,4 +806,4 @@ int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
839 return -1; 806 return -1;
840 else 807 else
841 return (retlen <= INT_MAX) ? (int)retlen : -1; 808 return (retlen <= INT_MAX) ? (int)retlen : -1;
842 } 809}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-12-09 09:07:57 +0000