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