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