Make "wtap_seek_read()" return TRUE on success and FALSE on error, like
[obnox/wireshark/wip.git] / wiretap / radcom.c
1 /* radcom.c
2  *
3  * $Id: radcom.c,v 1.35 2002/03/05 08:39:29 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
27 #include <stdlib.h>
28 #include <errno.h>
29 #include <string.h>
30 #include "wtap-int.h"
31 #include "file_wrappers.h"
32 #include "buffer.h"
33 #include "radcom.h"
34
35 struct frame_date {
36         guint16 year;
37         guint8  month;
38         guint8  day;
39         guint32 sec;            /* seconds since midnight */
40         guint32 usec;
41 };
42
43 struct unaligned_frame_date {
44         char    year[2];
45         char    month;
46         char    day;
47         char    sec[4];         /* seconds since midnight */
48         char    usec[4];
49 };
50
51 static guint8 radcom_magic[8] = {
52         0x42, 0xD2, 0x00, 0x34, 0x12, 0x66, 0x22, 0x88
53 };
54
55 /* RADCOM record header - followed by frame data (perhaps including FCS).
56    The first two bytes of "xxz" appear to equal "length", as do the
57    second two bytes; if a RADCOM box can be told not to save all of
58    the captured packet, might one or the other of those be the
59    captured length of the packet? */
60 struct radcomrec_hdr {
61         char    xxx[4];         /* unknown */
62         char    length[2];      /* packet length */
63         char    xxy[5];         /* unknown */
64         struct unaligned_frame_date date; /* date/time stamp of packet */
65         char    xxz[6];         /* unknown */
66         char    dce;            /* DCE/DTE flag (and other flags?) */
67         char    xxw[9];         /* unknown */
68 };
69
70 static gboolean radcom_read(wtap *wth, int *err, long *data_offset);
71 static gboolean radcom_seek_read(wtap *wth, long seek_off,
72         union wtap_pseudo_header *pseudo_header, u_char *pd, int length,
73         int *err);
74 static int radcom_read_rec_header(FILE_T fh, struct radcomrec_hdr *hdr,
75         int *err);
76 static gboolean radcom_read_rec_data(FILE_T fh, u_char *pd, int length,
77         int *err);
78
79 int radcom_open(wtap *wth, int *err)
80 {
81         int bytes_read;
82         char magic[8];
83         struct frame_date start_date;
84         guint32 sec;
85         struct tm tm;
86         char byte;
87         char encap_magic[4] = {0x00, 0x42, 0x43, 0x09};
88         char search_encap[7];
89
90         /* Read in the string that should be at the start of a RADCOM file */
91         errno = WTAP_ERR_CANT_READ;
92         bytes_read = file_read(magic, 1, 8, wth->fh);
93         if (bytes_read != 8) {
94                 *err = file_error(wth->fh);
95                 if (*err != 0)
96                         return -1;
97                 return 0;
98         }
99
100         if (memcmp(magic, radcom_magic, 8) != 0) {
101                 return 0;
102         }
103
104         if (file_seek(wth->fh, 0x8B, SEEK_SET) == -1) {
105                 *err = file_error(wth->fh);
106                 return -1;
107         }
108         wth->data_offset = 0x8B;
109         errno = WTAP_ERR_CANT_READ;
110         bytes_read = file_read(&byte, 1, 1, wth->fh);
111         if (bytes_read != 1) {
112                 *err = file_error(wth->fh);
113                 if (*err != 0)
114                         return -1;
115                 return 0;
116         }
117         wth->data_offset += 1;
118         while (byte) {
119                 errno = WTAP_ERR_CANT_READ;
120                 bytes_read = file_read(&byte, 1, 1, wth->fh);
121                 if (bytes_read != 1) {
122                         *err = file_error(wth->fh);
123                         if (*err != 0)
124                                 return -1;
125                         return 0;
126                 }
127                 wth->data_offset += 1;
128         }
129
130         /* Get capture start time */
131         errno = WTAP_ERR_CANT_READ;
132         bytes_read = file_read(&start_date, 1, sizeof(struct frame_date), wth->fh);
133         if (bytes_read != sizeof(struct frame_date)) {
134                 *err = file_error(wth->fh);
135                 if (*err != 0)
136                         return -1;
137                 return 0;
138         }
139         wth->data_offset += sizeof(struct frame_date);
140
141         /* This is a radcom file */
142         wth->file_type = WTAP_FILE_RADCOM;
143         wth->subtype_read = radcom_read;
144         wth->subtype_seek_read = radcom_seek_read;
145         wth->snapshot_length = 0;       /* not available in header, only in frame */
146
147         tm.tm_year = pletohs(&start_date.year)-1900;
148         tm.tm_mon = start_date.month-1;
149         tm.tm_mday = start_date.day;
150         sec = pletohl(&start_date.sec);
151         tm.tm_hour = sec/3600;
152         tm.tm_min = (sec%3600)/60;
153         tm.tm_sec = sec%60;
154         tm.tm_isdst = -1;
155
156         if (file_seek(wth->fh, sizeof(struct frame_date), SEEK_CUR) == -1) {
157                 *err = file_error(wth->fh);
158                 return -1;
159         }
160         wth->data_offset += sizeof(struct frame_date);
161
162         errno = WTAP_ERR_CANT_READ;
163         bytes_read = file_read(search_encap, 1, 4, wth->fh);
164         if (bytes_read != 4) {
165                 goto read_error;
166         }
167         wth->data_offset += 4;
168         while (memcmp(encap_magic, search_encap, 4)) {
169                 if (file_seek(wth->fh, -3, SEEK_CUR) == -1) {
170                         *err = file_error(wth->fh);
171                         return -1;
172                 }
173                 wth->data_offset -= 3;
174                 errno = WTAP_ERR_CANT_READ;
175                 bytes_read = file_read(search_encap, 1, 4, wth->fh);
176                 if (bytes_read != 4) {
177                         goto read_error;
178                 }
179                 wth->data_offset += 4;
180         }
181         if (file_seek(wth->fh, 12, SEEK_CUR) == -1) {
182                 *err = file_error(wth->fh);
183                 return -1;
184         }
185         wth->data_offset += 12;
186         errno = WTAP_ERR_CANT_READ;
187         bytes_read = file_read(search_encap, 1, 4, wth->fh);
188         if (bytes_read != 4) {
189                 goto read_error;
190         }
191         wth->data_offset += 4;
192         if (!memcmp(search_encap, "LAPB", 4))
193                 wth->file_encap = WTAP_ENCAP_LAPB;
194         else if (!memcmp(search_encap, "Ethe", 4))
195                 wth->file_encap = WTAP_ENCAP_ETHERNET;
196         else {
197                 g_message("pcap: network type \"%.4s\" unknown", search_encap);
198                 *err = WTAP_ERR_UNSUPPORTED_ENCAP;
199                 return -1;
200         }
201
202         /*bytes_read = file_read(&next_date, 1, sizeof(struct frame_date), wth->fh);
203         errno = WTAP_ERR_CANT_READ;
204         if (bytes_read != sizeof(struct frame_date)) {
205                 goto read_error;
206         }
207
208         while (memcmp(&start_date, &next_date, 4)) {
209                 if (file_seek(wth->fh, 1-sizeof(struct frame_date), SEEK_CUR) == -1) {
210                         *err = file_error(wth->fh);
211                         return -1;
212                 }
213                 errno = WTAP_ERR_CANT_READ;
214                 bytes_read = file_read(&next_date, 1, sizeof(struct frame_date),
215                                    wth->fh);
216                 if (bytes_read != sizeof(struct frame_date)) {
217                         goto read_error;
218                 }
219         }*/
220
221         if (wth->file_encap == WTAP_ENCAP_ETHERNET) {
222                 if (file_seek(wth->fh, 294, SEEK_CUR) == -1) {
223                         *err = file_error(wth->fh);
224                         return -1;
225                 }
226                 wth->data_offset += 294;
227         } else if (wth->file_encap == WTAP_ENCAP_LAPB) {
228                 if (file_seek(wth->fh, 297, SEEK_CUR) == -1) {
229                         *err = file_error(wth->fh);
230                         return -1;
231                 }
232                 wth->data_offset += 297;
233         }
234
235         return 1;
236
237 read_error:
238         *err = file_error(wth->fh);
239         if (*err != 0)
240                 return -1;
241         return 0;
242 }
243
244 /* Read the next packet */
245 static gboolean radcom_read(wtap *wth, int *err, long *data_offset)
246 {
247         int     ret;
248         struct radcomrec_hdr hdr;
249         guint16 length;
250         guint32 sec;
251         int     bytes_read;
252         struct tm tm;
253         char    fcs[2];
254
255         /* Read record header. */
256         *data_offset = wth->data_offset;
257         ret = radcom_read_rec_header(wth->fh, &hdr, err);
258         if (ret <= 0) {
259                 /* Read error or EOF */
260                 return FALSE;
261         }
262         wth->data_offset += sizeof hdr;
263         length = pletohs(&hdr.length);
264         if (length == 0) return FALSE;
265
266         if (wth->file_encap == WTAP_ENCAP_LAPB)
267                 length -= 2; /* FCS */
268
269         wth->phdr.len = length;
270         wth->phdr.caplen = length;
271
272         tm.tm_year = pletohs(&hdr.date.year)-1900;
273         tm.tm_mon = hdr.date.month-1;
274         tm.tm_mday = hdr.date.day;
275         sec = pletohl(&hdr.date.sec);
276         tm.tm_hour = sec/3600;
277         tm.tm_min = (sec%3600)/60;
278         tm.tm_sec = sec%60;
279         tm.tm_isdst = -1;
280         wth->phdr.ts.tv_sec = mktime(&tm);
281         wth->phdr.ts.tv_usec = pletohl(&hdr.date.usec);
282         wth->pseudo_header.x25.flags = (hdr.dce & 0x1) ? 0x00 : 0x80;
283
284         /*
285          * Read the packet data.
286          */
287         buffer_assure_space(wth->frame_buffer, length);
288         if (!radcom_read_rec_data(wth->fh,
289             buffer_start_ptr(wth->frame_buffer), length, err))
290                 return FALSE;   /* Read error */
291         wth->data_offset += length;
292
293         wth->phdr.pkt_encap = wth->file_encap;
294
295         if (wth->file_encap == WTAP_ENCAP_LAPB) {
296                 /* Read the FCS.
297                    XXX - should we put it in the pseudo-header? */
298                 errno = WTAP_ERR_CANT_READ;
299                 bytes_read = file_read(&fcs, 1, sizeof fcs, wth->fh);
300                 if (bytes_read != sizeof fcs) {
301                         *err = file_error(wth->fh);
302                         if (*err == 0)
303                                 *err = WTAP_ERR_SHORT_READ;
304                         return FALSE;
305                 }
306                 wth->data_offset += sizeof fcs;
307         }
308
309         return TRUE;
310 }
311
312 static gboolean
313 radcom_seek_read(wtap *wth, long seek_off,
314     union wtap_pseudo_header *pseudo_header, u_char *pd, int length, int *err)
315 {
316         int     ret;
317         struct radcomrec_hdr hdr;
318
319         if (file_seek(wth->random_fh, seek_off, SEEK_SET) == -1) {
320                 *err = file_error(wth->random_fh);
321                 return FALSE;
322         }
323
324         /* Read record header. */
325         ret = radcom_read_rec_header(wth->random_fh, &hdr, err);
326         if (ret <= 0) {
327                 /* Read error or EOF */
328                 if (ret == 0) {
329                         /* EOF means "short read" in random-access mode */
330                         *err = WTAP_ERR_SHORT_READ;
331                 }
332                 return FALSE;
333         }
334
335         pseudo_header->x25.flags = (hdr.dce & 0x1) ? 0x00 : 0x80;
336
337         /*
338          * Read the packet data.
339          */
340         return radcom_read_rec_data(wth->random_fh, pd, length, err);
341 }
342
343 static int
344 radcom_read_rec_header(FILE_T fh, struct radcomrec_hdr *hdr, int *err)
345 {
346         int     bytes_read;
347
348         errno = WTAP_ERR_CANT_READ;
349         bytes_read = file_read(hdr, 1, sizeof *hdr, fh);
350         if (bytes_read != sizeof *hdr) {
351                 *err = file_error(fh);
352                 if (*err != 0)
353                         return -1;
354                 if (bytes_read != 0) {
355                         *err = WTAP_ERR_SHORT_READ;
356                         return -1;
357                 }
358                 return 0;
359         }
360         return 1;
361 }
362
363 static gboolean
364 radcom_read_rec_data(FILE_T fh, u_char *pd, int length, int *err)
365 {
366         int     bytes_read;
367
368         errno = WTAP_ERR_CANT_READ;
369         bytes_read = file_read(pd, 1, length, fh);
370
371         if (bytes_read != length) {
372                 *err = file_error(fh);
373                 if (*err == 0)
374                         *err = WTAP_ERR_SHORT_READ;
375                 return FALSE;
376         }
377         return TRUE;
378 }