?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
5734 IPFGENITER needs to know when to hit the brakes
[illumos-gate.git] / usr / src / uts / common / inet / ipf / ip_nat.c
blobb556d0983e3acffc4b44343ec53f1fc30df73ff0
1 /*
2 * Copyright (C) 1995-2004 by Darren Reed.
3 *
4 * See the IPFILTER.LICENCE file for details on licencing.
5 *
6 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
7 * Use is subject to license terms.
8 */
9
10 #if defined(KERNEL) || defined(_KERNEL)
11 # undef KERNEL
12 # undef _KERNEL
13 # define KERNEL 1
14 # define _KERNEL 1
15 #endif
16 #include <sys/errno.h>
17 #include <sys/types.h>
18 #include <sys/param.h>
19 #include <sys/time.h>
20 #include <sys/file.h>
21 #if defined(__NetBSD__) && (NetBSD >= 199905) && !defined(IPFILTER_LKM) && \
22 defined(_KERNEL)
23 # include "opt_ipfilter_log.h"
24 #endif
25 #if !defined(_KERNEL)
26 # include <stdio.h>
27 # include <string.h>
28 # include <stdlib.h>
29 # define _KERNEL
30 # ifdef __OpenBSD__
31 struct file;
32 # endif
33 # include <sys/uio.h>
34 # undef _KERNEL
35 #endif
36 #if defined(_KERNEL) && (__FreeBSD_version >= 220000)
37 # include <sys/filio.h>
38 # include <sys/fcntl.h>
39 #else
40 # include <sys/ioctl.h>
41 #endif
42 #if !defined(AIX)
43 # include <sys/fcntl.h>
44 #endif
45 #if !defined(linux)
46 # include <sys/protosw.h>
47 #endif
48 #include <sys/socket.h>
49 #if defined(_KERNEL)
50 # include <sys/systm.h>
51 # if !defined(__SVR4) && !defined(__svr4__)
52 # include <sys/mbuf.h>
53 # endif
54 #endif
55 #if defined(__SVR4) || defined(__svr4__)
56 # include <sys/filio.h>
57 # include <sys/byteorder.h>
58 # ifdef _KERNEL
59 # include <sys/dditypes.h>
60 # endif
61 # include <sys/stream.h>
62 # include <sys/kmem.h>
63 #endif
64 #if __FreeBSD_version >= 300000
65 # include <sys/queue.h>
66 #endif
67 #include <net/if.h>
68 #if __FreeBSD_version >= 300000
69 # include <net/if_var.h>
70 # if defined(_KERNEL) && !defined(IPFILTER_LKM)
71 # include "opt_ipfilter.h"
72 # endif
73 #endif
74 #ifdef sun
75 # include <net/af.h>
76 #endif
77 #include <net/route.h>
78 #include <netinet/in.h>
79 #include <netinet/in_systm.h>
80 #include <netinet/ip.h>
81
82 #ifdef RFC1825
83 # include <vpn/md5.h>
84 # include <vpn/ipsec.h>
85 extern struct ifnet vpnif;
86 #endif
87
88 #if !defined(linux)
89 # include <netinet/ip_var.h>
90 #endif
91 #include <netinet/tcp.h>
92 #include <netinet/udp.h>
93 #include <netinet/ip_icmp.h>
94 #include "netinet/ip_compat.h"
95 #include <netinet/tcpip.h>
96 #include "netinet/ip_fil.h"
97 #include "netinet/ip_nat.h"
98 #include "netinet/ip_frag.h"
99 #include "netinet/ip_state.h"
100 #include "netinet/ip_proxy.h"
101 #include "netinet/ipf_stack.h"
102 #ifdef IPFILTER_SYNC
103 #include "netinet/ip_sync.h"
104 #endif
105 #if (__FreeBSD_version >= 300000)
106 # include <sys/malloc.h>
107 #endif
108 /* END OF INCLUDES */
109
110 #undef SOCKADDR_IN
111 #define SOCKADDR_IN struct sockaddr_in
112
113 #if !defined(lint)
114 static const char sccsid[] = "@(#)ip_nat.c 1.11 6/5/96 (C) 1995 Darren Reed";
115 static const char rcsid[] = "@(#)$Id: ip_nat.c,v 2.195.2.42 2005/08/11 19:51:36 darrenr Exp $";
116 #endif
117
118
119 /* ======================================================================== */
120 /* How the NAT is organised and works. */
121 /* */
122 /* Inside (interface y) NAT Outside (interface x) */
123 /* -------------------- -+- ------------------------------------- */
124 /* Packet going | out, processsed by fr_checknatout() for x */
125 /* ------------> | ------------> */
126 /* src=10.1.1.1 | src=192.1.1.1 */
127 /* | */
128 /* | in, processed by fr_checknatin() for x */
129 /* <------------ | <------------ */
130 /* dst=10.1.1.1 | dst=192.1.1.1 */
131 /* -------------------- -+- ------------------------------------- */
132 /* fr_checknatout() - changes ip_src and if required, sport */
133 /* - creates a new mapping, if required. */
134 /* fr_checknatin() - changes ip_dst and if required, dport */
135 /* */
136 /* In the NAT table, internal source is recorded as "in" and externally */
137 /* seen as "out". */
138 /* ======================================================================== */
139
140
141 static int nat_clearlist __P((ipf_stack_t *));
142 static void nat_addnat __P((struct ipnat *, ipf_stack_t *));
143 static void nat_addrdr __P((struct ipnat *, ipf_stack_t *));
144 static int fr_natgetent __P((caddr_t, ipf_stack_t *));
145 static int fr_natgetsz __P((caddr_t, ipf_stack_t *));
146 static int fr_natputent __P((caddr_t, int, ipf_stack_t *));
147 static void nat_tabmove __P((nat_t *, ipf_stack_t *));
148 static int nat_match __P((fr_info_t *, ipnat_t *));
149 static INLINE int nat_newmap __P((fr_info_t *, nat_t *, natinfo_t *));
150 static INLINE int nat_newrdr __P((fr_info_t *, nat_t *, natinfo_t *));
151 static hostmap_t *nat_hostmap __P((ipnat_t *, struct in_addr,
152 struct in_addr, struct in_addr, u_32_t,
153 ipf_stack_t *));
154 static INLINE int nat_icmpquerytype4 __P((int));
155 static int nat_ruleaddrinit __P((ipnat_t *));
156 static int nat_siocaddnat __P((ipnat_t *, ipnat_t **, int, ipf_stack_t *));
157 static void nat_siocdelnat __P((ipnat_t *, ipnat_t **, int, ipf_stack_t *));
158 static INLINE int nat_icmperrortype4 __P((int));
159 static INLINE int nat_finalise __P((fr_info_t *, nat_t *, natinfo_t *,
160 tcphdr_t *, nat_t **, int));
161 static INLINE int nat_resolverule __P((ipnat_t *, ipf_stack_t *));
162 static void nat_mssclamp __P((tcphdr_t *, u_32_t, u_short *));
163 static int nat_getnext __P((ipftoken_t *, ipfgeniter_t *, ipf_stack_t *));
164 static int nat_iterator __P((ipftoken_t *, ipfgeniter_t *, ipf_stack_t *));
165 static int nat_flushtable __P((int, ipf_stack_t *));
166
167 #define NAT_HAS_L4_CHANGED(n) \
168 (((n)->nat_flags & (IPN_TCPUDPICMP)) && \
169 (n)->nat_inport != (n)->nat_outport)
170
171
172 /* ------------------------------------------------------------------------ */
173 /* Function: fr_natinit */
174 /* Returns: int - 0 == success, -1 == failure */
175 /* Parameters: Nil */
176 /* */
177 /* Initialise all of the NAT locks, tables and other structures. */
178 /* ------------------------------------------------------------------------ */
179 int fr_natinit(ifs)
180 ipf_stack_t *ifs;
181 {
182 int i;
183
184 KMALLOCS(ifs->ifs_nat_table[0], nat_t **,
185 sizeof(nat_t *) * ifs->ifs_ipf_nattable_sz);
186 if (ifs->ifs_nat_table[0] != NULL)
187 bzero((char *)ifs->ifs_nat_table[0],
188 ifs->ifs_ipf_nattable_sz * sizeof(nat_t *));
189 else
190 return -1;
191
192 KMALLOCS(ifs->ifs_nat_table[1], nat_t **,
193 sizeof(nat_t *) * ifs->ifs_ipf_nattable_sz);
194 if (ifs->ifs_nat_table[1] != NULL)
195 bzero((char *)ifs->ifs_nat_table[1],
196 ifs->ifs_ipf_nattable_sz * sizeof(nat_t *));
197 else
198 return -2;
199
200 KMALLOCS(ifs->ifs_nat_rules, ipnat_t **,
201 sizeof(ipnat_t *) * ifs->ifs_ipf_natrules_sz);
202 if (ifs->ifs_nat_rules != NULL)
203 bzero((char *)ifs->ifs_nat_rules,
204 ifs->ifs_ipf_natrules_sz * sizeof(ipnat_t *));
205 else
206 return -3;
207
208 KMALLOCS(ifs->ifs_rdr_rules, ipnat_t **,
209 sizeof(ipnat_t *) * ifs->ifs_ipf_rdrrules_sz);
210 if (ifs->ifs_rdr_rules != NULL)
211 bzero((char *)ifs->ifs_rdr_rules,
212 ifs->ifs_ipf_rdrrules_sz * sizeof(ipnat_t *));
213 else
214 return -4;
215
216 KMALLOCS(ifs->ifs_maptable, hostmap_t **,
217 sizeof(hostmap_t *) * ifs->ifs_ipf_hostmap_sz);
218 if (ifs->ifs_maptable != NULL)
219 bzero((char *)ifs->ifs_maptable,
220 sizeof(hostmap_t *) * ifs->ifs_ipf_hostmap_sz);
221 else
222 return -5;
223
224 ifs->ifs_ipf_hm_maplist = NULL;
225
226 KMALLOCS(ifs->ifs_nat_stats.ns_bucketlen[0], u_long *,
227 ifs->ifs_ipf_nattable_sz * sizeof(u_long));
228 if (ifs->ifs_nat_stats.ns_bucketlen[0] == NULL)
229 return -1;
230 bzero((char *)ifs->ifs_nat_stats.ns_bucketlen[0],
231 ifs->ifs_ipf_nattable_sz * sizeof(u_long));
232
233 KMALLOCS(ifs->ifs_nat_stats.ns_bucketlen[1], u_long *,
234 ifs->ifs_ipf_nattable_sz * sizeof(u_long));
235 if (ifs->ifs_nat_stats.ns_bucketlen[1] == NULL)
236 return -1;
237 bzero((char *)ifs->ifs_nat_stats.ns_bucketlen[1],
238 ifs->ifs_ipf_nattable_sz * sizeof(u_long));
239
240 if (ifs->ifs_fr_nat_maxbucket == 0) {
241 for (i = ifs->ifs_ipf_nattable_sz; i > 0; i >>= 1)
242 ifs->ifs_fr_nat_maxbucket++;
243 ifs->ifs_fr_nat_maxbucket *= 2;
244 }
245
246 fr_sttab_init(ifs->ifs_nat_tqb, ifs);
247 /*
248 * Increase this because we may have "keep state" following this too
249 * and packet storms can occur if this is removed too quickly.
250 */
251 ifs->ifs_nat_tqb[IPF_TCPS_CLOSED].ifq_ttl = ifs->ifs_fr_tcplastack;
252 ifs->ifs_nat_tqb[IPF_TCP_NSTATES - 1].ifq_next = &ifs->ifs_nat_udptq;
253 ifs->ifs_nat_udptq.ifq_ttl = ifs->ifs_fr_defnatage;
254 ifs->ifs_nat_udptq.ifq_ref = 1;
255 ifs->ifs_nat_udptq.ifq_head = NULL;
256 ifs->ifs_nat_udptq.ifq_tail = &ifs->ifs_nat_udptq.ifq_head;
257 MUTEX_INIT(&ifs->ifs_nat_udptq.ifq_lock, "nat ipftq udp tab");
258 ifs->ifs_nat_udptq.ifq_next = &ifs->ifs_nat_icmptq;
259 ifs->ifs_nat_icmptq.ifq_ttl = ifs->ifs_fr_defnaticmpage;
260 ifs->ifs_nat_icmptq.ifq_ref = 1;
261 ifs->ifs_nat_icmptq.ifq_head = NULL;
262 ifs->ifs_nat_icmptq.ifq_tail = &ifs->ifs_nat_icmptq.ifq_head;
263 MUTEX_INIT(&ifs->ifs_nat_icmptq.ifq_lock, "nat icmp ipftq tab");
264 ifs->ifs_nat_icmptq.ifq_next = &ifs->ifs_nat_iptq;
265 ifs->ifs_nat_iptq.ifq_ttl = ifs->ifs_fr_defnatipage;
266 ifs->ifs_nat_iptq.ifq_ref = 1;
267 ifs->ifs_nat_iptq.ifq_head = NULL;
268 ifs->ifs_nat_iptq.ifq_tail = &ifs->ifs_nat_iptq.ifq_head;
269 MUTEX_INIT(&ifs->ifs_nat_iptq.ifq_lock, "nat ip ipftq tab");
270 ifs->ifs_nat_iptq.ifq_next = NULL;
271
272 for (i = 0; i < IPF_TCP_NSTATES; i++) {
273 if (ifs->ifs_nat_tqb[i].ifq_ttl < ifs->ifs_fr_defnaticmpage)
274 ifs->ifs_nat_tqb[i].ifq_ttl = ifs->ifs_fr_defnaticmpage;
275 #ifdef LARGE_NAT
276 else if (ifs->ifs_nat_tqb[i].ifq_ttl > ifs->ifs_fr_defnatage)
277 ifs->ifs_nat_tqb[i].ifq_ttl = ifs->ifs_fr_defnatage;
278 #endif
279 }
280
281 /*
282 * Increase this because we may have "keep state" following
283 * this too and packet storms can occur if this is removed
284 * too quickly.
285 */
286 ifs->ifs_nat_tqb[IPF_TCPS_CLOSED].ifq_ttl =
287 ifs->ifs_nat_tqb[IPF_TCPS_LAST_ACK].ifq_ttl;
288
289 RWLOCK_INIT(&ifs->ifs_ipf_nat, "ipf IP NAT rwlock");
290 RWLOCK_INIT(&ifs->ifs_ipf_natfrag, "ipf IP NAT-Frag rwlock");
291 MUTEX_INIT(&ifs->ifs_ipf_nat_new, "ipf nat new mutex");
292 MUTEX_INIT(&ifs->ifs_ipf_natio, "ipf nat io mutex");
293
294 ifs->ifs_fr_nat_init = 1;
295 ifs->ifs_nat_last_force_flush = ifs->ifs_fr_ticks;
296 return 0;
297 }
298
299
300 /* ------------------------------------------------------------------------ */
301 /* Function: nat_addrdr */
302 /* Returns: Nil */
303 /* Parameters: n(I) - pointer to NAT rule to add */
304 /* */
305 /* Adds a redirect rule to the hash table of redirect rules and the list of */
306 /* loaded NAT rules. Updates the bitmask indicating which netmasks are in */
307 /* use by redirect rules. */
308 /* ------------------------------------------------------------------------ */
309 static void nat_addrdr(n, ifs)
310 ipnat_t *n;
311 ipf_stack_t *ifs;
312 {
313 ipnat_t **np;
314 u_32_t j;
315 u_int hv;
316 int k;
317
318 k = count4bits(n->in_outmsk);
319 if ((k >= 0) && (k != 32))
320 ifs->ifs_rdr_masks |= 1 << k;
321 j = (n->in_outip & n->in_outmsk);
322 hv = NAT_HASH_FN(j, 0, ifs->ifs_ipf_rdrrules_sz);
323 np = ifs->ifs_rdr_rules + hv;
324 while (*np != NULL)
325 np = &(*np)->in_rnext;
326 n->in_rnext = NULL;
327 n->in_prnext = np;
328 n->in_hv = hv;
329 *np = n;
330 }
331
332
333 /* ------------------------------------------------------------------------ */
334 /* Function: nat_addnat */
335 /* Returns: Nil */
336 /* Parameters: n(I) - pointer to NAT rule to add */
337 /* */
338 /* Adds a NAT map rule to the hash table of rules and the list of loaded */
339 /* NAT rules. Updates the bitmask indicating which netmasks are in use by */
340 /* redirect rules. */
341 /* ------------------------------------------------------------------------ */
342 static void nat_addnat(n, ifs)
343 ipnat_t *n;
344 ipf_stack_t *ifs;
345 {
346 ipnat_t **np;
347 u_32_t j;
348 u_int hv;
349 int k;
350
351 k = count4bits(n->in_inmsk);
352 if ((k >= 0) && (k != 32))
353 ifs->ifs_nat_masks |= 1 << k;
354 j = (n->in_inip & n->in_inmsk);
355 hv = NAT_HASH_FN(j, 0, ifs->ifs_ipf_natrules_sz);
356 np = ifs->ifs_nat_rules + hv;
357 while (*np != NULL)
358 np = &(*np)->in_mnext;
359 n->in_mnext = NULL;
360 n->in_pmnext = np;
361 n->in_hv = hv;
362 *np = n;
363 }
364
365
366 /* ------------------------------------------------------------------------ */
367 /* Function: nat_delrdr */
368 /* Returns: Nil */
369 /* Parameters: n(I) - pointer to NAT rule to delete */
370 /* */
371 /* Removes a redirect rule from the hash table of redirect rules. */
372 /* ------------------------------------------------------------------------ */
373 void nat_delrdr(n)
374 ipnat_t *n;
375 {
376 if (n->in_rnext)
377 n->in_rnext->in_prnext = n->in_prnext;
378 *n->in_prnext = n->in_rnext;
379 }
380
381
382 /* ------------------------------------------------------------------------ */
383 /* Function: nat_delnat */
384 /* Returns: Nil */
385 /* Parameters: n(I) - pointer to NAT rule to delete */
386 /* */
387 /* Removes a NAT map rule from the hash table of NAT map rules. */
388 /* ------------------------------------------------------------------------ */
389 void nat_delnat(n)
390 ipnat_t *n;
391 {
392 if (n->in_mnext != NULL)
393 n->in_mnext->in_pmnext = n->in_pmnext;
394 *n->in_pmnext = n->in_mnext;
395 }
396
397
398 /* ------------------------------------------------------------------------ */
399 /* Function: nat_hostmap */
400 /* Returns: struct hostmap* - NULL if no hostmap could be created, */
401 /* else a pointer to the hostmapping to use */
402 /* Parameters: np(I) - pointer to NAT rule */
403 /* real(I) - real IP address */
404 /* map(I) - mapped IP address */
405 /* port(I) - destination port number */
406 /* Write Locks: ipf_nat */
407 /* */
408 /* Check if an ip address has already been allocated for a given mapping */
409 /* that is not doing port based translation. If is not yet allocated, then */
410 /* create a new entry if a non-NULL NAT rule pointer has been supplied. */
411 /* ------------------------------------------------------------------------ */
412 static struct hostmap *nat_hostmap(np, src, dst, map, port, ifs)
413 ipnat_t *np;
414 struct in_addr src;
415 struct in_addr dst;
416 struct in_addr map;
417 u_32_t port;
418 ipf_stack_t *ifs;
419 {
420 hostmap_t *hm;
421 u_int hv;
422
423 hv = (src.s_addr ^ dst.s_addr);
424 hv += src.s_addr;
425 hv += dst.s_addr;
426 hv %= HOSTMAP_SIZE;
427 for (hm = ifs->ifs_maptable[hv]; hm; hm = hm->hm_next)
428 if ((hm->hm_srcip.s_addr == src.s_addr) &&
429 (hm->hm_dstip.s_addr == dst.s_addr) &&
430 ((np == NULL) || (np == hm->hm_ipnat)) &&
431 ((port == 0) || (port == hm->hm_port))) {
432 hm->hm_ref++;
433 return hm;
434 }
435
436 if (np == NULL)
437 return NULL;
438
439 KMALLOC(hm, hostmap_t *);
440 if (hm) {
441 hm->hm_hnext = ifs->ifs_ipf_hm_maplist;
442 hm->hm_phnext = &ifs->ifs_ipf_hm_maplist;
443 if (ifs->ifs_ipf_hm_maplist != NULL)
444 ifs->ifs_ipf_hm_maplist->hm_phnext = &hm->hm_hnext;
445 ifs->ifs_ipf_hm_maplist = hm;
446
447 hm->hm_next = ifs->ifs_maptable[hv];
448 hm->hm_pnext = ifs->ifs_maptable + hv;
449 if (ifs->ifs_maptable[hv] != NULL)
450 ifs->ifs_maptable[hv]->hm_pnext = &hm->hm_next;
451 ifs->ifs_maptable[hv] = hm;
452 hm->hm_ipnat = np;
453 hm->hm_srcip = src;
454 hm->hm_dstip = dst;
455 hm->hm_mapip = map;
456 hm->hm_ref = 1;
457 hm->hm_port = port;
458 hm->hm_v = 4;
459 }
460 return hm;
461 }
462
463
464 /* ------------------------------------------------------------------------ */
465 /* Function: fr_hostmapdel */
466 /* Returns: Nil */
467 /* Parameters: hmp(I) - pointer to pointer to hostmap structure */
468 /* Write Locks: ipf_nat */
469 /* */
470 /* Decrement the references to this hostmap structure by one. If this */
471 /* reaches zero then remove it and free it. */
472 /* ------------------------------------------------------------------------ */
473 void fr_hostmapdel(hmp)
474 struct hostmap **hmp;
475 {
476 struct hostmap *hm;
477
478 hm = *hmp;
479 *hmp = NULL;
480
481 hm->hm_ref--;
482 if (hm->hm_ref == 0) {
483 if (hm->hm_next)
484 hm->hm_next->hm_pnext = hm->hm_pnext;
485 *hm->hm_pnext = hm->hm_next;
486 if (hm->hm_hnext)
487 hm->hm_hnext->hm_phnext = hm->hm_phnext;
488 *hm->hm_phnext = hm->hm_hnext;
489 KFREE(hm);
490 }
491 }
492
493
494 /* ------------------------------------------------------------------------ */
495 /* Function: fix_outcksum */
496 /* Returns: Nil */
497 /* Parameters: sp(I) - location of 16bit checksum to update */
498 /* n((I) - amount to adjust checksum by */
499 /* */
500 /* Adjusts the 16bit checksum by "n" for packets going out. */
501 /* ------------------------------------------------------------------------ */
502 void fix_outcksum(sp, n)
503 u_short *sp;
504 u_32_t n;
505 {
506 u_short sumshort;
507 u_32_t sum1;
508
509 if (n == 0)
510 return;
511
512 sum1 = (~ntohs(*sp)) & 0xffff;
513 sum1 += (n);
514 sum1 = (sum1 >> 16) + (sum1 & 0xffff);
515 /* Again */
516 sum1 = (sum1 >> 16) + (sum1 & 0xffff);
517 sumshort = ~(u_short)sum1;
518 *(sp) = htons(sumshort);
519 }
520
521
522 /* ------------------------------------------------------------------------ */
523 /* Function: fix_incksum */
524 /* Returns: Nil */
525 /* Parameters: sp(I) - location of 16bit checksum to update */
526 /* n((I) - amount to adjust checksum by */
527 /* */
528 /* Adjusts the 16bit checksum by "n" for packets going in. */
529 /* ------------------------------------------------------------------------ */
530 void fix_incksum(sp, n)
531 u_short *sp;
532 u_32_t n;
533 {
534 u_short sumshort;
535 u_32_t sum1;
536
537 if (n == 0)
538 return;
539
540 sum1 = (~ntohs(*sp)) & 0xffff;
541 sum1 += ~(n) & 0xffff;
542 sum1 = (sum1 >> 16) + (sum1 & 0xffff);
543 /* Again */
544 sum1 = (sum1 >> 16) + (sum1 & 0xffff);
545 sumshort = ~(u_short)sum1;
546 *(sp) = htons(sumshort);
547 }
548
549
550 /* ------------------------------------------------------------------------ */
551 /* Function: fix_datacksum */
552 /* Returns: Nil */
553 /* Parameters: sp(I) - location of 16bit checksum to update */
554 /* n((I) - amount to adjust checksum by */
555 /* */
556 /* Fix_datacksum is used *only* for the adjustments of checksums in the */
557 /* data section of an IP packet. */
558 /* */
559 /* The only situation in which you need to do this is when NAT'ing an */
560 /* ICMP error message. Such a message, contains in its body the IP header */
561 /* of the original IP packet, that causes the error. */
562 /* */
563 /* You can't use fix_incksum or fix_outcksum in that case, because for the */
564 /* kernel the data section of the ICMP error is just data, and no special */
565 /* processing like hardware cksum or ntohs processing have been done by the */
566 /* kernel on the data section. */
567 /* ------------------------------------------------------------------------ */
568 void fix_datacksum(sp, n)
569 u_short *sp;
570 u_32_t n;
571 {
572 u_short sumshort;
573 u_32_t sum1;
574
575 if (n == 0)
576 return;
577
578 sum1 = (~ntohs(*sp)) & 0xffff;
579 sum1 += (n);
580 sum1 = (sum1 >> 16) + (sum1 & 0xffff);
581 /* Again */
582 sum1 = (sum1 >> 16) + (sum1 & 0xffff);
583 sumshort = ~(u_short)sum1;
584 *(sp) = htons(sumshort);
585 }
586
587
588 /* ------------------------------------------------------------------------ */
589 /* Function: fr_nat_ioctl */
590 /* Returns: int - 0 == success, != 0 == failure */
591 /* Parameters: data(I) - pointer to ioctl data */
592 /* cmd(I) - ioctl command integer */
593 /* mode(I) - file mode bits used with open */
594 /* uid(I) - uid of caller */
595 /* ctx(I) - pointer to give the uid context */
596 /* ifs - ipf stack instance */
597 /* */
598 /* Processes an ioctl call made to operate on the IP Filter NAT device. */
599 /* ------------------------------------------------------------------------ */
600 int fr_nat_ioctl(data, cmd, mode, uid, ctx, ifs)
601 ioctlcmd_t cmd;
602 caddr_t data;
603 int mode, uid;
604 void *ctx;
605 ipf_stack_t *ifs;
606 {
607 ipnat_t *nat, *nt, *n = NULL, **np = NULL;
608 int error = 0, ret, arg, getlock;
609 ipnat_t natd;
610
611 #if (BSD >= 199306) && defined(_KERNEL)
612 if ((securelevel >= 2) && (mode & FWRITE))
613 return EPERM;
614 #endif
615
616 #if defined(__osf__) && defined(_KERNEL)
617 getlock = 0;
618 #else
619 getlock = (mode & NAT_LOCKHELD) ? 0 : 1;
620 #endif
621
622 nat = NULL; /* XXX gcc -Wuninitialized */
623 if (cmd == (ioctlcmd_t)SIOCADNAT) {
624 KMALLOC(nt, ipnat_t *);
625 } else {
626 nt = NULL;
627 }
628
629 if ((cmd == (ioctlcmd_t)SIOCADNAT) || (cmd == (ioctlcmd_t)SIOCRMNAT)) {
630 if (mode & NAT_SYSSPACE) {
631 bcopy(data, (char *)&natd, sizeof(natd));
632 error = 0;
633 } else {
634 error = fr_inobj(data, &natd, IPFOBJ_IPNAT);
635 }
636
637 }
638
639 if (error != 0)
640 goto done;
641
642 /*
643 * For add/delete, look to see if the NAT entry is already present
644 */
645 if ((cmd == (ioctlcmd_t)SIOCADNAT) || (cmd == (ioctlcmd_t)SIOCRMNAT)) {
646 nat = &natd;
647 if (nat->in_v == 0) /* For backward compat. */
648 nat->in_v = 4;
649 nat->in_flags &= IPN_USERFLAGS;
650 if ((nat->in_redir & NAT_MAPBLK) == 0) {
651 if ((nat->in_flags & IPN_SPLIT) == 0)
652 nat->in_inip &= nat->in_inmsk;
653 if ((nat->in_flags & IPN_IPRANGE) == 0)
654 nat->in_outip &= nat->in_outmsk;
655 }
656 MUTEX_ENTER(&ifs->ifs_ipf_natio);
657 for (np = &ifs->ifs_nat_list; ((n = *np) != NULL);
658 np = &n->in_next)
659 if (bcmp((char *)&nat->in_flags, (char *)&n->in_flags,
660 IPN_CMPSIZ) == 0) {
661 if (nat->in_redir == NAT_REDIRECT &&
662 nat->in_pnext != n->in_pnext)
663 continue;
664 break;
665 }
666 }
667
668 switch (cmd)
669 {
670 case SIOCGENITER :
671 {
672 ipfgeniter_t iter;
673 ipftoken_t *token;
674
675 error = fr_inobj(data, &iter, IPFOBJ_GENITER);
676 if (error != 0)
677 break;
678
679 token = ipf_findtoken(iter.igi_type, uid, ctx, ifs);
680 if (token != NULL)
681 error = nat_iterator(token, &iter, ifs);
682 else
683 error = ESRCH;
684 RWLOCK_EXIT(&ifs->ifs_ipf_tokens);
685 break;
686 }
687 #ifdef IPFILTER_LOG
688 case SIOCIPFFB :
689 {
690 int tmp;
691
692 if (!(mode & FWRITE))
693 error = EPERM;
694 else {
695 tmp = ipflog_clear(IPL_LOGNAT, ifs);
696 error = BCOPYOUT((char *)&tmp, (char *)data,
697 sizeof(tmp));
698 if (error != 0)
699 error = EFAULT;
700 }
701 break;
702 }
703 case SIOCSETLG :
704 if (!(mode & FWRITE)) {
705 error = EPERM;
706 } else {
707 error = BCOPYIN((char *)data,
708 (char *)&ifs->ifs_nat_logging,
709 sizeof(ifs->ifs_nat_logging));
710 if (error != 0)
711 error = EFAULT;
712 }
713 break;
714 case SIOCGETLG :
715 error = BCOPYOUT((char *)&ifs->ifs_nat_logging, (char *)data,
716 sizeof(ifs->ifs_nat_logging));
717 if (error != 0)
718 error = EFAULT;
719 break;
720 case FIONREAD :
721 arg = ifs->ifs_iplused[IPL_LOGNAT];
722 error = BCOPYOUT(&arg, data, sizeof(arg));
723 if (error != 0)
724 error = EFAULT;
725 break;
726 #endif
727 case SIOCADNAT :
728 if (!(mode & FWRITE)) {
729 error = EPERM;
730 } else if (n != NULL) {
731 error = EEXIST;
732 } else if (nt == NULL) {
733 error = ENOMEM;
734 }
735 if (error != 0) {
736 MUTEX_EXIT(&ifs->ifs_ipf_natio);
737 break;
738 }
739 bcopy((char *)nat, (char *)nt, sizeof(*n));
740 error = nat_siocaddnat(nt, np, getlock, ifs);
741 MUTEX_EXIT(&ifs->ifs_ipf_natio);
742 if (error == 0)
743 nt = NULL;
744 break;
745 case SIOCRMNAT :
746 if (!(mode & FWRITE)) {
747 error = EPERM;
748 n = NULL;
749 } else if (n == NULL) {
750 error = ESRCH;
751 }
752
753 if (error != 0) {
754 MUTEX_EXIT(&ifs->ifs_ipf_natio);
755 break;
756 }
757 nat_siocdelnat(n, np, getlock, ifs);
758
759 MUTEX_EXIT(&ifs->ifs_ipf_natio);
760 n = NULL;
761 break;
762 case SIOCGNATS :
763 ifs->ifs_nat_stats.ns_table[0] = ifs->ifs_nat_table[0];
764 ifs->ifs_nat_stats.ns_table[1] = ifs->ifs_nat_table[1];
765 ifs->ifs_nat_stats.ns_list = ifs->ifs_nat_list;
766 ifs->ifs_nat_stats.ns_maptable = ifs->ifs_maptable;
767 ifs->ifs_nat_stats.ns_maplist = ifs->ifs_ipf_hm_maplist;
768 ifs->ifs_nat_stats.ns_nattab_max = ifs->ifs_ipf_nattable_max;
769 ifs->ifs_nat_stats.ns_nattab_sz = ifs->ifs_ipf_nattable_sz;
770 ifs->ifs_nat_stats.ns_rultab_sz = ifs->ifs_ipf_natrules_sz;
771 ifs->ifs_nat_stats.ns_rdrtab_sz = ifs->ifs_ipf_rdrrules_sz;
772 ifs->ifs_nat_stats.ns_hostmap_sz = ifs->ifs_ipf_hostmap_sz;
773 ifs->ifs_nat_stats.ns_instances = ifs->ifs_nat_instances;
774 ifs->ifs_nat_stats.ns_apslist = ifs->ifs_ap_sess_list;
775 error = fr_outobj(data, &ifs->ifs_nat_stats, IPFOBJ_NATSTAT);
776 break;
777 case SIOCGNATL :
778 {
779 natlookup_t nl;
780
781 if (getlock) {
782 READ_ENTER(&ifs->ifs_ipf_nat);
783 }
784 error = fr_inobj(data, &nl, IPFOBJ_NATLOOKUP);
785 if (nl.nl_v != 6)
786 nl.nl_v = 4;
787 if (error == 0) {
788 void *ptr;
789
790 switch (nl.nl_v)
791 {
792 case 4:
793 ptr = nat_lookupredir(&nl, ifs);
794 break;
795 #ifdef USE_INET6
796 case 6:
797 ptr = nat6_lookupredir(&nl, ifs);
798 break;
799 #endif
800 default:
801 ptr = NULL;
802 break;
803 }
804
805 if (ptr != NULL) {
806 error = fr_outobj(data, &nl, IPFOBJ_NATLOOKUP);
807 } else {
808 error = ESRCH;
809 }
810 }
811 if (getlock) {
812 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
813 }
814 break;
815 }
816 case SIOCIPFFL : /* old SIOCFLNAT & SIOCCNATL */
817 if (!(mode & FWRITE)) {
818 error = EPERM;
819 break;
820 }
821 if (getlock) {
822 WRITE_ENTER(&ifs->ifs_ipf_nat);
823 }
824 error = BCOPYIN(data, &arg, sizeof(arg));
825 if (error != 0) {
826 error = EFAULT;
827 } else {
828 if (arg == FLUSH_LIST)
829 ret = nat_clearlist(ifs);
830 else if (VALID_TABLE_FLUSH_OPT(arg))
831 ret = nat_flushtable(arg, ifs);
832 else
833 error = EINVAL;
834 }
835 if (getlock) {
836 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
837 }
838 if (error == 0) {
839 error = BCOPYOUT(&ret, data, sizeof(ret));
840 if (error != 0)
841 error = EFAULT;
842 }
843 break;
844 case SIOCPROXY :
845 error = appr_ioctl(data, cmd, mode, ifs);
846 break;
847 case SIOCSTLCK :
848 if (!(mode & FWRITE)) {
849 error = EPERM;
850 } else {
851 error = fr_lock(data, &ifs->ifs_fr_nat_lock);
852 }
853 break;
854 case SIOCSTPUT :
855 if ((mode & FWRITE) != 0) {
856 error = fr_natputent(data, getlock, ifs);
857 } else {
858 error = EACCES;
859 }
860 break;
861 case SIOCSTGSZ :
862 if (ifs->ifs_fr_nat_lock) {
863 if (getlock) {
864 READ_ENTER(&ifs->ifs_ipf_nat);
865 }
866 error = fr_natgetsz(data, ifs);
867 if (getlock) {
868 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
869 }
870 } else
871 error = EACCES;
872 break;
873 case SIOCSTGET :
874 if (ifs->ifs_fr_nat_lock) {
875 if (getlock) {
876 READ_ENTER(&ifs->ifs_ipf_nat);
877 }
878 error = fr_natgetent(data, ifs);
879 if (getlock) {
880 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
881 }
882 } else
883 error = EACCES;
884 break;
885 case SIOCIPFDELTOK :
886 error = BCOPYIN((caddr_t)data, (caddr_t)&arg, sizeof(arg));
887 if (error != 0) {
888 error = EFAULT;
889 } else {
890 error = ipf_deltoken(arg, uid, ctx, ifs);
891 }
892 break;
893 default :
894 error = EINVAL;
895 break;
896 }
897 done:
898 if (nt)
899 KFREE(nt);
900 return error;
901 }
902
903
904 /* ------------------------------------------------------------------------ */
905 /* Function: nat_siocaddnat */
906 /* Returns: int - 0 == success, != 0 == failure */
907 /* Parameters: n(I) - pointer to new NAT rule */
908 /* np(I) - pointer to where to insert new NAT rule */
909 /* getlock(I) - flag indicating if lock on ipf_nat is held */
910 /* Mutex Locks: ipf_natio */
911 /* */
912 /* Handle SIOCADNAT. Resolve and calculate details inside the NAT rule */
913 /* from information passed to the kernel, then add it to the appropriate */
914 /* NAT rule table(s). */
915 /* ------------------------------------------------------------------------ */
916 static int nat_siocaddnat(n, np, getlock, ifs)
917 ipnat_t *n, **np;
918 int getlock;
919 ipf_stack_t *ifs;
920 {
921 int error = 0, i, j;
922
923 if (nat_resolverule(n, ifs) != 0)
924 return ENOENT;
925
926 if ((n->in_age[0] == 0) && (n->in_age[1] != 0))
927 return EINVAL;
928
929 n->in_use = 0;
930 if (n->in_redir & NAT_MAPBLK)
931 n->in_space = USABLE_PORTS * ~ntohl(n->in_outmsk);
932 else if (n->in_flags & IPN_AUTOPORTMAP)
933 n->in_space = USABLE_PORTS * ~ntohl(n->in_inmsk);
934 else if (n->in_flags & IPN_IPRANGE)
935 n->in_space = ntohl(n->in_outmsk) - ntohl(n->in_outip);
936 else if (n->in_flags & IPN_SPLIT)
937 n->in_space = 2;
938 else if (n->in_outmsk != 0)
939 n->in_space = ~ntohl(n->in_outmsk);
940 else
941 n->in_space = 1;
942 if ((n->in_flags & NAT_TCPUDPICMPQ) && (n->in_redir != NAT_REDIRECT)) {
943 if (ntohs(n->in_pmax) < ntohs(n->in_pmin))
944 return EINVAL;
945 }
946
947 /*
948 * Calculate the number of valid IP addresses in the output
949 * mapping range. In all cases, the range is inclusive of
950 * the start and ending IP addresses.
951 * If to a CIDR address, lose 2: broadcast + network address
952 * (so subtract 1)
953 * If to a range, add one.
954 * If to a single IP address, set to 1.
955 */
956 if (n->in_space) {
957 if ((n->in_flags & IPN_IPRANGE) != 0)
958 n->in_space += 1;
959 else
960 n->in_space -= 1;
961 } else
962 n->in_space = 1;
963
964 #ifdef USE_INET6
965 if (n->in_v == 6 && (n->in_flags & (IPN_IPRANGE|IPN_SPLIT)) == 0 &&
966 !IP6_ISONES(&n->in_out[1]) && !IP6_ISZERO(&n->in_out[1]))
967 IP6_ADD(&n->in_out[0], 1, &n->in_next6)
968 else if (n->in_v == 6 &&
969 (n->in_flags & IPN_SPLIT) && (n->in_redir & NAT_REDIRECT))
970 n->in_next6 = n->in_in[0];
971 else if (n->in_v == 6)
972 n->in_next6 = n->in_out[0];
973 else
974 #endif
975 if ((n->in_outmsk != 0xffffffff) && (n->in_outmsk != 0) &&
976 ((n->in_flags & (IPN_IPRANGE|IPN_SPLIT)) == 0))
977 n->in_nip = ntohl(n->in_outip) + 1;
978 else if ((n->in_flags & IPN_SPLIT) &&
979 (n->in_redir & NAT_REDIRECT))
980 n->in_nip = ntohl(n->in_inip);
981 else
982 n->in_nip = ntohl(n->in_outip);
983
984 if (n->in_redir & NAT_MAP) {
985 n->in_pnext = ntohs(n->in_pmin);
986 /*
987 * Multiply by the number of ports made available.
988 */
989 if (ntohs(n->in_pmax) >= ntohs(n->in_pmin)) {
990 n->in_space *= (ntohs(n->in_pmax) -
991 ntohs(n->in_pmin) + 1);
992 /*
993 * Because two different sources can map to
994 * different destinations but use the same
995 * local IP#/port #.
996 * If the result is smaller than in_space, then
997 * we may have wrapped around 32bits.
998 */
999 i = n->in_inmsk;
1000 if ((i != 0) && (i != 0xffffffff)) {
1001 j = n->in_space * (~ntohl(i) + 1);
1002 if (j >= n->in_space)
1003 n->in_space = j;
1004 else
1005 n->in_space = 0xffffffff;
1006 }
1007 }
1008 /*
1009 * If no protocol is specified, multiple by 256 to allow for
1010 * at least one IP:IP mapping per protocol.
1011 */
1012 if ((n->in_flags & IPN_TCPUDPICMP) == 0) {
1013 j = n->in_space * 256;
1014 if (j >= n->in_space)
1015 n->in_space = j;
1016 else
1017 n->in_space = 0xffffffff;
1018 }
1019 }
1020
1021 /* Otherwise, these fields are preset */
1022
1023 if (getlock) {
1024 WRITE_ENTER(&ifs->ifs_ipf_nat);
1025 }
1026 n->in_next = NULL;
1027 *np = n;
1028
1029 if (n->in_age[0] != 0)
1030 n->in_tqehead[0] = fr_addtimeoutqueue(&ifs->ifs_nat_utqe,
1031 n->in_age[0], ifs);
1032
1033 if (n->in_age[1] != 0)
1034 n->in_tqehead[1] = fr_addtimeoutqueue(&ifs->ifs_nat_utqe,
1035 n->in_age[1], ifs);
1036
1037 if (n->in_redir & NAT_REDIRECT) {
1038 n->in_flags &= ~IPN_NOTDST;
1039 switch (n->in_v)
1040 {
1041 case 4 :
1042 nat_addrdr(n, ifs);
1043 break;
1044 #ifdef USE_INET6
1045 case 6 :
1046 nat6_addrdr(n, ifs);
1047 break;
1048 #endif
1049 default :
1050 break;
1051 }
1052 }
1053 if (n->in_redir & (NAT_MAP|NAT_MAPBLK)) {
1054 n->in_flags &= ~IPN_NOTSRC;
1055 switch (n->in_v)
1056 {
1057 case 4 :
1058 nat_addnat(n, ifs);
1059 break;
1060 #ifdef USE_INET6
1061 case 6 :
1062 nat6_addnat(n, ifs);
1063 break;
1064 #endif
1065 default :
1066 break;
1067 }
1068 }
1069 n = NULL;
1070 ifs->ifs_nat_stats.ns_rules++;
1071 if (getlock) {
1072 RWLOCK_EXIT(&ifs->ifs_ipf_nat); /* WRITE */
1073 }
1074
1075 return error;
1076 }
1077
1078
1079 /* ------------------------------------------------------------------------ */
1080 /* Function: nat_resolvrule */
1081 /* Returns: int - 0 == success, -1 == failure */
1082 /* Parameters: n(I) - pointer to NAT rule */
1083 /* */
1084 /* Resolve some of the details inside the NAT rule. Includes resolving */
1085 /* any specified interfaces and proxy labels, and determines whether or not */
1086 /* all proxy labels are correctly specified. */
1087 /* */
1088 /* Called by nat_siocaddnat() (SIOCADNAT) and fr_natputent (SIOCSTPUT). */
1089 /* ------------------------------------------------------------------------ */
1090 static int nat_resolverule(n, ifs)
1091 ipnat_t *n;
1092 ipf_stack_t *ifs;
1093 {
1094 n->in_ifnames[0][LIFNAMSIZ - 1] = '\0';
1095 n->in_ifps[0] = fr_resolvenic(n->in_ifnames[0], n->in_v, ifs);
1096
1097 n->in_ifnames[1][LIFNAMSIZ - 1] = '\0';
1098 if (n->in_ifnames[1][0] == '\0') {
1099 (void) strncpy(n->in_ifnames[1], n->in_ifnames[0], LIFNAMSIZ);
1100 n->in_ifps[1] = n->in_ifps[0];
1101 } else {
1102 n->in_ifps[1] = fr_resolvenic(n->in_ifnames[1], n->in_v, ifs);
1103 }
1104
1105 if (n->in_plabel[0] != '\0') {
1106 n->in_apr = appr_lookup(n->in_p, n->in_plabel, ifs);
1107 if (n->in_apr == NULL)
1108 return -1;
1109 }
1110 return 0;
1111 }
1112
1113
1114 /* ------------------------------------------------------------------------ */
1115 /* Function: nat_siocdelnat */
1116 /* Returns: int - 0 == success, != 0 == failure */
1117 /* Parameters: n(I) - pointer to new NAT rule */
1118 /* np(I) - pointer to where to insert new NAT rule */
1119 /* getlock(I) - flag indicating if lock on ipf_nat is held */
1120 /* Mutex Locks: ipf_natio */
1121 /* */
1122 /* Handle SIOCADNAT. Resolve and calculate details inside the NAT rule */
1123 /* from information passed to the kernel, then add it to the appropriate */
1124 /* NAT rule table(s). */
1125 /* ------------------------------------------------------------------------ */
1126 static void nat_siocdelnat(n, np, getlock, ifs)
1127 ipnat_t *n, **np;
1128 int getlock;
1129 ipf_stack_t *ifs;
1130 {
1131 int i;
1132
1133 if (getlock) {
1134 WRITE_ENTER(&ifs->ifs_ipf_nat);
1135 }
1136 if (n->in_redir & NAT_REDIRECT)
1137 nat_delrdr(n);
1138 if (n->in_redir & (NAT_MAPBLK|NAT_MAP))
1139 nat_delnat(n);
1140 if (ifs->ifs_nat_list == NULL) {
1141 ifs->ifs_nat_masks = 0;
1142 ifs->ifs_rdr_masks = 0;
1143 for (i = 0; i < 4; i++) {
1144 ifs->ifs_nat6_masks[i] = 0;
1145 ifs->ifs_rdr6_masks[i] = 0;
1146 }
1147 }
1148
1149 if (n->in_tqehead[0] != NULL) {
1150 if (fr_deletetimeoutqueue(n->in_tqehead[0]) == 0) {
1151 fr_freetimeoutqueue(n->in_tqehead[0], ifs);
1152 }
1153 }
1154
1155 if (n->in_tqehead[1] != NULL) {
1156 if (fr_deletetimeoutqueue(n->in_tqehead[1]) == 0) {
1157 fr_freetimeoutqueue(n->in_tqehead[1], ifs);
1158 }
1159 }
1160
1161 *np = n->in_next;
1162
1163 if (n->in_use == 0) {
1164 if (n->in_apr)
1165 appr_free(n->in_apr);
1166 KFREE(n);
1167 ifs->ifs_nat_stats.ns_rules--;
1168 } else {
1169 n->in_flags |= IPN_DELETE;
1170 n->in_next = NULL;
1171 }
1172 if (getlock) {
1173 RWLOCK_EXIT(&ifs->ifs_ipf_nat); /* READ/WRITE */
1174 }
1175 }
1176
1177
1178 /* ------------------------------------------------------------------------ */
1179 /* Function: fr_natgetsz */
1180 /* Returns: int - 0 == success, != 0 is the error value. */
1181 /* Parameters: data(I) - pointer to natget structure with kernel pointer */
1182 /* get the size of. */
1183 /* */
1184 /* Handle SIOCSTGSZ. */
1185 /* Return the size of the nat list entry to be copied back to user space. */
1186 /* The size of the entry is stored in the ng_sz field and the enture natget */
1187 /* structure is copied back to the user. */
1188 /* ------------------------------------------------------------------------ */
1189 static int fr_natgetsz(data, ifs)
1190 caddr_t data;
1191 ipf_stack_t *ifs;
1192 {
1193 ap_session_t *aps;
1194 nat_t *nat, *n;
1195 natget_t ng;
1196 int err;
1197
1198 err = BCOPYIN(data, &ng, sizeof(ng));
1199 if (err != 0)
1200 return EFAULT;
1201
1202 nat = ng.ng_ptr;
1203 if (!nat) {
1204 nat = ifs->ifs_nat_instances;
1205 ng.ng_sz = 0;
1206 /*
1207 * Empty list so the size returned is 0. Simple.
1208 */
1209 if (nat == NULL) {
1210 err = BCOPYOUT(&ng, data, sizeof(ng));
1211 if (err != 0) {
1212 return EFAULT;
1213 } else {
1214 return 0;
1215 }
1216 }
1217 } else {
1218 /*
1219 * Make sure the pointer we're copying from exists in the
1220 * current list of entries. Security precaution to prevent
1221 * copying of random kernel data.
1222 */
1223 for (n = ifs->ifs_nat_instances; n; n = n->nat_next)
1224 if (n == nat)
1225 break;
1226 if (!n)
1227 return ESRCH;
1228 }
1229
1230 /*
1231 * Incluse any space required for proxy data structures.
1232 */
1233 ng.ng_sz = sizeof(nat_save_t);
1234 aps = nat->nat_aps;
1235 if (aps != NULL) {
1236 ng.ng_sz += sizeof(ap_session_t) - 4;
1237 if (aps->aps_data != 0)
1238 ng.ng_sz += aps->aps_psiz;
1239 }
1240
1241 err = BCOPYOUT(&ng, data, sizeof(ng));
1242 if (err != 0)
1243 return EFAULT;
1244 return 0;
1245 }
1246
1247
1248 /* ------------------------------------------------------------------------ */
1249 /* Function: fr_natgetent */
1250 /* Returns: int - 0 == success, != 0 is the error value. */
1251 /* Parameters: data(I) - pointer to natget structure with kernel pointer */
1252 /* to NAT structure to copy out. */
1253 /* */
1254 /* Handle SIOCSTGET. */
1255 /* Copies out NAT entry to user space. Any additional data held for a */
1256 /* proxy is also copied, as to is the NAT rule which was responsible for it */
1257 /* ------------------------------------------------------------------------ */
1258 static int fr_natgetent(data, ifs)
1259 caddr_t data;
1260 ipf_stack_t *ifs;
1261 {
1262 int error, outsize;
1263 ap_session_t *aps;
1264 nat_save_t *ipn, ipns;
1265 nat_t *n, *nat;
1266
1267 error = fr_inobj(data, &ipns, IPFOBJ_NATSAVE);
1268 if (error != 0)
1269 return error;
1270
1271 if ((ipns.ipn_dsize < sizeof(ipns)) || (ipns.ipn_dsize > 81920))
1272 return EINVAL;
1273
1274 KMALLOCS(ipn, nat_save_t *, ipns.ipn_dsize);
1275 if (ipn == NULL)
1276 return ENOMEM;
1277
1278 ipn->ipn_dsize = ipns.ipn_dsize;
1279 nat = ipns.ipn_next;
1280 if (nat == NULL) {
1281 nat = ifs->ifs_nat_instances;
1282 if (nat == NULL) {
1283 if (ifs->ifs_nat_instances == NULL)
1284 error = ENOENT;
1285 goto finished;
1286 }
1287 } else {
1288 /*
1289 * Make sure the pointer we're copying from exists in the
1290 * current list of entries. Security precaution to prevent
1291 * copying of random kernel data.
1292 */
1293 for (n = ifs->ifs_nat_instances; n; n = n->nat_next)
1294 if (n == nat)
1295 break;
1296 if (n == NULL) {
1297 error = ESRCH;
1298 goto finished;
1299 }
1300 }
1301 ipn->ipn_next = nat->nat_next;
1302
1303 /*
1304 * Copy the NAT structure.
1305 */
1306 bcopy((char *)nat, &ipn->ipn_nat, sizeof(*nat));
1307
1308 /*
1309 * If we have a pointer to the NAT rule it belongs to, save that too.
1310 */
1311 if (nat->nat_ptr != NULL)
1312 bcopy((char *)nat->nat_ptr, (char *)&ipn->ipn_ipnat,
1313 sizeof(ipn->ipn_ipnat));
1314
1315 /*
1316 * If we also know the NAT entry has an associated filter rule,
1317 * save that too.
1318 */
1319 if (nat->nat_fr != NULL)
1320 bcopy((char *)nat->nat_fr, (char *)&ipn->ipn_fr,
1321 sizeof(ipn->ipn_fr));
1322
1323 /*
1324 * Last but not least, if there is an application proxy session set
1325 * up for this NAT entry, then copy that out too, including any
1326 * private data saved along side it by the proxy.
1327 */
1328 aps = nat->nat_aps;
1329 outsize = ipn->ipn_dsize - sizeof(*ipn) + sizeof(ipn->ipn_data);
1330 if (aps != NULL) {
1331 char *s;
1332
1333 if (outsize < sizeof(*aps)) {
1334 error = ENOBUFS;
1335 goto finished;
1336 }
1337
1338 s = ipn->ipn_data;
1339 bcopy((char *)aps, s, sizeof(*aps));
1340 s += sizeof(*aps);
1341 outsize -= sizeof(*aps);
1342 if ((aps->aps_data != NULL) && (outsize >= aps->aps_psiz))
1343 bcopy(aps->aps_data, s, aps->aps_psiz);
1344 else
1345 error = ENOBUFS;
1346 }
1347 if (error == 0) {
1348 error = fr_outobjsz(data, ipn, IPFOBJ_NATSAVE, ipns.ipn_dsize);
1349 }
1350
1351 finished:
1352 if (ipn != NULL) {
1353 KFREES(ipn, ipns.ipn_dsize);
1354 }
1355 return error;
1356 }
1357
1358 /* ------------------------------------------------------------------------ */
1359 /* Function: nat_calc_chksum_diffs */
1360 /* Returns: void */
1361 /* Parameters: nat - pointer to NAT table entry */
1362 /* */
1363 /* Function calculates chksum deltas for IP header (nat_ipsumd) and TCP/UDP */
1364 /* headers (nat_sumd). The things for L4 (UDP/TCP) get complicated when */
1365 /* we are dealing with partial chksum offload. For these cases we need to */
1366 /* compute a 'partial chksum delta'. The 'partial chksum delta'is stored */
1367 /* into nat_sumd[1], while ordinary chksum delta for TCP/UDP is in */
1368 /* nat_sumd[0]. */
1369 /* */
1370 /* The function accepts initialized NAT table entry and computes the deltas */
1371 /* from nat_inip/nat_outip members. The function is called right before */
1372 /* the new entry is inserted into the table. */
1373 /* */
1374 /* The ipsumd (IP hedaer chksum delta adjustment) is computed as a chksum */
1375 /* of delta between original and new IP addresses. */
1376 /* */
1377 /* the nat_sumd[0] (TCP/UDP header chksum delta adjustment) is computed as */
1378 /* a chkusm of delta between original an new IP addrress:port tupples. */
1379 /* */
1380 /* Some facts about chksum, we should remember: */
1381 /* IP header chksum covers IP header only */
1382 /* */
1383 /* TCP/UDP chksum covers data payload and so called pseudo header */
1384 /* SRC, DST IP address */
1385 /* SRC, DST Port */
1386 /* length of payload */
1387 /* */
1388 /* The partial chksum delta (nat_sumd[1] is used to adjust db_ckusm16 */
1389 /* member of dblk_t structure. The db_ckusm16 member is not part of */
1390 /* IP/UDP/TCP header it is 16 bit value computed by NIC driver with partial */
1391 /* chksum offload capacbility for every inbound packet. The db_cksum16 is */
1392 /* stored along with other IP packet data in dblk_t structure and used in */
1393 /* for IP/UDP/TCP chksum validation later in ip.c. */
1394 /* */
1395 /* The partial chksum delta (adjustment, nat_sumd[1]) is computed as chksum */
1396 /* of delta between new and orig address. NOTE: the order of operands for */
1397 /* partial delta operation is swapped compared to computing the IP/TCP/UDP */
1398 /* header adjustment. It is by design see (IP_CKSUM_RECV() macro in ip.c). */
1399 /* */
1400 /* ------------------------------------------------------------------------ */
1401 void nat_calc_chksum_diffs(nat)
1402 nat_t *nat;
1403 {
1404 u_32_t sum_orig = 0;
1405 u_32_t sum_changed = 0;
1406 u_32_t sumd;
1407 u_32_t ipsum_orig = 0;
1408 u_32_t ipsum_changed = 0;
1409
1410 if (nat->nat_v != 4 && nat->nat_v != 6)
1411 return;
1412
1413 /*
1414 * the switch calculates operands for CALC_SUMD(),
1415 * which will compute the partial chksum delta.
1416 */
1417 switch (nat->nat_dir)
1418 {
1419 case NAT_INBOUND:
1420 /*
1421 * we are dealing with RDR rule (DST address gets
1422 * modified on packet from client)
1423 */
1424 if (nat->nat_v == 4) {
1425 sum_changed = LONG_SUM(ntohl(nat->nat_inip.s_addr));
1426 sum_orig = LONG_SUM(ntohl(nat->nat_outip.s_addr));
1427 } else {
1428 sum_changed = LONG_SUM6(&nat->nat_inip6);
1429 sum_orig = LONG_SUM6(&nat->nat_outip6);
1430 }
1431 break;
1432 case NAT_OUTBOUND:
1433 /*
1434 * we are dealing with MAP rule (SRC address gets
1435 * modified on packet from client)
1436 */
1437 if (nat->nat_v == 4) {
1438 sum_changed = LONG_SUM(ntohl(nat->nat_outip.s_addr));
1439 sum_orig = LONG_SUM(ntohl(nat->nat_inip.s_addr));
1440 } else {
1441 sum_changed = LONG_SUM6(&nat->nat_outip6);
1442 sum_orig = LONG_SUM6(&nat->nat_inip6);
1443 }
1444 break;
1445 default: ;
1446 break;
1447 }
1448
1449 /*
1450 * we also preserve CALC_SUMD() operands here, for IP chksum delta
1451 * calculation, which happens at the end of function.
1452 */
1453 ipsum_changed = sum_changed;
1454 ipsum_orig = sum_orig;
1455 /*
1456 * NOTE: the order of operands for partial chksum adjustment
1457 * computation has to be swapped!
1458 */
1459 CALC_SUMD(sum_changed, sum_orig, sumd);
1460 nat->nat_sumd[1] = (sumd & 0xffff) + (sumd >> 16);
1461
1462 if (nat->nat_flags & (IPN_TCPUDP | IPN_ICMPQUERY)) {
1463
1464 /*
1465 * switch calculates operands for CALC_SUMD(), which will
1466 * compute the full chksum delta.
1467 */
1468 switch (nat->nat_dir)
1469 {
1470 case NAT_INBOUND:
1471 if (nat->nat_v == 4) {
1472 sum_changed = LONG_SUM(
1473 ntohl(nat->nat_inip.s_addr) +
1474 ntohs(nat->nat_inport));
1475 sum_orig = LONG_SUM(
1476 ntohl(nat->nat_outip.s_addr) +
1477 ntohs(nat->nat_outport));
1478 } else {
1479 sum_changed = LONG_SUM6(&nat->nat_inip6) +
1480 ntohs(nat->nat_inport);
1481 sum_orig = LONG_SUM6(&nat->nat_outip6) +
1482 ntohs(nat->nat_outport);
1483 }
1484 break;
1485 case NAT_OUTBOUND:
1486 if (nat->nat_v == 4) {
1487 sum_changed = LONG_SUM(
1488 ntohl(nat->nat_outip.s_addr) +
1489 ntohs(nat->nat_outport));
1490 sum_orig = LONG_SUM(
1491 ntohl(nat->nat_inip.s_addr) +
1492 ntohs(nat->nat_inport));
1493 } else {
1494 sum_changed = LONG_SUM6(&nat->nat_outip6) +
1495 ntohs(nat->nat_outport);
1496 sum_orig = LONG_SUM6(&nat->nat_inip6) +
1497 ntohs(nat->nat_inport);
1498 }
1499 break;
1500 default: ;
1501 break;
1502 }
1503
1504 CALC_SUMD(sum_orig, sum_changed, sumd);
1505 nat->nat_sumd[0] = (sumd & 0xffff) + (sumd >> 16);
1506
1507 if (!(nat->nat_flags & IPN_TCPUDP)) {
1508 /*
1509 * partial HW chksum offload works for TCP/UDP headers only,
1510 * so we need to enforce full chksum adjustment for ICMP
1511 */
1512 nat->nat_sumd[1] = nat->nat_sumd[0];
1513 }
1514 }
1515 else
1516 nat->nat_sumd[0] = nat->nat_sumd[1];
1517
1518 /*
1519 * we may reuse the already computed nat_sumd[0] for IP header chksum
1520 * adjustment in case the L4 (TCP/UDP header) is not changed by NAT.
1521 */
1522 if (nat->nat_v == 4) {
1523 if (NAT_HAS_L4_CHANGED(nat)) {
1524 /*
1525 * bad luck, NAT changes also the L4 header, use IP
1526 * addresses to compute chksum adjustment for IP header.
1527 */
1528 CALC_SUMD(ipsum_orig, ipsum_changed, sumd);
1529 nat->nat_ipsumd = (sumd & 0xffff) + (sumd >> 16);
1530 } else {
1531 /*
1532 * the NAT does not change L4 hdr -> reuse chksum
1533 * adjustment for IP hdr.
1534 */
1535 nat->nat_ipsumd = nat->nat_sumd[0];
1536
1537 /*
1538 * if L4 header does not use chksum - zero out deltas
1539 */
1540 if (!(nat->nat_flags & IPN_TCPUDP)) {
1541 nat->nat_sumd[0] = 0;
1542 nat->nat_sumd[1] = 0;
1543 }
1544 }
1545 }
1546
1547 return;
1548 }
1549
1550 /* ------------------------------------------------------------------------ */
1551 /* Function: fr_natputent */
1552 /* Returns: int - 0 == success, != 0 is the error value. */
1553 /* Parameters: data(I) - pointer to natget structure with NAT */
1554 /* structure information to load into the kernel */
1555 /* getlock(I) - flag indicating whether or not a write lock */
1556 /* on ipf_nat is already held. */
1557 /* ifs - ipf stack instance */
1558 /* */
1559 /* Handle SIOCSTPUT. */
1560 /* Loads a NAT table entry from user space, including a NAT rule, proxy and */
1561 /* firewall rule data structures, if pointers to them indicate so. */
1562 /* ------------------------------------------------------------------------ */
1563 static int fr_natputent(data, getlock, ifs)
1564 caddr_t data;
1565 int getlock;
1566 ipf_stack_t *ifs;
1567 {
1568 nat_save_t ipn, *ipnn;
1569 ap_session_t *aps;
1570 nat_t *n, *nat;
1571 frentry_t *fr;
1572 fr_info_t fin;
1573 ipnat_t *in;
1574 int error;
1575
1576 error = fr_inobj(data, &ipn, IPFOBJ_NATSAVE);
1577 if (error != 0)
1578 return error;
1579
1580 /*
1581 * Trigger automatic call to nat_flushtable() if the
1582 * table has reached capcity specified by hi watermark.
1583 */
1584 if (NAT_TAB_WATER_LEVEL(ifs) > ifs->ifs_nat_flush_level_hi)
1585 ifs->ifs_nat_doflush = 1;
1586
1587 /*
1588 * If automatic flushing did not do its job, and the table
1589 * has filled up, don't try to create a new entry.
1590 */
1591 if (ifs->ifs_nat_stats.ns_inuse >= ifs->ifs_ipf_nattable_max) {
1592 ifs->ifs_nat_stats.ns_memfail++;
1593 return ENOMEM;
1594 }
1595
1596 /*
1597 * Initialise early because of code at junkput label.
1598 */
1599 in = NULL;
1600 aps = NULL;
1601 nat = NULL;
1602 ipnn = NULL;
1603
1604 /*
1605 * New entry, copy in the rest of the NAT entry if it's size is more
1606 * than just the nat_t structure.
1607 */
1608 fr = NULL;
1609 if (ipn.ipn_dsize > sizeof(ipn)) {
1610 if (ipn.ipn_dsize > 81920) {
1611 error = ENOMEM;
1612 goto junkput;
1613 }
1614
1615 KMALLOCS(ipnn, nat_save_t *, ipn.ipn_dsize);
1616 if (ipnn == NULL)
1617 return ENOMEM;
1618
1619 error = fr_inobjsz(data, ipnn, IPFOBJ_NATSAVE, ipn.ipn_dsize);
1620 if (error != 0) {
1621 error = EFAULT;
1622 goto junkput;
1623 }
1624 } else
1625 ipnn = &ipn;
1626
1627 KMALLOC(nat, nat_t *);
1628 if (nat == NULL) {
1629 error = ENOMEM;
1630 goto junkput;
1631 }
1632
1633 bcopy((char *)&ipnn->ipn_nat, (char *)nat, sizeof(*nat));
1634 /*
1635 * Initialize all these so that nat_delete() doesn't cause a crash.
1636 */
1637 bzero((char *)nat, offsetof(struct nat, nat_tqe));
1638 nat->nat_tqe.tqe_pnext = NULL;
1639 nat->nat_tqe.tqe_next = NULL;
1640 nat->nat_tqe.tqe_ifq = NULL;
1641 nat->nat_tqe.tqe_parent = nat;
1642
1643 /*
1644 * Restore the rule associated with this nat session
1645 */
1646 in = ipnn->ipn_nat.nat_ptr;
1647 if (in != NULL) {
1648 KMALLOC(in, ipnat_t *);
1649 nat->nat_ptr = in;
1650 if (in == NULL) {
1651 error = ENOMEM;
1652 goto junkput;
1653 }
1654 bzero((char *)in, offsetof(struct ipnat, in_next6));
1655 bcopy((char *)&ipnn->ipn_ipnat, (char *)in, sizeof(*in));
1656 in->in_use = 1;
1657 in->in_flags |= IPN_DELETE;
1658
1659 ATOMIC_INC(ifs->ifs_nat_stats.ns_rules);
1660
1661 if (nat_resolverule(in, ifs) != 0) {
1662 error = ESRCH;
1663 goto junkput;
1664 }
1665 }
1666
1667 /*
1668 * Check that the NAT entry doesn't already exist in the kernel.
1669 */
1670 if (nat->nat_v != 6)
1671 nat->nat_v = 4;
1672 bzero((char *)&fin, sizeof(fin));
1673 fin.fin_p = nat->nat_p;
1674 fin.fin_ifs = ifs;
1675 if (nat->nat_dir == NAT_OUTBOUND) {
1676 fin.fin_data[0] = ntohs(nat->nat_oport);
1677 fin.fin_data[1] = ntohs(nat->nat_outport);
1678 fin.fin_ifp = nat->nat_ifps[0];
1679 if (getlock) {
1680 READ_ENTER(&ifs->ifs_ipf_nat);
1681 }
1682
1683 switch (nat->nat_v)
1684 {
1685 case 4:
1686 fin.fin_v = nat->nat_v;
1687 n = nat_inlookup(&fin, nat->nat_flags, fin.fin_p,
1688 nat->nat_oip, nat->nat_outip);
1689 break;
1690 #ifdef USE_INET6
1691 case 6:
1692 n = nat6_inlookup(&fin, nat->nat_flags, fin.fin_p,
1693 &nat->nat_oip6.in6, &nat->nat_outip6.in6);
1694 break;
1695 #endif
1696 default:
1697 n = NULL;
1698 break;
1699 }
1700
1701 if (getlock) {
1702 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
1703 }
1704 if (n != NULL) {
1705 error = EEXIST;
1706 goto junkput;
1707 }
1708 } else if (nat->nat_dir == NAT_INBOUND) {
1709 fin.fin_data[0] = ntohs(nat->nat_inport);
1710 fin.fin_data[1] = ntohs(nat->nat_oport);
1711 fin.fin_ifp = nat->nat_ifps[1];
1712 if (getlock) {
1713 READ_ENTER(&ifs->ifs_ipf_nat);
1714 }
1715
1716 switch (nat->nat_v)
1717 {
1718 case 4:
1719 n = nat_outlookup(&fin, nat->nat_flags, fin.fin_p,
1720 nat->nat_inip, nat->nat_oip);
1721 break;
1722 #ifdef USE_INET6
1723 case 6:
1724 n = nat6_outlookup(&fin, nat->nat_flags, fin.fin_p,
1725 &nat->nat_inip6.in6, &nat->nat_oip6.in6);
1726 break;
1727 #endif
1728 default:
1729 n = NULL;
1730 break;
1731 }
1732
1733 if (getlock) {
1734 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
1735 }
1736 if (n != NULL) {
1737 error = EEXIST;
1738 goto junkput;
1739 }
1740 } else {
1741 error = EINVAL;
1742 goto junkput;
1743 }
1744
1745 /*
1746 * Restore ap_session_t structure. Include the private data allocated
1747 * if it was there.
1748 */
1749 aps = nat->nat_aps;
1750 if (aps != NULL) {
1751 KMALLOC(aps, ap_session_t *);
1752 nat->nat_aps = aps;
1753 if (aps == NULL) {
1754 error = ENOMEM;
1755 goto junkput;
1756 }
1757 bcopy(ipnn->ipn_data, (char *)aps, sizeof(*aps));
1758 if (in != NULL)
1759 aps->aps_apr = in->in_apr;
1760 else
1761 aps->aps_apr = NULL;
1762 if (aps->aps_psiz != 0) {
1763 if (aps->aps_psiz > 81920) {
1764 error = ENOMEM;
1765 goto junkput;
1766 }
1767 KMALLOCS(aps->aps_data, void *, aps->aps_psiz);
1768 if (aps->aps_data == NULL) {
1769 error = ENOMEM;
1770 goto junkput;
1771 }
1772 bcopy(ipnn->ipn_data + sizeof(*aps), aps->aps_data,
1773 aps->aps_psiz);
1774 } else {
1775 aps->aps_psiz = 0;
1776 aps->aps_data = NULL;
1777 }
1778 }
1779
1780 /*
1781 * If there was a filtering rule associated with this entry then
1782 * build up a new one.
1783 */
1784 fr = nat->nat_fr;
1785 if (fr != NULL) {
1786 if ((nat->nat_flags & SI_NEWFR) != 0) {
1787 KMALLOC(fr, frentry_t *);
1788 nat->nat_fr = fr;
1789 if (fr == NULL) {
1790 error = ENOMEM;
1791 goto junkput;
1792 }
1793 ipnn->ipn_nat.nat_fr = fr;
1794 (void) fr_outobj(data, ipnn, IPFOBJ_NATSAVE);
1795 bcopy((char *)&ipnn->ipn_fr, (char *)fr, sizeof(*fr));
1796
1797 fr->fr_ref = 1;
1798 fr->fr_dsize = 0;
1799 fr->fr_data = NULL;
1800 fr->fr_type = FR_T_NONE;
1801
1802 MUTEX_NUKE(&fr->fr_lock);
1803 MUTEX_INIT(&fr->fr_lock, "nat-filter rule lock");
1804 } else {
1805 if (getlock) {
1806 READ_ENTER(&ifs->ifs_ipf_nat);
1807 }
1808 for (n = ifs->ifs_nat_instances; n; n = n->nat_next)
1809 if (n->nat_fr == fr)
1810 break;
1811
1812 if (n != NULL) {
1813 MUTEX_ENTER(&fr->fr_lock);
1814 fr->fr_ref++;
1815 MUTEX_EXIT(&fr->fr_lock);
1816 }
1817 if (getlock) {
1818 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
1819 }
1820 if (!n) {
1821 error = ESRCH;
1822 goto junkput;
1823 }
1824 }
1825 }
1826
1827 if (ipnn != &ipn) {
1828 KFREES(ipnn, ipn.ipn_dsize);
1829 ipnn = NULL;
1830 }
1831
1832 nat_calc_chksum_diffs(nat);
1833
1834 if (getlock) {
1835 WRITE_ENTER(&ifs->ifs_ipf_nat);
1836 }
1837
1838 nat_calc_chksum_diffs(nat);
1839
1840 switch (nat->nat_v)
1841 {
1842 case 4 :
1843 error = nat_insert(nat, nat->nat_rev, ifs);
1844 break;
1845 #ifdef USE_INET6
1846 case 6 :
1847 error = nat6_insert(nat, nat->nat_rev, ifs);
1848 break;
1849 #endif
1850 default :
1851 break;
1852 }
1853
1854 if ((error == 0) && (aps != NULL)) {
1855 aps->aps_next = ifs->ifs_ap_sess_list;
1856 ifs->ifs_ap_sess_list = aps;
1857 }
1858 if (getlock) {
1859 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
1860 }
1861
1862 if (error == 0)
1863 return 0;
1864
1865 error = ENOMEM;
1866
1867 junkput:
1868 if (fr != NULL)
1869 (void) fr_derefrule(&fr, ifs);
1870
1871 if ((ipnn != NULL) && (ipnn != &ipn)) {
1872 KFREES(ipnn, ipn.ipn_dsize);
1873 }
1874 if (nat != NULL) {
1875 if (aps != NULL) {
1876 if (aps->aps_data != NULL) {
1877 KFREES(aps->aps_data, aps->aps_psiz);
1878 }
1879 KFREE(aps);
1880 }
1881 if (in != NULL) {
1882 if (in->in_apr)
1883 appr_free(in->in_apr);
1884 KFREE(in);
1885 }
1886 KFREE(nat);
1887 }
1888 return error;
1889 }
1890
1891
1892 /* ------------------------------------------------------------------------ */
1893 /* Function: nat_delete */
1894 /* Returns: int - 0 if entry deleted. Otherwise, ref count on entry */
1895 /* Parameters: nat - pointer to the NAT entry to delete */
1896 /* logtype - type of LOG record to create before deleting */
1897 /* ifs - ipf stack instance */
1898 /* Write Lock: ipf_nat */
1899 /* */
1900 /* Delete a nat entry from the various lists and table. If NAT logging is */
1901 /* enabled then generate a NAT log record for this event. */
1902 /* ------------------------------------------------------------------------ */
1903 int nat_delete(nat, logtype, ifs)
1904 struct nat *nat;
1905 int logtype;
1906 ipf_stack_t *ifs;
1907 {
1908 struct ipnat *ipn;
1909 int removed = 0;
1910
1911 if (logtype != 0 && ifs->ifs_nat_logging != 0)
1912 nat_log(nat, logtype, ifs);
1913
1914 /*
1915 * Start by removing the entry from the hash table of nat entries
1916 * so it will not be "used" again.
1917 *
1918 * It will remain in the "list" of nat entries until all references
1919 * have been accounted for.
1920 */
1921 if ((nat->nat_phnext[0] != NULL) && (nat->nat_phnext[1] != NULL)) {
1922 removed = 1;
1923
1924 ifs->ifs_nat_stats.ns_bucketlen[0][nat->nat_hv[0]]--;
1925 ifs->ifs_nat_stats.ns_bucketlen[1][nat->nat_hv[1]]--;
1926
1927 *nat->nat_phnext[0] = nat->nat_hnext[0];
1928 if (nat->nat_hnext[0] != NULL) {
1929 nat->nat_hnext[0]->nat_phnext[0] = nat->nat_phnext[0];
1930 nat->nat_hnext[0] = NULL;
1931 }
1932 nat->nat_phnext[0] = NULL;
1933
1934 *nat->nat_phnext[1] = nat->nat_hnext[1];
1935 if (nat->nat_hnext[1] != NULL) {
1936 nat->nat_hnext[1]->nat_phnext[1] = nat->nat_phnext[1];
1937 nat->nat_hnext[1] = NULL;
1938 }
1939 nat->nat_phnext[1] = NULL;
1940
1941 if ((nat->nat_flags & SI_WILDP) != 0)
1942 ifs->ifs_nat_stats.ns_wilds--;
1943 }
1944
1945 /*
1946 * Next, remove it from the timeout queue it is in.
1947 */
1948 fr_deletequeueentry(&nat->nat_tqe);
1949
1950 if (nat->nat_me != NULL) {
1951 *nat->nat_me = NULL;
1952 nat->nat_me = NULL;
1953 }
1954
1955 MUTEX_ENTER(&nat->nat_lock);
1956 if (nat->nat_ref > 1) {
1957 nat->nat_ref--;
1958 MUTEX_EXIT(&nat->nat_lock);
1959 if (removed)
1960 ifs->ifs_nat_stats.ns_orphans++;
1961 return (nat->nat_ref);
1962 }
1963 MUTEX_EXIT(&nat->nat_lock);
1964
1965 nat->nat_ref = 0;
1966
1967 /*
1968 * If entry had already been removed,
1969 * it means we're cleaning up an orphan.
1970 */
1971 if (!removed)
1972 ifs->ifs_nat_stats.ns_orphans--;
1973
1974 #ifdef IPFILTER_SYNC
1975 if (nat->nat_sync)
1976 ipfsync_del(nat->nat_sync);
1977 #endif
1978
1979 /*
1980 * Now remove it from master list of nat table entries
1981 */
1982 if (nat->nat_pnext != NULL) {
1983 *nat->nat_pnext = nat->nat_next;
1984 if (nat->nat_next != NULL) {
1985 nat->nat_next->nat_pnext = nat->nat_pnext;
1986 nat->nat_next = NULL;
1987 }
1988 nat->nat_pnext = NULL;
1989 }
1990
1991 if (nat->nat_fr != NULL)
1992 (void)fr_derefrule(&nat->nat_fr, ifs);
1993
1994 if (nat->nat_hm != NULL)
1995 fr_hostmapdel(&nat->nat_hm);
1996
1997 /*
1998 * If there is an active reference from the nat entry to its parent
1999 * rule, decrement the rule's reference count and free it too if no
2000 * longer being used.
2001 */
2002 ipn = nat->nat_ptr;
2003 if (ipn != NULL) {
2004 ipn->in_space++;
2005 ipn->in_use--;
2006 if (ipn->in_use == 0 && (ipn->in_flags & IPN_DELETE)) {
2007 if (ipn->in_apr)
2008 appr_free(ipn->in_apr);
2009 KFREE(ipn);
2010 ifs->ifs_nat_stats.ns_rules--;
2011 }
2012 }
2013
2014 MUTEX_DESTROY(&nat->nat_lock);
2015
2016 aps_free(nat->nat_aps, ifs);
2017 ifs->ifs_nat_stats.ns_inuse--;
2018
2019 /*
2020 * If there's a fragment table entry too for this nat entry, then
2021 * dereference that as well. This is after nat_lock is released
2022 * because of Tru64.
2023 */
2024 fr_forgetnat((void *)nat, ifs);
2025
2026 KFREE(nat);
2027
2028 return (0);
2029 }
2030
2031
2032 /* ------------------------------------------------------------------------ */
2033 /* Function: nat_clearlist */
2034 /* Returns: int - number of NAT/RDR rules deleted */
2035 /* Parameters: Nil */
2036 /* */
2037 /* Delete all rules in the current list of rules. There is nothing elegant */
2038 /* about this cleanup: simply free all entries on the list of rules and */
2039 /* clear out the tables used for hashed NAT rule lookups. */
2040 /* ------------------------------------------------------------------------ */
2041 static int nat_clearlist(ifs)
2042 ipf_stack_t *ifs;
2043 {
2044 ipnat_t *n, **np = &ifs->ifs_nat_list;
2045 int i = 0;
2046
2047 if (ifs->ifs_nat_rules != NULL)
2048 bzero((char *)ifs->ifs_nat_rules,
2049 sizeof(*ifs->ifs_nat_rules) * ifs->ifs_ipf_natrules_sz);
2050 if (ifs->ifs_rdr_rules != NULL)
2051 bzero((char *)ifs->ifs_rdr_rules,
2052 sizeof(*ifs->ifs_rdr_rules) * ifs->ifs_ipf_rdrrules_sz);
2053
2054 while ((n = *np) != NULL) {
2055 *np = n->in_next;
2056 if (n->in_use == 0) {
2057 if (n->in_apr != NULL)
2058 appr_free(n->in_apr);
2059 KFREE(n);
2060 ifs->ifs_nat_stats.ns_rules--;
2061 } else {
2062 n->in_flags |= IPN_DELETE;
2063 n->in_next = NULL;
2064 }
2065 i++;
2066 }
2067 ifs->ifs_nat_masks = 0;
2068 ifs->ifs_rdr_masks = 0;
2069 for (i = 0; i < 4; i++) {
2070 ifs->ifs_nat6_masks[i] = 0;
2071 ifs->ifs_rdr6_masks[i] = 0;
2072 }
2073 return i;
2074 }
2075
2076
2077 /* ------------------------------------------------------------------------ */
2078 /* Function: nat_newmap */
2079 /* Returns: int - -1 == error, 0 == success */
2080 /* Parameters: fin(I) - pointer to packet information */
2081 /* nat(I) - pointer to NAT entry */
2082 /* ni(I) - pointer to structure with misc. information needed */
2083 /* to create new NAT entry. */
2084 /* */
2085 /* Given an empty NAT structure, populate it with new information about a */
2086 /* new NAT session, as defined by the matching NAT rule. */
2087 /* ni.nai_ip is passed in uninitialised and must be set, in host byte order,*/
2088 /* to the new IP address for the translation. */
2089 /* ------------------------------------------------------------------------ */
2090 static INLINE int nat_newmap(fin, nat, ni)
2091 fr_info_t *fin;
2092 nat_t *nat;
2093 natinfo_t *ni;
2094 {
2095 u_short st_port, dport, sport, port, sp, dp;
2096 struct in_addr in, inb;
2097 hostmap_t *hm;
2098 u_32_t flags;
2099 u_32_t st_ip;
2100 ipnat_t *np;
2101 nat_t *natl;
2102 int l;
2103 ipf_stack_t *ifs = fin->fin_ifs;
2104
2105 /*
2106 * If it's an outbound packet which doesn't match any existing
2107 * record, then create a new port
2108 */
2109 l = 0;
2110 hm = NULL;
2111 np = ni->nai_np;
2112 st_ip = np->in_nip;
2113 st_port = np->in_pnext;
2114 flags = ni->nai_flags;
2115 sport = ni->nai_sport;
2116 dport = ni->nai_dport;
2117
2118 /*
2119 * Do a loop until we either run out of entries to try or we find
2120 * a NAT mapping that isn't currently being used. This is done
2121 * because the change to the source is not (usually) being fixed.
2122 */
2123 do {
2124 port = 0;
2125 in.s_addr = htonl(np->in_nip);
2126 if (l == 0) {
2127 /*
2128 * Check to see if there is an existing NAT
2129 * setup for this IP address pair.
2130 */
2131 hm = nat_hostmap(np, fin->fin_src, fin->fin_dst,
2132 in, 0, ifs);
2133 if (hm != NULL)
2134 in.s_addr = hm->hm_mapip.s_addr;
2135 } else if ((l == 1) && (hm != NULL)) {
2136 fr_hostmapdel(&hm);
2137 }
2138 in.s_addr = ntohl(in.s_addr);
2139
2140 nat->nat_hm = hm;
2141
2142 if ((np->in_outmsk == 0xffffffff) && (np->in_pnext == 0)) {
2143 if (l > 0)
2144 return -1;
2145 }
2146
2147 if (np->in_redir == NAT_BIMAP &&
2148 np->in_inmsk == np->in_outmsk) {
2149 /*
2150 * map the address block in a 1:1 fashion
2151 */
2152 in.s_addr = np->in_outip;
2153 in.s_addr |= fin->fin_saddr & ~np->in_inmsk;
2154 in.s_addr = ntohl(in.s_addr);
2155
2156 } else if (np->in_redir & NAT_MAPBLK) {
2157 if ((l >= np->in_ppip) || ((l > 0) &&
2158 !(flags & IPN_TCPUDP)))
2159 return -1;
2160 /*
2161 * map-block - Calculate destination address.
2162 */
2163 in.s_addr = ntohl(fin->fin_saddr);
2164 in.s_addr &= ntohl(~np->in_inmsk);
2165 inb.s_addr = in.s_addr;
2166 in.s_addr /= np->in_ippip;
2167 in.s_addr &= ntohl(~np->in_outmsk);
2168 in.s_addr += ntohl(np->in_outip);
2169 /*
2170 * Calculate destination port.
2171 */
2172 if ((flags & IPN_TCPUDP) &&
2173 (np->in_ppip != 0)) {
2174 port = ntohs(sport) + l;
2175 port %= np->in_ppip;
2176 port += np->in_ppip *
2177 (inb.s_addr % np->in_ippip);
2178 port += MAPBLK_MINPORT;
2179 port = htons(port);
2180 }
2181
2182 } else if ((np->in_outip == 0) &&
2183 (np->in_outmsk == 0xffffffff)) {
2184 /*
2185 * 0/32 - use the interface's IP address.
2186 */
2187 if ((l > 0) ||
2188 fr_ifpaddr(4, FRI_NORMAL, fin->fin_ifp,
2189 &in, NULL, fin->fin_ifs) == -1)
2190 return -1;
2191 in.s_addr = ntohl(in.s_addr);
2192
2193 } else if ((np->in_outip == 0) && (np->in_outmsk == 0)) {
2194 /*
2195 * 0/0 - use the original source address/port.
2196 */
2197 if (l > 0)
2198 return -1;
2199 in.s_addr = ntohl(fin->fin_saddr);
2200
2201 } else if ((np->in_outmsk != 0xffffffff) &&
2202 (np->in_pnext == 0) && ((l > 0) || (hm == NULL)))
2203 np->in_nip++;
2204
2205 natl = NULL;
2206
2207 if ((flags & IPN_TCPUDP) &&
2208 ((np->in_redir & NAT_MAPBLK) == 0) &&
2209 (np->in_flags & IPN_AUTOPORTMAP)) {
2210 /*
2211 * "ports auto" (without map-block)
2212 */
2213 if ((l > 0) && (l % np->in_ppip == 0)) {
2214 if (l > np->in_space) {
2215 return -1;
2216 } else if ((l > np->in_ppip) &&
2217 np->in_outmsk != 0xffffffff)
2218 np->in_nip++;
2219 }
2220 if (np->in_ppip != 0) {
2221 port = ntohs(sport);
2222 port += (l % np->in_ppip);
2223 port %= np->in_ppip;
2224 port += np->in_ppip *
2225 (ntohl(fin->fin_saddr) %
2226 np->in_ippip);
2227 port += MAPBLK_MINPORT;
2228 port = htons(port);
2229 }
2230
2231 } else if (((np->in_redir & NAT_MAPBLK) == 0) &&
2232 (flags & IPN_TCPUDPICMP) && (np->in_pnext != 0)) {
2233 /*
2234 * Standard port translation. Select next port.
2235 */
2236 if (np->in_flags & IPN_SEQUENTIAL) {
2237 port = np->in_pnext;
2238 } else {
2239 port = ipf_random() % (ntohs(np->in_pmax) -
2240 ntohs(np->in_pmin) + 1);
2241 port += ntohs(np->in_pmin);
2242 }
2243 port = htons(port);
2244 np->in_pnext++;
2245
2246 if (np->in_pnext > ntohs(np->in_pmax)) {
2247 np->in_pnext = ntohs(np->in_pmin);
2248 if (np->in_outmsk != 0xffffffff)
2249 np->in_nip++;
2250 }
2251 }
2252
2253 if (np->in_flags & IPN_IPRANGE) {
2254 if (np->in_nip > ntohl(np->in_outmsk))
2255 np->in_nip = ntohl(np->in_outip);
2256 } else {
2257 if ((np->in_outmsk != 0xffffffff) &&
2258 ((np->in_nip + 1) & ntohl(np->in_outmsk)) >
2259 ntohl(np->in_outip))
2260 np->in_nip = ntohl(np->in_outip) + 1;
2261 }
2262
2263 if ((port == 0) && (flags & (IPN_TCPUDPICMP|IPN_ICMPQUERY)))
2264 port = sport;
2265
2266 /*
2267 * Here we do a lookup of the connection as seen from
2268 * the outside. If an IP# pair already exists, try
2269 * again. So if you have A->B becomes C->B, you can
2270 * also have D->E become C->E but not D->B causing
2271 * another C->B. Also take protocol and ports into
2272 * account when determining whether a pre-existing
2273 * NAT setup will cause an external conflict where
2274 * this is appropriate.
2275 */
2276 inb.s_addr = htonl(in.s_addr);
2277 sp = fin->fin_data[0];
2278 dp = fin->fin_data[1];
2279 fin->fin_data[0] = fin->fin_data[1];
2280 fin->fin_data[1] = htons(port);
2281 natl = nat_inlookup(fin, flags & ~(SI_WILDP|NAT_SEARCH),
2282 (u_int)fin->fin_p, fin->fin_dst, inb);
2283 fin->fin_data[0] = sp;
2284 fin->fin_data[1] = dp;
2285
2286 /*
2287 * Has the search wrapped around and come back to the
2288 * start ?
2289 */
2290 if ((natl != NULL) &&
2291 (np->in_pnext != 0) && (st_port == np->in_pnext) &&
2292 (np->in_nip != 0) && (st_ip == np->in_nip))
2293 return -1;
2294 l++;
2295 } while (natl != NULL);
2296
2297 if (np->in_space > 0)
2298 np->in_space--;
2299
2300 /* Setup the NAT table */
2301 nat->nat_inip = fin->fin_src;
2302 nat->nat_outip.s_addr = htonl(in.s_addr);
2303 nat->nat_oip = fin->fin_dst;
2304 if (nat->nat_hm == NULL)
2305 nat->nat_hm = nat_hostmap(np, fin->fin_src, fin->fin_dst,
2306 nat->nat_outip, 0, ifs);
2307
2308 if (flags & IPN_TCPUDP) {
2309 nat->nat_inport = sport;
2310 nat->nat_outport = port; /* sport */
2311 nat->nat_oport = dport;
2312 ((tcphdr_t *)fin->fin_dp)->th_sport = port;
2313 } else if (flags & IPN_ICMPQUERY) {
2314 ((icmphdr_t *)fin->fin_dp)->icmp_id = port;
2315 nat->nat_inport = port;
2316 nat->nat_outport = port;
2317 }
2318
2319 ni->nai_ip.s_addr = in.s_addr;
2320 ni->nai_port = port;
2321 ni->nai_nport = dport;
2322 return 0;
2323 }
2324
2325
2326 /* ------------------------------------------------------------------------ */
2327 /* Function: nat_newrdr */
2328 /* Returns: int - -1 == error, 0 == success (no move), 1 == success and */
2329 /* allow rule to be moved if IPN_ROUNDR is set. */
2330 /* Parameters: fin(I) - pointer to packet information */
2331 /* nat(I) - pointer to NAT entry */
2332 /* ni(I) - pointer to structure with misc. information needed */
2333 /* to create new NAT entry. */
2334 /* */
2335 /* ni.nai_ip is passed in uninitialised and must be set, in host byte order,*/
2336 /* to the new IP address for the translation. */
2337 /* ------------------------------------------------------------------------ */
2338 static INLINE int nat_newrdr(fin, nat, ni)
2339 fr_info_t *fin;
2340 nat_t *nat;
2341 natinfo_t *ni;
2342 {
2343 u_short nport, dport, sport;
2344 struct in_addr in, inb;
2345 u_short sp, dp;
2346 hostmap_t *hm;
2347 u_32_t flags;
2348 ipnat_t *np;
2349 nat_t *natl;
2350 int move;
2351 ipf_stack_t *ifs = fin->fin_ifs;
2352
2353 move = 1;
2354 hm = NULL;
2355 in.s_addr = 0;
2356 np = ni->nai_np;
2357 flags = ni->nai_flags;
2358 sport = ni->nai_sport;
2359 dport = ni->nai_dport;
2360
2361 /*
2362 * If the matching rule has IPN_STICKY set, then we want to have the
2363 * same rule kick in as before. Why would this happen? If you have
2364 * a collection of rdr rules with "round-robin sticky", the current
2365 * packet might match a different one to the previous connection but
2366 * we want the same destination to be used.
2367 */
2368 if ((np->in_flags & (IPN_ROUNDR|IPN_STICKY)) ==
2369 (IPN_ROUNDR|IPN_STICKY)) {
2370 hm = nat_hostmap(NULL, fin->fin_src, fin->fin_dst, in,
2371 (u_32_t)dport, ifs);
2372 if (hm != NULL) {
2373 in.s_addr = ntohl(hm->hm_mapip.s_addr);
2374 np = hm->hm_ipnat;
2375 ni->nai_np = np;
2376 move = 0;
2377 }
2378 }
2379
2380 /*
2381 * Otherwise, it's an inbound packet. Most likely, we don't
2382 * want to rewrite source ports and source addresses. Instead,
2383 * we want to rewrite to a fixed internal address and fixed
2384 * internal port.
2385 */
2386 if (np->in_flags & IPN_SPLIT) {
2387 in.s_addr = np->in_nip;
2388
2389 if ((np->in_flags & (IPN_ROUNDR|IPN_STICKY)) == IPN_STICKY) {
2390 hm = nat_hostmap(np, fin->fin_src, fin->fin_dst,
2391 in, (u_32_t)dport, ifs);
2392 if (hm != NULL) {
2393 in.s_addr = hm->hm_mapip.s_addr;
2394 move = 0;
2395 }
2396 }
2397
2398 if (hm == NULL || hm->hm_ref == 1) {
2399 if (np->in_inip == htonl(in.s_addr)) {
2400 np->in_nip = ntohl(np->in_inmsk);
2401 move = 0;
2402 } else {
2403 np->in_nip = ntohl(np->in_inip);
2404 }
2405 }
2406
2407 } else if ((np->in_inip == 0) && (np->in_inmsk == 0xffffffff)) {
2408 /*
2409 * 0/32 - use the interface's IP address.
2410 */
2411 if (fr_ifpaddr(4, FRI_NORMAL, fin->fin_ifp, &in, NULL,
2412 fin->fin_ifs) == -1)
2413 return -1;
2414 in.s_addr = ntohl(in.s_addr);
2415
2416 } else if ((np->in_inip == 0) && (np->in_inmsk== 0)) {
2417 /*
2418 * 0/0 - use the original destination address/port.
2419 */
2420 in.s_addr = ntohl(fin->fin_daddr);
2421
2422 } else if (np->in_redir == NAT_BIMAP &&
2423 np->in_inmsk == np->in_outmsk) {
2424 /*
2425 * map the address block in a 1:1 fashion
2426 */
2427 in.s_addr = np->in_inip;
2428 in.s_addr |= fin->fin_daddr & ~np->in_inmsk;
2429 in.s_addr = ntohl(in.s_addr);
2430 } else {
2431 in.s_addr = ntohl(np->in_inip);
2432 }
2433
2434 if ((np->in_pnext == 0) || ((flags & NAT_NOTRULEPORT) != 0))
2435 nport = dport;
2436 else {
2437 /*
2438 * Whilst not optimized for the case where
2439 * pmin == pmax, the gain is not significant.
2440 */
2441 if (((np->in_flags & IPN_FIXEDDPORT) == 0) &&
2442 (np->in_pmin != np->in_pmax)) {
2443 nport = ntohs(dport) - ntohs(np->in_pmin) +
2444 ntohs(np->in_pnext);
2445 nport = htons(nport);
2446 } else
2447 nport = np->in_pnext;
2448 }
2449
2450 /*
2451 * When the redirect-to address is set to 0.0.0.0, just
2452 * assume a blank `forwarding' of the packet. We don't
2453 * setup any translation for this either.
2454 */
2455 if (in.s_addr == 0) {
2456 if (nport == dport)
2457 return -1;
2458 in.s_addr = ntohl(fin->fin_daddr);
2459 }
2460
2461 /*
2462 * Check to see if this redirect mapping already exists and if
2463 * it does, return "failure" (allowing it to be created will just
2464 * cause one or both of these "connections" to stop working.)
2465 */
2466 inb.s_addr = htonl(in.s_addr);
2467 sp = fin->fin_data[0];
2468 dp = fin->fin_data[1];
2469 fin->fin_data[1] = fin->fin_data[0];
2470 fin->fin_data[0] = ntohs(nport);
2471 natl = nat_outlookup(fin, flags & ~(SI_WILDP|NAT_SEARCH),
2472 (u_int)fin->fin_p, inb, fin->fin_src);
2473 fin->fin_data[0] = sp;
2474 fin->fin_data[1] = dp;
2475 if (natl != NULL)
2476 return (-1);
2477
2478 nat->nat_inip.s_addr = htonl(in.s_addr);
2479 nat->nat_outip = fin->fin_dst;
2480 nat->nat_oip = fin->fin_src;
2481
2482 ni->nai_ip.s_addr = in.s_addr;
2483 ni->nai_nport = nport;
2484 ni->nai_port = sport;
2485
2486 if (flags & IPN_TCPUDP) {
2487 nat->nat_inport = nport;
2488 nat->nat_outport = dport;
2489 nat->nat_oport = sport;
2490 ((tcphdr_t *)fin->fin_dp)->th_dport = nport;
2491 } else if (flags & IPN_ICMPQUERY) {
2492 ((icmphdr_t *)fin->fin_dp)->icmp_id = nport;
2493 nat->nat_inport = nport;
2494 nat->nat_outport = nport;
2495 }
2496
2497 return move;
2498 }
2499
2500 /* ------------------------------------------------------------------------ */
2501 /* Function: nat_new */
2502 /* Returns: nat_t* - NULL == failure to create new NAT structure, */
2503 /* else pointer to new NAT structure */
2504 /* Parameters: fin(I) - pointer to packet information */
2505 /* np(I) - pointer to NAT rule */
2506 /* natsave(I) - pointer to where to store NAT struct pointer */
2507 /* flags(I) - flags describing the current packet */
2508 /* direction(I) - direction of packet (in/out) */
2509 /* Write Lock: ipf_nat */
2510 /* */
2511 /* Attempts to create a new NAT entry. Does not actually change the packet */
2512 /* in any way. */
2513 /* */
2514 /* This fucntion is in three main parts: (1) deal with creating a new NAT */
2515 /* structure for a "MAP" rule (outgoing NAT translation); (2) deal with */
2516 /* creating a new NAT structure for a "RDR" rule (incoming NAT translation) */
2517 /* and (3) building that structure and putting it into the NAT table(s). */
2518 /* ------------------------------------------------------------------------ */
2519 nat_t *nat_new(fin, np, natsave, flags, direction)
2520 fr_info_t *fin;
2521 ipnat_t *np;
2522 nat_t **natsave;
2523 u_int flags;
2524 int direction;
2525 {
2526 tcphdr_t *tcp = NULL;
2527 hostmap_t *hm = NULL;
2528 nat_t *nat, *natl;
2529 u_int nflags;
2530 natinfo_t ni;
2531 int move;
2532 ipf_stack_t *ifs = fin->fin_ifs;
2533
2534 /*
2535 * Trigger automatic call to nat_flushtable() if the
2536 * table has reached capcity specified by hi watermark.
2537 */
2538 if (NAT_TAB_WATER_LEVEL(ifs) > ifs->ifs_nat_flush_level_hi)
2539 ifs->ifs_nat_doflush = 1;
2540
2541 /*
2542 * If automatic flushing did not do its job, and the table
2543 * has filled up, don't try to create a new entry.
2544 */
2545 if (ifs->ifs_nat_stats.ns_inuse >= ifs->ifs_ipf_nattable_max) {
2546 ifs->ifs_nat_stats.ns_memfail++;
2547 return NULL;
2548 }
2549
2550 move = 1;
2551 nflags = np->in_flags & flags;
2552 nflags &= NAT_FROMRULE;
2553
2554 ni.nai_np = np;
2555 ni.nai_nflags = nflags;
2556 ni.nai_flags = flags;
2557
2558 /* Give me a new nat */
2559 KMALLOC(nat, nat_t *);
2560 if (nat == NULL) {
2561 ifs->ifs_nat_stats.ns_memfail++;
2562 /*
2563 * Try to automatically tune the max # of entries in the
2564 * table allowed to be less than what will cause kmem_alloc()
2565 * to fail and try to eliminate panics due to out of memory
2566 * conditions arising.
2567 */
2568 if (ifs->ifs_ipf_nattable_max > ifs->ifs_ipf_nattable_sz) {
2569 ifs->ifs_ipf_nattable_max = ifs->ifs_nat_stats.ns_inuse - 100;
2570 printf("ipf_nattable_max reduced to %d\n",
2571 ifs->ifs_ipf_nattable_max);
2572 }
2573 return NULL;
2574 }
2575
2576 if (flags & IPN_TCPUDP) {
2577 tcp = fin->fin_dp;
2578 ni.nai_sport = htons(fin->fin_sport);
2579 ni.nai_dport = htons(fin->fin_dport);
2580 } else if (flags & IPN_ICMPQUERY) {
2581 /*
2582 * In the ICMP query NAT code, we translate the ICMP id fields
2583 * to make them unique. This is indepedent of the ICMP type
2584 * (e.g. in the unlikely event that a host sends an echo and
2585 * an tstamp request with the same id, both packets will have
2586 * their ip address/id field changed in the same way).
2587 */
2588 /* The icmp_id field is used by the sender to identify the
2589 * process making the icmp request. (the receiver justs
2590 * copies it back in its response). So, it closely matches
2591 * the concept of source port. We overlay sport, so we can
2592 * maximally reuse the existing code.
2593 */
2594 ni.nai_sport = ((icmphdr_t *)fin->fin_dp)->icmp_id;
2595 ni.nai_dport = ni.nai_sport;
2596 }
2597
2598 bzero((char *)nat, sizeof(*nat));
2599 nat->nat_flags = flags;
2600 nat->nat_redir = np->in_redir;
2601
2602 if ((flags & NAT_SLAVE) == 0) {
2603 MUTEX_ENTER(&ifs->ifs_ipf_nat_new);
2604 }
2605
2606 /*
2607 * Search the current table for a match.
2608 */
2609 if (direction == NAT_OUTBOUND) {
2610 /*
2611 * We can now arrange to call this for the same connection
2612 * because ipf_nat_new doesn't protect the code path into
2613 * this function.
2614 */
2615 natl = nat_outlookup(fin, nflags, (u_int)fin->fin_p,
2616 fin->fin_src, fin->fin_dst);
2617 if (natl != NULL) {
2618 KFREE(nat);
2619 nat = natl;
2620 goto done;
2621 }
2622
2623 move = nat_newmap(fin, nat, &ni);
2624 if (move == -1)
2625 goto badnat;
2626
2627 np = ni.nai_np;
2628 } else {
2629 /*
2630 * NAT_INBOUND is used only for redirects rules
2631 */
2632 natl = nat_inlookup(fin, nflags, (u_int)fin->fin_p,
2633 fin->fin_src, fin->fin_dst);
2634 if (natl != NULL) {
2635 KFREE(nat);
2636 nat = natl;
2637 goto done;
2638 }
2639
2640 move = nat_newrdr(fin, nat, &ni);
2641 if (move == -1)
2642 goto badnat;
2643
2644 np = ni.nai_np;
2645 }
2646
2647 if ((move == 1) && (np->in_flags & IPN_ROUNDR)) {
2648 if (np->in_redir == NAT_REDIRECT) {
2649 nat_delrdr(np);
2650 nat_addrdr(np, ifs);
2651 } else if (np->in_redir == NAT_MAP) {
2652 nat_delnat(np);
2653 nat_addnat(np, ifs);
2654 }
2655 }
2656
2657 if (nat_finalise(fin, nat, &ni, tcp, natsave, direction) == -1) {
2658 goto badnat;
2659 }
2660
2661 nat_calc_chksum_diffs(nat);
2662
2663 if (flags & SI_WILDP)
2664 ifs->ifs_nat_stats.ns_wilds++;
2665 fin->fin_flx |= FI_NEWNAT;
2666 goto done;
2667 badnat:
2668 ifs->ifs_nat_stats.ns_badnat++;
2669 if ((hm = nat->nat_hm) != NULL)
2670 fr_hostmapdel(&hm);
2671 KFREE(nat);
2672 nat = NULL;
2673 done:
2674 if ((flags & NAT_SLAVE) == 0) {
2675 MUTEX_EXIT(&ifs->ifs_ipf_nat_new);
2676 }
2677 return nat;
2678 }
2679
2680
2681 /* ------------------------------------------------------------------------ */
2682 /* Function: nat_finalise */
2683 /* Returns: int - 0 == sucess, -1 == failure */
2684 /* Parameters: fin(I) - pointer to packet information */
2685 /* nat(I) - pointer to NAT entry */
2686 /* ni(I) - pointer to structure with misc. information needed */
2687 /* to create new NAT entry. */
2688 /* Write Lock: ipf_nat */
2689 /* */
2690 /* This is the tail end of constructing a new NAT entry and is the same */
2691 /* for both IPv4 and IPv6. */
2692 /* ------------------------------------------------------------------------ */
2693 /*ARGSUSED*/
2694 static INLINE int nat_finalise(fin, nat, ni, tcp, natsave, direction)
2695 fr_info_t *fin;
2696 nat_t *nat;
2697 natinfo_t *ni;
2698 tcphdr_t *tcp;
2699 nat_t **natsave;
2700 int direction;
2701 {
2702 frentry_t *fr;
2703 ipnat_t *np;
2704 ipf_stack_t *ifs = fin->fin_ifs;
2705
2706 np = ni->nai_np;
2707
2708 COPYIFNAME(fin->fin_ifp, nat->nat_ifnames[0], fin->fin_v);
2709
2710 #ifdef IPFILTER_SYNC
2711 if ((nat->nat_flags & SI_CLONE) == 0)
2712 nat->nat_sync = ipfsync_new(SMC_NAT, fin, nat);
2713 #endif
2714
2715 nat->nat_me = natsave;
2716 nat->nat_dir = direction;
2717 nat->nat_ifps[0] = np->in_ifps[0];
2718 nat->nat_ifps[1] = np->in_ifps[1];
2719 nat->nat_ptr = np;
2720 nat->nat_p = fin->fin_p;
2721 nat->nat_v = fin->fin_v;
2722 nat->nat_mssclamp = np->in_mssclamp;
2723 fr = fin->fin_fr;
2724 nat->nat_fr = fr;
2725
2726 if ((np->in_apr != NULL) && ((ni->nai_flags & NAT_SLAVE) == 0))
2727 if (appr_new(fin, nat) == -1)
2728 return -1;
2729
2730 if (nat_insert(nat, fin->fin_rev, ifs) == 0) {
2731 if (ifs->ifs_nat_logging)
2732 nat_log(nat, (u_int)np->in_redir, ifs);
2733 np->in_use++;
2734 if (fr != NULL) {
2735 MUTEX_ENTER(&fr->fr_lock);
2736 fr->fr_ref++;
2737 MUTEX_EXIT(&fr->fr_lock);
2738 }
2739 return 0;
2740 }
2741
2742 /*
2743 * nat_insert failed, so cleanup time...
2744 */
2745 return -1;
2746 }
2747
2748
2749 /* ------------------------------------------------------------------------ */
2750 /* Function: nat_insert */
2751 /* Returns: int - 0 == sucess, -1 == failure */
2752 /* Parameters: nat(I) - pointer to NAT structure */
2753 /* rev(I) - flag indicating forward/reverse direction of packet */
2754 /* Write Lock: ipf_nat */
2755 /* */
2756 /* Insert a NAT entry into the hash tables for searching and add it to the */
2757 /* list of active NAT entries. Adjust global counters when complete. */
2758 /* ------------------------------------------------------------------------ */
2759 int nat_insert(nat, rev, ifs)
2760 nat_t *nat;
2761 int rev;
2762 ipf_stack_t *ifs;
2763 {
2764 u_int hv1, hv2;
2765 nat_t **natp;
2766
2767 /*
2768 * Try and return an error as early as possible, so calculate the hash
2769 * entry numbers first and then proceed.
2770 */
2771 if ((nat->nat_flags & (SI_W_SPORT|SI_W_DPORT)) == 0) {
2772 hv1 = NAT_HASH_FN(nat->nat_inip.s_addr, nat->nat_inport,
2773 0xffffffff);
2774 hv1 = NAT_HASH_FN(nat->nat_oip.s_addr, hv1 + nat->nat_oport,
2775 ifs->ifs_ipf_nattable_sz);
2776 hv2 = NAT_HASH_FN(nat->nat_outip.s_addr, nat->nat_outport,
2777 0xffffffff);
2778 hv2 = NAT_HASH_FN(nat->nat_oip.s_addr, hv2 + nat->nat_oport,
2779 ifs->ifs_ipf_nattable_sz);
2780 } else {
2781 hv1 = NAT_HASH_FN(nat->nat_inip.s_addr, 0, 0xffffffff);
2782 hv1 = NAT_HASH_FN(nat->nat_oip.s_addr, hv1,
2783 ifs->ifs_ipf_nattable_sz);
2784 hv2 = NAT_HASH_FN(nat->nat_outip.s_addr, 0, 0xffffffff);
2785 hv2 = NAT_HASH_FN(nat->nat_oip.s_addr, hv2,
2786 ifs->ifs_ipf_nattable_sz);
2787 }
2788
2789 if (ifs->ifs_nat_stats.ns_bucketlen[0][hv1] >= ifs->ifs_fr_nat_maxbucket ||
2790 ifs->ifs_nat_stats.ns_bucketlen[1][hv2] >= ifs->ifs_fr_nat_maxbucket) {
2791 return -1;
2792 }
2793
2794 nat->nat_hv[0] = hv1;
2795 nat->nat_hv[1] = hv2;
2796
2797 MUTEX_INIT(&nat->nat_lock, "nat entry lock");
2798
2799 nat->nat_rev = rev;
2800 nat->nat_ref = 1;
2801 nat->nat_bytes[0] = 0;
2802 nat->nat_pkts[0] = 0;
2803 nat->nat_bytes[1] = 0;
2804 nat->nat_pkts[1] = 0;
2805
2806 nat->nat_ifnames[0][LIFNAMSIZ - 1] = '\0';
2807 nat->nat_ifps[0] = fr_resolvenic(nat->nat_ifnames[0], 4, ifs);
2808
2809 if (nat->nat_ifnames[1][0] !='\0') {
2810 nat->nat_ifnames[1][LIFNAMSIZ - 1] = '\0';
2811 nat->nat_ifps[1] = fr_resolvenic(nat->nat_ifnames[1], 4, ifs);
2812 } else {
2813 (void) strncpy(nat->nat_ifnames[1], nat->nat_ifnames[0],
2814 LIFNAMSIZ);
2815 nat->nat_ifnames[1][LIFNAMSIZ - 1] = '\0';
2816 nat->nat_ifps[1] = nat->nat_ifps[0];
2817 }
2818
2819 nat->nat_next = ifs->ifs_nat_instances;
2820 nat->nat_pnext = &ifs->ifs_nat_instances;
2821 if (ifs->ifs_nat_instances)
2822 ifs->ifs_nat_instances->nat_pnext = &nat->nat_next;
2823 ifs->ifs_nat_instances = nat;
2824
2825 natp = &ifs->ifs_nat_table[0][hv1];
2826 if (*natp)
2827 (*natp)->nat_phnext[0] = &nat->nat_hnext[0];
2828 nat->nat_phnext[0] = natp;
2829 nat->nat_hnext[0] = *natp;
2830 *natp = nat;
2831 ifs->ifs_nat_stats.ns_bucketlen[0][hv1]++;
2832
2833 natp = &ifs->ifs_nat_table[1][hv2];
2834 if (*natp)
2835 (*natp)->nat_phnext[1] = &nat->nat_hnext[1];
2836 nat->nat_phnext[1] = natp;
2837 nat->nat_hnext[1] = *natp;
2838 *natp = nat;
2839 ifs->ifs_nat_stats.ns_bucketlen[1][hv2]++;
2840
2841 fr_setnatqueue(nat, rev, ifs);
2842
2843 ifs->ifs_nat_stats.ns_added++;
2844 ifs->ifs_nat_stats.ns_inuse++;
2845 return 0;
2846 }
2847
2848
2849 /* ------------------------------------------------------------------------ */
2850 /* Function: nat_icmperrorlookup */
2851 /* Returns: nat_t* - point to matching NAT structure */
2852 /* Parameters: fin(I) - pointer to packet information */
2853 /* dir(I) - direction of packet (in/out) */
2854 /* */
2855 /* Check if the ICMP error message is related to an existing TCP, UDP or */
2856 /* ICMP query nat entry. It is assumed that the packet is already of the */
2857 /* the required length. */
2858 /* ------------------------------------------------------------------------ */
2859 nat_t *nat_icmperrorlookup(fin, dir)
2860 fr_info_t *fin;
2861 int dir;
2862 {
2863 int flags = 0, minlen;
2864 icmphdr_t *orgicmp;
2865 tcphdr_t *tcp = NULL;
2866 u_short data[2];
2867 nat_t *nat;
2868 ip_t *oip;
2869 u_int p;
2870
2871 /*
2872 * Does it at least have the return (basic) IP header ?
2873 * Only a basic IP header (no options) should be with an ICMP error
2874 * header. Also, if it's not an error type, then return.
2875 */
2876 if ((fin->fin_hlen != sizeof(ip_t)) || !(fin->fin_flx & FI_ICMPERR))
2877 return NULL;
2878
2879 /*
2880 * Check packet size
2881 */
2882 oip = (ip_t *)((char *)fin->fin_dp + 8);
2883 minlen = IP_HL(oip) << 2;
2884 if ((minlen < sizeof(ip_t)) ||
2885 (fin->fin_plen < ICMPERR_IPICMPHLEN + minlen))
2886 return NULL;
2887 /*
2888 * Is the buffer big enough for all of it ? It's the size of the IP
2889 * header claimed in the encapsulated part which is of concern. It
2890 * may be too big to be in this buffer but not so big that it's
2891 * outside the ICMP packet, leading to TCP deref's causing problems.
2892 * This is possible because we don't know how big oip_hl is when we
2893 * do the pullup early in fr_check() and thus can't gaurantee it is
2894 * all here now.
2895 */
2896 #ifdef _KERNEL
2897 {
2898 mb_t *m;
2899
2900 m = fin->fin_m;
2901 # if defined(MENTAT)
2902 if ((char *)oip + fin->fin_dlen - ICMPERR_ICMPHLEN > (char *)m->b_wptr)
2903 return NULL;
2904 # else
2905 if ((char *)oip + fin->fin_dlen - ICMPERR_ICMPHLEN >
2906 (char *)fin->fin_ip + M_LEN(m))
2907 return NULL;
2908 # endif
2909 }
2910 #endif
2911
2912 if (fin->fin_daddr != oip->ip_src.s_addr)
2913 return NULL;
2914
2915 p = oip->ip_p;
2916 if (p == IPPROTO_TCP)
2917 flags = IPN_TCP;
2918 else if (p == IPPROTO_UDP)
2919 flags = IPN_UDP;
2920 else if (p == IPPROTO_ICMP) {
2921 orgicmp = (icmphdr_t *)((char *)oip + (IP_HL(oip) << 2));
2922
2923 /* see if this is related to an ICMP query */
2924 if (nat_icmpquerytype4(orgicmp->icmp_type)) {
2925 data[0] = fin->fin_data[0];
2926 data[1] = fin->fin_data[1];
2927 fin->fin_data[0] = 0;
2928 fin->fin_data[1] = orgicmp->icmp_id;
2929
2930 flags = IPN_ICMPERR|IPN_ICMPQUERY;
2931 /*
2932 * NOTE : dir refers to the direction of the original
2933 * ip packet. By definition the icmp error
2934 * message flows in the opposite direction.
2935 */
2936 if (dir == NAT_INBOUND)
2937 nat = nat_inlookup(fin, flags, p, oip->ip_dst,
2938 oip->ip_src);
2939 else
2940 nat = nat_outlookup(fin, flags, p, oip->ip_dst,
2941 oip->ip_src);
2942 fin->fin_data[0] = data[0];
2943 fin->fin_data[1] = data[1];
2944 return nat;
2945 }
2946 }
2947
2948 if (flags & IPN_TCPUDP) {
2949 minlen += 8; /* + 64bits of data to get ports */
2950 if (fin->fin_plen < ICMPERR_IPICMPHLEN + minlen)
2951 return NULL;
2952
2953 data[0] = fin->fin_data[0];
2954 data[1] = fin->fin_data[1];
2955 tcp = (tcphdr_t *)((char *)oip + (IP_HL(oip) << 2));
2956 fin->fin_data[0] = ntohs(tcp->th_dport);
2957 fin->fin_data[1] = ntohs(tcp->th_sport);
2958
2959 if (dir == NAT_INBOUND) {
2960 nat = nat_inlookup(fin, flags, p, oip->ip_dst,
2961 oip->ip_src);
2962 } else {
2963 nat = nat_outlookup(fin, flags, p, oip->ip_dst,
2964 oip->ip_src);
2965 }
2966 fin->fin_data[0] = data[0];
2967 fin->fin_data[1] = data[1];
2968 return nat;
2969 }
2970 if (dir == NAT_INBOUND)
2971 return nat_inlookup(fin, 0, p, oip->ip_dst, oip->ip_src);
2972 else
2973 return nat_outlookup(fin, 0, p, oip->ip_dst, oip->ip_src);
2974 }
2975
2976
2977 /* ------------------------------------------------------------------------ */
2978 /* Function: nat_icmperror */
2979 /* Returns: nat_t* - point to matching NAT structure */
2980 /* Parameters: fin(I) - pointer to packet information */
2981 /* nflags(I) - NAT flags for this packet */
2982 /* dir(I) - direction of packet (in/out) */
2983 /* */
2984 /* Fix up an ICMP packet which is an error message for an existing NAT */
2985 /* session. This will correct both packet header data and checksums. */
2986 /* */
2987 /* This should *ONLY* be used for incoming ICMP error packets to make sure */
2988 /* a NAT'd ICMP packet gets correctly recognised. */
2989 /* ------------------------------------------------------------------------ */
2990 nat_t *nat_icmperror(fin, nflags, dir)
2991 fr_info_t *fin;
2992 u_int *nflags;
2993 int dir;
2994 {
2995 u_32_t sum1, sum2, sumd, psum1, psum2, psumd, sumd2;
2996 struct in_addr in;
2997 icmphdr_t *icmp, *orgicmp;
2998 int dlen;
2999 udphdr_t *udp;
3000 tcphdr_t *tcp;
3001 nat_t *nat;
3002 ip_t *oip;
3003 if ((fin->fin_flx & (FI_SHORT|FI_FRAGBODY)))
3004 return NULL;
3005
3006 /*
3007 * nat_icmperrorlookup() looks up nat entry associated with the
3008 * offending IP packet and returns pointer to the entry, or NULL
3009 * if packet wasn't natted or for `defective' packets.
3010 */
3011
3012 if ((fin->fin_v != 4) || !(nat = nat_icmperrorlookup(fin, dir)))
3013 return NULL;
3014
3015 sumd2 = 0;
3016 *nflags = IPN_ICMPERR;
3017 icmp = fin->fin_dp;
3018 oip = (ip_t *)&icmp->icmp_ip;
3019 udp = (udphdr_t *)((((char *)oip) + (IP_HL(oip) << 2)));
3020 tcp = (tcphdr_t *)udp;
3021 dlen = fin->fin_plen - ((char *)udp - (char *)fin->fin_ip);
3022
3023 /*
3024 * Need to adjust ICMP header to include the real IP#'s and
3025 * port #'s. There are three steps required.
3026 *
3027 * Step 1
3028 * Fix the IP addresses in the offending IP packet and update
3029 * ip header checksum to compensate for the change.
3030 *
3031 * No update needed here for icmp_cksum because the ICMP checksum
3032 * is calculated over the complete ICMP packet, which includes the
3033 * changed oip IP addresses and oip->ip_sum. These two changes
3034 * cancel each other out (if the delta for the IP address is x,
3035 * then the delta for ip_sum is minus x).
3036 */
3037
3038 if (oip->ip_dst.s_addr == nat->nat_oip.s_addr) {
3039 sum1 = LONG_SUM(ntohl(oip->ip_src.s_addr));
3040 in = nat->nat_inip;
3041 oip->ip_src = in;
3042 } else {
3043 sum1 = LONG_SUM(ntohl(oip->ip_dst.s_addr));
3044 in = nat->nat_outip;
3045 oip->ip_dst = in;
3046 }
3047
3048 sum2 = LONG_SUM(ntohl(in.s_addr));
3049 CALC_SUMD(sum1, sum2, sumd);
3050 fix_datacksum(&oip->ip_sum, sumd);
3051
3052 /*
3053 * Step 2
3054 * Perform other adjustments based on protocol of offending packet.
3055 */
3056
3057 switch (oip->ip_p) {
3058 case IPPROTO_TCP :
3059 case IPPROTO_UDP :
3060
3061 /*
3062 * For offending TCP/UDP IP packets, translate the ports
3063 * based on the NAT specification.
3064 *
3065 * Advance notice : Now it becomes complicated :-)
3066 *
3067 * Since the port and IP addresse fields are both part
3068 * of the TCP/UDP checksum of the offending IP packet,
3069 * we need to adjust that checksum as well.
3070 *
3071 * To further complicate things, the TCP/UDP checksum
3072 * may not be present. We must check to see if the
3073 * length of the data portion is big enough to hold
3074 * the checksum. In the UDP case, a test to determine
3075 * if the checksum is even set is also required.
3076 *
3077 * Any changes to an IP address, port or checksum within
3078 * the ICMP packet requires a change to icmp_cksum.
3079 *
3080 * Be extremely careful here ... The change is dependent
3081 * upon whether or not the TCP/UPD checksum is present.
3082 *
3083 * If TCP/UPD checksum is present, the icmp_cksum must
3084 * compensate for checksum modification resulting from
3085 * IP address change only. Port change and resulting
3086 * data checksum adjustments cancel each other out.
3087 *
3088 * If TCP/UDP checksum is not present, icmp_cksum must
3089 * compensate for port change only. The IP address
3090 * change does not modify anything else in this case.
3091 */
3092
3093 psum1 = 0;
3094 psum2 = 0;
3095 psumd = 0;
3096
3097 if ((tcp->th_dport == nat->nat_oport) &&
3098 (tcp->th_sport != nat->nat_inport)) {
3099
3100 /*
3101 * Translate the source port.
3102 */
3103
3104 psum1 = ntohs(tcp->th_sport);
3105 psum2 = ntohs(nat->nat_inport);
3106 tcp->th_sport = nat->nat_inport;
3107
3108 } else if ((tcp->th_sport == nat->nat_oport) &&
3109 (tcp->th_dport != nat->nat_outport)) {
3110
3111 /*
3112 * Translate the destination port.
3113 */
3114
3115 psum1 = ntohs(tcp->th_dport);
3116 psum2 = ntohs(nat->nat_outport);
3117 tcp->th_dport = nat->nat_outport;
3118 }
3119
3120 if ((oip->ip_p == IPPROTO_TCP) && (dlen >= 18)) {
3121
3122 /*
3123 * TCP checksum present.
3124 *
3125 * Adjust data checksum and icmp checksum to
3126 * compensate for any IP address change.
3127 */
3128
3129 sum1 = ntohs(tcp->th_sum);
3130 fix_datacksum(&tcp->th_sum, sumd);
3131 sum2 = ntohs(tcp->th_sum);
3132 sumd2 = sumd << 1;
3133 CALC_SUMD(sum1, sum2, sumd);
3134 sumd2 += sumd;
3135
3136 /*
3137 * Also make data checksum adjustment to
3138 * compensate for any port change.
3139 */
3140
3141 if (psum1 != psum2) {
3142 CALC_SUMD(psum1, psum2, psumd);
3143 fix_datacksum(&tcp->th_sum, psumd);
3144 }
3145
3146 } else if ((oip->ip_p == IPPROTO_UDP) &&
3147 (dlen >= 8) && (udp->uh_sum != 0)) {
3148
3149 /*
3150 * The UDP checksum is present and set.
3151 *
3152 * Adjust data checksum and icmp checksum to
3153 * compensate for any IP address change.
3154 */
3155
3156 sum1 = ntohs(udp->uh_sum);
3157 fix_datacksum(&udp->uh_sum, sumd);
3158 sum2 = ntohs(udp->uh_sum);
3159 sumd2 = sumd << 1;
3160 CALC_SUMD(sum1, sum2, sumd);
3161 sumd2 += sumd;
3162
3163 /*
3164 * Also make data checksum adjustment to
3165 * compensate for any port change.
3166 */
3167
3168 if (psum1 != psum2) {
3169 CALC_SUMD(psum1, psum2, psumd);
3170 fix_datacksum(&udp->uh_sum, psumd);
3171 }
3172
3173 } else {
3174
3175 /*
3176 * Data checksum was not present.
3177 *
3178 * Compensate for any port change.
3179 */
3180
3181 CALC_SUMD(psum2, psum1, psumd);
3182 sumd2 += psumd;
3183 }
3184 break;
3185
3186 case IPPROTO_ICMP :
3187
3188 orgicmp = (icmphdr_t *)udp;
3189
3190 if ((nat->nat_dir == NAT_OUTBOUND) &&
3191 (orgicmp->icmp_id != nat->nat_inport) &&
3192 (dlen >= 8)) {
3193
3194 /*
3195 * Fix ICMP checksum (of the offening ICMP
3196 * query packet) to compensate the change
3197 * in the ICMP id of the offending ICMP
3198 * packet.
3199 *
3200 * Since you modify orgicmp->icmp_id with
3201 * a delta (say x) and you compensate that
3202 * in origicmp->icmp_cksum with a delta
3203 * minus x, you don't have to adjust the
3204 * overall icmp->icmp_cksum
3205 */
3206
3207 sum1 = ntohs(orgicmp->icmp_id);
3208 sum2 = ntohs(nat->nat_inport);
3209 CALC_SUMD(sum1, sum2, sumd);
3210 orgicmp->icmp_id = nat->nat_inport;
3211 fix_datacksum(&orgicmp->icmp_cksum, sumd);
3212
3213 } /* nat_dir can't be NAT_INBOUND for icmp queries */
3214
3215 break;
3216
3217 default :
3218
3219 break;
3220
3221 } /* switch (oip->ip_p) */
3222
3223 /*
3224 * Step 3
3225 * Make the adjustments to icmp checksum.
3226 */
3227
3228 if (sumd2 != 0) {
3229 sumd2 = (sumd2 & 0xffff) + (sumd2 >> 16);
3230 sumd2 = (sumd2 & 0xffff) + (sumd2 >> 16);
3231 fix_incksum(&icmp->icmp_cksum, sumd2);
3232 }
3233 return nat;
3234 }
3235
3236
3237 /*
3238 * NB: these lookups don't lock access to the list, it assumed that it has
3239 * already been done!
3240 */
3241
3242 /* ------------------------------------------------------------------------ */
3243 /* Function: nat_inlookup */
3244 /* Returns: nat_t* - NULL == no match, */
3245 /* else pointer to matching NAT entry */
3246 /* Parameters: fin(I) - pointer to packet information */
3247 /* flags(I) - NAT flags for this packet */
3248 /* p(I) - protocol for this packet */
3249 /* src(I) - source IP address */
3250 /* mapdst(I) - destination IP address */
3251 /* */
3252 /* Lookup a nat entry based on the mapped destination ip address/port and */
3253 /* real source address/port. We use this lookup when receiving a packet, */
3254 /* we're looking for a table entry, based on the destination address. */
3255 /* */
3256 /* NOTE: THE PACKET BEING CHECKED (IF FOUND) HAS A MAPPING ALREADY. */
3257 /* */
3258 /* NOTE: IT IS ASSUMED THAT ipf_nat IS ONLY HELD WITH A READ LOCK WHEN */
3259 /* THIS FUNCTION IS CALLED WITH NAT_SEARCH SET IN nflags. */
3260 /* */
3261 /* flags -> relevant are IPN_UDP/IPN_TCP/IPN_ICMPQUERY that indicate if */
3262 /* the packet is of said protocol */
3263 /* ------------------------------------------------------------------------ */
3264 nat_t *nat_inlookup(fin, flags, p, src, mapdst)
3265 fr_info_t *fin;
3266 u_int flags, p;
3267 struct in_addr src , mapdst;
3268 {
3269 u_short sport, dport;
3270 ipnat_t *ipn;
3271 u_int sflags;
3272 nat_t *nat;
3273 int nflags;
3274 u_32_t dst;
3275 void *ifp;
3276 u_int hv;
3277 ipf_stack_t *ifs = fin->fin_ifs;
3278
3279 if (fin != NULL)
3280 ifp = fin->fin_ifp;
3281 else
3282 ifp = NULL;
3283 sport = 0;
3284 dport = 0;
3285 dst = mapdst.s_addr;
3286 sflags = flags & NAT_TCPUDPICMP;
3287
3288 switch (p)
3289 {
3290 case IPPROTO_TCP :
3291 case IPPROTO_UDP :
3292 sport = htons(fin->fin_data[0]);
3293 dport = htons(fin->fin_data[1]);
3294 break;
3295 case IPPROTO_ICMP :
3296 if (flags & IPN_ICMPERR)
3297 sport = fin->fin_data[1];
3298 else
3299 dport = fin->fin_data[1];
3300 break;
3301 default :
3302 break;
3303 }
3304
3305
3306 if ((flags & SI_WILDP) != 0)
3307 goto find_in_wild_ports;
3308
3309 hv = NAT_HASH_FN(dst, dport, 0xffffffff);
3310 hv = NAT_HASH_FN(src.s_addr, hv + sport, ifs->ifs_ipf_nattable_sz);
3311 nat = ifs->ifs_nat_table[1][hv];
3312 for (; nat; nat = nat->nat_hnext[1]) {
3313 if (nat->nat_v != 4)
3314 continue;
3315
3316 if (nat->nat_ifps[0] != NULL) {
3317 if ((ifp != NULL) && (ifp != nat->nat_ifps[0]))
3318 continue;
3319 } else if (ifp != NULL)
3320 nat->nat_ifps[0] = ifp;
3321
3322 nflags = nat->nat_flags;
3323
3324 if (nat->nat_oip.s_addr == src.s_addr &&
3325 nat->nat_outip.s_addr == dst &&
3326 (((p == 0) &&
3327 (sflags == (nat->nat_flags & IPN_TCPUDPICMP)))
3328 || (p == nat->nat_p))) {
3329 switch (p)
3330 {
3331 #if 0
3332 case IPPROTO_GRE :
3333 if (nat->nat_call[1] != fin->fin_data[0])
3334 continue;
3335 break;
3336 #endif
3337 case IPPROTO_ICMP :
3338 if ((flags & IPN_ICMPERR) != 0) {
3339 if (nat->nat_outport != sport)
3340 continue;
3341 } else {
3342 if (nat->nat_outport != dport)
3343 continue;
3344 }
3345 break;
3346 case IPPROTO_TCP :
3347 case IPPROTO_UDP :
3348 if (nat->nat_oport != sport)
3349 continue;
3350 if (nat->nat_outport != dport)
3351 continue;
3352 break;
3353 default :
3354 break;
3355 }
3356
3357 ipn = nat->nat_ptr;
3358 if ((ipn != NULL) && (nat->nat_aps != NULL))
3359 if (appr_match(fin, nat) != 0)
3360 continue;
3361 return nat;
3362 }
3363 }
3364
3365 /*
3366 * So if we didn't find it but there are wildcard members in the hash
3367 * table, go back and look for them. We do this search and update here
3368 * because it is modifying the NAT table and we want to do this only
3369 * for the first packet that matches. The exception, of course, is
3370 * for "dummy" (FI_IGNORE) lookups.
3371 */
3372 find_in_wild_ports:
3373 if (!(flags & NAT_TCPUDP) || !(flags & NAT_SEARCH))
3374 return NULL;
3375 if (ifs->ifs_nat_stats.ns_wilds == 0)
3376 return NULL;
3377
3378 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
3379
3380 hv = NAT_HASH_FN(dst, 0, 0xffffffff);
3381 hv = NAT_HASH_FN(src.s_addr, hv, ifs->ifs_ipf_nattable_sz);
3382
3383 WRITE_ENTER(&ifs->ifs_ipf_nat);
3384
3385 nat = ifs->ifs_nat_table[1][hv];
3386 for (; nat; nat = nat->nat_hnext[1]) {
3387 if (nat->nat_v != 4)
3388 continue;
3389
3390 if (nat->nat_ifps[0] != NULL) {
3391 if ((ifp != NULL) && (ifp != nat->nat_ifps[0]))
3392 continue;
3393 } else if (ifp != NULL)
3394 nat->nat_ifps[0] = ifp;
3395
3396 if (nat->nat_p != fin->fin_p)
3397 continue;
3398 if (nat->nat_oip.s_addr != src.s_addr ||
3399 nat->nat_outip.s_addr != dst)
3400 continue;
3401
3402 nflags = nat->nat_flags;
3403 if (!(nflags & (NAT_TCPUDP|SI_WILDP)))
3404 continue;
3405
3406 if (nat_wildok(nat, (int)sport, (int)dport, nflags,
3407 NAT_INBOUND) == 1) {
3408 if ((fin->fin_flx & FI_IGNORE) != 0)
3409 break;
3410 if ((nflags & SI_CLONE) != 0) {
3411 nat = fr_natclone(fin, nat);
3412 if (nat == NULL)
3413 break;
3414 } else {
3415 MUTEX_ENTER(&ifs->ifs_ipf_nat_new);
3416 ifs->ifs_nat_stats.ns_wilds--;
3417 MUTEX_EXIT(&ifs->ifs_ipf_nat_new);
3418 }
3419 nat->nat_oport = sport;
3420 nat->nat_outport = dport;
3421 nat->nat_flags &= ~(SI_W_DPORT|SI_W_SPORT);
3422 nat_tabmove(nat, ifs);
3423 break;
3424 }
3425 }
3426
3427 MUTEX_DOWNGRADE(&ifs->ifs_ipf_nat);
3428
3429 return nat;
3430 }
3431
3432
3433 /* ------------------------------------------------------------------------ */
3434 /* Function: nat_tabmove */
3435 /* Returns: Nil */
3436 /* Parameters: nat(I) - pointer to NAT structure */
3437 /* Write Lock: ipf_nat */
3438 /* */
3439 /* This function is only called for TCP/UDP NAT table entries where the */
3440 /* original was placed in the table without hashing on the ports and we now */
3441 /* want to include hashing on port numbers. */
3442 /* ------------------------------------------------------------------------ */
3443 static void nat_tabmove(nat, ifs)
3444 nat_t *nat;
3445 ipf_stack_t *ifs;
3446 {
3447 nat_t **natp;
3448 u_int hv;
3449
3450 if (nat->nat_flags & SI_CLONE)
3451 return;
3452
3453 /*
3454 * Remove the NAT entry from the old location
3455 */
3456 if (nat->nat_hnext[0])
3457 nat->nat_hnext[0]->nat_phnext[0] = nat->nat_phnext[0];
3458 *nat->nat_phnext[0] = nat->nat_hnext[0];
3459 ifs->ifs_nat_stats.ns_bucketlen[0][nat->nat_hv[0]]--;
3460
3461 if (nat->nat_hnext[1])
3462 nat->nat_hnext[1]->nat_phnext[1] = nat->nat_phnext[1];
3463 *nat->nat_phnext[1] = nat->nat_hnext[1];
3464 ifs->ifs_nat_stats.ns_bucketlen[1][nat->nat_hv[1]]--;
3465
3466 /*
3467 * Add into the NAT table in the new position
3468 */
3469 hv = NAT_HASH_FN(nat->nat_inip.s_addr, nat->nat_inport, 0xffffffff);
3470 hv = NAT_HASH_FN(nat->nat_oip.s_addr, hv + nat->nat_oport,
3471 ifs->ifs_ipf_nattable_sz);
3472 nat->nat_hv[0] = hv;
3473 natp = &ifs->ifs_nat_table[0][hv];
3474 if (*natp)
3475 (*natp)->nat_phnext[0] = &nat->nat_hnext[0];
3476 nat->nat_phnext[0] = natp;
3477 nat->nat_hnext[0] = *natp;
3478 *natp = nat;
3479 ifs->ifs_nat_stats.ns_bucketlen[0][hv]++;
3480
3481 hv = NAT_HASH_FN(nat->nat_outip.s_addr, nat->nat_outport, 0xffffffff);
3482 hv = NAT_HASH_FN(nat->nat_oip.s_addr, hv + nat->nat_oport,
3483 ifs->ifs_ipf_nattable_sz);
3484 nat->nat_hv[1] = hv;
3485 natp = &ifs->ifs_nat_table[1][hv];
3486 if (*natp)
3487 (*natp)->nat_phnext[1] = &nat->nat_hnext[1];
3488 nat->nat_phnext[1] = natp;
3489 nat->nat_hnext[1] = *natp;
3490 *natp = nat;
3491 ifs->ifs_nat_stats.ns_bucketlen[1][hv]++;
3492 }
3493
3494
3495 /* ------------------------------------------------------------------------ */
3496 /* Function: nat_outlookup */
3497 /* Returns: nat_t* - NULL == no match, */
3498 /* else pointer to matching NAT entry */
3499 /* Parameters: fin(I) - pointer to packet information */
3500 /* flags(I) - NAT flags for this packet */
3501 /* p(I) - protocol for this packet */
3502 /* src(I) - source IP address */
3503 /* dst(I) - destination IP address */
3504 /* rw(I) - 1 == write lock on ipf_nat held, 0 == read lock. */
3505 /* */
3506 /* Lookup a nat entry based on the source 'real' ip address/port and */
3507 /* destination address/port. We use this lookup when sending a packet out, */
3508 /* we're looking for a table entry, based on the source address. */
3509 /* */
3510 /* NOTE: THE PACKET BEING CHECKED (IF FOUND) HAS A MAPPING ALREADY. */
3511 /* */
3512 /* NOTE: IT IS ASSUMED THAT ipf_nat IS ONLY HELD WITH A READ LOCK WHEN */
3513 /* THIS FUNCTION IS CALLED WITH NAT_SEARCH SET IN nflags. */
3514 /* */
3515 /* flags -> relevant are IPN_UDP/IPN_TCP/IPN_ICMPQUERY that indicate if */
3516 /* the packet is of said protocol */
3517 /* ------------------------------------------------------------------------ */
3518 nat_t *nat_outlookup(fin, flags, p, src, dst)
3519 fr_info_t *fin;
3520 u_int flags, p;
3521 struct in_addr src , dst;
3522 {
3523 u_short sport, dport;
3524 u_int sflags;
3525 ipnat_t *ipn;
3526 u_32_t srcip;
3527 nat_t *nat;
3528 int nflags;
3529 void *ifp;
3530 u_int hv;
3531 ipf_stack_t *ifs = fin->fin_ifs;
3532
3533 ifp = fin->fin_ifp;
3534
3535 srcip = src.s_addr;
3536 sflags = flags & IPN_TCPUDPICMP;
3537 sport = 0;
3538 dport = 0;
3539
3540 switch (p)
3541 {
3542 case IPPROTO_TCP :
3543 case IPPROTO_UDP :
3544 sport = htons(fin->fin_data[0]);
3545 dport = htons(fin->fin_data[1]);
3546 break;
3547 case IPPROTO_ICMP :
3548 if (flags & IPN_ICMPERR)
3549 sport = fin->fin_data[1];
3550 else
3551 dport = fin->fin_data[1];
3552 break;
3553 default :
3554 break;
3555 }
3556
3557 if ((flags & SI_WILDP) != 0)
3558 goto find_out_wild_ports;
3559
3560 hv = NAT_HASH_FN(srcip, sport, 0xffffffff);
3561 hv = NAT_HASH_FN(dst.s_addr, hv + dport, ifs->ifs_ipf_nattable_sz);
3562 nat = ifs->ifs_nat_table[0][hv];
3563 for (; nat; nat = nat->nat_hnext[0]) {
3564 if (nat->nat_v != 4)
3565 continue;
3566
3567 if (nat->nat_ifps[1] != NULL) {
3568 if ((ifp != NULL) && (ifp != nat->nat_ifps[1]))
3569 continue;
3570 } else if (ifp != NULL)
3571 nat->nat_ifps[1] = ifp;
3572
3573 nflags = nat->nat_flags;
3574
3575 if (nat->nat_inip.s_addr == srcip &&
3576 nat->nat_oip.s_addr == dst.s_addr &&
3577 (((p == 0) && (sflags == (nflags & NAT_TCPUDPICMP)))
3578 || (p == nat->nat_p))) {
3579 switch (p)
3580 {
3581 #if 0
3582 case IPPROTO_GRE :
3583 if (nat->nat_call[1] != fin->fin_data[0])
3584 continue;
3585 break;
3586 #endif
3587 case IPPROTO_TCP :
3588 case IPPROTO_UDP :
3589 if (nat->nat_oport != dport)
3590 continue;
3591 if (nat->nat_inport != sport)
3592 continue;
3593 break;
3594 default :
3595 break;
3596 }
3597
3598 ipn = nat->nat_ptr;
3599 if ((ipn != NULL) && (nat->nat_aps != NULL))
3600 if (appr_match(fin, nat) != 0)
3601 continue;
3602 return nat;
3603 }
3604 }
3605
3606 /*
3607 * So if we didn't find it but there are wildcard members in the hash
3608 * table, go back and look for them. We do this search and update here
3609 * because it is modifying the NAT table and we want to do this only
3610 * for the first packet that matches. The exception, of course, is
3611 * for "dummy" (FI_IGNORE) lookups.
3612 */
3613 find_out_wild_ports:
3614 if (!(flags & NAT_TCPUDP) || !(flags & NAT_SEARCH))
3615 return NULL;
3616 if (ifs->ifs_nat_stats.ns_wilds == 0)
3617 return NULL;
3618
3619 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
3620
3621 hv = NAT_HASH_FN(srcip, 0, 0xffffffff);
3622 hv = NAT_HASH_FN(dst.s_addr, hv, ifs->ifs_ipf_nattable_sz);
3623
3624 WRITE_ENTER(&ifs->ifs_ipf_nat);
3625
3626 nat = ifs->ifs_nat_table[0][hv];
3627 for (; nat; nat = nat->nat_hnext[0]) {
3628 if (nat->nat_v != 4)
3629 continue;
3630
3631 if (nat->nat_ifps[1] != NULL) {
3632 if ((ifp != NULL) && (ifp != nat->nat_ifps[1]))
3633 continue;
3634 } else if (ifp != NULL)
3635 nat->nat_ifps[1] = ifp;
3636
3637 if (nat->nat_p != fin->fin_p)
3638 continue;
3639 if ((nat->nat_inip.s_addr != srcip) ||
3640 (nat->nat_oip.s_addr != dst.s_addr))
3641 continue;
3642
3643 nflags = nat->nat_flags;
3644 if (!(nflags & (NAT_TCPUDP|SI_WILDP)))
3645 continue;
3646
3647 if (nat_wildok(nat, (int)sport, (int)dport, nflags,
3648 NAT_OUTBOUND) == 1) {
3649 if ((fin->fin_flx & FI_IGNORE) != 0)
3650 break;
3651 if ((nflags & SI_CLONE) != 0) {
3652 nat = fr_natclone(fin, nat);
3653 if (nat == NULL)
3654 break;
3655 } else {
3656 MUTEX_ENTER(&ifs->ifs_ipf_nat_new);
3657 ifs->ifs_nat_stats.ns_wilds--;
3658 MUTEX_EXIT(&ifs->ifs_ipf_nat_new);
3659 }
3660 nat->nat_inport = sport;
3661 nat->nat_oport = dport;
3662 if (nat->nat_outport == 0)
3663 nat->nat_outport = sport;
3664 nat->nat_flags &= ~(SI_W_DPORT|SI_W_SPORT);
3665 nat_tabmove(nat, ifs);
3666 break;
3667 }
3668 }
3669
3670 MUTEX_DOWNGRADE(&ifs->ifs_ipf_nat);
3671
3672 return nat;
3673 }
3674
3675
3676 /* ------------------------------------------------------------------------ */
3677 /* Function: nat_lookupredir */
3678 /* Returns: nat_t* - NULL == no match, */
3679 /* else pointer to matching NAT entry */
3680 /* Parameters: np(I) - pointer to description of packet to find NAT table */
3681 /* entry for. */
3682 /* */
3683 /* Lookup the NAT tables to search for a matching redirect */
3684 /* ------------------------------------------------------------------------ */
3685 nat_t *nat_lookupredir(np, ifs)
3686 natlookup_t *np;
3687 ipf_stack_t *ifs;
3688 {
3689 fr_info_t fi;
3690 nat_t *nat;
3691
3692 bzero((char *)&fi, sizeof(fi));
3693 if (np->nl_flags & IPN_IN) {
3694 fi.fin_data[0] = ntohs(np->nl_realport);
3695 fi.fin_data[1] = ntohs(np->nl_outport);
3696 } else {
3697 fi.fin_data[0] = ntohs(np->nl_inport);
3698 fi.fin_data[1] = ntohs(np->nl_outport);
3699 }
3700 if (np->nl_flags & IPN_TCP)
3701 fi.fin_p = IPPROTO_TCP;
3702 else if (np->nl_flags & IPN_UDP)
3703 fi.fin_p = IPPROTO_UDP;
3704 else if (np->nl_flags & (IPN_ICMPERR|IPN_ICMPQUERY))
3705 fi.fin_p = IPPROTO_ICMP;
3706
3707 fi.fin_ifs = ifs;
3708 /*
3709 * We can do two sorts of lookups:
3710 * - IPN_IN: we have the `real' and `out' address, look for `in'.
3711 * - default: we have the `in' and `out' address, look for `real'.
3712 */
3713 if (np->nl_flags & IPN_IN) {
3714 if ((nat = nat_inlookup(&fi, np->nl_flags, fi.fin_p,
3715 np->nl_realip, np->nl_outip))) {
3716 np->nl_inip = nat->nat_inip;
3717 np->nl_inport = nat->nat_inport;
3718 }
3719 } else {
3720 /*
3721 * If nl_inip is non null, this is a lookup based on the real
3722 * ip address. Else, we use the fake.
3723 */
3724 if ((nat = nat_outlookup(&fi, np->nl_flags, fi.fin_p,
3725 np->nl_inip, np->nl_outip))) {
3726
3727 if ((np->nl_flags & IPN_FINDFORWARD) != 0) {
3728 fr_info_t fin;
3729 bzero((char *)&fin, sizeof(fin));
3730 fin.fin_p = nat->nat_p;
3731 fin.fin_data[0] = ntohs(nat->nat_outport);
3732 fin.fin_data[1] = ntohs(nat->nat_oport);
3733 fin.fin_ifs = ifs;
3734 if (nat_inlookup(&fin, np->nl_flags, fin.fin_p,
3735 nat->nat_outip,
3736 nat->nat_oip) != NULL) {
3737 np->nl_flags &= ~IPN_FINDFORWARD;
3738 }
3739 }
3740
3741 np->nl_realip = nat->nat_outip;
3742 np->nl_realport = nat->nat_outport;
3743 }
3744 }
3745
3746 return nat;
3747 }
3748
3749
3750 /* ------------------------------------------------------------------------ */
3751 /* Function: nat_match */
3752 /* Returns: int - 0 == no match, 1 == match */
3753 /* Parameters: fin(I) - pointer to packet information */
3754 /* np(I) - pointer to NAT rule */
3755 /* */
3756 /* Pull the matching of a packet against a NAT rule out of that complex */
3757 /* loop inside fr_checknatin() and lay it out properly in its own function. */
3758 /* ------------------------------------------------------------------------ */
3759 static int nat_match(fin, np)
3760 fr_info_t *fin;
3761 ipnat_t *np;
3762 {
3763 frtuc_t *ft;
3764
3765 if (fin->fin_v != 4)
3766 return 0;
3767
3768 if (np->in_p && fin->fin_p != np->in_p)
3769 return 0;
3770
3771 if (fin->fin_out) {
3772 if (!(np->in_redir & (NAT_MAP|NAT_MAPBLK)))
3773 return 0;
3774 if (((fin->fin_fi.fi_saddr & np->in_inmsk) != np->in_inip)
3775 ^ ((np->in_flags & IPN_NOTSRC) != 0))
3776 return 0;
3777 if (((fin->fin_fi.fi_daddr & np->in_srcmsk) != np->in_srcip)
3778 ^ ((np->in_flags & IPN_NOTDST) != 0))
3779 return 0;
3780 } else {
3781 if (!(np->in_redir & NAT_REDIRECT))
3782 return 0;
3783 if (((fin->fin_fi.fi_saddr & np->in_srcmsk) != np->in_srcip)
3784 ^ ((np->in_flags & IPN_NOTSRC) != 0))
3785 return 0;
3786 if (((fin->fin_fi.fi_daddr & np->in_outmsk) != np->in_outip)
3787 ^ ((np->in_flags & IPN_NOTDST) != 0))
3788 return 0;
3789 }
3790
3791 ft = &np->in_tuc;
3792 if (!(fin->fin_flx & FI_TCPUDP) ||
3793 (fin->fin_flx & (FI_SHORT|FI_FRAGBODY))) {
3794 if (ft->ftu_scmp || ft->ftu_dcmp)
3795 return 0;
3796 return 1;
3797 }
3798
3799 return fr_tcpudpchk(fin, ft);
3800 }
3801
3802
3803 /* ------------------------------------------------------------------------ */
3804 /* Function: nat_update */
3805 /* Returns: Nil */
3806 /* Parameters: fin(I) - pointer to packet information */
3807 /* nat(I) - pointer to NAT structure */
3808 /* np(I) - pointer to NAT rule */
3809 /* Locks: nat_lock */
3810 /* */
3811 /* Updates the lifetime of a NAT table entry for non-TCP packets. Must be */
3812 /* called with fin_rev updated - i.e. after calling nat_proto(). */
3813 /* ------------------------------------------------------------------------ */
3814 void nat_update(fin, nat, np)
3815 fr_info_t *fin;
3816 nat_t *nat;
3817 ipnat_t *np;
3818 {
3819 ipftq_t *ifq, *ifq2;
3820 ipftqent_t *tqe;
3821 ipf_stack_t *ifs = fin->fin_ifs;
3822
3823 tqe = &nat->nat_tqe;
3824 ifq = tqe->tqe_ifq;
3825
3826 /*
3827 * We allow over-riding of NAT timeouts from NAT rules, even for
3828 * TCP, however, if it is TCP and there is no rule timeout set,
3829 * then do not update the timeout here.
3830 */
3831 if (np != NULL)
3832 ifq2 = np->in_tqehead[fin->fin_rev];
3833 else
3834 ifq2 = NULL;
3835
3836 if (nat->nat_p == IPPROTO_TCP && ifq2 == NULL) {
3837 (void) fr_tcp_age(&nat->nat_tqe, fin, ifs->ifs_nat_tqb, 0);
3838 } else {
3839 if (ifq2 == NULL) {
3840 if (nat->nat_p == IPPROTO_UDP)
3841 ifq2 = &ifs->ifs_nat_udptq;
3842 else if (nat->nat_p == IPPROTO_ICMP)
3843 ifq2 = &ifs->ifs_nat_icmptq;
3844 else
3845 ifq2 = &ifs->ifs_nat_iptq;
3846 }
3847
3848 fr_movequeue(tqe, ifq, ifq2, ifs);
3849 }
3850 }
3851
3852
3853 /* ------------------------------------------------------------------------ */
3854 /* Function: fr_checknatout */
3855 /* Returns: int - -1 == packet failed NAT checks so block it, */
3856 /* 0 == no packet translation occurred, */
3857 /* 1 == packet was successfully translated. */
3858 /* Parameters: fin(I) - pointer to packet information */
3859 /* passp(I) - pointer to filtering result flags */
3860 /* */
3861 /* Check to see if an outcoming packet should be changed. ICMP packets are */
3862 /* first checked to see if they match an existing entry (if an error), */
3863 /* otherwise a search of the current NAT table is made. If neither results */
3864 /* in a match then a search for a matching NAT rule is made. Create a new */
3865 /* NAT entry if a we matched a NAT rule. Lastly, actually change the */
3866 /* packet header(s) as required. */
3867 /* ------------------------------------------------------------------------ */
3868 int fr_checknatout(fin, passp)
3869 fr_info_t *fin;
3870 u_32_t *passp;
3871 {
3872 ipnat_t *np = NULL, *npnext;
3873 struct ifnet *ifp, *sifp;
3874 icmphdr_t *icmp = NULL;
3875 tcphdr_t *tcp = NULL;
3876 int rval, natfailed;
3877 u_int nflags = 0;
3878 u_32_t ipa, iph;
3879 int natadd = 1;
3880 frentry_t *fr;
3881 nat_t *nat;
3882 ipf_stack_t *ifs = fin->fin_ifs;
3883
3884 if (ifs->ifs_fr_nat_lock != 0)
3885 return 0;
3886 if (ifs->ifs_nat_stats.ns_rules == 0 && ifs->ifs_nat_instances == NULL)
3887 return 0;
3888
3889 natfailed = 0;
3890 fr = fin->fin_fr;
3891 sifp = fin->fin_ifp;
3892 if ((fr != NULL) && !(fr->fr_flags & FR_DUP) &&
3893 fr->fr_tifs[fin->fin_rev].fd_ifp &&
3894 fr->fr_tifs[fin->fin_rev].fd_ifp != (void *)-1)
3895 fin->fin_ifp = fr->fr_tifs[fin->fin_rev].fd_ifp;
3896 ifp = fin->fin_ifp;
3897
3898 if (!(fin->fin_flx & FI_SHORT) && (fin->fin_off == 0)) {
3899 switch (fin->fin_p)
3900 {
3901 case IPPROTO_TCP :
3902 nflags = IPN_TCP;
3903 break;
3904 case IPPROTO_UDP :
3905 nflags = IPN_UDP;
3906 break;
3907 case IPPROTO_ICMP :
3908 icmp = fin->fin_dp;
3909
3910 /*
3911 * This is an incoming packet, so the destination is
3912 * the icmp_id and the source port equals 0
3913 */
3914 if (nat_icmpquerytype4(icmp->icmp_type))
3915 nflags = IPN_ICMPQUERY;
3916 break;
3917 default :
3918 break;
3919 }
3920
3921 if ((nflags & IPN_TCPUDP))
3922 tcp = fin->fin_dp;
3923 }
3924
3925 ipa = fin->fin_saddr;
3926
3927 READ_ENTER(&ifs->ifs_ipf_nat);
3928
3929 if ((fin->fin_p == IPPROTO_ICMP) && !(nflags & IPN_ICMPQUERY) &&
3930 (nat = nat_icmperror(fin, &nflags, NAT_OUTBOUND)))
3931 /*EMPTY*/;
3932 else if ((fin->fin_flx & FI_FRAG) && (nat = fr_nat_knownfrag(fin)))
3933 natadd = 0;
3934 else if ((nat = nat_outlookup(fin, nflags|NAT_SEARCH, (u_int)fin->fin_p,
3935 fin->fin_src, fin->fin_dst))) {
3936 nflags = nat->nat_flags;
3937 } else {
3938 u_32_t hv, msk, nmsk;
3939
3940 /*
3941 * There is no current entry in the nat table for this packet.
3942 *
3943 * If the packet is a fragment, but not the first fragment,
3944 * then don't do anything. Otherwise, if there is a matching
3945 * nat rule, try to create a new nat entry.
3946 */
3947 if ((fin->fin_off != 0) && (fin->fin_flx & FI_TCPUDP))
3948 goto nonatfrag;
3949
3950 msk = 0xffffffff;
3951 nmsk = ifs->ifs_nat_masks;
3952 maskloop:
3953 iph = ipa & htonl(msk);
3954 hv = NAT_HASH_FN(iph, 0, ifs->ifs_ipf_natrules_sz);
3955 for (np = ifs->ifs_nat_rules[hv]; np; np = npnext) {
3956 npnext = np->in_mnext;
3957 if ((np->in_ifps[1] && (np->in_ifps[1] != ifp)))
3958 continue;
3959 if (np->in_v != fin->fin_v)
3960 continue;
3961 if (np->in_p && (np->in_p != fin->fin_p))
3962 continue;
3963 if ((np->in_flags & IPN_RF) && !(np->in_flags & nflags))
3964 continue;
3965 if (np->in_flags & IPN_FILTER) {
3966 if (!nat_match(fin, np))
3967 continue;
3968 } else if ((ipa & np->in_inmsk) != np->in_inip)
3969 continue;
3970
3971 if ((fr != NULL) &&
3972 !fr_matchtag(&np->in_tag, &fr->fr_nattag))
3973 continue;
3974
3975 if (*np->in_plabel != '\0') {
3976 if (((np->in_flags & IPN_FILTER) == 0) &&
3977 (np->in_dport != tcp->th_dport))
3978 continue;
3979 if (appr_ok(fin, tcp, np) == 0)
3980 continue;
3981 }
3982
3983 ATOMIC_INC32(np->in_use);
3984 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
3985 WRITE_ENTER(&ifs->ifs_ipf_nat);
3986 nat = nat_new(fin, np, NULL, nflags, NAT_OUTBOUND);
3987 if (nat != NULL) {
3988 np->in_use--;
3989 np->in_hits++;
3990 MUTEX_DOWNGRADE(&ifs->ifs_ipf_nat);
3991 break;
3992 }
3993 natfailed = -1;
3994 npnext = np->in_mnext;
3995 fr_ipnatderef(&np, ifs);
3996 MUTEX_DOWNGRADE(&ifs->ifs_ipf_nat);
3997 }
3998 if ((np == NULL) && (nmsk != 0)) {
3999 while (nmsk) {
4000 msk <<= 1;
4001 if (nmsk & 0x80000000)
4002 break;
4003 nmsk <<= 1;
4004 }
4005 if (nmsk != 0) {
4006 nmsk <<= 1;
4007 goto maskloop;
4008 }
4009 }
4010 }
4011
4012 nonatfrag:
4013 if (nat != NULL) {
4014 rval = fr_natout(fin, nat, natadd, nflags);
4015 if (rval == 1) {
4016 MUTEX_ENTER(&nat->nat_lock);
4017 nat_update(fin, nat, nat->nat_ptr);
4018 nat->nat_bytes[1] += fin->fin_plen;
4019 nat->nat_pkts[1]++;
4020 fin->fin_pktnum = nat->nat_pkts[1];
4021 MUTEX_EXIT(&nat->nat_lock);
4022 }
4023 } else
4024 rval = natfailed;
4025 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
4026
4027 if (rval == -1) {
4028 if (passp != NULL)
4029 *passp = FR_BLOCK;
4030 fin->fin_flx |= FI_BADNAT;
4031 }
4032 fin->fin_ifp = sifp;
4033 return rval;
4034 }
4035
4036 /* ------------------------------------------------------------------------ */
4037 /* Function: fr_natout */
4038 /* Returns: int - -1 == packet failed NAT checks so block it, */
4039 /* 1 == packet was successfully translated. */
4040 /* Parameters: fin(I) - pointer to packet information */
4041 /* nat(I) - pointer to NAT structure */
4042 /* natadd(I) - flag indicating if it is safe to add frag cache */
4043 /* nflags(I) - NAT flags set for this packet */
4044 /* */
4045 /* Translate a packet coming "out" on an interface. */
4046 /* ------------------------------------------------------------------------ */
4047 int fr_natout(fin, nat, natadd, nflags)
4048 fr_info_t *fin;
4049 nat_t *nat;
4050 int natadd;
4051 u_32_t nflags;
4052 {
4053 icmphdr_t *icmp;
4054 u_short *csump;
4055 u_32_t sumd;
4056 tcphdr_t *tcp;
4057 ipnat_t *np;
4058 int i;
4059 ipf_stack_t *ifs = fin->fin_ifs;
4060
4061 if (fin->fin_v == 6) {
4062 #ifdef USE_INET6
4063 return fr_nat6out(fin, nat, natadd, nflags);
4064 #else
4065 return NULL;
4066 #endif
4067 }
4068
4069 #if SOLARIS && defined(_KERNEL)
4070 net_handle_t net_data_p = ifs->ifs_ipf_ipv4;
4071 #endif
4072
4073 tcp = NULL;
4074 icmp = NULL;
4075 csump = NULL;
4076 np = nat->nat_ptr;
4077
4078 if ((natadd != 0) && (fin->fin_flx & FI_FRAG))
4079 (void) fr_nat_newfrag(fin, 0, nat);
4080
4081 /*
4082 * Fix up checksums, not by recalculating them, but
4083 * simply computing adjustments.
4084 * This is only done for STREAMS based IP implementations where the
4085 * checksum has already been calculated by IP. In all other cases,
4086 * IPFilter is called before the checksum needs calculating so there
4087 * is no call to modify whatever is in the header now.
4088 */
4089 ASSERT(fin->fin_m != NULL);
4090 if (fin->fin_v == 4 && !NET_IS_HCK_L3_FULL(net_data_p, fin->fin_m)) {
4091 if (nflags == IPN_ICMPERR) {
4092 u_32_t s1, s2;
4093
4094 s1 = LONG_SUM(ntohl(fin->fin_saddr));
4095 s2 = LONG_SUM(ntohl(nat->nat_outip.s_addr));
4096 CALC_SUMD(s1, s2, sumd);
4097
4098 fix_outcksum(&fin->fin_ip->ip_sum, sumd);
4099 }
4100 #if !defined(_KERNEL) || defined(MENTAT) || defined(__sgi) || \
4101 defined(linux) || defined(BRIDGE_IPF)
4102 else {
4103 /*
4104 * Strictly speaking, this isn't necessary on BSD
4105 * kernels because they do checksum calculation after
4106 * this code has run BUT if ipfilter is being used
4107 * to do NAT as a bridge, that code doesn't exist.
4108 */
4109 if (nat->nat_dir == NAT_OUTBOUND)
4110 fix_outcksum(&fin->fin_ip->ip_sum,
4111 nat->nat_ipsumd);
4112 else
4113 fix_incksum(&fin->fin_ip->ip_sum,
4114 nat->nat_ipsumd);
4115 }
4116 #endif
4117 }
4118
4119 if (!(fin->fin_flx & FI_SHORT) && (fin->fin_off == 0)) {
4120 if ((nat->nat_outport != 0) && (nflags & IPN_TCPUDP)) {
4121 tcp = fin->fin_dp;
4122
4123 tcp->th_sport = nat->nat_outport;
4124 fin->fin_data[0] = ntohs(nat->nat_outport);
4125 }
4126
4127 if ((nat->nat_outport != 0) && (nflags & IPN_ICMPQUERY)) {
4128 icmp = fin->fin_dp;
4129 icmp->icmp_id = nat->nat_outport;
4130 }
4131
4132 csump = nat_proto(fin, nat, nflags);
4133 }
4134
4135 fin->fin_ip->ip_src = nat->nat_outip;
4136
4137 /*
4138 * The above comments do not hold for layer 4 (or higher) checksums...
4139 */
4140 if (csump != NULL && !NET_IS_HCK_L4_FULL(net_data_p, fin->fin_m)) {
4141 if (nflags & IPN_TCPUDP &&
4142 NET_IS_HCK_L4_PART(net_data_p, fin->fin_m))
4143 sumd = nat->nat_sumd[1];
4144 else
4145 sumd = nat->nat_sumd[0];
4146
4147 if (nat->nat_dir == NAT_OUTBOUND)
4148 fix_outcksum(csump, sumd);
4149 else
4150 fix_incksum(csump, sumd);
4151 }
4152 #ifdef IPFILTER_SYNC
4153 ipfsync_update(SMC_NAT, fin, nat->nat_sync);
4154 #endif
4155 /* ------------------------------------------------------------- */
4156 /* A few quick notes: */
4157 /* Following are test conditions prior to calling the */
4158 /* appr_check routine. */
4159 /* */
4160 /* A NULL tcp indicates a non TCP/UDP packet. When dealing */
4161 /* with a redirect rule, we attempt to match the packet's */
4162 /* source port against in_dport, otherwise we'd compare the */
4163 /* packet's destination. */
4164 /* ------------------------------------------------------------- */
4165 if ((np != NULL) && (np->in_apr != NULL)) {
4166 i = appr_check(fin, nat);
4167 if (i == 0)
4168 i = 1;
4169 } else
4170 i = 1;
4171 ifs->ifs_nat_stats.ns_mapped[1]++;
4172 fin->fin_flx |= FI_NATED;
4173 return i;
4174 }
4175
4176
4177 /* ------------------------------------------------------------------------ */
4178 /* Function: fr_checknatin */
4179 /* Returns: int - -1 == packet failed NAT checks so block it, */
4180 /* 0 == no packet translation occurred, */
4181 /* 1 == packet was successfully translated. */
4182 /* Parameters: fin(I) - pointer to packet information */
4183 /* passp(I) - pointer to filtering result flags */
4184 /* */
4185 /* Check to see if an incoming packet should be changed. ICMP packets are */
4186 /* first checked to see if they match an existing entry (if an error), */
4187 /* otherwise a search of the current NAT table is made. If neither results */
4188 /* in a match then a search for a matching NAT rule is made. Create a new */
4189 /* NAT entry if a we matched a NAT rule. Lastly, actually change the */
4190 /* packet header(s) as required. */
4191 /* ------------------------------------------------------------------------ */
4192 int fr_checknatin(fin, passp)
4193 fr_info_t *fin;
4194 u_32_t *passp;
4195 {
4196 u_int nflags, natadd;
4197 ipnat_t *np, *npnext;
4198 int rval, natfailed;
4199 struct ifnet *ifp;
4200 struct in_addr in;
4201 icmphdr_t *icmp;
4202 tcphdr_t *tcp;
4203 u_short dport;
4204 nat_t *nat;
4205 u_32_t iph;
4206 ipf_stack_t *ifs = fin->fin_ifs;
4207
4208 if (ifs->ifs_fr_nat_lock != 0)
4209 return 0;
4210 if (ifs->ifs_nat_stats.ns_rules == 0 && ifs->ifs_nat_instances == NULL)
4211 return 0;
4212
4213 tcp = NULL;
4214 icmp = NULL;
4215 dport = 0;
4216 natadd = 1;
4217 nflags = 0;
4218 natfailed = 0;
4219 ifp = fin->fin_ifp;
4220
4221 if (!(fin->fin_flx & FI_SHORT) && (fin->fin_off == 0)) {
4222 switch (fin->fin_p)
4223 {
4224 case IPPROTO_TCP :
4225 nflags = IPN_TCP;
4226 break;
4227 case IPPROTO_UDP :
4228 nflags = IPN_UDP;
4229 break;
4230 case IPPROTO_ICMP :
4231 icmp = fin->fin_dp;
4232
4233 /*
4234 * This is an incoming packet, so the destination is
4235 * the icmp_id and the source port equals 0
4236 */
4237 if (nat_icmpquerytype4(icmp->icmp_type)) {
4238 nflags = IPN_ICMPQUERY;
4239 dport = icmp->icmp_id;
4240 } break;
4241 default :
4242 break;
4243 }
4244
4245 if ((nflags & IPN_TCPUDP)) {
4246 tcp = fin->fin_dp;
4247 dport = tcp->th_dport;
4248 }
4249 }
4250
4251 in = fin->fin_dst;
4252
4253 READ_ENTER(&ifs->ifs_ipf_nat);
4254
4255 if ((fin->fin_p == IPPROTO_ICMP) && !(nflags & IPN_ICMPQUERY) &&
4256 (nat = nat_icmperror(fin, &nflags, NAT_INBOUND)))
4257 /*EMPTY*/;
4258 else if ((fin->fin_flx & FI_FRAG) && (nat = fr_nat_knownfrag(fin)))
4259 natadd = 0;
4260 else if ((nat = nat_inlookup(fin, nflags|NAT_SEARCH, (u_int)fin->fin_p,
4261 fin->fin_src, in))) {
4262 nflags = nat->nat_flags;
4263 } else {
4264 u_32_t hv, msk, rmsk;
4265
4266 /*
4267 * There is no current entry in the nat table for this packet.
4268 *
4269 * If the packet is a fragment, but not the first fragment,
4270 * then don't do anything. Otherwise, if there is a matching
4271 * nat rule, try to create a new nat entry.
4272 */
4273 if ((fin->fin_off != 0) && (fin->fin_flx & FI_TCPUDP))
4274 goto nonatfrag;
4275
4276 rmsk = ifs->ifs_rdr_masks;
4277 msk = 0xffffffff;
4278 maskloop:
4279 iph = in.s_addr & htonl(msk);
4280 hv = NAT_HASH_FN(iph, 0, ifs->ifs_ipf_rdrrules_sz);
4281 for (np = ifs->ifs_rdr_rules[hv]; np; np = npnext) {
4282 npnext = np->in_rnext;
4283 if (np->in_ifps[0] && (np->in_ifps[0] != ifp))
4284 continue;
4285 if (np->in_v != fin->fin_v)
4286 continue;
4287 if (np->in_p && (np->in_p != fin->fin_p))
4288 continue;
4289 if ((np->in_flags & IPN_RF) && !(np->in_flags & nflags))
4290 continue;
4291 if (np->in_flags & IPN_FILTER) {
4292 if (!nat_match(fin, np))
4293 continue;
4294 } else {
4295 if ((in.s_addr & np->in_outmsk) != np->in_outip)
4296 continue;
4297 if (np->in_pmin &&
4298 ((ntohs(np->in_pmax) < ntohs(dport)) ||
4299 (ntohs(dport) < ntohs(np->in_pmin))))
4300 continue;
4301 }
4302
4303 if (*np->in_plabel != '\0') {
4304 if (!appr_ok(fin, tcp, np)) {
4305 continue;
4306 }
4307 }
4308
4309 ATOMIC_INC32(np->in_use);
4310 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
4311 WRITE_ENTER(&ifs->ifs_ipf_nat);
4312 nat = nat_new(fin, np, NULL, nflags, NAT_INBOUND);
4313 if (nat != NULL) {
4314 np->in_use--;
4315 np->in_hits++;
4316 MUTEX_DOWNGRADE(&ifs->ifs_ipf_nat);
4317 break;
4318 }
4319 natfailed = -1;
4320 npnext = np->in_rnext;
4321 fr_ipnatderef(&np, ifs);
4322 MUTEX_DOWNGRADE(&ifs->ifs_ipf_nat);
4323 }
4324
4325 if ((np == NULL) && (rmsk != 0)) {
4326 while (rmsk) {
4327 msk <<= 1;
4328 if (rmsk & 0x80000000)
4329 break;
4330 rmsk <<= 1;
4331 }
4332 if (rmsk != 0) {
4333 rmsk <<= 1;
4334 goto maskloop;
4335 }
4336 }
4337 }
4338
4339 nonatfrag:
4340 if (nat != NULL) {
4341 rval = fr_natin(fin, nat, natadd, nflags);
4342 if (rval == 1) {
4343 MUTEX_ENTER(&nat->nat_lock);
4344 nat_update(fin, nat, nat->nat_ptr);
4345 nat->nat_bytes[0] += fin->fin_plen;
4346 nat->nat_pkts[0]++;
4347 fin->fin_pktnum = nat->nat_pkts[0];
4348 MUTEX_EXIT(&nat->nat_lock);
4349 }
4350 } else
4351 rval = natfailed;
4352 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
4353
4354 if (rval == -1) {
4355 if (passp != NULL)
4356 *passp = FR_BLOCK;
4357 fin->fin_flx |= FI_BADNAT;
4358 }
4359 return rval;
4360 }
4361
4362
4363 /* ------------------------------------------------------------------------ */
4364 /* Function: fr_natin */
4365 /* Returns: int - -1 == packet failed NAT checks so block it, */
4366 /* 1 == packet was successfully translated. */
4367 /* Parameters: fin(I) - pointer to packet information */
4368 /* nat(I) - pointer to NAT structure */
4369 /* natadd(I) - flag indicating if it is safe to add frag cache */
4370 /* nflags(I) - NAT flags set for this packet */
4371 /* Locks Held: ipf_nat (READ) */
4372 /* */
4373 /* Translate a packet coming "in" on an interface. */
4374 /* ------------------------------------------------------------------------ */
4375 int fr_natin(fin, nat, natadd, nflags)
4376 fr_info_t *fin;
4377 nat_t *nat;
4378 int natadd;
4379 u_32_t nflags;
4380 {
4381 icmphdr_t *icmp;
4382 u_short *csump;
4383 tcphdr_t *tcp;
4384 ipnat_t *np;
4385 int i;
4386 ipf_stack_t *ifs = fin->fin_ifs;
4387
4388 if (fin->fin_v == 6) {
4389 #ifdef USE_INET6
4390 return fr_nat6in(fin, nat, natadd, nflags);
4391 #else
4392 return NULL;
4393 #endif
4394 }
4395
4396 #if SOLARIS && defined(_KERNEL)
4397 net_handle_t net_data_p = ifs->ifs_ipf_ipv4;
4398 #endif
4399
4400 tcp = NULL;
4401 csump = NULL;
4402 np = nat->nat_ptr;
4403 fin->fin_fr = nat->nat_fr;
4404
4405 if ((natadd != 0) && (fin->fin_flx & FI_FRAG))
4406 (void) fr_nat_newfrag(fin, 0, nat);
4407
4408 if (np != NULL) {
4409
4410 /* ------------------------------------------------------------- */
4411 /* A few quick notes: */
4412 /* Following are test conditions prior to calling the */
4413 /* appr_check routine. */
4414 /* */
4415 /* A NULL tcp indicates a non TCP/UDP packet. When dealing */
4416 /* with a map rule, we attempt to match the packet's */
4417 /* source port against in_dport, otherwise we'd compare the */
4418 /* packet's destination. */
4419 /* ------------------------------------------------------------- */
4420 if (np->in_apr != NULL) {
4421 i = appr_check(fin, nat);
4422 if (i == -1) {
4423 return -1;
4424 }
4425 }
4426 }
4427
4428 #ifdef IPFILTER_SYNC
4429 ipfsync_update(SMC_NAT, fin, nat->nat_sync);
4430 #endif
4431
4432 fin->fin_ip->ip_dst = nat->nat_inip;
4433 fin->fin_fi.fi_daddr = nat->nat_inip.s_addr;
4434 if (nflags & IPN_TCPUDP)
4435 tcp = fin->fin_dp;
4436
4437 /*
4438 * Fix up checksums, not by recalculating them, but
4439 * simply computing adjustments.
4440 * Why only do this for some platforms on inbound packets ?
4441 * Because for those that it is done, IP processing is yet to happen
4442 * and so the IPv4 header checksum has not yet been evaluated.
4443 * Perhaps it should always be done for the benefit of things like
4444 * fast forwarding (so that it doesn't need to be recomputed) but with
4445 * header checksum offloading, perhaps it is a moot point.
4446 */
4447 #if !defined(_KERNEL) || defined(MENTAT) || defined(__sgi) || \
4448 defined(__osf__) || defined(linux)
4449 if (nat->nat_dir == NAT_OUTBOUND)
4450 fix_incksum(&fin->fin_ip->ip_sum, nat->nat_ipsumd);
4451 else
4452 fix_outcksum(&fin->fin_ip->ip_sum, nat->nat_ipsumd);
4453 #endif
4454
4455 if (!(fin->fin_flx & FI_SHORT) && (fin->fin_off == 0)) {
4456 if ((nat->nat_inport != 0) && (nflags & IPN_TCPUDP)) {
4457 tcp->th_dport = nat->nat_inport;
4458 fin->fin_data[1] = ntohs(nat->nat_inport);
4459 }
4460
4461
4462 if ((nat->nat_inport != 0) && (nflags & IPN_ICMPQUERY)) {
4463 icmp = fin->fin_dp;
4464
4465 icmp->icmp_id = nat->nat_inport;
4466 }
4467
4468 csump = nat_proto(fin, nat, nflags);
4469 }
4470
4471 /*
4472 * In case they are being forwarded, inbound packets always need to have
4473 * their checksum adjusted even if hardware checksum validation said OK.
4474 */
4475 if (csump != NULL) {
4476 if (nat->nat_dir == NAT_OUTBOUND)
4477 fix_incksum(csump, nat->nat_sumd[0]);
4478 else
4479 fix_outcksum(csump, nat->nat_sumd[0]);
4480 }
4481
4482 #if SOLARIS && defined(_KERNEL)
4483 if (nflags & IPN_TCPUDP &&
4484 NET_IS_HCK_L4_PART(net_data_p, fin->fin_m)) {
4485 /*
4486 * Need to adjust the partial checksum result stored in
4487 * db_cksum16, which will be used for validation in IP.
4488 * See IP_CKSUM_RECV().
4489 * Adjustment data should be the inverse of the IP address
4490 * changes, because db_cksum16 is supposed to be the complement
4491 * of the pesudo header.
4492 */
4493 csump = &fin->fin_m->b_datap->db_cksum16;
4494 if (nat->nat_dir == NAT_OUTBOUND)
4495 fix_outcksum(csump, nat->nat_sumd[1]);
4496 else
4497 fix_incksum(csump, nat->nat_sumd[1]);
4498 }
4499 #endif
4500
4501 ifs->ifs_nat_stats.ns_mapped[0]++;
4502 fin->fin_flx |= FI_NATED;
4503 if (np != NULL && np->in_tag.ipt_num[0] != 0)
4504 fin->fin_nattag = &np->in_tag;
4505 return 1;
4506 }
4507
4508
4509 /* ------------------------------------------------------------------------ */
4510 /* Function: nat_proto */
4511 /* Returns: u_short* - pointer to transport header checksum to update, */
4512 /* NULL if the transport protocol is not recognised */
4513 /* as needing a checksum update. */
4514 /* Parameters: fin(I) - pointer to packet information */
4515 /* nat(I) - pointer to NAT structure */
4516 /* nflags(I) - NAT flags set for this packet */
4517 /* */
4518 /* Return the pointer to the checksum field for each protocol so understood.*/
4519 /* If support for making other changes to a protocol header is required, */
4520 /* that is not strictly 'address' translation, such as clamping the MSS in */
4521 /* TCP down to a specific value, then do it from here. */
4522 /* ------------------------------------------------------------------------ */
4523 u_short *nat_proto(fin, nat, nflags)
4524 fr_info_t *fin;
4525 nat_t *nat;
4526 u_int nflags;
4527 {
4528 icmphdr_t *icmp;
4529 struct icmp6_hdr *icmp6;
4530 u_short *csump;
4531 tcphdr_t *tcp;
4532 udphdr_t *udp;
4533
4534 csump = NULL;
4535 if (fin->fin_out == 0) {
4536 fin->fin_rev = (nat->nat_dir == NAT_OUTBOUND);
4537 } else {
4538 fin->fin_rev = (nat->nat_dir == NAT_INBOUND);
4539 }
4540
4541 switch (fin->fin_p)
4542 {
4543 case IPPROTO_TCP :
4544 tcp = fin->fin_dp;
4545
4546 csump = &tcp->th_sum;
4547
4548 /*
4549 * Do a MSS CLAMPING on a SYN packet,
4550 * only deal IPv4 for now.
4551 */
4552 if ((nat->nat_mssclamp != 0) && (tcp->th_flags & TH_SYN) != 0)
4553 nat_mssclamp(tcp, nat->nat_mssclamp, csump);
4554
4555 break;
4556
4557 case IPPROTO_UDP :
4558 udp = fin->fin_dp;
4559
4560 if (udp->uh_sum)
4561 csump = &udp->uh_sum;
4562 break;
4563
4564 case IPPROTO_ICMP :
4565 icmp = fin->fin_dp;
4566
4567 if ((nflags & IPN_ICMPQUERY) != 0) {
4568 if (icmp->icmp_cksum != 0)
4569 csump = &icmp->icmp_cksum;
4570 }
4571 break;
4572
4573 case IPPROTO_ICMPV6 :
4574 icmp6 = fin->fin_dp;
4575
4576 if ((nflags & IPN_ICMPQUERY) != 0) {
4577 if (icmp6->icmp6_cksum != 0)
4578 csump = &icmp6->icmp6_cksum;
4579 }
4580 break;
4581 }
4582 return csump;
4583 }
4584
4585
4586 /* ------------------------------------------------------------------------ */
4587 /* Function: fr_natunload */
4588 /* Returns: Nil */
4589 /* Parameters: ifs - ipf stack instance */
4590 /* */
4591 /* Free all memory used by NAT structures allocated at runtime. */
4592 /* ------------------------------------------------------------------------ */
4593 void fr_natunload(ifs)
4594 ipf_stack_t *ifs;
4595 {
4596 ipftq_t *ifq, *ifqnext;
4597
4598 (void) nat_clearlist(ifs);
4599 (void) nat_flushtable(FLUSH_TABLE_ALL, ifs);
4600
4601 /*
4602 * Proxy timeout queues are not cleaned here because although they
4603 * exist on the NAT list, appr_unload is called after fr_natunload
4604 * and the proxies actually are responsible for them being created.
4605 * Should the proxy timeouts have their own list? There's no real
4606 * justification as this is the only complication.
4607 */
4608 for (ifq = ifs->ifs_nat_utqe; ifq != NULL; ifq = ifqnext) {
4609 ifqnext = ifq->ifq_next;
4610 if (((ifq->ifq_flags & IFQF_PROXY) == 0) &&
4611 (fr_deletetimeoutqueue(ifq) == 0))
4612 fr_freetimeoutqueue(ifq, ifs);
4613 }
4614
4615 if (ifs->ifs_nat_table[0] != NULL) {
4616 KFREES(ifs->ifs_nat_table[0],
4617 sizeof(nat_t *) * ifs->ifs_ipf_nattable_sz);
4618 ifs->ifs_nat_table[0] = NULL;
4619 }
4620 if (ifs->ifs_nat_table[1] != NULL) {
4621 KFREES(ifs->ifs_nat_table[1],
4622 sizeof(nat_t *) * ifs->ifs_ipf_nattable_sz);
4623 ifs->ifs_nat_table[1] = NULL;
4624 }
4625 if (ifs->ifs_nat_rules != NULL) {
4626 KFREES(ifs->ifs_nat_rules,
4627 sizeof(ipnat_t *) * ifs->ifs_ipf_natrules_sz);
4628 ifs->ifs_nat_rules = NULL;
4629 }
4630 if (ifs->ifs_rdr_rules != NULL) {
4631 KFREES(ifs->ifs_rdr_rules,
4632 sizeof(ipnat_t *) * ifs->ifs_ipf_rdrrules_sz);
4633 ifs->ifs_rdr_rules = NULL;
4634 }
4635 if (ifs->ifs_maptable != NULL) {
4636 KFREES(ifs->ifs_maptable,
4637 sizeof(hostmap_t *) * ifs->ifs_ipf_hostmap_sz);
4638 ifs->ifs_maptable = NULL;
4639 }
4640 if (ifs->ifs_nat_stats.ns_bucketlen[0] != NULL) {
4641 KFREES(ifs->ifs_nat_stats.ns_bucketlen[0],
4642 sizeof(u_long *) * ifs->ifs_ipf_nattable_sz);
4643 ifs->ifs_nat_stats.ns_bucketlen[0] = NULL;
4644 }
4645 if (ifs->ifs_nat_stats.ns_bucketlen[1] != NULL) {
4646 KFREES(ifs->ifs_nat_stats.ns_bucketlen[1],
4647 sizeof(u_long *) * ifs->ifs_ipf_nattable_sz);
4648 ifs->ifs_nat_stats.ns_bucketlen[1] = NULL;
4649 }
4650
4651 if (ifs->ifs_fr_nat_maxbucket_reset == 1)
4652 ifs->ifs_fr_nat_maxbucket = 0;
4653
4654 if (ifs->ifs_fr_nat_init == 1) {
4655 ifs->ifs_fr_nat_init = 0;
4656 fr_sttab_destroy(ifs->ifs_nat_tqb);
4657
4658 RW_DESTROY(&ifs->ifs_ipf_natfrag);
4659 RW_DESTROY(&ifs->ifs_ipf_nat);
4660
4661 MUTEX_DESTROY(&ifs->ifs_ipf_nat_new);
4662 MUTEX_DESTROY(&ifs->ifs_ipf_natio);
4663
4664 MUTEX_DESTROY(&ifs->ifs_nat_udptq.ifq_lock);
4665 MUTEX_DESTROY(&ifs->ifs_nat_icmptq.ifq_lock);
4666 MUTEX_DESTROY(&ifs->ifs_nat_iptq.ifq_lock);
4667 }
4668 }
4669
4670
4671 /* ------------------------------------------------------------------------ */
4672 /* Function: fr_natexpire */
4673 /* Returns: Nil */
4674 /* Parameters: ifs - ipf stack instance */
4675 /* */
4676 /* Check all of the timeout queues for entries at the top which need to be */
4677 /* expired. */
4678 /* ------------------------------------------------------------------------ */
4679 void fr_natexpire(ifs)
4680 ipf_stack_t *ifs;
4681 {
4682 ipftq_t *ifq, *ifqnext;
4683 ipftqent_t *tqe, *tqn;
4684 int i;
4685 SPL_INT(s);
4686
4687 SPL_NET(s);
4688 WRITE_ENTER(&ifs->ifs_ipf_nat);
4689 for (ifq = ifs->ifs_nat_tqb, i = 0; ifq != NULL; ifq = ifq->ifq_next) {
4690 for (tqn = ifq->ifq_head; ((tqe = tqn) != NULL); i++) {
4691 if (tqe->tqe_die > ifs->ifs_fr_ticks)
4692 break;
4693 tqn = tqe->tqe_next;
4694 (void) nat_delete(tqe->tqe_parent, NL_EXPIRE, ifs);
4695 }
4696 }
4697
4698 for (ifq = ifs->ifs_nat_utqe; ifq != NULL; ifq = ifqnext) {
4699 ifqnext = ifq->ifq_next;
4700
4701 for (tqn = ifq->ifq_head; ((tqe = tqn) != NULL); i++) {
4702 if (tqe->tqe_die > ifs->ifs_fr_ticks)
4703 break;
4704 tqn = tqe->tqe_next;
4705 (void) nat_delete(tqe->tqe_parent, NL_EXPIRE, ifs);
4706 }
4707 }
4708
4709 for (ifq = ifs->ifs_nat_utqe; ifq != NULL; ifq = ifqnext) {
4710 ifqnext = ifq->ifq_next;
4711
4712 if (((ifq->ifq_flags & IFQF_DELETE) != 0) &&
4713 (ifq->ifq_ref == 0)) {
4714 fr_freetimeoutqueue(ifq, ifs);
4715 }
4716 }
4717
4718 if (ifs->ifs_nat_doflush != 0) {
4719 (void) nat_flushtable(FLUSH_TABLE_EXTRA, ifs);
4720 ifs->ifs_nat_doflush = 0;
4721 }
4722
4723 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
4724 SPL_X(s);
4725 }
4726
4727
4728 /* ------------------------------------------------------------------------ */
4729 /* Function: fr_nataddrsync */
4730 /* Returns: Nil */
4731 /* Parameters: ifp(I) - pointer to network interface */
4732 /* addr(I) - pointer to new network address */
4733 /* */
4734 /* Walk through all of the currently active NAT sessions, looking for those */
4735 /* which need to have their translated address updated (where the interface */
4736 /* matches the one passed in) and change it, recalculating the checksum sum */
4737 /* difference too. */
4738 /* ------------------------------------------------------------------------ */
4739 void fr_nataddrsync(v, ifp, addr, ifs)
4740 int v;
4741 void *ifp;
4742 void *addr;
4743 ipf_stack_t *ifs;
4744 {
4745 u_32_t sum1, sum2, sumd;
4746 nat_t *nat;
4747 ipnat_t *np;
4748 SPL_INT(s);
4749
4750 if (ifs->ifs_fr_running <= 0)
4751 return;
4752
4753 SPL_NET(s);
4754 WRITE_ENTER(&ifs->ifs_ipf_nat);
4755
4756 if (ifs->ifs_fr_running <= 0) {
4757 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
4758 return;
4759 }
4760
4761 /*
4762 * Change IP addresses for NAT sessions for any protocol except TCP
4763 * since it will break the TCP connection anyway. The only rules
4764 * which will get changed are those which are "map ... -> 0/32",
4765 * where the rule specifies the address is taken from the interface.
4766 */
4767 for (nat = ifs->ifs_nat_instances; nat; nat = nat->nat_next) {
4768 if (addr != NULL) {
4769 if (((ifp != NULL) && ifp != (nat->nat_ifps[0])) ||
4770 ((nat->nat_flags & IPN_TCP) != 0))
4771 continue;
4772 if ((np = nat->nat_ptr) == NULL)
4773 continue;
4774 if (v == 4 && np->in_v == 4) {
4775 if (np->in_nip || np->in_outmsk != 0xffffffff)
4776 continue;
4777 /*
4778 * Change the map-to address to be the same as
4779 * the new one.
4780 */
4781 sum1 = nat->nat_outip.s_addr;
4782 nat->nat_outip = *(struct in_addr *)addr;
4783 sum2 = nat->nat_outip.s_addr;
4784 } else if (v == 6 && np->in_v == 6) {
4785 if (!IP6_ISZERO(&np->in_next6.in6) ||
4786 !IP6_ISONES(&np->in_out[1].in6))
4787 continue;
4788 /*
4789 * Change the map-to address to be the same as
4790 * the new one.
4791 */
4792 nat->nat_outip6.in6 = *(struct in6_addr *)addr;
4793 } else
4794 continue;
4795
4796 } else if (((ifp == NULL) || (ifp == nat->nat_ifps[0])) &&
4797 !(nat->nat_flags & IPN_TCP) && (np = nat->nat_ptr)) {
4798 if (np->in_v == 4 && (v == 4 || v == 0)) {
4799 struct in_addr in;
4800 if (np->in_outmsk != 0xffffffff || np->in_nip)
4801 continue;
4802 /*
4803 * Change the map-to address to be the same as
4804 * the new one.
4805 */
4806 sum1 = nat->nat_outip.s_addr;
4807 if (fr_ifpaddr(4, FRI_NORMAL, nat->nat_ifps[0],
4808 &in, NULL, ifs) != -1)
4809 nat->nat_outip = in;
4810 sum2 = nat->nat_outip.s_addr;
4811 } else if (np->in_v == 6 && (v == 6 || v == 0)) {
4812 struct in6_addr in6;
4813 if (!IP6_ISZERO(&np->in_next6.in6) ||
4814 !IP6_ISONES(&np->in_out[1].in6))
4815 continue;
4816 /*
4817 * Change the map-to address to be the same as
4818 * the new one.
4819 */
4820 if (fr_ifpaddr(6, FRI_NORMAL, nat->nat_ifps[0],
4821 (void *)&in6, NULL, ifs) != -1)
4822 nat->nat_outip6.in6 = in6;
4823 } else
4824 continue;
4825 } else {
4826 continue;
4827 }
4828
4829 if (sum1 == sum2)
4830 continue;
4831 /*
4832 * Readjust the checksum adjustment to take into
4833 * account the new IP#.
4834 */
4835 CALC_SUMD(sum1, sum2, sumd);
4836 /* XXX - dont change for TCP when solaris does
4837 * hardware checksumming.
4838 */
4839 sumd += nat->nat_sumd[0];
4840 nat->nat_sumd[0] = (sumd & 0xffff) + (sumd >> 16);
4841 nat->nat_sumd[1] = nat->nat_sumd[0];
4842 }
4843
4844 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
4845 SPL_X(s);
4846 }
4847
4848
4849 /* ------------------------------------------------------------------------ */
4850 /* Function: fr_natifpsync */
4851 /* Returns: Nil */
4852 /* Parameters: action(I) - how we are syncing */
4853 /* ifp(I) - pointer to network interface */
4854 /* name(I) - name of interface to sync to */
4855 /* */
4856 /* This function is used to resync the mapping of interface names and their */
4857 /* respective 'pointers'. For "action == IPFSYNC_RESYNC", resync all */
4858 /* interfaces by doing a new lookup of name to 'pointer'. For "action == */
4859 /* IPFSYNC_NEWIFP", treat ifp as the new pointer value associated with */
4860 /* "name" and for "action == IPFSYNC_OLDIFP", ifp is a pointer for which */
4861 /* there is no longer any interface associated with it. */
4862 /* ------------------------------------------------------------------------ */
4863 void fr_natifpsync(action, v, ifp, name, ifs)
4864 int action, v;
4865 void *ifp;
4866 char *name;
4867 ipf_stack_t *ifs;
4868 {
4869 #if defined(_KERNEL) && !defined(MENTAT) && defined(USE_SPL)
4870 int s;
4871 #endif
4872 nat_t *nat;
4873 ipnat_t *n;
4874 int nv;
4875
4876 if (ifs->ifs_fr_running <= 0)
4877 return;
4878
4879 SPL_NET(s);
4880 WRITE_ENTER(&ifs->ifs_ipf_nat);
4881
4882 if (ifs->ifs_fr_running <= 0) {
4883 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
4884 return;
4885 }
4886
4887 switch (action)
4888 {
4889 case IPFSYNC_RESYNC :
4890 for (nat = ifs->ifs_nat_instances; nat; nat = nat->nat_next) {
4891 nv = (v == 0) ? nat->nat_v : v;
4892 if (nat->nat_v != nv)
4893 continue;
4894 if ((ifp == nat->nat_ifps[0]) ||
4895 (nat->nat_ifps[0] == (void *)-1)) {
4896 nat->nat_ifps[0] =
4897 fr_resolvenic(nat->nat_ifnames[0], nv, ifs);
4898 }
4899
4900 if ((ifp == nat->nat_ifps[1]) ||
4901 (nat->nat_ifps[1] == (void *)-1)) {
4902 nat->nat_ifps[1] =
4903 fr_resolvenic(nat->nat_ifnames[1], nv, ifs);
4904 }
4905 }
4906
4907 for (n = ifs->ifs_nat_list; (n != NULL); n = n->in_next) {
4908 nv = (v == 0) ? (int)n->in_v : v;
4909 if ((int)n->in_v != nv)
4910 continue;
4911 if (n->in_ifps[0] == ifp ||
4912 n->in_ifps[0] == (void *)-1) {
4913 n->in_ifps[0] =
4914 fr_resolvenic(n->in_ifnames[0], nv, ifs);
4915 }
4916 if (n->in_ifps[1] == ifp ||
4917 n->in_ifps[1] == (void *)-1) {
4918 n->in_ifps[1] =
4919 fr_resolvenic(n->in_ifnames[1], nv, ifs);
4920 }
4921 }
4922 break;
4923 case IPFSYNC_NEWIFP :
4924 for (nat = ifs->ifs_nat_instances; nat; nat = nat->nat_next) {
4925 if (nat->nat_v != v)
4926 continue;
4927 if (!strncmp(name, nat->nat_ifnames[0],
4928 sizeof(nat->nat_ifnames[0])))
4929 nat->nat_ifps[0] = ifp;
4930 if (!strncmp(name, nat->nat_ifnames[1],
4931 sizeof(nat->nat_ifnames[1])))
4932 nat->nat_ifps[1] = ifp;
4933 }
4934 for (n = ifs->ifs_nat_list; (n != NULL); n = n->in_next) {
4935 if ((int)n->in_v != v)
4936 continue;
4937 if (!strncmp(name, n->in_ifnames[0],
4938 sizeof(n->in_ifnames[0])))
4939 n->in_ifps[0] = ifp;
4940 if (!strncmp(name, n->in_ifnames[1],
4941 sizeof(n->in_ifnames[1])))
4942 n->in_ifps[1] = ifp;
4943 }
4944 break;
4945 case IPFSYNC_OLDIFP :
4946 for (nat = ifs->ifs_nat_instances; nat; nat = nat->nat_next) {
4947 if (nat->nat_v != v)
4948 continue;
4949 if (ifp == nat->nat_ifps[0])
4950 nat->nat_ifps[0] = (void *)-1;
4951 if (ifp == nat->nat_ifps[1])
4952 nat->nat_ifps[1] = (void *)-1;
4953 }
4954 for (n = ifs->ifs_nat_list; (n != NULL); n = n->in_next) {
4955 if ((int)n->in_v != v)
4956 continue;
4957 if (n->in_ifps[0] == ifp)
4958 n->in_ifps[0] = (void *)-1;
4959 if (n->in_ifps[1] == ifp)
4960 n->in_ifps[1] = (void *)-1;
4961 }
4962 break;
4963 }
4964 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
4965 SPL_X(s);
4966 }
4967
4968 #if SOLARIS2 >= 10
4969 /* ------------------------------------------------------------------------ */
4970 /* Function: fr_natifindexsync */
4971 /* Returns: void */
4972 /* Parameters: ifp - interface, which is being sync'd */
4973 /* newifp - new ifindex value for interface */
4974 /* ifs - IPF's stack */
4975 /* */
4976 /* Write Locks: assumes ipf_mutex is locked */
4977 /* */
4978 /* Updates all interface index references in NAT rules and NAT entries. */
4979 /* the index, which is about to be updated must match ifp value. */
4980 /* ------------------------------------------------------------------------ */
4981 void fr_natifindexsync(ifp, newifp, ifs)
4982 void *ifp;
4983 void *newifp;
4984 ipf_stack_t *ifs;
4985 {
4986 nat_t *nat;
4987 ipnat_t *n;
4988
4989 WRITE_ENTER(&ifs->ifs_ipf_nat);
4990
4991 for (nat = ifs->ifs_nat_instances; nat != NULL; nat = nat->nat_next) {
4992 if (ifp == nat->nat_ifps[0])
4993 nat->nat_ifps[0] = newifp;
4994
4995 if (ifp == nat->nat_ifps[1])
4996 nat->nat_ifps[1] = newifp;
4997 }
4998
4999 for (n = ifs->ifs_nat_list; n != NULL; n = n->in_next) {
5000 if (ifp == n->in_ifps[0])
5001 n->in_ifps[0] = newifp;
5002
5003 if (ifp == n->in_ifps[1])
5004 n->in_ifps[1] = newifp;
5005 }
5006
5007 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
5008 }
5009 #endif
5010
5011 /* ------------------------------------------------------------------------ */
5012 /* Function: nat_icmpquerytype4 */
5013 /* Returns: int - 1 == success, 0 == failure */
5014 /* Parameters: icmptype(I) - ICMP type number */
5015 /* */
5016 /* Tests to see if the ICMP type number passed is a query/response type or */
5017 /* not. */
5018 /* ------------------------------------------------------------------------ */
5019 static INLINE int nat_icmpquerytype4(icmptype)
5020 int icmptype;
5021 {
5022
5023 /*
5024 * For the ICMP query NAT code, it is essential that both the query
5025 * and the reply match on the NAT rule. Because the NAT structure
5026 * does not keep track of the icmptype, and a single NAT structure
5027 * is used for all icmp types with the same src, dest and id, we
5028 * simply define the replies as queries as well. The funny thing is,
5029 * altough it seems silly to call a reply a query, this is exactly
5030 * as it is defined in the IPv4 specification
5031 */
5032
5033 switch (icmptype)
5034 {
5035
5036 case ICMP_ECHOREPLY:
5037 case ICMP_ECHO:
5038 /* route aedvertisement/solliciation is currently unsupported: */
5039 /* it would require rewriting the ICMP data section */
5040 case ICMP_TSTAMP:
5041 case ICMP_TSTAMPREPLY:
5042 case ICMP_IREQ:
5043 case ICMP_IREQREPLY:
5044 case ICMP_MASKREQ:
5045 case ICMP_MASKREPLY:
5046 return 1;
5047 default:
5048 return 0;
5049 }
5050 }
5051
5052
5053 /* ------------------------------------------------------------------------ */
5054 /* Function: nat_log */
5055 /* Returns: Nil */
5056 /* Parameters: nat(I) - pointer to NAT structure */
5057 /* type(I) - type of log entry to create */
5058 /* */
5059 /* Creates a NAT log entry. */
5060 /* ------------------------------------------------------------------------ */
5061 void nat_log(nat, type, ifs)
5062 struct nat *nat;
5063 u_int type;
5064 ipf_stack_t *ifs;
5065 {
5066 #ifdef IPFILTER_LOG
5067 # ifndef LARGE_NAT
5068 struct ipnat *np;
5069 int rulen;
5070 # endif
5071 struct natlog natl;
5072 void *items[1];
5073 size_t sizes[1];
5074 int types[1];
5075
5076 natl.nlg_inip = nat->nat_inip6;
5077 natl.nlg_outip = nat->nat_outip6;
5078 natl.nlg_origip = nat->nat_oip6;
5079 natl.nlg_bytes[0] = nat->nat_bytes[0];
5080 natl.nlg_bytes[1] = nat->nat_bytes[1];
5081 natl.nlg_pkts[0] = nat->nat_pkts[0];
5082 natl.nlg_pkts[1] = nat->nat_pkts[1];
5083 natl.nlg_origport = nat->nat_oport;
5084 natl.nlg_inport = nat->nat_inport;
5085 natl.nlg_outport = nat->nat_outport;
5086 natl.nlg_p = nat->nat_p;
5087 natl.nlg_type = type;
5088 natl.nlg_rule = -1;
5089 natl.nlg_v = nat->nat_v;
5090 # ifndef LARGE_NAT
5091 if (nat->nat_ptr != NULL) {
5092 for (rulen = 0, np = ifs->ifs_nat_list; np;
5093 np = np->in_next, rulen++)
5094 if (np == nat->nat_ptr) {
5095 natl.nlg_rule = rulen;
5096 break;
5097 }
5098 }
5099 # endif
5100 items[0] = &natl;
5101 sizes[0] = sizeof(natl);
5102 types[0] = 0;
5103
5104 (void) ipllog(IPL_LOGNAT, NULL, items, sizes, types, 1, ifs);
5105 #endif
5106 }
5107
5108
5109 #if defined(__OpenBSD__)
5110 /* ------------------------------------------------------------------------ */
5111 /* Function: nat_ifdetach */
5112 /* Returns: Nil */
5113 /* Parameters: ifp(I) - pointer to network interface */
5114 /* */
5115 /* Compatibility interface for OpenBSD to trigger the correct updating of */
5116 /* interface references within IPFilter. */
5117 /* ------------------------------------------------------------------------ */
5118 void nat_ifdetach(ifp, ifs)
5119 void *ifp;
5120 ipf_stack_t *ifs;
5121 {
5122 frsync(ifp, ifs);
5123 return;
5124 }
5125 #endif
5126
5127
5128 /* ------------------------------------------------------------------------ */
5129 /* Function: fr_ipnatderef */
5130 /* Returns: Nil */
5131 /* Parameters: inp(I) - pointer to pointer to NAT rule */
5132 /* Write Locks: ipf_nat */
5133 /* */
5134 /* ------------------------------------------------------------------------ */
5135 void fr_ipnatderef(inp, ifs)
5136 ipnat_t **inp;
5137 ipf_stack_t *ifs;
5138 {
5139 ipnat_t *in;
5140
5141 in = *inp;
5142 *inp = NULL;
5143 in->in_use--;
5144 if (in->in_use == 0 && (in->in_flags & IPN_DELETE)) {
5145 if (in->in_apr)
5146 appr_free(in->in_apr);
5147 KFREE(in);
5148 ifs->ifs_nat_stats.ns_rules--;
5149 #ifdef notdef
5150 #if SOLARIS
5151 if (ifs->ifs_nat_stats.ns_rules == 0)
5152 ifs->ifs_pfil_delayed_copy = 1;
5153 #endif
5154 #endif
5155 }
5156 }
5157
5158
5159 /* ------------------------------------------------------------------------ */
5160 /* Function: fr_natderef */
5161 /* Returns: Nil */
5162 /* Parameters: natp - pointer to pointer to NAT table entry */
5163 /* ifs - ipf stack instance */
5164 /* */
5165 /* Decrement the reference counter for this NAT table entry and free it if */
5166 /* there are no more things using it. */
5167 /* */
5168 /* IF nat_ref == 1 when this function is called, then we have an orphan nat */
5169 /* structure *because* it only gets called on paths _after_ nat_ref has been*/
5170 /* incremented. If nat_ref == 1 then we shouldn't decrement it here */
5171 /* because nat_delete() will do that and send nat_ref to -1. */
5172 /* */
5173 /* Holding the lock on nat_lock is required to serialise nat_delete() being */
5174 /* called from a NAT flush ioctl with a deref happening because of a packet.*/
5175 /* ------------------------------------------------------------------------ */
5176 void fr_natderef(natp, ifs)
5177 nat_t **natp;
5178 ipf_stack_t *ifs;
5179 {
5180 nat_t *nat;
5181
5182 nat = *natp;
5183 *natp = NULL;
5184
5185 MUTEX_ENTER(&nat->nat_lock);
5186 if (nat->nat_ref > 1) {
5187 nat->nat_ref--;
5188 MUTEX_EXIT(&nat->nat_lock);
5189 return;
5190 }
5191 MUTEX_EXIT(&nat->nat_lock);
5192
5193 WRITE_ENTER(&ifs->ifs_ipf_nat);
5194 (void) nat_delete(nat, NL_EXPIRE, ifs);
5195 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
5196 }
5197
5198
5199 /* ------------------------------------------------------------------------ */
5200 /* Function: fr_natclone */
5201 /* Returns: ipstate_t* - NULL == cloning failed, */
5202 /* else pointer to new NAT structure */
5203 /* Parameters: fin(I) - pointer to packet information */
5204 /* nat(I) - pointer to master NAT structure */
5205 /* Write Lock: ipf_nat */
5206 /* */
5207 /* Create a "duplicate" NAT table entry from the master. */
5208 /* ------------------------------------------------------------------------ */
5209 nat_t *fr_natclone(fin, nat)
5210 fr_info_t *fin;
5211 nat_t *nat;
5212 {
5213 frentry_t *fr;
5214 nat_t *clone;
5215 ipnat_t *np;
5216 ipf_stack_t *ifs = fin->fin_ifs;
5217
5218 /*
5219 * Trigger automatic call to nat_flushtable() if the
5220 * table has reached capcity specified by hi watermark.
5221 */
5222 if (NAT_TAB_WATER_LEVEL(ifs) > ifs->ifs_nat_flush_level_hi)
5223 ifs->ifs_nat_doflush = 1;
5224
5225 /*
5226 * If automatic flushing did not do its job, and the table
5227 * has filled up, don't try to create a new entry.
5228 */
5229 if (ifs->ifs_nat_stats.ns_inuse >= ifs->ifs_ipf_nattable_max) {
5230 ifs->ifs_nat_stats.ns_memfail++;
5231 return NULL;
5232 }
5233
5234 KMALLOC(clone, nat_t *);
5235 if (clone == NULL)
5236 return NULL;
5237 bcopy((char *)nat, (char *)clone, sizeof(*clone));
5238
5239 MUTEX_NUKE(&clone->nat_lock);
5240
5241 clone->nat_aps = NULL;
5242 /*
5243 * Initialize all these so that nat_delete() doesn't cause a crash.
5244 */
5245 clone->nat_tqe.tqe_pnext = NULL;
5246 clone->nat_tqe.tqe_next = NULL;
5247 clone->nat_tqe.tqe_ifq = NULL;
5248 clone->nat_tqe.tqe_parent = clone;
5249
5250 clone->nat_flags &= ~SI_CLONE;
5251 clone->nat_flags |= SI_CLONED;
5252
5253 if (clone->nat_hm)
5254 clone->nat_hm->hm_ref++;
5255
5256 if (nat_insert(clone, fin->fin_rev, ifs) == -1) {
5257 KFREE(clone);
5258 return NULL;
5259 }
5260 np = clone->nat_ptr;
5261 if (np != NULL) {
5262 if (ifs->ifs_nat_logging)
5263 nat_log(clone, (u_int)np->in_redir, ifs);
5264 np->in_use++;
5265 }
5266 fr = clone->nat_fr;
5267 if (fr != NULL) {
5268 MUTEX_ENTER(&fr->fr_lock);
5269 fr->fr_ref++;
5270 MUTEX_EXIT(&fr->fr_lock);
5271 }
5272
5273 /*
5274 * Because the clone is created outside the normal loop of things and
5275 * TCP has special needs in terms of state, initialise the timeout
5276 * state of the new NAT from here.
5277 */
5278 if (clone->nat_p == IPPROTO_TCP) {
5279 (void) fr_tcp_age(&clone->nat_tqe, fin, ifs->ifs_nat_tqb,
5280 clone->nat_flags);
5281 }
5282 #ifdef IPFILTER_SYNC
5283 clone->nat_sync = ipfsync_new(SMC_NAT, fin, clone);
5284 #endif
5285 if (ifs->ifs_nat_logging)
5286 nat_log(clone, NL_CLONE, ifs);
5287 return clone;
5288 }
5289
5290
5291 /* ------------------------------------------------------------------------ */
5292 /* Function: nat_wildok */
5293 /* Returns: int - 1 == packet's ports match wildcards */
5294 /* 0 == packet's ports don't match wildcards */
5295 /* Parameters: nat(I) - NAT entry */
5296 /* sport(I) - source port */
5297 /* dport(I) - destination port */
5298 /* flags(I) - wildcard flags */
5299 /* dir(I) - packet direction */
5300 /* */
5301 /* Use NAT entry and packet direction to determine which combination of */
5302 /* wildcard flags should be used. */
5303 /* ------------------------------------------------------------------------ */
5304 int nat_wildok(nat, sport, dport, flags, dir)
5305 nat_t *nat;
5306 int sport;
5307 int dport;
5308 int flags;
5309 int dir;
5310 {
5311 /*
5312 * When called by dir is set to
5313 * nat_inlookup NAT_INBOUND (0)
5314 * nat_outlookup NAT_OUTBOUND (1)
5315 *
5316 * We simply combine the packet's direction in dir with the original
5317 * "intended" direction of that NAT entry in nat->nat_dir to decide
5318 * which combination of wildcard flags to allow.
5319 */
5320
5321 switch ((dir << 1) | nat->nat_dir)
5322 {
5323 case 3: /* outbound packet / outbound entry */
5324 if (((nat->nat_inport == sport) ||
5325 (flags & SI_W_SPORT)) &&
5326 ((nat->nat_oport == dport) ||
5327 (flags & SI_W_DPORT)))
5328 return 1;
5329 break;
5330 case 2: /* outbound packet / inbound entry */
5331 if (((nat->nat_outport == sport) ||
5332 (flags & SI_W_DPORT)) &&
5333 ((nat->nat_oport == dport) ||
5334 (flags & SI_W_SPORT)))
5335 return 1;
5336 break;
5337 case 1: /* inbound packet / outbound entry */
5338 if (((nat->nat_oport == sport) ||
5339 (flags & SI_W_DPORT)) &&
5340 ((nat->nat_outport == dport) ||
5341 (flags & SI_W_SPORT)))
5342 return 1;
5343 break;
5344 case 0: /* inbound packet / inbound entry */
5345 if (((nat->nat_oport == sport) ||
5346 (flags & SI_W_SPORT)) &&
5347 ((nat->nat_outport == dport) ||
5348 (flags & SI_W_DPORT)))
5349 return 1;
5350 break;
5351 default:
5352 break;
5353 }
5354
5355 return(0);
5356 }
5357
5358
5359 /* ------------------------------------------------------------------------ */
5360 /* Function: nat_mssclamp */
5361 /* Returns: Nil */
5362 /* Parameters: tcp(I) - pointer to TCP header */
5363 /* maxmss(I) - value to clamp the TCP MSS to */
5364 /* csump(I) - pointer to TCP checksum */
5365 /* */
5366 /* Check for MSS option and clamp it if necessary. If found and changed, */
5367 /* then the TCP header checksum will be updated to reflect the change in */
5368 /* the MSS. */
5369 /* ------------------------------------------------------------------------ */
5370 static void nat_mssclamp(tcp, maxmss, csump)
5371 tcphdr_t *tcp;
5372 u_32_t maxmss;
5373 u_short *csump;
5374 {
5375 u_char *cp, *ep, opt;
5376 int hlen, advance;
5377 u_32_t mss, sumd;
5378
5379 hlen = TCP_OFF(tcp) << 2;
5380 if (hlen > sizeof(*tcp)) {
5381 cp = (u_char *)tcp + sizeof(*tcp);
5382 ep = (u_char *)tcp + hlen;
5383
5384 while (cp < ep) {
5385 opt = cp[0];
5386 if (opt == TCPOPT_EOL)
5387 break;
5388 else if (opt == TCPOPT_NOP) {
5389 cp++;
5390 continue;
5391 }
5392
5393 if (cp + 1 >= ep)
5394 break;
5395 advance = cp[1];
5396 if ((cp + advance > ep) || (advance <= 0))
5397 break;
5398 switch (opt)
5399 {
5400 case TCPOPT_MAXSEG:
5401 if (advance != 4)
5402 break;
5403 mss = cp[2] * 256 + cp[3];
5404 if (mss > maxmss) {
5405 cp[2] = maxmss / 256;
5406 cp[3] = maxmss & 0xff;
5407 CALC_SUMD(mss, maxmss, sumd);
5408 fix_outcksum(csump, sumd);
5409 }
5410 break;
5411 default:
5412 /* ignore unknown options */
5413 break;
5414 }
5415
5416 cp += advance;
5417 }
5418 }
5419 }
5420
5421
5422 /* ------------------------------------------------------------------------ */
5423 /* Function: fr_setnatqueue */
5424 /* Returns: Nil */
5425 /* Parameters: nat(I)- pointer to NAT structure */
5426 /* rev(I) - forward(0) or reverse(1) direction */
5427 /* Locks: ipf_nat (read or write) */
5428 /* */
5429 /* Put the NAT entry on its default queue entry, using rev as a helped in */
5430 /* determining which queue it should be placed on. */
5431 /* ------------------------------------------------------------------------ */
5432 void fr_setnatqueue(nat, rev, ifs)
5433 nat_t *nat;
5434 int rev;
5435 ipf_stack_t *ifs;
5436 {
5437 ipftq_t *oifq, *nifq;
5438
5439 if (nat->nat_ptr != NULL)
5440 nifq = nat->nat_ptr->in_tqehead[rev];
5441 else
5442 nifq = NULL;
5443
5444 if (nifq == NULL) {
5445 switch (nat->nat_p)
5446 {
5447 case IPPROTO_UDP :
5448 nifq = &ifs->ifs_nat_udptq;
5449 break;
5450 case IPPROTO_ICMP :
5451 nifq = &ifs->ifs_nat_icmptq;
5452 break;
5453 case IPPROTO_TCP :
5454 nifq = ifs->ifs_nat_tqb + nat->nat_tqe.tqe_state[rev];
5455 break;
5456 default :
5457 nifq = &ifs->ifs_nat_iptq;
5458 break;
5459 }
5460 }
5461
5462 oifq = nat->nat_tqe.tqe_ifq;
5463 /*
5464 * If it's currently on a timeout queue, move it from one queue to
5465 * another, else put it on the end of the newly determined queue.
5466 */
5467 if (oifq != NULL)
5468 fr_movequeue(&nat->nat_tqe, oifq, nifq, ifs);
5469 else
5470 fr_queueappend(&nat->nat_tqe, nifq, nat, ifs);
5471 return;
5472 }
5473
5474 /* ------------------------------------------------------------------------ */
5475 /* Function: nat_getnext */
5476 /* Returns: int - 0 == ok, else error */
5477 /* Parameters: t(I) - pointer to ipftoken structure */
5478 /* itp(I) - pointer to ipfgeniter_t structure */
5479 /* ifs - ipf stack instance */
5480 /* */
5481 /* Fetch the next nat/ipnat/hostmap structure pointer from the linked list */
5482 /* and copy it out to the storage space pointed to by itp. The next item */
5483 /* in the list to look at is put back in the ipftoken struture. */
5484 /* ------------------------------------------------------------------------ */
5485 static int nat_getnext(t, itp, ifs)
5486 ipftoken_t *t;
5487 ipfgeniter_t *itp;
5488 ipf_stack_t *ifs;
5489 {
5490 hostmap_t *hm, *nexthm = NULL, zerohm;
5491 ipnat_t *ipn, *nextipnat = NULL, zeroipn;
5492 nat_t *nat, *nextnat = NULL, zeronat;
5493 int error = 0, count;
5494 char *dst;
5495
5496 if (itp->igi_nitems == 0)
5497 return EINVAL;
5498
5499 READ_ENTER(&ifs->ifs_ipf_nat);
5500
5501 /*
5502 * Get "previous" entry from the token and find the next entry.
5503 */
5504 switch (itp->igi_type)
5505 {
5506 case IPFGENITER_HOSTMAP :
5507 hm = t->ipt_data;
5508 if (hm == NULL) {
5509 nexthm = ifs->ifs_ipf_hm_maplist;
5510 } else {
5511 nexthm = hm->hm_next;
5512 }
5513 break;
5514
5515 case IPFGENITER_IPNAT :
5516 ipn = t->ipt_data;
5517 if (ipn == NULL) {
5518 nextipnat = ifs->ifs_nat_list;
5519 } else {
5520 nextipnat = ipn->in_next;
5521 }
5522 break;
5523
5524 case IPFGENITER_NAT :
5525 nat = t->ipt_data;
5526 if (nat == NULL) {
5527 nextnat = ifs->ifs_nat_instances;
5528 } else {
5529 nextnat = nat->nat_next;
5530 }
5531 break;
5532 default :
5533 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
5534 return EINVAL;
5535 }
5536
5537 /*
5538 * Note, this loop is based on the number of items that a user
5539 * requested. The user can request any number, potentially far more than
5540 * the number of items that actually exist. If a user does that, we'll
5541 * break out of this by setting the value of count to 1 which terminates
5542 * the loop. This should be fine from an ioctl perspective, because the
5543 * last entry that we insert will be the zero entry which terminates the
5544 * chain.
5545 */
5546 dst = itp->igi_data;
5547 for (count = itp->igi_nitems; count > 0; count--) {
5548 /*
5549 * If we found an entry, add a reference to it and update the token.
5550 * Otherwise, zero out data to be returned and NULL out token.
5551 */
5552 switch (itp->igi_type)
5553 {
5554 case IPFGENITER_HOSTMAP :
5555 if (nexthm != NULL) {
5556 ATOMIC_INC32(nexthm->hm_ref);
5557 t->ipt_data = nexthm;
5558 } else {
5559 bzero(&zerohm, sizeof(zerohm));
5560 nexthm = &zerohm;
5561 t->ipt_data = NULL;
5562 }
5563 break;
5564 case IPFGENITER_IPNAT :
5565 if (nextipnat != NULL) {
5566 ATOMIC_INC32(nextipnat->in_use);
5567 t->ipt_data = nextipnat;
5568 } else {
5569 bzero(&zeroipn, sizeof(zeroipn));
5570 nextipnat = &zeroipn;
5571 t->ipt_data = NULL;
5572 }
5573 break;
5574 case IPFGENITER_NAT :
5575 if (nextnat != NULL) {
5576 MUTEX_ENTER(&nextnat->nat_lock);
5577 nextnat->nat_ref++;
5578 MUTEX_EXIT(&nextnat->nat_lock);
5579 t->ipt_data = nextnat;
5580 } else {
5581 bzero(&zeronat, sizeof(zeronat));
5582 nextnat = &zeronat;
5583 t->ipt_data = NULL;
5584 }
5585 break;
5586 default :
5587 break;
5588 }
5589
5590 /*
5591 * Now that we have ref, it's save to give up lock.
5592 */
5593 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
5594
5595 /*
5596 * Copy out data and clean up references and token as needed.
5597 */
5598 switch (itp->igi_type)
5599 {
5600 case IPFGENITER_HOSTMAP :
5601 error = COPYOUT(nexthm, dst, sizeof(*nexthm));
5602 if (error != 0)
5603 error = EFAULT;
5604 if (t->ipt_data == NULL) {
5605 ipf_freetoken(t, ifs);
5606 count = 1;
5607 break;
5608 } else {
5609 if (hm != NULL) {
5610 WRITE_ENTER(&ifs->ifs_ipf_nat);
5611 fr_hostmapdel(&hm);
5612 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
5613 }
5614 if (nexthm->hm_next == NULL) {
5615 ipf_freetoken(t, ifs);
5616 count = 1;
5617 break;
5618 }
5619 dst += sizeof(*nexthm);
5620 hm = nexthm;
5621 nexthm = nexthm->hm_next;
5622 }
5623 break;
5624
5625 case IPFGENITER_IPNAT :
5626 error = COPYOUT(nextipnat, dst, sizeof(*nextipnat));
5627 if (error != 0)
5628 error = EFAULT;
5629 if (t->ipt_data == NULL) {
5630 ipf_freetoken(t, ifs);
5631 count = 1;
5632 break;
5633 } else {
5634 if (ipn != NULL) {
5635 WRITE_ENTER(&ifs->ifs_ipf_nat);
5636 fr_ipnatderef(&ipn, ifs);
5637 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
5638 }
5639 if (nextipnat->in_next == NULL) {
5640 ipf_freetoken(t, ifs);
5641 count = 1;
5642 break;
5643 }
5644 dst += sizeof(*nextipnat);
5645 ipn = nextipnat;
5646 nextipnat = nextipnat->in_next;
5647 }
5648 break;
5649
5650 case IPFGENITER_NAT :
5651 error = COPYOUT(nextnat, dst, sizeof(*nextnat));
5652 if (error != 0)
5653 error = EFAULT;
5654 if (t->ipt_data == NULL) {
5655 ipf_freetoken(t, ifs);
5656 count = 1;
5657 break;
5658 } else {
5659 if (nat != NULL)
5660 fr_natderef(&nat, ifs);
5661 if (nextnat->nat_next == NULL) {
5662 ipf_freetoken(t, ifs);
5663 count = 1;
5664 break;
5665 }
5666 dst += sizeof(*nextnat);
5667 nat = nextnat;
5668 nextnat = nextnat->nat_next;
5669 }
5670 break;
5671 default :
5672 break;
5673 }
5674
5675 if ((count == 1) || (error != 0))
5676 break;
5677
5678 READ_ENTER(&ifs->ifs_ipf_nat);
5679 }
5680
5681 return error;
5682 }
5683
5684
5685 /* ------------------------------------------------------------------------ */
5686 /* Function: nat_iterator */
5687 /* Returns: int - 0 == ok, else error */
5688 /* Parameters: token(I) - pointer to ipftoken structure */
5689 /* itp(I) - pointer to ipfgeniter_t structure */
5690 /* */
5691 /* This function acts as a handler for the SIOCGENITER ioctls that use a */
5692 /* generic structure to iterate through a list. There are three different */
5693 /* linked lists of NAT related information to go through: NAT rules, active */
5694 /* NAT mappings and the NAT fragment cache. */
5695 /* ------------------------------------------------------------------------ */
5696 static int nat_iterator(token, itp, ifs)
5697 ipftoken_t *token;
5698 ipfgeniter_t *itp;
5699 ipf_stack_t *ifs;
5700 {
5701 int error;
5702
5703 if (itp->igi_data == NULL)
5704 return EFAULT;
5705
5706 token->ipt_subtype = itp->igi_type;
5707
5708 switch (itp->igi_type)
5709 {
5710 case IPFGENITER_HOSTMAP :
5711 case IPFGENITER_IPNAT :
5712 case IPFGENITER_NAT :
5713 error = nat_getnext(token, itp, ifs);
5714 break;
5715 case IPFGENITER_NATFRAG :
5716 error = fr_nextfrag(token, itp, &ifs->ifs_ipfr_natlist,
5717 &ifs->ifs_ipfr_nattail,
5718 &ifs->ifs_ipf_natfrag, ifs);
5719 break;
5720 default :
5721 error = EINVAL;
5722 break;
5723 }
5724
5725 return error;
5726 }
5727
5728
5729 /* ---------------------------------------------------------------------- */
5730 /* Function: nat_flushtable */
5731 /* Returns: int - 0 == success, -1 == failure */
5732 /* Parameters: flush_option - how to flush the active NAT table */
5733 /* ifs - ipf stack instance */
5734 /* Write Locks: ipf_nat */
5735 /* */
5736 /* Flush NAT tables. Three actions currently defined: */
5737 /* */
5738 /* FLUSH_TABLE_ALL : Flush all NAT table entries */
5739 /* */
5740 /* FLUSH_TABLE_CLOSING : Flush entries with TCP connections which */
5741 /* have started to close on both ends using */
5742 /* ipf_flushclosing(). */
5743 /* */
5744 /* FLUSH_TABLE_EXTRA : First, flush entries which are "almost" closed. */
5745 /* Then, if needed, flush entries with TCP */
5746 /* connections which have been idle for a long */
5747 /* time with ipf_extraflush(). */
5748 /* ---------------------------------------------------------------------- */
5749 static int nat_flushtable(flush_option, ifs)
5750 int flush_option;
5751 ipf_stack_t *ifs;
5752 {
5753 nat_t *nat, *natn;
5754 int removed;
5755 SPL_INT(s);
5756
5757 removed = 0;
5758
5759 SPL_NET(s);
5760 switch (flush_option)
5761 {
5762 case FLUSH_TABLE_ALL:
5763 natn = ifs->ifs_nat_instances;
5764 while ((nat = natn) != NULL) {
5765 natn = nat->nat_next;
5766 if (nat_delete(nat, NL_FLUSH, ifs) == 0)
5767 removed++;
5768 }
5769 break;
5770
5771 case FLUSH_TABLE_CLOSING:
5772 removed = ipf_flushclosing(NAT_FLUSH,
5773 IPF_TCPS_CLOSE_WAIT,
5774 ifs->ifs_nat_tqb,
5775 ifs->ifs_nat_utqe,
5776 ifs);
5777 break;
5778
5779 case FLUSH_TABLE_EXTRA:
5780 removed = ipf_flushclosing(NAT_FLUSH,
5781 IPF_TCPS_FIN_WAIT_2,
5782 ifs->ifs_nat_tqb,
5783 ifs->ifs_nat_utqe,
5784 ifs);
5785
5786 /*
5787 * Be sure we haven't done this in the last 10 seconds.
5788 */
5789 if (ifs->ifs_fr_ticks - ifs->ifs_nat_last_force_flush <
5790 IPF_TTLVAL(10))
5791 break;
5792 ifs->ifs_nat_last_force_flush = ifs->ifs_fr_ticks;
5793 removed += ipf_extraflush(NAT_FLUSH,
5794 &ifs->ifs_nat_tqb[IPF_TCPS_ESTABLISHED],
5795 ifs->ifs_nat_utqe,
5796 ifs);
5797 break;
5798
5799 default: /* Flush Nothing */
5800 break;
5801 }
5802
5803 SPL_X(s);
5804 return (removed);
5805 }
5806
5807
5808 /* ------------------------------------------------------------------------ */
5809 /* Function: nat_uncreate */
5810 /* Returns: Nil */
5811 /* Parameters: fin(I) - pointer to packet information */
5812 /* */
5813 /* This function is used to remove a NAT entry from the NAT table when we */
5814 /* decide that the create was actually in error. It is thus assumed that */
5815 /* fin_flx will have both FI_NATED and FI_NATNEW set. Because we're dealing */
5816 /* with the translated packet (not the original), we have to reverse the */
5817 /* lookup. Although doing the lookup is expensive (relatively speaking), it */
5818 /* is not anticipated that this will be a frequent occurance for normal */
5819 /* traffic patterns. */
5820 /* ------------------------------------------------------------------------ */
5821 void nat_uncreate(fin)
5822 fr_info_t *fin;
5823 {
5824 ipf_stack_t *ifs = fin->fin_ifs;
5825 int nflags;
5826 nat_t *nat;
5827
5828 switch (fin->fin_p)
5829 {
5830 case IPPROTO_TCP :
5831 nflags = IPN_TCP;
5832 break;
5833 case IPPROTO_UDP :
5834 nflags = IPN_UDP;
5835 break;
5836 default :
5837 nflags = 0;
5838 break;
5839 }
5840
5841 WRITE_ENTER(&ifs->ifs_ipf_nat);
5842
5843 if (fin->fin_out == 0) {
5844 nat = nat_outlookup(fin, nflags, (u_int)fin->fin_p,
5845 fin->fin_dst, fin->fin_src);
5846 } else {
5847 nat = nat_inlookup(fin, nflags, (u_int)fin->fin_p,
5848 fin->fin_src, fin->fin_dst);
5849 }
5850
5851 if (nat != NULL) {
5852 ifs->ifs_nat_stats.ns_uncreate[fin->fin_out][0]++;
5853 (void) nat_delete(nat, NL_DESTROY, ifs);
5854 } else {
5855 ifs->ifs_nat_stats.ns_uncreate[fin->fin_out][1]++;
5856 }
5857
5858 RWLOCK_EXIT(&ifs->ifs_ipf_nat);
5859 }
Community developed and maintained version of the OS/Net consolidation