1: /* print.c
2:
3: Turn data structures into printable text. */
4:
5: /*
6: * Copyright (c) 2009-2011 by Internet Systems Consortium, Inc. ("ISC")
7: * Copyright (c) 2004-2007 by Internet Systems Consortium, Inc. ("ISC")
8: * Copyright (c) 1995-2003 by Internet Software Consortium
9: *
10: * Permission to use, copy, modify, and distribute this software for any
11: * purpose with or without fee is hereby granted, provided that the above
12: * copyright notice and this permission notice appear in all copies.
13: *
14: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
15: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
16: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
17: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
18: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
20: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21: *
22: * Internet Systems Consortium, Inc.
23: * 950 Charter Street
24: * Redwood City, CA 94063
25: * <info@isc.org>
26: * https://www.isc.org/
27: *
28: * This software has been written for Internet Systems Consortium
29: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
30: * To learn more about Internet Systems Consortium, see
31: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
32: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
33: * ``http://www.nominum.com''.
34: */
35:
36: #include "dhcpd.h"
37:
38: int db_time_format = DEFAULT_TIME_FORMAT;
39:
40: char *quotify_string (const char *s, const char *file, int line)
41: {
42: unsigned len = 0;
43: const char *sp;
44: char *buf, *nsp;
45:
46: for (sp = s; sp && *sp; sp++) {
47: if (*sp == ' ')
48: len++;
49: else if (!isascii ((int)*sp) || !isprint ((int)*sp))
50: len += 4;
51: else if (*sp == '"' || *sp == '\\')
52: len += 2;
53: else
54: len++;
55: }
56:
57: buf = dmalloc (len + 1, file, line);
58: if (buf) {
59: nsp = buf;
60: for (sp = s; sp && *sp; sp++) {
61: if (*sp == ' ')
62: *nsp++ = ' ';
63: else if (!isascii ((int)*sp) || !isprint ((int)*sp)) {
64: sprintf (nsp, "\\%03o",
65: *(const unsigned char *)sp);
66: nsp += 4;
67: } else if (*sp == '"' || *sp == '\\') {
68: *nsp++ = '\\';
69: *nsp++ = *sp;
70: } else
71: *nsp++ = *sp;
72: }
73: *nsp++ = 0;
74: }
75: return buf;
76: }
77:
78: char *quotify_buf (const unsigned char *s, unsigned len,
79: const char *file, int line)
80: {
81: unsigned nulen = 0;
82: char *buf, *nsp;
83: int i;
84:
85: for (i = 0; i < len; i++) {
86: if (s [i] == ' ')
87: nulen++;
88: else if (!isascii (s [i]) || !isprint (s [i]))
89: nulen += 4;
90: else if (s [i] == '"' || s [i] == '\\')
91: nulen += 2;
92: else
93: nulen++;
94: }
95:
96: buf = dmalloc (nulen + 1, MDL);
97: if (buf) {
98: nsp = buf;
99: for (i = 0; i < len; i++) {
100: if (s [i] == ' ')
101: *nsp++ = ' ';
102: else if (!isascii (s [i]) || !isprint (s [i])) {
103: sprintf (nsp, "\\%03o", s [i]);
104: nsp += 4;
105: } else if (s [i] == '"' || s [i] == '\\') {
106: *nsp++ = '\\';
107: *nsp++ = s [i];
108: } else
109: *nsp++ = s [i];
110: }
111: *nsp++ = 0;
112: }
113: return buf;
114: }
115:
116: char *print_base64 (const unsigned char *buf, unsigned len,
117: const char *file, int line)
118: {
119: char *s, *b;
120: unsigned bl;
121: int i;
122: unsigned val, extra;
123: static char to64 [] =
124: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
125:
126: bl = ((len * 4 + 2) / 3) + 1;
127: b = dmalloc (bl + 1, file, line);
128: if (!b)
129: return (char *)0;
130:
131: i = 0;
132: s = b;
133: while (i != len) {
134: val = buf [i++];
135: extra = val & 3;
136: val = val >> 2;
137: *s++ = to64 [val];
138: if (i == len) {
139: *s++ = to64 [extra << 4];
140: *s++ = '=';
141: break;
142: }
143: val = (extra << 8) + buf [i++];
144: extra = val & 15;
145: val = val >> 4;
146: *s++ = to64 [val];
147: if (i == len) {
148: *s++ = to64 [extra << 2];
149: *s++ = '=';
150: break;
151: }
152: val = (extra << 8) + buf [i++];
153: extra = val & 0x3f;
154: val = val >> 6;
155: *s++ = to64 [val];
156: *s++ = to64 [extra];
157: }
158: if (!len)
159: *s++ = '=';
160: *s++ = 0;
161: if (s > b + bl + 1)
162: abort ();
163: return b;
164: }
165:
166: char *print_hw_addr (htype, hlen, data)
167: int htype;
168: int hlen;
169: unsigned char *data;
170: {
171: static char habuf [49];
172: char *s;
173: int i;
174:
175: if (hlen <= 0)
176: habuf [0] = 0;
177: else {
178: s = habuf;
179: for (i = 0; i < hlen; i++) {
180: sprintf (s, "%02x", data [i]);
181: s += strlen (s);
182: *s++ = ':';
183: }
184: *--s = 0;
185: }
186: return habuf;
187: }
188:
189: void print_lease (lease)
190: struct lease *lease;
191: {
192: struct tm *t;
193: char tbuf [32];
194:
195: log_debug (" Lease %s",
196: piaddr (lease -> ip_addr));
197:
198: t = gmtime (&lease -> starts);
199: strftime (tbuf, sizeof tbuf, "%Y/%m/%d %H:%M:%S", t);
200: log_debug (" start %s", tbuf);
201:
202: t = gmtime (&lease -> ends);
203: strftime (tbuf, sizeof tbuf, "%Y/%m/%d %H:%M:%S", t);
204: log_debug (" end %s", tbuf);
205:
206: if (lease -> hardware_addr.hlen)
207: log_debug (" hardware addr = %s",
208: print_hw_addr (lease -> hardware_addr.hbuf [0],
209: lease -> hardware_addr.hlen - 1,
210: &lease -> hardware_addr.hbuf [1]));
211: log_debug (" host %s ",
212: lease -> host ? lease -> host -> name : "<none>");
213: }
214:
215: #if defined (DEBUG_PACKET)
216: void dump_packet_option (struct option_cache *oc,
217: struct packet *packet,
218: struct lease *lease,
219: struct client_state *client,
220: struct option_state *in_options,
221: struct option_state *cfg_options,
222: struct binding_scope **scope,
223: struct universe *u, void *foo)
224: {
225: const char *name, *dot;
226: struct data_string ds;
227: memset (&ds, 0, sizeof ds);
228:
229: if (u != &dhcp_universe) {
230: name = u -> name;
231: dot = ".";
232: } else {
233: name = "";
234: dot = "";
235: }
236: if (evaluate_option_cache (&ds, packet, lease, client,
237: in_options, cfg_options, scope, oc, MDL)) {
238: log_debug (" option %s%s%s %s;\n",
239: name, dot, oc -> option -> name,
240: pretty_print_option (oc -> option,
241: ds.data, ds.len, 1, 1));
242: data_string_forget (&ds, MDL);
243: }
244: }
245:
246: void dump_packet (tp)
247: struct packet *tp;
248: {
249: struct dhcp_packet *tdp = tp -> raw;
250:
251: log_debug ("packet length %d", tp -> packet_length);
252: log_debug ("op = %d htype = %d hlen = %d hops = %d",
253: tdp -> op, tdp -> htype, tdp -> hlen, tdp -> hops);
254: log_debug ("xid = %x secs = %ld flags = %x",
255: tdp -> xid, (unsigned long)tdp -> secs, tdp -> flags);
256: log_debug ("ciaddr = %s", inet_ntoa (tdp -> ciaddr));
257: log_debug ("yiaddr = %s", inet_ntoa (tdp -> yiaddr));
258: log_debug ("siaddr = %s", inet_ntoa (tdp -> siaddr));
259: log_debug ("giaddr = %s", inet_ntoa (tdp -> giaddr));
260: log_debug ("chaddr = %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
261: ((unsigned char *)(tdp -> chaddr)) [0],
262: ((unsigned char *)(tdp -> chaddr)) [1],
263: ((unsigned char *)(tdp -> chaddr)) [2],
264: ((unsigned char *)(tdp -> chaddr)) [3],
265: ((unsigned char *)(tdp -> chaddr)) [4],
266: ((unsigned char *)(tdp -> chaddr)) [5]);
267: log_debug ("filename = %s", tdp -> file);
268: log_debug ("server_name = %s", tdp -> sname);
269: if (tp -> options_valid) {
270: int i;
271:
272: for (i = 0; i < tp -> options -> universe_count; i++) {
273: if (tp -> options -> universes [i]) {
274: option_space_foreach (tp, (struct lease *)0,
275: (struct client_state *)0,
276: (struct option_state *)0,
277: tp -> options,
278: &global_scope,
279: universes [i], 0,
280: dump_packet_option);
281: }
282: }
283: }
284: log_debug ("%s", "");
285: }
286: #endif
287:
288: void dump_raw (buf, len)
289: const unsigned char *buf;
290: unsigned len;
291: {
292: int i;
293: char lbuf [80];
294: int lbix = 0;
295:
296: /*
297: 1 2 3 4 5 6 7
298: 01234567890123456789012345678901234567890123456789012345678901234567890123
299: 280: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 .................
300: */
301:
302: memset(lbuf, ' ', 79);
303: lbuf [79] = 0;
304:
305: for (i = 0; i < len; i++) {
306: if ((i & 15) == 0) {
307: if (lbix) {
308: lbuf[53]=' ';
309: lbuf[54]=' ';
310: lbuf[55]=' ';
311: lbuf[73]='\0';
312: log_info ("%s", lbuf);
313: }
314: memset(lbuf, ' ', 79);
315: lbuf [79] = 0;
316: sprintf (lbuf, "%03x:", i);
317: lbix = 4;
318: } else if ((i & 7) == 0)
319: lbuf [lbix++] = ' ';
320:
321: if(isprint(buf[i])) {
322: lbuf[56+(i%16)]=buf[i];
323: } else {
324: lbuf[56+(i%16)]='.';
325: }
326:
327: sprintf (&lbuf [lbix], " %02x", buf [i]);
328: lbix += 3;
329: lbuf[lbix]=' ';
330:
331: }
332: lbuf[53]=' ';
333: lbuf[54]=' ';
334: lbuf[55]=' ';
335: lbuf[73]='\0';
336: log_info ("%s", lbuf);
337: }
338:
339: void hash_dump (table)
340: struct hash_table *table;
341: {
342: int i;
343: struct hash_bucket *bp;
344:
345: if (!table)
346: return;
347:
348: for (i = 0; i < table -> hash_count; i++) {
349: if (!table -> buckets [i])
350: continue;
351: log_info ("hash bucket %d:", i);
352: for (bp = table -> buckets [i]; bp; bp = bp -> next) {
353: if (bp -> len)
354: dump_raw (bp -> name, bp -> len);
355: else
356: log_info ("%s", (const char *)bp -> name);
357: }
358: }
359: }
360:
361: /*
362: * print a string as hex. This only outputs
363: * colon separated hex list no matter what
364: * the input looks like. See print_hex
365: * for a function that prints either cshl
366: * or a string if all bytes are printible
367: * It only uses limit characters from buf
368: * and doesn't do anything if buf == NULL
369: *
370: * len - length of data
371: * data - input data
372: * limit - length of buf to use
373: * buf - output buffer
374: */
375: void print_hex_only (len, data, limit, buf)
376: unsigned len;
377: const u_int8_t *data;
378: unsigned limit;
379: char *buf;
380: {
381: unsigned i;
382:
383: if ((buf == NULL) || (limit < 3))
384: return;
385:
386: for (i = 0; (i < limit / 3) && (i < len); i++) {
387: sprintf(&buf[i*3], "%02x:", data[i]);
388: }
389: buf[(i * 3) - 1] = 0;
390: return;
391: }
392:
393: /*
394: * print a string as either text if all the characters
395: * are printable or colon separated hex if they aren't
396: *
397: * len - length of data
398: * data - input data
399: * limit - length of buf to use
400: * buf - output buffer
401: */
402: void print_hex_or_string (len, data, limit, buf)
403: unsigned len;
404: const u_int8_t *data;
405: unsigned limit;
406: char *buf;
407: {
408: unsigned i;
409: if ((buf == NULL) || (limit < 3))
410: return;
411:
412: for (i = 0; (i < (limit - 3)) && (i < len); i++) {
413: if (!isascii(data[i]) || !isprint(data[i])) {
414: print_hex_only(len, data, limit, buf);
415: return;
416: }
417: }
418:
419: buf[0] = '"';
420: i = len;
421: if (i > (limit - 3))
422: i = limit - 3;
423: memcpy(&buf[1], data, i);
424: buf[i + 1] = '"';
425: buf[i + 2] = 0;
426: return;
427: }
428:
429: /*
430: * print a string as either hex or text
431: * using static buffers to hold the output
432: *
433: * len - length of data
434: * data - input data
435: * limit - length of buf
436: * buf_num - the output buffer to use
437: */
438: #define HBLEN 1024
439: char *print_hex(len, data, limit, buf_num)
440: unsigned len;
441: const u_int8_t *data;
442: unsigned limit;
443: unsigned buf_num;
444: {
445: static char hex_buf_1[HBLEN + 1];
446: static char hex_buf_2[HBLEN + 1];
447: static char hex_buf_3[HBLEN + 1];
448: char *hex_buf;
449:
450: switch(buf_num) {
451: case 0:
452: hex_buf = hex_buf_1;
453: if (limit >= sizeof(hex_buf_1))
454: limit = sizeof(hex_buf_1);
455: break;
456: case 1:
457: hex_buf = hex_buf_2;
458: if (limit >= sizeof(hex_buf_2))
459: limit = sizeof(hex_buf_2);
460: break;
461: case 2:
462: hex_buf = hex_buf_3;
463: if (limit >= sizeof(hex_buf_3))
464: limit = sizeof(hex_buf_3);
465: break;
466: default:
467: return(NULL);
468: }
469:
470: print_hex_or_string(len, data, limit, hex_buf);
471: return(hex_buf);
472: }
473:
474: #define DQLEN 80
475:
476: char *print_dotted_quads (len, data)
477: unsigned len;
478: const u_int8_t *data;
479: {
480: static char dq_buf [DQLEN + 1];
481: int i;
482: char *s, *last;
483:
484: s = &dq_buf [0];
485: last = s;
486:
487: i = 0;
488:
489: /* %Audit% Loop bounds checks to 21 bytes. %2004.06.17,Safe%
490: * The sprintf can't exceed 18 bytes, and since the loop enforces
491: * 21 bytes of space per iteration at no time can we exit the
492: * loop without at least 3 bytes spare.
493: */
494: do {
495: sprintf (s, "%u.%u.%u.%u, ",
496: data [i], data [i + 1], data [i + 2], data [i + 3]);
497: s += strlen (s);
498: i += 4;
499: } while ((s - &dq_buf [0] > DQLEN - 21) &&
500: i + 3 < len);
501: if (i == len)
502: s [-2] = 0;
503: else
504: strcpy (s, "...");
505: return dq_buf;
506: }
507:
508: char *print_dec_1 (val)
509: unsigned long val;
510: {
511: static char vbuf [32];
512: sprintf (vbuf, "%lu", val);
513: return vbuf;
514: }
515:
516: char *print_dec_2 (val)
517: unsigned long val;
518: {
519: static char vbuf [32];
520: sprintf (vbuf, "%lu", val);
521: return vbuf;
522: }
523:
524: static unsigned print_subexpression (struct expression *, char *, unsigned);
525:
526: static unsigned print_subexpression (expr, buf, len)
527: struct expression *expr;
528: char *buf;
529: unsigned len;
530: {
531: unsigned rv, left;
532: const char *s;
533:
534: switch (expr -> op) {
535: case expr_none:
536: if (len > 3) {
537: strcpy (buf, "nil");
538: return 3;
539: }
540: break;
541:
542: case expr_match:
543: if (len > 7) {
544: strcpy (buf, "(match)");
545: return 7;
546: }
547: break;
548:
549: case expr_check:
550: rv = 10 + strlen (expr -> data.check -> name);
551: if (len > rv) {
552: sprintf (buf, "(check %s)",
553: expr -> data.check -> name);
554: return rv;
555: }
556: break;
557:
558: case expr_equal:
559: if (len > 6) {
560: rv = 4;
561: strcpy (buf, "(eq ");
562: rv += print_subexpression (expr -> data.equal [0],
563: buf + rv, len - rv - 2);
564: buf [rv++] = ' ';
565: rv += print_subexpression (expr -> data.equal [1],
566: buf + rv, len - rv - 1);
567: buf [rv++] = ')';
568: buf [rv] = 0;
569: return rv;
570: }
571: break;
572:
573: case expr_not_equal:
574: if (len > 7) {
575: rv = 5;
576: strcpy (buf, "(neq ");
577: rv += print_subexpression (expr -> data.equal [0],
578: buf + rv, len - rv - 2);
579: buf [rv++] = ' ';
580: rv += print_subexpression (expr -> data.equal [1],
581: buf + rv, len - rv - 1);
582: buf [rv++] = ')';
583: buf [rv] = 0;
584: return rv;
585: }
586: break;
587:
588: case expr_regex_match:
589: if (len > 10) {
590: rv = 4;
591: strcpy(buf, "(regex ");
592: rv += print_subexpression(expr->data.equal[0],
593: buf + rv, len - rv - 2);
594: buf[rv++] = ' ';
595: rv += print_subexpression(expr->data.equal[1],
596: buf + rv, len - rv - 1);
597: buf[rv++] = ')';
598: buf[rv] = 0;
599: return rv;
600: }
601: break;
602:
603: case expr_substring:
604: if (len > 11) {
605: rv = 8;
606: strcpy (buf, "(substr ");
607: rv += print_subexpression (expr -> data.substring.expr,
608: buf + rv, len - rv - 3);
609: buf [rv++] = ' ';
610: rv += print_subexpression
611: (expr -> data.substring.offset,
612: buf + rv, len - rv - 2);
613: buf [rv++] = ' ';
614: rv += print_subexpression (expr -> data.substring.len,
615: buf + rv, len - rv - 1);
616: buf [rv++] = ')';
617: buf [rv] = 0;
618: return rv;
619: }
620: break;
621:
622: case expr_suffix:
623: if (len > 10) {
624: rv = 8;
625: strcpy (buf, "(suffix ");
626: rv += print_subexpression (expr -> data.suffix.expr,
627: buf + rv, len - rv - 2);
628: if (len > rv)
629: buf [rv++] = ' ';
630: rv += print_subexpression (expr -> data.suffix.len,
631: buf + rv, len - rv - 1);
632: if (len > rv)
633: buf [rv++] = ')';
634: buf [rv] = 0;
635: return rv;
636: }
637: break;
638:
639: case expr_lcase:
640: if (len > 9) {
641: rv = 7;
642: strcpy(buf, "(lcase ");
643: rv += print_subexpression(expr->data.lcase,
644: buf + rv, len - rv - 1);
645: buf[rv++] = ')';
646: buf[rv] = 0;
647: return rv;
648: }
649: break;
650:
651: case expr_ucase:
652: if (len > 9) {
653: rv = 7;
654: strcpy(buf, "(ucase ");
655: rv += print_subexpression(expr->data.ucase,
656: buf + rv, len - rv - 1);
657: buf[rv++] = ')';
658: buf[rv] = 0;
659: return rv;
660: }
661: break;
662:
663: case expr_concat:
664: if (len > 10) {
665: rv = 8;
666: strcpy (buf, "(concat ");
667: rv += print_subexpression (expr -> data.concat [0],
668: buf + rv, len - rv - 2);
669: buf [rv++] = ' ';
670: rv += print_subexpression (expr -> data.concat [1],
671: buf + rv, len - rv - 1);
672: buf [rv++] = ')';
673: buf [rv] = 0;
674: return rv;
675: }
676: break;
677:
678: case expr_pick_first_value:
679: if (len > 8) {
680: rv = 6;
681: strcpy (buf, "(pick1st ");
682: rv += print_subexpression
683: (expr -> data.pick_first_value.car,
684: buf + rv, len - rv - 2);
685: buf [rv++] = ' ';
686: rv += print_subexpression
687: (expr -> data.pick_first_value.cdr,
688: buf + rv, len - rv - 1);
689: buf [rv++] = ')';
690: buf [rv] = 0;
691: return rv;
692: }
693: break;
694:
695: case expr_host_lookup:
696: rv = 15 + strlen (expr -> data.host_lookup -> hostname);
697: if (len > rv) {
698: sprintf (buf, "(dns-lookup %s)",
699: expr -> data.host_lookup -> hostname);
700: return rv;
701: }
702: break;
703:
704: case expr_and:
705: s = "and";
706: binop:
707: rv = strlen (s);
708: if (len > rv + 4) {
709: buf [0] = '(';
710: strcpy (&buf [1], s);
711: rv += 1;
712: buf [rv++] = ' ';
713: rv += print_subexpression (expr -> data.and [0],
714: buf + rv, len - rv - 2);
715: buf [rv++] = ' ';
716: rv += print_subexpression (expr -> data.and [1],
717: buf + rv, len - rv - 1);
718: buf [rv++] = ')';
719: buf [rv] = 0;
720: return rv;
721: }
722: break;
723:
724: case expr_or:
725: s = "or";
726: goto binop;
727:
728: case expr_add:
729: s = "+";
730: goto binop;
731:
732: case expr_subtract:
733: s = "-";
734: goto binop;
735:
736: case expr_multiply:
737: s = "*";
738: goto binop;
739:
740: case expr_divide:
741: s = "/";
742: goto binop;
743:
744: case expr_remainder:
745: s = "%";
746: goto binop;
747:
748: case expr_binary_and:
749: s = "&";
750: goto binop;
751:
752: case expr_binary_or:
753: s = "|";
754: goto binop;
755:
756: case expr_binary_xor:
757: s = "^";
758: goto binop;
759:
760: case expr_not:
761: if (len > 6) {
762: rv = 5;
763: strcpy (buf, "(not ");
764: rv += print_subexpression (expr -> data.not,
765: buf + rv, len - rv - 1);
766: buf [rv++] = ')';
767: buf [rv] = 0;
768: return rv;
769: }
770: break;
771:
772: case expr_config_option:
773: s = "cfg-option";
774: goto dooption;
775:
776: case expr_option:
777: s = "option";
778: dooption:
779: rv = strlen (s) + 2 + (strlen (expr -> data.option -> name) +
780: strlen (expr -> data.option -> universe -> name));
781: if (len > rv) {
782: sprintf (buf, "(option %s.%s)",
783: expr -> data.option -> universe -> name,
784: expr -> data.option -> name);
785: return rv;
786: }
787: break;
788:
789: case expr_hardware:
790: if (len > 10) {
791: strcpy (buf, "(hardware)");
792: return 10;
793: }
794: break;
795:
796: case expr_packet:
797: if (len > 10) {
798: rv = 8;
799: strcpy (buf, "(substr ");
800: rv += print_subexpression (expr -> data.packet.offset,
801: buf + rv, len - rv - 2);
802: buf [rv++] = ' ';
803: rv += print_subexpression (expr -> data.packet.len,
804: buf + rv, len - rv - 1);
805: buf [rv++] = ')';
806: buf [rv] = 0;
807: return rv;
808: }
809: break;
810:
811: case expr_const_data:
812: s = print_hex_1 (expr -> data.const_data.len,
813: expr -> data.const_data.data, len);
814: rv = strlen (s);
815: if (rv >= len)
816: rv = len - 1;
817: strncpy (buf, s, rv);
818: buf [rv] = 0;
819: return rv;
820:
821: case expr_encapsulate:
822: rv = 13;
823: strcpy (buf, "(encapsulate ");
824: rv += expr -> data.encapsulate.len;
825: if (rv + 2 > len)
826: rv = len - 2;
827: strncpy (buf,
828: (const char *)expr -> data.encapsulate.data, rv - 13);
829: buf [rv++] = ')';
830: buf [rv++] = 0;
831: break;
832:
833: case expr_extract_int8:
834: if (len > 7) {
835: rv = 6;
836: strcpy (buf, "(int8 ");
837: rv += print_subexpression (expr -> data.extract_int,
838: buf + rv, len - rv - 1);
839: buf [rv++] = ')';
840: buf [rv] = 0;
841: return rv;
842: }
843: break;
844:
845: case expr_extract_int16:
846: if (len > 8) {
847: rv = 7;
848: strcpy (buf, "(int16 ");
849: rv += print_subexpression (expr -> data.extract_int,
850: buf + rv, len - rv - 1);
851: buf [rv++] = ')';
852: buf [rv] = 0;
853: return rv;
854: }
855: break;
856:
857: case expr_extract_int32:
858: if (len > 8) {
859: rv = 7;
860: strcpy (buf, "(int32 ");
861: rv += print_subexpression (expr -> data.extract_int,
862: buf + rv, len - rv - 1);
863: buf [rv++] = ')';
864: buf [rv] = 0;
865: return rv;
866: }
867: break;
868:
869: case expr_encode_int8:
870: if (len > 7) {
871: rv = 6;
872: strcpy (buf, "(to-int8 ");
873: rv += print_subexpression (expr -> data.encode_int,
874: buf + rv, len - rv - 1);
875: buf [rv++] = ')';
876: buf [rv] = 0;
877: return rv;
878: }
879: break;
880:
881: case expr_encode_int16:
882: if (len > 8) {
883: rv = 7;
884: strcpy (buf, "(to-int16 ");
885: rv += print_subexpression (expr -> data.encode_int,
886: buf + rv, len - rv - 1);
887: buf [rv++] = ')';
888: buf [rv] = 0;
889: return rv;
890: }
891: break;
892:
893: case expr_encode_int32:
894: if (len > 8) {
895: rv = 7;
896: strcpy (buf, "(to-int32 ");
897: rv += print_subexpression (expr -> data.encode_int,
898: buf + rv, len - rv - 1);
899: buf [rv++] = ')';
900: buf [rv] = 0;
901: return rv;
902: }
903: break;
904:
905: case expr_const_int:
906: s = print_dec_1 (expr -> data.const_int);
907: rv = strlen (s);
908: if (len > rv) {
909: strcpy (buf, s);
910: return rv;
911: }
912: break;
913:
914: case expr_exists:
915: rv = 10 + (strlen (expr -> data.option -> name) +
916: strlen (expr -> data.option -> universe -> name));
917: if (len > rv) {
918: sprintf (buf, "(exists %s.%s)",
919: expr -> data.option -> universe -> name,
920: expr -> data.option -> name);
921: return rv;
922: }
923: break;
924:
925: case expr_variable_exists:
926: rv = 10 + strlen (expr -> data.variable);
927: if (len > rv) {
928: sprintf (buf, "(defined %s)", expr -> data.variable);
929: return rv;
930: }
931: break;
932:
933: case expr_variable_reference:
934: rv = strlen (expr -> data.variable);
935: if (len > rv) {
936: sprintf (buf, "%s", expr -> data.variable);
937: return rv;
938: }
939: break;
940:
941: case expr_known:
942: s = "known";
943: astring:
944: rv = strlen (s);
945: if (len > rv) {
946: strcpy (buf, s);
947: return rv;
948: }
949: break;
950:
951: case expr_leased_address:
952: s = "leased-address";
953: goto astring;
954:
955: case expr_client_state:
956: s = "client-state";
957: goto astring;
958:
959: case expr_host_decl_name:
960: s = "host-decl-name";
961: goto astring;
962:
963: case expr_lease_time:
964: s = "lease-time";
965: goto astring;
966:
967: case expr_static:
968: s = "static";
969: goto astring;
970:
971: case expr_filename:
972: s = "filename";
973: goto astring;
974:
975: case expr_sname:
976: s = "server-name";
977: goto astring;
978:
979: case expr_reverse:
980: if (len > 11) {
981: rv = 13;
982: strcpy (buf, "(reverse ");
983: rv += print_subexpression (expr -> data.reverse.width,
984: buf + rv, len - rv - 2);
985: buf [rv++] = ' ';
986: rv += print_subexpression (expr -> data.reverse.buffer,
987: buf + rv, len - rv - 1);
988: buf [rv++] = ')';
989: buf [rv] = 0;
990: return rv;
991: }
992: break;
993:
994: case expr_binary_to_ascii:
995: if (len > 5) {
996: rv = 9;
997: strcpy (buf, "(b2a ");
998: rv += print_subexpression (expr -> data.b2a.base,
999: buf + rv, len - rv - 4);
1000: buf [rv++] = ' ';
1001: rv += print_subexpression (expr -> data.b2a.width,
1002: buf + rv, len - rv - 3);
1003: buf [rv++] = ' ';
1004: rv += print_subexpression (expr -> data.b2a.separator,
1005: buf + rv, len - rv - 2);
1006: buf [rv++] = ' ';
1007: rv += print_subexpression (expr -> data.b2a.buffer,
1008: buf + rv, len - rv - 1);
1009: buf [rv++] = ')';
1010: buf [rv] = 0;
1011: return rv;
1012: }
1013: break;
1014:
1015: case expr_dns_transaction:
1016: rv = 10;
1017: if (len < rv + 2) {
1018: buf [0] = '(';
1019: strcpy (&buf [1], "ns-update ");
1020: while (len < rv + 2) {
1021: rv += print_subexpression
1022: (expr -> data.dns_transaction.car,
1023: buf + rv, len - rv - 2);
1024: buf [rv++] = ' ';
1025: expr = expr -> data.dns_transaction.cdr;
1026: }
1027: buf [rv - 1] = ')';
1028: buf [rv] = 0;
1029: return rv;
1030: }
1031: return 0;
1032:
1033: case expr_ns_delete:
1034: s = "delete";
1035: left = 4;
1036: goto dodnsupd;
1037: case expr_ns_exists:
1038: s = "exists";
1039: left = 4;
1040: goto dodnsupd;
1041: case expr_ns_not_exists:
1042: s = "not_exists";
1043: left = 4;
1044: goto dodnsupd;
1045: case expr_ns_add:
1046: s = "update";
1047: left = 5;
1048: dodnsupd:
1049: rv = strlen (s);
1050: if (len > strlen (s) + 1) {
1051: buf [0] = '(';
1052: strcpy (buf + 1, s);
1053: rv++;
1054: buf [rv++] = ' ';
1055: s = print_dec_1 (expr -> data.ns_add.rrclass);
1056: if (len > rv + strlen (s) + left) {
1057: strcpy (&buf [rv], s);
1058: rv += strlen (&buf [rv]);
1059: }
1060: buf [rv++] = ' ';
1061: left--;
1062: s = print_dec_1 (expr -> data.ns_add.rrtype);
1063: if (len > rv + strlen (s) + left) {
1064: strcpy (&buf [rv], s);
1065: rv += strlen (&buf [rv]);
1066: }
1067: buf [rv++] = ' ';
1068: left--;
1069: rv += print_subexpression
1070: (expr -> data.ns_add.rrname,
1071: buf + rv, len - rv - left);
1072: buf [rv++] = ' ';
1073: left--;
1074: rv += print_subexpression
1075: (expr -> data.ns_add.rrdata,
1076: buf + rv, len - rv - left);
1077: buf [rv++] = ' ';
1078: left--;
1079: rv += print_subexpression
1080: (expr -> data.ns_add.ttl,
1081: buf + rv, len - rv - left);
1082: buf [rv++] = ')';
1083: buf [rv] = 0;
1084: return rv;
1085: }
1086: break;
1087:
1088: case expr_null:
1089: if (len > 6) {
1090: strcpy (buf, "(null)");
1091: return 6;
1092: }
1093: break;
1094: case expr_funcall:
1095: rv = 12 + strlen (expr -> data.funcall.name);
1096: if (len > rv + 1) {
1097: strcpy (buf, "(funcall ");
1098: strcpy (buf + 9, expr -> data.funcall.name);
1099: buf [rv++] = ' ';
1100: rv += print_subexpression
1101: (expr -> data.funcall.arglist, buf + rv,
1102: len - rv - 1);
1103: buf [rv++] = ')';
1104: buf [rv] = 0;
1105: return rv;
1106: }
1107: break;
1108:
1109: case expr_arg:
1110: rv = print_subexpression (expr -> data.arg.val, buf, len);
1111: if (expr -> data.arg.next && rv + 2 < len) {
1112: buf [rv++] = ' ';
1113: rv += print_subexpression (expr -> data.arg.next,
1114: buf, len);
1115: if (rv + 1 < len)
1116: buf [rv++] = 0;
1117: return rv;
1118: }
1119: break;
1120:
1121: case expr_function:
1122: rv = 9;
1123: if (len > rv + 1) {
1124: struct string_list *foo;
1125: strcpy (buf, "(function");
1126: for (foo = expr -> data.func -> args;
1127: foo; foo = foo -> next) {
1128: if (len > rv + 2 + strlen (foo -> string)) {
1129: buf [rv - 1] = ' ';
1130: strcpy (&buf [rv], foo -> string);
1131: rv += strlen (foo -> string);
1132: }
1133: }
1134: buf [rv++] = ')';
1135: buf [rv] = 0;
1136: return rv;
1137: }
1138:
1139: default:
1140: log_fatal("Impossible case at %s:%d (undefined expression "
1141: "%d).", MDL, expr->op);
1142: break;
1143: }
1144: return 0;
1145: }
1146:
1147: void print_expression (name, expr)
1148: const char *name;
1149: struct expression *expr;
1150: {
1151: char buf [1024];
1152:
1153: print_subexpression (expr, buf, sizeof buf);
1154: log_info ("%s: %s", name, buf);
1155: }
1156:
1157: int token_print_indent_concat (FILE *file, int col, int indent,
1158: const char *prefix,
1159: const char *suffix, ...)
1160: {
1161: va_list list;
1162: unsigned len;
1163: char *s, *t, *u;
1164:
1165: va_start (list, suffix);
1166: s = va_arg (list, char *);
1167: len = 0;
1168: while (s) {
1169: len += strlen (s);
1170: s = va_arg (list, char *);
1171: }
1172: va_end (list);
1173:
1174: t = dmalloc (len + 1, MDL);
1175: if (!t)
1176: log_fatal ("token_print_indent: no memory for copy buffer");
1177:
1178: va_start (list, suffix);
1179: s = va_arg (list, char *);
1180: u = t;
1181: while (s) {
1182: len = strlen (s);
1183: strcpy (u, s);
1184: u += len;
1185: s = va_arg (list, char *);
1186: }
1187: va_end (list);
1188:
1189: len = token_print_indent (file, col, indent,
1190: prefix, suffix, t);
1191: dfree (t, MDL);
1192: return col;
1193: }
1194:
1195: int token_indent_data_string (FILE *file, int col, int indent,
1196: const char *prefix, const char *suffix,
1197: struct data_string *data)
1198: {
1199: int i;
1200: char *buf;
1201: char obuf [3];
1202:
1203: /* See if this is just ASCII. */
1204: for (i = 0; i < data -> len; i++)
1205: if (!isascii (data -> data [i]) ||
1206: !isprint (data -> data [i]))
1207: break;
1208:
1209: /* If we have a purely ASCII string, output it as text. */
1210: if (i == data -> len) {
1211: buf = dmalloc (data -> len + 3, MDL);
1212: if (buf) {
1213: buf [0] = '"';
1214: memcpy (buf + 1, data -> data, data -> len);
1215: buf [data -> len + 1] = '"';
1216: buf [data -> len + 2] = 0;
1217: i = token_print_indent (file, col, indent,
1218: prefix, suffix, buf);
1219: dfree (buf, MDL);
1220: return i;
1221: }
1222: }
1223:
1224: for (i = 0; i < data -> len; i++) {
1225: sprintf (obuf, "%2.2x", data -> data [i]);
1226: col = token_print_indent (file, col, indent,
1227: i == 0 ? prefix : "",
1228: (i + 1 == data -> len
1229: ? suffix
1230: : ""), obuf);
1231: if (i + 1 != data -> len)
1232: col = token_print_indent (file, col, indent,
1233: prefix, suffix, ":");
1234: }
1235: return col;
1236: }
1237:
1238: int token_print_indent (FILE *file, int col, int indent,
1239: const char *prefix,
1240: const char *suffix, const char *buf)
1241: {
1242: int len = strlen (buf) + strlen (prefix);
1243: if (col + len > 79) {
1244: if (indent + len < 79) {
1245: indent_spaces (file, indent);
1246: col = indent;
1247: } else {
1248: indent_spaces (file, col);
1249: col = len > 79 ? 0 : 79 - len - 1;
1250: }
1251: } else if (prefix && *prefix) {
1252: fputs (prefix, file);
1253: col += strlen (prefix);
1254: }
1255: fputs (buf, file);
1256: col += len;
1257: if (suffix && *suffix) {
1258: if (col + strlen (suffix) > 79) {
1259: indent_spaces (file, indent);
1260: col = indent;
1261: } else {
1262: fputs (suffix, file);
1263: col += strlen (suffix);
1264: }
1265: }
1266: return col;
1267: }
1268:
1269: void indent_spaces (FILE *file, int indent)
1270: {
1271: int i;
1272: fputc ('\n', file);
1273: for (i = 0; i < indent; i++)
1274: fputc (' ', file);
1275: }
1276:
1277: #if defined (NSUPDATE)
1278: void print_dns_status (int status, ns_updque *uq)
1279: {
1280: char obuf [1024];
1281: char *s = &obuf [0], *end = &obuf [1022];
1282: ns_updrec *u;
1283: int position;
1284: int ttlp;
1285: const char *predicate = "if", *en, *op;
1286: int errorp;
1287:
1288: for (u = ISC_LIST_HEAD (*uq); u; u = ISC_LIST_NEXT (u, r_link)) {
1289: ttlp = 0;
1290:
1291: switch (u -> r_opcode)
1292: {
1293: case NXRRSET:
1294: op = "rrset doesn't exist";
1295: position = 1;
1296: break;
1297: case YXRRSET:
1298: op = "rrset exists";
1299: position = 1;
1300: break;
1301: case NXDOMAIN:
1302: op = "domain doesn't exist";
1303: position = 1;
1304: break;
1305: case YXDOMAIN:
1306: op = "domain exists";
1307: position = 1;
1308: break;
1309: case ADD:
1310: op = "add";
1311: position = 0;
1312: ttlp = 1;
1313: break;
1314: case DELETE:
1315: op = "delete";
1316: position = 0;
1317: break;
1318: default:
1319: op = "unknown";
1320: position = 0;
1321: break;
1322: }
1323: if (!position) {
1324: if (s != &obuf [0] && s + 1 < end)
1325: *s++ = ' ';
1326: if (s + strlen (op) < end) {
1327: strcpy (s, op);
1328: s += strlen (s);
1329: }
1330: } else {
1331: if (s != &obuf [0] && s + 1 < end)
1332: *s++ = ' ';
1333: if (s + strlen (predicate) < end) {
1334: strcpy (s, predicate);
1335: s += strlen (s);
1336: }
1337: predicate = "and";
1338: }
1339: if (u -> r_dname) {
1340: if (s + 1 < end)
1341: *s++ = ' ';
1342: if (s + strlen (u -> r_dname) < end) {
1343: strcpy (s, u -> r_dname);
1344: s += strlen (s);
1345: }
1346: }
1347: if (ttlp) {
1348: if (s + 1 < end)
1349: *s++ = ' ';
1350: /* 27 is as big as a ttl can get. */
1351: if (s + 27 < end) {
1352: sprintf (s, "%lu",
1353: (unsigned long)(u -> r_ttl));
1354: s += strlen (s);
1355: }
1356: }
1357: switch (u -> r_class) {
1358: case C_IN:
1359: en = "IN";
1360: break;
1361: case C_CHAOS:
1362: en = "CHAOS";
1363: break;
1364: case C_HS:
1365: en = "HS";
1366: break;
1367: default:
1368: en = "UNKNOWN";
1369: break;
1370: }
1371: if (s + strlen (en) < end) {
1372: if (s + 1 < end)
1373: *s++ = ' ';
1374: strcpy (s, en);
1375: s += strlen (en);
1376: }
1377: switch (u -> r_type) {
1378: case T_A:
1379: en = "A";
1380: break;
1381: case T_AAAA:
1382: en = "AAAA";
1383: break;
1384: case T_PTR:
1385: en = "PTR";
1386: break;
1387: case T_MX:
1388: en = "MX";
1389: break;
1390: case T_TXT:
1391: en = "TXT";
1392: break;
1393: case T_KEY:
1394: en = "KEY";
1395: break;
1396: case T_CNAME:
1397: en = "CNAME";
1398: break;
1399: default:
1400: en = "UNKNOWN";
1401: break;
1402: }
1403: if (s + strlen (en) < end) {
1404: if (s + 1 < end)
1405: *s++ = ' ';
1406: strcpy (s, en);
1407: s += strlen (en);
1408: }
1409: if (u -> r_data) {
1410: if (s + 1 < end)
1411: *s++ = ' ';
1412: if (u -> r_type == T_TXT) {
1413: if (s + 1 < end)
1414: *s++ = '"';
1415: }
1416: if(u->r_type == T_KEY) {
1417: strcat(s, "<keydata>");
1418: s+=strlen("<keydata>");
1419: }
1420: else {
1421: if (s + u -> r_size < end) {
1422: memcpy (s, u -> r_data, u -> r_size);
1423: s += u -> r_size;
1424: if (u -> r_type == T_TXT) {
1425: if (s + 1 < end)
1426: *s++ = '"';
1427: }
1428: }
1429: }
1430: }
1431: if (position) {
1432: if (s + 1 < end)
1433: *s++ = ' ';
1434: if (s + strlen (op) < end) {
1435: strcpy (s, op);
1436: s += strlen (s);
1437: }
1438: }
1439: if (u == ISC_LIST_TAIL (*uq))
1440: break;
1441: }
1442: if (s == &obuf [0]) {
1443: strcpy (s, "empty update");
1444: s += strlen (s);
1445: }
1446: if (status == NOERROR)
1447: errorp = 0;
1448: else
1449: errorp = 1;
1450: en = isc_result_totext (status);
1451: #if 0
1452: switch (status) {
1453: case -1:
1454: en = "resolver failed";
1455: break;
1456:
1457: case FORMERR:
1458: en = "format error";
1459: break;
1460:
1461: case NOERROR:
1462: en = "succeeded";
1463: errorp = 0;
1464: break;
1465:
1466: case NOTAUTH:
1467: en = "not authorized";
1468: break;
1469:
1470: case NOTIMP:
1471: en = "not implemented";
1472: break;
1473:
1474: case NOTZONE:
1475: en = "not a single valid zone";
1476: break;
1477:
1478: case NXDOMAIN:
1479: en = "no such domain";
1480: break;
1481:
1482: case NXRRSET:
1483: en = "no such record";
1484: break;
1485:
1486: case REFUSED:
1487: en = "refused";
1488: break;
1489:
1490: case SERVFAIL:
1491: en = "server failed";
1492: break;
1493:
1494: case YXDOMAIN:
1495: en = "domain exists";
1496: break;
1497:
1498: case YXRRSET:
1499: en = "record exists";
1500: break;
1501:
1502: default:
1503: en = "unknown error";
1504: break;
1505: }
1506: #endif
1507:
1508: if (s + 2 < end) {
1509: *s++ = ':';
1510: *s++ = ' ';
1511: }
1512: if (s + strlen (en) < end) {
1513: strcpy (s, en);
1514: s += strlen (en);
1515: }
1516: if (s + 1 < end)
1517: *s++ = '.';
1518: *s++ = 0;
1519: if (errorp)
1520: log_error ("%s", obuf);
1521: else
1522: log_info ("%s", obuf);
1523: }
1524: #endif /* NSUPDATE */
1525:
1526: /* Format the given time as "A; # B", where A is the format
1527: * used by the parser, and B is the local time, for humans.
1528: */
1529: const char *
1530: print_time(TIME t)
1531: {
1532: static char buf[sizeof("epoch 9223372036854775807; "
1533: "# Wed Jun 30 21:49:08 2147483647")];
1534: static char buf1[sizeof("# Wed Jun 30 21:49:08 2147483647")];
1535: time_t since_epoch;
1536: /* The string: "6 2147483647/12/31 23:59:60;"
1537: * is smaller than the other, used to declare the buffer size, so
1538: * we can use one buffer for both.
1539: */
1540:
1541: if (t == MAX_TIME)
1542: return "never;";
1543:
1544: if (t < 0)
1545: return NULL;
1546:
1547: /* For those lucky enough to have a 128-bit time_t, ensure that
1548: * whatever (corrupt) value we're given doesn't exceed the static
1549: * buffer.
1550: */
1551: #if (MAX_TIME > 0x7fffffffffffffff)
1552: if (t > 0x7fffffffffffffff)
1553: return NULL;
1554: #endif
1555:
1556: if (db_time_format == LOCAL_TIME_FORMAT) {
1557: since_epoch = mktime(localtime(&t));
1558: if ((strftime(buf1, sizeof(buf1),
1559: "# %a %b %d %H:%M:%S %Y",
1560: localtime(&t)) == 0) ||
1561: (snprintf(buf, sizeof(buf), "epoch %lu; %s",
1562: (unsigned long)since_epoch, buf1) >= sizeof(buf)))
1563: return NULL;
1564:
1565: } else {
1566: /* No bounds check for the year is necessary - in this case,
1567: * strftime() will run out of space and assert an error.
1568: */
1569: if (strftime(buf, sizeof(buf), "%w %Y/%m/%d %H:%M:%S;",
1570: gmtime(&t)) == 0)
1571: return NULL;
1572: }
1573:
1574: return buf;
1575: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to print.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / common