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