a489fc233aeb21976e463e27fa8e4b43ac43a9f6
[obnox/wireshark/wip.git] / merge.c
1 /* Combine multiple dump files, either by appending or by merging by timestamp
2  *
3  * $Id$
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 #include <errno.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 #include "merge.h"
30
31 /*
32  * Scan through the arguments and open the input files
33  */
34 gboolean
35 merge_open_in_files(int in_file_count, char *const *in_file_names,
36                     merge_in_file_t **in_files, int *err, gchar **err_info,
37                     int *err_fileno)
38 {
39   int i, j;
40   size_t files_size = in_file_count * sizeof(merge_in_file_t);
41   merge_in_file_t *files;
42   gint64 size;
43
44   files = (merge_in_file_t *)g_malloc(files_size);
45   *in_files = files;
46
47   for (i = 0; i < in_file_count; i++) {
48     files[i].filename    = in_file_names[i];
49     files[i].wth         = wtap_open_offline(in_file_names[i], err, err_info, FALSE);
50     files[i].data_offset = 0;
51     files[i].state       = PACKET_NOT_PRESENT;
52     files[i].packet_num  = 0;
53     if (!files[i].wth) {
54       /* Close the files we've already opened. */
55       for (j = 0; j < i; j++)
56         wtap_close(files[j].wth);
57       *err_fileno = i;
58       return FALSE;
59     }
60     size = wtap_file_size(files[i].wth, err);
61     if (size == -1) {
62       for (j = 0; j <= i; j++)
63         wtap_close(files[j].wth);
64       *err_fileno = i;
65       return FALSE;
66     }
67     files[i].size = size;
68   }
69   return TRUE;
70 }
71
72 /*
73  * Scan through and close each input file
74  */
75 void
76 merge_close_in_files(int count, merge_in_file_t in_files[])
77 {
78   int i;
79   for (i = 0; i < count; i++) {
80     wtap_close(in_files[i].wth);
81   }
82 }
83
84 /*
85  * Select an output frame type based on the input files
86  * From Guy: If all files have the same frame type, then use that.
87  *           Otherwise select WTAP_ENCAP_PER_PACKET.  If the selected
88  *           output file type doesn't support per packet frame types,
89  *           then the wtap_dump_open call will fail with a reasonable
90  *           error condition.
91  */
92 int
93 merge_select_frame_type(int count, merge_in_file_t files[])
94 {
95   int i;
96   int selected_frame_type;
97
98   selected_frame_type = wtap_file_encap(files[0].wth);
99
100   for (i = 1; i < count; i++) {
101     int this_frame_type = wtap_file_encap(files[i].wth);
102     if (selected_frame_type != this_frame_type) {
103       selected_frame_type = WTAP_ENCAP_PER_PACKET;
104       break;
105     }
106   }
107
108   return selected_frame_type;
109 }
110
111 /*
112  * Scan through input files and find maximum snapshot length
113  */
114 int
115 merge_max_snapshot_length(int count, merge_in_file_t in_files[])
116 {
117   int i;
118   int max_snapshot = 0;
119   int snapshot_length;
120
121   for (i = 0; i < count; i++) {
122     snapshot_length = wtap_snapshot_length(in_files[i].wth);
123     if (snapshot_length == 0) {
124       /* Snapshot length of input file not known. */
125       snapshot_length = WTAP_MAX_PACKET_SIZE;
126     }
127     if (snapshot_length > max_snapshot)
128       max_snapshot = snapshot_length;
129   }
130   return max_snapshot;
131 }
132
133 /*
134  * returns TRUE if first argument is earlier than second
135  */
136 static gboolean
137 is_earlier(struct wtap_nstime *l, struct wtap_nstime *r) {
138   if (l->secs > r->secs) {  /* left is later */
139     return FALSE;
140   } else if (l->secs < r->secs) { /* left is earlier */
141     return TRUE;
142   } else if (l->nsecs > r->nsecs) { /* tv_sec equal, l.usec later */
143     return FALSE;
144   }
145   /* either one < two or one == two
146    * either way, return one
147    */
148   return TRUE;
149 }
150
151 /*
152  * Read the next packet, in chronological order, from the set of files
153  * to be merged.  Return a pointer to the merge_in_file_t for the file
154  * from which the packet was read on success, or NULL on EOF or error.
155  * On EOF, *err is 0; on an error, it's an error code.
156  */
157 merge_in_file_t *
158 merge_read_packet(int in_file_count, merge_in_file_t in_files[],
159                   int *err, gchar **err_info)
160 {
161   int i;
162   int ei = -1;
163   struct wtap_nstime tv = { sizeof(time_t) > sizeof(int) ? LONG_MAX : INT_MAX, INT_MAX };
164   struct wtap_pkthdr *phdr;
165
166   /*
167    * Make sure we have a packet available from each file, if there are any
168    * packets left in the file in question, and search for the packet
169    * with the earliest time stamp.
170    */
171   for (i = 0; i < in_file_count; i++) {
172     if (in_files[i].state == PACKET_NOT_PRESENT) {
173       /*
174        * No packet available, and we haven't seen an error or EOF yet,
175        * so try to read the next packet.
176        */
177       if (!wtap_read(in_files[i].wth, err, err_info, &in_files[i].data_offset)) {
178         if (*err != 0) {
179           in_files[i].state = GOT_ERROR;
180           return NULL;
181         }
182         in_files[i].state = AT_EOF;
183       } else
184         in_files[i].state = PACKET_PRESENT;
185     }
186     
187     if (in_files[i].state == PACKET_PRESENT) {
188       phdr = wtap_phdr(in_files[i].wth);
189       if (is_earlier(&phdr->ts, &tv)) {
190         tv = phdr->ts;
191         ei = i;
192       }
193     }
194   }
195
196   if (ei == -1) {
197     /* All the streams are at EOF.  Return an EOF indication. */
198     *err = 0;
199     return NULL;
200   }
201
202   /* We'll need to read another packet from this file. */
203   in_files[ei].state = PACKET_NOT_PRESENT;
204
205   /* Count this packet. */
206   in_files[ei].packet_num++;
207
208   /* Return the ordinal of the file from which the packet was read. */
209   return &in_files[ei];
210 }
211
212 /*
213  * Read the next packet, in file sequence order, from the set of files
214  * to be merged.  Return a pointer to the merge_in_file_t for the file
215  * from which the packet was read on success, or NULL on EOF or error.
216  * On EOF, *err is 0; on an error, it's an error code.
217  */
218 merge_in_file_t *
219 merge_append_read_packet(int in_file_count, merge_in_file_t in_files[],
220                          int *err, gchar **err_info)
221 {
222   int i;
223
224   /*
225    * Find the first file not at EOF, and read the next packet from it.
226    */
227   for (i = 0; i < in_file_count; i++) {
228     if (in_files[i].state == AT_EOF)
229       continue; /* This file is already at EOF */
230     if (wtap_read(in_files[i].wth, err, err_info, &in_files[i].data_offset))
231       break; /* We have a packet */
232     if (*err != 0) {
233       /* Read error - quit immediately. */
234       in_files[i].state = GOT_ERROR;
235       return NULL;
236     }
237     /* EOF - flag this file as being at EOF, and try the next one. */
238     in_files[i].state = AT_EOF;
239   }
240   if (i == in_file_count) {
241     /* All the streams are at EOF.  Return an EOF indication. */
242     *err = 0;
243     return NULL;
244   }
245
246   /* Return the ordinal of the file from which the packet was read. */
247   return &in_files[i];
248 }