![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clnp_raw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso|
Return to clnp_raw.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso |
1.1 ! root 1: /*********************************************************** ! 2: Copyright IBM Corporation 1987 ! 3: ! 4: All Rights Reserved ! 5: ! 6: Permission to use, copy, modify, and distribute this software and its ! 7: documentation for any purpose and without fee is hereby granted, ! 8: provided that the above copyright notice appear in all copies and that ! 9: both that copyright notice and this permission notice appear in ! 10: supporting documentation, and that the name of IBM not be ! 11: used in advertising or publicity pertaining to distribution of the ! 12: software without specific, written prior permission. ! 13: ! 14: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 15: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 16: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 17: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 18: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 19: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 20: SOFTWARE. ! 21: ! 22: ******************************************************************/ ! 23: ! 24: /* ! 25: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 26: */ ! 27: /* $Header: clnp_raw.c,v 4.2 88/06/29 14:58:56 hagens Exp $ */ ! 28: /* $Source: /usr/argo/sys/netiso/RCS/clnp_raw.c,v $ */ ! 29: /* @(#)clnp_raw.c 7.7 (Berkeley) 4/5/90 */ ! 30: #ifndef lint ! 31: static char *rcsid = "$Header: clnp_raw.c,v 4.2 88/06/29 14:58:56 hagens Exp $"; ! 32: #endif lint ! 33: ! 34: #include "param.h" ! 35: #include "mbuf.h" ! 36: #include "domain.h" ! 37: #include "protosw.h" ! 38: #include "socket.h" ! 39: #include "socketvar.h" ! 40: #include "errno.h" ! 41: #include "time.h" ! 42: ! 43: #include "../net/if.h" ! 44: #include "../net/route.h" ! 45: #include "../net/raw_cb.h" ! 46: ! 47: #include "iso.h" ! 48: #include "iso_pcb.h" ! 49: #include "clnp.h" ! 50: #include "clnp_stat.h" ! 51: #include "argo_debug.h" ! 52: ! 53: #include "tp_user.h"/* XXX -- defines SOL_NETWORK */ ! 54: ! 55: struct sockproto rclnp_proto = { PF_ISO, 0 }; ! 56: /* ! 57: * FUNCTION: rclnp_input ! 58: * ! 59: * PURPOSE: Setup generic address an protocol structures for ! 60: * raw input routine, then pass them along with the ! 61: * mbuf chain. ! 62: * ! 63: * RETURNS: none ! 64: * ! 65: * SIDE EFFECTS: ! 66: * ! 67: * NOTES: The protocol field of rclnp_proto is set to zero indicating ! 68: * no protocol. ! 69: */ ! 70: rclnp_input(m, src, dst, hdrlen) ! 71: struct mbuf *m; /* ptr to packet */ ! 72: struct sockaddr_iso *src; /* ptr to src address */ ! 73: struct sockaddr_iso *dst; /* ptr to dest address */ ! 74: int hdrlen; /* length (in bytes) of clnp header */ ! 75: { ! 76: #ifdef TROLL ! 77: if (trollctl.tr_ops & TR_CHUCK) { ! 78: m_freem(m); ! 79: return; ! 80: } ! 81: #endif TROLL ! 82: ! 83: if (raw_input(m, &rclnp_proto, (struct sockaddr *)src, ! 84: (struct sockaddr *)dst) == 0) { ! 85: clnp_stat.cns_delivered--; ! 86: clnp_stat.cns_noproto++; ! 87: } ! 88: } ! 89: ! 90: /* ! 91: * FUNCTION: rclnp_output ! 92: * ! 93: * PURPOSE: Prepare to send a raw clnp packet. Setup src and dest ! 94: * addresses, count the number of bytes to send, and ! 95: * call clnp_output. ! 96: * ! 97: * RETURNS: success - 0 ! 98: * failure - an appropriate error code ! 99: * ! 100: * SIDE EFFECTS: ! 101: * ! 102: * NOTES: ! 103: */ ! 104: rclnp_output(m0, so) ! 105: struct mbuf *m0; /* packet to send */ ! 106: struct socket *so; /* socket to send from */ ! 107: { ! 108: register struct mbuf *m; /* used to scan a chain */ ! 109: int len = 0; /* store length of chain here */ ! 110: struct rawisopcb *rp = sotorawisopcb(so); /* ptr to raw cb */ ! 111: int error; /* return value of function */ ! 112: int flags; /* flags for clnp_output */ ! 113: ! 114: if (0 == m0->m_flags & M_PKTHDR) ! 115: return (EINVAL); ! 116: /* ! 117: * Set up src address. If user has bound socket to an address, use it. ! 118: * Otherwise, do not specify src (clnp_output will fill it in). ! 119: */ ! 120: if (rp->risop_rcb.rcb_laddr) { ! 121: if (rp->risop_isop.isop_sladdr.siso_family != AF_ISO) { ! 122: bad: ! 123: m_freem(m0); ! 124: return(EAFNOSUPPORT); ! 125: } ! 126: } ! 127: /* set up dest address */ ! 128: if (rp->risop_rcb.rcb_faddr == 0) ! 129: goto bad; ! 130: rp->risop_isop.isop_sfaddr = ! 131: *(struct sockaddr_iso *)rp->risop_rcb.rcb_faddr; ! 132: rp->risop_isop.isop_faddr = &rp->risop_isop.isop_sfaddr; ! 133: ! 134: /* get flags and ship it off */ ! 135: flags = rp->risop_flags & CLNP_VFLAGS; ! 136: ! 137: error = clnp_output(m0, &rp->risop_isop, m0->m_pkthdr.len, ! 138: flags|CLNP_NOCACHE); ! 139: ! 140: return (error); ! 141: } ! 142: ! 143: /* ! 144: * FUNCTION: rclnp_ctloutput ! 145: * ! 146: * PURPOSE: Raw clnp socket option processing ! 147: * All options are stored inside an mbuf. ! 148: * ! 149: * RETURNS: success - 0 ! 150: * failure - unix error code ! 151: * ! 152: * SIDE EFFECTS: If the options mbuf does not exist, it the mbuf passed ! 153: * is used. ! 154: * ! 155: * NOTES: ! 156: */ ! 157: rclnp_ctloutput(op, so, level, optname, m) ! 158: int op; /* type of operation */ ! 159: struct socket *so; /* ptr to socket */ ! 160: int level; /* level of option */ ! 161: int optname; /* name of option */ ! 162: struct mbuf **m; /* ptr to ptr to option data */ ! 163: { ! 164: int error = 0; ! 165: register struct rawisopcb *rp = sotorawisopcb(so);/* raw cb ptr */ ! 166: ! 167: IFDEBUG(D_CTLOUTPUT) ! 168: printf("rclnp_ctloutput: op = x%x, level = x%x, name = x%x\n", ! 169: op, level, optname); ! 170: if (*m != NULL) { ! 171: printf("rclnp_ctloutput: %d bytes of mbuf data\n", (*m)->m_len); ! 172: dump_buf(mtod((*m), caddr_t), (*m)->m_len); ! 173: } ! 174: ENDDEBUG ! 175: ! 176: #ifdef SOL_NETWORK ! 177: if (level != SOL_NETWORK) ! 178: error = EINVAL; ! 179: else switch (op) { ! 180: #else ! 181: switch (op) { ! 182: #endif SOL_NETWORK ! 183: case PRCO_SETOPT: ! 184: switch (optname) { ! 185: case CLNPOPT_FLAGS: { ! 186: u_short usr_flags; ! 187: /* ! 188: * Insure that the data passed has exactly one short in it ! 189: */ ! 190: if ((*m == NULL) || ((*m)->m_len != sizeof(short))) { ! 191: error = EINVAL; ! 192: break; ! 193: } ! 194: ! 195: /* ! 196: * Don't allow invalid flags to be set ! 197: */ ! 198: usr_flags = (*mtod((*m), short *)); ! 199: ! 200: if ((usr_flags & (CLNP_VFLAGS)) != usr_flags) { ! 201: error = EINVAL; ! 202: } else ! 203: rp->risop_flags |= usr_flags; ! 204: ! 205: } break; ! 206: ! 207: case CLNPOPT_OPTS: ! 208: if (error = clnp_set_opts(&rp->risop_isop.isop_options, m)) ! 209: break; ! 210: rp->risop_isop.isop_optindex = m_get(M_WAIT, MT_SOOPTS); ! 211: (void) clnp_opt_sanity(rp->risop_isop.isop_options, ! 212: mtod(rp->risop_isop.isop_options, caddr_t), ! 213: rp->risop_isop.isop_options->m_len, ! 214: mtod(rp->risop_isop.isop_optindex, ! 215: struct clnp_optidx *)); ! 216: break; ! 217: } ! 218: break; ! 219: ! 220: case PRCO_GETOPT: ! 221: #ifdef notdef ! 222: /* commented out to keep hi C quiet */ ! 223: switch (optname) { ! 224: default: ! 225: error = EINVAL; ! 226: break; ! 227: } ! 228: #endif notdef ! 229: break; ! 230: default: ! 231: error = EINVAL; ! 232: break; ! 233: } ! 234: if (op == PRCO_SETOPT) { ! 235: /* note: m_freem does not barf is *m is NULL */ ! 236: m_freem(*m); ! 237: *m = NULL; ! 238: } ! 239: ! 240: return error; ! 241: } ! 242: ! 243: /*ARGSUSED*/ ! 244: clnp_usrreq(so, req, m, nam, control) ! 245: register struct socket *so; ! 246: int req; ! 247: struct mbuf *m, *nam, *control; ! 248: { ! 249: register int error = 0; ! 250: register struct rawisopcb *rp = sotorawisopcb(so); ! 251: ! 252: rp = sotorawisopcb(so); ! 253: switch (req) { ! 254: ! 255: case PRU_ATTACH: ! 256: if (rp) ! 257: panic("rip_attach"); ! 258: MALLOC(rp, struct rawisopcb *, sizeof *rp, M_PCB, M_WAITOK); ! 259: if (rp == 0) ! 260: return (ENOBUFS); ! 261: bzero((caddr_t)rp, sizeof *rp); ! 262: so->so_pcb = (caddr_t)rp; ! 263: break; ! 264: ! 265: case PRU_DETACH: ! 266: if (rp == 0) ! 267: panic("rip_detach"); ! 268: if (rp->risop_isop.isop_options) ! 269: m_freem(rp->risop_isop.isop_options); ! 270: if (rp->risop_isop.isop_route.ro_rt) ! 271: RTFREE(rp->risop_isop.isop_route.ro_rt); ! 272: if (rp->risop_rcb.rcb_laddr) ! 273: rp->risop_rcb.rcb_laddr = 0; ! 274: /* free clnp cached hdr if necessary */ ! 275: if (rp->risop_isop.isop_clnpcache != NULL) { ! 276: struct clnp_cache *clcp = ! 277: mtod(rp->risop_isop.isop_clnpcache, struct clnp_cache *); ! 278: if (clcp->clc_hdr != NULL) { ! 279: m_free(clcp->clc_hdr); ! 280: } ! 281: m_free(rp->risop_isop.isop_clnpcache); ! 282: } ! 283: if (rp->risop_isop.isop_optindex != NULL) ! 284: m_free(rp->risop_isop.isop_optindex); ! 285: ! 286: break; ! 287: ! 288: case PRU_BIND: ! 289: { ! 290: struct sockaddr_iso *addr = mtod(nam, struct sockaddr_iso *); ! 291: ! 292: if (nam->m_len != sizeof(*addr)) ! 293: return (EINVAL); ! 294: if ((ifnet == 0) || ! 295: (addr->siso_family != AF_ISO) || ! 296: (addr->siso_addr.isoa_len && ! 297: ifa_ifwithaddr((struct sockaddr *)addr) == 0)) ! 298: return (EADDRNOTAVAIL); ! 299: rp->risop_isop.isop_sladdr = *addr; ! 300: rp->risop_rcb.rcb_laddr = (struct sockaddr *) ! 301: (rp->risop_isop.isop_laddr = &rp->risop_isop.isop_sladdr); ! 302: return (0); ! 303: } ! 304: case PRU_CONNECT: ! 305: { ! 306: struct sockaddr_iso *addr = mtod(nam, struct sockaddr_iso *); ! 307: ! 308: if ((nam->m_len > sizeof(*addr)) || (addr->siso_len > sizeof(*addr))) ! 309: return (EINVAL); ! 310: if (ifnet == 0) ! 311: return (EADDRNOTAVAIL); ! 312: if (addr->siso_family != AF_ISO) ! 313: rp->risop_isop.isop_sfaddr = *addr; ! 314: rp->risop_rcb.rcb_faddr = (struct sockaddr *) ! 315: (rp->risop_isop.isop_faddr = &rp->risop_isop.isop_sfaddr); ! 316: soisconnected(so); ! 317: return (0); ! 318: } ! 319: } ! 320: error = raw_usrreq(so, req, m, nam, control); ! 321: ! 322: if (error && req == PRU_ATTACH && so->so_pcb) ! 323: free((caddr_t)rp, M_PCB); ! 324: return (error); ! 325: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.