summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/bio/b_print.c
diff options
context:
space:
mode:
authorjsing <>2014-04-15 16:37:22 +0000
committerjsing <>2014-04-15 16:37:22 +0000
commit405f0a76509e0e96df735b5b902a28b8ab6c9c55 (patch)
tree41dd30d546977ed0c409d7de59564fa1a2e3b100 /src/lib/libcrypto/bio/b_print.c
parent4e5cf8d1c0be703d2956348c807ab6ac39172547 (diff)
downloadopenbsd-405f0a76509e0e96df735b5b902a28b8ab6c9c55.tar.gz
openbsd-405f0a76509e0e96df735b5b902a28b8ab6c9c55.tar.bz2
openbsd-405f0a76509e0e96df735b5b902a28b8ab6c9c55.zip
First pass at applying KNF to the OpenSSL code, which almost makes it
readable. This pass is whitespace only and can readily be verified using tr and md5.
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 13:02:01 +0000