The DLT_ value 127 is being used for the BSD radio header, and the
[obnox/wireshark/wip.git] / wiretap / wtap.c
1 /* wtap.c
2  *
3  * $Id: wtap.c,v 1.89 2004/01/29 10:58:28 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 #include <string.h>
24 #include <errno.h>
25
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29 #include "wtap-int.h"
30 #include "file_wrappers.h"
31 #include "buffer.h"
32
33 int
34 wtap_fd(wtap *wth)
35 {
36         return wth->fd;
37 }
38
39 int
40 wtap_file_type(wtap *wth)
41 {
42         return wth->file_type;
43 }
44
45 int
46 wtap_snapshot_length(wtap *wth)
47 {
48         return wth->snapshot_length;
49 }
50
51 int
52 wtap_file_encap(wtap *wth)
53 {
54         return wth->file_encap;
55 }
56
57 /* Table of the encapsulation types we know about. */
58 static const struct encap_type_info {
59         const char *name;
60         const char *short_name;
61 } encap_table[WTAP_NUM_ENCAP_TYPES] = {
62         /* WTAP_ENCAP_UNKNOWN */
63         { "Unknown", NULL },
64
65         /* WTAP_ENCAP_ETHERNET */
66         { "Ethernet", "ether" },
67
68         /* WTAP_ENCAP_TOKEN_RING */
69         { "Token Ring", "tr" },
70
71         /* WTAP_ENCAP_SLIP */
72         { "SLIP", "slip" },
73
74         /* WTAP_ENCAP_PPP */
75         { "PPP", "ppp" },
76
77         /* WTAP_ENCAP_FDDI */
78         { "FDDI", "fddi" },
79
80         /* WTAP_ENCAP_FDDI_BITSWAPPED */
81         { "FDDI with bit-swapped MAC addresses", "fddi-swapped" },
82
83         /* WTAP_ENCAP_RAW_IP */
84         { "Raw IP", "rawip" },
85
86         /* WTAP_ENCAP_ARCNET */
87         { "ARCNET", "arcnet" },
88
89         /* WTAP_ENCAP_ARCNET_LINUX */
90         { "Linux ARCNET", "arcnet_linux" },
91
92         /* WTAP_ENCAP_ATM_RFC1483 */
93         { "RFC 1483 ATM", "atm-rfc1483" },
94
95         /* WTAP_ENCAP_LINUX_ATM_CLIP */
96         { "Linux ATM CLIP", "linux-atm-clip" },
97
98         /* WTAP_ENCAP_LAPB */
99         { "LAPB", "lapb" },
100
101         /* WTAP_ENCAP_ATM_PDUS */
102         { "ATM PDUs", "atm-pdus" },
103
104         /* WTAP_ENCAP_ATM_PDUS_UNTRUNCATED */
105         { "ATM PDUs - untruncated", "atm-pdus-untruncated" },
106
107         /* WTAP_ENCAP_NULL */
108         { "NULL", "null" },
109
110         /* WTAP_ENCAP_ASCEND */
111         { "Lucent/Ascend access equipment", "ascend" },
112
113         /* WTAP_ENCAP_ISDN */
114         { "ISDN", "isdn" },
115
116         /* WTAP_ENCAP_IP_OVER_FC */
117         { "RFC 2625 IP-over-Fibre Channel", "ip-over-fc" },
118
119         /* WTAP_ENCAP_PPP_WITH_PHDR */
120         { "PPP with Directional Info", "ppp-with-direction" },
121
122         /* WTAP_ENCAP_IEEE_802_11 */
123         { "IEEE 802.11 Wireless LAN", "ieee-802-11" },
124
125         /* WTAP_ENCAP_PRISM_HEADER */
126         { "IEEE 802.11 plus Prism II monitor mode header", "prism" },
127
128         /* WTAP_ENCAP_IEEE_802_11_WITH_RADIO */
129         { "IEEE 802.11 Wireless LAN with radio information", "ieee-802-11-radio" },
130
131         /* WTAP_ENCAP_IEEE_802_11_WLAN_BSD */
132         { "IEEE 802.11 plus BSD WLAN header", "ieee-802-11-bsd" },
133
134         /* WTAP_ENCAP_IEEE_802_11_WLAN_AVS */
135         { "IEEE 802.11 plus AVS WLAN header", "ieee-802-11-avs" },
136
137         /* WTAP_ENCAP_SLL */
138         { "Linux cooked-mode capture", "linux-sll" },
139
140         /* WTAP_ENCAP_FRELAY */
141         { "Frame Relay", "frelay" },
142
143         /* WTAP_ENCAP_FRELAY_WITH_PHDR */
144         { "Frame Relay with Directional Info", "frelay-with-direction" },
145
146         /* WTAP_ENCAP_CHDLC */
147         { "Cisco HDLC", "chdlc" },
148
149         /* WTAP_ENCAP_CISCO_IOS */
150         { "Cisco IOS internal", "ios" },
151
152         /* WTAP_ENCAP_LOCALTALK */
153         { "Localtalk", "ltalk" },
154
155         /* WTAP_ENCAP_OLD_PFLOG  */
156         { "OpenBSD PF Firewall logs, pre-3.4", "pflog-old" },
157
158         /* WTAP_ENCAP_HHDLC */
159         { "HiPath HDLC", "hhdlc" },
160
161         /* WTAP_ENCAP_DOCSIS */
162         { "Data Over Cable Service Interface Specification", "docsis" },
163
164         /* WTAP_ENCAP_COSINE */
165         { "CoSine L2 debug log", "cosine" },
166
167         /* WTAP_ENCAP_WFLEET_HDLC */
168         { "Wellfleet HDLC", "whdlc" },
169
170         /* WTAP_ENCAP_SDLC */
171         { "SDLC", "sdlc" },
172
173         /* WTAP_ENCAP_TZSP */
174         { "Tazmen sniffer protocol", "tzsp" },
175
176         /* WTAP_ENCAP_ENC */
177         { "OpenBSD enc(4) encapsulating interface", "enc" },
178
179         /* WTAP_ENCAP_PFLOG  */
180         { "OpenBSD PF Firewall logs", "pflog" },
181
182         /* WTAP_ENCAP_CHDLC_WITH_PHDR */
183         { "Cisco HDLC with Directional Info", "chdlc-with-direction" },
184
185         /* WTAP_ENCAP_BLUETOOTH_H4 */
186         { "Bluetooth H4", "bluetooth-h4" },
187
188         /* WTAP_ENCAP_MTP2 */
189         { "SS7 MTP2", "mtp2" },
190
191         /* WTAP_ENCAP_MTP3 */
192         { "SS7 MTP3", "mtp3" },
193
194         /* WTAP_ENCAP_IRDA */
195         { "IrDA", "irda" },
196
197         /* WTAP_ENCAP_USER0 */
198         { "USER 0", "user0" },
199
200         /* WTAP_ENCAP_USER1 */
201         { "USER 1", "user1" },
202
203         /* WTAP_ENCAP_USER2 */
204         { "USER 2", "user2" },
205
206         /* WTAP_ENCAP_USER3 */
207         { "USER 3", "user3" },
208
209         /* WTAP_ENCAP_USER4 */
210         { "USER 4", "user4" },
211
212         /* WTAP_ENCAP_USER5 */
213         { "USER 5", "user5" },
214
215         /* WTAP_ENCAP_USER6 */
216         { "USER 6", "user6" },
217
218         /* WTAP_ENCAP_USER7 */
219         { "USER 7", "user7" },
220
221         /* WTAP_ENCAP_USER8 */
222         { "USER 8", "user8" },
223
224         /* WTAP_ENCAP_USER9 */
225         { "USER 9", "user9" },
226
227         /* WTAP_ENCAP_USER10 */
228         { "USER 10", "user10" },
229
230         /* WTAP_ENCAP_USER11 */
231         { "USER 11", "user11" },
232
233         /* WTAP_ENCAP_USER12 */
234         { "USER 12", "user12" },
235
236         /* WTAP_ENCAP_USER13 */
237         { "USER 13", "user13" },
238
239         /* WTAP_ENCAP_USER14 */
240         { "USER 14", "user14" },
241
242         /* WTAP_ENCAP_USER15 */
243         { "USER 15", "user15" },
244 };
245
246 /* Name that should be somewhat descriptive. */
247 const char
248 *wtap_encap_string(int encap)
249 {
250         if (encap < 0 || encap >= WTAP_NUM_ENCAP_TYPES)
251                 return NULL;
252         else
253                 return encap_table[encap].name;
254 }
255
256 /* Name to use in, say, a command-line flag specifying the type. */
257 const char
258 *wtap_encap_short_string(int encap)
259 {
260         if (encap < 0 || encap >= WTAP_NUM_ENCAP_TYPES)
261                 return NULL;
262         else
263                 return encap_table[encap].short_name;
264 }
265
266 /* Translate a short name to a capture file type. */
267 int
268 wtap_short_string_to_encap(const char *short_name)
269 {
270         int encap;
271
272         for (encap = 0; encap < WTAP_NUM_ENCAP_TYPES; encap++) {
273                 if (encap_table[encap].short_name != NULL &&
274                     strcmp(short_name, encap_table[encap].short_name) == 0)
275                         return encap;
276         }
277         return -1;      /* no such encapsulation type */
278 }
279
280 static const char *wtap_errlist[] = {
281         "The file isn't a plain file or pipe",
282         "The file is being opened for random access but is a pipe",
283         "The file isn't a capture file in a known format",
284         "File contains record data we don't support",
285         "That file format cannot be written to a pipe",
286         NULL,
287         "Files can't be saved in that format",
288         "Files from that network type can't be saved in that format",
289         "That file format doesn't support per-packet encapsulations",
290         NULL,
291         NULL,
292         "Less data was read than was expected",
293         "File contains a record that's not valid",
294         "Less data was written than was requested",
295         "Uncompression error: data oddly truncated",
296         "Uncompression error: data would overflow buffer",
297         "Uncompression error: bad LZ77 offset",
298 };
299 #define WTAP_ERRLIST_SIZE       (sizeof wtap_errlist / sizeof wtap_errlist[0])
300
301 const char
302 *wtap_strerror(int err)
303 {
304         static char errbuf[128];
305         unsigned int wtap_errlist_index;
306
307         if (err < 0) {
308 #ifdef HAVE_LIBZ
309                 if (err >= WTAP_ERR_ZLIB_MIN && err <= WTAP_ERR_ZLIB_MAX) {
310                         /* Assume it's a zlib error. */
311                         sprintf(errbuf, "Uncompression error: %s",
312                             zError(err - WTAP_ERR_ZLIB));
313                         return errbuf;
314                 }
315 #endif
316                 wtap_errlist_index = -1 - err;
317                 if (wtap_errlist_index >= WTAP_ERRLIST_SIZE) {
318                         sprintf(errbuf, "Error %d", err);
319                         return errbuf;
320                 }
321                 if (wtap_errlist[wtap_errlist_index] == NULL)
322                         return "Unknown reason";
323                 return wtap_errlist[wtap_errlist_index];
324         } else
325                 return strerror(err);
326 }
327
328 /* Close only the sequential side, freeing up memory it uses.
329
330    Note that we do *not* want to call the subtype's close function,
331    as it would free any per-subtype data, and that data may be
332    needed by the random-access side.
333
334    Instead, if the subtype has a "sequential close" function, we call it,
335    to free up stuff used only by the sequential side. */
336 void
337 wtap_sequential_close(wtap *wth)
338 {
339         if (wth->subtype_sequential_close != NULL)
340                 (*wth->subtype_sequential_close)(wth);
341
342         if (wth->fh != NULL) {
343                 file_close(wth->fh);
344                 wth->fh = NULL;
345         }
346
347         if (wth->frame_buffer) {
348                 buffer_free(wth->frame_buffer);
349                 g_free(wth->frame_buffer);
350                 wth->frame_buffer = NULL;
351         }
352 }
353
354 void
355 wtap_close(wtap *wth)
356 {
357         wtap_sequential_close(wth);
358
359         if (wth->subtype_close != NULL)
360                 (*wth->subtype_close)(wth);
361
362         if (wth->random_fh != NULL)
363                 file_close(wth->random_fh);
364
365         g_free(wth);
366 }
367
368 gboolean
369 wtap_read(wtap *wth, int *err, gchar **err_info, long *data_offset)
370 {
371         if (!wth->subtype_read(wth, err, err_info, data_offset))
372                 return FALSE;   /* failure */
373
374         /*
375          * It makes no sense for the captured data length to be bigger
376          * than the actual data length.
377          */
378         if (wth->phdr.caplen > wth->phdr.len)
379                 wth->phdr.caplen = wth->phdr.len;
380         return TRUE;    /* success */
381 }
382
383 struct wtap_pkthdr*
384 wtap_phdr(wtap *wth)
385 {
386         return &wth->phdr;
387 }
388
389 union wtap_pseudo_header*
390 wtap_pseudoheader(wtap *wth)
391 {
392         return &wth->pseudo_header;
393 }
394
395 guint8*
396 wtap_buf_ptr(wtap *wth)
397 {
398         return buffer_start_ptr(wth->frame_buffer);
399 }
400
401 gboolean
402 wtap_loop(wtap *wth, int count, wtap_handler callback, guchar* user, int *err,
403     gchar **err_info)
404 {
405         long            data_offset;
406         int             loop = 0;
407
408         /* Start by clearing error flag */
409         *err = 0;
410
411         while ( (wtap_read(wth, err, err_info, &data_offset)) ) {
412                 callback(user, &wth->phdr, data_offset,
413                     &wth->pseudo_header, buffer_start_ptr(wth->frame_buffer));
414                 if (count > 0 && ++loop >= count)
415                         break;
416         }
417
418         if (*err == 0)
419                 return TRUE;    /* success */
420         else
421                 return FALSE;   /* failure */
422 }
423
424 gboolean
425 wtap_seek_read(wtap *wth, long seek_off,
426         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len,
427         int *err, gchar **err_info)
428 {
429         return wth->subtype_seek_read(wth, seek_off, pseudo_header, pd, len,
430                 err, err_info);
431 }