6 * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
29 #include "file_wrappers.h"
36 /* This module reads the output of the EyeSDN USB S0/E1 ISDN probes
37 * They store HDLC frames of D and B channels in a binary format
40 * 1-6 Byte: EyeSDN - Magic
43 * Each Frame starts with the 0xff Flag byte
44 * - Bytes 0-2: timestamp (usec in network byte order)
45 * - Bytes 3-7: timestamp (40bits sec since 1970 in network byte order)
46 * - Byte 8: channel (0 for D channel, 1-30 for B1-B30)
47 * - Byte 9: Sender Bit 0(0 NT, 1 TE), Protocol in Bits 7:1, see enum
48 * - Byte 10-11: frame size in bytes
49 * - Byte 12-n: Frame Payload
51 * All multibyte values are represented in network byte order
52 * The frame is terminated with a flag character (0xff)
53 * bytes 0xff within a frame are escaped using the 0xfe escape character
54 * the byte following the escape character is decremented by two:
55 * so 0xfe 0xfd is actually a 0xff
56 * Characters that need to be escaped are 0xff and 0xfe
60 static int esc_read(guint8 *buf, int len, FILE_T fh)
65 for(i=0; i<len; i++) {
68 return -2; /* EOF or error */
70 return -1; /* error !!, read into next frame */
72 /* we need to escape */
84 /* Magic text to check for eyesdn-ness of file */
85 static const unsigned char eyesdn_hdr_magic[] =
86 { 'E', 'y', 'e', 'S', 'D', 'N'};
87 #define EYESDN_HDR_MAGIC_SIZE (sizeof(eyesdn_hdr_magic) / sizeof(eyesdn_hdr_magic[0]))
89 /* Size of a record header */
90 #define EYESDN_HDR_LENGTH 12
93 * XXX - is this the biggest packet we can get?
95 #define EYESDN_MAX_PACKET_LEN 16384
97 static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
99 static gboolean eyesdn_seek_read(wtap *wth, gint64 seek_off,
100 union wtap_pseudo_header *pseudo_header, guint8 *pd, int len,
101 int *err, gchar **err_info);
102 static gboolean parse_eyesdn_packet_data(FILE_T fh, int pkt_len, guint8* buf,
103 int *err, gchar **err_info);
104 static int parse_eyesdn_rec_hdr(wtap *wth, FILE_T fh,
105 union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info);
107 /* Seeks to the beginning of the next packet, and returns the
108 byte offset. Returns -1 on failure, and sets "*err" to the error. */
109 static gint64 eyesdn_seek_next_packet(wtap *wth, int *err)
114 while ((byte = file_getc(wth->fh)) != EOF) {
116 cur_off = file_tell(wth->fh);
119 *err = file_error(wth->fh);
125 if (file_eof(wth->fh)) {
129 /* We (presumably) got an error (there's no equivalent to
130 "ferror()" in zlib, alas, so we don't have a wrapper to
131 check for an error). */
132 *err = file_error(wth->fh);
137 int eyesdn_open(wtap *wth, int *err, gchar **err_info _U_)
140 char magic[EYESDN_HDR_MAGIC_SIZE];
142 /* Look for eyesdn header */
143 errno = WTAP_ERR_CANT_READ;
144 bytes_read = file_read(&magic, sizeof magic, wth->fh);
145 if (bytes_read != sizeof magic) {
146 *err = file_error(wth->fh);
151 if (memcmp(magic, eyesdn_hdr_magic, EYESDN_HDR_MAGIC_SIZE) != 0)
154 wth->data_offset = 0;
155 wth->file_encap = WTAP_ENCAP_PER_PACKET;
156 wth->file_type = WTAP_FILE_EYESDN;
157 wth->snapshot_length = 0; /* not known */
158 wth->subtype_read = eyesdn_read;
159 wth->subtype_seek_read = eyesdn_seek_read;
160 wth->tsprecision = WTAP_FILE_TSPREC_USEC;
165 /* Find the next packet and parse it; called from wtap_read(). */
166 static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
173 /* Find the next packet */
174 offset = eyesdn_seek_next_packet(wth, err);
178 /* Parse the header */
179 pkt_len = parse_eyesdn_rec_hdr(wth, wth->fh, &wth->pseudo_header, err,
184 /* Make sure we have enough room for the packet */
185 buffer_assure_space(wth->frame_buffer, EYESDN_MAX_PACKET_LEN);
186 buf = buffer_start_ptr(wth->frame_buffer);
188 /* Read the packet data */
189 if (!parse_eyesdn_packet_data(wth->fh, pkt_len, buf, err, err_info))
192 wth->data_offset = offset;
193 *data_offset = offset;
197 /* Used to read packets in random-access fashion */
199 eyesdn_seek_read (wtap *wth, gint64 seek_off,
200 union wtap_pseudo_header *pseudo_header, guint8 *pd, int len,
201 int *err, gchar **err_info)
205 if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
208 pkt_len = parse_eyesdn_rec_hdr(NULL, wth->random_fh, pseudo_header,
211 if (pkt_len != len) {
213 *err = WTAP_ERR_BAD_RECORD;
214 *err_info = g_strdup_printf("eyesdn: requested length %d doesn't match length %d",
220 return parse_eyesdn_packet_data(wth->random_fh, pkt_len, pd, err,
224 /* Parses a packet record header. */
226 parse_eyesdn_rec_hdr(wtap *wth, FILE_T fh,
227 union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
229 guint8 hdr[EYESDN_HDR_LENGTH];
233 guint8 channel, direction;
235 /* Our file pointer should be at the summary information header
236 * for a packet. Read in that header and extract the useful
239 if (esc_read(hdr, EYESDN_HDR_LENGTH, fh) != EYESDN_HDR_LENGTH) {
240 *err = file_error(fh);
242 *err = WTAP_ERR_SHORT_READ;
246 /* extract information from header */
247 usecs = pntoh24(&hdr[0]);
253 secs = (secs << 8) | hdr[4];
254 secs = (secs << 8) | hdr[5];
255 secs = (secs << 8) | hdr[6];
256 secs = (secs << 8) | hdr[7];
260 pkt_len = pntohs(&hdr[10]);
262 switch(direction >> 1) {
265 case EYESDN_ENCAP_ISDN: /* ISDN */
266 pseudo_header->isdn.uton = direction & 1;
267 pseudo_header->isdn.channel = channel;
268 if(channel) { /* bearer channels */
270 wth->phdr.pkt_encap = WTAP_ENCAP_ISDN; /* recognises PPP */
271 pseudo_header->isdn.uton=!pseudo_header->isdn.uton; /* bug */
273 } else { /* D channel */
275 wth->phdr.pkt_encap = WTAP_ENCAP_ISDN;
280 case EYESDN_ENCAP_MSG: /* Layer 1 message */
282 wth->phdr.pkt_encap = WTAP_ENCAP_LAYER1_EVENT;
284 pseudo_header->l1event.uton = (direction & 1);
287 case EYESDN_ENCAP_LAPB: /* X.25 via LAPB */
289 wth->phdr.pkt_encap = WTAP_ENCAP_LAPB;
291 pseudo_header->x25.flags = (direction & 1) ? 0 : 0x80;
294 case EYESDN_ENCAP_ATM: { /* ATM cells */
296 unsigned char cell[CELL_LEN];
299 if(pkt_len != CELL_LEN) {
300 *err = WTAP_ERR_BAD_RECORD;
301 *err_info = g_strdup_printf(
302 "eyesdn: ATM cell has a length != 53 (%u)",
307 cur_off = file_tell(fh);
308 if (esc_read(cell, CELL_LEN, fh) != CELL_LEN) {
309 *err = file_error(fh);
311 *err = WTAP_ERR_SHORT_READ;
314 if (file_seek(fh, cur_off, SEEK_SET, err) == -1)
317 wth->phdr.pkt_encap = WTAP_ENCAP_ATM_PDUS_UNTRUNCATED;
319 pseudo_header->atm.flags=ATM_RAW_CELL;
320 pseudo_header->atm.aal=AAL_UNKNOWN;
321 pseudo_header->atm.type=TRAF_UMTS_FP;
322 pseudo_header->atm.subtype=TRAF_ST_UNKNOWN;
323 pseudo_header->atm.vpi=((cell[0]&0xf)<<4) + (cell[0]&0xf);
324 pseudo_header->atm.vci=((cell[0]&0xf)<<4) + cell[0]; /* from cell */
325 pseudo_header->atm.channel=direction & 1;
329 case EYESDN_ENCAP_MTP2: /* SS7 frames */
330 pseudo_header->mtp2.sent = direction & 1;
331 pseudo_header->mtp2.annex_a_used = MTP2_ANNEX_A_USED_UNKNOWN;
332 pseudo_header->mtp2.link_number = channel;
334 wth->phdr.pkt_encap = WTAP_ENCAP_MTP2;
338 case EYESDN_ENCAP_DPNSS: /* DPNSS */
339 pseudo_header->isdn.uton = direction & 1;
340 pseudo_header->isdn.channel = channel;
342 wth->phdr.pkt_encap = WTAP_ENCAP_DPNSS;
346 case EYESDN_ENCAP_DASS2: /* DASS2 frames */
347 pseudo_header->isdn.uton = direction & 1;
348 pseudo_header->isdn.channel = channel;
350 wth->phdr.pkt_encap = WTAP_ENCAP_DPNSS;
354 case EYESDN_ENCAP_BACNET: /* BACNET async over HDLC frames */
355 /* pseudo_header->isdn.uton = direction & 1; */
356 /* pseudo_header->isdn.channel = channel; */
358 wth->phdr.pkt_encap = WTAP_ENCAP_BACNET_MS_TP;
363 if(pkt_len > EYESDN_MAX_PACKET_LEN) {
364 *err = WTAP_ERR_BAD_RECORD;
365 *err_info = g_strdup_printf("eyesdn: File has %u-byte packet, bigger than maximum of %u",
366 pkt_len, EYESDN_MAX_PACKET_LEN);
371 wth->phdr.ts.secs = secs;
372 wth->phdr.ts.nsecs = usecs * 1000;
373 wth->phdr.caplen = pkt_len;
374 wth->phdr.len = pkt_len;
382 parse_eyesdn_packet_data(FILE_T fh, int pkt_len, guint8* buf, int *err,
387 errno = WTAP_ERR_CANT_READ;
388 bytes_read = esc_read(buf, pkt_len, fh);
389 if (bytes_read != pkt_len) {
390 if (bytes_read == -2) {
391 *err = file_error(fh);
393 *err = WTAP_ERR_SHORT_READ;
394 } else if (bytes_read == -1) {
395 *err = WTAP_ERR_BAD_RECORD;
396 *err_info = g_strdup("eyesdn: No flag character seen in frame");
398 *err = WTAP_ERR_SHORT_READ;
406 esc_write(wtap_dumper *wdh, const guint8 *buf, int len, int *err)
410 static const guint8 esc = 0xfe;
412 for(i=0; i<len; i++) {
414 if(byte == 0xff || byte == 0xfe) {
416 * Escape the frame delimiter and escape byte.
418 if (!wtap_dump_file_write(wdh, &esc, sizeof esc, err))
422 if (!wtap_dump_file_write(wdh, &byte, sizeof byte, err))
428 static gboolean eyesdn_dump(wtap_dumper *wdh,
429 const struct wtap_pkthdr *phdr,
430 const union wtap_pseudo_header *pseudo_header _U_,
431 const guchar *pd, int *err);
433 gboolean eyesdn_dump_open(wtap_dumper *wdh, gboolean cant_seek _U_, int *err)
435 wdh->subtype_write=eyesdn_dump;
436 wdh->subtype_close=NULL;
438 if (!wtap_dump_file_write(wdh, eyesdn_hdr_magic,
439 EYESDN_HDR_MAGIC_SIZE, err))
441 wdh->bytes_dumped += EYESDN_HDR_MAGIC_SIZE;
446 int eyesdn_dump_can_write_encap(int encap)
449 case WTAP_ENCAP_ISDN:
450 case WTAP_ENCAP_LAYER1_EVENT:
451 case WTAP_ENCAP_DPNSS:
452 case WTAP_ENCAP_ATM_PDUS_UNTRUNCATED:
453 case WTAP_ENCAP_LAPB:
454 case WTAP_ENCAP_MTP2:
455 case WTAP_ENCAP_BACNET_MS_TP:
456 case WTAP_ENCAP_PER_PACKET:
460 return WTAP_ERR_UNSUPPORTED_ENCAP;
464 /* Write a record for a packet to a dump file.
465 * Returns TRUE on success, FALSE on failure. */
466 static gboolean eyesdn_dump(wtap_dumper *wdh,
467 const struct wtap_pkthdr *phdr,
468 const union wtap_pseudo_header *pseudo_header _U_,
469 const guchar *pd, int *err)
471 static const guint8 start_flag = 0xff;
472 guint8 buf[EYESDN_HDR_LENGTH];
480 usecs=phdr->ts.nsecs/1000;
483 origin = pseudo_header->isdn.uton;
484 channel = pseudo_header->isdn.channel;
486 switch(phdr->pkt_encap) {
488 case WTAP_ENCAP_ISDN:
489 protocol=EYESDN_ENCAP_ISDN; /* set depending on decoder format and mode */
492 case WTAP_ENCAP_LAYER1_EVENT:
493 protocol=EYESDN_ENCAP_MSG;
496 case WTAP_ENCAP_DPNSS:
497 protocol=EYESDN_ENCAP_DPNSS;
501 case WTAP_ENCAP_DASS2:
502 protocol=EYESDN_ENCAP_DASS2;
506 case WTAP_ENCAP_ATM_PDUS_UNTRUNCATED:
507 protocol=EYESDN_ENCAP_ATM;
511 case WTAP_ENCAP_LAPB:
512 protocol=EYESDN_ENCAP_LAPB;
515 case WTAP_ENCAP_MTP2:
516 protocol=EYESDN_ENCAP_MTP2;
519 case WTAP_ENCAP_BACNET_MS_TP:
520 protocol=EYESDN_ENCAP_BACNET;
524 *err=WTAP_ERR_UNSUPPORTED_ENCAP;
528 phton24(&buf[0], usecs);
531 buf[4] = (guint8)(0xff & (secs >> 24));
532 buf[5] = (guint8)(0xff & (secs >> 16));
533 buf[6] = (guint8)(0xff & (secs >> 8));
534 buf[7] = (guint8)(0xff & (secs >> 0));
536 buf[8] = (guint8) channel;
537 buf[9] = (guint8) (origin?1:0) + (protocol << 1);
538 phtons(&buf[10], size);
541 if (!wtap_dump_file_write(wdh, &start_flag, sizeof start_flag, err))
543 if (!esc_write(wdh, buf, 12, err))
545 if (!esc_write(wdh, pd, size, err))