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