text2pcap.c

   1 /**-*-C-*-**********************************************************************
   2  *
   3  * text2pcap.c
   4  *
   5  * Utility to convert an ASCII hexdump into a libpcap-format capture file
   6  *
   7  * (c) Copyright 2001 Ashok Narayanan <ashokn@cisco.com>
   8  *
   9  * $Id: text2pcap.c,v 1.14 2002/01/30 10:19:43 guy Exp $
  10  *
  11  * Ethereal - Network traffic analyzer
  12  * By Gerald Combs <gerald@ethereal.com>
  13  * Copyright 1998 Gerald Combs
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  28  *
  29  *******************************************************************************/
  30
  31 /*******************************************************************************
  32  *
  33  * This utility reads in an ASCII hexdump of this common format:
  34  *
  35  * 00000000  00 E0 1E A7 05 6F 00 10 5A A0 B9 12 08 00 46 00 .....o..Z.....F.
  36  * 00000010  03 68 00 00 00 00 0A 2E EE 33 0F 19 08 7F 0F 19 .h.......3...\7f..
  37  * 00000020  03 80 94 04 00 00 10 01 16 A2 0A 00 03 50 00 0C .............P..
  38  * 00000030  01 01 0F 19 03 80 11 01 1E 61 00 0C 03 01 0F 19 .........a......
  39  *
  40  * Each bytestring line consists of an offset, one or more bytes, and
  41  * text at the end. An offset is defined as a hex string of more than
  42  * two characters. A byte is defined as a hex string of exactly two
  43  * characters. The text at the end is ignored, as is any text before
  44  * the offset. Bytes read from a bytestring line are added to the
  45  * current packet only if all the following conditions are satisfied:
  46  *
  47  * - No text appears between the offset and the bytes (any bytes appearing after
  48  *   such text would be ignored)
  49  *
  50  * - The offset must be arithmetically correct, i.e. if the offset is 00000020, then
  51  *   exactly 32 bytes must have been read into this packet before this. If the offset
  52  *   is wrong, the packet is immediately terminated
  53  *
  54  * A packet start is signalled by a zero offset.
  55  *
  56  * Lines starting with #TEXT2PCAP are directives. These allow the user
  57  * to embed instructions into the capture file which allows text2pcap
  58  * to take some actions (e.g. specifying the encapsulation
  59  * etc.). Currently no directives are implemented.
  60  *
  61  * Lines beginning with # which are not directives are ignored as
  62  * comments. Currently all non-hexdump text is ignored by text2pcap;
  63  * in the future, text processing may be added, but lines prefixed
  64  * with '#' will still be ignored.
  65  *
  66  * The output is a libpcap packet containing Ethernet frames by
  67  * default. This program takes options which allow the user to add
  68  * dummy Ethernet, IP and UDP headers to the packets in order to allow
  69  * dumps of L3 or higher protocols to be decoded.
  70  *
  71  * Considerable flexibility is built into this code to read hexdumps
  72  * of slightly different formats. For example, any text prefixing the
  73  * hexdump line is dropped (including mail forwarding '>'). The offset
  74  * can be any hex number of four digits or greater.
  75  *
  76  * This converter cannot read a single packet greater than 64K. Packet
  77  * snaplength is automatically set to 64K.
  78  */
  79
  80 #ifdef HAVE_CONFIG_H
  81 # include "config.h"
  82 #endif
  83
  84 #include <ctype.h>
  85 #include <stdio.h>
  86 #include <stdlib.h>
  87 #include <string.h>
  88
  89 /*
  90  * Just make sure we include the prototype for strptime as well
  91  * (needed for glibc 2.2)
  92  */
  93 #define __USE_XOPEN
  94
  95 #include <time.h>
  96
  97 #include <sys/types.h>
  98 #ifdef HAVE_UNISTD_H
  99 # include <unistd.h>
 100 #endif
 101 #ifdef HAVE_NETINET_IN_H
 102 # include <netinet/in.h>
 103 #endif
 104 #ifdef HAVE_WINSOCK_H
 105 # include <winsock.h>
 106 #endif
 107 #include <errno.h>
 108 #include <assert.h>
 109
 110 #ifdef NEED_GETOPT_H
 111 # include "getopt.h"
 112 #endif
 113
 114 #ifdef NEED_STRPTIME_H
 115 # include "strptime.h"
 116 #endif
 117
 118 #ifndef TRUE
 119 #define TRUE 1
 120 #endif
 121
 122 #ifndef FALSE
 123 #define FALSE 0
 124 #endif
 125
 126 #include "text2pcap.h"
 127
 128 /*--- Options --------------------------------------------------------------------*/
 129
 130 /* Debug level */
 131 int debug = 0;
 132 /* Be quiet */
 133 int quiet = FALSE;
 134
 135 /* Dummy Ethernet header */
 136 int hdr_ethernet = FALSE;
 137 unsigned long hdr_ethernet_proto = 0;
 138
 139 /* Dummy IP header */
 140 int hdr_ip = FALSE;
 141 unsigned long hdr_ip_proto = 0;
 142
 143 /* Dummy UDP header */
 144 int hdr_udp = FALSE;
 145 unsigned long hdr_udp_dest = 0;
 146 unsigned long hdr_udp_src = 0;
 147
 148 /* Dummy SCTP header */
 149 int hdr_sctp = FALSE;
 150 unsigned long hdr_sctp_src  = 0;
 151 unsigned long hdr_sctp_dest = 0;
 152 unsigned long hdr_sctp_tag  = 0;
 153
 154 /* Dummy DATA chunk header */
 155 int hdr_data_chunk = FALSE;
 156 unsigned char  hdr_data_chunk_type = 0;
 157 unsigned char  hdr_data_chunk_bits = 3;
 158 unsigned long  hdr_data_chunk_tsn  = 0;
 159 unsigned short hdr_data_chunk_sid  = 0;
 160 unsigned short hdr_data_chunk_ssn  = 0;
 161 unsigned long  hdr_data_chunk_ppid = 0;
 162
 163
 164 /*--- Local date -----------------------------------------------------------------*/
 165
 166 /* This is where we store the packet currently being built */
 167 #define MAX_PACKET 64000
 168 unsigned char packet_buf[MAX_PACKET];
 169 unsigned long curr_offset = 0;
 170
 171 /* This buffer contains strings present before the packet offset 0 */
 172 #define PACKET_PREAMBLE_MAX_LEN 2048
 173 static unsigned char packet_preamble[PACKET_PREAMBLE_MAX_LEN+1];
 174 static int packet_preamble_len = 0;
 175
 176 /* Number of packets read and written */
 177 unsigned long num_packets_read = 0;
 178 unsigned long num_packets_written = 0;
 179
 180 /* Time code of packet, derived from packet_preamble */
 181 static unsigned long ts_sec  = 0;
 182 static unsigned long ts_usec = 0;
 183 static char *ts_fmt = NULL;
 184
 185 /* Input file */
 186 char *input_filename;
 187 FILE *input_file = NULL;
 188 /* Output file */
 189 char *output_filename;
 190 FILE *output_file = NULL;
 191
 192 /* Offset base to parse */
 193 unsigned long offset_base = 16;
 194
 195 FILE *yyin;
 196
 197 /* ----- State machine -----------------------------------------------------------*/
 198
 199 /* Current state of parser */
 200 typedef enum {
 201     INIT,             /* Waiting for start of new packet */
 202     START_OF_LINE,    /* Starting from beginning of line */
 203     READ_OFFSET,      /* Just read the offset */
 204     READ_BYTE,        /* Just read a byte */
 205     READ_TEXT,        /* Just read text - ignore until EOL */
 206 } parser_state_t;
 207 parser_state_t state = INIT;
 208
 209 const char *state_str[] = {"Init",
 210                            "Start-of-line",
 211                            "Offset",
 212                            "Byte",
 213                            "Text"
 214 };
 215
 216 const char *token_str[] = {"",
 217                            "Byte",
 218                            "Offset",
 219                            "Directive",
 220                            "Text",
 221                            "End-of-line"
 222 };
 223
 224 /* ----- Skeleton Packet Headers --------------------------------------------------*/
 225
 226 typedef struct {
 227     unsigned char   src_addr[6];
 228     unsigned char   dest_addr[6];
 229     unsigned short l3pid;
 230 } hdr_ethernet_t;
 231
 232 hdr_ethernet_t HDR_ETHERNET = {
 233     {0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
 234     {0x02, 0x02, 0x02, 0x02, 0x02, 0x02},
 235     0};
 236
 237 typedef struct {
 238     unsigned char   ver_hdrlen;
 239     unsigned char   dscp;
 240     unsigned short packet_length;
 241     unsigned short identification;
 242     unsigned char   flags;
 243     unsigned char   fragment;
 244     unsigned char   ttl;
 245     unsigned char   protocol;
 246     unsigned short hdr_checksum;
 247     unsigned long src_addr;
 248     unsigned long dest_addr;
 249 } hdr_ip_t;
 250
 251 hdr_ip_t HDR_IP = {0x45, 0, 0, 0x3412, 0, 0, 0xff, 0, 0, 0x01010101, 0x02020202};
 252
 253 typedef struct {
 254     unsigned short source_port;
 255     unsigned short dest_port;
 256     unsigned short length;
 257     unsigned short checksum;
 258 } hdr_udp_t;
 259
 260 hdr_udp_t HDR_UDP = {0, 0, 0, 0};
 261
 262 typedef struct {
 263     unsigned short src_port;
 264     unsigned short dest_port;
 265     unsigned long  tag;
 266     unsigned long  checksum;
 267 } hdr_sctp_t;
 268
 269 hdr_sctp_t HDR_SCTP = {0, 0, 0, 0};
 270
 271 typedef struct {
 272     unsigned char  type;
 273     unsigned char  bits;
 274     unsigned short length;
 275     unsigned long  tsn;
 276     unsigned short sid;
 277     unsigned short ssn;
 278     unsigned long  ppid;
 279 } hdr_data_chunk_t;
 280
 281 hdr_data_chunk_t HDR_DATA_CHUNK = {0, 0, 0, 0, 0, 0, 0};
 282
 283 char tempbuf[64];
 284
 285 /*----------------------------------------------------------------------
 286  * Stuff for writing a PCap file
 287  */
 288 #define PCAP_MAGIC                      0xa1b2c3d4
 289
 290 /* "libpcap" file header (minus magic number). */
 291 struct pcap_hdr {
 292     unsigned long    magic;          /* magic */
 293     unsigned short      version_major;  /* major version number */
 294     unsigned short      version_minor;  /* minor version number */
 295     unsigned long       thiszone;       /* GMT to local correction */
 296     unsigned long       sigfigs;        /* accuracy of timestamps */
 297     unsigned long       snaplen;        /* max length of captured packets, in octets */
 298     unsigned long       network;        /* data link type */
 299 };
 300
 301 /* "libpcap" record header. */
 302 struct pcaprec_hdr {
 303     unsigned long       ts_sec;         /* timestamp seconds */
 304     unsigned long       ts_usec;        /* timestamp microseconds */
 305     unsigned long       incl_len;       /* number of octets of packet saved in file */
 306     unsigned long       orig_len;       /* actual length of packet */
 307 };
 308
 309 /* Link-layer type; see net/bpf.h for details */
 310 unsigned long pcap_link_type = 1;   /* Default is DLT-EN10MB */
 311
 312 /*----------------------------------------------------------------------
 313  * Parse a single hex number
 314  * Will abort the program if it can't parse the number
 315  * Pass in TRUE if this is an offset, FALSE if not
 316  */
 317 static unsigned long
 318 parse_num (char *str, int offset)
 319 {
 320     unsigned long num;
 321     char *c;
 322
 323     num = strtoul(str, &c, offset ? offset_base : 16);
 324     if (c==str) {
 325         fprintf(stderr, "FATAL ERROR: Bad hex number? [%s]\n", str);
 326         exit(-1);
 327     }
 328     return num;
 329 }
 330
 331 /*----------------------------------------------------------------------
 332  * Write this byte into current packet
 333  */
 334 static void
 335 write_byte (char *str)
 336 {
 337     unsigned long num;
 338
 339     num = parse_num(str, FALSE);
 340     packet_buf[curr_offset] = num;
 341     curr_offset ++;
 342 }
 343
 344 /*----------------------------------------------------------------------
 345  * Remove bytes from the current packet
 346  */
 347 static void
 348 unwrite_bytes (unsigned long nbytes)
 349 {
 350     curr_offset -= nbytes;
 351 }
 352
 353 /*----------------------------------------------------------------------
 354  * Compute one's complement checksum (from RFC1071)
 355  */
 356 static unsigned short
 357 in_checksum (void *buf, unsigned long count)
 358 {
 359     unsigned long sum = 0;
 360     unsigned short *addr = buf;
 361
 362     while( count > 1 )  {
 363         /*  This is the inner loop */
 364         sum += ntohs(* (unsigned short *) addr++);
 365         count -= 2;
 366     }
 367
 368     /*  Add left-over byte, if any */
 369     if( count > 0 )
 370         sum += * (unsigned char *) addr;
 371
 372     /*  Fold 32-bit sum to 16 bits */
 373     while (sum>>16)
 374         sum = (sum & 0xffff) + (sum >> 16);
 375
 376     return htons(~sum);
 377 }
 378
 379 /* The CRC32C code is taken from draft-ietf-tsvwg-sctpcsum-01.txt.
 380  * That code is copyrighted by D. Otis and has been modified.
 381  */
 382
 383 #define CRC32C(c,d) (c=(c>>8)^crc_c[(c^(d))&0xFF])
 384 static unsigned long crc_c[256] =
 385 {
 386 0x00000000L, 0xF26B8303L, 0xE13B70F7L, 0x1350F3F4L,
 387 0xC79A971FL, 0x35F1141CL, 0x26A1E7E8L, 0xD4CA64EBL,
 388 0x8AD958CFL, 0x78B2DBCCL, 0x6BE22838L, 0x9989AB3BL,
 389 0x4D43CFD0L, 0xBF284CD3L, 0xAC78BF27L, 0x5E133C24L,
 390 0x105EC76FL, 0xE235446CL, 0xF165B798L, 0x030E349BL,
 391 0xD7C45070L, 0x25AFD373L, 0x36FF2087L, 0xC494A384L,
 392 0x9A879FA0L, 0x68EC1CA3L, 0x7BBCEF57L, 0x89D76C54L,
 393 0x5D1D08BFL, 0xAF768BBCL, 0xBC267848L, 0x4E4DFB4BL,
 394 0x20BD8EDEL, 0xD2D60DDDL, 0xC186FE29L, 0x33ED7D2AL,
 395 0xE72719C1L, 0x154C9AC2L, 0x061C6936L, 0xF477EA35L,
 396 0xAA64D611L, 0x580F5512L, 0x4B5FA6E6L, 0xB93425E5L,
 397 0x6DFE410EL, 0x9F95C20DL, 0x8CC531F9L, 0x7EAEB2FAL,
 398 0x30E349B1L, 0xC288CAB2L, 0xD1D83946L, 0x23B3BA45L,
 399 0xF779DEAEL, 0x05125DADL, 0x1642AE59L, 0xE4292D5AL,
 400 0xBA3A117EL, 0x4851927DL, 0x5B016189L, 0xA96AE28AL,
 401 0x7DA08661L, 0x8FCB0562L, 0x9C9BF696L, 0x6EF07595L,
 402 0x417B1DBCL, 0xB3109EBFL, 0xA0406D4BL, 0x522BEE48L,
 403 0x86E18AA3L, 0x748A09A0L, 0x67DAFA54L, 0x95B17957L,
 404 0xCBA24573L, 0x39C9C670L, 0x2A993584L, 0xD8F2B687L,
 405 0x0C38D26CL, 0xFE53516FL, 0xED03A29BL, 0x1F682198L,
 406 0x5125DAD3L, 0xA34E59D0L, 0xB01EAA24L, 0x42752927L,
 407 0x96BF4DCCL, 0x64D4CECFL, 0x77843D3BL, 0x85EFBE38L,
 408 0xDBFC821CL, 0x2997011FL, 0x3AC7F2EBL, 0xC8AC71E8L,
 409 0x1C661503L, 0xEE0D9600L, 0xFD5D65F4L, 0x0F36E6F7L,
 410 0x61C69362L, 0x93AD1061L, 0x80FDE395L, 0x72966096L,
 411 0xA65C047DL, 0x5437877EL, 0x4767748AL, 0xB50CF789L,
 412 0xEB1FCBADL, 0x197448AEL, 0x0A24BB5AL, 0xF84F3859L,
 413 0x2C855CB2L, 0xDEEEDFB1L, 0xCDBE2C45L, 0x3FD5AF46L,
 414 0x7198540DL, 0x83F3D70EL, 0x90A324FAL, 0x62C8A7F9L,
 415 0xB602C312L, 0x44694011L, 0x5739B3E5L, 0xA55230E6L,
 416 0xFB410CC2L, 0x092A8FC1L, 0x1A7A7C35L, 0xE811FF36L,
 417 0x3CDB9BDDL, 0xCEB018DEL, 0xDDE0EB2AL, 0x2F8B6829L,
 418 0x82F63B78L, 0x709DB87BL, 0x63CD4B8FL, 0x91A6C88CL,
 419 0x456CAC67L, 0xB7072F64L, 0xA457DC90L, 0x563C5F93L,
 420 0x082F63B7L, 0xFA44E0B4L, 0xE9141340L, 0x1B7F9043L,
 421 0xCFB5F4A8L, 0x3DDE77ABL, 0x2E8E845FL, 0xDCE5075CL,
 422 0x92A8FC17L, 0x60C37F14L, 0x73938CE0L, 0x81F80FE3L,
 423 0x55326B08L, 0xA759E80BL, 0xB4091BFFL, 0x466298FCL,
 424 0x1871A4D8L, 0xEA1A27DBL, 0xF94AD42FL, 0x0B21572CL,
 425 0xDFEB33C7L, 0x2D80B0C4L, 0x3ED04330L, 0xCCBBC033L,
 426 0xA24BB5A6L, 0x502036A5L, 0x4370C551L, 0xB11B4652L,
 427 0x65D122B9L, 0x97BAA1BAL, 0x84EA524EL, 0x7681D14DL,
 428 0x2892ED69L, 0xDAF96E6AL, 0xC9A99D9EL, 0x3BC21E9DL,
 429 0xEF087A76L, 0x1D63F975L, 0x0E330A81L, 0xFC588982L,
 430 0xB21572C9L, 0x407EF1CAL, 0x532E023EL, 0xA145813DL,
 431 0x758FE5D6L, 0x87E466D5L, 0x94B49521L, 0x66DF1622L,
 432 0x38CC2A06L, 0xCAA7A905L, 0xD9F75AF1L, 0x2B9CD9F2L,
 433 0xFF56BD19L, 0x0D3D3E1AL, 0x1E6DCDEEL, 0xEC064EEDL,
 434 0xC38D26C4L, 0x31E6A5C7L, 0x22B65633L, 0xD0DDD530L,
 435 0x0417B1DBL, 0xF67C32D8L, 0xE52CC12CL, 0x1747422FL,
 436 0x49547E0BL, 0xBB3FFD08L, 0xA86F0EFCL, 0x5A048DFFL,
 437 0x8ECEE914L, 0x7CA56A17L, 0x6FF599E3L, 0x9D9E1AE0L,
 438 0xD3D3E1ABL, 0x21B862A8L, 0x32E8915CL, 0xC083125FL,
 439 0x144976B4L, 0xE622F5B7L, 0xF5720643L, 0x07198540L,
 440 0x590AB964L, 0xAB613A67L, 0xB831C993L, 0x4A5A4A90L,
 441 0x9E902E7BL, 0x6CFBAD78L, 0x7FAB5E8CL, 0x8DC0DD8FL,
 442 0xE330A81AL, 0x115B2B19L, 0x020BD8EDL, 0xF0605BEEL,
 443 0x24AA3F05L, 0xD6C1BC06L, 0xC5914FF2L, 0x37FACCF1L,
 444 0x69E9F0D5L, 0x9B8273D6L, 0x88D28022L, 0x7AB90321L,
 445 0xAE7367CAL, 0x5C18E4C9L, 0x4F48173DL, 0xBD23943EL,
 446 0xF36E6F75L, 0x0105EC76L, 0x12551F82L, 0xE03E9C81L,
 447 0x34F4F86AL, 0xC69F7B69L, 0xD5CF889DL, 0x27A40B9EL,
 448 0x79B737BAL, 0x8BDCB4B9L, 0x988C474DL, 0x6AE7C44EL,
 449 0xBE2DA0A5L, 0x4C4623A6L, 0x5F16D052L, 0xAD7D5351L,
 450 };
 451
 452 static unsigned int
 453 crc32c(const unsigned char* buf, unsigned int len, unsigned long crc32_init)
 454 {
 455   unsigned int i;
 456   unsigned long crc32;
 457
 458   crc32 = crc32_init;
 459   for (i = 0; i < len; i++)
 460     CRC32C(crc32, buf[i]);
 461   return crc32;
 462 }
 463
 464 static unsigned long
 465 number_of_padding_bytes (unsigned long length)
 466 {
 467   unsigned long remainder;
 468
 469   remainder = length % 4;
 470
 471   if (remainder == 0)
 472     return 0;
 473   else
 474     return 4 - remainder;
 475 }
 476
 477 /*----------------------------------------------------------------------
 478  * Write current packet out
 479  */
 480 static void
 481 write_current_packet (void)
 482 {
 483     int length = 0;
 484     int udp_length = 0;
 485     int ip_length = 0;
 486     int eth_trailer_length = 0;
 487     int i, padding_length;
 488     struct pcaprec_hdr ph;
 489
 490     if (curr_offset > 0) {
 491         /* Write the packet */
 492
 493         /* Compute packet length */
 494         length = curr_offset;
 495         if (hdr_data_chunk) { length += sizeof(HDR_DATA_CHUNK) + number_of_padding_bytes(curr_offset); }
 496         if (hdr_sctp) { length += sizeof(HDR_SCTP); }
 497         if (hdr_udp) { length += sizeof(HDR_UDP); udp_length = length; }
 498         if (hdr_ip) { length += sizeof(HDR_IP); ip_length = length; }
 499         if (hdr_ethernet) {
 500             length += sizeof(HDR_ETHERNET);
 501             /* Pad trailer */
 502             if (length < 60) {
 503                 eth_trailer_length = 60 - length;
 504                 length = 60;
 505             }
 506         }
 507
 508         /* Write PCap header */
 509         ph.ts_sec = ts_sec;
 510         ph.ts_usec = ts_usec;
 511         ph.incl_len = length;
 512         ph.orig_len = length;
 513         fwrite(&ph, sizeof(ph), 1, output_file);
 514
 515         /* Write Ethernet header */
 516         if (hdr_ethernet) {
 517             HDR_ETHERNET.l3pid = htons(hdr_ethernet_proto);
 518             fwrite(&HDR_ETHERNET, sizeof(HDR_ETHERNET), 1, output_file);
 519         }
 520
 521         /* Write IP header */
 522         if (hdr_ip) {
 523             HDR_IP.packet_length = htons(ip_length);
 524             HDR_IP.protocol = hdr_ip_proto;
 525             HDR_IP.hdr_checksum = 0;
 526             HDR_IP.hdr_checksum = in_checksum(&HDR_IP, sizeof(HDR_IP));
 527             fwrite(&HDR_IP, sizeof(HDR_IP), 1, output_file);
 528         }
 529
 530         /* Write UDP header */
 531         if (hdr_udp) {
 532             HDR_UDP.source_port = htons(hdr_udp_src);
 533             HDR_UDP.dest_port = htons(hdr_udp_dest);
 534             HDR_UDP.length = htons(udp_length);
 535
 536             fwrite(&HDR_UDP, sizeof(HDR_UDP), 1, output_file);
 537         }
 538
 539         /* Compute DATA chunk header and append padding */
 540         if (hdr_data_chunk) {
 541             HDR_DATA_CHUNK.type   = hdr_data_chunk_type;
 542             HDR_DATA_CHUNK.bits   = hdr_data_chunk_bits;
 543             HDR_DATA_CHUNK.length = htons(curr_offset + sizeof(HDR_DATA_CHUNK));
 544             HDR_DATA_CHUNK.tsn    = htonl(hdr_data_chunk_tsn);
 545             HDR_DATA_CHUNK.sid    = htons(hdr_data_chunk_sid);
 546             HDR_DATA_CHUNK.ssn    = htons(hdr_data_chunk_ssn);
 547             HDR_DATA_CHUNK.ppid   = htonl(hdr_data_chunk_ppid);
 548
 549             padding_length = number_of_padding_bytes(curr_offset);
 550             for (i=0; i<padding_length; i++)
 551               write_byte("0");
 552         }
 553
 554         /* Write SCTP header */
 555         if (hdr_sctp) {
 556             HDR_SCTP.src_port  = htons(hdr_sctp_src);
 557             HDR_SCTP.dest_port = htons(hdr_sctp_dest);
 558             HDR_SCTP.tag       = htonl(hdr_sctp_tag);
 559             HDR_SCTP.checksum  = htonl(0);
 560             HDR_SCTP.checksum  = crc32c((unsigned char *)&HDR_SCTP, sizeof(HDR_SCTP), ~0L);
 561             if (hdr_data_chunk)
 562               HDR_SCTP.checksum  = crc32c((unsigned char *)&HDR_DATA_CHUNK, sizeof(HDR_DATA_CHUNK), HDR_SCTP.checksum);
 563             HDR_SCTP.checksum  = htonl(crc32c(packet_buf, curr_offset, HDR_SCTP.checksum));
 564
 565             fwrite(&HDR_SCTP, sizeof(HDR_SCTP), 1, output_file);
 566         }
 567
 568         /* Write DATA chunk header */
 569         if (hdr_data_chunk) {
 570             fwrite(&HDR_DATA_CHUNK, sizeof(HDR_DATA_CHUNK), 1, output_file);
 571         }
 572         /* Write packet */
 573         fwrite(packet_buf, curr_offset, 1, output_file);
 574
 575         /* Write Ethernet trailer */
 576         if (hdr_ethernet && eth_trailer_length > 0) {
 577             memset(tempbuf, 0, eth_trailer_length);
 578             fwrite(tempbuf, eth_trailer_length, 1, output_file);
 579         }
 580
 581         if (!quiet)
 582             fprintf(stderr, "Wrote packet of %lu bytes\n", curr_offset);
 583         num_packets_written ++;
 584     }
 585     curr_offset = 0;
 586 }
 587
 588 /*----------------------------------------------------------------------
 589  * Write the PCap file header
 590  */
 591 static void
 592 write_file_header (void)
 593 {
 594     struct pcap_hdr fh;
 595
 596     fh.magic = PCAP_MAGIC;
 597     fh.version_major = 2;
 598     fh.version_minor = 4;
 599     fh.thiszone = 0;
 600     fh.sigfigs = 0;
 601     fh.snaplen = 102400;
 602     fh.network = pcap_link_type;
 603
 604     fwrite(&fh, sizeof(fh), 1, output_file);
 605 }
 606
 607 /*----------------------------------------------------------------------
 608  * Append a token to the packet preamble.
 609  */
 610 static void
 611 append_to_preamble(char *str)
 612 {
 613     size_t toklen;
 614
 615     if (packet_preamble_len != 0) {
 616         if (packet_preamble_len == PACKET_PREAMBLE_MAX_LEN)
 617             return;     /* no room to add more preamble */
 618         /* Add a blank separator between the previous token and this token. */
 619         packet_preamble[packet_preamble_len++] = ' ';
 620     }
 621     toklen = strlen(str);
 622     if (toklen != 0) {
 623         if (packet_preamble_len + toklen > PACKET_PREAMBLE_MAX_LEN)
 624             return;     /* no room to add the token to the preamble */
 625         strcpy(&packet_preamble[packet_preamble_len], str);
 626         packet_preamble_len += toklen;
 627     }
 628 }
 629
 630 /*----------------------------------------------------------------------
 631  * Parse the preamble to get the timecode.
 632  */
 633 static void
 634 parse_preamble (void)
 635 {
 636         struct tm timecode;
 637         char *subsecs;
 638         char *p;
 639         int  subseclen;
 640         int  i;
 641
 642         /*
 643          * If no "-t" flag was specified, don't attempt to parse a packet
 644          * preamble to extract a time stamp.
 645          */
 646         if (ts_fmt == NULL)
 647             return;
 648
 649         ts_sec  = 0;
 650         ts_usec = 0;
 651
 652         /*
 653          * Null-terminate the preamble.
 654          */
 655         packet_preamble[packet_preamble_len] = '\0';
 656
 657         /* Ensure preamble has more than two chars before atempting to parse.
 658          * This should cover line breaks etc that get counted.
 659          */
 660         if ( strlen(packet_preamble) > 2 ) {
 661                 /*
 662                  * Initialize to the Epoch, just in case not all fields
 663                  * of the date and time are specified.
 664                  */
 665                 timecode.tm_sec = 0;
 666                 timecode.tm_min = 0;
 667                 timecode.tm_hour = 0;
 668                 timecode.tm_mday = 1;
 669                 timecode.tm_mon = 0;
 670                 timecode.tm_year = 70;
 671                 timecode.tm_wday = 0;
 672                 timecode.tm_yday = 0;
 673                 timecode.tm_isdst = -1;
 674
 675                 /* Get Time leaving subseconds */
 676                 subsecs = strptime( packet_preamble, ts_fmt, &timecode );
 677                 if (subsecs != NULL) {
 678                         /* Get the long time from the tm structure */
 679                         ts_sec  = (unsigned long)mktime( &timecode );
 680                 } else
 681                         ts_sec = -1;    /* we failed to parse it */
 682
 683                 /* This will ensure incorrectly parsed dates get set to zero */
 684                 if ( -1L == (long)ts_sec )
 685                 {
 686                         ts_sec  = 0;
 687                         ts_usec = 0;
 688                 }
 689                 else
 690                 {
 691                         /* Parse subseconds */
 692                         ts_usec = strtol(subsecs, &p, 10);
 693                         if (subsecs == p) {
 694                                 /* Error */
 695                                 ts_usec = 0;
 696                         } else {
 697                                 /*
 698                                  * Convert that number to a number
 699                                  * of microseconds; if it's N digits
 700                                  * long, it's in units of 10^(-N) seconds,
 701                                  * so, to convert it to units of
 702                                  * 10^-6 seconds, we multiply by
 703                                  * 10^(6-N).
 704                                  */
 705                                 subseclen = p - subsecs;
 706                                 if (subseclen > 6) {
 707                                         /*
 708                                          * *More* than 6 digits; 6-N is
 709                                          * negative, so we divide by
 710                                          * 10^(N-6).
 711                                          */
 712                                         for (i = subseclen - 6; i != 0; i--)
 713                                                 ts_usec /= 10;
 714                                 } else if (subseclen < 6) {
 715                                         for (i = 6 - subseclen; i != 0; i--)
 716                                                 ts_usec *= 10;
 717                                 }
 718                         }
 719                 }
 720         }
 721
 722
 723         /*printf("Format(%s), time(%u), subsecs(%u)\n\n", ts_fmt, ts_sec, ts_usec);*/
 724
 725         /* Clear Preamble */
 726         packet_preamble_len = 0;
 727 }
 728
 729 /*----------------------------------------------------------------------
 730  * Start a new packet
 731  */
 732 static void
 733 start_new_packet (void)
 734 {
 735     if (debug>=1)
 736         fprintf(stderr, "Start new packet\n");
 737
 738     /* Write out the current packet, if required */
 739     write_current_packet();
 740     curr_offset = 0;
 741     num_packets_read ++;
 742
 743     /* Ensure we parse the packet preamble as it may contain the time */
 744     parse_preamble();
 745 }
 746
 747 /*----------------------------------------------------------------------
 748  * Process a directive
 749  */
 750 static void
 751 process_directive (char *str)
 752 {
 753     fprintf(stderr, "\n--- Directive [%s] currently unsupported ---\n", str+10);
 754
 755 }
 756
 757 /*----------------------------------------------------------------------
 758  * Parse a single token (called from the scanner)
 759  */
 760 void
 761 parse_token (token_t token, char *str)
 762 {
 763     unsigned long num;
 764
 765     /*
 766      * This is implemented as a simple state machine of five states.
 767      * State transitions are caused by tokens being received from the
 768      * scanner. The code should be self_documenting.
 769      */
 770
 771     if (debug>=2) {
 772         /* Sanitize - remove all '\r' */
 773         char *c;
 774         if (str!=NULL) { while ((c = strchr(str, '\r')) != NULL) *c=' '; }
 775
 776         fprintf(stderr, "(%s, %s \"%s\") -> (",
 777                 state_str[state], token_str[token], str ? str : "");
 778     }
 779
 780     switch(state) {
 781
 782     /* ----- Waiting for new packet -------------------------------------------*/
 783     case INIT:
 784         switch(token) {
 785         case T_TEXT:
 786             append_to_preamble(str);
 787             break;
 788         case T_DIRECTIVE:
 789             process_directive(str);
 790             break;
 791         case T_OFFSET:
 792             num = parse_num(str, TRUE);
 793             if (num==0) {
 794                 /* New packet starts here */
 795                 start_new_packet();
 796                 state = READ_OFFSET;
 797             }
 798             break;
 799         default:
 800             break;
 801         }
 802         break;
 803
 804     /* ----- Processing packet, start of new line -----------------------------*/
 805     case START_OF_LINE:
 806         switch(token) {
 807         case T_TEXT:
 808             append_to_preamble(str);
 809             break;
 810         case T_DIRECTIVE:
 811             process_directive(str);
 812             break;
 813         case T_OFFSET:
 814             num = parse_num(str, TRUE);
 815             if (num==0) {
 816                 /* New packet starts here */
 817                 start_new_packet();
 818                 state = READ_OFFSET;
 819             } else if (num != curr_offset) {
 820                 /*
 821                  * The offset we read isn't the one we expected.
 822                  * This may only mean that we mistakenly interpreted
 823                  * some text as byte values (e.g., if the text dump
 824                  * of packet data included a number with spaces around
 825                  * it).  If the offset is less than what we expected,
 826                  * assume that's the problem, and throw away the putative
 827                  * extra byte values.
 828                  */
 829                 if (num < curr_offset) {
 830                     unwrite_bytes(curr_offset - num);
 831                     state = READ_OFFSET;
 832                 } else {
 833                     /* Bad offset; switch to INIT state */
 834                     if (debug>=1)
 835                         fprintf(stderr, "Inconsistent offset. Expecting %0lX, got %0lX. Ignoring rest of packet\n",
 836                                 curr_offset, num);
 837                     write_current_packet();
 838                     state = INIT;
 839                 }
 840             } else
 841                 state = READ_OFFSET;
 842             break;
 843         default:
 844             break;
 845         }
 846         break;
 847
 848     /* ----- Processing packet, read offset -----------------------------------*/
 849     case READ_OFFSET:
 850         switch(token) {
 851         case T_BYTE:
 852             /* Record the byte */
 853             state = READ_BYTE;
 854             write_byte(str);
 855             break;
 856         case T_TEXT:
 857         case T_DIRECTIVE:
 858         case T_OFFSET:
 859             state = READ_TEXT;
 860             break;
 861         case T_EOL:
 862             state = START_OF_LINE;
 863             break;
 864         default:
 865             break;
 866         }
 867         break;
 868
 869     /* ----- Processing packet, read byte -------------------------------------*/
 870     case READ_BYTE:
 871         switch(token) {
 872         case T_BYTE:
 873             /* Record the byte */
 874             write_byte(str);
 875             break;
 876         case T_TEXT:
 877         case T_DIRECTIVE:
 878         case T_OFFSET:
 879             state = READ_TEXT;
 880             break;
 881         case T_EOL:
 882             state = START_OF_LINE;
 883             break;
 884         default:
 885             break;
 886         }
 887         break;
 888
 889     /* ----- Processing packet, read text -------------------------------------*/
 890     case READ_TEXT:
 891         switch(token) {
 892         case T_EOL:
 893             state = START_OF_LINE;
 894             break;
 895         default:
 896             break;
 897         }
 898         break;
 899
 900     default:
 901         fprintf(stderr, "FATAL ERROR: Bad state (%d)", state);
 902         exit(-1);
 903     }
 904
 905     if (debug>=2)
 906         fprintf(stderr, ", %s)\n", state_str[state]);
 907
 908 }
 909
 910 /*----------------------------------------------------------------------
 911  * Print helpstring and exit
 912  */
 913 static void
 914 help (char *progname)
 915 {
 916     fprintf(stderr,
 917             "\n"
 918             "Usage: %s [-d] [-q] [-o h|o] [-l typenum] [-e l3pid] [-i proto] \n"
 919             "          [-u srcp,destp] [-s srcp,destp,tag] [-S srcp,destp,tag] [-t timefmt] <input-filename> <output-filename>\n"
 920             "\n"
 921             "where <input-filename> specifies input filename (use - for standard input)\n"
 922             "      <output-filename> specifies output filename (use - for standard output)\n"
 923             "\n"
 924             "[options] are one or more of the following \n"
 925             "\n"
 926             " -w filename     : Write capfile to <filename>. Default is standard output\n"
 927             " -h              : Display this help message \n"
 928             " -d              : Generate detailed debug of parser states \n"
 929             " -o hex|oct      : Parse offsets as (h)ex or (o)ctal. Default is hex\n"
 930             " -l typenum      : Specify link-layer type number. Default is 1 (Ethernet). \n"
 931             "                   See net/bpf.h for list of numbers.\n"
 932             " -q              : Generate no output at all (automatically turns off -d)\n"
 933             " -e l3pid        : Prepend dummy Ethernet II header with specified L3PID (in HEX)\n"
 934             "                   Example: -e 0x800\n"
 935             " -i proto        : Prepend dummy IP header with specified IP protocol (in DECIMAL). \n"
 936             "                   Automatically prepends Ethernet header as well. Example: -i 46\n"
 937             " -u srcp,destp   : Prepend dummy UDP header with specified dest and source ports (in DECIMAL).\n"
 938             "                   Automatically prepends Ethernet and IP headers as well\n"
 939             "                   Example: -u 30,40\n"
 940             " -s srcp,dstp,tag: Prepend dummy SCTP header with specified dest/source ports and\n"
 941             "                   verification tag (in DECIMAL).\n"
 942             "                   Automatically prepends Ethernet and IP headers as well\n"
 943             "                   Example: -s 30,40,34\n"
 944             " -S srcp,dstp,tag: Same as -s srcp,dstp,tag but also prepends a DATA chunk header.\n"
 945             "                   Example: -S 30,40,34\n"
 946             " -t timefmt      : Treats the text before the packet as a date/time code; the\n"
 947             "                   specified argument is a format string of the sort supported\n"
 948             "                   by strptime.\n"
 949             "                   Example: The time \"10:15:14.5476\" has the format code\n"
 950             "                   \"%%H:%%M:%%S.\"\n"
 951             "                   NOTE:    The subsecond component delimiter must be specified\n"
 952             "                            (.) but no pattern is required; the remaining number\n"
 953             "                            is assumed to be fractions of a second.\n"
 954             "",
 955             progname);
 956
 957     exit(-1);
 958 }
 959
 960 /*----------------------------------------------------------------------
 961  * Parse CLI options
 962  */
 963 static void
 964 parse_options (int argc, char *argv[])
 965 {
 966     int c;
 967     char *p;
 968
 969     /* Scan CLI parameters */
 970     while ((c = getopt(argc, argv, "dqr:w:e:i:l:o:u:s:S:t:")) != -1) {
 971         switch(c) {
 972         case '?': help(argv[0]); break;
 973         case 'h': help(argv[0]); break;
 974         case 'd': if (!quiet) debug++; break;
 975         case 'q': quiet = TRUE; debug = FALSE; break;
 976         case 'l': pcap_link_type = atoi(optarg); break;
 977         case 'o':
 978             if (optarg[0]!='h' && optarg[0] != 'o') {
 979                 fprintf(stderr, "Bad argument for '-e': %s\n", optarg);
 980                 help(argv[0]);
 981             }
 982             offset_base = (optarg[0]=='o') ? 8 : 16;
 983             break;
 984         case 'e':
 985             hdr_ethernet = TRUE;
 986             if (sscanf(optarg, "%lx", &hdr_ethernet_proto) < 1) {
 987                 fprintf(stderr, "Bad argument for '-e': %s\n", optarg);
 988                 help(argv[0]);
 989             }
 990             break;
 991
 992         case 'i':
 993             hdr_ip = TRUE;
 994             if (sscanf(optarg, "%ld", &hdr_ip_proto) < 1) {
 995                 fprintf(stderr, "Bad argument for '-i': %s\n", optarg);
 996                 help(argv[0]);
 997             }
 998             hdr_ethernet = TRUE;
 999             hdr_ethernet_proto = 0x800;
1000             break;
1001
1002         case 'S':
1003             hdr_data_chunk = TRUE;
1004         case 's':
1005             hdr_sctp = TRUE;
1006             hdr_sctp_src = strtol(optarg, &p, 10);
1007             if (p == optarg || (*p != ',' && *p != '\0')) {
1008                 fprintf(stderr, "Bad src port for '-%c'\n", c);
1009                 help(argv[0]);
1010             }
1011             if (*p == '\0') {
1012                 fprintf(stderr, "No dest port specified for '-%c'\n", c);
1013                 help(argv[0]);
1014             }
1015             p++;
1016             optarg = p;
1017             hdr_sctp_dest = strtol(optarg, &p, 10);
1018             if (p == optarg || (*p != ',' && *p != '\0')) {
1019                 fprintf(stderr, "Bad dest port for '-s'\n");
1020                 help(argv[0]);
1021             }            if (*p == '\0') {
1022                 fprintf(stderr, "No dest port specified for '-%c'\n", c);
1023                 help(argv[0]);
1024             }
1025             p++;
1026             optarg = p;
1027             hdr_sctp_tag = strtol(optarg, &p, 10);
1028             if (p == optarg || *p != '\0') {
1029                 fprintf(stderr, "Bad tag for '-%c'\n", c);
1030                 help(argv[0]);
1031             }
1032
1033             hdr_ip = TRUE;
1034             hdr_ip_proto = 132;
1035             hdr_ethernet = TRUE;
1036             hdr_ethernet_proto = 0x800;
1037             break;
1038
1039         case 't':
1040             ts_fmt = optarg;
1041             break;
1042
1043         case 'u':
1044             hdr_udp = TRUE;
1045             hdr_udp_src = strtol(optarg, &p, 10);
1046             if (p == optarg || (*p != ',' && *p != '\0')) {
1047                 fprintf(stderr, "Bad src port for '-u'\n");
1048                 help(argv[0]);
1049             }
1050             if (*p == '\0') {
1051                 fprintf(stderr, "No dest port specified for '-u'\n");
1052                 help(argv[0]);
1053             }
1054             p++;
1055             optarg = p;
1056             hdr_udp_dest = strtol(optarg, &p, 10);
1057             if (p == optarg || *p != '\0') {
1058                 fprintf(stderr, "Bad dest port for '-u'\n");
1059                 help(argv[0]);
1060             }
1061             hdr_ip = TRUE;
1062             hdr_ip_proto = 17;
1063             hdr_ethernet = TRUE;
1064             hdr_ethernet_proto = 0x800;
1065             break;
1066
1067         default:
1068             help(argv[0]);
1069         }
1070     }
1071
1072     if (optind >= argc || argc-optind < 2) {
1073         fprintf(stderr, "Must specify input and output filename\n");
1074         help(argv[0]);
1075     }
1076
1077     if (strcmp(argv[optind], "-")) {
1078         input_filename = strdup(argv[optind]);
1079         input_file = fopen(input_filename, "rb");
1080         if (!input_file) {
1081             fprintf(stderr, "Cannot open file [%s] for reading: %s\n",
1082                     input_filename, strerror(errno));
1083             exit(-1);
1084         }
1085     } else {
1086         input_filename = "Standard input";
1087         input_file = stdin;
1088     }
1089
1090     if (strcmp(argv[optind+1], "-")) {
1091         output_filename = strdup(argv[optind+1]);
1092         output_file = fopen(output_filename, "wb");
1093         if (!output_file) {
1094             fprintf(stderr, "Cannot open file [%s] for writing: %s\n",
1095                     output_filename, strerror(errno));
1096             exit(-1);
1097         }
1098     } else {
1099         output_filename = "Standard output";
1100         output_file = stdout;
1101     }
1102
1103     /* Some validation */
1104     if (pcap_link_type != 1 && hdr_ethernet) {
1105         fprintf(stderr, "Dummy headers (-e, -i, -u, -s, -S) cannot be specified with link type override (-l)\n");
1106         exit(-1);
1107     }
1108
1109     /* Set up our variables */
1110     if (!input_file) {
1111         input_file = stdin;
1112         input_filename = "Standard input";
1113     }
1114     if (!output_file) {
1115         output_file = stdout;
1116         output_filename = "Standard output";
1117     }
1118
1119     /* Display summary of our state */
1120     if (!quiet) {
1121         fprintf(stderr, "Input from: %s\n", input_filename);
1122         fprintf(stderr, "Output to: %s\n", output_filename);
1123
1124         if (hdr_ethernet) fprintf(stderr, "Generate dummy Ethernet header: Protocol: 0x%0lX\n",
1125                                   hdr_ethernet_proto);
1126         if (hdr_ip) fprintf(stderr, "Generate dummy IP header: Protocol: %ld\n",
1127                             hdr_ip_proto);
1128         if (hdr_udp) fprintf(stderr, "Generate dummy UDP header: Source port: %ld. Dest port: %ld\n",
1129                              hdr_udp_src, hdr_udp_dest);
1130         if (hdr_sctp) fprintf(stderr, "Generate dummy SCTP header: Source port: %ld. Dest port: %ld. Tag: %ld\n",
1131                               hdr_sctp_src, hdr_sctp_dest, hdr_sctp_tag);
1132         if (hdr_data_chunk) fprintf(stderr, "Generate dummy DATA chunk header: TSN: %ld. SID: %d. SSN: %d. PPID: %ld\n",
1133                                     hdr_data_chunk_tsn, hdr_data_chunk_sid, hdr_data_chunk_ssn, hdr_data_chunk_ppid);
1134     }
1135 }
1136
1137 int main(int argc, char *argv[])
1138 {
1139     parse_options(argc, argv);
1140
1141     assert(input_file != NULL);
1142     assert(output_file != NULL);
1143
1144     write_file_header();
1145
1146     yyin = input_file;
1147     yylex();
1148
1149     write_current_packet();
1150     if (debug)
1151         fprintf(stderr, "\n-------------------------\n");
1152     if (!quiet) {
1153     fprintf(stderr, "Read %ld potential packets, wrote %ld packets\n",
1154             num_packets_read, num_packets_written);
1155     }
1156     return 0;
1157 }