Fix some of the Errors/warnings detected by checkapi.
[obnox/wireshark/wip.git] / 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., 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 (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
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(guint8 *buf, int len, FILE_T fh, int seekback)
61 {
62     int i;
63     int value;
64     gint64 cur_off;
65     int err;
66
67     if(seekback) cur_off = file_tell(fh);
68     else cur_off=0; /* suppress uninitialized warning */
69     
70     for(i=0; i<len; i++) {
71         value=file_getc(fh);
72         if(value==-1)
73             return -2; /* EOF or error */
74         if(value==0xff)
75             return -1; /* error !!, read into next frame */
76         if(value==0xfe) {
77             /* we need to escape */
78             value=file_getc(fh);
79             if(value==-1)
80                 return -2;
81             value+=2;
82         }
83         buf[i]=value;
84     }
85
86     if(seekback) {
87         if (file_seek(fh, cur_off, SEEK_SET, &err) == -1)
88             return err<0?err:-err;
89     }
90     return i;
91 }
92
93 /* Magic text to check for eyesdn-ness of file */
94 static const unsigned char eyesdn_hdr_magic[]  =
95 { 'E', 'y', 'e', 'S', 'D', 'N'};
96 #define EYESDN_HDR_MAGIC_SIZE  (sizeof(eyesdn_hdr_magic)  / sizeof(eyesdn_hdr_magic[0]))
97
98 /* Size of a record header */
99 #define EYESDN_HDR_LENGTH               12
100
101 /*
102  * XXX - is this the biggest packet we can get?
103  */
104 #define EYESDN_MAX_PACKET_LEN   16384
105
106 static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
107         gint64 *data_offset);
108 static gboolean eyesdn_seek_read(wtap *wth, gint64 seek_off,
109         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len,
110         int *err, gchar **err_info);
111 static gboolean parse_eyesdn_packet_data(FILE_T fh, int pkt_len, guint8* buf,
112         int *err, gchar **err_info);
113 static int parse_eyesdn_rec_hdr(wtap *wth, FILE_T fh,
114         union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info);
115
116 /* Seeks to the beginning of the next packet, and returns the
117    byte offset.  Returns -1 on failure, and sets "*err" to the error. */
118 static gint64 eyesdn_seek_next_packet(wtap *wth, int *err)
119 {
120   int byte;
121   gint64 cur_off;
122
123   while ((byte = file_getc(wth->fh)) != EOF) {
124     if (byte == 0xff) {
125         cur_off = file_tell(wth->fh);
126         if (cur_off == -1) {
127           /* Error. */
128           *err = file_error(wth->fh);
129           return -1;
130         }
131         return cur_off;
132       }
133   }
134   if (file_eof(wth->fh)) {
135     /* We got an EOF. */
136     *err = 0;
137   } else {
138     /* We (presumably) got an error (there's no equivalent to "ferror()"
139        in zlib, alas, so we don't have a wrapper to check for an error). */
140     *err = file_error(wth->fh);
141   }
142   return -1;
143 }
144
145 int eyesdn_open(wtap *wth, int *err, gchar **err_info _U_)
146 {
147         int     bytes_read;
148         char    magic[EYESDN_HDR_MAGIC_SIZE];
149
150         /* Look for eyesdn header */
151         errno = WTAP_ERR_CANT_READ;
152         bytes_read = file_read(&magic, 1, sizeof magic, wth->fh);
153         if (bytes_read != sizeof magic) {
154                 *err = file_error(wth->fh);
155                 if (*err != 0)
156                         return -1;
157                 return 0;
158         }
159         if (memcmp(magic, eyesdn_hdr_magic, EYESDN_HDR_MAGIC_SIZE) != 0)
160                 return 0;
161
162         wth->data_offset = 0;
163         wth->file_encap = WTAP_ENCAP_PER_PACKET;
164         wth->file_type = WTAP_FILE_EYESDN;
165         wth->snapshot_length = 0; /* not known */
166         wth->subtype_read = eyesdn_read;
167         wth->subtype_seek_read = eyesdn_seek_read;
168         wth->tsprecision = WTAP_FILE_TSPREC_USEC;
169
170         return 1;
171 }
172
173 /* Find the next packet and parse it; called from wtap_read(). */
174 static gboolean eyesdn_read(wtap *wth, int *err, gchar **err_info,
175     gint64 *data_offset)
176 {
177         gint64  offset;
178         guint8  *buf;
179         int     pkt_len;
180
181         /* Find the next packet */
182         offset = eyesdn_seek_next_packet(wth, err);
183         if (offset < 1)
184                 return FALSE;
185
186         /* Parse the header */
187         pkt_len = parse_eyesdn_rec_hdr(wth, wth->fh, &wth->pseudo_header, err,
188             err_info);
189         if (pkt_len == -1)
190                 return FALSE;
191
192         /* Make sure we have enough room for the packet */
193         buffer_assure_space(wth->frame_buffer, EYESDN_MAX_PACKET_LEN);
194         buf = buffer_start_ptr(wth->frame_buffer);
195
196         /* Read the packet data */
197         if (!parse_eyesdn_packet_data(wth->fh, pkt_len, buf, err, err_info))
198                 return FALSE;
199
200         wth->data_offset = offset;
201         *data_offset = offset;
202         return TRUE;
203 }
204
205 /* Used to read packets in random-access fashion */
206 static gboolean
207 eyesdn_seek_read (wtap *wth, gint64 seek_off,
208         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len,
209         int *err, gchar **err_info)
210 {
211         int     pkt_len;
212
213         if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
214                 return FALSE;
215
216         pkt_len = parse_eyesdn_rec_hdr(NULL, wth->random_fh, pseudo_header,
217             err, err_info);
218
219         if (pkt_len != len) {
220                 if (pkt_len != -1) {
221                         *err = WTAP_ERR_BAD_RECORD;
222                         *err_info = g_strdup_printf("eyesdn: requested length %d doesn't match length %d",
223                             len, pkt_len);
224                 }
225                 return FALSE;
226         }
227
228         return parse_eyesdn_packet_data(wth->random_fh, pkt_len, pd, err,
229             err_info);
230 }
231
232 /* Parses a packet record header. */
233 static int
234 parse_eyesdn_rec_hdr(wtap *wth, FILE_T fh,
235     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info)
236 {
237         guint8          hdr[EYESDN_HDR_LENGTH];
238         unsigned long   secs, usecs;
239         int             pkt_len;
240         guint8          channel, direction;
241
242         /* Our file pointer should be at the summary information header
243          * for a packet. Read in that header and extract the useful
244          * information.
245          */
246         if (esc_read(hdr, EYESDN_HDR_LENGTH, fh, 0) != EYESDN_HDR_LENGTH) {
247                 *err = file_error(fh);
248                 if (*err == 0)
249                         *err = WTAP_ERR_SHORT_READ;
250                 return -1;
251         }
252     
253         /* extract information from header */
254         usecs = ((unsigned long) hdr[0]);
255         usecs = (usecs << 8) | ((unsigned long) hdr[1]);
256         usecs = (usecs << 8) | ((unsigned long) hdr[2]);
257 #ifdef TV64BITS    
258         secs = ((unsigned long) hdr[3]);
259 #else    
260         secs = 0;
261 #endif    
262         secs = (secs << 8) | ((unsigned long) hdr[4]);
263         secs = (secs << 8) | ((unsigned long) hdr[5]);
264         secs = (secs << 8) | ((unsigned long) hdr[6]);
265         secs = (secs << 8) | ((unsigned long) hdr[7]);
266
267         channel = hdr[8];
268         direction = hdr[9];
269         pkt_len = ((unsigned long) hdr[10]);
270         pkt_len = (pkt_len << 8) | ((unsigned long) hdr[11]);
271
272         switch(direction >> 1) {
273         default:
274         case EYESDN_ENCAP_ISDN: /* ISDN */
275             pseudo_header->isdn.uton = direction & 1;
276             pseudo_header->isdn.channel = channel;
277             if(channel) { /* bearer channels */
278                 if(wth) {
279                     wth->phdr.pkt_encap = WTAP_ENCAP_ISDN; /* recognises PPP */
280                     pseudo_header->isdn.uton=!pseudo_header->isdn.uton; /* bug */
281                 }
282             } else { /* D channel */
283                 if(wth) {
284                     wth->phdr.pkt_encap = WTAP_ENCAP_ISDN;
285                 }
286             }
287             break;
288         case EYESDN_ENCAP_MSG: /* Layer 1 message */
289             if(wth) {
290                 wth->phdr.pkt_encap = WTAP_ENCAP_LAYER1_EVENT;
291             }
292             pseudo_header->l1event.uton = (direction & 1);
293             break;
294         case EYESDN_ENCAP_LAPB: /* X.25 via LAPB */ 
295             if(wth) {
296                 wth->phdr.pkt_encap = WTAP_ENCAP_LAPB;
297             }
298             pseudo_header->x25.flags = (direction & 1) ? 0 : 0x80;
299             break;
300         case EYESDN_ENCAP_ATM: { /* ATM cells */
301 #define CELL_LEN 53
302             unsigned char cell[CELL_LEN];
303             if(pkt_len != CELL_LEN) {
304                 *err = WTAP_ERR_BAD_RECORD;
305                 *err_info = g_strdup_printf("eyesdn: ATM cell has a length "
306                                             "!= 53 (%u)", pkt_len);
307                 return -1;
308             }
309
310             if (esc_read(cell, CELL_LEN, fh, 1) != CELL_LEN) {
311                 *err = file_error(fh);
312                 if (*err == 0)
313                     *err = WTAP_ERR_SHORT_READ;
314                 return -1;
315             }
316
317             if(wth) {
318                 wth->phdr.pkt_encap = WTAP_ENCAP_ATM_PDUS_UNTRUNCATED;
319             }
320             pseudo_header->atm.flags=ATM_RAW_CELL;
321             pseudo_header->atm.aal=AAL_UNKNOWN;
322             pseudo_header->atm.type=TRAF_UMTS_FP;
323             pseudo_header->atm.subtype=TRAF_ST_UNKNOWN;
324             pseudo_header->atm.vpi=((cell[0]&0xf)<<4) + (cell[0]&0xf);
325             pseudo_header->atm.vci=((cell[0]&0xf)<<4) + cell[0]; /* from cell */
326             pseudo_header->atm.channel=direction & 1;
327         }
328             break;
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;      
333             if(wth) {
334                 wth->phdr.pkt_encap = WTAP_ENCAP_MTP2;
335             }
336             break;
337         } 
338
339         if(pkt_len > EYESDN_MAX_PACKET_LEN) {
340             *err = WTAP_ERR_BAD_RECORD;
341             *err_info = g_strdup_printf("eyesdn: File has %u-byte packet, bigger than maximum of %u",
342                 pkt_len, EYESDN_MAX_PACKET_LEN);
343             return -1;
344         }
345
346         if (wth) {
347                 wth->phdr.ts.secs = secs;
348                 wth->phdr.ts.nsecs = usecs * 1000;
349                 wth->phdr.caplen = pkt_len;
350                 wth->phdr.len = pkt_len;
351         }
352
353         return pkt_len;
354 }
355
356 /* read a packet */
357 static gboolean
358 parse_eyesdn_packet_data(FILE_T fh, int pkt_len, guint8* buf, int *err,
359     gchar **err_info)
360 {
361         int bytes_read;
362
363         errno = WTAP_ERR_CANT_READ;
364         bytes_read = esc_read(buf, pkt_len, fh, 0);
365         if (bytes_read != pkt_len) {
366             if (bytes_read == -2) {
367                 *err = file_error(fh);
368                 if (*err == 0)
369                     *err = WTAP_ERR_SHORT_READ;
370             }  else if (bytes_read == -1) {
371                 *err = WTAP_ERR_BAD_RECORD;
372                 *err_info = g_strdup("eyesdn: No flag character seen in frame");
373             } else
374                 *err = WTAP_ERR_SHORT_READ;
375             return FALSE;
376         }
377         return TRUE;
378 }