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#define WANT_SYS_IOCTL_H
9#include "qemu-common.h"
10#include <slirp.h>
11#include "ip_icmp.h"
12#include "main.h"
13#ifdef __sun__
14#include <sys/filio.h>
15#endif
16#define  SLIRP_COMPILATION 1
17#include "android/sockets.h"
18#include "proxy_common.h"
19
20static void sofcantrcvmore(struct socket *so);
21static void sofcantsendmore(struct socket *so);
22
23#if 0
24static void
25so_init()
26{
27	/* Nothing yet */
28}
29#endif
30
31struct socket *
32solookup(struct socket *head, uint32_t laddr, u_int lport,
33         uint32_t faddr, u_int fport)
34{
35	struct socket *so;
36
37	for (so = head->so_next; so != head; so = so->so_next) {
38		if (so->so_laddr_port == lport &&
39		    so->so_laddr_ip   == laddr &&
40		    so->so_faddr_ip   == faddr &&
41		    so->so_faddr_port == fport)
42		   break;
43	}
44
45	if (so == head)
46	   return (struct socket *)NULL;
47	return so;
48
49}
50
51/*
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
55 */
56struct socket *
57socreate(void)
58{
59  struct socket *so;
60
61  so = (struct socket *)malloc(sizeof(struct socket));
62  if(so) {
63    memset(so, 0, sizeof(struct socket));
64    so->so_state = SS_NOFDREF;
65    so->s = -1;
66  }
67  return(so);
68}
69
70/*
71 * remque and free a socket, clobber cache
72 */
73void
74sofree(struct socket *so)
75{
76  if (so->so_state & SS_PROXIFIED)
77    proxy_manager_del(so);
78
79  if (so->so_emu==EMU_RSH && so->extra) {
80	sofree(so->extra);
81	so->extra=NULL;
82  }
83  if (so == tcp_last_so)
84    tcp_last_so = &tcb;
85  else if (so == udp_last_so)
86    udp_last_so = &udb;
87
88  m_free(so->so_m);
89
90  if(so->so_next && so->so_prev)
91    remque(so);  /* crashes if so is not in a queue */
92
93  free(so);
94}
95
96size_t sopreprbuf(struct socket *so, struct iovec *iov, int *np)
97{
98	int n, lss, total;
99	struct sbuf *sb = &so->so_snd;
100	int len = sb->sb_datalen - sb->sb_cc;
101	int mss = so->so_tcpcb->t_maxseg;
102
103	DEBUG_CALL("sopreprbuf");
104	DEBUG_ARG("so = %lx", (long )so);
105
106	len = sb->sb_datalen - sb->sb_cc;
107
108	if (len <= 0)
109		return 0;
110
111	iov[0].iov_base = sb->sb_wptr;
112        iov[1].iov_base = NULL;
113        iov[1].iov_len = 0;
114	if (sb->sb_wptr < sb->sb_rptr) {
115		iov[0].iov_len = sb->sb_rptr - sb->sb_wptr;
116		/* Should never succeed, but... */
117		if (iov[0].iov_len > len)
118		   iov[0].iov_len = len;
119		if (iov[0].iov_len > mss)
120		   iov[0].iov_len -= iov[0].iov_len%mss;
121		n = 1;
122	} else {
123		iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_wptr;
124		/* Should never succeed, but... */
125		if (iov[0].iov_len > len) iov[0].iov_len = len;
126		len -= iov[0].iov_len;
127		if (len) {
128			iov[1].iov_base = sb->sb_data;
129			iov[1].iov_len = sb->sb_rptr - sb->sb_data;
130			if(iov[1].iov_len > len)
131			   iov[1].iov_len = len;
132			total = iov[0].iov_len + iov[1].iov_len;
133			if (total > mss) {
134				lss = total%mss;
135				if (iov[1].iov_len > lss) {
136					iov[1].iov_len -= lss;
137					n = 2;
138				} else {
139					lss -= iov[1].iov_len;
140					iov[0].iov_len -= lss;
141					n = 1;
142				}
143			} else
144				n = 2;
145		} else {
146			if (iov[0].iov_len > mss)
147			   iov[0].iov_len -= iov[0].iov_len%mss;
148			n = 1;
149		}
150	}
151	if (np)
152		*np = n;
153
154	return iov[0].iov_len + (n - 1) * iov[1].iov_len;
155}
156
157/*
158 * Read from so's socket into sb_snd, updating all relevant sbuf fields
159 * NOTE: This will only be called if it is select()ed for reading, so
160 * a read() of 0 (or less) means it's disconnected
161 */
162int
163soread(struct socket *so)
164{
165	int n, nn;
166	struct sbuf *sb = &so->so_snd;
167	struct iovec iov[2];
168
169	DEBUG_CALL("soread");
170	DEBUG_ARG("so = %lx", (long )so);
171
172	/*
173	 * No need to check if there's enough room to read.
174	 * soread wouldn't have been called if there weren't
175	 */
176	sopreprbuf(so, iov, &n);
177
178#ifdef HAVE_READV
179	nn = readv(so->s, (struct iovec *)iov, n);
180	DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn));
181#else
182	nn = socket_recv(so->s, iov[0].iov_base, iov[0].iov_len);
183#endif
184	if (nn <= 0) {
185		if (nn < 0 && (errno == EINTR || errno == EAGAIN))
186			return 0;
187		else {
188			DEBUG_MISC((dfd, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn, errno,errno_str));
189			sofcantrcvmore(so);
190			tcp_sockclosed(sototcpcb(so));
191			return -1;
192		}
193	}
194
195#ifndef HAVE_READV
196	/*
197	 * If there was no error, try and read the second time round
198	 * We read again if n = 2 (ie, there's another part of the buffer)
199	 * and we read as much as we could in the first read
200	 * We don't test for <= 0 this time, because there legitimately
201	 * might not be any more data (since the socket is non-blocking),
202	 * a close will be detected on next iteration.
203	 * A return of -1 wont (shouldn't) happen, since it didn't happen above
204	 */
205	if (n == 2 && nn == iov[0].iov_len) {
206            int ret;
207            ret = socket_recv(so->s, iov[1].iov_base, iov[1].iov_len);
208            if (ret > 0)
209                nn += ret;
210        }
211
212	DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn));
213#endif
214
215	/* Update fields */
216	sb->sb_cc += nn;
217	sb->sb_wptr += nn;
218	if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen))
219		sb->sb_wptr -= sb->sb_datalen;
220	return nn;
221}
222
223int soreadbuf(struct socket *so, const char *buf, int size)
224{
225    int n, nn, copy = size;
226	struct sbuf *sb = &so->so_snd;
227	struct iovec iov[2];
228
229	DEBUG_CALL("soreadbuf");
230	DEBUG_ARG("so = %lx", (long )so);
231
232	/*
233	 * No need to check if there's enough room to read.
234	 * soread wouldn't have been called if there weren't
235	 */
236	if (sopreprbuf(so, iov, &n) < size)
237        goto err;
238
239    nn = MIN(iov[0].iov_len, copy);
240    memcpy(iov[0].iov_base, buf, nn);
241
242    copy -= nn;
243    buf += nn;
244
245    if (copy == 0)
246        goto done;
247
248    memcpy(iov[1].iov_base, buf, copy);
249
250done:
251    /* Update fields */
252	sb->sb_cc += size;
253	sb->sb_wptr += size;
254	if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen))
255		sb->sb_wptr -= sb->sb_datalen;
256    return size;
257err:
258
259    sofcantrcvmore(so);
260    tcp_sockclosed(sototcpcb(so));
261    fprintf(stderr, "soreadbuf buffer to small");
262    return -1;
263}
264
265/*
266 * Get urgent data
267 *
268 * When the socket is created, we set it SO_OOBINLINE,
269 * so when OOB data arrives, we soread() it and everything
270 * in the send buffer is sent as urgent data
271 */
272void
273sorecvoob(struct socket *so)
274{
275	struct tcpcb *tp = sototcpcb(so);
276
277	DEBUG_CALL("sorecvoob");
278	DEBUG_ARG("so = %lx", (long)so);
279
280	/*
281	 * We take a guess at how much urgent data has arrived.
282	 * In most situations, when urgent data arrives, the next
283	 * read() should get all the urgent data.  This guess will
284	 * be wrong however if more data arrives just after the
285	 * urgent data, or the read() doesn't return all the
286	 * urgent data.
287	 */
288	soread(so);
289	tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
290	tp->t_force = 1;
291	tcp_output(tp);
292	tp->t_force = 0;
293}
294
295/*
296 * Send urgent data
297 * There's a lot duplicated code here, but...
298 */
299int
300sosendoob(struct socket *so)
301{
302	struct sbuf *sb = &so->so_rcv;
303	char buff[2048]; /* XXX Shouldn't be sending more oob data than this */
304
305	int n, len;
306
307	DEBUG_CALL("sosendoob");
308	DEBUG_ARG("so = %lx", (long)so);
309	DEBUG_ARG("sb->sb_cc = %d", sb->sb_cc);
310
311	if (so->so_urgc > 2048)
312	   so->so_urgc = 2048; /* XXXX */
313
314	if (sb->sb_rptr < sb->sb_wptr) {
315		/* We can send it directly */
316		n = socket_send_oob(so->s, sb->sb_rptr, so->so_urgc); /* |MSG_DONTWAIT)); */
317		so->so_urgc -= n;
318
319		DEBUG_MISC((dfd, " --- sent %d bytes urgent data, %d urgent bytes left\n", n, so->so_urgc));
320	} else {
321		/*
322		 * Since there's no sendv or sendtov like writev,
323		 * we must copy all data to a linear buffer then
324		 * send it all
325		 */
326		len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr;
327		if (len > so->so_urgc) len = so->so_urgc;
328		memcpy(buff, sb->sb_rptr, len);
329		so->so_urgc -= len;
330		if (so->so_urgc) {
331			n = sb->sb_wptr - sb->sb_data;
332			if (n > so->so_urgc) n = so->so_urgc;
333			memcpy((buff + len), sb->sb_data, n);
334			so->so_urgc -= n;
335			len += n;
336		}
337		n = socket_send_oob(so->s, buff, len); /* |MSG_DONTWAIT)); */
338#ifdef DEBUG
339		if (n != len)
340		   DEBUG_ERROR((dfd, "Didn't send all data urgently XXXXX\n"));
341#endif
342		DEBUG_MISC((dfd, " ---2 sent %d bytes urgent data, %d urgent bytes left\n", n, so->so_urgc));
343	}
344
345	sb->sb_cc -= n;
346	sb->sb_rptr += n;
347	if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen))
348		sb->sb_rptr -= sb->sb_datalen;
349
350	return n;
351}
352
353/*
354 * Write data from so_rcv to so's socket,
355 * updating all sbuf field as necessary
356 */
357int
358sowrite(struct socket *so)
359{
360	int  n,nn;
361	struct sbuf *sb = &so->so_rcv;
362	int len = sb->sb_cc;
363	struct iovec iov[2];
364
365	DEBUG_CALL("sowrite");
366	DEBUG_ARG("so = %lx", (long)so);
367
368	if (so->so_urgc) {
369		sosendoob(so);
370		if (sb->sb_cc == 0)
371			return 0;
372	}
373
374	/*
375	 * No need to check if there's something to write,
376	 * sowrite wouldn't have been called otherwise
377	 */
378
379        len = sb->sb_cc;
380
381	iov[0].iov_base = sb->sb_rptr;
382        iov[1].iov_base = NULL;
383        iov[1].iov_len = 0;
384	if (sb->sb_rptr < sb->sb_wptr) {
385		iov[0].iov_len = sb->sb_wptr - sb->sb_rptr;
386		/* Should never succeed, but... */
387		if (iov[0].iov_len > len) iov[0].iov_len = len;
388		n = 1;
389	} else {
390		iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr;
391		if (iov[0].iov_len > len) iov[0].iov_len = len;
392		len -= iov[0].iov_len;
393		if (len) {
394			iov[1].iov_base = sb->sb_data;
395			iov[1].iov_len = sb->sb_wptr - sb->sb_data;
396			if (iov[1].iov_len > len) iov[1].iov_len = len;
397			n = 2;
398		} else
399			n = 1;
400	}
401	/* Check if there's urgent data to send, and if so, send it */
402
403#ifdef HAVE_READV
404	nn = writev(so->s, (const struct iovec *)iov, n);
405
406	DEBUG_MISC((dfd, "  ... wrote nn = %d bytes\n", nn));
407#else
408	nn = socket_send(so->s, iov[0].iov_base, iov[0].iov_len);
409#endif
410	/* This should never happen, but people tell me it does *shrug* */
411	if (nn < 0 && (errno == EAGAIN || errno == EINTR))
412		return 0;
413
414	if (nn <= 0) {
415		DEBUG_MISC((dfd, " --- sowrite disconnected, so->so_state = %x, errno = %d\n",
416			so->so_state, errno));
417		sofcantsendmore(so);
418		tcp_sockclosed(sototcpcb(so));
419		return -1;
420	}
421
422#ifndef HAVE_READV
423	if (n == 2 && nn == iov[0].iov_len) {
424            int ret;
425            ret = socket_send(so->s, iov[1].iov_base, iov[1].iov_len);
426            if (ret > 0)
427                nn += ret;
428        }
429        DEBUG_MISC((dfd, "  ... wrote nn = %d bytes\n", nn));
430#endif
431
432	/* Update sbuf */
433	sb->sb_cc -= nn;
434	sb->sb_rptr += nn;
435	if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen))
436		sb->sb_rptr -= sb->sb_datalen;
437
438	/*
439	 * If in DRAIN mode, and there's no more data, set
440	 * it CANTSENDMORE
441	 */
442	if ((so->so_state & SS_FWDRAIN) && sb->sb_cc == 0)
443		sofcantsendmore(so);
444
445	return nn;
446}
447
448/*
449 * recvfrom() a UDP socket
450 */
451void
452sorecvfrom(struct socket *so)
453{
454        SockAddress  addr;
455
456	DEBUG_CALL("sorecvfrom");
457	DEBUG_ARG("so = %lx", (long)so);
458
459	if (so->so_type == IPPROTO_ICMP) {   /* This is a "ping" reply */
460	  char buff[256];
461	  int len;
462
463	  len = socket_recvfrom(so->s, buff, 256, &addr);
464	  /* XXX Check if reply is "correct"? */
465
466	  if(len == -1 || len == 0) {
467	    u_char code=ICMP_UNREACH_PORT;
468
469	    if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
470	    else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;
471
472	    DEBUG_MISC((dfd," udp icmp rx errno = %d-%s\n",
473			errno,errno_str));
474	    icmp_error(so->so_m, ICMP_UNREACH,code, 0,errno_str);
475	  } else {
476	    icmp_reflect(so->so_m);
477	    so->so_m = 0; /* Don't mbuf_free() it again! */
478	  }
479	  /* No need for this socket anymore, udp_detach it */
480	  udp_detach(so);
481	} else {                            	/* A "normal" UDP packet */
482	  struct mbuf *m;
483          int len;
484		  int n;
485
486	  if (!(m = m_get())) return;
487	  m->m_data += IF_MAXLINKHDR;
488
489	  /*
490	   * XXX Shouldn't FIONREAD packets destined for port 53,
491	   * but I don't know the max packet size for DNS lookups
492	   */
493	  len = M_FREEROOM(m);
494	  /* if (so->so_fport != htons(53)) { */
495	  n = socket_can_read(so->s);
496
497	  if (n > len) {
498	    n = (m->m_data - m->m_dat) + m->m_len + n + 1;
499	    m_inc(m, n);
500	    len = M_FREEROOM(m);
501	  }
502	  /* } */
503
504	  m->m_len = socket_recvfrom(so->s, m->m_data, len, &addr);
505	  DEBUG_MISC((dfd, " did recvfrom %d, errno = %d-%s\n",
506		      m->m_len, errno,errno_str));
507	  if(m->m_len<0) {
508	    u_char code=ICMP_UNREACH_PORT;
509
510	    if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
511	    else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;
512
513	    DEBUG_MISC((dfd," rx error, tx icmp ICMP_UNREACH:%i\n", code));
514	    icmp_error(so->so_m, ICMP_UNREACH,code, 0,errno_str);
515	    m_free(m);
516	  } else {
517	  /*
518	   * Hack: domain name lookup will be used the most for UDP,
519	   * and since they'll only be used once there's no need
520	   * for the 4 minute (or whatever) timeout... So we time them
521	   * out much quicker (10 seconds  for now...)
522	   */
523	    if (so->so_expire) {
524	      if (so->so_faddr_port == 53)
525		so->so_expire = curtime + SO_EXPIREFAST;
526	      else
527		so->so_expire = curtime + SO_EXPIRE;
528	    }
529
530	    /*		if (m->m_len == len) {
531	     *			m_inc(m, MINCSIZE);
532	     *			m->m_len = 0;
533	     *		}
534	     */
535
536	    /*
537	     * If this packet was destined for CTL_ADDR,
538	     * make it look like that's where it came from, done by udp_output
539	     */
540	    udp_output_(so, m, &addr);
541	  } /* rx error */
542	} /* if ping packet */
543}
544
545/*
546 * sendto() a socket
547 */
548int
549sosendto(struct socket *so, struct mbuf *m)
550{
551	int ret;
552    SockAddress   addr;
553    uint32_t      addr_ip;
554    uint16_t      addr_port;
555
556	DEBUG_CALL("sosendto");
557	DEBUG_ARG("so = %lx", (long)so);
558	DEBUG_ARG("m = %lx", (long)m);
559
560	if ((so->so_faddr_ip & 0xffffff00) == special_addr_ip) {
561        /* It's an alias */
562      	int  low = so->so_faddr_ip & 0xff;
563
564        if ( CTL_IS_DNS(low) )
565            addr_ip = dns_addr[low - CTL_DNS];
566        else
567            addr_ip = loopback_addr_ip;
568	} else
569	    addr_ip = so->so_faddr_ip;
570
571	addr_port = so->so_faddr_port;
572
573	/*
574	 * test for generic forwarding; this function replaces the arguments
575	 * only on success
576	 */
577	unsigned long faddr = addr_ip;
578        int fport = addr_port;
579
580	if (slirp_should_net_forward(faddr, fport, &faddr, &fport)) {
581      time_t timestamp = time(NULL);
582      slirp_drop_log(
583	       "Redirected UDP: src: 0x%08lx:0x%04x org dst: 0x%08lx:0x%04x "
584	       "new dst: 0x%08lx:0x%04x %ld\n",
585	        so->so_laddr_ip, so->so_laddr_port,
586	        addr_ip, addr_port,
587	        faddr, fport, timestamp
588	    );
589	}
590	addr_ip = faddr;
591	addr_port = fport;
592
593
594        sock_address_init_inet(&addr, addr_ip, addr_port);
595
596	DEBUG_MISC((dfd, " sendto()ing, addr.sin_port=%d, addr.sin_addr.s_addr=%08x\n", addr_port, addr_ip));
597
598	/* Don't care what port we get */
599	ret = socket_sendto(so->s, m->m_data, m->m_len,&addr);
600	if (ret < 0)
601		return -1;
602
603	/*
604	 * Kill the socket if there's no reply in 4 minutes,
605	 * but only if it's an expirable socket
606	 */
607	if (so->so_expire)
608		so->so_expire = curtime + SO_EXPIRE;
609	so->so_state = SS_ISFCONNECTED; /* So that it gets select()ed */
610	return 0;
611}
612
613/*
614 * XXX This should really be tcp_listen
615 */
616struct socket *
617solisten(u_int port, u_int32_t laddr, u_int lport, int flags)
618{
619	SockAddress  addr;
620	uint32_t     addr_ip;
621	struct socket *so;
622	int s;
623
624	DEBUG_CALL("solisten");
625	DEBUG_ARG("port = %d", port);
626	DEBUG_ARG("laddr = %x", laddr);
627	DEBUG_ARG("lport = %d", lport);
628	DEBUG_ARG("flags = %x", flags);
629
630	if ((so = socreate()) == NULL) {
631	  /* free(so);      Not sofree() ??? free(NULL) == NOP */
632	  return NULL;
633	}
634
635	/* Don't tcp_attach... we don't need so_snd nor so_rcv */
636	if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL) {
637		free(so);
638		return NULL;
639	}
640	insque(so,&tcb);
641
642	/*
643	 * SS_FACCEPTONCE sockets must time out.
644	 */
645	if (flags & SS_FACCEPTONCE)
646	   so->so_tcpcb->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT*2;
647
648	so->so_state      = (SS_FACCEPTCONN|flags);
649	so->so_laddr_port = lport; /* Kept in host format */
650    so->so_laddr_ip   = laddr; /* Ditto */
651    so->so_haddr_port = port;
652
653    s = socket_loopback_server( port, SOCKET_STREAM );
654    if (s < 0)
655        return NULL;
656
657    socket_get_address(s, &addr);
658
659	so->so_faddr_port = sock_address_get_port(&addr);
660
661    addr_ip = (uint32_t) sock_address_get_ip(&addr);
662
663    if (addr_ip == 0 || addr_ip == loopback_addr_ip)
664        so->so_faddr_ip = alias_addr_ip;
665    else
666        so->so_faddr_ip = addr_ip;
667
668	so->s = s;
669	return so;
670}
671
672
673int
674sounlisten(u_int  port)
675{
676    struct socket *so;
677
678    for (so = tcb.so_next; so != &tcb; so = so->so_next) {
679        if (so->so_haddr_port == port) {
680            break;
681        }
682    }
683
684    if (so == &tcb) {
685        return -1;
686    }
687
688    sofcantrcvmore( so );
689    sofcantsendmore( so );
690    close( so->s );
691    so->s = -1;
692    sofree( so );
693    return 0;
694}
695
696
697#if 0
698/*
699 * Data is available in so_rcv
700 * Just write() the data to the socket
701 * XXX not yet...
702 */
703static void
704sorwakeup(so)
705	struct socket *so;
706{
707/*	sowrite(so); */
708/*	FD_CLR(so->s,&writefds); */
709}
710
711/*
712 * Data has been freed in so_snd
713 * We have room for a read() if we want to
714 * For now, don't read, it'll be done in the main loop
715 */
716static void
717sowwakeup(so)
718	struct socket *so;
719{
720	/* Nothing, yet */
721}
722#endif
723
724/*
725 * Various session state calls
726 * XXX Should be #define's
727 * The socket state stuff needs work, these often get call 2 or 3
728 * times each when only 1 was needed
729 */
730void
731soisfconnecting(struct socket *so)
732{
733	so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE|
734			  SS_FCANTSENDMORE|SS_FWDRAIN);
735	so->so_state |= SS_ISFCONNECTING; /* Clobber other states */
736}
737
738void
739soisfconnected(struct socket *so)
740{
741	so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF);
742	so->so_state |= SS_ISFCONNECTED; /* Clobber other states */
743}
744
745static void
746sofcantrcvmore(struct socket *so)
747{
748	if ((so->so_state & SS_NOFDREF) == 0) {
749		shutdown(so->s,0);
750		if(global_writefds) {
751		  FD_CLR(so->s,global_writefds);
752		}
753	}
754	so->so_state &= ~(SS_ISFCONNECTING);
755	if (so->so_state & SS_FCANTSENDMORE)
756	   so->so_state = SS_NOFDREF; /* Don't select it */ /* XXX close() here as well? */
757	else
758	   so->so_state |= SS_FCANTRCVMORE;
759}
760
761static void
762sofcantsendmore(struct socket *so)
763{
764	if ((so->so_state & SS_NOFDREF) == 0) {
765            shutdown(so->s,1);           /* send FIN to fhost */
766            if (global_readfds) {
767                FD_CLR(so->s,global_readfds);
768            }
769            if (global_xfds) {
770                FD_CLR(so->s,global_xfds);
771            }
772	}
773	so->so_state &= ~(SS_ISFCONNECTING);
774	if (so->so_state & SS_FCANTRCVMORE)
775	   so->so_state = SS_NOFDREF; /* as above */
776	else
777	   so->so_state |= SS_FCANTSENDMORE;
778}
779
780void
781soisfdisconnected(struct socket *so)
782{
783/*	so->so_state &= ~(SS_ISFCONNECTING|SS_ISFCONNECTED); */
784/*	close(so->s); */
785/*	so->so_state = SS_ISFDISCONNECTED; */
786	/*
787	 * XXX Do nothing ... ?
788	 */
789}
790
791/*
792 * Set write drain mode
793 * Set CANTSENDMORE once all data has been write()n
794 */
795void
796sofwdrain(struct socket *so)
797{
798	if (so->so_rcv.sb_cc)
799		so->so_state |= SS_FWDRAIN;
800	else
801		sofcantsendmore(so);
802}
803