From be9362190ccafd05a188ffeb59c08d40960979f7 Mon Sep 17 00:00:00 2001 From: Hans Leidekker Date: Mon, 4 Oct 2021 14:36:39 +0200 Subject: [PATCH] wpcap: Wrap native handles in a structure. Signed-off-by: Hans Leidekker Signed-off-by: Alexandre Julliard --- 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 #include +#include #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 ) -- 2.11.4.GIT