sys/net/raw_usrreq.c

   1 /*
   2  * Copyright (c) 1980, 1986, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      @(#)raw_usrreq.c        8.1 (Berkeley) 6/10/93
  30  * $FreeBSD: src/sys/net/raw_usrreq.c,v 1.18 1999/08/28 00:48:28 peter Exp $
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/mbuf.h>
  36 #include <sys/proc.h>
  37 #include <sys/priv.h>
  38 #include <sys/protosw.h>
  39 #include <sys/socket.h>
  40 #include <sys/socketvar.h>
  41
  42 #include <sys/socketvar2.h>
  43 #include <sys/msgport2.h>
  44
  45 #include <net/raw_cb.h>
  46
  47
  48 static struct lwkt_token raw_token = LWKT_TOKEN_INITIALIZER(raw_token);
  49
  50 /*
  51  * Initialize raw connection block q.
  52  */
  53 void
  54 raw_init(void)
  55 {
  56         LIST_INIT(&rawcb_list);
  57 }
  58
  59 /************************************************************************
  60  *                       RAW PROTOCOL INTERFACE                         *
  61  ************************************************************************/
  62
  63 /*
  64  * Raw protocol input routine.  Find the socket associated with the packet(s)
  65  * and move them over.  If nothing exists for this packet, drop it.  This
  66  * routine is indirect called via rts_input() and will be serialized on
  67  * cpu 0.
  68  *
  69  * Most other raw protocol interface functions are also serialized XXX.
  70  */
  71 void
  72 raw_input(struct mbuf *m0, const struct sockproto *proto,
  73           const struct sockaddr *src, const struct sockaddr *dst,
  74           const struct rawcb *skip)
  75 {
  76         struct rawcb *rp;
  77         struct mbuf *m = m0;
  78         struct socket *last;
  79
  80         lwkt_gettoken(&raw_token);
  81
  82         last = NULL;
  83         LIST_FOREACH(rp, &rawcb_list, list) {
  84                 if (rp == skip)
  85                         continue;
  86                 if (rp->rcb_proto.sp_family != proto->sp_family)
  87                         continue;
  88                 if (rp->rcb_proto.sp_protocol  &&
  89                     rp->rcb_proto.sp_protocol != proto->sp_protocol)
  90                         continue;
  91                 /*
  92                  * We assume the lower level routines have
  93                  * placed the address in a canonical format
  94                  * suitable for a structure comparison.
  95                  *
  96                  * Note that if the lengths are not the same
  97                  * the comparison will fail at the first byte.
  98                  */
  99                 if (rp->rcb_laddr && !sa_equal(rp->rcb_laddr, dst))
 100                         continue;
 101                 if (rp->rcb_faddr && !sa_equal(rp->rcb_faddr, src))
 102                         continue;
 103                 if (last) {
 104                         struct mbuf *n;
 105
 106                         n = m_copypacket(m, M_NOWAIT);
 107                         if (n != NULL) {
 108                                 lwkt_gettoken(&last->so_rcv.ssb_token);
 109                                 if (ssb_appendaddr(&last->so_rcv, src, n,
 110                                                  NULL) == 0) {
 111                                         /* should notify about lost packet */
 112                                         m_freem(n);
 113                                 } else {
 114                                         sorwakeup(last);
 115                                 }
 116                                 lwkt_reltoken(&last->so_rcv.ssb_token);
 117                         }
 118                 }
 119                 last = rp->rcb_socket;
 120         }
 121         if (last) {
 122                 lwkt_gettoken(&last->so_rcv.ssb_token);
 123                 if (ssb_appendaddr(&last->so_rcv, src, m, NULL) == 0)
 124                         m_freem(m);
 125                 else
 126                         sorwakeup(last);
 127                 lwkt_reltoken(&last->so_rcv.ssb_token);
 128         } else {
 129                 m_freem(m);
 130         }
 131         lwkt_reltoken(&raw_token);
 132 }
 133
 134 /*
 135  * nm_cmd, nm_arg, nm_extra
 136  */
 137 void
 138 raw_ctlinput(netmsg_t msg)
 139 {
 140         int error = 0;
 141
 142         if (msg->ctlinput.nm_cmd < 0 || msg->ctlinput.nm_cmd > PRC_NCMDS)
 143                 ;
 144         lwkt_replymsg(&msg->lmsg, error);
 145 }
 146
 147 /*
 148  * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort()
 149  *       will sofree() it when we return.
 150  */
 151 static void
 152 raw_uabort(netmsg_t msg)
 153 {
 154         struct rawcb *rp = sotorawcb(msg->base.nm_so);
 155         int error;
 156
 157         if (rp) {
 158                 raw_disconnect(rp);
 159                 soisdisconnected(msg->base.nm_so);
 160                 error = 0;
 161         } else {
 162                 error = EINVAL;
 163         }
 164         lwkt_replymsg(&msg->lmsg, error);
 165 }
 166
 167 /* pru_accept is EOPNOTSUPP */
 168
 169 static void
 170 raw_uattach(netmsg_t msg)
 171 {
 172         struct socket *so = msg->base.nm_so;
 173         int proto = msg->attach.nm_proto;
 174         struct pru_attach_info *ai = msg->attach.nm_ai;
 175         struct rawcb *rp;
 176         int error;
 177
 178         rp = sotorawcb(so);
 179         if (rp) {
 180                 error = priv_check_cred(ai->p_ucred, PRIV_ROOT, NULL_CRED_OKAY);
 181                 if (error == 0)
 182                         error = raw_attach(so, proto, ai->sb_rlimit);
 183         } else {
 184                 error = EINVAL;
 185         }
 186         lwkt_replymsg(&msg->lmsg, error);
 187 }
 188
 189 static void
 190 raw_ubind(netmsg_t msg)
 191 {
 192         lwkt_replymsg(&msg->lmsg, EINVAL);
 193 }
 194
 195 static void
 196 raw_uconnect(netmsg_t msg)
 197 {
 198         lwkt_replymsg(&msg->lmsg, EINVAL);
 199 }
 200
 201 /* pru_connect2 is EOPNOTSUPP */
 202 /* pru_control is EOPNOTSUPP */
 203
 204 static void
 205 raw_udetach(netmsg_t msg)
 206 {
 207         struct rawcb *rp = sotorawcb(msg->base.nm_so);
 208         int error;
 209
 210         if (rp) {
 211                 raw_detach(rp);
 212                 error = 0;
 213         } else {
 214                 error = EINVAL;
 215         }
 216         lwkt_replymsg(&msg->lmsg, error);
 217 }
 218
 219 static void
 220 raw_udisconnect(netmsg_t msg)
 221 {
 222         struct socket *so = msg->base.nm_so;
 223         struct rawcb *rp;
 224         int error;
 225
 226         rp = sotorawcb(so);
 227         if (rp == NULL) {
 228                 error = EINVAL;
 229         } else if (rp->rcb_faddr == NULL) {
 230                 error = ENOTCONN;
 231         } else {
 232                 soreference(so);
 233                 raw_disconnect(rp);
 234                 soisdisconnected(so);
 235                 sofree(so);
 236                 error = 0;
 237         }
 238         lwkt_replymsg(&msg->lmsg, error);
 239 }
 240
 241 /* pru_listen is EOPNOTSUPP */
 242
 243 static void
 244 raw_upeeraddr(netmsg_t msg)
 245 {
 246         struct rawcb *rp = sotorawcb(msg->base.nm_so);
 247         int error;
 248
 249         if (rp == NULL) {
 250                 error = EINVAL;
 251         } else if (rp->rcb_faddr == NULL) {
 252                 error = ENOTCONN;
 253         } else {
 254                 *msg->peeraddr.nm_nam = dup_sockaddr(rp->rcb_faddr);
 255                 error = 0;
 256         }
 257         lwkt_replymsg(&msg->lmsg, error);
 258 }
 259
 260 /* pru_rcvd is EOPNOTSUPP */
 261 /* pru_rcvoob is EOPNOTSUPP */
 262
 263 static void
 264 raw_usend(netmsg_t msg)
 265 {
 266         struct socket *so = msg->base.nm_so;
 267         struct mbuf *m = msg->send.nm_m;
 268         struct mbuf *control = msg->send.nm_control;
 269         struct rawcb *rp = sotorawcb(so);
 270         struct pr_output_info oi;
 271         int flags = msg->send.nm_flags;
 272         int error;
 273
 274         if (rp == NULL) {
 275                 error = EINVAL;
 276                 goto release;
 277         }
 278
 279         if (flags & PRUS_OOB) {
 280                 error = EOPNOTSUPP;
 281                 goto release;
 282         }
 283
 284         if (control && control->m_len) {
 285                 error = EOPNOTSUPP;
 286                 goto release;
 287         }
 288         if (msg->send.nm_addr) {
 289                 if (rp->rcb_faddr) {
 290                         error = EISCONN;
 291                         goto release;
 292                 }
 293                 rp->rcb_faddr = msg->send.nm_addr;
 294         } else if (rp->rcb_faddr == NULL) {
 295                 error = ENOTCONN;
 296                 goto release;
 297         }
 298         oi.p_pid = msg->send.nm_td->td_proc->p_pid;
 299         error = (*so->so_proto->pr_output)(m, so, &oi);
 300         m = NULL;
 301         if (msg->send.nm_addr)
 302                 rp->rcb_faddr = NULL;
 303 release:
 304         if (m != NULL)
 305                 m_freem(m);
 306         lwkt_replymsg(&msg->lmsg, error);
 307 }
 308
 309 /* pru_sense is null */
 310
 311 static void
 312 raw_ushutdown(netmsg_t msg)
 313 {
 314         struct rawcb *rp = sotorawcb(msg->base.nm_so);
 315         int error;
 316
 317         if (rp) {
 318                 socantsendmore(msg->base.nm_so);
 319                 error = 0;
 320         } else {
 321                 error = EINVAL;
 322         }
 323         lwkt_replymsg(&msg->lmsg, error);
 324 }
 325
 326 static void
 327 raw_usockaddr(netmsg_t msg)
 328 {
 329         struct rawcb *rp = sotorawcb(msg->base.nm_so);
 330         int error;
 331
 332         if (rp == NULL) {
 333                 error = EINVAL;
 334         } else if (rp->rcb_laddr == NULL) {
 335                 error = EINVAL;
 336         } else {
 337                 *msg->sockaddr.nm_nam = dup_sockaddr(rp->rcb_laddr);
 338                 error = 0;
 339         }
 340         lwkt_replymsg(&msg->lmsg, error);
 341 }
 342
 343 struct pr_usrreqs raw_usrreqs = {
 344         .pru_abort = raw_uabort,
 345         .pru_accept = pr_generic_notsupp,
 346         .pru_attach = raw_uattach,
 347         .pru_bind = raw_ubind,
 348         .pru_connect = raw_uconnect,
 349         .pru_connect2 = pr_generic_notsupp,
 350         .pru_control = pr_generic_notsupp,
 351         .pru_detach = raw_udetach,
 352         .pru_disconnect = raw_udisconnect,
 353         .pru_listen = pr_generic_notsupp,
 354         .pru_peeraddr = raw_upeeraddr,
 355         .pru_rcvd = pr_generic_notsupp,
 356         .pru_rcvoob = pr_generic_notsupp,
 357         .pru_send = raw_usend,
 358         .pru_sense = pru_sense_null,
 359         .pru_shutdown = raw_ushutdown,
 360         .pru_sockaddr = raw_usockaddr,
 361         .pru_sosend = sosend,
 362         .pru_soreceive = soreceive
 363 };