wiretap/eyesdn.c

   1 /* eyesdn.c
   2  *
   3  * $Id$
   4  *
   5  * Wiretap Library
   6  * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
   7  *
   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.
  12  *
  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.
  17  *
  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include "config.h"
  24 #include "wtap-int.h"
  25 #include "buffer.h"
  26 #include "eyesdn.h"
  27 #include "file_wrappers.h"
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <errno.h>
  33
  34 /* This module reads the output of the EyeSDN USB S0/E1 ISDN probes
  35  * They store HDLC frames of D and B channels in a binary format
  36  * The fileformat is
  37  *
  38  * 1-6 Byte: EyeSDN - Magic
  39  * 7-n Byte: Frames
  40  *
  41  * Each Frame starts with the 0xff Flag byte
  42  * - Bytes 0-2: timestamp (usec in network byte order)
  43  * - Bytes 3-7: timestamp (40bits sec since 1970 in network byte order)
  44  * - Byte 8: channel (0 for D channel, 1-30 for B1-B30)
  45  * - Byte 9: Sender Bit 0(0 NT, 1 TE), Protocol in Bits 7:1, see enum
  46  * - Byte 10-11: frame size in bytes
  47  * - Byte 12-n: Frame Payload
  48  *
  49  * All multibyte values are represented in network byte order
  50  * The frame is terminated with a flag character (0xff)
  51  * bytes 0xff within a frame are escaped using the 0xfe escape character
  52  * the byte following the escape character is decremented by two:
  53  * so 0xfe 0xfd is actually a 0xff
  54  * Characters that need to be escaped are 0xff and 0xfe
  55  */
  56
  57
  58 static int esc_read(guint8 *buf, int len, FILE_T fh)
  59 {
  60         int i;
  61         int value;
  62
  63         for(i=0; i<len; i++) {
  64                 value=file_getc(fh);
  65                 if(value==-1)
  66                         return -2; /* EOF or error */
  67                 if(value==0xff)
  68                         return -1; /* error !!, read into next frame */
  69                 if(value==0xfe) {
  70                         /* we need to escape */
  71                         value=file_getc(fh);
  72                         if(value==-1)
  73                                 return -2;
  74                         value+=2;
  75                 }
  76                 buf[i]=value;
  77         }
  78
  79         return i;
  80 }
  81
  82 /* Magic text to check for eyesdn-ness of file */
  83 static const unsigned char eyesdn_hdr_magic[]  =
  84 { 'E', 'y', 'e', 'S', 'D', 'N'};
  85 #define EYESDN_HDR_MAGIC_SIZE  (sizeof(eyesdn_hdr_magic)  / sizeof(eyesdn_hdr_magic[0]))
  86
  87 /* Size of a record header */
  88 #define EYESDN_HDR_LENGTH               12
  89
  90 /*
  91  * XXX - is this the biggest packet we can get?
  92  */
  93 #define EYESDN_MAX_PACKET_LEN   16384
  94
  95 static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
  96         gint64 *data_offset);
  97 static gboolean eyesdn_seek_read(wtap *wth, gint64 seek_off,
  98         struct wtap_pkthdr *phdr, Buffer *buf, int len,
  99         int *err, gchar **err_info);
 100 static int read_eyesdn_rec(FILE_T fh, struct wtap_pkthdr *phdr, Buffer* buf,
 101         int *err, gchar **err_info);
 102
 103 /* Seeks to the beginning of the next packet, and returns the
 104    byte offset.  Returns -1 on failure, and sets "*err" to the error
 105    and "*err_info" to null or an additional error string. */
 106 static gint64 eyesdn_seek_next_packet(wtap *wth, int *err, gchar **err_info)
 107 {
 108         int byte;
 109         gint64 cur_off;
 110
 111         while ((byte = file_getc(wth->fh)) != EOF) {
 112                 if (byte == 0xff) {
 113                         cur_off = file_tell(wth->fh);
 114                         if (cur_off == -1) {
 115                                 /* Error. */
 116                                 *err = file_error(wth->fh, err_info);
 117                                 return -1;
 118                         }
 119                         return cur_off;
 120                 }
 121         }
 122         /* EOF or error. */
 123         *err = file_error(wth->fh, err_info);
 124         return -1;
 125 }
 126
 127 int eyesdn_open(wtap *wth, int *err, gchar **err_info)
 128 {
 129         int     bytes_read;
 130         char    magic[EYESDN_HDR_MAGIC_SIZE];
 131
 132         /* Look for eyesdn header */
 133         errno = WTAP_ERR_CANT_READ;
 134         bytes_read = file_read(&magic, sizeof magic, wth->fh);
 135         if (bytes_read != sizeof magic) {
 136                 *err = file_error(wth->fh, err_info);
 137                 if (*err != 0 && *err != WTAP_ERR_SHORT_READ)
 138                         return -1;
 139                 return 0;
 140         }
 141         if (memcmp(magic, eyesdn_hdr_magic, EYESDN_HDR_MAGIC_SIZE) != 0)
 142                 return 0;
 143
 144         wth->file_encap = WTAP_ENCAP_PER_PACKET;
 145         wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_EYESDN;
 146         wth->snapshot_length = 0; /* not known */
 147         wth->subtype_read = eyesdn_read;
 148         wth->subtype_seek_read = eyesdn_seek_read;
 149         wth->tsprecision = WTAP_FILE_TSPREC_USEC;
 150
 151         return 1;
 152 }
 153
 154 /* Find the next packet and parse it; called from wtap_read(). */
 155 static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
 156     gint64 *data_offset)
 157 {
 158         gint64  offset;
 159
 160         /* Find the next record */
 161         offset = eyesdn_seek_next_packet(wth, err, err_info);
 162         if (offset < 1)
 163                 return FALSE;
 164         *data_offset = offset;
 165
 166         /* Parse the record */
 167         return read_eyesdn_rec(wth->fh, &wth->phdr, wth->frame_buffer,
 168             err, err_info);
 169 }
 170
 171 /* Used to read packets in random-access fashion */
 172 static gboolean
 173 eyesdn_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
 174         Buffer *buf, int len _U_, int *err, gchar **err_info)
 175 {
 176         if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
 177                 return FALSE;
 178
 179         return read_eyesdn_rec(wth->random_fh, phdr, buf, err, err_info);
 180 }
 181
 182 /* Parses a record. */
 183 static gboolean
 184 read_eyesdn_rec(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf, int *err,
 185     gchar **err_info)
 186 {
 187         union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
 188         guint8          hdr[EYESDN_HDR_LENGTH];
 189         time_t          secs;
 190         int             usecs;
 191         int             pkt_len;
 192         guint8          channel, direction;
 193         int             bytes_read;
 194         guint8          *pd;
 195
 196         /* Our file pointer should be at the summary information header
 197          * for a packet. Read in that header and extract the useful
 198          * information.
 199          */
 200         if (esc_read(hdr, EYESDN_HDR_LENGTH, fh) != EYESDN_HDR_LENGTH) {
 201                 *err = file_error(fh, err_info);
 202                 if (*err == 0)
 203                         *err = WTAP_ERR_SHORT_READ;
 204                 return FALSE;
 205         }
 206
 207         /* extract information from header */
 208         usecs = pntoh24(&hdr[0]);
 209 #ifdef TV64BITS
 210         secs = hdr[3];
 211 #else
 212         secs = 0;
 213 #endif
 214         secs = (secs << 8) | hdr[4];
 215         secs = (secs << 8) | hdr[5];
 216         secs = (secs << 8) | hdr[6];
 217         secs = (secs << 8) | hdr[7];
 218
 219         channel = hdr[8];
 220         direction = hdr[9];
 221         pkt_len = pntohs(&hdr[10]);
 222
 223         switch(direction >> 1) {
 224
 225         default:
 226         case EYESDN_ENCAP_ISDN: /* ISDN */
 227                 pseudo_header->isdn.uton = direction & 1;
 228                 pseudo_header->isdn.channel = channel;
 229                 if(channel) { /* bearer channels */
 230                         phdr->pkt_encap = WTAP_ENCAP_ISDN; /* recognises PPP */
 231                         pseudo_header->isdn.uton=!pseudo_header->isdn.uton; /* bug */
 232                 } else { /* D channel */
 233                         phdr->pkt_encap = WTAP_ENCAP_ISDN;
 234                 }
 235                 break;
 236
 237         case EYESDN_ENCAP_MSG: /* Layer 1 message */
 238                 phdr->pkt_encap = WTAP_ENCAP_LAYER1_EVENT;
 239                 pseudo_header->l1event.uton = (direction & 1);
 240                 break;
 241
 242         case EYESDN_ENCAP_LAPB: /* X.25 via LAPB */
 243                 phdr->pkt_encap = WTAP_ENCAP_LAPB;
 244                 pseudo_header->x25.flags = (direction & 1) ? 0 : 0x80;
 245                 break;
 246
 247         case EYESDN_ENCAP_ATM: { /* ATM cells */
 248 #define CELL_LEN 53
 249                 unsigned char cell[CELL_LEN];
 250                 gint64 cur_off;
 251
 252                 if(pkt_len != CELL_LEN) {
 253                         *err = WTAP_ERR_BAD_FILE;
 254                         *err_info = g_strdup_printf(
 255                             "eyesdn: ATM cell has a length != 53 (%u)",
 256                             pkt_len);
 257                         return FALSE;
 258                 }
 259
 260                 cur_off = file_tell(fh);
 261                 if (esc_read(cell, CELL_LEN, fh) != CELL_LEN) {
 262                         *err = file_error(fh, err_info);
 263                         if (*err == 0)
 264                                 *err = WTAP_ERR_SHORT_READ;
 265                         return FALSE;
 266                 }
 267                 if (file_seek(fh, cur_off, SEEK_SET, err) == -1)
 268                         return FALSE;
 269                 phdr->pkt_encap = WTAP_ENCAP_ATM_PDUS_UNTRUNCATED;
 270                 pseudo_header->atm.flags=ATM_RAW_CELL;
 271                 pseudo_header->atm.aal=AAL_UNKNOWN;
 272                 pseudo_header->atm.type=TRAF_UMTS_FP;
 273                 pseudo_header->atm.subtype=TRAF_ST_UNKNOWN;
 274                 pseudo_header->atm.vpi=((cell[0]&0xf)<<4) + (cell[0]&0xf);
 275                 pseudo_header->atm.vci=((cell[0]&0xf)<<4) + cell[0]; /* from cell */
 276                 pseudo_header->atm.channel=direction & 1;
 277                 }
 278                 break;
 279
 280         case EYESDN_ENCAP_MTP2: /* SS7 frames */
 281                 pseudo_header->mtp2.sent = direction & 1;
 282                 pseudo_header->mtp2.annex_a_used = MTP2_ANNEX_A_USED_UNKNOWN;
 283                 pseudo_header->mtp2.link_number = channel;
 284                 phdr->pkt_encap = WTAP_ENCAP_MTP2_WITH_PHDR;
 285                 break;
 286
 287         case EYESDN_ENCAP_DPNSS: /* DPNSS */
 288                 pseudo_header->isdn.uton = direction & 1;
 289                 pseudo_header->isdn.channel = channel;
 290                 phdr->pkt_encap = WTAP_ENCAP_DPNSS;
 291                 break;
 292
 293         case EYESDN_ENCAP_DASS2: /* DASS2 frames */
 294                 pseudo_header->isdn.uton = direction & 1;
 295                 pseudo_header->isdn.channel = channel;
 296                 phdr->pkt_encap = WTAP_ENCAP_DPNSS;
 297                 break;
 298
 299         case EYESDN_ENCAP_BACNET: /* BACNET async over HDLC frames */
 300                 pseudo_header->isdn.uton = direction & 1;
 301                 pseudo_header->isdn.channel = channel;
 302                 phdr->pkt_encap = WTAP_ENCAP_BACNET_MS_TP_WITH_PHDR;
 303                 break;
 304
 305         case EYESDN_ENCAP_V5_EF: /* V5EF */
 306                 pseudo_header->isdn.uton = direction & 1;
 307                 pseudo_header->isdn.channel = channel;
 308                 phdr->pkt_encap = WTAP_ENCAP_V5_EF;
 309                 break;
 310         }
 311
 312         if(pkt_len > EYESDN_MAX_PACKET_LEN) {
 313                 *err = WTAP_ERR_BAD_FILE;
 314                 *err_info = g_strdup_printf("eyesdn: File has %u-byte packet, bigger than maximum of %u",
 315                     pkt_len, EYESDN_MAX_PACKET_LEN);
 316                 return FALSE;
 317         }
 318
 319         phdr->presence_flags = WTAP_HAS_TS;
 320         phdr->ts.secs = secs;
 321         phdr->ts.nsecs = usecs * 1000;
 322         phdr->caplen = pkt_len;
 323         phdr->len = pkt_len;
 324
 325         /* Make sure we have enough room for the packet */
 326         buffer_assure_space(buf, EYESDN_MAX_PACKET_LEN);
 327
 328         errno = WTAP_ERR_CANT_READ;
 329         pd = buffer_start_ptr(buf);
 330         bytes_read = esc_read(pd, pkt_len, fh);
 331         if (bytes_read != pkt_len) {
 332                 if (bytes_read == -2) {
 333                         *err = file_error(fh, err_info);
 334                         if (*err == 0)
 335                                 *err = WTAP_ERR_SHORT_READ;
 336                 } else if (bytes_read == -1) {
 337                         *err = WTAP_ERR_BAD_FILE;
 338                         *err_info = g_strdup("eyesdn: No flag character seen in frame");
 339                 } else
 340                         *err = WTAP_ERR_SHORT_READ;
 341                 return FALSE;
 342         }
 343         return TRUE;
 344 }
 345
 346
 347 static gboolean
 348 esc_write(wtap_dumper *wdh, const guint8 *buf, int len, int *err)
 349 {
 350         int i;
 351         guint8 byte;
 352         static const guint8 esc = 0xfe;
 353
 354         for(i=0; i<len; i++) {
 355                 byte=buf[i];
 356                 if(byte == 0xff || byte == 0xfe) {
 357                         /*
 358                          * Escape the frame delimiter and escape byte.
 359                          */
 360                         if (!wtap_dump_file_write(wdh, &esc, sizeof esc, err))
 361                                 return FALSE;
 362                         byte-=2;
 363                 }
 364                 if (!wtap_dump_file_write(wdh, &byte, sizeof byte, err))
 365                         return FALSE;
 366         }
 367         return TRUE;
 368 }
 369
 370 static gboolean eyesdn_dump(wtap_dumper *wdh,
 371                             const struct wtap_pkthdr *phdr,
 372                             const guint8 *pd, int *err);
 373
 374 gboolean eyesdn_dump_open(wtap_dumper *wdh, int *err)
 375 {
 376         wdh->subtype_write=eyesdn_dump;
 377         wdh->subtype_close=NULL;
 378
 379         if (!wtap_dump_file_write(wdh, eyesdn_hdr_magic,
 380             EYESDN_HDR_MAGIC_SIZE, err))
 381                 return FALSE;
 382         wdh->bytes_dumped += EYESDN_HDR_MAGIC_SIZE;
 383         *err=0;
 384         return TRUE;
 385 }
 386
 387 int eyesdn_dump_can_write_encap(int encap)
 388 {
 389         switch (encap) {
 390         case WTAP_ENCAP_ISDN:
 391         case WTAP_ENCAP_LAYER1_EVENT:
 392         case WTAP_ENCAP_DPNSS:
 393         case WTAP_ENCAP_ATM_PDUS_UNTRUNCATED:
 394         case WTAP_ENCAP_LAPB:
 395         case WTAP_ENCAP_MTP2_WITH_PHDR:
 396         case WTAP_ENCAP_BACNET_MS_TP_WITH_PHDR:
 397         case WTAP_ENCAP_PER_PACKET:
 398                 return 0;
 399
 400         default:
 401                 return WTAP_ERR_UNSUPPORTED_ENCAP;
 402         }
 403 }
 404
 405 /* Write a record for a packet to a dump file.
 406  *    Returns TRUE on success, FALSE on failure. */
 407 static gboolean eyesdn_dump(wtap_dumper *wdh,
 408                             const struct wtap_pkthdr *phdr,
 409                             const guint8 *pd, int *err)
 410 {
 411         static const guint8 start_flag = 0xff;
 412         const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
 413         guint8 buf[EYESDN_HDR_LENGTH];
 414         int usecs;
 415         time_t secs;
 416         int channel;
 417         int origin;
 418         int protocol;
 419         int size;
 420
 421         usecs=phdr->ts.nsecs/1000;
 422         secs=phdr->ts.secs;
 423         size=phdr->caplen;
 424         origin = pseudo_header->isdn.uton;
 425         channel = pseudo_header->isdn.channel;
 426
 427         switch(phdr->pkt_encap) {
 428
 429         case WTAP_ENCAP_ISDN:
 430                 protocol=EYESDN_ENCAP_ISDN; /* set depending on decoder format and mode */
 431                 break;
 432
 433         case WTAP_ENCAP_LAYER1_EVENT:
 434                 protocol=EYESDN_ENCAP_MSG;
 435                 break;
 436
 437         case WTAP_ENCAP_DPNSS:
 438                 protocol=EYESDN_ENCAP_DPNSS;
 439                 break;
 440
 441 #if 0
 442         case WTAP_ENCAP_DASS2:
 443                 protocol=EYESDN_ENCAP_DASS2;
 444                 break;
 445 #endif
 446
 447         case WTAP_ENCAP_ATM_PDUS_UNTRUNCATED:
 448                 protocol=EYESDN_ENCAP_ATM;
 449                 channel=0x80;
 450                 break;
 451
 452         case WTAP_ENCAP_LAPB:
 453                 protocol=EYESDN_ENCAP_LAPB;
 454                 break;
 455
 456         case WTAP_ENCAP_MTP2_WITH_PHDR:
 457                 protocol=EYESDN_ENCAP_MTP2;
 458                 break;
 459
 460         case WTAP_ENCAP_BACNET_MS_TP_WITH_PHDR:
 461                 protocol=EYESDN_ENCAP_BACNET;
 462                 break;
 463
 464         case WTAP_ENCAP_V5_EF:
 465                 protocol=EYESDN_ENCAP_V5_EF;
 466                 break;
 467
 468         default:
 469                 *err=WTAP_ERR_UNSUPPORTED_ENCAP;
 470                 return FALSE;
 471         }
 472
 473         phton24(&buf[0], usecs);
 474
 475         buf[3] = (guint8)0;
 476         buf[4] = (guint8)(0xff & (secs >> 24));
 477         buf[5] = (guint8)(0xff & (secs >> 16));
 478         buf[6] = (guint8)(0xff & (secs >> 8));
 479         buf[7] = (guint8)(0xff & (secs >> 0));
 480
 481         buf[8] = (guint8) channel;
 482         buf[9] = (guint8) (origin?1:0) + (protocol << 1);
 483         phtons(&buf[10], size);
 484
 485         /* start flag */
 486         if (!wtap_dump_file_write(wdh, &start_flag, sizeof start_flag, err))
 487                 return FALSE;
 488         if (!esc_write(wdh, buf, 12, err))
 489                 return FALSE;
 490         if (!esc_write(wdh, pd, size, err))
 491                 return FALSE;
 492         return TRUE;
 493 }