Fix all fixable warnings
[obnox/wireshark/wip.git] / wiretap / vms.c
1 /* vms.c
2  *
3  * $Id: vms.c,v 1.20 2004/01/24 16:48:12 jmayer Exp $
4  *
5  * Wiretap Library
6  * Copyright (c) 2001 by Marc Milgram <ethereal@mmilgram.NOSPAMmail.net>
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 /* Notes:
24  *   TCPIPtrace TCP fragments don't have the header line.  So, we are never
25  *   to look for that line for the first line of a packet except the first
26  *   packet.  This allows us to read fragmented packets.  Define
27  *   TCPIPTRACE_FRAGMENTS_HAVE_HEADER_LINE to expect the first line to be
28  *   at the start of every packet.
29  */
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33 #include "wtap-int.h"
34 #include "buffer.h"
35 #include "vms.h"
36 #include "file_wrappers.h"
37
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <ctype.h>
42
43 /* This module reads the output of the various VMS TCPIP trace utilities
44  * such as TCPIPTRACE, TCPTRACE and UCX$TRACE
45  *
46  * It was initially based on toshiba.c and refined with code from cosine.c
47
48 --------------------------------------------------------------------------------
49    Example TCPIPTRACE TCPTRACE output data:
50
51    TCPIPtrace full display RCV packet 8 at 10-JUL-2001 14:54:19.56
52
53    IP Version = 4,  IHL = 5,  TOS = 00,   Total Length = 84 = ^x0054
54    IP Identifier  = ^x178F,  Flags (0=0,DF=0,MF=0),
55          Fragment Offset = 0 = ^x0000,   Calculated Offset = 0 = ^x0000
56    IP TTL = 64 = ^x40,  Protocol = 17 = ^x11,  Header Checksum = ^x4C71
57    IP Source Address      = 10.12.1.80
58    IP Destination Address = 10.12.1.50
59
60    UDP Source Port = 731,   UDP Destination Port = 111
61    UDP Header and Datagram Length = 64 = ^x0040,   Checksum = ^xB6C0
62
63    50010C0A   714C1140   00008F17   54000045    0000    E..T....@.Lq...P
64    27E54C3C | C0B64000   6F00DB02 | 32010C0A    0010    ...2...o.@..<L.'
65    02000000   A0860100   02000000   00000000    0020    ................
66    00000000   00000000   00000000   03000000    0030    ................
67    06000000   01000000   A5860100   00000000    0040    ................
68                                     00000000    0050    ....
69 --------------------------------------------------------------------------------
70
71    Example UCX$TRACE output data:
72
73     UCX INTERnet trace RCV packet seq # = 1 at 14-MAY-2003 11:32:10.93 
74
75    IP Version = 4,  IHL = 5,  TOS = 00,   Total Length = 583 = ^x0247 
76    IP Identifier  = ^x702E,  Flags (0=0,DF=0,MF=0),  
77          Fragment Offset = 0 = ^x0000,   Calculated Offset = 0 = ^x0000 
78    IP TTL = 128 = ^x80,  Protocol = 17 = ^x11,  Header Checksum = ^x70EC 
79    IP Source Address      = 10.20.4.159 
80    IP Destination Address = 10.20.4.255 
81
82    UDP Source Port = 138,   UDP Destination Port = 138 
83    UDP Header and Datagram Length = 563 = ^x0233,   Checksum = ^xB913 
84
85    9F04140A   70EC1180   0000702E   47020045    0000    E..G.p.....p....
86    B1B80E11 | B9133302   8A008A00 | FF04140A    0010    .........3......
87    46484648   45200000   1D028A00   9F04140A    0020    ...........EHFHF
88    43414341   4341434D   454D4546   45454550    0030    PEEEFEMEMCACACAC
89
90 --------------------------------------------------------------------------------
91
92    Alternate UCX$TRACE type output data:
93
94    TCPIP INTERnet trace RCV packet seq # = 1 at 23-OCT-1998 15:19:33.29
95
96    IP Version = 4,  IHL = 5,  TOS = 00,   Total Length = 217 = ^x00D9
97    IP Identifier  = ^x0065,  Flags (0=0,DF=0,MF=0),
98          Fragment Offset = 0 = ^x0000,   Calculated Offset = 0 = ^x0000
99    IP TTL = 32 = ^x20,  Protocol = 17 = ^x11,  Header Checksum = ^x8F6C
100    IP Source Address      = 16.20.168.93
101    IP Destination Address = 16.20.255.255
102
103    UDP Source Port = 138,   UDP Destination Port = 138
104    UDP Header and Datagram Length = 197 = ^x00C5,   Checksum = ^x0E77
105
106    5DA81410   8F6C1120   00000065   D9000045    0000    E...awe.....l....]
107             | 0E77C500   8A008A00 | FFFF1410    0010    ..........w.
108
109 --------------------------------------------------------------------------------
110
111 The only difference between the utilities is the Packet header line, primarily
112 the utility identifier and the packet sequence formats.
113
114 There appear to be 2 formats for packet seqencing
115
116 Format 1:
117
118  ... packet nn at DD-MMM-YYYY hh:mm:ss.ss
119
120 Format 2:
121
122  ... packet seq # = nn at DD-MMM-YYYY hh:mm:ss.ss
123
124 If there are other formats then code will have to be written in parse_vms_rec_hdr()
125 to handle them.
126
127 --------------------------------------------------------------------------------
128
129  */
130
131 /* Magic text to check for VMS-ness of file using possible utility names
132  *
133  */
134 #define VMS_HDR_MAGIC_STR1      "TCPIPtrace"
135 #define VMS_HDR_MAGIC_STR2      "TCPtrace"
136 #define VMS_HDR_MAGIC_STR3      "INTERnet trace"
137
138 /* Magic text for start of packet */
139 #define VMS_REC_MAGIC_STR1      VMS_HDR_MAGIC_STR1
140 #define VMS_REC_MAGIC_STR2      VMS_HDR_MAGIC_STR2
141 #define VMS_REC_MAGIC_STR3      VMS_HDR_MAGIC_STR3
142
143 #define VMS_HEADER_LINES_TO_CHECK    200
144 #define VMS_LINE_LENGTH              240
145
146 static gboolean vms_read(wtap *wth, int *err, long *data_offset);
147 static gboolean vms_seek_read(wtap *wth, long seek_off,
148     union wtap_pseudo_header *pseudo_header, guint8 *pd, int len, int *err);
149 static gboolean parse_single_hex_dump_line(char* rec, guint8 *buf,
150     long byte_offset, int in_off, int remaining_bytes);
151 static gboolean parse_vms_hex_dump(FILE_T fh, int pkt_len, guint8* buf,
152     int *err);
153 static int parse_vms_rec_hdr(wtap *wth, FILE_T fh, int *err);
154
155 #ifdef TCPIPTRACE_FRAGMENTS_HAVE_HEADER_LINE
156 /* Seeks to the beginning of the next packet, and returns the
157    byte offset.  Returns -1 on failure, and sets "*err" to the error. */
158 static long vms_seek_next_packet(wtap *wth, int *err)
159 {
160   long cur_off;
161   char buf[VMS_LINE_LENGTH];
162   
163   while (1) {
164     cur_off = file_tell(wth->fh);
165     if (cur_off == -1) {
166       /* Error */
167       *err = file_error(wth->fh);
168       hdr = NULL;
169       return -1;
170     }
171     if (file_gets(buf, sizeof(buf), wth->fh) != NULL) {
172       if (strstr(buf, VMS_REC_MAGIC_STR1) ||
173           strstr(buf, VMS_REC_MAGIC_STR2) ||
174           strstr(buf, VMS_REC_MAGIC_STR2)) {
175         strncpy(hdr, buf, VMS_LINE_LENGTH-1);
176         hdr[VMS_LINE_LENGTH-1] = '\0';
177         return cur_off;
178       }
179     } else {
180       if (file_eof(wth->fh)) {
181         /* We got an EOF. */
182         *err = 0;
183       } else {
184         /* We (presumably) got an error (there's no
185            equivalent to "ferror()" in zlib, alas,
186            so we don't have a wrapper to check for
187            an error). */
188         *err = file_error(wth->fh);
189       }
190       break;
191     }
192   }
193   hdr = NULL;
194   return -1;
195 }
196 #endif /* TCPIPTRACE_FRAGMENTS_HAVE_HEADER_LINE */
197
198 /* Look through the first part of a file to see if this is
199  * a VMS trace file.
200  *
201  * Returns TRUE if it is, FALSE if it isn't or if we get an I/O error;
202  * if we get an I/O error, "*err" will be set to a non-zero value.
203  *
204  * Leaves file handle at begining of line that contains the VMS Magic
205  * identifier.
206  */
207 static gboolean vms_check_file_type(wtap *wth, int *err)
208 {
209   char  buf[VMS_LINE_LENGTH];
210   guint reclen, line;
211   long mpos;
212   
213   buf[VMS_LINE_LENGTH-1] = '\0';
214   
215   for (line = 0; line < VMS_HEADER_LINES_TO_CHECK; line++) {
216     mpos = file_tell(wth->fh);
217     if (mpos == -1) {
218       /* Error. */
219       *err = file_error(wth->fh);
220       return FALSE;
221     }
222     if (file_gets(buf, VMS_LINE_LENGTH, wth->fh) != NULL) {
223       
224       reclen = strlen(buf);
225       if (reclen < strlen(VMS_HDR_MAGIC_STR1) ||
226           reclen < strlen(VMS_HDR_MAGIC_STR2) || 
227           reclen < strlen(VMS_HDR_MAGIC_STR3)) {
228         continue;
229       }
230       
231       if (strstr(buf, VMS_HDR_MAGIC_STR1) ||
232           strstr(buf, VMS_HDR_MAGIC_STR2) ||
233           strstr(buf, VMS_HDR_MAGIC_STR3)) {
234         /* Go back to the beginning of this line, so we will
235          * re-read it. */
236         if (file_seek(wth->fh, mpos, SEEK_SET, err) == -1) {
237           /* Error. */
238           return FALSE;
239         }
240         return TRUE;
241       }
242     } else {
243       /* EOF or error. */
244       if (file_eof(wth->fh))
245         *err = 0;
246       else
247         *err = file_error(wth->fh);
248       return FALSE;
249     }
250   }
251   *err = 0;
252   return FALSE;
253 }
254
255
256 int vms_open(wtap *wth, int *err)
257 {
258     /* Look for VMS header */
259     if (!vms_check_file_type(wth, err)) {
260         if (*err == 0)
261             return 0;
262         else
263             return -1;
264     }
265
266     wth->data_offset = 0;
267     wth->file_encap = WTAP_ENCAP_RAW_IP;
268     wth->file_type = WTAP_FILE_VMS;
269     wth->snapshot_length = 0; /* not known */
270     wth->subtype_read = vms_read;
271     wth->subtype_seek_read = vms_seek_read;
272
273     return 1;
274 }
275
276 /* Find the next packet and parse it; called from wtap_loop(). */
277 static gboolean vms_read(wtap *wth, int *err, long *data_offset)
278 {
279     long   offset = 0;
280     guint8    *buf;
281     int    pkt_len;
282
283     /* Find the next packet */
284 #ifdef TCPIPTRACE_FRAGMENTS_HAVE_HEADER_LINE
285     offset = vms_seek_next_packet(wth, err);
286 #else
287     offset = file_tell(wth->fh);
288 #endif
289     if (offset < 1)
290         return FALSE;
291
292     /* Parse the header */
293     pkt_len = parse_vms_rec_hdr(wth, wth->fh, err);
294     if (pkt_len == -1)
295         return FALSE;
296
297     /* Make sure we have enough room for the packet */
298     buffer_assure_space(wth->frame_buffer, pkt_len);
299     buf = buffer_start_ptr(wth->frame_buffer);
300
301     /* Convert the ASCII hex dump to binary data */
302     if (!parse_vms_hex_dump(wth->fh, pkt_len, buf, err))
303         return FALSE;
304
305     wth->data_offset = offset;
306     *data_offset = offset;
307     return TRUE;
308 }
309
310 /* Used to read packets in random-access fashion */
311 static gboolean
312 vms_seek_read (wtap *wth, long seek_off,
313     union wtap_pseudo_header *pseudo_header _U_,
314     guint8 *pd, int len, int *err)
315 {
316     int    pkt_len;
317
318     if (file_seek(wth->random_fh, seek_off - 1, SEEK_SET, err) == -1)
319         return FALSE;
320
321     pkt_len = parse_vms_rec_hdr(NULL, wth->random_fh, err);
322
323     if (pkt_len != len) {
324         if (pkt_len != -1)
325             *err = WTAP_ERR_BAD_RECORD;
326         return FALSE;
327     }
328
329     return parse_vms_hex_dump(wth->random_fh, pkt_len, pd, err);
330 }
331
332 /* isdumpline assumes that dump lines start with some non-alphanumerics
333  * followed by 4 hex numbers - each 8 digits long, each hex number followed
334  * by 3 spaces.
335  */
336 static int
337 isdumpline( gchar *line )
338 {
339     int i, j;
340
341     while (*line && !isalnum(*line))
342         line++;
343
344     for (j=0; j<4; j++) {
345         for (i=0; i<8; i++, line++)
346             if (! isxdigit(*line))
347                 return FALSE;
348
349         for (i=0; i<3; i++, line++)
350             if (*line != ' ')
351                 return FALSE;
352     }
353
354     return isspace(*line);
355 }
356
357 /* Parses a packet record header. */
358 static int
359 parse_vms_rec_hdr(wtap *wth, FILE_T fh, int *err)
360 {
361     char   line[VMS_LINE_LENGTH + 1];
362     int    num_items_scanned;
363     int    pkt_len = 0;
364     int    pktnum;
365     int    csec = 101;
366     struct tm time;
367     char mon[4] = {'J', 'A', 'N', 0};
368     gchar *p;
369     static gchar months[] = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
370
371     time.tm_year = 1970;
372     time.tm_hour = 1;
373     time.tm_min = 1;
374     time.tm_sec = 1;
375
376     /* Skip lines until one starts with a hex number */
377     do {
378         if (file_gets(line, VMS_LINE_LENGTH, fh) == NULL) {
379             *err = file_error(fh);
380             if ((*err == 0) && (csec != 101)) {
381                 *err = WTAP_ERR_SHORT_READ;
382             }
383             return -1;
384         }
385         line[VMS_LINE_LENGTH] = '\0';
386
387         if ((csec == 101) && (p = strstr(line, "packet "))
388             && (! strstr(line, "could not save "))) {
389             /* Find text in line starting with "packet ". */
390
391             /* First look for the Format 1 type sequencing */
392             num_items_scanned = sscanf(p,  
393                                        "packet %d at %d-%3s-%d %d:%d:%d.%d",
394                                        &pktnum, &time.tm_mday, mon,
395                                        &time.tm_year, &time.tm_hour,
396                                        &time.tm_min, &time.tm_sec, &csec);
397             /* Next look for the Format 2 type sequencing */
398             if (num_items_scanned != 8) {
399               num_items_scanned = sscanf(p,
400                                          "packet seq # = %d at %d-%3s-%d %d:%d:%d.%d",
401                                          &pktnum, &time.tm_mday, mon,
402                                          &time.tm_year, &time.tm_hour,
403                                          &time.tm_min, &time.tm_sec, &csec);
404             }
405             /* if unknown format then exit with error        */
406             /* We will need to add code to handle new format */
407             if (num_items_scanned != 8) {
408                 *err = WTAP_ERR_BAD_RECORD;
409                 return -1;
410             }
411         }
412         if ( (! pkt_len) && (p = strstr(line, "Length"))) {
413             p += sizeof("Length ");
414             while (*p && ! isdigit(*p))
415                 p++;
416
417             if ( !*p ) {
418                 *err = WTAP_ERR_BAD_RECORD;
419                 return -1;
420             }
421
422             pkt_len = atoi(p);
423             break;
424         }
425     } while (! isdumpline(line));
426
427     if (wth) {
428         p = strstr(months, mon);
429         if (p)
430             time.tm_mon = (p - months) / 3;
431         time.tm_year -= 1900;
432
433         time.tm_isdst = -1;
434         wth->phdr.ts.tv_sec = mktime(&time);
435
436         wth->phdr.ts.tv_usec = csec * 10000;
437         wth->phdr.caplen = pkt_len;
438         wth->phdr.len = pkt_len;
439         wth->phdr.pkt_encap = WTAP_ENCAP_RAW_IP;
440     }
441
442     return pkt_len;
443 }
444
445 /* Converts ASCII hex dump to binary data */
446 static gboolean
447 parse_vms_hex_dump(FILE_T fh, int pkt_len, guint8* buf, int *err)
448 {
449     gchar line[VMS_LINE_LENGTH + 1];
450     int    i;
451     int    offset = 0;
452
453     for (i = 0; i < pkt_len; i += 16) {
454         if (file_gets(line, VMS_LINE_LENGTH, fh) == NULL) {
455             *err = file_error(fh);
456             if (*err == 0) {
457                 *err = WTAP_ERR_SHORT_READ;
458             }
459             return FALSE;
460         }
461         line[VMS_LINE_LENGTH] = '\0';
462         if (i == 0) {
463             while (! isdumpline(line)) { /* advance to start of hex data */
464                 if (file_gets(line, VMS_LINE_LENGTH, fh) == NULL) {
465                     *err = file_error(fh);
466                     if (*err == 0) {
467                         *err = WTAP_ERR_SHORT_READ;
468                     }
469                     return FALSE;
470                 }
471                 line[VMS_LINE_LENGTH] = '\0';
472             }
473             while (line[offset] && !isxdigit(line[offset]))
474                 offset++;
475         }
476         if (!parse_single_hex_dump_line(line, buf, i,
477                                         offset, pkt_len - i)) {
478             *err = WTAP_ERR_BAD_RECORD;
479             return FALSE;
480         }
481     }
482     /* Avoid TCPIPTRACE-W-BUFFERSFUL, TCPIPtrace could not save n packets.
483      * errors. */
484     file_gets(line, VMS_LINE_LENGTH, fh);
485     return TRUE;
486 }
487
488 /*
489           1         2         3         4
490 0123456789012345678901234567890123456789012345
491    50010C0A   A34C0640   00009017   2C000045    0000    E..,....@.L....P
492    00000000   14945E52   0A00DC02 | 32010C0A    0010    ...2....R^......
493        0000 | B4050402   00003496   00020260    0020    `....4........
494 */
495
496 #define START_POS    7
497 #define HEX_LENGTH    ((8 * 4) + 7) /* eight clumps of 4 bytes with 7 inner spaces */
498 /* Take a string representing one line from a hex dump and converts the
499  * text to binary data. We check the printed offset with the offset
500  * we are passed to validate the record. We place the bytes in the buffer
501  * at the specified offset.
502  *
503  * Returns TRUE if good hex dump, FALSE if bad.
504  */
505 static gboolean
506 parse_single_hex_dump_line(char* rec, guint8 *buf, long byte_offset,
507                int in_off, int remaining) {
508
509     int        i;
510     char        *s;
511     int        value;
512     static int offsets[16] = {39,37,35,33,28,26,24,22,17,15,13,11,6,4,2,0};
513     char lbuf[3] = {0,0,0};
514
515
516     /* Get the byte_offset directly from the record */
517     s = rec;
518     value = strtoul(s + 45 + in_off, NULL, 16);
519
520     if (value != byte_offset) {
521         return FALSE;
522     }
523
524     if (remaining > 16)
525         remaining = 16;
526
527     /* Read the octets right to left, as that is how they are displayed
528      * in VMS.
529      */
530
531     for (i = 0; i < remaining; i++) {
532         lbuf[0] = rec[offsets[i] + in_off];
533         lbuf[1] = rec[offsets[i] + 1 + in_off];
534
535         buf[byte_offset + i] = (guint8) strtoul(lbuf, NULL, 16);
536     }
537
538     return TRUE;
539 }