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 #include "winsock2.h"
  27 #include "ws2ipdef.h"
  28 #include "iphlpapi.h"
  29 #include "netioapi.h"
  30
  31 #include "wine/unixlib.h"
  32 #include "wine/debug.h"
  33 #include "unixlib.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(wpcap);
  36
  37 #define PCAP_CALL( func, params ) WINE_UNIX_CALL( unix_ ## func, params )
  38
  39 int CDECL pcap_activate( struct pcap *pcap )
  40 {
  41     TRACE( "%p\n", pcap );
  42     return PCAP_CALL( activate, pcap );
  43 }
  44
  45 void CDECL pcap_breakloop( struct pcap *pcap )
  46 {
  47     TRACE( "%p\n", pcap );
  48     PCAP_CALL( breakloop, pcap );
  49 }
  50
  51 int CDECL pcap_can_set_rfmon( struct pcap *pcap )
  52 {
  53     TRACE( "%p\n", pcap );
  54     return PCAP_CALL( can_set_rfmon, pcap );
  55 }
  56
  57 void CDECL pcap_close( struct pcap *pcap )
  58 {
  59     TRACE( "%p\n", pcap );
  60     PCAP_CALL( close, pcap );
  61 }
  62
  63 int CDECL pcap_compile( struct pcap *pcap, void *program, const char *buf, int optimize, unsigned int mask )
  64 {
  65     struct compile_params params = { pcap, program, buf, optimize, mask };
  66     TRACE( "%p, %p, %s, %d, %u\n", pcap, program, debugstr_a(buf), optimize, mask );
  67     return PCAP_CALL( compile, &params );
  68 }
  69
  70 int CDECL pcap_datalink( struct pcap *pcap )
  71 {
  72     TRACE( "%p\n", pcap );
  73     return PCAP_CALL( datalink, pcap );
  74 }
  75
  76 int CDECL pcap_datalink_name_to_val( const char *name )
  77 {
  78     struct datalink_name_to_val_params params = { name };
  79     TRACE( "%s\n", debugstr_a(name) );
  80     return PCAP_CALL( datalink_name_to_val, &params );
  81 }
  82
  83 const char * CDECL pcap_datalink_val_to_description( int link )
  84 {
  85     const char *ret;
  86     struct datalink_val_to_description_params params = { link, &ret };
  87     TRACE( "%d\n", link );
  88     PCAP_CALL( datalink_val_to_description, &params );
  89     return ret;
  90 }
  91
  92 const char * CDECL pcap_datalink_val_to_name( int link )
  93 {
  94     const char *ret;
  95     struct datalink_val_to_name_params params = { link, &ret };
  96     TRACE( "%d\n", link );
  97     PCAP_CALL( datalink_val_to_name, &params );
  98     return ret;
  99 }
 100
 101 void CDECL pcap_dump( unsigned char *user, const struct pcap_pkthdr_win32 *hdr, const unsigned char *packet )
 102 {
 103     struct dump_params params = { user, hdr, packet };
 104     TRACE( "%p, %p, %p\n", user, hdr, packet );
 105     PCAP_CALL( dump, &params );
 106 }
 107
 108 static inline WCHAR *strdupAW( const char *str )
 109 {
 110     WCHAR *ret = NULL;
 111     if (str)
 112     {
 113         int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 114         if ((ret = malloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
 115     }
 116     return ret;
 117 }
 118
 119 void * CDECL pcap_dump_open( struct pcap *pcap, const char *filename )
 120 {
 121     void *dumper;
 122     WCHAR *filenameW;
 123     char *unix_path;
 124     struct dump_open_params params;
 125
 126     TRACE( "%p, %s\n", pcap, debugstr_a(filename) );
 127
 128     if (!(filenameW = strdupAW( filename ))) return NULL;
 129     unix_path = wine_get_unix_file_name( filenameW );
 130     free( filenameW );
 131     if (!unix_path) return NULL;
 132
 133     TRACE( "unix_path %s\n", debugstr_a(unix_path) );
 134
 135     params.pcap = pcap;
 136     params.name = unix_path;
 137     params.ret = &dumper;
 138     PCAP_CALL( dump_open, &params );
 139     HeapFree( GetProcessHeap(), 0, unix_path );
 140     return dumper;
 141 }
 142
 143 static void free_addresses( struct pcap_address *addrs )
 144 {
 145     struct pcap_address *next, *cur = addrs;
 146     if (!addrs) return;
 147     do
 148     {
 149         free( cur->addr );
 150         free( cur->netmask );
 151         free( cur->broadaddr );
 152         free( cur->dstaddr );
 153         next = cur->next;
 154         free( cur );
 155         cur = next;
 156     } while (next);
 157 }
 158
 159 static void free_devices( struct pcap_interface *devs )
 160 {
 161     struct pcap_interface *next, *cur = devs;
 162     if (!devs) return;
 163     do
 164     {
 165         free( cur->name );
 166         free( cur->description );
 167         free_addresses( cur->addresses );
 168         next = cur->next;
 169         free( cur );
 170         cur = next;
 171     } while (next);
 172 }
 173
 174 static IP_ADAPTER_ADDRESSES *get_adapters( void )
 175 {
 176     DWORD size = 0;
 177     IP_ADAPTER_ADDRESSES *ret;
 178     ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
 179
 180     if (GetAdaptersAddresses( AF_UNSPEC, flags, NULL, NULL, &size ) != ERROR_BUFFER_OVERFLOW) return NULL;
 181     if (!(ret = malloc( size ))) return NULL;
 182     if (GetAdaptersAddresses( AF_UNSPEC, flags, NULL, ret, &size ))
 183     {
 184         free( ret );
 185         return NULL;
 186     }
 187     return ret;
 188 }
 189
 190 static IP_ADAPTER_ADDRESSES *find_adapter( IP_ADAPTER_ADDRESSES *list, const char *name )
 191 {
 192     IP_ADAPTER_ADDRESSES *ret;
 193     WCHAR *nameW;
 194
 195     if (!(nameW = strdupAW( name ))) return NULL;
 196     for (ret = list; ret; ret = ret->Next)
 197     {
 198         if (!wcscmp( nameW, ret->FriendlyName )) break;
 199     }
 200     free( nameW);
 201     return ret;
 202 }
 203
 204 static char *build_win32_name( const char *source, const char *adapter_name )
 205 {
 206     const char prefix[] = "\\Device\\NPF_";
 207     int len = sizeof(prefix) + strlen(adapter_name);
 208     char *ret;
 209
 210     if (source) len += strlen( source );
 211     if ((ret = malloc( len )))
 212     {
 213         ret[0] = 0;
 214         if (source) strcat( ret, source );
 215         strcat( ret, prefix );
 216         strcat( ret, adapter_name );
 217     }
 218     return ret;
 219 }
 220
 221 static char *build_win32_description( const struct pcap_interface *unix_dev )
 222 {
 223     int len = strlen(unix_dev->name) + 1;
 224     char *ret;
 225
 226     if (unix_dev->description && unix_dev->description[0]) len += strlen(unix_dev->description) + 1;
 227     if ((ret = malloc( len )))
 228     {
 229         if (unix_dev->description)
 230         {
 231             strcpy( ret, unix_dev->description );
 232             strcat( ret, " " );
 233             strcat( ret, unix_dev->name );
 234         }
 235         else strcpy( ret, unix_dev->name );
 236     }
 237     return ret;
 238 }
 239
 240 static struct sockaddr *get_address( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 241 {
 242     struct sockaddr *ret;
 243     if (!(ret = malloc( addr->Address.iSockaddrLength ))) return NULL;
 244     memcpy( ret, addr->Address.lpSockaddr, addr->Address.iSockaddrLength );
 245     return ret;
 246 }
 247
 248 static void convert_length_to_ipv6_mask( ULONG length, IN6_ADDR *mask )
 249 {
 250     unsigned int i;
 251     for (i = 0; i < length / 8; i++) mask->u.Byte[i] = 0xff;
 252     mask->u.Byte[i] = 0xff << (8 - length % 8);
 253 }
 254
 255 static struct sockaddr *get_netmask( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 256 {
 257     struct sockaddr *ret;
 258
 259     switch (addr->Address.lpSockaddr->sa_family)
 260     {
 261     case AF_INET:
 262     {
 263         struct sockaddr_in *netmask_addr_in;
 264
 265         if (!(netmask_addr_in = calloc( 1, sizeof(*netmask_addr_in) ))) return NULL;
 266         netmask_addr_in->sin_family = AF_INET;
 267         ConvertLengthToIpv4Mask( addr->OnLinkPrefixLength, &netmask_addr_in->sin_addr.S_un.S_addr );
 268         ret = (struct sockaddr *)netmask_addr_in;
 269         break;
 270     }
 271     case AF_INET6:
 272     {
 273         struct sockaddr_in6 *netmask_addr_in6;
 274
 275         if (!(netmask_addr_in6 = calloc( 1, sizeof(*netmask_addr_in6) ))) return NULL;
 276         netmask_addr_in6->sin6_family = AF_INET6;
 277         convert_length_to_ipv6_mask( addr->OnLinkPrefixLength, &netmask_addr_in6->sin6_addr );
 278         ret = (struct sockaddr *)netmask_addr_in6;
 279         break;
 280     }
 281     default:
 282         FIXME( "address family %u not supported\n", addr->Address.lpSockaddr->sa_family );
 283         return NULL;
 284     }
 285
 286     return ret;
 287 }
 288
 289 static struct sockaddr *get_broadcast( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 290 {
 291     struct sockaddr *ret;
 292
 293     switch (addr->Address.lpSockaddr->sa_family)
 294     {
 295     case AF_INET:
 296     {
 297         struct sockaddr_in *broadcast_addr_in, *addr_in = (struct sockaddr_in *)addr->Address.lpSockaddr;
 298         ULONG netmask;
 299
 300         if (!(broadcast_addr_in = calloc( 1, sizeof(*broadcast_addr_in) ))) return FALSE;
 301         broadcast_addr_in->sin_family = AF_INET;
 302         ConvertLengthToIpv4Mask( addr->OnLinkPrefixLength, &netmask );
 303         broadcast_addr_in->sin_addr.S_un.S_addr = addr_in->sin_addr.S_un.S_addr | ~netmask;
 304         ret = (struct sockaddr *)broadcast_addr_in;
 305         break;
 306     }
 307     case AF_INET6:
 308     {
 309         struct sockaddr_in6 *broadcast_addr_in6, *addr_in6 = (struct sockaddr_in6 *)addr->Address.lpSockaddr;
 310         IN6_ADDR netmask, *address = (IN6_ADDR *)&addr_in6->sin6_addr;
 311         unsigned int i;
 312
 313         if (!(broadcast_addr_in6 = calloc( 1, sizeof(*broadcast_addr_in6) ))) return NULL;
 314         broadcast_addr_in6->sin6_family = AF_INET6;
 315         convert_length_to_ipv6_mask( addr->OnLinkPrefixLength, &netmask );
 316         for (i = 0; i < 8; i++) broadcast_addr_in6->sin6_addr.u.Word[i] = address->u.Word[i] | ~netmask.u.Word[i];
 317         ret = (struct sockaddr *)broadcast_addr_in6;
 318         break;
 319     }
 320     default:
 321         FIXME( "address family %u not supported\n", addr->Address.lpSockaddr->sa_family );
 322         return NULL;
 323     }
 324
 325     return ret;
 326 }
 327
 328 static struct pcap_address *build_win32_address( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 329 {
 330     struct pcap_address *ret;
 331
 332     if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
 333     if (!(ret->addr = get_address( addr ))) goto err;
 334     if (!(ret->netmask = get_netmask( addr ))) goto err;
 335     if (!(ret->broadaddr = get_broadcast( addr ))) goto err;
 336     return ret;
 337
 338 err:
 339     free( ret->addr );
 340     free( ret->netmask );
 341     free( ret->broadaddr );
 342     free( ret );
 343     return NULL;
 344 }
 345
 346 static void add_win32_address( struct pcap_address **list, struct pcap_address *addr )
 347 {
 348     struct pcap_address *cur = *list;
 349     if (!cur) *list = addr;
 350     else
 351     {
 352         while (cur->next) { cur = cur->next; }
 353         cur->next = addr;
 354     }
 355 }
 356
 357 static struct pcap_address *build_win32_addresses( const IP_ADAPTER_ADDRESSES *adapter )
 358 {
 359     struct pcap_address *dst, *ret = NULL;
 360     IP_ADAPTER_UNICAST_ADDRESS *src = adapter->FirstUnicastAddress;
 361     while (src)
 362     {
 363         if ((dst = build_win32_address( src ))) add_win32_address( &ret, dst );
 364         src = src->Next;
 365     }
 366     return ret;
 367 }
 368
 369 static struct pcap_interface *build_win32_device( const struct pcap_interface *unix_dev, const char *source,
 370                                                   const IP_ADAPTER_ADDRESSES *adapter )
 371 {
 372     struct pcap_interface *ret;
 373
 374     if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
 375     if (!(ret->name = build_win32_name( source, adapter->AdapterName ))) goto err;
 376     if (!(ret->description = build_win32_description( unix_dev ))) goto err;
 377     ret->addresses = build_win32_addresses( adapter );
 378     ret->flags = unix_dev->flags;
 379     return ret;
 380
 381 err:
 382     free( ret->name );
 383     free( ret->description );
 384     free_addresses( ret->addresses );
 385     free( ret );
 386     return NULL;
 387 }
 388
 389 static void add_win32_device( struct pcap_interface **list, struct pcap_interface *dev )
 390 {
 391     struct pcap_interface *cur = *list;
 392     if (!cur) *list = dev;
 393     else
 394     {
 395         while (cur->next) { cur = cur->next; }
 396         cur->next = dev;
 397     }
 398 }
 399
 400 static int find_all_devices( const char *source, struct pcap_interface **devs, char *errbuf )
 401 {
 402     struct pcap_interface *unix_devs, *win32_devs = NULL, *cur, *dev;
 403     IP_ADAPTER_ADDRESSES *ptr, *adapters = get_adapters();
 404     struct findalldevs_params params = { &unix_devs, errbuf };
 405     int ret;
 406
 407     if (!adapters)
 408     {
 409         if (errbuf) sprintf( errbuf, "Out of memory." );
 410         return -1;
 411     }
 412
 413     if (!(ret = PCAP_CALL( findalldevs, &params )))
 414     {
 415         cur = unix_devs;
 416         while (cur)
 417         {
 418             if ((ptr = find_adapter( adapters, cur->name )) && (dev = build_win32_device( cur, source, ptr )))
 419             {
 420                 add_win32_device( &win32_devs, dev );
 421             }
 422             cur = cur->next;
 423         }
 424         *devs = win32_devs;
 425         PCAP_CALL( freealldevs, unix_devs );
 426     }
 427
 428     free( adapters );
 429     return ret;
 430 }
 431
 432 int CDECL pcap_findalldevs( struct pcap_interface **devs, char *errbuf )
 433 {
 434     TRACE( "%p, %p\n", devs, errbuf );
 435     return find_all_devices( NULL, devs, errbuf );
 436 }
 437
 438 int CDECL pcap_findalldevs_ex( char *source, void *auth, struct pcap_interface **devs, char *errbuf )
 439 {
 440     FIXME( "%s, %p, %p, %p: partial stub\n", debugstr_a(source), auth, devs, errbuf );
 441     return find_all_devices( source, devs, errbuf );
 442 }
 443
 444 void CDECL pcap_free_datalinks( int *links )
 445 {
 446     TRACE( "%p\n", links );
 447     PCAP_CALL( free_datalinks, links );
 448 }
 449
 450 void CDECL pcap_free_tstamp_types( int *types )
 451 {
 452     TRACE( "%p\n", types );
 453     PCAP_CALL( free_tstamp_types, types );
 454 }
 455
 456 void CDECL pcap_freealldevs( struct pcap_interface *devs )
 457 {
 458     TRACE( "%p\n", devs );
 459     free_devices( devs );
 460 }
 461
 462 void CDECL pcap_freecode( void *program )
 463 {
 464     TRACE( "%p\n", program );
 465     PCAP_CALL( freecode, program );
 466 }
 467
 468 void * CDECL pcap_get_airpcap_handle( struct pcap *pcap )
 469 {
 470     TRACE( "%p\n", pcap );
 471     return NULL;
 472 }
 473
 474 int CDECL pcap_get_tstamp_precision( struct pcap *pcap )
 475 {
 476     TRACE( "%p\n", pcap );
 477     return PCAP_CALL( get_tstamp_precision, pcap );
 478 }
 479
 480 char * CDECL pcap_geterr( struct pcap *pcap )
 481 {
 482     char *ret;
 483     struct geterr_params params = { pcap, &ret };
 484     TRACE( "%p\n", pcap );
 485     PCAP_CALL( geterr, &params );
 486     return ret;
 487 }
 488
 489 int CDECL pcap_getnonblock( struct pcap *pcap, char *errbuf )
 490 {
 491     struct getnonblock_params params = { pcap, errbuf };
 492     TRACE( "%p, %p\n", pcap, errbuf );
 493     return PCAP_CALL( getnonblock, &params );
 494 }
 495
 496 static char lib_version[256];
 497 static BOOL WINAPI init_lib_version( INIT_ONCE *once, void *param, void **ctx )
 498 {
 499     struct lib_version_params params = { lib_version, sizeof(lib_version) };
 500     PCAP_CALL( lib_version, &params );
 501     return TRUE;
 502 }
 503
 504 const char * CDECL pcap_lib_version( void )
 505 {
 506     static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
 507     if (!lib_version[0]) InitOnceExecuteOnce( &once, init_lib_version, NULL, NULL );
 508     TRACE( "%s\n", debugstr_a(lib_version) );
 509     return lib_version;
 510 }
 511
 512 int CDECL pcap_list_datalinks( struct pcap *pcap, int **buf )
 513 {
 514     struct list_datalinks_params params = { pcap, buf };
 515     TRACE( "%p, %p\n", pcap, buf );
 516     return PCAP_CALL( list_datalinks, &params );
 517 }
 518
 519 int CDECL pcap_list_tstamp_types( struct pcap *pcap, int **types )
 520 {
 521     struct list_tstamp_types_params params = { pcap, types };
 522     TRACE( "%p, %p\n", pcap, types );
 523     return PCAP_CALL( list_tstamp_types, &params );
 524 }
 525
 526 char * CDECL pcap_lookupdev( char *errbuf )
 527 {
 528     static char *ret;
 529     struct pcap_interface *devs;
 530
 531     TRACE( "%p\n", errbuf );
 532     if (!ret)
 533     {
 534         if (pcap_findalldevs( &devs, errbuf ) == -1 || !devs) return NULL;
 535         if ((ret = malloc( strlen(devs->name) + 1 ))) strcpy( ret, devs->name );
 536         pcap_freealldevs( devs );
 537     }
 538     return ret;
 539 }
 540
 541 int CDECL pcap_lookupnet( const char *device, unsigned int *net, unsigned int *mask, char *errbuf )
 542 {
 543     struct lookupnet_params params = { device, net, mask, errbuf };
 544     TRACE( "%s, %p, %p, %p\n", debugstr_a(device), net, mask, errbuf );
 545     return PCAP_CALL( lookupnet, &params );
 546 }
 547
 548 int CDECL pcap_loop( struct pcap *pcap, int count,
 549                      void (CALLBACK *callback)(unsigned char *, const struct pcap_pkthdr_win32 *, const unsigned char *),
 550                      unsigned char *user)
 551 {
 552     /* FIXME: reimplement on top of pcap_next_ex */
 553     FIXME( "%p, %d, %p, %p: not implemented\n", pcap, count, callback, user );
 554     return -1;
 555 }
 556
 557 int CDECL pcap_major_version( struct pcap *pcap )
 558 {
 559     TRACE( "%p\n", pcap );
 560     return PCAP_CALL( major_version, pcap );
 561 }
 562
 563 int CDECL pcap_minor_version( struct pcap *pcap )
 564 {
 565     TRACE( "%p\n", pcap );
 566     return PCAP_CALL( minor_version, pcap );
 567 }
 568
 569 int CDECL pcap_next_ex( struct pcap *pcap, struct pcap_pkthdr_win32 **hdr, const unsigned char **data )
 570 {
 571     struct next_ex_params params = { pcap, hdr, data };
 572     TRACE( "%p, %p, %p\n", pcap, hdr, data );
 573     return PCAP_CALL( next_ex, &params );
 574 }
 575
 576 const unsigned char * CDECL pcap_next( struct pcap *pcap, struct pcap_pkthdr_win32 *hdr )
 577 {
 578     struct pcap_pkthdr_win32 *hdr_ptr;
 579     const unsigned char *data;
 580
 581     pcap_next_ex( pcap, &hdr_ptr, &data );
 582     *hdr = *hdr_ptr;
 583     return data;
 584 }
 585
 586 int CDECL pcap_dispatch( struct pcap *pcap, int count,
 587                          void (CALLBACK *callback)(unsigned char *, const struct pcap_pkthdr_win32 *, const unsigned char *),
 588                          unsigned char *user )
 589 {
 590     int processed = 0;
 591     TRACE( "%p, %d, %p, %p\n", pcap, count, callback, user );
 592
 593     while (processed < count)
 594     {
 595         struct pcap_pkthdr_win32 *hdr = NULL;
 596         const unsigned char *data = NULL;
 597
 598         int ret = pcap_next_ex( pcap, &hdr, &data );
 599
 600         if (ret == 1)
 601             processed++;
 602         else if (ret == 0)
 603             break;
 604         else if (ret == -2)
 605         {
 606             if (processed == 0) return -2;
 607             break;
 608         }
 609         else
 610             return ret;
 611
 612         callback( user, hdr, data );
 613     }
 614
 615     return processed;
 616 }
 617
 618 static char *strdupWA( const WCHAR *src )
 619 {
 620     char *dst;
 621     int len = WideCharToMultiByte( CP_ACP, 0, src, -1, NULL, 0, NULL, NULL );
 622     if ((dst = malloc( len ))) WideCharToMultiByte( CP_ACP, 0, src, -1, dst, len, NULL, NULL );
 623     return dst;
 624 }
 625
 626 static char *map_win32_device_name( const char *dev )
 627 {
 628     IP_ADAPTER_ADDRESSES *ptr, *adapters = get_adapters();
 629     const char *name = strchr( dev, '{' );
 630     char *ret = NULL;
 631
 632     if (!adapters || !name) return NULL;
 633     for (ptr = adapters; ptr; ptr = ptr->Next)
 634     {
 635         if (!strcmp( name, ptr->AdapterName ))
 636         {
 637             ret = strdupWA( ptr->FriendlyName );
 638             break;
 639         }
 640     }
 641     free( adapters );
 642     return ret;
 643 }
 644
 645 struct pcap * CDECL pcap_create( const char *source, char *errbuf )
 646 {
 647     char *unix_dev;
 648     struct pcap *ret;
 649     TRACE( "%s, %p\n", source, errbuf );
 650
 651     if (!(unix_dev = map_win32_device_name( source )))
 652     {
 653         if (errbuf) sprintf( errbuf, "Unable to open the adapter." );
 654         return NULL;
 655     }
 656     else
 657     {
 658         struct create_params params = { unix_dev, errbuf, &ret };
 659         PCAP_CALL( create, &params );
 660     }
 661     free( unix_dev );
 662     return ret;
 663 }
 664
 665 static struct pcap *open_live( const char *source, int snaplen, int promisc, int timeout, char *errbuf )
 666 {
 667     char *unix_dev;
 668     struct pcap *ret;
 669
 670     if (!(unix_dev = map_win32_device_name( source )))
 671     {
 672         if (errbuf) sprintf( errbuf, "Unable to open the adapter." );
 673         return NULL;
 674     }
 675     else
 676     {
 677         struct open_live_params params = { unix_dev, snaplen, promisc, timeout, errbuf, &ret };
 678         PCAP_CALL( open_live, &params );
 679     }
 680     free( unix_dev );
 681     return ret;
 682 }
 683
 684 #define PCAP_OPENFLAG_PROMISCUOUS 1
 685 struct pcap * CDECL pcap_open( const char *source, int snaplen, int flags, int timeout, void *auth, char *errbuf )
 686 {
 687     FIXME( "%s, %d, %d, %d, %p, %p: partial stub\n", debugstr_a(source), snaplen, flags, timeout, auth, errbuf );
 688     return open_live( source, snaplen, flags & PCAP_OPENFLAG_PROMISCUOUS, timeout, errbuf );
 689 }
 690
 691 struct pcap * CDECL pcap_open_live( const char *source, int snaplen, int promisc, int to_ms, char *errbuf )
 692 {
 693     TRACE( "%s, %d, %d, %d, %p\n", debugstr_a(source), snaplen, promisc, to_ms, errbuf );
 694     return open_live( source, snaplen, promisc, to_ms, errbuf );
 695 }
 696
 697 #define PCAP_SRC_FILE    2
 698 #define PCAP_SRC_IFLOCAL 3
 699
 700 int CDECL pcap_parsesrcstr( const char *source, int *type, char *host, char *port, char *name, char *errbuf )
 701 {
 702     int t = PCAP_SRC_IFLOCAL;
 703     const char *p = source;
 704
 705     FIXME( "%s, %p, %p, %p, %p, %p: partial stub\n", debugstr_a(source), type, host, port, name, errbuf );
 706
 707     if (host)
 708         *host = '\0';
 709     if (port)
 710         *port = '\0';
 711     if (name)
 712         *name = '\0';
 713
 714     if (!strncmp(p, "rpcap://", strlen("rpcap://")))
 715         p += strlen("rpcap://");
 716     else if (!strncmp(p, "file://", strlen("file://")))
 717     {
 718         p += strlen("file://");
 719         t = PCAP_SRC_FILE;
 720     }
 721
 722     if (type)
 723         *type = t;
 724
 725     if (!*p)
 726     {
 727         if (errbuf)
 728             sprintf(errbuf, "The name has not been specified in the source string.");
 729         return -1;
 730     }
 731
 732     if (name)
 733         strcpy(name, p);
 734
 735     return 0;
 736 }
 737
 738 int CDECL pcap_sendpacket( struct pcap *pcap, const unsigned char *buf, int size )
 739 {
 740     struct sendpacket_params params = { pcap, buf, size };
 741     TRACE( "%p, %p, %d\n", pcap, buf, size );
 742     return PCAP_CALL( sendpacket, &params );
 743 }
 744
 745 int CDECL pcap_set_buffer_size( struct pcap *pcap, int size )
 746 {
 747     struct set_buffer_size_params params = { pcap, size };
 748     TRACE( "%p, %d\n", pcap, size );
 749     return PCAP_CALL( set_buffer_size, &params );
 750 }
 751
 752 int CDECL pcap_set_datalink( struct pcap *pcap, int link )
 753 {
 754     struct set_datalink_params params = { pcap, link };
 755     TRACE( "%p, %d\n", pcap, link );
 756     return PCAP_CALL( set_datalink, &params );
 757 }
 758
 759 int CDECL pcap_set_promisc( struct pcap *pcap, int enable )
 760 {
 761     struct set_promisc_params params = { pcap, enable };
 762     TRACE( "%p, %d\n", pcap, enable );
 763     return PCAP_CALL( set_promisc, &params );
 764 }
 765
 766 int CDECL pcap_set_rfmon( struct pcap *pcap, int enable )
 767 {
 768     struct set_rfmon_params params = { pcap, enable };
 769     TRACE( "%p, %d\n", pcap, enable );
 770     return PCAP_CALL( set_rfmon, &params );
 771 }
 772
 773 int CDECL pcap_set_snaplen( struct pcap *pcap, int len )
 774 {
 775     struct set_snaplen_params params = { pcap, len };
 776     TRACE( "%p, %d\n", pcap, len );
 777     return PCAP_CALL( set_snaplen, &params );
 778 }
 779
 780 int CDECL pcap_set_timeout( struct pcap *pcap, int timeout )
 781 {
 782     struct set_timeout_params params = { pcap, timeout };
 783     TRACE( "%p, %d\n", pcap, timeout );
 784     return PCAP_CALL( set_timeout, &params );
 785 }
 786
 787 int CDECL pcap_set_tstamp_precision( struct pcap *pcap, int precision )
 788 {
 789     struct set_tstamp_precision_params params = { pcap, precision };
 790     TRACE( "%p, %d\n", pcap, precision );
 791     return PCAP_CALL( set_tstamp_precision, &params );
 792 }
 793
 794 int CDECL pcap_set_tstamp_type( struct pcap *pcap, int type )
 795 {
 796     struct set_tstamp_type_params params = { pcap, type };
 797     TRACE( "%p, %d\n", pcap, type );
 798     return PCAP_CALL( set_tstamp_type, &params );
 799 }
 800
 801 int CDECL pcap_setbuff( struct pcap *pcap, int size )
 802 {
 803     FIXME( "%p, %d\n", pcap, size );
 804     return 0;
 805 }
 806
 807 int CDECL pcap_setfilter( struct pcap *pcap, void *program )
 808 {
 809     struct setfilter_params params = { pcap, program };
 810     TRACE( "%p, %p\n", pcap, program );
 811     return PCAP_CALL( setfilter, &params );
 812 }
 813
 814 int CDECL pcap_setnonblock( struct pcap *pcap, int nonblock, char *errbuf )
 815 {
 816     struct setnonblock_params params = { pcap, nonblock, errbuf };
 817     TRACE( "%p, %d, %p\n", pcap, nonblock, errbuf );
 818     return PCAP_CALL( setnonblock, &params );
 819 }
 820
 821 int CDECL pcap_snapshot( struct pcap *pcap )
 822 {
 823     TRACE( "%p\n", pcap );
 824     return PCAP_CALL( snapshot, pcap );
 825 }
 826
 827 int CDECL pcap_stats( struct pcap *pcap, void *stats )
 828 {
 829     struct stats_params params = { pcap, stats };
 830     TRACE( "%p, %p\n", pcap, stats );
 831     return PCAP_CALL( stats, &params );
 832 }
 833
 834 const char * CDECL pcap_statustostr( int status )
 835 {
 836     const char *ret;
 837     struct statustostr_params params = { status, &ret };
 838     TRACE( "%d\n", status );
 839     PCAP_CALL( statustostr, &params );
 840     return ret;
 841 }
 842
 843 int CDECL pcap_tstamp_type_name_to_val( const char *name )
 844 {
 845     struct tstamp_type_name_to_val_params params = { name };
 846     TRACE( "%s\n", debugstr_a(name) );
 847     return PCAP_CALL( tstamp_type_name_to_val, &params );
 848 }
 849
 850 const char * CDECL pcap_tstamp_type_val_to_description( int val )
 851 {
 852     const char *ret;
 853     struct tstamp_type_val_to_description_params params = { val, &ret };
 854     TRACE( "%d\n", val );
 855     PCAP_CALL( tstamp_type_val_to_description, &params );
 856     return ret;
 857 }
 858
 859 const char * CDECL pcap_tstamp_type_val_to_name( int val )
 860 {
 861     const char *ret;
 862     struct tstamp_type_val_to_name_params params = { val, &ret };
 863     TRACE( "%d\n", val );
 864     PCAP_CALL( tstamp_type_val_to_name, &params );
 865     return ret;
 866 }
 867
 868 int CDECL wsockinit( void )
 869 {
 870     WSADATA wsadata;
 871     TRACE( "\n" );
 872     if (WSAStartup( MAKEWORD(1, 1), &wsadata )) return -1;
 873     return 0;
 874 }
 875
 876 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, void *reserved )
 877 {
 878     switch (reason)
 879     {
 880     case DLL_PROCESS_ATTACH:
 881         DisableThreadLibraryCalls( hinst );
 882         if (__wine_init_unix_call())
 883             ERR( "No pcap support, expect problems\n" );
 884         break;
 885     case DLL_PROCESS_DETACH:
 886         break;
 887     }
 888     return TRUE;
 889 }