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/malloc.h> 36 #include <sys/mbuf.h> 37 #include <sys/proc.h> 38 #include <sys/priv.h> 39 #include <sys/protosw.h> 40 #include <sys/socket.h> 41 #include <sys/socketvar.h> 42 43 #include <sys/socketvar2.h> 44 #include <sys/msgport2.h> 45 46 #include <net/raw_cb.h> 47 #include <net/netisr2.h> 48 49 /* 50 * Except from the raw_init(), rest of interfaces must be called 51 * from netisr0. 52 */ 53 54 /* 55 * Initialize raw connection block q. 56 */ 57 void 58 raw_init(void) 59 { 60 LIST_INIT(&rawcb_list); 61 } 62 63 /************************************************************************ 64 * RAW PROTOCOL INTERFACE * 65 ************************************************************************/ 66 67 /* 68 * Raw protocol input routine. Find the socket associated with the packet(s) 69 * and move them over. If nothing exists for this packet, drop it. This 70 * routine is indirect called via rts_input() and will be serialized on 71 * cpu 0. 72 * 73 * Most other raw protocol interface functions are also serialized XXX. 74 */ 75 void 76 raw_input(struct mbuf *m0, const struct sockproto *proto, 77 const struct sockaddr *src, const struct sockaddr *dst, 78 const struct rawcb *skip) 79 { 80 struct rawcb *rp; 81 struct mbuf *m = m0; 82 struct socket *last; 83 84 ASSERT_NETISR0; 85 86 last = NULL; 87 88 LIST_FOREACH(rp, &rawcb_list, list) { 89 if (rp == skip) 90 continue; 91 if (rp->rcb_proto.sp_family != proto->sp_family) 92 continue; 93 if (rp->rcb_proto.sp_protocol && 94 rp->rcb_proto.sp_protocol != proto->sp_protocol) 95 continue; 96 /* 97 * We assume the lower level routines have 98 * placed the address in a canonical format 99 * suitable for a structure comparison. 100 * 101 * Note that if the lengths are not the same 102 * the comparison will fail at the first byte. 103 */ 104 if (rp->rcb_laddr && !sa_equal(rp->rcb_laddr, dst)) 105 continue; 106 if (rp->rcb_faddr && !sa_equal(rp->rcb_faddr, src)) 107 continue; 108 /* Run any filtering that may have been installed. */ 109 if (rp->rcb_filter != NULL && rp->rcb_filter(m, proto, rp) != 0) 110 continue; 111 if (last) { 112 struct mbuf *n; 113 114 n = m_copypacket(m, M_NOWAIT); 115 if (n != NULL) { 116 lwkt_gettoken(&last->so_rcv.ssb_token); 117 if (ssb_appendaddr(&last->so_rcv, src, n, 118 NULL) == 0) { 119 m_freem(n); 120 soroverflow(last); 121 } else { 122 sorwakeup(last); 123 } 124 lwkt_reltoken(&last->so_rcv.ssb_token); 125 } 126 } 127 last = rp->rcb_socket; 128 } 129 if (last) { 130 lwkt_gettoken(&last->so_rcv.ssb_token); 131 if (ssb_appendaddr(&last->so_rcv, src, m, NULL) == 0) { 132 m_freem(m); 133 soroverflow(last); 134 } else 135 sorwakeup(last); 136 lwkt_reltoken(&last->so_rcv.ssb_token); 137 } else { 138 m_freem(m); 139 } 140 } 141 142 /* 143 * nm_cmd, nm_arg, nm_extra 144 */ 145 void 146 raw_ctlinput(netmsg_t msg) 147 { 148 int error = 0; 149 150 ASSERT_NETISR0; 151 152 if (msg->ctlinput.nm_cmd < 0 || msg->ctlinput.nm_cmd > PRC_NCMDS) { 153 ; /* no-op */ 154 } 155 lwkt_replymsg(&msg->lmsg, error); 156 } 157 158 /* 159 * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort() 160 * will sofree() it when we return. 161 */ 162 static void 163 raw_uabort(netmsg_t msg) 164 { 165 struct rawcb *rp = sotorawcb(msg->base.nm_so); 166 int error; 167 168 ASSERT_NETISR0; 169 170 if (rp) { 171 raw_disconnect(rp); 172 soisdisconnected(msg->base.nm_so); 173 error = 0; 174 } else { 175 error = EINVAL; 176 } 177 lwkt_replymsg(&msg->lmsg, error); 178 } 179 180 /* pru_accept is EOPNOTSUPP */ 181 182 static void 183 raw_uattach(netmsg_t msg) 184 { 185 struct socket *so = msg->base.nm_so; 186 int proto = msg->attach.nm_proto; 187 struct pru_attach_info *ai = msg->attach.nm_ai; 188 struct rawcb *rp; 189 int error; 190 191 ASSERT_NETISR0; 192 193 rp = sotorawcb(so); 194 if (rp) { 195 error = priv_check_cred(ai->p_ucred, PRIV_ROOT, NULL_CRED_OKAY); 196 if (error == 0) 197 error = raw_attach(so, proto, ai->sb_rlimit); 198 } else { 199 error = EINVAL; 200 } 201 lwkt_replymsg(&msg->lmsg, error); 202 } 203 204 static void 205 raw_ubind(netmsg_t msg) 206 { 207 ASSERT_NETISR0; 208 lwkt_replymsg(&msg->lmsg, EINVAL); 209 } 210 211 static void 212 raw_uconnect(netmsg_t msg) 213 { 214 ASSERT_NETISR0; 215 lwkt_replymsg(&msg->lmsg, EINVAL); 216 } 217 218 /* pru_connect2 is EOPNOTSUPP */ 219 /* pru_control is EOPNOTSUPP */ 220 221 static void 222 raw_udetach(netmsg_t msg) 223 { 224 struct rawcb *rp = sotorawcb(msg->base.nm_so); 225 int error; 226 227 ASSERT_NETISR0; 228 229 if (rp) { 230 raw_detach(rp); 231 error = 0; 232 } else { 233 error = EINVAL; 234 } 235 lwkt_replymsg(&msg->lmsg, error); 236 } 237 238 static void 239 raw_udisconnect(netmsg_t msg) 240 { 241 struct socket *so = msg->base.nm_so; 242 struct rawcb *rp; 243 int error; 244 245 ASSERT_NETISR0; 246 247 rp = sotorawcb(so); 248 if (rp == NULL) { 249 error = EINVAL; 250 } else if (rp->rcb_faddr == NULL) { 251 error = ENOTCONN; 252 } else { 253 soreference(so); 254 raw_disconnect(rp); 255 soisdisconnected(so); 256 sofree(so); 257 error = 0; 258 } 259 lwkt_replymsg(&msg->lmsg, error); 260 } 261 262 /* pru_listen is EOPNOTSUPP */ 263 264 static void 265 raw_upeeraddr(netmsg_t msg) 266 { 267 struct rawcb *rp = sotorawcb(msg->base.nm_so); 268 int error; 269 270 ASSERT_NETISR0; 271 272 if (rp == NULL) { 273 error = EINVAL; 274 } else if (rp->rcb_faddr == NULL) { 275 error = ENOTCONN; 276 } else { 277 *msg->peeraddr.nm_nam = dup_sockaddr(rp->rcb_faddr); 278 error = 0; 279 } 280 lwkt_replymsg(&msg->lmsg, error); 281 } 282 283 /* pru_rcvd is EOPNOTSUPP */ 284 /* pru_rcvoob is EOPNOTSUPP */ 285 286 static void 287 raw_usend(netmsg_t msg) 288 { 289 struct socket *so = msg->base.nm_so; 290 struct mbuf *m = msg->send.nm_m; 291 struct mbuf *control = msg->send.nm_control; 292 struct rawcb *rp = sotorawcb(so); 293 struct pr_output_info oi; 294 int flags = msg->send.nm_flags; 295 int error; 296 297 ASSERT_NETISR0; 298 299 if (rp == NULL) { 300 error = EINVAL; 301 goto release; 302 } 303 304 if (flags & PRUS_OOB) { 305 error = EOPNOTSUPP; 306 goto release; 307 } 308 309 if (control && control->m_len) { 310 error = EOPNOTSUPP; 311 goto release; 312 } 313 if (msg->send.nm_addr) { 314 if (rp->rcb_faddr) { 315 error = EISCONN; 316 goto release; 317 } 318 rp->rcb_faddr = msg->send.nm_addr; 319 } else if (rp->rcb_faddr == NULL) { 320 error = ENOTCONN; 321 goto release; 322 } 323 oi.p_pid = msg->send.nm_td->td_proc->p_pid; 324 error = (*so->so_proto->pr_output)(m, so, &oi); 325 m = NULL; 326 if (msg->send.nm_addr) 327 rp->rcb_faddr = NULL; 328 release: 329 if (m != NULL) 330 m_freem(m); 331 lwkt_replymsg(&msg->lmsg, error); 332 } 333 334 /* pru_sense is null */ 335 336 static void 337 raw_ushutdown(netmsg_t msg) 338 { 339 struct rawcb *rp = sotorawcb(msg->base.nm_so); 340 int error; 341 342 ASSERT_NETISR0; 343 344 if (rp) { 345 socantsendmore(msg->base.nm_so); 346 error = 0; 347 } else { 348 error = EINVAL; 349 } 350 lwkt_replymsg(&msg->lmsg, error); 351 } 352 353 static void 354 raw_usockaddr(netmsg_t msg) 355 { 356 struct rawcb *rp = sotorawcb(msg->base.nm_so); 357 int error; 358 359 ASSERT_NETISR0; 360 361 if (rp == NULL) { 362 error = EINVAL; 363 } else if (rp->rcb_laddr == NULL) { 364 error = EINVAL; 365 } else { 366 *msg->sockaddr.nm_nam = dup_sockaddr(rp->rcb_laddr); 367 error = 0; 368 } 369 lwkt_replymsg(&msg->lmsg, error); 370 } 371 372 struct pr_usrreqs raw_usrreqs = { 373 .pru_abort = raw_uabort, 374 .pru_accept = pr_generic_notsupp, 375 .pru_attach = raw_uattach, 376 .pru_bind = raw_ubind, 377 .pru_connect = raw_uconnect, 378 .pru_connect2 = pr_generic_notsupp, 379 .pru_control = pr_generic_notsupp, 380 .pru_detach = raw_udetach, 381 .pru_disconnect = raw_udisconnect, 382 .pru_listen = pr_generic_notsupp, 383 .pru_peeraddr = raw_upeeraddr, 384 .pru_rcvd = pr_generic_notsupp, 385 .pru_rcvoob = pr_generic_notsupp, 386 .pru_send = raw_usend, 387 .pru_sense = pru_sense_null, 388 .pru_shutdown = raw_ushutdown, 389 .pru_sockaddr = raw_usockaddr, 390 .pru_sosend = sosend, 391 .pru_soreceive = soreceive 392 }; 393