00c12f0191958fa09c8d341626dde2e6bce085e5
[metze/wireshark/wip.git] / wiretap / wtap.c
1 /* wtap.c
2  *
3  * $Id$
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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  */
22
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include <string.h>
28 #include <errno.h>
29
30 #ifdef HAVE_SYS_TYPES_H
31 #include <sys/types.h>
32 #endif
33
34 #ifdef HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif
37
38 #ifdef HAVE_LIBZ
39 #include <zlib.h>
40 #endif
41
42 #include "wtap-int.h"
43
44 #include "file_wrappers.h"
45 #include <wsutil/file_util.h>
46 #include "buffer.h"
47
48 /*
49  * Return the size of the file, as reported by the OS.
50  * (gint64, in case that's 64 bits.)
51  */
52 gint64
53 wtap_file_size(wtap *wth, int *err)
54 {
55         ws_statb64 statb;
56
57         if (file_fstat((wth->fh == NULL) ? wth->random_fh : wth->fh,
58             &statb, err) == -1)
59                 return -1;
60         return statb.st_size;
61 }
62
63 /*
64  * Do an fstat on the file.
65  */
66 int
67 wtap_fstat(wtap *wth, ws_statb64 *statb, int *err)
68 {
69         if (file_fstat((wth->fh == NULL) ? wth->random_fh : wth->fh,
70             statb, err) == -1)
71                 return -1;
72         return 0;
73 }
74
75 int
76 wtap_file_type(wtap *wth)
77 {
78         return wth->file_type;
79 }
80
81 guint
82 wtap_snapshot_length(wtap *wth)
83 {
84         return wth->snapshot_length;
85 }
86
87 int
88 wtap_file_encap(wtap *wth)
89 {
90         return wth->file_encap;
91 }
92
93 int
94 wtap_file_tsprecision(wtap *wth)
95 {
96         return wth->tsprecision;
97 }
98
99 wtapng_section_t* wtap_file_get_shb_info(wtap *wth)
100 {
101         wtapng_section_t                *shb_hdr;
102
103         shb_hdr = g_new(wtapng_section_t,1);
104         shb_hdr->section_length = wth->shb_hdr.section_length;
105         /* options */
106         shb_hdr->opt_comment   =        wth->shb_hdr.opt_comment;       /* NULL if not available */
107         shb_hdr->shb_hardware  =        wth->shb_hdr.shb_hardware;      /* NULL if not available, UTF-8 string containing the description of the hardware used to create this section. */
108         shb_hdr->shb_os        =        wth->shb_hdr.shb_os;            /* NULL if not available, UTF-8 string containing the name of the operating system used to create this section. */
109         shb_hdr->shb_user_appl =        wth->shb_hdr.shb_user_appl;     /* NULL if not available, UTF-8 string containing the name of the application used to create this section. */
110
111
112         return shb_hdr;
113 }
114
115 wtapng_iface_descriptions_t* wtap_file_get_idb_info(wtap *wth)
116 {
117         wtapng_iface_descriptions_t *idb_info;
118
119         idb_info = g_new(wtapng_iface_descriptions_t,1);
120
121         idb_info->number_of_interfaces  = wth->number_of_interfaces;
122         idb_info->interface_data                = wth->interface_data;
123
124         return idb_info;
125 }
126
127 /* Table of the encapsulation types we know about. */
128 struct encap_type_info {
129         const char *name;
130         const char *short_name;
131 };
132
133 static struct encap_type_info encap_table_base[] = {
134         /* WTAP_ENCAP_UNKNOWN */
135         { "Unknown", "unknown" },
136
137         /* WTAP_ENCAP_ETHERNET */
138         { "Ethernet", "ether" },
139
140         /* WTAP_ENCAP_TOKEN_RING */
141         { "Token Ring", "tr" },
142
143         /* WTAP_ENCAP_SLIP */
144         { "SLIP", "slip" },
145
146         /* WTAP_ENCAP_PPP */
147         { "PPP", "ppp" },
148
149         /* WTAP_ENCAP_FDDI */
150         { "FDDI", "fddi" },
151
152         /* WTAP_ENCAP_FDDI_BITSWAPPED */
153         { "FDDI with bit-swapped MAC addresses", "fddi-swapped" },
154
155         /* WTAP_ENCAP_RAW_IP */
156         { "Raw IP", "rawip" },
157
158         /* WTAP_ENCAP_ARCNET */
159         { "ARCNET", "arcnet" },
160
161         /* WTAP_ENCAP_ARCNET_LINUX */
162         { "Linux ARCNET", "arcnet_linux" },
163
164         /* WTAP_ENCAP_ATM_RFC1483 */
165         { "RFC 1483 ATM", "atm-rfc1483" },
166
167         /* WTAP_ENCAP_LINUX_ATM_CLIP */
168         { "Linux ATM CLIP", "linux-atm-clip" },
169
170         /* WTAP_ENCAP_LAPB */
171         { "LAPB", "lapb" },
172
173         /* WTAP_ENCAP_ATM_PDUS */
174         { "ATM PDUs", "atm-pdus" },
175
176         /* WTAP_ENCAP_ATM_PDUS_UNTRUNCATED */
177         { "ATM PDUs - untruncated", "atm-pdus-untruncated" },
178
179         /* WTAP_ENCAP_NULL */
180         { "NULL", "null" },
181
182         /* WTAP_ENCAP_ASCEND */
183         { "Lucent/Ascend access equipment", "ascend" },
184
185         /* WTAP_ENCAP_ISDN */
186         { "ISDN", "isdn" },
187
188         /* WTAP_ENCAP_IP_OVER_FC */
189         { "RFC 2625 IP-over-Fibre Channel", "ip-over-fc" },
190
191         /* WTAP_ENCAP_PPP_WITH_PHDR */
192         { "PPP with Directional Info", "ppp-with-direction" },
193
194         /* WTAP_ENCAP_IEEE_802_11 */
195         { "IEEE 802.11 Wireless LAN", "ieee-802-11" },
196
197         /* WTAP_ENCAP_PRISM_HEADER */
198         { "IEEE 802.11 plus Prism II monitor mode header", "prism" },
199
200         /* WTAP_ENCAP_IEEE_802_11_WITH_RADIO */
201         { "IEEE 802.11 Wireless LAN with radio information", "ieee-802-11-radio" },
202
203         /* WTAP_ENCAP_IEEE_802_11_WLAN_RADIOTAP */
204         { "IEEE 802.11 plus radiotap WLAN header", "ieee-802-11-radiotap" },
205
206         /* WTAP_ENCAP_IEEE_802_11_WLAN_AVS */
207         { "IEEE 802.11 plus AVS WLAN header", "ieee-802-11-avs" },
208
209         /* WTAP_ENCAP_SLL */
210         { "Linux cooked-mode capture", "linux-sll" },
211
212         /* WTAP_ENCAP_FRELAY */
213         { "Frame Relay", "frelay" },
214
215         /* WTAP_ENCAP_FRELAY_WITH_PHDR */
216         { "Frame Relay with Directional Info", "frelay-with-direction" },
217
218         /* WTAP_ENCAP_CHDLC */
219         { "Cisco HDLC", "chdlc" },
220
221         /* WTAP_ENCAP_CISCO_IOS */
222         { "Cisco IOS internal", "ios" },
223
224         /* WTAP_ENCAP_LOCALTALK */
225         { "Localtalk", "ltalk" },
226
227         /* WTAP_ENCAP_OLD_PFLOG  */
228         { "OpenBSD PF Firewall logs, pre-3.4", "pflog-old" },
229
230         /* WTAP_ENCAP_HHDLC */
231         { "HiPath HDLC", "hhdlc" },
232
233         /* WTAP_ENCAP_DOCSIS */
234         { "Data Over Cable Service Interface Specification", "docsis" },
235
236         /* WTAP_ENCAP_COSINE */
237         { "CoSine L2 debug log", "cosine" },
238
239         /* WTAP_ENCAP_WFLEET_HDLC */
240         { "Wellfleet HDLC", "whdlc" },
241
242         /* WTAP_ENCAP_SDLC */
243         { "SDLC", "sdlc" },
244
245         /* WTAP_ENCAP_TZSP */
246         { "Tazmen sniffer protocol", "tzsp" },
247
248         /* WTAP_ENCAP_ENC */
249         { "OpenBSD enc(4) encapsulating interface", "enc" },
250
251         /* WTAP_ENCAP_PFLOG  */
252         { "OpenBSD PF Firewall logs", "pflog" },
253
254         /* WTAP_ENCAP_CHDLC_WITH_PHDR */
255         { "Cisco HDLC with Directional Info", "chdlc-with-direction" },
256
257         /* WTAP_ENCAP_BLUETOOTH_H4 */
258         { "Bluetooth H4", "bluetooth-h4" },
259
260         /* WTAP_ENCAP_MTP2 */
261         { "SS7 MTP2", "mtp2" },
262
263         /* WTAP_ENCAP_MTP3 */
264         { "SS7 MTP3", "mtp3" },
265
266         /* WTAP_ENCAP_IRDA */
267         { "IrDA", "irda" },
268
269         /* WTAP_ENCAP_USER0 */
270         { "USER 0", "user0" },
271
272         /* WTAP_ENCAP_USER1 */
273         { "USER 1", "user1" },
274
275         /* WTAP_ENCAP_USER2 */
276         { "USER 2", "user2" },
277
278         /* WTAP_ENCAP_USER3 */
279         { "USER 3", "user3" },
280
281         /* WTAP_ENCAP_USER4 */
282         { "USER 4", "user4" },
283
284         /* WTAP_ENCAP_USER5 */
285         { "USER 5", "user5" },
286
287         /* WTAP_ENCAP_USER6 */
288         { "USER 6", "user6" },
289
290         /* WTAP_ENCAP_USER7 */
291         { "USER 7", "user7" },
292
293         /* WTAP_ENCAP_USER8 */
294         { "USER 8", "user8" },
295
296         /* WTAP_ENCAP_USER9 */
297         { "USER 9", "user9" },
298
299         /* WTAP_ENCAP_USER10 */
300         { "USER 10", "user10" },
301
302         /* WTAP_ENCAP_USER11 */
303         { "USER 11", "user11" },
304
305         /* WTAP_ENCAP_USER12 */
306         { "USER 12", "user12" },
307
308         /* WTAP_ENCAP_USER13 */
309         { "USER 13", "user13" },
310
311         /* WTAP_ENCAP_USER14 */
312         { "USER 14", "user14" },
313
314         /* WTAP_ENCAP_USER15 */
315         { "USER 15", "user15" },
316
317         /* WTAP_ENCAP_SYMANTEC */
318         { "Symantec Enterprise Firewall", "symantec" },
319
320         /* WTAP_ENCAP_APPLE_IP_OVER_IEEE1394 */
321         { "Apple IP-over-IEEE 1394", "ap1394" },
322
323         /* WTAP_ENCAP_BACNET_MS_TP */
324         { "BACnet MS/TP", "bacnet-ms-tp" },
325
326         /* WTAP_ENCAP_NETTL_RAW_ICMP */
327         { "Raw ICMP with nettl headers", "raw-icmp-nettl" },
328
329         /* WTAP_ENCAP_NETTL_RAW_ICMPV6 */
330         { "Raw ICMPv6 with nettl headers", "raw-icmpv6-nettl" },
331
332         /* WTAP_ENCAP_GPRS_LLC */
333         { "GPRS LLC", "gprs-llc" },
334
335         /* WTAP_ENCAP_JUNIPER_ATM1 */
336         { "Juniper ATM1", "juniper-atm1" },
337
338         /* WTAP_ENCAP_JUNIPER_ATM2 */
339         { "Juniper ATM2", "juniper-atm2" },
340
341         /* WTAP_ENCAP_REDBACK */
342         { "Redback SmartEdge", "redback" },
343
344         /* WTAP_ENCAP_NETTL_RAW_IP */
345         { "Raw IP with nettl headers", "rawip-nettl" },
346
347         /* WTAP_ENCAP_NETTL_ETHERNET */
348         { "Ethernet with nettl headers", "ether-nettl" },
349
350         /* WTAP_ENCAP_NETTL_TOKEN_RING */
351         { "Token Ring with nettl headers", "tr-nettl" },
352
353         /* WTAP_ENCAP_NETTL_FDDI */
354         { "FDDI with nettl headers", "fddi-nettl" },
355
356         /* WTAP_ENCAP_NETTL_UNKNOWN */
357         { "Unknown link-layer type with nettl headers", "unknown-nettl" },
358
359         /* WTAP_ENCAP_MTP2_WITH_PHDR */
360         { "MTP2 with pseudoheader", "mtp2-with-phdr" },
361
362         /* WTAP_ENCAP_JUNIPER_PPPOE */
363         { "Juniper PPPoE", "juniper-pppoe" },
364
365         /* WTAP_ENCAP_GCOM_TIE1 */
366         { "GCOM TIE1", "gcom-tie1" },
367
368         /* WTAP_ENCAP_GCOM_SERIAL */
369         { "GCOM Serial", "gcom-serial" },
370
371         /* WTAP_ENCAP_NETTL_X25 */
372         { "X25 with nettl headers", "x25-nettl" },
373
374         /* WTAP_ENCAP_K12 */
375         { "K12 protocol analyzer", "k12" },
376
377         /* WTAP_ENCAP_JUNIPER_MLPPP */
378         { "Juniper MLPPP", "juniper-mlppp" },
379
380         /* WTAP_ENCAP_JUNIPER_MLFR */
381         { "Juniper MLFR", "juniper-mlfr" },
382
383         /* WTAP_ENCAP_JUNIPER_ETHER */
384         { "Juniper Ethernet", "juniper-ether" },
385
386         /* WTAP_ENCAP_JUNIPER_PPP */
387         { "Juniper PPP", "juniper-ppp" },
388
389         /* WTAP_ENCAP_JUNIPER_FRELAY */
390         { "Juniper Frame-Relay", "juniper-frelay" },
391
392         /* WTAP_ENCAP_JUNIPER_CHDLC */
393         { "Juniper C-HDLC", "juniper-chdlc" },
394
395         /* WTAP_ENCAP_JUNIPER_GGSN */
396         { "Juniper GGSN", "juniper-ggsn" },
397
398         /* WTAP_ENCAP_LINUX_LAPD */
399         { "LAPD", "lapd" },
400
401         /* WTAP_ENCAP_CATAPULT_DCT2000 */
402         { "Catapult DCT2000", "dct2000" },
403
404         /* WTAP_ENCAP_BER */
405         { "ASN.1 Basic Encoding Rules", "ber" },
406
407         /* WTAP_ENCAP_JUNIPER_VP */
408         { "Juniper Voice PIC", "juniper-vp" },
409
410         /* WTAP_ENCAP_USB */
411         { "Raw USB packets", "usb" },
412
413         /* WTAP_ENCAP_IEEE802_16_MAC_CPS */
414         { "IEEE 802.16 MAC Common Part Sublayer", "ieee-802-16-mac-cps" },
415
416         /* WTAP_ENCAP_NETTL_RAW_TELNET */
417         { "Raw telnet with nettl headers", "raw-telnet-nettl" },
418
419         /* WTAP_ENCAP_USB_LINUX */
420         { "USB packets with Linux header", "usb-linux" },
421
422         /* WTAP_ENCAP_MPEG */
423         { "MPEG", "mpeg" },
424
425         /* WTAP_ENCAP_PPI */
426         { "Per-Packet Information header", "ppi" },
427
428         /* WTAP_ENCAP_ERF */
429         { "Endace Record File", "erf" },
430
431         /* WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR */
432         { "Bluetooth H4 with linux header", "bluetooth-h4-linux" },
433
434         /* WTAP_ENCAP_SITA */
435         { "SITA WAN packets", "sita-wan" },
436
437         /* WTAP_ENCAP_SCCP */
438         { "SS7 SCCP", "sccp" },
439
440         /* WTAP_ENCAP_BLUETOOTH_HCI */
441         { "Bluetooth without transport layer", "bluetooth-hci" },
442
443         /* WTAP_ENCAP_IPMB */
444         { "Intelligent Platform Management Bus", "ipmb" },
445
446         /* WTAP_ENCAP_IEEE802_15_4 */
447         { "IEEE 802.15.4 Wireless PAN", "wpan" },
448
449         /* WTAP_ENCAP_X2E_XORAYA */
450         { "X2E Xoraya", "x2e-xoraya" },
451
452         /* WTAP_ENCAP_FLEXRAY */
453         { "FlexRay", "flexray" },
454
455         /* WTAP_ENCAP_LIN */
456         { "Local Interconnect Network", "lin" },
457
458         /* WTAP_ENCAP_MOST */
459         { "Media Oriented Systems Transport", "most" },
460
461         /* WTAP_ENCAP_CAN20B */
462         { "Controller Area Network 2.0B", "can20b" },
463
464         /* WTAP_ENCAP_LAYER1_EVENT */
465         { "EyeSDN Layer 1 event", "layer1-event" },
466
467         /* WTAP_ENCAP_X2E_SERIAL */
468         { "X2E serial line capture", "x2e-serial" },
469
470         /* WTAP_ENCAP_I2C */
471         { "I2C", "i2c" },
472
473         /* WTAP_ENCAP_IEEE802_15_4_NONASK_PHY */
474         { "IEEE 802.15.4 Wireless PAN non-ASK PHY", "wpan-nonask-phy" },
475
476         /* WTAP_ENCAP_TNEF */
477         { "Transport-Neutral Encapsulation Format", "tnef" },
478
479         /* WTAP_ENCAP_USB_LINUX_MMAPPED */
480         { "USB packets with Linux header and padding", "usb-linux-mmap" },
481
482         /* WTAP_ENCAP_GSM_UM */
483         { "GSM Um Interface", "gsm_um" },
484
485         /* WTAP_ENCAP_DPNSS */
486         { "Digital Private Signalling System No 1 Link Layer", "dpnss_link" },
487
488         /* WTAP_ENCAP_PACKETLOGGER */
489         { "PacketLogger", "packetlogger" },
490
491         /* WTAP_ENCAP_NSTRACE_1_0 */
492         { "NetScaler Encapsulation 1.0 of Ethernet", "nstrace10" },
493
494         /* WTAP_ENCAP_NSTRACE_2_0 */
495         { "NetScaler Encapsulation 2.0 of Ethernet", "nstrace20" },
496
497         /* WTAP_ENCAP_FIBRE_CHANNEL_FC2 */
498         { "Fibre Channel FC-2", "fc2" },
499
500         /* WTAP_ENCAP_FIBRE_CHANNEL_FC2_WITH_FRAME_DELIMS */
501         { "Fibre Channel FC-2 With Frame Delimiter", "fc2sof"},
502
503         /* WTAP_ENCAP_JPEG_JFIF */
504         { "JPEG/JFIF", "jfif" },
505
506         /* WTAP_ENCAP_IPNET */
507         { "Solaris IPNET", "ipnet" },
508
509         /* WTAP_ENCAP_SOCKETCAN */
510         { "SocketCAN", "socketcan" },
511
512         /* WTAP_ENCAP_IEEE802_11_NETMON_RADIO */
513         { "IEEE 802.11 plus Network Monitor radio header", "ieee-802-11-netmon" },
514
515         /* WTAP_ENCAP_IEEE802_15_4_NOFCS */
516         { "IEEE 802.15.4 Wireless PAN with FCS not present", "wpan-nofcs" },
517
518         /* WTAP_ENCAP_RAW_IPFIX */
519         { "IPFIX", "ipfix" },
520
521         /* WTAP_ENCAP_RAW_IP4 */
522         { "Raw IPv4", "rawip4" },
523
524         /* WTAP_ENCAP_RAW_IP6 */
525         { "Raw IPv6", "rawip6" },
526
527         /* WTAP_ENCAP_LAPD */
528         { "Lapd header", "lapd" },
529
530         /* WTAP_ENCAP_DVBCI */
531         { "DVB-CI (Common Interface)", "dvbci"},
532
533         /* WTAP_ENCAP_MUX27010 */
534         { "MUX27010", "mux27010"},
535
536         /* WTAP_ENCAP_MIME */
537         { "MIME", "mime" },
538
539         /* WTAP_ENCAP_NETANALYZER */
540         { "netANALYZER", "netanalyzer" },
541
542         /* WTAP_ENCAP_NETANALYZER_TRANSPARENT */
543         { "netANALYZER-Transparent", "netanalyzer-transparent" },
544
545         /* WTAP_ENCAP_IP_OVER_IB */
546         { "IP over Infiniband", "ip-over-ib" },
547
548         /* WTAP_ENCAP_MPEG_2_TS */
549         { "ISO/IEC 13818-1 MPEG2-TS", "mp2ts" }
550 };
551
552 gint wtap_num_encap_types = sizeof(encap_table_base) / sizeof(struct encap_type_info);
553 static GArray* encap_table_arr = NULL;
554 static const struct encap_type_info* encap_table = NULL;
555
556 static void wtap_init_encap_types(void) {
557
558         if (encap_table_arr) return;
559
560         encap_table_arr = g_array_new(FALSE,TRUE,sizeof(struct encap_type_info));
561
562         g_array_append_vals(encap_table_arr,encap_table_base,wtap_num_encap_types);
563
564         encap_table = (void*)encap_table_arr->data;
565 }
566
567 int wtap_get_num_encap_types(void) {
568         wtap_init_encap_types();
569         return wtap_num_encap_types;
570 }
571
572
573 int wtap_register_encap_type(char* name, char* short_name) {
574         struct encap_type_info e;
575         wtap_init_encap_types();
576
577         e.name = g_strdup(name);
578         e.short_name = g_strdup(short_name);
579
580         g_array_append_val(encap_table_arr,e);
581
582         encap_table = (void*)encap_table_arr->data;
583
584         return wtap_num_encap_types++;
585 }
586
587
588 /* Name that should be somewhat descriptive. */
589 const char
590 *wtap_encap_string(int encap)
591 {
592         if (encap < WTAP_ENCAP_PER_PACKET || encap >= WTAP_NUM_ENCAP_TYPES)
593                 return "Illegal";
594         else if (encap == WTAP_ENCAP_PER_PACKET)
595                 return "Per packet";
596         else
597                 return encap_table[encap].name;
598 }
599
600 /* Name to use in, say, a command-line flag specifying the type. */
601 const char
602 *wtap_encap_short_string(int encap)
603 {
604         if (encap < WTAP_ENCAP_PER_PACKET || encap >= WTAP_NUM_ENCAP_TYPES)
605                 return "illegal";
606         else if (encap == WTAP_ENCAP_PER_PACKET)
607                 return "per-packet";
608         else
609                 return encap_table[encap].short_name;
610 }
611
612 /* Translate a short name to a capture file type. */
613 int
614 wtap_short_string_to_encap(const char *short_name)
615 {
616         int encap;
617
618         for (encap = 0; encap < WTAP_NUM_ENCAP_TYPES; encap++) {
619                 if (encap_table[encap].short_name != NULL &&
620                     strcmp(short_name, encap_table[encap].short_name) == 0)
621                         return encap;
622         }
623         return -1;      /* no such encapsulation type */
624 }
625
626 static const char *wtap_errlist[] = {
627         "The file isn't a plain file or pipe",
628         "The file is being opened for random access but is a pipe",
629         "The file isn't a capture file in a known format",
630         "File contains record data we don't support",
631         "That file format cannot be written to a pipe",
632         NULL,
633         "Files can't be saved in that format",
634         "Files from that network type can't be saved in that format",
635         "That file format doesn't support per-packet encapsulations",
636         NULL,
637         NULL,
638         "Less data was read than was expected",
639         "The file appears to be damaged or corrupt.",
640         "Less data was written than was requested",
641         "Uncompression error: data oddly truncated",
642         "Uncompression error: data would overflow buffer",
643         "Uncompression error: bad LZ77 offset",
644         "The standard input cannot be opened for random access",
645         "That file format doesn't support compression",
646         NULL,
647         "Uncompression error",
648         "Internal error"
649 };
650 #define WTAP_ERRLIST_SIZE       (sizeof wtap_errlist / sizeof wtap_errlist[0])
651
652 const char
653 *wtap_strerror(int err)
654 {
655         static char errbuf[128];
656         unsigned int wtap_errlist_index;
657
658         if (err < 0) {
659                 wtap_errlist_index = -1 - err;
660                 if (wtap_errlist_index >= WTAP_ERRLIST_SIZE) {
661                         g_snprintf(errbuf, 128, "Error %d", err);
662                         return errbuf;
663                 }
664                 if (wtap_errlist[wtap_errlist_index] == NULL)
665                         return "Unknown reason";
666                 return wtap_errlist[wtap_errlist_index];
667         } else
668                 return g_strerror(err);
669 }
670
671 /* Close only the sequential side, freeing up memory it uses.
672
673    Note that we do *not* want to call the subtype's close function,
674    as it would free any per-subtype data, and that data may be
675    needed by the random-access side.
676
677    Instead, if the subtype has a "sequential close" function, we call it,
678    to free up stuff used only by the sequential side. */
679 void
680 wtap_sequential_close(wtap *wth)
681 {
682         if (wth->subtype_sequential_close != NULL)
683                 (*wth->subtype_sequential_close)(wth);
684
685         if (wth->fh != NULL) {
686                 file_close(wth->fh);
687                 wth->fh = NULL;
688         }
689
690         if (wth->frame_buffer) {
691                 buffer_free(wth->frame_buffer);
692                 g_free(wth->frame_buffer);
693                 wth->frame_buffer = NULL;
694         }
695 }
696
697 static void
698 g_fast_seek_item_free(gpointer data, gpointer user_data _U_)
699 {
700         g_free(data);
701 }
702
703 void
704 wtap_close(wtap *wth)
705 {
706         wtap_sequential_close(wth);
707
708         if (wth->subtype_close != NULL)
709                 (*wth->subtype_close)(wth);
710
711         if (wth->random_fh != NULL)
712                 file_close(wth->random_fh);
713
714         if (wth->priv != NULL)
715                 g_free(wth->priv);
716
717         if (wth->fast_seek != NULL) {
718                 g_ptr_array_foreach(wth->fast_seek, g_fast_seek_item_free, NULL);
719                 g_ptr_array_free(wth->fast_seek, TRUE);
720         }
721         g_free(wth);
722 }
723
724 void
725 wtap_cleareof(wtap *wth) {
726         /* Reset EOF */
727         file_clearerr(wth->fh);
728 }
729
730 void wtap_set_cb_new_ipv4(wtap *wth, wtap_new_ipv4_callback_t add_new_ipv4) {
731         if (wth)
732                 wth->add_new_ipv4 = add_new_ipv4;
733 }
734
735 void wtap_set_cb_new_ipv6(wtap *wth, wtap_new_ipv6_callback_t add_new_ipv6) {
736         if (wth)
737                 wth->add_new_ipv6 = add_new_ipv6;
738 }
739
740 gboolean
741 wtap_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
742 {
743         /*
744          * Set the packet encapsulation to the file's encapsulation
745          * value; if that's not WTAP_ENCAP_PER_PACKET, it's the
746          * right answer (and means that the read routine for this
747          * capture file type doesn't have to set it), and if it
748          * *is* WTAP_ENCAP_PER_PACKET, the caller needs to set it
749          * anyway.
750          */
751         wth->phdr.pkt_encap = wth->file_encap;
752
753         if (!wth->subtype_read(wth, err, err_info, data_offset)) {
754                 /*
755                  * If we didn't get an error indication, we read
756                  * the last packet.  See if there's any deferred
757                  * error, as might, for example, occur if we're
758                  * reading a compressed file, and we got an error
759                  * reading compressed data from the file, but
760                  * got enough compressed data to decompress the
761                  * last packet of the file.
762                  */
763                 if (*err == 0)
764                         *err = file_error(wth->fh, err_info);
765                 return FALSE;   /* failure */
766         }
767
768         /*
769          * It makes no sense for the captured data length to be bigger
770          * than the actual data length.
771          */
772         if (wth->phdr.caplen > wth->phdr.len)
773                 wth->phdr.caplen = wth->phdr.len;
774
775         /*
776          * Make sure that it's not WTAP_ENCAP_PER_PACKET, as that
777          * probably means the file has that encapsulation type
778          * but the read routine didn't set this packet's
779          * encapsulation type.
780          */
781         g_assert(wth->phdr.pkt_encap != WTAP_ENCAP_PER_PACKET);
782
783         return TRUE;    /* success */
784 }
785
786 /*
787  * Return an approximation of the amount of data we've read sequentially
788  * from the file so far.  (gint64, in case that's 64 bits.)
789  */
790 gint64
791 wtap_read_so_far(wtap *wth)
792 {
793         return file_tell_raw(wth->fh);
794 }
795
796 struct wtap_pkthdr*
797 wtap_phdr(wtap *wth)
798 {
799         return &wth->phdr;
800 }
801
802 union wtap_pseudo_header*
803 wtap_pseudoheader(wtap *wth)
804 {
805         return &wth->pseudo_header;
806 }
807
808 guint8*
809 wtap_buf_ptr(wtap *wth)
810 {
811         return buffer_start_ptr(wth->frame_buffer);
812 }
813
814 gboolean
815 wtap_seek_read(wtap *wth, gint64 seek_off,
816         union wtap_pseudo_header *pseudo_header, guint8 *pd, int len,
817         int *err, gchar **err_info)
818 {
819         return wth->subtype_seek_read(wth, seek_off, pseudo_header, pd, len,
820                 err, err_info);
821 }