2000-05-19 23:07:04 +00:00
|
|
|
/* wtap-int.h
|
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
2000-05-19 23:07:04 +00:00
|
|
|
*
|
|
|
|
* Wiretap Library
|
2001-11-13 23:55:44 +00:00
|
|
|
* Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
|
2002-08-28 20:30:45 +00:00
|
|
|
*
|
2000-05-19 23:07:04 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-08-28 20:30:45 +00:00
|
|
|
*
|
2000-05-19 23:07:04 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2002-08-28 20:30:45 +00:00
|
|
|
*
|
2000-05-19 23:07:04 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __WTAP_INT_H__
|
|
|
|
#define __WTAP_INT_H__
|
|
|
|
|
|
|
|
#ifdef HAVE_SYS_TIME_H
|
|
|
|
#include <sys/time.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <glib.h>
|
|
|
|
#include <stdio.h>
|
2000-08-25 21:25:43 +00:00
|
|
|
#include <time.h>
|
2000-05-19 23:07:04 +00:00
|
|
|
|
2002-10-15 05:38:01 +00:00
|
|
|
#ifdef HAVE_WINSOCK2_H
|
|
|
|
#include <winsock2.h>
|
|
|
|
#endif
|
2008-10-24 00:42:09 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_LIBZ
|
2002-07-31 22:52:38 +00:00
|
|
|
#include <zlib.h>
|
2000-05-19 23:07:04 +00:00
|
|
|
#define FILE_T gzFile
|
|
|
|
#else /* No zLib */
|
|
|
|
#define FILE_T FILE *
|
|
|
|
#endif /* HAVE_LIBZ */
|
|
|
|
|
|
|
|
#include "wtap.h"
|
|
|
|
|
2006-11-05 22:46:44 +00:00
|
|
|
typedef gboolean (*subtype_read_func)(struct wtap*, int*, char**, gint64*);
|
|
|
|
typedef gboolean (*subtype_seek_read_func)(struct wtap*, gint64, union wtap_pseudo_header*,
|
Have the Wiretap open, read, and seek-and-read routines return, in
addition to an error code, an error info string, for
WTAP_ERR_UNSUPPORTED, WTAP_ERR_UNSUPPORTED_ENCAP, and
WTAP_ERR_BAD_RECORD errors. Replace the error messages logged with
"g_message()" for those errors with g_strdup()ed or g_strdup_printf()ed
strings returned as the error info string, and change the callers of
those routines to, for those errors, put the info string into the
printed message or alert box for the error.
Add messages for cases where those errors were returned without printing
an additional message.
Nobody uses the error code from "cf_read()" - "cf_read()" puts up the
alert box itself for failures; get rid of the error code, so it just
returns a success/failure indication.
Rename "file_read_error_message()" to "cf_read_error_message()", as it
handles read errors from Wiretap, and have it take an error info string
as an argument. (That handles a lot of the work of putting the info
string into the error message.)
Make some variables in "ascend-grammar.y" static.
Check the return value of "erf_read_header()" in "erf_seek_read()".
Get rid of an unused #define in "i4btrace.c".
svn path=/trunk/; revision=9852
2004-01-25 21:55:17 +00:00
|
|
|
guint8*, int, int *, char **);
|
2000-05-19 23:07:04 +00:00
|
|
|
struct wtap {
|
|
|
|
FILE_T fh;
|
|
|
|
int fd; /* File descriptor for cap file */
|
|
|
|
FILE_T random_fh; /* Secondary FILE_T for random access */
|
|
|
|
int file_type;
|
|
|
|
int snapshot_length;
|
|
|
|
struct Buffer *frame_buffer;
|
|
|
|
struct wtap_pkthdr phdr;
|
|
|
|
union wtap_pseudo_header pseudo_header;
|
|
|
|
|
2006-11-05 22:46:44 +00:00
|
|
|
gint64 data_offset;
|
2000-05-19 23:07:04 +00:00
|
|
|
|
2010-02-26 07:59:54 +00:00
|
|
|
void *priv;
|
2000-05-19 23:07:04 +00:00
|
|
|
|
|
|
|
subtype_read_func subtype_read;
|
|
|
|
subtype_seek_read_func subtype_seek_read;
|
2000-05-25 09:00:24 +00:00
|
|
|
void (*subtype_sequential_close)(struct wtap*);
|
2000-05-19 23:07:04 +00:00
|
|
|
void (*subtype_close)(struct wtap*);
|
|
|
|
int file_encap; /* per-file, for those
|
|
|
|
file formats that have
|
|
|
|
per-file encapsulation
|
|
|
|
types */
|
2005-08-24 21:31:56 +00:00
|
|
|
int tsprecision; /* timestamp precision of the lower 32bits
|
2006-12-25 21:34:11 +00:00
|
|
|
* e.g. WTAP_FILE_TSPREC_USEC */
|
2011-03-24 22:47:57 +00:00
|
|
|
wtap_new_ipv4_callback_t add_new_ipv4;
|
|
|
|
wtap_new_ipv6_callback_t add_new_ipv6;
|
2000-05-19 23:07:04 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct wtap_dumper;
|
|
|
|
|
|
|
|
typedef gboolean (*subtype_write_func)(struct wtap_dumper*,
|
|
|
|
const struct wtap_pkthdr*, const union wtap_pseudo_header*,
|
2002-07-29 06:09:59 +00:00
|
|
|
const guchar*, int*);
|
2000-05-19 23:07:04 +00:00
|
|
|
typedef gboolean (*subtype_close_func)(struct wtap_dumper*, int*);
|
|
|
|
|
|
|
|
struct wtap_dumper {
|
|
|
|
FILE* fh;
|
|
|
|
int file_type;
|
|
|
|
int snaplen;
|
|
|
|
int encap;
|
2011-03-24 22:47:57 +00:00
|
|
|
gboolean compressed;
|
|
|
|
gint64 bytes_dumped;
|
2000-05-19 23:07:04 +00:00
|
|
|
|
2010-02-26 07:59:54 +00:00
|
|
|
void *priv;
|
2000-05-19 23:07:04 +00:00
|
|
|
|
|
|
|
subtype_write_func subtype_write;
|
|
|
|
subtype_close_func subtype_close;
|
2005-08-30 09:43:47 +00:00
|
|
|
|
|
|
|
int tsprecision; /* timestamp precision of the lower 32bits
|
|
|
|
* e.g. WTAP_FILE_TSPREC_USEC */
|
2011-03-24 22:47:57 +00:00
|
|
|
struct addrinfo *addrinfo_list;
|
2000-05-19 23:07:04 +00:00
|
|
|
};
|
|
|
|
|
2010-06-06 19:14:32 +00:00
|
|
|
extern gboolean wtap_dump_file_write(wtap_dumper *wdh, const void *buf,
|
|
|
|
size_t bufsize, int *err);
|
2011-03-24 22:47:57 +00:00
|
|
|
extern gint64 wtap_dump_file_seek(wtap_dumper *wdh, gint64 offset, int whence, int *err);
|
|
|
|
extern gint64 wtap_dump_file_tell(wtap_dumper *wdh);
|
|
|
|
|
2000-05-19 23:07:04 +00:00
|
|
|
|
2007-05-05 10:47:35 +00:00
|
|
|
extern gint wtap_num_file_types;
|
|
|
|
|
2008-01-20 02:31:34 +00:00
|
|
|
/* Macros to byte-swap 64-bit, 32-bit and 16-bit quantities. */
|
|
|
|
#define BSWAP64(x) \
|
|
|
|
((((x)&G_GINT64_CONSTANT(0xFF00000000000000U))>>56) | \
|
|
|
|
(((x)&G_GINT64_CONSTANT(0x00FF000000000000U))>>40) | \
|
|
|
|
(((x)&G_GINT64_CONSTANT(0x0000FF0000000000U))>>24) | \
|
|
|
|
(((x)&G_GINT64_CONSTANT(0x000000FF00000000U))>>8) | \
|
|
|
|
(((x)&G_GINT64_CONSTANT(0x00000000FF000000U))<<8) | \
|
|
|
|
(((x)&G_GINT64_CONSTANT(0x0000000000FF0000U))<<24) | \
|
|
|
|
(((x)&G_GINT64_CONSTANT(0x000000000000FF00U))<<40) | \
|
|
|
|
(((x)&G_GINT64_CONSTANT(0x00000000000000FFU))<<56))
|
2000-05-19 23:07:04 +00:00
|
|
|
#define BSWAP32(x) \
|
|
|
|
((((x)&0xFF000000)>>24) | \
|
|
|
|
(((x)&0x00FF0000)>>8) | \
|
|
|
|
(((x)&0x0000FF00)<<8) | \
|
|
|
|
(((x)&0x000000FF)<<24))
|
|
|
|
#define BSWAP16(x) \
|
|
|
|
((((x)&0xFF00)>>8) | \
|
|
|
|
(((x)&0x00FF)<<8))
|
|
|
|
|
2010-04-21 20:51:22 +00:00
|
|
|
/* Macros to byte-swap possibly-unaligned 64-bit, 32-bit and 16-bit quantities;
|
2007-05-28 06:47:50 +00:00
|
|
|
* they take a pointer to the quantity, and byte-swap it in place.
|
|
|
|
*/
|
2010-04-21 20:51:22 +00:00
|
|
|
#define PBSWAP64(p) \
|
|
|
|
{ \
|
|
|
|
guint8 tmp; \
|
|
|
|
tmp = (p)[7]; \
|
|
|
|
(p)[7] = (p)[0]; \
|
|
|
|
(p)[0] = tmp; \
|
|
|
|
tmp = (p)[6]; \
|
|
|
|
(p)[6] = (p)[1]; \
|
|
|
|
(p)[1] = tmp; \
|
|
|
|
tmp = (p)[5]; \
|
|
|
|
(p)[5] = (p)[2]; \
|
|
|
|
(p)[2] = tmp; \
|
|
|
|
tmp = (p)[4]; \
|
|
|
|
(p)[4] = (p)[3]; \
|
|
|
|
(p)[3] = tmp; \
|
|
|
|
}
|
2007-05-28 06:47:50 +00:00
|
|
|
#define PBSWAP32(p) \
|
|
|
|
{ \
|
|
|
|
guint8 tmp; \
|
|
|
|
tmp = (p)[3]; \
|
|
|
|
(p)[3] = (p)[0]; \
|
|
|
|
(p)[0] = tmp; \
|
|
|
|
tmp = (p)[2]; \
|
|
|
|
(p)[2] = (p)[1]; \
|
|
|
|
(p)[1] = tmp; \
|
|
|
|
}
|
|
|
|
#define PBSWAP16(p) \
|
|
|
|
{ \
|
|
|
|
guint8 tmp; \
|
|
|
|
tmp = (p)[1]; \
|
|
|
|
(p)[1] = (p)[0]; \
|
|
|
|
(p)[0] = tmp; \
|
|
|
|
}
|
|
|
|
|
2000-05-19 23:07:04 +00:00
|
|
|
/* Turn host-byte-order values into little-endian values. */
|
2003-07-29 20:49:32 +00:00
|
|
|
#define htoles(s) GUINT16_TO_LE(s)
|
|
|
|
#define htolel(l) GUINT32_TO_LE(l)
|
2001-02-13 00:50:05 +00:00
|
|
|
#define htolell(ll) GUINT64_TO_LE(ll)
|
|
|
|
|
2000-05-19 23:07:04 +00:00
|
|
|
/* Pointer versions of ntohs and ntohl. Given a pointer to a member of a
|
|
|
|
* byte array, returns the value of the two or four bytes at the pointer.
|
|
|
|
* The pletoh[sl] versions return the little-endian representation.
|
2007-05-28 06:47:50 +00:00
|
|
|
* We also provide pntohll and pletohll, which extract 64-bit integral
|
2005-08-26 19:40:46 +00:00
|
|
|
* quantities.
|
2007-05-28 06:47:50 +00:00
|
|
|
*
|
|
|
|
* These will work regardless of the byte alignment of the pointer.
|
2000-05-19 23:07:04 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef pntohs
|
|
|
|
#define pntohs(p) ((guint16) \
|
2002-11-27 22:21:41 +00:00
|
|
|
((guint16)*((const guint8 *)(p)+0)<<8| \
|
|
|
|
(guint16)*((const guint8 *)(p)+1)<<0))
|
2001-02-13 00:50:05 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef pntoh24
|
2002-11-27 22:21:41 +00:00
|
|
|
#define pntoh24(p) ((guint32)*((const guint8 *)(p)+0)<<16| \
|
|
|
|
(guint32)*((const guint8 *)(p)+1)<<8| \
|
|
|
|
(guint32)*((const guint8 *)(p)+2)<<0)
|
2000-05-19 23:07:04 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef pntohl
|
2002-11-27 22:21:41 +00:00
|
|
|
#define pntohl(p) ((guint32)*((const guint8 *)(p)+0)<<24| \
|
|
|
|
(guint32)*((const guint8 *)(p)+1)<<16| \
|
|
|
|
(guint32)*((const guint8 *)(p)+2)<<8| \
|
|
|
|
(guint32)*((const guint8 *)(p)+3)<<0)
|
2001-02-13 00:50:05 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef pntohll
|
2002-11-27 22:21:41 +00:00
|
|
|
#define pntohll(p) ((guint64)*((const guint8 *)(p)+0)<<56| \
|
|
|
|
(guint64)*((const guint8 *)(p)+1)<<48| \
|
|
|
|
(guint64)*((const guint8 *)(p)+2)<<40| \
|
|
|
|
(guint64)*((const guint8 *)(p)+3)<<32| \
|
|
|
|
(guint64)*((const guint8 *)(p)+4)<<24| \
|
|
|
|
(guint64)*((const guint8 *)(p)+5)<<16| \
|
|
|
|
(guint64)*((const guint8 *)(p)+6)<<8| \
|
|
|
|
(guint64)*((const guint8 *)(p)+7)<<0)
|
2000-05-19 23:07:04 +00:00
|
|
|
#endif
|
2001-02-13 00:50:05 +00:00
|
|
|
|
2000-05-19 23:07:04 +00:00
|
|
|
|
|
|
|
#ifndef pletohs
|
|
|
|
#define pletohs(p) ((guint16) \
|
2002-11-27 22:21:41 +00:00
|
|
|
((guint16)*((const guint8 *)(p)+1)<<8| \
|
|
|
|
(guint16)*((const guint8 *)(p)+0)<<0))
|
2001-02-13 00:50:05 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef pletoh24
|
2002-11-27 22:21:41 +00:00
|
|
|
#define pletoh24(p) ((guint32)*((const guint8 *)(p)+2)<<16| \
|
|
|
|
(guint32)*((const guint8 *)(p)+1)<<8| \
|
|
|
|
(guint32)*((const guint8 *)(p)+0)<<0)
|
2000-05-19 23:07:04 +00:00
|
|
|
#endif
|
|
|
|
|
2001-02-13 00:50:05 +00:00
|
|
|
|
2000-05-19 23:07:04 +00:00
|
|
|
#ifndef pletohl
|
2002-11-27 22:21:41 +00:00
|
|
|
#define pletohl(p) ((guint32)*((const guint8 *)(p)+3)<<24| \
|
|
|
|
(guint32)*((const guint8 *)(p)+2)<<16| \
|
|
|
|
(guint32)*((const guint8 *)(p)+1)<<8| \
|
|
|
|
(guint32)*((const guint8 *)(p)+0)<<0)
|
2000-05-19 23:07:04 +00:00
|
|
|
#endif
|
|
|
|
|
2000-09-19 17:22:11 +00:00
|
|
|
|
2001-02-13 00:50:05 +00:00
|
|
|
#ifndef pletohll
|
2002-11-27 22:21:41 +00:00
|
|
|
#define pletohll(p) ((guint64)*((const guint8 *)(p)+7)<<56| \
|
|
|
|
(guint64)*((const guint8 *)(p)+6)<<48| \
|
|
|
|
(guint64)*((const guint8 *)(p)+5)<<40| \
|
|
|
|
(guint64)*((const guint8 *)(p)+4)<<32| \
|
|
|
|
(guint64)*((const guint8 *)(p)+3)<<24| \
|
|
|
|
(guint64)*((const guint8 *)(p)+2)<<16| \
|
|
|
|
(guint64)*((const guint8 *)(p)+1)<<8| \
|
|
|
|
(guint64)*((const guint8 *)(p)+0)<<0)
|
2001-02-13 00:50:05 +00:00
|
|
|
#endif
|
|
|
|
|
2007-05-28 06:47:50 +00:00
|
|
|
/* Pointer routines to put items out in a particular byte order.
|
|
|
|
* These will work regardless of the byte alignment of the pointer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef phtons
|
|
|
|
#define phtons(p, v) \
|
2007-05-28 08:31:18 +00:00
|
|
|
{ \
|
|
|
|
(p)[0] = (guint8)((v) >> 8); \
|
|
|
|
(p)[1] = (guint8)((v) >> 0); \
|
2007-05-28 06:47:50 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-06-06 19:37:49 +00:00
|
|
|
#ifndef phton24
|
|
|
|
#define phton24(p, v) \
|
|
|
|
{ \
|
|
|
|
(p)[0] = (guint8)((v) >> 16); \
|
|
|
|
(p)[1] = (guint8)((v) >> 8); \
|
|
|
|
(p)[2] = (guint8)((v) >> 0); \
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-05-28 06:47:50 +00:00
|
|
|
#ifndef phtonl
|
|
|
|
#define phtonl(p, v) \
|
|
|
|
{ \
|
2007-05-28 08:31:18 +00:00
|
|
|
(p)[0] = (guint8)((v) >> 24); \
|
|
|
|
(p)[1] = (guint8)((v) >> 16); \
|
|
|
|
(p)[2] = (guint8)((v) >> 8); \
|
|
|
|
(p)[3] = (guint8)((v) >> 0); \
|
2007-05-28 06:47:50 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-10-08 11:41:21 +00:00
|
|
|
#ifndef phtonll
|
|
|
|
#define phtonll(p, v) \
|
|
|
|
{ \
|
|
|
|
(p)[0] = (guint8)((v) >> 56); \
|
|
|
|
(p)[1] = (guint8)((v) >> 48); \
|
|
|
|
(p)[2] = (guint8)((v) >> 40); \
|
|
|
|
(p)[3] = (guint8)((v) >> 32); \
|
|
|
|
(p)[4] = (guint8)((v) >> 24); \
|
|
|
|
(p)[5] = (guint8)((v) >> 16); \
|
|
|
|
(p)[6] = (guint8)((v) >> 8); \
|
|
|
|
(p)[7] = (guint8)((v) >> 0); \
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef pletonll
|
|
|
|
#define pletonll(p, v) \
|
|
|
|
{ \
|
|
|
|
(p)[0] = (guint8)((v) >> 0); \
|
|
|
|
(p)[1] = (guint8)((v) >> 8); \
|
|
|
|
(p)[2] = (guint8)((v) >> 16); \
|
|
|
|
(p)[3] = (guint8)((v) >> 24); \
|
|
|
|
(p)[4] = (guint8)((v) >> 32); \
|
|
|
|
(p)[5] = (guint8)((v) >> 40); \
|
|
|
|
(p)[6] = (guint8)((v) >> 48); \
|
|
|
|
(p)[7] = (guint8)((v) >> 56); \
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-09-19 17:22:11 +00:00
|
|
|
#define wtap_file_read_unknown_bytes(target, num_bytes, fh, err) \
|
|
|
|
G_STMT_START \
|
|
|
|
{ \
|
|
|
|
int _bytes_read; \
|
|
|
|
_bytes_read = file_read((target), 1, (num_bytes), (fh)); \
|
2004-01-05 17:33:28 +00:00
|
|
|
if (_bytes_read != (int) (num_bytes)) { \
|
2000-09-19 17:22:11 +00:00
|
|
|
*(err) = file_error((fh)); \
|
|
|
|
return FALSE; \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
G_STMT_END
|
|
|
|
|
|
|
|
#define wtap_file_read_expected_bytes(target, num_bytes, fh, err) \
|
|
|
|
G_STMT_START \
|
|
|
|
{ \
|
|
|
|
int _bytes_read; \
|
|
|
|
_bytes_read = file_read((target), 1, (num_bytes), (fh)); \
|
2004-01-05 17:33:28 +00:00
|
|
|
if (_bytes_read != (int) (num_bytes)) { \
|
2000-09-19 17:22:11 +00:00
|
|
|
*(err) = file_error((fh)); \
|
|
|
|
if (*(err) == 0 && _bytes_read > 0) { \
|
|
|
|
*(err) = WTAP_ERR_SHORT_READ; \
|
|
|
|
} \
|
|
|
|
return FALSE; \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
G_STMT_END
|
|
|
|
|
2001-12-13 05:49:13 +00:00
|
|
|
/* glib doesn't have g_ptr_array_len of all things!*/
|
|
|
|
#ifndef g_ptr_array_len
|
|
|
|
#define g_ptr_array_len(a) ((a)->len)
|
|
|
|
#endif
|
|
|
|
|
2000-05-19 23:07:04 +00:00
|
|
|
#endif /* __WTAP_INT_H__ */
|
2011-03-24 22:47:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Editor modelines
|
|
|
|
*
|
|
|
|
* Local Variables:
|
|
|
|
* c-basic-offset: 8
|
|
|
|
* tab-width: 8
|
|
|
|
* indent-tabs-mode: t
|
|
|
|
* End:
|
|
|
|
*
|
|
|
|
* ex: set shiftwidth=8 tabstop=8 noexpandtab
|
|
|
|
* :indentSize=8:tabSize=8:noTabs=false:
|
|
|
|
*/
|