[PATCH 1/2] wpcap: Wrap native handles in a structure.

[Hans Leidekker]

Signed-off-by: Hans Leidekker 
---
 dlls/wpcap/unixlib.c | 150 +++++++++++++++++---------------
 dlls/wpcap/unixlib.h |  73 +++++++++-------
 dlls/wpcap/wpcap.c   | 200 +++++++++++++++++++++----------------------
 3 files changed, 222 insertions(+), 201 deletions(-)

diff --git a/dlls/wpcap/unixlib.c b/dlls/wpcap/unixlib.c
index f3eb06a2849..b48a5540edc 100644
--- a/dlls/wpcap/unixlib.c
+++ b/dlls/wpcap/unixlib.c
@@ -27,6 +27,7 @@
 #include <pcap/pcap.h>

#include <stdarg.h>
+#include <stdlib.h>
 #include "ntstatus.h"
 #define WIN32_NO_STATUS
 #include "windef.h"
@@ -40,39 +41,46 @@ WINE_DECLARE_DEBUG_CHANNEL(winediag);

static const struct pcap_callbacks *callbacks;

-static int CDECL wrap_activate( void *handle )
+static int CDECL wrap_activate( struct pcap *pcap )
 {
-    return pcap_activate( handle );
+    return pcap_activate( pcap->handle );
 }

-static void CDECL wrap_breakloop( void *handle )
+static void CDECL wrap_breakloop( struct pcap *pcap )
 {
-    return pcap_breakloop( handle );
+    return pcap_breakloop( pcap->handle );
 }

-static int CDECL wrap_can_set_rfmon( void *handle )
+static int CDECL wrap_can_set_rfmon( struct pcap *pcap )
 {
-    return pcap_can_set_rfmon( handle );
+    return pcap_can_set_rfmon( pcap->handle );
 }

-static void CDECL wrap_close( void *handle )
+static void CDECL wrap_close( struct pcap *pcap )
 {
-    pcap_close( handle );
+    pcap_close( pcap->handle );
+    free( pcap );
 }

-static int CDECL wrap_compile( void *handle, void *program, const char *buf, int optimize, unsigned int mask )
+static int CDECL wrap_compile( struct pcap *pcap, void *program, const char *buf, int optimize, unsigned int mask )
 {
-    return pcap_compile( handle, program, buf, optimize, mask );
+    return pcap_compile( pcap->handle, program, buf, optimize, mask );
 }

-static void * CDECL wrap_create( const char *src, char *errbuf )
+static struct pcap * CDECL wrap_create( const char *src, char *errbuf )
 {
-    return pcap_create( src, errbuf );
+    struct pcap *ret = malloc( sizeof(*ret) );
+    if (ret && !(ret->handle = pcap_create( src, errbuf )))
+    {
+        free( ret );
+        return NULL;
+    }
+    return ret;
 }

-static int CDECL wrap_datalink( void *handle )
+static int CDECL wrap_datalink( struct pcap *pcap )
 {
-    return pcap_datalink( handle );
+    return pcap_datalink( pcap->handle );
 }

static int CDECL wrap_datalink_name_to_val( const char *name )
@@ -96,7 +104,7 @@ static void wrap_pcap_handler( unsigned char *user, const struct pcap_pkthdr *hd
     callbacks->handler( cb, hdr, packet );
 }

-static int CDECL wrap_dispatch( void *handle, int count,
+static int CDECL wrap_dispatch( struct pcap *pcap, int count,
                                 void (CALLBACK *callback)(unsigned char *, const void *, const unsigned char *),
                                 unsigned char *user )
 {
@@ -105,9 +113,9 @@ static int CDECL wrap_dispatch( void *handle, int count,
         struct handler_callback cb;
         cb.callback = callback;
         cb.user     = user;
-        return pcap_dispatch( handle, count, wrap_pcap_handler, (unsigned char *)&cb );
+        return pcap_dispatch( pcap->handle, count, wrap_pcap_handler, (unsigned char *)&cb );
     }
-    return pcap_dispatch( handle, count, NULL, user );
+    return pcap_dispatch( pcap->handle, count, NULL, user );
 }

static void CDECL wrap_dump( unsigned char *user, const void *hdr, const unsigned char *packet )
@@ -115,9 +123,9 @@ static void CDECL wrap_dump( unsigned char *user, const void *hdr, const unsigne
     return pcap_dump( user, hdr, packet );
 }

-static void * CDECL wrap_dump_open( void *handle, const char *name )
+static void * CDECL wrap_dump_open( struct pcap *pcap, const char *name )
 {
-    return pcap_dump_open( handle, name );
+    return pcap_dump_open( pcap->handle, name );
 }

static int CDECL wrap_findalldevs( struct pcap_if_hdr **devs, char *errbuf )
@@ -149,19 +157,19 @@ static void CDECL wrap_freecode( void *program )
     return pcap_freecode( program );
 }

-static int CDECL wrap_get_tstamp_precision( void *handle )
+static int CDECL wrap_get_tstamp_precision( struct pcap *pcap )
 {
-    return pcap_get_tstamp_precision( handle );
+    return pcap_get_tstamp_precision( pcap->handle );
 }

-static char * CDECL wrap_geterr( void *handle )
+static char * CDECL wrap_geterr( struct pcap *pcap )
 {
-    return pcap_geterr( handle );
+    return pcap_geterr( pcap->handle );
 }

-static int CDECL wrap_getnonblock( void *handle, char *errbuf )
+static int CDECL wrap_getnonblock( struct pcap *pcap, char *errbuf )
 {
-    return pcap_getnonblock( handle, errbuf );
+    return pcap_getnonblock( pcap->handle, errbuf );
 }

static const char * CDECL wrap_lib_version( void )
@@ -169,14 +177,14 @@ static const char * CDECL wrap_lib_version( void )
     return pcap_lib_version();
 }

-static int CDECL wrap_list_datalinks( void *handle, int **buf )
+static int CDECL wrap_list_datalinks( struct pcap *pcap, int **buf )
 {
-    return pcap_list_datalinks( handle, buf );
+    return pcap_list_datalinks( pcap->handle, buf );
 }

-static int CDECL wrap_list_tstamp_types( void *handle, int **types )
+static int CDECL wrap_list_tstamp_types( struct pcap *pcap, int **types )
 {
-    return pcap_list_tstamp_types( handle, types );
+    return pcap_list_tstamp_types( pcap->handle, types );
 }

static int CDECL wrap_lookupnet( const char *device, unsigned int *net, unsigned int *mask, char *errbuf )
@@ -184,7 +192,7 @@ static int CDECL wrap_lookupnet( const char *device, unsigned int *net, unsigned
     return pcap_lookupnet( device, net, mask, errbuf );
 }

-static int CDECL wrap_loop( void *handle, int count,
+static int CDECL wrap_loop( struct pcap *pcap, int count,
                             void (CALLBACK *callback)(unsigned char *, const void *, const unsigned char *),
                             unsigned char *user )
 {
@@ -193,99 +201,105 @@ static int CDECL wrap_loop( void *handle, int count,
         struct handler_callback cb;
         cb.callback = callback;
         cb.user     = user;
-        return pcap_loop( handle, count, wrap_pcap_handler, (unsigned char *)&cb );
+        return pcap_loop( pcap->handle, count, wrap_pcap_handler, (unsigned char *)&cb );
     }
-    return pcap_loop( handle, count, NULL, user );
+    return pcap_loop( pcap->handle, count, NULL, user );
 }

-static int CDECL wrap_major_version( void *handle )
+static int CDECL wrap_major_version( struct pcap *pcap )
 {
-    return pcap_major_version( handle );
+    return pcap_major_version( pcap->handle );
 }

-static int CDECL wrap_minor_version( void *handle )
+static int CDECL wrap_minor_version( struct pcap *pcap )
 {
-    return pcap_minor_version( handle );
+    return pcap_minor_version( pcap->handle );
 }

-static const unsigned char * CDECL wrap_next( void *handle, void *hdr )
+static const unsigned char * CDECL wrap_next( struct pcap *pcap, void *hdr )
 {
-    return pcap_next( handle, hdr );
+    return pcap_next( pcap->handle, hdr );
 }

-static int CDECL wrap_next_ex( void *handle, void **hdr, const unsigned char **data )
+static int CDECL wrap_next_ex( struct pcap *pcap, void **hdr, const unsigned char **data )
 {
-    return pcap_next_ex( handle, (struct pcap_pkthdr **)hdr, data );
+    return pcap_next_ex( pcap->handle, (struct pcap_pkthdr **)hdr, data );
 }

-static void * CDECL wrap_open_live( const char *source, int snaplen, int promisc, int to_ms, char *errbuf )
+static struct pcap * CDECL wrap_open_live( const char *source, int snaplen, int promisc, int to_ms, char *errbuf )
 {
-    return pcap_open_live( source, snaplen, promisc, to_ms, errbuf );
+    struct pcap *ret = malloc( sizeof(*ret) );
+    if (ret && !(ret->handle = pcap_open_live( source, snaplen, promisc, to_ms, errbuf )))
+    {
+        free( ret );
+        return NULL;
+    }
+    return ret;
 }

-static int CDECL wrap_sendpacket( void *handle, const unsigned char *buf, int size )
+static int CDECL wrap_sendpacket( struct pcap *pcap, const unsigned char *buf, int size )
 {
-    return pcap_sendpacket( handle, buf, size );
+    return pcap_sendpacket( pcap->handle, buf, size );
 }

-static int CDECL wrap_set_buffer_size( void *handle, int size )
+static int CDECL wrap_set_buffer_size( struct pcap *pcap, int size )
 {
-    return pcap_set_buffer_size( handle, size );
+    return pcap_set_buffer_size( pcap->handle, size );
 }

-static int CDECL wrap_set_datalink( void *handle, int link )
+static int CDECL wrap_set_datalink( struct pcap *pcap, int link )
 {
-    return pcap_set_datalink( handle, link );
+    return pcap_set_datalink( pcap->handle, link );
 }

-static int CDECL wrap_set_promisc( void *handle, int enable )
+static int CDECL wrap_set_promisc( struct pcap *pcap, int enable )
 {
-    return pcap_set_promisc( handle, enable );
+    return pcap_set_promisc( pcap->handle, enable );
 }

-static int CDECL wrap_set_rfmon( void *handle, int enable )
+static int CDECL wrap_set_rfmon( struct pcap *pcap, int enable )
 {
-    return pcap_set_rfmon( handle, enable );
+    return pcap_set_rfmon( pcap->handle, enable );
 }

-static int CDECL wrap_set_snaplen( void *handle, int len )
+static int CDECL wrap_set_snaplen( struct pcap *pcap, int len )
 {
-    return pcap_set_snaplen( handle, len );
+    return pcap_set_snaplen( pcap->handle, len );
 }

-static int CDECL wrap_set_timeout( void *handle, int timeout )
+static int CDECL wrap_set_timeout( struct pcap *pcap, int timeout )
 {
-    return pcap_set_timeout( handle, timeout );
+    return pcap_set_timeout( pcap->handle, timeout );
 }

-static int CDECL wrap_set_tstamp_precision( void *handle, int precision )
+static int CDECL wrap_set_tstamp_precision( struct pcap *pcap, int precision )
 {
-    return pcap_set_tstamp_precision( handle, precision );
+    return pcap_set_tstamp_precision( pcap->handle, precision );
 }

-static int CDECL wrap_set_tstamp_type( void *handle, int type )
+static int CDECL wrap_set_tstamp_type( struct pcap *pcap, int type )
 {
-    return pcap_set_tstamp_type( handle, type );
+    return pcap_set_tstamp_type( pcap->handle, type );
 }

-static int CDECL wrap_setfilter( void *handle, void *program )
+static int CDECL wrap_setfilter( struct pcap *pcap, void *program )
 {
-    return pcap_setfilter( handle, program );
+    return pcap_setfilter( pcap->handle, program );
 }

-static int CDECL wrap_setnonblock( void *handle, int nonblock, char *errbuf )
+static int CDECL wrap_setnonblock( struct pcap *pcap, int nonblock, char *errbuf )
 {
-    return pcap_setnonblock( handle, nonblock, errbuf );
+    return pcap_setnonblock( pcap->handle, nonblock, errbuf );
 }

-static int CDECL wrap_snapshot( void *handle )
+static int CDECL wrap_snapshot( struct pcap *pcap )
 {
-    return pcap_snapshot( handle );
+    return pcap_snapshot( pcap->handle );
 }

-static int CDECL wrap_stats( void *handle, void *stats )
+static int CDECL wrap_stats( struct pcap *pcap, void *stats )
 {
-    return pcap_stats( handle, stats );
+    return pcap_stats( pcap->handle, stats );
 }

static const char * CDECL wrap_statustostr( int status )
diff --git a/dlls/wpcap/unixlib.h b/dlls/wpcap/unixlib.h
index 71ee298e689..c5279f860fd 100644
--- a/dlls/wpcap/unixlib.h
+++ b/dlls/wpcap/unixlib.h
@@ -23,6 +23,11 @@ struct pcap_if_hdr
     char *name;
 };

+struct pcap
+{
+    void *handle;
+};
+
 struct handler_callback
 {
     void (CALLBACK *callback)( unsigned char *, const void *, const unsigned char * );
@@ -31,52 +36,54 @@ struct handler_callback

struct pcap_funcs
 {
-    int (CDECL *activate)( void * );
-    void (CDECL *breakloop)( void * );
-    int (CDECL *can_set_rfmon)( void * );
-    void (CDECL *close)( void * );
-    int (CDECL *compile)( void *, void *, const char *, int, unsigned int );
-    void * (CDECL *create)( const char *, char * );
-    int (CDECL *datalink)( void * );
+    int (CDECL *activate)( struct pcap * );
+    void (CDECL *breakloop)( struct pcap * );
+    int (CDECL *can_set_rfmon)( struct pcap * );
+    void (CDECL *close)( struct pcap * );
+    int (CDECL *compile)( struct pcap *, void *, const char *, int, unsigned int );
+    struct pcap * (CDECL *create)( const char *, char * );
+    int (CDECL *datalink)( struct pcap * );
     int (CDECL *datalink_name_to_val)( const char * );
     const char * (CDECL *datalink_val_to_description)( int );
     const char * (CDECL *datalink_val_to_name)( int );
-    int (CDECL *dispatch)( void *, int, void (CALLBACK *)(unsigned char *, const void *, const unsigned char *),
+    int (CDECL *dispatch)( struct pcap *, int,
+                           void (CALLBACK *)(unsigned char *, const void *, const unsigned char *),
                            unsigned char * );
     void (CDECL *dump)( unsigned char *, const void *, const unsigned char * );
-    void * (CDECL *dump_open)( void *, const char * );
+    void * (CDECL *dump_open)( struct pcap *, const char * );
     int (CDECL *findalldevs)( struct pcap_if_hdr **, char * );
     void (CDECL *free_datalinks)( int * );
     void (CDECL *free_tstamp_types)( int * );
     void (CDECL *freealldevs)( struct pcap_if_hdr * );
     void (CDECL *freecode)( void * );
-    int (CDECL *get_tstamp_precision)( void * );
-    char * (CDECL *geterr)( void * );
-    int (CDECL *getnonblock)( void *, char * );
+    int (CDECL *get_tstamp_precision)( struct pcap * );
+    char * (CDECL *geterr)( struct pcap * );
+    int (CDECL *getnonblock)( struct pcap *, char * );
     const char * (CDECL *lib_version)( void );
-    int (CDECL *list_datalinks)( void *, int ** );
-    int (CDECL *list_tstamp_types)( void *, int ** );
+    int (CDECL *list_datalinks)( struct pcap *, int ** );
+    int (CDECL *list_tstamp_types)( struct pcap *, int ** );
     int (CDECL *lookupnet)( const char *, unsigned int *, unsigned int *, char * );
-    int (CDECL *loop)( void *, int, void (CALLBACK *)(unsigned char *, const void *, const unsigned char *),
+    int (CDECL *loop)( struct pcap *, int,
+                       void (CALLBACK *)(unsigned char *, const void *, const unsigned char *),
                        unsigned char * );
-    int (CDECL *major_version)( void * );
-    int (CDECL *minor_version)( void * );
-    const unsigned char * (CDECL *next)( void *, void * );
-    int (CDECL *next_ex)( void *, void **, const unsigned char ** );
-    void * (CDECL *open_live)( const char *, int, int, int, char * );
-    int (CDECL *sendpacket)( void *, const unsigned char *, int );
-    int (CDECL *set_buffer_size)( void *, int );
-    int (CDECL *set_datalink)( void *, int );
-    int (CDECL *set_promisc)( void *, int );
-    int (CDECL *set_rfmon)( void *, int );
-    int (CDECL *set_snaplen)( void *, int );
-    int (CDECL *set_timeout)( void *, int );
-    int (CDECL *set_tstamp_precision)( void *, int );
-    int (CDECL *set_tstamp_type)( void *, int );
-    int (CDECL *setfilter)( void *, void * );
-    int (CDECL *setnonblock)( void *, int, char * );
-    int (CDECL *snapshot)( void * );
-    int (CDECL *stats)( void *, void * );
+    int (CDECL *major_version)( struct pcap * );
+    int (CDECL *minor_version)( struct pcap * );
+    const unsigned char * (CDECL *next)( struct pcap *, void * );
+    int (CDECL *next_ex)( struct pcap *, void **, const unsigned char ** );
+    struct pcap * (CDECL *open_live)( const char *, int, int, int, char * );
+    int (CDECL *sendpacket)( struct pcap *, const unsigned char *, int );
+    int (CDECL *set_buffer_size)( struct pcap *, int );
+    int (CDECL *set_datalink)( struct pcap *, int );
+    int (CDECL *set_promisc)( struct pcap *, int );
+    int (CDECL *set_rfmon)( struct pcap *, int );
+    int (CDECL *set_snaplen)( struct pcap *, int );
+    int (CDECL *set_timeout)( struct pcap *, int );
+    int (CDECL *set_tstamp_precision)( struct pcap *, int );
+    int (CDECL *set_tstamp_type)( struct pcap *, int );
+    int (CDECL *setfilter)( struct pcap *, void * );
+    int (CDECL *setnonblock)( struct pcap *, int, char * );
+    int (CDECL *snapshot)( struct pcap * );
+    int (CDECL *stats)( struct pcap *, void * );
     const char * (CDECL *statustostr)( int );
     int (CDECL *tstamp_type_name_to_val)( const char * );
     const char * (CDECL *tstamp_type_val_to_description)( int );
diff --git a/dlls/wpcap/wpcap.c b/dlls/wpcap/wpcap.c
index 009a51c5a2b..a190634ac22 100644
--- a/dlls/wpcap/wpcap.c
+++ b/dlls/wpcap/wpcap.c
@@ -33,46 +33,46 @@ WINE_DEFAULT_DEBUG_CHANNEL(wpcap);

const struct pcap_funcs *pcap_funcs = NULL;

-int CDECL pcap_activate( void *handle )
+int CDECL pcap_activate( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
-    return pcap_funcs->activate( handle );
+    TRACE( "%p\n", pcap );
+    return pcap_funcs->activate( pcap );
 }

-void CDECL pcap_breakloop( void *handle )
+void CDECL pcap_breakloop( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
-    pcap_funcs->breakloop( handle );
+    TRACE( "%p\n", pcap );
+    pcap_funcs->breakloop( pcap );
 }

-int CDECL pcap_can_set_rfmon( void *handle )
+int CDECL pcap_can_set_rfmon( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
-    return pcap_funcs->can_set_rfmon( handle );
+    TRACE( "%p\n", pcap );
+    return pcap_funcs->can_set_rfmon( pcap );
 }

-void CDECL pcap_close( void *handle )
+void CDECL pcap_close( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
-    pcap_funcs->close( handle );
+    TRACE( "%p\n", pcap );
+    pcap_funcs->close( pcap );
 }

-int CDECL pcap_compile( void *handle, void *program, const char *buf, int optimize, unsigned int mask )
+int CDECL pcap_compile( struct pcap *pcap, void *program, const char *buf, int optimize, unsigned int mask )
 {
-    TRACE( "%p, %p, %s, %d, %u\n", handle, program, debugstr_a(buf), optimize, mask );
-    return pcap_funcs->compile( handle, program, buf, optimize, mask );
+    TRACE( "%p, %p, %s, %d, %u\n", pcap, program, debugstr_a(buf), optimize, mask );
+    return pcap_funcs->compile( pcap, program, buf, optimize, mask );
 }

-void * CDECL pcap_create( const char *src, char *errbuf )
+struct pcap * CDECL pcap_create( const char *src, char *errbuf )
 {
     TRACE( "%s, %p\n", src, errbuf );
     return pcap_funcs->create( src, errbuf );
 }

-int CDECL pcap_datalink( void *handle )
+int CDECL pcap_datalink( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
-    return pcap_funcs->datalink( handle );
+    TRACE( "%p\n", pcap );
+    return pcap_funcs->datalink( pcap );
 }

int CDECL pcap_datalink_name_to_val( const char *name )
@@ -93,12 +93,12 @@ const char * CDECL pcap_datalink_val_to_name( int link )
     return pcap_funcs->datalink_val_to_name( link );
 }

-int CDECL pcap_dispatch( void *handle, int count,
+int CDECL pcap_dispatch( struct pcap *pcap, int count,
                          void (CALLBACK *callback)(unsigned char *, const void *, const unsigned char *),
                          unsigned char *user )
 {
-    TRACE( "%p, %d, %p, %p\n", handle, count, callback, user );
-    return pcap_funcs->dispatch( handle, count, callback, user );
+    TRACE( "%p, %d, %p, %p\n", pcap, count, callback, user );
+    return pcap_funcs->dispatch( pcap, count, callback, user );
 }

void CDECL pcap_dump( unsigned char *user, const void *hdr, const unsigned char *packet )
@@ -118,13 +118,13 @@ static inline WCHAR *strdupAW( const char *str )
     return ret;
 }

-void * CDECL pcap_dump_open( void *handle, const char *filename )
+void * CDECL pcap_dump_open( struct pcap *pcap, const char *filename )
 {
     void *dumper;
     WCHAR *filenameW;
     char *unix_path;

-    TRACE( "%p, %s\n", handle, debugstr_a(filename) );
+    TRACE( "%p, %s\n", pcap, debugstr_a(filename) );

if (!(filenameW = strdupAW( filename ))) return NULL;
     unix_path = wine_get_unix_file_name( filenameW );
@@ -133,7 +133,7 @@ void * CDECL pcap_dump_open( void *handle, const char *filename )

TRACE( "unix_path %s\n", debugstr_a(unix_path) );

-    dumper = pcap_funcs->dump_open( handle, unix_path );
+    dumper = pcap_funcs->dump_open( pcap, unix_path );
     RtlFreeHeap( GetProcessHeap(), 0, unix_path );
     return dumper;
 }
@@ -174,28 +174,28 @@ void CDECL pcap_freecode( void *program )
     pcap_funcs->freecode( program );
 }

-void * CDECL pcap_get_airpcap_handle( void *handle )
+void * CDECL pcap_get_airpcap_handle( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
+    TRACE( "%p\n", pcap );
     return NULL;
 }

-int CDECL pcap_get_tstamp_precision( void *handle )
+int CDECL pcap_get_tstamp_precision( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
-    return pcap_funcs->get_tstamp_precision( handle );
+    TRACE( "%p\n", pcap );
+    return pcap_funcs->get_tstamp_precision( pcap );
 }

-char * CDECL pcap_geterr( void *handle )
+char * CDECL pcap_geterr( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
-    return pcap_funcs->geterr( handle );
+    TRACE( "%p\n", pcap );
+    return pcap_funcs->geterr( pcap );
 }

-int CDECL pcap_getnonblock( void *handle, char *errbuf )
+int CDECL pcap_getnonblock( struct pcap *pcap, char *errbuf )
 {
-    TRACE( "%p, %p\n", handle, errbuf );
-    return pcap_funcs->getnonblock( handle, errbuf );
+    TRACE( "%p, %p\n", pcap, errbuf );
+    return pcap_funcs->getnonblock( pcap, errbuf );
 }

static char lib_version[256];
@@ -214,16 +214,16 @@ const char * CDECL pcap_lib_version( void )
     return lib_version;
 }

-int CDECL pcap_list_datalinks( void *handle, int **buf )
+int CDECL pcap_list_datalinks( struct pcap *pcap, int **buf )
 {
-    TRACE( "%p, %p\n", handle, buf );
-    return pcap_funcs->list_datalinks( handle, buf );
+    TRACE( "%p, %p\n", pcap, buf );
+    return pcap_funcs->list_datalinks( pcap, buf );
 }

-int CDECL pcap_list_tstamp_types( void *handle, int **types )
+int CDECL pcap_list_tstamp_types( struct pcap *pcap, int **types )
 {
-    TRACE( "%p, %p\n", handle, types );
-    return pcap_funcs->list_tstamp_types( handle, types );
+    TRACE( "%p, %p\n", pcap, types );
+    return pcap_funcs->list_tstamp_types( pcap, types );
 }

char * CDECL pcap_lookupdev( char *errbuf )
@@ -248,46 +248,46 @@ int CDECL pcap_lookupnet( const char *device, unsigned int *net, unsigned int *m
     return pcap_funcs->lookupnet( device, net, mask, errbuf );
 }

-int CDECL pcap_loop( void *handle, int count,
+int CDECL pcap_loop( struct pcap *pcap, int count,
                      void (CALLBACK *callback)(unsigned char *, const void *, const unsigned char *),
                      unsigned char *user)
 {
-    TRACE( "%p, %d, %p, %p\n", handle, count, callback, user );
-    return pcap_funcs->loop( handle, count, callback, user );
+    TRACE( "%p, %d, %p, %p\n", pcap, count, callback, user );
+    return pcap_funcs->loop( pcap, count, callback, user );
 }

-int CDECL pcap_major_version( void *handle )
+int CDECL pcap_major_version( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
-    return pcap_funcs->major_version( handle );
+    TRACE( "%p\n", pcap );
+    return pcap_funcs->major_version( pcap );
 }

-int CDECL pcap_minor_version( void *handle )
+int CDECL pcap_minor_version( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
-    return pcap_funcs->minor_version( handle );
+    TRACE( "%p\n", pcap );
+    return pcap_funcs->minor_version( pcap );
 }

-const unsigned char * CDECL pcap_next( void *handle, void *hdr )
+const unsigned char * CDECL pcap_next( struct pcap *pcap, void *hdr )
 {
-    TRACE( "%p, %p\n", handle, hdr );
-    return pcap_funcs->next( handle, hdr );
+    TRACE( "%p, %p\n", pcap, hdr );
+    return pcap_funcs->next( pcap, hdr );
 }

-int CDECL pcap_next_ex( void *handle, void **hdr, const unsigned char **data )
+int CDECL pcap_next_ex( struct pcap *pcap, void **hdr, const unsigned char **data )
 {
-    TRACE( "%p, %p, %p\n", handle, hdr, data );
-    return pcap_funcs->next_ex( handle, hdr, data );
+    TRACE( "%p, %p, %p\n", pcap, hdr, data );
+    return pcap_funcs->next_ex( pcap, hdr, data );
 }

#define PCAP_OPENFLAG_PROMISCUOUS 1
-void * CDECL pcap_open( const char *source, int snaplen, int flags, int timeout, void *auth, char *errbuf )
+struct pcap * CDECL pcap_open( const char *source, int snaplen, int flags, int timeout, void *auth, char *errbuf )
 {
     FIXME( "%s, %d, %d, %d, %p, %p: partial stub\n", debugstr_a(source), snaplen, flags, timeout, auth, errbuf );
     return pcap_funcs->open_live( source, snaplen, flags & PCAP_OPENFLAG_PROMISCUOUS, timeout, errbuf );
 }

-void * CDECL pcap_open_live( const char *source, int snaplen, int promisc, int to_ms, char *errbuf )
+struct pcap * CDECL pcap_open_live( const char *source, int snaplen, int promisc, int to_ms, char *errbuf )
 {
     TRACE( "%s, %d, %d, %d, %p\n", debugstr_a(source), snaplen, promisc, to_ms, errbuf );
     return pcap_funcs->open_live( source, snaplen, promisc, to_ms, errbuf );
@@ -334,88 +334,88 @@ int CDECL pcap_parsesrcstr( const char *source, int *type, char *host, char *por
     return 0;
 }

-int CDECL pcap_sendpacket( void *handle, const unsigned char *buf, int size )
+int CDECL pcap_sendpacket( struct pcap *pcap, const unsigned char *buf, int size )
 {
-    TRACE( "%p, %p, %d\n", handle, buf, size );
-    return pcap_funcs->sendpacket( handle, buf, size );
+    TRACE( "%p, %p, %d\n", pcap, buf, size );
+    return pcap_funcs->sendpacket( pcap, buf, size );
 }

-int CDECL pcap_set_buffer_size( void *handle, int size )
+int CDECL pcap_set_buffer_size( struct pcap *pcap, int size )
 {
-    TRACE( "%p, %d\n", handle, size );
-    return pcap_funcs->set_buffer_size( handle, size );
+    TRACE( "%p, %d\n", pcap, size );
+    return pcap_funcs->set_buffer_size( pcap, size );
 }

-int CDECL pcap_set_datalink( void *handle, int link )
+int CDECL pcap_set_datalink( struct pcap *pcap, int link )
 {
-    TRACE( "%p, %d\n", handle, link );
-    return pcap_funcs->set_datalink( handle, link );
+    TRACE( "%p, %d\n", pcap, link );
+    return pcap_funcs->set_datalink( pcap, link );
 }

-int CDECL pcap_set_promisc( void *handle, int enable )
+int CDECL pcap_set_promisc( struct pcap *pcap, int enable )
 {
-    TRACE( "%p, %d\n", handle, enable );
-    return pcap_funcs->set_promisc( handle, enable );
+    TRACE( "%p, %d\n", pcap, enable );
+    return pcap_funcs->set_promisc( pcap, enable );
 }

-int CDECL pcap_set_rfmon( void *handle, int enable )
+int CDECL pcap_set_rfmon( struct pcap *pcap, int enable )
 {
-    TRACE( "%p, %d\n", handle, enable );
-    return pcap_funcs->set_rfmon( handle, enable );
+    TRACE( "%p, %d\n", pcap, enable );
+    return pcap_funcs->set_rfmon( pcap, enable );
 }

-int CDECL pcap_set_snaplen( void *handle, int len )
+int CDECL pcap_set_snaplen( struct pcap *pcap, int len )
 {
-    TRACE( "%p, %d\n", handle, len );
-    return pcap_funcs->set_snaplen( handle, len );
+    TRACE( "%p, %d\n", pcap, len );
+    return pcap_funcs->set_snaplen( pcap, len );
 }

-int CDECL pcap_set_timeout( void *handle, int timeout )
+int CDECL pcap_set_timeout( struct pcap *pcap, int timeout )
 {
-    TRACE( "%p, %d\n", handle, timeout );
-    return pcap_funcs->set_timeout( handle, timeout );
+    TRACE( "%p, %d\n", pcap, timeout );
+    return pcap_funcs->set_timeout( pcap, timeout );
 }

-int CDECL pcap_set_tstamp_precision( void *handle, int precision )
+int CDECL pcap_set_tstamp_precision( struct pcap *pcap, int precision )
 {
-    TRACE( "%p, %d\n", handle, precision );
-    return pcap_funcs->set_tstamp_precision( handle, precision );
+    TRACE( "%p, %d\n", pcap, precision );
+    return pcap_funcs->set_tstamp_precision( pcap, precision );
 }

-int CDECL pcap_set_tstamp_type( void *handle, int type )
+int CDECL pcap_set_tstamp_type( struct pcap *pcap, int type )
 {
-    TRACE( "%p, %d\n", handle, type );
-    return pcap_funcs->set_tstamp_type( handle, type );
+    TRACE( "%p, %d\n", pcap, type );
+    return pcap_funcs->set_tstamp_type( pcap, type );
 }

-int CDECL pcap_setbuff( void *handle, int size )
+int CDECL pcap_setbuff( struct pcap *pcap, int size )
 {
-    FIXME( "%p, %d\n", handle, size );
+    FIXME( "%p, %d\n", pcap, size );
     return 0;
 }

-int CDECL pcap_setfilter( void *handle, void *program )
+int CDECL pcap_setfilter( struct pcap *pcap, void *program )
 {
-    TRACE( "%p, %p\n", handle, program );
-    return pcap_funcs->setfilter( handle, program );
+    TRACE( "%p, %p\n", pcap, program );
+    return pcap_funcs->setfilter( pcap, program );
 }

-int CDECL pcap_setnonblock( void *handle, int nonblock, char *errbuf )
+int CDECL pcap_setnonblock( struct pcap *pcap, int nonblock, char *errbuf )
 {
-    TRACE( "%p, %d, %p\n", handle, nonblock, errbuf );
-    return pcap_funcs->setnonblock( handle, nonblock, errbuf );
+    TRACE( "%p, %d, %p\n", pcap, nonblock, errbuf );
+    return pcap_funcs->setnonblock( pcap, nonblock, errbuf );
 }

-int CDECL pcap_snapshot( void *handle )
+int CDECL pcap_snapshot( struct pcap *pcap )
 {
-    TRACE( "%p\n", handle );
-    return pcap_funcs->snapshot( handle );
+    TRACE( "%p\n", pcap );
+    return pcap_funcs->snapshot( pcap );
 }

-int CDECL pcap_stats( void *handle, void *stats )
+int CDECL pcap_stats( struct pcap *pcap, void *stats )
 {
-    TRACE( "%p, %p\n", handle, stats );
-    return pcap_funcs->stats( handle, stats );
+    TRACE( "%p, %p\n", pcap, stats );
+    return pcap_funcs->stats( pcap, stats );
 }

const char * CDECL pcap_statustostr( int status )