6 * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
32 #include "file_wrappers.h"
35 #include "catapult_dct2000.h"
37 #define MAX_FIRST_LINE_LENGTH 200
38 #define MAX_TIMESTAMP_LINE_LENGTH 100
39 #define MAX_LINE_LENGTH 65536
40 #define MAX_TIMESTAMP_LEN 32
41 #define MAX_SECONDS_CHARS 16
42 #define MAX_SUBSECOND_DECIMALS 4
43 #define MAX_CONTEXT_NAME 64
44 #define MAX_PROTOCOL_NAME 64
45 #define MAX_PORT_DIGITS 2
46 #define MAX_VARIANT_DIGITS 32
47 #define MAX_OUTHDR_NAME 256
48 #define AAL_HEADER_CHARS 12
51 - support for FP over AAL0
52 - support for IuR interface FP
56 /* 's' or 'r' of a packet as read from .out file */
57 typedef enum packet_direction_t
64 /***********************************************************************/
65 /* For each line, store (in case we need to dump): */
66 /* - String before time field */
67 /* - String beween time field and data (if NULL assume " l ") */
75 /*******************************************************************/
76 /* Information stored external to a file (wtap) needed for dumping */
77 typedef struct dct2000_file_externals
79 /* Buffer to hold first line, including magic and format number */
80 gchar firstline[MAX_FIRST_LINE_LENGTH];
81 gint firstline_length;
83 /* Buffer to hold second line with formatted file creation data/time */
84 gchar secondline[MAX_TIMESTAMP_LINE_LENGTH];
85 gint secondline_length;
87 /* Hash table to store text prefix data part of displayed packets.
88 Records (file offset -> line_prefix_info_t)
89 N.B. This is only needed for dumping
91 GHashTable *packet_prefix_table;
92 } dct2000_file_externals_t;
94 /* This global table maps wtap -> dct2000_file_externals_t structs */
95 static GHashTable *file_externals_table = NULL;
98 /***********************************************************/
99 /* Transient data used for parsing */
101 /* Buffer to hold a single text line read from the file */
102 static gchar linebuff[MAX_LINE_LENGTH];
104 /* Buffer for separate AAL header */
105 static gchar aal_header_chars[AAL_HEADER_CHARS];
107 /* 'Magic number' at start of Catapult DCT2000 .out files. */
108 static const gchar catapult_dct2000_magic[] = "Session Transcript";
110 /* Context name + port that the packet was captured at */
111 static gchar context_name[MAX_CONTEXT_NAME];
112 static guint8 context_port;
114 /* The DCT2000 protocol name of the packet, plus variant number */
115 static gchar protocol_name[MAX_PROTOCOL_NAME+1];
116 static gchar variant_name[MAX_VARIANT_DIGITS+1];
117 static gchar outhdr_name[MAX_OUTHDR_NAME+1];
120 /************************************************************/
121 /* Functions called from wiretap core */
122 static gboolean catapult_dct2000_read(wtap *wth, int *err, gchar **err_info,
123 gint64 *data_offset);
124 static gboolean catapult_dct2000_seek_read(wtap *wth, gint64 seek_off,
125 union wtap_pseudo_header *pseudo_header,
126 guchar *pd, int length,
127 int *err, gchar **err_info);
128 static void catapult_dct2000_close(wtap *wth);
130 static gboolean catapult_dct2000_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
131 const union wtap_pseudo_header *pseudo_header,
132 const guchar *pd, int *err);
133 static gboolean catapult_dct2000_dump_close(wtap_dumper *wdh, int *err);
136 /************************************************************/
137 /* Private helper functions */
138 static gboolean read_new_line(FILE_T fh, gint64 *offset, gint *length);
139 static gboolean parse_line(gint line_length, gint *seconds, gint *useconds,
140 long *before_time_offset, long *after_time_offset,
143 packet_direction_t *direction,
145 static int write_stub_header(guchar *frame_buffer, char *timestamp_string,
146 packet_direction_t direction, int encap);
147 static guchar hex_from_char(gchar c);
148 static gchar char_from_hex(guchar hex);
150 static void set_pseudo_header_info(wtap *wth,
153 union wtap_pseudo_header *pseudo_header,
154 packet_direction_t direction);
155 static void set_aal_info(union wtap_pseudo_header *pseudo_header,
156 packet_direction_t direction);
157 static void set_isdn_info(union wtap_pseudo_header *pseudo_header,
158 packet_direction_t direction);
159 static void set_ppp_info(union wtap_pseudo_header *pseudo_header,
160 packet_direction_t direction);
162 static gint wth_equal(gconstpointer v, gconstpointer v2);
163 static guint wth_hash_func(gconstpointer v);
164 static gint packet_offset_equal(gconstpointer v, gconstpointer v2);
165 static guint packet_offset_hash_func(gconstpointer v);
167 static gboolean get_file_time_stamp(time_t *secs, guint32 *usecs);
168 static gboolean free_line_prefix_info(gpointer key, gpointer value, gpointer user_data);
172 /********************************************/
173 /* Open file (for reading) */
174 /********************************************/
175 int catapult_dct2000_open(wtap *wth, int *err, gchar **err_info _U_)
180 gint firstline_length = 0;
181 dct2000_file_externals_t *file_externals;
183 /* Clear errno before reading from the file */
187 /********************************************************************/
188 /* First line needs to contain at least as many characters as magic */
190 read_new_line(wth->fh, &offset, &firstline_length);
191 if (((size_t)firstline_length < strlen(catapult_dct2000_magic)) ||
192 firstline_length >= MAX_FIRST_LINE_LENGTH)
197 /* This file is not for us if it doesn't match our signature */
198 if (memcmp(catapult_dct2000_magic, linebuff, strlen(catapult_dct2000_magic)) != 0)
204 /*********************************************************************/
205 /* Need entry in file_externals table */
207 /* Create file externals table if it doesn't yet exist */
208 if (file_externals_table == NULL)
210 file_externals_table = g_hash_table_new(wth_hash_func, wth_equal);
213 /* Allocate a new file_externals structure for this file */
214 file_externals = g_malloc(sizeof(dct2000_file_externals_t));
215 memset((void*)file_externals, '\0', sizeof(dct2000_file_externals_t));
217 /* Copy this first line into buffer so could write out later */
218 g_strlcpy(file_externals->firstline, linebuff, firstline_length+1);
219 file_externals->firstline_length = firstline_length;
222 /***********************************************************/
223 /* Second line contains file timestamp */
224 /* Store this offset in in wth->capture->catapult_dct2000 */
226 read_new_line(wth->fh, &offset, &(file_externals->secondline_length));
227 if ((file_externals->secondline_length >= MAX_TIMESTAMP_LINE_LENGTH) ||
228 (!get_file_time_stamp(×tamp, &usecs)))
230 /* Give up if file time line wasn't valid */
231 g_free(file_externals);
235 /* Allocate struct and fill in timestamp */
236 wth->capture.catapult_dct2000 = g_malloc(sizeof(catapult_dct2000_t));
237 wth->capture.catapult_dct2000->start_secs = timestamp;
238 wth->capture.catapult_dct2000->start_usecs = usecs;
240 /* Copy this second line into buffer so could write out later */
241 g_strlcpy(file_externals->secondline, linebuff, file_externals->secondline_length+1);
244 /************************************************************/
245 /* File is for us. Fill in details so packets can be read */
247 /* Set our file type */
248 wth->file_type = WTAP_FILE_CATAPULT_DCT2000;
250 /* Use our own encapsulation to send all packets to our stub dissector */
251 wth->file_encap = WTAP_ENCAP_CATAPULT_DCT2000;
253 /* Callbacks for reading operations */
254 wth->subtype_read = catapult_dct2000_read;
255 wth->subtype_seek_read = catapult_dct2000_seek_read;
256 wth->subtype_close = catapult_dct2000_close;
258 /* Choose microseconds (have 4 decimal places...) */
259 wth->tsprecision = WTAP_FILE_TSPREC_USEC;
262 /***************************************************************/
263 /* Initialise packet_prefix_table (index is offset into file) */
264 file_externals->packet_prefix_table =
265 g_hash_table_new(packet_offset_hash_func, packet_offset_equal);
267 /* Add file_externals for this wtap into the global table */
268 g_hash_table_insert(file_externals_table,
269 (void*)wth, (void*)file_externals);
276 /**************************************************/
277 /* Read packet function. */
278 /* Look for and read the next usable packet */
279 /* - return TRUE and details if found */
280 /**************************************************/
281 gboolean catapult_dct2000_read(wtap *wth, int *err, gchar **err_info _U_,
284 gint64 offset = wth->data_offset;
285 long dollar_offset, before_time_offset, after_time_offset;
286 packet_direction_t direction;
289 /* Find wtap external structure for this wtap */
290 dct2000_file_externals_t *file_externals =
291 (dct2000_file_externals_t*)g_hash_table_lookup(file_externals_table, wth);
293 /* There *has* to be an entry for this wth */
299 /* Search for a line containing a usable packet */
302 int line_length, seconds, useconds, data_chars;
303 gint64 this_offset = offset;
305 /* Are looking for first packet after 2nd line */
306 if (wth->data_offset == 0)
308 this_offset += (file_externals->firstline_length+1+
309 file_externals->secondline_length+1);
312 /* Clear errno before reading from the file */
315 /* Read a new line from file into linebuff */
316 if (read_new_line(wth->fh, &offset, &line_length) == FALSE)
318 /* Get out if no more lines can be read */
322 /* Try to parse the line as a frame record */
323 if (parse_line(line_length, &seconds, &useconds,
324 &before_time_offset, &after_time_offset,
326 &data_chars, &direction, &encap))
328 guchar *frame_buffer;
331 line_prefix_info_t *line_prefix_info;
332 char timestamp_string[MAX_TIMESTAMP_LEN+1];
335 g_snprintf(timestamp_string, 32, "%d.%04d", seconds, useconds/100);
337 /* All packets go to Catapult DCT2000 stub dissector */
338 wth->phdr.pkt_encap = WTAP_ENCAP_CATAPULT_DCT2000;
340 /* Set data_offset to the beginning of the line we're returning.
341 This will be the seek_off parameter when this frame is re-read.
343 *data_offset = this_offset;
345 /* This is the position in the file where the next _read() will be called from */
346 wth->data_offset = this_offset + line_length + 1;
348 /* Fill in timestamp (capture base + packet offset) */
349 wth->phdr.ts.secs = wth->capture.catapult_dct2000->start_secs + seconds;
350 if ((wth->capture.catapult_dct2000->start_usecs + useconds) >= 1000000)
355 ((wth->capture.catapult_dct2000->start_usecs + useconds) % 1000000) *1000;
357 /* Get buffer pointer ready */
358 buffer_assure_space(wth->frame_buffer,
359 strlen(context_name)+1 + /* Context name */
361 strlen(timestamp_string)+1 + /* timestamp */
362 strlen(variant_name)+1 + /* variant */
363 strlen(outhdr_name)+1 + /* outhdr */
364 strlen(protocol_name)+1 + /* Protocol name */
368 frame_buffer = buffer_start_ptr(wth->frame_buffer);
371 /*********************/
372 /* Write stub header */
373 stub_offset = write_stub_header(frame_buffer, timestamp_string,
376 /* Binary data length is half bytestring length + stub header */
377 wth->phdr.len = data_chars/2 + stub_offset;
378 wth->phdr.caplen = data_chars/2 + stub_offset;
381 /*************************/
382 /* Copy data into buffer */
383 for (n=0; n <= data_chars; n+=2)
385 frame_buffer[stub_offset + n/2] =
386 (hex_from_char(linebuff[dollar_offset+n]) << 4) |
387 hex_from_char(linebuff[dollar_offset+n+1]);
390 /* Store the packet prefix in the hash table */
391 line_prefix_info = g_malloc(sizeof(line_prefix_info_t));
393 /* Create and use buffer for contents before time */
394 line_prefix_info->before_time = g_malloc(before_time_offset+2);
395 g_strlcpy(line_prefix_info->before_time, linebuff, before_time_offset+1);
396 line_prefix_info->before_time[before_time_offset+1] = '\0';
398 /* Create and use buffer for contents before time.
399 Do this only if it doesn't correspond to " l ", which is by far the most
401 if (((size_t)(dollar_offset - after_time_offset -1) == strlen(" l ")) &&
402 (strncmp(linebuff+after_time_offset, " l ", strlen(" l ")) == 0))
404 line_prefix_info->after_time = NULL;
408 /* Allocate & write buffer for line between timestamp and data */
409 line_prefix_info->after_time = g_malloc(dollar_offset - after_time_offset);
410 g_strlcpy(line_prefix_info->after_time, linebuff+after_time_offset,
411 dollar_offset - after_time_offset);
412 line_prefix_info->after_time[dollar_offset - after_time_offset-1] = '\0';
415 /* Add packet entry into table */
416 pkey = g_malloc(sizeof(*pkey));
418 g_hash_table_insert(file_externals->packet_prefix_table, pkey, line_prefix_info);
420 /* Set pseudo-header if necessary */
421 set_pseudo_header_info(wth, encap, this_offset, &wth->pseudo_header,
424 /* OK, we have packet details to return */
430 /* No packet details to return... */
436 /**************************************************/
437 /* Read & seek function. */
438 /**************************************************/
440 catapult_dct2000_seek_read(wtap *wth, gint64 seek_off,
441 union wtap_pseudo_header *pseudo_header, guchar *pd,
442 int length, int *err, gchar **err_info)
444 gint64 offset = wth->data_offset;
445 long dollar_offset, before_time_offset, after_time_offset;
446 packet_direction_t direction;
448 int seconds, useconds, data_chars;
453 /* Seek to beginning of packet */
454 if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
459 /* Re-read whole line (this really should succeed) */
460 if (read_new_line(wth->random_fh, &offset, &length) == FALSE)
465 /* Try to parse this line again (should succeed as re-reading...) */
466 if (parse_line(length, &seconds, &useconds,
467 &before_time_offset, &after_time_offset,
469 &data_chars, &direction, &encap))
473 char timestamp_string[32];
474 g_snprintf(timestamp_string, 32, "%d.%04d", seconds, useconds/100);
476 /* Make sure all packets go to catapult dct2000 dissector */
477 wth->phdr.pkt_encap = WTAP_ENCAP_CATAPULT_DCT2000;
480 /*********************/
481 /* Write stub header */
482 stub_offset = write_stub_header((guchar*)pd, timestamp_string,
486 /********************************/
487 /* Copy packet data into buffer */
488 for (n=0; n <= data_chars; n+=2)
490 pd[stub_offset + n/2] = (hex_from_char(linebuff[dollar_offset+n]) << 4) |
491 hex_from_char(linebuff[dollar_offset+n+1]);
494 /* Set packet pseudo-header if necessary */
495 set_pseudo_header_info(wth, encap, seek_off, pseudo_header, direction);
501 /* If get here, must have failed */
503 *err_info = g_strdup_printf("catapult dct2000: seek_read failed to read/parse "
504 "line at position %" G_GINT64_MODIFIER "d",
510 /***************************************************************************/
511 /* Free dct2000-specific capture info from file that was open for reading */
512 /***************************************************************************/
513 void catapult_dct2000_close(wtap *wth)
515 /* Look up externals for this file */
516 dct2000_file_externals_t *file_externals =
517 (dct2000_file_externals_t*)g_hash_table_lookup(file_externals_table, wth);
519 /* The entry *has* to be found */
525 /* Free up its line prefix values */
526 g_hash_table_foreach_remove(file_externals->packet_prefix_table,
527 free_line_prefix_info, NULL);
528 /* Free up its line prefix table */
529 g_hash_table_destroy(file_externals->packet_prefix_table);
531 /* And remove the externals entry from the global table */
532 g_hash_table_remove(file_externals_table, (void*)wth);
534 /* And free up file_externals itself */
535 g_free(file_externals);
537 /* Also free this capture info */
538 g_free(wth->capture.catapult_dct2000);
544 /***************************/
546 /***************************/
548 /*****************************************************/
549 /* The file that we are writing to has been opened. */
550 /* Set other dump callbacks. */
551 /*****************************************************/
552 gboolean catapult_dct2000_dump_open(wtap_dumper *wdh, gboolean cant_seek _U_, int *err _U_)
554 /* Fill in other dump callbacks */
555 wdh->subtype_write = catapult_dct2000_dump;
556 wdh->subtype_close = catapult_dct2000_dump_close;
561 /*********************************************************/
562 /* Respond to queries about which encap types we support */
564 /*********************************************************/
565 int catapult_dct2000_dump_can_write_encap(int encap)
569 case WTAP_ENCAP_CATAPULT_DCT2000:
570 /* We support this */
574 /* But don't write to any other formats... */
575 return WTAP_ERR_UNSUPPORTED_ENCAP;
580 /*****************************************/
581 /* Write a single packet out to the file */
582 /*****************************************/
584 static gboolean do_fwrite(const void *data, size_t size, size_t count, FILE *stream, int *err_p)
588 nwritten = fwrite(data, size, count, stream);
589 if (nwritten != count) {
590 if (nwritten == 0 && ferror(stream))
596 *err_p = WTAP_ERR_SHORT_WRITE;
604 gboolean catapult_dct2000_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
605 const union wtap_pseudo_header *pseudo_header,
606 const guchar *pd, int *err)
609 line_prefix_info_t *prefix = NULL;
610 gchar time_string[16];
612 /******************************************************/
613 /* Look up the file_externals structure for this file */
614 /* Find wtap external structure for this wtap */
615 dct2000_file_externals_t *file_externals =
616 (dct2000_file_externals_t*)g_hash_table_lookup(file_externals_table,
617 pseudo_header->dct2000.wth);
619 if (wdh->dump.dct2000 == NULL)
621 /* Allocate the dct2000-specific dump structure */
622 wdh->dump.dct2000 = g_malloc(sizeof(catapult_dct2000_t));
624 /* Write out saved first line */
625 if (! do_fwrite(file_externals->firstline, 1, file_externals->firstline_length, wdh->fh, err))
629 if (! do_fwrite("\n", 1, 1, wdh->fh, err))
634 /* Also write out saved second line with timestamp corresponding to the
635 opening time of the log.
637 if (! do_fwrite(file_externals->secondline, 1, file_externals->secondline_length, wdh->fh, err))
641 if (! do_fwrite("\n", 1, 1, wdh->fh, err))
646 /* Allocate the dct2000-specific dump structure */
647 wdh->dump.dct2000 = g_malloc(sizeof(catapult_dct2000_t));
649 /* Copy time of beginning of file */
650 wdh->dump.dct2000->start_time.secs =
651 pseudo_header->dct2000.wth->capture.catapult_dct2000->start_secs;
652 wdh->dump.dct2000->start_time.nsecs =
653 (pseudo_header->dct2000.wth->capture.catapult_dct2000->start_usecs * 1000);
655 /* Set flag do don't write header out again */
656 wdh->dump.dct2000->first_packet_written = TRUE;
660 /******************************************************************/
661 /* Write out this packet's prefix, including calculated timestamp */
663 /* Look up line data prefix using stored offset */
664 prefix = (line_prefix_info_t*)g_hash_table_lookup(file_externals->packet_prefix_table,
665 (const void*)&(pseudo_header->dct2000.seek_off));
667 /* Write out text before timestamp */
668 if (! do_fwrite(prefix->before_time, 1, strlen(prefix->before_time), wdh->fh, err))
673 /* Calculate time of this packet to write, relative to start of dump */
674 if (phdr->ts.nsecs >= wdh->dump.dct2000->start_time.nsecs)
676 g_snprintf(time_string, 16, "%ld.%04d",
677 (long)(phdr->ts.secs - wdh->dump.dct2000->start_time.secs),
678 (phdr->ts.nsecs - wdh->dump.dct2000->start_time.nsecs) / 100000);
682 g_snprintf(time_string, 16, "%ld.%04u",
683 (long)(phdr->ts.secs - wdh->dump.dct2000->start_time.secs-1),
684 ((1000000000 + (phdr->ts.nsecs / 100000)) - (wdh->dump.dct2000->start_time.nsecs / 100000)) % 10000);
687 /* Write out the calculated timestamp */
688 if (! do_fwrite(time_string, 1, strlen(time_string), wdh->fh, err))
693 /* Write out text between timestamp and start of hex data */
694 if (prefix->after_time == NULL)
696 if (! do_fwrite(" l ", 1, strlen(" l "), wdh->fh, err))
703 if (! do_fwrite(prefix->after_time, 1, strlen(prefix->after_time), wdh->fh, err))
710 /****************************************************************/
711 /* Need to skip stub header at start of pd before we reach data */
714 for (n=0; pd[n] != '\0'; n++);
717 /* Context port number */
721 for (; pd[n] != '\0'; n++);
725 for (; pd[n] != '\0'; n++);
728 /* Variant number (as string) */
729 for (; pd[n] != '\0'; n++);
732 /* Outhdr (as string) */
733 for (; pd[n] != '\0'; n++);
736 /* Direction & encap */
740 /**************************************/
741 /* Remainder is encapsulated protocol */
742 if (! do_fwrite("$", 1, 1, wdh->fh, err))
747 /* Each binary byte is written out as 2 hex string chars */
748 for (; n < phdr->len; n++)
751 c[0] = char_from_hex((guchar)(pd[n] >> 4));
752 c[1] = char_from_hex((guchar)(pd[n] & 0x0f));
754 /* Write both hex chars of byte together */
755 if (! do_fwrite(c, 1, 2, wdh->fh, err))
762 if (! do_fwrite("\n", 1, 1, wdh->fh, err))
771 /******************************************************/
772 /* Close a file we've been writing to. */
773 /******************************************************/
774 static gboolean catapult_dct2000_dump_close(wtap_dumper *wdh _U_, int *err _U_)
782 /****************************/
783 /* Private helper functions */
784 /****************************/
786 /**********************************************************************/
787 /* Read a new line from the file, starting at offset. */
788 /* - writes data to static var linebuff */
789 /* - on return 'offset' will point to the next position to read from */
790 /* - return TRUE if this read is successful */
791 /**********************************************************************/
792 gboolean read_new_line(FILE_T fh, gint64 *offset, gint *length)
797 result = file_gets(linebuff, MAX_LINE_LENGTH, fh);
800 /* No characters found */
804 /* Set length and offset.. */
805 *length = strlen(linebuff);
806 *offset = *offset + *length;
808 /* ...but don't want to include newline in line length */
809 if (linebuff[*length-1] == '\n')
811 linebuff[*length-1] = '\0';
812 *length = *length - 1;
819 /**********************************************************************/
820 /* Parse a line from buffer, by identifying: */
821 /* - context, port and direction of packet */
823 /* - data position and length */
824 /* Return TRUE if this packet looks valid and can be displayed */
825 /**********************************************************************/
826 gboolean parse_line(gint line_length, gint *seconds, gint *useconds,
827 long *before_time_offset, long *after_time_offset,
828 long *data_offset, gint *data_chars,
829 packet_direction_t *direction,
834 char port_number_string[MAX_PORT_DIGITS+1];
835 int variant_digits = 0;
837 int protocol_chars = 0;
838 int outhdr_chars = 0;
840 char seconds_buff[MAX_SECONDS_CHARS+1];
842 char subsecond_decimals_buff[MAX_SUBSECOND_DECIMALS+1];
843 int subsecond_decimals_chars;
844 int skip_first_byte = FALSE;
846 gboolean atm_header_present = FALSE;
848 /* Read context name until find '.' */
849 for (n=0; linebuff[n] != '.' && (n < MAX_CONTEXT_NAME) && (n+1 < line_length); n++)
851 if (!isalnum((guchar)linebuff[n]) && (linebuff[n] != '_'))
855 context_name[n] = linebuff[n];
857 if (n == MAX_CONTEXT_NAME || (n+1 >= line_length))
862 /* '.' must follow context name */
863 if (linebuff[n] != '.')
867 context_name[n] = '\0';
872 /* Now read port number */
873 for (port_digits = 0;
874 (linebuff[n] != '/') && (port_digits <= MAX_PORT_DIGITS) && (n+1 < line_length);
877 if (!isdigit((guchar)linebuff[n]))
881 port_number_string[port_digits] = linebuff[n];
883 if (port_digits > MAX_PORT_DIGITS || (n+1 >= line_length))
888 /* Slash char must follow port number */
889 if (linebuff[n] != '/')
893 port_number_string[port_digits] = '\0';
894 context_port = atoi(port_number_string);
899 /* Now for the protocol name */
900 for (protocol_chars = 0;
901 (linebuff[n] != '/') && (protocol_chars < MAX_PROTOCOL_NAME) && (n < line_length);
902 n++, protocol_chars++)
904 if (!isalnum((guchar)linebuff[n]) && linebuff[n] != '_')
908 protocol_name[protocol_chars] = linebuff[n];
910 if (protocol_chars == MAX_PROTOCOL_NAME || n >= line_length)
912 /* If doesn't fit, fail rather than truncate */
915 protocol_name[protocol_chars] = '\0';
917 /* Slash char must follow protocol name */
918 if (linebuff[n] != '/')
926 /* Following the / is the variant number. No digits indicate 1 */
927 for (variant_digits = 0;
928 (isdigit((guchar)linebuff[n])) && (variant_digits <= MAX_VARIANT_DIGITS) && (n+1 < line_length);
929 n++, variant_digits++)
931 if (!isdigit((guchar)linebuff[n]))
935 variant_name[variant_digits] = linebuff[n];
937 if (variant_digits > MAX_VARIANT_DIGITS || (n+1 >= line_length))
941 if (variant_digits > 0)
943 variant_name[variant_digits] = '\0';
944 variant = atoi(variant_name);
948 g_strlcpy(variant_name, "1", MAX_VARIANT_DIGITS+1);
952 /* Outheader values may follow */
953 outhdr_name[0] = '\0';
954 if (linebuff[n] == ',')
959 for (outhdr_chars = 0;
960 (isdigit((guchar)linebuff[n]) || linebuff[n] == ',') &&
961 (outhdr_chars <= MAX_OUTHDR_NAME) && (n+1 < line_length);
964 if (!isdigit((guchar)linebuff[n]) && (linebuff[n] != ','))
968 outhdr_name[outhdr_chars] = linebuff[n];
970 if (outhdr_chars > MAX_OUTHDR_NAME || (n+1 >= line_length))
974 /* Terminate (possibly empty) string */
975 outhdr_name[outhdr_chars] = '\0';
981 /******************************************************************/
982 /* Now check whether we know how to use a packet of this protocol */
984 if ((strcmp(protocol_name, "ip") == 0) ||
985 (strcmp(protocol_name, "sctp") == 0) ||
986 (strcmp(protocol_name, "gre") == 0) ||
987 (strcmp(protocol_name, "mipv6") == 0) ||
988 (strcmp(protocol_name, "igmp") == 0))
990 *encap = WTAP_ENCAP_RAW_IP;
994 /* FP may be carried over ATM, which has separate atm header to parse */
995 if ((strcmp(protocol_name, "fp") == 0) ||
996 (strcmp(protocol_name, "fp_r4") == 0) ||
997 (strcmp(protocol_name, "fp_r5") == 0) ||
998 (strcmp(protocol_name, "fp_r6") == 0) ||
999 (strcmp(protocol_name, "fp_r7") == 0))
1001 if ((variant > 256) && (variant % 256 == 3))
1003 /* FP over udp is contained in IPPrim... */
1008 /* FP over AAL0 or AAL2 */
1009 *encap = WTAP_ENCAP_ATM_PDUS_UNTRUNCATED;
1010 atm_header_present = TRUE;
1013 else if (strcmp(protocol_name, "fpiur_r5") == 0)
1015 /* FP (IuR) over AAL2 */
1016 *encap = WTAP_ENCAP_ATM_PDUS_UNTRUNCATED;
1017 atm_header_present = TRUE;
1022 if (strcmp(protocol_name, "ppp") == 0)
1024 *encap = WTAP_ENCAP_PPP;
1027 if (strcmp(protocol_name, "isdn_l3") == 0)
1029 /* TODO: find out what this byte means... */
1030 skip_first_byte = TRUE;
1031 *encap = WTAP_ENCAP_ISDN;
1034 if (strcmp(protocol_name, "isdn_l2") == 0)
1036 *encap = WTAP_ENCAP_ISDN;
1039 if (strcmp(protocol_name, "ethernet") == 0)
1041 *encap = WTAP_ENCAP_ETHERNET;
1044 if ((strcmp(protocol_name, "saalnni_sscop") == 0) ||
1045 (strcmp(protocol_name, "saaluni_sscop") == 0))
1047 *encap = DCT2000_ENCAP_SSCOP;
1050 if (strcmp(protocol_name, "frelay_l2") == 0)
1052 *encap = WTAP_ENCAP_FRELAY;
1055 if (strcmp(protocol_name, "ss7_mtp2") == 0)
1057 *encap = DCT2000_ENCAP_MTP2;
1060 if ((strcmp(protocol_name, "nbap") == 0) ||
1061 (strcmp(protocol_name, "nbap_r4") == 0) ||
1062 (strncmp(protocol_name, "nbap_sscfuni", strlen("nbap_sscfuni")) == 0))
1064 /* The entire message in these cases is nbap, so use an encap value. */
1065 *encap = DCT2000_ENCAP_NBAP;
1069 /* Not a supported board port protocol/encap, but can show as raw data or
1070 in some cases find protocol embedded inside primitive */
1071 *encap = DCT2000_ENCAP_UNHANDLED;
1075 /* Find separate ATM header if necessary */
1076 if (atm_header_present)
1078 int header_chars_seen = 0;
1080 /* Scan ahead to the next $ */
1081 for (; (linebuff[n] != '$') && (n+1 < line_length); n++);
1084 if (n+1 >= line_length)
1089 /* Read consecutive hex chars into atm header buffer */
1091 ((linebuff[n] >= '0') && (linebuff[n] <= '?') &&
1092 (n < line_length) &&
1093 (header_chars_seen < AAL_HEADER_CHARS));
1094 n++, header_chars_seen++)
1096 aal_header_chars[header_chars_seen] = linebuff[n];
1097 /* Next 6 characters after '9' are mapped to a->f */
1098 if (!isdigit((guchar)linebuff[n]))
1100 aal_header_chars[header_chars_seen] = 'a' + (linebuff[n] - '9') -1;
1104 if (header_chars_seen != AAL_HEADER_CHARS || n >= line_length)
1111 /* Scan ahead to the next space */
1112 for (; (linebuff[n] != ' ') && (n+1 < line_length); n++);
1113 if (n+1 >= line_length)
1120 /* Next character gives direction of message (must be 's' or 'r') */
1121 if (linebuff[n] == 's')
1126 if (linebuff[n] == 'r')
1128 *direction = received;
1138 /*********************************************************************/
1139 /* Find and read the timestamp */
1141 /* Now scan to the next digit, which should be the start of the timestamp */
1142 /* This will involve skipping " tm " */
1143 for (; !isdigit((guchar)linebuff[n]) && (n < line_length); n++);
1144 if (n >= line_length)
1149 *before_time_offset = n;
1152 for (seconds_chars = 0;
1153 (linebuff[n] != '.') &&
1154 (seconds_chars <= MAX_SECONDS_CHARS) &&
1156 n++, seconds_chars++)
1158 if (!isdigit((guchar)linebuff[n]))
1160 /* Found a non-digit before decimal point. Fail */
1163 seconds_buff[seconds_chars] = linebuff[n];
1165 if (seconds_chars > MAX_SECONDS_CHARS || n >= line_length)
1167 /* Didn't fit in buffer. Fail rather than use truncated */
1171 /* Convert found value into number */
1172 seconds_buff[seconds_chars] = '\0';
1173 *seconds = atoi(seconds_buff);
1175 /* The decimal point must follow the last of the seconds digits */
1176 if (linebuff[n] != '.')
1183 /* Subsecond decimal digits (expect 4-digit accuracy) */
1184 for (subsecond_decimals_chars = 0;
1185 (linebuff[n] != ' ') &&
1186 (subsecond_decimals_chars <= MAX_SUBSECOND_DECIMALS) &&
1188 n++, subsecond_decimals_chars++)
1190 if (!isdigit((guchar)linebuff[n]))
1194 subsecond_decimals_buff[subsecond_decimals_chars] = linebuff[n];
1196 if (subsecond_decimals_chars > MAX_SUBSECOND_DECIMALS || n >= line_length)
1198 /* More numbers than expected - give up */
1201 /* Convert found value into microseconds */
1202 subsecond_decimals_buff[subsecond_decimals_chars] = '\0';
1203 *useconds = atoi(subsecond_decimals_buff) * 100;
1205 /* Space character must follow end of timestamp */
1206 if (linebuff[n] != ' ')
1211 *after_time_offset = n;
1213 /* Now skip ahead to find start of data (marked by '$') */
1214 for (; (linebuff[n] != '$') && (n+1 < line_length); n++);
1215 if (n+1 >= line_length)
1222 /* Set offset to data start within line */
1225 /* Set number of chars that comprise the hex string protocol data */
1226 *data_chars = line_length - n;
1228 /* May need to skip first byte (2 hex string chars) */
1229 if (skip_first_byte)
1239 /*****************************************************************/
1240 /* Write the stub info to the data buffer while reading a packet */
1241 /*****************************************************************/
1242 int write_stub_header(guchar *frame_buffer, char *timestamp_string,
1243 packet_direction_t direction, int encap)
1245 int stub_offset = 0;
1247 g_strlcpy((char*)frame_buffer, context_name, MAX_CONTEXT_NAME+1);
1248 stub_offset += (strlen(context_name) + 1);
1250 /* Context port number */
1251 frame_buffer[stub_offset] = context_port;
1254 /* Timestamp within file */
1255 g_strlcpy((char*)&frame_buffer[stub_offset], timestamp_string, MAX_TIMESTAMP_LEN+1);
1256 stub_offset += (strlen(timestamp_string) + 1);
1259 g_strlcpy((char*)&frame_buffer[stub_offset], protocol_name, MAX_PROTOCOL_NAME+1);
1260 stub_offset += (strlen(protocol_name) + 1);
1262 /* Protocol variant number (as string) */
1263 g_strlcpy((void*)&frame_buffer[stub_offset], variant_name, MAX_VARIANT_DIGITS+1);
1264 stub_offset += (strlen(variant_name) + 1);
1267 g_strlcpy((char*)&frame_buffer[stub_offset], outhdr_name, MAX_OUTHDR_NAME+1);
1268 stub_offset += (strlen(outhdr_name) + 1);
1271 frame_buffer[stub_offset] = direction;
1275 frame_buffer[stub_offset] = (guint8)encap;
1282 /**************************************************************/
1283 /* Set pseudo-header info depending upon packet encapsulation */
1284 /**************************************************************/
1285 void set_pseudo_header_info(wtap *wth,
1288 union wtap_pseudo_header *pseudo_header,
1289 packet_direction_t direction)
1291 pseudo_header->dct2000.seek_off = file_offset;
1292 pseudo_header->dct2000.wth = wth;
1296 case WTAP_ENCAP_ATM_PDUS_UNTRUNCATED:
1297 set_aal_info(pseudo_header, direction);
1299 case WTAP_ENCAP_ISDN:
1300 set_isdn_info(pseudo_header, direction);
1302 case WTAP_ENCAP_PPP:
1303 set_ppp_info(pseudo_header, direction);
1307 /* Other supported types don't need to set anything here... */
1313 /*********************************************/
1314 /* Fill in atm pseudo-header with known info */
1315 /*********************************************/
1316 void set_aal_info(union wtap_pseudo_header *pseudo_header, packet_direction_t direction)
1318 /* 'aal_head_chars' has this format (for AAL2 at least):
1319 Global Flow Control (4 bits) | VPI (8 bits) | VCI (16 bits) |
1320 Payload Type (4 bits) | Padding (3 bits?) | Link? (1 bit) |
1321 Channel Identifier (8 bits) | ...
1324 /* Indicate that this is a reassembled PDU */
1325 pseudo_header->dct2000.inner_pseudo_header.atm.flags = 0x00;
1327 /* Channel 0 is DTE->DCE, 1 is DCE->DTE. Always set 0 for now.
1328 TODO: Can we infer the correct value here?
1329 Meanwhile, just use the direction to make them distinguishable...
1331 pseudo_header->dct2000.inner_pseudo_header.atm.channel = (direction == received);
1333 /* Assume always AAL2 for FP */
1334 pseudo_header->dct2000.inner_pseudo_header.atm.aal = AAL_2;
1336 pseudo_header->dct2000.inner_pseudo_header.atm.type = TRAF_UMTS_FP;
1337 pseudo_header->dct2000.inner_pseudo_header.atm.subtype = TRAF_ST_UNKNOWN;
1339 /* vpi is 8 bits (2nd & 3rd nibble) */
1340 pseudo_header->dct2000.inner_pseudo_header.atm.vpi =
1341 ((hex_from_char(aal_header_chars[1]) << 4) |
1342 hex_from_char(aal_header_chars[2]));
1344 /* vci is next 16 bits */
1345 pseudo_header->dct2000.inner_pseudo_header.atm.vci =
1346 ((hex_from_char(aal_header_chars[3]) << 12) |
1347 (hex_from_char(aal_header_chars[4]) << 8) |
1348 (hex_from_char(aal_header_chars[5]) << 4) |
1349 hex_from_char(aal_header_chars[6]));
1351 /* 0 means we don't know how many cells the frame comprises. */
1352 pseudo_header->dct2000.inner_pseudo_header.atm.cells = 0;
1354 /* cid is usually last byte. Unless last char is not hex digit, in which
1355 case cid is derived from last char in ascii */
1356 if (isalnum((guchar)aal_header_chars[11]))
1358 pseudo_header->dct2000.inner_pseudo_header.atm.aal2_cid =
1359 ((hex_from_char(aal_header_chars[10]) << 4) |
1360 hex_from_char(aal_header_chars[11]));
1364 pseudo_header->dct2000.inner_pseudo_header.atm.aal2_cid =
1365 (int)aal_header_chars[11] - 48;
1371 /**********************************************/
1372 /* Fill in isdn pseudo-header with known info */
1373 /**********************************************/
1374 void set_isdn_info(union wtap_pseudo_header *pseudo_header,
1375 packet_direction_t direction)
1377 /* This field is used to set the 'Source' and 'Destination' columns to
1378 'User' or 'Network'. If we assume that we're simulating the network,
1379 treat Received messages as being destined for the network.
1381 pseudo_header->dct2000.inner_pseudo_header.isdn.uton = (direction == received);
1383 /* This corresponds to the circuit ID. 0 is treated as LAPD,
1384 everything else would be treated as a B-channel
1386 pseudo_header->dct2000.inner_pseudo_header.isdn.channel = 0;
1390 /*********************************************/
1391 /* Fill in ppp pseudo-header with known info */
1392 /*********************************************/
1393 static void set_ppp_info(union wtap_pseudo_header *pseudo_header,
1394 packet_direction_t direction)
1396 /* Set direction. */
1397 pseudo_header->dct2000.inner_pseudo_header.p2p.sent = (direction == sent);
1401 /********************************************************/
1402 /* Return hex nibble equivalent of hex string character */
1403 /********************************************************/
1404 guchar hex_from_char(gchar c)
1406 if ((c >= '0') && (c <= '9'))
1411 if ((c >= 'a') && (c <= 'f'))
1413 return 0x0a + (c - 'a');
1416 /* Not a valid hex string character */
1421 /********************************************************/
1422 /* Return character corresponding to hex nibble value */
1423 /********************************************************/
1424 gchar char_from_hex(guchar hex)
1426 static char hex_lookup[16] =
1427 { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
1434 return hex_lookup[hex];
1437 /***************************************************/
1438 /* Equality function for file_externals hash table */
1439 /***************************************************/
1440 gint wth_equal(gconstpointer v, gconstpointer v2)
1445 /***********************************************/
1446 /* Hash function for file_externals hash table */
1447 /***********************************************/
1448 guint wth_hash_func(gconstpointer v)
1450 return (guint)(unsigned long)v;
1454 /***********************************************/
1455 /* Equality test for packet prefix hash tables */
1456 /***********************************************/
1457 gint packet_offset_equal(gconstpointer v, gconstpointer v2)
1459 /* Dereferenced pointers must have same gint64 offset value */
1460 return (*(const gint64*)v == *(const gint64*)v2);
1464 /********************************************/
1465 /* Hash function for packet-prefix hash table */
1466 /********************************************/
1467 guint packet_offset_hash_func(gconstpointer v)
1469 /* Use low-order bits of git64 offset value */
1470 return (guint)(*(const gint64*)v);
1474 /************************************************************************/
1475 /* Parse year, month, day, hour, minute, seconds out of formatted line. */
1476 /* Set secs and usecs as output */
1477 /* Return FALSE if no valid time can be read */
1478 /************************************************************************/
1479 gboolean get_file_time_stamp(time_t *secs, guint32 *usecs)
1483 #define MAX_MONTH_LETTERS 9
1484 char month[MAX_MONTH_LETTERS+1];
1486 int day, year, hour, minute, second;
1489 /* If line longer than expected, file is probably not correctly formatted */
1490 if (strlen(linebuff) > MAX_TIMESTAMP_LINE_LENGTH)
1495 /**************************************************************/
1496 /* First is month. Read until get a space following the month */
1497 for (n=0; (linebuff[n] != ' ') && (n < MAX_MONTH_LETTERS); n++)
1499 month[n] = linebuff[n];
1503 if (strcmp(month, "January" ) == 0) tm.tm_mon = 0;
1504 else if (strcmp(month, "February" ) == 0) tm.tm_mon = 1;
1505 else if (strcmp(month, "March" ) == 0) tm.tm_mon = 2;
1506 else if (strcmp(month, "April" ) == 0) tm.tm_mon = 3;
1507 else if (strcmp(month, "May" ) == 0) tm.tm_mon = 4;
1508 else if (strcmp(month, "June" ) == 0) tm.tm_mon = 5;
1509 else if (strcmp(month, "July" ) == 0) tm.tm_mon = 6;
1510 else if (strcmp(month, "August" ) == 0) tm.tm_mon = 7;
1511 else if (strcmp(month, "September") == 0) tm.tm_mon = 8;
1512 else if (strcmp(month, "October" ) == 0) tm.tm_mon = 9;
1513 else if (strcmp(month, "November" ) == 0) tm.tm_mon = 10;
1514 else if (strcmp(month, "December" ) == 0) tm.tm_mon = 11;
1517 /* Give up if not found a properly-formatted date */
1520 /* Skip space char */
1523 /********************************************************/
1524 /* Scan for remaining numerical fields */
1525 scan_found = sscanf(linebuff+n, "%d, %d %d:%d:%d.%u",
1526 &day, &year, &hour, &minute, &second, usecs);
1527 if (scan_found != 6)
1529 /* Give up if not all found */
1533 /******************************************************/
1534 /* Fill in remaining fields and return it in a time_t */
1535 tm.tm_year = year - 1900;
1540 tm.tm_isdst = -1; /* daylight saving time info not known */
1542 /* Get seconds from this time */
1543 *secs = mktime(&tm);
1545 /* Multiply 4 digits given to get micro-seconds */
1546 *usecs = *usecs * 100;
1551 /* Free the data allocated inside a line_prefix_info_t */
1552 gboolean free_line_prefix_info(gpointer key, gpointer value,
1553 gpointer user_data _U_)
1555 line_prefix_info_t *info = (line_prefix_info_t*)value;
1557 /* Free the 64-bit key value */
1560 /* Free the strings inside */
1561 g_free(info->before_time);
1562 if (info->after_time)
1564 g_free(info->after_time);
1567 /* And the structure itself */
1570 /* Item will always be removed from table */