summaryrefslogtreecommitdiff
path: root/other/ssharp/openbsd-compat/bsd-snprintf.c
diff options
context:
space:
mode:
authorSkyperTHC2026-03-03 06:28:55 +0000
committerSkyperTHC2026-03-03 06:28:55 +0000
commit5d3573ef7a109ee70416fe94db098fe6a769a798 (patch)
treedc2d5b294c9db8ab2db7433511f94e1c4bb8b698 /other/ssharp/openbsd-compat/bsd-snprintf.c
parentc6c59dc73cc4586357f93ab38ecf459e98675cc5 (diff)
packetstorm sync
Diffstat (limited to 'other/ssharp/openbsd-compat/bsd-snprintf.c')
-rw-r--r--other/ssharp/openbsd-compat/bsd-snprintf.c744
1 files changed, 744 insertions, 0 deletions
diff --git a/other/ssharp/openbsd-compat/bsd-snprintf.c b/other/ssharp/openbsd-compat/bsd-snprintf.c
new file mode 100644
index 0000000..14d12fc
--- /dev/null
+++ b/other/ssharp/openbsd-compat/bsd-snprintf.c
@@ -0,0 +1,744 @@
1/**************************************************************
2 * Original:
3 * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
4 * A bombproof version of doprnt (dopr) included.
5 * Sigh. This sort of thing is always nasty do deal with. Note that
6 * the version here does not include floating point...
7 *
8 * snprintf() is used instead of sprintf() as it does limit checks
9 * for string length. This covers a nasty loophole.
10 *
11 * The other functions are there to prevent NULL pointers from
12 * causing nast effects.
13 *
14 * More Recently:
15 * Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
16 * This was ugly. It is still ugly. I opted out of floating point
17 * numbers, but the formatter understands just about everything
18 * from the normal C string format, at least as far as I can tell from
19 * the Solaris 2.5 printf(3S) man page.
20 *
21 * Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
22 * Ok, added some minimal floating point support, which means this
23 * probably requires libm on most operating systems. Don't yet
24 * support the exponent (e,E) and sigfig (g,G). Also, fmtint()
25 * was pretty badly broken, it just wasn't being exercised in ways
26 * which showed it, so that's been fixed. Also, formated the code
27 * to mutt conventions, and removed dead code left over from the
28 * original. Also, there is now a builtin-test, just compile with:
29 * gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
30 * and run snprintf for results.
31 *
32 * Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
33 * The PGP code was using unsigned hexadecimal formats.
34 * Unfortunately, unsigned formats simply didn't work.
35 *
36 * Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
37 * The original code assumed that both snprintf() and vsnprintf() were
38 * missing. Some systems only have snprintf() but not vsnprintf(), so
39 * the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
40 *
41 * Ben Lindstrom <mouring@eviladmin.org> 09/27/00 for OpenSSH
42 * Welcome to the world of %lld and %qd support. With other
43 * long long support. This is needed for sftp-server to work
44 * right.
45 *
46 * Ben Lindstrom <mouring@eviladmin.org> 02/12/01 for OpenSSH
47 * Removed all hint of VARARGS stuff and banished it to the void,
48 * and did a bit of KNF style work to make things a bit more
49 * acceptable. Consider stealing from mutt or enlightenment.
50 **************************************************************/
51
52#include "includes.h"
53
54RCSID("$Id: bsd-snprintf.c,v 1.1.1.1 2001/09/19 14:44:59 stealth Exp $");
55
56#if defined(BROKEN_SNPRINTF) /* For those with broken snprintf() */
57# undef HAVE_SNPRINTF
58# undef HAVE_VSNPRINTF
59#endif
60
61#if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)
62
63static void
64dopr(char *buffer, size_t maxlen, const char *format, va_list args);
65
66static void
67fmtstr(char *buffer, size_t *currlen, size_t maxlen, char *value, int flags,
68 int min, int max);
69
70static void
71fmtint(char *buffer, size_t *currlen, size_t maxlen, long value, int base,
72 int min, int max, int flags);
73
74static void
75fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue,
76 int min, int max, int flags);
77
78static void
79dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
80
81/*
82 * dopr(): poor man's version of doprintf
83 */
84
85/* format read states */
86#define DP_S_DEFAULT 0
87#define DP_S_FLAGS 1
88#define DP_S_MIN 2
89#define DP_S_DOT 3
90#define DP_S_MAX 4
91#define DP_S_MOD 5
92#define DP_S_CONV 6
93#define DP_S_DONE 7
94
95/* format flags - Bits */
96#define DP_F_MINUS (1 << 0)
97#define DP_F_PLUS (1 << 1)
98#define DP_F_SPACE (1 << 2)
99#define DP_F_NUM (1 << 3)
100#define DP_F_ZERO (1 << 4)
101#define DP_F_UP (1 << 5)
102#define DP_F_UNSIGNED (1 << 6)
103
104/* Conversion Flags */
105#define DP_C_SHORT 1
106#define DP_C_LONG 2
107#define DP_C_LDOUBLE 3
108#define DP_C_LONG_LONG 4
109
110#define char_to_int(p) (p - '0')
111#define abs_val(p) (p < 0 ? -p : p)
112
113
114static void
115dopr(char *buffer, size_t maxlen, const char *format, va_list args)
116{
117 char *strvalue;
118 char ch;
119 long value;
120 long double fvalue;
121 int min = 0;
122 int max = -1;
123 int state = DP_S_DEFAULT;
124 int flags = 0;
125 int cflags = 0;
126 size_t currlen = 0;
127
128 ch = *format++;
129
130 while (state != DP_S_DONE) {
131 if ((ch == '\0') || (currlen >= maxlen))
132 state = DP_S_DONE;
133
134 switch(state) {
135 case DP_S_DEFAULT:
136 if (ch == '%')
137 state = DP_S_FLAGS;
138 else
139 dopr_outch(buffer, &currlen, maxlen, ch);
140 ch = *format++;
141 break;
142 case DP_S_FLAGS:
143 switch (ch) {
144 case '-':
145 flags |= DP_F_MINUS;
146 ch = *format++;
147 break;
148 case '+':
149 flags |= DP_F_PLUS;
150 ch = *format++;
151 break;
152 case ' ':
153 flags |= DP_F_SPACE;
154 ch = *format++;
155 break;
156 case '#':
157 flags |= DP_F_NUM;
158 ch = *format++;
159 break;
160 case '0':
161 flags |= DP_F_ZERO;
162 ch = *format++;
163 break;
164 default:
165 state = DP_S_MIN;
166 break;
167 }
168 break;
169 case DP_S_MIN:
170 if (isdigit((unsigned char)ch)) {
171 min = 10*min + char_to_int (ch);
172 ch = *format++;
173 } else if (ch == '*') {
174 min = va_arg (args, int);
175 ch = *format++;
176 state = DP_S_DOT;
177 } else
178 state = DP_S_DOT;
179 break;
180 case DP_S_DOT:
181 if (ch == '.') {
182 state = DP_S_MAX;
183 ch = *format++;
184 } else
185 state = DP_S_MOD;
186 break;
187 case DP_S_MAX:
188 if (isdigit((unsigned char)ch)) {
189 if (max < 0)
190 max = 0;
191 max = 10*max + char_to_int(ch);
192 ch = *format++;
193 } else if (ch == '*') {
194 max = va_arg (args, int);
195 ch = *format++;
196 state = DP_S_MOD;
197 } else
198 state = DP_S_MOD;
199 break;
200 case DP_S_MOD:
201 switch (ch) {
202 case 'h':
203 cflags = DP_C_SHORT;
204 ch = *format++;
205 break;
206 case 'l':
207 cflags = DP_C_LONG;
208 ch = *format++;
209 if (ch == 'l') {
210 cflags = DP_C_LONG_LONG;
211 ch = *format++;
212 }
213 break;
214 case 'q':
215 cflags = DP_C_LONG_LONG;
216 ch = *format++;
217 break;
218 case 'L':
219 cflags = DP_C_LDOUBLE;
220 ch = *format++;
221 break;
222 default:
223 break;
224 }
225 state = DP_S_CONV;
226 break;
227 case DP_S_CONV:
228 switch (ch) {
229 case 'd':
230 case 'i':
231 if (cflags == DP_C_SHORT)
232 value = va_arg(args, int);
233 else if (cflags == DP_C_LONG)
234 value = va_arg(args, long int);
235 else if (cflags == DP_C_LONG_LONG)
236 value = va_arg (args, long long);
237 else
238 value = va_arg (args, int);
239 fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
240 break;
241 case 'o':
242 flags |= DP_F_UNSIGNED;
243 if (cflags == DP_C_SHORT)
244 value = va_arg(args, unsigned int);
245 else if (cflags == DP_C_LONG)
246 value = va_arg(args, unsigned long int);
247 else if (cflags == DP_C_LONG_LONG)
248 value = va_arg(args, unsigned long long);
249 else
250 value = va_arg(args, unsigned int);
251 fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags);
252 break;
253 case 'u':
254 flags |= DP_F_UNSIGNED;
255 if (cflags == DP_C_SHORT)
256 value = va_arg(args, unsigned int);
257 else if (cflags == DP_C_LONG)
258 value = va_arg(args, unsigned long int);
259 else if (cflags == DP_C_LONG_LONG)
260 value = va_arg(args, unsigned long long);
261 else
262 value = va_arg(args, unsigned int);
263 fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
264 break;
265 case 'X':
266 flags |= DP_F_UP;
267 case 'x':
268 flags |= DP_F_UNSIGNED;
269 if (cflags == DP_C_SHORT)
270 value = va_arg(args, unsigned int);
271 else if (cflags == DP_C_LONG)
272 value = va_arg(args, unsigned long int);
273 else if (cflags == DP_C_LONG_LONG)
274 value = va_arg(args, unsigned long long);
275 else
276 value = va_arg(args, unsigned int);
277 fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags);
278 break;
279 case 'f':
280 if (cflags == DP_C_LDOUBLE)
281 fvalue = va_arg(args, long double);
282 else
283 fvalue = va_arg(args, double);
284 /* um, floating point? */
285 fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
286 break;
287 case 'E':
288 flags |= DP_F_UP;
289 case 'e':
290 if (cflags == DP_C_LDOUBLE)
291 fvalue = va_arg(args, long double);
292 else
293 fvalue = va_arg(args, double);
294 break;
295 case 'G':
296 flags |= DP_F_UP;
297 case 'g':
298 if (cflags == DP_C_LDOUBLE)
299 fvalue = va_arg(args, long double);
300 else
301 fvalue = va_arg(args, double);
302 break;
303 case 'c':
304 dopr_outch(buffer, &currlen, maxlen, va_arg(args, int));
305 break;
306 case 's':
307 strvalue = va_arg(args, char *);
308 if (max < 0)
309 max = maxlen; /* ie, no max */
310 fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max);
311 break;
312 case 'p':
313 strvalue = va_arg(args, void *);
314 fmtint(buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
315 break;
316 case 'n':
317 if (cflags == DP_C_SHORT) {
318 short int *num;
319 num = va_arg(args, short int *);
320 *num = currlen;
321 } else if (cflags == DP_C_LONG) {
322 long int *num;
323 num = va_arg(args, long int *);
324 *num = currlen;
325 } else if (cflags == DP_C_LONG_LONG) {
326 long long *num;
327 num = va_arg(args, long long *);
328 *num = currlen;
329 } else {
330 int *num;
331 num = va_arg(args, int *);
332 *num = currlen;
333 }
334 break;
335 case '%':
336 dopr_outch(buffer, &currlen, maxlen, ch);
337 break;
338 case 'w': /* not supported yet, treat as next char */
339 ch = *format++;
340 break;
341 default: /* Unknown, skip */
342 break;
343 }
344 ch = *format++;
345 state = DP_S_DEFAULT;
346 flags = cflags = min = 0;
347 max = -1;
348 break;
349 case DP_S_DONE:
350 break;
351 default: /* hmm? */
352 break; /* some picky compilers need this */
353 }
354 }
355 if (currlen < maxlen - 1)
356 buffer[currlen] = '\0';
357 else
358 buffer[maxlen - 1] = '\0';
359}
360
361static void
362fmtstr(char *buffer, size_t *currlen, size_t maxlen,
363 char *value, int flags, int min, int max)
364{
365 int padlen, strln; /* amount to pad */
366 int cnt = 0;
367
368 if (value == 0)
369 value = "<NULL>";
370
371 for (strln = 0; value[strln]; ++strln); /* strlen */
372 padlen = min - strln;
373 if (padlen < 0)
374 padlen = 0;
375 if (flags & DP_F_MINUS)
376 padlen = -padlen; /* Left Justify */
377
378 while ((padlen > 0) && (cnt < max)) {
379 dopr_outch(buffer, currlen, maxlen, ' ');
380 --padlen;
381 ++cnt;
382 }
383 while (*value && (cnt < max)) {
384 dopr_outch(buffer, currlen, maxlen, *value++);
385 ++cnt;
386 }
387 while ((padlen < 0) && (cnt < max)) {
388 dopr_outch(buffer, currlen, maxlen, ' ');
389 ++padlen;
390 ++cnt;
391 }
392}
393
394/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
395
396static void
397fmtint(char *buffer, size_t *currlen, size_t maxlen,
398 long value, int base, int min, int max, int flags)
399{
400 unsigned long uvalue;
401 char convert[20];
402 int signvalue = 0;
403 int place = 0;
404 int spadlen = 0; /* amount to space pad */
405 int zpadlen = 0; /* amount to zero pad */
406 int caps = 0;
407
408 if (max < 0)
409 max = 0;
410
411 uvalue = value;
412
413 if (!(flags & DP_F_UNSIGNED)) {
414 if (value < 0) {
415 signvalue = '-';
416 uvalue = -value;
417 } else if (flags & DP_F_PLUS) /* Do a sign (+/i) */
418 signvalue = '+';
419 else if (flags & DP_F_SPACE)
420 signvalue = ' ';
421 }
422
423 if (flags & DP_F_UP)
424 caps = 1; /* Should characters be upper case? */
425
426 do {
427 convert[place++] =
428 (caps? "0123456789ABCDEF":"0123456789abcdef")
429 [uvalue % (unsigned)base];
430 uvalue = (uvalue / (unsigned)base );
431 } while (uvalue && (place < 20));
432 if (place == 20)
433 place--;
434 convert[place] = 0;
435
436 zpadlen = max - place;
437 spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
438 if (zpadlen < 0)
439 zpadlen = 0;
440 if (spadlen < 0)
441 spadlen = 0;
442 if (flags & DP_F_ZERO) {
443 zpadlen = MAX(zpadlen, spadlen);
444 spadlen = 0;
445 }
446 if (flags & DP_F_MINUS)
447 spadlen = -spadlen; /* Left Justifty */
448
449
450 /* Spaces */
451 while (spadlen > 0) {
452 dopr_outch(buffer, currlen, maxlen, ' ');
453 --spadlen;
454 }
455
456 /* Sign */
457 if (signvalue)
458 dopr_outch(buffer, currlen, maxlen, signvalue);
459
460 /* Zeros */
461 if (zpadlen > 0) {
462 while (zpadlen > 0) {
463 dopr_outch(buffer, currlen, maxlen, '0');
464 --zpadlen;
465 }
466 }
467
468 /* Digits */
469 while (place > 0)
470 dopr_outch(buffer, currlen, maxlen, convert[--place]);
471
472 /* Left Justified spaces */
473 while (spadlen < 0) {
474 dopr_outch (buffer, currlen, maxlen, ' ');
475 ++spadlen;
476 }
477}
478
479static long double
480pow10(int exp)
481{
482 long double result = 1;
483
484 while (exp) {
485 result *= 10;
486 exp--;
487 }
488
489 return result;
490}
491
492static long
493round(long double value)
494{
495 long intpart = value;
496
497 value -= intpart;
498 if (value >= 0.5)
499 intpart++;
500
501 return intpart;
502}
503
504static void
505fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue,
506 int min, int max, int flags)
507{
508 char iconvert[20];
509 char fconvert[20];
510 int signvalue = 0;
511 int iplace = 0;
512 int fplace = 0;
513 int padlen = 0; /* amount to pad */
514 int zpadlen = 0;
515 int caps = 0;
516 long intpart;
517 long fracpart;
518 long double ufvalue;
519
520 /*
521 * AIX manpage says the default is 0, but Solaris says the default
522 * is 6, and sprintf on AIX defaults to 6
523 */
524 if (max < 0)
525 max = 6;
526
527 ufvalue = abs_val(fvalue);
528
529 if (fvalue < 0)
530 signvalue = '-';
531 else if (flags & DP_F_PLUS) /* Do a sign (+/i) */
532 signvalue = '+';
533 else if (flags & DP_F_SPACE)
534 signvalue = ' ';
535
536 intpart = ufvalue;
537
538 /*
539 * Sorry, we only support 9 digits past the decimal because of our
540 * conversion method
541 */
542 if (max > 9)
543 max = 9;
544
545 /* We "cheat" by converting the fractional part to integer by
546 * multiplying by a factor of 10
547 */
548 fracpart = round((pow10 (max)) * (ufvalue - intpart));
549
550 if (fracpart >= pow10 (max)) {
551 intpart++;
552 fracpart -= pow10 (max);
553 }
554
555 /* Convert integer part */
556 do {
557 iconvert[iplace++] =
558 (caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10];
559 intpart = (intpart / 10);
560 } while(intpart && (iplace < 20));
561 if (iplace == 20)
562 iplace--;
563 iconvert[iplace] = 0;
564
565 /* Convert fractional part */
566 do {
567 fconvert[fplace++] =
568 (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10];
569 fracpart = (fracpart / 10);
570 } while(fracpart && (fplace < 20));
571 if (fplace == 20)
572 fplace--;
573 fconvert[fplace] = 0;
574
575 /* -1 for decimal point, another -1 if we are printing a sign */
576 padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
577 zpadlen = max - fplace;
578 if (zpadlen < 0)
579 zpadlen = 0;
580 if (padlen < 0)
581 padlen = 0;
582 if (flags & DP_F_MINUS)
583 padlen = -padlen; /* Left Justifty */
584
585 if ((flags & DP_F_ZERO) && (padlen > 0)) {
586 if (signvalue) {
587 dopr_outch(buffer, currlen, maxlen, signvalue);
588 --padlen;
589 signvalue = 0;
590 }
591 while (padlen > 0) {
592 dopr_outch(buffer, currlen, maxlen, '0');
593 --padlen;
594 }
595 }
596 while (padlen > 0) {
597 dopr_outch(buffer, currlen, maxlen, ' ');
598 --padlen;
599 }
600 if (signvalue)
601 dopr_outch(buffer, currlen, maxlen, signvalue);
602
603 while (iplace > 0)
604 dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]);
605
606 /*
607 * Decimal point. This should probably use locale to find the correct
608 * char to print out.
609 */
610 dopr_outch(buffer, currlen, maxlen, '.');
611
612 while (fplace > 0)
613 dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]);
614
615 while (zpadlen > 0) {
616 dopr_outch(buffer, currlen, maxlen, '0');
617 --zpadlen;
618 }
619
620 while (padlen < 0) {
621 dopr_outch(buffer, currlen, maxlen, ' ');
622 ++padlen;
623 }
624}
625
626static void
627dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
628{
629 if (*currlen < maxlen)
630 buffer[(*currlen)++] = c;
631}
632#endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */
633
634#ifndef HAVE_VSNPRINTF
635int
636vsnprintf(char *str, size_t count, const char *fmt, va_list args)
637{
638 str[0] = 0;
639 dopr(str, count, fmt, args);
640
641 return(strlen(str));
642}
643#endif /* !HAVE_VSNPRINTF */
644
645#ifndef HAVE_SNPRINTF
646int
647snprintf(char *str,size_t count,const char *fmt,...)
648{
649 va_list ap;
650
651 va_start(ap, fmt);
652 (void) vsnprintf(str, count, fmt, ap);
653 va_end(ap);
654
655 return(strlen(str));
656}
657
658#ifdef TEST_SNPRINTF
659int
660main(void)
661{
662#define LONG_STRING 1024
663 char buf1[LONG_STRING];
664 char buf2[LONG_STRING];
665 char *fp_fmt[] = {
666 "%-1.5f",
667 "%1.5f",
668 "%123.9f",
669 "%10.5f",
670 "% 10.5f",
671 "%+22.9f",
672 "%+4.9f",
673 "%01.3f",
674 "%4f",
675 "%3.1f",
676 "%3.2f",
677 NULL
678 };
679 double fp_nums[] = {
680 -1.5,
681 134.21,
682 91340.2,
683 341.1234,
684 0203.9,
685 0.96,
686 0.996,
687 0.9996,
688 1.996,
689 4.136,
690 0
691 };
692 char *int_fmt[] = {
693 "%-1.5d",
694 "%1.5d",
695 "%123.9d",
696 "%5.5d",
697 "%10.5d",
698 "% 10.5d",
699 "%+22.33d",
700 "%01.3d",
701 "%4d",
702 "%lld",
703 "%qd",
704 NULL
705 };
706 long long int_nums[] = { -1, 134, 91340, 341, 0203, 0, 9999999 };
707 int x, y;
708 int fail = 0;
709 int num = 0;
710
711 printf("Testing snprintf format codes against system sprintf...\n");
712
713 for (x = 0; fp_fmt[x] != NULL ; x++) {
714 for (y = 0; fp_nums[y] != 0 ; y++) {
715 snprintf(buf1, sizeof (buf1), fp_fmt[x], fp_nums[y]);
716 sprintf (buf2, fp_fmt[x], fp_nums[y]);
717 if (strcmp (buf1, buf2)) {
718 printf("snprintf doesn't match Format: %s\n\t"
719 "snprintf = %s\n\tsprintf = %s\n",
720 fp_fmt[x], buf1, buf2);
721 fail++;
722 }
723 num++;
724 }
725 }
726 for (x = 0; int_fmt[x] != NULL ; x++) {
727 for (y = 0; int_nums[y] != 0 ; y++) {
728 snprintf(buf1, sizeof (buf1), int_fmt[x], int_nums[y]);
729 sprintf(buf2, int_fmt[x], int_nums[y]);
730 if (strcmp (buf1, buf2)) {
731 printf("snprintf doesn't match Format: %s\n\t"
732 "snprintf = %s\n\tsprintf = %s\n",
733 int_fmt[x], buf1, buf2);
734 fail++;
735 }
736 num++;
737 }
738 }
739 printf("%d tests failed out of %d.\n", fail, num);
740 return(0);
741}
742#endif /* SNPRINTF_TEST */
743
744#endif /* !HAVE_SNPRINTF */