Return to raw_pup.c CVS log

Up to [CSRG BSD Unix] / 42BSD / sys / netpup

Annotation of 42BSD/sys/netpup/raw_pup.c, revision 1.1

1.1     ! root        1: /*     raw_pup.c       6.1     83/07/29        */
        !             2: 
        !             3: #include "../h/param.h"
        !             4: #include "../h/mbuf.h"
        !             5: #include "../h/socket.h"
        !             6: #include "../h/protosw.h"
        !             7: #include "../h/socketvar.h"
        !             8: #include "../h/errno.h"
        !             9: 
        !            10: #include "../net/if.h"
        !            11: #include "../net/route.h"
        !            12: #include "../net/raw_cb.h"
        !            13: 
        !            14: #include "../netpup/pup.h"
        !            15: 
        !            16: /*
        !            17:  * Raw PUP protocol interface.
        !            18:  */
        !            19: 
        !            20: struct sockaddr_pup pupsrc = { AF_PUP };
        !            21: struct sockaddr_pup pupdst = { AF_PUP };
        !            22: struct sockproto pupproto = { PF_PUP };
        !            23: /*
        !            24:  * Raw PUP input.
        !            25:  */
        !            26: rpup_input(m)
        !            27:        struct mbuf *m;
        !            28: {
        !            29:        register struct pup_header *pup = mtod(m, struct pup_header *);
        !            30: 
        !            31:        pupproto.sp_protocol = pup->pup_type;
        !            32:        bcopy((caddr_t)&pup->pup_dnet, (caddr_t)&pupdst.spup_net,
        !            33:            sizeof (struct pupport));
        !            34:        bcopy((caddr_t)&pup->pup_snet, (caddr_t)&pupsrc.spup_net,
        !            35:            sizeof (struct pupport));
        !            36:        raw_input(m, &pupproto, (struct sockaddr *)&pupsrc,
        !            37:          (struct sockaddr *)&pupdst);
        !            38: }
        !            39: 
        !            40: /*
        !            41:  * Encapsulate packet in PUP header which is supplied by the
        !            42:  * user.  This is done to allow user to specify PUP identifier.
        !            43:  */
        !            44: rpup_output(m, so)
        !            45:        register struct mbuf *m;
        !            46:        struct socket *so;
        !            47: {
        !            48:        register struct rawcb *rp = sotorawcb(so);
        !            49:        register struct pup_header *pup;
        !            50:        int len, error = 0;
        !            51:        register struct mbuf *n, *last;
        !            52:        struct sockaddr_pup *dst;
        !            53:        struct ifnet *ifp;
        !            54:        u_short *pc;
        !            55: 
        !            56:        /*
        !            57:         * Verify user has supplied necessary space
        !            58:         * for the header and check parameters in it.
        !            59:         */
        !            60:        if ((m->m_off > MMAXOFF || m->m_len < sizeof(struct pup_header)) &&
        !            61:            (m = m_pullup(m, sizeof(struct pup_header))) == 0) {
        !            62:                error = EINVAL;
        !            63:                goto bad;
        !            64:        }
        !            65:        pup = mtod(m, struct pup_header *);
        !            66:        if (pup->pup_type == 0 || (pup->pup_tcontrol &~ PUP_TRACE)) {
        !            67:                error = EINVAL;
        !            68:                goto bad;
        !            69:        }
        !            70:        for (len = 0, n = last = m; n; last = n, n = n->m_next)
        !            71:                len += n->m_len;
        !            72:        /* assume user leaves space for checksum */
        !            73:        if ((len & 1) || len < MINPUPSIZ || len > MAXPUPSIZ) {
        !            74:                error = EMSGSIZE;
        !            75:                goto bad;
        !            76:        }
        !            77:        pup->pup_length = htons((u_short)len);
        !            78:        dst = (struct sockaddr_pup *)&rp->rcb_faddr;
        !            79:        bcopy((caddr_t)&dst->spup_net, (caddr_t)&pup->pup_dnet,
        !            80:            sizeof (struct pupport));
        !            81:        if (rp->rcb_route.ro_rt == 0)
        !            82:                ifp = if_ifonnetof(dst->spup_net);
        !            83:        else {
        !            84:                rp->rcb_route.ro_rt->rt_use++;
        !            85:                ifp = rp->rcb_route.ro_rt->rt_ifp;
        !            86:        }
        !            87:        if (ifp == 0) {
        !            88:                error = ENETUNREACH;
        !            89:                goto bad;
        !            90:        }
        !            91:        if (rp->rcb_flags & RAW_LADDR) {
        !            92:                register struct sockaddr_pup *src;
        !            93: 
        !            94:                src = (struct sockaddr_pup *)&rp->rcb_laddr;
        !            95:                bcopy((caddr_t)&src->spup_net, (caddr_t)&pup->pup_snet,
        !            96:                    sizeof (struct pupport));
        !            97:        } else {
        !            98:                pup->pup_snet = ifp->if_net;
        !            99:                pup->pup_shost = ifp->if_host[0];
        !           100:                /* socket is specified by user */
        !           101:        }
        !           102:        /*
        !           103:         * Fill in checksum unless user indicates none should be specified.
        !           104:         */
        !           105:        pc = (u_short *)(mtod(last, caddr_t) + last->m_len - sizeof (short));
        !           106:        if (*pc != PUP_NOCKSUM)
        !           107:                *pc = htons((u_short)pup_cksum(m, len - sizeof (short)));
        !           108:        return ((*ifp->if_output)(ifp, m, (struct sockaddr *)dst));
        !           109: bad:
        !           110:        m_freem(m);
        !           111:        return (error);
        !           112: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.