VirtualBox

source: vbox/trunk/src/VBox/Devices/Network/slirp/slirp_state.h@ 39085

Last change on this file since 39085 was 38968, checked in by vboxsync, 13 years ago

NAT: replacement of in-place icmp depth calculation with reference counting.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 28.3 KB
Line 
1/** @file
2 * NAT - slirp state/configuration.
3 */
4
5/*
6 * Copyright (C) 2006-2010 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 */
16
17#ifndef ___slirp_state_h
18#define ___slirp_state_h
19
20#include <iprt/req.h>
21#include <iprt/critsect.h>
22
23#define COUNTERS_INIT
24#include "counters.h"
25
26#include "ip_icmp.h"
27#include "dnsproxy/dnsproxy.h"
28
29
30/** Where to start DHCP IP number allocation. */
31#define START_ADDR 15
32
33/** DHCP Lease time. */
34#define LEASE_TIME (24 * 3600)
35
36/*
37 * ARP cache this is naive implementaion of ARP
38 * cache of mapping 4 byte IPv4 address to 6 byte
39 * ethernet one.
40 */
41struct arp_cache_entry
42{
43 uint32_t ip;
44 uint8_t ether[6];
45 LIST_ENTRY(arp_cache_entry) list;
46};
47LIST_HEAD(arp_cache_head, arp_cache_entry);
48
49/** TFTP session entry. */
50struct tftp_session
51{
52 int in_use;
53 unsigned char filename[TFTP_FILENAME_MAX];
54
55 struct in_addr client_ip;
56 u_int16_t client_port;
57
58 int timestamp;
59};
60
61struct dns_domain_entry
62{
63 char *dd_pszDomain;
64 LIST_ENTRY(dns_domain_entry) dd_list;
65};
66LIST_HEAD(dns_domain_list_head, dns_domain_entry);
67
68struct dns_entry
69{
70 struct in_addr de_addr;
71 TAILQ_ENTRY(dns_entry) de_list;
72};
73TAILQ_HEAD(dns_list_head, dns_entry);
74TAILQ_HEAD(if_queue, mbuf);
75
76struct port_forward_rule
77{
78 uint16_t proto;
79 uint16_t host_port;
80 uint16_t guest_port;
81 struct in_addr guest_addr;
82 struct in_addr bind_ip;
83 uint8_t mac_address[6]; /*need ETH_ALEN here */
84 int activated;
85 struct socket *so;
86 LIST_ENTRY(port_forward_rule) list;
87};
88LIST_HEAD(port_forward_rule_list, port_forward_rule);
89
90
91
92/* forward declaration */
93struct proto_handler;
94
95/** Main state/configuration structure for slirp NAT. */
96typedef struct NATState
97{
98#define PROFILE_COUNTER(name, dsc) STAMPROFILE Stat ## name
99#define COUNTING_COUNTER(name, dsc) STAMCOUNTER Stat ## name
100#include "counters.h"
101 /* Stuff from boot.c */
102 void *pbootp_clients;
103 const char *bootp_filename;
104 /* Stuff from if.c */
105 int if_mtu, if_mru;
106 int if_comp;
107 int if_maxlinkhdr;
108 int if_queued;
109 int if_thresh;
110 /* Stuff from icmp.c */
111 struct icmpstat_t icmpstat;
112 /* Stuff from ip_input.c */
113 struct ipstat_t ipstat;
114 struct ipqhead ipq[IPREASS_NHASH];
115 int maxnipq; /* Administrative limit on # of reass queues*/
116 int maxfragsperpacket; /* Maximum number of IPv4 fragments allowed per packet */
117 int nipq; /* total number of reass queues */
118 uint16_t ip_currid;
119 /* Stuff from mbuf.c */
120 /* Stuff from slirp.c */
121 void *pvUser;
122 uint32_t curtime;
123 uint32_t time_fasttimo;
124 uint32_t last_slowtimo;
125 bool do_slowtimo;
126 bool link_up;
127 struct timeval tt;
128 struct in_addr our_addr;
129 struct in_addr alias_addr;
130 struct in_addr special_addr;
131
132 int tcp_rcvspace;
133 int tcp_sndspace;
134 int socket_rcv;
135 int socket_snd;
136 int soMaxConn;
137#ifdef VBOX_WITH_SLIRP_MT
138 PRTREQQUEUE pReqQueue;
139#endif
140#ifdef RT_OS_WINDOWS
141 ULONG (WINAPI * pfGetAdaptersAddresses)(ULONG, ULONG, PVOID, PIP_ADAPTER_ADDRESSES, PULONG);
142#endif
143 struct dns_list_head pDnsList;
144 struct dns_domain_list_head pDomainList;
145 struct in_addr tftp_server;
146 struct in_addr loopback_addr;
147 uint32_t dnsLastUpdate;
148 uint32_t netmask;
149#ifndef VBOX_WITH_NAT_SERVICE
150 uint8_t client_ethaddr[6];
151#endif
152 const uint8_t *slirp_ethaddr;
153 char slirp_hostname[33];
154 bool fPassDomain;
155 struct in_addr bindIP;
156 /* Stuff from tcp_input.c */
157 struct socket tcb;
158#ifdef VBOX_WITH_SLIRP_MT
159 RTCRITSECT tcb_mutex;
160#endif
161 struct socket *tcp_last_so;
162 tcp_seq tcp_iss;
163 /* Stuff from tcp_timer.c */
164 struct tcpstat_t tcpstat;
165 uint32_t tcp_now;
166 int tcp_reass_qsize;
167 int tcp_reass_maxqlen;
168 int tcp_reass_maxseg;
169 int tcp_reass_overflows;
170 /* Stuff from tftp.c */
171 struct tftp_session tftp_sessions[TFTP_SESSIONS_MAX];
172 const char *tftp_prefix;
173 /* Stuff from udp.c */
174 struct udpstat_t udpstat;
175 struct socket udb;
176#ifdef VBOX_WITH_SLIRP_MT
177 RTCRITSECT udb_mutex;
178#endif
179 struct socket *udp_last_so;
180 struct socket icmp_socket;
181 struct icmp_storage icmp_msg_head;
182# ifndef RT_OS_WINDOWS
183 /* counter of sockets needed for allocation enough room to
184 * process sockets with poll/epoll
185 *
186 * NSOCK_INC/DEC should be injected before every
187 * operation on socket queue (tcb, udb)
188 */
189 int nsock;
190# define NSOCK_INC() do {pData->nsock++;} while (0)
191# define NSOCK_DEC() do {pData->nsock--;} while (0)
192# define NSOCK_INC_EX(ex) do {ex->pData->nsock++;} while (0)
193# define NSOCK_DEC_EX(ex) do {ex->pData->nsock--;} while (0)
194# else
195# define NSOCK_INC() do {} while (0)
196# define NSOCK_DEC() do {} while (0)
197# define NSOCK_INC_EX(ex) do {} while (0)
198# define NSOCK_DEC_EX(ex) do {} while (0)
199# endif
200 int cIcmpCacheSize;
201 int iIcmpCacheLimit;
202# ifdef RT_OS_WINDOWS
203 void *pvIcmpBuffer;
204 size_t szIcmpBuffer;
205 /* Accordin MSDN specification IcmpParseReplies
206 * function should be detected in runtime
207 */
208 long (WINAPI * pfIcmpParseReplies)(void *, long);
209 BOOL (WINAPI * pfIcmpCloseHandle)(HANDLE);
210 HMODULE hmIcmpLibrary;
211# endif
212#if defined(RT_OS_WINDOWS)
213# define VBOX_SOCKET_EVENT (pData->phEvents[VBOX_SOCKET_EVENT_INDEX])
214 HANDLE phEvents[VBOX_EVENT_COUNT];
215#endif
216#ifdef zone_mbuf
217# undef zone_mbuf
218#endif
219 uma_zone_t zone_mbuf;
220#ifdef zone_clust
221# undef zone_clust
222#endif
223 uma_zone_t zone_clust;
224#ifdef zone_pack
225# undef zone_pack
226#endif
227 uma_zone_t zone_pack;
228#ifdef zone_jumbop
229# undef zone_jumbop
230#endif
231 uma_zone_t zone_jumbop;
232#ifdef zone_jumbo9
233# undef zone_jumbo9
234#endif
235 uma_zone_t zone_jumbo9;
236#ifdef zone_jumbo16
237# undef zone_jumbo16
238#endif
239 uma_zone_t zone_jumbo16;
240#ifdef zone_ext_refcnt
241# undef zone_ext_refcnt
242 int nmbclusters; /* limits number of mbuf clusters */
243 int nmbjumbop; /* limits number of page size jumbo clusters */
244 int nmbjumbo9; /* limits number of 9k jumbo clusters */
245 int nmbjumbo16; /* limits number of 16k jumbo clusters */
246 struct mbstat mbstat;
247#endif
248 uma_zone_t zone_ext_refcnt;
249 bool fUseHostResolver;
250 /* from dnsproxy/dnsproxy.h*/
251 unsigned int authoritative_port;
252 unsigned int authoritative_timeout;
253 unsigned int recursive_port;
254 unsigned int recursive_timeout;
255 unsigned int stats_timeout;
256 unsigned int port;
257
258 unsigned long active_queries;
259 unsigned long all_queries;
260 unsigned long authoritative_queries;
261 unsigned long recursive_queries;
262 unsigned long removed_queries;
263 unsigned long dropped_queries;
264 unsigned long answered_queries;
265 unsigned long dropped_answers;
266 unsigned long late_answers;
267 unsigned long hash_collisions;
268 /*dnsproxy/dnsproxy.c*/
269 unsigned short queryid;
270 struct sockaddr_in authoritative_addr;
271 struct sockaddr_in recursive_addr;
272 int sock_query;
273 int sock_answer;
274 /* dnsproxy/hash.c */
275#define HASHSIZE 10
276#define HASH(id) (id & ((1 << HASHSIZE) - 1))
277 struct request *request_hash[1 << HASHSIZE];
278 /* this field control behaviour of DHCP server */
279 bool fUseDnsProxy;
280
281 LIST_HEAD(RT_NOTHING, libalias) instancehead;
282 int i32AliasMode;
283 struct libalias *proxy_alias;
284 struct libalias *dns_alias;
285 LIST_HEAD(handler_chain, proto_handler) handler_chain;
286 struct port_forward_rule_list port_forward_rule_head;
287 int cRedirectionsActive;
288 int cRedirectionsStored;
289 struct arp_cache_head arp_cache;
290 /*libalis modules' handlers*/
291 struct proto_handler *ftp_module;
292 struct proto_handler *nbt_module;
293 struct proto_handler *dns_module;
294
295} NATState;
296
297
298/** Default IP time to live. */
299#define ip_defttl IPDEFTTL
300
301/** Number of permanent buffers in mbuf. */
302#define mbuf_thresh 30
303
304/** Use a fixed time before sending keepalive. */
305#define tcp_keepidle TCPTV_KEEP_IDLE
306
307/** Use a fixed interval between keepalive. */
308#define tcp_keepintvl TCPTV_KEEPINTVL
309
310/** Maximum idle time before timing out a connection. */
311#define tcp_maxidle (TCPTV_KEEPCNT * tcp_keepintvl)
312
313/** Default TCP socket options. */
314#define so_options DO_KEEPALIVE
315
316/** Default TCP MSS value. */
317#define tcp_mssdflt TCP_MSS
318
319/** Default TCP round trip time. */
320#define tcp_rttdflt (TCPTV_SRTTDFLT / PR_SLOWHZ)
321
322/** Enable RFC1323 performance enhancements.
323 * @todo check if it really works, it was turned off before. */
324#define tcp_do_rfc1323 1
325
326/** TCP receive buffer size. */
327#define tcp_rcvspace pData->tcp_rcvspace
328
329/** TCP receive buffer size. */
330#define tcp_sndspace pData->tcp_sndspace
331
332/* TCP duplicate ACK retransmit threshold. */
333#define tcprexmtthresh 3
334
335
336#define bootp_filename pData->bootp_filename
337
338#define if_mtu pData->if_mtu
339#define if_mru pData->if_mru
340#define if_comp pData->if_comp
341#define if_maxlinkhdr pData->if_maxlinkhdr
342#define if_queued pData->if_queued
343#define if_thresh pData->if_thresh
344
345#define icmpstat pData->icmpstat
346
347#define ipstat pData->ipstat
348#define ipq pData->ipq
349#define ip_currid pData->ip_currid
350
351#define mbuf_alloced pData->mbuf_alloced
352#define mbuf_max pData->mbuf_max
353#define msize pData->msize
354#define m_freelist pData->m_freelist
355#define m_usedlist pData->m_usedlist
356
357#define curtime pData->curtime
358#define time_fasttimo pData->time_fasttimo
359#define last_slowtimo pData->last_slowtimo
360#define do_slowtimo pData->do_slowtimo
361#define link_up pData->link_up
362#define cUsers pData->cUsers
363#define tt pData->tt
364#define our_addr pData->our_addr
365#ifndef VBOX_SLIRP_ALIAS
366# define alias_addr pData->alias_addr
367#else
368# define handler_chain pData->handler_chain
369#endif
370#define dns_addr pData->dns_addr
371#define loopback_addr pData->loopback_addr
372#define client_ethaddr pData->client_ethaddr
373#define slirp_hostname pData->slirp_hostname
374
375#define tcb pData->tcb
376#define tcp_last_so pData->tcp_last_so
377#define tcp_iss pData->tcp_iss
378
379#define tcpstat pData->tcpstat
380#define tcp_now pData->tcp_now
381
382#define tftp_sessions pData->tftp_sessions
383#define tftp_prefix pData->tftp_prefix
384
385#define udpstat pData->udpstat
386#define udb pData->udb
387#define udp_last_so pData->udp_last_so
388
389#define maxfragsperpacket pData->maxfragsperpacket
390#define maxnipq pData->maxnipq
391#define nipq pData->nipq
392
393#define tcp_reass_qsize pData->tcp_reass_qsize
394#define tcp_reass_maxqlen pData->tcp_reass_maxqlen
395#define tcp_reass_maxseg pData->tcp_reass_maxseg
396#define tcp_reass_overflows pData->tcp_reass_overflows
397
398#define queue_tcp_label tcb
399#define queue_udp_label udb
400#define VBOX_X2(x) x
401#define VBOX_X(x) VBOX_X2(x)
402
403#ifdef VBOX_WITH_SLIRP_MT
404
405# define QSOCKET_LOCK(queue) \
406 do { \
407 int rc; \
408 /* Assert(strcmp(RTThreadSelfName(), "EMT") != 0); */ \
409 rc = RTCritSectEnter(&VBOX_X(queue) ## _mutex); \
410 AssertRC(rc); \
411 } while (0)
412# define QSOCKET_UNLOCK(queue) \
413 do { \
414 int rc; \
415 rc = RTCritSectLeave(&VBOX_X(queue) ## _mutex); \
416 AssertRC(rc); \
417 } while (0)
418# define QSOCKET_LOCK_CREATE(queue) \
419 do { \
420 int rc; \
421 rc = RTCritSectInit(&pData->queue ## _mutex); \
422 AssertRC(rc); \
423 } while (0)
424# define QSOCKET_LOCK_DESTROY(queue) \
425 do { \
426 int rc = RTCritSectDelete(&pData->queue ## _mutex); \
427 AssertRC(rc); \
428 } while (0)
429
430# define QSOCKET_FOREACH(so, sonext, label) \
431 QSOCKET_LOCK(VBOX_X2(queue_## label ## _label)); \
432 (so) = (VBOX_X(queue_ ## label ## _label)).so_next; \
433 QSOCKET_UNLOCK(VBOX_X2(queue_## label ##_label)); \
434 if ((so) != &(VBOX_X(queue_## label ## _label))) SOCKET_LOCK((so));\
435 for (;;) \
436 { \
437 if ((so) == &(VBOX_X(queue_## label ## _label))) \
438 { \
439 break; \
440 } \
441 Log2(("%s:%d Processing so:%R[natsock]\n", __FUNCTION__, __LINE__, (so)));
442
443# define CONTINUE_NO_UNLOCK(label) goto loop_end_ ## label ## _mt_nounlock
444# define CONTINUE(label) goto loop_end_ ## label ## _mt
445/* @todo replace queue parameter with macrodinition */
446/* _mt_nounlock - user should lock so_next before calling CONTINUE_NO_UNLOCK */
447# define LOOP_LABEL(label, so, sonext) loop_end_ ## label ## _mt: \
448 (sonext) = (so)->so_next; \
449 SOCKET_UNLOCK(so); \
450 QSOCKET_LOCK(VBOX_X(queue_ ## label ## _label)); \
451 if ((sonext) != &(VBOX_X(queue_## label ## _label))) \
452 { \
453 SOCKET_LOCK((sonext)); \
454 QSOCKET_UNLOCK(VBOX_X(queue_ ## label ## _label)); \
455 } \
456 else \
457 { \
458 so = &VBOX_X(queue_ ## label ## _label); \
459 QSOCKET_UNLOCK(VBOX_X(queue_ ## label ## _label)); \
460 break; \
461 } \
462 (so) = (sonext); \
463 continue; \
464 loop_end_ ## label ## _mt_nounlock: \
465 (so) = (sonext)
466
467# define DO_TCP_OUTPUT(data, sotcb) \
468 do { \
469 PRTREQ pReq; \
470 int rc; \
471 rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /*cMillies*/, \
472 (PFNRT)tcp_output 2, data, sotcb); \
473 if (RT_LIKELY(rc == VERR_TIMEOUT)) \
474 { \
475 SOCKET_UNLOCK(so); \
476 rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
477 AssertReleaseRC(rc); \
478 SOCKET_LOCK(so); \
479 RTReqFree(pReq); \
480 } \
481 else \
482 AssertReleaseRC(rc); \
483} while(0)
484
485# define DO_TCP_INPUT(data, mbuf, size, so) \
486 do { \
487 int rc; \
488 rc = RTReqCallEx((data)->pReqQueue, NULL, 0 /*cMillies*/, \
489 RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT, \
490 (PFNRT)tcp_input, 4, data, mbuf, size, so); \
491 AssertReleaseRC(rc); \
492 } while(0)
493
494# define DO_TCP_CONNECT(data, so) \
495 do { \
496 PRTREQ pReq; \
497 int rc; \
498 rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /*cMillies*/, \
499 (PFNRT)tcp_connect, 2, data, so); \
500 if (RT_LIKELY(rc == VERR_TIMEOUT)) \
501 { \
502 SOCKET_UNLOCK(so); \
503 rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
504 AssertReleaseRC(rc); \
505 SOCKET_LOCK(so); \
506 RTReqFree(pReq); \
507 } \
508 else \
509 AssertReleaseRC(rc); \
510 } while(0)
511
512# define DO_SOREAD(ret, data, so, ifclose) \
513 do { \
514 PRTREQ pReq; \
515 int rc; \
516 rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /*cMillies*/, \
517 (PFNRT)soread_queue, 4, \
518 data, so, ifclose, &(ret)); \
519 if (RT_LIKELY(rc == VERR_TIMEOUT)) \
520 { \
521 SOCKET_UNLOCK(so); \
522 rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
523 AssertReleaseRC(rc); \
524 SOCKET_LOCK(so); \
525 RTReqFree(pReq); \
526 } \
527 else \
528 AssertReleaseRC(rc); \
529 } while(0)
530
531# define DO_SOWRITE(ret, data, so) \
532 do { \
533 PRTREQ pReq; \
534 int rc; \
535 rc = RTReqCall((data)->pReqQueue, &pReq, 0 /*cMillies*/, \
536 (PFNRT)sowrite, 2, data, so); \
537 if (RT_LIKELY(rc == VERR_TIMEOUT)) \
538 { \
539 SOCKET_UNLOCK(so); \
540 rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
541 SOCKET_LOCK(so); \
542 ret = pReq->iStatus; \
543 RTReqFree(pReq); \
544 } \
545 else \
546 AssertReleaseRC(rc); \
547 } while(0)
548
549# define DO_SORECFROM(data, so) \
550 do { \
551 PRTREQ pReq; \
552 int rc; \
553 rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /*cMillies */, \
554 (PFNRT)sorecvfrom, 2, data, so); \
555 if (RT_LIKELY(rc == VERR_TIMEOUT)) \
556 { \
557 SOCKET_UNLOCK(so); \
558 rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
559 AssertReleaseRC(rc); \
560 SOCKET_LOCK(so); \
561 RTReqFree(pReq); \
562 } \
563 else \
564 AssertReleaseRC(rc); \
565 } while(0)
566
567# define DO_UDP_DETACH(data, so, so_next) \
568 do { \
569 PRTREQ pReq; \
570 int rc; \
571 rc = RTReqCallVoid((data)->pReqQueue, &pReq, 0 /* cMillies*/, \
572 (PFNRT)udp_detach, 2, data, so); \
573 if (RT_LIKELY(rc == VERR_TIMEOUT)) \
574 { \
575 SOCKET_UNLOCK(so); \
576 rc = RTReqWait(pReq, RT_INDEFINITE_WAIT); \
577 AssertReleaseRC(rc); \
578 if ((so_next) != &udb) SOCKET_LOCK((so_next)); \
579 RTReqFree(pReq); \
580 } \
581 else \
582 AssertReleaseRC(rc); \
583 } while(0)
584
585# define SOLOOKUP(so, label, src, sport, dst, dport) \
586 do { \
587 struct socket *sonxt; \
588 (so) = NULL; \
589 QSOCKET_FOREACH(so, sonxt, label) \
590 /* { */ \
591 if ( so->so_lport == (sport) \
592 && so->so_laddr.s_addr == (src).s_addr \
593 && so->so_faddr.s_addr == (dst).s_addr \
594 && so->so_fport == (dport)) \
595 { \
596 if (sonxt != &VBOX_X2(queue_ ## label ## _label)) \
597 SOCKET_UNLOCK(sonxt); \
598 break; /*so is locked*/ \
599 } \
600 LOOP_LABEL(so, sonxt, label); \
601 } \
602 } \
603 } while (0)
604
605#else /* !VBOX_WITH_SLIRP_MT */
606
607# define QSOCKET_LOCK(queue) do {} while (0)
608# define QSOCKET_UNLOCK(queue) do {} while (0)
609# define QSOCKET_LOCK_CREATE(queue) do {} while (0)
610# define QSOCKET_LOCK_DESTROY(queue) do {} while (0)
611# define QSOCKET_FOREACH(so, sonext, label) \
612 for ((so) = VBOX_X2(queue_ ## label ## _label).so_next; \
613 (so) != &(VBOX_X2(queue_ ## label ## _label)); \
614 (so) = (sonext)) \
615 { \
616 (sonext) = (so)->so_next; \
617 Log2(("%s:%d Processing so:%R[natsock]\n", __FUNCTION__, __LINE__, (so)));
618# define CONTINUE(label) continue
619# define CONTINUE_NO_UNLOCK(label) continue
620# define LOOP_LABEL(label, so, sonext) /* empty*/
621# define DO_TCP_OUTPUT(data, sotcb) tcp_output((data), (sotcb))
622# define DO_TCP_INPUT(data, mbuf, size, so) tcp_input((data), (mbuf), (size), (so))
623# define DO_TCP_CONNECT(data, so) tcp_connect((data), (so))
624# define DO_SOREAD(ret, data, so, ifclose) \
625 do { \
626 (ret) = soread((data), (so), (ifclose)); \
627 } while(0)
628# define DO_SOWRITE(ret, data, so) \
629 do { \
630 (ret) = sowrite((data), (so)); \
631 } while(0)
632# define DO_SORECFROM(data, so) sorecvfrom((data), (so))
633# define SOLOOKUP(so, label, src, sport, dst, dport) \
634 do { \
635 (so) = solookup(&VBOX_X2(queue_ ## label ## _label), (src), (sport), (dst), (dport)); \
636 } while (0)
637# define DO_UDP_DETACH(data, so, ignored) udp_detach((data), (so))
638
639#endif /* !VBOX_WITH_SLIRP_MT */
640
641#define TCP_OUTPUT(data, sotcb) DO_TCP_OUTPUT((data), (sotcb))
642#define TCP_INPUT(data, mbuf, size, so) DO_TCP_INPUT((data), (mbuf), (size), (so))
643#define TCP_CONNECT(data, so) DO_TCP_CONNECT((data), (so))
644#define SOREAD(ret, data, so, ifclose) DO_SOREAD((ret), (data), (so), (ifclose))
645#define SOWRITE(ret, data, so) DO_SOWRITE((ret), (data), (so))
646#define SORECVFROM(data, so) DO_SORECFROM((data), (so))
647#define UDP_DETACH(data, so, so_next) DO_UDP_DETACH((data), (so), (so_next))
648
649/* dnsproxy/dnsproxy.c */
650#define authoritative_port pData->authoritative_port
651#define authoritative_timeout pData->authoritative_timeout
652#define recursive_port pData->recursive_port
653#define recursive_timeout pData->recursive_timeout
654#define stats_timeout pData->stats_timeout
655/* dnsproxy/hash.c */
656#define dns_port pData->port
657#define request_hash pData->request_hash
658#define hash_collisions pData->hash_collisions
659#define active_queries pData->active_queries
660#define all_queries pData->all_queries
661#define authoritative_queries pData->authoritative_queries
662#define recursive_queries pData->recursive_queries
663#define removed_queries pData->removed_queries
664#define dropped_queries pData->dropped_queries
665#define answered_queries pData->answered_queries
666#define dropped_answers pData->dropped_answers
667#define late_answers pData->late_answers
668
669/* dnsproxy/dnsproxy.c */
670#define queryid pData->queryid
671#define authoritative_addr pData->authoritative_addr
672#define recursive_addr pData->recursive_addr
673#define sock_query pData->sock_query
674#define sock_answer pData->sock_answer
675
676#define instancehead pData->instancehead
677
678#define nmbclusters pData->nmbclusters
679#define nmbjumbop pData->nmbjumbop
680#define nmbjumbo9 pData->nmbjumbo9
681#define nmbjumbo16 pData->nmbjumbo16
682#define mbstat pData->mbstat
683#include "ext.h"
684#undef zone_mbuf
685#undef zone_clust
686#undef zone_pack
687#undef zone_jumbop
688#undef zone_jumbo9
689#undef zone_jumbo16
690#undef zone_ext_refcnt
691static inline uma_zone_t slirp_zone_pack(PNATState pData)
692{
693 return pData->zone_pack;
694}
695static inline uma_zone_t slirp_zone_jumbop(PNATState pData)
696{
697 return pData->zone_jumbop;
698}
699static inline uma_zone_t slirp_zone_jumbo9(PNATState pData)
700{
701 return pData->zone_jumbo9;
702}
703static inline uma_zone_t slirp_zone_jumbo16(PNATState pData)
704{
705 return pData->zone_jumbo16;
706}
707static inline uma_zone_t slirp_zone_ext_refcnt(PNATState pData)
708{
709 return pData->zone_ext_refcnt;
710}
711static inline uma_zone_t slirp_zone_mbuf(PNATState pData)
712{
713 return pData->zone_mbuf;
714}
715static inline uma_zone_t slirp_zone_clust(PNATState pData)
716{
717 return pData->zone_clust;
718}
719#ifndef VBOX_SLIRP_BSD
720# define m_adj(m, len) m_adj(pData, (m), (len))
721#endif
722
723#endif /* !___slirp_state_h */
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette