![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mrtrace.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 / omapip|
Return to mrtrace.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / omapip |
1.1 misho 1: /* mrtrace.c
2:
3: Subroutines that support minires tracing... */
4:
5: /*
6: * Copyright (c) 2004,2007,2009 by Internet Systems Consortium, Inc. ("ISC")
7: * Copyright (c) 2001-2003 by Internet Software Consortium
8: *
9: * Permission to use, copy, modify, and distribute this software for any
10: * purpose with or without fee is hereby granted, provided that the above
11: * copyright notice and this permission notice appear in all copies.
12: *
13: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
14: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
16: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
19: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20: *
21: * Internet Systems Consortium, Inc.
22: * 950 Charter Street
23: * Redwood City, CA 94063
24: * <info@isc.org>
25: * https://www.isc.org/
26: *
27: * This software has been written for Internet Systems Consortium
28: * by Ted Lemon, as part of a project for Nominum, Inc. To learn more
29: * about Internet Systems Consortium, see https://www.isc.org/. To
30: * learn more about Nominum, Inc., see ``http://www.nominum.com''.
31: */
32:
33: #include "dhcpd.h"
34: #include <omapip/omapip_p.h>
35:
36: #include "minires/minires.h"
37: #include "arpa/nameser.h"
38:
39: #include <errno.h>
40:
41: #if defined(TRACING)
42: static void trace_mr_output_input (trace_type_t *, unsigned, char *);
43: static void trace_mr_output_stop (trace_type_t *);
44: static void trace_mr_input_input (trace_type_t *, unsigned, char *);
45: static void trace_mr_input_stop (trace_type_t *);
46: static void trace_mr_statp_input (trace_type_t *, unsigned, char *);
47: static void trace_mr_statp_stop (trace_type_t *);
48: static void trace_mr_randomid_input (trace_type_t *, unsigned, char *);
49: static void trace_mr_randomid_stop (trace_type_t *);
50: #endif /* TRACING */
51: trace_type_t *trace_mr_output;
52: trace_type_t *trace_mr_input;
53: trace_type_t *trace_mr_statp;
54: trace_type_t *trace_mr_randomid;
55: ssize_t trace_mr_send (int, void *, size_t, int);
56: ssize_t trace_mr_read_playback (struct sockaddr_in *, void *, size_t);
57: void trace_mr_read_record (struct sockaddr_in *, void *, ssize_t);
58: ssize_t trace_mr_recvfrom (int s, void *, size_t, int,
59: struct sockaddr *, SOCKLEN_T *);
60: ssize_t trace_mr_read (int, void *, size_t);
61: int trace_mr_connect (int s, struct sockaddr *, SOCKLEN_T);
62: int trace_mr_socket (int, int, int);
63: int trace_mr_bind (int, struct sockaddr *, SOCKLEN_T);
64: int trace_mr_close (int);
65: time_t trace_mr_time (time_t *);
66: int trace_mr_select (int, fd_set *, fd_set *, fd_set *, struct timeval *);
67: unsigned int trace_mr_res_randomid (unsigned int);
68:
69: #if defined (TRACING)
70: void trace_mr_init ()
71: {
72: trace_mr_output = trace_type_register ("mr-output", (void *)0,
73: trace_mr_output_input,
74: trace_mr_output_stop, MDL);
75: trace_mr_input = trace_type_register ("mr-input", (void *)0,
76: trace_mr_input_input,
77: trace_mr_input_stop, MDL);
78: trace_mr_statp = trace_type_register ("mr-statp", (void *)0,
79: trace_mr_statp_input,
80: trace_mr_statp_stop, MDL);
81: trace_mr_randomid = trace_type_register ("mr-randomid", (void *)0,
82: trace_mr_randomid_input,
83: trace_mr_randomid_stop, MDL);
84: }
85:
86: void trace_mr_statp_setup (res_state statp)
87: {
88: unsigned buflen = 0;
89: char *buf = (char *)0;
90: isc_result_t status;
91: int i;
92:
93: if (trace_playback ()) {
94: int nscount;
95: status = trace_get_packet (&trace_mr_statp, &buflen, &buf);
96: if (status != ISC_R_SUCCESS) {
97: log_error ("trace_mr_statp: no statp packet found.");
98: return;
99: }
100: nscount = buflen / sizeof (struct in_addr);
101: if (nscount * (sizeof (struct in_addr)) != buflen ||
102: nscount < 1) {
103: log_error ("trace_mr_statp: bogus length: %d",
104: buflen);
105: return;
106: }
107: if (nscount > MAXNS)
108: nscount = MAXNS;
109: for (i = 0; i < nscount; i++) {
110: #if defined (HAVE_SA_LEN)
111: statp -> nsaddr_list [i].sin_len =
112: sizeof (struct sockaddr_in);
113: #endif
114: memset (&statp -> nsaddr_list [i].sin_zero, 0,
115: sizeof statp -> nsaddr_list [i].sin_zero);
116: statp -> nsaddr_list [i].sin_port = htons (53); /*XXX*/
117: statp -> nsaddr_list [i].sin_family = AF_INET;
118: memcpy (&statp -> nsaddr_list [i].sin_addr,
119: (buf + i * (sizeof (struct in_addr))),
120: sizeof (struct in_addr));
121: }
122: statp -> nscount = nscount;
123: dfree (buf, MDL);
124: buf = (char *)0;
125: }
126: if (trace_record ()) {
127: trace_iov_t *iov;
128: iov = dmalloc ((statp -> nscount *
129: sizeof (trace_iov_t)), MDL);
130: if (!iov) {
131: trace_stop ();
132: log_error ("No memory for statp iov.");
133: return;
134: }
135: for (i = 0; i < statp -> nscount; i++) {
136: iov [i].buf =
137: (char *)&statp -> nsaddr_list [i].sin_addr;
138: iov [i].len = sizeof (struct in_addr);
139: }
140: trace_write_packet_iov (trace_mr_statp, i, iov, MDL);
141: dfree (iov, MDL);
142: }
143: }
144: #endif
145:
146: ssize_t trace_mr_send (int fd, void *msg, size_t len, int flags)
147: {
148: ssize_t rv;
149: #if defined (TRACING)
150: isc_result_t status;
151: unsigned buflen = 0;
152: char *inbuf = (char *)0;
153: u_int32_t result;
154: u_int32_t sflags;
155:
156: if (trace_playback()) {
157: status = trace_get_packet (&trace_mr_output, &buflen, &inbuf);
158: if (status != ISC_R_SUCCESS) {
159: log_error ("trace_mr_recvfrom: no input found.");
160: errno = ECONNREFUSED;
161: return -1;
162: }
163: if (buflen < sizeof result) {
164: log_error ("trace_mr_recvfrom: data too short.");
165: errno = ECONNREFUSED;
166: dfree (inbuf, MDL);
167: return -1;
168: }
169: memcpy (&result, inbuf, sizeof result);
170: rv = ntohl (result);
171: dfree (inbuf, MDL);
172: } else
173: #endif
174: rv = send (fd, msg, len, flags);
175: #if defined (TRACING)
176: if (trace_record ()) {
177: trace_iov_t iov [3];
178: result = htonl (rv);
179: sflags = htonl (flags);
180: iov [0].len = sizeof result;
181: iov [0].buf = (char *)&result;
182: iov [1].len = sizeof sflags;
183: iov [1].buf = (char *)&flags;
184: iov [2].len = len;
185: iov [2].buf = msg;
186: trace_write_packet_iov (trace_mr_output, 3, iov, MDL);
187: }
188: #endif
189: return rv;
190: }
191:
192: #if defined (TRACING)
193: ssize_t trace_mr_read_playback (struct sockaddr_in *from,
194: void *buf, size_t nbytes)
195: {
196: isc_result_t status;
197: unsigned buflen = 0, left;
198: char *inbuf = (char *)0;
199: char *bufp;
200: u_int32_t result;
201:
202: status = trace_get_packet (&trace_mr_input, &buflen, &inbuf);
203: if (status != ISC_R_SUCCESS) {
204: log_error ("trace_mr_recvfrom: no input found.");
205: errno = ECONNREFUSED;
206: return -1;
207: }
208: if (buflen < sizeof result) {
209: log_error ("trace_mr_recvfrom: data too short.");
210: errno = ECONNREFUSED;
211: dfree (inbuf, MDL);
212: return -1;
213: }
214: bufp = inbuf;
215: left = buflen;
216: memcpy (&result, bufp, sizeof result);
217: result = ntohl (result);
218: bufp += sizeof result;
219: left -= sizeof result;
220: if (result == 0) {
221: if (left < ((sizeof from -> sin_port) +
222: sizeof (from -> sin_addr))) {
223: log_error ("trace_mr_recvfrom: data too short.");
224: errno = ECONNREFUSED;
225: dfree (inbuf, MDL);
226: return -1;
227: }
228: if (from)
229: memcpy (&from -> sin_addr, bufp,
230: sizeof from -> sin_addr);
231: bufp += sizeof from -> sin_addr;
232: left -= sizeof from -> sin_addr;
233: if (from)
234: memcpy (&from -> sin_port, bufp,
235: sizeof from -> sin_port);
236: bufp += sizeof from -> sin_port;
237: left -= sizeof from -> sin_port;
238: if (from) {
239: from -> sin_family = AF_INET;
240: #if defined(HAVE_SA_LEN)
241: from -> sin_len = sizeof (struct sockaddr_in);
242: #endif
243: memset (from -> sin_zero, 0, sizeof from -> sin_zero);
244: }
245: if (left > nbytes) {
246: log_error ("trace_mr_recvfrom: too much%s",
247: " data.");
248: errno = ECONNREFUSED;
249: dfree (inbuf, MDL);
250: return -1;
251: }
252: memcpy (buf, bufp, left);
253: dfree (inbuf, MDL);
254: return left;
255: }
256: errno = ECONNREFUSED;
257: return -1;
258: }
259:
260: void trace_mr_read_record (struct sockaddr_in *from, void *buf, ssize_t rv)
261: {
262: trace_iov_t iov [4];
263: u_int32_t result;
264: int iolen = 0;
265: static char zero [4] = { 0, 0, 0, 0 };
266:
267: if (rv < 0)
268: result = htonl (errno); /* XXX */
269: else
270: result = 0;
271: iov [iolen].buf = (char *)&result;
272: iov [iolen++].len = sizeof result;
273: if (rv > 0) {
274: if (from) {
275: iov [iolen].buf = (char *)&from -> sin_addr;
276: iov [iolen++].len = sizeof from -> sin_addr;
277: iov [iolen].buf = (char *)&from -> sin_port;
278: iov [iolen++].len = sizeof from -> sin_port;
279: } else {
280: iov [iolen].buf = zero;
281: iov [iolen++].len = sizeof from -> sin_addr;
282: iov [iolen].buf = zero;
283: iov [iolen++].len = sizeof from -> sin_port;
284: }
285:
286: iov [iolen].buf = buf;
287: iov [iolen++].len = rv;
288: }
289: trace_write_packet_iov (trace_mr_input, iolen, iov, MDL);
290: }
291: #endif
292:
293: ssize_t trace_mr_recvfrom (int s, void *buf, size_t len, int flags,
294: struct sockaddr *from, SOCKLEN_T *fromlen)
295: {
296: ssize_t rv;
297:
298: #if defined (TRACING)
299: if (trace_playback ())
300: rv = trace_mr_read_playback ((struct sockaddr_in *)from,
301: buf, len);
302: else
303: #endif
304: rv = recvfrom (s, buf, len, flags, from, fromlen);
305: #if defined (TRACING)
306: if (trace_record ()) {
307: trace_mr_read_record ((struct sockaddr_in *)from, buf, rv);
308: }
309: #endif
310: return rv;
311: }
312:
313: ssize_t trace_mr_read (int d, void *buf, size_t nbytes)
314: {
315: ssize_t rv;
316:
317: #if defined (TRACING)
318: if (trace_playback ())
319: rv = trace_mr_read_playback ((struct sockaddr_in *)0,
320: buf, nbytes);
321: else
322: #endif
323: rv = read (d, buf, nbytes);
324: #if defined (TRACING)
325: if (trace_record ()) {
326: trace_mr_read_record ((struct sockaddr_in *)0, buf, rv);
327: }
328: #endif
329: return rv;
330: }
331:
332: int trace_mr_connect (int s, struct sockaddr *name, SOCKLEN_T namelen)
333: {
334: #if defined (TRACING)
335: if (!trace_playback ())
336: #endif
337: return connect (s, name, namelen);
338: #if defined (TRACING)
339: return 0;
340: #endif
341: }
342:
343: int trace_mr_socket (int domain, int type, int protocol)
344: {
345: #if defined (TRACING)
346: if (!trace_playback ())
347: #endif
348: return socket (domain, type, protocol);
349: #if defined (TRACING)
350: return 100;
351: #endif
352: }
353:
354: int trace_mr_bind (int s, struct sockaddr *name, SOCKLEN_T namelen)
355: {
356: #if defined (TRACING)
357: if (!trace_playback ())
358: #endif
359: return bind (s, name, namelen);
360: #if defined (TRACING)
361: return 0;
362: #endif
363: }
364:
365: int trace_mr_close (int s)
366: {
367: #if defined (TRACING)
368: if (!trace_playback ())
369: #endif
370: return close (s);
371: #if defined (TRACING)
372: return 0;
373: #endif
374: }
375:
376: time_t trace_mr_time (time_t *tp)
377: {
378: #if defined (TRACING)
379: if (trace_playback ()) {
380: if (tp)
381: *tp = cur_time;
382: return cur_time;
383: }
384: #endif
385: return time (tp);
386: }
387:
388: int trace_mr_select (int s, fd_set *r, fd_set *w, fd_set *x, struct timeval *t)
389: {
390: #if defined (TRACING)
391: trace_type_t *ttp = (trace_type_t *)0;
392:
393: if (trace_playback ()) {
394: time_t nct = trace_snoop_time (&ttp);
395: time_t secr = t -> tv_sec;
396: t -> tv_sec = nct - cur_time;
397: if (t -> tv_sec > secr)
398: return 0;
399: if (ttp == trace_mr_input)
400: return 1;
401: return 0;
402: }
403: #endif
404: return select (s, r, w, x, t);
405: }
406:
407: unsigned int trace_mr_res_randomid (unsigned int oldid)
408: {
409: int rid = oldid;
410: #if defined (TRACING)
411: u_int32_t id;
412: unsigned buflen = 0;
413: char *buf = (char *)0;
414: isc_result_t status;
415:
416: if (trace_playback ()) {
417: status = trace_get_packet (&trace_mr_randomid, &buflen, &buf);
418: if (status != ISC_R_SUCCESS) {
419: log_error ("trace_mr_statp: no statp packet found.");
420: return oldid;
421: }
422: if (buflen != sizeof id) {
423: log_error ("trace_mr_randomid: bogus length: %d",
424: buflen);
425: return oldid;
426: }
427: memcpy (&id, buf, sizeof id);
428: dfree (buf, MDL);
429: buf = (char *)0;
430: rid = ntohl (id);
431: }
432: if (trace_record ()) {
433: id = htonl (rid);
434: trace_write_packet (trace_mr_randomid,
435: sizeof id, (char *)&id, MDL);
436: }
437: #endif
438: return rid;
439: }
440:
441: #if defined (TRACING)
442: static void trace_mr_output_input (trace_type_t *ttype,
443: unsigned length, char *buf)
444: {
445: }
446:
447: static void trace_mr_output_stop (trace_type_t *ttype)
448: {
449: }
450:
451: static void trace_mr_input_input (trace_type_t *ttype,
452: unsigned length, char *buf)
453: {
454: log_error ("unaccounted-for minires input.");
455: }
456:
457: static void trace_mr_input_stop (trace_type_t *ttype)
458: {
459: }
460:
461: static void trace_mr_statp_input (trace_type_t *ttype,
462: unsigned length, char *buf)
463: {
464: log_error ("unaccounted-for minires statp input.");
465: }
466:
467: static void trace_mr_statp_stop (trace_type_t *ttype)
468: {
469: }
470:
471: static void trace_mr_randomid_input (trace_type_t *ttype,
472: unsigned length, char *buf)
473: {
474: log_error ("unaccounted-for minires randomid input.");
475: }
476:
477: static void trace_mr_randomid_stop (trace_type_t *ttype)
478: {
479: }
480: #endif