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.
 154  *
 155  * On success, set *err to 0 and return a pointer to the merge_in_file_t
 156  * for the file from which the packet was read.
 157  *
 158  * On a read error, set *err to the error and return a pointer to the
 159  * merge_in_file_t for the file on which we got an error.
 160  *
 161  * On an EOF (meaning all the files are at EOF), set *err to 0 and return
 162  * NULL.
 163  */
 164 merge_in_file_t *
 165 merge_read_packet(int in_file_count, merge_in_file_t in_files[],
 166                   int *err, gchar **err_info)
 167 {
 168   int i;
 169   int ei = -1;
 170   struct wtap_nstime tv = { sizeof(time_t) > sizeof(int) ? LONG_MAX : INT_MAX, INT_MAX };
 171   struct wtap_pkthdr *phdr;
 172
 173   /*
 174    * Make sure we have a packet available from each file, if there are any
 175    * packets left in the file in question, and search for the packet
 176    * with the earliest time stamp.
 177    */
 178   for (i = 0; i < in_file_count; i++) {
 179     if (in_files[i].state == PACKET_NOT_PRESENT) {
 180       /*
 181        * No packet available, and we haven't seen an error or EOF yet,
 182        * so try to read the next packet.
 183        */
 184       if (!wtap_read(in_files[i].wth, err, err_info, &in_files[i].data_offset)) {
 185         if (*err != 0) {
 186           in_files[i].state = GOT_ERROR;
 187           return NULL;
 188         }
 189         in_files[i].state = AT_EOF;
 190       } else
 191         in_files[i].state = PACKET_PRESENT;
 192     }
 193
 194     if (in_files[i].state == PACKET_PRESENT) {
 195       phdr = wtap_phdr(in_files[i].wth);
 196       if (is_earlier(&phdr->ts, &tv)) {
 197         tv = phdr->ts;
 198         ei = i;
 199       }
 200     }
 201   }
 202
 203   if (ei == -1) {
 204     /* All the streams are at EOF.  Return an EOF indication. */
 205     *err = 0;
 206     return NULL;
 207   }
 208
 209   /* We'll need to read another packet from this file. */
 210   in_files[ei].state = PACKET_NOT_PRESENT;
 211
 212   /* Count this packet. */
 213   in_files[ei].packet_num++;
 214
 215   /* Return the ordinal of the file from which the packet was read. */
 216   return &in_files[ei];
 217 }
 218
 219 /*
 220  * Read the next packet, in file sequence order, from the set of files
 221  * to be merged.
 222  *
 223  * On success, set *err to 0 and return a pointer to the merge_in_file_t
 224  * for the file from which the packet was read.
 225  *
 226  * On a read error, set *err to the error and return a pointer to the
 227  * merge_in_file_t for the file on which we got an error.
 228  *
 229  * On an EOF (meaning all the files are at EOF), set *err to 0 and return
 230  * NULL.
 231  */
 232 merge_in_file_t *
 233 merge_append_read_packet(int in_file_count, merge_in_file_t in_files[],
 234                          int *err, gchar **err_info)
 235 {
 236   int i;
 237
 238   /*
 239    * Find the first file not at EOF, and read the next packet from it.
 240    */
 241   for (i = 0; i < in_file_count; i++) {
 242     if (in_files[i].state == AT_EOF)
 243       continue; /* This file is already at EOF */
 244     if (wtap_read(in_files[i].wth, err, err_info, &in_files[i].data_offset))
 245       break; /* We have a packet */
 246     if (*err != 0) {
 247       /* Read error - quit immediately. */
 248       in_files[i].state = GOT_ERROR;
 249       return &in_files[i];
 250     }
 251     /* EOF - flag this file as being at EOF, and try the next one. */
 252     in_files[i].state = AT_EOF;
 253   }
 254   if (i == in_file_count) {
 255     /* All the streams are at EOF.  Return an EOF indication. */
 256     *err = 0;
 257     return NULL;
 258   }
 259
 260   /* Return the ordinal of the file from which the packet was read. */
 261   *err = 0;
 262   return &in_files[i];
 263 }