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