71420568bf95f4accf595a815bac0ce0ede2263e
[obnox/wireshark/wip.git] / wiretap / eyesdn.c
1 /* eyesdn.c
2  *
3  * $Id: eyesdn.c,v 1.1 2004/02/11 20:05:16 guy Exp $
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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  */
22
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26 #include "wtap-int.h"
27 #include "buffer.h"
28 #include "eyesdn.h"
29 #include "file_wrappers.h"
30
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <errno.h>
35
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
38  * The fileformat is
39  * 
40  * 1-6 Byte: EyeSDN - Magic
41  * 7-n Byte: Frames
42  * 
43  * Each Frame starts with the 0xff Flag byte
44  * - Bytes 0-2: timestamp (long usec in network byte order)
45  * - Bytes 3-7: timestamp (40bits sec since 1970 in network byte order)
46  * - Byte 8: channel (0d for D channel, 0e for e channel, b1-ce for B1-B30)
47  * - Byte 9: Sender (0 NT, 1 TE)
48  * - Byte 10-11: frame size in bytes
49  * - Byte 12-n: Frame Payload
50  * 
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
57  */
58
59
60 static int esc_read(unsigned char *buf, int len, FILE_T *fh)
61 {
62     int i, err;
63     unsigned char value;
64     
65     for(i=0; i<len; i++) {
66         value=file_getc(fh);
67         err=0 /*file_eof(fh)*/;
68         if(err) break;
69         if(value==0xff) return -1; /* error !!, read into next frame */
70         if(value==0xfe) { // we need to escape 
71             value=file_getc(fh);
72             value+=2;
73         }
74         buf[i]=value;
75     }
76     if(file_error(fh)) return -2;
77     return i;
78 }
79
80 /* Magic text to check for eyesdn-ness of file */
81 static const unsigned char eyesdn_hdr_magic[]  =
82 { 'E', 'y', 'e', 'S', 'D', 'N'};
83 #define EYESDN_HDR_MAGIC_SIZE  (sizeof(eyesdn_hdr_magic)  / sizeof(eyesdn_hdr_magic[0]))
84
85 /* Magic text for start of packet */
86 static const unsigned char eyesdn_rec_magic[]  = { 0xff };
87 #define EYESDN_REC_MAGIC_SIZE  (sizeof eyesdn_rec_magic  / sizeof eyesdn_rec_magic[0])
88
89 #define EYESDN_HEADER_LINES_TO_CHECK    1
90 #define EYESDN_HDR_LENGTH               12
91 #define EYESDN_LINE_LENGTH              12
92
93 /*
94  * XXX - is this the biggest packet we can get?
95  */
96 #define EYESDN_MAX_PACKET_LEN   16384
97
98 static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
99         long *data_offset);
100 static gboolean eyesdn_seek_read(wtap *wth, long seek_off,
101         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len,
102         int *err, gchar **err_info);
103 static gboolean parse_eyesdn_hex_dump(FILE_T fh, int pkt_len, guint8* buf,
104         int *err, gchar **err_info);
105 static int parse_eyesdn_rec_hdr(wtap *wth, FILE_T fh,
106         union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info);
107
108 /* Seeks to the beginning of the next packet, and returns the
109    byte offset.  Returns -1 on failure, and sets "*err" to the error. */
110 static long eyesdn_seek_next_packet(wtap *wth, int *err)
111 {
112   int byte;
113   long cur_off;
114
115   while ((byte = file_getc(wth->fh)) != EOF) {
116     if (byte == 0xff) {
117         cur_off = file_tell(wth->fh);
118         if (cur_off == -1) {
119           /* Error. */
120           *err = file_error(wth->fh);
121           return -1;
122         }
123         return cur_off;
124       }
125   }
126   if (file_eof(wth->fh)) {
127     /* We got an EOF. */
128     *err = 0;
129   } else {
130     /* We (presumably) got an error (there's no equivalent to "ferror()"
131        in zlib, alas, so we don't have a wrapper to check for an error). */
132     *err = file_error(wth->fh);
133   }
134   return -1;
135 }
136
137 /* Look through the first part of a file to see if this is
138  * a eyesdn trace file.
139  *
140  * Returns TRUE if it is, FALSE if it isn't or if we get an I/O error;
141  * if we get an I/O error, "*err" will be set to a non-zero value.
142  */
143 static gboolean eyesdn_check_file_type(wtap *wth, int *err)
144 {
145         char    buf[EYESDN_HDR_MAGIC_SIZE];
146         int     i, reclen;
147         guint   level;
148         char    byte;
149
150         reclen=EYESDN_HDR_MAGIC_SIZE;
151         if (file_read(buf, 1, reclen, wth->fh) == reclen) {
152             level = 0;
153             for (i = 0; i < reclen; i++) {
154                 byte = buf[i];
155                 if (byte == eyesdn_hdr_magic[level]) {
156                     level++;
157                     if (level >= EYESDN_HDR_MAGIC_SIZE) {
158                         return TRUE;
159                     }
160                 } else {
161                     level = 0;
162                 }
163             }
164         } else {/* EOF or error. */
165             if (file_eof(wth->fh))
166                 *err = 0;
167             else
168                 *err = file_error(wth->fh);
169             return FALSE;
170         }
171         *err = 0;
172         return FALSE;
173 }
174
175
176 int eyesdn_open(wtap *wth, int *err, gchar **err_info _U_)
177 {
178         /* Look for eyesdn header */
179         if (!eyesdn_check_file_type(wth, err)) {
180                 if (*err == 0)
181                         return 0;
182                 else
183                         return -1;
184         }
185
186         wth->data_offset = 0;
187         wth->file_encap = WTAP_ENCAP_ISDN;
188         wth->file_type = WTAP_FILE_EYESDN;
189         wth->snapshot_length = 0; /* not known */
190         wth->subtype_read = eyesdn_read;
191         wth->subtype_seek_read = eyesdn_seek_read;
192
193         return 1;
194 }
195
196 /* Find the next packet and parse it; called from wtap_loop() and wtap_read(). */
197 static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
198     long *data_offset)
199 {
200         long    offset;
201         guint8  *buf;
202         int     pkt_len;
203
204         /* Find the next packet */
205         offset = eyesdn_seek_next_packet(wth, err);
206         if (offset < 1)
207                 return FALSE;
208
209         /* Parse the header */
210         pkt_len = parse_eyesdn_rec_hdr(wth, wth->fh, &wth->pseudo_header, err,
211             err_info);
212         if (pkt_len == -1)
213                 return FALSE;
214
215         /* Make sure we have enough room for the packet */
216         buffer_assure_space(wth->frame_buffer, EYESDN_MAX_PACKET_LEN);
217         buf = buffer_start_ptr(wth->frame_buffer);
218
219         /* Convert the ASCII hex dump to binary data */
220         if (!parse_eyesdn_hex_dump(wth->fh, pkt_len, buf, err, err_info))
221                 return FALSE;
222
223         wth->data_offset = offset;
224         *data_offset = offset;
225         return TRUE;
226 }
227
228 /* Used to read packets in random-access fashion */
229 static gboolean
230 eyesdn_seek_read (wtap *wth, long seek_off,
231         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len,
232         int *err, gchar **err_info)
233 {
234         int     pkt_len;
235
236         if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
237                 return FALSE;
238
239         pkt_len = parse_eyesdn_rec_hdr(NULL, wth->random_fh, pseudo_header,
240             err, err_info);
241
242         if (pkt_len != len) {
243                 if (pkt_len != -1) {
244                         *err = WTAP_ERR_BAD_RECORD;
245                         *err_info = g_strdup_printf("eyesdn: requested length %d doesn't match length %d",
246                             len, pkt_len);
247                 }
248                 return FALSE;
249         }
250
251         return parse_eyesdn_hex_dump(wth->random_fh, pkt_len, pd, err,
252             err_info);
253 }
254
255 /* Parses a packet record header. */
256 static int
257 parse_eyesdn_rec_hdr(wtap *wth, FILE_T fh,
258     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
259 {
260         unsigned char   line[EYESDN_HDR_LENGTH];
261         unsigned long   secs, usecs;
262         int     pkt_len;
263         unsigned int    channel, direction;
264
265         /* Our file pointer should be on the line containing the
266          * summary information for a packet. Read in that line and
267          * extract the useful information
268          */
269         if (esc_read(line, EYESDN_HDR_LENGTH, fh) != EYESDN_HDR_LENGTH) {
270                 *err = file_error(fh);
271                 if (*err == 0) {
272                         *err = WTAP_ERR_SHORT_READ;
273                 }
274                 return -1;
275         }
276     
277         /* extract information from header */
278         usecs = ((unsigned long) line[0]);
279         usecs = (usecs << 8) | ((unsigned long) line[1]);
280         usecs = (usecs << 8) | ((unsigned long) line[2]);
281 #ifdef TV64BITS    
282         secs = ((unsigned long) line[3]);
283 #else    
284         secs = 0;
285 #endif    
286         secs = (secs << 8) | ((unsigned long) line[4]);
287         secs = (secs << 8) | ((unsigned long) line[5]);
288         secs = (secs << 8) | ((unsigned long) line[6]);
289         secs = (secs << 8) | ((unsigned long) line[7]);
290
291         channel = line[8];
292         direction = line[9];
293         pkt_len = ((unsigned long) line[10]) << 8;
294         pkt_len = (pkt_len << 8) | ((unsigned long) line[11]);
295
296         /* sanity checks */
297         if(channel>30) {
298             *err = WTAP_ERR_BAD_RECORD;
299             *err_info = g_strdup_printf("eyesdn: bad channel number %u",
300                 channel);
301             return -1;
302         }
303
304         if(direction>1) {
305             *err = WTAP_ERR_BAD_RECORD;
306             *err_info = g_strdup_printf("eyesdn: bad direction value %u",
307                 direction);
308             return -1;
309         }
310         if(pkt_len > EYESDN_MAX_PACKET_LEN) {
311             *err = WTAP_ERR_BAD_RECORD;
312             *err_info = g_strdup_printf("eyesdn: File has %u-byte packet, bigger than maximum of %u",
313                 pkt_len, EYESDN_MAX_PACKET_LEN);
314             return -1;
315         }
316
317         if (wth) {
318                 wth->phdr.ts.tv_sec = secs;
319                 wth->phdr.ts.tv_usec = usecs;
320                 wth->phdr.caplen = pkt_len;
321                 wth->phdr.len = pkt_len;
322         }
323         pseudo_header->isdn.uton = direction;
324         pseudo_header->isdn.channel = channel;
325
326         return pkt_len;
327 }
328
329 /* read a packet */
330 static gboolean
331 parse_eyesdn_hex_dump(FILE_T fh, int pkt_len, guint8* buf, int *err,
332     gchar **err_info)
333 {
334         int bytes_read;
335
336         errno = WTAP_ERR_CANT_READ;
337         bytes_read = esc_read(buf, pkt_len, fh);
338         if (bytes_read != pkt_len) {
339             if (bytes_read == -2)
340                 *err = file_error(fh);
341             else if (bytes_read == -1) {
342                 *err = WTAP_ERR_BAD_RECORD;
343                 *err_info = g_strdup("eyesdn: No flag character seen in frame");
344             } else
345                 *err = WTAP_ERR_SHORT_READ;
346             return FALSE;
347         }
348         return TRUE;
349 }