Various minor changes:

- Create/use some extended value_strings
- Remove unneeded #includes;
- Do whitespace changes;
- Add editor modelines.

Change-Id: I2e1ea37dddfd5e8656c90c0d45a6596c4912bb2c
Reviewed-on: https://code.wireshark.org/review/4065
Reviewed-by: Bill Meier <wmeier@newsguy.com>

1 files changed, 1046 insertions, 1033 deletions

diff --git a/wiretap/file_wrappers.c b/wiretap/file_wrappers.c
index b121ddd9ac..65c35d1e6c 100644
--- a/wiretap/file_wrappers.c
+++ b/wiretap/file_wrappers.c
@@ -37,7 +37,7 @@
  *  2. Altered source versions must be plainly marked as such, and must not be
  *     misrepresented as being the original software.
  *  3. This notice may not be removed or altered from any source distribution.
-*/
+ */
 
 #include "config.h"
 
@@ -64,9 +64,9 @@
  *
  * Some other compressed file formats we might want to support:
  *
- *	XZ format: http://tukaani.org/xz/
+ *      XZ format: http://tukaani.org/xz/
  *
- *	Bzip2 format: http://bzip.org/
+ *      Bzip2 format: http://bzip.org/
  */
 
 /*
@@ -77,9 +77,9 @@
  */
 static const char *compressed_file_extensions[] = {
 #ifdef HAVE_LIBZ
-	"gz",
+    "gz",
 #endif
-	NULL
+    NULL
 };
 
 /*
@@ -90,14 +90,14 @@ static const char *compressed_file_extensions[] = {
 GSList *
 wtap_get_compressed_file_extensions(void)
 {
-	const char **extension;
-	GSList *extensions;
-
-	extensions = NULL;
-	for (extension = &compressed_file_extensions[0]; *extension != NULL;
-	    extension++)
-		extensions = g_slist_append(extensions, (gpointer)(*extension));
-	return extensions;
+    const char **extension;
+    GSList *extensions;
+
+    extensions = NULL;
+    for (extension = &compressed_file_extensions[0]; *extension != NULL;
+         extension++)
+        extensions = g_slist_append(extensions, (gpointer)(*extension));
+    return extensions;
 }
 
 /* #define GZBUFSIZE 8192 */
@@ -105,166 +105,166 @@ wtap_get_compressed_file_extensions(void)
 
 /* values for wtap_reader compression */
 typedef enum {
-	UNKNOWN,	/* unknown - look for a gzip header */
-	UNCOMPRESSED,	/* uncompressed - copy input directly */
+    UNKNOWN,       /* unknown - look for a gzip header */
+    UNCOMPRESSED,  /* uncompressed - copy input directly */
 #ifdef HAVE_LIBZ
-	ZLIB,		/* decompress a zlib stream */
-	GZIP_AFTER_HEADER
+    ZLIB,          /* decompress a zlib stream */
+    GZIP_AFTER_HEADER
 #endif
 } compression_t;
 
 struct wtap_reader {
-	int fd;                    /* file descriptor */
-	gint64 raw_pos;            /* current position in file (just to not call lseek()) */
-	gint64 pos;                /* current position in uncompressed data */
-	guint size;                /* buffer size */
-	unsigned char *in;         /* input buffer */
-	unsigned char *out;        /* output buffer (double-sized when reading) */
-	unsigned char *next;       /* next output data to deliver or write */
-
-	guint have;                /* amount of output data unused at next */
-	gboolean eof;              /* TRUE if end of input file reached */
-	gint64 start;              /* where the gzip data started, for rewinding */
-	gint64 raw;                /* where the raw data started, for seeking */
-	compression_t compression; /* type of compression, if any */
-	gboolean is_compressed;    /* FALSE if completely uncompressed, TRUE otherwise */
-	/* seek request */
-	gint64 skip;               /* amount to skip (already rewound if backwards) */
-	gboolean seek_pending;     /* TRUE if seek request pending */
-	/* error information */
-	int err;                   /* error code */
-	const char *err_info;      /* additional error information string for some errors */
-
-	guint avail_in;            /* number of bytes available at next_in */
-	unsigned char *next_in;    /* next input byte */
+    int fd;                    /* file descriptor */
+    gint64 raw_pos;            /* current position in file (just to not call lseek()) */
+    gint64 pos;                /* current position in uncompressed data */
+    guint size;                /* buffer size */
+    unsigned char *in;         /* input buffer */
+    unsigned char *out;        /* output buffer (double-sized when reading) */
+    unsigned char *next;       /* next output data to deliver or write */
+
+    guint have;                /* amount of output data unused at next */
+    gboolean eof;              /* TRUE if end of input file reached */
+    gint64 start;              /* where the gzip data started, for rewinding */
+    gint64 raw;                /* where the raw data started, for seeking */
+    compression_t compression; /* type of compression, if any */
+    gboolean is_compressed;    /* FALSE if completely uncompressed, TRUE otherwise */
+    /* seek request */
+    gint64 skip;               /* amount to skip (already rewound if backwards) */
+    gboolean seek_pending;     /* TRUE if seek request pending */
+    /* error information */
+    int err;                   /* error code */
+    const char *err_info;      /* additional error information string for some errors */
+
+    guint avail_in;            /* number of bytes available at next_in */
+    unsigned char *next_in;    /* next input byte */
 #ifdef HAVE_LIBZ
-	/* zlib inflate stream */
-	z_stream strm;             /* stream structure in-place (not a pointer) */
-	gboolean dont_check_crc;   /* TRUE if we aren't supposed to check the CRC */
+    /* zlib inflate stream */
+    z_stream strm;             /* stream structure in-place (not a pointer) */
+    gboolean dont_check_crc;   /* TRUE if we aren't supposed to check the CRC */
 #endif
-	/* fast seeking */
-	GPtrArray *fast_seek;
-	void *fast_seek_cur;
+    /* fast seeking */
+    GPtrArray *fast_seek;
+    void *fast_seek_cur;
 };
 
-static int	/* gz_load */
+static int     /* gz_load */
 raw_read(FILE_T state, unsigned char *buf, unsigned int count, guint *have)
 {
-	ssize_t ret;
-
-	*have = 0;
-	do {
-		ret = read(state->fd, buf + *have, count - *have);
-		if (ret <= 0)
-			break;
-		*have += (unsigned)ret;
-		state->raw_pos += ret;
-	} while (*have < count);
-	if (ret < 0) {
-		state->err = errno;
-		state->err_info = NULL;
-		return -1;
-	}
-	if (ret == 0)
-		state->eof = TRUE;
-	return 0;
+    ssize_t ret;
+
+    *have = 0;
+    do {
+        ret = read(state->fd, buf + *have, count - *have);
+        if (ret <= 0)
+            break;
+        *have += (unsigned)ret;
+        state->raw_pos += ret;
+    } while (*have < count);
+    if (ret < 0) {
+        state->err = errno;
+        state->err_info = NULL;
+        return -1;
+    }
+    if (ret == 0)
+        state->eof = TRUE;
+    return 0;
 }
 
 static int /* gz_avail */
 fill_in_buffer(FILE_T state)
 {
-	if (state->err)
-		return -1;
-	if (state->eof == 0) {
-		if (raw_read(state, state->in, state->size, &(state->avail_in)) == -1)
-			return -1;
-		state->next_in = state->in;
-	}
-	return 0;
+    if (state->err)
+        return -1;
+    if (state->eof == 0) {
+        if (raw_read(state, state->in, state->size, &(state->avail_in)) == -1)
+            return -1;
+        state->next_in = state->in;
+    }
+    return 0;
 }
 
 #define ZLIB_WINSIZE 32768
 
 struct fast_seek_point {
-	gint64 out; 	/* corresponding offset in uncompressed data */
-	gint64 in;		/* offset in input file of first full byte */
+    gint64 out;         /* corresponding offset in uncompressed data */
+    gint64 in;          /* offset in input file of first full byte */
 
-	compression_t compression;
-	union {
-		struct {
+    compression_t compression;
+    union {
+        struct {
 #ifdef HAVE_INFLATEPRIME
-			int bits;		/* number of bits (1-7) from byte at in - 1, or 0 */
+            int bits;   /* number of bits (1-7) from byte at in - 1, or 0 */
 #endif
-			unsigned char window[ZLIB_WINSIZE];	/* preceding 32K of uncompressed data */
+            unsigned char window[ZLIB_WINSIZE]; /* preceding 32K of uncompressed data */
 
-			/* be gentle with Z_STREAM_END, 8 bytes more... Another solution would be to comment checks out */
-			guint32 adler;
-			guint32 total_out;
-		} zlib;
-	} data;
+            /* be gentle with Z_STREAM_END, 8 bytes more... Another solution would be to comment checks out */
+            guint32 adler;
+            guint32 total_out;
+        } zlib;
+    } data;
 };
 
 struct zlib_cur_seek_point {
-	unsigned char window[ZLIB_WINSIZE];	/* preceding 32K of uncompressed data */
-	unsigned int pos;
-	unsigned int have;
+    unsigned char window[ZLIB_WINSIZE]; /* preceding 32K of uncompressed data */
+    unsigned int pos;
+    unsigned int have;
 };
 
 #define SPAN G_GINT64_CONSTANT(1048576)
 static struct fast_seek_point *
 fast_seek_find(FILE_T file, gint64 pos)
 {
-	struct fast_seek_point *smallest = NULL;
-	struct fast_seek_point *item;
-	guint low, i, max;
-
-	if (!file->fast_seek)
-		return NULL;
-
-	for (low = 0, max = file->fast_seek->len; low < max; ) {
-		i = (low + max) / 2;
-		item = (struct fast_seek_point *)file->fast_seek->pdata[i];
-
-		if (pos < item->out)
-			max = i;
-		else if (pos > item->out) {
-			smallest = item;
-			low = i + 1;
-		} else {
-			return item;
-		}
-	}
-	return smallest;
+    struct fast_seek_point *smallest = NULL;
+    struct fast_seek_point *item;
+    guint low, i, max;
+
+    if (!file->fast_seek)
+        return NULL;
+
+    for (low = 0, max = file->fast_seek->len; low < max; ) {
+        i = (low + max) / 2;
+        item = (struct fast_seek_point *)file->fast_seek->pdata[i];
+
+        if (pos < item->out)
+            max = i;
+        else if (pos > item->out) {
+            smallest = item;
+            low = i + 1;
+        } else {
+            return item;
+        }
+    }
+    return smallest;
 }
 
 static void
 fast_seek_header(FILE_T file, gint64 in_pos, gint64 out_pos,
-    compression_t compression)
+                 compression_t compression)
 {
-	struct fast_seek_point *item = NULL;
+    struct fast_seek_point *item = NULL;
 
-	if (file->fast_seek->len != 0)
-		item = (struct fast_seek_point *)file->fast_seek->pdata[file->fast_seek->len - 1];
+    if (file->fast_seek->len != 0)
+        item = (struct fast_seek_point *)file->fast_seek->pdata[file->fast_seek->len - 1];
 
-	if (!item || item->out < out_pos) {
-		struct fast_seek_point *val = g_new(struct fast_seek_point,1);
-		val->in = in_pos;
-		val->out = out_pos;
-		val->compression = compression;
+    if (!item || item->out < out_pos) {
+        struct fast_seek_point *val = g_new(struct fast_seek_point,1);
+        val->in = in_pos;
+        val->out = out_pos;
+        val->compression = compression;
 
-		g_ptr_array_add(file->fast_seek, val);
-	}
+        g_ptr_array_add(file->fast_seek, val);
+    }
 }
 
 static void
 fast_seek_reset(FILE_T state _U_)
 {
 #ifdef HAVE_LIBZ
-	if (state->compression == ZLIB && state->fast_seek_cur) {
-		struct zlib_cur_seek_point *cur = (struct zlib_cur_seek_point *) state->fast_seek_cur;
+    if (state->compression == ZLIB && state->fast_seek_cur) {
+        struct zlib_cur_seek_point *cur = (struct zlib_cur_seek_point *) state->fast_seek_cur;
 
-		cur->have = 0;
-	}
+        cur->have = 0;
+    }
 #endif
 }
 
@@ -274,36 +274,36 @@ fast_seek_reset(FILE_T state _U_)
  *
  * Note:
  *
- *	1) errors from raw_read(), and thus from fill_in_buffer(), are
- *	"sticky", and fill_in_buffer() won't do any reading if there's
- *	an error;
+ *      1) errors from raw_read(), and thus from fill_in_buffer(), are
+ *      "sticky", and fill_in_buffer() won't do any reading if there's
+ *      an error;
  *
- *	2) GZ_GETC() returns -1 on an EOF;
+ *      2) GZ_GETC() returns -1 on an EOF;
  *
  * so it's safe to make multiple GZ_GETC() calls and only check the
  * last one for an error. */
 #define GZ_GETC() ((state->avail_in == 0 && fill_in_buffer(state) == -1) ? -1 : \
-                (state->avail_in == 0 ? -1 : \
-                 (state->avail_in--, *(state->next_in)++)))
+                   (state->avail_in == 0 ? -1 :                         \
+                    (state->avail_in--, *(state->next_in)++)))
 
 /* Get a one-byte integer and return 0 on success and the value in *ret.
    Otherwise -1 is returned, state->err is set, and *ret is not modified. */
 static int
 gz_next1(FILE_T state, guint8 *ret)
 {
-	int ch;
-
-	ch = GZ_GETC();
-	if (ch == -1) {
-		if (state->err == 0) {
-			/* EOF */
-			state->err = WTAP_ERR_SHORT_READ;
-			state->err_info = NULL;
-		}
-		return -1;
-	}
-	*ret = ch;
-	return 0;
+    int ch;
+
+    ch = GZ_GETC();
+    if (ch == -1) {
+        if (state->err == 0) {
+            /* EOF */
+            state->err = WTAP_ERR_SHORT_READ;
+            state->err_info = NULL;
+        }
+        return -1;
+    }
+    *ret = ch;
+    return 0;
 }
 
 /* Get a two-byte little-endian integer and return 0 on success and the value
@@ -312,22 +312,22 @@ gz_next1(FILE_T state, guint8 *ret)
 static int
 gz_next2(FILE_T state, guint16 *ret)
 {
-	guint16 val;
-	int ch;
-
-	val = GZ_GETC();
-	ch = GZ_GETC();
-	if (ch == -1) {
-		if (state->err == 0) {
-			/* EOF */
-			state->err = WTAP_ERR_SHORT_READ;
-			state->err_info = NULL;
-		}
-		return -1;
-	}
-	val += (guint16)ch << 8;
-	*ret = val;
-	return 0;
+    guint16 val;
+    int ch;
+
+    val = GZ_GETC();
+    ch = GZ_GETC();
+    if (ch == -1) {
+        if (state->err == 0) {
+            /* EOF */
+            state->err = WTAP_ERR_SHORT_READ;
+            state->err_info = NULL;
+        }
+        return -1;
+    }
+    val += (guint16)ch << 8;
+    *ret = val;
+    return 0;
 }
 
 /* Get a four-byte little-endian integer and return 0 on success and the value
@@ -336,24 +336,24 @@ gz_next2(FILE_T state, guint16 *ret)
 static int
 gz_next4(FILE_T state, guint32 *ret)
 {
-	guint32 val;
-	int ch;
-
-	val = GZ_GETC();
-	val += (unsigned)GZ_GETC() << 8;
-	val += (guint32)GZ_GETC() << 16;
-	ch = GZ_GETC();
-	if (ch == -1) {
-		if (state->err == 0) {
-			/* EOF */
-			state->err = WTAP_ERR_SHORT_READ;
-			state->err_info = NULL;
-		}
-		return -1;
-	}
-	val += (guint32)ch << 24;
-	*ret = val;
-	return 0;
+    guint32 val;
+    int ch;
+
+    val = GZ_GETC();
+    val += (unsigned)GZ_GETC() << 8;
+    val += (guint32)GZ_GETC() << 16;
+    ch = GZ_GETC();
+    if (ch == -1) {
+        if (state->err == 0) {
+            /* EOF */
+            state->err = WTAP_ERR_SHORT_READ;
+            state->err_info = NULL;
+        }
+        return -1;
+    }
+    val += (guint32)ch << 24;
+    *ret = val;
+    return 0;
 }
 
 /* Skip the specified number of bytes and return 0 on success.  Otherwise -1
@@ -361,18 +361,18 @@ gz_next4(FILE_T state, guint32 *ret)
 static int
 gz_skipn(FILE_T state, size_t n)
 {
-	while (n != 0) {
-		if (GZ_GETC() == -1) {
-			if (state->err == 0) {
-				/* EOF */
-				state->err = WTAP_ERR_SHORT_READ;
-				state->err_info = NULL;
-			}
-			return -1;
-		}
-		n--;
-	}
-	return 0;
+    while (n != 0) {
+        if (GZ_GETC() == -1) {
+            if (state->err == 0) {
+                /* EOF */
+                state->err = WTAP_ERR_SHORT_READ;
+                state->err_info = NULL;
+            }
+            return -1;
+        }
+        n--;
+    }
+    return 0;
 }
 
 /* Skip a null-terminated string and return 0 on success.  Otherwise -1
@@ -380,728 +380,728 @@ gz_skipn(FILE_T state, size_t n)
 static int
 gz_skipzstr(FILE_T state)
 {
-	int ch;
-
-	/* It's null-terminated, so scan until we read a byte with
-	   the value 0 or get an error. */
-	while ((ch = GZ_GETC()) > 0)
-		;
-	if (ch == -1) {
-		if (state->err == 0) {
-			/* EOF */
-			state->err = WTAP_ERR_SHORT_READ;
-			state->err_info = NULL;
-		}
-		return -1;
-	}
-	return 0;
+    int ch;
+
+    /* It's null-terminated, so scan until we read a byte with
+       the value 0 or get an error. */
+    while ((ch = GZ_GETC()) > 0)
+        ;
+    if (ch == -1) {
+        if (state->err == 0) {
+            /* EOF */
+            state->err = WTAP_ERR_SHORT_READ;
+            state->err_info = NULL;
+        }
+        return -1;
+    }
+    return 0;
 }
 
 static void
 zlib_fast_seek_add(FILE_T file, struct zlib_cur_seek_point *point, int bits, gint64 in_pos, gint64 out_pos)
 {
-	/* it's for sure after gzip header, so file->fast_seek->len != 0 */
-	struct fast_seek_point *item = (struct fast_seek_point *)file->fast_seek->pdata[file->fast_seek->len - 1];
+    /* it's for sure after gzip header, so file->fast_seek->len != 0 */
+    struct fast_seek_point *item = (struct fast_seek_point *)file->fast_seek->pdata[file->fast_seek->len - 1];
 
 #ifndef HAVE_INFLATEPRIME
-	if (bits)
-		return;
+    if (bits)
+        return;
 #endif
 
-	/* Glib has got Balanced Binary Trees (GTree) but I couldn't find a way to do quick search for nearest (and smaller) value to seek (It's what fast_seek_find() do)
-	 *      Inserting value in middle of sorted array is expensive, so we want to add only in the end.
-	 *      It's not big deal, cause first-read don't usually invoke seeking
-	 */
-	if (item->out + SPAN < out_pos) {
-		struct fast_seek_point *val = g_new(struct fast_seek_point,1);
-		val->in = in_pos;
-		val->out = out_pos;
-		val->compression = ZLIB;
+    /* Glib has got Balanced Binary Trees (GTree) but I couldn't find a way to do quick search for nearest (and smaller) value to seek (It's what fast_seek_find() do)
+     *      Inserting value in middle of sorted array is expensive, so we want to add only in the end.
+     *      It's not big deal, cause first-read don't usually invoke seeking
+     */
+    if (item->out + SPAN < out_pos) {
+        struct fast_seek_point *val = g_new(struct fast_seek_point,1);
+        val->in = in_pos;
+        val->out = out_pos;
+        val->compression = ZLIB;
 #ifdef HAVE_INFLATEPRIME
-		val->data.zlib.bits = bits;
+        val->data.zlib.bits = bits;
 #endif
-		if (point->pos != 0) {
-			unsigned int left = ZLIB_WINSIZE - point->pos;
-
-			memcpy(val->data.zlib.window, point->window + point->pos, left);
-			memcpy(val->data.zlib.window + left, point->window, point->pos);
-		} else
-			memcpy(val->data.zlib.window, point->window, ZLIB_WINSIZE);
-
-		/*
-		 * XXX - strm.adler is a uLong in at least some versions
-		 * of zlib, and uLong is an unsigned long in at least
-		 * some of those versions, which means it's 64-bit
-		 * on LP64 platforms, even though the checksum is
-		 * 32-bit.  We assume the actual Adler checksum
-		 * is in the lower 32 bits of strm.adler; as the
-		 * checksum in the file is only 32 bits, we save only
-		 * those lower 32 bits, and cast away any additional
-		 * bits to squelch warnings.
-		 *
-		 * The same applies to strm.total_out.
-		 */
-		val->data.zlib.adler = (guint32) file->strm.adler;
-		val->data.zlib.total_out = (guint32) file->strm.total_out;
-		g_ptr_array_add(file->fast_seek, val);
-	}
+        if (point->pos != 0) {
+            unsigned int left = ZLIB_WINSIZE - point->pos;
+
+            memcpy(val->data.zlib.window, point->window + point->pos, left);
+            memcpy(val->data.zlib.window + left, point->window, point->pos);
+        } else
+            memcpy(val->data.zlib.window, point->window, ZLIB_WINSIZE);
+
+        /*
+         * XXX - strm.adler is a uLong in at least some versions
+         * of zlib, and uLong is an unsigned long in at least
+         * some of those versions, which means it's 64-bit
+         * on LP64 platforms, even though the checksum is
+         * 32-bit.  We assume the actual Adler checksum
+         * is in the lower 32 bits of strm.adler; as the
+         * checksum in the file is only 32 bits, we save only
+         * those lower 32 bits, and cast away any additional
+         * bits to squelch warnings.
+         *
+         * The same applies to strm.total_out.
+         */
+        val->data.zlib.adler = (guint32) file->strm.adler;
+        val->data.zlib.total_out = (guint32) file->strm.total_out;
+        g_ptr_array_add(file->fast_seek, val);
+    }
 }
 
 static void /* gz_decomp */
 zlib_read(FILE_T state, unsigned char *buf, unsigned int count)
 {
-	int ret = 0;	/* XXX */
-	guint32 crc, len;
-	z_streamp strm = &(state->strm);
-
-	unsigned char *buf2 = buf;
-	unsigned int count2 = count;
-
-	strm->avail_out = count;
-	strm->next_out = buf;
-
-	/* fill output buffer up to end of deflate stream or error */
-	do {
-		/* get more input for inflate() */
-		if (state->avail_in == 0 && fill_in_buffer(state) == -1)
-			break;
-		if (state->avail_in == 0) {
-			/* EOF */
-			state->err = WTAP_ERR_SHORT_READ;
-			state->err_info = NULL;
-			break;
-		}
-
-		strm->avail_in = state->avail_in;
-		strm->next_in = state->next_in;
-		/* decompress and handle errors */
+    int ret = 0;        /* XXX */
+    guint32 crc, len;
+    z_streamp strm = &(state->strm);
+
+    unsigned char *buf2 = buf;
+    unsigned int count2 = count;
+
+    strm->avail_out = count;
+    strm->next_out = buf;
+
+    /* fill output buffer up to end of deflate stream or error */
+    do {
+        /* get more input for inflate() */
+        if (state->avail_in == 0 && fill_in_buffer(state) == -1)
+            break;
+        if (state->avail_in == 0) {
+            /* EOF */
+            state->err = WTAP_ERR_SHORT_READ;
+            state->err_info = NULL;
+            break;
+        }
+
+        strm->avail_in = state->avail_in;
+        strm->next_in = state->next_in;
+        /* decompress and handle errors */
 #ifdef Z_BLOCK
-		ret = inflate(strm, Z_BLOCK);
+        ret = inflate(strm, Z_BLOCK);
 #else
-		ret = inflate(strm, Z_NO_FLUSH);
+        ret = inflate(strm, Z_NO_FLUSH);
 #endif
-		state->avail_in = strm->avail_in;
-		state->next_in = strm->next_in;
-		if (ret == Z_STREAM_ERROR) {
-			state->err = WTAP_ERR_DECOMPRESS;
-			state->err_info = strm->msg;
-			break;
-		}
-		if (ret == Z_NEED_DICT) {
-			state->err = WTAP_ERR_DECOMPRESS;
-			state->err_info = "preset dictionary needed";
-			break;
-		}
-		if (ret == Z_MEM_ERROR) {
-			/* This means "not enough memory". */
-			state->err = ENOMEM;
-			state->err_info = NULL;
-			break;
-		}
-		if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
-			state->err = WTAP_ERR_DECOMPRESS;
-			state->err_info = strm->msg;
-			break;
-		}
-		/*
-		 * XXX - Z_BUF_ERROR?
-		 */
-
-		strm->adler = crc32(strm->adler, buf2, count2 - strm->avail_out);
+        state->avail_in = strm->avail_in;
+        state->next_in = strm->next_in;
+        if (ret == Z_STREAM_ERROR) {
+            state->err = WTAP_ERR_DECOMPRESS;
+            state->err_info = strm->msg;
+            break;
+        }
+        if (ret == Z_NEED_DICT) {
+            state->err = WTAP_ERR_DECOMPRESS;
+            state->err_info = "preset dictionary needed";
+            break;
+        }
+        if (ret == Z_MEM_ERROR) {
+            /* This means "not enough memory". */
+            state->err = ENOMEM;
+            state->err_info = NULL;
+            break;
+        }
+        if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
+            state->err = WTAP_ERR_DECOMPRESS;
+            state->err_info = strm->msg;
+            break;
+        }
+        /*
+         * XXX - Z_BUF_ERROR?
+         */
+
+        strm->adler = crc32(strm->adler, buf2, count2 - strm->avail_out);
 #ifdef Z_BLOCK
-		if (state->fast_seek_cur) {
-			struct zlib_cur_seek_point *cur = (struct zlib_cur_seek_point *) state->fast_seek_cur;
-			unsigned int ready = count2 - strm->avail_out;
-
-			if (ready < ZLIB_WINSIZE) {
-				guint left = ZLIB_WINSIZE - cur->pos;
-
-				if (ready >= left) {
-					memcpy(cur->window + cur->pos, buf2, left);
-					if (ready != left)
-						memcpy(cur->window, buf2 + left, ready - left);
-
-					cur->pos = ready - left;
-					cur->have += ready;
-				} else {
-					memcpy(cur->window + cur->pos, buf2, ready);
-					cur->pos += ready;
-					cur->have += ready;
-				}
-
-				if (cur->have >= ZLIB_WINSIZE)
-					cur->have = ZLIB_WINSIZE;
-
-			} else {
-				memcpy(cur->window, buf2 + (ready - ZLIB_WINSIZE), ZLIB_WINSIZE);
-				cur->pos = 0;
-				cur->have = ZLIB_WINSIZE;
-			}
-
-			if (cur->have >= ZLIB_WINSIZE && ret != Z_STREAM_END && (strm->data_type & 128) && !(strm->data_type & 64))
-				zlib_fast_seek_add(state, cur, (strm->data_type & 7), state->raw_pos - strm->avail_in, state->pos + (count - strm->avail_out));
-		}
+        if (state->fast_seek_cur) {
+            struct zlib_cur_seek_point *cur = (struct zlib_cur_seek_point *) state->fast_seek_cur;
+            unsigned int ready = count2 - strm->avail_out;
+
+            if (ready < ZLIB_WINSIZE) {
+                guint left = ZLIB_WINSIZE - cur->pos;
+
+                if (ready >= left) {
+                    memcpy(cur->window + cur->pos, buf2, left);
+                    if (ready != left)
+                        memcpy(cur->window, buf2 + left, ready - left);
+
+                    cur->pos = ready - left;
+                    cur->have += ready;
+                } else {
+                    memcpy(cur->window + cur->pos, buf2, ready);
+                    cur->pos += ready;
+                    cur->have += ready;
+                }
+
+                if (cur->have >= ZLIB_WINSIZE)
+                    cur->have = ZLIB_WINSIZE;
+
+            } else {
+                memcpy(cur->window, buf2 + (ready - ZLIB_WINSIZE), ZLIB_WINSIZE);
+                cur->pos = 0;
+                cur->have = ZLIB_WINSIZE;
+            }
+
+            if (cur->have >= ZLIB_WINSIZE && ret != Z_STREAM_END && (strm->data_type & 128) && !(strm->data_type & 64))
+                zlib_fast_seek_add(state, cur, (strm->data_type & 7), state->raw_pos - strm->avail_in, state->pos + (count - strm->avail_out));
+        }
 #endif
-		buf2 = (buf2 + count2 - strm->avail_out);
-		count2 = strm->avail_out;
-
-	} while (strm->avail_out && ret != Z_STREAM_END);
-
-	/* update available output and crc check value */
-	state->next = buf;
-	state->have = count - strm->avail_out;
-
-	/* Check gzip trailer if at end of deflate stream.
-	   We don't fail immediately here, we just set an error
-	   indication, so that we try to process what data we
-	   got before the error.  The next attempt to read
-	   something past that data will get the error. */
-	if (ret == Z_STREAM_END) {
-		if (gz_next4(state, &crc) != -1 &&
-		    gz_next4(state, &len) != -1) {
-			if (crc != strm->adler && !state->dont_check_crc) {
-				state->err = WTAP_ERR_DECOMPRESS;
-				state->err_info = "bad CRC";
-			} else if (len != (strm->total_out & 0xffffffffL)) {
-				state->err = WTAP_ERR_DECOMPRESS;
-				state->err_info = "length field wrong";
-			}
-		}
-		state->compression = UNKNOWN;      /* ready for next stream, once have is 0 */
-		g_free(state->fast_seek_cur);
-		state->fast_seek_cur = NULL;
-	}
+        buf2 = (buf2 + count2 - strm->avail_out);
+        count2 = strm->avail_out;
+
+    } while (strm->avail_out && ret != Z_STREAM_END);
+
+    /* update available output and crc check value */
+    state->next = buf;
+    state->have = count - strm->avail_out;
+
+    /* Check gzip trailer if at end of deflate stream.
+       We don't fail immediately here, we just set an error
+       indication, so that we try to process what data we
+       got before the error.  The next attempt to read
+       something past that data will get the error. */
+    if (ret == Z_STREAM_END) {
+        if (gz_next4(state, &crc) != -1 &&
+            gz_next4(state, &len) != -1) {
+            if (crc != strm->adler && !state->dont_check_crc) {
+                state->err = WTAP_ERR_DECOMPRESS;
+                state->err_info = "bad CRC";
+            } else if (len != (strm->total_out & 0xffffffffL)) {
+                state->err = WTAP_ERR_DECOMPRESS;
+                state->err_info = "length field wrong";
+            }
+        }
+        state->compression = UNKNOWN;      /* ready for next stream, once have is 0 */
+        g_free(state->fast_seek_cur);
+        state->fast_seek_cur = NULL;
+    }
 }
 #endif
 
 static int
 gz_head(FILE_T state)
 {
-	/* get some data in the input buffer */
-	if (state->avail_in == 0) {
-		if (fill_in_buffer(state) == -1)
-			return -1;
-		if (state->avail_in == 0)
-			return 0;
-	}
-
-	/* look for the gzip magic header bytes 31 and 139 */
+    /* get some data in the input buffer */
+    if (state->avail_in == 0) {
+        if (fill_in_buffer(state) == -1)
+            return -1;
+        if (state->avail_in == 0)
+            return 0;
+    }
+
+    /* look for the gzip magic header bytes 31 and 139 */
 #ifdef HAVE_LIBZ
-	if (state->next_in[0] == 31) {
-		state->avail_in--;
-		state->next_in++;
-		if (state->avail_in == 0 && fill_in_buffer(state) == -1)
-			return -1;
-		if (state->avail_in && state->next_in[0] == 139) {
-			guint8 cm;
-			guint8 flags;
-			guint16 len;
-			guint16 hcrc;
-
-			/* we have a gzip header, woo hoo! */
-			state->avail_in--;
-			state->next_in++;
-
-			/* read rest of header */
-
-			/* compression method (CM) */
-			if (gz_next1(state, &cm) == -1)
-				return -1;
-			if (cm != 8) {
-				state->err = WTAP_ERR_DECOMPRESS;
-				state->err_info = "unknown compression method";
-				return -1;
-			}
-
-			/* flags (FLG) */
-			if (gz_next1(state, &flags) == -1)
-				return -1;
-			if (flags & 0xe0) {     /* reserved flag bits */
-				state->err = WTAP_ERR_DECOMPRESS;
-				state->err_info = "reserved flag bits set";
-				return -1;
-			}
-
-			/* modification time (MTIME) */
-			if (gz_skipn(state, 4) == -1)
-				return -1;
-
-			/* extra flags (XFL) */
-			if (gz_skipn(state, 1) == -1)
-				return -1;
-
-			/* operating system (OS) */
-			if (gz_skipn(state, 1) == -1)
-				return -1;
-
-			if (flags & 4) {
-				/* extra field - get XLEN */
-				if (gz_next2(state, &len) == -1)
-					return -1;
-
-				/* skip the extra field */
-				if (gz_skipn(state, len) == -1)
-					return -1;
-			}
-			if (flags & 8) {
-				/* file name */
-				if (gz_skipzstr(state) == -1)
-					return -1;
-			}
-			if (flags & 16) {
-				/* comment */
-				if (gz_skipzstr(state) == -1)
-					return -1;
-			}
-			if (flags & 2) {
-				/* header crc */
-				if (gz_next2(state, &hcrc) == -1)
-					return -1;
-				/* XXX - check the CRC? */
-			}
-
-			/* set up for decompression */
-			inflateReset(&(state->strm));
-			state->strm.adler = crc32(0L, Z_NULL, 0);
-			state->compression = ZLIB;
-			state->is_compressed = TRUE;
+    if (state->next_in[0] == 31) {
+        state->avail_in--;
+        state->next_in++;
+        if (state->avail_in == 0 && fill_in_buffer(state) == -1)
+            return -1;
+        if (state->avail_in && state->next_in[0] == 139) {
+            guint8 cm;
+            guint8 flags;
+            guint16 len;
+            guint16 hcrc;
+
+            /* we have a gzip header, woo hoo! */
+            state->avail_in--;
+            state->next_in++;
+
+            /* read rest of header */
+
+            /* compression method (CM) */
+            if (gz_next1(state, &cm) == -1)
+                return -1;
+            if (cm != 8) {
+                state->err = WTAP_ERR_DECOMPRESS;
+                state->err_info = "unknown compression method";
+                return -1;
+            }
+
+            /* flags (FLG) */
+            if (gz_next1(state, &flags) == -1)
+                return -1;
+            if (flags & 0xe0) {     /* reserved flag bits */
+                state->err = WTAP_ERR_DECOMPRESS;
+                state->err_info = "reserved flag bits set";
+                return -1;
+            }
+
+            /* modification time (MTIME) */
+            if (gz_skipn(state, 4) == -1)
+                return -1;
+
+            /* extra flags (XFL) */
+            if (gz_skipn(state, 1) == -1)
+                return -1;
+
+            /* operating system (OS) */
+            if (gz_skipn(state, 1) == -1)
+                return -1;
+
+            if (flags & 4) {
+                /* extra field - get XLEN */
+                if (gz_next2(state, &len) == -1)
+                    return -1;
+
+                /* skip the extra field */
+                if (gz_skipn(state, len) == -1)
+                    return -1;
+            }
+            if (flags & 8) {
+                /* file name */
+                if (gz_skipzstr(state) == -1)
+                    return -1;
+            }
+            if (flags & 16) {
+                /* comment */
+                if (gz_skipzstr(state) == -1)
+                    return -1;
+            }
+            if (flags & 2) {
+                /* header crc */
+                if (gz_next2(state, &hcrc) == -1)
+                    return -1;
+                /* XXX - check the CRC? */
+            }
+
+            /* set up for decompression */
+            inflateReset(&(state->strm));
+            state->strm.adler = crc32(0L, Z_NULL, 0);
+            state->compression = ZLIB;
+            state->is_compressed = TRUE;
 #ifdef Z_BLOCK
-			if (state->fast_seek) {
-				struct zlib_cur_seek_point *cur = g_new(struct zlib_cur_seek_point,1);
-
-				cur->pos = cur->have = 0;
-				g_free(state->fast_seek_cur);
-				state->fast_seek_cur = cur;
-				fast_seek_header(state, state->raw_pos - state->avail_in, state->pos, GZIP_AFTER_HEADER);
-			}
+            if (state->fast_seek) {
+                struct zlib_cur_seek_point *cur = g_new(struct zlib_cur_seek_point,1);
+
+                cur->pos = cur->have = 0;
+                g_free(state->fast_seek_cur);
+                state->fast_seek_cur = cur;
+                fast_seek_header(state, state->raw_pos - state->avail_in, state->pos, GZIP_AFTER_HEADER);
+            }
 #endif
-			return 0;
-		}
-		else {
-			/* not a gzip file -- save first byte (31) and fall to raw i/o */
-			state->out[0] = 31;
-			state->have = 1;
-		}
-	}
+            return 0;
+        }
+        else {
+            /* not a gzip file -- save first byte (31) and fall to raw i/o */
+            state->out[0] = 31;
+            state->have = 1;
+        }
+    }
 #endif
 #ifdef HAVE_LIBXZ
-	/* { 0xFD, '7', 'z', 'X', 'Z', 0x00 } */
-	/* FD 37 7A 58 5A 00 */
+    /* { 0xFD, '7', 'z', 'X', 'Z', 0x00 } */
+    /* FD 37 7A 58 5A 00 */
 #endif
-	if (state->fast_seek)
-		fast_seek_header(state, state->raw_pos - state->avail_in - state->have, state->pos, UNCOMPRESSED);
-
-	/* doing raw i/o, save start of raw data for seeking, copy any leftover
-	   input to output -- this assumes that the output buffer is larger than
-	   the input buffer, which also assures space for gzungetc() */
-	state->raw = state->pos;
-	state->next = state->out;
-	if (state->avail_in) {
-		memcpy(state->next + state->have, state->next_in, state->avail_in);
-		state->have += state->avail_in;
-		state->avail_in = 0;
-	}
-	state->compression = UNCOMPRESSED;
-	return 0;
+    if (state->fast_seek)
+        fast_seek_header(state, state->raw_pos - state->avail_in - state->have, state->pos, UNCOMPRESSED);
+
+    /* doing raw i/o, save start of raw data for seeking, copy any leftover
+       input to output -- this assumes that the output buffer is larger than
+       the input buffer, which also assures space for gzungetc() */
+    state->raw = state->pos;
+    state->next = state->out;
+    if (state->avail_in) {
+        memcpy(state->next + state->have, state->next_in, state->avail_in);
+        state->have += state->avail_in;
+        state->avail_in = 0;
+    }
+    state->compression = UNCOMPRESSED;
+    return 0;
 }
 
 static int /* gz_make */
 fill_out_buffer(FILE_T state)
 {
-	if (state->compression == UNKNOWN) {           /* look for gzip header */
-		if (gz_head(state) == -1)
-			return -1;
-		if (state->have)                /* got some data from gz_head() */
-			return 0;
-	}
-	if (state->compression == UNCOMPRESSED) {           /* straight copy */
-		if (raw_read(state, state->out, state->size /* << 1 */, &(state->have)) == -1)
-			return -1;
-		state->next = state->out;
-	}
+    if (state->compression == UNKNOWN) {           /* look for gzip header */
+        if (gz_head(state) == -1)
+            return -1;
+        if (state->have)                /* got some data from gz_head() */
+            return 0;
+    }
+    if (state->compression == UNCOMPRESSED) {           /* straight copy */
+        if (raw_read(state, state->out, state->size /* << 1 */, &(state->have)) == -1)
+            return -1;
+        state->next = state->out;
+    }
 #ifdef HAVE_LIBZ
-	else if (state->compression == ZLIB) {      /* decompress */
-		zlib_read(state, state->out, state->size << 1);
-	}
+    else if (state->compression == ZLIB) {      /* decompress */
+        zlib_read(state, state->out, state->size << 1);
+    }
 #endif
-	return 0;
+    return 0;
 }
 
 static int
 gz_skip(FILE_T state, gint64 len)
 {
-	guint n;
-
-	/* skip over len bytes or reach end-of-file, whichever comes first */
-	while (len)
-		if (state->have) {
-			/* We have stuff in the output buffer; skip over
-			   it. */
-			n = (gint64)state->have > len ? (unsigned)len : state->have;
-			state->have -= n;
-			state->next += n;
-			state->pos += n;
-			len -= n;
-		} else if (state->err) {
-			/* We have nothing in the output buffer, and
-			   we have an error that may not have been
-			   reported yet; that means we can't generate
-			   any more data into the output buffer, so
-			   return an error indication. */
-			return -1;
-		} else if (state->eof && state->avail_in == 0) {
-			/* We have nothing in the output buffer, and
-			   we're at the end of the input; just return. */
-			break;
-		} else {
-			/* We have nothing in the output buffer, and
-			   we can generate more data; get more output,
-			   looking for header if required. */
-			if (fill_out_buffer(state) == -1)
-				return -1;
-		}
-	return 0;
+    guint n;
+
+    /* skip over len bytes or reach end-of-file, whichever comes first */
+    while (len)
+        if (state->have) {
+            /* We have stuff in the output buffer; skip over
+               it. */
+            n = (gint64)state->have > len ? (unsigned)len : state->have;
+            state->have -= n;
+            state->next += n;
+            state->pos += n;
+            len -= n;
+        } else if (state->err) {
+            /* We have nothing in the output buffer, and
+               we have an error that may not have been
+               reported yet; that means we can't generate
+               any more data into the output buffer, so
+               return an error indication. */
+            return -1;
+        } else if (state->eof && state->avail_in == 0) {
+            /* We have nothing in the output buffer, and
+               we're at the end of the input; just return. */
+            break;
+        } else {
+            /* We have nothing in the output buffer, and
+               we can generate more data; get more output,
+               looking for header if required. */
+            if (fill_out_buffer(state) == -1)
+                return -1;
+        }
+    return 0;
 }
 
 static void
 gz_reset(FILE_T state)
 {
-	state->have = 0;              /* no output data available */
-	state->eof = FALSE;           /* not at end of file */
-	state->compression = UNKNOWN; /* look for gzip header */
-
-	state->seek_pending = FALSE;  /* no seek request pending */
-	state->err = 0;               /* clear error */
-	state->err_info = NULL;
-	state->pos = 0;               /* no uncompressed data yet */
-	state->avail_in = 0;          /* no input data yet */
+    state->have = 0;              /* no output data available */
+    state->eof = FALSE;           /* not at end of file */
+    state->compression = UNKNOWN; /* look for gzip header */
+
+    state->seek_pending = FALSE;  /* no seek request pending */
+    state->err = 0;               /* clear error */
+    state->err_info = NULL;
+    state->pos = 0;               /* no uncompressed data yet */
+    state->avail_in = 0;          /* no input data yet */
 }
 
 FILE_T
 file_fdopen(int fd)
 {
-#ifdef _STATBUF_ST_BLKSIZE	/* XXX, _STATBUF_ST_BLKSIZE portable? */
-	ws_statb64 st;
+#ifdef _STATBUF_ST_BLKSIZE      /* XXX, _STATBUF_ST_BLKSIZE portable? */
+    ws_statb64 st;
 #endif
-	int want = GZBUFSIZE;
-	FILE_T state;
+    int want = GZBUFSIZE;
+    FILE_T state;
 
-	if (fd == -1)
-		return NULL;
+    if (fd == -1)
+        return NULL;
 
-	/* allocate FILE_T structure to return */
-	state = (FILE_T)g_try_malloc(sizeof *state);
-	if (state == NULL)
-		return NULL;
+    /* allocate FILE_T structure to return */
+    state = (FILE_T)g_try_malloc(sizeof *state);
+    if (state == NULL)
+        return NULL;
 
-	state->fast_seek_cur = NULL;
-	state->fast_seek = NULL;
+    state->fast_seek_cur = NULL;
+    state->fast_seek = NULL;
 
-	/* open the file with the appropriate mode (or just use fd) */
-	state->fd = fd;
+    /* open the file with the appropriate mode (or just use fd) */
+    state->fd = fd;
 
-	/* we don't yet know whether it's compressed */
-	state->is_compressed = FALSE;
+    /* we don't yet know whether it's compressed */
+    state->is_compressed = FALSE;
 
-	/* save the current position for rewinding (only if reading) */
-	state->start = ws_lseek64(state->fd, 0, SEEK_CUR);
-	if (state->start == -1) state->start = 0;
-	state->raw_pos = state->start;
+    /* save the current position for rewinding (only if reading) */
+    state->start = ws_lseek64(state->fd, 0, SEEK_CUR);
+    if (state->start == -1) state->start = 0;
+    state->raw_pos = state->start;
 
-	/* initialize stream */
-	gz_reset(state);
+    /* initialize stream */
+    gz_reset(state);
 
 #ifdef _STATBUF_ST_BLKSIZE
-	if (ws_fstat64(fd, &st) >= 0) {
-		/*
-		 * Yes, st_blksize can be bigger than an int; apparently,
-		 * it's a long on LP64 Linux, for example.
-		 *
-		 * If the value is too big to fit into an int, just
-		 * use the default.
-		 */
-		if (st.st_blksize <= G_MAXINT)
-			want = (int)st.st_blksize;
-		/* XXX, verify result? */
-	}
+    if (ws_fstat64(fd, &st) >= 0) {
+        /*
+         * Yes, st_blksize can be bigger than an int; apparently,
+         * it's a long on LP64 Linux, for example.
+         *
+         * If the value is too big to fit into an int, just
+         * use the default.
+         */
+        if (st.st_blksize <= G_MAXINT)
+            want = (int)st.st_blksize;
+        /* XXX, verify result? */
+    }
 #endif
 
-	/* allocate buffers */
-	state->in = (unsigned char *)g_try_malloc(want);
-	state->out = (unsigned char *)g_try_malloc(want << 1);
-	state->size = want;
-	if (state->in == NULL || state->out == NULL) {
-		g_free(state->out);
-		g_free(state->in);
-		g_free(state);
-		errno = ENOMEM;
-		return NULL;
-	}
+    /* allocate buffers */
+    state->in = (unsigned char *)g_try_malloc(want);
+    state->out = (unsigned char *)g_try_malloc(want << 1);
+    state->size = want;
+    if (state->in == NULL || state->out == NULL) {
+        g_free(state->out);
+        g_free(state->in);
+        g_free(state);
+        errno = ENOMEM;
+        return NULL;
+    }
 
 #ifdef HAVE_LIBZ
-	/* allocate inflate memory */
-	state->strm.zalloc = Z_NULL;
-	state->strm.zfree = Z_NULL;
-	state->strm.opaque = Z_NULL;
-	state->strm.avail_in = 0;
-	state->strm.next_in = Z_NULL;
-	if (inflateInit2(&(state->strm), -15) != Z_OK) {    /* raw inflate */
-		g_free(state->out);
-		g_free(state->in);
-		g_free(state);
-		errno = ENOMEM;
-		return NULL;
-	}
-
-	/* for now, assume we should check the crc */
-	state->dont_check_crc = FALSE;
+    /* allocate inflate memory */
+    state->strm.zalloc = Z_NULL;
+    state->strm.zfree = Z_NULL;
+    state->strm.opaque = Z_NULL;
+    state->strm.avail_in = 0;
+    state->strm.next_in = Z_NULL;
+    if (inflateInit2(&(state->strm), -15) != Z_OK) {    /* raw inflate */
+        g_free(state->out);
+        g_free(state->in);
+        g_free(state);
+        errno = ENOMEM;
+        return NULL;
+    }
+
+    /* for now, assume we should check the crc */
+    state->dont_check_crc = FALSE;
 #endif
-	/* return stream */
-	return state;
+    /* return stream */
+    return state;
 }
 
 FILE_T
 file_open(const char *path)
 {
-	int fd;
-	FILE_T ft;
+    int fd;
+    FILE_T ft;
 #ifdef HAVE_LIBZ
-	const char *suffixp;
+    const char *suffixp;
 #endif
 
-	/* open file and do correct filename conversions.
-
-	   XXX - do we need O_LARGEFILE?  On UN*X, if we need to do
-	   something special to get large file support, the configure
-	   script should have set us up with the appropriate #defines,
-	   so we should be getting a large-file-enabled file descriptor
-	   here.  Pre-Large File Summit UN*Xes, and possibly even some
-	   post-LFS UN*Xes, might require O_LARGEFILE here, though.
-	   If so, we should probably handle that in ws_open(). */
-	if ((fd = ws_open(path, O_RDONLY|O_BINARY, 0000)) == -1)
-		return NULL;
-
-	/* open file handle */
-	ft = file_fdopen(fd);
-	if (ft == NULL) {
-		ws_close(fd);
-		return NULL;
-	}
+    /* open file and do correct filename conversions.
+
+       XXX - do we need O_LARGEFILE?  On UN*X, if we need to do
+       something special to get large file support, the configure
+       script should have set us up with the appropriate #defines,
+       so we should be getting a large-file-enabled file descriptor
+       here.  Pre-Large File Summit UN*Xes, and possibly even some
+       post-LFS UN*Xes, might require O_LARGEFILE here, though.
+       If so, we should probably handle that in ws_open(). */
+    if ((fd = ws_open(path, O_RDONLY|O_BINARY, 0000)) == -1)
+        return NULL;
+
+    /* open file handle */
+    ft = file_fdopen(fd);
+    if (ft == NULL) {
+        ws_close(fd);
+        return NULL;
+    }
 
 #ifdef HAVE_LIBZ
-	/*
-	 * If this file's name ends in ".caz", it's probably a compressed
-	 * Windows Sniffer file.  The compression is gzip, but if we
-	 * process the CRC as specified by RFC 1952, the computed CRC
-	 * doesn't match the stored CRC.
-	 *
-	 * Compressed Windows Sniffer files don't all have the same CRC
-	 * value; is it just random crap, or are they running the CRC on
-	 * a different set of data than you're supposed to (e.g., not
-	 * CRCing some of the data), or something such as that?
-	 *
-	 * For now, we just set a flag to ignore CRC errors.
-	 */
-	suffixp = strrchr(path, '.');
-	if (suffixp != NULL) {
-		if (g_ascii_strcasecmp(suffixp, ".caz") == 0)
-			ft->dont_check_crc = TRUE;
-	}
+    /*
+     * If this file's name ends in ".caz", it's probably a compressed
+     * Windows Sniffer file.  The compression is gzip, but if we
+     * process the CRC as specified by RFC 1952, the computed CRC
+     * doesn't match the stored CRC.
+     *
+     * Compressed Windows Sniffer files don't all have the same CRC
+     * value; is it just random crap, or are they running the CRC on
+     * a different set of data than you're supposed to (e.g., not
+     * CRCing some of the data), or something such as that?
+     *
+     * For now, we just set a flag to ignore CRC errors.
+     */
+    suffixp = strrchr(path, '.');
+    if (suffixp != NULL) {
+        if (g_ascii_strcasecmp(suffixp, ".caz") == 0)
+            ft->dont_check_crc = TRUE;
+    }
 #endif
 
-	return ft;
+    return ft;
 }
 
 void
 file_set_random_access(FILE_T stream, gboolean random_flag _U_, GPtrArray *seek)
 {
-	stream->fast_seek = seek;
+    stream->fast_seek = seek;
 }
 
 gint64
 file_seek(FILE_T file, gint64 offset, int whence, int *err)
 {
-	struct fast_seek_point *here;
-	guint n;
+    struct fast_seek_point *here;
+    guint n;
 
-	/* can only seek from start or relative to current position */
-	if (whence != SEEK_SET && whence != SEEK_CUR) {
-		g_assert_not_reached();
+    /* can only seek from start or relative to current position */
+    if (whence != SEEK_SET && whence != SEEK_CUR) {
+        g_assert_not_reached();
 /*
-		*err = EINVAL;
-		return -1;
- */
-	}
-
-	/* normalize offset to a SEEK_CUR specification */
-	if (whence == SEEK_SET)
-		offset -= file->pos;
-	else if (file->seek_pending)
-		offset += file->skip;
-	file->seek_pending = FALSE;
-
-	if (offset < 0 && file->next) {
-		/*
-		 * This is guaranteed to fit in an unsigned int.
-		 * To squelch compiler warnings, we cast the
-		 * result.
-		 */
-		guint had = (unsigned)(file->next - file->out);
-		if (-offset <= had) {
-			/*
-			 * Offset is negative, so -offset is
-			 * non-negative, and -offset is
-			 * <= an unsigned and thus fits in an
-			 * unsigned.  Get that value and
-			 * adjust appropriately.
-			 *
-			 * (Casting offset to unsigned makes
-			 * it positive, which is not what we
-			 * would want, so we cast -offset
-			 * instead.)
-			 */
-			guint adjustment = (unsigned)(-offset);
-			file->have += adjustment;
-			file->next -= adjustment;
-			file->pos -= adjustment;
-			return file->pos;
-		}
-	}
-
-	/* XXX, profile */
-	if ((here = fast_seek_find(file, file->pos + offset)) && (offset < 0 || offset > SPAN || here->compression == UNCOMPRESSED)) {
-		gint64 off, off2;
+ *err = EINVAL;
+ return -1;
+*/
+    }
+
+    /* normalize offset to a SEEK_CUR specification */
+    if (whence == SEEK_SET)
+        offset -= file->pos;
+    else if (file->seek_pending)
+        offset += file->skip;
+    file->seek_pending = FALSE;
+
+    if (offset < 0 && file->next) {
+        /*
+         * This is guaranteed to fit in an unsigned int.
+         * To squelch compiler warnings, we cast the
+         * result.
+         */
+        guint had = (unsigned)(file->next - file->out);
+        if (-offset <= had) {
+            /*
+             * Offset is negative, so -offset is
+             * non-negative, and -offset is
+             * <= an unsigned and thus fits in an
+             * unsigned.  Get that value and
+             * adjust appropriately.
+             *
+             * (Casting offset to unsigned makes
+             * it positive, which is not what we
+             * would want, so we cast -offset
+             * instead.)
+             */
+            guint adjustment = (unsigned)(-offset);
+            file->have += adjustment;
+            file->next -= adjustment;
+            file->pos -= adjustment;
+            return file->pos;
+        }
+    }
+
+    /* XXX, profile */
+    if ((here = fast_seek_find(file, file->pos + offset)) && (offset < 0 || offset > SPAN || here->compression == UNCOMPRESSED)) {
+        gint64 off, off2;
 
 #ifdef HAVE_LIBZ
-		if (here->compression == ZLIB) {
+        if (here->compression == ZLIB) {
 #ifdef HAVE_INFLATEPRIME
-			off = here->in - (here->data.zlib.bits ? 1 : 0);
+            off = here->in - (here->data.zlib.bits ? 1 : 0);
 #else
-			off = here->in;
+            off = here->in;
 #endif
-			off2 = here->out;
-		} else if (here->compression == GZIP_AFTER_HEADER) {
-			off = here->in;
-			off2 = here->out;
-		} else
+            off2 = here->out;
+        } else if (here->compression == GZIP_AFTER_HEADER) {
+            off = here->in;
+            off2 = here->out;
+        } else
 #endif
-		{
-			off2 = (file->pos + offset);
-			off = here->in + (off2 - here->out);
-		}
-
-		if (ws_lseek64(file->fd, off, SEEK_SET) == -1) {
-			*err = errno;
-			return -1;
-		}
-		fast_seek_reset(file);
-
-		file->raw_pos = off;
-		file->have = 0;
-		file->eof = FALSE;
-		file->seek_pending = FALSE;
-		file->err = 0;
-		file->err_info = NULL;
-		file->avail_in = 0;
+        {
+            off2 = (file->pos + offset);
+            off = here->in + (off2 - here->out);
+        }
+
+        if (ws_lseek64(file->fd, off, SEEK_SET) == -1) {
+            *err = errno;
+            return -1;
+        }
+        fast_seek_reset(file);
+
+        file->raw_pos = off;
+        file->have = 0;
+        file->eof = FALSE;
+        file->seek_pending = FALSE;
+        file->err = 0;
+        file->err_info = NULL;
+        file->avail_in = 0;
 
 #ifdef HAVE_LIBZ
-		if (here->compression == ZLIB) {
-			z_stream *strm = &file->strm;
+        if (here->compression == ZLIB) {
+            z_stream *strm = &file->strm;
 
-			inflateReset(strm);
-			strm->adler = here->data.zlib.adler;
-			strm->total_out = here->data.zlib.total_out;
+            inflateReset(strm);
+            strm->adler = here->data.zlib.adler;
+            strm->total_out = here->data.zlib.total_out;
 #ifdef HAVE_INFLATEPRIME
-			if (here->data.zlib.bits) {
-				FILE_T state = file;
-				int ret = GZ_GETC();
-
-				if (ret == -1) {
-					if (state->err == 0) {
-						/* EOF */
-						*err = WTAP_ERR_SHORT_READ;
-					} else
-						*err = state->err;
-					return -1;
-				}
-				(void)inflatePrime(strm, here->data.zlib.bits, ret >> (8 - here->data.zlib.bits));
-			}
+            if (here->data.zlib.bits) {
+                FILE_T state = file;
+                int ret = GZ_GETC();
+
+                if (ret == -1) {
+                    if (state->err == 0) {
+                        /* EOF */
+                        *err = WTAP_ERR_SHORT_READ;
+                    } else
+                        *err = state->err;
+                    return -1;
+                }
+                (void)inflatePrime(strm, here->data.zlib.bits, ret >> (8 - here->data.zlib.bits));
+            }
 #endif
-			(void)inflateSetDictionary(strm, here->data.zlib.window, ZLIB_WINSIZE);
-			file->compression = ZLIB;
-		} else if (here->compression == GZIP_AFTER_HEADER) {
-			z_stream *strm = &file->strm;
-
-			inflateReset(strm);
-			strm->adler = crc32(0L, Z_NULL, 0);
-			file->compression = ZLIB;
-		} else
+            (void)inflateSetDictionary(strm, here->data.zlib.window, ZLIB_WINSIZE);
+            file->compression = ZLIB;
+        } else if (here->compression == GZIP_AFTER_HEADER) {
+            z_stream *strm = &file->strm;
+
+            inflateReset(strm);
+            strm->adler = crc32(0L, Z_NULL, 0);
+            file->compression = ZLIB;
+        } else
 #endif
-			file->compression = here->compression;
-
-		offset = (file->pos + offset) - off2;
-		file->pos = off2;
-		/* g_print("OK! %ld\n", offset); */
-
-		if (offset) {
-			file->seek_pending = TRUE;
-			file->skip = offset;
-		}
-		return file->pos + offset;
-	}
-
-	/* if within raw area while reading, just go there */
-	if (file->compression == UNCOMPRESSED && file->pos + offset >= file->raw
-			&& (offset < 0 || offset >= file->have) /* seek only when we don't have that offset in buffer */
-			&& (file->fast_seek) /* seek only when random access is supported */)
-	{
-		if (ws_lseek64(file->fd, offset - file->have, SEEK_CUR) == -1) {
-			*err = errno;
-			return -1;
-		}
-		file->raw_pos += (offset - file->have);
-		file->have = 0;
-		file->eof = FALSE;
-		file->seek_pending = FALSE;
-		file->err = 0;
-		file->err_info = NULL;
-		file->avail_in = 0;
-		file->pos += offset;
-		return file->pos;
-	}
-
-	/* calculate skip amount, rewinding if needed for back seek when reading */
-	if (offset < 0) {
-		offset += file->pos;
-		if (offset < 0) {                    /* before start of file! */
-			*err = EINVAL;
-			return -1;
-		}
-		/* rewind, then skip to offset */
-
-		/* back up and start over */
-		if (ws_lseek64(file->fd, file->start, SEEK_SET) == -1) {
-			*err = errno;
-			return -1;
-		}
-		fast_seek_reset(file);
-		file->raw_pos = file->start;
-		gz_reset(file);
-	}
-
-	/* skip what's in output buffer (one less gzgetc() check) */
-	n = (gint64)file->have > offset ? (unsigned)offset : file->have;
-	file->have -= n;
-	file->next += n;
-	file->pos += n;
-	offset -= n;
-
-	/* request skip (if not zero) */
-	if (offset) {
-		file->seek_pending = TRUE;
-		file->skip = offset;
-	}
-	return file->pos + offset;
+            file->compression = here->compression;
+
+        offset = (file->pos + offset) - off2;
+        file->pos = off2;
+        /* g_print("OK! %ld\n", offset); */
+
+        if (offset) {
+            file->seek_pending = TRUE;
+            file->skip = offset;
+        }
+        return file->pos + offset;
+    }
+
+    /* if within raw area while reading, just go there */
+    if (file->compression == UNCOMPRESSED && file->pos + offset >= file->raw
+        && (offset < 0 || offset >= file->have) /* seek only when we don't have that offset in buffer */
+        && (file->fast_seek) /* seek only when random access is supported */)
+    {
+        if (ws_lseek64(file->fd, offset - file->have, SEEK_CUR) == -1) {
+            *err = errno;
+            return -1;
+        }
+        file->raw_pos += (offset - file->have);
+        file->have = 0;
+        file->eof = FALSE;
+        file->seek_pending = FALSE;
+        file->err = 0;
+        file->err_info = NULL;
+        file->avail_in = 0;
+        file->pos += offset;
+        return file->pos;
+    }
+
+    /* calculate skip amount, rewinding if needed for back seek when reading */
+    if (offset < 0) {
+        offset += file->pos;
+        if (offset < 0) {                    /* before start of file! */
+            *err = EINVAL;
+            return -1;
+        }
+        /* rewind, then skip to offset */
+
+        /* back up and start over */
+        if (ws_lseek64(file->fd, file->start, SEEK_SET) == -1) {
+            *err = errno;
+            return -1;
+        }
+        fast_seek_reset(file);
+        file->raw_pos = file->start;
+        gz_reset(file);
+    }
+
+    /* skip what's in output buffer (one less gzgetc() check) */
+    n = (gint64)file->have > offset ? (unsigned)offset : file->have;
+    file->have -= n;
+    file->next += n;
+    file->pos += n;
+    offset -= n;
+
+    /* request skip (if not zero) */
+    if (offset) {
+        file->seek_pending = TRUE;
+        file->skip = offset;
+    }
+    return file->pos + offset;
 }
 
 /*
@@ -1114,97 +1114,97 @@ file_seek(FILE_T file, gint64 offset, int whence, int *err)
 gboolean
 file_skip(FILE_T file, gint64 delta, int *err)
 {
-	if (file_seek(file, delta, SEEK_CUR, err) == -1)
-		return FALSE;
-	return TRUE;
+    if (file_seek(file, delta, SEEK_CUR, err) == -1)
+        return FALSE;
+    return TRUE;
 }
 
 gint64
 file_tell(FILE_T stream)
 {
-	/* return position */
-	return stream->pos + (stream->seek_pending ? stream->skip : 0);
+    /* return position */
+    return stream->pos + (stream->seek_pending ? stream->skip : 0);
 }
 
 gint64
 file_tell_raw(FILE_T stream)
 {
-	return stream->raw_pos;
+    return stream->raw_pos;
 }
 
 int
 file_fstat(FILE_T stream, ws_statb64 *statb, int *err)
 {
-	if (ws_fstat64(stream->fd, statb) == -1) {
-		if (err != NULL)
-			*err = errno;
-		return -1;
-	}
-	return 0;
+    if (ws_fstat64(stream->fd, statb) == -1) {
+        if (err != NULL)
+            *err = errno;
+        return -1;
+    }
+    return 0;
 }
 
 gboolean
 file_iscompressed(FILE_T stream)
 {
-	return stream->is_compressed;
+    return stream->is_compressed;
 }
 
 int
 file_read(void *buf, unsigned int len, FILE_T file)
 {
-	guint got, n;
-
-	/* if len is zero, avoid unnecessary operations */
-	if (len == 0)
-		return 0;
-
-	/* process a skip request */
-	if (file->seek_pending) {
-		file->seek_pending = FALSE;
-		if (gz_skip(file, file->skip) == -1)
-			return -1;
-	}
-
-	/* get len bytes to buf, or less than len if at the end */
-	got = 0;
-	do {
-		if (file->have) {
-			/* We have stuff in the output buffer; copy
-			   what we have. */
-			n = file->have > len ? len : file->have;
-			memcpy(buf, file->next, n);
-			file->next += n;
-			file->have -= n;
-		} else if (file->err) {
-			/* We have nothing in the output buffer, and
-			   we have an error that may not have been
-			   reported yet; that means we can't generate
-			   any more data into the output buffer, so
-			   return an error indication. */
-			return -1;
-		} else if (file->eof && file->avail_in == 0) {
-			/* We have nothing in the output buffer, and
-			   we're at the end of the input; just return
-			   with what we've gotten so far. */
-			break;
-		} else {
-			/* We have nothing in the output buffer, and
-			   we can generate more data; get more output,
-			   looking for header if required, and
-			   keep looping to process the new stuff
-			   in the output buffer. */
-			if (fill_out_buffer(file) == -1)
-				return -1;
-			continue;       /* no progress yet -- go back to memcpy() above */
-		}
-		/* update progress */
-		len -= n;
-		buf = (char *)buf + n;
-		got += n;
-		file->pos += n;
-	} while (len);
-
-	return (int)got;
+    guint got, n;
+
+    /* if len is zero, avoid unnecessary operations */
+    if (len == 0)
+        return 0;
+
+    /* process a skip request */
+    if (file->seek_pending) {
+        file->seek_pending = FALSE;
+        if (gz_skip(file, file->skip) == -1)
+            return -1;
+    }
+
+    /* get len bytes to buf, or less than len if at the end */
+    got = 0;
+    do {
+        if (file->have) {
+            /* We have stuff in the output buffer; copy
+               what we have. */
+            n = file->have > len ? len : file->have;
+            memcpy(buf, file->next, n);
+            file->next += n;
+            file->have -= n;
+        } else if (file->err) {
+            /* We have nothing in the output buffer, and
+               we have an error that may not have been
+               reported yet; that means we can't generate
+               any more data into the output buffer, so
+               return an error indication. */
+            return -1;
+        } else if (file->eof && file->avail_in == 0) {
+            /* We have nothing in the output buffer, and
+               we're at the end of the input; just return
+               with what we've gotten so far. */
+            break;
+        } else {
+            /* We have nothing in the output buffer, and
+               we can generate more data; get more output,
+               looking for header if required, and
+               keep looping to process the new stuff
+               in the output buffer. */
+            if (fill_out_buffer(file) == -1)
+                return -1;
+            continue;       /* no progress yet -- go back to memcpy() above */
+        }
+        /* update progress */
+        len -= n;
+        buf = (char *)buf + n;
+        got += n;
+        file->pos += n;
+    } while (len);
+
+    return (int)got;
 }
 
 /*
@@ -1213,45 +1213,45 @@ file_read(void *buf, unsigned int len, FILE_T file)
 int
 file_peekc(FILE_T file)
 {
-	int ret = 0;
-
-	/* check that we're reading and that there's no error */
-	if (file->err)
-		return -1;
-
-	/* try output buffer (no need to check for skip request) */
-	if (file->have) {
-		return *(file->next);
-	}
-
-	/* process a skip request */
-	if (file->seek_pending) {
-		file->seek_pending = FALSE;
-		if (gz_skip(file, file->skip) == -1)
-			return -1;
-	}
-	/* if we processed a skip request, there may be data in the buffer,
-	 * or an error could have occurred; likewise if we didn't do seek but
-	 * now call fill_out_buffer, the errors can occur.  So we do this while
-	 * loop to check before and after - this is basically the logic from
-	 * file_read() but only for peeking not consuming a byte
-	 */
-	while (1) {
-		if (file->have) {
-			return *(file->next);
-		}
-		else if (file->err) {
-			return -1;
-		}
-		else if (file->eof && file->avail_in == 0) {
-			return -1;
-		}
-		else if (fill_out_buffer(file) == -1) {
-			return -1;
-		}
-	}
-	/* it's actually impossible to get here */
-	return ret;
+    int ret = 0;
+
+    /* check that we're reading and that there's no error */
+    if (file->err)
+        return -1;
+
+    /* try output buffer (no need to check for skip request) */
+    if (file->have) {
+        return *(file->next);
+    }
+
+    /* process a skip request */
+    if (file->seek_pending) {
+        file->seek_pending = FALSE;
+        if (gz_skip(file, file->skip) == -1)
+            return -1;
+    }
+    /* if we processed a skip request, there may be data in the buffer,
+     * or an error could have occurred; likewise if we didn't do seek but
+     * now call fill_out_buffer, the errors can occur.  So we do this while
+     * loop to check before and after - this is basically the logic from
+     * file_read() but only for peeking not consuming a byte
+     */
+    while (1) {
+        if (file->have) {
+            return *(file->next);
+        }
+        else if (file->err) {
+            return -1;
+        }
+        else if (file->eof && file->avail_in == 0) {
+            return -1;
+        }
+        else if (fill_out_buffer(file) == -1) {
+            return -1;
+        }
+    }
+    /* it's actually impossible to get here */
+    return ret;
 }
 
 /*
@@ -1260,97 +1260,97 @@ file_peekc(FILE_T file)
 int
 file_getc(FILE_T file)
 {
-	unsigned char buf[1];
-	int ret;
-
-	/* check that we're reading and that there's no error */
-	if (file->err)
-		return -1;
-
-	/* try output buffer (no need to check for skip request) */
-	if (file->have) {
-		file->have--;
-		file->pos++;
-		return *(file->next)++;
-	}
-
-	ret = file_read(buf, 1, file);
-	return ret < 1 ? -1 : buf[0];
+    unsigned char buf[1];
+    int ret;
+
+    /* check that we're reading and that there's no error */
+    if (file->err)
+        return -1;
+
+    /* try output buffer (no need to check for skip request) */
+    if (file->have) {
+        file->have--;
+        file->pos++;
+        return *(file->next)++;
+    }
+
+    ret = file_read(buf, 1, file);
+    return ret < 1 ? -1 : buf[0];
 }
 
 char *
 file_gets(char *buf, int len, FILE_T file)
 {
-	guint left, n;
-	char *str;
-	unsigned char *eol;
-
-	/* check parameters */
-	if (buf == NULL || len < 1)
-		return NULL;
-
-	/* check that there's no error */
-	if (file->err)
-		return NULL;
-
-	/* process a skip request */
-	if (file->seek_pending) {
-		file->seek_pending = FALSE;
-		if (gz_skip(file, file->skip) == -1)
-			return NULL;
-	}
-
-	/* copy output bytes up to new line or len - 1, whichever comes first --
-	   append a terminating zero to the string (we don't check for a zero in
-	   the contents, let the user worry about that) */
-	str = buf;
-	left = (unsigned)len - 1;
-	if (left) do {
-		/* assure that something is in the output buffer */
-		if (file->have == 0) {
-			/* We have nothing in the output buffer. */
-			if (file->err) {
-				/* We have an error that may not have
-				   been reported yet; that means we
-				   can't generate any more data into
-				   the output buffer, so return an
-				   error indication. */
-				return NULL;
-			}
-			if (fill_out_buffer(file) == -1)
-				return NULL;            /* error */
-			if (file->have == 0)  {     /* end of file */
-				if (buf == str)         /* got bupkus */
-					return NULL;
-				break;                  /* got something -- return it */
-			}
-		}
-
-		/* look for end-of-line in current output buffer */
-		n = file->have > left ? left : file->have;
-		eol = (unsigned char *)memchr(file->next, '\n', n);
-		if (eol != NULL)
-			n = (unsigned)(eol - file->next) + 1;
-
-		/* copy through end-of-line, or remainder if not found */
-		memcpy(buf, file->next, n);
-		file->have -= n;
-		file->next += n;
-		file->pos += n;
-		left -= n;
-		buf += n;
-	} while (left && eol == NULL);
-
-	/* found end-of-line or out of space -- terminate string and return it */
-	buf[0] = 0;
-	return str;
+    guint left, n;
+    char *str;
+    unsigned char *eol;
+
+    /* check parameters */
+    if (buf == NULL || len < 1)
+        return NULL;
+
+    /* check that there's no error */
+    if (file->err)
+        return NULL;
+
+    /* process a skip request */
+    if (file->seek_pending) {
+        file->seek_pending = FALSE;
+        if (gz_skip(file, file->skip) == -1)
+            return NULL;
+    }
+
+    /* copy output bytes up to new line or len - 1, whichever comes first --
+       append a terminating zero to the string (we don't check for a zero in
+       the contents, let the user worry about that) */
+    str = buf;
+    left = (unsigned)len - 1;
+    if (left) do {
+            /* assure that something is in the output buffer */
+            if (file->have == 0) {
+                /* We have nothing in the output buffer. */
+                if (file->err) {
+                    /* We have an error that may not have
+                       been reported yet; that means we
+                       can't generate any more data into
+                       the output buffer, so return an
+                       error indication. */
+                    return NULL;
+                }
+                if (fill_out_buffer(file) == -1)
+                    return NULL;            /* error */
+                if (file->have == 0)  {     /* end of file */
+                    if (buf == str)         /* got bupkus */
+                        return NULL;
+                    break;                  /* got something -- return it */
+                }
+            }
+
+            /* look for end-of-line in current output buffer */
+            n = file->have > left ? left : file->have;
+            eol = (unsigned char *)memchr(file->next, '\n', n);
+            if (eol != NULL)
+                n = (unsigned)(eol - file->next) + 1;
+
+            /* copy through end-of-line, or remainder if not found */
+            memcpy(buf, file->next, n);
+            file->have -= n;
+            file->next += n;
+            file->pos += n;
+            left -= n;
+            buf += n;
+        } while (left && eol == NULL);
+
+    /* found end-of-line or out of space -- terminate string and return it */
+    buf[0] = 0;
+    return str;
 }
 
 int
 file_eof(FILE_T file)
 {
-	/* return end-of-file state */
-	return (file->eof && file->avail_in == 0 && file->have == 0);
+    /* return end-of-file state */
+    return (file->eof && file->avail_in == 0 && file->have == 0);
 }
 
 /*
@@ -1361,64 +1361,64 @@ file_eof(FILE_T file)
 int
 file_error(FILE_T fh, gchar **err_info)
 {
-	if (fh->err!=0 && err_info) {
-		/* g_strdup() returns NULL for NULL argument */
-		*err_info = g_strdup(fh->err_info);
-	}
-	return fh->err;
+    if (fh->err!=0 && err_info) {
+        /* g_strdup() returns NULL for NULL argument */
+        *err_info = g_strdup(fh->err_info);
+    }
+    return fh->err;
 }
 
 void
 file_clearerr(FILE_T stream)
 {
-	/* clear error and end-of-file */
-	stream->err = 0;
-	stream->err_info = NULL;
-	stream->eof = FALSE;
+    /* clear error and end-of-file */
+    stream->err = 0;
+    stream->err_info = NULL;
+    stream->eof = FALSE;
 }
 
 void
 file_fdclose(FILE_T file)
 {
-	ws_close(file->fd);
-	file->fd = -1;
+    ws_close(file->fd);
+    file->fd = -1;
 }
 
 gboolean
 file_fdreopen(FILE_T file, const char *path)
 {
-	int fd;
+    int fd;
 
-	if ((fd = ws_open(path, O_RDONLY|O_BINARY, 0000)) == -1)
-		return FALSE;
-	file->fd = fd;
-	return TRUE;
+    if ((fd = ws_open(path, O_RDONLY|O_BINARY, 0000)) == -1)
+        return FALSE;
+    file->fd = fd;
+    return TRUE;
 }
 
 void
 file_close(FILE_T file)
 {
-	int fd = file->fd;
+    int fd = file->fd;
 
-	/* free memory and close file */
-	if (file->size) {
+    /* free memory and close file */
+    if (file->size) {
 #ifdef HAVE_LIBZ
-		inflateEnd(&(file->strm));
+        inflateEnd(&(file->strm));
 #endif
-		g_free(file->out);
-		g_free(file->in);
-	}
-	g_free(file->fast_seek_cur);
-	file->err = 0;
-	file->err_info = NULL;
-	g_free(file);
-	/*
-	 * If fd is -1, somebody's done a file_closefd() on us, so
-	 * we don't need to close the FD itself, and shouldn't do
-	 * so.
-	 */
-	if (fd != -1)
-		ws_close(fd);
+        g_free(file->out);
+        g_free(file->in);
+    }
+    g_free(file->fast_seek_cur);
+    file->err = 0;
+    file->err_info = NULL;
+    g_free(file);
+    /*
+     * If fd is -1, somebody's done a file_closefd() on us, so
+     * we don't need to close the FD itself, and shouldn't do
+     * so.
+     */
+    if (fd != -1)
+        ws_close(fd);
 }
 
 #ifdef HAVE_LIBZ
@@ -1434,7 +1434,7 @@ struct wtap_writer {
     int level;              /* compression level */
     int strategy;           /* compression strategy */
     int err;                /* error code */
-	/* zlib deflate stream */
+    /* zlib deflate stream */
     z_stream strm;          /* stream structure in-place (not a pointer) */
 };
 
@@ -1511,11 +1511,11 @@ gz_init(GZWFILE_T state)
         g_free(state->out);
         g_free(state->in);
         if (ret == Z_MEM_ERROR) {
-        	/* This means "not enough memory". */
-        	state->err = ENOMEM;
+            /* This means "not enough memory". */
+            state->err = ENOMEM;
         } else {
-        	/* This "shouldn't happen". */
-        	state->err = WTAP_ERR_INTERNAL;
+            /* This "shouldn't happen". */
+            state->err = WTAP_ERR_INTERNAL;
         }
         return -1;
     }
@@ -1553,11 +1553,11 @@ gz_comp(GZWFILE_T state, int flush)
         /* write out current buffer contents if full, or if flushing, but if
            doing Z_FINISH then don't write until we get to Z_STREAM_END */
         if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
-            (flush != Z_FINISH || ret == Z_STREAM_END))) {
+                                     (flush != Z_FINISH || ret == Z_STREAM_END))) {
             have = strm->next_out - state->next;
             if (have) {
-		got = write(state->fd, state->next, (unsigned int)have);
-		if (got < 0) {
+                got = write(state->fd, state->next, (unsigned int)have);
+                if (got < 0) {
                     state->err = errno;
                     return -1;
                 }
@@ -1693,3 +1693,16 @@ gzwfile_geterr(GZWFILE_T state)
     return state->err;
 }
 #endif
+
+/*
+ * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */