contrib/dhcp-3.0/omapip/trace.c

   1 /* trace.c
   2
   3    Subroutines that support tracing of OMAPI wire transactions and
   4    provide a mechanism for programs using OMAPI to trace their own
   5    transactions... */
   6
   7 /*
   8  * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
   9  * Copyright (c) 2001-2003 by Internet Software Consortium
  10  *
  11  * Permission to use, copy, modify, and distribute this software for any
  12  * purpose with or without fee is hereby granted, provided that the above
  13  * copyright notice and this permission notice appear in all copies.
  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  *   950 Charter Street
  25  *   Redwood City, CA 94063
  26  *   <info@isc.org>
  27  *   http://www.isc.org/
  28  *
  29  * This software has been written for Internet Systems Consortium
  30  * by Ted Lemon, as part of a project for Nominum, Inc.   To learn more
  31  * about Internet Systems Consortium, see http://www.isc.org/.  To
  32  * learn more about Nominum, Inc., see ``http://www.nominum.com''.
  33  */
  34
  35 #include <omapip/omapip_p.h>
  36
  37 #if defined (TRACING)
  38 void (*trace_set_time_hook) (u_int32_t);
  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;
  50
  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;
  54
  55 void trace_free_all ()
  56 {
  57         trace_type_t *tp;
  58         int i;
  59         tp = new_trace_types;
  60         while (tp) {
  61                 new_trace_types = tp -> next;
  62                 if (tp -> name) {
  63                         dfree (tp -> name, MDL);
  64                         tp -> name = (char *)0;
  65                 }
  66                 dfree (tp, MDL);
  67                 tp = new_trace_types;
  68         }
  69         for (i = 0; i < trace_type_count; i++) {
  70                 if (trace_types [i]) {
  71                         if (trace_types [i] -> name)
  72                                 dfree (trace_types [i] -> name, MDL);
  73                         dfree (trace_types [i], MDL);
  74                 }
  75         }
  76         dfree (trace_types, MDL);
  77         trace_types = (trace_type_t **)0;
  78         trace_type_count = trace_type_max = 0;
  79
  80         omapi_array_free (&trace_listeners, MDL);
  81         omapi_array_free (&omapi_connections, MDL);
  82 }
  83 #endif
  84
  85 static isc_result_t trace_type_record (trace_type_t *,
  86                                        unsigned, const char *, int);
  87
  88 int trace_playback ()
  89 {
  90         return trace_playback_flag;
  91 }
  92
  93 int trace_record ()
  94 {
  95         if (traceoutfile && !tracing_stopped)
  96                 return 1;
  97         return 0;
  98 }
  99
 100 isc_result_t trace_init (void (*set_time) (u_int32_t),
 101                          const char *file, int line)
 102 {
 103         trace_type_t *root_type;
 104         static int root_setup = 0;
 105
 106         if (root_setup)
 107                 return ISC_R_SUCCESS;
 108
 109         trace_set_time_hook = set_time;
 110
 111         root_type = trace_type_register ("trace-index-mapping",
 112                                          (void *)0, trace_index_map_input,
 113                                          trace_index_stop_tracing, file, line);
 114         if (!root_type)
 115                 return ISC_R_UNEXPECTED;
 116         if (new_trace_types == root_type)
 117                 new_trace_types = new_trace_types -> next;
 118         root_type -> index = 0;
 119         trace_type_stash (root_type);
 120
 121         root_setup = 1;
 122         return ISC_R_SUCCESS;
 123 }
 124
 125 isc_result_t trace_begin (const char *filename,
 126                           const char *file, int line)
 127 {
 128         tracefile_header_t tfh;
 129         int status;
 130         trace_type_t *tptr, *next;
 131         isc_result_t result;
 132
 133         if (traceoutfile) {
 134                 log_error ("%s(%d): trace_begin called twice",
 135                            file, line);
 136                 return ISC_R_INVALIDARG;
 137         }
 138
 139         traceoutfile = open (filename, O_CREAT | O_WRONLY | O_EXCL, 0644);
 140         if (traceoutfile < 0) {
 141                 log_error ("%s(%d): trace_begin: %s: %m",
 142                            file, line, filename);
 143                 return ISC_R_UNEXPECTED;
 144         }
 145 #if defined (HAVE_SETFD)
 146         if (fcntl (traceoutfile, F_SETFD, 1) < 0)
 147                 log_error ("Can't set close-on-exec on %s: %m", filename);
 148 #endif
 149
 150         tfh.magic = htonl (TRACEFILE_MAGIC);
 151         tfh.version = htonl (TRACEFILE_VERSION);
 152         tfh.hlen = htonl (sizeof (tracefile_header_t));
 153         tfh.phlen = htonl (sizeof (tracepacket_t));
 154
 155         status = write (traceoutfile, &tfh, sizeof tfh);
 156         if (status < 0) {
 157                 log_error ("%s(%d): trace_begin write failed: %m", file, line);
 158                 return ISC_R_UNEXPECTED;
 159         } else if (status != sizeof tfh) {
 160                 log_error ("%s(%d): trace_begin: short write (%d:%ld)",
 161                            file, line, status, (long)(sizeof tfh));
 162                 trace_stop ();
 163                 return ISC_R_UNEXPECTED;
 164         }
 165
 166         /* Stash all the types that have already been set up. */
 167         if (new_trace_types) {
 168                 next = new_trace_types;
 169                 new_trace_types = (trace_type_t *)0;
 170                 for (tptr = next; tptr; tptr = next) {
 171                         next = tptr -> next;
 172                         if (tptr -> index != 0) {
 173                                 result = (trace_type_record
 174                                           (tptr,
 175                                            strlen (tptr -> name), file, line));
 176                                 if (result != ISC_R_SUCCESS)
 177                                         return status;
 178                         }
 179                 }
 180         }
 181
 182         return ISC_R_SUCCESS;
 183 }
 184
 185 isc_result_t trace_write_packet (trace_type_t *ttype, unsigned length,
 186                                  const char *buf, const char *file, int line)
 187 {
 188         trace_iov_t iov;
 189
 190         iov.buf = buf;
 191         iov.len = length;
 192         return trace_write_packet_iov (ttype, 1, &iov, file, line);
 193 }
 194
 195 isc_result_t trace_write_packet_iov (trace_type_t *ttype,
 196                                      int count, trace_iov_t *iov,
 197                                      const char *file, int line)
 198 {
 199         tracepacket_t tmp;
 200         int status;
 201         int i;
 202         int length;
 203
 204         /* Really shouldn't get called here, but it may be hard to turn off
 205            tracing midstream if the trace file write fails or something. */
 206         if (tracing_stopped)
 207                 return 0;
 208
 209         if (!ttype) {
 210                 log_error ("%s(%d): trace_write_packet with null trace type",
 211                            file ? file : "<unknown file>", line);
 212                 return ISC_R_INVALIDARG;
 213         }
 214         if (!traceoutfile) {
 215                 log_error ("%s(%d): trace_write_packet with no tracefile.",
 216                            file ? file : "<unknown file>", line);
 217                 return ISC_R_INVALIDARG;
 218         }
 219
 220         /* Compute the total length of the iov. */
 221         length = 0;
 222         for (i = 0; i < count; i++)
 223                 length += iov [i].len;
 224
 225         /* We have to swap out the data, because it may be read back on a
 226            machine of different endianness. */
 227         tmp.type_index = htonl (ttype -> index);
 228         tmp.when = htonl (time ((time_t *)0)); /* XXX */
 229         tmp.length = htonl (length);
 230
 231         status = write (traceoutfile, &tmp, sizeof tmp);
 232         if (status < 0) {
 233                 log_error ("%s(%d): trace_write_packet write failed: %m",
 234                            file, line);
 235                 return ISC_R_UNEXPECTED;
 236         } else if (status != sizeof tmp) {
 237                 log_error ("%s(%d): trace_write_packet: short write (%d:%ld)",
 238                            file, line, status, (long)(sizeof tmp));
 239                 trace_stop ();
 240         }
 241
 242         for (i = 0; i < count; i++) {
 243                 status = write (traceoutfile, iov [i].buf, iov [i].len);
 244                 if (status < 0) {
 245                         log_error ("%s(%d): %s write failed: %m",
 246                                    file, line, "trace_write_packet");
 247                         return ISC_R_UNEXPECTED;
 248                 } else if (status != iov [i].len) {
 249                         log_error ("%s(%d): %s: short write (%d:%d)",
 250                                    file, line,
 251                                    "trace_write_packet", status, length);
 252                         trace_stop ();
 253                 }
 254         }
 255
 256         /* Write padding on the end of the packet to align the next
 257            packet to an 8-byte boundary.   This is in case we decide to
 258            use mmap in some clever way later on. */
 259         if (length % 8) {
 260             static char zero [] = { 0, 0, 0, 0, 0, 0, 0 };
 261             unsigned padl = 8 - (length % 8);
 262
 263             status = write (traceoutfile, zero, padl);
 264             if (status < 0) {
 265                 log_error ("%s(%d): trace_write_packet write failed: %m",
 266                            file, line);
 267                 return ISC_R_UNEXPECTED;
 268             } else if (status != padl) {
 269                 log_error ("%s(%d): trace_write_packet: short write (%d:%d)",
 270                            file, line, status, padl);
 271                 trace_stop ();
 272             }
 273         }
 274
 275         return ISC_R_SUCCESS;
 276 }
 277
 278 void trace_type_stash (trace_type_t *tptr)
 279 {
 280         trace_type_t **vec;
 281         int delta;
 282         if (trace_type_max <= tptr -> index) {
 283                 delta = tptr -> index - trace_type_max + 10;
 284                 vec = dmalloc (((trace_type_max + delta) *
 285                                 sizeof (trace_type_t *)), MDL);
 286                 if (!vec)
 287                         return;
 288                 memset (&vec [trace_type_max], 0,
 289                         (sizeof (trace_type_t *)) * delta);
 290                 trace_type_max += delta;
 291                 if (trace_types) {
 292                     memcpy (vec, trace_types,
 293                             trace_type_count * sizeof (trace_type_t *));
 294                     dfree (trace_types, MDL);
 295                 }
 296                 trace_types = vec;
 297         }
 298         trace_types [tptr -> index] = tptr;
 299         if (tptr -> index >= trace_type_count)
 300                 trace_type_count = tptr -> index + 1;
 301 }
 302
 303 trace_type_t *trace_type_register (const char *name,
 304                                    void *baggage,
 305                                    void (*have_packet) (trace_type_t *,
 306                                                         unsigned, char *),
 307                                    void (*stop_tracing) (trace_type_t *),
 308                                    const char *file, int line)
 309 {
 310         trace_type_t *ttmp, *tptr;
 311         unsigned slen = strlen (name);
 312         isc_result_t status;
 313
 314         ttmp = dmalloc (sizeof *ttmp, file, line);
 315         if (!ttmp)
 316                 return ttmp;
 317         ttmp -> index = -1;
 318         ttmp -> name = dmalloc (slen + 1, file, line);
 319         if (!ttmp -> name) {
 320                 dfree (ttmp, file, line);
 321                 return (trace_type_t *)0;
 322         }
 323         strcpy (ttmp -> name, name);
 324         ttmp -> have_packet = have_packet;
 325         ttmp -> stop_tracing = stop_tracing;
 326
 327         if (traceoutfile) {
 328                 status = trace_type_record (ttmp, slen, file, line);
 329                 if (status != ISC_R_SUCCESS) {
 330                         dfree (ttmp -> name, file, line);
 331                         dfree (ttmp, file, line);
 332                         return (trace_type_t *)0;
 333                 }
 334         } else {
 335                 ttmp -> next = new_trace_types;
 336                 new_trace_types = ttmp;
 337         }
 338
 339         return ttmp;
 340 }
 341
 342 static isc_result_t trace_type_record (trace_type_t *ttmp, unsigned slen,
 343                                        const char *file, int line)
 344 {
 345         trace_index_mapping_t *tim;
 346         isc_result_t status;
 347
 348         tim = dmalloc (slen + TRACE_INDEX_MAPPING_SIZE, file, line);
 349         if (!tim)
 350                 return ISC_R_NOMEMORY;
 351         ttmp -> index = ++traceindex;
 352         trace_type_stash (ttmp);
 353         tim -> index = htonl (ttmp -> index);
 354         memcpy (tim -> name, ttmp -> name, slen);
 355         status = trace_write_packet (trace_types [0],
 356                                      slen + TRACE_INDEX_MAPPING_SIZE,
 357                                      (char *)tim, file, line);
 358         dfree (tim, file, line);
 359         return status;
 360 }
 361
 362 /* Stop all registered trace types from trying to trace. */
 363
 364 void trace_stop (void)
 365 {
 366         int i;
 367
 368         for (i = 0; i < trace_type_count; i++)
 369                 if (trace_types [i] -> stop_tracing)
 370                         (*(trace_types [i] -> stop_tracing))
 371                                 (trace_types [i]);
 372         tracing_stopped = 1;
 373 }
 374
 375 void trace_index_map_input (trace_type_t *ttype, unsigned length, char *buf)
 376 {
 377         trace_index_mapping_t *tmap;
 378         unsigned len;
 379         trace_type_t *tptr, **prev;
 380
 381         if (length < TRACE_INDEX_MAPPING_SIZE) {
 382                 log_error ("short trace index mapping");
 383                 return;
 384         }
 385         tmap = (trace_index_mapping_t *)buf;
 386
 387         prev = &new_trace_types;
 388         for (tptr = new_trace_types; tptr; tptr = tptr -> next) {
 389                 len = strlen (tptr -> name);
 390                 if (len == length - TRACE_INDEX_MAPPING_SIZE &&
 391                     !memcmp (tptr -> name, tmap -> name, len)) {
 392                         tptr -> index = ntohl (tmap -> index);
 393                         trace_type_stash (tptr);
 394                         *prev = tptr -> next;
 395                         return;
 396                 }
 397                 prev = &tptr -> next;
 398         }
 399
 400         log_error ("No registered trace type for type name %.*s",
 401                    (int)length - TRACE_INDEX_MAPPING_SIZE, tmap -> name);
 402         return;
 403 }
 404
 405 void trace_index_stop_tracing (trace_type_t *ttype) { }
 406
 407 void trace_replay_init (void)
 408 {
 409         trace_playback_flag = 1;
 410 }
 411
 412 void trace_file_replay (const char *filename)
 413 {
 414         tracepacket_t *tpkt = (tracepacket_t *)0;
 415         int status;
 416         char *buf = (char *)0;
 417         unsigned buflen;
 418         unsigned bufmax = 0;
 419         trace_type_t *ttype = (trace_type_t *)0;
 420         isc_result_t result;
 421         int len;
 422
 423         traceinfile = fopen (filename, "r");
 424         if (!traceinfile) {
 425                 log_error ("Can't open tracefile %s: %m", filename);
 426                 return;
 427         }
 428 #if defined (HAVE_SETFD)
 429         if (fcntl (fileno (traceinfile), F_SETFD, 1) < 0)
 430                 log_error ("Can't set close-on-exec on %s: %m", filename);
 431 #endif
 432         status = fread (&tracefile_header, 1,
 433                         sizeof tracefile_header, traceinfile);
 434         if (status < sizeof tracefile_header) {
 435                 if (ferror (traceinfile))
 436                         log_error ("Error reading trace file header: %m");
 437                 else
 438                         log_error ("Short read on trace file header: %d %ld.",
 439                                    status, (long)(sizeof tracefile_header));
 440                 goto out;
 441         }
 442         tracefile_header.magic = ntohl (tracefile_header.magic);
 443         tracefile_header.version = ntohl (tracefile_header.version);
 444         tracefile_header.hlen = ntohl (tracefile_header.hlen);
 445         tracefile_header.phlen = ntohl (tracefile_header.phlen);
 446
 447         if (tracefile_header.magic != TRACEFILE_MAGIC) {
 448                 log_error ("%s: not a dhcp trace file.", filename);
 449                 goto out;
 450         }
 451         if (tracefile_header.version > TRACEFILE_VERSION) {
 452                 log_error ("tracefile version %ld > current %ld.",
 453                            (long int)tracefile_header.version,
 454                            (long int)TRACEFILE_VERSION);
 455                 goto out;
 456         }
 457         if (tracefile_header.phlen < sizeof *tpkt) {
 458                 log_error ("tracefile packet size too small - %ld < %ld",
 459                            (long int)tracefile_header.phlen,
 460                            (long int)sizeof *tpkt);
 461                 goto out;
 462         }
 463         len = (sizeof tracefile_header) - tracefile_header.hlen;
 464         if (len < 0) {
 465                 log_error ("tracefile header size too small - %ld < %ld",
 466                            (long int)tracefile_header.hlen,
 467                            (long int)sizeof tracefile_header);
 468                 goto out;
 469         }
 470         if (len > 0) {
 471                 status = fseek (traceinfile, (long)len, SEEK_CUR);
 472                 if (status < 0) {
 473                         log_error ("can't seek past header: %m");
 474                         goto out;
 475                 }
 476         }
 477
 478         tpkt = dmalloc ((unsigned)tracefile_header.phlen, MDL);
 479         if (!tpkt) {
 480                 log_error ("can't allocate trace packet header.");
 481                 goto out;
 482         }
 483
 484         while ((result = trace_get_next_packet (&ttype, tpkt, &buf, &buflen,
 485                                                 &bufmax)) == ISC_R_SUCCESS) {
 486             (*ttype -> have_packet) (ttype, tpkt -> length, buf);
 487             ttype = (trace_type_t *)0;
 488         }
 489       out:
 490         fclose (traceinfile);
 491         if (buf)
 492                 dfree (buf, MDL);
 493         if (tpkt)
 494                 dfree (tpkt, MDL);
 495 }
 496
 497 /* Get the next packet from the file.   If ttp points to a nonzero pointer
 498    to a trace type structure, check the next packet to see if it's of the
 499    expected type, and back off if not. */
 500
 501 isc_result_t trace_get_next_packet (trace_type_t **ttp,
 502                                     tracepacket_t *tpkt,
 503                                     char **buf, unsigned *buflen,
 504                                     unsigned *bufmax)
 505 {
 506         trace_type_t *ttype;
 507         unsigned paylen;
 508         int status;
 509         int len;
 510         fpos_t curpos;
 511
 512         status = fgetpos (traceinfile, &curpos);
 513         if (status < 0)
 514                 log_error ("Can't save tracefile position: %m");
 515
 516         status = fread (tpkt, 1, (size_t)tracefile_header.phlen, traceinfile);
 517         if (status < tracefile_header.phlen) {
 518                 if (ferror (traceinfile))
 519                         log_error ("Error reading trace packet header: %m");
 520                 else if (status == 0)
 521                         return ISC_R_EOF;
 522                 else
 523                         log_error ("Short read on trace packet header: "
 524                                    "%ld %ld.",
 525                                    (long int)status,
 526                                    (long int)tracefile_header.phlen);
 527                 return ISC_R_PROTOCOLERROR;
 528         }
 529
 530         /* Swap the packet. */
 531         tpkt -> type_index = ntohl (tpkt -> type_index);
 532         tpkt -> length = ntohl (tpkt -> length);
 533         tpkt -> when = ntohl (tpkt -> when);
 534
 535         /* See if there's a handler for this packet type. */
 536         if (tpkt -> type_index < trace_type_count &&
 537             trace_types [tpkt -> type_index])
 538                 ttype = trace_types [tpkt -> type_index];
 539         else {
 540                 log_error ("Trace packet with unknown index %ld",
 541                            (long int)tpkt -> type_index);
 542                 return ISC_R_PROTOCOLERROR;
 543         }
 544
 545         /* If we were just hunting for the time marker, we've found it,
 546            so back up to the beginning of the packet and return its
 547            type. */
 548         if (ttp && *ttp == &trace_time_marker) {
 549                 *ttp = ttype;
 550                 status = fsetpos (traceinfile, &curpos);
 551                 if (status < 0) {
 552                         log_error ("fsetpos in tracefile failed: %m");
 553                         return ISC_R_PROTOCOLERROR;
 554                 }
 555                 return ISC_R_EXISTS;
 556         }
 557
 558         /* If we were supposed to get a particular kind of packet,
 559            check to see that we got the right kind. */
 560         if (ttp && *ttp && ttype != *ttp) {
 561                 log_error ("Read packet type %s when expecting %s",
 562                            ttype -> name, (*ttp) -> name);
 563                 status = fsetpos (traceinfile, &curpos);
 564                 if (status < 0) {
 565                         log_error ("fsetpos in tracefile failed: %m");
 566                         return ISC_R_PROTOCOLERROR;
 567                 }
 568                 return ISC_R_UNEXPECTEDTOKEN;
 569         }
 570
 571         paylen = tpkt -> length;
 572         if (paylen % 8)
 573                 paylen += 8 - (tpkt -> length % 8);
 574         if (paylen > (*bufmax)) {
 575                 if ((*buf))
 576                         dfree ((*buf), MDL);
 577                 (*bufmax) = ((paylen + 1023) & ~1023U);
 578                 (*buf) = dmalloc ((*bufmax), MDL);
 579                 if (!(*buf)) {
 580                         log_error ("Can't allocate input buffer sized %d",
 581                                    (*bufmax));
 582                         return ISC_R_NOMEMORY;
 583                 }
 584         }
 585
 586         status = fread ((*buf), 1, paylen, traceinfile);
 587         if (status < paylen) {
 588                 if (ferror (traceinfile))
 589                         log_error ("Error reading trace payload: %m");
 590                 else
 591                         log_error ("Short read on trace payload: %d %d.",
 592                                    status, paylen);
 593                 return ISC_R_PROTOCOLERROR;
 594         }
 595
 596         /* Store the actual length of the payload. */
 597         *buflen = tpkt -> length;
 598
 599         if (trace_set_time_hook)
 600                 (*trace_set_time_hook) (tpkt -> when);
 601
 602         if (ttp)
 603                 *ttp = ttype;
 604         return ISC_R_SUCCESS;
 605 }
 606
 607 isc_result_t trace_get_packet (trace_type_t **ttp,
 608                                unsigned *buflen, char **buf)
 609 {
 610         tracepacket_t *tpkt;
 611         unsigned bufmax = 0;
 612         isc_result_t status;
 613
 614         if (!buf || *buf)
 615                 return ISC_R_INVALIDARG;
 616
 617         tpkt = dmalloc ((unsigned)tracefile_header.phlen, MDL);
 618         if (!tpkt) {
 619                 log_error ("can't allocate trace packet header.");
 620                 return ISC_R_NOMEMORY;
 621         }
 622
 623         status = trace_get_next_packet (ttp, tpkt, buf, buflen, &bufmax);
 624
 625         dfree (tpkt, MDL);
 626         return status;
 627 }
 628
 629 time_t trace_snoop_time (trace_type_t **ptp)
 630 {
 631         tracepacket_t *tpkt;
 632         unsigned bufmax = 0;
 633         unsigned buflen = 0;
 634         char *buf = (char *)0;
 635         isc_result_t status;
 636         time_t result;
 637         trace_type_t *ttp;
 638
 639         if (!ptp)
 640                 ptp = &ttp;
 641
 642         tpkt = dmalloc ((unsigned)tracefile_header.phlen, MDL);
 643         if (!tpkt) {
 644                 log_error ("can't allocate trace packet header.");
 645                 return ISC_R_NOMEMORY;
 646         }
 647
 648         *ptp = &trace_time_marker;
 649         trace_get_next_packet (ptp, tpkt, &buf, &buflen, &bufmax);
 650         result = tpkt -> when;
 651
 652         dfree (tpkt, MDL);
 653         return result;
 654 }
 655
 656 /* Get a packet from the trace input file that contains a file with the
 657    specified name.   We don't hunt for the packet - it should be the next
 658    packet in the tracefile.   If it's not, or something else bad happens,
 659    return an error code. */
 660
 661 isc_result_t trace_get_file (trace_type_t *ttype,
 662                              const char *filename, unsigned *len, char **buf)
 663 {
 664         fpos_t curpos;
 665         unsigned max = 0;
 666         tracepacket_t *tpkt;
 667         int status;
 668         isc_result_t result;
 669
 670         /* Disallow some obvious bogosities. */
 671         if (!buf || !len || *buf)
 672                 return ISC_R_INVALIDARG;
 673
 674         /* Save file position in case of filename mismatch. */
 675         status = fgetpos (traceinfile, &curpos);
 676         if (status < 0)
 677                 log_error ("Can't save tracefile position: %m");
 678
 679         tpkt = dmalloc ((unsigned)tracefile_header.phlen, MDL);
 680         if (!tpkt) {
 681                 log_error ("can't allocate trace packet header.");
 682                 return ISC_R_NOMEMORY;
 683         }
 684
 685         result = trace_get_next_packet (&ttype, tpkt, buf, len, &max);
 686         if (result != ISC_R_SUCCESS) {
 687                 dfree (tpkt, MDL);
 688                 if (*buf)
 689                         dfree (*buf, MDL);
 690                 return result;
 691         }
 692
 693         /* Make sure the filename is right. */
 694         if (strcmp (filename, *buf)) {
 695                 log_error ("Read file %s when expecting %s", *buf, filename);
 696                 status = fsetpos (traceinfile, &curpos);
 697                 if (status < 0) {
 698                         log_error ("fsetpos in tracefile failed: %m");
 699                         dfree (tpkt, MDL);
 700                         dfree (*buf, MDL);
 701                         return ISC_R_PROTOCOLERROR;
 702                 }
 703                 return ISC_R_UNEXPECTEDTOKEN;
 704         }
 705
 706         dfree (tpkt, MDL);
 707         return ISC_R_SUCCESS;
 708 }
 709 #endif /* TRACING */