Annotation of embedaddon/bird2/lib/printf.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD Library -- Formatted Output
! 3: *
! 4: * (c) 1991, 1992 Lars Wirzenius & Linus Torvalds
! 5: *
! 6: * Hacked up for BIRD by Martin Mares <mj@ucw.cz>
! 7: * Buffer size limitation implemented by Martin Mares.
! 8: */
! 9:
! 10: #include "nest/bird.h"
! 11: #include "string.h"
! 12:
! 13: #include <errno.h>
! 14:
! 15: #include "nest/iface.h"
! 16:
! 17: /* we use this so that we can do without the ctype library */
! 18: #define is_digit(c) ((c) >= '0' && (c) <= '9')
! 19:
! 20: static int skip_atoi(const char **s)
! 21: {
! 22: int i=0;
! 23:
! 24: while (is_digit(**s))
! 25: i = i*10 + *((*s)++) - '0';
! 26: return i;
! 27: }
! 28:
! 29: #define ZEROPAD 1 /* pad with zero */
! 30: #define SIGN 2 /* unsigned/signed long */
! 31: #define PLUS 4 /* show plus */
! 32: #define SPACE 8 /* space if plus */
! 33: #define LEFT 16 /* left justified */
! 34: #define SPECIAL 32 /* 0x */
! 35: #define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */
! 36:
! 37: static char * number(char * str, u64 num, uint base, int size, int precision,
! 38: int type, int remains)
! 39: {
! 40: char c,sign,tmp[66];
! 41: const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";
! 42: int i;
! 43:
! 44: if (size >= 0 && (remains -= size) < 0)
! 45: return NULL;
! 46: if (type & LARGE)
! 47: digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
! 48: if (type & LEFT)
! 49: type &= ~ZEROPAD;
! 50: if (base < 2 || base > 36)
! 51: return 0;
! 52: c = (type & ZEROPAD) ? '0' : ' ';
! 53: sign = 0;
! 54: if (type & SIGN) {
! 55: if (num > (u64) INT64_MAX) {
! 56: sign = '-';
! 57: num = -num;
! 58: size--;
! 59: } else if (type & PLUS) {
! 60: sign = '+';
! 61: size--;
! 62: } else if (type & SPACE) {
! 63: sign = ' ';
! 64: size--;
! 65: }
! 66: }
! 67: if (type & SPECIAL) {
! 68: if (base == 16)
! 69: size -= 2;
! 70: else if (base == 8)
! 71: size--;
! 72: }
! 73: i = 0;
! 74: if (num == 0)
! 75: tmp[i++]='0';
! 76: else while (num != 0) {
! 77: uint res = num % base;
! 78: num = num / base;
! 79: tmp[i++] = digits[res];
! 80: }
! 81: if (i > precision)
! 82: precision = i;
! 83: size -= precision;
! 84: if (size < 0 && -size > remains)
! 85: return NULL;
! 86: if (!(type&(ZEROPAD+LEFT)))
! 87: while(size-->0)
! 88: *str++ = ' ';
! 89: if (sign)
! 90: *str++ = sign;
! 91: if (type & SPECIAL) {
! 92: if (base==8)
! 93: *str++ = '0';
! 94: else if (base==16) {
! 95: *str++ = '0';
! 96: *str++ = digits[33];
! 97: }
! 98: }
! 99: if (!(type & LEFT))
! 100: while (size-- > 0)
! 101: *str++ = c;
! 102: while (i < precision--)
! 103: *str++ = '0';
! 104: while (i-- > 0)
! 105: *str++ = tmp[i];
! 106: while (size-- > 0)
! 107: *str++ = ' ';
! 108: return str;
! 109: }
! 110:
! 111: /**
! 112: * bvsnprintf - BIRD's vsnprintf()
! 113: * @buf: destination buffer
! 114: * @size: size of the buffer
! 115: * @fmt: format string
! 116: * @args: a list of arguments to be formatted
! 117: *
! 118: * This functions acts like ordinary sprintf() except that it checks available
! 119: * space to avoid buffer overflows and it allows some more format specifiers:
! 120: * |%I| for formatting of IP addresses (width of 1 is automatically replaced by
! 121: * standard IP address width which depends on whether we use IPv4 or IPv6; |%I4|
! 122: * or |%I6| can be used for explicit ip4_addr / ip6_addr arguments, |%N| for
! 123: * generic network addresses (net_addr *), |%R| for Router / Network ID (u32
! 124: * value printed as IPv4 address), |%lR| for 64bit Router / Network ID (u64
! 125: * value printed as eight :-separated octets), |%t| for time values (btime) with
! 126: * specified subsecond precision, and |%m| resp. |%M| for error messages (uses
! 127: * strerror() to translate @errno code to message text). On the other hand, it
! 128: * doesn't support floating point numbers. The bvsnprintf() supports |%h| and
! 129: * |%l| qualifiers, but |%l| is used for s64/u64 instead of long/ulong.
! 130: *
! 131: * Result: number of characters of the output string or -1 if
! 132: * the buffer space was insufficient.
! 133: */
! 134: int bvsnprintf(char *buf, int size, const char *fmt, va_list args)
! 135: {
! 136: int len, i;
! 137: u64 num;
! 138: uint base;
! 139: u32 x;
! 140: u64 X;
! 141: btime t;
! 142: s64 t1, t2;
! 143: char *str, *start;
! 144: const char *s;
! 145: char ipbuf[NET_MAX_TEXT_LENGTH+1];
! 146: struct iface *iface;
! 147:
! 148: int flags; /* flags to number() */
! 149:
! 150: int field_width; /* width of output field */
! 151: int precision; /* min. # of digits for integers; max
! 152: number of chars for from string */
! 153: int qualifier; /* 'h' or 'l' for integer fields */
! 154:
! 155: for (start=str=buf ; *fmt ; ++fmt, size-=(str-start), start=str) {
! 156: if (*fmt != '%') {
! 157: if (!size)
! 158: return -1;
! 159: *str++ = *fmt;
! 160: continue;
! 161: }
! 162:
! 163: /* process flags */
! 164: flags = 0;
! 165: repeat:
! 166: ++fmt; /* this also skips first '%' */
! 167: switch (*fmt) {
! 168: case '-': flags |= LEFT; goto repeat;
! 169: case '+': flags |= PLUS; goto repeat;
! 170: case ' ': flags |= SPACE; goto repeat;
! 171: case '#': flags |= SPECIAL; goto repeat;
! 172: case '0': flags |= ZEROPAD; goto repeat;
! 173: }
! 174:
! 175: /* get field width */
! 176: field_width = -1;
! 177: if (is_digit(*fmt))
! 178: field_width = skip_atoi(&fmt);
! 179: else if (*fmt == '*') {
! 180: ++fmt;
! 181: /* it's the next argument */
! 182: field_width = va_arg(args, int);
! 183: if (field_width < 0) {
! 184: field_width = -field_width;
! 185: flags |= LEFT;
! 186: }
! 187: }
! 188:
! 189: /* get the precision */
! 190: precision = -1;
! 191: if (*fmt == '.') {
! 192: ++fmt;
! 193: if (is_digit(*fmt))
! 194: precision = skip_atoi(&fmt);
! 195: else if (*fmt == '*') {
! 196: ++fmt;
! 197: /* it's the next argument */
! 198: precision = va_arg(args, int);
! 199: }
! 200: if (precision < 0)
! 201: precision = 0;
! 202: }
! 203:
! 204: /* get the conversion qualifier */
! 205: qualifier = -1;
! 206: if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
! 207: qualifier = *fmt;
! 208: ++fmt;
! 209: }
! 210:
! 211: /* default base */
! 212: base = 10;
! 213:
! 214: if (field_width > size)
! 215: return -1;
! 216: switch (*fmt) {
! 217: case 'c':
! 218: if (!(flags & LEFT))
! 219: while (--field_width > 0)
! 220: *str++ = ' ';
! 221: *str++ = (byte) va_arg(args, int);
! 222: while (--field_width > 0)
! 223: *str++ = ' ';
! 224: continue;
! 225:
! 226: case 'm':
! 227: if (flags & SPECIAL) {
! 228: if (!errno)
! 229: continue;
! 230: if (size < 2)
! 231: return -1;
! 232: *str++ = ':';
! 233: *str++ = ' ';
! 234: start += 2;
! 235: size -= 2;
! 236: }
! 237: s = strerror(errno);
! 238: goto str;
! 239: case 'M':
! 240: s = strerror(va_arg(args, int));
! 241: goto str;
! 242: case 'N': {
! 243: net_addr *n = va_arg(args, net_addr *);
! 244: if (field_width == 1)
! 245: field_width = net_max_text_length[n->type];
! 246: net_format(n, ipbuf, sizeof(ipbuf));
! 247: s = ipbuf;
! 248: goto str;
! 249: }
! 250: case 's':
! 251: s = va_arg(args, char *);
! 252: if (!s)
! 253: s = "<NULL>";
! 254:
! 255: str:
! 256: len = strlen(s);
! 257: if (precision >= 0 && len > precision)
! 258: len = precision;
! 259: if (len > size)
! 260: return -1;
! 261:
! 262: if (!(flags & LEFT))
! 263: while (len < field_width--)
! 264: *str++ = ' ';
! 265: for (i = 0; i < len; ++i)
! 266: *str++ = *s++;
! 267: while (len < field_width--)
! 268: *str++ = ' ';
! 269: continue;
! 270:
! 271: case 'V': {
! 272: const char *vfmt = va_arg(args, const char *);
! 273: va_list *vargs = va_arg(args, va_list *);
! 274: int res = bvsnprintf(str, size, vfmt, *vargs);
! 275: if (res < 0)
! 276: return -1;
! 277: str += res;
! 278: size -= res;
! 279: continue;
! 280: }
! 281:
! 282: case 'p':
! 283: if (field_width == -1) {
! 284: field_width = 2*sizeof(void *);
! 285: flags |= ZEROPAD;
! 286: }
! 287: str = number(str, (uintptr_t) va_arg(args, void *), 16,
! 288: field_width, precision, flags, size);
! 289: if (!str)
! 290: return -1;
! 291: continue;
! 292:
! 293: case 'n':
! 294: if (qualifier == 'l') {
! 295: s64 * ip = va_arg(args, s64 *);
! 296: *ip = (str - buf);
! 297: } else {
! 298: int * ip = va_arg(args, int *);
! 299: *ip = (str - buf);
! 300: }
! 301: continue;
! 302:
! 303: /* IP address */
! 304: case 'I':
! 305: if (fmt[1] == '4') {
! 306: /* Explicit IPv4 address */
! 307: ip4_addr a = va_arg(args, ip4_addr);
! 308: ip4_ntop(a, ipbuf);
! 309: i = IP4_MAX_TEXT_LENGTH;
! 310: fmt++;
! 311: } else if (fmt[1] == '6') {
! 312: /* Explicit IPv6 address */
! 313: ip6_addr a = va_arg(args, ip6_addr);
! 314: ip6_ntop(a, ipbuf);
! 315: i = IP6_MAX_TEXT_LENGTH;
! 316: fmt++;
! 317: } else {
! 318: /* Just IP address */
! 319: ip_addr a = va_arg(args, ip_addr);
! 320:
! 321: if (ipa_is_ip4(a)) {
! 322: ip4_ntop(ipa_to_ip4(a), ipbuf);
! 323: i = IP4_MAX_TEXT_LENGTH;
! 324: } else {
! 325: ip6_ntop(ipa_to_ip6(a), ipbuf);
! 326: i = IP6_MAX_TEXT_LENGTH;
! 327: }
! 328: }
! 329:
! 330: s = ipbuf;
! 331: if (field_width == 1)
! 332: field_width = i;
! 333:
! 334: goto str;
! 335:
! 336: /* Interface scope after link-local IP address */
! 337: case 'J':
! 338: iface = va_arg(args, struct iface *);
! 339: if (!iface)
! 340: continue;
! 341: if (!size)
! 342: return -1;
! 343:
! 344: *str++ = '%';
! 345: start++;
! 346: size--;
! 347:
! 348: s = iface->name;
! 349: goto str;
! 350:
! 351: /* Router/Network ID - essentially IPv4 address in u32 value */
! 352: case 'R':
! 353: if (qualifier == 'l') {
! 354: X = va_arg(args, u64);
! 355: bsprintf(ipbuf, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
! 356: (uint) ((X >> 56) & 0xff),
! 357: (uint) ((X >> 48) & 0xff),
! 358: (uint) ((X >> 40) & 0xff),
! 359: (uint) ((X >> 32) & 0xff),
! 360: (uint) ((X >> 24) & 0xff),
! 361: (uint) ((X >> 16) & 0xff),
! 362: (uint) ((X >> 8) & 0xff),
! 363: (uint) (X & 0xff));
! 364: }
! 365: else
! 366: {
! 367: x = va_arg(args, u32);
! 368: ip4_ntop(ip4_from_u32(x), ipbuf);
! 369: }
! 370: s = ipbuf;
! 371: goto str;
! 372:
! 373: case 't':
! 374: t = va_arg(args, btime);
! 375: t1 = t TO_S;
! 376: t2 = t - t1 S;
! 377:
! 378: if (precision < 0)
! 379: precision = 3;
! 380:
! 381: if (precision > 6)
! 382: precision = 6;
! 383:
! 384: /* Compute field_width for second part */
! 385: if ((precision > 0) && (field_width > 0))
! 386: field_width -= (1 + precision);
! 387:
! 388: if (field_width < 0)
! 389: field_width = 0;
! 390:
! 391: /* Print seconds */
! 392: flags |= SIGN;
! 393: str = number(str, (u64) t1, 10, field_width, 0, flags, size);
! 394: if (!str)
! 395: return -1;
! 396:
! 397: if (precision > 0)
! 398: {
! 399: size -= (str-start);
! 400: start = str;
! 401:
! 402: if ((1 + precision) > size)
! 403: return -1;
! 404:
! 405: /* Convert microseconds to requested precision */
! 406: for (i = precision; i < 6; i++)
! 407: t2 /= 10;
! 408:
! 409: /* Print sub-seconds */
! 410: *str++ = '.';
! 411: str = number(str, (u64) t2, 10, precision, 0, ZEROPAD, size - 1);
! 412: if (!str)
! 413: return -1;
! 414: }
! 415: goto done;
! 416:
! 417: /* integer number formats - set up the flags and "break" */
! 418: case 'o':
! 419: base = 8;
! 420: break;
! 421:
! 422: case 'X':
! 423: flags |= LARGE;
! 424: /* fallthrough */
! 425: case 'x':
! 426: base = 16;
! 427: break;
! 428:
! 429: case 'd':
! 430: case 'i':
! 431: flags |= SIGN;
! 432: case 'u':
! 433: break;
! 434:
! 435: default:
! 436: if (size < 2)
! 437: return -1;
! 438: if (*fmt != '%')
! 439: *str++ = '%';
! 440: if (*fmt)
! 441: *str++ = *fmt;
! 442: else
! 443: --fmt;
! 444: continue;
! 445: }
! 446: if (flags & SIGN) {
! 447: /* Conversions valid per ISO C99 6.3.1.3 (2) */
! 448: if (qualifier == 'l')
! 449: num = (u64) va_arg(args, s64);
! 450: else if (qualifier == 'h')
! 451: num = (u64) (short) va_arg(args, int);
! 452: else
! 453: num = (u64) va_arg(args, int);
! 454: } else {
! 455: if (qualifier == 'l')
! 456: num = va_arg(args, u64);
! 457: else if (qualifier == 'h')
! 458: num = (unsigned short) va_arg(args, int);
! 459: else
! 460: num = va_arg(args, uint);
! 461: }
! 462: str = number(str, num, base, field_width, precision, flags, size);
! 463: if (!str)
! 464: return -1;
! 465: done: ;
! 466: }
! 467: if (!size)
! 468: return -1;
! 469: *str = '\0';
! 470: return str-buf;
! 471: }
! 472:
! 473: /**
! 474: * bvsprintf - BIRD's vsprintf()
! 475: * @buf: buffer
! 476: * @fmt: format string
! 477: * @args: a list of arguments to be formatted
! 478: *
! 479: * This function is equivalent to bvsnprintf() with an infinite
! 480: * buffer size. Please use carefully only when you are absolutely
! 481: * sure the buffer won't overflow.
! 482: */
! 483: int bvsprintf(char *buf, const char *fmt, va_list args)
! 484: {
! 485: return bvsnprintf(buf, 1000000000, fmt, args);
! 486: }
! 487:
! 488: /**
! 489: * bsprintf - BIRD's sprintf()
! 490: * @buf: buffer
! 491: * @fmt: format string
! 492: *
! 493: * This function is equivalent to bvsnprintf() with an infinite
! 494: * buffer size and variable arguments instead of a &va_list.
! 495: * Please use carefully only when you are absolutely
! 496: * sure the buffer won't overflow.
! 497: */
! 498: int bsprintf(char * buf, const char *fmt, ...)
! 499: {
! 500: va_list args;
! 501: int i;
! 502:
! 503: va_start(args, fmt);
! 504: i=bvsnprintf(buf, 1000000000, fmt, args);
! 505: va_end(args);
! 506: return i;
! 507: }
! 508:
! 509: /**
! 510: * bsnprintf - BIRD's snprintf()
! 511: * @buf: buffer
! 512: * @size: buffer size
! 513: * @fmt: format string
! 514: *
! 515: * This function is equivalent to bsnprintf() with variable arguments instead of a &va_list.
! 516: */
! 517: int bsnprintf(char * buf, int size, const char *fmt, ...)
! 518: {
! 519: va_list args;
! 520: int i;
! 521:
! 522: va_start(args, fmt);
! 523: i=bvsnprintf(buf, size, fmt, args);
! 524: va_end(args);
! 525: return i;
! 526: }
! 527:
! 528: int
! 529: buffer_vprint(buffer *buf, const char *fmt, va_list args)
! 530: {
! 531: int i = bvsnprintf((char *) buf->pos, buf->end - buf->pos, fmt, args);
! 532:
! 533: if ((i < 0) && (buf->pos < buf->end))
! 534: *buf->pos = 0;
! 535:
! 536: buf->pos = (i >= 0) ? (buf->pos + i) : buf->end;
! 537: return i;
! 538: }
! 539:
! 540: int
! 541: buffer_print(buffer *buf, const char *fmt, ...)
! 542: {
! 543: va_list args;
! 544: int i;
! 545:
! 546: va_start(args, fmt);
! 547: i = bvsnprintf((char *) buf->pos, buf->end - buf->pos, fmt, args);
! 548: va_end(args);
! 549:
! 550: if ((i < 0) && (buf->pos < buf->end))
! 551: *buf->pos = 0;
! 552:
! 553: buf->pos = (i >= 0) ? (buf->pos + i) : buf->end;
! 554: return i;
! 555: }
! 556:
! 557: void
! 558: buffer_puts(buffer *buf, const char *str)
! 559: {
! 560: byte *bp = buf->pos;
! 561: byte *be = buf->end - 1;
! 562:
! 563: while (bp < be && *str)
! 564: *bp++ = *str++;
! 565:
! 566: if (bp <= be)
! 567: *bp = 0;
! 568:
! 569: buf->pos = (bp < be) ? bp : buf->end;
! 570: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to printf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / lib