64e0a6395c073579e4597ad5062661f7006f3024
[obnox/wireshark/wip.git] / wiretap / cosine.c
1 /* cosine.c
2  *
3  * $Id: cosine.c,v 1.6 2003/11/25 05:58:56 guy Exp $
4  *
5  * CoSine IPNOS L2 debug output parsing
6  * Copyright (c) 2002 by Motonori Shindo <mshindo@mshindo.net>
7  *
8  * Wiretap Library
9  * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29 #include "wtap-int.h"
30 #include "buffer.h"
31 #include "cosine.h"
32 #include "file_wrappers.h"
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <ctype.h>
38
39 /*
40
41   IPNOS: CONFIG VPN(100) VR(1.1.1.1)# diags
42   ipnos diags: Control (1/0) :: layer-2 ?
43   Registered commands for area "layer-2"
44       apply-pkt-log-profile  Configure packet logging on an interface
45       create-pkt-log-profile  Set packet-log-profile to be used for packet logging (see layer-2 pkt-log)
46       detail                Get Layer 2 low-level details
47
48   ipnos diags: Control (1/0) :: layer-2 create ?
49       create-pkt-log-profile  <pkt-log-profile-id ctl-tx-trace-length ctl-rx-trace-length data-tx-trace-length data-rx-trace-length pe-logging-or-control-blade>
50
51   ipnos diags: Control (1/0) :: layer-2 create 1 32 32 0 0 0
52   ipnos diags: Control (1/0) :: layer-2 create 2 32 32 100 100 0
53   ipnos diags: Control (1/0) :: layer-2 apply ?
54       apply-pkt-log-profile  <slot port channel subif pkt-log-profile-id>
55
56   ipnos diags: Control (1/0) :: layer-2 apply 3 0x0701 100 0 1
57   Successfully applied packet-log-profile on LI
58
59   -- Note that only the control packets are logged because the data packet size parameters are 0 in profile 1
60   IPNOS: CONFIG VPN(200) VR(3.3.3.3)# ping 20.20.20.43
61   vpn 200 : [max tries 4, timeout 5 seconds, data length 64 bytes, ttl 255]
62   ping #1 ok, RTT 0.000 seconds
63   ping #2 ok, RTT 0.000 seconds
64   ping #3 ok, RTT 0.000 seconds
65   ping #4 ok, RTT 0.000 seconds
66   [finished]
67
68   IPNOS: CONFIG VPN(200) VR(3.3.3.3)# 2000-2-1,18:19:46.8:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
69
70
71   2000-2-1,18:19:46.8:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x30000]
72
73   2000-2-1,18:19:46.8:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
74
75   2000-2-1,18:19:46.8:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x8030000]
76
77   ipnos diags: Control (1/0) :: layer-2 apply 3 0x0701 100 0 0
78   Successfully applied packet-log-profile on LI
79   ipnos diags: Control (1/0) :: layer-2 apply 3 0x0701 100 0 2
80   Successfully applied packet-log-profile on LI
81
82   -- Note that both control and data packets are logged because the data packet size parameter is 100 in profile 2
83      Please ignore the event-log messages getting mixed up with the ping command
84   ping 20.20.20.43 cou2000-2-1,18:20:17.0:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
85
86           00 D0 D8 D2 FF 03 C0 21  09 29 00 08 6B 60 84 AA
87
88   2000-2-1,18:20:17.0:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x30000]
89           00 D0 D8 D2 FF 03 C0 21  09 29 00 08 6D FE FA AA
90
91   2000-2-1,18:20:17.0:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
92           00 D0 D8 D2 FF 03 C0 21  0A 29 00 08 6B 60 84 AA
93
94   2000-2-1,18:20:17.0:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x8030000]
95           00 D0 D8 D2 FF 03 C0 21  0A 29 00 08 6D FE FA AA
96
97   nt 1 length 500
98   vpn 200 : [max tries 1, timeout 5 seconds, data length 500 bytes, ttl 255]
99   2000-2-1,18:20:24.1:  l2-tx (PPP:3/7/1:100), Length:536, Pro:1, Off:8, Pri:7, RM:0, Err:0 [0x4070, 0x801]
100           00 D0 D8 D2 FF 03 00 21  45 00 02 10 00 27 00 00
101           FF 01 69 51 14 14 14 22  14 14 14 2B 08 00 AD B8
102           00 03 00 01 10 11 12 13  14 15 16 17 18 19 1A 1B
103           1C 1D 1E 1F 20 21 22 23  24 25 26 27 28 29 2A 2B
104           2C 2D 2E 2F 30 31 32 33  34 35 36 37 38 39 3A 3B
105           3C 3D 3E 3F 40 41 42 43  44 45 46 47 48 49 4A 4B
106           4C 4D 4E 4F
107
108   ping #1 ok, RTT 0.010 seconds
109   2000-2-1,18:20:24.1:  l2-rx (PPP:3/7/1:100), Length:536, Pro:1, Off:8, Pri:7, RM:0, Err:0 [0x4071, 0x30801]
110           00 D0 D8 D2 FF 03 00 21  45 00 02 10 00 23 00 00
111           FF 01 69 55 14 14 14 2B  14 14 14 22 00 00 B5 B8
112           00 03 00 01 10 11 12 13  14 15 16 17 18 19 1A 1B
113           1C 1D 1E 1F 20 21 22 23  24 25 26 27 28 29 2A 2B
114           2C 2D 2E 2F 30 31 32 33  34 35 36 37 38 39 3A 3B
115           3C 3D 3E 3F 40 41 42 43  44 45 46 47 48 49 4A 4B
116           4C 4D 4E 4F
117
118   [finished]
119
120   IPNOS: CONFIG VPN(200) VR(3.3.3.3)# 2000-2-1,18:20:27.0:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
121
122           00 D0 D8 D2 FF 03 C0 21  09 2A 00 08 6B 60 84 AA
123
124   2000-2-1,18:20:27.0:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x30000]
125           00 D0 D8 D2 FF 03 C0 21  09 2A 00 08 6D FE FA AA
126
127   2000-2-1,18:20:27.0:  l2-tx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
128           00 D0 D8 D2 FF 03 C0 21  0A 2A 00 08 6B 60 84 AA
129
130   2000-2-1,18:20:27.0:  l2-rx (PPP:3/7/1:100), Length:16, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4001, 0x30000]
131           00 D0 D8 D2 FF 03 C0 21  0A 2A 00 08 6D FE FA AA
132
133
134   ipnos diags: Control (1/0) :: layer-2 apply 3 0x0701 100 0 0
135   Successfully applied packet-log-profile on LI
136   ipnos diags: Control (1/0) ::
137
138  */
139
140 /* XXX TODO:
141
142   o Handle a case where an empty line doesn't exists as a delimiter of
143     each packet. If the output is sent to a control blade and
144     displayed as an event log, there's always an empty line between
145     each packet output, but it may not be true when it is an PE
146     output.
147
148   o Some telnet client on Windows may put in a line break at 80
149     columns when it save the session to a text file ("CRT" is such an
150     example). I don't think it's a good idea for the telnet client to
151     do so, but CRT is widely used in Windows community, I should
152     take care of that in the future.
153
154 */
155
156 /* Magic text to check for CoSine L2 debug output */
157 #define COSINE_HDR_MAGIC_STR1   "l2-tx"
158 #define COSINE_HDR_MAGIC_STR2   "l2-rx"
159
160 /* Magic text for start of packet */
161 #define COSINE_REC_MAGIC_STR1   COSINE_HDR_MAGIC_STR1
162 #define COSINE_REC_MAGIC_STR2   COSINE_HDR_MAGIC_STR2
163
164 #define COSINE_HEADER_LINES_TO_CHECK    200
165 #define COSINE_LINE_LENGTH              240
166
167 #define COSINE_MAX_PACKET_LEN   65536
168
169 static gboolean empty_line(const guchar *line);
170 static long cosine_seek_next_packet(wtap *wth, int *err, char *hdr);
171 static gboolean cosine_check_file_type(wtap *wth, int *err);
172 static gboolean cosine_read(wtap *wth, int *err, long *data_offset);
173 static gboolean cosine_seek_read(wtap *wth, long seek_off,
174         union wtap_pseudo_header *pseudo_header, guint8 *pd,
175         int len, int *err);
176 static int parse_cosine_rec_hdr(wtap *wth, const char *line,
177         union wtap_pseudo_header *pseudo_header, int *err);
178 static int parse_cosine_hex_dump(FILE_T fh, int pkt_len, guint8* buf,
179         int *err);
180 static int parse_single_hex_dump_line(char* rec, guint8 *buf,
181         guint byte_offset);
182
183 /* Returns TRUE if the line appears to be an empty line. Otherwise it
184    returns FALSE. */
185 static gboolean empty_line(const guchar *line)
186 {
187         while (*line) {
188                 if (isspace(*line)) {
189                         line++;
190                         continue;
191                 } else {
192                         break;
193                 }
194         }
195         if (*line == '\0')
196                 return TRUE;
197         else
198                 return FALSE;
199 }
200
201 /* Seeks to the beginning of the next packet, and returns the
202    byte offset. Copy the header line to hdr. Returns -1 on failure,
203    and sets "*err" to the error and set hdr as NULL. */
204 static long cosine_seek_next_packet(wtap *wth, int *err, char *hdr)
205 {
206         long cur_off;
207         char buf[COSINE_LINE_LENGTH];
208
209         while (1) {
210                 cur_off = file_tell(wth->fh);
211                 if (cur_off == -1) {
212                         /* Error */
213                         *err = file_error(wth->fh);
214                         hdr = NULL;
215                         return -1;
216                 }
217                 if (file_gets(buf, sizeof(buf), wth->fh) != NULL) {
218                         if (strstr(buf, COSINE_REC_MAGIC_STR1) ||
219                             strstr(buf, COSINE_REC_MAGIC_STR2)) {
220                                 strncpy(hdr, buf, COSINE_LINE_LENGTH-1);
221                                 hdr[COSINE_LINE_LENGTH-1] = '\0';
222                                 return cur_off;
223                         }
224                 } else {
225                         if (file_eof(wth->fh)) {
226                                 /* We got an EOF. */
227                                 *err = 0;
228                         } else {
229                                 /* We (presumably) got an error (there's no
230                                    equivalent to "ferror()" in zlib, alas,
231                                    so we don't have a wrapper to check for
232                                    an error). */
233                                 *err = file_error(wth->fh);
234                         }
235                         break;
236                 }
237         }
238         hdr = NULL;
239         return -1;
240 }
241
242 /* Look through the first part of a file to see if this is
243  * a CoSine L2 debug output.
244  *
245  * Returns TRUE if it is, FALSE if it isn't or if we get an I/O error;
246  * if we get an I/O error, "*err" will be set to a non-zero value.
247  */
248 static gboolean cosine_check_file_type(wtap *wth, int *err)
249 {
250         char    buf[COSINE_LINE_LENGTH];
251         guint   reclen, line;
252
253         buf[COSINE_LINE_LENGTH-1] = '\0';
254
255         for (line = 0; line < COSINE_HEADER_LINES_TO_CHECK; line++) {
256                 if (file_gets(buf, COSINE_LINE_LENGTH, wth->fh) != NULL) {
257
258                         reclen = strlen(buf);
259                         if (reclen < strlen(COSINE_HDR_MAGIC_STR1) ||
260                                 reclen < strlen(COSINE_HDR_MAGIC_STR2)) {
261                                 continue;
262                         }
263
264                         if (strstr(buf, COSINE_HDR_MAGIC_STR1) ||
265                             strstr(buf, COSINE_HDR_MAGIC_STR2)) {
266                                 return TRUE;
267                         }
268                 } else {
269                         /* EOF or error. */
270                         if (file_eof(wth->fh))
271                                 *err = 0;
272                         else
273                                 *err = file_error(wth->fh);
274                         return FALSE;
275                 }
276         }
277         *err = 0;
278         return FALSE;
279 }
280
281
282 int cosine_open(wtap *wth, int *err)
283 {
284         /* Look for CoSine header */
285         if (!cosine_check_file_type(wth, err)) {
286                 if (*err == 0)
287                         return 0;
288                 else
289                         return -1;
290         }
291
292         if (file_seek(wth->fh, 0L, SEEK_SET, err) == -1)        /* rewind */
293                 return -1;
294
295         wth->data_offset = 0;
296         wth->file_encap = WTAP_ENCAP_COSINE;
297         wth->file_type = WTAP_FILE_COSINE;
298         wth->snapshot_length = 0; /* not known */
299         wth->subtype_read = cosine_read;
300         wth->subtype_seek_read = cosine_seek_read;
301
302         return 1;
303 }
304
305 /* Find the next packet and parse it; called from wtap_loop(). */
306 static gboolean cosine_read(wtap *wth, int *err, long *data_offset)
307 {
308         long    offset;
309         guint8  *buf;
310         int     pkt_len, caplen;
311         char    line[COSINE_LINE_LENGTH];
312
313         /* Find the next packet */
314         offset = cosine_seek_next_packet(wth, err, line);
315         if (offset < 0)
316                 return FALSE;
317
318         /* Parse the header */
319         pkt_len = parse_cosine_rec_hdr(wth, line, &wth->pseudo_header, err);
320         if (pkt_len == -1)
321                 return FALSE;
322
323         /* Make sure we have enough room for the packet */
324         buffer_assure_space(wth->frame_buffer, COSINE_MAX_PACKET_LEN);
325         buf = buffer_start_ptr(wth->frame_buffer);
326
327         /* Convert the ASCII hex dump to binary data */
328         if ((caplen = parse_cosine_hex_dump(wth->fh, pkt_len, buf, err)) == -1)
329                 return FALSE;
330
331         wth->data_offset = offset;
332         wth->phdr.caplen = caplen;
333         *data_offset = offset;
334         return TRUE;
335 }
336
337 /* Used to read packets in random-access fashion */
338 static gboolean
339 cosine_seek_read (wtap *wth, long seek_off,
340         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len, int *err)
341 {
342         char    line[COSINE_LINE_LENGTH];
343
344         if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
345                 return FALSE;
346
347         if (file_gets(line, COSINE_LINE_LENGTH, wth->random_fh) == NULL) {
348                 *err = file_error(wth->random_fh);
349                 if (*err == 0) {
350                         *err = WTAP_ERR_SHORT_READ;
351                 }
352                 return FALSE;
353         }
354
355         if (parse_cosine_rec_hdr(NULL, line, pseudo_header, err) == -1)
356                 return FALSE;
357
358         return parse_cosine_hex_dump(wth->random_fh, len, pd, err);
359 }
360
361 /* Parses a packet record header. There are two possible formats:
362     1) output to a control blade with date and time
363         2002-5-10,20:1:31.4:  l2-tx (FR:3/7/1:1), Length:18, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
364     2) output to PE without date and time
365         l2-tx (FR:3/7/1:1), Length:18, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0] */
366 static int
367 parse_cosine_rec_hdr(wtap *wth, const char *line, union wtap_pseudo_header *pseudo_header, int *err)
368 {
369         int     num_items_scanned;
370         int     yy, mm, dd, hr, min, sec, csec, pkt_len;
371         int     pro, off, pri, rm, error, code1, code2;
372         char    if_name[COSINE_MAX_IF_NAME_LEN], direction[6];
373         struct  tm tm;
374
375         if (sscanf(line, "%d-%d-%d,%d:%d:%d.%d:",
376                    &yy, &mm, &dd, &hr, &min, &sec, &csec) == 7) {
377                 /* appears to be output to a control blade */
378                 num_items_scanned = sscanf(line,
379                    "%d-%d-%d,%d:%d:%d.%d: %5s (%127[A-Za-z0-9/:]), Length:%d, Pro:%d, Off:%d, Pri:%d, RM:%d, Err:%d [%x, %x]",
380                         &yy, &mm, &dd, &hr, &min, &sec, &csec,
381                                    direction, if_name, &pkt_len,
382                                    &pro, &off, &pri, &rm, &error,
383                                    &code1, &code2);
384
385                 if (num_items_scanned != 17) {
386                         *err = WTAP_ERR_BAD_RECORD;
387                         return -1;
388                 }
389         } else {
390                 /* appears to be output to PE */
391                 num_items_scanned = sscanf(line,
392                    "%5s (%127[A-Za-z0-9/:]), Length:%d, Pro:%d, Off:%d, Pri:%d, RM:%d, Err:%d [%x, %x]",
393                                    direction, if_name, &pkt_len,
394                                    &pro, &off, &pri, &rm, &error,
395                                    &code1, &code2);
396
397                 if (num_items_scanned != 10) {
398                         *err = WTAP_ERR_BAD_RECORD;
399                         return -1;
400                 }
401                 yy = mm = dd = hr = min = sec = csec = 0;
402         }
403
404         if (wth) {
405                 tm.tm_year = yy - 1900;
406                 tm.tm_mon = mm - 1;
407                 tm.tm_mday = dd;
408                 tm.tm_hour = hr;
409                 tm.tm_min = min;
410                 tm.tm_sec = sec;
411                 tm.tm_isdst = -1;
412                 wth->phdr.ts.tv_sec = mktime(&tm);
413                 wth->phdr.ts.tv_usec = csec * 10000;
414                 wth->phdr.len = pkt_len;
415                 wth->phdr.pkt_encap = WTAP_ENCAP_COSINE;
416         }
417         /* XXX need to handle other encapsulations like Cisco HDLC,
418            Frame Relay and ATM */
419         if (strncmp(if_name, "TEST:", 5) == 0) {
420                 pseudo_header->cosine.encap = COSINE_ENCAP_TEST;
421         } else if (strncmp(if_name, "PPoATM:", 7) == 0) {
422                 pseudo_header->cosine.encap = COSINE_ENCAP_PPoATM;
423         } else if (strncmp(if_name, "PPoFR:", 6) == 0) {
424                 pseudo_header->cosine.encap = COSINE_ENCAP_PPoFR;
425         } else if (strncmp(if_name, "ATM:", 4) == 0) {
426                 pseudo_header->cosine.encap = COSINE_ENCAP_ATM;
427         } else if (strncmp(if_name, "FR:", 3) == 0) {
428                 pseudo_header->cosine.encap = COSINE_ENCAP_FR;
429         } else if (strncmp(if_name, "HDLC:", 5) == 0) {
430                 pseudo_header->cosine.encap = COSINE_ENCAP_HDLC;
431         } else if (strncmp(if_name, "PPP:", 4) == 0) {
432                 pseudo_header->cosine.encap = COSINE_ENCAP_PPP;
433         } else if (strncmp(if_name, "ETH:", 4) == 0) {
434                 pseudo_header->cosine.encap = COSINE_ENCAP_ETH;
435         } else {
436                 pseudo_header->cosine.encap = COSINE_ENCAP_UNKNOWN;
437         }
438         if (strncmp(direction, "l2-tx", 5) == 0) {
439                 pseudo_header->cosine.direction = COSINE_DIR_TX;
440         } else if (strncmp(direction, "l2-rx", 5) == 0) {
441                 pseudo_header->cosine.direction = COSINE_DIR_RX;
442         }
443         strncpy(pseudo_header->cosine.if_name, if_name,
444                 COSINE_MAX_IF_NAME_LEN - 1);
445         pseudo_header->cosine.pro = pro;
446         pseudo_header->cosine.off = off;
447         pseudo_header->cosine.pri = pri;
448         pseudo_header->cosine.rm = rm;
449         pseudo_header->cosine.err = error;
450
451         return pkt_len;
452 }
453
454 /* Converts ASCII hex dump to binary data. Returns the capture length.
455    If any error is encountered, -1 is returned. */
456 static int
457 parse_cosine_hex_dump(FILE_T fh, int pkt_len, guint8* buf, int *err)
458 {
459         char    line[COSINE_LINE_LENGTH];
460         int     i, hex_lines, n, caplen = 0;
461
462         /* Calculate the number of hex dump lines, each
463          * containing 16 bytes of data */
464         hex_lines = pkt_len / 16 + ((pkt_len % 16) ? 1 : 0);
465
466         for (i = 0; i < hex_lines; i++) {
467                 if (file_gets(line, COSINE_LINE_LENGTH, fh) == NULL) {
468                         *err = file_error(fh);
469                         if (*err == 0) {
470                                 *err = WTAP_ERR_SHORT_READ;
471                         }
472                         return -1;
473                 }
474                 if (empty_line(line)) {
475                         break;
476                 }
477                 if ((n = parse_single_hex_dump_line(line, buf, i*16)) == -1) {
478                         *err = WTAP_ERR_BAD_RECORD;
479                         return -1;
480                 }
481                 caplen += n;
482         }
483         return caplen;
484 }
485
486
487 /* Take a string representing one line from a hex dump and converts
488  * the text to binary data. We place the bytes in the buffer at the
489  * specified offset.
490  *
491  * Returns number of bytes successfully read, -1 if bad.  */
492 static int
493 parse_single_hex_dump_line(char* rec, guint8 *buf, guint byte_offset)
494 {
495         int num_items_scanned, i;
496         unsigned int bytes[16];
497
498         num_items_scanned = sscanf(rec, "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
499                                &bytes[0], &bytes[1], &bytes[2], &bytes[3],
500                                &bytes[4], &bytes[5], &bytes[6], &bytes[7],
501                                &bytes[8], &bytes[9], &bytes[10], &bytes[11],
502                                &bytes[12], &bytes[13], &bytes[14], &bytes[15]);
503         if (num_items_scanned == 0)
504                 return -1;
505
506         if (num_items_scanned > 16)
507                 num_items_scanned = 16;
508
509         for (i=0; i<num_items_scanned; i++) {
510                 buf[byte_offset + i] = (guint8)bytes[i];
511         }
512
513         return num_items_scanned;
514 }