Subversion Repositories openrisc

//==========================================================================

//

//      sys/net/raw_usrreq.c

//

//     

//

//==========================================================================

//####BSDCOPYRIGHTBEGIN####

//

// -------------------------------------------

//

// Portions of this software may have been derived from OpenBSD or other sources,

// and are covered by the appropriate copyright disclaimers included herein.

//

// -------------------------------------------

//

//####BSDCOPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):    gthomas

// Contributors: gthomas

// Date:         2000-01-10

// Purpose:      

// Description:  

//              

//

//####DESCRIPTIONEND####

//

//==========================================================================

/*      $OpenBSD: raw_usrreq.c,v 1.3 1998/09/17 12:29:55 deraadt Exp $  */

/*      $NetBSD: raw_usrreq.c,v 1.11 1996/02/13 22:00:43 christos Exp $ */

/*

 * Copyright (c) 1980, 1986, 1993

 *      The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *      This product includes software developed by the University of

 *      California, Berkeley and its contributors.

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 *      @(#)raw_usrreq.c        8.1 (Berkeley) 6/10/93

 */

#include <sys/param.h>

#include <sys/mbuf.h>

#include <sys/domain.h>

#include <sys/protosw.h>

#include <sys/socket.h>

#include <sys/socketvar.h>

#include <sys/errno.h>

#ifndef __ECOS

#include <sys/systm.h>

#endif

#include <net/if.h>

#include <net/route.h>

#include <net/netisr.h>

#include <net/raw_cb.h>

#include <machine/stdarg.h>

/*

 * Initialize raw connection block q.

 */

void

raw_init()

{

        LIST_INIT(&rawcb);

}

/*

 * Raw protocol input routine.  Find the socket

 * associated with the packet(s) and move them over.  If

 * nothing exists for this packet, drop it.

 */

/*

 * Raw protocol interface.

 */

void

#if __STDC__

raw_input(struct mbuf *m0, ...)

#else

raw_input(m0, va_alist)

        struct mbuf *m0;

        va_dcl

#endif

{

        register struct rawcb *rp;

        register struct mbuf *m = m0;

        register int sockets = 0;

        struct socket *last;

        va_list ap;

        register struct sockproto *proto;

        struct sockaddr *src, *dst;

        va_start(ap, m0);

        proto = va_arg(ap, struct sockproto *);

        src = va_arg(ap, struct sockaddr *);

        dst = va_arg(ap, struct sockaddr *);

        va_end(ap);

        last = 0;

        for (rp = rawcb.lh_first; rp != 0; rp = rp->rcb_list.le_next) {

                if (rp->rcb_proto.sp_family != proto->sp_family)

                        continue;

                if (rp->rcb_proto.sp_protocol  &&

                    rp->rcb_proto.sp_protocol != proto->sp_protocol)

                        continue;

                /*

                 * We assume the lower level routines have

                 * placed the address in a canonical format

                 * suitable for a structure comparison.

                 *

                 * Note that if the lengths are not the same

                 * the comparison will fail at the first byte.

                 */

#define equal(a1, a2) \

  (bcmp((caddr_t)(a1), (caddr_t)(a2), a1->sa_len) == 0)

                if (rp->rcb_laddr && !equal(rp->rcb_laddr, dst))

                        continue;

                if (rp->rcb_faddr && !equal(rp->rcb_faddr, src))

                        continue;

                if (last) {

                        struct mbuf *n;

                        if ((n = m_copy(m, 0, (int)M_COPYALL)) != NULL) {

                                if (sbappendaddr(&last->so_rcv, src,

                                    n, (struct mbuf *)0) == 0)

                                        /* should notify about lost packet */

                                        m_freem(n);

                                else {

                                        sorwakeup(last);

                                        sockets++;

                                }

                        }

                }

                last = rp->rcb_socket;

        }

        if (last) {

                if (sbappendaddr(&last->so_rcv, src,

                    m, (struct mbuf *)0) == 0)

                        m_freem(m);

                else {

                        sorwakeup(last);

                        sockets++;

                }

        } else

                m_freem(m);

}

/*ARGSUSED*/

void *

raw_ctlinput(cmd, arg, d)

        int cmd;

        struct sockaddr *arg;

        void *d;

{

        if (cmd < 0 || cmd > PRC_NCMDS)

                return NULL;

        return NULL;

        /* INCOMPLETE */

}

/*ARGSUSED*/

int

raw_usrreq(so, req, m, nam, control)

        struct socket *so;

        int req;

        struct mbuf *m, *nam, *control;

{

        register struct rawcb *rp = sotorawcb(so);

        register int error = 0;

        int len;

        if (req == PRU_CONTROL)

                return (EOPNOTSUPP);

        if (control && control->m_len) {

                error = EOPNOTSUPP;

                goto release;

        }

        if (rp == 0) {

                error = EINVAL;

                goto release;

        }

        switch (req) {

        /*

         * Allocate a raw control block and fill in the

         * necessary info to allow packets to be routed to

         * the appropriate raw interface routine.

         */

        case PRU_ATTACH:

#ifndef __ECOS

                if ((so->so_state & SS_PRIV) == 0) {

                        error = EACCES;

                        break;

                }

#endif

                error = raw_attach(so, (int)(long)nam);

                break;

        /*

         * Destroy state just before socket deallocation.

         * Flush data or not depending on the options.

         */

        case PRU_DETACH:

                if (rp == 0) {

                        error = ENOTCONN;

                        break;

                }

                raw_detach(rp);

                break;

#ifdef notdef

        /*

         * If a socket isn't bound to a single address,

         * the raw input routine will hand it anything

         * within that protocol family (assuming there's

         * nothing else around it should go to).

         */

        case PRU_CONNECT:

                if (rp->rcb_faddr) {

                        error = EISCONN;

                        break;

                }

                nam = m_copym(nam, 0, M_COPYALL, M_WAIT);

                rp->rcb_faddr = mtod(nam, struct sockaddr *);

                soisconnected(so);

                break;

        case PRU_BIND:

                if (rp->rcb_laddr) {

                        error = EINVAL;                 /* XXX */

                        break;

                }

                error = raw_bind(so, nam);

                break;

#else

        case PRU_CONNECT:

        case PRU_BIND:

#endif

        case PRU_CONNECT2:

                error = EOPNOTSUPP;

                goto release;

        case PRU_DISCONNECT:

                if (rp->rcb_faddr == 0) {

                        error = ENOTCONN;

                        break;

                }

                raw_disconnect(rp);

                soisdisconnected(so);

                break;

        /*

         * Mark the connection as being incapable of further input.

         */

        case PRU_SHUTDOWN:

                socantsendmore(so);

                break;

        /*

         * Ship a packet out.  The appropriate raw output

         * routine handles any massaging necessary.

         */

        case PRU_SEND:

                if (nam) {

                        if (rp->rcb_faddr) {

                                error = EISCONN;

                                break;

                        }

                        rp->rcb_faddr = mtod(nam, struct sockaddr *);

                } else if (rp->rcb_faddr == 0) {

                        error = ENOTCONN;

                        break;

                }

                error = (*so->so_proto->pr_output)(m, so);

                m = NULL;

                if (nam)

                        rp->rcb_faddr = 0;

                break;

        case PRU_ABORT:

                raw_disconnect(rp);

                sofree(so);

                soisdisconnected(so);

                break;

        case PRU_SENSE:

                /*

                 * stat: don't bother with a blocksize.

                 */

                return (0);

        /*

         * Not supported.

         */

        case PRU_RCVOOB:

        case PRU_RCVD:

                return(EOPNOTSUPP);

        case PRU_LISTEN:

        case PRU_ACCEPT:

        case PRU_SENDOOB:

                error = EOPNOTSUPP;

                break;

        case PRU_SOCKADDR:

                if (rp->rcb_laddr == 0) {

                        error = EINVAL;

                        break;

                }

                len = rp->rcb_laddr->sa_len;

                bcopy((caddr_t)rp->rcb_laddr, mtod(nam, caddr_t), (unsigned)len);

                nam->m_len = len;

                break;

        case PRU_PEERADDR:

                if (rp->rcb_faddr == 0) {

                        error = ENOTCONN;

                        break;

                }

                len = rp->rcb_faddr->sa_len;

                bcopy((caddr_t)rp->rcb_faddr, mtod(nam, caddr_t), (unsigned)len);

                nam->m_len = len;

                break;

        default:

                panic("raw_usrreq");

        }

release:

        if (m != NULL)

                m_freem(m);

        return (error);

}