Removed trailing whitespaces from .h and .c files using the
[obnox/wireshark/wip.git] / wiretap / ascend.c
1 /* ascend.c
2  *
3  * $Id: ascend.c,v 1.31 2002/08/28 20:30:44 jmayer 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 "ascend.h"
29 #include "ascend-int.h"
30 #include "file_wrappers.h"
31
32 #include <errno.h>
33
34 #ifdef HAVE_SYS_STAT_H
35 #include <sys/stat.h>
36 #endif
37
38 #ifdef HAVE_UNISTD_H
39 #include <unistd.h>
40 #endif
41
42 #include <ctype.h>
43 #include <string.h>
44
45 /* This module reads the output of the 'wandsession', 'wannext',
46    'wandisplay', and similar commands available on Lucent/Ascend access
47    equipment.  The output is text, with a header line followed by the
48    packet data.  Usage instructions for the commands can be found by
49    searching http://aos.ascend.com .  Ascend likes to move their pages
50    around quite a bit, otherwise I'd put a more specific URL here.
51
52    Example 'wandsess' output data:
53
54 RECV-iguana:241:(task: B02614C0, time: 1975432.85) 49 octets @ 8003BD94
55   [0000]: FF 03 00 3D C0 06 CA 22 2F 45 00 00 28 6A 3B 40
56   [0010]: 00 3F 03 D7 37 CE 41 62 12 CF 00 FB 08 20 27 00
57   [0020]: 50 E4 08 DD D7 7C 4C 71 92 50 10 7D 78 67 C8 00
58   [0030]: 00
59 XMIT-iguana:241:(task: B04E12C0, time: 1975432.85) 53 octets @ 8009EB16
60   [0000]: FF 03 00 3D C0 09 1E 31 21 45 00 00 2C 2D BD 40
61   [0010]: 00 7A 06 D8 B1 CF 00 FB 08 CE 41 62 12 00 50 20
62   [0020]: 29 7C 4C 71 9C 9A 6A 93 A4 60 12 22 38 3F 10 00
63   [0030]: 00 02 04 05 B4
64
65     Example 'wdd' output data:
66
67 Date: 01/12/1990.  Time: 12:22:33
68 Cause an attempt to place call to 14082750382
69 WD_DIALOUT_DISP: chunk 2515EE type IP.
70 (task: 251790, time: 994953.28) 44 octets @ 2782B8
71   [0000]: 00 C0 7B 71 45 6C 00 60 08 16 AA 51 08 00 45 00
72   [0010]: 00 2C 66 1C 40 00 80 06 53 F6 AC 14 00 18 CC 47
73   [0020]: C8 45 0A 31 00 50 3B D9 5B 75 00 00
74
75     (note that the capture whence this came dates back to January
76     *1999*; I presume that either the person who sent it to me
77     hadn't bothered keeping its internal clock set, or that its
78     internal clock or the date it displays in those messages
79     is only loosely connected to reality)
80
81   Note that a maximum of eight rows will be displayed (for a maximum of
82   128 bytes), no matter what the octet count is.
83
84   When reading a packet, the module prepends an ascend_pkt_hdr to the
85   data.
86
87  */
88
89 /* How far into the file we should look for packet headers */
90 #define ASCEND_MAX_SEEK 100000
91
92 /* XXX  Should we replace this with a more generalized array? */
93 /* Magic numbers for Ascend wandsession/wanopening/ether-display data */
94 static const char ascend_xmagic[]  = { 'X', 'M', 'I', 'T', '-' };
95 static const char ascend_rmagic[]  = { 'R', 'E', 'C', 'V', '-' };
96 static const char ascend_w1magic[] = { 'D', 'a', 't', 'e', ':',  };
97 static const char ascend_w2magic[] = { 'W', 'D', '_', 'D', 'I', 'A', 'L', 'O', 'U', 'T', '_', 'D', 'I', 'S', 'P', ':' };
98
99 #define ASCEND_X_SIZE  (sizeof ascend_xmagic  / sizeof ascend_xmagic[0])
100 #define ASCEND_R_SIZE  (sizeof ascend_rmagic  / sizeof ascend_rmagic[0])
101 #define ASCEND_W1_SIZE (sizeof ascend_w1magic / sizeof ascend_w1magic[0])
102 #define ASCEND_W2_SIZE (sizeof ascend_w2magic / sizeof ascend_w2magic[0])
103
104 static gboolean ascend_read(wtap *wth, int *err, long *data_offset);
105 static gboolean ascend_seek_read (wtap *wth, long seek_off,
106         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len, int *err);
107 static void ascend_close(wtap *wth);
108
109 /* Seeks to the beginning of the next packet, and returns the
110    byte offset at which the heade for that packet begins.
111    Returns -1 on failure.
112
113    If it finds a packet, then, if "wth->capture.ascend" is non-null,
114    it sets "wth->capture.ascend->next_packet_seek_start" to the point
115    at which the seek pointer should be set before this routine is called
116    to find the packet *after* the packet it finds. */
117 static long ascend_seek(wtap *wth, int max_seek, int *err)
118 {
119   int byte, bytes_read = 0;
120   long date_off = -1, cur_off, packet_off;
121   unsigned int r_level = 0, x_level = 0, w1_level = 0, w2_level = 0;
122
123   while (((byte = file_getc(wth->fh)) != EOF) && bytes_read < max_seek) {
124     if (byte == ascend_xmagic[x_level]) {
125       x_level++;
126       if (x_level >= ASCEND_X_SIZE) {
127         /* At what offset are we now? */
128         cur_off = file_tell(wth->fh);
129         if (cur_off == -1) {
130           /* Error. */
131           *err = file_error(wth->fh);
132           return -1;
133         }
134
135         /* Back up over the header we just read; that's where a read
136            of this packet should start. */
137         packet_off = cur_off - ASCEND_X_SIZE;
138         goto found;
139       }
140     } else {
141       x_level = 0;
142     }
143     if (byte == ascend_rmagic[r_level]) {
144       r_level++;
145       if (r_level >= ASCEND_R_SIZE) {
146         /* At what offset are we now? */
147         cur_off = file_tell(wth->fh);
148         if (cur_off == -1) {
149           /* Error. */
150           *err = file_error(wth->fh);
151           return -1;
152         }
153
154         /* Back up over the header we just read; that's where a read
155            of this packet should start. */
156         packet_off = cur_off - ASCEND_R_SIZE;
157         goto found;
158       }
159     } else {
160       r_level = 0;
161     }
162     if (byte == ascend_w1magic[w1_level]) {
163       w1_level++;
164       if (w1_level >= ASCEND_W1_SIZE) {
165         /* Get the offset at which the "Date:" header started. */
166         cur_off = file_tell(wth->fh);
167         if (cur_off == -1) {
168           /* Error. */
169           *err = file_error(wth->fh);
170           return -1;
171         }
172
173         date_off = cur_off - ASCEND_W1_SIZE;
174       }
175     } else {
176       w1_level = 0;
177     }
178     if (byte == ascend_w2magic[w2_level]) {
179       w2_level++;
180       if (w2_level >= ASCEND_W2_SIZE) {
181         /* At what offset are we now? */
182         cur_off = file_tell(wth->fh);
183         if (cur_off == -1) {
184           /* Error. */
185           *err = file_error(wth->fh);
186           return -1;
187         }
188
189         if (date_off != -1) {
190           /* This packet has a date/time header; a read of it should
191              start at the beginning of *that* header. */
192           packet_off = date_off;
193         } else {
194           /* This packet has only a per-packet header.
195              Back up over that header, which we just read; that's where
196              a read of this packet should start. */
197           packet_off = cur_off - ASCEND_W2_SIZE;
198         }
199         goto found;
200       }
201     } else {
202       w2_level = 0;
203     }
204     bytes_read++;
205   }
206   if (byte != EOF || file_eof(wth->fh)) {
207     /* Either we didn't find the offset, or we got an EOF. */
208     *err = 0;
209   } else {
210     /* We (presumably) got an error (there's no equivalent to "ferror()"
211        in zlib, alas, so we don't have a wrapper to check for an error). */
212     *err = file_error(wth->fh);
213   }
214   return -1;
215
216 found:
217   /*
218    * The search for the packet after this one should start right
219    * after the header for this packet.  (Ideally, it should
220    * start after the *data* for this one, but we haven't
221    * read that yet.)
222    */
223   if (wth->capture.ascend != NULL)
224     wth->capture.ascend->next_packet_seek_start = cur_off + 1;
225
226   /*
227    * Move to where the read for this packet should start, and return
228    * that seek offset.
229    */
230   if (file_seek(wth->fh, packet_off, SEEK_SET, err) == -1)
231     return -1;
232   return packet_off;
233 }
234
235 int ascend_open(wtap *wth, int *err)
236 {
237   long offset;
238   struct stat statbuf;
239
240   /* We haven't yet allocated a data structure for our private stuff;
241      set the pointer to null, so that "ascend_seek()" knows not to
242      fill it in. */
243   wth->capture.ascend = NULL;
244
245   offset = ascend_seek(wth, ASCEND_MAX_SEEK, err);
246   if (offset == -1) {
247     if (*err == 0)
248       return 0;
249     else
250       return -1;
251   }
252
253   wth->data_offset = offset;
254   wth->file_encap = WTAP_ENCAP_ASCEND;
255   wth->file_type = WTAP_FILE_ASCEND;
256   wth->snapshot_length = ASCEND_MAX_PKT_LEN;
257   wth->subtype_read = ascend_read;
258   wth->subtype_seek_read = ascend_seek_read;
259   wth->subtype_close = ascend_close;
260   wth->capture.ascend = g_malloc(sizeof(ascend_t));
261
262   /* The first packet we want to read is the one that "ascend_seek()"
263      just found; start searching for it at the offset at which it
264      found it. */
265   wth->capture.ascend->next_packet_seek_start = offset;
266
267   /* MAXen and Pipelines report the time since reboot.  In order to keep
268      from reporting packet times near the epoch, we subtract the first
269      packet's timestamp from the capture file's ctime, which gives us an
270      offset that we can apply to each packet.
271    */
272   if (fstat(wtap_fd(wth), &statbuf) == -1) {
273     *err = errno;
274     g_free(wth->capture.ascend);
275     return -1;
276   }
277   wth->capture.ascend->inittime = statbuf.st_ctime;
278   wth->capture.ascend->adjusted = 0;
279
280   init_parse_ascend();
281
282   return 1;
283 }
284
285 /* Read the next packet; called from wtap_loop(). */
286 static gboolean ascend_read(wtap *wth, int *err, long *data_offset)
287 {
288   long offset;
289   guint8 *buf = buffer_start_ptr(wth->frame_buffer);
290   ascend_pkthdr header;
291
292   /* (f)lex reads large chunks of the file into memory, so file_tell() doesn't
293      give us the correct location of the packet.  Instead, we seek to the
294      offset after the header of the previous packet and try to find the next
295      packet.  */
296   if (file_seek(wth->fh, wth->capture.ascend->next_packet_seek_start,
297                 SEEK_SET, err) == -1)
298     return FALSE;
299   offset = ascend_seek(wth, ASCEND_MAX_SEEK, err);
300   if (offset == -1)
301     return FALSE;
302   if (! parse_ascend(wth->fh, buf, &wth->pseudo_header.ascend, &header, 0)) {
303     *err = WTAP_ERR_BAD_RECORD;
304     return FALSE;
305   }
306
307   buffer_assure_space(wth->frame_buffer, wth->snapshot_length);
308
309   if (! wth->capture.ascend->adjusted) {
310     wth->capture.ascend->adjusted = 1;
311     if (header.start_time != 0) {
312       /*
313        * Capture file contained a date and time.
314        * We do this only if this is the very first packet we've seen -
315        * i.e., if "wth->capture.ascend->adjusted" is false - because
316        * if we get a date and time after the first packet, we can't
317        * go back and adjust the time stamps of the packets we've already
318        * processed, and basing the time stamps of this and following
319        * packets on the time stamp from the file text rather than the
320        * ctime of the capture file means times before this and after
321        * this can't be compared.
322        */
323       wth->capture.ascend->inittime = header.start_time;
324     }
325     if (wth->capture.ascend->inittime > header.secs)
326       wth->capture.ascend->inittime -= header.secs;
327   }
328   wth->phdr.ts.tv_sec = header.secs + wth->capture.ascend->inittime;
329   wth->phdr.ts.tv_usec = header.usecs;
330   wth->phdr.caplen = header.caplen;
331   wth->phdr.len = header.len;
332   wth->phdr.pkt_encap = wth->file_encap;
333   wth->data_offset = offset;
334
335   *data_offset = offset;
336   return TRUE;
337 }
338
339 static gboolean ascend_seek_read (wtap *wth, long seek_off,
340         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len, int *err)
341 {
342   if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
343     return FALSE;
344   if (! parse_ascend(wth->random_fh, pd, &pseudo_header->ascend, NULL, len)) {
345     *err = WTAP_ERR_BAD_RECORD;
346     return FALSE;
347   }
348   return TRUE;
349 }
350
351 static void ascend_close(wtap *wth)
352 {
353   g_free(wth->capture.ascend);
354 }