On Windows, do the appropriate DLL exporting and importing.

diff --git a/Makefile.in b/Makefile.in
index ac719e9d3e08a8f56c1ca93a37a01cb1800205b9..87dd8b56c26bad3370c5528384460a76b2ef8017 100644 (file)
--- a/Makefile.in
+++ b/Makefile.in
@@ -49,7 +49,7 @@ LN_S = @LN_S@
 MKDEP = @MKDEP@
 CCOPT = @V_CCOPT@
 INCLS = -I. @V_INCLS@
-DEFS = @DEFS@ @V_DEFS@
+DEFS = -DLIBPCAP_EXPORTS @DEFS@ @V_DEFS@
 ADDLOBJS = @ADDLOBJS@
 ADDLARCHIVEOBJS = @ADDLARCHIVEOBJS@
 LIBS = @LIBS@

diff --git a/pcap/pcap.h b/pcap/pcap.h
index b4520a7b6bbf936a9f09955536616eb2b0b346ba..104adcb1ba85e8321f276dac7acaeec747bf521c 100644 (file)
--- a/pcap/pcap.h
+++ b/pcap/pcap.h
@@ -37,12 +37,25 @@
 
 #if defined(_WIN32)
   #include <pcap-stdinc.h>
+  #ifdef LIBPCAP_EXPORTS
+    /*
+     * We're compiling libpcap, so we should export functions in our
+     * API.
+     */
+    #define PCAP_API   __declspec(dllexport)
+  #else
+    #define PCAP_API   __declspec(dllimport)
+  #endif
 #elif defined(MSDOS)
   #include <sys/types.h>
   #include <sys/socket.h>  /* u_int, u_char etc. */
+
+  /* XXX - does this need special treatment? */
+  #define PCAP_API     extern
 #else /* UN*X */
   #include <sys/types.h>
   #include <sys/time.h>
+  #define PCAP_API     extern
 #endif /* _WIN32/MSDOS/UN*X */
 
 #ifndef PCAP_DONT_INCLUDE_PCAP_BPF_H
@@ -273,27 +286,27 @@ typedef void (*pcap_handler)(u_char *, const struct pcap_pkthdr *,
  */
 #define PCAP_NETMASK_UNKNOWN   0xffffffff
 
-char   *pcap_lookupdev(char *);
-int    pcap_lookupnet(const char *, bpf_u_int32 *, bpf_u_int32 *, char *);
-
-pcap_t *pcap_create(const char *, char *);
-int    pcap_set_snaplen(pcap_t *, int);
-int    pcap_set_promisc(pcap_t *, int);
-int    pcap_can_set_rfmon(pcap_t *);
-int    pcap_set_rfmon(pcap_t *, int);
-int    pcap_set_timeout(pcap_t *, int);
-int    pcap_set_tstamp_type(pcap_t *, int);
-int    pcap_set_immediate_mode(pcap_t *, int);
-int    pcap_set_buffer_size(pcap_t *, int);
-int    pcap_set_tstamp_precision(pcap_t *, int);
-int    pcap_get_tstamp_precision(pcap_t *);
-int    pcap_activate(pcap_t *);
-
-int    pcap_list_tstamp_types(pcap_t *, int **);
-void   pcap_free_tstamp_types(int *);
-int    pcap_tstamp_type_name_to_val(const char *);
-const char *pcap_tstamp_type_val_to_name(int);
-const char *pcap_tstamp_type_val_to_description(int);
+PCAP_API char  *pcap_lookupdev(char *);
+PCAP_API int   pcap_lookupnet(const char *, bpf_u_int32 *, bpf_u_int32 *, char *);
+
+PCAP_API pcap_t        *pcap_create(const char *, char *);
+PCAP_API int   pcap_set_snaplen(pcap_t *, int);
+PCAP_API int   pcap_set_promisc(pcap_t *, int);
+PCAP_API int   pcap_can_set_rfmon(pcap_t *);
+PCAP_API int   pcap_set_rfmon(pcap_t *, int);
+PCAP_API int   pcap_set_timeout(pcap_t *, int);
+PCAP_API int   pcap_set_tstamp_type(pcap_t *, int);
+PCAP_API int   pcap_set_immediate_mode(pcap_t *, int);
+PCAP_API int   pcap_set_buffer_size(pcap_t *, int);
+PCAP_API int   pcap_set_tstamp_precision(pcap_t *, int);
+PCAP_API int   pcap_get_tstamp_precision(pcap_t *);
+PCAP_API int   pcap_activate(pcap_t *);
+
+PCAP_API int   pcap_list_tstamp_types(pcap_t *, int **);
+PCAP_API void  pcap_free_tstamp_types(int *);
+PCAP_API int   pcap_tstamp_type_name_to_val(const char *);
+PCAP_API const char *pcap_tstamp_type_val_to_name(int);
+PCAP_API const char *pcap_tstamp_type_val_to_description(int);
 
 /*
  * Time stamp types.
@@ -348,87 +361,87 @@ const char *pcap_tstamp_type_val_to_description(int);
 #define PCAP_TSTAMP_PRECISION_MICRO    0       /* use timestamps with microsecond precision, default */
 #define PCAP_TSTAMP_PRECISION_NANO     1       /* use timestamps with nanosecond precision */
 
-pcap_t *pcap_open_live(const char *, int, int, int, char *);
-pcap_t *pcap_open_dead(int, int);
-pcap_t *pcap_open_dead_with_tstamp_precision(int, int, u_int);
-pcap_t *pcap_open_offline_with_tstamp_precision(const char *, u_int, char *);
-pcap_t *pcap_open_offline(const char *, char *);
-#if defined(_WIN32)
-pcap_t  *pcap_hopen_offline_with_tstamp_precision(intptr_t, u_int, char *);
-pcap_t  *pcap_hopen_offline(intptr_t, char *);
-#if !defined(LIBPCAP_EXPORTS)
-#define pcap_fopen_offline_with_tstamp_precision(f,p,b) \
+PCAP_API pcap_t        *pcap_open_live(const char *, int, int, int, char *);
+PCAP_API pcap_t        *pcap_open_dead(int, int);
+PCAP_API pcap_t        *pcap_open_dead_with_tstamp_precision(int, int, u_int);
+PCAP_API pcap_t        *pcap_open_offline_with_tstamp_precision(const char *, u_int, char *);
+PCAP_API pcap_t        *pcap_open_offline(const char *, char *);
+#ifdef _WIN32
+  PCAP_API pcap_t  *pcap_hopen_offline_with_tstamp_precision(intptr_t, u_int, char *);
+  PCAP_API pcap_t  *pcap_hopen_offline(intptr_t, char *);
+  /*
+   * If we're building libpcap, these are internal routines in savefile.c,
+   * so we mustn't define them as macros.
+   */
+  #ifndef LIBPCAP_EXPORTS
+    #define pcap_fopen_offline_with_tstamp_precision(f,p,b) \
        pcap_hopen_offline_with_tstamp_precision(_get_osfhandle(_fileno(f)), p, b)
-#define pcap_fopen_offline(f,b) \
+    #define pcap_fopen_offline(f,b) \
        pcap_hopen_offline(_get_osfhandle(_fileno(f)), b)
-#else /*LIBPCAP_EXPORTS*/
-static pcap_t *pcap_fopen_offline_with_tstamp_precision(FILE *, u_int, char *);
-static pcap_t *pcap_fopen_offline(FILE *, char *);
-#endif
+  #endif
 #else /*_WIN32*/
-pcap_t *pcap_fopen_offline_with_tstamp_precision(FILE *, u_int, char *);
-pcap_t *pcap_fopen_offline(FILE *, char *);
+  PCAP_API pcap_t      *pcap_fopen_offline_with_tstamp_precision(FILE *, u_int, char *);
+  PCAP_API pcap_t      *pcap_fopen_offline(FILE *, char *);
 #endif /*_WIN32*/
 
-void   pcap_close(pcap_t *);
-int    pcap_loop(pcap_t *, int, pcap_handler, u_char *);
-int    pcap_dispatch(pcap_t *, int, pcap_handler, u_char *);
-const u_char*
-       pcap_next(pcap_t *, struct pcap_pkthdr *);
-int    pcap_next_ex(pcap_t *, struct pcap_pkthdr **, const u_char **);
-void   pcap_breakloop(pcap_t *);
-int    pcap_stats(pcap_t *, struct pcap_stat *);
-int    pcap_setfilter(pcap_t *, struct bpf_program *);
-int    pcap_setdirection(pcap_t *, pcap_direction_t);
-int    pcap_getnonblock(pcap_t *, char *);
-int    pcap_setnonblock(pcap_t *, int, char *);
-int    pcap_inject(pcap_t *, const void *, size_t);
-int    pcap_sendpacket(pcap_t *, const u_char *, int);
-const char *pcap_statustostr(int);
-const char *pcap_strerror(int);
-char   *pcap_geterr(pcap_t *);
-void   pcap_perror(pcap_t *, char *);
-int    pcap_compile(pcap_t *, struct bpf_program *, const char *, int,
+PCAP_API void  pcap_close(pcap_t *);
+PCAP_API int   pcap_loop(pcap_t *, int, pcap_handler, u_char *);
+PCAP_API int   pcap_dispatch(pcap_t *, int, pcap_handler, u_char *);
+PCAP_API const u_char *pcap_next(pcap_t *, struct pcap_pkthdr *);
+PCAP_API int   pcap_next_ex(pcap_t *, struct pcap_pkthdr **, const u_char **);
+PCAP_API void  pcap_breakloop(pcap_t *);
+PCAP_API int   pcap_stats(pcap_t *, struct pcap_stat *);
+PCAP_API int   pcap_setfilter(pcap_t *, struct bpf_program *);
+PCAP_API int   pcap_setdirection(pcap_t *, pcap_direction_t);
+PCAP_API int   pcap_getnonblock(pcap_t *, char *);
+PCAP_API int   pcap_setnonblock(pcap_t *, int, char *);
+PCAP_API int   pcap_inject(pcap_t *, const void *, size_t);
+PCAP_API int   pcap_sendpacket(pcap_t *, const u_char *, int);
+PCAP_API const char *pcap_statustostr(int);
+PCAP_API const char *pcap_strerror(int);
+PCAP_API char  *pcap_geterr(pcap_t *);
+PCAP_API void  pcap_perror(pcap_t *, char *);
+PCAP_API int   pcap_compile(pcap_t *, struct bpf_program *, const char *, int,
            bpf_u_int32);
-int    pcap_compile_nopcap(int, int, struct bpf_program *,
+PCAP_API int   pcap_compile_nopcap(int, int, struct bpf_program *,
            const char *, int, bpf_u_int32);
-void   pcap_freecode(struct bpf_program *);
-int    pcap_offline_filter(const struct bpf_program *,
+PCAP_API void  pcap_freecode(struct bpf_program *);
+PCAP_API int   pcap_offline_filter(const struct bpf_program *,
            const struct pcap_pkthdr *, const u_char *);
-int    pcap_datalink(pcap_t *);
-int    pcap_datalink_ext(pcap_t *);
-int    pcap_list_datalinks(pcap_t *, int **);
-int    pcap_set_datalink(pcap_t *, int);
-void   pcap_free_datalinks(int *);
-int    pcap_datalink_name_to_val(const char *);
-const char *pcap_datalink_val_to_name(int);
-const char *pcap_datalink_val_to_description(int);
-int    pcap_snapshot(pcap_t *);
-int    pcap_is_swapped(pcap_t *);
-int    pcap_major_version(pcap_t *);
-int    pcap_minor_version(pcap_t *);
+PCAP_API int   pcap_datalink(pcap_t *);
+PCAP_API int   pcap_datalink_ext(pcap_t *);
+PCAP_API int   pcap_list_datalinks(pcap_t *, int **);
+PCAP_API int   pcap_set_datalink(pcap_t *, int);
+PCAP_API void  pcap_free_datalinks(int *);
+PCAP_API int   pcap_datalink_name_to_val(const char *);
+PCAP_API const char *pcap_datalink_val_to_name(int);
+PCAP_API const char *pcap_datalink_val_to_description(int);
+PCAP_API int   pcap_snapshot(pcap_t *);
+PCAP_API int   pcap_is_swapped(pcap_t *);
+PCAP_API int   pcap_major_version(pcap_t *);
+PCAP_API int   pcap_minor_version(pcap_t *);
 
 /* XXX */
-FILE   *pcap_file(pcap_t *);
-int    pcap_fileno(pcap_t *);
+PCAP_API FILE  *pcap_file(pcap_t *);
+PCAP_API int   pcap_fileno(pcap_t *);
 
 #ifdef _WIN32
-int    pcap_wsockinit(void);
+  PCAP_API int pcap_wsockinit(void);
 #endif
 
-pcap_dumper_t *pcap_dump_open(pcap_t *, const char *);
-pcap_dumper_t *pcap_dump_fopen(pcap_t *, FILE *fp);
-pcap_dumper_t *pcap_dump_open_append(pcap_t *, const char *);
-FILE   *pcap_dump_file(pcap_dumper_t *);
-long   pcap_dump_ftell(pcap_dumper_t *);
-int    pcap_dump_flush(pcap_dumper_t *);
-void   pcap_dump_close(pcap_dumper_t *);
-void   pcap_dump(u_char *, const struct pcap_pkthdr *, const u_char *);
+PCAP_API pcap_dumper_t *pcap_dump_open(pcap_t *, const char *);
+PCAP_API pcap_dumper_t *pcap_dump_fopen(pcap_t *, FILE *fp);
+PCAP_API pcap_dumper_t *pcap_dump_open_append(pcap_t *, const char *);
+PCAP_API FILE  *pcap_dump_file(pcap_dumper_t *);
+PCAP_API long  pcap_dump_ftell(pcap_dumper_t *);
+PCAP_API int   pcap_dump_flush(pcap_dumper_t *);
+PCAP_API void  pcap_dump_close(pcap_dumper_t *);
+PCAP_API void  pcap_dump(u_char *, const struct pcap_pkthdr *, const u_char *);
 
-int    pcap_findalldevs(pcap_if_t **, char *);
-void   pcap_freealldevs(pcap_if_t *);
+PCAP_API int   pcap_findalldevs(pcap_if_t **, char *);
+PCAP_API void  pcap_freealldevs(pcap_if_t *);
 
-const char *pcap_lib_version(void);
+PCAP_API const char *pcap_lib_version(void);
 
 /*
  * On at least some versions of NetBSD and QNX, we don't want to declare
@@ -438,89 +451,89 @@ const char *pcap_lib_version(void);
  * declared when we build pcap-bpf.c.
  */
 #if !defined(__NetBSD__) && !defined(__QNX__)
-u_int  bpf_filter(const struct bpf_insn *, const u_char *, u_int, u_int);
+  PCAP_API u_int       bpf_filter(const struct bpf_insn *, const u_char *, u_int, u_int);
 #endif
-int    bpf_validate(const struct bpf_insn *f, int len);
-char   *bpf_image(const struct bpf_insn *, int);
-void   bpf_dump(const struct bpf_program *, int);
+PCAP_API int   bpf_validate(const struct bpf_insn *f, int len);
+PCAP_API char  *bpf_image(const struct bpf_insn *, int);
+PCAP_API void  bpf_dump(const struct bpf_program *, int);
 
 #if defined(_WIN32)
 
-/*
- * Win32 definitions
- */
+  /*
+   * Win32 definitions
+   */
 
-/*!
-  \brief A queue of raw packets that will be sent to the network with pcap_sendqueue_transmit().
-*/
-struct pcap_send_queue
-{
+  /*!
+    \brief A queue of raw packets that will be sent to the network with pcap_sendqueue_transmit().
+  */
+  struct pcap_send_queue
+  {
        u_int maxlen;   /* Maximum size of the the queue, in bytes. This
                           variable contains the size of the buffer field. */
        u_int len;      /* Current size of the queue, in bytes. */
        char *buffer;   /* Buffer containing the packets to be sent. */
-};
+  };
 
-typedef struct pcap_send_queue pcap_send_queue;
+  typedef struct pcap_send_queue pcap_send_queue;
 
-/*!
-  \brief This typedef is a support for the pcap_get_airpcap_handle() function
-*/
-#if !defined(AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_)
-#define AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_
-typedef struct _AirpcapHandle *PAirpcapHandle;
-#endif
+  /*!
+    \brief This typedef is a support for the pcap_get_airpcap_handle() function
+  */
+  #if !defined(AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_)
+    #define AIRPCAP_HANDLE__EAE405F5_0171_9592_B3C2_C19EC426AD34__DEFINED_
+    typedef struct _AirpcapHandle *PAirpcapHandle;
+  #endif
 
-int pcap_setbuff(pcap_t *p, int dim);
-int pcap_setmode(pcap_t *p, int mode);
-int pcap_setmintocopy(pcap_t *p, int size);
+  PCAP_API int pcap_setbuff(pcap_t *p, int dim);
+  PCAP_API int pcap_setmode(pcap_t *p, int mode);
+  PCAP_API int pcap_setmintocopy(pcap_t *p, int size);
 
-HANDLE pcap_getevent(pcap_t *p);
+  PCAP_API HANDLE pcap_getevent(pcap_t *p);
 
-int pcap_oid_get_request(pcap_t *, bpf_u_int32, void *, size_t);
-int pcap_oid_set_request(pcap_t *, bpf_u_int32, const void *, size_t);
+  PCAP_API int pcap_oid_get_request(pcap_t *, bpf_u_int32, void *, size_t);
+  PCAP_API int pcap_oid_set_request(pcap_t *, bpf_u_int32, const void *, size_t);
 
-pcap_send_queue* pcap_sendqueue_alloc(u_int memsize);
+  PCAP_API pcap_send_queue* pcap_sendqueue_alloc(u_int memsize);
 
-void pcap_sendqueue_destroy(pcap_send_queue* queue);
+  PCAP_API void pcap_sendqueue_destroy(pcap_send_queue* queue);
 
-int pcap_sendqueue_queue(pcap_send_queue* queue, const struct pcap_pkthdr *pkt_header, const u_char *pkt_data);
+  PCAP_API int pcap_sendqueue_queue(pcap_send_queue* queue, const struct pcap_pkthdr *pkt_header, const u_char *pkt_data);
 
-u_int pcap_sendqueue_transmit(pcap_t *p, pcap_send_queue* queue, int sync);
+  PCAP_API u_int pcap_sendqueue_transmit(pcap_t *p, pcap_send_queue* queue, int sync);
 
-struct pcap_stat *pcap_stats_ex(pcap_t *p, int *pcap_stat_size);
+  PCAP_API struct pcap_stat *pcap_stats_ex(pcap_t *p, int *pcap_stat_size);
 
-int pcap_setuserbuffer(pcap_t *p, int size);
+  PCAP_API int pcap_setuserbuffer(pcap_t *p, int size);
 
-int pcap_live_dump(pcap_t *p, char *filename, int maxsize, int maxpacks);
+  PCAP_API int pcap_live_dump(pcap_t *p, char *filename, int maxsize, int maxpacks);
 
-int pcap_live_dump_ended(pcap_t *p, int sync);
+  PCAP_API int pcap_live_dump_ended(pcap_t *p, int sync);
 
-int pcap_start_oem(char* err_str, int flags);
+  PCAP_API int pcap_start_oem(char* err_str, int flags);
 
-PAirpcapHandle pcap_get_airpcap_handle(pcap_t *p);
+  PCAP_API PAirpcapHandle pcap_get_airpcap_handle(pcap_t *p);
 
-#define MODE_CAPT 0
-#define MODE_STAT 1
-#define MODE_MON 2
+  #define MODE_CAPT 0
+  #define MODE_STAT 1
+  #define MODE_MON 2
 
 #elif defined(MSDOS)
 
-/*
- * MS-DOS definitions
- */
+  /*
+   * MS-DOS definitions
+   */
 
-int  pcap_stats_ex (pcap_t *, struct pcap_stat_ex *);
-void pcap_set_wait (pcap_t *p, void (*yield)(void), int wait);
-u_long pcap_mac_packets (void);
+  PCAP_API int  pcap_stats_ex (pcap_t *, struct pcap_stat_ex *);
+  PCAP_API void pcap_set_wait (pcap_t *p, void (*yield)(void), int wait);
+  PCAP_API u_long pcap_mac_packets (void);
 
 #else /* UN*X */
 
-/*
- * UN*X definitions
- */
+  /*
+   * UN*X definitions
+   */
 
-int    pcap_get_selectable_fd(pcap_t *);
+  PCAP_API int pcap_get_selectable_fd(pcap_t *);
 
 #endif /* _WIN32/MSDOS/UN*X */
 

diff --git a/savefile.c b/savefile.c
index b8d1d305805436a17af8353c00b078cd3716f0e4..5d9429c462d0f508c8970447e11ef7f7772662b0 100644 (file)
--- a/savefile.c
+++ b/savefile.c
@@ -62,6 +62,23 @@
 #include "sf-pcap.h"
 #include "sf-pcap-ng.h"
 
+#ifdef _WIN32
+/*
+ * These aren't exported on Windows, because they would only work if both
+ * WinPcap and the code using it were to use the Universal CRT; otherwise,
+ * a FILE structure in WinPcap and a FILE structure in the code using it
+ * could be different if they're using different versions of the C runtime.
+ *
+ * Instead, pcap/pcap.h defines them as macros that wrap the hopen versions,
+ * with the wrappers calling _fileno() and _get_osfhandle() themselves,
+ * so that they convert the appropriate CRT version's FILE structure to
+ * a HANDLE (which is OS-defined, not CRT-defined, and is part of the Win32
+ * and Win64 ABIs).
+ */
+static pcap_t *pcap_fopen_offline_with_tstamp_precision(FILE *, u_int, char *);
+static pcap_t *pcap_fopen_offline(FILE *, char *);
+#endif
+
 /*
  * Setting O_BINARY on DOS/Windows is a bit tricky
  */