3 Subroutines that support tracing of OMAPI wire transactions and
4 provide a mechanism for programs using OMAPI to trace their own
8 * Copyright (c) 2012,2014 by Internet Systems Consortium, Inc. ("ISC")
9 * Copyright (c) 2009-2010 by Internet Systems Consortium, Inc. ("ISC")
10 * Copyright (c) 2004-2007 by Internet Systems Consortium, Inc. ("ISC")
11 * Copyright (c) 2001-2003 by Internet Software Consortium
13 * Permission to use, copy, modify, and distribute this software for any
14 * purpose with or without fee is hereby granted, provided that the above
15 * copyright notice and this permission notice appear in all copies.
17 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
18 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
20 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
21 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
22 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
23 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
25 * Internet Systems Consortium, Inc.
27 * Redwood City, CA 94063
29 * https://www.isc.org/
34 #include <omapip/omapip_p.h>
38 void (*trace_set_time_hook
) (TIME
);
39 static int tracing_stopped
;
40 static int traceoutfile
;
41 static int traceindex
;
42 static trace_type_t
**trace_types
;
43 static int trace_type_count
;
44 static int trace_type_max
;
45 static trace_type_t
*new_trace_types
;
46 static FILE *traceinfile
;
47 static tracefile_header_t tracefile_header
;
48 static int trace_playback_flag
;
49 trace_type_t trace_time_marker
;
51 #if defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
52 extern omapi_array_t
*trace_listeners
;
53 extern omapi_array_t
*omapi_connections
;
57 void trace_free_all ()
63 new_trace_types
= tp
-> next
;
65 dfree (tp
-> name
, MDL
);
66 tp
-> name
= (char *)0;
71 for (i
= 0; i
< trace_type_count
; i
++) {
72 if (trace_types
[i
]) {
73 if (trace_types
[i
] -> name
)
74 dfree (trace_types
[i
] -> name
, MDL
);
75 dfree (trace_types
[i
], MDL
);
78 dfree (trace_types
, MDL
);
79 trace_types
= (trace_type_t
**)0;
80 trace_type_count
= trace_type_max
= 0;
82 omapi_array_free (&trace_listeners
, MDL
);
83 omapi_array_free (&omapi_connections
, MDL
);
87 static isc_result_t
trace_type_record (trace_type_t
*,
88 unsigned, const char *, int);
92 return trace_playback_flag
;
97 if (traceoutfile
&& !tracing_stopped
)
102 isc_result_t
trace_init (void (*set_time
) (TIME
),
103 const char *file
, int line
)
105 trace_type_t
*root_type
;
106 static int root_setup
= 0;
109 return ISC_R_SUCCESS
;
111 trace_set_time_hook
= set_time
;
113 root_type
= trace_type_register ("trace-index-mapping",
114 (void *)0, trace_index_map_input
,
115 trace_index_stop_tracing
, file
, line
);
117 return ISC_R_UNEXPECTED
;
118 if (new_trace_types
== root_type
)
119 new_trace_types
= new_trace_types
-> next
;
120 root_type
-> index
= 0;
121 trace_type_stash (root_type
);
124 return ISC_R_SUCCESS
;
127 isc_result_t
trace_begin (const char *filename
,
128 const char *file
, int line
)
130 tracefile_header_t tfh
;
132 trace_type_t
*tptr
, *next
;
136 log_error ("%s(%d): trace_begin called twice",
138 return DHCP_R_INVALIDARG
;
141 traceoutfile
= open (filename
, O_CREAT
| O_WRONLY
| O_EXCL
, 0600);
142 if (traceoutfile
< 0 && errno
== EEXIST
) {
143 log_error ("WARNING: Overwriting trace file \"%s\"", filename
);
144 traceoutfile
= open (filename
, O_WRONLY
| O_EXCL
| O_TRUNC
,
148 if (traceoutfile
< 0) {
149 log_error ("%s(%d): trace_begin: %s: %m",
150 file
, line
, filename
);
151 return ISC_R_UNEXPECTED
;
153 #if defined (HAVE_SETFD)
154 if (fcntl (traceoutfile
, F_SETFD
, 1) < 0)
155 log_error ("Can't set close-on-exec on %s: %m", filename
);
158 tfh
.magic
= htonl (TRACEFILE_MAGIC
);
159 tfh
.version
= htonl (TRACEFILE_VERSION
);
160 tfh
.hlen
= htonl (sizeof (tracefile_header_t
));
161 tfh
.phlen
= htonl (sizeof (tracepacket_t
));
163 status
= write (traceoutfile
, &tfh
, sizeof tfh
);
165 log_error ("%s(%d): trace_begin write failed: %m", file
, line
);
166 return ISC_R_UNEXPECTED
;
167 } else if (status
!= sizeof tfh
) {
168 log_error ("%s(%d): trace_begin: short write (%d:%ld)",
169 file
, line
, status
, (long)(sizeof tfh
));
171 return ISC_R_UNEXPECTED
;
174 /* Stash all the types that have already been set up. */
175 if (new_trace_types
) {
176 next
= new_trace_types
;
177 new_trace_types
= (trace_type_t
*)0;
178 for (tptr
= next
; tptr
; tptr
= next
) {
180 if (tptr
-> index
!= 0) {
181 result
= (trace_type_record
183 strlen (tptr
-> name
), file
, line
));
184 if (result
!= ISC_R_SUCCESS
)
190 return ISC_R_SUCCESS
;
193 isc_result_t
trace_write_packet (trace_type_t
*ttype
, unsigned length
,
194 const char *buf
, const char *file
, int line
)
200 return trace_write_packet_iov (ttype
, 1, &iov
, file
, line
);
203 isc_result_t
trace_write_packet_iov (trace_type_t
*ttype
,
204 int count
, trace_iov_t
*iov
,
205 const char *file
, int line
)
212 /* Really shouldn't get called here, but it may be hard to turn off
213 tracing midstream if the trace file write fails or something. */
218 log_error ("%s(%d): trace_write_packet with null trace type",
219 file
? file
: "<unknown file>", line
);
220 return DHCP_R_INVALIDARG
;
223 log_error ("%s(%d): trace_write_packet with no tracefile.",
224 file
? file
: "<unknown file>", line
);
225 return DHCP_R_INVALIDARG
;
228 /* Compute the total length of the iov. */
230 for (i
= 0; i
< count
; i
++)
231 length
+= iov
[i
].len
;
233 /* We have to swap out the data, because it may be read back on a
234 machine of different endianness. */
235 memset(&tmp
, 0, sizeof(tmp
));
236 tmp
.type_index
= htonl (ttype
-> index
);
237 tmp
.when
= htonl (time ((time_t *)0)); /* XXX */
238 tmp
.length
= htonl (length
);
240 status
= write (traceoutfile
, &tmp
, sizeof tmp
);
242 log_error ("%s(%d): trace_write_packet write failed: %m",
244 return ISC_R_UNEXPECTED
;
245 } else if (status
!= sizeof tmp
) {
246 log_error ("%s(%d): trace_write_packet: short write (%d:%ld)",
247 file
, line
, status
, (long)(sizeof tmp
));
251 for (i
= 0; i
< count
; i
++) {
252 status
= write (traceoutfile
, iov
[i
].buf
, iov
[i
].len
);
254 log_error ("%s(%d): %s write failed: %m",
255 file
, line
, "trace_write_packet");
256 return ISC_R_UNEXPECTED
;
257 } else if (status
!= iov
[i
].len
) {
258 log_error ("%s(%d): %s: short write (%d:%d)",
260 "trace_write_packet", status
, length
);
265 /* Write padding on the end of the packet to align the next
266 packet to an 8-byte boundary. This is in case we decide to
267 use mmap in some clever way later on. */
269 static char zero
[] = { 0, 0, 0, 0, 0, 0, 0 };
270 unsigned padl
= 8 - (length
% 8);
272 status
= write (traceoutfile
, zero
, padl
);
274 log_error ("%s(%d): trace_write_packet write failed: %m",
276 return ISC_R_UNEXPECTED
;
277 } else if (status
!= padl
) {
278 log_error ("%s(%d): trace_write_packet: short write (%d:%d)",
279 file
, line
, status
, padl
);
284 return ISC_R_SUCCESS
;
287 void trace_type_stash (trace_type_t
*tptr
)
291 if (trace_type_max
<= tptr
-> index
) {
292 delta
= tptr
-> index
- trace_type_max
+ 10;
293 vec
= dmalloc (((trace_type_max
+ delta
) *
294 sizeof (trace_type_t
*)), MDL
);
297 memset (&vec
[trace_type_max
], 0,
298 (sizeof (trace_type_t
*)) * delta
);
299 trace_type_max
+= delta
;
301 memcpy (vec
, trace_types
,
302 trace_type_count
* sizeof (trace_type_t
*));
303 dfree (trace_types
, MDL
);
307 trace_types
[tptr
-> index
] = tptr
;
308 if (tptr
-> index
>= trace_type_count
)
309 trace_type_count
= tptr
-> index
+ 1;
312 trace_type_t
*trace_type_register (const char *name
,
314 void (*have_packet
) (trace_type_t
*,
316 void (*stop_tracing
) (trace_type_t
*),
317 const char *file
, int line
)
320 unsigned slen
= strlen (name
);
323 ttmp
= dmalloc (sizeof *ttmp
, file
, line
);
327 ttmp
-> name
= dmalloc (slen
+ 1, file
, line
);
329 dfree (ttmp
, file
, line
);
330 return (trace_type_t
*)0;
332 strcpy (ttmp
-> name
, name
);
333 ttmp
-> have_packet
= have_packet
;
334 ttmp
-> stop_tracing
= stop_tracing
;
337 status
= trace_type_record (ttmp
, slen
, file
, line
);
338 if (status
!= ISC_R_SUCCESS
) {
339 dfree (ttmp
-> name
, file
, line
);
340 dfree (ttmp
, file
, line
);
341 return (trace_type_t
*)0;
344 ttmp
-> next
= new_trace_types
;
345 new_trace_types
= ttmp
;
351 static isc_result_t
trace_type_record (trace_type_t
*ttmp
, unsigned slen
,
352 const char *file
, int line
)
354 trace_index_mapping_t
*tim
;
357 tim
= dmalloc (slen
+ TRACE_INDEX_MAPPING_SIZE
, file
, line
);
359 return ISC_R_NOMEMORY
;
360 ttmp
-> index
= ++traceindex
;
361 trace_type_stash (ttmp
);
362 tim
-> index
= htonl (ttmp
-> index
);
363 memcpy (tim
-> name
, ttmp
-> name
, slen
);
364 status
= trace_write_packet (trace_types
[0],
365 slen
+ TRACE_INDEX_MAPPING_SIZE
,
366 (char *)tim
, file
, line
);
367 dfree (tim
, file
, line
);
371 /* Stop all registered trace types from trying to trace. */
373 void trace_stop (void)
377 for (i
= 0; i
< trace_type_count
; i
++)
378 if (trace_types
[i
] -> stop_tracing
)
379 (*(trace_types
[i
] -> stop_tracing
))
384 void trace_index_map_input (trace_type_t
*ttype
, unsigned length
, char *buf
)
386 trace_index_mapping_t
*tmap
;
388 trace_type_t
*tptr
, **prev
;
390 if (length
< TRACE_INDEX_MAPPING_SIZE
) {
391 log_error ("short trace index mapping");
394 tmap
= (trace_index_mapping_t
*)buf
;
396 prev
= &new_trace_types
;
397 for (tptr
= new_trace_types
; tptr
; tptr
= tptr
-> next
) {
398 len
= strlen (tptr
-> name
);
399 if (len
== length
- TRACE_INDEX_MAPPING_SIZE
&&
400 !memcmp (tptr
-> name
, tmap
-> name
, len
)) {
401 tptr
-> index
= ntohl (tmap
-> index
);
402 trace_type_stash (tptr
);
403 *prev
= tptr
-> next
;
406 prev
= &tptr
-> next
;
409 log_error ("No registered trace type for type name %.*s",
410 (int)length
- TRACE_INDEX_MAPPING_SIZE
, tmap
-> name
);
414 void trace_index_stop_tracing (trace_type_t
*ttype
) { }
416 void trace_replay_init (void)
418 trace_playback_flag
= 1;
421 void trace_file_replay (const char *filename
)
423 tracepacket_t
*tpkt
= NULL
;
428 trace_type_t
*ttype
= NULL
;
432 traceinfile
= fopen (filename
, "r");
434 log_error("Can't open tracefile %s: %m", filename
);
437 #if defined (HAVE_SETFD)
438 if (fcntl (fileno(traceinfile
), F_SETFD
, 1) < 0)
439 log_error("Can't set close-on-exec on %s: %m", filename
);
441 status
= fread(&tracefile_header
, 1,
442 sizeof tracefile_header
, traceinfile
);
443 if (status
< sizeof tracefile_header
) {
444 if (ferror(traceinfile
))
445 log_error("Error reading trace file header: %m");
447 log_error("Short read on trace file header: %d %ld.",
448 status
, (long)(sizeof tracefile_header
));
451 tracefile_header
.magic
= ntohl(tracefile_header
.magic
);
452 tracefile_header
.version
= ntohl(tracefile_header
.version
);
453 tracefile_header
.hlen
= ntohl(tracefile_header
.hlen
);
454 tracefile_header
.phlen
= ntohl(tracefile_header
.phlen
);
456 if (tracefile_header
.magic
!= TRACEFILE_MAGIC
) {
457 log_error("%s: not a dhcp trace file.", filename
);
460 if (tracefile_header
.version
> TRACEFILE_VERSION
) {
461 log_error ("tracefile version %ld > current %ld.",
462 (long int)tracefile_header
.version
,
463 (long int)TRACEFILE_VERSION
);
466 if (tracefile_header
.phlen
< sizeof *tpkt
) {
467 log_error("tracefile packet size too small - %ld < %ld",
468 (long int)tracefile_header
.phlen
,
469 (long int)sizeof *tpkt
);
472 len
= (sizeof tracefile_header
) - tracefile_header
.hlen
;
474 log_error("tracefile header size too small - %ld < %ld",
475 (long int)tracefile_header
.hlen
,
476 (long int)sizeof tracefile_header
);
480 status
= fseek(traceinfile
, (long)len
, SEEK_CUR
);
482 log_error("can't seek past header: %m");
487 tpkt
= dmalloc((unsigned)tracefile_header
.phlen
, MDL
);
489 log_error ("can't allocate trace packet header.");
493 while ((result
= trace_get_next_packet(&ttype
, tpkt
, &buf
, &buflen
,
494 &bufmax
)) == ISC_R_SUCCESS
) {
495 (*ttype
->have_packet
)(ttype
, tpkt
->length
, buf
);
506 /* Get the next packet from the file. If ttp points to a nonzero pointer
507 to a trace type structure, check the next packet to see if it's of the
508 expected type, and back off if not. */
510 isc_result_t
trace_get_next_packet (trace_type_t
**ttp
,
512 char **buf
, unsigned *buflen
,
517 int status
, curposok
= 0;
522 status
= fgetpos(traceinfile
, &curpos
);
524 log_error("Can't save tracefile position: %m");
529 status
= fread(tpkt
, 1, (size_t)tracefile_header
.phlen
,
531 if (status
< tracefile_header
.phlen
) {
532 if (ferror(traceinfile
))
533 log_error("Error reading trace packet header: "
535 else if (status
== 0)
538 log_error ("Short read on trace packet header:"
541 (long int)tracefile_header
.phlen
);
542 return DHCP_R_PROTOCOLERROR
;
545 /* Swap the packet. */
546 tpkt
->type_index
= ntohl(tpkt
-> type_index
);
547 tpkt
->length
= ntohl(tpkt
-> length
);
548 tpkt
->when
= ntohl(tpkt
-> when
);
550 /* See if there's a handler for this packet type. */
551 if (tpkt
->type_index
< trace_type_count
&&
552 trace_types
[tpkt
->type_index
])
553 ttype
= trace_types
[tpkt
->type_index
];
555 log_error ("Trace packet with unknown index %ld",
556 (long int)tpkt
->type_index
);
557 return DHCP_R_PROTOCOLERROR
;
561 * Determine if we should try to expire any timer events.
563 * we aren't looking for a specific type of packet
564 * we have a hook to use to update the timer
565 * the timestamp on the packet doesn't match the current time
566 * When we do so we rewind the file to the beginning of this
567 * packet and then try for a new packet. This allows
568 * any code triggered by a timeout to get the current packet
569 * while we get the next one.
572 if ((ttp
!= NULL
) && (*ttp
== NULL
) &&
573 (tpkt
->when
!= cur_tv
.tv_sec
) &&
574 (trace_set_time_hook
!= NULL
)) {
576 log_error("no curpos for fsetpos in "
578 return DHCP_R_PROTOCOLERROR
;
581 status
= fsetpos(traceinfile
, &curpos
);
583 log_error("fsetpos in tracefile failed: %m");
584 return DHCP_R_PROTOCOLERROR
;
587 (*trace_set_time_hook
) (tpkt
->when
);
593 /* If we were supposed to get a particular kind of packet,
594 check to see that we got the right kind. */
595 if (ttp
&& *ttp
&& ttype
!= *ttp
) {
596 log_error ("Read packet type %s when expecting %s",
597 ttype
-> name
, (*ttp
) -> name
);
598 status
= fsetpos (traceinfile
, &curpos
);
600 log_error ("fsetpos in tracefile failed: %m");
601 return DHCP_R_PROTOCOLERROR
;
603 return ISC_R_UNEXPECTEDTOKEN
;
606 paylen
= tpkt
-> length
;
608 paylen
+= 8 - (tpkt
-> length
% 8);
610 /* allocate a buffer if we need one or current buffer is too small */
611 if ((*buf
== NULL
) || (paylen
> (*bufmax
))) {
614 (*bufmax
) = ((paylen
+ 1023) & ~1023U);
615 (*buf
) = dmalloc ((*bufmax
), MDL
);
617 log_error ("Can't allocate input buffer sized %d",
619 return ISC_R_NOMEMORY
;
623 status
= fread ((*buf
), 1, paylen
, traceinfile
);
624 if (status
< paylen
) {
625 if (ferror (traceinfile
))
626 log_error ("Error reading trace payload: %m");
628 log_error ("Short read on trace payload: %d %d.",
630 return DHCP_R_PROTOCOLERROR
;
633 /* Store the actual length of the payload. */
634 *buflen
= tpkt
-> length
;
638 return ISC_R_SUCCESS
;
641 isc_result_t
trace_get_packet (trace_type_t
**ttp
,
642 unsigned *buflen
, char **buf
)
649 return DHCP_R_INVALIDARG
;
651 tpkt
= dmalloc ((unsigned)tracefile_header
.phlen
, MDL
);
653 log_error ("can't allocate trace packet header.");
654 return ISC_R_NOMEMORY
;
657 status
= trace_get_next_packet (ttp
, tpkt
, buf
, buflen
, &bufmax
);
663 /* Get a packet from the trace input file that contains a file with the
664 specified name. We don't hunt for the packet - it should be the next
665 packet in the tracefile. If it's not, or something else bad happens,
666 return an error code. */
668 isc_result_t
trace_get_file (trace_type_t
*ttype
,
669 const char *filename
, unsigned *len
, char **buf
)
677 /* Disallow some obvious bogosities. */
678 if (!buf
|| !len
|| *buf
)
679 return DHCP_R_INVALIDARG
;
681 /* Save file position in case of filename mismatch. */
682 status
= fgetpos (traceinfile
, &curpos
);
684 log_error ("Can't save tracefile position: %m");
686 tpkt
= dmalloc ((unsigned)tracefile_header
.phlen
, MDL
);
688 log_error ("can't allocate trace packet header.");
689 return ISC_R_NOMEMORY
;
692 result
= trace_get_next_packet (&ttype
, tpkt
, buf
, len
, &max
);
693 /* done with tpkt, free it */
695 if (result
!= ISC_R_SUCCESS
) {
703 /* Make sure the filename is right. */
704 if (strcmp (filename
, *buf
)) {
705 log_error ("Read file %s when expecting %s", *buf
, filename
);
709 status
= fsetpos (traceinfile
, &curpos
);
711 log_error ("fsetpos in tracefile failed: %m");
712 return DHCP_R_PROTOCOLERROR
;
714 return ISC_R_UNEXPECTEDTOKEN
;
717 return ISC_R_SUCCESS
;