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