slirp: correct size computation while concatenating mbuf
[qemu.git] / slirp / socket.c
1 /*
2 * Copyright (c) 1995 Danny Gasparovski.
3 *
4 * Please read the file COPYRIGHT for the
5 * terms and conditions of the copyright.
6 */
7
8 #include "qemu/osdep.h"
9 #include "qemu-common.h"
10 #include "slirp.h"
11 #include "ip_icmp.h"
12 #ifdef __sun__
13 #include <sys/filio.h>
14 #endif
15
16 static void sofcantrcvmore(struct socket *so);
17 static void sofcantsendmore(struct socket *so);
18
19 struct socket *solookup(struct socket **last, struct socket *head,
20 struct sockaddr_storage *lhost, struct sockaddr_storage *fhost)
21 {
22 struct socket *so = *last;
23
24 /* Optimisation */
25 if (so != head && sockaddr_equal(&(so->lhost.ss), lhost)
26 && (!fhost || sockaddr_equal(&so->fhost.ss, fhost))) {
27 return so;
28 }
29
30 for (so = head->so_next; so != head; so = so->so_next) {
31 if (sockaddr_equal(&(so->lhost.ss), lhost)
32 && (!fhost || sockaddr_equal(&so->fhost.ss, fhost))) {
33 *last = so;
34 return so;
35 }
36 }
37
38 return (struct socket *)NULL;
39 }
40
41 /*
42 * Create a new socket, initialise the fields
43 * It is the responsibility of the caller to
44 * insque() it into the correct linked-list
45 */
46 struct socket *
47 socreate(Slirp *slirp)
48 {
49 struct socket *so;
50
51 so = (struct socket *)malloc(sizeof(struct socket));
52 if(so) {
53 memset(so, 0, sizeof(struct socket));
54 so->so_state = SS_NOFDREF;
55 so->s = -1;
56 so->slirp = slirp;
57 so->pollfds_idx = -1;
58 }
59 return(so);
60 }
61
62 /*
63 * Remove references to so from the given message queue.
64 */
65 static void
66 soqfree(struct socket *so, struct quehead *qh)
67 {
68 struct mbuf *ifq;
69
70 for (ifq = (struct mbuf *) qh->qh_link;
71 (struct quehead *) ifq != qh;
72 ifq = ifq->ifq_next) {
73 if (ifq->ifq_so == so) {
74 struct mbuf *ifm;
75 ifq->ifq_so = NULL;
76 for (ifm = ifq->ifs_next; ifm != ifq; ifm = ifm->ifs_next) {
77 ifm->ifq_so = NULL;
78 }
79 }
80 }
81 }
82
83 /*
84 * remque and free a socket, clobber cache
85 */
86 void
87 sofree(struct socket *so)
88 {
89 Slirp *slirp = so->slirp;
90
91 soqfree(so, &slirp->if_fastq);
92 soqfree(so, &slirp->if_batchq);
93
94 if (so->so_emu==EMU_RSH && so->extra) {
95 sofree(so->extra);
96 so->extra=NULL;
97 }
98 if (so == slirp->tcp_last_so) {
99 slirp->tcp_last_so = &slirp->tcb;
100 } else if (so == slirp->udp_last_so) {
101 slirp->udp_last_so = &slirp->udb;
102 } else if (so == slirp->icmp_last_so) {
103 slirp->icmp_last_so = &slirp->icmp;
104 }
105 m_free(so->so_m);
106
107 if(so->so_next && so->so_prev)
108 remque(so); /* crashes if so is not in a queue */
109
110 if (so->so_tcpcb) {
111 free(so->so_tcpcb);
112 }
113 free(so);
114 }
115
116 size_t sopreprbuf(struct socket *so, struct iovec *iov, int *np)
117 {
118 int n, lss, total;
119 struct sbuf *sb = &so->so_snd;
120 int len = sb->sb_datalen - sb->sb_cc;
121 int mss = so->so_tcpcb->t_maxseg;
122
123 DEBUG_CALL("sopreprbuf");
124 DEBUG_ARG("so = %p", so);
125
126 if (len <= 0)
127 return 0;
128
129 iov[0].iov_base = sb->sb_wptr;
130 iov[1].iov_base = NULL;
131 iov[1].iov_len = 0;
132 if (sb->sb_wptr < sb->sb_rptr) {
133 iov[0].iov_len = sb->sb_rptr - sb->sb_wptr;
134 /* Should never succeed, but... */
135 if (iov[0].iov_len > len)
136 iov[0].iov_len = len;
137 if (iov[0].iov_len > mss)
138 iov[0].iov_len -= iov[0].iov_len%mss;
139 n = 1;
140 } else {
141 iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_wptr;
142 /* Should never succeed, but... */
143 if (iov[0].iov_len > len) iov[0].iov_len = len;
144 len -= iov[0].iov_len;
145 if (len) {
146 iov[1].iov_base = sb->sb_data;
147 iov[1].iov_len = sb->sb_rptr - sb->sb_data;
148 if(iov[1].iov_len > len)
149 iov[1].iov_len = len;
150 total = iov[0].iov_len + iov[1].iov_len;
151 if (total > mss) {
152 lss = total%mss;
153 if (iov[1].iov_len > lss) {
154 iov[1].iov_len -= lss;
155 n = 2;
156 } else {
157 lss -= iov[1].iov_len;
158 iov[0].iov_len -= lss;
159 n = 1;
160 }
161 } else
162 n = 2;
163 } else {
164 if (iov[0].iov_len > mss)
165 iov[0].iov_len -= iov[0].iov_len%mss;
166 n = 1;
167 }
168 }
169 if (np)
170 *np = n;
171
172 return iov[0].iov_len + (n - 1) * iov[1].iov_len;
173 }
174
175 /*
176 * Read from so's socket into sb_snd, updating all relevant sbuf fields
177 * NOTE: This will only be called if it is select()ed for reading, so
178 * a read() of 0 (or less) means it's disconnected
179 */
180 int
181 soread(struct socket *so)
182 {
183 int n, nn;
184 struct sbuf *sb = &so->so_snd;
185 struct iovec iov[2];
186
187 DEBUG_CALL("soread");
188 DEBUG_ARG("so = %p", so);
189
190 /*
191 * No need to check if there's enough room to read.
192 * soread wouldn't have been called if there weren't
193 */
194 sopreprbuf(so, iov, &n);
195
196 #ifdef HAVE_READV
197 nn = readv(so->s, (struct iovec *)iov, n);
198 DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn));
199 #else
200 nn = qemu_recv(so->s, iov[0].iov_base, iov[0].iov_len,0);
201 #endif
202 if (nn <= 0) {
203 if (nn < 0 && (errno == EINTR || errno == EAGAIN))
204 return 0;
205 else {
206 int err;
207 socklen_t slen = sizeof err;
208
209 err = errno;
210 if (nn == 0) {
211 getsockopt(so->s, SOL_SOCKET, SO_ERROR,
212 &err, &slen);
213 }
214
215 DEBUG_MISC((dfd, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn, errno,strerror(errno)));
216 sofcantrcvmore(so);
217
218 if (err == ECONNRESET || err == ECONNREFUSED
219 || err == ENOTCONN || err == EPIPE) {
220 tcp_drop(sototcpcb(so), err);
221 } else {
222 tcp_sockclosed(sototcpcb(so));
223 }
224 return -1;
225 }
226 }
227
228 #ifndef HAVE_READV
229 /*
230 * If there was no error, try and read the second time round
231 * We read again if n = 2 (ie, there's another part of the buffer)
232 * and we read as much as we could in the first read
233 * We don't test for <= 0 this time, because there legitimately
234 * might not be any more data (since the socket is non-blocking),
235 * a close will be detected on next iteration.
236 * A return of -1 won't (shouldn't) happen, since it didn't happen above
237 */
238 if (n == 2 && nn == iov[0].iov_len) {
239 int ret;
240 ret = qemu_recv(so->s, iov[1].iov_base, iov[1].iov_len,0);
241 if (ret > 0)
242 nn += ret;
243 }
244
245 DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn));
246 #endif
247
248 /* Update fields */
249 sb->sb_cc += nn;
250 sb->sb_wptr += nn;
251 if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen))
252 sb->sb_wptr -= sb->sb_datalen;
253 return nn;
254 }
255
256 int soreadbuf(struct socket *so, const char *buf, int size)
257 {
258 int n, nn, copy = size;
259 struct sbuf *sb = &so->so_snd;
260 struct iovec iov[2];
261
262 DEBUG_CALL("soreadbuf");
263 DEBUG_ARG("so = %p", so);
264
265 /*
266 * No need to check if there's enough room to read.
267 * soread wouldn't have been called if there weren't
268 */
269 if (sopreprbuf(so, iov, &n) < size)
270 goto err;
271
272 nn = MIN(iov[0].iov_len, copy);
273 memcpy(iov[0].iov_base, buf, nn);
274
275 copy -= nn;
276 buf += nn;
277
278 if (copy == 0)
279 goto done;
280
281 memcpy(iov[1].iov_base, buf, copy);
282
283 done:
284 /* Update fields */
285 sb->sb_cc += size;
286 sb->sb_wptr += size;
287 if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen))
288 sb->sb_wptr -= sb->sb_datalen;
289 return size;
290 err:
291
292 sofcantrcvmore(so);
293 tcp_sockclosed(sototcpcb(so));
294 fprintf(stderr, "soreadbuf buffer to small");
295 return -1;
296 }
297
298 /*
299 * Get urgent data
300 *
301 * When the socket is created, we set it SO_OOBINLINE,
302 * so when OOB data arrives, we soread() it and everything
303 * in the send buffer is sent as urgent data
304 */
305 int
306 sorecvoob(struct socket *so)
307 {
308 struct tcpcb *tp = sototcpcb(so);
309 int ret;
310
311 DEBUG_CALL("sorecvoob");
312 DEBUG_ARG("so = %p", so);
313
314 /*
315 * We take a guess at how much urgent data has arrived.
316 * In most situations, when urgent data arrives, the next
317 * read() should get all the urgent data. This guess will
318 * be wrong however if more data arrives just after the
319 * urgent data, or the read() doesn't return all the
320 * urgent data.
321 */
322 ret = soread(so);
323 if (ret > 0) {
324 tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
325 tp->t_force = 1;
326 tcp_output(tp);
327 tp->t_force = 0;
328 }
329
330 return ret;
331 }
332
333 /*
334 * Send urgent data
335 * There's a lot duplicated code here, but...
336 */
337 int
338 sosendoob(struct socket *so)
339 {
340 struct sbuf *sb = &so->so_rcv;
341 char buff[2048]; /* XXX Shouldn't be sending more oob data than this */
342
343 int n;
344
345 DEBUG_CALL("sosendoob");
346 DEBUG_ARG("so = %p", so);
347 DEBUG_ARG("sb->sb_cc = %d", sb->sb_cc);
348
349 if (so->so_urgc > 2048)
350 so->so_urgc = 2048; /* XXXX */
351
352 if (sb->sb_rptr < sb->sb_wptr) {
353 /* We can send it directly */
354 n = slirp_send(so, sb->sb_rptr, so->so_urgc, (MSG_OOB)); /* |MSG_DONTWAIT)); */
355 } else {
356 /*
357 * Since there's no sendv or sendtov like writev,
358 * we must copy all data to a linear buffer then
359 * send it all
360 */
361 uint32_t urgc = so->so_urgc;
362 int len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr;
363 if (len > urgc) {
364 len = urgc;
365 }
366 memcpy(buff, sb->sb_rptr, len);
367 urgc -= len;
368 if (urgc) {
369 n = sb->sb_wptr - sb->sb_data;
370 if (n > urgc) {
371 n = urgc;
372 }
373 memcpy((buff + len), sb->sb_data, n);
374 len += n;
375 }
376 n = slirp_send(so, buff, len, (MSG_OOB)); /* |MSG_DONTWAIT)); */
377 #ifdef DEBUG
378 if (n != len) {
379 DEBUG_ERROR((dfd, "Didn't send all data urgently XXXXX\n"));
380 }
381 #endif
382 }
383
384 if (n < 0) {
385 return n;
386 }
387 so->so_urgc -= n;
388 DEBUG_MISC((dfd, " ---2 sent %d bytes urgent data, %d urgent bytes left\n", n, so->so_urgc));
389
390 sb->sb_cc -= n;
391 sb->sb_rptr += n;
392 if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen))
393 sb->sb_rptr -= sb->sb_datalen;
394
395 return n;
396 }
397
398 /*
399 * Write data from so_rcv to so's socket,
400 * updating all sbuf field as necessary
401 */
402 int
403 sowrite(struct socket *so)
404 {
405 int n,nn;
406 struct sbuf *sb = &so->so_rcv;
407 int len = sb->sb_cc;
408 struct iovec iov[2];
409
410 DEBUG_CALL("sowrite");
411 DEBUG_ARG("so = %p", so);
412
413 if (so->so_urgc) {
414 uint32_t expected = so->so_urgc;
415 if (sosendoob(so) < expected) {
416 /* Treat a short write as a fatal error too,
417 * rather than continuing on and sending the urgent
418 * data as if it were non-urgent and leaving the
419 * so_urgc count wrong.
420 */
421 goto err_disconnected;
422 }
423 if (sb->sb_cc == 0)
424 return 0;
425 }
426
427 /*
428 * No need to check if there's something to write,
429 * sowrite wouldn't have been called otherwise
430 */
431
432 iov[0].iov_base = sb->sb_rptr;
433 iov[1].iov_base = NULL;
434 iov[1].iov_len = 0;
435 if (sb->sb_rptr < sb->sb_wptr) {
436 iov[0].iov_len = sb->sb_wptr - sb->sb_rptr;
437 /* Should never succeed, but... */
438 if (iov[0].iov_len > len) iov[0].iov_len = len;
439 n = 1;
440 } else {
441 iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr;
442 if (iov[0].iov_len > len) iov[0].iov_len = len;
443 len -= iov[0].iov_len;
444 if (len) {
445 iov[1].iov_base = sb->sb_data;
446 iov[1].iov_len = sb->sb_wptr - sb->sb_data;
447 if (iov[1].iov_len > len) iov[1].iov_len = len;
448 n = 2;
449 } else
450 n = 1;
451 }
452 /* Check if there's urgent data to send, and if so, send it */
453
454 #ifdef HAVE_READV
455 nn = writev(so->s, (const struct iovec *)iov, n);
456
457 DEBUG_MISC((dfd, " ... wrote nn = %d bytes\n", nn));
458 #else
459 nn = slirp_send(so, iov[0].iov_base, iov[0].iov_len,0);
460 #endif
461 /* This should never happen, but people tell me it does *shrug* */
462 if (nn < 0 && (errno == EAGAIN || errno == EINTR))
463 return 0;
464
465 if (nn <= 0) {
466 goto err_disconnected;
467 }
468
469 #ifndef HAVE_READV
470 if (n == 2 && nn == iov[0].iov_len) {
471 int ret;
472 ret = slirp_send(so, iov[1].iov_base, iov[1].iov_len,0);
473 if (ret > 0)
474 nn += ret;
475 }
476 DEBUG_MISC((dfd, " ... wrote nn = %d bytes\n", nn));
477 #endif
478
479 /* Update sbuf */
480 sb->sb_cc -= nn;
481 sb->sb_rptr += nn;
482 if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen))
483 sb->sb_rptr -= sb->sb_datalen;
484
485 /*
486 * If in DRAIN mode, and there's no more data, set
487 * it CANTSENDMORE
488 */
489 if ((so->so_state & SS_FWDRAIN) && sb->sb_cc == 0)
490 sofcantsendmore(so);
491
492 return nn;
493
494 err_disconnected:
495 DEBUG_MISC((dfd, " --- sowrite disconnected, so->so_state = %x, errno = %d\n",
496 so->so_state, errno));
497 sofcantsendmore(so);
498 tcp_sockclosed(sototcpcb(so));
499 return -1;
500 }
501
502 /*
503 * recvfrom() a UDP socket
504 */
505 void
506 sorecvfrom(struct socket *so)
507 {
508 struct sockaddr_storage addr;
509 struct sockaddr_storage saddr, daddr;
510 socklen_t addrlen = sizeof(struct sockaddr_storage);
511
512 DEBUG_CALL("sorecvfrom");
513 DEBUG_ARG("so = %p", so);
514
515 if (so->so_type == IPPROTO_ICMP) { /* This is a "ping" reply */
516 char buff[256];
517 int len;
518
519 len = recvfrom(so->s, buff, 256, 0,
520 (struct sockaddr *)&addr, &addrlen);
521 /* XXX Check if reply is "correct"? */
522
523 if(len == -1 || len == 0) {
524 u_char code=ICMP_UNREACH_PORT;
525
526 if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
527 else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;
528
529 DEBUG_MISC((dfd," udp icmp rx errno = %d-%s\n",
530 errno,strerror(errno)));
531 icmp_send_error(so->so_m, ICMP_UNREACH, code, 0, strerror(errno));
532 } else {
533 icmp_reflect(so->so_m);
534 so->so_m = NULL; /* Don't m_free() it again! */
535 }
536 /* No need for this socket anymore, udp_detach it */
537 udp_detach(so);
538 } else { /* A "normal" UDP packet */
539 struct mbuf *m;
540 int len;
541 #ifdef _WIN32
542 unsigned long n;
543 #else
544 int n;
545 #endif
546
547 m = m_get(so->slirp);
548 if (!m) {
549 return;
550 }
551 switch (so->so_ffamily) {
552 case AF_INET:
553 m->m_data += IF_MAXLINKHDR + sizeof(struct udpiphdr);
554 break;
555 case AF_INET6:
556 m->m_data += IF_MAXLINKHDR + sizeof(struct ip6)
557 + sizeof(struct udphdr);
558 break;
559 default:
560 g_assert_not_reached();
561 break;
562 }
563
564 /*
565 * XXX Shouldn't FIONREAD packets destined for port 53,
566 * but I don't know the max packet size for DNS lookups
567 */
568 len = M_FREEROOM(m);
569 /* if (so->so_fport != htons(53)) { */
570 ioctlsocket(so->s, FIONREAD, &n);
571
572 if (n > len) {
573 n = (m->m_data - m->m_dat) + m->m_len + n + 1;
574 m_inc(m, n);
575 len = M_FREEROOM(m);
576 }
577 /* } */
578
579 m->m_len = recvfrom(so->s, m->m_data, len, 0,
580 (struct sockaddr *)&addr, &addrlen);
581 DEBUG_MISC((dfd, " did recvfrom %d, errno = %d-%s\n",
582 m->m_len, errno,strerror(errno)));
583 if(m->m_len<0) {
584 /* Report error as ICMP */
585 switch (so->so_lfamily) {
586 uint8_t code;
587 case AF_INET:
588 code = ICMP_UNREACH_PORT;
589
590 if (errno == EHOSTUNREACH) {
591 code = ICMP_UNREACH_HOST;
592 } else if (errno == ENETUNREACH) {
593 code = ICMP_UNREACH_NET;
594 }
595
596 DEBUG_MISC((dfd, " rx error, tx icmp ICMP_UNREACH:%i\n", code));
597 icmp_send_error(so->so_m, ICMP_UNREACH, code, 0, strerror(errno));
598 break;
599 case AF_INET6:
600 code = ICMP6_UNREACH_PORT;
601
602 if (errno == EHOSTUNREACH) {
603 code = ICMP6_UNREACH_ADDRESS;
604 } else if (errno == ENETUNREACH) {
605 code = ICMP6_UNREACH_NO_ROUTE;
606 }
607
608 DEBUG_MISC((dfd, " rx error, tx icmp6 ICMP_UNREACH:%i\n", code));
609 icmp6_send_error(so->so_m, ICMP6_UNREACH, code);
610 break;
611 default:
612 g_assert_not_reached();
613 break;
614 }
615 m_free(m);
616 } else {
617 /*
618 * Hack: domain name lookup will be used the most for UDP,
619 * and since they'll only be used once there's no need
620 * for the 4 minute (or whatever) timeout... So we time them
621 * out much quicker (10 seconds for now...)
622 */
623 if (so->so_expire) {
624 if (so->so_fport == htons(53))
625 so->so_expire = curtime + SO_EXPIREFAST;
626 else
627 so->so_expire = curtime + SO_EXPIRE;
628 }
629
630 /*
631 * If this packet was destined for CTL_ADDR,
632 * make it look like that's where it came from
633 */
634 saddr = addr;
635 sotranslate_in(so, &saddr);
636 daddr = so->lhost.ss;
637
638 switch (so->so_ffamily) {
639 case AF_INET:
640 udp_output(so, m, (struct sockaddr_in *) &saddr,
641 (struct sockaddr_in *) &daddr,
642 so->so_iptos);
643 break;
644 case AF_INET6:
645 udp6_output(so, m, (struct sockaddr_in6 *) &saddr,
646 (struct sockaddr_in6 *) &daddr);
647 break;
648 default:
649 g_assert_not_reached();
650 break;
651 }
652 } /* rx error */
653 } /* if ping packet */
654 }
655
656 /*
657 * sendto() a socket
658 */
659 int
660 sosendto(struct socket *so, struct mbuf *m)
661 {
662 int ret;
663 struct sockaddr_storage addr;
664
665 DEBUG_CALL("sosendto");
666 DEBUG_ARG("so = %p", so);
667 DEBUG_ARG("m = %p", m);
668
669 addr = so->fhost.ss;
670 DEBUG_CALL(" sendto()ing)");
671 sotranslate_out(so, &addr);
672
673 /* Don't care what port we get */
674 ret = sendto(so->s, m->m_data, m->m_len, 0,
675 (struct sockaddr *)&addr, sockaddr_size(&addr));
676 if (ret < 0)
677 return -1;
678
679 /*
680 * Kill the socket if there's no reply in 4 minutes,
681 * but only if it's an expirable socket
682 */
683 if (so->so_expire)
684 so->so_expire = curtime + SO_EXPIRE;
685 so->so_state &= SS_PERSISTENT_MASK;
686 so->so_state |= SS_ISFCONNECTED; /* So that it gets select()ed */
687 return 0;
688 }
689
690 /*
691 * Listen for incoming TCP connections
692 */
693 struct socket *
694 tcp_listen(Slirp *slirp, uint32_t haddr, u_int hport, uint32_t laddr,
695 u_int lport, int flags)
696 {
697 struct sockaddr_in addr;
698 struct socket *so;
699 int s, opt = 1;
700 socklen_t addrlen = sizeof(addr);
701 memset(&addr, 0, addrlen);
702
703 DEBUG_CALL("tcp_listen");
704 DEBUG_ARG("haddr = %s", inet_ntoa((struct in_addr){.s_addr = haddr}));
705 DEBUG_ARG("hport = %d", ntohs(hport));
706 DEBUG_ARG("laddr = %s", inet_ntoa((struct in_addr){.s_addr = laddr}));
707 DEBUG_ARG("lport = %d", ntohs(lport));
708 DEBUG_ARG("flags = %x", flags);
709
710 so = socreate(slirp);
711 if (!so) {
712 return NULL;
713 }
714
715 /* Don't tcp_attach... we don't need so_snd nor so_rcv */
716 if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL) {
717 free(so);
718 return NULL;
719 }
720 insque(so, &slirp->tcb);
721
722 /*
723 * SS_FACCEPTONCE sockets must time out.
724 */
725 if (flags & SS_FACCEPTONCE)
726 so->so_tcpcb->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT*2;
727
728 so->so_state &= SS_PERSISTENT_MASK;
729 so->so_state |= (SS_FACCEPTCONN | flags);
730 so->so_lfamily = AF_INET;
731 so->so_lport = lport; /* Kept in network format */
732 so->so_laddr.s_addr = laddr; /* Ditto */
733
734 addr.sin_family = AF_INET;
735 addr.sin_addr.s_addr = haddr;
736 addr.sin_port = hport;
737
738 if (((s = qemu_socket(AF_INET,SOCK_STREAM,0)) < 0) ||
739 (socket_set_fast_reuse(s) < 0) ||
740 (bind(s,(struct sockaddr *)&addr, sizeof(addr)) < 0) ||
741 (listen(s,1) < 0)) {
742 int tmperrno = errno; /* Don't clobber the real reason we failed */
743
744 if (s >= 0) {
745 closesocket(s);
746 }
747 sofree(so);
748 /* Restore the real errno */
749 #ifdef _WIN32
750 WSASetLastError(tmperrno);
751 #else
752 errno = tmperrno;
753 #endif
754 return NULL;
755 }
756 qemu_setsockopt(s, SOL_SOCKET, SO_OOBINLINE, &opt, sizeof(int));
757 opt = 1;
758 qemu_setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(int));
759
760 getsockname(s,(struct sockaddr *)&addr,&addrlen);
761 so->so_ffamily = AF_INET;
762 so->so_fport = addr.sin_port;
763 if (addr.sin_addr.s_addr == 0 || addr.sin_addr.s_addr == loopback_addr.s_addr)
764 so->so_faddr = slirp->vhost_addr;
765 else
766 so->so_faddr = addr.sin_addr;
767
768 so->s = s;
769 return so;
770 }
771
772 /*
773 * Various session state calls
774 * XXX Should be #define's
775 * The socket state stuff needs work, these often get call 2 or 3
776 * times each when only 1 was needed
777 */
778 void
779 soisfconnecting(struct socket *so)
780 {
781 so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE|
782 SS_FCANTSENDMORE|SS_FWDRAIN);
783 so->so_state |= SS_ISFCONNECTING; /* Clobber other states */
784 }
785
786 void
787 soisfconnected(struct socket *so)
788 {
789 so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF);
790 so->so_state |= SS_ISFCONNECTED; /* Clobber other states */
791 }
792
793 static void
794 sofcantrcvmore(struct socket *so)
795 {
796 if ((so->so_state & SS_NOFDREF) == 0) {
797 shutdown(so->s,0);
798 }
799 so->so_state &= ~(SS_ISFCONNECTING);
800 if (so->so_state & SS_FCANTSENDMORE) {
801 so->so_state &= SS_PERSISTENT_MASK;
802 so->so_state |= SS_NOFDREF; /* Don't select it */
803 } else {
804 so->so_state |= SS_FCANTRCVMORE;
805 }
806 }
807
808 static void
809 sofcantsendmore(struct socket *so)
810 {
811 if ((so->so_state & SS_NOFDREF) == 0) {
812 shutdown(so->s,1); /* send FIN to fhost */
813 }
814 so->so_state &= ~(SS_ISFCONNECTING);
815 if (so->so_state & SS_FCANTRCVMORE) {
816 so->so_state &= SS_PERSISTENT_MASK;
817 so->so_state |= SS_NOFDREF; /* as above */
818 } else {
819 so->so_state |= SS_FCANTSENDMORE;
820 }
821 }
822
823 /*
824 * Set write drain mode
825 * Set CANTSENDMORE once all data has been write()n
826 */
827 void
828 sofwdrain(struct socket *so)
829 {
830 if (so->so_rcv.sb_cc)
831 so->so_state |= SS_FWDRAIN;
832 else
833 sofcantsendmore(so);
834 }
835
836 /*
837 * Translate addr in host addr when it is a virtual address
838 */
839 void sotranslate_out(struct socket *so, struct sockaddr_storage *addr)
840 {
841 Slirp *slirp = so->slirp;
842 struct sockaddr_in *sin = (struct sockaddr_in *)addr;
843 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr;
844
845 switch (addr->ss_family) {
846 case AF_INET:
847 if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) ==
848 slirp->vnetwork_addr.s_addr) {
849 /* It's an alias */
850 if (so->so_faddr.s_addr == slirp->vnameserver_addr.s_addr) {
851 if (get_dns_addr(&sin->sin_addr) < 0) {
852 sin->sin_addr = loopback_addr;
853 }
854 } else {
855 sin->sin_addr = loopback_addr;
856 }
857 }
858
859 DEBUG_MISC((dfd, " addr.sin_port=%d, "
860 "addr.sin_addr.s_addr=%.16s\n",
861 ntohs(sin->sin_port), inet_ntoa(sin->sin_addr)));
862 break;
863
864 case AF_INET6:
865 if (in6_equal_net(&so->so_faddr6, &slirp->vprefix_addr6,
866 slirp->vprefix_len)) {
867 if (in6_equal(&so->so_faddr6, &slirp->vnameserver_addr6)) {
868 uint32_t scope_id;
869 if (get_dns6_addr(&sin6->sin6_addr, &scope_id) >= 0) {
870 sin6->sin6_scope_id = scope_id;
871 } else {
872 sin6->sin6_addr = in6addr_loopback;
873 }
874 } else {
875 sin6->sin6_addr = in6addr_loopback;
876 }
877 }
878 break;
879
880 default:
881 break;
882 }
883 }
884
885 void sotranslate_in(struct socket *so, struct sockaddr_storage *addr)
886 {
887 Slirp *slirp = so->slirp;
888 struct sockaddr_in *sin = (struct sockaddr_in *)addr;
889 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr;
890
891 switch (addr->ss_family) {
892 case AF_INET:
893 if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) ==
894 slirp->vnetwork_addr.s_addr) {
895 uint32_t inv_mask = ~slirp->vnetwork_mask.s_addr;
896
897 if ((so->so_faddr.s_addr & inv_mask) == inv_mask) {
898 sin->sin_addr = slirp->vhost_addr;
899 } else if (sin->sin_addr.s_addr == loopback_addr.s_addr ||
900 so->so_faddr.s_addr != slirp->vhost_addr.s_addr) {
901 sin->sin_addr = so->so_faddr;
902 }
903 }
904 break;
905
906 case AF_INET6:
907 if (in6_equal_net(&so->so_faddr6, &slirp->vprefix_addr6,
908 slirp->vprefix_len)) {
909 if (in6_equal(&sin6->sin6_addr, &in6addr_loopback)
910 || !in6_equal(&so->so_faddr6, &slirp->vhost_addr6)) {
911 sin6->sin6_addr = so->so_faddr6;
912 }
913 }
914 break;
915
916 default:
917 break;
918 }
919 }
920
921 /*
922 * Translate connections from localhost to the real hostname
923 */
924 void sotranslate_accept(struct socket *so)
925 {
926 Slirp *slirp = so->slirp;
927
928 switch (so->so_ffamily) {
929 case AF_INET:
930 if (so->so_faddr.s_addr == INADDR_ANY ||
931 (so->so_faddr.s_addr & loopback_mask) ==
932 (loopback_addr.s_addr & loopback_mask)) {
933 so->so_faddr = slirp->vhost_addr;
934 }
935 break;
936
937 case AF_INET6:
938 if (in6_equal(&so->so_faddr6, &in6addr_any) ||
939 in6_equal(&so->so_faddr6, &in6addr_loopback)) {
940 so->so_faddr6 = slirp->vhost_addr6;
941 }
942 break;
943
944 default:
945 break;
946 }
947 }