URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [libnetworking/] [rtems/] [rtems_syscall.c] - Blame information for rev 492

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *  $Id: rtems_syscall.c,v 1.2 2001-09-27 12:02:00 chris Exp $
 */
 
#include <string.h>
#include <stdarg.h>
/* #include <stdlib.h> */
#include <stdio.h>
 
#include <rtems.h>
#include <rtems/libio.h>
#include <rtems/error.h>
#include <rtems/rtems_bsdnet.h>
 
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/protosw.h>
#include <sys/proc.h>
#include <sys/fcntl.h>
#include <sys/filio.h>
 
#include <net/if.h>
#include <net/route.h>
 
/*
 * Hooks to RTEMS I/O system
 */
static const rtems_filesystem_file_handlers_r socket_handlers;
int rtems_bsdnet_makeFdForSocket(void *so, const rtems_filesystem_file_handlers_r *h);
struct socket *rtems_bsdnet_fdToSocket(int fd);
 
/*
 * Package system call argument into mbuf.
 */
static int
sockargstombuf (struct mbuf **mp, const void *buf, int buflen, int type)
{
        struct mbuf *m;
 
        if ((u_int)buflen > MLEN)
                return (EINVAL);
        m = m_get(M_WAIT, type);
        if (m == NULL)
                return (ENOBUFS);
        m->m_len = buflen;
        memcpy (mtod(m, caddr_t), buf, buflen);
        *mp = m;
        if (type == MT_SONAME) {
                struct sockaddr *sa;
                sa = mtod(m, struct sockaddr *);
                sa->sa_len = buflen;
        }
        return 0;
}
 
/*
 *********************************************************************
 *                       BSD-style entry points                      *
 *********************************************************************
 */
int
socket (int domain, int type, int protocol)
{
        int fd;
        int error;
        struct socket *so;
 
        rtems_bsdnet_semaphore_obtain ();
        error = socreate(domain, &so, type, protocol, NULL);
        if (error == 0) {
                fd = rtems_bsdnet_makeFdForSocket (so, &socket_handlers);
                if (fd < 0)
                        soclose (so);
        }
        else {
                errno = error;
                fd = -1;
        }
        rtems_bsdnet_semaphore_release ();
        return fd;
}
 
int
bind (int s, struct sockaddr *name, int namelen)
{
        int error;
        int ret = -1;
        struct socket *so;
        struct mbuf *nam;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((so = rtems_bsdnet_fdToSocket (s)) != NULL) {
                error = sockargstombuf (&nam, name, namelen, MT_SONAME);
                if (error == 0) {
                        error = sobind (so, nam);
                        if (error == 0)
                                ret = 0;
                        else
                                errno = error;
                        m_freem (nam);
                }
                else {
                        errno = error;
                }
        }
        rtems_bsdnet_semaphore_release ();
        return ret;
}
 
int
connect (int s, struct sockaddr *name, int namelen)
{
        int error;
        int ret = -1;
        struct socket *so;
        struct mbuf *nam;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
                errno = EALREADY;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        error = sockargstombuf (&nam, name, namelen, MT_SONAME);
        if (error) {
                errno = error;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        error = soconnect (so, nam);
        if (error)
                goto bad;
        if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
                m_freem(nam);
                errno = EINPROGRESS;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
                error = soconnsleep (so);
                if (error)
                        break;
        }
        if (error == 0) {
                error = so->so_error;
                so->so_error = 0;
        }
    bad:
        so->so_state &= ~SS_ISCONNECTING;
        m_freem (nam);
        if (error)
                errno = error;
        else
                ret = 0;
        rtems_bsdnet_semaphore_release ();
        return ret;
}
 
int
listen (int s, int backlog)
{
        int error;
        int ret = -1;
        struct socket *so;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((so = rtems_bsdnet_fdToSocket (s)) != NULL) {
                error = solisten (so, backlog);
                if (error == 0)
                        ret = 0;
                else
                        errno = error;
        }
        rtems_bsdnet_semaphore_release ();
        return ret;
}
 
int
accept (int s, struct sockaddr *name, int *namelen)
{
        int fd;
        struct socket *head, *so;
        struct mbuf *nam;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((head = rtems_bsdnet_fdToSocket (s)) == NULL) {
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        if ((head->so_options & SO_ACCEPTCONN) == 0) {
                errno = EINVAL;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        if ((head->so_state & SS_NBIO) && head->so_comp.tqh_first == NULL) {
                errno = EWOULDBLOCK;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        while (head->so_comp.tqh_first == NULL && head->so_error == 0) {
                if (head->so_state & SS_CANTRCVMORE) {
                        head->so_error = ECONNABORTED;
                        break;
                }
                head->so_error = soconnsleep (head);
        }
        if (head->so_error) {
                errno = head->so_error;
                head->so_error = 0;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
 
        so = head->so_comp.tqh_first;
        TAILQ_REMOVE(&head->so_comp, so, so_list);
        head->so_qlen--;
 
        fd = rtems_bsdnet_makeFdForSocket (so, &socket_handlers);
        if (fd < 0) {
                TAILQ_INSERT_HEAD(&head->so_comp, so, so_list);
                head->so_qlen++;
                soconnwakeup (head);
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        so->so_state &= ~SS_COMP;
        so->so_head = NULL;
 
        nam = m_get(M_WAIT, MT_SONAME);
        (void) soaccept(so, nam);
        if (name) {
                 /* check length before it is destroyed */
                if (*namelen > nam->m_len)
                        *namelen = nam->m_len;
                memcpy (name, mtod(nam, caddr_t), *namelen);
        }
        m_freem(nam);
        rtems_bsdnet_semaphore_release ();
        return (fd);
 
}
 
/*
 *  Shutdown routine
 */
 
int
shutdown (int s, int how)
{
      struct socket *so;
      int error;
 
      rtems_bsdnet_semaphore_obtain ();
      if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
              rtems_bsdnet_semaphore_release ();
              return -1;
      }
      error = soshutdown(so, how);
      rtems_bsdnet_semaphore_release ();
      if (error) {
              errno = error;
              return -1;
      }
      return 0;
}
 
/*
 * All `transmit' operations end up calling this routine.
 */
ssize_t
sendmsg (int s, const struct msghdr *mp, int flags)
{
        int ret = -1;
        int error;
        struct uio auio;
        struct iovec *iov;
        struct socket *so;
        struct mbuf *to, *control;
        int i;
        int len;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        auio.uio_iov = mp->msg_iov;
        auio.uio_iovcnt = mp->msg_iovlen;
        auio.uio_segflg = UIO_USERSPACE;
        auio.uio_rw = UIO_WRITE;
        auio.uio_offset = 0;
        auio.uio_resid = 0;
        iov = mp->msg_iov;
        for (i = 0; i < mp->msg_iovlen; i++, iov++) {
                if ((auio.uio_resid += iov->iov_len) < 0) {
                        errno = EINVAL;
                        rtems_bsdnet_semaphore_release ();
                        return -1;
                }
        }
        if (mp->msg_name) {
                error = sockargstombuf (&to, mp->msg_name, mp->msg_namelen, MT_SONAME);
                if (error) {
                        errno = error;
                        rtems_bsdnet_semaphore_release ();
                        return -1;
                }
        }
        else {
                to = NULL;
        }
        if (mp->msg_control) {
                if (mp->msg_controllen < sizeof (struct cmsghdr)) {
                        errno = EINVAL;
                        if (to)
                                m_freem(to);
                        rtems_bsdnet_semaphore_release ();
                        return -1;
                }
                sockargstombuf (&control, mp->msg_control, mp->msg_controllen, MT_CONTROL);
        }
        else {
                control = NULL;
        }
        len = auio.uio_resid;
        error = sosend (so, to, &auio, (struct mbuf *)0, control, flags);
        if (error) {
                if (auio.uio_resid != len && (error == EINTR || error == EWOULDBLOCK))
                        error = 0;
        }
        if (error)
                errno = error;
        else
                ret = len - auio.uio_resid;
        if (to)
                m_freem(to);
        rtems_bsdnet_semaphore_release ();
        return (ret);
}
 
/*
 * Send a message to a host
 */
ssize_t
sendto (int s, const void *buf, size_t buflen, int flags, const struct sockaddr *to, int tolen)
{
        struct msghdr msg;
        struct iovec iov;
 
        iov.iov_base = (void *)buf;
        iov.iov_len = buflen;
        msg.msg_name = (caddr_t)to;
        msg.msg_namelen = tolen;
        msg.msg_iov = &iov;
        msg.msg_iovlen = 1;
        msg.msg_control = NULL;
        msg.msg_controllen = 0;
        return sendmsg (s, &msg, flags);
}
 
/*
 * Send a message to a connected host
 */
ssize_t
send (int s, const void *buf, size_t buflen, int flags)
{
        return sendto (s, buf, buflen, flags, NULL, 0);
}
 
/*
 * All `receive' operations end up calling this routine.
 */
ssize_t
recvmsg (int s, struct msghdr *mp, int flags)
{
        int ret = -1;
        int error;
        struct uio auio;
        struct iovec *iov;
        struct socket *so;
        struct mbuf *from = NULL, *control = NULL;
        int i;
        int len;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        auio.uio_iov = mp->msg_iov;
        auio.uio_iovcnt = mp->msg_iovlen;
        auio.uio_segflg = UIO_USERSPACE;
        auio.uio_rw = UIO_READ;
        auio.uio_offset = 0;
        auio.uio_resid = 0;
        iov = mp->msg_iov;
        for (i = 0; i < mp->msg_iovlen; i++, iov++) {
                if ((auio.uio_resid += iov->iov_len) < 0) {
                        errno = EINVAL;
                        rtems_bsdnet_semaphore_release ();
                        return -1;
                }
        }
        len = auio.uio_resid;
        mp->msg_flags = flags;
        error = soreceive (so, &from, &auio, (struct mbuf **)NULL,
                        mp->msg_control ? &control : (struct mbuf **)NULL,
                        &mp->msg_flags);
        if (error) {
                if (auio.uio_resid != len && (error == EINTR || error == EWOULDBLOCK))
                        error = 0;
        }
        if (error) {
                errno = error;
        }
        else {
                ret = len - auio.uio_resid;
                if (mp->msg_name) {
                        len = mp->msg_namelen;
                        if ((len <= 0) || (from == NULL)) {
                                len = 0;
                        }
                        else {
                                if (len > from->m_len)
                                        len = from->m_len;
                                memcpy (mp->msg_name, mtod(from, caddr_t), len);
                        }
                        mp->msg_namelen = len;
                }
                if (mp->msg_control) {
                        struct mbuf *m;
                        caddr_t ctlbuf;
 
                        len = mp->msg_controllen;
                        m = control;
                        mp->msg_controllen = 0;
                        ctlbuf = (caddr_t) mp->msg_control;
 
                        while (m && (len > 0)) {
                                unsigned int tocopy;
 
                                if (len >= m->m_len)
                                        tocopy = m->m_len;
                                else {
                                        mp->msg_flags |= MSG_CTRUNC;
                                        tocopy = len;
                                }
                                memcpy(ctlbuf, mtod(m, caddr_t), tocopy);
                                ctlbuf += tocopy;
                                len -= tocopy;
                                m = m->m_next;
                        }
                        mp->msg_controllen = ctlbuf - mp->msg_control;
                }
        }
        if (from)
                m_freem (from);
        if (control)
                m_freem (control);
        rtems_bsdnet_semaphore_release ();
        return (ret);
}
 
/*
 * Receive a message from a host
 */
ssize_t
recvfrom (int s, void *buf, size_t buflen, int flags, const struct sockaddr *from, int *fromlen)
{
        struct msghdr msg;
        struct iovec iov;
        int ret;
 
        iov.iov_base = buf;
        iov.iov_len = buflen;
        msg.msg_name = (caddr_t)from;
        if (fromlen)
                msg.msg_namelen = *fromlen;
        else
        msg.msg_namelen = 0;
        msg.msg_iov = &iov;
        msg.msg_iovlen = 1;
        msg.msg_control = NULL;
        msg.msg_controllen = 0;
        ret = recvmsg (s, &msg, flags);
        if ((from != NULL) && (fromlen != NULL) && (ret >= 0))
                *fromlen = msg.msg_namelen;
        return ret;
}
 
/*
 * Receive a message from a connected host
 */
ssize_t
recv (int s, void *buf, size_t buflen, int flags)
{
        return recvfrom (s, buf, buflen, flags, NULL, NULL);
}
 
int
setsockopt (int s, int level, int name, const void *val, int len)
{
        struct socket *so;
        struct mbuf *m = NULL;
        int error;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        if (len > MLEN) {
                errno = EINVAL;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        if (val) {
                error = sockargstombuf (&m, val, len, MT_SOOPTS);
                if (error) {
                        errno = error;
                        rtems_bsdnet_semaphore_release ();
                        return -1;
                }
        }
        error = sosetopt(so, level, name, m);
        if (error) {
                errno = error;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        rtems_bsdnet_semaphore_release ();
        return 0;
}
 
int
getsockopt (int s, int level, int name, void *aval, int *avalsize)
{
        struct socket *so;
        struct mbuf *m = NULL, *m0;
        char *val = aval;
        int i, op, valsize;
        int error;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        if (val)
                valsize = *avalsize;
        else
                valsize = 0;
        if (((error = sogetopt(so, level, name, &m)) == 0) && val && valsize && m) {
                op = 0;
                while (m && op < valsize) {
                        i = valsize - op;
                        if (i > m->m_len)
                                i = m->m_len;
                        memcpy (val, mtod(m, caddr_t), i);
                        op += i;
                        val += i;
                        m0 = m;
                        MFREE (m0, m);
                }
                *avalsize = op;
        }
        if (m != NULL)
                (void) m_free(m);
        if (error) {
                errno = error;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        rtems_bsdnet_semaphore_release ();
        return 0;
}
 
static int
getpeersockname (int s, struct sockaddr *name, int *namelen, int pflag)
{
        struct socket *so;
        struct mbuf *m;
        int len = *namelen;
        int error;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        m = m_getclr(M_WAIT, MT_SONAME);
        if (m == NULL) {
                errno = ENOBUFS;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        if (pflag)
                error = (*so->so_proto->pr_usrreqs->pru_peeraddr)(so, m);
        else
                error = (*so->so_proto->pr_usrreqs->pru_sockaddr)(so, m);
        if (error) {
                m_freem(m);
                errno = error;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        if (len > m->m_len) {
                len = m->m_len;
                *namelen = len;
        }
        memcpy (name, mtod(m, caddr_t), len);
        m_freem (m);
        rtems_bsdnet_semaphore_release ();
        return 0;
}
 
int
getpeername (int s, struct sockaddr *name, int *namelen)
{
        return getpeersockname (s, name, namelen, 1);
}
int
getsockname (int s, struct sockaddr *name, int *namelen)
{
        return getpeersockname (s, name, namelen, 0);
}
 
/*
 ************************************************************************
 *                      RTEMS I/O HANDLER ROUTINES                      *
 ************************************************************************
 */
static int
rtems_bsdnet_close (rtems_libio_t *iop)
{
        struct socket *so;
        int error;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((so = iop->data1) == NULL) {
                errno = EBADF;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        error = soclose (so);
        rtems_bsdnet_semaphore_release ();
        if (error) {
                errno = error;
                return -1;
        }
        return 0;
}
 
static int
rtems_bsdnet_read (rtems_libio_t *iop, void *buffer, unsigned32 count)
{
        return recv (iop->data0, buffer, count, 0);
}
 
static int
rtems_bsdnet_write (rtems_libio_t *iop, const void *buffer, unsigned32 count)
{
        return send (iop->data0, buffer, count, 0);
}
 
static int
so_ioctl (rtems_libio_t *iop, struct socket *so, unsigned32 command, void *buffer)
{
        switch (command) {
        case FIONBIO:
                if (*(int *)buffer) {
                        iop->flags |= O_NONBLOCK;
                        so->so_state |= SS_NBIO;
                }
                else {
                        iop->flags &= ~O_NONBLOCK;
                        so->so_state &= ~SS_NBIO;
                }
                return 0;
 
        case FIONREAD:
                *(int *)buffer = so->so_rcv.sb_cc;
                return 0;
        }
 
        if (IOCGROUP(command) == 'i')
                return ifioctl (so, command, buffer, NULL);
        if (IOCGROUP(command) == 'r')
                return rtioctl (command, buffer, NULL);
        return (*so->so_proto->pr_usrreqs->pru_control)(so, command, buffer, 0);
}
 
static int
rtems_bsdnet_ioctl (rtems_libio_t *iop, unsigned32 command, void *buffer)
{
        struct socket *so;
        int error;
 
        rtems_bsdnet_semaphore_obtain ();
        if ((so = iop->data1) == NULL) {
                errno = EBADF;
                rtems_bsdnet_semaphore_release ();
                return -1;
        }
        error = so_ioctl (iop, so, command, buffer);
        rtems_bsdnet_semaphore_release ();
        if (error) {
                errno = error;
                return -1;
        }
        return 0;
}
 
static int
rtems_bsdnet_fcntl (int cmd, rtems_libio_t *iop)
{
        struct socket *so;
 
        if (cmd == F_SETFL) {
                rtems_bsdnet_semaphore_obtain ();
                if ((so = iop->data1) == NULL) {
                        rtems_bsdnet_semaphore_release ();
                        return EBADF;
                }
                if (iop->flags & O_NONBLOCK)
                        so->so_state |= SS_NBIO;
                else
                        so->so_state &= ~SS_NBIO;
                rtems_bsdnet_semaphore_release ();
        }
        return 0;
}
 
static int
rtems_bsdnet_fstat (rtems_filesystem_location_info_t *loc, struct stat *sp)
{
        sp->st_mode = S_IFSOCK;
        return 0;
}
 
static const rtems_filesystem_file_handlers_r socket_handlers = {
        NULL,                   /* open */
        rtems_bsdnet_close,     /* close */
        rtems_bsdnet_read,      /* read */
        rtems_bsdnet_write,     /* write */
        rtems_bsdnet_ioctl,     /* ioctl */
        NULL,                   /* lseek */
        rtems_bsdnet_fstat,     /* fstat */
        NULL,                   /* fchmod */
        NULL,                   /* ftruncate */
        NULL,                   /* fpathconf */
        NULL,                   /* fsync */
        NULL,                   /* fdatasync */
        rtems_bsdnet_fcntl,     /* fcntl */
};

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [libnetworking/] [rtems/] [rtems_syscall.c] - Blame information for rev 492

Line No.	Rev	Author	Line
1	30	unneback	`/*`
2			`* $Id: rtems_syscall.c,v 1.2 2001-09-27 12:02:00 chris Exp $`
3			`*/`
4
5			`#include <string.h>`
6			`#include <stdarg.h>`
7			`/* #include <stdlib.h> */`
8			`#include <stdio.h>`
9
10			`#include <rtems.h>`
11			`#include <rtems/libio.h>`
12			`#include <rtems/error.h>`
13			`#include <rtems/rtems_bsdnet.h>`
14
15			`#include <sys/errno.h>`
16			`#include <sys/types.h>`
17			`#include <sys/param.h>`
18			`#include <sys/mbuf.h>`
19			`#include <sys/socket.h>`
20			`#include <sys/socketvar.h>`
21			`#include <sys/protosw.h>`
22			`#include <sys/proc.h>`
23			`#include <sys/fcntl.h>`
24			`#include <sys/filio.h>`
25
26			`#include <net/if.h>`
27			`#include <net/route.h>`
28
29			`/*`
30			`* Hooks to RTEMS I/O system`
31			`*/`
32			`static const rtems_filesystem_file_handlers_r socket_handlers;`
33			`int rtems_bsdnet_makeFdForSocket(void so, const rtems_filesystem_file_handlers_r h);`
34			`struct socket *rtems_bsdnet_fdToSocket(int fd);`
35
36			`/*`
37			`* Package system call argument into mbuf.`
38			`*/`
39			`static int`
40			`sockargstombuf (struct mbuf *mp, const void buf, int buflen, int type)`
41			`{`
42			`struct mbuf *m;`
43
44			`if ((u_int)buflen > MLEN)`
45			`return (EINVAL);`
46			`m = m_get(M_WAIT, type);`
47			`if (m == NULL)`
48			`return (ENOBUFS);`
49			`m->m_len = buflen;`
50			`memcpy (mtod(m, caddr_t), buf, buflen);`
51			`*mp = m;`
52			`if (type == MT_SONAME) {`
53			`struct sockaddr *sa;`
54			`sa = mtod(m, struct sockaddr *);`
55			`sa->sa_len = buflen;`
56			`}`
57			`return 0;`
58			`}`
59
60			`/*`
61			`*********************************************************************`
62			`* BSD-style entry points *`
63			`*********************************************************************`
64			`*/`
65			`int`
66			`socket (int domain, int type, int protocol)`
67			`{`
68			`int fd;`
69			`int error;`
70			`struct socket *so;`
71
72			`rtems_bsdnet_semaphore_obtain ();`
73			`error = socreate(domain, &so, type, protocol, NULL);`
74			`if (error == 0) {`
75			`fd = rtems_bsdnet_makeFdForSocket (so, &socket_handlers);`
76			`if (fd < 0)`
77			`soclose (so);`
78			`}`
79			`else {`
80			`errno = error;`
81			`fd = -1;`
82			`}`
83			`rtems_bsdnet_semaphore_release ();`
84			`return fd;`
85			`}`
86
87			`int`
88			`bind (int s, struct sockaddr *name, int namelen)`
89			`{`
90			`int error;`
91			`int ret = -1;`
92			`struct socket *so;`
93			`struct mbuf *nam;`
94
95			`rtems_bsdnet_semaphore_obtain ();`
96			`if ((so = rtems_bsdnet_fdToSocket (s)) != NULL) {`
97			`error = sockargstombuf (&nam, name, namelen, MT_SONAME);`
98			`if (error == 0) {`
99			`error = sobind (so, nam);`
100			`if (error == 0)`
101			`ret = 0;`
102			`else`
103			`errno = error;`
104			`m_freem (nam);`
105			`}`
106			`else {`
107			`errno = error;`
108			`}`
109			`}`
110			`rtems_bsdnet_semaphore_release ();`
111			`return ret;`
112			`}`
113
114			`int`
115			`connect (int s, struct sockaddr *name, int namelen)`
116			`{`
117			`int error;`
118			`int ret = -1;`
119			`struct socket *so;`
120			`struct mbuf *nam;`
121
122			`rtems_bsdnet_semaphore_obtain ();`
123			`if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {`
124			`rtems_bsdnet_semaphore_release ();`
125			`return -1;`
126			`}`
127			`if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {`
128			`errno = EALREADY;`
129			`rtems_bsdnet_semaphore_release ();`
130			`return -1;`
131			`}`
132			`error = sockargstombuf (&nam, name, namelen, MT_SONAME);`
133			`if (error) {`
134			`errno = error;`
135			`rtems_bsdnet_semaphore_release ();`
136			`return -1;`
137			`}`
138			`error = soconnect (so, nam);`
139			`if (error)`
140			`goto bad;`
141			`if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {`
142			`m_freem(nam);`
143			`errno = EINPROGRESS;`
144			`rtems_bsdnet_semaphore_release ();`
145			`return -1;`
146			`}`
147			`while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {`
148			`error = soconnsleep (so);`
149			`if (error)`
150			`break;`
151			`}`
152			`if (error == 0) {`
153			`error = so->so_error;`
154			`so->so_error = 0;`
155			`}`
156			`bad:`
157			`so->so_state &= ~SS_ISCONNECTING;`
158			`m_freem (nam);`
159			`if (error)`
160			`errno = error;`
161			`else`
162			`ret = 0;`
163			`rtems_bsdnet_semaphore_release ();`
164			`return ret;`
165			`}`
166
167			`int`
168			`listen (int s, int backlog)`
169			`{`
170			`int error;`
171			`int ret = -1;`
172			`struct socket *so;`
173
174			`rtems_bsdnet_semaphore_obtain ();`
175			`if ((so = rtems_bsdnet_fdToSocket (s)) != NULL) {`
176			`error = solisten (so, backlog);`
177			`if (error == 0)`
178			`ret = 0;`
179			`else`
180			`errno = error;`
181			`}`
182			`rtems_bsdnet_semaphore_release ();`
183			`return ret;`
184			`}`
185
186			`int`
187			`accept (int s, struct sockaddr name, int namelen)`
188			`{`
189			`int fd;`
190			`struct socket head, so;`
191			`struct mbuf *nam;`
192
193			`rtems_bsdnet_semaphore_obtain ();`
194			`if ((head = rtems_bsdnet_fdToSocket (s)) == NULL) {`
195			`rtems_bsdnet_semaphore_release ();`
196			`return -1;`
197			`}`
198			`if ((head->so_options & SO_ACCEPTCONN) == 0) {`
199			`errno = EINVAL;`
200			`rtems_bsdnet_semaphore_release ();`
201			`return -1;`
202			`}`
203			`if ((head->so_state & SS_NBIO) && head->so_comp.tqh_first == NULL) {`
204			`errno = EWOULDBLOCK;`
205			`rtems_bsdnet_semaphore_release ();`
206			`return -1;`
207			`}`
208			`while (head->so_comp.tqh_first == NULL && head->so_error == 0) {`
209			`if (head->so_state & SS_CANTRCVMORE) {`
210			`head->so_error = ECONNABORTED;`
211			`break;`
212			`}`
213			`head->so_error = soconnsleep (head);`
214			`}`
215			`if (head->so_error) {`
216			`errno = head->so_error;`
217			`head->so_error = 0;`
218			`rtems_bsdnet_semaphore_release ();`
219			`return -1;`
220			`}`
221
222			`so = head->so_comp.tqh_first;`
223			`TAILQ_REMOVE(&head->so_comp, so, so_list);`
224			`head->so_qlen--;`
225
226			`fd = rtems_bsdnet_makeFdForSocket (so, &socket_handlers);`
227			`if (fd < 0) {`
228			`TAILQ_INSERT_HEAD(&head->so_comp, so, so_list);`
229			`head->so_qlen++;`
230			`soconnwakeup (head);`
231			`rtems_bsdnet_semaphore_release ();`
232			`return -1;`
233			`}`
234			`so->so_state &= ~SS_COMP;`
235			`so->so_head = NULL;`
236
237			`nam = m_get(M_WAIT, MT_SONAME);`
238			`(void) soaccept(so, nam);`
239			`if (name) {`
240			`/* check length before it is destroyed */`
241			`if (*namelen > nam->m_len)`
242			`*namelen = nam->m_len;`
243			`memcpy (name, mtod(nam, caddr_t), *namelen);`
244			`}`
245			`m_freem(nam);`
246			`rtems_bsdnet_semaphore_release ();`
247			`return (fd);`
248
249			`}`
250
251			`/*`
252			`* Shutdown routine`
253			`*/`
254
255			`int`
256			`shutdown (int s, int how)`
257			`{`
258			`struct socket *so;`
259			`int error;`
260
261			`rtems_bsdnet_semaphore_obtain ();`
262			`if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {`
263			`rtems_bsdnet_semaphore_release ();`
264			`return -1;`
265			`}`
266			`error = soshutdown(so, how);`
267			`rtems_bsdnet_semaphore_release ();`
268			`if (error) {`
269			`errno = error;`
270			`return -1;`
271			`}`
272			`return 0;`
273			`}`
274
275			`/*`
276			* All `transmit' operations end up calling this routine.
277			`*/`
278			`ssize_t`
279			`sendmsg (int s, const struct msghdr *mp, int flags)`
280			`{`
281			`int ret = -1;`
282			`int error;`
283			`struct uio auio;`
284			`struct iovec *iov;`
285			`struct socket *so;`
286			`struct mbuf to, control;`
287			`int i;`
288			`int len;`
289
290			`rtems_bsdnet_semaphore_obtain ();`
291			`if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {`
292			`rtems_bsdnet_semaphore_release ();`
293			`return -1;`
294			`}`
295			`auio.uio_iov = mp->msg_iov;`
296			`auio.uio_iovcnt = mp->msg_iovlen;`
297			`auio.uio_segflg = UIO_USERSPACE;`
298			`auio.uio_rw = UIO_WRITE;`
299			`auio.uio_offset = 0;`
300			`auio.uio_resid = 0;`
301			`iov = mp->msg_iov;`
302			`for (i = 0; i < mp->msg_iovlen; i++, iov++) {`
303			`if ((auio.uio_resid += iov->iov_len) < 0) {`
304			`errno = EINVAL;`
305			`rtems_bsdnet_semaphore_release ();`
306			`return -1;`
307			`}`
308			`}`
309			`if (mp->msg_name) {`
310			`error = sockargstombuf (&to, mp->msg_name, mp->msg_namelen, MT_SONAME);`
311			`if (error) {`
312			`errno = error;`
313			`rtems_bsdnet_semaphore_release ();`
314			`return -1;`
315			`}`
316			`}`
317			`else {`
318			`to = NULL;`
319			`}`
320			`if (mp->msg_control) {`
321			`if (mp->msg_controllen < sizeof (struct cmsghdr)) {`
322			`errno = EINVAL;`
323			`if (to)`
324			`m_freem(to);`
325			`rtems_bsdnet_semaphore_release ();`
326			`return -1;`
327			`}`
328			`sockargstombuf (&control, mp->msg_control, mp->msg_controllen, MT_CONTROL);`
329			`}`
330			`else {`
331			`control = NULL;`
332			`}`
333			`len = auio.uio_resid;`
334			`error = sosend (so, to, &auio, (struct mbuf *)0, control, flags);`
335			`if (error) {`
336			`if (auio.uio_resid != len && (error == EINTR \|\| error == EWOULDBLOCK))`
337			`error = 0;`
338			`}`
339			`if (error)`
340			`errno = error;`
341			`else`
342			`ret = len - auio.uio_resid;`
343			`if (to)`
344			`m_freem(to);`
345			`rtems_bsdnet_semaphore_release ();`
346			`return (ret);`
347			`}`
348
349			`/*`
350			`* Send a message to a host`
351			`*/`
352			`ssize_t`
353			`sendto (int s, const void buf, size_t buflen, int flags, const struct sockaddr to, int tolen)`
354			`{`
355			`struct msghdr msg;`
356			`struct iovec iov;`
357
358			`iov.iov_base = (void *)buf;`
359			`iov.iov_len = buflen;`
360			`msg.msg_name = (caddr_t)to;`
361			`msg.msg_namelen = tolen;`
362			`msg.msg_iov = &iov;`
363			`msg.msg_iovlen = 1;`
364			`msg.msg_control = NULL;`
365			`msg.msg_controllen = 0;`
366			`return sendmsg (s, &msg, flags);`
367			`}`
368
369			`/*`
370			`* Send a message to a connected host`
371			`*/`
372			`ssize_t`
373			`send (int s, const void *buf, size_t buflen, int flags)`
374			`{`
375			`return sendto (s, buf, buflen, flags, NULL, 0);`
376			`}`
377
378			`/*`
379			* All `receive' operations end up calling this routine.
380			`*/`
381			`ssize_t`
382			`recvmsg (int s, struct msghdr *mp, int flags)`
383			`{`
384			`int ret = -1;`
385			`int error;`
386			`struct uio auio;`
387			`struct iovec *iov;`
388			`struct socket *so;`
389			`struct mbuf from = NULL, control = NULL;`
390			`int i;`
391			`int len;`
392
393			`rtems_bsdnet_semaphore_obtain ();`
394			`if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {`
395			`rtems_bsdnet_semaphore_release ();`
396			`return -1;`
397			`}`
398			`auio.uio_iov = mp->msg_iov;`
399			`auio.uio_iovcnt = mp->msg_iovlen;`
400			`auio.uio_segflg = UIO_USERSPACE;`
401			`auio.uio_rw = UIO_READ;`
402			`auio.uio_offset = 0;`
403			`auio.uio_resid = 0;`
404			`iov = mp->msg_iov;`
405			`for (i = 0; i < mp->msg_iovlen; i++, iov++) {`
406			`if ((auio.uio_resid += iov->iov_len) < 0) {`
407			`errno = EINVAL;`
408			`rtems_bsdnet_semaphore_release ();`
409			`return -1;`
410			`}`
411			`}`
412			`len = auio.uio_resid;`
413			`mp->msg_flags = flags;`
414			`error = soreceive (so, &from, &auio, (struct mbuf **)NULL,`
415			`mp->msg_control ? &control : (struct mbuf **)NULL,`
416			`&mp->msg_flags);`
417			`if (error) {`
418			`if (auio.uio_resid != len && (error == EINTR \|\| error == EWOULDBLOCK))`
419			`error = 0;`
420			`}`
421			`if (error) {`
422			`errno = error;`
423			`}`
424			`else {`
425			`ret = len - auio.uio_resid;`
426			`if (mp->msg_name) {`
427			`len = mp->msg_namelen;`
428			`if ((len <= 0) \|\| (from == NULL)) {`
429			`len = 0;`
430			`}`
431			`else {`
432			`if (len > from->m_len)`
433			`len = from->m_len;`
434			`memcpy (mp->msg_name, mtod(from, caddr_t), len);`
435			`}`
436			`mp->msg_namelen = len;`
437			`}`
438			`if (mp->msg_control) {`
439			`struct mbuf *m;`
440			`caddr_t ctlbuf;`
441
442			`len = mp->msg_controllen;`
443			`m = control;`
444			`mp->msg_controllen = 0;`
445			`ctlbuf = (caddr_t) mp->msg_control;`
446
447			`while (m && (len > 0)) {`
448			`unsigned int tocopy;`
449
450			`if (len >= m->m_len)`
451			`tocopy = m->m_len;`
452			`else {`
453			`mp->msg_flags \|= MSG_CTRUNC;`
454			`tocopy = len;`
455			`}`
456			`memcpy(ctlbuf, mtod(m, caddr_t), tocopy);`
457			`ctlbuf += tocopy;`
458			`len -= tocopy;`
459			`m = m->m_next;`
460			`}`
461			`mp->msg_controllen = ctlbuf - mp->msg_control;`
462			`}`
463			`}`
464			`if (from)`
465			`m_freem (from);`
466			`if (control)`
467			`m_freem (control);`
468			`rtems_bsdnet_semaphore_release ();`
469			`return (ret);`
470			`}`
471
472			`/*`
473			`* Receive a message from a host`
474			`*/`
475			`ssize_t`
476			`recvfrom (int s, void buf, size_t buflen, int flags, const struct sockaddr from, int *fromlen)`
477			`{`
478			`struct msghdr msg;`
479			`struct iovec iov;`
480			`int ret;`
481
482			`iov.iov_base = buf;`
483			`iov.iov_len = buflen;`
484			`msg.msg_name = (caddr_t)from;`
485			`if (fromlen)`
486			`msg.msg_namelen = *fromlen;`
487			`else`
488			`msg.msg_namelen = 0;`
489			`msg.msg_iov = &iov;`
490			`msg.msg_iovlen = 1;`
491			`msg.msg_control = NULL;`
492			`msg.msg_controllen = 0;`
493			`ret = recvmsg (s, &msg, flags);`
494			`if ((from != NULL) && (fromlen != NULL) && (ret >= 0))`
495			`*fromlen = msg.msg_namelen;`
496			`return ret;`
497			`}`
498
499			`/*`
500			`* Receive a message from a connected host`
501			`*/`
502			`ssize_t`
503			`recv (int s, void *buf, size_t buflen, int flags)`
504			`{`
505			`return recvfrom (s, buf, buflen, flags, NULL, NULL);`
506			`}`
507
508			`int`
509			`setsockopt (int s, int level, int name, const void *val, int len)`
510			`{`
511			`struct socket *so;`
512			`struct mbuf *m = NULL;`
513			`int error;`
514
515			`rtems_bsdnet_semaphore_obtain ();`
516			`if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {`
517			`rtems_bsdnet_semaphore_release ();`
518			`return -1;`
519			`}`
520			`if (len > MLEN) {`
521			`errno = EINVAL;`
522			`rtems_bsdnet_semaphore_release ();`
523			`return -1;`
524			`}`
525			`if (val) {`
526			`error = sockargstombuf (&m, val, len, MT_SOOPTS);`
527			`if (error) {`
528			`errno = error;`
529			`rtems_bsdnet_semaphore_release ();`
530			`return -1;`
531			`}`
532			`}`
533			`error = sosetopt(so, level, name, m);`
534			`if (error) {`
535			`errno = error;`
536			`rtems_bsdnet_semaphore_release ();`
537			`return -1;`
538			`}`
539			`rtems_bsdnet_semaphore_release ();`
540			`return 0;`
541			`}`
542
543			`int`
544			`getsockopt (int s, int level, int name, void aval, int avalsize)`
545			`{`
546			`struct socket *so;`
547			`struct mbuf m = NULL, m0;`
548			`char *val = aval;`
549			`int i, op, valsize;`
550			`int error;`
551
552			`rtems_bsdnet_semaphore_obtain ();`
553			`if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {`
554			`rtems_bsdnet_semaphore_release ();`
555			`return -1;`
556			`}`
557			`if (val)`
558			`valsize = *avalsize;`
559			`else`
560			`valsize = 0;`
561			`if (((error = sogetopt(so, level, name, &m)) == 0) && val && valsize && m) {`
562			`op = 0;`
563			`while (m && op < valsize) {`
564			`i = valsize - op;`
565			`if (i > m->m_len)`
566			`i = m->m_len;`
567			`memcpy (val, mtod(m, caddr_t), i);`
568			`op += i;`
569			`val += i;`
570			`m0 = m;`
571			`MFREE (m0, m);`
572			`}`
573			`*avalsize = op;`
574			`}`
575			`if (m != NULL)`
576			`(void) m_free(m);`
577			`if (error) {`
578			`errno = error;`
579			`rtems_bsdnet_semaphore_release ();`
580			`return -1;`
581			`}`
582			`rtems_bsdnet_semaphore_release ();`
583			`return 0;`
584			`}`
585
586			`static int`
587			`getpeersockname (int s, struct sockaddr name, int namelen, int pflag)`
588			`{`
589			`struct socket *so;`
590			`struct mbuf *m;`
591			`int len = *namelen;`
592			`int error;`
593
594			`rtems_bsdnet_semaphore_obtain ();`
595			`if ((so = rtems_bsdnet_fdToSocket (s)) == NULL) {`
596			`rtems_bsdnet_semaphore_release ();`
597			`return -1;`
598			`}`
599			`m = m_getclr(M_WAIT, MT_SONAME);`
600			`if (m == NULL) {`
601			`errno = ENOBUFS;`
602			`rtems_bsdnet_semaphore_release ();`
603			`return -1;`
604			`}`
605			`if (pflag)`
606			`error = (*so->so_proto->pr_usrreqs->pru_peeraddr)(so, m);`
607			`else`
608			`error = (*so->so_proto->pr_usrreqs->pru_sockaddr)(so, m);`
609			`if (error) {`
610			`m_freem(m);`
611			`errno = error;`
612			`rtems_bsdnet_semaphore_release ();`
613			`return -1;`
614			`}`
615			`if (len > m->m_len) {`
616			`len = m->m_len;`
617			`*namelen = len;`
618			`}`
619			`memcpy (name, mtod(m, caddr_t), len);`
620			`m_freem (m);`
621			`rtems_bsdnet_semaphore_release ();`
622			`return 0;`
623			`}`
624
625			`int`
626			`getpeername (int s, struct sockaddr name, int namelen)`
627			`{`
628			`return getpeersockname (s, name, namelen, 1);`
629			`}`
630			`int`
631			`getsockname (int s, struct sockaddr name, int namelen)`
632			`{`
633			`return getpeersockname (s, name, namelen, 0);`
634			`}`
635
636			`/*`
637			`************************************************************************`
638			`* RTEMS I/O HANDLER ROUTINES *`
639			`************************************************************************`
640			`*/`
641			`static int`
642			`rtems_bsdnet_close (rtems_libio_t *iop)`
643			`{`
644			`struct socket *so;`
645			`int error;`
646
647			`rtems_bsdnet_semaphore_obtain ();`
648			`if ((so = iop->data1) == NULL) {`
649			`errno = EBADF;`
650			`rtems_bsdnet_semaphore_release ();`
651			`return -1;`
652			`}`
653			`error = soclose (so);`
654			`rtems_bsdnet_semaphore_release ();`
655			`if (error) {`
656			`errno = error;`
657			`return -1;`
658			`}`
659			`return 0;`
660			`}`
661
662			`static int`
663			`rtems_bsdnet_read (rtems_libio_t iop, void buffer, unsigned32 count)`
664			`{`
665			`return recv (iop->data0, buffer, count, 0);`
666			`}`
667
668			`static int`
669			`rtems_bsdnet_write (rtems_libio_t iop, const void buffer, unsigned32 count)`
670			`{`
671			`return send (iop->data0, buffer, count, 0);`
672			`}`
673
674			`static int`
675			`so_ioctl (rtems_libio_t iop, struct socket so, unsigned32 command, void *buffer)`
676			`{`
677			`switch (command) {`
678			`case FIONBIO:`
679			`if ((int )buffer) {`
680			`iop->flags \|= O_NONBLOCK;`
681			`so->so_state \|= SS_NBIO;`
682			`}`
683			`else {`
684			`iop->flags &= ~O_NONBLOCK;`
685			`so->so_state &= ~SS_NBIO;`
686			`}`
687			`return 0;`
688
689			`case FIONREAD:`
690			`(int )buffer = so->so_rcv.sb_cc;`
691			`return 0;`
692			`}`
693
694			`if (IOCGROUP(command) == 'i')`
695			`return ifioctl (so, command, buffer, NULL);`
696			`if (IOCGROUP(command) == 'r')`
697			`return rtioctl (command, buffer, NULL);`
698			`return (*so->so_proto->pr_usrreqs->pru_control)(so, command, buffer, 0);`
699			`}`
700
701			`static int`
702			`rtems_bsdnet_ioctl (rtems_libio_t iop, unsigned32 command, void buffer)`
703			`{`
704			`struct socket *so;`
705			`int error;`
706
707			`rtems_bsdnet_semaphore_obtain ();`
708			`if ((so = iop->data1) == NULL) {`
709			`errno = EBADF;`
710			`rtems_bsdnet_semaphore_release ();`
711			`return -1;`
712			`}`
713			`error = so_ioctl (iop, so, command, buffer);`
714			`rtems_bsdnet_semaphore_release ();`
715			`if (error) {`
716			`errno = error;`
717			`return -1;`
718			`}`
719			`return 0;`
720			`}`
721
722			`static int`
723			`rtems_bsdnet_fcntl (int cmd, rtems_libio_t *iop)`
724			`{`
725			`struct socket *so;`
726
727			`if (cmd == F_SETFL) {`
728			`rtems_bsdnet_semaphore_obtain ();`
729			`if ((so = iop->data1) == NULL) {`
730			`rtems_bsdnet_semaphore_release ();`
731			`return EBADF;`
732			`}`
733			`if (iop->flags & O_NONBLOCK)`
734			`so->so_state \|= SS_NBIO;`
735			`else`
736			`so->so_state &= ~SS_NBIO;`
737			`rtems_bsdnet_semaphore_release ();`
738			`}`
739			`return 0;`
740			`}`
741
742			`static int`
743			`rtems_bsdnet_fstat (rtems_filesystem_location_info_t loc, struct stat sp)`
744			`{`
745			`sp->st_mode = S_IFSOCK;`
746			`return 0;`
747			`}`
748
749			`static const rtems_filesystem_file_handlers_r socket_handlers = {`
750			`NULL, /* open */`
751			`rtems_bsdnet_close, /* close */`
752			`rtems_bsdnet_read, /* read */`
753			`rtems_bsdnet_write, /* write */`
754			`rtems_bsdnet_ioctl, /* ioctl */`
755			`NULL, /* lseek */`
756			`rtems_bsdnet_fstat, /* fstat */`
757			`NULL, /* fchmod */`
758			`NULL, /* ftruncate */`
759			`NULL, /* fpathconf */`
760			`NULL, /* fsync */`
761			`NULL, /* fdatasync */`
762			`rtems_bsdnet_fcntl, /* fcntl */`
763			`};`