sys/kern/uipc_accf.c

   1 /*      $NetBSD: uipc_accf.c,v 1.9 2009/09/16 15:23:04 pooka Exp $      */
   2
   3 /*-
   4  * Copyright (c) 2008 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software developed for The NetBSD Foundation
   8  * by Andrew Doran.
   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 /*-
  33  * Copyright (c) 2000 Paycounter, Inc.
  34  * Copyright (c) 2005 Robert N. M. Watson
  35  * Author: Alfred Perlstein <alfred@paycounter.com>, <alfred@FreeBSD.org>
  36  * All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  * 1. Redistributions of source code must retain the above copyright
  42  *    notice, this list of conditions and the following disclaimer.
  43  * 2. Redistributions in binary form must reproduce the above copyright
  44  *    notice, this list of conditions and the following disclaimer in the
  45  *    documentation and/or other materials provided with the distribution.
  46  *
  47  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  48  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  50  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  51  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  52  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  53  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  54  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  55  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  56  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  57  * SUCH DAMAGE.
  58  */
  59
  60 #include <sys/cdefs.h>
  61 __KERNEL_RCSID(0, "$NetBSD: uipc_accf.c,v 1.9 2009/09/16 15:23:04 pooka Exp $");
  62
  63 #define ACCEPT_FILTER_MOD
  64
  65 #include <sys/param.h>
  66 #include <sys/systm.h>
  67 #include <sys/domain.h>
  68 #include <sys/kernel.h>
  69 #include <sys/lock.h>
  70 #include <sys/kmem.h>
  71 #include <sys/mbuf.h>
  72 #include <sys/rwlock.h>
  73 #include <sys/protosw.h>
  74 #include <sys/sysctl.h>
  75 #include <sys/socket.h>
  76 #include <sys/socketvar.h>
  77 #include <sys/queue.h>
  78 #include <sys/once.h>
  79 #include <sys/atomic.h>
  80 #include <sys/module.h>
  81
  82 static krwlock_t accept_filter_lock;
  83
  84 static LIST_HEAD(, accept_filter) accept_filtlsthd =
  85     LIST_HEAD_INITIALIZER(&accept_filtlsthd);
  86
  87 /*
  88  * Names of Accept filter sysctl objects
  89  */
  90 static struct sysctllog *ctllog;
  91 static void
  92 sysctl_net_inet_accf_setup(void)
  93 {
  94
  95         sysctl_createv(&ctllog, 0, NULL, NULL,
  96                        CTLFLAG_PERMANENT,
  97                        CTLTYPE_NODE, "net", NULL,
  98                        NULL, 0, NULL, 0,
  99                        CTL_NET, CTL_EOL);
 100         sysctl_createv(&ctllog, 0, NULL, NULL,
 101                        CTLFLAG_PERMANENT,
 102                        CTLTYPE_NODE, "inet", NULL,
 103                        NULL, 0, NULL, 0,
 104                        CTL_NET, PF_INET, CTL_EOL);
 105         sysctl_createv(&ctllog, 0, NULL, NULL,
 106                        CTLFLAG_PERMANENT,
 107                        CTLTYPE_NODE, "accf",
 108                        SYSCTL_DESCR("Accept filters"),
 109                        NULL, 0, NULL, 0,
 110                        CTL_NET, PF_INET, SO_ACCEPTFILTER, CTL_EOL);
 111 }
 112
 113 int
 114 accept_filt_add(struct accept_filter *filt)
 115 {
 116         struct accept_filter *p;
 117
 118         accept_filter_init();
 119
 120         rw_enter(&accept_filter_lock, RW_WRITER);
 121         LIST_FOREACH(p, &accept_filtlsthd, accf_next) {
 122                 if (strcmp(p->accf_name, filt->accf_name) == 0)  {
 123                         rw_exit(&accept_filter_lock);
 124                         return EEXIST;
 125                 }
 126         }
 127         LIST_INSERT_HEAD(&accept_filtlsthd, filt, accf_next);
 128         rw_exit(&accept_filter_lock);
 129
 130         return 0;
 131 }
 132
 133 int
 134 accept_filt_del(struct accept_filter *p)
 135 {
 136
 137         rw_enter(&accept_filter_lock, RW_WRITER);
 138         if (p->accf_refcnt != 0) {
 139                 rw_exit(&accept_filter_lock);
 140                 return EBUSY;
 141         }
 142         LIST_REMOVE(p, accf_next);
 143         rw_exit(&accept_filter_lock);
 144
 145         return 0;
 146 }
 147
 148 struct accept_filter *
 149 accept_filt_get(char *name)
 150 {
 151         struct accept_filter *p;
 152         char buf[32];
 153         u_int gen;
 154
 155         do {
 156                 rw_enter(&accept_filter_lock, RW_READER);
 157                 LIST_FOREACH(p, &accept_filtlsthd, accf_next) {
 158                         if (strcmp(p->accf_name, name) == 0) {
 159                                 atomic_inc_uint(&p->accf_refcnt);
 160                                 break;
 161                         }
 162                 }
 163                 rw_exit(&accept_filter_lock);
 164                 if (p != NULL) {
 165                         break;
 166                 }
 167                 /* Try to autoload a module to satisfy the request. */
 168                 strcpy(buf, "accf_");
 169                 strlcat(buf, name, sizeof(buf));
 170                 mutex_enter(&module_lock);
 171                 gen = module_gen;
 172                 (void)module_autoload(buf, MODULE_CLASS_ANY);
 173                 mutex_exit(&module_lock);
 174         } while (gen != module_gen);
 175
 176         return p;
 177 }
 178
 179 /*
 180  * Accept filter initialization routine.
 181  * This should be called only once.
 182  */
 183
 184 static int
 185 accept_filter_init0(void)
 186 {
 187
 188         rw_init(&accept_filter_lock);
 189         sysctl_net_inet_accf_setup();
 190
 191         return 0;
 192 }
 193
 194 /*
 195  * Initialization routine: This can also be replaced with
 196  * accept_filt_generic_mod_event for attaching new accept filter.
 197  */
 198
 199 void
 200 accept_filter_init(void)
 201 {
 202         static ONCE_DECL(accept_filter_init_once);
 203
 204         RUN_ONCE(&accept_filter_init_once, accept_filter_init0);
 205 }
 206
 207 int
 208 accept_filt_getopt(struct socket *so, struct sockopt *sopt)
 209 {
 210         struct accept_filter_arg afa;
 211         int error;
 212
 213         KASSERT(solocked(so));
 214
 215         if ((so->so_options & SO_ACCEPTCONN) == 0) {
 216                 error = EINVAL;
 217                 goto out;
 218         }
 219         if ((so->so_options & SO_ACCEPTFILTER) == 0) {
 220                 error = EINVAL;
 221                 goto out;
 222         }
 223
 224         memset(&afa, 0, sizeof(afa));
 225         strcpy(afa.af_name, so->so_accf->so_accept_filter->accf_name);
 226         if (so->so_accf->so_accept_filter_str != NULL)
 227                 strcpy(afa.af_arg, so->so_accf->so_accept_filter_str);
 228         error = sockopt_set(sopt, &afa, sizeof(afa));
 229 out:
 230         return error;
 231 }
 232
 233 /*
 234  * Simple delete case, with socket locked.
 235  */
 236 int
 237 accept_filt_clear(struct socket *so)
 238 {
 239         struct accept_filter_arg afa;
 240         struct accept_filter *afp;
 241         struct socket *so2, *next;
 242         struct so_accf *af;
 243
 244         KASSERT(solocked(so));
 245
 246         if ((so->so_options & SO_ACCEPTCONN) == 0) {
 247                 return EINVAL;
 248         }
 249         if (so->so_accf != NULL) {
 250                 /* Break in-flight processing. */
 251                 for (so2 = TAILQ_FIRST(&so->so_q0); so2 != NULL; so2 = next) {
 252                         next = TAILQ_NEXT(so2, so_qe);
 253                         if (so2->so_upcall == NULL) {
 254                                 continue;
 255                         }
 256                         so2->so_upcall = NULL;
 257                         so2->so_upcallarg = NULL;
 258                         so2->so_options &= ~SO_ACCEPTFILTER;
 259                         so2->so_rcv.sb_flags &= ~SB_UPCALL;
 260                         soisconnected(so2);
 261                 }
 262                 af = so->so_accf;
 263                 afp = af->so_accept_filter;
 264                 if (afp != NULL && afp->accf_destroy != NULL) {
 265                         (*afp->accf_destroy)(so);
 266                 }
 267                 if (af->so_accept_filter_str != NULL) {
 268                         kmem_free(af->so_accept_filter_str,
 269                             sizeof(afa.af_name));
 270                 }
 271                 kmem_free(af, sizeof(*af));
 272                 so->so_accf = NULL;
 273                 atomic_dec_uint(&afp->accf_refcnt);
 274         }
 275         so->so_options &= ~SO_ACCEPTFILTER;
 276         return 0;
 277 }
 278
 279 /*
 280  * setsockopt() for accept filters.  Called with the socket unlocked,
 281  * will always return it locked.
 282  */
 283 int
 284 accept_filt_setopt(struct socket *so, const struct sockopt *sopt)
 285 {
 286         struct accept_filter_arg afa;
 287         struct accept_filter *afp;
 288         struct so_accf *newaf;
 289         int error;
 290
 291         if (sopt == NULL || sopt->sopt_size == 0) {
 292                 solock(so);
 293                 return accept_filt_clear(so);
 294         }
 295
 296         /*
 297          * Pre-allocate any memory we may need later to avoid blocking at
 298          * untimely moments.  This does not optimize for invalid arguments.
 299          */
 300         error = sockopt_get(sopt, &afa, sizeof(afa));
 301         if (error) {
 302                 solock(so);
 303                 return error;
 304         }
 305         afa.af_name[sizeof(afa.af_name)-1] = '\0';
 306         afa.af_arg[sizeof(afa.af_arg)-1] = '\0';
 307         afp = accept_filt_get(afa.af_name);
 308         if (afp == NULL) {
 309                 solock(so);
 310                 return ENOENT;
 311         }
 312         /*
 313          * Allocate the new accept filter instance storage.  We may
 314          * have to free it again later if we fail to attach it.  If
 315          * attached properly, 'newaf' is NULLed to avoid a free()
 316          * while in use.
 317          */
 318         newaf = kmem_zalloc(sizeof(*newaf), KM_SLEEP);
 319         if (afp->accf_create != NULL && afa.af_name[0] != '\0') {
 320                 /*
 321                  * FreeBSD did a variable-size allocation here
 322                  * with the actual string length from afa.af_name
 323                  * but it is so short, why bother tracking it?
 324                  * XXX as others have noted, this is an API mistake;
 325                  * XXX accept_filter_arg should have a mandatory namelen.
 326                  * XXX (but it's a bit too late to fix that now)
 327                  */
 328                 newaf->so_accept_filter_str =
 329                     kmem_alloc(sizeof(afa.af_name), KM_SLEEP);
 330                 strcpy(newaf->so_accept_filter_str, afa.af_name);
 331         }
 332
 333         /*
 334          * Require a listen socket; don't try to replace an existing filter
 335          * without first removing it.
 336          */
 337         solock(so);
 338         if ((so->so_options & SO_ACCEPTCONN) == 0 || so->so_accf != NULL) {
 339                 error = EINVAL;
 340                 goto out;
 341         }
 342
 343         /*
 344          * Invoke the accf_create() method of the filter if required.  The
 345          * socket lock is held over this call, so create methods for filters
 346          * shouldn't block.
 347          */
 348         if (afp->accf_create != NULL) {
 349                 newaf->so_accept_filter_arg =
 350                     (*afp->accf_create)(so, afa.af_arg);
 351                 if (newaf->so_accept_filter_arg == NULL) {
 352                         error = EINVAL;
 353                         goto out;
 354                 }
 355         }
 356         newaf->so_accept_filter = afp;
 357         so->so_accf = newaf;
 358         so->so_options |= SO_ACCEPTFILTER;
 359         newaf = NULL;
 360 out:
 361         if (newaf != NULL) {
 362                 if (newaf->so_accept_filter_str != NULL)
 363                         kmem_free(newaf->so_accept_filter_str,
 364                             sizeof(afa.af_name));
 365                 kmem_free(newaf, sizeof(*newaf));
 366                 atomic_dec_uint(&afp->accf_refcnt);
 367         }
 368         return error;
 369 }