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 <assert.h>
  30 #include <stdarg.h>
  31 #include <stdlib.h>
  32 #include <limits.h>
  33 #include "ntstatus.h"
  34 #define WIN32_NO_STATUS
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "winternl.h"
  38
  39 #include "wine/unixlib.h"
  40 #include "wine/debug.h"
  41 #include "unixlib.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(wpcap);
  44
  45 static NTSTATUS wrap_activate( void *args )
  46 {
  47     const struct activate_params *params = args;
  48     return pcap_activate( (pcap_t *)(ULONG_PTR)params->handle );
  49 }
  50
  51 static NTSTATUS wrap_breakloop( void *args )
  52 {
  53     const struct breakloop_params *params = args;
  54     pcap_breakloop( (pcap_t *)(ULONG_PTR)params->handle );
  55     return STATUS_SUCCESS;
  56 }
  57
  58 static NTSTATUS wrap_bufsize( void *args )
  59 {
  60     const struct bufsize_params *params = args;
  61     return pcap_bufsize( (pcap_t *)(ULONG_PTR)params->handle );
  62 }
  63
  64 static NTSTATUS wrap_can_set_rfmon( void *args )
  65 {
  66     const struct can_set_rfmon_params *params = args;
  67     return pcap_can_set_rfmon( (pcap_t *)(ULONG_PTR)params->handle );
  68 }
  69
  70 static NTSTATUS wrap_close( void *args )
  71 {
  72     const struct close_params *params = args;
  73     pcap_close( (pcap_t *)(ULONG_PTR)params->handle );
  74     return STATUS_SUCCESS;
  75 }
  76
  77 static NTSTATUS wrap_compile( void *args )
  78 {
  79     struct compile_params *params = args;
  80     struct bpf_program program;
  81     int ret;
  82
  83     if (!(ret = pcap_compile( (pcap_t *)(ULONG_PTR)params->handle, &program, params->str, params->optimize,
  84                               params->mask )))
  85     {
  86         if (*params->program_len < program.bf_len) ret = STATUS_BUFFER_TOO_SMALL;
  87         else memcpy( params->program_insns, program.bf_insns, program.bf_len * sizeof(*program.bf_insns) );
  88         *params->program_len = program.bf_len;
  89         pcap_freecode( &program );
  90     }
  91     return ret;
  92 }
  93
  94 static NTSTATUS wrap_create( void *args )
  95 {
  96     struct create_params *params = args;
  97     if (!(*params->handle = (ULONG_PTR)pcap_create( params->source, params->errbuf ))) return STATUS_NO_MEMORY;
  98     return STATUS_SUCCESS;
  99 }
 100
 101 static NTSTATUS wrap_datalink( void *args )
 102 {
 103     struct datalink_params *params = args;
 104     return pcap_datalink( (pcap_t *)(ULONG_PTR)params->handle );
 105 }
 106
 107 static NTSTATUS wrap_datalink_name_to_val( void *args )
 108 {
 109     struct datalink_name_to_val_params *params = args;
 110     return pcap_datalink_name_to_val( params->name );
 111 }
 112
 113 static NTSTATUS wrap_datalink_val_to_description( void *args )
 114 {
 115     const struct datalink_val_to_description_params *params = args;
 116     const char *str = pcap_datalink_val_to_description( params->link );
 117     int len;
 118
 119     if (!str || !params->buf) return STATUS_INVALID_PARAMETER;
 120     if ((len = strlen( str )) >= *params->buflen)
 121     {
 122         *params->buflen = len + 1;
 123         return STATUS_BUFFER_TOO_SMALL;
 124     }
 125     strcpy( params->buf, str );
 126     return STATUS_SUCCESS;
 127 }
 128
 129 static NTSTATUS wrap_datalink_val_to_name( void *args )
 130 {
 131     const struct datalink_val_to_name_params *params = args;
 132     const char *str = pcap_datalink_val_to_name( params->link );
 133     int len;
 134
 135     if (!str || !params->buf) return STATUS_INVALID_PARAMETER;
 136     if ((len = strlen( str )) >= *params->buflen)
 137     {
 138         *params->buflen = len + 1;
 139         return STATUS_BUFFER_TOO_SMALL;
 140     }
 141     strcpy( params->buf, str );
 142     return STATUS_SUCCESS;
 143 }
 144
 145 static NTSTATUS wrap_dump( void *args )
 146 {
 147     const struct dump_params *params = args;
 148     struct pcap_pkthdr hdr_unix;
 149
 150     hdr_unix.ts.tv_sec  = params->hdr->ts.tv_sec;
 151     hdr_unix.ts.tv_usec = params->hdr->ts.tv_usec;
 152     hdr_unix.caplen     = params->hdr->caplen;
 153     hdr_unix.len        = params->hdr->len;
 154     pcap_dump( params->user, &hdr_unix, params->packet );
 155     return STATUS_SUCCESS;
 156 }
 157
 158 static NTSTATUS wrap_dump_close( void *args )
 159 {
 160     const struct dump_close_params *params = args;
 161     pcap_dump_close( (pcap_dumper_t *)(ULONG_PTR)params->handle );
 162     return STATUS_SUCCESS;
 163 }
 164
 165 static NTSTATUS wrap_dump_open( void *args )
 166 {
 167     const struct dump_open_params *params = args;
 168     *params->ret_handle = (ULONG_PTR)pcap_dump_open( (pcap_t *)(ULONG_PTR)params->handle, params->name );
 169     return STATUS_SUCCESS;
 170 }
 171
 172 static NTSTATUS wrap_findalldevs( void *args )
 173 {
 174     const struct findalldevs_params *params = args;
 175     pcap_if_t *devs = NULL, *src;
 176     struct pcap_interface_offsets *dst = (struct pcap_interface_offsets *)params->buf;
 177     int ret, len_total = 0;
 178
 179     if ((ret = pcap_findalldevs( &devs, params->errbuf ))) return ret;
 180
 181     src = devs;
 182     while (src)
 183     {
 184         int len_name = strlen( src->name ) + 1, len_description = src->description ? strlen( src->description ) + 1 : 0;
 185         int len = sizeof(*dst) + len_name + len_description;
 186
 187         if (*params->buflen >= len_total + len)
 188         {
 189             dst->name_offset = sizeof(*dst);
 190             dst->name_len = len_name;
 191             strcpy( (char *)dst + dst->name_offset, src->name );
 192             if (!len_description) dst->description_offset = dst->description_len = 0;
 193             else
 194             {
 195                 dst->description_offset = dst->name_offset + len_name;
 196                 dst->description_len = len_description;
 197                 strcpy( (char *)dst + dst->description_offset, src->description );
 198             }
 199             dst->flags = src->flags;
 200             dst = (struct pcap_interface_offsets *)((char *)dst + len);
 201         }
 202         len_total += len;
 203         src = src->next;
 204     }
 205
 206     if (*params->buflen < len_total) ret = STATUS_BUFFER_TOO_SMALL;
 207     *params->buflen = len_total;
 208     pcap_freealldevs( devs );
 209     return ret;
 210 }
 211
 212 static NTSTATUS wrap_get_tstamp_precision( void *args )
 213 {
 214     const struct get_tstamp_precision_params *params = args;
 215     return pcap_get_tstamp_precision( (pcap_t *)(ULONG_PTR)params->handle );
 216 }
 217
 218 static NTSTATUS wrap_geterr( void *args )
 219 {
 220     const struct geterr_params *params = args;
 221     char *errbuf = pcap_geterr( (pcap_t *)(ULONG_PTR)params->handle );
 222     assert( strlen(errbuf) < PCAP_ERRBUF_SIZE );
 223     strcpy( params->errbuf, errbuf );
 224     return STATUS_SUCCESS;
 225 }
 226
 227 static NTSTATUS wrap_getnonblock( void *args )
 228 {
 229     const struct getnonblock_params *params = args;
 230     return pcap_getnonblock( (pcap_t *)(ULONG_PTR)params->handle, params->errbuf );
 231 }
 232
 233 static NTSTATUS wrap_init( void *args )
 234 {
 235     const struct init_params *params = args;
 236     return pcap_init( params->opt, params->errbuf );
 237 }
 238
 239 static NTSTATUS wrap_lib_version( void *args )
 240 {
 241     const struct lib_version_params *params = args;
 242     const char *str = pcap_lib_version();
 243     unsigned int len = min( strlen(str) + 1, params->size );
 244
 245     memcpy( params->version, str, len );
 246     params->version[len - 1] = 0;
 247     return STATUS_SUCCESS;
 248 }
 249
 250 static NTSTATUS wrap_list_datalinks( void *args )
 251 {
 252     const struct list_datalinks_params *params = args;
 253     NTSTATUS status = STATUS_SUCCESS;
 254     int *links = NULL, count;
 255
 256     if ((count = pcap_list_datalinks( (pcap_t *)(ULONG_PTR)params->handle, &links )) > 0)
 257     {
 258         if (*params->count < count) status = STATUS_BUFFER_TOO_SMALL;
 259         else memcpy( params->links, links, count * sizeof(*links) );
 260     }
 261     pcap_free_datalinks( links );
 262     *params->count = count;
 263     return status;
 264 }
 265
 266 static NTSTATUS wrap_list_tstamp_types( void *args )
 267 {
 268     const struct list_tstamp_types_params *params = args;
 269     NTSTATUS status = STATUS_SUCCESS;
 270     int *types = NULL, count;
 271
 272     if ((count = pcap_list_tstamp_types( (pcap_t *)(ULONG_PTR)params->handle, &types )) > 0)
 273     {
 274         if (*params->count < count) status = STATUS_BUFFER_TOO_SMALL;
 275         else memcpy( params->types, types, count * sizeof(*types) );
 276     }
 277     pcap_free_tstamp_types( types );
 278     *params->count = count;
 279     return status;
 280 }
 281
 282 static NTSTATUS wrap_lookupnet( void *args )
 283 {
 284     const struct lookupnet_params *params = args;
 285     return pcap_lookupnet( params->device, params->net, params->mask, params->errbuf );
 286 }
 287
 288 static NTSTATUS wrap_major_version( void *args )
 289 {
 290     const struct major_version_params *params = args;
 291     return pcap_major_version( (pcap_t *)(ULONG_PTR)params->handle );
 292 }
 293
 294 static NTSTATUS wrap_minor_version( void *args )
 295 {
 296     const struct minor_version_params *params = args;
 297     return pcap_minor_version( (pcap_t *)(ULONG_PTR)params->handle );
 298 }
 299
 300 static NTSTATUS wrap_next_ex( void *args )
 301 {
 302     struct next_ex_params *params = args;
 303     struct pcap_pkthdr *hdr_unix;
 304     int ret;
 305
 306     if ((ret = pcap_next_ex( (pcap_t *)(ULONG_PTR)params->handle, &hdr_unix, params->data )) == 1)
 307     {
 308         if (hdr_unix->ts.tv_sec > INT_MAX || hdr_unix->ts.tv_usec > INT_MAX) WARN( "truncating timeval values(s)\n" );
 309         params->hdr->ts.tv_sec  = hdr_unix->ts.tv_sec;
 310         params->hdr->ts.tv_usec = hdr_unix->ts.tv_usec;
 311         params->hdr->caplen     = hdr_unix->caplen;
 312         params->hdr->len        = hdr_unix->len;
 313     }
 314     return ret;
 315 }
 316
 317 static NTSTATUS wrap_open_live( void *args )
 318 {
 319     const struct open_live_params *params = args;
 320     if (!(*params->handle = (ULONG_PTR)pcap_open_live( params->source, params->snaplen, params->promisc,
 321                                                        params->timeout, params->errbuf ))) return STATUS_NO_MEMORY;
 322     return STATUS_SUCCESS;
 323 }
 324
 325 static NTSTATUS wrap_sendpacket( void *args )
 326 {
 327     const struct sendpacket_params *params = args;
 328     return pcap_sendpacket( (pcap_t *)(ULONG_PTR)params->handle, params->buf, params->size );
 329 }
 330
 331 static NTSTATUS wrap_set_buffer_size( void *args )
 332 {
 333     const struct set_buffer_size_params *params = args;
 334     return pcap_set_buffer_size( (pcap_t *)(ULONG_PTR)params->handle, params->size );
 335 }
 336
 337 static NTSTATUS wrap_set_datalink( void *args )
 338 {
 339     const struct set_datalink_params *params = args;
 340     return pcap_set_datalink( (pcap_t *)(ULONG_PTR)params->handle, params->link );
 341 }
 342
 343 static NTSTATUS wrap_set_promisc( void *args )
 344 {
 345     const struct set_promisc_params *params = args;
 346     return pcap_set_promisc( (pcap_t *)(ULONG_PTR)params->handle, params->enable );
 347 }
 348
 349 static NTSTATUS wrap_set_rfmon( void *args )
 350 {
 351     const struct set_rfmon_params *params = args;
 352     return pcap_set_rfmon( (pcap_t *)(ULONG_PTR)params->handle, params->enable );
 353 }
 354
 355 static NTSTATUS wrap_set_snaplen( void *args )
 356 {
 357     const struct set_snaplen_params *params = args;
 358     return pcap_set_snaplen( (pcap_t *)(ULONG_PTR)params->handle, params->len );
 359 }
 360
 361 static NTSTATUS wrap_set_timeout( void *args )
 362 {
 363     const struct set_timeout_params *params = args;
 364     return pcap_set_timeout( (pcap_t *)(ULONG_PTR)params->handle, params->timeout );
 365 }
 366
 367 static NTSTATUS wrap_set_tstamp_precision( void *args )
 368 {
 369     const struct set_tstamp_precision_params *params = args;
 370     return pcap_set_tstamp_precision( (pcap_t *)(ULONG_PTR)params->handle, params->precision );
 371 }
 372
 373 static NTSTATUS wrap_set_tstamp_type( void *args )
 374 {
 375     const struct set_tstamp_type_params *params = args;
 376     return pcap_set_tstamp_type( (pcap_t *)(ULONG_PTR)params->handle, params->type );
 377 }
 378
 379 static NTSTATUS wrap_setfilter( void *args )
 380 {
 381     const struct setfilter_params *params = args;
 382     struct bpf_program program = { params->program_len, params->program_insns };
 383     return pcap_setfilter( (pcap_t *)(ULONG_PTR)params->handle, &program );
 384 }
 385
 386 static NTSTATUS wrap_setnonblock( void *args )
 387 {
 388     const struct setnonblock_params *params = args;
 389     return pcap_setnonblock( (pcap_t *)(ULONG_PTR)params->handle, params->nonblock, params->errbuf );
 390 }
 391
 392 static NTSTATUS wrap_snapshot( void *args )
 393 {
 394     const struct snapshot_params *params = args;
 395     return pcap_snapshot( (pcap_t *)(ULONG_PTR)params->handle );
 396 }
 397
 398 static NTSTATUS wrap_stats( void *args )
 399 {
 400     struct stats_params *params = args;
 401     struct pcap_stat stat;
 402     int ret;
 403
 404     if (!(ret = pcap_stats( (pcap_t *)(ULONG_PTR)params->handle, &stat )))
 405     {
 406         params->stat.ps_recv    = stat.ps_recv;
 407         params->stat.ps_drop    = stat.ps_drop;
 408         params->stat.ps_ifdrop  = stat.ps_ifdrop;
 409         params->stat.ps_capt    = 0;
 410         params->stat.ps_sent    = 0;
 411         params->stat.ps_netdrop = 0;
 412     }
 413     return ret;
 414 }
 415
 416 static NTSTATUS wrap_tstamp_type_name_to_val( void *args )
 417 {
 418     const struct tstamp_type_name_to_val_params *params = args;
 419     return pcap_tstamp_type_name_to_val( params->name );
 420 }
 421
 422 static NTSTATUS wrap_tstamp_type_val_to_description( void *args )
 423 {
 424     const struct tstamp_type_val_to_description_params *params = args;
 425     const char *str = pcap_tstamp_type_val_to_description( params->type );
 426     int len;
 427
 428     if (!str || !params->buf) return STATUS_INVALID_PARAMETER;
 429     if ((len = strlen( str )) >= *params->buflen)
 430     {
 431         *params->buflen = len + 1;
 432         return STATUS_BUFFER_TOO_SMALL;
 433     }
 434     strcpy( params->buf, str );
 435     return STATUS_SUCCESS;
 436 }
 437
 438 static NTSTATUS wrap_tstamp_type_val_to_name( void *args )
 439 {
 440     const struct tstamp_type_val_to_name_params *params = args;
 441     const char *str = pcap_tstamp_type_val_to_name( params->type );
 442     int len;
 443
 444     if (!str || !params->buf) return STATUS_INVALID_PARAMETER;
 445     if ((len = strlen( str )) >= *params->buflen)
 446     {
 447         *params->buflen = len + 1;
 448         return STATUS_BUFFER_TOO_SMALL;
 449     }
 450     strcpy( params->buf, str );
 451     return STATUS_SUCCESS;
 452 }
 453
 454 const unixlib_entry_t __wine_unix_call_funcs[] =
 455 {
 456     wrap_activate,
 457     wrap_breakloop,
 458     wrap_bufsize,
 459     wrap_can_set_rfmon,
 460     wrap_close,
 461     wrap_compile,
 462     wrap_create,
 463     wrap_datalink,
 464     wrap_datalink_name_to_val,
 465     wrap_datalink_val_to_description,
 466     wrap_datalink_val_to_name,
 467     wrap_dump,
 468     wrap_dump_close,
 469     wrap_dump_open,
 470     wrap_findalldevs,
 471     wrap_get_tstamp_precision,
 472     wrap_geterr,
 473     wrap_getnonblock,
 474     wrap_init,
 475     wrap_lib_version,
 476     wrap_list_datalinks,
 477     wrap_list_tstamp_types,
 478     wrap_lookupnet,
 479     wrap_major_version,
 480     wrap_minor_version,
 481     wrap_next_ex,
 482     wrap_open_live,
 483     wrap_sendpacket,
 484     wrap_set_buffer_size,
 485     wrap_set_datalink,
 486     wrap_set_promisc,
 487     wrap_set_rfmon,
 488     wrap_set_snaplen,
 489     wrap_set_timeout,
 490     wrap_set_tstamp_precision,
 491     wrap_set_tstamp_type,
 492     wrap_setfilter,
 493     wrap_setnonblock,
 494     wrap_snapshot,
 495     wrap_stats,
 496     wrap_tstamp_type_name_to_val,
 497     wrap_tstamp_type_val_to_description,
 498     wrap_tstamp_type_val_to_name,
 499 };
 500
 501 C_ASSERT( ARRAYSIZE(__wine_unix_call_funcs) == unix_funcs_count );
 502
 503 #ifdef _WIN64
 504
 505 typedef ULONG PTR32;
 506
 507 static NTSTATUS wow64_compile( void *args )
 508 {
 509     struct
 510     {
 511         UINT64 handle;
 512         PTR32 program_len;
 513         PTR32 program_insns;
 514         PTR32 str;
 515         int optimize;
 516         unsigned int mask;
 517     } const *params32 = args;
 518
 519     struct compile_params params =
 520     {
 521         params32->handle,
 522         ULongToPtr(params32->program_len),
 523         ULongToPtr(params32->program_insns),
 524         ULongToPtr(params32->str),
 525         params32->optimize,
 526         params32->mask
 527     };
 528     return wrap_compile( &params );
 529 }
 530
 531 static NTSTATUS wow64_create( void *args )
 532 {
 533     struct
 534     {
 535         PTR32 source;
 536         PTR32 errbuf;
 537         PTR32 handle;
 538     } const *params32 = args;
 539
 540     struct create_params params =
 541     {
 542         ULongToPtr(params32->source),
 543         ULongToPtr(params32->errbuf),
 544         ULongToPtr(params32->handle),
 545     };
 546     return wrap_create( &params );
 547 }
 548
 549 static NTSTATUS wow64_datalink_name_to_val( void *args )
 550 {
 551     struct
 552     {
 553         PTR32 name;
 554     } const *params32 = args;
 555
 556     struct datalink_name_to_val_params params =
 557     {
 558         ULongToPtr(params32->name),
 559     };
 560     return wrap_datalink_name_to_val( &params );
 561 }
 562
 563 static NTSTATUS wow64_datalink_val_to_description( void *args )
 564 {
 565     struct
 566     {
 567         int link;
 568         PTR32 buf;
 569         PTR32 buflen;
 570     } const *params32 = args;
 571
 572     struct datalink_val_to_description_params params =
 573     {
 574         params32->link,
 575         ULongToPtr(params32->buf),
 576         ULongToPtr(params32->buflen)
 577     };
 578     return wrap_datalink_val_to_description( &params );
 579 }
 580
 581 static NTSTATUS wow64_datalink_val_to_name( void *args )
 582 {
 583     struct
 584     {
 585         int link;
 586         PTR32 buf;
 587         PTR32 buflen;
 588     } const *params32 = args;
 589
 590     struct datalink_val_to_name_params params =
 591     {
 592         params32->link,
 593         ULongToPtr(params32->buf),
 594         ULongToPtr(params32->buflen)
 595     };
 596     return wrap_datalink_val_to_name( &params );
 597 }
 598
 599 static NTSTATUS wow64_dump( void *args )
 600 {
 601     struct
 602     {
 603         PTR32 user;
 604         PTR32 hdr;
 605         PTR32 packet;
 606     } const *params32 = args;
 607
 608     struct dump_params params =
 609     {
 610         ULongToPtr(params32->user),
 611         ULongToPtr(params32->hdr),
 612         ULongToPtr(params32->packet)
 613     };
 614     return wrap_dump( &params );
 615 }
 616
 617 static NTSTATUS wow64_dump_open( void *args )
 618 {
 619     struct
 620     {
 621         UINT64 handle;
 622         PTR32 name;
 623         PTR32 ret_handle;
 624     } const *params32 = args;
 625
 626     struct datalink_val_to_name_params params =
 627     {
 628         params32->handle,
 629         ULongToPtr(params32->name),
 630         ULongToPtr(params32->ret_handle)
 631     };
 632     return wrap_dump_open( &params );
 633 }
 634
 635 static NTSTATUS wow64_findalldevs( void *args )
 636 {
 637     struct
 638     {
 639         PTR32 buf;
 640         PTR32 buflen;
 641         PTR32 errbuf;
 642     } const *params32 = args;
 643
 644     struct findalldevs_params params =
 645     {
 646         ULongToPtr(params32->buf),
 647         ULongToPtr(params32->buflen),
 648         ULongToPtr(params32->errbuf)
 649     };
 650     return wrap_findalldevs( &params );
 651 }
 652
 653 static NTSTATUS wow64_geterr( void *args )
 654 {
 655     struct
 656     {
 657         UINT64 handle;
 658         PTR32 errbuf;
 659     } const *params32 = args;
 660
 661     struct geterr_params params =
 662     {
 663         params32->handle,
 664         ULongToPtr(params32->errbuf)
 665     };
 666     return wrap_geterr( &params );
 667 }
 668
 669 static NTSTATUS wow64_getnonblock( void *args )
 670 {
 671     struct
 672     {
 673         UINT64 handle;
 674         PTR32 errbuf;
 675     } const *params32 = args;
 676
 677     struct getnonblock_params params =
 678     {
 679         params32->handle,
 680         ULongToPtr(params32->errbuf)
 681     };
 682     return wrap_getnonblock( &params );
 683 }
 684
 685 static NTSTATUS wow64_init( void *args )
 686 {
 687     struct
 688     {
 689         int opt;
 690         PTR32 errbuf;
 691     } const *params32 = args;
 692
 693     struct init_params params =
 694     {
 695         params32->opt,
 696         ULongToPtr(params32->errbuf)
 697     };
 698     return wrap_init( &params );
 699 }
 700
 701 static NTSTATUS wow64_lib_version( void *args )
 702 {
 703     struct
 704     {
 705         PTR32 version;
 706         unsigned int size;
 707     } const *params32 = args;
 708
 709     struct lib_version_params params =
 710     {
 711         ULongToPtr(params32->version),
 712         params32->size
 713     };
 714     return wrap_lib_version( &params );
 715 }
 716
 717 static NTSTATUS wow64_list_datalinks( void *args )
 718 {
 719     struct
 720     {
 721         UINT64 handle;
 722         PTR32 links;
 723         PTR32 count;
 724     } const *params32 = args;
 725
 726     struct list_datalinks_params params =
 727     {
 728         params32->handle,
 729         ULongToPtr(params32->links),
 730         ULongToPtr(params32->count)
 731     };
 732     return wrap_list_datalinks( &params );
 733 }
 734
 735 static NTSTATUS wow64_list_tstamp_types( void *args )
 736 {
 737     struct
 738     {
 739         UINT64 handle;
 740         PTR32 types;
 741         PTR32 count;
 742     } const *params32 = args;
 743
 744     struct list_tstamp_types_params params =
 745     {
 746         params32->handle,
 747         ULongToPtr(params32->types),
 748         ULongToPtr(params32->count)
 749     };
 750     return wrap_list_tstamp_types( &params );
 751 }
 752
 753 static NTSTATUS wow64_lookupnet( void *args )
 754 {
 755     struct
 756     {
 757         PTR32 device;
 758         PTR32 net;
 759         PTR32 mask;
 760         PTR32 errbuf;
 761     } const *params32 = args;
 762
 763     struct lookupnet_params params =
 764     {
 765         ULongToPtr(params32->device),
 766         ULongToPtr(params32->net),
 767         ULongToPtr(params32->mask),
 768         ULongToPtr(params32->errbuf)
 769     };
 770     return wrap_lookupnet( &params );
 771 }
 772
 773 static NTSTATUS wow64_next_ex( void *args )
 774 {
 775     struct
 776     {
 777         UINT64 handle;
 778         PTR32 hdr;
 779         PTR32 data;
 780     } const *params32 = args;
 781
 782     struct next_ex_params params =
 783     {
 784         params32->handle,
 785         ULongToPtr(params32->hdr),
 786         ULongToPtr(params32->data)
 787     };
 788     return wrap_next_ex( &params );
 789 }
 790
 791 static NTSTATUS wow64_open_live( void *args )
 792 {
 793     struct
 794     {
 795         PTR32 source;
 796         int snaplen;
 797         int promisc;
 798         int timeout;
 799         PTR32 errbuf;
 800         PTR32 handle;
 801     } const *params32 = args;
 802
 803     struct open_live_params params =
 804     {
 805         ULongToPtr(params32->source),
 806         params32->snaplen,
 807         params32->promisc,
 808         params32->timeout,
 809         ULongToPtr(params32->errbuf),
 810         ULongToPtr(params32->handle)
 811     };
 812     return wrap_open_live( &params );
 813 }
 814
 815 static NTSTATUS wow64_sendpacket( void *args )
 816 {
 817     struct
 818     {
 819         UINT64 handle;
 820         PTR32 buf;
 821         int size;
 822     } const *params32 = args;
 823
 824     struct sendpacket_params params =
 825     {
 826         params32->handle,
 827         ULongToPtr(params32->buf),
 828         params32->size
 829     };
 830     return wrap_sendpacket( &params );
 831 }
 832
 833 static NTSTATUS wow64_setfilter( void *args )
 834 {
 835     struct
 836     {
 837         UINT64 handle;
 838         unsigned int program_len;
 839         PTR32 program_insns;
 840     } const *params32 = args;
 841
 842     struct setfilter_params params =
 843     {
 844         params32->handle,
 845         params32->program_len,
 846         ULongToPtr(params32->program_insns)
 847     };
 848     return wrap_setfilter( &params );
 849 }
 850
 851 static NTSTATUS wow64_setnonblock( void *args )
 852 {
 853     struct
 854     {
 855         UINT64 handle;
 856         int nonblock;
 857         PTR32 errbuf;
 858     } const *params32 = args;
 859
 860     struct setnonblock_params params =
 861     {
 862         params32->handle,
 863         params32->nonblock,
 864         ULongToPtr(params32->errbuf)
 865     };
 866     return wrap_setnonblock( &params );
 867 }
 868
 869 static NTSTATUS wow64_tstamp_type_name_to_val( void *args )
 870 {
 871     struct
 872     {
 873         PTR32 name;
 874     } const *params32 = args;
 875
 876     struct tstamp_type_name_to_val_params params =
 877     {
 878         ULongToPtr(params32->name)
 879     };
 880     return wrap_tstamp_type_name_to_val( &params );
 881 }
 882
 883 static NTSTATUS wow64_tstamp_type_val_to_description( void *args )
 884 {
 885     struct
 886     {
 887         int type;
 888         PTR32 buf;
 889         PTR32 buflen;
 890     } const *params32 = args;
 891
 892     struct tstamp_type_val_to_description_params params =
 893     {
 894         params32->type,
 895         ULongToPtr(params32->buf),
 896         ULongToPtr(params32->buflen)
 897     };
 898     return wrap_tstamp_type_val_to_description( &params );
 899 }
 900
 901 static NTSTATUS wow64_tstamp_type_val_to_name( void *args )
 902 {
 903     struct
 904     {
 905         int type;
 906         PTR32 buf;
 907         PTR32 buflen;
 908     } const *params32 = args;
 909
 910     struct tstamp_type_val_to_name_params params =
 911     {
 912         params32->type,
 913         ULongToPtr(params32->buf),
 914         ULongToPtr(params32->buflen)
 915     };
 916     return wrap_tstamp_type_val_to_name( &params );
 917 }
 918
 919 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
 920 {
 921     wrap_activate,
 922     wrap_breakloop,
 923     wrap_bufsize,
 924     wrap_can_set_rfmon,
 925     wrap_close,
 926     wow64_compile,
 927     wow64_create,
 928     wrap_datalink,
 929     wow64_datalink_name_to_val,
 930     wow64_datalink_val_to_description,
 931     wow64_datalink_val_to_name,
 932     wow64_dump,
 933     wrap_dump_close,
 934     wow64_dump_open,
 935     wow64_findalldevs,
 936     wrap_get_tstamp_precision,
 937     wow64_geterr,
 938     wow64_getnonblock,
 939     wow64_init,
 940     wow64_lib_version,
 941     wow64_list_datalinks,
 942     wow64_list_tstamp_types,
 943     wow64_lookupnet,
 944     wrap_major_version,
 945     wrap_minor_version,
 946     wow64_next_ex,
 947     wow64_open_live,
 948     wow64_sendpacket,
 949     wrap_set_buffer_size,
 950     wrap_set_datalink,
 951     wrap_set_promisc,
 952     wrap_set_rfmon,
 953     wrap_set_snaplen,
 954     wrap_set_timeout,
 955     wrap_set_tstamp_precision,
 956     wrap_set_tstamp_type,
 957     wow64_setfilter,
 958     wow64_setnonblock,
 959     wrap_snapshot,
 960     wrap_stats,
 961     wow64_tstamp_type_name_to_val,
 962     wow64_tstamp_type_val_to_description,
 963     wow64_tstamp_type_val_to_name,
 964 };
 965
 966 C_ASSERT( ARRAYSIZE(__wine_unix_call_wow64_funcs) == unix_funcs_count );
 967
 968 #endif /* _WIN64 */
 969
 970 #endif /* HAVE_PCAP_PCAP_H */