1: /* trace.c
2:
3: Subroutines that support dhcp 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:
35: #if defined (TRACING)
36: void trace_interface_register (trace_type_t *ttype, struct interface_info *ip)
37: {
38: trace_interface_packet_t tipkt;
39:
40: if (trace_record ()) {
41: memset (&tipkt, 0, sizeof tipkt);
42: memcpy (&tipkt.hw_address,
43: &ip -> hw_address, sizeof ip -> hw_address);
44: if (ip->address_count)
45: memcpy(&tipkt.primary_address,
46: ip->addresses, sizeof(*ip->addresses));
47: memcpy (tipkt.name, ip -> name, sizeof ip -> name);
48: tipkt.index = htonl (ip -> index);
49:
50: trace_write_packet (ttype, sizeof tipkt, (char *)&tipkt, MDL);
51: }
52: }
53:
54: void trace_interface_input (trace_type_t *ttype, unsigned len, char *buf)
55: {
56: trace_interface_packet_t *tipkt;
57: struct interface_info *ip;
58: struct sockaddr_in *sin;
59: struct iaddr addr;
60: isc_result_t status;
61:
62: if (len != sizeof *tipkt) {
63: log_error ("trace interface packet size mismatch: %ld != %d",
64: (long)(sizeof *tipkt), len);
65: return;
66: }
67: tipkt = (trace_interface_packet_t *)buf;
68:
69: ip = (struct interface_info *)0;
70: status = interface_allocate (&ip, MDL);
71: if (status != ISC_R_SUCCESS) {
72: foo:
73: log_error ("trace_interface_input: %s.",
74: isc_result_totext (status));
75: return;
76: }
77: ip -> ifp = dmalloc (sizeof *(ip -> ifp), MDL);
78: if (!ip -> ifp) {
79: interface_dereference (&ip, MDL);
80: status = ISC_R_NOMEMORY;
81: goto foo;
82: }
83:
84: memcpy (&ip -> hw_address, &tipkt -> hw_address,
85: sizeof ip -> hw_address);
86: /* XXX: Without the full addresses state it's not quite a full
87: * trace.
88: */
89: ip->address_count = ip->address_max = 1;
90: ip->addresses = dmalloc(sizeof(*ip->addresses), MDL);
91: memcpy(ip->addresses, &tipkt->primary_address, sizeof(*ip->addresses));
92: memcpy (ip -> name, tipkt -> name, sizeof ip -> name);
93: ip -> index = ntohl (tipkt -> index);
94:
95: interface_snorf (ip, 0);
96: if (dhcp_interface_discovery_hook)
97: (*dhcp_interface_discovery_hook) (ip);
98:
99: /* Fake up an ifp. */
100: memcpy (ip -> ifp -> ifr_name, ip -> name, sizeof ip -> name);
101: #ifdef HAVE_SA_LEN
102: ip -> ifp -> ifr_addr.sa_len = sizeof (struct sockaddr_in);
103: #endif
104: sin = (struct sockaddr_in *)&ip -> ifp -> ifr_addr;
105: sin->sin_addr = ip->addresses[0];
106:
107: addr.len = 4;
108: memcpy (addr.iabuf, &sin -> sin_addr.s_addr, addr.len);
109: if (dhcp_interface_setup_hook)
110: (*dhcp_interface_setup_hook) (ip, &addr);
111: interface_stash (ip);
112:
113: if (!quiet_interface_discovery) {
114: log_info ("Listening on Trace/%s/%s%s%s",
115: ip -> name,
116: print_hw_addr (ip -> hw_address.hbuf [0],
117: ip -> hw_address.hlen - 1,
118: &ip -> hw_address.hbuf [1]),
119: (ip -> shared_network ? "/" : ""),
120: (ip -> shared_network ?
121: ip -> shared_network -> name : ""));
122: if (strcmp (ip -> name, "fallback")) {
123: log_info ("Sending on Trace/%s/%s%s%s",
124: ip -> name,
125: print_hw_addr (ip -> hw_address.hbuf [0],
126: ip -> hw_address.hlen - 1,
127: &ip -> hw_address.hbuf [1]),
128: (ip -> shared_network ? "/" : ""),
129: (ip -> shared_network ?
130: ip -> shared_network -> name : ""));
131: }
132: }
133: interface_dereference (&ip, MDL);
134: }
135:
136: void trace_interface_stop (trace_type_t *ttype) {
137: /* XXX */
138: }
139:
140: void trace_inpacket_stash (struct interface_info *interface,
141: struct dhcp_packet *packet,
142: unsigned len,
143: unsigned int from_port,
144: struct iaddr from,
145: struct hardware *hfrom)
146: {
147: trace_inpacket_t tip;
148: trace_iov_t iov [2];
149:
150: if (!trace_record ())
151: return;
152: tip.from_port = from_port;
153: tip.from = from;
154: tip.from.len = htonl (tip.from.len);
155: if (hfrom) {
156: tip.hfrom = *hfrom;
157: tip.havehfrom = 1;
158: } else {
159: memset (&tip.hfrom, 0, sizeof tip.hfrom);
160: tip.havehfrom = 0;
161: }
162: tip.index = htonl (interface -> index);
163:
164: iov [0].buf = (char *)&tip;
165: iov [0].len = sizeof tip;
166: iov [1].buf = (char *)packet;
167: iov [1].len = len;
168: trace_write_packet_iov (inpacket_trace, 2, iov, MDL);
169: }
170:
171: void trace_inpacket_input (trace_type_t *ttype, unsigned len, char *buf)
172: {
173: trace_inpacket_t *tip;
174: int index;
175:
176: if (len < sizeof *tip) {
177: log_error ("trace_input_packet: too short - %d", len);
178: return;
179: }
180: tip = (trace_inpacket_t *)buf;
181: index = ntohl (tip -> index);
182: tip -> from.len = ntohl (tip -> from.len);
183:
184: if (index > interface_count ||
185: index < 0 ||
186: !interface_vector [index]) {
187: log_error ("trace_input_packet: unknown interface index %d",
188: index);
189: return;
190: }
191:
192: if (!bootp_packet_handler) {
193: log_error ("trace_input_packet: no bootp packet handler.");
194: return;
195: }
196:
197: (*bootp_packet_handler) (interface_vector [index],
198: (struct dhcp_packet *)(tip + 1),
199: len - sizeof *tip,
200: tip -> from_port,
201: tip -> from,
202: (tip -> havehfrom ?
203: &tip -> hfrom
204: : (struct hardware *)0));
205: }
206:
207: void trace_inpacket_stop (trace_type_t *ttype) { }
208:
209: ssize_t trace_packet_send (struct interface_info *interface,
210: struct packet *packet,
211: struct dhcp_packet *raw,
212: size_t len,
213: struct in_addr from,
214: struct sockaddr_in *to,
215: struct hardware *hto)
216: {
217: trace_outpacket_t tip;
218: trace_iov_t iov [2];
219:
220: if (trace_record ()) {
221: if (hto) {
222: tip.hto = *hto;
223: tip.havehto = 1;
224: } else {
225: memset (&tip.hto, 0, sizeof tip.hto);
226: tip.havehto = 0;
227: }
228: tip.from.len = 4;
229: memcpy (tip.from.iabuf, &from, 4);
230: tip.to.len = 4;
231: memcpy (tip.to.iabuf, &to -> sin_addr, 4);
232: tip.to_port = to -> sin_port;
233: tip.index = htonl (interface -> index);
234:
235: iov [0].buf = (char *)&tip;
236: iov [0].len = sizeof tip;
237: iov [1].buf = (char *)raw;
238: iov [1].len = len;
239: trace_write_packet_iov (outpacket_trace, 2, iov, MDL);
240: }
241: if (!trace_playback ()) {
242: return send_packet (interface, packet, raw, len,
243: from, to, hto);
244: }
245: return len;
246: }
247:
248: void trace_outpacket_input (trace_type_t *ttype, unsigned len, char *buf)
249: {
250: trace_outpacket_t *tip;
251: int index;
252:
253: if (len < sizeof *tip) {
254: log_error ("trace_input_packet: too short - %d", len);
255: return;
256: }
257: tip = (trace_outpacket_t *)buf;
258: index = ntohl (tip -> index);
259:
260: if (index > interface_count ||
261: index < 0 ||
262: !interface_vector [index]) {
263: log_error ("trace_input_packet: unknown interface index %d",
264: index);
265: return;
266: }
267:
268: /* XXX would be nice to somehow take notice of these. */
269: }
270:
271: void trace_outpacket_stop (trace_type_t *ttype) { }
272:
273: void trace_seed_stash (trace_type_t *ttype, unsigned seed)
274: {
275: u_int32_t outseed;
276: if (!trace_record ())
277: return;
278: outseed = htonl (seed);
279: trace_write_packet (ttype, sizeof outseed, (char *)&outseed, MDL);
280: return;
281: }
282:
283: void trace_seed_input (trace_type_t *ttype, unsigned length, char *buf)
284: {
285: u_int32_t *seed;
286:
287: if (length != sizeof seed) {
288: log_error ("trace_seed_input: wrong size (%d)", length);
289: }
290: seed = (u_int32_t *)buf;
291: srandom (ntohl (*seed));
292: }
293:
294: void trace_seed_stop (trace_type_t *ttype) { }
295: #endif /* TRACING */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ctrace.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