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.16 2002/04/15 21:53:55 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 long
 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
 462   return ( crc32 );
 463 }
 464
 465 static unsigned long
 466 finalize_crc32c(unsigned long crc32)
 467 {
 468   unsigned long result;
 469   unsigned char byte0,byte1,byte2,byte3;
 470
 471   result = ~crc32;
 472   byte0 = result & 0xff;
 473   byte1 = (result>>8) & 0xff;
 474   byte2 = (result>>16) & 0xff;
 475   byte3 = (result>>24) & 0xff;
 476   result = ((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3);
 477   return ( result );
 478 }
 479
 480 static unsigned long
 481 number_of_padding_bytes (unsigned long length)
 482 {
 483   unsigned long remainder;
 484
 485   remainder = length % 4;
 486
 487   if (remainder == 0)
 488     return 0;
 489   else
 490     return 4 - remainder;
 491 }
 492
 493 /*----------------------------------------------------------------------
 494  * Write current packet out
 495  */
 496 static void
 497 write_current_packet (void)
 498 {
 499     int length = 0;
 500     int udp_length = 0;
 501     int ip_length = 0;
 502     int eth_trailer_length = 0;
 503     int i, padding_length;
 504     struct pcaprec_hdr ph;
 505
 506     if (curr_offset > 0) {
 507         /* Write the packet */
 508
 509         /* Compute packet length */
 510         length = curr_offset;
 511         if (hdr_data_chunk) { length += sizeof(HDR_DATA_CHUNK) + number_of_padding_bytes(curr_offset); }
 512         if (hdr_sctp) { length += sizeof(HDR_SCTP); }
 513         if (hdr_udp) { length += sizeof(HDR_UDP); udp_length = length; }
 514         if (hdr_ip) { length += sizeof(HDR_IP); ip_length = length; }
 515         if (hdr_ethernet) {
 516             length += sizeof(HDR_ETHERNET);
 517             /* Pad trailer */
 518             if (length < 60) {
 519                 eth_trailer_length = 60 - length;
 520                 length = 60;
 521             }
 522         }
 523
 524         /* Write PCap header */
 525         ph.ts_sec = ts_sec;
 526         ph.ts_usec = ts_usec;
 527         ph.incl_len = length;
 528         ph.orig_len = length;
 529         fwrite(&ph, sizeof(ph), 1, output_file);
 530
 531         /* Write Ethernet header */
 532         if (hdr_ethernet) {
 533             HDR_ETHERNET.l3pid = htons(hdr_ethernet_proto);
 534             fwrite(&HDR_ETHERNET, sizeof(HDR_ETHERNET), 1, output_file);
 535         }
 536
 537         /* Write IP header */
 538         if (hdr_ip) {
 539             HDR_IP.packet_length = htons(ip_length);
 540             HDR_IP.protocol = hdr_ip_proto;
 541             HDR_IP.hdr_checksum = 0;
 542             HDR_IP.hdr_checksum = in_checksum(&HDR_IP, sizeof(HDR_IP));
 543             fwrite(&HDR_IP, sizeof(HDR_IP), 1, output_file);
 544         }
 545
 546         /* Write UDP header */
 547         if (hdr_udp) {
 548             HDR_UDP.source_port = htons(hdr_udp_src);
 549             HDR_UDP.dest_port = htons(hdr_udp_dest);
 550             HDR_UDP.length = htons(udp_length);
 551
 552             fwrite(&HDR_UDP, sizeof(HDR_UDP), 1, output_file);
 553         }
 554
 555         /* Compute DATA chunk header and append padding */
 556         if (hdr_data_chunk) {
 557             HDR_DATA_CHUNK.type   = hdr_data_chunk_type;
 558             HDR_DATA_CHUNK.bits   = hdr_data_chunk_bits;
 559             HDR_DATA_CHUNK.length = htons(curr_offset + sizeof(HDR_DATA_CHUNK));
 560             HDR_DATA_CHUNK.tsn    = htonl(hdr_data_chunk_tsn);
 561             HDR_DATA_CHUNK.sid    = htons(hdr_data_chunk_sid);
 562             HDR_DATA_CHUNK.ssn    = htons(hdr_data_chunk_ssn);
 563             HDR_DATA_CHUNK.ppid   = htonl(hdr_data_chunk_ppid);
 564
 565             padding_length = number_of_padding_bytes(curr_offset);
 566             for (i=0; i<padding_length; i++)
 567               write_byte("0");
 568         }
 569
 570         /* Write SCTP header */
 571         if (hdr_sctp) {
 572             HDR_SCTP.src_port  = htons(hdr_sctp_src);
 573             HDR_SCTP.dest_port = htons(hdr_sctp_dest);
 574             HDR_SCTP.tag       = htonl(hdr_sctp_tag);
 575             HDR_SCTP.checksum  = htonl(0);
 576             HDR_SCTP.checksum  = crc32c((unsigned char *)&HDR_SCTP, sizeof(HDR_SCTP), ~0L);
 577             if (hdr_data_chunk)
 578               HDR_SCTP.checksum  = crc32c((unsigned char *)&HDR_DATA_CHUNK, sizeof(HDR_DATA_CHUNK), HDR_SCTP.checksum);
 579             HDR_SCTP.checksum  = htonl(finalize_crc32c(crc32c(packet_buf, curr_offset, HDR_SCTP.checksum)));
 580
 581             fwrite(&HDR_SCTP, sizeof(HDR_SCTP), 1, output_file);
 582         }
 583
 584         /* Write DATA chunk header */
 585         if (hdr_data_chunk) {
 586             fwrite(&HDR_DATA_CHUNK, sizeof(HDR_DATA_CHUNK), 1, output_file);
 587         }
 588         /* Write packet */
 589         fwrite(packet_buf, curr_offset, 1, output_file);
 590
 591         /* Write Ethernet trailer */
 592         if (hdr_ethernet && eth_trailer_length > 0) {
 593             memset(tempbuf, 0, eth_trailer_length);
 594             fwrite(tempbuf, eth_trailer_length, 1, output_file);
 595         }
 596
 597         if (!quiet)
 598             fprintf(stderr, "Wrote packet of %lu bytes\n", curr_offset);
 599         num_packets_written ++;
 600     }
 601     curr_offset = 0;
 602 }
 603
 604 /*----------------------------------------------------------------------
 605  * Write the PCap file header
 606  */
 607 static void
 608 write_file_header (void)
 609 {
 610     struct pcap_hdr fh;
 611
 612     fh.magic = PCAP_MAGIC;
 613     fh.version_major = 2;
 614     fh.version_minor = 4;
 615     fh.thiszone = 0;
 616     fh.sigfigs = 0;
 617     fh.snaplen = 102400;
 618     fh.network = pcap_link_type;
 619
 620     fwrite(&fh, sizeof(fh), 1, output_file);
 621 }
 622
 623 /*----------------------------------------------------------------------
 624  * Append a token to the packet preamble.
 625  */
 626 static void
 627 append_to_preamble(char *str)
 628 {
 629     size_t toklen;
 630
 631     if (packet_preamble_len != 0) {
 632         if (packet_preamble_len == PACKET_PREAMBLE_MAX_LEN)
 633             return;     /* no room to add more preamble */
 634         /* Add a blank separator between the previous token and this token. */
 635         packet_preamble[packet_preamble_len++] = ' ';
 636     }
 637     toklen = strlen(str);
 638     if (toklen != 0) {
 639         if (packet_preamble_len + toklen > PACKET_PREAMBLE_MAX_LEN)
 640             return;     /* no room to add the token to the preamble */
 641         strcpy(&packet_preamble[packet_preamble_len], str);
 642         packet_preamble_len += toklen;
 643     }
 644 }
 645
 646 /*----------------------------------------------------------------------
 647  * Parse the preamble to get the timecode.
 648  */
 649 static void
 650 parse_preamble (void)
 651 {
 652         struct tm timecode;
 653         char *subsecs;
 654         char *p;
 655         int  subseclen;
 656         int  i;
 657
 658         /*
 659          * If no "-t" flag was specified, don't attempt to parse a packet
 660          * preamble to extract a time stamp.
 661          */
 662         if (ts_fmt == NULL)
 663             return;
 664
 665         ts_sec  = 0;
 666         ts_usec = 0;
 667
 668         /*
 669          * Null-terminate the preamble.
 670          */
 671         packet_preamble[packet_preamble_len] = '\0';
 672
 673         /* Ensure preamble has more than two chars before atempting to parse.
 674          * This should cover line breaks etc that get counted.
 675          */
 676         if ( strlen(packet_preamble) > 2 ) {
 677                 /*
 678                  * Initialize to the Epoch, just in case not all fields
 679                  * of the date and time are specified.
 680                  */
 681                 timecode.tm_sec = 0;
 682                 timecode.tm_min = 0;
 683                 timecode.tm_hour = 0;
 684                 timecode.tm_mday = 1;
 685                 timecode.tm_mon = 0;
 686                 timecode.tm_year = 70;
 687                 timecode.tm_wday = 0;
 688                 timecode.tm_yday = 0;
 689                 timecode.tm_isdst = -1;
 690
 691                 /* Get Time leaving subseconds */
 692                 subsecs = strptime( packet_preamble, ts_fmt, &timecode );
 693                 if (subsecs != NULL) {
 694                         /* Get the long time from the tm structure */
 695                         ts_sec  = (unsigned long)mktime( &timecode );
 696                 } else
 697                         ts_sec = -1;    /* we failed to parse it */
 698
 699                 /* This will ensure incorrectly parsed dates get set to zero */
 700                 if ( -1L == (long)ts_sec )
 701                 {
 702                         ts_sec  = 0;
 703                         ts_usec = 0;
 704                 }
 705                 else
 706                 {
 707                         /* Parse subseconds */
 708                         ts_usec = strtol(subsecs, &p, 10);
 709                         if (subsecs == p) {
 710                                 /* Error */
 711                                 ts_usec = 0;
 712                         } else {
 713                                 /*
 714                                  * Convert that number to a number
 715                                  * of microseconds; if it's N digits
 716                                  * long, it's in units of 10^(-N) seconds,
 717                                  * so, to convert it to units of
 718                                  * 10^-6 seconds, we multiply by
 719                                  * 10^(6-N).
 720                                  */
 721                                 subseclen = p - subsecs;
 722                                 if (subseclen > 6) {
 723                                         /*
 724                                          * *More* than 6 digits; 6-N is
 725                                          * negative, so we divide by
 726                                          * 10^(N-6).
 727                                          */
 728                                         for (i = subseclen - 6; i != 0; i--)
 729                                                 ts_usec /= 10;
 730                                 } else if (subseclen < 6) {
 731                                         for (i = 6 - subseclen; i != 0; i--)
 732                                                 ts_usec *= 10;
 733                                 }
 734                         }
 735                 }
 736         }
 737
 738
 739         /*printf("Format(%s), time(%u), subsecs(%u)\n\n", ts_fmt, ts_sec, ts_usec);*/
 740
 741         /* Clear Preamble */
 742         packet_preamble_len = 0;
 743 }
 744
 745 /*----------------------------------------------------------------------
 746  * Start a new packet
 747  */
 748 static void
 749 start_new_packet (void)
 750 {
 751     if (debug>=1)
 752         fprintf(stderr, "Start new packet\n");
 753
 754     /* Write out the current packet, if required */
 755     write_current_packet();
 756     curr_offset = 0;
 757     num_packets_read ++;
 758
 759     /* Ensure we parse the packet preamble as it may contain the time */
 760     parse_preamble();
 761 }
 762
 763 /*----------------------------------------------------------------------
 764  * Process a directive
 765  */
 766 static void
 767 process_directive (char *str)
 768 {
 769     fprintf(stderr, "\n--- Directive [%s] currently unsupported ---\n", str+10);
 770
 771 }
 772
 773 /*----------------------------------------------------------------------
 774  * Parse a single token (called from the scanner)
 775  */
 776 void
 777 parse_token (token_t token, char *str)
 778 {
 779     unsigned long num;
 780
 781     /*
 782      * This is implemented as a simple state machine of five states.
 783      * State transitions are caused by tokens being received from the
 784      * scanner. The code should be self_documenting.
 785      */
 786
 787     if (debug>=2) {
 788         /* Sanitize - remove all '\r' */
 789         char *c;
 790         if (str!=NULL) { while ((c = strchr(str, '\r')) != NULL) *c=' '; }
 791
 792         fprintf(stderr, "(%s, %s \"%s\") -> (",
 793                 state_str[state], token_str[token], str ? str : "");
 794     }
 795
 796     switch(state) {
 797
 798     /* ----- Waiting for new packet -------------------------------------------*/
 799     case INIT:
 800         switch(token) {
 801         case T_TEXT:
 802             append_to_preamble(str);
 803             break;
 804         case T_DIRECTIVE:
 805             process_directive(str);
 806             break;
 807         case T_OFFSET:
 808             num = parse_num(str, TRUE);
 809             if (num==0) {
 810                 /* New packet starts here */
 811                 start_new_packet();
 812                 state = READ_OFFSET;
 813             }
 814             break;
 815         default:
 816             break;
 817         }
 818         break;
 819
 820     /* ----- Processing packet, start of new line -----------------------------*/
 821     case START_OF_LINE:
 822         switch(token) {
 823         case T_TEXT:
 824             append_to_preamble(str);
 825             break;
 826         case T_DIRECTIVE:
 827             process_directive(str);
 828             break;
 829         case T_OFFSET:
 830             num = parse_num(str, TRUE);
 831             if (num==0) {
 832                 /* New packet starts here */
 833                 start_new_packet();
 834                 state = READ_OFFSET;
 835             } else if (num != curr_offset) {
 836                 /*
 837                  * The offset we read isn't the one we expected.
 838                  * This may only mean that we mistakenly interpreted
 839                  * some text as byte values (e.g., if the text dump
 840                  * of packet data included a number with spaces around
 841                  * it).  If the offset is less than what we expected,
 842                  * assume that's the problem, and throw away the putative
 843                  * extra byte values.
 844                  */
 845                 if (num < curr_offset) {
 846                     unwrite_bytes(curr_offset - num);
 847                     state = READ_OFFSET;
 848                 } else {
 849                     /* Bad offset; switch to INIT state */
 850                     if (debug>=1)
 851                         fprintf(stderr, "Inconsistent offset. Expecting %0lX, got %0lX. Ignoring rest of packet\n",
 852                                 curr_offset, num);
 853                     write_current_packet();
 854                     state = INIT;
 855                 }
 856             } else
 857                 state = READ_OFFSET;
 858             break;
 859         default:
 860             break;
 861         }
 862         break;
 863
 864     /* ----- Processing packet, read offset -----------------------------------*/
 865     case READ_OFFSET:
 866         switch(token) {
 867         case T_BYTE:
 868             /* Record the byte */
 869             state = READ_BYTE;
 870             write_byte(str);
 871             break;
 872         case T_TEXT:
 873         case T_DIRECTIVE:
 874         case T_OFFSET:
 875             state = READ_TEXT;
 876             break;
 877         case T_EOL:
 878             state = START_OF_LINE;
 879             break;
 880         default:
 881             break;
 882         }
 883         break;
 884
 885     /* ----- Processing packet, read byte -------------------------------------*/
 886     case READ_BYTE:
 887         switch(token) {
 888         case T_BYTE:
 889             /* Record the byte */
 890             write_byte(str);
 891             break;
 892         case T_TEXT:
 893         case T_DIRECTIVE:
 894         case T_OFFSET:
 895             state = READ_TEXT;
 896             break;
 897         case T_EOL:
 898             state = START_OF_LINE;
 899             break;
 900         default:
 901             break;
 902         }
 903         break;
 904
 905     /* ----- Processing packet, read text -------------------------------------*/
 906     case READ_TEXT:
 907         switch(token) {
 908         case T_EOL:
 909             state = START_OF_LINE;
 910             break;
 911         default:
 912             break;
 913         }
 914         break;
 915
 916     default:
 917         fprintf(stderr, "FATAL ERROR: Bad state (%d)", state);
 918         exit(-1);
 919     }
 920
 921     if (debug>=2)
 922         fprintf(stderr, ", %s)\n", state_str[state]);
 923
 924 }
 925
 926 /*----------------------------------------------------------------------
 927  * Print helpstring and exit
 928  */
 929 static void
 930 help (char *progname)
 931 {
 932     fprintf(stderr,
 933             "\n"
 934             "Usage: %s [-d] [-q] [-o h|o] [-l typenum] [-e l3pid] [-i proto] \n"
 935             "          [-u srcp,destp] [-s srcp,destp,tag] [-S srcp,destp,tag] [-t timefmt] <input-filename> <output-filename>\n"
 936             "\n"
 937             "where <input-filename> specifies input filename (use - for standard input)\n"
 938             "      <output-filename> specifies output filename (use - for standard output)\n"
 939             "\n"
 940             "[options] are one or more of the following \n"
 941             "\n"
 942             " -w filename     : Write capfile to <filename>. Default is standard output\n"
 943             " -h              : Display this help message \n"
 944             " -d              : Generate detailed debug of parser states \n"
 945             " -o hex|oct      : Parse offsets as (h)ex or (o)ctal. Default is hex\n"
 946             " -l typenum      : Specify link-layer type number. Default is 1 (Ethernet). \n"
 947             "                   See net/bpf.h for list of numbers.\n"
 948             " -q              : Generate no output at all (automatically turns off -d)\n"
 949             " -e l3pid        : Prepend dummy Ethernet II header with specified L3PID (in HEX)\n"
 950             "                   Example: -e 0x800\n"
 951             " -i proto        : Prepend dummy IP header with specified IP protocol (in DECIMAL). \n"
 952             "                   Automatically prepends Ethernet header as well. Example: -i 46\n"
 953             " -u srcp,destp   : Prepend dummy UDP header with specified dest and source ports (in DECIMAL).\n"
 954             "                   Automatically prepends Ethernet and IP headers as well\n"
 955             "                   Example: -u 30,40\n"
 956             " -s srcp,dstp,tag: Prepend dummy SCTP header with specified dest/source ports and\n"
 957             "                   verification tag (in DECIMAL).\n"
 958             "                   Automatically prepends Ethernet and IP headers as well\n"
 959             "                   Example: -s 30,40,34\n"
 960             " -S srcp,dstp,ppi: Prepend dummy SCTP header with specified dest/source ports and\n"
 961             "                   verification tag 0. It also prepends a dummy SCTP DATA chunk header\n"
 962             "                   with payload protocol identifier ppi.\n"
 963             "                   Example: -S 30,40,34\n"
 964             " -t timefmt      : Treats the text before the packet as a date/time code; the\n"
 965             "                   specified argument is a format string of the sort supported\n"
 966             "                   by strptime.\n"
 967             "                   Example: The time \"10:15:14.5476\" has the format code\n"
 968             "                   \"%%H:%%M:%%S.\"\n"
 969             "                   NOTE:    The subsecond component delimiter must be specified\n"
 970             "                            (.) but no pattern is required; the remaining number\n"
 971             "                            is assumed to be fractions of a second.\n"
 972             "",
 973             progname);
 974
 975     exit(-1);
 976 }
 977
 978 /*----------------------------------------------------------------------
 979  * Parse CLI options
 980  */
 981 static void
 982 parse_options (int argc, char *argv[])
 983 {
 984     int c;
 985     char *p;
 986
 987     /* Scan CLI parameters */
 988     while ((c = getopt(argc, argv, "dqr:w:e:i:l:o:u:s:S:t:")) != -1) {
 989         switch(c) {
 990         case '?': help(argv[0]); break;
 991         case 'h': help(argv[0]); break;
 992         case 'd': if (!quiet) debug++; break;
 993         case 'q': quiet = TRUE; debug = FALSE; break;
 994         case 'l': pcap_link_type = atoi(optarg); break;
 995         case 'o':
 996             if (optarg[0]!='h' && optarg[0] != 'o') {
 997                 fprintf(stderr, "Bad argument for '-e': %s\n", optarg);
 998                 help(argv[0]);
 999             }
1000             offset_base = (optarg[0]=='o') ? 8 : 16;
1001             break;
1002         case 'e':
1003             hdr_ethernet = TRUE;
1004             if (sscanf(optarg, "%lx", &hdr_ethernet_proto) < 1) {
1005                 fprintf(stderr, "Bad argument for '-e': %s\n", optarg);
1006                 help(argv[0]);
1007             }
1008             break;
1009
1010         case 'i':
1011             hdr_ip = TRUE;
1012             if (sscanf(optarg, "%ld", &hdr_ip_proto) < 1) {
1013                 fprintf(stderr, "Bad argument for '-i': %s\n", optarg);
1014                 help(argv[0]);
1015             }
1016             hdr_ethernet = TRUE;
1017             hdr_ethernet_proto = 0x800;
1018             break;
1019
1020         case 's':
1021             hdr_sctp       = TRUE;
1022             hdr_sctp_src   = strtol(optarg, &p, 10);
1023             if (p == optarg || (*p != ',' && *p != '\0')) {
1024                 fprintf(stderr, "Bad src port for '-%c'\n", c);
1025                 help(argv[0]);
1026             }
1027             if (*p == '\0') {
1028                 fprintf(stderr, "No dest port specified for '-%c'\n", c);
1029                 help(argv[0]);
1030             }
1031             p++;
1032             optarg = p;
1033             hdr_sctp_dest = strtol(optarg, &p, 10);
1034             if (p == optarg || (*p != ',' && *p != '\0')) {
1035                 fprintf(stderr, "Bad dest port for '-s'\n");
1036                 help(argv[0]);
1037             }
1038             if (*p == '\0') {
1039                 fprintf(stderr, "No tag specified for '-%c'\n", c);
1040                 help(argv[0]);
1041             }
1042             p++;
1043             optarg = p;
1044             hdr_sctp_tag = strtol(optarg, &p, 10);
1045             if (p == optarg || *p != '\0') {
1046                 fprintf(stderr, "Bad tag for '-%c'\n", c);
1047                 help(argv[0]);
1048             }
1049
1050             hdr_ip = TRUE;
1051             hdr_ip_proto = 132;
1052             hdr_ethernet = TRUE;
1053             hdr_ethernet_proto = 0x800;
1054             break;
1055         case 'S':
1056             hdr_sctp       = TRUE;
1057             hdr_data_chunk = TRUE;
1058             hdr_sctp_src   = strtol(optarg, &p, 10);
1059             if (p == optarg || (*p != ',' && *p != '\0')) {
1060                 fprintf(stderr, "Bad src port for '-%c'\n", c);
1061                 help(argv[0]);
1062             }
1063             if (*p == '\0') {
1064                 fprintf(stderr, "No dest port specified for '-%c'\n", c);
1065                 help(argv[0]);
1066             }
1067             p++;
1068             optarg = p;
1069             hdr_sctp_dest = strtol(optarg, &p, 10);
1070             if (p == optarg || (*p != ',' && *p != '\0')) {
1071                 fprintf(stderr, "Bad dest port for '-s'\n");
1072                 help(argv[0]);
1073             }            if (*p == '\0') {
1074                 fprintf(stderr, "No ppi specified for '-%c'\n", c);
1075                 help(argv[0]);
1076             }
1077             p++;
1078             optarg = p;
1079             hdr_data_chunk_ppid = strtoul(optarg, &p, 10);
1080             if (p == optarg || *p != '\0') {
1081                 fprintf(stderr, "Bad ppi for '-%c'\n", c);
1082                 help(argv[0]);
1083             }
1084
1085             hdr_ip = TRUE;
1086             hdr_ip_proto = 132;
1087             hdr_ethernet = TRUE;
1088             hdr_ethernet_proto = 0x800;
1089             break;
1090
1091         case 't':
1092             ts_fmt = optarg;
1093             break;
1094
1095         case 'u':
1096             hdr_udp = TRUE;
1097             hdr_udp_src = strtol(optarg, &p, 10);
1098             if (p == optarg || (*p != ',' && *p != '\0')) {
1099                 fprintf(stderr, "Bad src port for '-u'\n");
1100                 help(argv[0]);
1101             }
1102             if (*p == '\0') {
1103                 fprintf(stderr, "No dest port specified for '-u'\n");
1104                 help(argv[0]);
1105             }
1106             p++;
1107             optarg = p;
1108             hdr_udp_dest = strtol(optarg, &p, 10);
1109             if (p == optarg || *p != '\0') {
1110                 fprintf(stderr, "Bad dest port for '-u'\n");
1111                 help(argv[0]);
1112             }
1113             hdr_ip = TRUE;
1114             hdr_ip_proto = 17;
1115             hdr_ethernet = TRUE;
1116             hdr_ethernet_proto = 0x800;
1117             break;
1118
1119         default:
1120             help(argv[0]);
1121         }
1122     }
1123
1124     if (optind >= argc || argc-optind < 2) {
1125         fprintf(stderr, "Must specify input and output filename\n");
1126         help(argv[0]);
1127     }
1128
1129     if (strcmp(argv[optind], "-")) {
1130         input_filename = strdup(argv[optind]);
1131         input_file = fopen(input_filename, "rb");
1132         if (!input_file) {
1133             fprintf(stderr, "Cannot open file [%s] for reading: %s\n",
1134                     input_filename, strerror(errno));
1135             exit(-1);
1136         }
1137     } else {
1138         input_filename = "Standard input";
1139         input_file = stdin;
1140     }
1141
1142     if (strcmp(argv[optind+1], "-")) {
1143         output_filename = strdup(argv[optind+1]);
1144         output_file = fopen(output_filename, "wb");
1145         if (!output_file) {
1146             fprintf(stderr, "Cannot open file [%s] for writing: %s\n",
1147                     output_filename, strerror(errno));
1148             exit(-1);
1149         }
1150     } else {
1151         output_filename = "Standard output";
1152         output_file = stdout;
1153     }
1154
1155     /* Some validation */
1156     if (pcap_link_type != 1 && hdr_ethernet) {
1157         fprintf(stderr, "Dummy headers (-e, -i, -u, -s, -S) cannot be specified with link type override (-l)\n");
1158         exit(-1);
1159     }
1160
1161     /* Set up our variables */
1162     if (!input_file) {
1163         input_file = stdin;
1164         input_filename = "Standard input";
1165     }
1166     if (!output_file) {
1167         output_file = stdout;
1168         output_filename = "Standard output";
1169     }
1170
1171     /* Display summary of our state */
1172     if (!quiet) {
1173         fprintf(stderr, "Input from: %s\n", input_filename);
1174         fprintf(stderr, "Output to: %s\n", output_filename);
1175
1176         if (hdr_ethernet) fprintf(stderr, "Generate dummy Ethernet header: Protocol: 0x%0lX\n",
1177                                   hdr_ethernet_proto);
1178         if (hdr_ip) fprintf(stderr, "Generate dummy IP header: Protocol: %ld\n",
1179                             hdr_ip_proto);
1180         if (hdr_udp) fprintf(stderr, "Generate dummy UDP header: Source port: %ld. Dest port: %ld\n",
1181                              hdr_udp_src, hdr_udp_dest);
1182         if (hdr_sctp) fprintf(stderr, "Generate dummy SCTP header: Source port: %ld. Dest port: %ld. Tag: %ld\n",
1183                               hdr_sctp_src, hdr_sctp_dest, hdr_sctp_tag);
1184         if (hdr_data_chunk) fprintf(stderr, "Generate dummy DATA chunk header: TSN: %lu. SID: %d. SSN: %d. PPID: %lu\n",
1185                                     hdr_data_chunk_tsn, hdr_data_chunk_sid, hdr_data_chunk_ssn, hdr_data_chunk_ppid);
1186     }
1187 }
1188
1189 int main(int argc, char *argv[])
1190 {
1191     parse_options(argc, argv);
1192
1193     assert(input_file != NULL);
1194     assert(output_file != NULL);
1195
1196     write_file_header();
1197
1198     yyin = input_file;
1199     yylex();
1200
1201     write_current_packet();
1202     if (debug)
1203         fprintf(stderr, "\n-------------------------\n");
1204     if (!quiet) {
1205     fprintf(stderr, "Read %ld potential packets, wrote %ld packets\n",
1206             num_packets_read, num_packets_written);
1207     }
1208     return 0;
1209 }