NetBSD/dist/dhcp/common/ctrace.c

298 lines
8.2 KiB
C

/* trace.c
Subroutines that support dhcp tracing... */
/*
* Copyright (c) 2001-2002 Internet Software Consortium.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of The Internet Software Consortium nor the names
* of its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This software has been written for the Internet Software Consortium
* by Ted Lemon, as part of a project for Nominum, Inc. To learn more
* about the Internet Software Consortium, see http://www.isc.org/. To
* learn more about Nominum, Inc., see ``http://www.nominum.com''.
*/
#include "dhcpd.h"
#if defined (TRACING)
void trace_interface_register (trace_type_t *ttype, struct interface_info *ip)
{
trace_interface_packet_t tipkt;
if (trace_record ()) {
memset (&tipkt, 0, sizeof tipkt);
memcpy (&tipkt.hw_address,
&ip -> hw_address, sizeof ip -> hw_address);
memcpy (&tipkt.primary_address,
&ip -> primary_address, sizeof ip -> primary_address);
memcpy (tipkt.name, ip -> name, sizeof ip -> name);
tipkt.index = htonl (ip -> index);
trace_write_packet (ttype, sizeof tipkt, (char *)&tipkt, MDL);
}
}
void trace_interface_input (trace_type_t *ttype, unsigned len, char *buf)
{
trace_interface_packet_t *tipkt;
struct interface_info *ip;
struct sockaddr_in *sin;
struct iaddr addr;
isc_result_t status;
if (len != sizeof *tipkt) {
log_error ("trace interface packet size mismatch: %ld != %d",
(long)(sizeof *tipkt), len);
return;
}
tipkt = (trace_interface_packet_t *)buf;
ip = (struct interface_info *)0;
status = interface_allocate (&ip, MDL);
if (status != ISC_R_SUCCESS) {
foo:
log_error ("trace_interface_input: %s.",
isc_result_totext (status));
return;
}
ip -> ifp = dmalloc (sizeof *(ip -> ifp), MDL);
if (!ip -> ifp) {
interface_dereference (&ip, MDL);
status = ISC_R_NOMEMORY;
goto foo;
}
memcpy (&ip -> hw_address, &tipkt -> hw_address,
sizeof ip -> hw_address);
memcpy (&ip -> primary_address, &tipkt -> primary_address,
sizeof ip -> primary_address);
memcpy (ip -> name, tipkt -> name, sizeof ip -> name);
ip -> index = ntohl (tipkt -> index);
interface_snorf (ip, 0);
if (dhcp_interface_discovery_hook)
(*dhcp_interface_discovery_hook) (ip);
/* Fake up an ifp. */
memcpy (ip -> ifp -> ifr_name, ip -> name, sizeof ip -> name);
#ifdef HAVE_SA_LEN
ip -> ifp -> ifr_addr.sa_len = sizeof (struct sockaddr_in);
#endif
sin = (struct sockaddr_in *)&ip -> ifp -> ifr_addr;
sin -> sin_addr = ip -> primary_address;
addr.len = 4;
memcpy (addr.iabuf, &sin -> sin_addr.s_addr, addr.len);
if (dhcp_interface_setup_hook)
(*dhcp_interface_setup_hook) (ip, &addr);
interface_stash (ip);
if (!quiet_interface_discovery) {
log_info ("Listening on Trace/%s/%s%s%s",
ip -> name,
print_hw_addr (ip -> hw_address.hbuf [0],
ip -> hw_address.hlen - 1,
&ip -> hw_address.hbuf [1]),
(ip -> shared_network ? "/" : ""),
(ip -> shared_network ?
ip -> shared_network -> name : ""));
if (strcmp (ip -> name, "fallback")) {
log_info ("Sending on Trace/%s/%s%s%s",
ip -> name,
print_hw_addr (ip -> hw_address.hbuf [0],
ip -> hw_address.hlen - 1,
&ip -> hw_address.hbuf [1]),
(ip -> shared_network ? "/" : ""),
(ip -> shared_network ?
ip -> shared_network -> name : ""));
}
}
interface_dereference (&ip, MDL);
}
void trace_interface_stop (trace_type_t *ttype) {
/* XXX */
}
void trace_inpacket_stash (struct interface_info *interface,
struct dhcp_packet *packet,
unsigned len,
unsigned int from_port,
struct iaddr from,
struct hardware *hfrom)
{
trace_inpacket_t tip;
trace_iov_t iov [2];
if (!trace_record ())
return;
tip.from_port = from_port;
tip.from = from;
if (hfrom) {
tip.hfrom = *hfrom;
tip.havehfrom = 1;
} else {
memset (&tip.hfrom, 0, sizeof tip.hfrom);
tip.havehfrom = 0;
}
tip.index = htonl (interface -> index);
iov [0].buf = (char *)&tip;
iov [0].len = sizeof tip;
iov [1].buf = (char *)packet;
iov [1].len = len;
trace_write_packet_iov (inpacket_trace, 2, iov, MDL);
}
void trace_inpacket_input (trace_type_t *ttype, unsigned len, char *buf)
{
trace_inpacket_t *tip;
int index;
if (len < sizeof *tip) {
log_error ("trace_input_packet: too short - %d", len);
return;
}
tip = (trace_inpacket_t *)buf;
index = ntohl (tip -> index);
if (index > interface_count ||
index < 0 ||
!interface_vector [index]) {
log_error ("trace_input_packet: unknown interface index %d",
index);
return;
}
if (!bootp_packet_handler) {
log_error ("trace_input_packet: no bootp packet handler.");
return;
}
(*bootp_packet_handler) (interface_vector [index],
(struct dhcp_packet *)(tip + 1),
len - sizeof *tip,
tip -> from_port,
tip -> from,
(tip -> havehfrom ?
&tip -> hfrom
: (struct hardware *)0));
}
void trace_inpacket_stop (trace_type_t *ttype) { }
ssize_t trace_packet_send (struct interface_info *interface,
struct packet *packet,
struct dhcp_packet *raw,
size_t len,
struct in_addr from,
struct sockaddr_in *to,
struct hardware *hto)
{
trace_outpacket_t tip;
trace_iov_t iov [2];
if (trace_record ()) {
if (hto) {
tip.hto = *hto;
tip.havehto = 1;
} else {
memset (&tip.hto, 0, sizeof tip.hto);
tip.havehto = 0;
}
tip.from.len = 4;
memcpy (tip.from.iabuf, &from, 4);
tip.to.len = 4;
memcpy (tip.to.iabuf, &to -> sin_addr, 4);
tip.to_port = to -> sin_port;
tip.index = htonl (interface -> index);
iov [0].buf = (char *)&tip;
iov [0].len = sizeof tip;
iov [1].buf = (char *)raw;
iov [1].len = len;
trace_write_packet_iov (outpacket_trace, 2, iov, MDL);
}
if (!trace_playback ()) {
return send_packet (interface, packet, raw, len,
from, to, hto);
}
return len;
}
void trace_outpacket_input (trace_type_t *ttype, unsigned len, char *buf)
{
trace_outpacket_t *tip;
int index;
if (len < sizeof *tip) {
log_error ("trace_input_packet: too short - %d", len);
return;
}
tip = (trace_outpacket_t *)buf;
index = ntohl (tip -> index);
if (index > interface_count ||
index < 0 ||
!interface_vector [index]) {
log_error ("trace_input_packet: unknown interface index %d",
index);
return;
}
/* XXX would be nice to somehow take notice of these. */
}
void trace_outpacket_stop (trace_type_t *ttype) { }
void trace_seed_stash (trace_type_t *ttype, unsigned seed)
{
u_int32_t outseed;
if (!trace_record ())
return;
outseed = htonl (seed);
trace_write_packet (ttype, sizeof outseed, (char *)&outseed, MDL);
return;
}
void trace_seed_input (trace_type_t *ttype, unsigned length, char *buf)
{
u_int32_t *seed;
if (length != sizeof seed) {
log_error ("trace_seed_input: wrong size (%d)", length);
}
seed = (u_int32_t *)buf;
srandom (ntohl (*seed));
}
void trace_seed_stop (trace_type_t *ttype) { }
#endif /* TRACING */