2004-02-11 20:05:16 +00:00
|
|
|
/* eyesdn.c
|
|
|
|
*
|
|
|
|
* Wiretap Library
|
|
|
|
* Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
2012-06-28 22:56:06 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2004-02-11 20:05:16 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "wtap-int.h"
|
|
|
|
#include "buffer.h"
|
|
|
|
#include "eyesdn.h"
|
|
|
|
#include "file_wrappers.h"
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
|
|
|
/* This module reads the output of the EyeSDN USB S0/E1 ISDN probes
|
|
|
|
* They store HDLC frames of D and B channels in a binary format
|
|
|
|
* The fileformat is
|
2013-11-08 17:17:57 +00:00
|
|
|
*
|
2004-02-11 20:05:16 +00:00
|
|
|
* 1-6 Byte: EyeSDN - Magic
|
|
|
|
* 7-n Byte: Frames
|
2013-11-08 17:17:57 +00:00
|
|
|
*
|
2004-02-11 20:05:16 +00:00
|
|
|
* Each Frame starts with the 0xff Flag byte
|
2009-04-22 03:07:37 +00:00
|
|
|
* - Bytes 0-2: timestamp (usec in network byte order)
|
2004-02-11 20:05:16 +00:00
|
|
|
* - Bytes 3-7: timestamp (40bits sec since 1970 in network byte order)
|
2008-04-20 11:53:31 +00:00
|
|
|
* - Byte 8: channel (0 for D channel, 1-30 for B1-B30)
|
|
|
|
* - Byte 9: Sender Bit 0(0 NT, 1 TE), Protocol in Bits 7:1, see enum
|
2004-02-11 20:05:16 +00:00
|
|
|
* - Byte 10-11: frame size in bytes
|
|
|
|
* - Byte 12-n: Frame Payload
|
2013-11-08 17:17:57 +00:00
|
|
|
*
|
2004-02-11 20:05:16 +00:00
|
|
|
* All multibyte values are represented in network byte order
|
|
|
|
* The frame is terminated with a flag character (0xff)
|
|
|
|
* bytes 0xff within a frame are escaped using the 0xfe escape character
|
|
|
|
* the byte following the escape character is decremented by two:
|
|
|
|
* so 0xfe 0xfd is actually a 0xff
|
|
|
|
* Characters that need to be escaped are 0xff and 0xfe
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2010-06-06 19:37:49 +00:00
|
|
|
static int esc_read(guint8 *buf, int len, FILE_T fh)
|
2004-02-11 20:05:16 +00:00
|
|
|
{
|
2010-06-06 19:37:49 +00:00
|
|
|
int i;
|
|
|
|
int value;
|
|
|
|
|
|
|
|
for(i=0; i<len; i++) {
|
|
|
|
value=file_getc(fh);
|
|
|
|
if(value==-1)
|
|
|
|
return -2; /* EOF or error */
|
|
|
|
if(value==0xff)
|
|
|
|
return -1; /* error !!, read into next frame */
|
|
|
|
if(value==0xfe) {
|
|
|
|
/* we need to escape */
|
|
|
|
value=file_getc(fh);
|
|
|
|
if(value==-1)
|
|
|
|
return -2;
|
|
|
|
value+=2;
|
|
|
|
}
|
|
|
|
buf[i]=value;
|
2004-02-11 20:05:16 +00:00
|
|
|
}
|
2010-06-06 19:37:49 +00:00
|
|
|
|
|
|
|
return i;
|
2004-02-11 20:05:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Magic text to check for eyesdn-ness of file */
|
|
|
|
static const unsigned char eyesdn_hdr_magic[] =
|
|
|
|
{ 'E', 'y', 'e', 'S', 'D', 'N'};
|
|
|
|
#define EYESDN_HDR_MAGIC_SIZE (sizeof(eyesdn_hdr_magic) / sizeof(eyesdn_hdr_magic[0]))
|
|
|
|
|
2004-02-13 19:19:13 +00:00
|
|
|
/* Size of a record header */
|
2004-02-11 20:05:16 +00:00
|
|
|
#define EYESDN_HDR_LENGTH 12
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX - is this the biggest packet we can get?
|
|
|
|
*/
|
|
|
|
#define EYESDN_MAX_PACKET_LEN 16384
|
|
|
|
|
2014-05-23 10:50:02 +00:00
|
|
|
static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
|
2006-11-05 22:46:44 +00:00
|
|
|
gint64 *data_offset);
|
2014-05-23 10:50:02 +00:00
|
|
|
static gboolean eyesdn_seek_read(wtap *wth, gint64 seek_off,
|
2014-05-09 05:18:49 +00:00
|
|
|
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
|
2013-06-17 21:18:47 +00:00
|
|
|
static int read_eyesdn_rec(FILE_T fh, struct wtap_pkthdr *phdr, Buffer* buf,
|
2012-10-18 23:11:40 +00:00
|
|
|
int *err, gchar **err_info);
|
2004-02-11 20:05:16 +00:00
|
|
|
|
|
|
|
/* Seeks to the beginning of the next packet, and returns the
|
2011-04-21 09:41:52 +00:00
|
|
|
byte offset. Returns -1 on failure, and sets "*err" to the error
|
|
|
|
and "*err_info" to null or an additional error string. */
|
2014-05-09 05:18:49 +00:00
|
|
|
static gint64 eyesdn_seek_next_packet(wtap *wth, int *err, gchar **err_info)
|
2004-02-11 20:05:16 +00:00
|
|
|
{
|
2010-06-06 19:37:49 +00:00
|
|
|
int byte;
|
|
|
|
gint64 cur_off;
|
|
|
|
|
2014-05-09 05:18:49 +00:00
|
|
|
while ((byte = file_getc(wth->fh)) != EOF) {
|
2010-06-06 19:37:49 +00:00
|
|
|
if (byte == 0xff) {
|
2014-05-09 05:18:49 +00:00
|
|
|
cur_off = file_tell(wth->fh);
|
2010-06-06 19:37:49 +00:00
|
|
|
if (cur_off == -1) {
|
|
|
|
/* Error. */
|
2014-05-09 05:18:49 +00:00
|
|
|
*err = file_error(wth->fh, err_info);
|
2010-06-06 19:37:49 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return cur_off;
|
|
|
|
}
|
|
|
|
}
|
2012-12-27 22:59:39 +00:00
|
|
|
/* EOF or error. */
|
2014-05-09 05:18:49 +00:00
|
|
|
*err = file_error(wth->fh, err_info);
|
2010-06-06 19:37:49 +00:00
|
|
|
return -1;
|
2004-02-11 20:05:16 +00:00
|
|
|
}
|
|
|
|
|
2014-05-09 05:18:49 +00:00
|
|
|
int eyesdn_open(wtap *wth, int *err, gchar **err_info)
|
2004-02-11 20:05:16 +00:00
|
|
|
{
|
2004-03-23 00:17:50 +00:00
|
|
|
int bytes_read;
|
|
|
|
char magic[EYESDN_HDR_MAGIC_SIZE];
|
|
|
|
|
2004-02-11 20:05:16 +00:00
|
|
|
/* Look for eyesdn header */
|
2004-03-23 00:17:50 +00:00
|
|
|
errno = WTAP_ERR_CANT_READ;
|
2014-05-09 05:18:49 +00:00
|
|
|
bytes_read = file_read(&magic, sizeof magic, wth->fh);
|
2004-03-23 00:17:50 +00:00
|
|
|
if (bytes_read != sizeof magic) {
|
2014-05-09 05:18:49 +00:00
|
|
|
*err = file_error(wth->fh, err_info);
|
Do not call wtap_file_read_unknown_bytes() or
wtap_file_read_expected_bytes() from an open routine - open routines are
supposed to return -1 on error, 0 if the file doesn't appear to be a
file of the specified type, or 1 if the file does appear to be a file of
the specified type, but those macros will cause the caller to return
FALSE on errors (so that, even if there's an I/O error, it reports "the
file isn't a file of the specified type" rather than "we got an error
trying to read the file").
When doing reads in an open routine before we've concluded that the file
is probably of the right type, return 0, rather than -1, if we get
WTAP_ERR_SHORT_READ - if we don't have enough data to check whether a
file is of a given type, we should keep trying other types, not give up.
For reads done *after* we've concluded the file is probably of the right
type, if a read doesn't return the number of bytes we asked for, but
returns an error of 0, return WTAP_ERR_SHORT_READ - the file is
apparently cut short.
For NetMon and NetXRay/Windows Sniffer files, use a #define for the
magic number size, and use that for both magic numbers.
svn path=/trunk/; revision=46803
2012-12-27 12:19:25 +00:00
|
|
|
if (*err != 0 && *err != WTAP_ERR_SHORT_READ)
|
2004-02-11 20:05:16 +00:00
|
|
|
return -1;
|
2004-03-23 00:17:50 +00:00
|
|
|
return 0;
|
2004-02-11 20:05:16 +00:00
|
|
|
}
|
2004-03-23 00:17:50 +00:00
|
|
|
if (memcmp(magic, eyesdn_hdr_magic, EYESDN_HDR_MAGIC_SIZE) != 0)
|
|
|
|
return 0;
|
2004-02-11 20:05:16 +00:00
|
|
|
|
2014-05-09 05:18:49 +00:00
|
|
|
wth->file_encap = WTAP_ENCAP_PER_PACKET;
|
|
|
|
wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_EYESDN;
|
|
|
|
wth->snapshot_length = 0; /* not known */
|
|
|
|
wth->subtype_read = eyesdn_read;
|
|
|
|
wth->subtype_seek_read = eyesdn_seek_read;
|
|
|
|
wth->tsprecision = WTAP_FILE_TSPREC_USEC;
|
2004-02-11 20:05:16 +00:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-04-03 11:00:49 +00:00
|
|
|
/* Find the next packet and parse it; called from wtap_read(). */
|
2014-05-23 10:50:02 +00:00
|
|
|
static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
|
2006-11-05 22:46:44 +00:00
|
|
|
gint64 *data_offset)
|
2004-02-11 20:05:16 +00:00
|
|
|
{
|
2006-11-05 22:46:44 +00:00
|
|
|
gint64 offset;
|
2004-02-11 20:05:16 +00:00
|
|
|
|
2013-06-17 21:18:47 +00:00
|
|
|
/* Find the next record */
|
2014-05-09 05:18:49 +00:00
|
|
|
offset = eyesdn_seek_next_packet(wth, err, err_info);
|
2004-02-11 20:05:16 +00:00
|
|
|
if (offset < 1)
|
2014-05-23 10:50:02 +00:00
|
|
|
return FALSE;
|
2004-02-11 20:05:16 +00:00
|
|
|
*data_offset = offset;
|
2013-06-17 21:18:47 +00:00
|
|
|
|
|
|
|
/* Parse the record */
|
2014-05-09 05:18:49 +00:00
|
|
|
return read_eyesdn_rec(wth->fh, &wth->phdr, wth->frame_buffer,
|
2013-06-17 21:18:47 +00:00
|
|
|
err, err_info);
|
2004-02-11 20:05:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Used to read packets in random-access fashion */
|
2014-05-23 10:50:02 +00:00
|
|
|
static gboolean
|
2014-05-09 05:18:49 +00:00
|
|
|
eyesdn_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
|
2014-01-02 20:47:21 +00:00
|
|
|
Buffer *buf, int *err, gchar **err_info)
|
2004-02-11 20:05:16 +00:00
|
|
|
{
|
2014-05-09 05:18:49 +00:00
|
|
|
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
|
2014-05-23 10:50:02 +00:00
|
|
|
return FALSE;
|
2004-02-11 20:05:16 +00:00
|
|
|
|
2014-05-09 05:18:49 +00:00
|
|
|
return read_eyesdn_rec(wth->random_fh, phdr, buf, err, err_info);
|
2004-02-11 20:05:16 +00:00
|
|
|
}
|
|
|
|
|
2013-06-17 21:18:47 +00:00
|
|
|
/* Parses a record. */
|
2014-05-23 10:50:02 +00:00
|
|
|
static gboolean
|
2013-06-17 21:18:47 +00:00
|
|
|
read_eyesdn_rec(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, int *err,
|
|
|
|
gchar **err_info)
|
2004-02-11 20:05:16 +00:00
|
|
|
{
|
2012-10-17 20:28:22 +00:00
|
|
|
union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
|
2004-02-12 21:25:07 +00:00
|
|
|
guint8 hdr[EYESDN_HDR_LENGTH];
|
2009-04-22 03:07:37 +00:00
|
|
|
time_t secs;
|
|
|
|
int usecs;
|
2004-02-12 21:25:07 +00:00
|
|
|
int pkt_len;
|
2006-09-29 08:47:51 +00:00
|
|
|
guint8 channel, direction;
|
2014-05-09 05:18:49 +00:00
|
|
|
int bytes_read;
|
|
|
|
guint8 *pd;
|
2004-02-11 20:05:16 +00:00
|
|
|
|
2004-02-12 21:25:07 +00:00
|
|
|
/* Our file pointer should be at the summary information header
|
|
|
|
* for a packet. Read in that header and extract the useful
|
|
|
|
* information.
|
2004-02-11 20:05:16 +00:00
|
|
|
*/
|
2010-06-06 19:37:49 +00:00
|
|
|
if (esc_read(hdr, EYESDN_HDR_LENGTH, fh) != EYESDN_HDR_LENGTH) {
|
2011-04-21 09:41:52 +00:00
|
|
|
*err = file_error(fh, err_info);
|
2004-02-12 21:25:07 +00:00
|
|
|
if (*err == 0)
|
2004-02-11 20:05:16 +00:00
|
|
|
*err = WTAP_ERR_SHORT_READ;
|
2014-05-23 10:50:02 +00:00
|
|
|
return FALSE;
|
2004-02-11 20:05:16 +00:00
|
|
|
}
|
2013-11-08 17:17:57 +00:00
|
|
|
|
2004-02-11 20:05:16 +00:00
|
|
|
/* extract information from header */
|
2009-04-22 03:07:37 +00:00
|
|
|
usecs = pntoh24(&hdr[0]);
|
2013-11-08 17:17:57 +00:00
|
|
|
#ifdef TV64BITS
|
2009-04-22 03:07:37 +00:00
|
|
|
secs = hdr[3];
|
2013-11-08 17:17:57 +00:00
|
|
|
#else
|
2004-02-11 20:05:16 +00:00
|
|
|
secs = 0;
|
2013-11-08 17:17:57 +00:00
|
|
|
#endif
|
2009-04-22 03:07:37 +00:00
|
|
|
secs = (secs << 8) | hdr[4];
|
|
|
|
secs = (secs << 8) | hdr[5];
|
|
|
|
secs = (secs << 8) | hdr[6];
|
|
|
|
secs = (secs << 8) | hdr[7];
|
2004-02-11 20:05:16 +00:00
|
|
|
|
2004-02-12 21:25:07 +00:00
|
|
|
channel = hdr[8];
|
|
|
|
direction = hdr[9];
|
2013-12-03 20:35:50 +00:00
|
|
|
pkt_len = pntoh16(&hdr[10]);
|
2004-02-11 20:05:16 +00:00
|
|
|
|
2008-04-20 11:53:31 +00:00
|
|
|
switch(direction >> 1) {
|
2010-06-06 19:37:49 +00:00
|
|
|
|
2008-04-20 11:53:31 +00:00
|
|
|
default:
|
2008-05-07 05:26:40 +00:00
|
|
|
case EYESDN_ENCAP_ISDN: /* ISDN */
|
2010-06-06 19:37:49 +00:00
|
|
|
pseudo_header->isdn.uton = direction & 1;
|
|
|
|
pseudo_header->isdn.channel = channel;
|
|
|
|
if(channel) { /* bearer channels */
|
2012-10-18 23:11:40 +00:00
|
|
|
phdr->pkt_encap = WTAP_ENCAP_ISDN; /* recognises PPP */
|
|
|
|
pseudo_header->isdn.uton=!pseudo_header->isdn.uton; /* bug */
|
2010-06-06 19:37:49 +00:00
|
|
|
} else { /* D channel */
|
2012-10-17 20:28:22 +00:00
|
|
|
phdr->pkt_encap = WTAP_ENCAP_ISDN;
|
2008-04-20 11:53:31 +00:00
|
|
|
}
|
2010-06-06 19:37:49 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case EYESDN_ENCAP_MSG: /* Layer 1 message */
|
2012-10-17 20:28:22 +00:00
|
|
|
phdr->pkt_encap = WTAP_ENCAP_LAYER1_EVENT;
|
2010-06-06 19:37:49 +00:00
|
|
|
pseudo_header->l1event.uton = (direction & 1);
|
|
|
|
break;
|
|
|
|
|
2013-11-08 17:17:57 +00:00
|
|
|
case EYESDN_ENCAP_LAPB: /* X.25 via LAPB */
|
2012-10-17 20:28:22 +00:00
|
|
|
phdr->pkt_encap = WTAP_ENCAP_LAPB;
|
2010-06-06 19:37:49 +00:00
|
|
|
pseudo_header->x25.flags = (direction & 1) ? 0 : 0x80;
|
|
|
|
break;
|
|
|
|
|
2008-05-07 05:26:40 +00:00
|
|
|
case EYESDN_ENCAP_ATM: { /* ATM cells */
|
2008-04-20 11:53:31 +00:00
|
|
|
#define CELL_LEN 53
|
2010-06-06 19:37:49 +00:00
|
|
|
unsigned char cell[CELL_LEN];
|
|
|
|
gint64 cur_off;
|
|
|
|
|
|
|
|
if(pkt_len != CELL_LEN) {
|
2011-12-13 09:53:50 +00:00
|
|
|
*err = WTAP_ERR_BAD_FILE;
|
2010-06-06 19:37:49 +00:00
|
|
|
*err_info = g_strdup_printf(
|
|
|
|
"eyesdn: ATM cell has a length != 53 (%u)",
|
|
|
|
pkt_len);
|
2014-05-23 10:50:02 +00:00
|
|
|
return FALSE;
|
2010-06-06 19:37:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
cur_off = file_tell(fh);
|
|
|
|
if (esc_read(cell, CELL_LEN, fh) != CELL_LEN) {
|
2011-04-21 09:41:52 +00:00
|
|
|
*err = file_error(fh, err_info);
|
2010-06-06 19:37:49 +00:00
|
|
|
if (*err == 0)
|
|
|
|
*err = WTAP_ERR_SHORT_READ;
|
2014-05-23 10:50:02 +00:00
|
|
|
return FALSE;
|
2010-06-06 19:37:49 +00:00
|
|
|
}
|
|
|
|
if (file_seek(fh, cur_off, SEEK_SET, err) == -1)
|
2014-05-23 10:50:02 +00:00
|
|
|
return FALSE;
|
2012-10-17 20:28:22 +00:00
|
|
|
phdr->pkt_encap = WTAP_ENCAP_ATM_PDUS_UNTRUNCATED;
|
2010-06-06 19:37:49 +00:00
|
|
|
pseudo_header->atm.flags=ATM_RAW_CELL;
|
|
|
|
pseudo_header->atm.aal=AAL_UNKNOWN;
|
|
|
|
pseudo_header->atm.type=TRAF_UMTS_FP;
|
|
|
|
pseudo_header->atm.subtype=TRAF_ST_UNKNOWN;
|
|
|
|
pseudo_header->atm.vpi=((cell[0]&0xf)<<4) + (cell[0]&0xf);
|
|
|
|
pseudo_header->atm.vci=((cell[0]&0xf)<<4) + cell[0]; /* from cell */
|
|
|
|
pseudo_header->atm.channel=direction & 1;
|
|
|
|
}
|
|
|
|
break;
|
2004-02-11 20:05:16 +00:00
|
|
|
|
2008-05-07 05:26:40 +00:00
|
|
|
case EYESDN_ENCAP_MTP2: /* SS7 frames */
|
2010-06-06 19:37:49 +00:00
|
|
|
pseudo_header->mtp2.sent = direction & 1;
|
|
|
|
pseudo_header->mtp2.annex_a_used = MTP2_ANNEX_A_USED_UNKNOWN;
|
2013-11-08 17:17:57 +00:00
|
|
|
pseudo_header->mtp2.link_number = channel;
|
2012-10-17 20:28:22 +00:00
|
|
|
phdr->pkt_encap = WTAP_ENCAP_MTP2_WITH_PHDR;
|
2010-06-06 19:37:49 +00:00
|
|
|
break;
|
|
|
|
|
2009-01-27 21:13:26 +00:00
|
|
|
case EYESDN_ENCAP_DPNSS: /* DPNSS */
|
2010-06-06 19:37:49 +00:00
|
|
|
pseudo_header->isdn.uton = direction & 1;
|
|
|
|
pseudo_header->isdn.channel = channel;
|
2012-10-17 20:28:22 +00:00
|
|
|
phdr->pkt_encap = WTAP_ENCAP_DPNSS;
|
2010-06-06 19:37:49 +00:00
|
|
|
break;
|
|
|
|
|
2009-01-27 21:13:26 +00:00
|
|
|
case EYESDN_ENCAP_DASS2: /* DASS2 frames */
|
2010-06-06 19:37:49 +00:00
|
|
|
pseudo_header->isdn.uton = direction & 1;
|
|
|
|
pseudo_header->isdn.channel = channel;
|
2012-10-17 20:28:22 +00:00
|
|
|
phdr->pkt_encap = WTAP_ENCAP_DPNSS;
|
2010-06-06 19:37:49 +00:00
|
|
|
break;
|
|
|
|
|
2009-01-27 21:13:26 +00:00
|
|
|
case EYESDN_ENCAP_BACNET: /* BACNET async over HDLC frames */
|
2012-04-04 07:33:39 +00:00
|
|
|
pseudo_header->isdn.uton = direction & 1;
|
|
|
|
pseudo_header->isdn.channel = channel;
|
2012-10-17 20:28:22 +00:00
|
|
|
phdr->pkt_encap = WTAP_ENCAP_BACNET_MS_TP_WITH_PHDR;
|
2010-06-06 19:37:49 +00:00
|
|
|
break;
|
2012-04-04 07:33:39 +00:00
|
|
|
|
|
|
|
case EYESDN_ENCAP_V5_EF: /* V5EF */
|
|
|
|
pseudo_header->isdn.uton = direction & 1;
|
|
|
|
pseudo_header->isdn.channel = channel;
|
2012-10-17 20:28:22 +00:00
|
|
|
phdr->pkt_encap = WTAP_ENCAP_V5_EF;
|
2012-04-04 07:33:39 +00:00
|
|
|
break;
|
2010-06-06 19:37:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(pkt_len > EYESDN_MAX_PACKET_LEN) {
|
2011-12-13 09:53:50 +00:00
|
|
|
*err = WTAP_ERR_BAD_FILE;
|
2010-06-06 19:37:49 +00:00
|
|
|
*err_info = g_strdup_printf("eyesdn: File has %u-byte packet, bigger than maximum of %u",
|
2012-10-18 23:11:40 +00:00
|
|
|
pkt_len, EYESDN_MAX_PACKET_LEN);
|
2014-05-23 10:50:02 +00:00
|
|
|
return FALSE;
|
2004-02-11 20:05:16 +00:00
|
|
|
}
|
|
|
|
|
2014-05-24 18:28:30 +00:00
|
|
|
phdr->rec_type = REC_TYPE_PACKET;
|
2012-10-18 23:11:40 +00:00
|
|
|
phdr->presence_flags = WTAP_HAS_TS;
|
|
|
|
phdr->ts.secs = secs;
|
|
|
|
phdr->ts.nsecs = usecs * 1000;
|
|
|
|
phdr->caplen = pkt_len;
|
|
|
|
phdr->len = pkt_len;
|
2004-02-11 20:05:16 +00:00
|
|
|
|
2013-06-16 00:20:00 +00:00
|
|
|
/* Make sure we have enough room for the packet */
|
|
|
|
buffer_assure_space(buf, EYESDN_MAX_PACKET_LEN);
|
2004-02-11 20:05:16 +00:00
|
|
|
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
2013-06-16 00:20:00 +00:00
|
|
|
pd = buffer_start_ptr(buf);
|
|
|
|
bytes_read = esc_read(pd, pkt_len, fh);
|
2004-02-11 20:05:16 +00:00
|
|
|
if (bytes_read != pkt_len) {
|
2010-06-06 19:37:49 +00:00
|
|
|
if (bytes_read == -2) {
|
2011-04-21 09:41:52 +00:00
|
|
|
*err = file_error(fh, err_info);
|
2010-06-06 19:37:49 +00:00
|
|
|
if (*err == 0)
|
|
|
|
*err = WTAP_ERR_SHORT_READ;
|
|
|
|
} else if (bytes_read == -1) {
|
2011-12-13 09:53:50 +00:00
|
|
|
*err = WTAP_ERR_BAD_FILE;
|
2010-06-06 19:37:49 +00:00
|
|
|
*err_info = g_strdup("eyesdn: No flag character seen in frame");
|
|
|
|
} else
|
|
|
|
*err = WTAP_ERR_SHORT_READ;
|
2014-05-23 10:50:02 +00:00
|
|
|
return FALSE;
|
2004-02-11 20:05:16 +00:00
|
|
|
}
|
2014-05-23 10:50:02 +00:00
|
|
|
return TRUE;
|
2004-02-11 20:05:16 +00:00
|
|
|
}
|
2010-06-05 22:59:20 +00:00
|
|
|
|
|
|
|
|
2010-06-06 19:37:49 +00:00
|
|
|
static gboolean
|
2014-05-09 05:18:49 +00:00
|
|
|
esc_write(wtap_dumper *wdh, const guint8 *buf, int len, int *err)
|
2010-06-05 22:59:20 +00:00
|
|
|
{
|
2010-06-06 19:37:49 +00:00
|
|
|
int i;
|
|
|
|
guint8 byte;
|
|
|
|
static const guint8 esc = 0xfe;
|
2013-11-08 17:17:57 +00:00
|
|
|
|
2010-06-06 19:37:49 +00:00
|
|
|
for(i=0; i<len; i++) {
|
|
|
|
byte=buf[i];
|
|
|
|
if(byte == 0xff || byte == 0xfe) {
|
|
|
|
/*
|
|
|
|
* Escape the frame delimiter and escape byte.
|
|
|
|
*/
|
2014-05-09 05:18:49 +00:00
|
|
|
if (!wtap_dump_file_write(wdh, &esc, sizeof esc, err))
|
2010-06-06 19:37:49 +00:00
|
|
|
return FALSE;
|
|
|
|
byte-=2;
|
|
|
|
}
|
2014-05-09 05:18:49 +00:00
|
|
|
if (!wtap_dump_file_write(wdh, &byte, sizeof byte, err))
|
2010-06-06 19:37:49 +00:00
|
|
|
return FALSE;
|
2010-06-05 22:59:20 +00:00
|
|
|
}
|
2010-06-06 19:37:49 +00:00
|
|
|
return TRUE;
|
2010-06-05 22:59:20 +00:00
|
|
|
}
|
|
|
|
|
2014-05-09 05:18:49 +00:00
|
|
|
static gboolean eyesdn_dump(wtap_dumper *wdh,
|
2010-06-05 22:59:20 +00:00
|
|
|
const struct wtap_pkthdr *phdr,
|
2011-09-01 09:43:10 +00:00
|
|
|
const guint8 *pd, int *err);
|
2010-06-05 22:59:20 +00:00
|
|
|
|
2014-05-09 05:18:49 +00:00
|
|
|
gboolean eyesdn_dump_open(wtap_dumper *wdh, int *err)
|
2010-06-05 22:59:20 +00:00
|
|
|
{
|
2010-06-06 19:37:49 +00:00
|
|
|
wdh->subtype_write=eyesdn_dump;
|
|
|
|
wdh->subtype_close=NULL;
|
2010-06-05 22:59:20 +00:00
|
|
|
|
2014-05-09 05:18:49 +00:00
|
|
|
if (!wtap_dump_file_write(wdh, eyesdn_hdr_magic,
|
2010-06-06 19:37:49 +00:00
|
|
|
EYESDN_HDR_MAGIC_SIZE, err))
|
|
|
|
return FALSE;
|
|
|
|
wdh->bytes_dumped += EYESDN_HDR_MAGIC_SIZE;
|
|
|
|
*err=0;
|
|
|
|
return TRUE;
|
2010-06-05 22:59:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int eyesdn_dump_can_write_encap(int encap)
|
|
|
|
{
|
2010-06-06 19:37:49 +00:00
|
|
|
switch (encap) {
|
|
|
|
case WTAP_ENCAP_ISDN:
|
|
|
|
case WTAP_ENCAP_LAYER1_EVENT:
|
|
|
|
case WTAP_ENCAP_DPNSS:
|
|
|
|
case WTAP_ENCAP_ATM_PDUS_UNTRUNCATED:
|
|
|
|
case WTAP_ENCAP_LAPB:
|
2012-04-05 20:25:26 +00:00
|
|
|
case WTAP_ENCAP_MTP2_WITH_PHDR:
|
2012-04-06 03:42:32 +00:00
|
|
|
case WTAP_ENCAP_BACNET_MS_TP_WITH_PHDR:
|
2010-06-06 19:37:49 +00:00
|
|
|
case WTAP_ENCAP_PER_PACKET:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return WTAP_ERR_UNSUPPORTED_ENCAP;
|
|
|
|
}
|
2010-06-05 22:59:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Write a record for a packet to a dump file.
|
|
|
|
* Returns TRUE on success, FALSE on failure. */
|
2014-05-09 05:18:49 +00:00
|
|
|
static gboolean eyesdn_dump(wtap_dumper *wdh,
|
2010-06-05 22:59:20 +00:00
|
|
|
const struct wtap_pkthdr *phdr,
|
2011-09-01 09:43:10 +00:00
|
|
|
const guint8 *pd, int *err)
|
2010-06-05 22:59:20 +00:00
|
|
|
{
|
2010-06-06 19:37:49 +00:00
|
|
|
static const guint8 start_flag = 0xff;
|
2012-10-16 21:50:57 +00:00
|
|
|
const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
|
2010-06-06 19:37:49 +00:00
|
|
|
guint8 buf[EYESDN_HDR_LENGTH];
|
|
|
|
int usecs;
|
|
|
|
time_t secs;
|
|
|
|
int channel;
|
|
|
|
int origin;
|
|
|
|
int protocol;
|
|
|
|
int size;
|
|
|
|
|
2014-05-24 18:28:30 +00:00
|
|
|
/* We can only write packet records. */
|
|
|
|
if (phdr->rec_type != REC_TYPE_PACKET) {
|
|
|
|
*err = WTAP_ERR_REC_TYPE_UNSUPPORTED;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2014-01-22 00:26:36 +00:00
|
|
|
/* Don't write out anything bigger than we can read.
|
|
|
|
* (The length field in packet headers is 16 bits, which
|
|
|
|
* imposes a hard limit.) */
|
|
|
|
if (phdr->caplen > 65535) {
|
|
|
|
*err = WTAP_ERR_PACKET_TOO_LARGE;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2010-06-06 19:37:49 +00:00
|
|
|
usecs=phdr->ts.nsecs/1000;
|
|
|
|
secs=phdr->ts.secs;
|
|
|
|
size=phdr->caplen;
|
|
|
|
origin = pseudo_header->isdn.uton;
|
|
|
|
channel = pseudo_header->isdn.channel;
|
|
|
|
|
|
|
|
switch(phdr->pkt_encap) {
|
|
|
|
|
|
|
|
case WTAP_ENCAP_ISDN:
|
|
|
|
protocol=EYESDN_ENCAP_ISDN; /* set depending on decoder format and mode */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ENCAP_LAYER1_EVENT:
|
|
|
|
protocol=EYESDN_ENCAP_MSG;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ENCAP_DPNSS:
|
|
|
|
protocol=EYESDN_ENCAP_DPNSS;
|
|
|
|
break;
|
|
|
|
|
2010-06-05 22:59:20 +00:00
|
|
|
#if 0
|
2010-06-06 19:37:49 +00:00
|
|
|
case WTAP_ENCAP_DASS2:
|
|
|
|
protocol=EYESDN_ENCAP_DASS2;
|
|
|
|
break;
|
2010-06-05 22:59:20 +00:00
|
|
|
#endif
|
2010-06-06 19:37:49 +00:00
|
|
|
|
|
|
|
case WTAP_ENCAP_ATM_PDUS_UNTRUNCATED:
|
|
|
|
protocol=EYESDN_ENCAP_ATM;
|
|
|
|
channel=0x80;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ENCAP_LAPB:
|
|
|
|
protocol=EYESDN_ENCAP_LAPB;
|
|
|
|
break;
|
|
|
|
|
2012-04-05 20:25:26 +00:00
|
|
|
case WTAP_ENCAP_MTP2_WITH_PHDR:
|
2010-06-06 19:37:49 +00:00
|
|
|
protocol=EYESDN_ENCAP_MTP2;
|
|
|
|
break;
|
|
|
|
|
2012-04-06 03:42:32 +00:00
|
|
|
case WTAP_ENCAP_BACNET_MS_TP_WITH_PHDR:
|
2010-06-06 19:37:49 +00:00
|
|
|
protocol=EYESDN_ENCAP_BACNET;
|
|
|
|
break;
|
2013-11-08 17:17:57 +00:00
|
|
|
|
2012-04-04 07:33:39 +00:00
|
|
|
case WTAP_ENCAP_V5_EF:
|
|
|
|
protocol=EYESDN_ENCAP_V5_EF;
|
|
|
|
break;
|
2010-06-06 19:37:49 +00:00
|
|
|
|
|
|
|
default:
|
|
|
|
*err=WTAP_ERR_UNSUPPORTED_ENCAP;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
phton24(&buf[0], usecs);
|
|
|
|
|
|
|
|
buf[3] = (guint8)0;
|
|
|
|
buf[4] = (guint8)(0xff & (secs >> 24));
|
|
|
|
buf[5] = (guint8)(0xff & (secs >> 16));
|
|
|
|
buf[6] = (guint8)(0xff & (secs >> 8));
|
|
|
|
buf[7] = (guint8)(0xff & (secs >> 0));
|
|
|
|
|
|
|
|
buf[8] = (guint8) channel;
|
|
|
|
buf[9] = (guint8) (origin?1:0) + (protocol << 1);
|
|
|
|
phtons(&buf[10], size);
|
2013-11-08 17:17:57 +00:00
|
|
|
|
2010-06-06 19:37:49 +00:00
|
|
|
/* start flag */
|
2014-05-09 05:18:49 +00:00
|
|
|
if (!wtap_dump_file_write(wdh, &start_flag, sizeof start_flag, err))
|
2010-06-06 19:37:49 +00:00
|
|
|
return FALSE;
|
|
|
|
if (!esc_write(wdh, buf, 12, err))
|
|
|
|
return FALSE;
|
|
|
|
if (!esc_write(wdh, pd, size, err))
|
|
|
|
return FALSE;
|
|
|
|
return TRUE;
|
2010-06-05 22:59:20 +00:00
|
|
|
}
|