src/slirp/socket.c

/*
 * Copyright (c) 1995 Danny Gasparovski.
 * 
 * Please read the file COPYRIGHT for the 
 * terms and conditions of the copyright.
 */

#define WANT_SYS_IOCTL_H
#include <stdlib.h>
#include <slirp.h>
#include "ip_icmp.h"
#include "main.h"

void
so_init()
{
        /* Nothing yet */
}


struct socket *
solookup(head, laddr, lport, faddr, fport)
        struct socket *head;
        struct in_addr laddr;
        u_int lport;
        struct in_addr faddr;
        u_int fport;
{
        struct socket *so;
        
        for (so = head->so_next; so != head; so = so->so_next) {
                if (so->so_lport == lport && 
                    so->so_laddr.s_addr == laddr.s_addr &&
                    so->so_faddr.s_addr == faddr.s_addr &&
                    so->so_fport == fport)
                   break;
        }
        
        if (so == head)
           return (struct socket *)NULL;
        return so;
        
}

/*
 * Create a new socket, initialise the fields
 * It is the responsibility of the caller to
 * insque() it into the correct linked-list
 */
struct socket *
socreate()
{
  struct socket *so;
        
  so = (struct socket *)malloc(sizeof(struct socket));
  if(so) {
    memset(so, 0, sizeof(struct socket));
    so->so_state = SS_NOFDREF;
    so->s = -1;
  }
  return(so);
}

/*
 * remque and free a socket, clobber cache
 */
void
sofree(so)
        struct socket *so;
{
  if (so->so_emu==EMU_RSH && so->extra) {
        sofree(so->extra);
        so->extra=NULL;
  }
  if (so == tcp_last_so)
    tcp_last_so = &tcb;
  else if (so == udp_last_so)
    udp_last_so = &udb;
        
  m_free(so->so_m);
        
  if(so->so_next && so->so_prev) 
    remque(so);  /* crashes if so is not in a queue */

  free(so);
}

/*
 * Read from so's socket into sb_snd, updating all relevant sbuf fields
 * NOTE: This will only be called if it is select()ed for reading, so
 * a read() of 0 (or less) means it's disconnected
 */
int
soread(so)
        struct socket *so;
{
        int n, nn, lss, total;
        struct sbuf *sb = &so->so_snd;
        int len = sb->sb_datalen - sb->sb_cc;
        struct iovec iov[2];
        int mss = so->so_tcpcb->t_maxseg;
        
        DEBUG_CALL("soread");
        DEBUG_ARG("so = %lx", (long )so);
        
        /* 
         * No need to check if there's enough room to read.
         * soread wouldn't have been called if there weren't
         */
        
        len = sb->sb_datalen - sb->sb_cc;
        
        iov[0].iov_base = sb->sb_wptr;
        if (sb->sb_wptr < sb->sb_rptr) {
                iov[0].iov_len = sb->sb_rptr - sb->sb_wptr;
                /* Should never succeed, but... */
                if (iov[0].iov_len > len)
                   iov[0].iov_len = len;
                if (iov[0].iov_len > mss)
                   iov[0].iov_len -= iov[0].iov_len%mss;
                n = 1;
        } else {
                iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_wptr;
                /* Should never succeed, but... */
                if (iov[0].iov_len > len) iov[0].iov_len = len;
                len -= iov[0].iov_len;
                if (len) {
                        iov[1].iov_base = sb->sb_data;
                        iov[1].iov_len = sb->sb_rptr - sb->sb_data;
                        if(iov[1].iov_len > len)
                           iov[1].iov_len = len;
                        total = iov[0].iov_len + iov[1].iov_len;
                        if (total > mss) {
                                lss = total%mss;
                                if (iov[1].iov_len > lss) {
                                        iov[1].iov_len -= lss;
                                        n = 2;
                                } else {
                                        lss -= iov[1].iov_len;
                                        iov[0].iov_len -= lss;
                                        n = 1;
                                }
                        } else
                                n = 2;
                } else {
                        if (iov[0].iov_len > mss)
                           iov[0].iov_len -= iov[0].iov_len%mss;
                        n = 1;
                }
        }
        
#ifdef HAVE_READV
        nn = readv(so->s, (struct iovec *)iov, n);
        DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn));
#else
        nn = recv(so->s, iov[0].iov_base, iov[0].iov_len,0);
#endif  
        if (nn <= 0) {
                if (nn < 0 && (errno == EINTR || errno == EAGAIN))
                        return 0;
                else {
                        DEBUG_MISC((dfd, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn, errno,strerror(errno)));
                        sofcantrcvmore(so);
                        tcp_sockclosed(sototcpcb(so));
                        return -1;
                }
        }
        
#ifndef HAVE_READV
        /*
         * If there was no error, try and read the second time round
         * We read again if n = 2 (ie, there's another part of the buffer)
         * and we read as much as we could in the first read
         * We don't test for <= 0 this time, because there legitimately
         * might not be any more data (since the socket is non-blocking),
         * a close will be detected on next iteration.
         * A return of -1 wont (shouldn't) happen, since it didn't happen above
         */
        if (n == 2 && nn == iov[0].iov_len) {
            int ret;
            ret = recv(so->s, iov[1].iov_base, iov[1].iov_len,0);
            if (ret > 0)
                nn += ret;
        }
        
        DEBUG_MISC((dfd, " ... read nn = %d bytes\n", nn));
#endif
        
        /* Update fields */
        sb->sb_cc += nn;
        sb->sb_wptr += nn;
        if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen))
                sb->sb_wptr -= sb->sb_datalen;
        return nn;
}
        
/*
 * Get urgent data
 * 
 * When the socket is created, we set it SO_OOBINLINE,
 * so when OOB data arrives, we soread() it and everything
 * in the send buffer is sent as urgent data
 */
void
sorecvoob(so)
        struct socket *so;
{
        struct tcpcb *tp = sototcpcb(so);

        DEBUG_CALL("sorecvoob");
        DEBUG_ARG("so = %lx", (long)so);
        
        /*
         * We take a guess at how much urgent data has arrived.
         * In most situations, when urgent data arrives, the next
         * read() should get all the urgent data.  This guess will
         * be wrong however if more data arrives just after the
         * urgent data, or the read() doesn't return all the 
         * urgent data.
         */
        soread(so);
        tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
        tp->t_force = 1;
        tcp_output(tp);
        tp->t_force = 0;
}

/*
 * Send urgent data
 * There's a lot duplicated code here, but...
 */
int
sosendoob(so)
        struct socket *so;
{
        struct sbuf *sb = &so->so_rcv;
        char buff[2048]; /* XXX Shouldn't be sending more oob data than this */
        
        int n, len;
        
        DEBUG_CALL("sosendoob");
        DEBUG_ARG("so = %lx", (long)so);
        DEBUG_ARG("sb->sb_cc = %d", sb->sb_cc);
        
        if (so->so_urgc > 2048)
           so->so_urgc = 2048; /* XXXX */
        
        if (sb->sb_rptr < sb->sb_wptr) {
                /* We can send it directly */
                n = send(so->s, sb->sb_rptr, so->so_urgc, (MSG_OOB)); /* |MSG_DONTWAIT)); */
                so->so_urgc -= n;
                
                DEBUG_MISC((dfd, " --- sent %d bytes urgent data, %d urgent bytes left\n", n, so->so_urgc));
        } else {
                /* 
                 * Since there's no sendv or sendtov like writev,
                 * we must copy all data to a linear buffer then
                 * send it all
                 */
                len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr;
                if (len > so->so_urgc) len = so->so_urgc;
                memcpy(buff, sb->sb_rptr, len);
                so->so_urgc -= len;
                if (so->so_urgc) {
                        n = sb->sb_wptr - sb->sb_data;
                        if (n > so->so_urgc) n = so->so_urgc;
                        memcpy((buff + len), sb->sb_data, n);
                        so->so_urgc -= n;
                        len += n;
                }
                n = send(so->s, buff, len, (MSG_OOB)); /* |MSG_DONTWAIT)); */
#ifdef DEBUG
                if (n != len)
                   DEBUG_ERROR((dfd, "Didn't send all data urgently XXXXX\n"));
#endif          
                DEBUG_MISC((dfd, " ---2 sent %d bytes urgent data, %d urgent bytes left\n", n, so->so_urgc));
        }
        
        sb->sb_cc -= n;
        sb->sb_rptr += n;
        if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen))
                sb->sb_rptr -= sb->sb_datalen;
        
        return n;
}

/*
 * Write data from so_rcv to so's socket, 
 * updating all sbuf field as necessary
 */
int
sowrite(so)
        struct socket *so;
{
        int  n,nn;
        struct sbuf *sb = &so->so_rcv;
        int len = sb->sb_cc;
        struct iovec iov[2];
        
        DEBUG_CALL("sowrite");
        DEBUG_ARG("so = %lx", (long)so);
        
        if (so->so_urgc) {
                sosendoob(so);
                if (sb->sb_cc == 0)
                        return 0;
        }

        /*
         * No need to check if there's something to write,
         * sowrite wouldn't have been called otherwise
         */
        
        len = sb->sb_cc;
        
        iov[0].iov_base = sb->sb_rptr;
        if (sb->sb_rptr < sb->sb_wptr) {
                iov[0].iov_len = sb->sb_wptr - sb->sb_rptr;
                /* Should never succeed, but... */
                if (iov[0].iov_len > len) iov[0].iov_len = len;
                n = 1;
        } else {
                iov[0].iov_len = (sb->sb_data + sb->sb_datalen) - sb->sb_rptr;
                if (iov[0].iov_len > len) iov[0].iov_len = len;
                len -= iov[0].iov_len;
                if (len) {
                        iov[1].iov_base = sb->sb_data;
                        iov[1].iov_len = sb->sb_wptr - sb->sb_data;
                        if (iov[1].iov_len > len) iov[1].iov_len = len;
                        n = 2;
                } else
                        n = 1;
        }
        /* Check if there's urgent data to send, and if so, send it */

#ifdef HAVE_READV
        nn = writev(so->s, (const struct iovec *)iov, n);
        
        DEBUG_MISC((dfd, "  ... wrote nn = %d bytes\n", nn));
#else
        nn = send(so->s, iov[0].iov_base, iov[0].iov_len,0);
#endif
        /* This should never happen, but people tell me it does *shrug* */
        if (nn < 0 && (errno == EAGAIN || errno == EINTR))
                return 0;
        
        if (nn <= 0) {
                DEBUG_MISC((dfd, " --- sowrite disconnected, so->so_state = %x, errno = %d\n",
                        so->so_state, errno));
                sofcantsendmore(so);
                tcp_sockclosed(sototcpcb(so));
                return -1;
        }
        
#ifndef HAVE_READV
        if (n == 2 && nn == iov[0].iov_len) {
            int ret;
            ret = send(so->s, iov[1].iov_base, iov[1].iov_len,0);
            if (ret > 0)
                nn += ret;
        }
        DEBUG_MISC((dfd, "  ... wrote nn = %d bytes\n", nn));
#endif
        
        /* Update sbuf */
        sb->sb_cc -= nn;
        sb->sb_rptr += nn;
        if (sb->sb_rptr >= (sb->sb_data + sb->sb_datalen))
                sb->sb_rptr -= sb->sb_datalen;
        
        /*
         * If in DRAIN mode, and there's no more data, set
         * it CANTSENDMORE
         */
        if ((so->so_state & SS_FWDRAIN) && sb->sb_cc == 0)
                sofcantsendmore(so);
        
        return nn;
}

/*
 * recvfrom() a UDP socket
 */
void
sorecvfrom(so)
        struct socket *so;
{
        struct sockaddr_in addr;
        socklen_t addrlen = sizeof(struct sockaddr_in);
        
        DEBUG_CALL("sorecvfrom");
        DEBUG_ARG("so = %lx", (long)so);
        
        if (so->so_type == IPPROTO_ICMP) {   /* This is a "ping" reply */
          char buff[256];
          int len;
                
          len = recvfrom(so->s, buff, 256, 0, 
                         (struct sockaddr *)&addr, &addrlen);
          /* XXX Check if reply is "correct"? */
          
          if(len == -1 || len == 0) {
            u_char code=ICMP_UNREACH_PORT;

            if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
            else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;
            
            DEBUG_MISC((dfd," udp icmp rx errno = %d-%s\n",
                        errno,strerror(errno)));
            icmp_error(so->so_m, ICMP_UNREACH,code, 0,strerror(errno));
          } else {
            icmp_reflect(so->so_m);
            so->so_m = 0; /* Don't m_free() it again! */
          }
          /* No need for this socket anymore, udp_detach it */
          udp_detach(so);
        } else {                                /* A "normal" UDP packet */
          struct mbuf *m;
          int len;
          ioctlsockopt_t n;

          if (!(m = m_get())) return;
          m->m_data += if_maxlinkhdr;
                
          /* 
           * XXX Shouldn't FIONREAD packets destined for port 53,
           * but I don't know the max packet size for DNS lookups
           */
          len = M_FREEROOM(m);
          /* if (so->so_fport != htons(53)) { */
          ioctlsocket(so->s, FIONREAD, &n);
          
          if (n > len) {
            n = (m->m_data - m->m_dat) + m->m_len + n + 1;
            m_inc(m, n);
            len = M_FREEROOM(m);
          }
          /* } */
                
          m->m_len = recvfrom(so->s, m->m_data, len, 0,
                              (struct sockaddr *)&addr, &addrlen);
          DEBUG_MISC((dfd, " did recvfrom %d, errno = %d-%s\n", 
                      m->m_len, errno,strerror(errno)));
          if(m->m_len<0) {
            u_char code=ICMP_UNREACH_PORT;

            if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
            else if(errno == ENETUNREACH) code=ICMP_UNREACH_NET;
            
            DEBUG_MISC((dfd," rx error, tx icmp ICMP_UNREACH:%i\n", code));
            icmp_error(so->so_m, ICMP_UNREACH,code, 0,strerror(errno));
            m_free(m);
          } else {
          /*
           * Hack: domain name lookup will be used the most for UDP,
           * and since they'll only be used once there's no need
           * for the 4 minute (or whatever) timeout... So we time them
           * out much quicker (10 seconds  for now...)
           */
            if (so->so_expire) {
              if (so->so_fport == htons(53))
                so->so_expire = curtime + SO_EXPIREFAST;
              else
                so->so_expire = curtime + SO_EXPIRE;
            }

            /*          if (m->m_len == len) {
             *                  m_inc(m, MINCSIZE);
             *                  m->m_len = 0;
             *          }
             */
            
            /* 
             * If this packet was destined for CTL_ADDR,
             * make it look like that's where it came from, done by udp_output
             */
            udp_output(so, m, &addr);
          } /* rx error */
        } /* if ping packet */
}

/*
 * sendto() a socket
 */
int
sosendto(so, m)
        struct socket *so;
        struct mbuf *m;
{
        int ret;
        struct sockaddr_in addr;

        DEBUG_CALL("sosendto");
        DEBUG_ARG("so = %lx", (long)so);
        DEBUG_ARG("m = %lx", (long)m);
        
        addr.sin_family = AF_INET;
        if ((so->so_faddr.s_addr & htonl(0xffffff00)) == special_addr.s_addr) {
          /* It's an alias */
          switch(ntohl(so->so_faddr.s_addr) & 0xff) {
          case CTL_DNS:
            addr.sin_addr = dns_addr;
            break;
          case CTL_ALIAS:
          default:
            addr.sin_addr = loopback_addr;
            break;
          }
        } else
          addr.sin_addr = so->so_faddr;
        addr.sin_port = so->so_fport;

        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)));
        
        /* Don't care what port we get */
        ret = sendto(so->s, m->m_data, m->m_len, 0,
                     (struct sockaddr *)&addr, sizeof (struct sockaddr));
        if (ret < 0)
                return -1;
        
        /*
         * Kill the socket if there's no reply in 4 minutes,
         * but only if it's an expirable socket
         */
        if (so->so_expire)
                so->so_expire = curtime + SO_EXPIRE;
        so->so_state = SS_ISFCONNECTED; /* So that it gets select()ed */
        return 0;
}

/*
 * XXX This should really be tcp_listen
 */
struct socket *
solisten(port, laddr, lport, flags)
        u_int port;
        u_int32_t laddr;
        u_int lport;
        int flags;
{
        struct sockaddr_in addr;
        struct socket *so;
        int s;
        socklen_t addrlen = sizeof(addr);
        int opt = 1;

        DEBUG_CALL("solisten");
        DEBUG_ARG("port = %d", port);
        DEBUG_ARG("laddr = %x", laddr);
        DEBUG_ARG("lport = %d", lport);
        DEBUG_ARG("flags = %x", flags);
        
        if ((so = socreate()) == NULL) {
          /* free(so);      Not sofree() ??? free(NULL) == NOP */
          return NULL;
        }
        
        /* Don't tcp_attach... we don't need so_snd nor so_rcv */
        if ((so->so_tcpcb = tcp_newtcpcb(so)) == NULL) {
                free(so);
                return NULL;
        }
        insque(so,&tcb);
        
        /* 
         * SS_FACCEPTONCE sockets must time out.
         */
        if (flags & SS_FACCEPTONCE)
           so->so_tcpcb->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT*2;
        
        so->so_state = (SS_FACCEPTCONN|flags);
        so->so_lport = lport; /* Kept in network format */
        so->so_laddr.s_addr = laddr; /* Ditto */
        
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = INADDR_ANY;
        addr.sin_port = port;
        
        if (((s = socket(AF_INET,SOCK_STREAM,0)) < 0) ||
            (setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int)) < 0) ||
            (bind(s,(struct sockaddr *)&addr, sizeof(addr)) < 0) ||
            (listen(s,1) < 0)) {
                int tmperrno = errno; /* Don't clobber the real reason we failed */
                
                close(s);
                sofree(so);
                /* Restore the real errno */
#ifdef _WIN32
                WSASetLastError(tmperrno);
#else
                errno = tmperrno;
#endif
                return NULL;
        }
        setsockopt(s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int));
        
        getsockname(s,(struct sockaddr *)&addr,&addrlen);
        so->so_fport = addr.sin_port;
        if (addr.sin_addr.s_addr == 0 || addr.sin_addr.s_addr == loopback_addr.s_addr)
           so->so_faddr = our_addr;
        else
           so->so_faddr = addr.sin_addr;

        so->s = s;
        return so;
}

/* 
 * Data is available in so_rcv
 * Just write() the data to the socket
 * XXX not yet...
 */
void
sorwakeup(so)
        struct socket *so;
{
/*      sowrite(so); */
/*      FD_CLR(so->s,&writefds); */
}
        
/*
 * Data has been freed in so_snd
 * We have room for a read() if we want to
 * For now, don't read, it'll be done in the main loop
 */
void
sowwakeup(so)
        struct socket *so;
{
        /* Nothing, yet */
}

/*
 * Various session state calls
 * XXX Should be #define's
 * The socket state stuff needs work, these often get call 2 or 3
 * times each when only 1 was needed
 */
void
soisfconnecting(so)
        register struct socket *so;
{
        so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE|
                          SS_FCANTSENDMORE|SS_FWDRAIN);
        so->so_state |= SS_ISFCONNECTING; /* Clobber other states */
}

void
soisfconnected(so)
        register struct socket *so;
{
        so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF);
        so->so_state |= SS_ISFCONNECTED; /* Clobber other states */
}

void
sofcantrcvmore(so)
        struct  socket *so;
{
        if ((so->so_state & SS_NOFDREF) == 0) {
                shutdown(so->s,0);
                if(global_writefds) {
                  FD_CLR(so->s,global_writefds);
                }
        }
        so->so_state &= ~(SS_ISFCONNECTING);
        if (so->so_state & SS_FCANTSENDMORE)
           so->so_state = SS_NOFDREF; /* Don't select it */ /* XXX close() here as well? */
        else
           so->so_state |= SS_FCANTRCVMORE;
}

void
sofcantsendmore(so)
        struct socket *so;
{
        if ((so->so_state & SS_NOFDREF) == 0) {
            shutdown(so->s,1);           /* send FIN to fhost */
            if (global_readfds) {
                FD_CLR(so->s,global_readfds);
            }
            if (global_xfds) {
                FD_CLR(so->s,global_xfds);
            }
        }
        so->so_state &= ~(SS_ISFCONNECTING);
        if (so->so_state & SS_FCANTRCVMORE)
           so->so_state = SS_NOFDREF; /* as above */
        else
           so->so_state |= SS_FCANTSENDMORE;
}

void
soisfdisconnected(so)
        struct socket *so;
{
/*      so->so_state &= ~(SS_ISFCONNECTING|SS_ISFCONNECTED); */
/*      close(so->s); */
/*      so->so_state = SS_ISFDISCONNECTED; */
        /*
         * XXX Do nothing ... ?
         */
}

/*
 * Set write drain mode
 * Set CANTSENDMORE once all data has been write()n
 */
void
sofwdrain(so)
        struct socket *so;
{
        if (so->so_rcv.sb_cc)
                so->so_state |= SS_FWDRAIN;
        else
                sofcantsendmore(so);
}

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