1 /* $NetBSD: npf_alg.c,v 1.7 2013/02/09 03:35:31 rmind Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This material is based upon work partially supported by The 8 * NetBSD Foundation under a contract with Mindaugas Rasiukevicius. 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 * NPF interface for application level gateways (ALGs). 34 */ 35 36 #include <sys/cdefs.h> 37 __KERNEL_RCSID(0, "$NetBSD: npf_alg.c,v 1.7 2013/02/09 03:35:31 rmind Exp $"); 38 39 #include <sys/param.h> 40 #include <sys/types.h> 41 42 #include <sys/kmem.h> 43 #include <sys/pserialize.h> 44 #include <sys/mutex.h> 45 #include <net/pfil.h> 46 47 #include "npf_impl.h" 48 49 /* NAT ALG structure for registration. */ 50 struct npf_alg { 51 LIST_ENTRY(npf_alg) na_entry; 52 npf_alg_t * na_bptr; 53 npf_alg_func_t na_match_func; 54 npf_alg_func_t na_tr_func; 55 npf_alg_sfunc_t na_se_func; 56 }; 57 58 static LIST_HEAD(, npf_alg) nat_alg_list __cacheline_aligned; 59 static kmutex_t nat_alg_lock __cacheline_aligned; 60 static pserialize_t nat_alg_psz __cacheline_aligned; 61 62 void 63 npf_alg_sysinit(void) 64 { 65 66 mutex_init(&nat_alg_lock, MUTEX_DEFAULT, IPL_NONE); 67 nat_alg_psz = pserialize_create(); 68 LIST_INIT(&nat_alg_list); 69 } 70 71 void 72 npf_alg_sysfini(void) 73 { 74 75 KASSERT(LIST_EMPTY(&nat_alg_list)); 76 pserialize_destroy(nat_alg_psz); 77 mutex_destroy(&nat_alg_lock); 78 } 79 80 /* 81 * npf_alg_register: register application-level gateway. 82 */ 83 npf_alg_t * 84 npf_alg_register(npf_alg_func_t mfunc, npf_alg_func_t tfunc, 85 npf_alg_sfunc_t sfunc) 86 { 87 npf_alg_t *alg; 88 89 alg = kmem_zalloc(sizeof(npf_alg_t), KM_SLEEP); 90 alg->na_bptr = alg; 91 alg->na_match_func = mfunc; 92 alg->na_tr_func = tfunc; 93 alg->na_se_func = sfunc; 94 95 mutex_enter(&nat_alg_lock); 96 LIST_INSERT_HEAD(&nat_alg_list, alg, na_entry); 97 mutex_exit(&nat_alg_lock); 98 99 return alg; 100 } 101 102 /* 103 * npf_alg_unregister: unregister application-level gateway. 104 */ 105 int 106 npf_alg_unregister(npf_alg_t *alg) 107 { 108 mutex_enter(&nat_alg_lock); 109 LIST_REMOVE(alg, na_entry); 110 pserialize_perform(nat_alg_psz); 111 mutex_exit(&nat_alg_lock); 112 113 npf_config_enter(); 114 npf_ruleset_freealg(npf_config_natset(), alg); 115 npf_config_exit(); 116 117 kmem_free(alg, sizeof(npf_alg_t)); 118 return 0; 119 } 120 121 /* 122 * npf_alg_match: call ALG matching inspectors, determine if any ALG matches. 123 */ 124 bool 125 npf_alg_match(npf_cache_t *npc, nbuf_t *nbuf, npf_nat_t *nt, int di) 126 { 127 npf_alg_t *alg; 128 bool match = false; 129 int s; 130 131 s = pserialize_read_enter(); 132 LIST_FOREACH(alg, &nat_alg_list, na_entry) { 133 npf_alg_func_t func = alg->na_match_func; 134 135 if (func && func(npc, nbuf, nt, di)) { 136 match = true; 137 break; 138 } 139 } 140 pserialize_read_exit(s); 141 return match; 142 } 143 144 /* 145 * npf_alg_exec: execute ALG hooks for translation. 146 */ 147 void 148 npf_alg_exec(npf_cache_t *npc, nbuf_t *nbuf, npf_nat_t *nt, int di) 149 { 150 npf_alg_t *alg; 151 int s; 152 153 s = pserialize_read_enter(); 154 LIST_FOREACH(alg, &nat_alg_list, na_entry) { 155 npf_alg_func_t func; 156 157 if ((func = alg->na_tr_func) != NULL) { 158 (func)(npc, nbuf, nt, di); 159 } 160 } 161 pserialize_read_exit(s); 162 } 163 164 npf_session_t * 165 npf_alg_session(npf_cache_t *npc, nbuf_t *nbuf, int di) 166 { 167 npf_session_t *se = NULL; 168 npf_alg_t *alg; 169 int s; 170 171 s = pserialize_read_enter(); 172 LIST_FOREACH(alg, &nat_alg_list, na_entry) { 173 npf_alg_sfunc_t func = alg->na_se_func; 174 175 if (func && (se = func(npc, nbuf, di)) != NULL) { 176 break; 177 } 178 } 179 pserialize_read_exit(s); 180 return se; 181 } 182