1 /* $NetBSD: ctrace.c,v 1.3 2022/04/03 01:10:58 christos Exp $ */ 2 3 /* trace.c 4 5 Subroutines that support dhcp tracing... */ 6 7 /* 8 * Copyright (C) 2004-2022 Internet Systems Consortium, Inc. ("ISC") 9 * Copyright (c) 2001-2003 by Internet Software Consortium 10 * 11 * This Source Code Form is subject to the terms of the Mozilla Public 12 * License, v. 2.0. If a copy of the MPL was not distributed with this 13 * file, You can obtain one at http://mozilla.org/MPL/2.0/. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES 16 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 17 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR 18 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 19 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 20 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 21 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 22 * 23 * Internet Systems Consortium, Inc. 24 * PO Box 360 25 * Newmarket, NH 03857 USA 26 * <info (at) isc.org> 27 * https://www.isc.org/ 28 * 29 */ 30 31 #include <sys/cdefs.h> 32 __RCSID("$NetBSD: ctrace.c,v 1.3 2022/04/03 01:10:58 christos Exp $"); 33 34 #include "dhcpd.h" 35 36 #if defined (TRACING) 37 void trace_interface_register (trace_type_t *ttype, struct interface_info *ip) 38 { 39 trace_interface_packet_t tipkt; 40 41 if (trace_record ()) { 42 memset (&tipkt, 0, sizeof tipkt); 43 memcpy (&tipkt.hw_address, 44 &ip -> hw_address, sizeof ip -> hw_address); 45 if (ip->address_count) 46 memcpy(&tipkt.primary_address, 47 ip->addresses, sizeof(*ip->addresses)); 48 memcpy (tipkt.name, ip -> name, sizeof ip -> name); 49 tipkt.index = htonl (ip -> index); 50 51 trace_write_packet (ttype, sizeof tipkt, (char *)&tipkt, MDL); 52 } 53 } 54 55 void trace_interface_input (trace_type_t *ttype, unsigned len, char *buf) 56 { 57 trace_interface_packet_t *tipkt; 58 struct interface_info *ip; 59 struct sockaddr_in *sin; 60 struct iaddr addr; 61 isc_result_t status; 62 63 if (len != sizeof *tipkt) { 64 log_error ("trace interface packet size mismatch: %ld != %d", 65 (long)(sizeof *tipkt), len); 66 return; 67 } 68 tipkt = (trace_interface_packet_t *)buf; 69 70 ip = (struct interface_info *)0; 71 status = interface_allocate (&ip, MDL); 72 if (status != ISC_R_SUCCESS) { 73 foo: 74 log_error ("trace_interface_input: %s.", 75 isc_result_totext (status)); 76 return; 77 } 78 ip -> ifp = dmalloc (sizeof *(ip -> ifp), MDL); 79 if (!ip -> ifp) { 80 interface_dereference (&ip, MDL); 81 status = ISC_R_NOMEMORY; 82 goto foo; 83 } 84 85 memcpy (&ip -> hw_address, &tipkt -> hw_address, 86 sizeof ip -> hw_address); 87 /* XXX: Without the full addresses state it's not quite a full 88 * trace. 89 */ 90 ip->address_count = ip->address_max = 1; 91 ip->addresses = dmalloc(sizeof(*ip->addresses), MDL); 92 if (!ip->addresses) { 93 dfree(ip->ifp, MDL); 94 ip->ifp = NULL; 95 interface_dereference (&ip, MDL); 96 status = ISC_R_NOMEMORY; 97 goto foo; 98 } 99 memcpy(ip->addresses, &tipkt->primary_address, sizeof(*ip->addresses)); 100 memcpy (ip -> name, tipkt -> name, sizeof ip -> name); 101 ip -> index = ntohl (tipkt -> index); 102 103 interface_snorf (ip, 0); 104 if (dhcp_interface_discovery_hook) 105 (*dhcp_interface_discovery_hook) (ip); 106 107 /* Fake up an ifp. */ 108 memcpy (ip -> ifp -> ifr_name, ip -> name, sizeof ip -> name); 109 #ifdef HAVE_SA_LEN 110 ip -> ifp -> ifr_addr.sa_len = sizeof (struct sockaddr_in); 111 #endif 112 sin = (struct sockaddr_in *)&ip -> ifp -> ifr_addr; 113 sin->sin_addr = ip->addresses[0]; 114 115 addr.len = 4; 116 memcpy (addr.iabuf, &sin -> sin_addr.s_addr, addr.len); 117 if (dhcp_interface_setup_hook) 118 (*dhcp_interface_setup_hook) (ip, &addr); 119 interface_stash (ip); 120 121 if (!quiet_interface_discovery) { 122 log_info ("Listening on Trace/%s/%s%s%s", 123 ip -> name, 124 print_hw_addr (ip -> hw_address.hbuf [0], 125 ip -> hw_address.hlen - 1, 126 &ip -> hw_address.hbuf [1]), 127 (ip -> shared_network ? "/" : ""), 128 (ip -> shared_network ? 129 ip -> shared_network -> name : "")); 130 if (strcmp (ip -> name, "fallback")) { 131 log_info ("Sending on Trace/%s/%s%s%s", 132 ip -> name, 133 print_hw_addr (ip -> hw_address.hbuf [0], 134 ip -> hw_address.hlen - 1, 135 &ip -> hw_address.hbuf [1]), 136 (ip -> shared_network ? "/" : ""), 137 (ip -> shared_network ? 138 ip -> shared_network -> name : "")); 139 } 140 } 141 interface_dereference (&ip, MDL); 142 } 143 144 void trace_interface_stop (trace_type_t *ttype) { 145 /* XXX */ 146 } 147 148 void trace_inpacket_stash (struct interface_info *interface, 149 struct dhcp_packet *packet, 150 unsigned len, 151 unsigned int from_port, 152 struct iaddr from, 153 struct hardware *hfrom) 154 { 155 trace_inpacket_t tip; 156 trace_iov_t iov [2]; 157 158 if (!trace_record ()) 159 return; 160 tip.from_port = from_port; 161 tip.from = from; 162 tip.from.len = htonl (tip.from.len); 163 if (hfrom) { 164 tip.hfrom = *hfrom; 165 tip.havehfrom = 1; 166 } else { 167 memset (&tip.hfrom, 0, sizeof tip.hfrom); 168 tip.havehfrom = 0; 169 } 170 tip.index = htonl (interface -> index); 171 172 iov [0].buf = (char *)&tip; 173 iov [0].len = sizeof tip; 174 iov [1].buf = (char *)packet; 175 iov [1].len = len; 176 trace_write_packet_iov (inpacket_trace, 2, iov, MDL); 177 } 178 179 void trace_inpacket_input (trace_type_t *ttype, unsigned len, char *buf) 180 { 181 trace_inpacket_t *tip; 182 int index; 183 184 if (len < sizeof *tip) { 185 log_error ("trace_input_packet: too short - %d", len); 186 return; 187 } 188 tip = (trace_inpacket_t *)buf; 189 index = ntohl (tip -> index); 190 tip -> from.len = ntohl (tip -> from.len); 191 192 if (index > interface_count || 193 index < 0 || 194 !interface_vector [index]) { 195 log_error ("trace_input_packet: unknown interface index %d", 196 index); 197 return; 198 } 199 200 if (!bootp_packet_handler) { 201 log_error ("trace_input_packet: no bootp packet handler."); 202 return; 203 } 204 205 (*bootp_packet_handler) (interface_vector [index], 206 (struct dhcp_packet *)(tip + 1), 207 len - sizeof *tip, 208 tip -> from_port, 209 tip -> from, 210 (tip -> havehfrom ? 211 &tip -> hfrom 212 : (struct hardware *)0)); 213 } 214 215 void trace_inpacket_stop (trace_type_t *ttype) { } 216 217 ssize_t trace_packet_send (struct interface_info *interface, 218 struct packet *packet, 219 struct dhcp_packet *raw, 220 size_t len, 221 struct in_addr from, 222 struct sockaddr_in *to, 223 struct hardware *hto) 224 { 225 trace_outpacket_t tip; 226 trace_iov_t iov [2]; 227 228 if (trace_record ()) { 229 if (hto) { 230 tip.hto = *hto; 231 tip.havehto = 1; 232 } else { 233 memset (&tip.hto, 0, sizeof tip.hto); 234 tip.havehto = 0; 235 } 236 tip.from.len = 4; 237 memcpy (tip.from.iabuf, &from, 4); 238 tip.to.len = 4; 239 memcpy (tip.to.iabuf, &to -> sin_addr, 4); 240 tip.to_port = to -> sin_port; 241 tip.index = htonl (interface -> index); 242 243 iov [0].buf = (char *)&tip; 244 iov [0].len = sizeof tip; 245 iov [1].buf = (char *)raw; 246 iov [1].len = len; 247 trace_write_packet_iov (outpacket_trace, 2, iov, MDL); 248 } 249 if (!trace_playback ()) { 250 return send_packet (interface, packet, raw, len, 251 from, to, hto); 252 } 253 return len; 254 } 255 256 void trace_outpacket_input (trace_type_t *ttype, unsigned len, char *buf) 257 { 258 trace_outpacket_t *tip; 259 int index; 260 261 if (len < sizeof *tip) { 262 log_error ("trace_input_packet: too short - %d", len); 263 return; 264 } 265 tip = (trace_outpacket_t *)buf; 266 index = ntohl (tip -> index); 267 268 if (index > interface_count || 269 index < 0 || 270 !interface_vector [index]) { 271 log_error ("trace_input_packet: unknown interface index %d", 272 index); 273 return; 274 } 275 276 /* XXX would be nice to somehow take notice of these. */ 277 } 278 279 void trace_outpacket_stop (trace_type_t *ttype) { } 280 281 void trace_seed_stash (trace_type_t *ttype, unsigned seed) 282 { 283 u_int32_t outseed; 284 if (!trace_record ()) 285 return; 286 outseed = htonl (seed); 287 trace_write_packet (ttype, sizeof outseed, (char *)&outseed, MDL); 288 return; 289 } 290 291 void trace_seed_input (trace_type_t *ttype, unsigned length, char *buf) 292 { 293 u_int32_t *seed; 294 295 if (length != sizeof seed) { 296 log_error ("trace_seed_input: wrong size (%d)", length); 297 } 298 seed = (u_int32_t *)buf; 299 srandom (ntohl (*seed)); 300 } 301 302 void trace_seed_stop (trace_type_t *ttype) { } 303 #endif /* TRACING */ 304
Indexes created Wed Jul 01 00:25:26 UTC 2026