sys/net/raw_usrreq.c

   1 /*-
   2  * Copyright (c) 1980, 1986, 1993
   3  *      The Regents of the University of California.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 4. Neither the name of the University nor the names of its contributors
  15  *    may be used to endorse or promote products derived from this software
  16  *    without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  *      @(#)raw_usrreq.c        8.1 (Berkeley) 6/10/93
  31  * $FreeBSD$
  32  */
  33
  34 #include <sys/param.h>
  35 #include <sys/kernel.h>
  36 #include <sys/lock.h>
  37 #include <sys/malloc.h>
  38 #include <sys/mbuf.h>
  39 #include <sys/mutex.h>
  40 #include <sys/priv.h>
  41 #include <sys/protosw.h>
  42 #include <sys/signalvar.h>
  43 #include <sys/socket.h>
  44 #include <sys/socketvar.h>
  45 #include <sys/sx.h>
  46 #include <sys/systm.h>
  47
  48 #include <net/if.h>
  49 #include <net/raw_cb.h>
  50 #include <net/vnet.h>
  51
  52 MTX_SYSINIT(rawcb_mtx, &rawcb_mtx, "rawcb", MTX_DEF);
  53
  54 /*
  55  * Initialize raw connection block q.
  56  */
  57 void
  58 raw_init(void)
  59 {
  60
  61         LIST_INIT(&V_rawcb_list);
  62 }
  63
  64 /*
  65  * Raw protocol input routine.  Find the socket associated with the packet(s)
  66  * and move them over.  If nothing exists for this packet, drop it.
  67  */
  68 /*
  69  * Raw protocol interface.
  70  */
  71 void
  72 raw_input(struct mbuf *m0, struct sockproto *proto, struct sockaddr *src)
  73 {
  74         struct rawcb *rp;
  75         struct mbuf *m = m0;
  76         struct socket *last;
  77
  78         last = 0;
  79         mtx_lock(&rawcb_mtx);
  80         LIST_FOREACH(rp, &V_rawcb_list, list) {
  81                 if (rp->rcb_proto.sp_family != proto->sp_family)
  82                         continue;
  83                 if (rp->rcb_proto.sp_protocol  &&
  84                     rp->rcb_proto.sp_protocol != proto->sp_protocol)
  85                         continue;
  86                 if (last) {
  87                         struct mbuf *n;
  88                         n = m_copy(m, 0, (int)M_COPYALL);
  89                         if (n) {
  90                                 if (sbappendaddr(&last->so_rcv, src,
  91                                     n, (struct mbuf *)0) == 0)
  92                                         /* should notify about lost packet */
  93                                         m_freem(n);
  94                                 else
  95                                         sorwakeup(last);
  96                         }
  97                 }
  98                 last = rp->rcb_socket;
  99         }
 100         if (last) {
 101                 if (sbappendaddr(&last->so_rcv, src,
 102                     m, (struct mbuf *)0) == 0)
 103                         m_freem(m);
 104                 else
 105                         sorwakeup(last);
 106         } else
 107                 m_freem(m);
 108         mtx_unlock(&rawcb_mtx);
 109 }
 110
 111 /*ARGSUSED*/
 112 void
 113 raw_ctlinput(int cmd, struct sockaddr *arg, void *dummy)
 114 {
 115
 116         if (cmd < 0 || cmd >= PRC_NCMDS)
 117                 return;
 118         /* INCOMPLETE */
 119 }
 120
 121 static void
 122 raw_uabort(struct socket *so)
 123 {
 124
 125         KASSERT(sotorawcb(so) != NULL, ("raw_uabort: rp == NULL"));
 126
 127         soisdisconnected(so);
 128 }
 129
 130 static void
 131 raw_uclose(struct socket *so)
 132 {
 133
 134         KASSERT(sotorawcb(so) != NULL, ("raw_uabort: rp == NULL"));
 135
 136         soisdisconnected(so);
 137 }
 138
 139 /* pru_accept is EOPNOTSUPP */
 140
 141 static int
 142 raw_uattach(struct socket *so, int proto, struct thread *td)
 143 {
 144         int error;
 145
 146         /*
 147          * Implementors of raw sockets will already have allocated the PCB,
 148          * so it must be non-NULL here.
 149          */
 150         KASSERT(sotorawcb(so) != NULL, ("raw_uattach: so_pcb == NULL"));
 151
 152         if (td != NULL) {
 153                 error = priv_check(td, PRIV_NET_RAW);
 154                 if (error)
 155                         return (error);
 156         }
 157         return (raw_attach(so, proto));
 158 }
 159
 160 static int
 161 raw_ubind(struct socket *so, struct sockaddr *nam, struct thread *td)
 162 {
 163
 164         return (EINVAL);
 165 }
 166
 167 static int
 168 raw_uconnect(struct socket *so, struct sockaddr *nam, struct thread *td)
 169 {
 170
 171         return (EINVAL);
 172 }
 173
 174 /* pru_connect2 is EOPNOTSUPP */
 175 /* pru_control is EOPNOTSUPP */
 176
 177 static void
 178 raw_udetach(struct socket *so)
 179 {
 180         struct rawcb *rp = sotorawcb(so);
 181
 182         KASSERT(rp != NULL, ("raw_udetach: rp == NULL"));
 183
 184         raw_detach(rp);
 185 }
 186
 187 static int
 188 raw_udisconnect(struct socket *so)
 189 {
 190
 191         KASSERT(sotorawcb(so) != NULL, ("raw_udisconnect: rp == NULL"));
 192
 193         return (ENOTCONN);
 194 }
 195
 196 /* pru_listen is EOPNOTSUPP */
 197
 198 static int
 199 raw_upeeraddr(struct socket *so, struct sockaddr **nam)
 200 {
 201
 202         KASSERT(sotorawcb(so) != NULL, ("raw_upeeraddr: rp == NULL"));
 203
 204         return (ENOTCONN);
 205 }
 206
 207 /* pru_rcvd is EOPNOTSUPP */
 208 /* pru_rcvoob is EOPNOTSUPP */
 209
 210 static int
 211 raw_usend(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
 212     struct mbuf *control, struct thread *td)
 213 {
 214
 215         KASSERT(sotorawcb(so) != NULL, ("raw_usend: rp == NULL"));
 216
 217         if ((flags & PRUS_OOB) || (control && control->m_len)) {
 218                 /* XXXRW: Should control also be freed here? */
 219                 if (m != NULL)
 220                         m_freem(m);
 221                 return (EOPNOTSUPP);
 222         }
 223
 224         /*
 225          * For historical (bad?) reasons, we effectively ignore the address
 226          * argument to sendto(2).  Perhaps we should return an error instead?
 227          */
 228         return ((*so->so_proto->pr_output)(m, so));
 229 }
 230
 231 /* pru_sense is null */
 232
 233 static int
 234 raw_ushutdown(struct socket *so)
 235 {
 236
 237         KASSERT(sotorawcb(so) != NULL, ("raw_ushutdown: rp == NULL"));
 238
 239         socantsendmore(so);
 240         return (0);
 241 }
 242
 243 static int
 244 raw_usockaddr(struct socket *so, struct sockaddr **nam)
 245 {
 246
 247         KASSERT(sotorawcb(so) != NULL, ("raw_usockaddr: rp == NULL"));
 248
 249         return (EINVAL);
 250 }
 251
 252 struct pr_usrreqs raw_usrreqs = {
 253         .pru_abort =            raw_uabort,
 254         .pru_attach =           raw_uattach,
 255         .pru_bind =             raw_ubind,
 256         .pru_connect =          raw_uconnect,
 257         .pru_detach =           raw_udetach,
 258         .pru_disconnect =       raw_udisconnect,
 259         .pru_peeraddr =         raw_upeeraddr,
 260         .pru_send =             raw_usend,
 261         .pru_shutdown =         raw_ushutdown,
 262         .pru_sockaddr =         raw_usockaddr,
 263         .pru_close =            raw_uclose,
 264 };