![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to raw_usrreq.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / net|
Return to raw_usrreq.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / net |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)raw_usrreq.c 7.1 (Berkeley) 6/4/86 ! 7: */ ! 8: ! 9: #include "param.h" ! 10: #include "mbuf.h" ! 11: #include "domain.h" ! 12: #include "protosw.h" ! 13: #include "socket.h" ! 14: #include "socketvar.h" ! 15: #include "errno.h" ! 16: ! 17: #include "if.h" ! 18: #include "route.h" ! 19: #include "netisr.h" ! 20: #include "raw_cb.h" ! 21: ! 22: #include "../vax/mtpr.h" ! 23: ! 24: /* ! 25: * Initialize raw connection block q. ! 26: */ ! 27: raw_init() ! 28: { ! 29: ! 30: rawcb.rcb_next = rawcb.rcb_prev = &rawcb; ! 31: rawintrq.ifq_maxlen = IFQ_MAXLEN; ! 32: } ! 33: ! 34: /* ! 35: * Raw protocol interface. ! 36: */ ! 37: raw_input(m0, proto, src, dst) ! 38: struct mbuf *m0; ! 39: struct sockproto *proto; ! 40: struct sockaddr *src, *dst; ! 41: { ! 42: register struct mbuf *m; ! 43: struct raw_header *rh; ! 44: int s; ! 45: ! 46: /* ! 47: * Rip off an mbuf for a generic header. ! 48: */ ! 49: m = m_get(M_DONTWAIT, MT_HEADER); ! 50: if (m == 0) { ! 51: m_freem(m0); ! 52: return; ! 53: } ! 54: m->m_next = m0; ! 55: m->m_len = sizeof(struct raw_header); ! 56: rh = mtod(m, struct raw_header *); ! 57: rh->raw_dst = *dst; ! 58: rh->raw_src = *src; ! 59: rh->raw_proto = *proto; ! 60: ! 61: /* ! 62: * Header now contains enough info to decide ! 63: * which socket to place packet in (if any). ! 64: * Queue it up for the raw protocol process ! 65: * running at software interrupt level. ! 66: */ ! 67: s = splimp(); ! 68: if (IF_QFULL(&rawintrq)) ! 69: m_freem(m); ! 70: else ! 71: IF_ENQUEUE(&rawintrq, m); ! 72: splx(s); ! 73: schednetisr(NETISR_RAW); ! 74: } ! 75: ! 76: /* ! 77: * Raw protocol input routine. Process packets entered ! 78: * into the queue at interrupt time. Find the socket ! 79: * associated with the packet(s) and move them over. If ! 80: * nothing exists for this packet, drop it. ! 81: */ ! 82: rawintr() ! 83: { ! 84: int s; ! 85: struct mbuf *m; ! 86: register struct rawcb *rp; ! 87: register struct raw_header *rh; ! 88: struct socket *last; ! 89: ! 90: next: ! 91: s = splimp(); ! 92: IF_DEQUEUE(&rawintrq, m); ! 93: splx(s); ! 94: if (m == 0) ! 95: return; ! 96: rh = mtod(m, struct raw_header *); ! 97: last = 0; ! 98: for (rp = rawcb.rcb_next; rp != &rawcb; rp = rp->rcb_next) { ! 99: if (rp->rcb_proto.sp_family != rh->raw_proto.sp_family) ! 100: continue; ! 101: if (rp->rcb_proto.sp_protocol && ! 102: rp->rcb_proto.sp_protocol != rh->raw_proto.sp_protocol) ! 103: continue; ! 104: /* ! 105: * We assume the lower level routines have ! 106: * placed the address in a canonical format ! 107: * suitable for a structure comparison. ! 108: */ ! 109: #define equal(a1, a2) \ ! 110: (bcmp((caddr_t)&(a1), (caddr_t)&(a2), sizeof (struct sockaddr)) == 0) ! 111: if ((rp->rcb_flags & RAW_LADDR) && ! 112: !equal(rp->rcb_laddr, rh->raw_dst)) ! 113: continue; ! 114: if ((rp->rcb_flags & RAW_FADDR) && ! 115: !equal(rp->rcb_faddr, rh->raw_src)) ! 116: continue; ! 117: if (last) { ! 118: struct mbuf *n; ! 119: if (n = m_copy(m->m_next, 0, (int)M_COPYALL)) { ! 120: if (sbappendaddr(&last->so_rcv, &rh->raw_src, ! 121: n, (struct mbuf *)0) == 0) ! 122: /* should notify about lost packet */ ! 123: m_freem(n); ! 124: else ! 125: sorwakeup(last); ! 126: } ! 127: } ! 128: last = rp->rcb_socket; ! 129: } ! 130: if (last) { ! 131: if (sbappendaddr(&last->so_rcv, &rh->raw_src, ! 132: m->m_next, (struct mbuf *)0) == 0) ! 133: m_freem(m->m_next); ! 134: else ! 135: sorwakeup(last); ! 136: (void) m_free(m); /* header */ ! 137: } else ! 138: m_freem(m); ! 139: goto next; ! 140: } ! 141: ! 142: /*ARGSUSED*/ ! 143: raw_ctlinput(cmd, arg) ! 144: int cmd; ! 145: struct sockaddr *arg; ! 146: { ! 147: ! 148: if (cmd < 0 || cmd > PRC_NCMDS) ! 149: return; ! 150: /* INCOMPLETE */ ! 151: } ! 152: ! 153: /*ARGSUSED*/ ! 154: raw_usrreq(so, req, m, nam, rights) ! 155: struct socket *so; ! 156: int req; ! 157: struct mbuf *m, *nam, *rights; ! 158: { ! 159: register struct rawcb *rp = sotorawcb(so); ! 160: register int error = 0; ! 161: ! 162: if (req == PRU_CONTROL) ! 163: return (EOPNOTSUPP); ! 164: if (rights && rights->m_len) { ! 165: error = EOPNOTSUPP; ! 166: goto release; ! 167: } ! 168: if (rp == 0 && req != PRU_ATTACH) { ! 169: error = EINVAL; ! 170: goto release; ! 171: } ! 172: switch (req) { ! 173: ! 174: /* ! 175: * Allocate a raw control block and fill in the ! 176: * necessary info to allow packets to be routed to ! 177: * the appropriate raw interface routine. ! 178: */ ! 179: case PRU_ATTACH: ! 180: if ((so->so_state & SS_PRIV) == 0) { ! 181: error = EACCES; ! 182: break; ! 183: } ! 184: if (rp) { ! 185: error = EINVAL; ! 186: break; ! 187: } ! 188: error = raw_attach(so, (int)nam); ! 189: break; ! 190: ! 191: /* ! 192: * Destroy state just before socket deallocation. ! 193: * Flush data or not depending on the options. ! 194: */ ! 195: case PRU_DETACH: ! 196: if (rp == 0) { ! 197: error = ENOTCONN; ! 198: break; ! 199: } ! 200: raw_detach(rp); ! 201: break; ! 202: ! 203: /* ! 204: * If a socket isn't bound to a single address, ! 205: * the raw input routine will hand it anything ! 206: * within that protocol family (assuming there's ! 207: * nothing else around it should go to). ! 208: */ ! 209: case PRU_CONNECT: ! 210: if (rp->rcb_flags & RAW_FADDR) { ! 211: error = EISCONN; ! 212: break; ! 213: } ! 214: raw_connaddr(rp, nam); ! 215: soisconnected(so); ! 216: break; ! 217: ! 218: case PRU_CONNECT2: ! 219: error = EOPNOTSUPP; ! 220: goto release; ! 221: ! 222: case PRU_BIND: ! 223: if (rp->rcb_flags & RAW_LADDR) { ! 224: error = EINVAL; /* XXX */ ! 225: break; ! 226: } ! 227: error = raw_bind(so, nam); ! 228: break; ! 229: ! 230: case PRU_DISCONNECT: ! 231: if ((rp->rcb_flags & RAW_FADDR) == 0) { ! 232: error = ENOTCONN; ! 233: break; ! 234: } ! 235: raw_disconnect(rp); ! 236: soisdisconnected(so); ! 237: break; ! 238: ! 239: /* ! 240: * Mark the connection as being incapable of further input. ! 241: */ ! 242: case PRU_SHUTDOWN: ! 243: socantsendmore(so); ! 244: break; ! 245: ! 246: /* ! 247: * Ship a packet out. The appropriate raw output ! 248: * routine handles any massaging necessary. ! 249: */ ! 250: case PRU_SEND: ! 251: if (nam) { ! 252: if (rp->rcb_flags & RAW_FADDR) { ! 253: error = EISCONN; ! 254: break; ! 255: } ! 256: raw_connaddr(rp, nam); ! 257: } else if ((rp->rcb_flags & RAW_FADDR) == 0) { ! 258: error = ENOTCONN; ! 259: break; ! 260: } ! 261: error = (*so->so_proto->pr_output)(m, so); ! 262: m = NULL; ! 263: if (nam) ! 264: rp->rcb_flags &= ~RAW_FADDR; ! 265: break; ! 266: ! 267: case PRU_ABORT: ! 268: raw_disconnect(rp); ! 269: sofree(so); ! 270: soisdisconnected(so); ! 271: break; ! 272: ! 273: case PRU_SENSE: ! 274: /* ! 275: * stat: don't bother with a blocksize. ! 276: */ ! 277: return (0); ! 278: ! 279: /* ! 280: * Not supported. ! 281: */ ! 282: case PRU_RCVOOB: ! 283: case PRU_RCVD: ! 284: return(EOPNOTSUPP); ! 285: ! 286: case PRU_LISTEN: ! 287: case PRU_ACCEPT: ! 288: case PRU_SENDOOB: ! 289: error = EOPNOTSUPP; ! 290: break; ! 291: ! 292: case PRU_SOCKADDR: ! 293: bcopy((caddr_t)&rp->rcb_laddr, mtod(nam, caddr_t), ! 294: sizeof (struct sockaddr)); ! 295: nam->m_len = sizeof (struct sockaddr); ! 296: break; ! 297: ! 298: case PRU_PEERADDR: ! 299: bcopy((caddr_t)&rp->rcb_faddr, mtod(nam, caddr_t), ! 300: sizeof (struct sockaddr)); ! 301: nam->m_len = sizeof (struct sockaddr); ! 302: break; ! 303: ! 304: default: ! 305: panic("raw_usrreq"); ! 306: } ! 307: release: ! 308: if (m != NULL) ! 309: m_freem(m); ! 310: return (error); ! 311: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.