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 "winsock2.h"
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(wpcap);
  28 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  29
  30 void CDECL wine_pcap_breakloop(pcap_t *p)
  31 {
  32     TRACE("(%p)\n", p);
  33     return pcap_breakloop(p);
  34 }
  35
  36 void CDECL wine_pcap_close(pcap_t *p)
  37 {
  38     TRACE("(%p)\n", p);
  39     pcap_close(p);
  40 }
  41
  42 int CDECL wine_pcap_compile(pcap_t *p, struct bpf_program *program, const char *buf, int optimize,
  43                             unsigned int mask)
  44 {
  45     TRACE("(%p %p %s %i %u)\n", p, program, debugstr_a(buf), optimize, mask);
  46     return pcap_compile(p, program, buf, optimize, mask);
  47 }
  48
  49 int CDECL wine_pcap_datalink(pcap_t *p)
  50 {
  51     TRACE("(%p)\n", p);
  52     return pcap_datalink(p);
  53 }
  54
  55 int CDECL wine_pcap_datalink_name_to_val(const char *name)
  56 {
  57     TRACE("(%s)\n", debugstr_a(name));
  58     return pcap_datalink_name_to_val(name);
  59 }
  60
  61 const char* CDECL wine_pcap_datalink_val_to_description(int dlt)
  62 {
  63     TRACE("(%i)\n", dlt);
  64     return pcap_datalink_val_to_description(dlt);
  65 }
  66
  67 const char* CDECL wine_pcap_datalink_val_to_name(int dlt)
  68 {
  69     TRACE("(%i)\n", dlt);
  70     return pcap_datalink_val_to_name(dlt);
  71 }
  72
  73 typedef struct
  74 {
  75     void (CALLBACK *pfn_cb)(u_char *, const struct pcap_pkthdr *, const u_char *);
  76     void *user_data;
  77 } PCAP_HANDLER_CALLBACK;
  78
  79 static void pcap_handler_callback(u_char *user_data, const struct pcap_pkthdr *h, const u_char *p)
  80 {
  81     PCAP_HANDLER_CALLBACK *pcb;
  82     TRACE("(%p %p %p)\n", user_data, h, p);
  83     pcb = (PCAP_HANDLER_CALLBACK *)user_data;
  84     pcb->pfn_cb(pcb->user_data, h, p);
  85     HeapFree(GetProcessHeap(), 0, pcb);
  86     TRACE("Callback COMPLETED\n");
  87 }
  88
  89 int CDECL wine_pcap_dispatch(pcap_t *p, int cnt,
  90                              void (CALLBACK *callback)(u_char *, const struct pcap_pkthdr *, const u_char *),
  91                              unsigned char *user)
  92 {
  93     TRACE("(%p %i %p %p)\n", p, cnt, callback, user);
  94
  95     if (callback)
  96     {
  97         PCAP_HANDLER_CALLBACK *pcb;
  98         pcb = HeapAlloc(GetProcessHeap(), 0, sizeof(PCAP_HANDLER_CALLBACK));
  99         pcb->pfn_cb = callback;
 100         pcb->user_data = user;
 101         return pcap_dispatch(p, cnt, pcap_handler_callback, (unsigned char*)pcb);
 102     }
 103
 104     return pcap_dispatch(p, cnt, NULL, user);
 105 }
 106
 107 int CDECL wine_pcap_findalldevs(pcap_if_t **alldevsp, char *errbuf)
 108 {
 109     int ret;
 110
 111     TRACE("(%p %p)\n", alldevsp, errbuf);
 112     ret = pcap_findalldevs(alldevsp, errbuf);
 113     if(alldevsp && !*alldevsp)
 114         ERR_(winediag)("Failed to access raw network (pcap), this requires special permissions.\n");
 115
 116     return ret;
 117 }
 118
 119 int CDECL wine_pcap_findalldevs_ex(char *source, void *auth, pcap_if_t **alldevs, char *errbuf)
 120 {
 121     FIXME("(%s %p %p %p): partial stub\n", debugstr_a(source), auth, alldevs, errbuf);
 122     return wine_pcap_findalldevs(alldevs, errbuf);
 123 }
 124
 125 void CDECL wine_pcap_freealldevs(pcap_if_t *alldevs)
 126 {
 127     TRACE("(%p)\n", alldevs);
 128     pcap_freealldevs(alldevs);
 129 }
 130
 131 void CDECL wine_pcap_freecode(struct bpf_program *fp)
 132 {
 133     TRACE("(%p)\n", fp);
 134     return pcap_freecode(fp);
 135 }
 136
 137 typedef struct _AirpcapHandle *PAirpcapHandle;
 138 PAirpcapHandle CDECL wine_pcap_get_airpcap_handle(pcap_t *p)
 139 {
 140     TRACE("(%p)\n", p);
 141     return NULL;
 142 }
 143
 144 char* CDECL wine_pcap_geterr(pcap_t *p)
 145 {
 146     TRACE("(%p)\n", p);
 147     return pcap_geterr(p);
 148 }
 149
 150 int CDECL wine_pcap_getnonblock(pcap_t *p, char *errbuf)
 151 {
 152     TRACE("(%p %p)\n", p, errbuf);
 153     return pcap_getnonblock(p, errbuf);
 154 }
 155
 156 const char* CDECL wine_pcap_lib_version(void)
 157 {
 158     const char* ret = pcap_lib_version();
 159     TRACE("%s\n", debugstr_a(ret));
 160     return ret;
 161 }
 162
 163 int CDECL wine_pcap_list_datalinks(pcap_t *p, int **dlt_buffer)
 164 {
 165     TRACE("(%p %p)\n", p, dlt_buffer);
 166     return pcap_list_datalinks(p, dlt_buffer);
 167 }
 168
 169 char* CDECL wine_pcap_lookupdev(char *errbuf)
 170 {
 171     TRACE("(%p)\n", errbuf);
 172     return pcap_lookupdev(errbuf);
 173 }
 174
 175 int CDECL wine_pcap_lookupnet(const char *device, unsigned int *netp, unsigned int *maskp,
 176                               char *errbuf)
 177 {
 178     TRACE("(%s %p %p %p)\n", debugstr_a(device), netp, maskp, errbuf);
 179     return pcap_lookupnet(device, netp, maskp, errbuf);
 180 }
 181
 182 int CDECL wine_pcap_loop(pcap_t *p, int cnt,
 183                          void (CALLBACK *callback)(u_char *, const struct pcap_pkthdr *, const u_char *),
 184                          unsigned char *user)
 185 {
 186     TRACE("(%p %i %p %p)\n", p, cnt, callback, user);
 187
 188     if (callback)
 189     {
 190         PCAP_HANDLER_CALLBACK *pcb;
 191         pcb = HeapAlloc(GetProcessHeap(), 0, sizeof(PCAP_HANDLER_CALLBACK));
 192         pcb->pfn_cb = callback;
 193         pcb->user_data = user;
 194         return pcap_loop(p, cnt, pcap_handler_callback, (unsigned char*)pcb);
 195     }
 196
 197     return pcap_loop(p, cnt, NULL, user);
 198 }
 199
 200 int CDECL wine_pcap_major_version(pcap_t *p)
 201 {
 202     TRACE("(%p)\n", p);
 203     return pcap_major_version(p);
 204 }
 205
 206 int CDECL wine_pcap_minor_version(pcap_t *p)
 207 {
 208     TRACE("(%p)\n", p);
 209     return pcap_minor_version(p);
 210 }
 211
 212 const unsigned char* CDECL wine_pcap_next(pcap_t *p, struct pcap_pkthdr *h)
 213 {
 214     TRACE("(%p %p)\n", p, h);
 215     return pcap_next(p, h);
 216 }
 217
 218 int CDECL wine_pcap_next_ex(pcap_t *p, struct pcap_pkthdr **pkt_header, const unsigned char **pkt_data)
 219 {
 220     TRACE("(%p %p %p)\n", p, pkt_header, pkt_data);
 221     return pcap_next_ex(p, pkt_header, pkt_data);
 222 }
 223
 224 #define PCAP_OPENFLAG_PROMISCUOUS 1
 225
 226 pcap_t* CDECL wine_pcap_open(const char *source, int snaplen, int flags, int read_timeout,
 227                              void *auth, char *errbuf)
 228 {
 229     int promisc = flags & PCAP_OPENFLAG_PROMISCUOUS;
 230     FIXME("(%s %i %i %i %p %p): partial stub\n", debugstr_a(source), snaplen, flags, read_timeout,
 231                                                  auth, errbuf);
 232     return pcap_open_live(source, snaplen, promisc, read_timeout, errbuf);
 233 }
 234
 235 pcap_t* CDECL wine_pcap_open_live(const char *source, int snaplen, int promisc, int to_ms,
 236                                   char *errbuf)
 237 {
 238     TRACE("(%s %i %i %i %p)\n", debugstr_a(source), snaplen, promisc, to_ms, errbuf);
 239     return pcap_open_live(source, snaplen, promisc, to_ms, errbuf);
 240 }
 241
 242 int CDECL wine_pcap_sendpacket(pcap_t *p, const unsigned char *buf, int size)
 243 {
 244     TRACE("(%p %p %i)\n", p, buf, size);
 245     return pcap_sendpacket(p, buf, size);
 246 }
 247
 248 int CDECL wine_pcap_set_datalink(pcap_t *p, int dlt)
 249 {
 250     TRACE("(%p %i)\n", p, dlt);
 251     return pcap_set_datalink(p, dlt);
 252 }
 253
 254 int CDECL wine_pcap_setbuff(pcap_t * p, int dim)
 255 {
 256     FIXME("(%p %i) stub\n", p, dim);
 257     return 0;
 258 }
 259
 260 int CDECL wine_pcap_setfilter(pcap_t *p, struct bpf_program *fp)
 261 {
 262     TRACE("(%p %p)\n", p, fp);
 263     return pcap_setfilter(p, fp);
 264 }
 265
 266 int CDECL wine_pcap_setnonblock(pcap_t *p, int nonblock, char *errbuf)
 267 {
 268     TRACE("(%p %i %p)\n", p, nonblock, errbuf);
 269     return pcap_setnonblock(p, nonblock, errbuf);
 270 }
 271
 272 int CDECL wine_pcap_snapshot(pcap_t *p)
 273 {
 274     TRACE("(%p)\n", p);
 275     return pcap_snapshot(p);
 276 }
 277
 278 int CDECL wine_pcap_stats(pcap_t *p, struct pcap_stat *ps)
 279 {
 280     TRACE("(%p %p)\n", p, ps);
 281     return pcap_stats(p, ps);
 282 }
 283
 284 int CDECL wine_wsockinit(void)
 285 {
 286     WSADATA wsadata;
 287     TRACE("()\n");
 288     if (WSAStartup(MAKEWORD(1,1), &wsadata)) return -1;
 289     return 0;
 290 }