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>
15 static void sofcantrcvmore(struct socket
*so
);
16 static void sofcantsendmore(struct socket
*so
);
27 solookup(head
, laddr
, lport
, faddr
, fport
)
36 for (so
= head
->so_next
; so
!= head
; so
= so
->so_next
) {
37 if (so
->so_lport
== lport
&&
38 so
->so_laddr
.s_addr
== laddr
.s_addr
&&
39 so
->so_faddr
.s_addr
== faddr
.s_addr
&&
40 so
->so_fport
== fport
)
45 return (struct socket
*)NULL
;
51 * Create a new socket, initialise the fields
52 * It is the responsibility of the caller to
53 * insque() it into the correct linked-list
60 so
= (struct socket
*)malloc(sizeof(struct socket
));
62 memset(so
, 0, sizeof(struct socket
));
63 so
->so_state
= SS_NOFDREF
;
70 * remque and free a socket, clobber cache
76 if (so
->so_emu
==EMU_RSH
&& so
->extra
) {
80 if (so
== tcp_last_so
)
82 else if (so
== udp_last_so
)
87 if(so
->so_next
&& so
->so_prev
)
88 remque(so
); /* crashes if so is not in a queue */
94 * Read from so's socket into sb_snd, updating all relevant sbuf fields
95 * NOTE: This will only be called if it is select()ed for reading, so
96 * a read() of 0 (or less) means it's disconnected
102 int n
, nn
, lss
, total
;
103 struct sbuf
*sb
= &so
->so_snd
;
104 int len
= sb
->sb_datalen
- sb
->sb_cc
;
106 int mss
= so
->so_tcpcb
->t_maxseg
;
108 DEBUG_CALL("soread");
109 DEBUG_ARG("so = %lx", (long )so
);
112 * No need to check if there's enough room to read.
113 * soread wouldn't have been called if there weren't
116 len
= sb
->sb_datalen
- sb
->sb_cc
;
118 iov
[0].iov_base
= sb
->sb_wptr
;
119 if (sb
->sb_wptr
< sb
->sb_rptr
) {
120 iov
[0].iov_len
= sb
->sb_rptr
- sb
->sb_wptr
;
121 /* Should never succeed, but... */
122 if (iov
[0].iov_len
> len
)
123 iov
[0].iov_len
= len
;
124 if (iov
[0].iov_len
> mss
)
125 iov
[0].iov_len
-= iov
[0].iov_len
%mss
;
128 iov
[0].iov_len
= (sb
->sb_data
+ sb
->sb_datalen
) - sb
->sb_wptr
;
129 /* Should never succeed, but... */
130 if (iov
[0].iov_len
> len
) iov
[0].iov_len
= len
;
131 len
-= iov
[0].iov_len
;
133 iov
[1].iov_base
= sb
->sb_data
;
134 iov
[1].iov_len
= sb
->sb_rptr
- sb
->sb_data
;
135 if(iov
[1].iov_len
> len
)
136 iov
[1].iov_len
= len
;
137 total
= iov
[0].iov_len
+ iov
[1].iov_len
;
140 if (iov
[1].iov_len
> lss
) {
141 iov
[1].iov_len
-= lss
;
144 lss
-= iov
[1].iov_len
;
145 iov
[0].iov_len
-= lss
;
151 if (iov
[0].iov_len
> mss
)
152 iov
[0].iov_len
-= iov
[0].iov_len
%mss
;
158 nn
= readv(so
->s
, (struct iovec
*)iov
, n
);
159 DEBUG_MISC((dfd
, " ... read nn = %d bytes\n", nn
));
161 nn
= recv(so
->s
, iov
[0].iov_base
, iov
[0].iov_len
,0);
164 if (nn
< 0 && (errno
== EINTR
|| errno
== EAGAIN
))
167 DEBUG_MISC((dfd
, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn
, errno
,strerror(errno
)));
169 tcp_sockclosed(sototcpcb(so
));
176 * If there was no error, try and read the second time round
177 * We read again if n = 2 (ie, there's another part of the buffer)
178 * and we read as much as we could in the first read
179 * We don't test for <= 0 this time, because there legitimately
180 * might not be any more data (since the socket is non-blocking),
181 * a close will be detected on next iteration.
182 * A return of -1 wont (shouldn't) happen, since it didn't happen above
184 if (n
== 2 && nn
== iov
[0].iov_len
) {
186 ret
= recv(so
->s
, iov
[1].iov_base
, iov
[1].iov_len
,0);
191 DEBUG_MISC((dfd
, " ... read nn = %d bytes\n", nn
));
197 if (sb
->sb_wptr
>= (sb
->sb_data
+ sb
->sb_datalen
))
198 sb
->sb_wptr
-= sb
->sb_datalen
;
205 * When the socket is created, we set it SO_OOBINLINE,
206 * so when OOB data arrives, we soread() it and everything
207 * in the send buffer is sent as urgent data
213 struct tcpcb
*tp
= sototcpcb(so
);
215 DEBUG_CALL("sorecvoob");
216 DEBUG_ARG("so = %lx", (long)so
);
219 * We take a guess at how much urgent data has arrived.
220 * In most situations, when urgent data arrives, the next
221 * read() should get all the urgent data. This guess will
222 * be wrong however if more data arrives just after the
223 * urgent data, or the read() doesn't return all the
227 tp
->snd_up
= tp
->snd_una
+ so
->so_snd
.sb_cc
;
235 * There's a lot duplicated code here, but...
241 struct sbuf
*sb
= &so
->so_rcv
;
242 char buff
[2048]; /* XXX Shouldn't be sending more oob data than this */
246 DEBUG_CALL("sosendoob");
247 DEBUG_ARG("so = %lx", (long)so
);
248 DEBUG_ARG("sb->sb_cc = %d", sb
->sb_cc
);
250 if (so
->so_urgc
> 2048)
251 so
->so_urgc
= 2048; /* XXXX */
253 if (sb
->sb_rptr
< sb
->sb_wptr
) {
254 /* We can send it directly */
255 n
= send(so
->s
, sb
->sb_rptr
, so
->so_urgc
, (MSG_OOB
)); /* |MSG_DONTWAIT)); */
258 DEBUG_MISC((dfd
, " --- sent %d bytes urgent data, %d urgent bytes left\n", n
, so
->so_urgc
));
261 * Since there's no sendv or sendtov like writev,
262 * we must copy all data to a linear buffer then
265 len
= (sb
->sb_data
+ sb
->sb_datalen
) - sb
->sb_rptr
;
266 if (len
> so
->so_urgc
) len
= so
->so_urgc
;
267 memcpy(buff
, sb
->sb_rptr
, len
);
270 n
= sb
->sb_wptr
- sb
->sb_data
;
271 if (n
> so
->so_urgc
) n
= so
->so_urgc
;
272 memcpy((buff
+ len
), sb
->sb_data
, n
);
276 n
= send(so
->s
, buff
, len
, (MSG_OOB
)); /* |MSG_DONTWAIT)); */
279 DEBUG_ERROR((dfd
, "Didn't send all data urgently XXXXX\n"));
281 DEBUG_MISC((dfd
, " ---2 sent %d bytes urgent data, %d urgent bytes left\n", n
, so
->so_urgc
));
286 if (sb
->sb_rptr
>= (sb
->sb_data
+ sb
->sb_datalen
))
287 sb
->sb_rptr
-= sb
->sb_datalen
;
293 * Write data from so_rcv to so's socket,
294 * updating all sbuf field as necessary
301 struct sbuf
*sb
= &so
->so_rcv
;
305 DEBUG_CALL("sowrite");
306 DEBUG_ARG("so = %lx", (long)so
);
315 * No need to check if there's something to write,
316 * sowrite wouldn't have been called otherwise
321 iov
[0].iov_base
= sb
->sb_rptr
;
322 if (sb
->sb_rptr
< sb
->sb_wptr
) {
323 iov
[0].iov_len
= sb
->sb_wptr
- sb
->sb_rptr
;
324 /* Should never succeed, but... */
325 if (iov
[0].iov_len
> len
) iov
[0].iov_len
= len
;
328 iov
[0].iov_len
= (sb
->sb_data
+ sb
->sb_datalen
) - sb
->sb_rptr
;
329 if (iov
[0].iov_len
> len
) iov
[0].iov_len
= len
;
330 len
-= iov
[0].iov_len
;
332 iov
[1].iov_base
= sb
->sb_data
;
333 iov
[1].iov_len
= sb
->sb_wptr
- sb
->sb_data
;
334 if (iov
[1].iov_len
> len
) iov
[1].iov_len
= len
;
339 /* Check if there's urgent data to send, and if so, send it */
342 nn
= writev(so
->s
, (const struct iovec
*)iov
, n
);
344 DEBUG_MISC((dfd
, " ... wrote nn = %d bytes\n", nn
));
346 nn
= send(so
->s
, iov
[0].iov_base
, iov
[0].iov_len
,0);
348 /* This should never happen, but people tell me it does *shrug* */
349 if (nn
< 0 && (errno
== EAGAIN
|| errno
== EINTR
))
353 DEBUG_MISC((dfd
, " --- sowrite disconnected, so->so_state = %x, errno = %d\n",
354 so
->so_state
, errno
));
356 tcp_sockclosed(sototcpcb(so
));
361 if (n
== 2 && nn
== iov
[0].iov_len
) {
363 ret
= send(so
->s
, iov
[1].iov_base
, iov
[1].iov_len
,0);
367 DEBUG_MISC((dfd
, " ... wrote nn = %d bytes\n", nn
));
373 if (sb
->sb_rptr
>= (sb
->sb_data
+ sb
->sb_datalen
))
374 sb
->sb_rptr
-= sb
->sb_datalen
;
377 * If in DRAIN mode, and there's no more data, set
380 if ((so
->so_state
& SS_FWDRAIN
) && sb
->sb_cc
== 0)
387 * recvfrom() a UDP socket
393 struct sockaddr_in addr
;
394 socklen_t addrlen
= sizeof(struct sockaddr_in
);
396 DEBUG_CALL("sorecvfrom");
397 DEBUG_ARG("so = %lx", (long)so
);
399 if (so
->so_type
== IPPROTO_ICMP
) { /* This is a "ping" reply */
403 len
= recvfrom(so
->s
, buff
, 256, 0,
404 (struct sockaddr
*)&addr
, &addrlen
);
405 /* XXX Check if reply is "correct"? */
407 if(len
== -1 || len
== 0) {
408 u_char code
=ICMP_UNREACH_PORT
;
410 if(errno
== EHOSTUNREACH
) code
=ICMP_UNREACH_HOST
;
411 else if(errno
== ENETUNREACH
) code
=ICMP_UNREACH_NET
;
413 DEBUG_MISC((dfd
," udp icmp rx errno = %d-%s\n",
414 errno
,strerror(errno
)));
415 icmp_error(so
->so_m
, ICMP_UNREACH
,code
, 0,strerror(errno
));
417 icmp_reflect(so
->so_m
);
418 so
->so_m
= 0; /* Don't m_free() it again! */
420 /* No need for this socket anymore, udp_detach it */
422 } else { /* A "normal" UDP packet */
426 if (!(m
= m_get())) return;
427 m
->m_data
+= IF_MAXLINKHDR
;
430 * XXX Shouldn't FIONREAD packets destined for port 53,
431 * but I don't know the max packet size for DNS lookups
434 /* if (so->so_fport != htons(53)) { */
435 ioctlsocket(so
->s
, FIONREAD
, &n
);
438 n
= (m
->m_data
- m
->m_dat
) + m
->m_len
+ n
+ 1;
444 m
->m_len
= recvfrom(so
->s
, m
->m_data
, len
, 0,
445 (struct sockaddr
*)&addr
, &addrlen
);
446 DEBUG_MISC((dfd
, " did recvfrom %d, errno = %d-%s\n",
447 m
->m_len
, errno
,strerror(errno
)));
449 u_char code
=ICMP_UNREACH_PORT
;
451 if(errno
== EHOSTUNREACH
) code
=ICMP_UNREACH_HOST
;
452 else if(errno
== ENETUNREACH
) code
=ICMP_UNREACH_NET
;
454 DEBUG_MISC((dfd
," rx error, tx icmp ICMP_UNREACH:%i\n", code
));
455 icmp_error(so
->so_m
, ICMP_UNREACH
,code
, 0,strerror(errno
));
459 * Hack: domain name lookup will be used the most for UDP,
460 * and since they'll only be used once there's no need
461 * for the 4 minute (or whatever) timeout... So we time them
462 * out much quicker (10 seconds for now...)
465 if (so
->so_fport
== htons(53))
466 so
->so_expire
= curtime
+ SO_EXPIREFAST
;
468 so
->so_expire
= curtime
+ SO_EXPIRE
;
471 /* if (m->m_len == len) {
472 * m_inc(m, MINCSIZE);
478 * If this packet was destined for CTL_ADDR,
479 * make it look like that's where it came from, done by udp_output
481 udp_output(so
, m
, &addr
);
483 } /* if ping packet */
495 struct sockaddr_in addr
;
497 DEBUG_CALL("sosendto");
498 DEBUG_ARG("so = %lx", (long)so
);
499 DEBUG_ARG("m = %lx", (long)m
);
501 addr
.sin_family
= AF_INET
;
502 if ((so
->so_faddr
.s_addr
& htonl(0xffffff00)) == special_addr
.s_addr
) {
504 switch(ntohl(so
->so_faddr
.s_addr
) & 0xff) {
506 addr
.sin_addr
= dns_addr
;
510 addr
.sin_addr
= loopback_addr
;
514 addr
.sin_addr
= so
->so_faddr
;
515 addr
.sin_port
= so
->so_fport
;
517 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
)));
519 /* Don't care what port we get */
520 ret
= sendto(so
->s
, m
->m_data
, m
->m_len
, 0,
521 (struct sockaddr
*)&addr
, sizeof (struct sockaddr
));
526 * Kill the socket if there's no reply in 4 minutes,
527 * but only if it's an expirable socket
530 so
->so_expire
= curtime
+ SO_EXPIRE
;
531 so
->so_state
= SS_ISFCONNECTED
; /* So that it gets select()ed */
536 * XXX This should really be tcp_listen
539 solisten(port
, laddr
, lport
, flags
)
545 struct sockaddr_in addr
;
548 socklen_t addrlen
= sizeof(addr
);
550 DEBUG_CALL("solisten");
551 DEBUG_ARG("port = %d", port
);
552 DEBUG_ARG("laddr = %x", laddr
);
553 DEBUG_ARG("lport = %d", lport
);
554 DEBUG_ARG("flags = %x", flags
);
556 if ((so
= socreate()) == NULL
) {
557 /* free(so); Not sofree() ??? free(NULL) == NOP */
561 /* Don't tcp_attach... we don't need so_snd nor so_rcv */
562 if ((so
->so_tcpcb
= tcp_newtcpcb(so
)) == NULL
) {
569 * SS_FACCEPTONCE sockets must time out.
571 if (flags
& SS_FACCEPTONCE
)
572 so
->so_tcpcb
->t_timer
[TCPT_KEEP
] = TCPTV_KEEP_INIT
*2;
574 so
->so_state
= (SS_FACCEPTCONN
|flags
);
575 so
->so_lport
= lport
; /* Kept in network format */
576 so
->so_laddr
.s_addr
= laddr
; /* Ditto */
578 addr
.sin_family
= AF_INET
;
579 addr
.sin_addr
.s_addr
= INADDR_ANY
;
580 addr
.sin_port
= port
;
582 if (((s
= socket(AF_INET
,SOCK_STREAM
,0)) < 0) ||
583 (setsockopt(s
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&opt
,sizeof(int)) < 0) ||
584 (bind(s
,(struct sockaddr
*)&addr
, sizeof(addr
)) < 0) ||
586 int tmperrno
= errno
; /* Don't clobber the real reason we failed */
590 /* Restore the real errno */
592 WSASetLastError(tmperrno
);
598 setsockopt(s
,SOL_SOCKET
,SO_OOBINLINE
,(char *)&opt
,sizeof(int));
600 getsockname(s
,(struct sockaddr
*)&addr
,&addrlen
);
601 so
->so_fport
= addr
.sin_port
;
602 if (addr
.sin_addr
.s_addr
== 0 || addr
.sin_addr
.s_addr
== loopback_addr
.s_addr
)
603 so
->so_faddr
= alias_addr
;
605 so
->so_faddr
= addr
.sin_addr
;
613 * Data is available in so_rcv
614 * Just write() the data to the socket
622 /* FD_CLR(so->s,&writefds); */
626 * Data has been freed in so_snd
627 * We have room for a read() if we want to
628 * For now, don't read, it'll be done in the main loop
639 * Various session state calls
640 * XXX Should be #define's
641 * The socket state stuff needs work, these often get call 2 or 3
642 * times each when only 1 was needed
646 register struct socket
*so
;
648 so
->so_state
&= ~(SS_NOFDREF
|SS_ISFCONNECTED
|SS_FCANTRCVMORE
|
649 SS_FCANTSENDMORE
|SS_FWDRAIN
);
650 so
->so_state
|= SS_ISFCONNECTING
; /* Clobber other states */
655 register struct socket
*so
;
657 so
->so_state
&= ~(SS_ISFCONNECTING
|SS_FWDRAIN
|SS_NOFDREF
);
658 so
->so_state
|= SS_ISFCONNECTED
; /* Clobber other states */
662 sofcantrcvmore(struct socket
*so
)
664 if ((so
->so_state
& SS_NOFDREF
) == 0) {
666 if(global_writefds
) {
667 FD_CLR(so
->s
,global_writefds
);
670 so
->so_state
&= ~(SS_ISFCONNECTING
);
671 if (so
->so_state
& SS_FCANTSENDMORE
)
672 so
->so_state
= SS_NOFDREF
; /* Don't select it */ /* XXX close() here as well? */
674 so
->so_state
|= SS_FCANTRCVMORE
;
678 sofcantsendmore(struct socket
*so
)
680 if ((so
->so_state
& SS_NOFDREF
) == 0) {
681 shutdown(so
->s
,1); /* send FIN to fhost */
682 if (global_readfds
) {
683 FD_CLR(so
->s
,global_readfds
);
686 FD_CLR(so
->s
,global_xfds
);
689 so
->so_state
&= ~(SS_ISFCONNECTING
);
690 if (so
->so_state
& SS_FCANTRCVMORE
)
691 so
->so_state
= SS_NOFDREF
; /* as above */
693 so
->so_state
|= SS_FCANTSENDMORE
;
697 soisfdisconnected(so
)
700 /* so->so_state &= ~(SS_ISFCONNECTING|SS_ISFCONNECTED); */
702 /* so->so_state = SS_ISFDISCONNECTED; */
704 * XXX Do nothing ... ?
709 * Set write drain mode
710 * Set CANTSENDMORE once all data has been write()n
716 if (so
->so_rcv
.sb_cc
)
717 so
->so_state
|= SS_FWDRAIN
;