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 <pcap/pcap.h>
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(wpcap);
  27 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  28
  29 void CDECL wine_pcap_breakloop(pcap_t *p)
  30 {
  31     TRACE("(%p)\n", p);
  32     return pcap_breakloop(p);
  33 }
  34
  35 void CDECL wine_pcap_close(pcap_t *p)
  36 {
  37     TRACE("(%p)\n", p);
  38     pcap_close(p);
  39 }
  40
  41 int CDECL wine_pcap_compile(pcap_t *p, struct bpf_program *program, const char *buf, int optimize,
  42                             unsigned int mask)
  43 {
  44     TRACE("(%p %p %s %i %u)\n", p, program, debugstr_a(buf), optimize, mask);
  45     return pcap_compile(p, program, buf, optimize, mask);
  46 }
  47
  48 int CDECL wine_pcap_datalink(pcap_t *p)
  49 {
  50     TRACE("(%p)\n", p);
  51     return pcap_datalink(p);
  52 }
  53
  54 const char* CDECL wine_pcap_datalink_val_to_name(int dlt)
  55 {
  56     TRACE("(%i)\n", dlt);
  57     return pcap_datalink_val_to_name(dlt);
  58 }
  59
  60 typedef struct
  61 {
  62     void (CALLBACK *pfn_cb)(u_char *, const struct pcap_pkthdr *, const u_char *);
  63     void *user_data;
  64 } PCAP_HANDLER_CALLBACK;
  65
  66 static void pcap_handler_callback(u_char *user_data, const struct pcap_pkthdr *h, const u_char *p)
  67 {
  68     PCAP_HANDLER_CALLBACK *pcb;
  69     TRACE("(%p %p %p)\n", user_data, h, p);
  70     pcb = (PCAP_HANDLER_CALLBACK *)user_data;
  71     pcb->pfn_cb(pcb->user_data, h, p);
  72     HeapFree(GetProcessHeap(), 0, pcb);
  73     TRACE("Callback COMPLETED\n");
  74 }
  75
  76 int CDECL wine_pcap_dispatch(pcap_t *p, int cnt,
  77                              void (CALLBACK *callback)(u_char *, const struct pcap_pkthdr *, const u_char *),
  78                              unsigned char *user)
  79 {
  80     TRACE("(%p %i %p %p)\n", p, cnt, callback, user);
  81
  82     if (callback)
  83     {
  84         PCAP_HANDLER_CALLBACK *pcb;
  85         pcb = HeapAlloc(GetProcessHeap(), 0, sizeof(PCAP_HANDLER_CALLBACK));
  86         pcb->pfn_cb = callback;
  87         pcb->user_data = user;
  88         return pcap_dispatch(p, cnt, pcap_handler_callback, (unsigned char*)pcb);
  89     }
  90
  91     return pcap_dispatch(p, cnt, NULL, user);
  92 }
  93
  94 int CDECL wine_pcap_findalldevs(pcap_if_t **alldevsp, char *errbuf)
  95 {
  96     int ret;
  97
  98     TRACE("(%p %p)\n", alldevsp, errbuf);
  99     ret = pcap_findalldevs(alldevsp, errbuf);
 100     if(alldevsp && !*alldevsp)
 101         ERR_(winediag)("Failed to access raw network (pcap), this requires special permissions.\n");
 102
 103     return ret;
 104 }
 105
 106 void CDECL wine_pcap_freealldevs(pcap_if_t *alldevs)
 107 {
 108     TRACE("(%p)\n", alldevs);
 109     pcap_freealldevs(alldevs);
 110 }
 111
 112 void CDECL wine_pcap_freecode(struct bpf_program *fp)
 113 {
 114     TRACE("(%p)\n", fp);
 115     return pcap_freecode(fp);
 116 }
 117
 118 char* CDECL wine_pcap_geterr(pcap_t *p)
 119 {
 120     TRACE("(%p)\n", p);
 121     return pcap_geterr(p);
 122 }
 123
 124 const char* CDECL wine_pcap_lib_version(void)
 125 {
 126     const char* ret = pcap_lib_version();
 127     TRACE("%s\n", debugstr_a(ret));
 128     return ret;
 129 }
 130
 131 char* CDECL wine_pcap_lookupdev(char *errbuf)
 132 {
 133     TRACE("(%p)\n", errbuf);
 134     return pcap_lookupdev(errbuf);
 135 }
 136
 137 int CDECL wine_pcap_lookupnet(const char *device, unsigned int *netp, unsigned int *maskp,
 138                               char *errbuf)
 139 {
 140     TRACE("(%s %p %p %p)\n", debugstr_a(device), netp, maskp, errbuf);
 141     return pcap_lookupnet(device, netp, maskp, errbuf);
 142 }
 143
 144 int CDECL wine_pcap_loop(pcap_t *p, int cnt,
 145                          void (CALLBACK *callback)(u_char *, const struct pcap_pkthdr *, const u_char *),
 146                          unsigned char *user)
 147 {
 148     TRACE("(%p %i %p %p)\n", p, cnt, callback, user);
 149
 150     if (callback)
 151     {
 152         PCAP_HANDLER_CALLBACK *pcb;
 153         pcb = HeapAlloc(GetProcessHeap(), 0, sizeof(PCAP_HANDLER_CALLBACK));
 154         pcb->pfn_cb = callback;
 155         pcb->user_data = user;
 156         return pcap_loop(p, cnt, pcap_handler_callback, (unsigned char*)pcb);
 157     }
 158
 159     return pcap_loop(p, cnt, NULL, user);
 160 }
 161
 162 int CDECL wine_pcap_major_version(pcap_t *p)
 163 {
 164     TRACE("(%p)\n", p);
 165     return pcap_major_version(p);
 166 }
 167
 168 int CDECL wine_pcap_minor_version(pcap_t *p)
 169 {
 170     TRACE("(%p)\n", p);
 171     return pcap_minor_version(p);
 172 }
 173
 174 pcap_t* CDECL wine_pcap_open_live(const char *source, int snaplen, int promisc, int to_ms,
 175                                   char *errbuf)
 176 {
 177     TRACE("(%s %i %i %i %p)\n", debugstr_a(source), snaplen, promisc, to_ms, errbuf);
 178     return pcap_open_live(source, snaplen, promisc, to_ms, errbuf);
 179 }
 180
 181 int CDECL wine_pcap_setbuff(pcap_t * p, int dim)
 182 {
 183     FIXME("(%p %i) stub\n", p, dim);
 184     return 0;
 185 }
 186
 187 int CDECL wine_pcap_setfilter(pcap_t *p, struct bpf_program *fp)
 188 {
 189     TRACE("(%p %p)\n", p, fp);
 190     return pcap_setfilter(p, fp);
 191 }
 192
 193 int CDECL wine_pcap_snapshot(pcap_t *p)
 194 {
 195     TRACE("(%p)\n", p);
 196     return pcap_snapshot(p);
 197 }
 198
 199 int CDECL wine_pcap_stats(pcap_t *p, struct pcap_stat *ps)
 200 {
 201     TRACE("(%p %p)\n", p, ps);
 202     return pcap_stats(p, ps);
 203 }