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