Remove all the verbose-mode code from merge.c, and put most of it in

mergecap.c (get rid of the verbose printing of information for each
packet).

Have "merge_append_files()" return FALSE only on a write error, as
"merge_files()" does.

Sort the routines in "merge.c" in the order from "merge.h".

svn path=/trunk/; revision=12422

1 files changed, 147 insertions, 231 deletions

diff --git a/merge.c b/merge.c
index 2c7c7b566f..5d5f88298b 100644
--- a/merge.c
+++ b/merge.c
@@ -28,99 +28,152 @@
 #include "merge.h"
 
 /*
- * Global variables
+ * Scan through the arguments and open the input files
  */
-int merge_verbose = VERBOSE_NONE;
+gboolean
+merge_open_in_files(int in_file_count, char *const *in_file_names,
+                    merge_in_file_t **in_files, int *err, gchar **err_info,
+                    int *err_fileno)
+{
+  int i, j;
+  int files_size = in_file_count * sizeof(merge_in_file_t);
+  merge_in_file_t *files;
 
+  files = g_malloc(files_size);
+  *in_files = files;
+
+  for (i = 0; i < in_file_count; i++) {
+    files[i].filename    = in_file_names[i];
+    files[i].wth         = wtap_open_offline(in_file_names[i], err, err_info, FALSE);
+    files[i].err         = 0;
+    files[i].data_offset = 0;
+    files[i].ok          = TRUE;
+    if (!files[i].wth) {
+      /* Close the files we've already opened. */
+      for (j = 0; j < i; j++)
+        wtap_close(files[j].wth);
+      *err_fileno = i;
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
 
 /*
- * Routine to write frame to output file
+ * Scan through and close each input file
  */
-static gboolean
-write_frame(wtap *wth, merge_out_file_t *out_file, int *err)
+void
+merge_close_in_files(int count, merge_in_file_t in_files[])
 {
-  const struct wtap_pkthdr *phdr = wtap_phdr(wth);
-  struct wtap_pkthdr snap_phdr;
-
-  if (merge_verbose == VERBOSE_ALL)
-    fprintf(stderr, "Record: %u\n", out_file->count++);
-
-  /* We simply write it, perhaps after truncating it; we could do other
-   * things, like modify it. */
-  if (out_file->snaplen != 0 && phdr->caplen > out_file->snaplen) {
-    snap_phdr = *phdr;
-    snap_phdr.caplen = out_file->snaplen;
-    phdr = &snap_phdr;
+  int i;
+  for (i = 0; i < count; i++) {
+    wtap_close(in_files[i].wth);
   }
+}
 
-  if (!wtap_dump(out_file->pdh, phdr, wtap_pseudoheader(wth), wtap_buf_ptr(wth), err)) {
-    if (merge_verbose == VERBOSE_ERRORS)
-      fprintf(stderr, "mergecap: Error writing to outfile: %s\n",
-            wtap_strerror(*err));
+/*
+ * Open the output file
+ *
+ * Return FALSE if file cannot be opened (so caller can report an error
+ * and clean up)
+ */
+gboolean
+merge_open_outfile(merge_out_file_t *out_file, int fd, int file_type,
+                   int frame_type, int snapshot_len, int *err)
+{
+  out_file->pdh = wtap_dump_fdopen(fd, file_type, frame_type, snapshot_len,
+                                   err);
+  if (!out_file->pdh)
     return FALSE;
-  }
 
+  out_file->snaplen = snapshot_len;
+  out_file->count = 1;
   return TRUE;
 }
 
-
-static gboolean
-append_loop(wtap *wth, int count, merge_out_file_t *out_file, int *err,
-    gchar **err_info)
+/*
+ * Close the output file
+ */
+gboolean
+merge_close_outfile(merge_out_file_t *out_file, int *err)
 {
-	long		data_offset;
-	int		loop = 0;
-
-	/* Start by clearing error flag */
-	*err = 0;
-
-	while ( (wtap_read(wth, err, err_info, &data_offset)) ) {
-		if(!write_frame(wth, out_file, err))
-            return FALSE;   /* failure */
-		if (count > 0 && ++loop >= count)
-			break;
-	}
-
-    if (*err == 0) {
-		return TRUE;	/* success */
-    } else {
-		return FALSE;	/* failure */
-    }
+  if (!wtap_dump_close(out_file->pdh, err))
+    return FALSE;
+  return TRUE;
 }
 
+/*
+ * Select an output frame type based on the input files
+ * From Guy: If all files have the same frame type, then use that.
+ *           Otherwise select WTAP_ENCAP_PER_PACKET.  If the selected
+ *           output file type doesn't support per packet frame types,
+ *           then the wtap_dump_open call will fail with a reasonable
+ *           error condition.
+ */
+int
+merge_select_frame_type(int count, merge_in_file_t files[])
+{
+  int i;
+  int selected_frame_type;
 
+  selected_frame_type = wtap_file_encap(files[0].wth);
+
+  for (i = 1; i < count; i++) {
+    int this_frame_type = wtap_file_encap(files[i].wth);
+    if (selected_frame_type != this_frame_type) {
+      selected_frame_type = WTAP_ENCAP_PER_PACKET;
+      break;
+    }
+  }
+
+  return selected_frame_type;
+}
 
 /*
- * routine to concatenate files
+ * Scan through input files and find maximum snapshot length
  */
-gboolean
-merge_append_files(int count, merge_in_file_t in_files[], merge_out_file_t *out_file, int *err)
+int
+merge_max_snapshot_length(int count, merge_in_file_t in_files[])
 {
   int i;
-  gchar *err_info;
+  int max_snapshot = 0;
+  int snapshot_length;
 
   for (i = 0; i < count; i++) {
-    if (!append_loop(in_files[i].wth, 0, out_file, err, &err_info)) {
-        if (merge_verbose == VERBOSE_ERRORS)
-          fprintf(stderr, "mergecap: Error appending %s to outfile: %s\n",
-                  in_files[i].filename, wtap_strerror(*err));
-          switch (*err) {
-
-          case WTAP_ERR_UNSUPPORTED:
-          case WTAP_ERR_UNSUPPORTED_ENCAP:
-          case WTAP_ERR_BAD_RECORD:
-	      fprintf(stderr, "(%s)\n", err_info);
-
-	    break;
-      }
-      return FALSE;
+    snapshot_length = wtap_snapshot_length(in_files[i].wth);
+    if (snapshot_length == 0) {
+      /* Snapshot length of input file not known. */
+      snapshot_length = WTAP_MAX_PACKET_SIZE;
     }
+    if (snapshot_length > max_snapshot)
+      max_snapshot = snapshot_length;
   }
+  return max_snapshot;
+}
+
+/*
+ * Routine to write frame to output file
+ */
+static gboolean
+write_frame(wtap *wth, merge_out_file_t *out_file, int *err)
+{
+  const struct wtap_pkthdr *phdr = wtap_phdr(wth);
+  struct wtap_pkthdr snap_phdr;
+
+  /* We simply write it, perhaps after truncating it; we could do other
+   * things, like modify it. */
+  if (out_file->snaplen != 0 && phdr->caplen > out_file->snaplen) {
+    snap_phdr = *phdr;
+    snap_phdr.caplen = out_file->snaplen;
+    phdr = &snap_phdr;
+  }
+
+  if (!wtap_dump(out_file->pdh, phdr, wtap_pseudoheader(wth), wtap_buf_ptr(wth), err))
+    return FALSE;
 
   return TRUE;
 }
 
-
 /*
  * returns TRUE if first argument is earlier than second
  */
@@ -174,6 +227,10 @@ merge_files(int count, merge_in_file_t in_files[], merge_out_file_t *out_file, i
     in_files[i].ok = wtap_read(in_files[i].wth, &(in_files[i].err),
                                &(in_files[i].err_info),
                                &(in_files[i].data_offset));
+    if (!in_files[i].ok) {
+      /* Read failure, not write failure. */
+      return TRUE;
+    }
   }
 
   /* now keep writing the earliest frame until we're out of frames */
@@ -187,196 +244,55 @@ merge_files(int count, merge_in_file_t in_files[], merge_out_file_t *out_file, i
     in_files[i].ok = wtap_read(in_files[i].wth, &(in_files[i].err),
                                &(in_files[i].err_info),
                                &(in_files[i].data_offset));
+    if (!in_files[i].ok) {
+      /* Read failure, not write failure. */
+      return TRUE;
+    }
   }
 
   return TRUE;
 }
 
-
-/*
- * Select an output frame type based on the input files
- * From Guy: If all files have the same frame type, then use that.
- *           Otherwise select WTAP_ENCAP_PER_PACKET.  If the selected
- *           output file type doesn't support per packet frame types,
- *           then the wtap_dump_open call will fail with a reasonable
- *           error condition.
- */
-int
-merge_select_frame_type(int count, merge_in_file_t files[])
+static gboolean
+append_loop(merge_in_file_t in_files[], int i, int count,
+            merge_out_file_t *out_file, int *err)
 {
-  int i;
-  int selected_frame_type;
+  gchar        *err_info;
+  long		data_offset;
+  int		loop = 0;
 
-  selected_frame_type = wtap_file_encap(files[0].wth);
+  /* Start by clearing error flag */
+  *err = 0;
 
-  for (i = 1; i < count; i++) {
-    int this_frame_type = wtap_file_encap(files[i].wth);
-    if (selected_frame_type != this_frame_type) {
-      selected_frame_type = WTAP_ENCAP_PER_PACKET;
-      if (merge_verbose == VERBOSE_ALL) {
-        fprintf(stderr, "mergecap: multiple frame encapsulation types detected\n");
-        fprintf(stderr, "          defaulting to WTAP_ENCAP_PER_PACKET\n");
-        fprintf(stderr, "          %s had type %s (%s)\n",
-                files[0].filename,
-                wtap_encap_string(selected_frame_type),
-                wtap_encap_short_string(selected_frame_type));
-        fprintf(stderr, "          %s had type %s (%s)\n",
-                files[i].filename,
-                wtap_encap_string(this_frame_type),
-                wtap_encap_short_string(this_frame_type));
-      }
+  while ( (wtap_read(in_files[i].wth, err, &err_info, &data_offset)) ) {
+    if(!write_frame(in_files[i].wth, out_file, err))
+      return FALSE;   /* failure */
+    if (count > 0 && ++loop >= count)
       break;
-    }
-  }
-
-  if (merge_verbose == VERBOSE_ALL) {
-      fprintf(stderr, "mergecap: selected frame_type %s (%s)\n",
-              wtap_encap_string(selected_frame_type),
-              wtap_encap_short_string(selected_frame_type));
   }
 
-  return selected_frame_type;
-}
-
-
-/*
- * Close the output file
- */
-gboolean
-merge_close_outfile(merge_out_file_t *out_file, int *err)
-{
-  if (!wtap_dump_close(out_file->pdh, err)) {
-    if (merge_verbose == VERBOSE_ERRORS)
-        fprintf(stderr, "mergecap: Error closing output file: %s\n",
-            wtap_strerror(*err));
-    return FALSE;
+  if (*err != 0) {
+    /* Read failure, not write failure. */
+    in_files[i].ok = FALSE;
+    in_files[i].err = *err;
+    in_files[i].err_info = err_info;
   }
   return TRUE;
 }
 
-
 /*
- * Open the output file
- *
- * Return FALSE if file cannot be opened (so caller can clean up)
+ * routine to concatenate files
  */
 gboolean
-merge_open_outfile(merge_out_file_t *out_file, int fd, int file_type,
-                   int frame_type, int snapshot_len, int *err)
-{
-
-  if (!out_file) {
-    if (merge_verbose == VERBOSE_ERRORS)
-        fprintf(stderr, "mergecap: internal error (null out_file)\n");
-    return FALSE;
-  }
-
-  out_file->pdh = wtap_dump_fdopen(fd, file_type, frame_type, snapshot_len,
-                                   err);
-  if (!out_file->pdh) {
-    if (merge_verbose == VERBOSE_ERRORS) {
-        fprintf(stderr, "mergecap: Can't open/create output file:\n");
-        fprintf(stderr, "          %s\n", wtap_strerror(*err));
-    }
-    return FALSE;
-  }
-
-  out_file->snaplen = snapshot_len;
-  out_file->count = 1;
-  return TRUE;
-}
-
-
-/*
- * Scan through input files and find maximum snapshot length
- */
-int
-merge_max_snapshot_length(int count, merge_in_file_t in_files[])
+merge_append_files(int count, merge_in_file_t in_files[],
+                   merge_out_file_t *out_file, int *err)
 {
   int i;
-  int max_snapshot = 0;
-  int snapshot_length;
 
   for (i = 0; i < count; i++) {
-    snapshot_length = wtap_snapshot_length(in_files[i].wth);
-    if (snapshot_length == 0) {
-      /* Snapshot length of input file not known. */
-      snapshot_length = WTAP_MAX_PACKET_SIZE;
-    }
-    if (snapshot_length > max_snapshot)
-      max_snapshot = snapshot_length;
-  }
-  return max_snapshot;
-}
-
-
-/*
- * Scan through and close each input file
- */
-void
-merge_close_in_files(int count, merge_in_file_t in_files[])
-{
-  int i;
-  for (i = 0; i < count; i++) {
-    wtap_close(in_files[i].wth);
-  }
-}
-
-
-/*
- * Scan through the arguments and open the input files
- */
-int
-merge_open_in_files(int in_file_count, char *const *in_file_names,
-                    merge_in_file_t **in_files, int *err, gchar **err_info,
-                    int *err_fileno)
-{
-  int i;
-  int count = 0;
-  int files_size = in_file_count * sizeof(merge_in_file_t);
-  merge_in_file_t *files;
-
-  files = g_malloc(files_size);
-  *in_files = files;
-
-  for (i = 0; i < in_file_count; i++) {
-    files[count].filename    = in_file_names[i];
-    files[count].wth         = wtap_open_offline(in_file_names[i], err, err_info, FALSE);
-    files[count].err         = 0;
-    files[count].data_offset = 0;
-    files[count].ok          = TRUE;
-    if (!files[count].wth) {
-      if (merge_verbose >= VERBOSE_ERRORS) {
-        fprintf(stderr, "mergecap: skipping %s: %s\n", in_file_names[i],
-              wtap_strerror(*err));
-        switch (*err) {
-
-        case WTAP_ERR_UNSUPPORTED:
-        case WTAP_ERR_UNSUPPORTED_ENCAP:
-        case WTAP_ERR_BAD_RECORD:
-          fprintf(stderr, "(%s)\n", *err_info);
-          g_free(*err_info);
-          break;
-        }
-      } else {
-        /*
-         * We aren't reporting the errors, so return immediately so our
-         * caller can report the error.
-         */
-        *err_fileno = count;
-        return 0;
-      }
-    } else {
-      if (merge_verbose == VERBOSE_ALL) {
-        fprintf(stderr, "mergecap: %s is type %s.\n", in_file_names[i],
-                wtap_file_type_string(wtap_file_type(files[count].wth)));
-      }
-      count++;
-    }
+    if (!append_loop(in_files, i, 0, out_file, err))
+      return FALSE;
   }
-  if (merge_verbose == VERBOSE_ALL)
-    fprintf(stderr, "mergecap: opened %d of %d input files\n", count,
-    in_file_count);
 
-  return count;
+  return TRUE;
 }