dlls/wpcap/unixlib.c

   1 /*
   2  * Copyright 2011, 2014 André Hentschel
   3  * Copyright 2021 Hans Leidekker for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #if 0
  21 #pragma makedep unix
  22 #endif
  23
  24 #include "config.h"
  25
  26 #ifdef HAVE_PCAP_PCAP_H
  27 #include <pcap/pcap.h>
  28
  29 #include <stdarg.h>
  30 #include "ntstatus.h"
  31 #define WIN32_NO_STATUS
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "winternl.h"
  35
  36 #include "wine/debug.h"
  37 #include "unixlib.h"
  38
  39 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  40
  41 static const struct pcap_callbacks *callbacks;
  42
  43 static int CDECL wrap_activate( void *handle )
  44 {
  45     return pcap_activate( handle );
  46 }
  47
  48 static void CDECL wrap_breakloop( void *handle )
  49 {
  50     return pcap_breakloop( handle );
  51 }
  52
  53 static int CDECL wrap_can_set_rfmon( void *handle )
  54 {
  55     return pcap_can_set_rfmon( handle );
  56 }
  57
  58 static void CDECL wrap_close( void *handle )
  59 {
  60     pcap_close( handle );
  61 }
  62
  63 static int CDECL wrap_compile( void *handle, void *program, const char *buf, int optimize, unsigned int mask )
  64 {
  65     return pcap_compile( handle, program, buf, optimize, mask );
  66 }
  67
  68 static void * CDECL wrap_create( const char *src, char *errbuf )
  69 {
  70     return pcap_create( src, errbuf );
  71 }
  72
  73 static int CDECL wrap_datalink( void *handle )
  74 {
  75     return pcap_datalink( handle );
  76 }
  77
  78 static int CDECL wrap_datalink_name_to_val( const char *name )
  79 {
  80     return pcap_datalink_name_to_val( name );
  81 }
  82
  83 static const char * CDECL wrap_datalink_val_to_description( int link )
  84 {
  85     return pcap_datalink_val_to_description( link );
  86 }
  87
  88 static const char * CDECL wrap_datalink_val_to_name( int link )
  89 {
  90     return pcap_datalink_val_to_name( link );
  91 }
  92
  93 void wrap_pcap_handler( unsigned char *user, const struct pcap_pkthdr *hdr, const unsigned char *packet )
  94 {
  95     struct handler_callback *cb = (struct handler_callback *)user;
  96     callbacks->handler( cb, hdr, packet );
  97 }
  98
  99 static int CDECL wrap_dispatch( void *handle, int count,
 100                                 void (CALLBACK *callback)(unsigned char *, const void *, const unsigned char *),
 101                                 unsigned char *user )
 102 {
 103     if (callback)
 104     {
 105         struct handler_callback cb;
 106         cb.callback = callback;
 107         cb.user     = user;
 108         return pcap_dispatch( handle, count, wrap_pcap_handler, (unsigned char *)&cb );
 109     }
 110     return pcap_dispatch( handle, count, NULL, user );
 111 }
 112
 113 static void CDECL wrap_dump( unsigned char *user, const void *hdr, const unsigned char *packet )
 114 {
 115     return pcap_dump( user, hdr, packet );
 116 }
 117
 118 static void * CDECL wrap_dump_open( void *handle, const char *name )
 119 {
 120     return pcap_dump_open( handle, name );
 121 }
 122
 123 static int CDECL wrap_findalldevs( struct pcap_if_hdr **devs, char *errbuf )
 124 {
 125     int ret;
 126     ret = pcap_findalldevs( (pcap_if_t **)devs, errbuf );
 127     if (devs && !*devs)
 128         ERR_(winediag)( "Failed to access raw network (pcap), this requires special permissions.\n" );
 129     return ret;
 130 }
 131
 132 static void CDECL wrap_free_datalinks( int *links )
 133 {
 134     pcap_free_datalinks( links );
 135 }
 136
 137 static void CDECL wrap_free_tstamp_types( int *types )
 138 {
 139     pcap_free_tstamp_types( types );
 140 }
 141
 142 static void CDECL wrap_freealldevs( struct pcap_if_hdr *devs )
 143 {
 144     pcap_freealldevs( (pcap_if_t *)devs );
 145 }
 146
 147 static void CDECL wrap_freecode( void *program )
 148 {
 149     return pcap_freecode( program );
 150 }
 151
 152 static int CDECL wrap_get_tstamp_precision( void *handle )
 153 {
 154     return pcap_get_tstamp_precision( handle );
 155 }
 156
 157 static char * CDECL wrap_geterr( void *handle )
 158 {
 159     return pcap_geterr( handle );
 160 }
 161
 162 static int CDECL wrap_getnonblock( void *handle, char *errbuf )
 163 {
 164     return pcap_getnonblock( handle, errbuf );
 165 }
 166
 167 static const char * CDECL wrap_lib_version( void )
 168 {
 169     return pcap_lib_version();
 170 }
 171
 172 static int CDECL wrap_list_datalinks( void *handle, int **buf )
 173 {
 174     return pcap_list_datalinks( handle, buf );
 175 }
 176
 177 static int CDECL wrap_list_tstamp_types( void *handle, int **types )
 178 {
 179     return pcap_list_tstamp_types( handle, types );
 180 }
 181
 182 static int CDECL wrap_lookupnet( const char *device, unsigned int *net, unsigned int *mask, char *errbuf )
 183 {
 184     return pcap_lookupnet( device, net, mask, errbuf );
 185 }
 186
 187 static int CDECL wrap_loop( void *handle, int count,
 188                             void (CALLBACK *callback)(unsigned char *, const void *, const unsigned char *),
 189                             unsigned char *user )
 190 {
 191     if (callback)
 192     {
 193         struct handler_callback cb;
 194         cb.callback = callback;
 195         cb.user     = user;
 196         return pcap_loop( handle, count, wrap_pcap_handler, (unsigned char *)&cb );
 197     }
 198     return pcap_loop( handle, count, NULL, user );
 199 }
 200
 201 static int CDECL wrap_major_version( void *handle )
 202 {
 203     return pcap_major_version( handle );
 204 }
 205
 206 static int CDECL wrap_minor_version( void *handle )
 207 {
 208     return pcap_minor_version( handle );
 209 }
 210
 211 static const unsigned char * CDECL wrap_next( void *handle, void *hdr )
 212 {
 213     return pcap_next( handle, hdr );
 214 }
 215
 216 static int CDECL wrap_next_ex( void *handle, void **hdr, const unsigned char **data )
 217 {
 218     return pcap_next_ex( handle, (struct pcap_pkthdr **)hdr, data );
 219 }
 220
 221 static void * CDECL wrap_open_live( const char *source, int snaplen, int promisc, int to_ms, char *errbuf )
 222 {
 223     return pcap_open_live( source, snaplen, promisc, to_ms, errbuf );
 224 }
 225
 226 static int CDECL wrap_sendpacket( void *handle, const unsigned char *buf, int size )
 227 {
 228     return pcap_sendpacket( handle, buf, size );
 229 }
 230
 231 static int CDECL wrap_set_buffer_size( void *handle, int size )
 232 {
 233     return pcap_set_buffer_size( handle, size );
 234 }
 235
 236 static int CDECL wrap_set_datalink( void *handle, int link )
 237 {
 238     return pcap_set_datalink( handle, link );
 239 }
 240
 241 static int CDECL wrap_set_promisc( void *handle, int enable )
 242 {
 243     return pcap_set_promisc( handle, enable );
 244 }
 245
 246 static int CDECL wrap_set_rfmon( void *handle, int enable )
 247 {
 248     return pcap_set_rfmon( handle, enable );
 249 }
 250
 251 static int CDECL wrap_set_snaplen( void *handle, int len )
 252 {
 253     return pcap_set_snaplen( handle, len );
 254 }
 255
 256 static int CDECL wrap_set_timeout( void *handle, int timeout )
 257 {
 258     return pcap_set_timeout( handle, timeout );
 259 }
 260
 261 static int CDECL wrap_set_tstamp_precision( void *handle, int precision )
 262 {
 263     return pcap_set_tstamp_precision( handle, precision );
 264 }
 265
 266 static int CDECL wrap_set_tstamp_type( void *handle, int type )
 267 {
 268     return pcap_set_tstamp_type( handle, type );
 269 }
 270
 271 static int CDECL wrap_setfilter( void *handle, void *program )
 272 {
 273     return pcap_setfilter( handle, program );
 274 }
 275
 276 static int CDECL wrap_setnonblock( void *handle, int nonblock, char *errbuf )
 277 {
 278     return pcap_setnonblock( handle, nonblock, errbuf );
 279 }
 280
 281 static int CDECL wrap_snapshot( void *handle )
 282 {
 283     return pcap_snapshot( handle );
 284 }
 285
 286 static int CDECL wrap_stats( void *handle, void *stats )
 287 {
 288     return pcap_stats( handle, stats );
 289 }
 290
 291 static const char * CDECL wrap_statustostr( int status )
 292 {
 293     return pcap_statustostr( status );
 294 }
 295
 296 static int CDECL wrap_tstamp_type_name_to_val( const char *name )
 297 {
 298     return pcap_tstamp_type_name_to_val( name );
 299 }
 300
 301 static const char * CDECL wrap_tstamp_type_val_to_description( int val )
 302 {
 303     return pcap_tstamp_type_val_to_description( val );
 304 }
 305
 306 static const char * CDECL wrap_tstamp_type_val_to_name( int val )
 307 {
 308     return pcap_tstamp_type_val_to_name( val );
 309 }
 310
 311 static const struct pcap_funcs funcs =
 312 {
 313     wrap_activate,
 314     wrap_breakloop,
 315     wrap_can_set_rfmon,
 316     wrap_close,
 317     wrap_compile,
 318     wrap_create,
 319     wrap_datalink,
 320     wrap_datalink_name_to_val,
 321     wrap_datalink_val_to_description,
 322     wrap_datalink_val_to_name,
 323     wrap_dispatch,
 324     wrap_dump,
 325     wrap_dump_open,
 326     wrap_findalldevs,
 327     wrap_free_datalinks,
 328     wrap_free_tstamp_types,
 329     wrap_freealldevs,
 330     wrap_freecode,
 331     wrap_get_tstamp_precision,
 332     wrap_geterr,
 333     wrap_getnonblock,
 334     wrap_lib_version,
 335     wrap_list_datalinks,
 336     wrap_list_tstamp_types,
 337     wrap_lookupnet,
 338     wrap_loop,
 339     wrap_major_version,
 340     wrap_minor_version,
 341     wrap_next,
 342     wrap_next_ex,
 343     wrap_open_live,
 344     wrap_sendpacket,
 345     wrap_set_buffer_size,
 346     wrap_set_datalink,
 347     wrap_set_promisc,
 348     wrap_set_rfmon,
 349     wrap_set_snaplen,
 350     wrap_set_timeout,
 351     wrap_set_tstamp_precision,
 352     wrap_set_tstamp_type,
 353     wrap_setfilter,
 354     wrap_setnonblock,
 355     wrap_snapshot,
 356     wrap_stats,
 357     wrap_statustostr,
 358     wrap_tstamp_type_name_to_val,
 359     wrap_tstamp_type_val_to_description,
 360     wrap_tstamp_type_val_to_name,
 361 };
 362
 363 NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out )
 364 {
 365     if (reason != DLL_PROCESS_ATTACH) return STATUS_SUCCESS;
 366     callbacks = ptr_in;
 367     *(const struct pcap_funcs **)ptr_out = &funcs;
 368     return STATUS_SUCCESS;
 369 }
 370 #endif /* HAVE_PCAP_PCAP_H */