udp.c@ 14271

Last change on this file since 14271 was 14252, checked in by vboxsync, 16 years ago
csum validation hack, for testing IP integration of fragmentation routines borrowed from BSD
Property svn:eol-style set to `native`
File size: 18.0 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	#ifdef VBOX_WITH_BSD_REASS_CKSUM_HACK
126	/XXX: hack over csum calculation /
127	&& (m->m_sum_recalculate == 0 && ip->ip_sum != 0)
128	#endif /* VBOX_WITH_BSD_REASS_CKSUM_HACK */
129	) {
130	((struct ipovly *)ip)->ih_next = 0;
131	((struct ipovly *)ip)->ih_prev = 0;
132	((struct ipovly *)ip)->ih_x1 = 0;
133	((struct ipovly *)ip)->ih_len = uh->uh_ulen;
134	/* keep uh_sum for ICMP reply
135	* uh->uh_sum = cksum(m, len + sizeof (struct ip));
136	* if (uh->uh_sum) {
137	*/
138	if(cksum(m, len + sizeof(struct ip))) {
139	udpstat.udps_badsum++;
140	goto bad;
141	}
142	}
143
144	/*
145	* handle DHCP/BOOTP
146	*/
147	if (ntohs(uh->uh_dport) == BOOTP_SERVER) {
148	bootp_input(pData, m);
149	goto bad;
150	}
151
152	/*
153	* handle TFTP
154	*/
155	if (ntohs(uh->uh_dport) == TFTP_SERVER) {
156	tftp_input(pData, m);
157	goto bad;
158	}
159
160	/*
161	* Locate pcb for datagram.
162	*/
163	so = udp_last_so;
164	if (so->so_lport != uh->uh_sport \|\|
165	so->so_laddr.s_addr != ip->ip_src.s_addr) {
166	struct socket *tmp;
167
168	for (tmp = udb.so_next; tmp != &udb; tmp = tmp->so_next) {
169	if (tmp->so_lport == uh->uh_sport &&
170	tmp->so_laddr.s_addr == ip->ip_src.s_addr) {
171	so = tmp;
172	break;
173	}
174	}
175	if (tmp == &udb) {
176	so = NULL;
177	} else {
178	udpstat.udpps_pcbcachemiss++;
179	udp_last_so = so;
180	}
181	}
182
183	if (so == NULL) {
184	/*
185	* If there's no socket for this packet,
186	* create one
187	*/
188	if ((so = socreate()) == NULL) goto bad;
189	if(udp_attach(pData, so) == -1) {
190	DEBUG_MISC((dfd," udp_attach errno = %d-%s\n",
191	errno,strerror(errno)));
192	sofree(pData, so);
193	goto bad;
194	}
195
196	/*
197	* Setup fields
198	*/
199	/* udp_last_so = so; */
200	so->so_laddr = ip->ip_src;
201	so->so_lport = uh->uh_sport;
202
203	if ((so->so_iptos = udp_tos(so)) == 0)
204	so->so_iptos = ip->ip_tos;
205
206	/*
207	* XXXXX Here, check if it's in udpexec_list,
208	* and if it is, do the fork_exec() etc.
209	*/
210	}
211
212	so->so_faddr = ip->ip_dst; /* XXX */
213	so->so_fport = uh->uh_dport; /* XXX */
214
215	iphlen += sizeof(struct udphdr);
216	m->m_len -= iphlen;
217	m->m_data += iphlen;
218
219	/*
220	* Now we sendto() the packet.
221	*/
222	if (so->so_emu)
223	udp_emu(pData, so, m);
224
225	if(sosendto(pData, so,m) == -1) {
226	m->m_len += iphlen;
227	m->m_data -= iphlen;
228	*ip=save_ip;
229	DEBUG_MISC((dfd,"udp tx errno = %d-%s\n",errno,strerror(errno)));
230	icmp_error(pData, m, ICMP_UNREACH,ICMP_UNREACH_NET, 0,strerror(errno));
231	}
232
233	m_free(pData, so->so_m); /* used for ICMP if error on sorecvfrom */
234
235	/* restore the orig mbuf packet */
236	m->m_len += iphlen;
237	m->m_data -= iphlen;
238	*ip=save_ip;
239	so->so_m=m; /* ICMP backup */
240
241	return;
242	bad:
243	m_freem(pData, m);
244	/* if (opts) m_freem(opts); */
245	return;
246	}
247
248	int udp_output2(PNATState pData, struct socket so, struct mbuf m,
249	struct sockaddr_in saddr, struct sockaddr_in daddr,
250	int iptos)
251	{
252	register struct udpiphdr *ui;
253	int error = 0;
254
255	DEBUG_CALL("udp_output");
256	DEBUG_ARG("so = %lx", (long)so);
257	DEBUG_ARG("m = %lx", (long)m);
258	DEBUG_ARG("saddr = %lx", (long)saddr->sin_addr.s_addr);
259	DEBUG_ARG("daddr = %lx", (long)daddr->sin_addr.s_addr);
260
261	/*
262	* Adjust for header
263	*/
264	m->m_data -= sizeof(struct udpiphdr);
265	m->m_len += sizeof(struct udpiphdr);
266
267	/*
268	* Fill in mbuf with extended UDP header
269	* and addresses and length put into network format.
270	*/
271	ui = mtod(m, struct udpiphdr *);
272	ui->ui_next = ui->ui_prev = 0;
273	ui->ui_x1 = 0;
274	ui->ui_pr = IPPROTO_UDP;
275	ui->ui_len = htons(m->m_len - sizeof(struct ip)); /* + sizeof (struct udphdr)); */
276	/* XXXXX Check for from-one-location sockets, or from-any-location sockets */
277	ui->ui_src = saddr->sin_addr;
278	ui->ui_dst = daddr->sin_addr;
279	ui->ui_sport = saddr->sin_port;
280	ui->ui_dport = daddr->sin_port;
281	ui->ui_ulen = ui->ui_len;
282
283	/*
284	* Stuff checksum and output datagram.
285	*/
286	ui->ui_sum = 0;
287	if (udpcksum) {
288	if ((ui->ui_sum = cksum(m, /* sizeof (struct udpiphdr) + */ m->m_len)) == 0)
289	ui->ui_sum = 0xffff;
290	}
291	((struct ip *)ui)->ip_len = m->m_len;
292
293	((struct ip *)ui)->ip_ttl = ip_defttl;
294	((struct ip *)ui)->ip_tos = iptos;
295
296	udpstat.udps_opackets++;
297
298	error = ip_output(pData, so, m);
299
300	return (error);
301	}
302
303	int udp_output(PNATState pData, struct socket so, struct mbuf m,
304	struct sockaddr_in *addr)
305	{
306	struct sockaddr_in saddr, daddr;
307
308	saddr = *addr;
309	if ((so->so_faddr.s_addr & htonl(pData->netmask)) == special_addr.s_addr) {
310	saddr.sin_addr.s_addr = so->so_faddr.s_addr;
311	if ((so->so_faddr.s_addr & htonl(~pData->netmask)) == htonl(~pData->netmask))
312	saddr.sin_addr.s_addr = alias_addr.s_addr;
313	}
314	/* Any UDP packet to the loopback address must be translated to be from
315	* the forwarding address, i.e. 10.0.2.2. */
316	if ( (saddr.sin_addr.s_addr & htonl(IN_CLASSA_NET))
317	== htonl(INADDR_LOOPBACK & IN_CLASSA_NET))
318	saddr.sin_addr.s_addr = alias_addr.s_addr;
319
320	daddr.sin_addr = so->so_laddr;
321	daddr.sin_port = so->so_lport;
322
323	return udp_output2(pData, so, m, &saddr, &daddr, so->so_iptos);
324	}
325
326	int
327	udp_attach(PNATState pData, struct socket *so)
328	{
329	struct sockaddr_in addr;
330
331	if((so->s = socket(AF_INET,SOCK_DGRAM,0)) != -1) {
332	/*
333	* Here, we bind() the socket. Although not really needed
334	* (sendto() on an unbound socket will bind it), it's done
335	* here so that emulation of ytalk etc. don't have to do it
336	*/
337	addr.sin_family = AF_INET;
338	addr.sin_port = 0;
339	addr.sin_addr.s_addr = INADDR_ANY;
340	if(bind(so->s, (struct sockaddr *)&addr, sizeof(addr))<0) {
341	int lasterrno=errno;
342	closesocket(so->s);
343	so->s=-1;
344	#ifdef _WIN32
345	WSASetLastError(lasterrno);
346	#else
347	errno=lasterrno;
348	#endif
349	} else {
350	int opt = 1;
351	/* success, insert in queue */
352	so->so_expire = curtime + SO_EXPIRE;
353	/* enable broadcast for later use */
354	setsockopt(so->s, SOL_SOCKET, SO_BROADCAST, (const char *)&opt, sizeof(opt));
355	insque(pData, so,&udb);
356	}
357	}
358	return(so->s);
359	}
360
361	void
362	udp_detach(PNATState pData, struct socket *so)
363	{
364	/* Correctly update list if detaching last socket in list. */
365	if (so == udp_last_so) udp_last_so = &udb;
366	closesocket(so->s);
367	/* if (so->so_m) m_free(so->so_m); done by sofree */
368
369	sofree(pData, so);
370	}
371
372	static const struct tos_t udptos[] = {
373	{0, 53, IPTOS_LOWDELAY, 0}, /* DNS */
374	{517, 517, IPTOS_LOWDELAY, EMU_TALK}, /* talk */
375	{518, 518, IPTOS_LOWDELAY, EMU_NTALK}, /* ntalk */
376	{0, 7648, IPTOS_LOWDELAY, EMU_CUSEEME}, /* Cu-Seeme */
377	{0, 0, 0, 0}
378	};
379
380	u_int8_t
381	udp_tos(so)
382	struct socket *so;
383	{
384	int i = 0;
385
386	while(udptos[i].tos) {
387	if ((udptos[i].fport && ntohs(so->so_fport) == udptos[i].fport) \|\|
388	(udptos[i].lport && ntohs(so->so_lport) == udptos[i].lport)) {
389	so->so_emu = udptos[i].emu;
390	return udptos[i].tos;
391	}
392	i++;
393	}
394
395	return 0;
396	}
397
398	#ifdef EMULATE_TALK
399	#include "talkd.h"
400	#endif
401
402	/*
403	* Here, talk/ytalk/ntalk requests must be emulated
404	*/
405	void
406	udp_emu(PNATState pData, struct socket so, struct mbuf m)
407	{
408	struct sockaddr_in addr;
409	socklen_t addrlen = sizeof(addr);
410	#ifdef EMULATE_TALK
411	CTL_MSG_OLD *omsg;
412	CTL_MSG *nmsg;
413	char buff[sizeof(CTL_MSG)];
414	u_char type;
415
416	struct talk_request {
417	struct talk_request *next;
418	struct socket *udp_so;
419	struct socket *tcp_so;
420	} *req;
421
422	static struct talk_request *req_tbl = 0;
423
424	#endif
425
426	struct cu_header {
427	uint16_t d_family; /* destination family */
428	uint16_t d_port; /* destination port */
429	uint32_t d_addr; /* destination address */
430	uint16_t s_family; /* source family */
431	uint16_t s_port; /* source port */
432	uint32_t so_addr; /* source address */
433	uint32_t seqn; /* sequence number */
434	uint16_t message; /* message */
435	uint16_t data_type; /* data type */
436	uint16_t pkt_len; /* packet length */
437	} *cu_head;
438
439	switch(so->so_emu) {
440
441	#ifdef EMULATE_TALK
442	case EMU_TALK:
443	case EMU_NTALK:
444	/*
445	* Talk emulation. We always change the ctl_addr to get
446	* some answers from the daemon. When an ANNOUNCE comes,
447	* we send LEAVE_INVITE to the local daemons. Also when a
448	* DELETE comes, we send copies to the local daemons.
449	*/
450	if (getsockname(so->s, (struct sockaddr *)&addr, &addrlen) < 0)
451	return;
452
453	#define IS_OLD (so->so_emu == EMU_TALK)
454
455	#define COPY_MSG(dest, src) { dest->type = src->type; \
456	dest->id_num = src->id_num; \
457	dest->pid = src->pid; \
458	dest->addr = src->addr; \
459	dest->ctl_addr = src->ctl_addr; \
460	memcpy(&dest->l_name, &src->l_name, NAME_SIZE_OLD); \
461	memcpy(&dest->r_name, &src->r_name, NAME_SIZE_OLD); \
462	memcpy(&dest->r_tty, &src->r_tty, TTY_SIZE); }
463
464	#define OTOSIN(ptr, field) ((struct sockaddr_in *)&ptr->field)
465	/* old_sockaddr to sockaddr_in */
466
467
468	if (IS_OLD) { /* old talk */
469	omsg = mtod(m, CTL_MSG_OLD*);
470	nmsg = (CTL_MSG *) buff;
471	type = omsg->type;
472	OTOSIN(omsg, ctl_addr)->sin_port = addr.sin_port;
473	OTOSIN(omsg, ctl_addr)->sin_addr = our_addr;
474	strncpy(omsg->l_name, getlogin(), NAME_SIZE_OLD);
475	} else { /* new talk */
476	omsg = (CTL_MSG_OLD *) buff;
477	nmsg = mtod(m, CTL_MSG *);
478	type = nmsg->type;
479	OTOSIN(nmsg, ctl_addr)->sin_port = addr.sin_port;
480	OTOSIN(nmsg, ctl_addr)->sin_addr = our_addr;
481	strncpy(nmsg->l_name, getlogin(), NAME_SIZE_OLD);
482	}
483
484	if (type == LOOK_UP)
485	return; /* for LOOK_UP this is enough */
486
487	if (IS_OLD) { /* make a copy of the message */
488	COPY_MSG(nmsg, omsg);
489	nmsg->vers = 1;
490	nmsg->answer = 0;
491	} else
492	COPY_MSG(omsg, nmsg);
493
494	/*
495	* If if is an ANNOUNCE message, we go through the
496	* request table to see if a tcp port has already
497	* been redirected for this socket. If not, we solisten()
498	* a new socket and add this entry to the table.
499	* The port number of the tcp socket and our IP
500	* are put to the addr field of the message structures.
501	* Then a LEAVE_INVITE is sent to both local daemon
502	* ports, 517 and 518. This is why we have two copies
503	* of the message, one in old talk and one in new talk
504	* format.
505	*/
506
507	if (type == ANNOUNCE) {
508	int s;
509	u_short temp_port;
510
511	for(req = req_tbl; req; req = req->next)
512	if (so == req->udp_so)
513	break; /* found it */
514
515	if (!req) { /* no entry for so, create new */
516	req = (struct talk_request *)
517	malloc(sizeof(struct talk_request));
518	req->udp_so = so;
519	req->tcp_so = solisten(0,
520	OTOSIN(omsg, addr)->sin_addr.s_addr,
521	OTOSIN(omsg, addr)->sin_port,
522	SS_FACCEPTONCE);
523	req->next = req_tbl;
524	req_tbl = req;
525	}
526
527	/* replace port number in addr field */
528	addrlen = sizeof(addr);
529	getsockname(req->tcp_so->s,
530	(struct sockaddr *) &addr,
531	&addrlen);
532	OTOSIN(omsg, addr)->sin_port = addr.sin_port;
533	OTOSIN(omsg, addr)->sin_addr = our_addr;
534	OTOSIN(nmsg, addr)->sin_port = addr.sin_port;
535	OTOSIN(nmsg, addr)->sin_addr = our_addr;
536
537	/* send LEAVE_INVITEs */
538	temp_port = OTOSIN(omsg, ctl_addr)->sin_port;
539	OTOSIN(omsg, ctl_addr)->sin_port = 0;
540	OTOSIN(nmsg, ctl_addr)->sin_port = 0;
541	omsg->type = nmsg->type = LEAVE_INVITE;
542
543	s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
544	addr.sin_addr = our_addr;
545	addr.sin_family = AF_INET;
546	addr.sin_port = htons(517);
547	sendto(s, (char )omsg, sizeof(omsg), 0,
548	(struct sockaddr *)&addr, sizeof(addr));
549	addr.sin_port = htons(518);
550	sendto(s, (char )nmsg, sizeof(nmsg), 0,
551	(struct sockaddr *) &addr, sizeof(addr));
552	closesocket(s) ;
553
554	omsg->type = nmsg->type = ANNOUNCE;
555	OTOSIN(omsg, ctl_addr)->sin_port = temp_port;
556	OTOSIN(nmsg, ctl_addr)->sin_port = temp_port;
557	}
558
559	/*
560	* If it is a DELETE message, we send a copy to the
561	* local daemons. Then we delete the entry corresponding
562	* to our socket from the request table.
563	*/
564
565	if (type == DELETE) {
566	struct talk_request temp_req, req_next;
567	int s;
568	u_short temp_port;
569
570	temp_port = OTOSIN(omsg, ctl_addr)->sin_port;
571	OTOSIN(omsg, ctl_addr)->sin_port = 0;
572	OTOSIN(nmsg, ctl_addr)->sin_port = 0;
573
574	s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
575	addr.sin_addr = our_addr;
576	addr.sin_family = AF_INET;
577	addr.sin_port = htons(517);
578	sendto(s, (char )omsg, sizeof(omsg), 0,
579	(struct sockaddr *)&addr, sizeof(addr));
580	addr.sin_port = htons(518);
581	sendto(s, (char )nmsg, sizeof(nmsg), 0,
582	(struct sockaddr *)&addr, sizeof(addr));
583	closesocket(s);
584
585	OTOSIN(omsg, ctl_addr)->sin_port = temp_port;
586	OTOSIN(nmsg, ctl_addr)->sin_port = temp_port;
587
588	/* delete table entry */
589	if (so == req_tbl->udp_so) {
590	temp_req = req_tbl;
591	req_tbl = req_tbl->next;
592	free(temp_req);
593	} else {
594	temp_req = req_tbl;
595	for(req = req_tbl->next; req; req = req_next) {
596	req_next = req->next;
597	if (so == req->udp_so) {
598	temp_req->next = req_next;
599	free(req);
600	break;
601	} else {
602	temp_req = req;
603	}
604	}
605	}
606	}
607
608	return;
609	#endif
610
611	case EMU_CUSEEME:
612
613	/*
614	* Cu-SeeMe emulation.
615	* Hopefully the packet is more that 16 bytes long. We don't
616	* do any other tests, just replace the address and port
617	* fields.
618	*/
619	if (m->m_len >= sizeof (*cu_head)) {
620	if (getsockname(so->s, (struct sockaddr *)&addr, &addrlen) < 0)
621	return;
622	cu_head = mtod(m, struct cu_header *);
623	cu_head->s_port = addr.sin_port;
624	cu_head->so_addr = our_addr.s_addr;
625	}
626
627	return;
628	}
629	}
630
631	struct socket *
632	udp_listen(PNATState pData, u_int port, u_int32_t laddr, u_int lport, int flags)
633	{
634	struct sockaddr_in addr;
635	struct socket *so;
636	socklen_t addrlen = sizeof(struct sockaddr_in);
637	int opt = 1;
638
639	if ((so = socreate()) == NULL) {
640	free(so);
641	return NULL;
642	}
643	so->s = socket(AF_INET,SOCK_DGRAM,0);
644	so->so_expire = curtime + SO_EXPIRE;
645	insque(pData, so,&udb);
646
647	addr.sin_family = AF_INET;
648	addr.sin_addr.s_addr = INADDR_ANY;
649	addr.sin_port = port;
650
651	if (bind(so->s,(struct sockaddr *)&addr, addrlen) < 0) {
652	udp_detach(pData, so);
653	return NULL;
654	}
655	setsockopt(so->s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));
656	/* setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char )&opt,sizeof(int)); /
657
658	getsockname(so->s,(struct sockaddr *)&addr,&addrlen);
659	so->so_fport = addr.sin_port;
660	/* The original check was completely broken, as the commented out
661	* if statement was always true (INADDR_ANY=0). */
662	/* if (addr.sin_addr.s_addr == 0 \|\| addr.sin_addr.s_addr == loopback_addr.s_addr) */
663	if (1 == 0) /* always use the else part */
664	so->so_faddr = alias_addr;
665	else
666	so->so_faddr = addr.sin_addr;
667
668	so->so_lport = lport;
669	so->so_laddr.s_addr = laddr;
670	if (flags != SS_FACCEPTONCE)
671	so->so_expire = 0;
672
673	so->so_state = SS_ISFCONNECTED;
674
675	return so;
676	}

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

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

Download in other formats: