1 /* $NetBSD: can_pcb.c,v 1.8 2019/07/20 15:34:41 bouyer Exp $ */ 2 3 /*- 4 * Copyright (c) 2003, 2017 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Robert Swindells and Manuel Bouyer 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: can_pcb.c,v 1.8 2019/07/20 15:34:41 bouyer Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/malloc.h> 38 #include <sys/kmem.h> 39 #include <sys/mbuf.h> 40 #include <sys/protosw.h> 41 #include <sys/socket.h> 42 #include <sys/socketvar.h> 43 #include <sys/ioctl.h> 44 #include <sys/errno.h> 45 #include <sys/time.h> 46 #include <sys/pool.h> 47 #include <sys/proc.h> 48 49 #include <net/if.h> 50 #include <net/route.h> 51 52 #include <netcan/can.h> 53 #include <netcan/can_var.h> 54 #include <netcan/can_pcb.h> 55 56 #define CANPCBHASH_BIND(table, ifindex) \ 57 &(table)->canpt_bindhashtbl[ \ 58 (ifindex) & (table)->canpt_bindhash] 59 #define CANPCBHASH_CONNECT(table, ifindex) \ 60 &(table)->canpt_connecthashtbl[ \ 61 (ifindex) & (table)->canpt_bindhash] 62 63 struct pool canpcb_pool; 64 65 void 66 can_pcbinit(struct canpcbtable *table, int bindhashsize, int connecthashsize) 67 { 68 static int canpcb_pool_initialized; 69 70 if (canpcb_pool_initialized == 0) { 71 pool_init(&canpcb_pool, sizeof(struct canpcb), 0, 0, 0, 72 "canpcbpl", NULL, IPL_SOFTNET); 73 canpcb_pool_initialized = 1; 74 } 75 76 TAILQ_INIT(&table->canpt_queue); 77 table->canpt_bindhashtbl = hashinit(bindhashsize, HASH_LIST, true, 78 &table->canpt_bindhash); 79 table->canpt_connecthashtbl = hashinit(connecthashsize, HASH_LIST, 80 true, &table->canpt_connecthash); 81 } 82 83 int 84 can_pcballoc(struct socket *so, void *v) 85 { 86 struct canpcbtable *table = v; 87 struct canpcb *canp; 88 struct can_filter *can_init_filter; 89 int s; 90 91 can_init_filter = kmem_alloc(sizeof(struct can_filter), KM_NOSLEEP); 92 if (can_init_filter == NULL) 93 return (ENOBUFS); 94 can_init_filter->can_id = 0; 95 can_init_filter->can_mask = 0; /* accept all by default */ 96 97 s = splnet(); 98 canp = pool_get(&canpcb_pool, PR_NOWAIT); 99 splx(s); 100 if (canp == NULL) { 101 kmem_free(can_init_filter, sizeof(struct can_filter)); 102 return (ENOBUFS); 103 } 104 memset(canp, 0, sizeof(*canp)); 105 canp->canp_table = table; 106 canp->canp_socket = so; 107 canp->canp_filters = can_init_filter; 108 canp->canp_nfilters = 1; 109 mutex_init(&canp->canp_mtx, MUTEX_DEFAULT, IPL_NET); 110 canp->canp_refcount = 1; 111 112 so->so_pcb = canp; 113 mutex_enter(&canp->canp_mtx); 114 TAILQ_INSERT_HEAD(&table->canpt_queue, canp, canp_queue); 115 can_pcbstate(canp, CANP_ATTACHED); 116 mutex_exit(&canp->canp_mtx); 117 return (0); 118 } 119 120 int 121 can_pcbbind(void *v, struct sockaddr_can *scan, struct lwp *l) 122 { 123 struct canpcb *canp = v; 124 125 if (scan->can_family != AF_CAN) 126 return (EAFNOSUPPORT); 127 if (scan->can_len != sizeof(*scan)) 128 return EINVAL; 129 mutex_enter(&canp->canp_mtx); 130 if (scan->can_ifindex != 0) { 131 canp->canp_ifp = if_byindex(scan->can_ifindex); 132 if (canp->canp_ifp == NULL || 133 canp->canp_ifp->if_dlt != DLT_CAN_SOCKETCAN) { 134 canp->canp_ifp = NULL; 135 mutex_exit(&canp->canp_mtx); 136 return (EADDRNOTAVAIL); 137 } 138 soisconnected(canp->canp_socket); 139 } else { 140 canp->canp_ifp = NULL; 141 canp->canp_socket->so_state &= ~SS_ISCONNECTED; /* XXX */ 142 } 143 can_pcbstate(canp, CANP_BOUND); 144 mutex_exit(&canp->canp_mtx); 145 return 0; 146 } 147 148 /* 149 * Connect from a socket to a specified address. 150 */ 151 int 152 can_pcbconnect(void *v, struct sockaddr_can *scan) 153 { 154 #if 0 155 struct canpcb *canp = v; 156 struct sockaddr_can *ifaddr = NULL; 157 int error; 158 #endif 159 160 if (scan->can_family != AF_CAN) 161 return (EAFNOSUPPORT); 162 if (scan->can_len != sizeof(*scan)) 163 return EINVAL; 164 #if 0 165 mutex_enter(&canp->canp_mtx); 166 memcpy(&canp->canp_dst, scan, sizeof(struct sockaddr_can)); 167 can_pcbstate(canp, CANP_CONNECTED); 168 mutex_exit(&canp->canp_mtx); 169 return 0; 170 #endif 171 return EOPNOTSUPP; 172 } 173 174 void 175 can_pcbdisconnect(void *v) 176 { 177 struct canpcb *canp = v; 178 179 mutex_enter(&canp->canp_mtx); 180 can_pcbstate(canp, CANP_DETACHED); 181 mutex_exit(&canp->canp_mtx); 182 if (canp->canp_socket->so_state & SS_NOFDREF) 183 can_pcbdetach(canp); 184 } 185 186 void 187 can_pcbdetach(void *v) 188 { 189 struct canpcb *canp = v; 190 struct socket *so = canp->canp_socket; 191 192 KASSERT(mutex_owned(softnet_lock)); 193 so->so_pcb = NULL; 194 mutex_enter(&canp->canp_mtx); 195 can_pcbstate(canp, CANP_DETACHED); 196 mutex_exit(&canp->canp_mtx); 197 can_pcbsetfilter(canp, NULL, 0); 198 TAILQ_REMOVE(&canp->canp_table->canpt_queue, canp, canp_queue); 199 sofree(so); /* sofree drops the softnet_lock */ 200 canp_unref(canp); 201 mutex_enter(softnet_lock); 202 } 203 204 void 205 canp_ref(struct canpcb *canp) 206 { 207 KASSERT(mutex_owned(&canp->canp_mtx)); 208 canp->canp_refcount++; 209 } 210 211 void 212 canp_unref(struct canpcb *canp) 213 { 214 mutex_enter(&canp->canp_mtx); 215 canp->canp_refcount--; 216 KASSERT(canp->canp_refcount >= 0); 217 if (canp->canp_refcount > 0) { 218 mutex_exit(&canp->canp_mtx); 219 return; 220 } 221 mutex_exit(&canp->canp_mtx); 222 mutex_destroy(&canp->canp_mtx); 223 pool_put(&canpcb_pool, canp); 224 } 225 226 void 227 can_setsockaddr(struct canpcb *canp, struct sockaddr_can *scan) 228 { 229 230 mutex_enter(&canp->canp_mtx); 231 memset(scan, 0, sizeof (*scan)); 232 scan->can_family = AF_CAN; 233 scan->can_len = sizeof(*scan); 234 if (canp->canp_ifp) 235 scan->can_ifindex = canp->canp_ifp->if_index; 236 else 237 scan->can_ifindex = 0; 238 mutex_exit(&canp->canp_mtx); 239 } 240 241 int 242 can_pcbsetfilter(struct canpcb *canp, struct can_filter *fp, int nfilters) 243 { 244 245 struct can_filter *newf; 246 struct can_filter *oldf; 247 int oldnf; 248 int error = 0; 249 250 if (nfilters > 0) { 251 newf = 252 kmem_alloc(sizeof(struct can_filter) * nfilters, KM_SLEEP); 253 memcpy(newf, fp, sizeof(struct can_filter) * nfilters); 254 } else { 255 newf = NULL; 256 } 257 mutex_enter(&canp->canp_mtx); 258 oldf = canp->canp_filters; 259 oldnf = canp->canp_nfilters; 260 if (newf != NULL && canp->canp_state == CANP_DETACHED) { 261 error = ECONNRESET; 262 } else { 263 canp->canp_filters = newf; 264 canp->canp_nfilters = nfilters; 265 newf = NULL; 266 } 267 mutex_exit(&canp->canp_mtx); 268 if (oldf != NULL) { 269 kmem_free(oldf, sizeof(struct can_filter) * oldnf); 270 } 271 if (newf != NULL) { 272 kmem_free(newf, sizeof(struct can_filter) * nfilters); 273 } 274 return error; 275 } 276 277 278 279 #if 0 280 /* 281 * Pass some notification to all connections of a protocol 282 * associated with address dst. The local address and/or port numbers 283 * may be specified to limit the search. The "usual action" will be 284 * taken, depending on the ctlinput cmd. The caller must filter any 285 * cmds that are uninteresting (e.g., no error in the map). 286 * Call the protocol specific routine (if any) to report 287 * any errors for each matching socket. 288 * 289 * Must be called at splsoftnet. 290 */ 291 int 292 can_pcbnotify(struct canpcbtable *table, u_int32_t faddr, u_int32_t laddr, 293 int errno, void (*notify)(struct canpcb *, int)) 294 { 295 struct canpcbhead *head; 296 struct canpcb *canp, *ncanp; 297 int nmatch; 298 299 if (faddr == 0 || notify == 0) 300 return (0); 301 302 nmatch = 0; 303 head = CANPCBHASH_CONNECT(table, faddr, laddr); 304 for (canp = LIST_FIRST(head); canp != NULL; canp = ncanp) { 305 ncanp = LIST_NEXT(canp, canp_hash); 306 if (canp->canp_faddr == faddr && 307 canp->canp_laddr == laddr) { 308 (*notify)(canp, errno); 309 nmatch++; 310 } 311 } 312 return (nmatch); 313 } 314 315 void 316 can_pcbnotifyall(struct canpcbtable *table, u_int32_t faddr, int errno, 317 void (*notify)(struct canpcb *, int)) 318 { 319 struct canpcb *canp, *ncanp; 320 321 if (faddr == 0 || notify == 0) 322 return; 323 324 TAILQ_FOREACH_SAFE(canp, &table->canpt_queue, canp_queue, ncanp) { 325 if (canp->canp_faddr == faddr) 326 (*notify)(canp, errno); 327 } 328 } 329 #endif 330 331 #if 0 332 void 333 can_pcbpurgeif0(struct canpcbtable *table, struct ifnet *ifp) 334 { 335 struct canpcb *canp, *ncanp; 336 struct ip_moptions *imo; 337 int i, gap; 338 339 } 340 341 void 342 can_pcbpurgeif(struct canpcbtable *table, struct ifnet *ifp) 343 { 344 struct canpcb *canp, *ncanp; 345 346 for (canp = CIRCLEQ_FIRST(&table->canpt_queue); 347 canp != (void *)&table->canpt_queue; 348 canp = ncanp) { 349 ncanp = CIRCLEQ_NEXT(canp, canp_queue); 350 } 351 } 352 #endif 353 354 355 356 void 357 can_pcbstate(struct canpcb *canp, int state) 358 { 359 int ifindex = canp->canp_ifp ? canp->canp_ifp->if_index : 0; 360 KASSERT(mutex_owned(&canp->canp_mtx)); 361 362 if (canp->canp_state > CANP_ATTACHED) 363 LIST_REMOVE(canp, canp_hash); 364 365 switch (state) { 366 case CANP_BOUND: 367 LIST_INSERT_HEAD(CANPCBHASH_BIND(canp->canp_table, 368 ifindex), canp, canp_hash); 369 break; 370 case CANP_CONNECTED: 371 LIST_INSERT_HEAD(CANPCBHASH_CONNECT(canp->canp_table, 372 ifindex), canp, canp_hash); 373 break; 374 } 375 376 canp->canp_state = state; 377 } 378 379 /* 380 * check mbuf against socket accept filter. 381 * returns true if mbuf is accepted, false otherwise 382 */ 383 bool 384 can_pcbfilter(struct canpcb *canp, struct mbuf *m) 385 { 386 int i; 387 struct can_frame *fmp; 388 struct can_filter *fip; 389 390 KASSERT(mutex_owned(&canp->canp_mtx)); 391 KASSERT((m->m_flags & M_PKTHDR) != 0); 392 KASSERT(m->m_len == m->m_pkthdr.len); 393 394 fmp = mtod(m, struct can_frame *); 395 for (i = 0; i < canp->canp_nfilters; i++) { 396 fip = &canp->canp_filters[i]; 397 if ((fmp->can_id & fip->can_mask) == fip->can_id) 398 return true; 399 } 400 /* no match */ 401 return false; 402 } 403
Indexes created Sun Sep 21 20:09:37 GMT 2025