cda21a448aad07fd4c6ee1a070a240da4f746be5
[obnox/wireshark/wip.git] / wiretap / radcom.c
1 /* radcom.c
2  *
3  * $Id: radcom.c,v 1.38 2002/07/29 06:09:59 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, guchar *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, guchar *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, err) == -1)
105                 return -1;
106         wth->data_offset = 0x8B;
107         errno = WTAP_ERR_CANT_READ;
108         bytes_read = file_read(&byte, 1, 1, wth->fh);
109         if (bytes_read != 1) {
110                 *err = file_error(wth->fh);
111                 if (*err != 0)
112                         return -1;
113                 return 0;
114         }
115         wth->data_offset += 1;
116         while (byte) {
117                 errno = WTAP_ERR_CANT_READ;
118                 bytes_read = file_read(&byte, 1, 1, wth->fh);
119                 if (bytes_read != 1) {
120                         *err = file_error(wth->fh);
121                         if (*err != 0)
122                                 return -1;
123                         return 0;
124                 }
125                 wth->data_offset += 1;
126         }
127
128         /* Get capture start time */
129         errno = WTAP_ERR_CANT_READ;
130         bytes_read = file_read(&start_date, 1, sizeof(struct frame_date), wth->fh);
131         if (bytes_read != sizeof(struct frame_date)) {
132                 *err = file_error(wth->fh);
133                 if (*err != 0)
134                         return -1;
135                 return 0;
136         }
137         wth->data_offset += sizeof(struct frame_date);
138
139         /* This is a radcom file */
140         wth->file_type = WTAP_FILE_RADCOM;
141         wth->subtype_read = radcom_read;
142         wth->subtype_seek_read = radcom_seek_read;
143         wth->snapshot_length = 0;       /* not available in header, only in frame */
144
145         tm.tm_year = pletohs(&start_date.year)-1900;
146         tm.tm_mon = start_date.month-1;
147         tm.tm_mday = start_date.day;
148         sec = pletohl(&start_date.sec);
149         tm.tm_hour = sec/3600;
150         tm.tm_min = (sec%3600)/60;
151         tm.tm_sec = sec%60;
152         tm.tm_isdst = -1;
153
154         if (file_seek(wth->fh, sizeof(struct frame_date), SEEK_CUR, err) == -1)
155                 return -1;
156         wth->data_offset += sizeof(struct frame_date);
157
158         errno = WTAP_ERR_CANT_READ;
159         bytes_read = file_read(search_encap, 1, 4, wth->fh);
160         if (bytes_read != 4) {
161                 goto read_error;
162         }
163         wth->data_offset += 4;
164         while (memcmp(encap_magic, search_encap, 4)) {
165                 if (file_seek(wth->fh, -3, SEEK_CUR, err) == -1)
166                         return -1;
167                 wth->data_offset -= 3;
168                 errno = WTAP_ERR_CANT_READ;
169                 bytes_read = file_read(search_encap, 1, 4, wth->fh);
170                 if (bytes_read != 4) {
171                         goto read_error;
172                 }
173                 wth->data_offset += 4;
174         }
175         if (file_seek(wth->fh, 12, SEEK_CUR, err) == -1)
176                 return -1;
177         wth->data_offset += 12;
178         errno = WTAP_ERR_CANT_READ;
179         bytes_read = file_read(search_encap, 1, 4, wth->fh);
180         if (bytes_read != 4) {
181                 goto read_error;
182         }
183         wth->data_offset += 4;
184         if (!memcmp(search_encap, "LAPB", 4))
185                 wth->file_encap = WTAP_ENCAP_LAPB;
186         else if (!memcmp(search_encap, "Ethe", 4))
187                 wth->file_encap = WTAP_ENCAP_ETHERNET;
188         else {
189                 g_message("pcap: network type \"%.4s\" unknown", search_encap);
190                 *err = WTAP_ERR_UNSUPPORTED_ENCAP;
191                 return -1;
192         }
193
194         /*bytes_read = file_read(&next_date, 1, sizeof(struct frame_date), wth->fh);
195         errno = WTAP_ERR_CANT_READ;
196         if (bytes_read != sizeof(struct frame_date)) {
197                 goto read_error;
198         }
199
200         while (memcmp(&start_date, &next_date, 4)) {
201                 if (file_seek(wth->fh, 1-sizeof(struct frame_date), SEEK_CUR, err) == -1)
202                         return -1;
203                 errno = WTAP_ERR_CANT_READ;
204                 bytes_read = file_read(&next_date, 1, sizeof(struct frame_date),
205                                    wth->fh);
206                 if (bytes_read != sizeof(struct frame_date)) {
207                         goto read_error;
208                 }
209         }*/
210
211         if (wth->file_encap == WTAP_ENCAP_ETHERNET) {
212                 if (file_seek(wth->fh, 294, SEEK_CUR, err) == -1)
213                         return -1;
214                 wth->data_offset += 294;
215         } else if (wth->file_encap == WTAP_ENCAP_LAPB) {
216                 if (file_seek(wth->fh, 297, SEEK_CUR, err) == -1)
217                         return -1;
218                 wth->data_offset += 297;
219         }
220
221         return 1;
222
223 read_error:
224         *err = file_error(wth->fh);
225         if (*err != 0)
226                 return -1;
227         return 0;
228 }
229
230 /* Read the next packet */
231 static gboolean radcom_read(wtap *wth, int *err, long *data_offset)
232 {
233         int     ret;
234         struct radcomrec_hdr hdr;
235         guint16 length;
236         guint32 sec;
237         int     bytes_read;
238         struct tm tm;
239         char    fcs[2];
240
241         /* Read record header. */
242         *data_offset = wth->data_offset;
243         ret = radcom_read_rec_header(wth->fh, &hdr, err);
244         if (ret <= 0) {
245                 /* Read error or EOF */
246                 return FALSE;
247         }
248         wth->data_offset += sizeof hdr;
249         length = pletohs(&hdr.length);
250         if (length == 0) return FALSE;
251
252         if (wth->file_encap == WTAP_ENCAP_LAPB)
253                 length -= 2; /* FCS */
254
255         wth->phdr.len = length;
256         wth->phdr.caplen = length;
257
258         tm.tm_year = pletohs(&hdr.date.year)-1900;
259         tm.tm_mon = hdr.date.month-1;
260         tm.tm_mday = hdr.date.day;
261         sec = pletohl(&hdr.date.sec);
262         tm.tm_hour = sec/3600;
263         tm.tm_min = (sec%3600)/60;
264         tm.tm_sec = sec%60;
265         tm.tm_isdst = -1;
266         wth->phdr.ts.tv_sec = mktime(&tm);
267         wth->phdr.ts.tv_usec = pletohl(&hdr.date.usec);
268         wth->pseudo_header.x25.flags = (hdr.dce & 0x1) ? 0x00 : FROM_DCE;
269
270         /*
271          * Read the packet data.
272          */
273         buffer_assure_space(wth->frame_buffer, length);
274         if (!radcom_read_rec_data(wth->fh,
275             buffer_start_ptr(wth->frame_buffer), length, err))
276                 return FALSE;   /* Read error */
277         wth->data_offset += length;
278
279         wth->phdr.pkt_encap = wth->file_encap;
280
281         if (wth->file_encap == WTAP_ENCAP_LAPB) {
282                 /* Read the FCS.
283                    XXX - should we put it in the pseudo-header? */
284                 errno = WTAP_ERR_CANT_READ;
285                 bytes_read = file_read(&fcs, 1, sizeof fcs, wth->fh);
286                 if (bytes_read != sizeof fcs) {
287                         *err = file_error(wth->fh);
288                         if (*err == 0)
289                                 *err = WTAP_ERR_SHORT_READ;
290                         return FALSE;
291                 }
292                 wth->data_offset += sizeof fcs;
293         }
294
295         return TRUE;
296 }
297
298 static gboolean
299 radcom_seek_read(wtap *wth, long seek_off,
300     union wtap_pseudo_header *pseudo_header, guchar *pd, int length, int *err)
301 {
302         int     ret;
303         struct radcomrec_hdr hdr;
304
305         if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
306                 return FALSE;
307
308         /* Read record header. */
309         ret = radcom_read_rec_header(wth->random_fh, &hdr, err);
310         if (ret <= 0) {
311                 /* Read error or EOF */
312                 if (ret == 0) {
313                         /* EOF means "short read" in random-access mode */
314                         *err = WTAP_ERR_SHORT_READ;
315                 }
316                 return FALSE;
317         }
318
319         pseudo_header->x25.flags = (hdr.dce & 0x1) ? 0x00 : FROM_DCE;
320
321         /*
322          * Read the packet data.
323          */
324         return radcom_read_rec_data(wth->random_fh, pd, length, err);
325 }
326
327 static int
328 radcom_read_rec_header(FILE_T fh, struct radcomrec_hdr *hdr, int *err)
329 {
330         int     bytes_read;
331
332         errno = WTAP_ERR_CANT_READ;
333         bytes_read = file_read(hdr, 1, sizeof *hdr, fh);
334         if (bytes_read != sizeof *hdr) {
335                 *err = file_error(fh);
336                 if (*err != 0)
337                         return -1;
338                 if (bytes_read != 0) {
339                         *err = WTAP_ERR_SHORT_READ;
340                         return -1;
341                 }
342                 return 0;
343         }
344         return 1;
345 }
346
347 static gboolean
348 radcom_read_rec_data(FILE_T fh, guchar *pd, int length, int *err)
349 {
350         int     bytes_read;
351
352         errno = WTAP_ERR_CANT_READ;
353         bytes_read = file_read(pd, 1, length, fh);
354
355         if (bytes_read != length) {
356                 *err = file_error(fh);
357                 if (*err == 0)
358                         *err = WTAP_ERR_SHORT_READ;
359                 return FALSE;
360         }
361         return TRUE;
362 }