dlls/wpcap/wpcap.c

   1 /*
   2  * WPcap.dll Proxy.
   3  *
   4  * Copyright 2011, 2014 André Hentschel
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winternl.h"
  25 #include "winnls.h"
  26 #define USE_WS_PREFIX
  27 #include "winsock2.h"
  28
  29 #include "wine/debug.h"
  30 #include "unixlib.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(wpcap);
  33
  34 const struct pcap_funcs *pcap_funcs = NULL;
  35
  36 int CDECL pcap_activate( void *handle )
  37 {
  38     TRACE( "%p\n", handle );
  39     return pcap_funcs->activate( handle );
  40 }
  41
  42 void CDECL pcap_breakloop( void *handle )
  43 {
  44     TRACE( "%p\n", handle );
  45     pcap_funcs->breakloop( handle );
  46 }
  47
  48 int CDECL pcap_can_set_rfmon( void *handle )
  49 {
  50     TRACE( "%p\n", handle );
  51     return pcap_funcs->can_set_rfmon( handle );
  52 }
  53
  54 void CDECL pcap_close( void *handle )
  55 {
  56     TRACE( "%p\n", handle );
  57     pcap_funcs->close( handle );
  58 }
  59
  60 int CDECL pcap_compile( void *handle, void *program, const char *buf, int optimize, unsigned int mask )
  61 {
  62     TRACE( "%p, %p, %s, %d, %u\n", handle, program, debugstr_a(buf), optimize, mask );
  63     return pcap_funcs->compile( handle, program, buf, optimize, mask );
  64 }
  65
  66 void * CDECL pcap_create( const char *src, char *errbuf )
  67 {
  68     TRACE( "%s, %p\n", src, errbuf );
  69     return pcap_funcs->create( src, errbuf );
  70 }
  71
  72 int CDECL pcap_datalink( void *handle )
  73 {
  74     TRACE( "%p\n", handle );
  75     return pcap_funcs->datalink( handle );
  76 }
  77
  78 int CDECL pcap_datalink_name_to_val( const char *name )
  79 {
  80     TRACE( "%s\n", debugstr_a(name) );
  81     return pcap_funcs->datalink_name_to_val( name );
  82 }
  83
  84 const char * CDECL pcap_datalink_val_to_description( int link )
  85 {
  86     TRACE( "%d\n", link );
  87     return pcap_funcs->datalink_val_to_description( link );
  88 }
  89
  90 const char * CDECL pcap_datalink_val_to_name( int link )
  91 {
  92     TRACE( "%d\n", link );
  93     return pcap_funcs->datalink_val_to_name( link );
  94 }
  95
  96 int CDECL pcap_dispatch( void *handle, int count,
  97                          void (CALLBACK *callback)(unsigned char *, const void *, const unsigned char *),
  98                          unsigned char *user )
  99 {
 100     TRACE( "%p, %d, %p, %p\n", handle, count, callback, user );
 101     return pcap_funcs->dispatch( handle, count, callback, user );
 102 }
 103
 104 void CDECL pcap_dump( unsigned char *user, const void *hdr, const unsigned char *packet )
 105 {
 106     TRACE( "%p, %p, %p\n", user, hdr, packet );
 107     pcap_funcs->dump( user, hdr, packet );
 108 }
 109
 110 static inline WCHAR *strdupAW( const char *str )
 111 {
 112     WCHAR *ret = NULL;
 113     if (str)
 114     {
 115         int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 116         if ((ret = malloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
 117     }
 118     return ret;
 119 }
 120
 121 void * CDECL pcap_dump_open( void *handle, const char *filename )
 122 {
 123     void *dumper;
 124     WCHAR *filenameW;
 125     char *unix_path;
 126
 127     TRACE( "%p, %s\n", handle, debugstr_a(filename) );
 128
 129     if (!(filenameW = strdupAW( filename ))) return NULL;
 130     unix_path = wine_get_unix_file_name( filenameW );
 131     free( filenameW );
 132     if (!unix_path) return NULL;
 133
 134     TRACE( "unix_path %s\n", debugstr_a(unix_path) );
 135
 136     dumper = pcap_funcs->dump_open( handle, unix_path );
 137     RtlFreeHeap( GetProcessHeap(), 0, unix_path );
 138     return dumper;
 139 }
 140
 141 int CDECL pcap_findalldevs( struct pcap_if_hdr **devs, char *errbuf )
 142 {
 143     TRACE( "%p, %p\n", devs, errbuf );
 144     return pcap_funcs->findalldevs( devs, errbuf );
 145 }
 146
 147 int CDECL pcap_findalldevs_ex( char *source, void *auth, struct pcap_if_hdr **devs, char *errbuf )
 148 {
 149     FIXME( "%s, %p, %p, %p: partial stub\n", debugstr_a(source), auth, devs, errbuf );
 150     return pcap_funcs->findalldevs( devs, errbuf );
 151 }
 152
 153 void CDECL pcap_free_datalinks( int *links )
 154 {
 155     TRACE( "%p\n", links );
 156     pcap_funcs->free_datalinks( links );
 157 }
 158
 159 void CDECL pcap_free_tstamp_types( int *types )
 160 {
 161     TRACE( "%p\n", types );
 162     pcap_funcs->free_tstamp_types( types );
 163 }
 164
 165 void CDECL pcap_freealldevs( struct pcap_if_hdr *devs )
 166 {
 167     TRACE( "%p\n", devs );
 168     pcap_funcs->freealldevs( devs );
 169 }
 170
 171 void CDECL pcap_freecode( void *program )
 172 {
 173     TRACE( "%p\n", program );
 174     pcap_funcs->freecode( program );
 175 }
 176
 177 void * CDECL pcap_get_airpcap_handle( void *handle )
 178 {
 179     TRACE( "%p\n", handle );
 180     return NULL;
 181 }
 182
 183 int CDECL pcap_get_tstamp_precision( void *handle )
 184 {
 185     TRACE( "%p\n", handle );
 186     return pcap_funcs->get_tstamp_precision( handle );
 187 }
 188
 189 char * CDECL pcap_geterr( void *handle )
 190 {
 191     TRACE( "%p\n", handle );
 192     return pcap_funcs->geterr( handle );
 193 }
 194
 195 int CDECL pcap_getnonblock( void *handle, char *errbuf )
 196 {
 197     TRACE( "%p, %p\n", handle, errbuf );
 198     return pcap_funcs->getnonblock( handle, errbuf );
 199 }
 200
 201 static char lib_version[256];
 202 static BOOL WINAPI init_lib_version( INIT_ONCE *once, void *param, void **ctx )
 203 {
 204     const char *str = pcap_funcs->lib_version();
 205     if (strlen( str ) < sizeof(lib_version)) strcpy( lib_version, str );
 206     return TRUE;
 207 }
 208
 209 const char * CDECL pcap_lib_version( void )
 210 {
 211     static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
 212     if (!lib_version[0]) InitOnceExecuteOnce( &once, init_lib_version, NULL, NULL );
 213     TRACE( "%s\n", debugstr_a(lib_version) );
 214     return lib_version;
 215 }
 216
 217 int CDECL pcap_list_datalinks( void *handle, int **buf )
 218 {
 219     TRACE( "%p, %p\n", handle, buf );
 220     return pcap_funcs->list_datalinks( handle, buf );
 221 }
 222
 223 int CDECL pcap_list_tstamp_types( void *handle, int **types )
 224 {
 225     TRACE( "%p, %p\n", handle, types );
 226     return pcap_funcs->list_tstamp_types( handle, types );
 227 }
 228
 229 char * CDECL pcap_lookupdev( char *errbuf )
 230 {
 231     static char *ret;
 232     struct pcap_if_hdr *devs;
 233
 234     TRACE( "%p\n", errbuf );
 235     if (!ret)
 236     {
 237         if (pcap_funcs->findalldevs( &devs, errbuf ) == -1) return NULL;
 238         if (!devs) return NULL;
 239         if ((ret = malloc( strlen(devs->name) + 1 ))) strcpy( ret, devs->name );
 240         pcap_funcs->freealldevs( devs );
 241     }
 242     return ret;
 243 }
 244
 245 int CDECL pcap_lookupnet( const char *device, unsigned int *net, unsigned int *mask, char *errbuf )
 246 {
 247     TRACE( "%s, %p, %p, %p\n", debugstr_a(device), net, mask, errbuf );
 248     return pcap_funcs->lookupnet( device, net, mask, errbuf );
 249 }
 250
 251 int CDECL pcap_loop( void *handle, int count,
 252                      void (CALLBACK *callback)(unsigned char *, const void *, const unsigned char *),
 253                      unsigned char *user)
 254 {
 255     TRACE( "%p, %d, %p, %p\n", handle, count, callback, user );
 256     return pcap_funcs->loop( handle, count, callback, user );
 257 }
 258
 259 int CDECL pcap_major_version( void *handle )
 260 {
 261     TRACE( "%p\n", handle );
 262     return pcap_funcs->major_version( handle );
 263 }
 264
 265 int CDECL pcap_minor_version( void *handle )
 266 {
 267     TRACE( "%p\n", handle );
 268     return pcap_funcs->minor_version( handle );
 269 }
 270
 271 const unsigned char * CDECL pcap_next( void *handle, void *hdr )
 272 {
 273     TRACE( "%p, %p\n", handle, hdr );
 274     return pcap_funcs->next( handle, hdr );
 275 }
 276
 277 int CDECL pcap_next_ex( void *handle, void **hdr, const unsigned char **data )
 278 {
 279     TRACE( "%p, %p, %p\n", handle, hdr, data );
 280     return pcap_funcs->next_ex( handle, hdr, data );
 281 }
 282
 283 #define PCAP_OPENFLAG_PROMISCUOUS 1
 284 void * CDECL pcap_open( const char *source, int snaplen, int flags, int timeout, void *auth, char *errbuf )
 285 {
 286     FIXME( "%s, %d, %d, %d, %p, %p: partial stub\n", debugstr_a(source), snaplen, flags, timeout, auth, errbuf );
 287     return pcap_funcs->open_live( source, snaplen, flags & PCAP_OPENFLAG_PROMISCUOUS, timeout, errbuf );
 288 }
 289
 290 void * CDECL pcap_open_live( const char *source, int snaplen, int promisc, int to_ms, char *errbuf )
 291 {
 292     TRACE( "%s, %d, %d, %d, %p\n", debugstr_a(source), snaplen, promisc, to_ms, errbuf );
 293     return pcap_funcs->open_live( source, snaplen, promisc, to_ms, errbuf );
 294 }
 295
 296 #define PCAP_SRC_FILE    2
 297 #define PCAP_SRC_IFLOCAL 3
 298
 299 int CDECL pcap_parsesrcstr( const char *source, int *type, char *host, char *port, char *name, char *errbuf )
 300 {
 301     int t = PCAP_SRC_IFLOCAL;
 302     const char *p = source;
 303
 304     FIXME( "%s, %p, %p, %p, %p, %p: partial stub\n", debugstr_a(source), type, host, port, name, errbuf );
 305
 306     if (host)
 307         *host = '\0';
 308     if (port)
 309         *port = '\0';
 310     if (name)
 311         *name = '\0';
 312
 313     if (!strncmp(p, "rpcap://", strlen("rpcap://")))
 314         p += strlen("rpcap://");
 315     else if (!strncmp(p, "file://", strlen("file://")))
 316     {
 317         p += strlen("file://");
 318         t = PCAP_SRC_FILE;
 319     }
 320
 321     if (type)
 322         *type = t;
 323
 324     if (!*p)
 325     {
 326         if (errbuf)
 327             sprintf(errbuf, "The name has not been specified in the source string.");
 328         return -1;
 329     }
 330
 331     if (name)
 332         strcpy(name, p);
 333
 334     return 0;
 335 }
 336
 337 int CDECL pcap_sendpacket( void *handle, const unsigned char *buf, int size )
 338 {
 339     TRACE( "%p, %p, %d\n", handle, buf, size );
 340     return pcap_funcs->sendpacket( handle, buf, size );
 341 }
 342
 343 int CDECL pcap_set_buffer_size( void *handle, int size )
 344 {
 345     TRACE( "%p, %d\n", handle, size );
 346     return pcap_funcs->set_buffer_size( handle, size );
 347 }
 348
 349 int CDECL pcap_set_datalink( void *handle, int link )
 350 {
 351     TRACE( "%p, %d\n", handle, link );
 352     return pcap_funcs->set_datalink( handle, link );
 353 }
 354
 355 int CDECL pcap_set_promisc( void *handle, int enable )
 356 {
 357     TRACE( "%p, %d\n", handle, enable );
 358     return pcap_funcs->set_promisc( handle, enable );
 359 }
 360
 361 int CDECL pcap_set_rfmon( void *handle, int enable )
 362 {
 363     TRACE( "%p, %d\n", handle, enable );
 364     return pcap_funcs->set_rfmon( handle, enable );
 365 }
 366
 367 int CDECL pcap_set_snaplen( void *handle, int len )
 368 {
 369     TRACE( "%p, %d\n", handle, len );
 370     return pcap_funcs->set_snaplen( handle, len );
 371 }
 372
 373 int CDECL pcap_set_timeout( void *handle, int timeout )
 374 {
 375     TRACE( "%p, %d\n", handle, timeout );
 376     return pcap_funcs->set_timeout( handle, timeout );
 377 }
 378
 379 int CDECL pcap_set_tstamp_precision( void *handle, int precision )
 380 {
 381     TRACE( "%p, %d\n", handle, precision );
 382     return pcap_funcs->set_tstamp_precision( handle, precision );
 383 }
 384
 385 int CDECL pcap_set_tstamp_type( void *handle, int type )
 386 {
 387     TRACE( "%p, %d\n", handle, type );
 388     return pcap_funcs->set_tstamp_type( handle, type );
 389 }
 390
 391 int CDECL pcap_setbuff( void *handle, int size )
 392 {
 393     FIXME( "%p, %d\n", handle, size );
 394     return 0;
 395 }
 396
 397 int CDECL pcap_setfilter( void *handle, void *program )
 398 {
 399     TRACE( "%p, %p\n", handle, program );
 400     return pcap_funcs->setfilter( handle, program );
 401 }
 402
 403 int CDECL pcap_setnonblock( void *handle, int nonblock, char *errbuf )
 404 {
 405     TRACE( "%p, %d, %p\n", handle, nonblock, errbuf );
 406     return pcap_funcs->setnonblock( handle, nonblock, errbuf );
 407 }
 408
 409 int CDECL pcap_snapshot( void *handle )
 410 {
 411     TRACE( "%p\n", handle );
 412     return pcap_funcs->snapshot( handle );
 413 }
 414
 415 int CDECL pcap_stats( void *handle, void *stats )
 416 {
 417     TRACE( "%p, %p\n", handle, stats );
 418     return pcap_funcs->stats( handle, stats );
 419 }
 420
 421 const char * CDECL pcap_statustostr( int status )
 422 {
 423     TRACE( "%d\n", status );
 424     return pcap_funcs->statustostr( status );
 425 }
 426
 427 int CDECL pcap_tstamp_type_name_to_val( const char *name )
 428 {
 429     TRACE( "%s\n", debugstr_a(name) );
 430     return pcap_funcs->tstamp_type_name_to_val( name );
 431 }
 432
 433 const char * CDECL pcap_tstamp_type_val_to_description( int val )
 434 {
 435     TRACE( "%d\n", val );
 436     return pcap_funcs->tstamp_type_val_to_description( val );
 437 }
 438
 439 const char * CDECL pcap_tstamp_type_val_to_name( int val )
 440 {
 441     TRACE( "%d\n", val );
 442     return pcap_funcs->tstamp_type_val_to_name( val );
 443 }
 444
 445 int CDECL wsockinit( void )
 446 {
 447     WSADATA wsadata;
 448     TRACE( "\n" );
 449     if (WSAStartup( MAKEWORD(1, 1), &wsadata )) return -1;
 450     return 0;
 451 }
 452
 453 static void CDECL pcap_handler_cb( struct handler_callback *cb, const void *hdr, const unsigned char *packet )
 454 {
 455     TRACE( "%p, %p, %p\n", cb, hdr, packet );
 456     cb->callback( cb->user, hdr, packet );
 457     TRACE( "callback completed\n" );
 458 }
 459
 460 const struct pcap_callbacks pcap_callbacks =
 461 {
 462     pcap_handler_cb
 463 };
 464
 465 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, void *reserved )
 466 {
 467     switch (reason)
 468     {
 469     case DLL_PROCESS_ATTACH:
 470         DisableThreadLibraryCalls( hinst );
 471         if (__wine_init_unix_lib( hinst, reason, &pcap_callbacks, &pcap_funcs ))
 472             ERR( "No pcap support, expect problems\n" );
 473         break;
 474     case DLL_PROCESS_DETACH:
 475         break;
 476     }
 477     return TRUE;
 478 }