editcap.c

   1 /* Edit capture files.  We can delete records, 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 <glib.h>
  18
  19 #ifdef HAVE_UNISTD_H
  20 #include <unistd.h>
  21 #endif
  22
  23 #ifdef HAVE_SYS_TIME_H
  24 #include <sys/time.h>
  25 #endif
  26
  27 #include <string.h>
  28 #include "wtap.h"
  29
  30 #ifdef NEED_GETOPT_H
  31 #include "getopt.h"
  32 #endif
  33
  34 /*
  35  * Some globals so we can pass things to various routines
  36  */
  37
  38 struct select_item {
  39
  40   int inclusive;
  41   int first, second;
  42
  43 };
  44
  45 #define ONE_MILLION 1000000
  46
  47 struct time_adjustment {
  48   struct timeval tv;
  49   int is_negative;
  50 };
  51
  52 static struct select_item selectfrm[100];
  53 static int max_selected = -1;
  54 static int count = 1;
  55 static int keep_em = 0;
  56 static int out_file_type = WTAP_FILE_PCAP;   /* default to "libpcap"   */
  57 static int out_frame_type = -2;              /* Leave frame type alone */
  58 static int verbose = 0;                      /* Not so verbose         */
  59 static unsigned int snaplen = 0;             /* No limit               */
  60 static struct time_adjustment time_adj = {{0, 0}, 0}; /* no adjustment */
  61
  62 /* Add a selection item, a simple parser for now */
  63
  64 static void add_selection(char *sel)
  65 {
  66   char *locn;
  67   char *next;
  68
  69   if (max_selected == (sizeof(selectfrm)/sizeof(struct select_item)) - 1)
  70     return;
  71
  72   printf("Add_Selected: %s\n", sel);
  73
  74   if ((locn = strchr(sel, '-')) == NULL) { /* No dash, so a single number? */
  75
  76     printf("Not inclusive ...");
  77
  78     max_selected++;
  79     selectfrm[max_selected].inclusive = 0;
  80     selectfrm[max_selected].first = atoi(sel);
  81
  82     printf(" %i\n", selectfrm[max_selected].first);
  83
  84   }
  85   else {
  86
  87     printf("Inclusive ...");
  88
  89     next = locn + 1;
  90     max_selected++;
  91     selectfrm[max_selected].inclusive = 1;
  92     selectfrm[max_selected].first = atoi(sel);
  93     selectfrm[max_selected].second = atoi(next);
  94
  95     printf(" %i, %i\n", selectfrm[max_selected].first, selectfrm[max_selected].second);
  96
  97   }
  98
  99
 100 }
 101
 102 /* Was the record selected? */
 103
 104 static int selected(int recno)
 105 {
 106   int i = 0;
 107
 108   for (i = 0; i<= max_selected; i++) {
 109
 110     if (selectfrm[i].inclusive) {
 111       if (selectfrm[i].first <= recno && selectfrm[i].second >= recno)
 112         return 1;
 113     }
 114     else {
 115       if (recno == selectfrm[i].first)
 116         return 1;
 117     }
 118   }
 119
 120   return 0;
 121
 122 }
 123
 124 /* An argument to the callback routine */
 125
 126 typedef struct {
 127         char    *filename;
 128         wtap_dumper *pdh;
 129 } callback_arg;
 130
 131 /*
 132  *The callback routine that is called for each frame in the input file
 133  */
 134
 135 static void
 136 edit_callback(guchar *user, const struct wtap_pkthdr *phdr, long offset _U_,
 137     union wtap_pseudo_header *pseudo_header, const guchar *buf)
 138 {
 139   callback_arg *argp = (callback_arg *)user;
 140   int err;
 141   struct wtap_pkthdr snap_phdr;
 142
 143   if ((!selected(count) && !keep_em) ||
 144       (selected(count) && keep_em)) {
 145
 146     if (verbose)
 147       printf("Record: %u\n", count);
 148
 149     /* We simply write it, perhaps after truncating it; we could do other
 150        things, like modify it. */
 151
 152     if (snaplen != 0 && phdr->caplen > snaplen) {
 153       snap_phdr = *phdr;
 154       snap_phdr.caplen = snaplen;
 155       phdr = &snap_phdr;
 156     }
 157
 158     /* assume that if the frame's tv_sec is 0, then
 159      * the timestamp isn't supported */
 160     if (phdr->ts.tv_sec > 0 && time_adj.tv.tv_sec != 0) {
 161       snap_phdr = *phdr;
 162       if (time_adj.is_negative)
 163         snap_phdr.ts.tv_sec -= time_adj.tv.tv_sec;
 164       else
 165         snap_phdr.ts.tv_sec += time_adj.tv.tv_sec;
 166       phdr = &snap_phdr;
 167     }
 168
 169     /* assume that if the frame's tv_sec is 0, then
 170      * the timestamp isn't supported */
 171     if (phdr->ts.tv_sec > 0 && time_adj.tv.tv_usec != 0) {
 172       snap_phdr = *phdr;
 173       if (time_adj.is_negative) { /* subtract */
 174         if (snap_phdr.ts.tv_usec < time_adj.tv.tv_usec) { /* borrow */
 175           snap_phdr.ts.tv_sec--;
 176           snap_phdr.ts.tv_usec += ONE_MILLION;
 177         }
 178         snap_phdr.ts.tv_usec -= time_adj.tv.tv_usec;
 179       } else {                  /* add */
 180         if (snap_phdr.ts.tv_usec + time_adj.tv.tv_usec > ONE_MILLION) {
 181           /* carry */
 182           snap_phdr.ts.tv_sec++;
 183           snap_phdr.ts.tv_usec += time_adj.tv.tv_usec - ONE_MILLION;
 184         } else {
 185           snap_phdr.ts.tv_usec += time_adj.tv.tv_usec;
 186         }
 187       }
 188       phdr = &snap_phdr;
 189     }
 190
 191     if (!wtap_dump(argp->pdh, phdr, pseudo_header, buf, &err)) {
 192
 193       fprintf(stderr, "editcap: Error writing to %s: %s\n", argp->filename,
 194         wtap_strerror(err));
 195       exit(1);
 196
 197     }
 198
 199   }
 200
 201   count++;
 202
 203 }
 204
 205 static void
 206 set_time_adjustment(char *optarg)
 207 {
 208   char *frac, *end;
 209   long val;
 210   int frac_digits;
 211
 212   if (!optarg)
 213     return;
 214
 215   /* skip leading whitespace */
 216   while (*optarg == ' ' || *optarg == '\t') {
 217       optarg++;
 218   }
 219
 220   /* check for a negative adjustment */
 221   if (*optarg == '-') {
 222       time_adj.is_negative = 1;
 223       optarg++;
 224   }
 225
 226   /* collect whole number of seconds, if any */
 227   if (*optarg == '.') {         /* only fractional (i.e., .5 is ok) */
 228       val  = 0;
 229       frac = optarg;
 230   } else {
 231       val = strtol(optarg, &frac, 10);
 232       if (frac == NULL || frac == optarg || val == LONG_MIN || val == LONG_MAX) {
 233           fprintf(stderr, "editcap: \"%s\" is not a valid ime adjustment\n",
 234                   optarg);
 235           exit(1);
 236       }
 237       if (val < 0) {            /* implies '--' since we caught '-' above  */
 238           fprintf(stderr, "editcap: \"%s\" is not a valid time adjustment\n",
 239                   optarg);
 240           exit(1);
 241       }
 242   }
 243   time_adj.tv.tv_sec = val;
 244
 245   /* now collect the partial seconds, if any */
 246   if (*frac != '\0') {             /* chars left, so get fractional part */
 247     val = strtol(&(frac[1]), &end, 10);
 248     if (*frac != '.' || end == NULL || end == frac
 249         || val < 0 || val > ONE_MILLION || val == LONG_MIN || val == LONG_MAX) {
 250       fprintf(stderr, "editcap: \"%s\" is not a valid time adjustment\n",
 251               optarg);
 252       exit(1);
 253     }
 254   }
 255   else {
 256     return;                     /* no fractional digits */
 257   }
 258
 259   /* adjust fractional portion from fractional to numerator
 260    * e.g., in "1.5" from 5 to 500000 since .5*10^6 = 500000 */
 261   if (frac && end) {            /* both are valid */
 262     frac_digits = end - frac - 1;   /* fractional digit count (remember '.') */
 263     while(frac_digits < 6) {    /* this is frac of 10^6 */
 264       val *= 10;
 265       frac_digits++;
 266     }
 267   }
 268   time_adj.tv.tv_usec = val;
 269 }
 270
 271 static void usage(void)
 272 {
 273   int i;
 274   const char *string;
 275
 276   fprintf(stderr, "Usage: editcap [-r] [-h] [-v] [-T <encap type>] [-F <capture type>]\n");
 277   fprintf(stderr, "               [-s <snaplen>] [-t <time adjustment>]\n");
 278   fprintf(stderr, "               <infile> <outfile> [ <record#>[-<record#>] ... ]\n");
 279   fprintf(stderr, "  where\t-r specifies that the records specified should be kept, not deleted, \n");
 280   fprintf(stderr, "                           default is to delete\n");
 281   fprintf(stderr, "       \t-v specifies verbose operation, default is silent\n");
 282   fprintf(stderr, "       \t-h produces this help listing.\n");
 283   fprintf(stderr, "       \t-T <encap type> specifies the encapsulation type to use:\n");
 284   for (i = 0; i < WTAP_NUM_ENCAP_TYPES; i++) {
 285       string = wtap_encap_short_string(i);
 286       if (string != NULL)
 287         fprintf(stderr, "       \t    %s - %s\n",
 288           string, wtap_encap_string(i));
 289   }
 290   fprintf(stderr, "       \t    default is the same as the input file\n");
 291   fprintf(stderr, "       \t-F <capture type> specifies the capture file type to write:\n");
 292   for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
 293     if (wtap_dump_can_open(i))
 294       fprintf(stderr, "       \t    %s - %s\n",
 295         wtap_file_type_short_string(i), wtap_file_type_string(i));
 296   }
 297   fprintf(stderr, "       \t    default is libpcap\n");
 298   fprintf(stderr, "       \t-s <snaplen> specifies that packets should be truncated to\n");
 299   fprintf(stderr, "       \t   <snaplen> bytes of data\n");
 300   fprintf(stderr, "       \t-t <time adjustment> specifies the time adjustment\n");
 301   fprintf(stderr, "       \t   to be applied to selected packets\n");
 302   fprintf(stderr, "\n      \t    A range of records can be specified as well\n");
 303 }
 304
 305 int main(int argc, char *argv[])
 306
 307 {
 308   wtap *wth;
 309   int i, err;
 310   gchar *err_info;
 311   callback_arg args;
 312   extern char *optarg;
 313   extern int optind;
 314   int opt;
 315   char *p;
 316   int snapshot_length;
 317
 318   /* Process the options first */
 319
 320   while ((opt = getopt(argc, argv, "T:F:rvs:t:h")) !=-1) {
 321
 322     switch (opt) {
 323
 324     case 'T':
 325       out_frame_type = wtap_short_string_to_encap(optarg);
 326       if (out_frame_type < 0) {
 327         fprintf(stderr, "editcap: \"%s\" is not a valid encapsulation type\n",
 328             optarg);
 329         exit(1);
 330       }
 331       break;
 332
 333     case 'F':
 334       out_file_type = wtap_short_string_to_file_type(optarg);
 335       if (out_file_type < 0) {
 336         fprintf(stderr, "editcap: \"%s\" is not a valid capture file type\n",
 337             optarg);
 338         exit(1);
 339       }
 340       break;
 341
 342     case 'v':
 343       verbose = !verbose;  /* Just invert */
 344       break;
 345
 346     case 'r':
 347       keep_em = !keep_em;  /* Just invert */
 348       break;
 349
 350     case 's':
 351       snaplen = strtol(optarg, &p, 10);
 352       if (p == optarg || *p != '\0') {
 353         fprintf(stderr, "editcap: \"%s\" is not a valid snapshot length\n",
 354             optarg);
 355         exit(1);
 356       }
 357       break;
 358
 359     case 't':
 360       set_time_adjustment(optarg);
 361       break;
 362
 363     case 'h':
 364       usage();
 365       exit(1);
 366       break;
 367
 368     case '?':              /* Bad options if GNU getopt */
 369       usage();
 370       exit(1);
 371       break;
 372
 373     }
 374
 375   }
 376
 377 #ifdef DEBUG
 378   printf("Optind = %i, argc = %i\n", optind, argc);
 379 #endif
 380
 381   if ((argc - optind) < 1) {
 382
 383     usage();
 384     exit(1);
 385
 386   }
 387
 388   wth = wtap_open_offline(argv[optind], &err, &err_info, FALSE);
 389
 390   if (!wth) {
 391     fprintf(stderr, "editcap: Can't open %s: %s\n", argv[optind],
 392         wtap_strerror(err));
 393     switch (err) {
 394
 395     case WTAP_ERR_UNSUPPORTED:
 396     case WTAP_ERR_UNSUPPORTED_ENCAP:
 397     case WTAP_ERR_BAD_RECORD:
 398       fprintf(stderr, "(%s)\n", err_info);
 399       g_free(err_info);
 400       break;
 401     }
 402     exit(1);
 403
 404   }
 405
 406   if (verbose) {
 407
 408     fprintf(stderr, "File %s is a %s capture file.\n", argv[optind],
 409             wtap_file_type_string(wtap_file_type(wth)));
 410
 411   }
 412
 413   /*
 414    * Now, process the rest, if any ... we only write if there is an extra
 415    * argument or so ...
 416    */
 417
 418   if ((argc - optind) >= 2) {
 419
 420     args.filename = argv[optind + 1];
 421     if (out_frame_type == -2)
 422       out_frame_type = wtap_file_encap(wth);
 423
 424     snapshot_length = wtap_snapshot_length(wth);
 425     if (snapshot_length == 0) {
 426       /* Snapshot length of input file not known. */
 427       snapshot_length = WTAP_MAX_PACKET_SIZE;
 428     }
 429     args.pdh = wtap_dump_open(argv[optind + 1], out_file_type,
 430                               out_frame_type, wtap_snapshot_length(wth), &err);
 431     if (args.pdh == NULL) {
 432
 433       fprintf(stderr, "editcap: Can't open or create %s: %s\n", argv[optind+1],
 434               wtap_strerror(err));
 435       exit(1);
 436
 437     }
 438
 439     for (i = optind + 2; i < argc; i++)
 440       add_selection(argv[i]);
 441
 442     if (!wtap_loop(wth, 0, edit_callback, (char *)&args, &err, &err_info)) {
 443       /* Print a message noting that the read failed somewhere along the line. */
 444       fprintf(stderr,
 445               "editcap: An error occurred while reading \"%s\": %s.\n",
 446               argv[optind], wtap_strerror(err));
 447       switch (err) {
 448
 449       case WTAP_ERR_UNSUPPORTED:
 450       case WTAP_ERR_UNSUPPORTED_ENCAP:
 451       case WTAP_ERR_BAD_RECORD:
 452         fprintf(stderr, "(%s)\n", err_info);
 453         break;
 454       }
 455     }
 456
 457     if (!wtap_dump_close(args.pdh, &err)) {
 458
 459       fprintf(stderr, "editcap: Error writing to %s: %s\n", argv[2],
 460               wtap_strerror(err));
 461       exit(1);
 462
 463     }
 464   }
 465
 466   return 0;
 467 }
 468