From Harald Welte:
[obnox/wireshark/wip.git] / wiretap / commview.c
1 /* commview.c
2  * Routines for opening CommView file format packet captures
3  * Copyright 2007, Stephen Fisher (see AUTHORS file)
4  *
5  * $Id$
6  *
7  * Wireshark - Network traffic analyzer
8  * By Gerald Combs <gerald@wireshark.org>
9  * Copyright 1998 Gerald Combs
10  *
11  * Based on csids.c and nettl.c
12  *
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License
15  * as published by the Free Software Foundation; either version 2
16  * of the License, or (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
26  * USA.
27  */
28
29 /* A brief description of this file format is available at:
30  *    http://www.tamos.com/htmlhelp/commview/logformat.htm
31  */
32
33 #ifdef HAVE_CONFIG_H
34 #include "config.h"
35 #endif
36
37 #include <glib.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <errno.h>
41 #include <string.h>
42
43 #include "wtap.h"
44 #include "wtap-int.h"
45 #include "buffer.h"
46 #include "file_wrappers.h"
47 #include "commview.h"
48
49 typedef struct commview_header {
50         guint16         data_len;
51         guint16         source_data_len;
52         guint8          version;
53         guint16         year;
54         guint8          month;
55         guint8          day;
56         guint8          hours;
57         guint8          minutes;
58         guint8          seconds;
59         guint32         usecs;
60         guint8          flags;          /* Bit-field positions defined below */
61         guint8          signal_level_percent;
62         guint8          rate;
63         guint8          band;
64         guint8          channel;
65         guint8          direction;      /* Or for WiFi, high order byte of
66                                          * packet rate. */
67         guint8          signal_level_dbm;
68         guint8          noise_level;    /* In dBm (WiFi only) */
69 } commview_header_t;
70
71 #define COMMVIEW_HEADER_SIZE 24
72
73 /* Bit-field positions for various fields in the flags variable of the header */
74 #define FLAGS_MEDIUM            0x0F
75 #define FLAGS_DECRYPTED         0x10
76 #define FLAGS_BROKEN            0x20
77 #define FLAGS_COMPRESSED        0x40
78 #define FLAGS_RESERVED          0x80
79
80 /* Capture mediums as defined by the commview file format */
81 #define MEDIUM_ETHERNET         0
82 #define MEDIUM_WIFI             1
83 #define MEDIUM_TOKEN_RING       2
84
85 static gboolean commview_read(wtap *wth, int *err, gchar **err_info,
86                               gint64 *data_offset);
87 static gboolean commview_seek_read(wtap *wth, gint64 seek_off,
88                                    union wtap_pseudo_header *pseudo_header,
89                                    guint8 *pd, int length, int *err,
90                                    gchar **err_info);
91 static gboolean commview_read_header(commview_header_t *cv_hdr, FILE_T fh,
92                                      int *err, gchar **err_info);
93 static gboolean commview_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
94                               const union wtap_pseudo_header *pseudo_header,
95                               const guint8 *pd, int *err);
96
97 int commview_open(wtap *wth, int *err, gchar **err_info)
98 {
99         commview_header_t cv_hdr;
100
101         if(!commview_read_header(&cv_hdr, wth->fh, err, err_info))
102                 return -1;
103
104         /* If any of these fields do not match what we expect, bail out. */
105         if(cv_hdr.version != 0 ||
106            cv_hdr.year < 1970 || cv_hdr.year >= 2038 ||
107            cv_hdr.month < 1 || cv_hdr.month > 12 ||
108            cv_hdr.day < 1 || cv_hdr.day > 31 ||
109            cv_hdr.hours > 23 ||
110            cv_hdr.minutes > 59 ||
111            cv_hdr.seconds > 60 ||
112            cv_hdr.signal_level_percent > 100 ||
113            (cv_hdr.flags & FLAGS_RESERVED) != 0 ||
114            ((cv_hdr.flags & FLAGS_MEDIUM) != MEDIUM_ETHERNET &&
115             (cv_hdr.flags & FLAGS_MEDIUM) != MEDIUM_WIFI &&
116             (cv_hdr.flags & FLAGS_MEDIUM) != MEDIUM_TOKEN_RING))
117                 return 0; /* Not our kind of file */
118
119         /* No file header. Reset the fh to 0 so we can read the first packet */
120         if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
121                 return -1;
122
123         /* Set up the pointers to the handlers for this file type */
124         wth->subtype_read = commview_read;
125         wth->subtype_seek_read = commview_seek_read;
126
127         wth->data_offset = 0;
128         wth->file_type = WTAP_FILE_COMMVIEW;
129         wth->file_encap = WTAP_ENCAP_PER_PACKET;
130         wth->tsprecision = WTAP_FILE_TSPREC_USEC;
131
132         return 1; /* Our kind of file */
133 }
134
135 static void
136 commview_set_pseudo_header(commview_header_t *cv_hdrp, union wtap_pseudo_header
137                            *pseudo_header)
138 {
139         switch(cv_hdrp->flags & FLAGS_MEDIUM) {
140
141         case MEDIUM_ETHERNET :
142                 pseudo_header->eth.fcs_len = -1; /* Unknown */
143                 break;
144
145         case MEDIUM_WIFI :
146                 pseudo_header->ieee_802_11.fcs_len = -1; /* Unknown */
147                 pseudo_header->ieee_802_11.channel = cv_hdrp->channel;
148                 pseudo_header->ieee_802_11.data_rate = cv_hdrp->rate;
149                 pseudo_header->ieee_802_11.signal_level = cv_hdrp->signal_level_percent;
150                 break;
151
152         default :
153                 /* Token Ring or unknown - no pseudo-header for that */
154                 break;
155         }
156 }
157
158 static gboolean
159 commview_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
160 {
161         commview_header_t cv_hdr;
162         struct tm tm;
163         int bytes_read;
164
165         *data_offset = wth->data_offset;
166
167         if(!commview_read_header(&cv_hdr, wth->fh, err, err_info))
168                 return FALSE;
169
170         wth->data_offset += COMMVIEW_HEADER_SIZE;
171
172         switch(cv_hdr.flags & FLAGS_MEDIUM) {
173
174         case MEDIUM_ETHERNET :
175                 wth->phdr.pkt_encap = WTAP_ENCAP_ETHERNET;
176                 break;
177
178         case MEDIUM_WIFI :
179                 wth->phdr.pkt_encap = WTAP_ENCAP_IEEE_802_11_WITH_RADIO;
180                 break;
181
182         case MEDIUM_TOKEN_RING :
183                 wth->phdr.pkt_encap = WTAP_ENCAP_TOKEN_RING;
184                 break;
185
186         default :
187                 *err = WTAP_ERR_BAD_FILE;
188                 *err_info = g_strdup_printf("commview: unsupported encap: %u",
189                                             cv_hdr.flags & FLAGS_MEDIUM);
190                 return FALSE;
191         }
192
193         commview_set_pseudo_header(&cv_hdr, &wth->pseudo_header);
194
195         buffer_assure_space(wth->frame_buffer, cv_hdr.data_len);
196         bytes_read = file_read(buffer_start_ptr(wth->frame_buffer),
197                                cv_hdr.data_len, wth->fh);
198         if(bytes_read != cv_hdr.data_len) {
199                 *err = file_error(wth->fh, err_info);
200                 if(*err == 0)
201                         *err = WTAP_ERR_SHORT_READ;
202                 return FALSE;
203         }
204
205         tm.tm_year = cv_hdr.year - 1900;
206         tm.tm_mon = cv_hdr.month - 1;
207         tm.tm_mday = cv_hdr.day;
208         tm.tm_hour = cv_hdr.hours;
209         tm.tm_min = cv_hdr.minutes;
210         tm.tm_sec = cv_hdr.seconds;
211         tm.tm_isdst = -1;
212
213         wth->data_offset += cv_hdr.data_len;
214
215         wth->phdr.len = cv_hdr.data_len;
216         wth->phdr.caplen = cv_hdr.data_len;
217
218         wth->phdr.ts.secs = mktime(&tm);
219         wth->phdr.ts.nsecs = cv_hdr.usecs * 1000;
220
221         return TRUE;
222 }
223
224 static gboolean
225 commview_seek_read(wtap *wth, gint64 seek_off, union wtap_pseudo_header
226                    *pseudo_header, guint8 *pd, int length, int *err,
227                    gchar **err_info)
228 {
229         commview_header_t cv_hdr;
230         int bytes_read;
231
232         if(file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
233                 return FALSE;
234
235         if(!commview_read_header(&cv_hdr, wth->random_fh, err, err_info)) {
236                 if(*err == 0)
237                         *err = WTAP_ERR_SHORT_READ;
238
239                 return FALSE;
240         }
241
242         if(length != cv_hdr.data_len) {
243                 *err = WTAP_ERR_BAD_FILE;
244                 *err_info = g_strdup_printf("commview: record length %u doesn't match requested length %d", cv_hdr.data_len, length);
245                 return FALSE;
246         }
247
248         commview_set_pseudo_header(&cv_hdr, pseudo_header);
249
250         bytes_read = file_read(pd, cv_hdr.data_len, wth->random_fh);
251         if(bytes_read != cv_hdr.data_len) {
252                 *err = file_error(wth->random_fh, err_info);
253                 if(*err == 0)
254                         *err = WTAP_ERR_SHORT_READ;
255
256                 return FALSE;
257         }
258
259         return TRUE;
260 }
261
262 static gboolean
263 commview_read_header(commview_header_t *cv_hdr, FILE_T fh, int *err,
264     gchar **err_info)
265 {
266         wtap_file_read_expected_bytes(&cv_hdr->data_len, 2, fh, err, err_info);
267         wtap_file_read_expected_bytes(&cv_hdr->source_data_len, 2, fh, err, err_info);
268         wtap_file_read_expected_bytes(&cv_hdr->version, 1, fh, err, err_info);
269         wtap_file_read_expected_bytes(&cv_hdr->year, 2, fh, err, err_info);
270         wtap_file_read_expected_bytes(&cv_hdr->month, 1, fh, err, err_info);
271         wtap_file_read_expected_bytes(&cv_hdr->day, 1, fh, err, err_info);
272         wtap_file_read_expected_bytes(&cv_hdr->hours, 1, fh, err, err_info);
273         wtap_file_read_expected_bytes(&cv_hdr->minutes, 1, fh, err, err_info);
274         wtap_file_read_expected_bytes(&cv_hdr->seconds, 1, fh, err, err_info);
275         wtap_file_read_expected_bytes(&cv_hdr->usecs, 4, fh, err, err_info);
276         wtap_file_read_expected_bytes(&cv_hdr->flags, 1, fh, err, err_info);
277         wtap_file_read_expected_bytes(&cv_hdr->signal_level_percent, 1, fh, err, err_info);
278         wtap_file_read_expected_bytes(&cv_hdr->rate, 1, fh, err, err_info);
279         wtap_file_read_expected_bytes(&cv_hdr->band, 1, fh, err, err_info);
280         wtap_file_read_expected_bytes(&cv_hdr->channel, 1, fh, err, err_info);
281         wtap_file_read_expected_bytes(&cv_hdr->direction, 1, fh, err, err_info);
282         wtap_file_read_expected_bytes(&cv_hdr->signal_level_dbm, 1, fh, err, err_info);
283         wtap_file_read_expected_bytes(&cv_hdr->noise_level, 1, fh, err, err_info);
284
285         /* Convert multi-byte values from little endian to host endian format */
286         cv_hdr->data_len = GUINT16_FROM_LE(cv_hdr->data_len);
287         cv_hdr->source_data_len = GUINT16_FROM_LE(cv_hdr->source_data_len);
288         cv_hdr->year = GUINT16_FROM_LE(cv_hdr->year);
289         cv_hdr->usecs = GUINT32_FROM_LE(cv_hdr->usecs);
290
291         return TRUE;
292 }
293
294 /* Returns 0 if we can write out the specified encapsulation type
295  * into a CommView format file. */
296 int commview_dump_can_write_encap(int encap)
297 {
298         switch (encap) {
299
300         case WTAP_ENCAP_ETHERNET :
301         case WTAP_ENCAP_IEEE_802_11 :
302         case WTAP_ENCAP_IEEE_802_11_WITH_RADIO :
303         case WTAP_ENCAP_TOKEN_RING :
304         case WTAP_ENCAP_PER_PACKET :
305                 return 0;
306
307         default:
308                 return WTAP_ERR_UNSUPPORTED_ENCAP;
309         }
310 }
311
312 /* Returns TRUE on success, FALSE on failure;
313    sets "*err" to an error code on failure */
314 gboolean commview_dump_open(wtap_dumper *wdh, int *err _U_)
315 {
316         wdh->subtype_write = commview_dump;
317         wdh->subtype_close = NULL;
318
319         /* There is no file header to write out */
320         wdh->bytes_dumped = 0;
321
322         return TRUE;
323 }
324
325 /* Write a record for a packet to a dump file.
326  * Returns TRUE on success, FALSE on failure. */
327 static gboolean commview_dump(wtap_dumper *wdh,
328                               const struct wtap_pkthdr *phdr,
329                               const union wtap_pseudo_header *pseudo_header,
330                               const guint8 *pd, int *err)
331 {
332         commview_header_t cv_hdr;
333         struct tm *tm;
334
335         memset(&cv_hdr, 0, sizeof(cv_hdr));
336
337         cv_hdr.data_len = GUINT16_TO_LE((guint16)phdr->caplen);
338         cv_hdr.source_data_len = GUINT16_TO_LE((guint16)phdr->caplen);
339         cv_hdr.version = 0;
340
341         tm = localtime(&phdr->ts.secs);
342         cv_hdr.year = tm->tm_year + 1900;
343         cv_hdr.month = tm->tm_mon + 1;
344         cv_hdr.day = tm->tm_mday;
345         cv_hdr.hours = tm->tm_hour;
346         cv_hdr.minutes = tm->tm_min;
347         cv_hdr.seconds = tm->tm_sec;
348         cv_hdr.usecs = GUINT32_TO_LE(phdr->ts.nsecs / 1000);
349
350         switch(phdr->pkt_encap) {
351
352         case WTAP_ENCAP_ETHERNET :
353                 cv_hdr.flags |= MEDIUM_ETHERNET;
354                 break;
355
356         case WTAP_ENCAP_IEEE_802_11 :
357                 cv_hdr.flags |=  MEDIUM_WIFI;
358                 break;
359
360         case WTAP_ENCAP_IEEE_802_11_WITH_RADIO :
361                 cv_hdr.flags |=  MEDIUM_WIFI;
362
363                 cv_hdr.channel = pseudo_header->ieee_802_11.channel;
364                 cv_hdr.rate = pseudo_header->ieee_802_11.data_rate;
365                 cv_hdr.signal_level_percent = pseudo_header->ieee_802_11.signal_level;
366                 break;
367
368         case WTAP_ENCAP_TOKEN_RING :
369                 cv_hdr.flags |= MEDIUM_TOKEN_RING;
370                 break;
371
372         default :
373                 *err = WTAP_ERR_UNSUPPORTED_ENCAP;
374                 return FALSE;
375         }
376
377         if (!wtap_dump_file_write(wdh, &cv_hdr.data_len, 2, err))
378                 return FALSE;
379         if (!wtap_dump_file_write(wdh, &cv_hdr.source_data_len, 2, err))
380                 return FALSE;
381         if (!wtap_dump_file_write(wdh, &cv_hdr.version, 1, err))
382                 return FALSE;
383         if (!wtap_dump_file_write(wdh, &cv_hdr.year, 2, err))
384                 return FALSE;
385         if (!wtap_dump_file_write(wdh, &cv_hdr.month, 1, err))
386                 return FALSE;
387         if (!wtap_dump_file_write(wdh, &cv_hdr.day, 1, err))
388                 return FALSE;
389         if (!wtap_dump_file_write(wdh, &cv_hdr.hours, 1, err))
390                 return FALSE;
391         if (!wtap_dump_file_write(wdh, &cv_hdr.minutes, 1, err))
392                 return FALSE;
393         if (!wtap_dump_file_write(wdh, &cv_hdr.seconds, 1, err))
394                 return FALSE;
395         if (!wtap_dump_file_write(wdh, &cv_hdr.usecs, 4, err))
396                 return FALSE;
397         if (!wtap_dump_file_write(wdh, &cv_hdr.flags, 1, err))
398                 return FALSE;
399         if (!wtap_dump_file_write(wdh, &cv_hdr.signal_level_percent, 1, err))
400                 return FALSE;
401         if (!wtap_dump_file_write(wdh, &cv_hdr.rate, 1, err))
402                 return FALSE;
403         if (!wtap_dump_file_write(wdh, &cv_hdr.band, 1, err))
404                 return FALSE;
405         if (!wtap_dump_file_write(wdh, &cv_hdr.channel, 1, err))
406                 return FALSE;
407         if (!wtap_dump_file_write(wdh, &cv_hdr.direction, 1, err))
408                 return FALSE;
409         if (!wtap_dump_file_write(wdh, &cv_hdr.signal_level_dbm, 2, err))
410                 return FALSE;
411         if (!wtap_dump_file_write(wdh, &cv_hdr.noise_level, 2, err))
412                 return FALSE;
413         wdh->bytes_dumped += COMMVIEW_HEADER_SIZE;
414
415         if (!wtap_dump_file_write(wdh, pd, phdr->caplen, err))
416                 return FALSE;
417         wdh->bytes_dumped += phdr->caplen;
418
419         return TRUE;
420 }