2 * Copyright (c) 1995 Danny Gasparovski.
4 * Please read the file COPYRIGHT for the
5 * terms and conditions of the copyright.
8 #define WANT_SYS_IOCTL_H
12 #include <sys/filio.h>
14 #include "qemu-common.h"
16 static void sofcantrcvmore(struct socket
*so
);
17 static void sofcantsendmore(struct socket
*so
);
28 solookup(head
, laddr
, lport
, faddr
, fport
)
37 for (so
= head
->so_next
; so
!= head
; so
= so
->so_next
) {
38 if (so
->so_lport
== lport
&&
39 so
->so_laddr
.s_addr
== laddr
.s_addr
&&
40 so
->so_faddr
.s_addr
== faddr
.s_addr
&&
41 so
->so_fport
== fport
)
46 return (struct socket
*)NULL
;
52 * Create a new socket, initialise the fields
53 * It is the responsibility of the caller to
54 * insque() it into the correct linked-list
61 so
= (struct socket
*)malloc(sizeof(struct socket
));
63 memset(so
, 0, sizeof(struct socket
));
64 so
->so_state
= SS_NOFDREF
;
71 * remque and free a socket, clobber cache
77 if (so
->so_emu
==EMU_RSH
&& so
->extra
) {
81 if (so
== tcp_last_so
)
83 else if (so
== udp_last_so
)
88 if(so
->so_next
&& so
->so_prev
)
89 remque(so
); /* crashes if so is not in a queue */
95 * Read from so's socket into sb_snd, updating all relevant sbuf fields
96 * NOTE: This will only be called if it is select()ed for reading, so
97 * a read() of 0 (or less) means it's disconnected
103 int n
, nn
, lss
, total
;
104 struct sbuf
*sb
= &so
->so_snd
;
105 int len
= sb
->sb_datalen
- sb
->sb_cc
;
107 int mss
= so
->so_tcpcb
->t_maxseg
;
109 DEBUG_CALL("soread");
110 DEBUG_ARG("so = %lx", (long )so
);
113 * No need to check if there's enough room to read.
114 * soread wouldn't have been called if there weren't
117 len
= sb
->sb_datalen
- sb
->sb_cc
;
119 iov
[0].iov_base
= sb
->sb_wptr
;
120 iov
[1].iov_base
= NULL
;
122 if (sb
->sb_wptr
< sb
->sb_rptr
) {
123 iov
[0].iov_len
= sb
->sb_rptr
- sb
->sb_wptr
;
124 /* Should never succeed, but... */
125 if (iov
[0].iov_len
> len
)
126 iov
[0].iov_len
= len
;
127 if (iov
[0].iov_len
> mss
)
128 iov
[0].iov_len
-= iov
[0].iov_len
%mss
;
131 iov
[0].iov_len
= (sb
->sb_data
+ sb
->sb_datalen
) - sb
->sb_wptr
;
132 /* Should never succeed, but... */
133 if (iov
[0].iov_len
> len
) iov
[0].iov_len
= len
;
134 len
-= iov
[0].iov_len
;
136 iov
[1].iov_base
= sb
->sb_data
;
137 iov
[1].iov_len
= sb
->sb_rptr
- sb
->sb_data
;
138 if(iov
[1].iov_len
> len
)
139 iov
[1].iov_len
= len
;
140 total
= iov
[0].iov_len
+ iov
[1].iov_len
;
143 if (iov
[1].iov_len
> lss
) {
144 iov
[1].iov_len
-= lss
;
147 lss
-= iov
[1].iov_len
;
148 iov
[0].iov_len
-= lss
;
154 if (iov
[0].iov_len
> mss
)
155 iov
[0].iov_len
-= iov
[0].iov_len
%mss
;
161 nn
= readv(so
->s
, (struct iovec
*)iov
, n
);
162 DEBUG_MISC((dfd
, " ... read nn = %d bytes\n", nn
));
164 nn
= recv(so
->s
, iov
[0].iov_base
, iov
[0].iov_len
,0);
167 if (nn
< 0 && (errno
== EINTR
|| errno
== EAGAIN
))
170 DEBUG_MISC((dfd
, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn
, errno
,strerror(errno
)));
172 tcp_sockclosed(sototcpcb(so
));
179 * If there was no error, try and read the second time round
180 * We read again if n = 2 (ie, there's another part of the buffer)
181 * and we read as much as we could in the first read
182 * We don't test for <= 0 this time, because there legitimately
183 * might not be any more data (since the socket is non-blocking),
184 * a close will be detected on next iteration.
185 * A return of -1 wont (shouldn't) happen, since it didn't happen above
187 if (n
== 2 && nn
== iov
[0].iov_len
) {
189 ret
= recv(so
->s
, iov
[1].iov_base
, iov
[1].iov_len
,0);
194 DEBUG_MISC((dfd
, " ... read nn = %d bytes\n", nn
));
200 if (sb
->sb_wptr
>= (sb
->sb_data
+ sb
->sb_datalen
))
201 sb
->sb_wptr
-= sb
->sb_datalen
;
208 * When the socket is created, we set it SO_OOBINLINE,
209 * so when OOB data arrives, we soread() it and everything
210 * in the send buffer is sent as urgent data
216 struct tcpcb
*tp
= sototcpcb(so
);
218 DEBUG_CALL("sorecvoob");
219 DEBUG_ARG("so = %lx", (long)so
);
222 * We take a guess at how much urgent data has arrived.
223 * In most situations, when urgent data arrives, the next
224 * read() should get all the urgent data. This guess will
225 * be wrong however if more data arrives just after the
226 * urgent data, or the read() doesn't return all the
230 tp
->snd_up
= tp
->snd_una
+ so
->so_snd
.sb_cc
;
238 * There's a lot duplicated code here, but...
244 struct sbuf
*sb
= &so
->so_rcv
;
245 char buff
[2048]; /* XXX Shouldn't be sending more oob data than this */
249 DEBUG_CALL("sosendoob");
250 DEBUG_ARG("so = %lx", (long)so
);
251 DEBUG_ARG("sb->sb_cc = %d", sb
->sb_cc
);
253 if (so
->so_urgc
> 2048)
254 so
->so_urgc
= 2048; /* XXXX */
256 if (sb
->sb_rptr
< sb
->sb_wptr
) {
257 /* We can send it directly */
258 n
= send(so
->s
, sb
->sb_rptr
, so
->so_urgc
, (MSG_OOB
)); /* |MSG_DONTWAIT)); */
261 DEBUG_MISC((dfd
, " --- sent %d bytes urgent data, %d urgent bytes left\n", n
, so
->so_urgc
));
264 * Since there's no sendv or sendtov like writev,
265 * we must copy all data to a linear buffer then
268 len
= (sb
->sb_data
+ sb
->sb_datalen
) - sb
->sb_rptr
;
269 if (len
> so
->so_urgc
) len
= so
->so_urgc
;
270 memcpy(buff
, sb
->sb_rptr
, len
);
273 n
= sb
->sb_wptr
- sb
->sb_data
;
274 if (n
> so
->so_urgc
) n
= so
->so_urgc
;
275 memcpy((buff
+ len
), sb
->sb_data
, n
);
279 n
= send(so
->s
, buff
, len
, (MSG_OOB
)); /* |MSG_DONTWAIT)); */
282 DEBUG_ERROR((dfd
, "Didn't send all data urgently XXXXX\n"));
284 DEBUG_MISC((dfd
, " ---2 sent %d bytes urgent data, %d urgent bytes left\n", n
, so
->so_urgc
));
289 if (sb
->sb_rptr
>= (sb
->sb_data
+ sb
->sb_datalen
))
290 sb
->sb_rptr
-= sb
->sb_datalen
;
296 * Write data from so_rcv to so's socket,
297 * updating all sbuf field as necessary
304 struct sbuf
*sb
= &so
->so_rcv
;
308 DEBUG_CALL("sowrite");
309 DEBUG_ARG("so = %lx", (long)so
);
318 * No need to check if there's something to write,
319 * sowrite wouldn't have been called otherwise
324 iov
[0].iov_base
= sb
->sb_rptr
;
325 iov
[1].iov_base
= NULL
;
327 if (sb
->sb_rptr
< sb
->sb_wptr
) {
328 iov
[0].iov_len
= sb
->sb_wptr
- sb
->sb_rptr
;
329 /* Should never succeed, but... */
330 if (iov
[0].iov_len
> len
) iov
[0].iov_len
= len
;
333 iov
[0].iov_len
= (sb
->sb_data
+ sb
->sb_datalen
) - sb
->sb_rptr
;
334 if (iov
[0].iov_len
> len
) iov
[0].iov_len
= len
;
335 len
-= iov
[0].iov_len
;
337 iov
[1].iov_base
= sb
->sb_data
;
338 iov
[1].iov_len
= sb
->sb_wptr
- sb
->sb_data
;
339 if (iov
[1].iov_len
> len
) iov
[1].iov_len
= len
;
344 /* Check if there's urgent data to send, and if so, send it */
347 nn
= writev(so
->s
, (const struct iovec
*)iov
, n
);
349 DEBUG_MISC((dfd
, " ... wrote nn = %d bytes\n", nn
));
351 nn
= send(so
->s
, iov
[0].iov_base
, iov
[0].iov_len
,0);
353 /* This should never happen, but people tell me it does *shrug* */
354 if (nn
< 0 && (errno
== EAGAIN
|| errno
== EINTR
))
358 DEBUG_MISC((dfd
, " --- sowrite disconnected, so->so_state = %x, errno = %d\n",
359 so
->so_state
, errno
));
361 tcp_sockclosed(sototcpcb(so
));
366 if (n
== 2 && nn
== iov
[0].iov_len
) {
368 ret
= send(so
->s
, iov
[1].iov_base
, iov
[1].iov_len
,0);
372 DEBUG_MISC((dfd
, " ... wrote nn = %d bytes\n", nn
));
378 if (sb
->sb_rptr
>= (sb
->sb_data
+ sb
->sb_datalen
))
379 sb
->sb_rptr
-= sb
->sb_datalen
;
382 * If in DRAIN mode, and there's no more data, set
385 if ((so
->so_state
& SS_FWDRAIN
) && sb
->sb_cc
== 0)
392 * recvfrom() a UDP socket
398 struct sockaddr_in addr
;
399 socklen_t addrlen
= sizeof(struct sockaddr_in
);
401 DEBUG_CALL("sorecvfrom");
402 DEBUG_ARG("so = %lx", (long)so
);
404 if (so
->so_type
== IPPROTO_ICMP
) { /* This is a "ping" reply */
408 len
= recvfrom(so
->s
, buff
, 256, 0,
409 (struct sockaddr
*)&addr
, &addrlen
);
410 /* XXX Check if reply is "correct"? */
412 if(len
== -1 || len
== 0) {
413 u_char code
=ICMP_UNREACH_PORT
;
415 if(errno
== EHOSTUNREACH
) code
=ICMP_UNREACH_HOST
;
416 else if(errno
== ENETUNREACH
) code
=ICMP_UNREACH_NET
;
418 DEBUG_MISC((dfd
," udp icmp rx errno = %d-%s\n",
419 errno
,strerror(errno
)));
420 icmp_error(so
->so_m
, ICMP_UNREACH
,code
, 0,strerror(errno
));
422 icmp_reflect(so
->so_m
);
423 so
->so_m
= 0; /* Don't m_free() it again! */
425 /* No need for this socket anymore, udp_detach it */
427 } else { /* A "normal" UDP packet */
431 if (!(m
= m_get())) return;
432 m
->m_data
+= IF_MAXLINKHDR
;
435 * XXX Shouldn't FIONREAD packets destined for port 53,
436 * but I don't know the max packet size for DNS lookups
439 /* if (so->so_fport != htons(53)) { */
440 ioctlsocket(so
->s
, FIONREAD
, &n
);
443 n
= (m
->m_data
- m
->m_dat
) + m
->m_len
+ n
+ 1;
449 m
->m_len
= recvfrom(so
->s
, m
->m_data
, len
, 0,
450 (struct sockaddr
*)&addr
, &addrlen
);
451 DEBUG_MISC((dfd
, " did recvfrom %d, errno = %d-%s\n",
452 m
->m_len
, errno
,strerror(errno
)));
454 u_char code
=ICMP_UNREACH_PORT
;
456 if(errno
== EHOSTUNREACH
) code
=ICMP_UNREACH_HOST
;
457 else if(errno
== ENETUNREACH
) code
=ICMP_UNREACH_NET
;
459 DEBUG_MISC((dfd
," rx error, tx icmp ICMP_UNREACH:%i\n", code
));
460 icmp_error(so
->so_m
, ICMP_UNREACH
,code
, 0,strerror(errno
));
464 * Hack: domain name lookup will be used the most for UDP,
465 * and since they'll only be used once there's no need
466 * for the 4 minute (or whatever) timeout... So we time them
467 * out much quicker (10 seconds for now...)
470 if (so
->so_fport
== htons(53))
471 so
->so_expire
= curtime
+ SO_EXPIREFAST
;
473 so
->so_expire
= curtime
+ SO_EXPIRE
;
476 /* if (m->m_len == len) {
477 * m_inc(m, MINCSIZE);
483 * If this packet was destined for CTL_ADDR,
484 * make it look like that's where it came from, done by udp_output
486 udp_output(so
, m
, &addr
);
488 } /* if ping packet */
500 struct sockaddr_in addr
;
502 DEBUG_CALL("sosendto");
503 DEBUG_ARG("so = %lx", (long)so
);
504 DEBUG_ARG("m = %lx", (long)m
);
506 addr
.sin_family
= AF_INET
;
507 if ((so
->so_faddr
.s_addr
& htonl(0xffffff00)) == special_addr
.s_addr
) {
509 switch(ntohl(so
->so_faddr
.s_addr
) & 0xff) {
511 addr
.sin_addr
= dns_addr
;
515 addr
.sin_addr
= loopback_addr
;
519 addr
.sin_addr
= so
->so_faddr
;
520 addr
.sin_port
= so
->so_fport
;
522 DEBUG_MISC((dfd
, " sendto()ing, addr.sin_port=%d, addr.sin_addr.s_addr=%.16s\n", ntohs(addr
.sin_port
), inet_ntoa(addr
.sin_addr
)));
524 /* Don't care what port we get */
525 ret
= sendto(so
->s
, m
->m_data
, m
->m_len
, 0,
526 (struct sockaddr
*)&addr
, sizeof (struct sockaddr
));
531 * Kill the socket if there's no reply in 4 minutes,
532 * but only if it's an expirable socket
535 so
->so_expire
= curtime
+ SO_EXPIRE
;
536 so
->so_state
= SS_ISFCONNECTED
; /* So that it gets select()ed */
541 * XXX This should really be tcp_listen
544 solisten(port
, laddr
, lport
, flags
)
550 struct sockaddr_in addr
;
553 socklen_t addrlen
= sizeof(addr
);
555 DEBUG_CALL("solisten");
556 DEBUG_ARG("port = %d", port
);
557 DEBUG_ARG("laddr = %x", laddr
);
558 DEBUG_ARG("lport = %d", lport
);
559 DEBUG_ARG("flags = %x", flags
);
561 if ((so
= socreate()) == NULL
) {
562 /* free(so); Not sofree() ??? free(NULL) == NOP */
566 /* Don't tcp_attach... we don't need so_snd nor so_rcv */
567 if ((so
->so_tcpcb
= tcp_newtcpcb(so
)) == NULL
) {
574 * SS_FACCEPTONCE sockets must time out.
576 if (flags
& SS_FACCEPTONCE
)
577 so
->so_tcpcb
->t_timer
[TCPT_KEEP
] = TCPTV_KEEP_INIT
*2;
579 so
->so_state
= (SS_FACCEPTCONN
|flags
);
580 so
->so_lport
= lport
; /* Kept in network format */
581 so
->so_laddr
.s_addr
= laddr
; /* Ditto */
583 addr
.sin_family
= AF_INET
;
584 addr
.sin_addr
.s_addr
= INADDR_ANY
;
585 addr
.sin_port
= port
;
587 if (((s
= socket(AF_INET
,SOCK_STREAM
,0)) < 0) ||
588 (setsockopt(s
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&opt
,sizeof(int)) < 0) ||
589 (bind(s
,(struct sockaddr
*)&addr
, sizeof(addr
)) < 0) ||
591 int tmperrno
= errno
; /* Don't clobber the real reason we failed */
595 /* Restore the real errno */
597 WSASetLastError(tmperrno
);
603 setsockopt(s
,SOL_SOCKET
,SO_OOBINLINE
,(char *)&opt
,sizeof(int));
605 getsockname(s
,(struct sockaddr
*)&addr
,&addrlen
);
606 so
->so_fport
= addr
.sin_port
;
607 if (addr
.sin_addr
.s_addr
== 0 || addr
.sin_addr
.s_addr
== loopback_addr
.s_addr
)
608 so
->so_faddr
= alias_addr
;
610 so
->so_faddr
= addr
.sin_addr
;
618 * Data is available in so_rcv
619 * Just write() the data to the socket
627 /* FD_CLR(so->s,&writefds); */
631 * Data has been freed in so_snd
632 * We have room for a read() if we want to
633 * For now, don't read, it'll be done in the main loop
644 * Various session state calls
645 * XXX Should be #define's
646 * The socket state stuff needs work, these often get call 2 or 3
647 * times each when only 1 was needed
651 register struct socket
*so
;
653 so
->so_state
&= ~(SS_NOFDREF
|SS_ISFCONNECTED
|SS_FCANTRCVMORE
|
654 SS_FCANTSENDMORE
|SS_FWDRAIN
);
655 so
->so_state
|= SS_ISFCONNECTING
; /* Clobber other states */
660 register struct socket
*so
;
662 so
->so_state
&= ~(SS_ISFCONNECTING
|SS_FWDRAIN
|SS_NOFDREF
);
663 so
->so_state
|= SS_ISFCONNECTED
; /* Clobber other states */
667 sofcantrcvmore(struct socket
*so
)
669 if ((so
->so_state
& SS_NOFDREF
) == 0) {
671 if(global_writefds
) {
672 FD_CLR(so
->s
,global_writefds
);
675 so
->so_state
&= ~(SS_ISFCONNECTING
);
676 if (so
->so_state
& SS_FCANTSENDMORE
)
677 so
->so_state
= SS_NOFDREF
; /* Don't select it */ /* XXX close() here as well? */
679 so
->so_state
|= SS_FCANTRCVMORE
;
683 sofcantsendmore(struct socket
*so
)
685 if ((so
->so_state
& SS_NOFDREF
) == 0) {
686 shutdown(so
->s
,1); /* send FIN to fhost */
687 if (global_readfds
) {
688 FD_CLR(so
->s
,global_readfds
);
691 FD_CLR(so
->s
,global_xfds
);
694 so
->so_state
&= ~(SS_ISFCONNECTING
);
695 if (so
->so_state
& SS_FCANTRCVMORE
)
696 so
->so_state
= SS_NOFDREF
; /* as above */
698 so
->so_state
|= SS_FCANTSENDMORE
;
702 soisfdisconnected(so
)
705 /* so->so_state &= ~(SS_ISFCONNECTING|SS_ISFCONNECTED); */
707 /* so->so_state = SS_ISFDISCONNECTED; */
709 * XXX Do nothing ... ?
714 * Set write drain mode
715 * Set CANTSENDMORE once all data has been write()n
721 if (so
->so_rcv
.sb_cc
)
722 so
->so_state
|= SS_FWDRAIN
;