Update from Scott Renfro to allow mergecap to merge multiple capture
[obnox/wireshark/wip.git] / mergecap.c
1 /* Combine two dump files, either by appending or by merging by timestamp
2  *
3  * $Id: mergecap.c,v 1.2 2001/07/13 08:16:15 guy Exp $
4  *
5  * Written by Scott Renfro <scott@renfro.org> based on
6  * editcap by Richard Sharpe and Guy Harris
7  *
8  */
9
10 #ifdef HAVE_CONFIG_H
11 #include "config.h"
12 #endif
13
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <glib.h>
17
18 #ifdef HAVE_UNISTD_H
19 #include <unistd.h>
20 #endif
21
22 #ifdef HAVE_SYS_TIME_H
23 #include <sys/time.h>
24 #endif
25
26 #ifdef HAVE_WINSOCK_H
27 #include <winsock.h>
28 #endif
29
30 #include <string.h>
31 #include "wtap.h"
32
33 #ifdef NEED_GETOPT_H
34 #include "getopt.h"
35 #endif
36
37
38 /*
39  * Global variables
40  */
41 static int verbose = 0;                      /* Not so verbose         */
42
43 /* 
44  * Structures to manage our files
45  */
46 typedef struct in_file_t {
47   const char *filename;
48   wtap       *wth;
49   int         err;
50   int         data_offset;
51   gboolean    ok;
52 } in_file_t;
53
54 typedef struct out_file_t {
55   const char  *filename;
56   wtap_dumper *pdh;
57   int          file_type;
58   int          frame_type;
59   unsigned int snaplen;
60   int          count;
61 } out_file_t;
62 static out_file_t out_file;
63
64 /*
65  * Routine to write frame to output file
66  */
67 static void
68 write_frame(u_char *user, const struct wtap_pkthdr *phdr, int offset,
69             union wtap_pseudo_header *pseudo_header, const u_char *buf) 
70 {
71   wtap_dumper *pdh = (wtap_dumper*)user;
72   int err;
73   struct wtap_pkthdr snap_phdr;
74   
75   if (verbose)
76     printf("Record: %u\n", out_file.count++);
77
78   /* We simply write it, perhaps after truncating it; we could do other
79    * things, like modify it. */
80   if (out_file.snaplen != 0 && phdr->caplen > out_file.snaplen) {
81     snap_phdr = *phdr;
82     snap_phdr.caplen = out_file.snaplen;
83     phdr = &snap_phdr;
84   }
85
86   if (!wtap_dump(pdh, phdr, pseudo_header, buf, &err)) {
87     fprintf(stderr, "mergecap: Error writing to %s: %s\n",
88             out_file.filename, wtap_strerror(err));
89     exit(1);
90   }
91 }
92
93
94 /*
95  * routine to concatenate files
96  */
97 static void
98 append(int count, in_file_t in_files[], out_file_t *out_file)
99 {
100   int i;
101   int err;
102
103   for (i = 0; i < count; i++) {
104     if (!wtap_loop(in_files[i].wth, 0, write_frame,
105                    (u_char*)out_file->pdh, &err)) {
106     fprintf(stderr, "mergecap: Error appending from %s to %s: %s\n",
107             in_files[i].filename, out_file->filename, wtap_strerror(err));
108     }
109   }
110 }
111
112
113 /*
114  * returns TRUE if first argument is earlier than second
115  */
116 static gboolean
117 is_earlier(struct timeval *l, struct timeval *r) {     
118   if (l->tv_sec > r->tv_sec) {  /* left is later */
119     return FALSE;
120   } else if (l->tv_sec < r->tv_sec) { /* left is earlier */
121     return TRUE;
122   } else if (l->tv_usec > r->tv_usec) { /* tv_sec equal, l.usec later */
123     return FALSE;
124   }
125   /* either one < two or one == two
126    * either way, return one
127    */
128   return TRUE;    
129 }
130
131
132 /*
133  * returns index of earliest timestamp in set of input files
134  * or -1 if no valid files remain
135  */
136 static int
137 earliest(int count, in_file_t in_files[]) {
138   int i;
139   int ei = -1;
140   struct timeval tv = {LONG_MAX, LONG_MAX};
141
142   for (i = 0; i < count; i++) {
143     struct wtap_pkthdr *phdr = wtap_phdr(in_files[i].wth);
144
145     if (in_files[i].ok && is_earlier(&(phdr->ts), &tv)) {
146       tv = phdr->ts;
147       ei = i;
148     }
149   }
150   return ei;
151 }
152  
153 /*
154  * actually merge the files
155  */
156 static void
157 merge(int count, in_file_t in_files[], out_file_t *out_file)
158 {
159   int i;
160   int data_offset_1, data_offset_2, loop = 0;
161   gboolean ok_1, ok_2;
162
163   /* prime the pump (read in first frame from each file) */
164   for (i = 0; i < count; i++) {
165     in_files[i].ok = wtap_read(in_files[i].wth, &(in_files[i].err),
166                                &(in_files[i].data_offset));
167   }
168
169   /* now keep writing the earliest frame until we're out of frames */
170   while ( -1 != (i = earliest(count, in_files))) {
171     
172     /* write out earliest frame, and fetch another from its
173      * input file
174      */
175     write_frame((u_char*)out_file->pdh,
176                 wtap_phdr(in_files[i].wth),
177                 in_files[i].data_offset,
178                 wtap_pseudoheader(in_files[i].wth),
179                 wtap_buf_ptr(in_files[i].wth));
180     in_files[i].ok = wtap_read(in_files[i].wth, &(in_files[i].err),
181                                 &(in_files[i].data_offset));
182   }
183 }
184
185
186 /*
187  * Close the output file
188  */
189 static void
190 close_outfile(out_file_t *out_file)
191 {
192   int err;
193   if (!wtap_dump_close(out_file->pdh, &err)) {
194     fprintf(stderr, "mergecap: Error closing file %s: %s\n",
195             out_file->filename, wtap_strerror(err));
196     exit(1);
197   }
198 }
199
200
201 /*
202  * Open the output file
203  *
204  * Return FALSE if file cannot be opened (so caller can clean up)
205  */
206 static gboolean
207 open_outfile(out_file_t *out_file, int snapshot_len)
208 {
209   int err;
210   if (!out_file) {
211     fprintf(stderr, "mergecap: internal error (null out_file)\n");
212     exit(1);
213   }
214
215   out_file->pdh = wtap_dump_open(out_file->filename, out_file->file_type,
216                                  out_file->frame_type, snapshot_len, &err);
217   if (!out_file->pdh) {
218     fprintf(stderr, "mergecap: Can't open/create %s: %s\n",
219             out_file->filename, wtap_strerror(err));
220     return FALSE;
221   }
222   return TRUE;
223 }
224
225
226 /*
227  * Scan through input files and find maximum snapshot length
228  */
229 static int
230 max_snapshot_length(int count, in_file_t in_files[])
231 {
232   int i;
233   int max_snapshot = 0;
234
235   for (i = 0; i < count; i++) {
236     if (wtap_snapshot_length(in_files[i].wth) > max_snapshot)
237       max_snapshot = wtap_snapshot_length(in_files[i].wth);
238   }
239   return max_snapshot;
240 }
241
242
243 /*
244  * Scan through and close each input file
245  */
246 static void
247 close_in_files(int count, in_file_t in_files[])
248 {
249   int i;
250   for (i = 0; i < count; i++) {
251     wtap_close(in_files[i].wth);
252   }
253 }
254
255
256 /*
257  * Scan through the arguments and open the input files
258  */
259 static int
260 open_in_files(int argc, char *argv[], in_file_t *in_files[])
261 {
262   int i;
263   int count = 0;
264   int err;
265   in_file_t *files;
266   int files_size = argc * sizeof(in_file_t);
267   
268
269   files = malloc(files_size);
270   if (!files) {
271     fprintf(stderr, "mergecap: error allocating %d bytes of memory\n",
272             files_size);
273     exit(1);
274   }
275   *in_files = files;
276
277   for (i = 0; i < argc; i++) {
278     files[count].filename    = argv[i];
279     files[count].wth         = wtap_open_offline(argv[i], &err, FALSE);
280     files[count].err         = 0;
281     files[count].data_offset = 0;
282     files[count].ok          = TRUE;
283     if (!files[count].wth) {
284       fprintf(stderr, "mergecap: skipping %s: %s\n", argv[i],
285               wtap_strerror(err));
286     } else {
287       if (verbose) {
288         fprintf(stderr, "File %s is a %s capture file.\n", argv[i],
289                 wtap_file_type_string(wtap_file_type(files[count].wth)));
290       }
291       count++;
292     }
293   }
294   if (verbose)
295     fprintf(stderr, "mergecap: opened %d of %d input files\n", count,
296     argc);
297
298   return count;
299 }
300
301
302 /*
303  * Show the usage
304  */  
305 static void
306 usage()
307 {
308   int i;
309   const char *string;
310
311   fprintf(stderr, "Usage: mergecap [-h] [-v] [-a] [-s <snaplen>] [-T <encap type>]\n");
312   fprintf(stderr, "          [-F <capture type>] -w <outfile> <infile> [...]\n\n");
313   fprintf(stderr, "  where\t-h produces this help listing.\n");
314   fprintf(stderr, "       \t-v verbose operation, default is silent\n");
315   fprintf(stderr, "       \t-a files should be concatenated, not merged\n");
316   fprintf(stderr, "       \t     Default merges based on frame timestamps\n");
317   fprintf(stderr, "       \t-s <snaplen>: truncate packets to <snaplen> bytes of data\n");
318   fprintf(stderr, "       \t-w <outfile>: sets output filename to <outfile>\n");
319   fprintf(stderr, "       \t-T <encap type> encapsulation type to use:\n");
320   for (i = 0; i < WTAP_NUM_ENCAP_TYPES; i++) {
321       string = wtap_encap_short_string(i);
322       if (string != NULL)
323         fprintf(stderr, "       \t     %s - %s\n",
324           string, wtap_encap_string(i));
325   }
326   fprintf(stderr, "       \t     default is the same as the first input file\n");
327   fprintf(stderr, "       \t-F <capture type> capture file type to write:\n");
328   for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
329     if (wtap_dump_can_open(i))
330       fprintf(stderr, "       \t     %s - %s\n",
331         wtap_file_type_short_string(i), wtap_file_type_string(i));
332   }
333   fprintf(stderr, "       \t     default is libpcap\n");
334 }
335
336
337
338 int
339 main(int argc, char *argv[])
340 {
341   int          i;
342   extern char *optarg;
343   extern int   optind;
344   int          opt;
345   char        *p;
346   gboolean     do_append     = FALSE;
347   int          in_file_count = 0;
348   in_file_t   *in_files      = NULL;
349   
350   /* initialize out_file */
351   out_file.filename   = NULL;   
352   out_file.pdh        = NULL;              /* wiretap dumpfile */
353   out_file.file_type  = WTAP_FILE_PCAP;    /* default to "libpcap" */
354   out_file.frame_type = -2;                /* leave type alone */
355   out_file.snaplen    = 0;                 /* no limit */
356   out_file.count      = 1;                 /* frames output */
357
358   /* Process the options first */
359   while ((opt = getopt(argc, argv, "w:aT:F:vs:h")) != EOF) {
360
361     switch (opt) {
362     case 'w':
363       out_file.filename = optarg;
364       break;
365         
366     case 'a':
367       do_append = !do_append;
368       break;
369     
370     case 'T':
371       out_file.frame_type = wtap_short_string_to_encap(optarg);
372       if (out_file.frame_type < 0) {
373         fprintf(stderr, "mergecap: \"%s\" is not a valid encapsulation type\n",
374             optarg);
375         exit(1);
376       }
377       break;
378
379     case 'F':
380       out_file.file_type = wtap_short_string_to_file_type(optarg);
381       if (out_file.file_type < 0) {
382         fprintf(stderr, "mergecap: \"%s\" is not a valid capture file type\n",
383             optarg);
384         exit(1);
385       }
386       break;
387
388     case 'v':
389       verbose = !verbose;  /* Just invert */
390       break;
391
392     case 's':
393       out_file.snaplen = strtol(optarg, &p, 10);
394       if (p == optarg || *p != '\0') {
395         fprintf(stderr, "mergecap: \"%s\" is not a valid snapshot length\n",
396             optarg);
397         exit(1);
398       }
399       break;
400
401     case 'h':
402       fprintf(stderr, "mergecap version %s\n", VERSION);
403       usage();
404       exit(1);
405       break;
406
407     case '?':              /* Bad options if GNU getopt */
408       usage();
409       exit(1);
410       break;
411
412     }
413
414   }
415
416   /* check for proper args; at a minimum, must have an output
417    * filename and one input file
418    */
419   in_file_count = argc - optind;
420   if (!out_file.filename) {
421     fprintf(stderr, "mergecap: an output filename must be set with -w\n");
422     usage();
423     exit(1);
424   }
425
426   /* open the input files */
427   in_file_count = open_in_files(in_file_count, &argv[optind], &in_files);
428   if (in_file_count < 1) {
429     fprintf(stderr, "mergecap: No valid input files\n");
430     exit(1);
431   }
432
433   /* set the outfile frame type */
434   if (out_file.frame_type == -2)
435     out_file.frame_type = wtap_file_encap(in_files[0].wth);
436   
437   /* open the outfile */
438   if (!open_outfile(&out_file, max_snapshot_length(in_file_count, in_files))) {
439     close_in_files(in_file_count, in_files);
440     exit(1);
441   }
442
443   /* do the merge (or append) */
444   if (do_append)
445     append(in_file_count, in_files, &out_file);
446   else
447     merge(in_file_count, in_files, &out_file);
448
449   close_in_files(in_file_count, in_files);
450   close_outfile(&out_file);
451
452   free(in_files);
453
454   return 0;
455 }