udp.c@ 3021

Last change on this file since 3021 was 1824, checked in by vboxsync, 18 years ago
Disable NAT UDP broadcast resend to local address. Removed the inline declarations and the useless _MSC_VER checks. And eliminated a few compiler warnings.
Property svn:eol-style set to `native`
File size: 17.3 KB

Line
1	/*
2	* Copyright (c) 1982, 1986, 1988, 1990, 1993
3	* The Regents of the University of California. All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	* 3. All advertising materials mentioning features or use of this software
14	* must display the following acknowledgement:
15	* This product includes software developed by the University of
16	* California, Berkeley and its contributors.
17	* 4. Neither the name of the University nor the names of its contributors
18	* may be used to endorse or promote products derived from this software
19	* without specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31	* SUCH DAMAGE.
32	*
33	* @(#)udp_usrreq.c 8.4 (Berkeley) 1/21/94
34	* udp_usrreq.c,v 1.4 1994/10/02 17:48:45 phk Exp
35	*/
36
37	/*
38	* Changes and additions relating to SLiRP
39	* Copyright (c) 1995 Danny Gasparovski.
40	*
41	* Please read the file COPYRIGHT for the
42	* terms and conditions of the copyright.
43	*/
44
45	#include <slirp.h>
46	#include "ip_icmp.h"
47
48
49	/*
50	* UDP protocol implementation.
51	* Per RFC 768, August, 1980.
52	*/
53	#define udpcksum 1
54
55	void
56	udp_init(PNATState pData)
57	{
58	udp_last_so = &udb;
59	udb.so_next = udb.so_prev = &udb;
60	}
61
62	/* m->m_data points at ip packet header
63	* m->m_len length ip packet
64	* ip->ip_len length data (IPDU)
65	*/
66	void
67	udp_input(PNATState pData, register struct mbuf *m, int iphlen)
68	{
69	register struct ip *ip;
70	register struct udphdr *uh;
71	/* struct mbuf opts = 0;/
72	int len;
73	struct ip save_ip;
74	struct socket *so;
75
76	DEBUG_CALL("udp_input");
77	DEBUG_ARG("m = %lx", (long)m);
78	DEBUG_ARG("iphlen = %d", iphlen);
79
80	udpstat.udps_ipackets++;
81
82	/*
83	* Strip IP options, if any; should skip this,
84	* make available to user, and use on returned packets,
85	* but we don't yet have a way to check the checksum
86	* with options still present.
87	*/
88	if(iphlen > sizeof(struct ip)) {
89	ip_stripoptions(m, (struct mbuf *)0);
90	iphlen = sizeof(struct ip);
91	}
92
93	/*
94	* Get IP and UDP header together in first mbuf.
95	*/
96	ip = mtod(m, struct ip *);
97	uh = (struct udphdr *)((caddr_t)ip + iphlen);
98
99	/*
100	* Make mbuf data length reflect UDP length.
101	* If not enough data to reflect UDP length, drop.
102	*/
103	len = ntohs((u_int16_t)uh->uh_ulen);
104
105	if (ip->ip_len != len) {
106	if (len > ip->ip_len) {
107	udpstat.udps_badlen++;
108	goto bad;
109	}
110	m_adj(m, len - ip->ip_len);
111	ip->ip_len = len;
112	}
113
114	/*
115	* Save a copy of the IP header in case we want restore it
116	* for sending an ICMP error message in response.
117	*/
118	save_ip = *ip;
119	save_ip.ip_len+= iphlen; /* tcp_input subtracts this */
120
121	/*
122	* Checksum extended UDP header and data.
123	*/
124	if (udpcksum && uh->uh_sum) {
125	((struct ipovly *)ip)->ih_next = 0;
126	((struct ipovly *)ip)->ih_prev = 0;
127	((struct ipovly *)ip)->ih_x1 = 0;
128	((struct ipovly *)ip)->ih_len = uh->uh_ulen;
129	/* keep uh_sum for ICMP reply
130	* uh->uh_sum = cksum(m, len + sizeof (struct ip));
131	* if (uh->uh_sum) {
132	*/
133	if(cksum(m, len + sizeof(struct ip))) {
134	udpstat.udps_badsum++;
135	goto bad;
136	}
137	}
138
139	/*
140	* handle DHCP/BOOTP
141	*/
142	if (ntohs(uh->uh_dport) == BOOTP_SERVER) {
143	bootp_input(pData, m);
144	goto bad;
145	}
146
147	/*
148	* handle TFTP
149	*/
150	if (ntohs(uh->uh_dport) == TFTP_SERVER) {
151	tftp_input(pData, m);
152	goto bad;
153	}
154
155	/*
156	* Locate pcb for datagram.
157	*/
158	so = udp_last_so;
159	if (so->so_lport != uh->uh_sport \|\|
160	so->so_laddr.s_addr != ip->ip_src.s_addr) {
161	struct socket *tmp;
162
163	for (tmp = udb.so_next; tmp != &udb; tmp = tmp->so_next) {
164	if (tmp->so_lport == uh->uh_sport &&
165	tmp->so_laddr.s_addr == ip->ip_src.s_addr) {
166	so = tmp;
167	break;
168	}
169	}
170	if (tmp == &udb) {
171	so = NULL;
172	} else {
173	udpstat.udpps_pcbcachemiss++;
174	udp_last_so = so;
175	}
176	}
177
178	if (so == NULL) {
179	/*
180	* If there's no socket for this packet,
181	* create one
182	*/
183	if ((so = socreate()) == NULL) goto bad;
184	if(udp_attach(pData, so) == -1) {
185	DEBUG_MISC((dfd," udp_attach errno = %d-%s\n",
186	errno,strerror(errno)));
187	sofree(pData, so);
188	goto bad;
189	}
190
191	/*
192	* Setup fields
193	*/
194	/* udp_last_so = so; */
195	so->so_laddr = ip->ip_src;
196	so->so_lport = uh->uh_sport;
197
198	if ((so->so_iptos = udp_tos(so)) == 0)
199	so->so_iptos = ip->ip_tos;
200
201	/*
202	* XXXXX Here, check if it's in udpexec_list,
203	* and if it is, do the fork_exec() etc.
204	*/
205	}
206
207	so->so_faddr = ip->ip_dst; /* XXX */
208	so->so_fport = uh->uh_dport; /* XXX */
209
210	iphlen += sizeof(struct udphdr);
211	m->m_len -= iphlen;
212	m->m_data += iphlen;
213
214	/*
215	* Now we sendto() the packet.
216	*/
217	if (so->so_emu)
218	udp_emu(pData, so, m);
219
220	if(sosendto(pData, so,m) == -1) {
221	m->m_len += iphlen;
222	m->m_data -= iphlen;
223	*ip=save_ip;
224	DEBUG_MISC((dfd,"udp tx errno = %d-%s\n",errno,strerror(errno)));
225	icmp_error(pData, m, ICMP_UNREACH,ICMP_UNREACH_NET, 0,strerror(errno));
226	}
227
228	m_free(pData, so->so_m); /* used for ICMP if error on sorecvfrom */
229
230	/* restore the orig mbuf packet */
231	m->m_len += iphlen;
232	m->m_data -= iphlen;
233	*ip=save_ip;
234	so->so_m=m; /* ICMP backup */
235
236	return;
237	bad:
238	m_freem(pData, m);
239	/* if (opts) m_freem(opts); */
240	return;
241	}
242
243	int udp_output2(PNATState pData, struct socket so, struct mbuf m,
244	struct sockaddr_in saddr, struct sockaddr_in daddr,
245	int iptos)
246	{
247	register struct udpiphdr *ui;
248	int error = 0;
249
250	DEBUG_CALL("udp_output");
251	DEBUG_ARG("so = %lx", (long)so);
252	DEBUG_ARG("m = %lx", (long)m);
253	DEBUG_ARG("saddr = %lx", (long)saddr->sin_addr.s_addr);
254	DEBUG_ARG("daddr = %lx", (long)daddr->sin_addr.s_addr);
255
256	/*
257	* Adjust for header
258	*/
259	m->m_data -= sizeof(struct udpiphdr);
260	m->m_len += sizeof(struct udpiphdr);
261
262	/*
263	* Fill in mbuf with extended UDP header
264	* and addresses and length put into network format.
265	*/
266	ui = mtod(m, struct udpiphdr *);
267	ui->ui_next = ui->ui_prev = 0;
268	ui->ui_x1 = 0;
269	ui->ui_pr = IPPROTO_UDP;
270	ui->ui_len = htons(m->m_len - sizeof(struct ip)); /* + sizeof (struct udphdr)); */
271	/* XXXXX Check for from-one-location sockets, or from-any-location sockets */
272	ui->ui_src = saddr->sin_addr;
273	ui->ui_dst = daddr->sin_addr;
274	ui->ui_sport = saddr->sin_port;
275	ui->ui_dport = daddr->sin_port;
276	ui->ui_ulen = ui->ui_len;
277
278	/*
279	* Stuff checksum and output datagram.
280	*/
281	ui->ui_sum = 0;
282	if (udpcksum) {
283	if ((ui->ui_sum = cksum(m, /* sizeof (struct udpiphdr) + */ m->m_len)) == 0)
284	ui->ui_sum = 0xffff;
285	}
286	((struct ip *)ui)->ip_len = m->m_len;
287
288	((struct ip *)ui)->ip_ttl = ip_defttl;
289	((struct ip *)ui)->ip_tos = iptos;
290
291	udpstat.udps_opackets++;
292
293	error = ip_output(pData, so, m);
294
295	return (error);
296	}
297
298	int udp_output(PNATState pData, struct socket so, struct mbuf m,
299	struct sockaddr_in *addr)
300	{
301	struct sockaddr_in saddr, daddr;
302
303	saddr = *addr;
304	if ((so->so_faddr.s_addr & htonl(0xffffff00)) == special_addr.s_addr) {
305	saddr.sin_addr.s_addr = so->so_faddr.s_addr;
306	if ((so->so_faddr.s_addr & htonl(0x000000ff)) == htonl(0xff))
307	saddr.sin_addr.s_addr = alias_addr.s_addr;
308	}
309	daddr.sin_addr = so->so_laddr;
310	daddr.sin_port = so->so_lport;
311
312	return udp_output2(pData, so, m, &saddr, &daddr, so->so_iptos);
313	}
314
315	int
316	udp_attach(PNATState pData, struct socket *so)
317	{
318	struct sockaddr_in addr;
319
320	if((so->s = socket(AF_INET,SOCK_DGRAM,0)) != -1) {
321	/*
322	* Here, we bind() the socket. Although not really needed
323	* (sendto() on an unbound socket will bind it), it's done
324	* here so that emulation of ytalk etc. don't have to do it
325	*/
326	addr.sin_family = AF_INET;
327	addr.sin_port = 0;
328	addr.sin_addr.s_addr = INADDR_ANY;
329	if(bind(so->s, (struct sockaddr *)&addr, sizeof(addr))<0) {
330	int lasterrno=errno;
331	closesocket(so->s);
332	so->s=-1;
333	#ifdef _WIN32
334	WSASetLastError(lasterrno);
335	#else
336	errno=lasterrno;
337	#endif
338	} else {
339	int opt = 1;
340	/* success, insert in queue */
341	so->so_expire = curtime + SO_EXPIRE;
342	/* enable broadcast for later use */
343	setsockopt(so->s, SOL_SOCKET, SO_BROADCAST, (const char *)&opt, sizeof(opt));
344	insque(pData, so,&udb);
345	}
346	}
347	return(so->s);
348	}
349
350	void
351	udp_detach(PNATState pData, struct socket *so)
352	{
353	/* Correctly update list if detaching last socket in list. */
354	if (so == udp_last_so) udp_last_so = &udb;
355	closesocket(so->s);
356	/* if (so->so_m) m_free(so->so_m); done by sofree */
357
358	sofree(pData, so);
359	}
360
361	static const struct tos_t udptos[] = {
362	{0, 53, IPTOS_LOWDELAY, 0}, /* DNS */
363	{517, 517, IPTOS_LOWDELAY, EMU_TALK}, /* talk */
364	{518, 518, IPTOS_LOWDELAY, EMU_NTALK}, /* ntalk */
365	{0, 7648, IPTOS_LOWDELAY, EMU_CUSEEME}, /* Cu-Seeme */
366	{0, 0, 0, 0}
367	};
368
369	u_int8_t
370	udp_tos(so)
371	struct socket *so;
372	{
373	int i = 0;
374
375	while(udptos[i].tos) {
376	if ((udptos[i].fport && ntohs(so->so_fport) == udptos[i].fport) \|\|
377	(udptos[i].lport && ntohs(so->so_lport) == udptos[i].lport)) {
378	so->so_emu = udptos[i].emu;
379	return udptos[i].tos;
380	}
381	i++;
382	}
383
384	return 0;
385	}
386
387	#ifdef EMULATE_TALK
388	#include "talkd.h"
389	#endif
390
391	/*
392	* Here, talk/ytalk/ntalk requests must be emulated
393	*/
394	void
395	udp_emu(PNATState pData, struct socket so, struct mbuf m)
396	{
397	struct sockaddr_in addr;
398	socklen_t addrlen = sizeof(addr);
399	#ifdef EMULATE_TALK
400	CTL_MSG_OLD *omsg;
401	CTL_MSG *nmsg;
402	char buff[sizeof(CTL_MSG)];
403	u_char type;
404
405	struct talk_request {
406	struct talk_request *next;
407	struct socket *udp_so;
408	struct socket *tcp_so;
409	} *req;
410
411	static struct talk_request *req_tbl = 0;
412
413	#endif
414
415	struct cu_header {
416	uint16_t d_family; /* destination family */
417	uint16_t d_port; /* destination port */
418	uint32_t d_addr; /* destination address */
419	uint16_t s_family; /* source family */
420	uint16_t s_port; /* source port */
421	uint32_t so_addr; /* source address */
422	uint32_t seqn; /* sequence number */
423	uint16_t message; /* message */
424	uint16_t data_type; /* data type */
425	uint16_t pkt_len; /* packet length */
426	} *cu_head;
427
428	switch(so->so_emu) {
429
430	#ifdef EMULATE_TALK
431	case EMU_TALK:
432	case EMU_NTALK:
433	/*
434	* Talk emulation. We always change the ctl_addr to get
435	* some answers from the daemon. When an ANNOUNCE comes,
436	* we send LEAVE_INVITE to the local daemons. Also when a
437	* DELETE comes, we send copies to the local daemons.
438	*/
439	if (getsockname(so->s, (struct sockaddr *)&addr, &addrlen) < 0)
440	return;
441
442	#define IS_OLD (so->so_emu == EMU_TALK)
443
444	#define COPY_MSG(dest, src) { dest->type = src->type; \
445	dest->id_num = src->id_num; \
446	dest->pid = src->pid; \
447	dest->addr = src->addr; \
448	dest->ctl_addr = src->ctl_addr; \
449	memcpy(&dest->l_name, &src->l_name, NAME_SIZE_OLD); \
450	memcpy(&dest->r_name, &src->r_name, NAME_SIZE_OLD); \
451	memcpy(&dest->r_tty, &src->r_tty, TTY_SIZE); }
452
453	#define OTOSIN(ptr, field) ((struct sockaddr_in *)&ptr->field)
454	/* old_sockaddr to sockaddr_in */
455
456
457	if (IS_OLD) { /* old talk */
458	omsg = mtod(m, CTL_MSG_OLD*);
459	nmsg = (CTL_MSG *) buff;
460	type = omsg->type;
461	OTOSIN(omsg, ctl_addr)->sin_port = addr.sin_port;
462	OTOSIN(omsg, ctl_addr)->sin_addr = our_addr;
463	strncpy(omsg->l_name, getlogin(), NAME_SIZE_OLD);
464	} else { /* new talk */
465	omsg = (CTL_MSG_OLD *) buff;
466	nmsg = mtod(m, CTL_MSG *);
467	type = nmsg->type;
468	OTOSIN(nmsg, ctl_addr)->sin_port = addr.sin_port;
469	OTOSIN(nmsg, ctl_addr)->sin_addr = our_addr;
470	strncpy(nmsg->l_name, getlogin(), NAME_SIZE_OLD);
471	}
472
473	if (type == LOOK_UP)
474	return; /* for LOOK_UP this is enough */
475
476	if (IS_OLD) { /* make a copy of the message */
477	COPY_MSG(nmsg, omsg);
478	nmsg->vers = 1;
479	nmsg->answer = 0;
480	} else
481	COPY_MSG(omsg, nmsg);
482
483	/*
484	* If if is an ANNOUNCE message, we go through the
485	* request table to see if a tcp port has already
486	* been redirected for this socket. If not, we solisten()
487	* a new socket and add this entry to the table.
488	* The port number of the tcp socket and our IP
489	* are put to the addr field of the message structures.
490	* Then a LEAVE_INVITE is sent to both local daemon
491	* ports, 517 and 518. This is why we have two copies
492	* of the message, one in old talk and one in new talk
493	* format.
494	*/
495
496	if (type == ANNOUNCE) {
497	int s;
498	u_short temp_port;
499
500	for(req = req_tbl; req; req = req->next)
501	if (so == req->udp_so)
502	break; /* found it */
503
504	if (!req) { /* no entry for so, create new */
505	req = (struct talk_request *)
506	malloc(sizeof(struct talk_request));
507	req->udp_so = so;
508	req->tcp_so = solisten(0,
509	OTOSIN(omsg, addr)->sin_addr.s_addr,
510	OTOSIN(omsg, addr)->sin_port,
511	SS_FACCEPTONCE);
512	req->next = req_tbl;
513	req_tbl = req;
514	}
515
516	/* replace port number in addr field */
517	addrlen = sizeof(addr);
518	getsockname(req->tcp_so->s,
519	(struct sockaddr *) &addr,
520	&addrlen);
521	OTOSIN(omsg, addr)->sin_port = addr.sin_port;
522	OTOSIN(omsg, addr)->sin_addr = our_addr;
523	OTOSIN(nmsg, addr)->sin_port = addr.sin_port;
524	OTOSIN(nmsg, addr)->sin_addr = our_addr;
525
526	/* send LEAVE_INVITEs */
527	temp_port = OTOSIN(omsg, ctl_addr)->sin_port;
528	OTOSIN(omsg, ctl_addr)->sin_port = 0;
529	OTOSIN(nmsg, ctl_addr)->sin_port = 0;
530	omsg->type = nmsg->type = LEAVE_INVITE;
531
532	s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
533	addr.sin_addr = our_addr;
534	addr.sin_family = AF_INET;
535	addr.sin_port = htons(517);
536	sendto(s, (char )omsg, sizeof(omsg), 0,
537	(struct sockaddr *)&addr, sizeof(addr));
538	addr.sin_port = htons(518);
539	sendto(s, (char )nmsg, sizeof(nmsg), 0,
540	(struct sockaddr *) &addr, sizeof(addr));
541	closesocket(s) ;
542
543	omsg->type = nmsg->type = ANNOUNCE;
544	OTOSIN(omsg, ctl_addr)->sin_port = temp_port;
545	OTOSIN(nmsg, ctl_addr)->sin_port = temp_port;
546	}
547
548	/*
549	* If it is a DELETE message, we send a copy to the
550	* local daemons. Then we delete the entry corresponding
551	* to our socket from the request table.
552	*/
553
554	if (type == DELETE) {
555	struct talk_request temp_req, req_next;
556	int s;
557	u_short temp_port;
558
559	temp_port = OTOSIN(omsg, ctl_addr)->sin_port;
560	OTOSIN(omsg, ctl_addr)->sin_port = 0;
561	OTOSIN(nmsg, ctl_addr)->sin_port = 0;
562
563	s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
564	addr.sin_addr = our_addr;
565	addr.sin_family = AF_INET;
566	addr.sin_port = htons(517);
567	sendto(s, (char )omsg, sizeof(omsg), 0,
568	(struct sockaddr *)&addr, sizeof(addr));
569	addr.sin_port = htons(518);
570	sendto(s, (char )nmsg, sizeof(nmsg), 0,
571	(struct sockaddr *)&addr, sizeof(addr));
572	closesocket(s);
573
574	OTOSIN(omsg, ctl_addr)->sin_port = temp_port;
575	OTOSIN(nmsg, ctl_addr)->sin_port = temp_port;
576
577	/* delete table entry */
578	if (so == req_tbl->udp_so) {
579	temp_req = req_tbl;
580	req_tbl = req_tbl->next;
581	free(temp_req);
582	} else {
583	temp_req = req_tbl;
584	for(req = req_tbl->next; req; req = req_next) {
585	req_next = req->next;
586	if (so == req->udp_so) {
587	temp_req->next = req_next;
588	free(req);
589	break;
590	} else {
591	temp_req = req;
592	}
593	}
594	}
595	}
596
597	return;
598	#endif
599
600	case EMU_CUSEEME:
601
602	/*
603	* Cu-SeeMe emulation.
604	* Hopefully the packet is more that 16 bytes long. We don't
605	* do any other tests, just replace the address and port
606	* fields.
607	*/
608	if (m->m_len >= sizeof (*cu_head)) {
609	if (getsockname(so->s, (struct sockaddr *)&addr, &addrlen) < 0)
610	return;
611	cu_head = mtod(m, struct cu_header *);
612	cu_head->s_port = addr.sin_port;
613	cu_head->so_addr = our_addr.s_addr;
614	}
615
616	return;
617	}
618	}
619
620	struct socket *
621	udp_listen(PNATState pData, u_int port, u_int32_t laddr, u_int lport, int flags)
622	{
623	struct sockaddr_in addr;
624	struct socket *so;
625	socklen_t addrlen = sizeof(struct sockaddr_in);
626	int opt = 1;
627
628	if ((so = socreate()) == NULL) {
629	free(so);
630	return NULL;
631	}
632	so->s = socket(AF_INET,SOCK_DGRAM,0);
633	so->so_expire = curtime + SO_EXPIRE;
634	insque(pData, so,&udb);
635
636	addr.sin_family = AF_INET;
637	addr.sin_addr.s_addr = INADDR_ANY;
638	addr.sin_port = port;
639
640	if (bind(so->s,(struct sockaddr *)&addr, addrlen) < 0) {
641	udp_detach(pData, so);
642	return NULL;
643	}
644	setsockopt(so->s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));
645	/* setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char )&opt,sizeof(int)); /
646
647	getsockname(so->s,(struct sockaddr *)&addr,&addrlen);
648	so->so_fport = addr.sin_port;
649	if (addr.sin_addr.s_addr == 0 \|\| addr.sin_addr.s_addr == loopback_addr.s_addr)
650	so->so_faddr = alias_addr;
651	else
652	so->so_faddr = addr.sin_addr;
653
654	so->so_lport = lport;
655	so->so_laddr.s_addr = laddr;
656	if (flags != SS_FACCEPTONCE)
657	so->so_expire = 0;
658
659	so->so_state = SS_ISFCONNECTED;
660
661	return so;
662	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Network/slirp/udp.c@ 3021

Download in other formats: