editcap.c

   1 /* Edit capture files.  We can delete packets, adjust timestamps, or
   2  * simply convert from one format to another format.
   3  *
   4  * $Id$
   5  *
   6  * Originally written by Richard Sharpe.
   7  * Improved by Guy Harris.
   8  * Further improved by Richard Sharpe.
   9  */
  10
  11 #ifdef HAVE_CONFIG_H
  12 #include "config.h"
  13 #endif
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18
  19 /*
  20  * Just make sure we include the prototype for strptime as well
  21  * (needed for glibc 2.2)
  22  */
  23
  24 #define __USE_XOPEN
  25 #include <time.h>
  26 #include <glib.h>
  27
  28 #ifdef HAVE_UNISTD_H
  29 #include <unistd.h>
  30 #endif
  31
  32
  33
  34 #ifdef HAVE_SYS_TIME_H
  35 #include <sys/time.h>
  36 #endif
  37
  38 #include "wtap.h"
  39
  40 #ifdef NEED_GETOPT_H
  41 #include "getopt.h"
  42 #endif
  43
  44 #ifdef _WIN32
  45 #include <process.h>    /* getpid */
  46 #endif
  47
  48 #ifdef NEED_STRPTIME_H
  49 # include "strptime.h"
  50 #endif
  51
  52 #include "epan/crypt/crypt-md5.h"
  53
  54 #include "svnversion.h"
  55
  56 /*
  57  * Some globals so we can pass things to various routines
  58  */
  59
  60 struct select_item {
  61
  62   int inclusive;
  63   int first, second;
  64
  65 };
  66
  67
  68 /*
  69  * Duplicate frame detection
  70  */
  71 typedef struct _fd_hash_t {
  72   md5_byte_t digest[16];
  73   guint32 len;
  74 } fd_hash_t;
  75
  76 #define DUP_DEPTH 5
  77 fd_hash_t fd_hash[DUP_DEPTH];
  78 int cur_dup = 0;
  79
  80 #define ONE_MILLION 1000000
  81
  82 /* Weights of different errors we can introduce */
  83 /* We should probably make these command-line arguments */
  84 /* XXX - Should we add a bit-level error? */
  85 #define ERR_WT_BIT   5  /* Flip a random bit */
  86 #define ERR_WT_BYTE  5  /* Substitute a random byte */
  87 #define ERR_WT_ALNUM 5  /* Substitute a random character in [A-Za-z0-9] */
  88 #define ERR_WT_FMT   2  /* Substitute "%s" */
  89 #define ERR_WT_AA    1  /* Fill the remainder of the buffer with 0xAA */
  90 #define ERR_WT_TOTAL (ERR_WT_BIT + ERR_WT_BYTE + ERR_WT_ALNUM + ERR_WT_FMT + ERR_WT_AA)
  91
  92 #define ALNUM_CHARS "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
  93 #define ALNUM_LEN (sizeof(ALNUM_CHARS) - 1)
  94
  95
  96 struct time_adjustment {
  97   struct timeval tv;
  98   int is_negative;
  99 };
 100
 101 static struct select_item selectfrm[100];
 102 static int max_selected = -1;
 103 static int keep_em = 0;
 104 static int out_file_type = WTAP_FILE_PCAP;   /* default to "libpcap"   */
 105 static int out_frame_type = -2;              /* Leave frame type alone */
 106 static int verbose = 0;                      /* Not so verbose         */
 107 static struct time_adjustment time_adj = {{0, 0}, 0}; /* no adjustment */
 108 static double err_prob = 0.0;
 109 static time_t starttime = 0;
 110 static time_t stoptime = 0;
 111 static gboolean check_startstop = FALSE;
 112 static gboolean dup_detect = FALSE;
 113
 114 /* Add a selection item, a simple parser for now */
 115
 116 static void add_selection(char *sel)
 117 {
 118   char *locn;
 119   char *next;
 120
 121   if (max_selected == (sizeof(selectfrm)/sizeof(struct select_item)) - 1)
 122     return;
 123
 124   printf("Add_Selected: %s\n", sel);
 125
 126   if ((locn = strchr(sel, '-')) == NULL) { /* No dash, so a single number? */
 127
 128     printf("Not inclusive ...");
 129
 130     max_selected++;
 131     selectfrm[max_selected].inclusive = 0;
 132     selectfrm[max_selected].first = atoi(sel);
 133
 134     printf(" %i\n", selectfrm[max_selected].first);
 135
 136   }
 137   else {
 138
 139     printf("Inclusive ...");
 140
 141     next = locn + 1;
 142     max_selected++;
 143     selectfrm[max_selected].inclusive = 1;
 144     selectfrm[max_selected].first = atoi(sel);
 145     selectfrm[max_selected].second = atoi(next);
 146
 147     printf(" %i, %i\n", selectfrm[max_selected].first, selectfrm[max_selected].second);
 148
 149   }
 150
 151
 152 }
 153
 154 /* Was the packet selected? */
 155
 156 static int selected(int recno)
 157 {
 158   int i = 0;
 159
 160   for (i = 0; i<= max_selected; i++) {
 161
 162     if (selectfrm[i].inclusive) {
 163       if (selectfrm[i].first <= recno && selectfrm[i].second >= recno)
 164         return 1;
 165     }
 166     else {
 167       if (recno == selectfrm[i].first)
 168         return 1;
 169     }
 170   }
 171
 172   return 0;
 173
 174 }
 175
 176 /* is the packet in the selected timeframe */
 177 static gboolean check_timestamp(wtap *wth) {
 178         struct wtap_pkthdr* pkthdr = wtap_phdr(wth);
 179         return ( (time_t) pkthdr->ts.secs >= starttime ) && ( (time_t) pkthdr->ts.secs <= stoptime );
 180 }
 181
 182 static void
 183 set_time_adjustment(char *optarg)
 184 {
 185   char *frac, *end;
 186   long val;
 187   int frac_digits;
 188
 189   if (!optarg)
 190     return;
 191
 192   /* skip leading whitespace */
 193   while (*optarg == ' ' || *optarg == '\t') {
 194       optarg++;
 195   }
 196
 197   /* check for a negative adjustment */
 198   if (*optarg == '-') {
 199       time_adj.is_negative = 1;
 200       optarg++;
 201   }
 202
 203   /* collect whole number of seconds, if any */
 204   if (*optarg == '.') {         /* only fractional (i.e., .5 is ok) */
 205       val  = 0;
 206       frac = optarg;
 207   } else {
 208       val = strtol(optarg, &frac, 10);
 209       if (frac == NULL || frac == optarg || val == LONG_MIN || val == LONG_MAX) {
 210           fprintf(stderr, "editcap: \"%s\" isn't a valid time adjustment\n",
 211                   optarg);
 212           exit(1);
 213       }
 214       if (val < 0) {            /* implies '--' since we caught '-' above  */
 215           fprintf(stderr, "editcap: \"%s\" isn't a valid time adjustment\n",
 216                   optarg);
 217           exit(1);
 218       }
 219   }
 220   time_adj.tv.tv_sec = val;
 221
 222   /* now collect the partial seconds, if any */
 223   if (*frac != '\0') {             /* chars left, so get fractional part */
 224     val = strtol(&(frac[1]), &end, 10);
 225     if (*frac != '.' || end == NULL || end == frac
 226         || val < 0 || val > ONE_MILLION || val == LONG_MIN || val == LONG_MAX) {
 227       fprintf(stderr, "editcap: \"%s\" isn't a valid time adjustment\n",
 228               optarg);
 229       exit(1);
 230     }
 231   }
 232   else {
 233     return;                     /* no fractional digits */
 234   }
 235
 236   /* adjust fractional portion from fractional to numerator
 237    * e.g., in "1.5" from 5 to 500000 since .5*10^6 = 500000 */
 238   if (frac && end) {            /* both are valid */
 239     frac_digits = end - frac - 1;   /* fractional digit count (remember '.') */
 240     while(frac_digits < 6) {    /* this is frac of 10^6 */
 241       val *= 10;
 242       frac_digits++;
 243     }
 244   }
 245   time_adj.tv.tv_usec = val;
 246 }
 247
 248 static gboolean
 249 is_duplicate(guint8* fd, guint32 len) {
 250   int i;
 251   md5_state_t ms;
 252
 253   cur_dup++;
 254   if (cur_dup >= DUP_DEPTH)
 255     cur_dup = 0;
 256
 257   /* Calculate our digest */
 258   md5_init(&ms);
 259   md5_append(&ms, fd, len);
 260   md5_finish(&ms, fd_hash[cur_dup].digest);
 261
 262   fd_hash[cur_dup].len = len;
 263
 264   /* Look for duplicates */
 265   for (i = 0; i < DUP_DEPTH; i++) {
 266     if (i == cur_dup)
 267       continue;
 268
 269     if (fd_hash[i].len == fd_hash[cur_dup].len &&
 270         memcmp(fd_hash[i].digest, fd_hash[cur_dup].digest, 16) == 0) {
 271       return TRUE;
 272     }
 273   }
 274
 275   return FALSE;
 276 }
 277
 278 static void usage(void)
 279 {
 280   fprintf(stderr, "Editcap %s"
 281 #ifdef SVNVERSION
 282           " (" SVNVERSION ")"
 283 #endif
 284           "\n", VERSION);
 285   fprintf(stderr, "Edit and/or translate the format of capture files.\n");
 286   fprintf(stderr, "See http://www.wireshark.org for more information.\n");
 287   fprintf(stderr, "\n");
 288   fprintf(stderr, "Usage: editcap [options] ... <infile> <outfile> [ <packet#>[-<packet#>] ... ]\n");
 289   fprintf(stderr, "\n");
 290   fprintf(stderr, "A single packet or a range of packets can be selected.\n");
 291   fprintf(stderr, "\n");
 292   fprintf(stderr, "Packets:\n");
 293   fprintf(stderr, "  -C <choplen>           chop each packet at the end by <choplen> bytes\n");
 294   fprintf(stderr, "  -d                     remove duplicate packets\n");
 295   fprintf(stderr, "  -E <error probability> set the probability (between 0.0 and 1.0 incl.)\n");
 296   fprintf(stderr, "                         that a particular packet byte will be randomly changed\n");
 297   fprintf(stderr, "  -r                     keep the selected packets, default is to delete them\n");
 298   fprintf(stderr, "  -s <snaplen>           truncate packets to max. <snaplen> bytes of data\n");
 299   fprintf(stderr, "  -t <time adjustment>   adjust the timestamp of selected packets,\n");
 300   fprintf(stderr, "                         <time adjustment> is in relative seconds (e.g. -0.5)\n");
 301   fprintf(stderr, "  -A <start time>        don't output packets whose timestamp is before the\n");
 302   fprintf(stderr, "                         given time (format as YYYY-MM-DD hh:mm:ss)\n");
 303   fprintf(stderr, "  -B <stop time>         don't output packets whose timestamp is after the\n");
 304   fprintf(stderr, "                         given time (format as YYYY-MM-DD hh:mm:ss)\n");
 305   fprintf(stderr, "\n");
 306   fprintf(stderr, "Output File(s):\n");
 307   fprintf(stderr, "  -c <packets per file>  split the packet output to different files,\n");
 308   fprintf(stderr, "                         with a maximum of <packets per file> each\n");
 309   fprintf(stderr, "  -F <capture type>      set the output file type, default is libpcap\n");
 310   fprintf(stderr, "                         an empty \"-F\" option will list the file types\n");
 311   fprintf(stderr, "  -T <encap type>        set the output file encapsulation type,\n");
 312   fprintf(stderr, "                         default is the same as the input file\n");
 313   fprintf(stderr, "                         an empty \"-T\" option will list the encapsulation types\n");
 314   fprintf(stderr, "\n");
 315   fprintf(stderr, "Miscellaneous:\n");
 316   fprintf(stderr, "  -h                     display this help and exit\n");
 317   fprintf(stderr, "  -v                     verbose output\n");
 318   fprintf(stderr, "\n");
 319 }
 320
 321 static void list_capture_types(void) {
 322     int i;
 323
 324     fprintf(stderr, "editcap: The available capture file types for \"F\":\n");
 325     for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
 326       if (wtap_dump_can_open(i))
 327         fprintf(stderr, "    %s - %s\n",
 328           wtap_file_type_short_string(i), wtap_file_type_string(i));
 329     }
 330 }
 331
 332 static void list_encap_types(void) {
 333     int i;
 334     const char *string;
 335
 336     fprintf(stderr, "editcap: The available encapsulation types for \"T\":\n");
 337     for (i = 0; i < WTAP_NUM_ENCAP_TYPES; i++) {
 338         string = wtap_encap_short_string(i);
 339         if (string != NULL)
 340           fprintf(stderr, "    %s - %s\n",
 341             string, wtap_encap_string(i));
 342     }
 343 }
 344
 345 int main(int argc, char *argv[])
 346
 347 {
 348   wtap *wth;
 349   int i, j, err;
 350   gchar *err_info;
 351   extern char *optarg;
 352   extern int optind;
 353   int opt;
 354   char *p;
 355   unsigned int snaplen = 0;             /* No limit               */
 356   unsigned int choplen = 0;             /* No chop                */
 357   wtap_dumper *pdh;
 358   int count = 1;
 359   gint64 data_offset;
 360   struct wtap_pkthdr snap_phdr;
 361   const struct wtap_pkthdr *phdr;
 362   int err_type;
 363   guint8 *buf;
 364   int split_packet_count = 0;
 365   int written_count = 0;
 366   char *filename;
 367
 368   /* Process the options first */
 369
 370   while ((opt = getopt(argc, argv, "A:B:c:C:dE:F:hrs:t:T:v")) !=-1) {
 371
 372     switch (opt) {
 373
 374     case 'E':
 375       err_prob = strtod(optarg, &p);
 376       if (p == optarg || err_prob < 0.0 || err_prob > 1.0) {
 377         fprintf(stderr, "editcap: probability \"%s\" must be between 0.0 and 1.0\n",
 378             optarg);
 379         exit(1);
 380       }
 381       srand(time(NULL) + getpid());
 382       break;
 383
 384     case 'F':
 385       out_file_type = wtap_short_string_to_file_type(optarg);
 386       if (out_file_type < 0) {
 387         fprintf(stderr, "editcap: \"%s\" isn't a valid capture file type\n\n",
 388             optarg);
 389         list_capture_types();
 390         exit(1);
 391       }
 392       break;
 393
 394     case 'c':
 395       split_packet_count = strtol(optarg, &p, 10);
 396       if (p == optarg || *p != '\0') {
 397         fprintf(stderr, "editcap: \"%s\" isn't a valid packet count\n",
 398             optarg);
 399         exit(1);
 400       }
 401       if (split_packet_count <= 0) {
 402         fprintf(stderr, "editcap: \"%d\" packet count must be larger than zero\n",
 403                 split_packet_count);
 404         exit(1);
 405       }
 406       break;
 407
 408     case 'C':
 409       choplen = strtol(optarg, &p, 10);
 410       if (p == optarg || *p != '\0') {
 411         fprintf(stderr, "editcap: \"%s\" isn't a valid chop length\n",
 412             optarg);
 413         exit(1);
 414       }
 415       break;
 416
 417     case 'd':
 418       dup_detect = TRUE;
 419       for (i = 0; i < DUP_DEPTH; i++) {
 420         memset(&fd_hash[i].digest, 0, 16);
 421         fd_hash[i].len = 0;
 422       }
 423       break;
 424
 425     case '?':              /* Bad options if GNU getopt */
 426       switch(optopt) {
 427       case'F':
 428         list_capture_types();
 429         break;
 430       case'T':
 431         list_encap_types();
 432         break;
 433       default:
 434         usage();
 435       }
 436       exit(1);
 437       break;
 438
 439     case 'h':
 440       usage();
 441       exit(1);
 442       break;
 443
 444     case 'r':
 445       keep_em = !keep_em;  /* Just invert */
 446       break;
 447
 448     case 's':
 449       snaplen = strtol(optarg, &p, 10);
 450       if (p == optarg || *p != '\0') {
 451         fprintf(stderr, "editcap: \"%s\" isn't a valid snapshot length\n",
 452             optarg);
 453         exit(1);
 454       }
 455       break;
 456
 457     case 't':
 458       set_time_adjustment(optarg);
 459       break;
 460
 461     case 'T':
 462       out_frame_type = wtap_short_string_to_encap(optarg);
 463       if (out_frame_type < 0) {
 464         fprintf(stderr, "editcap: \"%s\" isn't a valid encapsulation type\n\n",
 465             optarg);
 466         list_encap_types();
 467         exit(1);
 468       }
 469       break;
 470
 471     case 'v':
 472       verbose = !verbose;  /* Just invert */
 473       break;
 474
 475         case 'A':
 476         {
 477                 struct tm starttm;
 478
 479                 memset(&starttm,0,sizeof(struct tm));
 480
 481                 if(!strptime(optarg,"%F %T",&starttm)) {
 482                         fprintf(stderr, "editcap: \"%s\" isn't a valid time format\n\n",
 483                                         optarg);
 484                         exit(1);
 485                 }
 486
 487                 check_startstop = TRUE;
 488                 starttm.tm_isdst = -1;
 489
 490                 starttime = mktime(&starttm);
 491                 break;
 492         }
 493         case 'B':
 494         {
 495                 struct tm stoptm;
 496
 497                 memset(&stoptm,0,sizeof(struct tm));
 498
 499                 if(!strptime(optarg,"%F %T",&stoptm)) {
 500                         fprintf(stderr, "editcap: \"%s\" isn't a valid time format\n\n",
 501                                         optarg);
 502                         exit(1);
 503                 }
 504                 check_startstop = TRUE;
 505                 stoptm.tm_isdst = -1;
 506                 stoptime = mktime(&stoptm);
 507                 break;
 508         }
 509     }
 510
 511   }
 512
 513 #ifdef DEBUG
 514   printf("Optind = %i, argc = %i\n", optind, argc);
 515 #endif
 516
 517   if ((argc - optind) < 1) {
 518
 519     usage();
 520     exit(1);
 521
 522   }
 523
 524   if (check_startstop && !stoptime) {
 525           struct tm stoptm;
 526           /* XXX: will work until 2035 */
 527           memset(&stoptm,0,sizeof(struct tm));
 528           stoptm.tm_year = 135;
 529           stoptm.tm_mday = 31;
 530           stoptm.tm_mon = 11;
 531
 532           stoptime = mktime(&stoptm);
 533   }
 534
 535   if (starttime > stoptime) {
 536           fprintf(stderr, "editcap: start time is after the stop time\n");
 537           exit(1);
 538   }
 539
 540   wth = wtap_open_offline(argv[optind], &err, &err_info, FALSE);
 541
 542   if (!wth) {
 543     fprintf(stderr, "editcap: Can't open %s: %s\n", argv[optind],
 544         wtap_strerror(err));
 545     switch (err) {
 546
 547     case WTAP_ERR_UNSUPPORTED:
 548     case WTAP_ERR_UNSUPPORTED_ENCAP:
 549     case WTAP_ERR_BAD_RECORD:
 550       fprintf(stderr, "(%s)\n", err_info);
 551       g_free(err_info);
 552       break;
 553     }
 554     exit(1);
 555
 556   }
 557
 558   if (verbose) {
 559
 560     fprintf(stderr, "File %s is a %s capture file.\n", argv[optind],
 561             wtap_file_type_string(wtap_file_type(wth)));
 562
 563   }
 564
 565   /*
 566    * Now, process the rest, if any ... we only write if there is an extra
 567    * argument or so ...
 568    */
 569
 570   if ((argc - optind) >= 2) {
 571
 572     if (out_frame_type == -2)
 573       out_frame_type = wtap_file_encap(wth);
 574
 575     if (split_packet_count > 0) {
 576       filename = (char *) malloc(strlen(argv[optind+1]) + 20);
 577       if (!filename) {
 578         exit(5);
 579       }
 580       sprintf(filename, "%s-%05d", argv[optind+1], 0);
 581     } else {
 582       filename = argv[optind+1];
 583     }
 584
 585     pdh = wtap_dump_open(filename, out_file_type,
 586                          out_frame_type, wtap_snapshot_length(wth), FALSE /* compressed */, &err);
 587     if (pdh == NULL) {
 588
 589       fprintf(stderr, "editcap: Can't open or create %s: %s\n", filename,
 590               wtap_strerror(err));
 591       exit(1);
 592
 593     }
 594
 595     for (i = optind + 2; i < argc; i++)
 596       add_selection(argv[i]);
 597
 598     while (wtap_read(wth, &err, &err_info, &data_offset)) {
 599
 600       if (split_packet_count > 0 && (written_count % split_packet_count == 0)) {
 601         if (!wtap_dump_close(pdh, &err)) {
 602
 603           fprintf(stderr, "editcap: Error writing to %s: %s\n", filename,
 604                   wtap_strerror(err));
 605           exit(1);
 606         }
 607
 608         sprintf(filename, "%s-%05d",argv[optind+1], count / split_packet_count);
 609
 610         if (verbose) {
 611           fprintf(stderr, "Continuing writing in file %s\n", filename);
 612         }
 613
 614         pdh = wtap_dump_open(filename, out_file_type,
 615                              out_frame_type, wtap_snapshot_length(wth), FALSE /* compressed */, &err);
 616         if (pdh == NULL) {
 617
 618           fprintf(stderr, "editcap: Can't open or create %s: %s\n", filename,
 619                   wtap_strerror(err));
 620           exit(1);
 621
 622         }
 623       }
 624
 625       if ( ((check_startstop && check_timestamp(wth)) || (!check_startstop && !check_timestamp(wth))) && ((!selected(count) && !keep_em) ||
 626           (selected(count) && keep_em)) ) {
 627
 628         if (verbose)
 629           printf("Packet: %u\n", count);
 630
 631         /* We simply write it, perhaps after truncating it; we could do other
 632            things, like modify it. */
 633
 634         phdr = wtap_phdr(wth);
 635
 636         if (choplen != 0 && phdr->caplen > choplen) {
 637           snap_phdr = *phdr;
 638           snap_phdr.caplen -= choplen;
 639           phdr = &snap_phdr;
 640         }
 641
 642         if (snaplen != 0 && phdr->caplen > snaplen) {
 643           snap_phdr = *phdr;
 644           snap_phdr.caplen = snaplen;
 645           phdr = &snap_phdr;
 646         }
 647
 648         /* assume that if the frame's tv_sec is 0, then
 649          * the timestamp isn't supported */
 650         if (phdr->ts.secs > 0 && time_adj.tv.tv_sec != 0) {
 651           snap_phdr = *phdr;
 652           if (time_adj.is_negative)
 653             snap_phdr.ts.secs -= time_adj.tv.tv_sec;
 654           else
 655             snap_phdr.ts.secs += time_adj.tv.tv_sec;
 656           phdr = &snap_phdr;
 657         }
 658
 659         /* assume that if the frame's tv_sec is 0, then
 660          * the timestamp isn't supported */
 661         if (phdr->ts.secs > 0 && time_adj.tv.tv_usec != 0) {
 662           snap_phdr = *phdr;
 663           if (time_adj.is_negative) { /* subtract */
 664             if (snap_phdr.ts.nsecs/1000 < time_adj.tv.tv_usec) { /* borrow */
 665               snap_phdr.ts.secs--;
 666               snap_phdr.ts.nsecs += ONE_MILLION * 1000;
 667             }
 668             snap_phdr.ts.nsecs -= time_adj.tv.tv_usec * 1000;
 669           } else {                  /* add */
 670             if (snap_phdr.ts.nsecs + time_adj.tv.tv_usec * 1000 > ONE_MILLION * 1000) {
 671               /* carry */
 672               snap_phdr.ts.secs++;
 673               snap_phdr.ts.nsecs += (time_adj.tv.tv_usec - ONE_MILLION) * 1000;
 674             } else {
 675               snap_phdr.ts.nsecs += time_adj.tv.tv_usec * 1000;
 676             }
 677           }
 678           phdr = &snap_phdr;
 679         }
 680
 681         if (dup_detect) {
 682           buf = wtap_buf_ptr(wth);
 683           if (is_duplicate(buf, phdr->caplen)) {
 684             if (verbose)
 685               printf("Skipping duplicate: %u\n", count);
 686             count++;
 687             continue;
 688           }
 689         }
 690
 691         if (err_prob > 0.0) {
 692           buf = wtap_buf_ptr(wth);
 693           for (i = 0; i < (int) phdr->caplen; i++) {
 694             if (rand() <= err_prob * RAND_MAX) {
 695               err_type = rand() / (RAND_MAX / ERR_WT_TOTAL + 1);
 696
 697               if (err_type < ERR_WT_BIT) {
 698                 buf[i] ^= 1 << (rand() / (RAND_MAX / 8 + 1));
 699                 err_type = ERR_WT_TOTAL;
 700               } else {
 701                 err_type -= ERR_WT_BYTE;
 702               }
 703
 704               if (err_type < ERR_WT_BYTE) {
 705                 buf[i] = rand() / (RAND_MAX / 255 + 1);
 706                 err_type = ERR_WT_TOTAL;
 707               } else {
 708                 err_type -= ERR_WT_BYTE;
 709               }
 710
 711               if (err_type < ERR_WT_ALNUM) {
 712                 buf[i] = ALNUM_CHARS[rand() / (RAND_MAX / ALNUM_LEN + 1)];
 713                 err_type = ERR_WT_TOTAL;
 714               } else {
 715                 err_type -= ERR_WT_ALNUM;
 716               }
 717
 718               if (err_type < ERR_WT_FMT) {
 719                 if ((unsigned int)i < phdr->caplen - 2)
 720                   strcpy((char*) &buf[i],  "%s");
 721                 err_type = ERR_WT_TOTAL;
 722               } else {
 723                 err_type -= ERR_WT_FMT;
 724               }
 725
 726               if (err_type < ERR_WT_AA) {
 727                 for (j = i; j < (int) phdr->caplen; j++) {
 728                   buf[j] = 0xAA;
 729                 }
 730                 i = phdr->caplen;
 731               }
 732             }
 733           }
 734         }
 735
 736         if (!wtap_dump(pdh, phdr, wtap_pseudoheader(wth), wtap_buf_ptr(wth),
 737                        &err)) {
 738
 739           fprintf(stderr, "editcap: Error writing to %s: %s\n",
 740                   filename, wtap_strerror(err));
 741           exit(1);
 742
 743         }
 744
 745         written_count++;
 746
 747       }
 748
 749       count++;
 750
 751     }
 752
 753     if (err != 0) {
 754       /* Print a message noting that the read failed somewhere along the line. */
 755       fprintf(stderr,
 756               "editcap: An error occurred while reading \"%s\": %s.\n",
 757               argv[optind], wtap_strerror(err));
 758       switch (err) {
 759
 760       case WTAP_ERR_UNSUPPORTED:
 761       case WTAP_ERR_UNSUPPORTED_ENCAP:
 762       case WTAP_ERR_BAD_RECORD:
 763         fprintf(stderr, "(%s)\n", err_info);
 764         break;
 765       }
 766     }
 767
 768     if (!wtap_dump_close(pdh, &err)) {
 769
 770       fprintf(stderr, "editcap: Error writing to %s: %s\n", filename,
 771               wtap_strerror(err));
 772       exit(1);
 773
 774     }
 775   }
 776
 777   return 0;
 778 }
 779