sys/net/libalias/alias.c

   1 /*-
   2  * Copyright (c) 2001 Charles Mott <cm@linktel.net>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *      notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *      notice, this list of conditions and the following disclaimer in the
  12  *      documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 /*
  31         Alias.c provides supervisory control for the functions of the
  32         packet aliasing software.  It consists of routines to monitor
  33         TCP connection state, protocol-specific aliasing routines,
  34         fragment handling and the following outside world functional
  35         interfaces: SaveFragmentPtr, GetFragmentPtr, FragmentAliasIn,
  36         PacketAliasIn and PacketAliasOut.
  37
  38         The other C program files are briefly described. The data
  39         structure framework which holds information needed to translate
  40         packets is encapsulated in alias_db.c.  Data is accessed by
  41         function calls, so other segments of the program need not know
  42         about the underlying data structures.  Alias_ftp.c contains
  43         special code for modifying the ftp PORT command used to establish
  44         data connections, while alias_irc.c does the same for IRC
  45         DCC. Alias_util.c contains a few utility routines.
  46
  47         Version 1.0 August, 1996  (cjm)
  48
  49         Version 1.1 August 20, 1996  (cjm)
  50         PPP host accepts incoming connections for ports 0 to 1023.
  51         (Gary Roberts pointed out the need to handle incoming
  52          connections.)
  53
  54         Version 1.2 September 7, 1996 (cjm)
  55         Fragment handling error in alias_db.c corrected.
  56         (Tom Torrance helped fix this problem.)
  57
  58         Version 1.4 September 16, 1996 (cjm)
  59         - A more generalized method for handling incoming
  60           connections, without the 0-1023 restriction, is
  61           implemented in alias_db.c
  62         - Improved ICMP support in alias.c.  Traceroute
  63           packet streams can now be correctly aliased.
  64         - TCP connection closing logic simplified in
  65           alias.c and now allows for additional 1 minute
  66           "grace period" after FIN or RST is observed.
  67
  68         Version 1.5 September 17, 1996 (cjm)
  69         Corrected error in handling incoming UDP packets with 0 checksum.
  70         (Tom Torrance helped fix this problem.)
  71
  72         Version 1.6 September 18, 1996 (cjm)
  73         Simplified ICMP aliasing scheme.  Should now support
  74         traceroute from Win95 as well as FreeBSD.
  75
  76         Version 1.7 January 9, 1997 (cjm)
  77         - Out-of-order fragment handling.
  78         - IP checksum error fixed for ftp transfers
  79           from aliasing host.
  80         - Integer return codes added to all
  81           aliasing/de-aliasing functions.
  82         - Some obsolete comments cleaned up.
  83         - Differential checksum computations for
  84           IP header (TCP, UDP and ICMP were already
  85           differential).
  86
  87         Version 2.1 May 1997 (cjm)
  88         - Added support for outgoing ICMP error
  89           messages.
  90         - Added two functions PacketAliasIn2()
  91           and PacketAliasOut2() for dynamic address
  92           control (e.g. round-robin allocation of
  93           incoming packets).
  94
  95         Version 2.2 July 1997 (cjm)
  96         - Rationalized API function names to begin
  97           with "PacketAlias..."
  98         - Eliminated PacketAliasIn2() and
  99           PacketAliasOut2() as poorly conceived.
 100
 101         Version 2.3 Dec 1998 (dillon)
 102         - Major bounds checking additions, see FreeBSD/CVS
 103
 104         Version 3.1 May, 2000 (salander)
 105         - Added hooks to handle PPTP.
 106
 107         Version 3.2 July, 2000 (salander and satoh)
 108         - Added PacketUnaliasOut routine.
 109         - Added hooks to handle RTSP/RTP.
 110
 111         See HISTORY file for additional revisions.
 112 */
 113
 114 #include <sys/param.h>
 115 #include <sys/systm.h>
 116 #include <sys/mbuf.h>
 117
 118 #include <netinet/in_systm.h>
 119 #include <netinet/in.h>
 120 #include <netinet/ip.h>
 121 #include <netinet/ip_icmp.h>
 122 #include <netinet/tcp.h>
 123 #include <netinet/udp.h>
 124
 125 #include "alias.h"
 126 #include "alias_local.h"
 127 #include "alias_mod.h"
 128
 129 static __inline int
 130 twowords(void *p)
 131 {
 132         uint8_t *c = p;
 133
 134 #if BYTE_ORDER == LITTLE_ENDIAN
 135         uint16_t s1 = ((uint16_t)c[1] << 8) + (uint16_t)c[0];
 136         uint16_t s2 = ((uint16_t)c[3] << 8) + (uint16_t)c[2];
 137 #else
 138         uint16_t s1 = ((uint16_t)c[0] << 8) + (uint16_t)c[1];
 139         uint16_t s2 = ((uint16_t)c[2] << 8) + (uint16_t)c[3];
 140 #endif
 141         return (s1 + s2);
 142 }
 143
 144 /* TCP Handling Routines
 145
 146         TcpMonitorIn()  -- These routines monitor TCP connections, and
 147         TcpMonitorOut() delete a link when a connection is closed.
 148
 149 These routines look for SYN, FIN and RST flags to determine when TCP
 150 connections open and close.  When a TCP connection closes, the data
 151 structure containing packet aliasing information is deleted after
 152 a timeout period.
 153 */
 154
 155 /* Local prototypes */
 156 static void     TcpMonitorIn(struct ip *, struct alias_link *);
 157
 158 static void     TcpMonitorOut(struct ip *, struct alias_link *);
 159
 160
 161 static void
 162 TcpMonitorIn(struct ip *pip, struct alias_link *lnk)
 163 {
 164         struct tcphdr *tc;
 165
 166         tc = (struct tcphdr *)ip_next(pip);
 167
 168         switch (GetStateIn(lnk)) {
 169         case ALIAS_TCP_STATE_NOT_CONNECTED:
 170                 if (tc->th_flags & TH_RST)
 171                         SetStateIn(lnk, ALIAS_TCP_STATE_DISCONNECTED);
 172                 else if (tc->th_flags & TH_SYN)
 173                         SetStateIn(lnk, ALIAS_TCP_STATE_CONNECTED);
 174                 break;
 175         case ALIAS_TCP_STATE_CONNECTED:
 176                 if (tc->th_flags & (TH_FIN | TH_RST))
 177                         SetStateIn(lnk, ALIAS_TCP_STATE_DISCONNECTED);
 178                 break;
 179         }
 180 }
 181
 182 static void
 183 TcpMonitorOut(struct ip *pip, struct alias_link *lnk)
 184 {
 185         struct tcphdr *tc;
 186
 187         tc = (struct tcphdr *)ip_next(pip);
 188
 189         switch (GetStateOut(lnk)) {
 190         case ALIAS_TCP_STATE_NOT_CONNECTED:
 191                 if (tc->th_flags & TH_RST)
 192                         SetStateOut(lnk, ALIAS_TCP_STATE_DISCONNECTED);
 193                 else if (tc->th_flags & TH_SYN)
 194                         SetStateOut(lnk, ALIAS_TCP_STATE_CONNECTED);
 195                 break;
 196         case ALIAS_TCP_STATE_CONNECTED:
 197                 if (tc->th_flags & (TH_FIN | TH_RST))
 198                         SetStateOut(lnk, ALIAS_TCP_STATE_DISCONNECTED);
 199                 break;
 200         }
 201 }
 202
 203
 204
 205
 206
 207 /* Protocol Specific Packet Aliasing Routines
 208
 209         IcmpAliasIn(), IcmpAliasIn1(), IcmpAliasIn2()
 210         IcmpAliasOut(), IcmpAliasOut1(), IcmpAliasOut2()
 211         ProtoAliasIn(), ProtoAliasOut()
 212         UdpAliasIn(), UdpAliasOut()
 213         TcpAliasIn(), TcpAliasOut()
 214
 215 These routines handle protocol specific details of packet aliasing.
 216 One may observe a certain amount of repetitive arithmetic in these
 217 functions, the purpose of which is to compute a revised checksum
 218 without actually summing over the entire data packet, which could be
 219 unnecessarily time consuming.
 220
 221 The purpose of the packet aliasing routines is to replace the source
 222 address of the outgoing packet and then correctly put it back for
 223 any incoming packets.  For TCP and UDP, ports are also re-mapped.
 224
 225 For ICMP echo/timestamp requests and replies, the following scheme
 226 is used: the ID number is replaced by an alias for the outgoing
 227 packet.
 228
 229 ICMP error messages are handled by looking at the IP fragment
 230 in the data section of the message.
 231
 232 For TCP and UDP protocols, a port number is chosen for an outgoing
 233 packet, and then incoming packets are identified by IP address and
 234 port numbers.  For TCP packets, there is additional logic in the event
 235 that sequence and ACK numbers have been altered (as in the case for
 236 FTP data port commands).
 237
 238 The port numbers used by the packet aliasing module are not true
 239 ports in the Unix sense.  No sockets are actually bound to ports.
 240 They are more correctly thought of as placeholders.
 241
 242 All packets go through the aliasing mechanism, whether they come from
 243 the gateway machine or other machines on a local area network.
 244 */
 245
 246
 247 /* Local prototypes */
 248 static int      IcmpAliasIn1(struct libalias *, struct ip *);
 249 static int      IcmpAliasIn2(struct libalias *, struct ip *);
 250 static int      IcmpAliasIn(struct libalias *, struct ip *);
 251
 252 static int      IcmpAliasOut1(struct libalias *, struct ip *, int create);
 253 static int      IcmpAliasOut2(struct libalias *, struct ip *);
 254 static int      IcmpAliasOut(struct libalias *, struct ip *, int create);
 255
 256 static int      ProtoAliasIn(struct libalias *, struct ip *);
 257 static int      ProtoAliasOut(struct libalias *, struct ip *, int create);
 258
 259 static int      UdpAliasIn(struct libalias *, struct ip *);
 260 static int      UdpAliasOut(struct libalias *, struct ip *, int create);
 261
 262 static int      TcpAliasIn(struct libalias *, struct ip *);
 263 static int      TcpAliasOut(struct libalias *, struct ip *, int, int create);
 264
 265
 266 static int
 267 IcmpAliasIn1(struct libalias *la, struct ip *pip)
 268 {
 269
 270         LIBALIAS_LOCK_ASSERT(la);
 271 /*
 272         De-alias incoming echo and timestamp replies.
 273         Alias incoming echo and timestamp requests.
 274 */
 275         struct alias_link *lnk;
 276         struct icmp *ic;
 277
 278         ic = (struct icmp *)ip_next(pip);
 279
 280 /* Get source address from ICMP data field and restore original data */
 281         lnk = FindIcmpIn(la, pip->ip_src, pip->ip_dst, ic->icmp_id, 1);
 282         if (lnk != NULL) {
 283                 u_short original_id;
 284                 int accumulate;
 285
 286                 original_id = GetOriginalPort(lnk);
 287
 288 /* Adjust ICMP checksum */
 289                 accumulate = ic->icmp_id;
 290                 accumulate -= original_id;
 291                 ADJUST_CHECKSUM(accumulate, ic->icmp_cksum);
 292
 293 /* Put original sequence number back in */
 294                 ic->icmp_id = original_id;
 295
 296 /* Put original address back into IP header */
 297                 {
 298                         struct in_addr original_address;
 299
 300                         original_address = GetOriginalAddress(lnk);
 301                         DifferentialChecksum(&pip->ip_sum,
 302                                 &original_address, &pip->ip_dst, 2);
 303                         pip->ip_dst = original_address;
 304                 }
 305
 306                 return (PKT_ALIAS_OK);
 307         }
 308         return (PKT_ALIAS_IGNORED);
 309 }
 310
 311 static int
 312 IcmpAliasIn2(struct libalias *la, struct ip *pip)
 313 {
 314
 315         LIBALIAS_LOCK_ASSERT(la);
 316 /*
 317         Alias incoming ICMP error messages containing
 318         IP header and first 64 bits of datagram.
 319 */
 320         struct ip *ip;
 321         struct icmp *ic, *ic2;
 322         struct udphdr *ud;
 323         struct tcphdr *tc;
 324         struct alias_link *lnk;
 325
 326         ic = (struct icmp *)ip_next(pip);
 327         ip = &ic->icmp_ip;
 328
 329         ud = (struct udphdr *)ip_next(ip);
 330         tc = (struct tcphdr *)ip_next(ip);
 331         ic2 = (struct icmp *)ip_next(ip);
 332
 333         if (ip->ip_p == IPPROTO_UDP)
 334                 lnk = FindUdpTcpIn(la, ip->ip_dst, ip->ip_src,
 335                         ud->uh_dport, ud->uh_sport,
 336                         IPPROTO_UDP, 0);
 337         else if (ip->ip_p == IPPROTO_TCP)
 338                 lnk = FindUdpTcpIn(la, ip->ip_dst, ip->ip_src,
 339                         tc->th_dport, tc->th_sport,
 340                         IPPROTO_TCP, 0);
 341         else if (ip->ip_p == IPPROTO_ICMP) {
 342                 if (ic2->icmp_type == ICMP_ECHO || ic2->icmp_type == ICMP_TSTAMP)
 343                         lnk = FindIcmpIn(la, ip->ip_dst, ip->ip_src, ic2->icmp_id, 0);
 344                 else
 345                         lnk = NULL;
 346         } else
 347                 lnk = NULL;
 348
 349         if (lnk != NULL) {
 350                 if (ip->ip_p == IPPROTO_UDP || ip->ip_p == IPPROTO_TCP) {
 351                         int accumulate, accumulate2;
 352                         struct in_addr original_address;
 353                         u_short original_port;
 354
 355                         original_address = GetOriginalAddress(lnk);
 356                         original_port = GetOriginalPort(lnk);
 357
 358 /* Adjust ICMP checksum */
 359                         accumulate = twowords(&ip->ip_src);
 360                         accumulate -= twowords(&original_address);
 361                         accumulate += ud->uh_sport;
 362                         accumulate -= original_port;
 363                         accumulate2 = accumulate;
 364                         accumulate2 += ip->ip_sum;
 365                         ADJUST_CHECKSUM(accumulate, ip->ip_sum);
 366                         accumulate2 -= ip->ip_sum;
 367                         ADJUST_CHECKSUM(accumulate2, ic->icmp_cksum);
 368
 369 /* Un-alias address in IP header */
 370                         DifferentialChecksum(&pip->ip_sum,
 371                                 &original_address, &pip->ip_dst, 2);
 372                         pip->ip_dst = original_address;
 373
 374 /* Un-alias address and port number of original IP packet
 375 fragment contained in ICMP data section */
 376                         ip->ip_src = original_address;
 377                         ud->uh_sport = original_port;
 378                 } else if (ip->ip_p == IPPROTO_ICMP) {
 379                         int accumulate, accumulate2;
 380                         struct in_addr original_address;
 381                         u_short original_id;
 382
 383                         original_address = GetOriginalAddress(lnk);
 384                         original_id = GetOriginalPort(lnk);
 385
 386 /* Adjust ICMP checksum */
 387                         accumulate = twowords(&ip->ip_src);
 388                         accumulate -= twowords(&original_address);
 389                         accumulate += ic2->icmp_id;
 390                         accumulate -= original_id;
 391                         accumulate2 = accumulate;
 392                         accumulate2 += ip->ip_sum;
 393                         ADJUST_CHECKSUM(accumulate, ip->ip_sum);
 394                         accumulate2 -= ip->ip_sum;
 395                         ADJUST_CHECKSUM(accumulate2, ic->icmp_cksum);
 396
 397 /* Un-alias address in IP header */
 398                         DifferentialChecksum(&pip->ip_sum,
 399                                 &original_address, &pip->ip_dst, 2);
 400                         pip->ip_dst = original_address;
 401
 402 /* Un-alias address of original IP packet and sequence number of
 403    embedded ICMP datagram */
 404                         ip->ip_src = original_address;
 405                         ic2->icmp_id = original_id;
 406                 }
 407                 return (PKT_ALIAS_OK);
 408         }
 409         return (PKT_ALIAS_IGNORED);
 410 }
 411
 412
 413 static int
 414 IcmpAliasIn(struct libalias *la, struct ip *pip)
 415 {
 416         int iresult;
 417         struct icmp *ic;
 418
 419         LIBALIAS_LOCK_ASSERT(la);
 420 /* Return if proxy-only mode is enabled */
 421         if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)
 422                 return (PKT_ALIAS_OK);
 423
 424         ic = (struct icmp *)ip_next(pip);
 425
 426         iresult = PKT_ALIAS_IGNORED;
 427         switch (ic->icmp_type) {
 428         case ICMP_ECHOREPLY:
 429         case ICMP_TSTAMPREPLY:
 430                 if (ic->icmp_code == 0) {
 431                         iresult = IcmpAliasIn1(la, pip);
 432                 }
 433                 break;
 434         case ICMP_UNREACH:
 435         case ICMP_SOURCEQUENCH:
 436         case ICMP_TIMXCEED:
 437         case ICMP_PARAMPROB:
 438                 iresult = IcmpAliasIn2(la, pip);
 439                 break;
 440         case ICMP_ECHO:
 441         case ICMP_TSTAMP:
 442                 iresult = IcmpAliasIn1(la, pip);
 443                 break;
 444         }
 445         return (iresult);
 446 }
 447
 448
 449 static int
 450 IcmpAliasOut1(struct libalias *la, struct ip *pip, int create)
 451 {
 452 /*
 453         Alias outgoing echo and timestamp requests.
 454         De-alias outgoing echo and timestamp replies.
 455 */
 456         struct alias_link *lnk;
 457         struct icmp *ic;
 458
 459         LIBALIAS_LOCK_ASSERT(la);
 460         ic = (struct icmp *)ip_next(pip);
 461
 462 /* Save overwritten data for when echo packet returns */
 463         lnk = FindIcmpOut(la, pip->ip_src, pip->ip_dst, ic->icmp_id, create);
 464         if (lnk != NULL) {
 465                 u_short alias_id;
 466                 int accumulate;
 467
 468                 alias_id = GetAliasPort(lnk);
 469
 470 /* Since data field is being modified, adjust ICMP checksum */
 471                 accumulate = ic->icmp_id;
 472                 accumulate -= alias_id;
 473                 ADJUST_CHECKSUM(accumulate, ic->icmp_cksum);
 474
 475 /* Alias sequence number */
 476                 ic->icmp_id = alias_id;
 477
 478 /* Change source address */
 479                 {
 480                         struct in_addr alias_address;
 481
 482                         alias_address = GetAliasAddress(lnk);
 483                         DifferentialChecksum(&pip->ip_sum,
 484                                 &alias_address, &pip->ip_src, 2);
 485                         pip->ip_src = alias_address;
 486                 }
 487
 488                 return (PKT_ALIAS_OK);
 489         }
 490         return (PKT_ALIAS_IGNORED);
 491 }
 492
 493
 494 static int
 495 IcmpAliasOut2(struct libalias *la, struct ip *pip)
 496 {
 497 /*
 498         Alias outgoing ICMP error messages containing
 499         IP header and first 64 bits of datagram.
 500 */
 501         struct ip *ip;
 502         struct icmp *ic, *ic2;
 503         struct udphdr *ud;
 504         struct tcphdr *tc;
 505         struct alias_link *lnk;
 506
 507         LIBALIAS_LOCK_ASSERT(la);
 508         ic = (struct icmp *)ip_next(pip);
 509         ip = &ic->icmp_ip;
 510
 511         ud = (struct udphdr *)ip_next(ip);
 512         tc = (struct tcphdr *)ip_next(ip);
 513         ic2 = (struct icmp *)ip_next(ip);
 514
 515         if (ip->ip_p == IPPROTO_UDP)
 516                 lnk = FindUdpTcpOut(la, ip->ip_dst, ip->ip_src,
 517                         ud->uh_dport, ud->uh_sport,
 518                         IPPROTO_UDP, 0);
 519         else if (ip->ip_p == IPPROTO_TCP)
 520                 lnk = FindUdpTcpOut(la, ip->ip_dst, ip->ip_src,
 521                         tc->th_dport, tc->th_sport,
 522                         IPPROTO_TCP, 0);
 523         else if (ip->ip_p == IPPROTO_ICMP) {
 524                 if (ic2->icmp_type == ICMP_ECHO || ic2->icmp_type == ICMP_TSTAMP)
 525                         lnk = FindIcmpOut(la, ip->ip_dst, ip->ip_src, ic2->icmp_id, 0);
 526                 else
 527                         lnk = NULL;
 528         } else
 529                 lnk = NULL;
 530
 531         if (lnk != NULL) {
 532                 if (ip->ip_p == IPPROTO_UDP || ip->ip_p == IPPROTO_TCP) {
 533                         int accumulate;
 534                         struct in_addr alias_address;
 535                         u_short alias_port;
 536
 537                         alias_address = GetAliasAddress(lnk);
 538                         alias_port = GetAliasPort(lnk);
 539
 540 /* Adjust ICMP checksum */
 541                         accumulate = twowords(&ip->ip_dst);
 542                         accumulate -= twowords(&alias_address);
 543                         accumulate += ud->uh_dport;
 544                         accumulate -= alias_port;
 545                         ADJUST_CHECKSUM(accumulate, ic->icmp_cksum);
 546
 547 /*
 548  * Alias address in IP header if it comes from the host
 549  * the original TCP/UDP packet was destined for.
 550  */
 551                         if (pip->ip_src.s_addr == ip->ip_dst.s_addr) {
 552                                 DifferentialChecksum(&pip->ip_sum,
 553                                         &alias_address, &pip->ip_src, 2);
 554                                 pip->ip_src = alias_address;
 555                         }
 556 /* Alias address and port number of original IP packet
 557 fragment contained in ICMP data section */
 558                         ip->ip_dst = alias_address;
 559                         ud->uh_dport = alias_port;
 560                 } else if (ip->ip_p == IPPROTO_ICMP) {
 561                         int accumulate;
 562                         struct in_addr alias_address;
 563                         u_short alias_id;
 564
 565                         alias_address = GetAliasAddress(lnk);
 566                         alias_id = GetAliasPort(lnk);
 567
 568 /* Adjust ICMP checksum */
 569                         accumulate = twowords(&ip->ip_dst);
 570                         accumulate -= twowords(&alias_address);
 571                         accumulate += ic2->icmp_id;
 572                         accumulate -= alias_id;
 573                         ADJUST_CHECKSUM(accumulate, ic->icmp_cksum);
 574
 575 /*
 576  * Alias address in IP header if it comes from the host
 577  * the original ICMP message was destined for.
 578  */
 579                         if (pip->ip_src.s_addr == ip->ip_dst.s_addr) {
 580                                 DifferentialChecksum(&pip->ip_sum,
 581                                         &alias_address, &pip->ip_src, 2);
 582                                 pip->ip_src = alias_address;
 583                         }
 584 /* Alias address of original IP packet and sequence number of
 585    embedded ICMP datagram */
 586                         ip->ip_dst = alias_address;
 587                         ic2->icmp_id = alias_id;
 588                 }
 589                 return (PKT_ALIAS_OK);
 590         }
 591         return (PKT_ALIAS_IGNORED);
 592 }
 593
 594
 595 static int
 596 IcmpAliasOut(struct libalias *la, struct ip *pip, int create)
 597 {
 598         int iresult;
 599         struct icmp *ic;
 600
 601         LIBALIAS_LOCK_ASSERT(la);
 602         (void)create;
 603
 604 /* Return if proxy-only mode is enabled */
 605         if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)
 606                 return (PKT_ALIAS_OK);
 607
 608         ic = (struct icmp *)ip_next(pip);
 609
 610         iresult = PKT_ALIAS_IGNORED;
 611         switch (ic->icmp_type) {
 612         case ICMP_ECHO:
 613         case ICMP_TSTAMP:
 614                 if (ic->icmp_code == 0) {
 615                         iresult = IcmpAliasOut1(la, pip, create);
 616                 }
 617                 break;
 618         case ICMP_UNREACH:
 619         case ICMP_SOURCEQUENCH:
 620         case ICMP_TIMXCEED:
 621         case ICMP_PARAMPROB:
 622                 iresult = IcmpAliasOut2(la, pip);
 623                 break;
 624         case ICMP_ECHOREPLY:
 625         case ICMP_TSTAMPREPLY:
 626                 iresult = IcmpAliasOut1(la, pip, create);
 627         }
 628         return (iresult);
 629 }
 630
 631
 632
 633 static int
 634 ProtoAliasIn(struct libalias *la, struct ip *pip)
 635 {
 636 /*
 637   Handle incoming IP packets. The
 638   only thing which is done in this case is to alias
 639   the dest IP address of the packet to our inside
 640   machine.
 641 */
 642         struct alias_link *lnk;
 643
 644         LIBALIAS_LOCK_ASSERT(la);
 645 /* Return if proxy-only mode is enabled */
 646         if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)
 647                 return (PKT_ALIAS_OK);
 648
 649         lnk = FindProtoIn(la, pip->ip_src, pip->ip_dst, pip->ip_p);
 650         if (lnk != NULL) {
 651                 struct in_addr original_address;
 652
 653                 original_address = GetOriginalAddress(lnk);
 654
 655 /* Restore original IP address */
 656                 DifferentialChecksum(&pip->ip_sum,
 657                         &original_address, &pip->ip_dst, 2);
 658                 pip->ip_dst = original_address;
 659
 660                 return (PKT_ALIAS_OK);
 661         }
 662         return (PKT_ALIAS_IGNORED);
 663 }
 664
 665
 666 static int
 667 ProtoAliasOut(struct libalias *la, struct ip *pip, int create)
 668 {
 669 /*
 670   Handle outgoing IP packets. The
 671   only thing which is done in this case is to alias
 672   the source IP address of the packet.
 673 */
 674         struct alias_link *lnk;
 675
 676         LIBALIAS_LOCK_ASSERT(la);
 677         (void)create;
 678
 679 /* Return if proxy-only mode is enabled */
 680         if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)
 681                 return (PKT_ALIAS_OK);
 682
 683         lnk = FindProtoOut(la, pip->ip_src, pip->ip_dst, pip->ip_p);
 684         if (lnk != NULL) {
 685                 struct in_addr alias_address;
 686
 687                 alias_address = GetAliasAddress(lnk);
 688
 689 /* Change source address */
 690                 DifferentialChecksum(&pip->ip_sum,
 691                         &alias_address, &pip->ip_src, 2);
 692                 pip->ip_src = alias_address;
 693
 694                 return (PKT_ALIAS_OK);
 695         }
 696         return (PKT_ALIAS_IGNORED);
 697 }
 698
 699
 700 static int
 701 UdpAliasIn(struct libalias *la, struct ip *pip)
 702 {
 703         struct udphdr *ud;
 704         struct alias_link *lnk;
 705
 706         LIBALIAS_LOCK_ASSERT(la);
 707 /* Return if proxy-only mode is enabled */
 708         if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)
 709                 return (PKT_ALIAS_OK);
 710
 711         ud = (struct udphdr *)ip_next(pip);
 712
 713         lnk = FindUdpTcpIn(la, pip->ip_src, pip->ip_dst,
 714                 ud->uh_sport, ud->uh_dport,
 715                 IPPROTO_UDP, 1);
 716         if (lnk != NULL) {
 717                 struct in_addr alias_address;
 718                 struct in_addr original_address;
 719                 u_short alias_port;
 720                 int accumulate;
 721                 int r = 0, error;
 722                 struct alias_data ad = {
 723                         .lnk = lnk,
 724                         .oaddr = &original_address,
 725                         .aaddr = &alias_address,
 726                         .aport = &alias_port,
 727                         .sport = &ud->uh_sport,
 728                         .dport = &ud->uh_dport,
 729                         .maxpktsize = 0
 730                 };
 731
 732                 alias_address = GetAliasAddress(lnk);
 733                 original_address = GetOriginalAddress(lnk);
 734                 alias_port = ud->uh_dport;
 735                 ud->uh_dport = GetOriginalPort(lnk);
 736
 737                 /* Walk out chain. */
 738                 error = find_handler(IN, UDP, la, pip, &ad);
 739
 740 /* If UDP checksum is not zero, then adjust since destination port */
 741 /* is being unaliased and destination address is being altered. */
 742                 if (ud->uh_sum != 0) {
 743                         accumulate = alias_port;
 744                         accumulate -= ud->uh_dport;
 745                         accumulate += twowords(&alias_address);
 746                         accumulate -= twowords(&original_address);
 747                         ADJUST_CHECKSUM(accumulate, ud->uh_sum);
 748                 }
 749 /* Restore original IP address */
 750                 DifferentialChecksum(&pip->ip_sum,
 751                         &original_address, &pip->ip_dst, 2);
 752                 pip->ip_dst = original_address;
 753
 754                 /*
 755                  * If we cannot figure out the packet, ignore it.
 756                  */
 757                 if (r < 0)
 758                         return (PKT_ALIAS_IGNORED);
 759                 else
 760                         return (PKT_ALIAS_OK);
 761         }
 762         return (PKT_ALIAS_IGNORED);
 763 }
 764
 765 static int
 766 UdpAliasOut(struct libalias *la, struct ip *pip, int create)
 767 {
 768         struct udphdr *ud;
 769         struct alias_link *lnk;
 770         int error;
 771
 772         LIBALIAS_LOCK_ASSERT(la);
 773 /* Return if proxy-only mode is enabled */
 774         if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)
 775                 return (PKT_ALIAS_OK);
 776
 777         ud = (struct udphdr *)ip_next(pip);
 778
 779         lnk = FindUdpTcpOut(la, pip->ip_src, pip->ip_dst,
 780                 ud->uh_sport, ud->uh_dport,
 781                 IPPROTO_UDP, create);
 782         if (lnk != NULL) {
 783                 u_short alias_port;
 784                 struct in_addr alias_address;
 785                 struct alias_data ad = {
 786                         .lnk = lnk,
 787                         .oaddr = NULL,
 788                         .aaddr = &alias_address,
 789                         .aport = &alias_port,
 790                         .sport = &ud->uh_sport,
 791                         .dport = &ud->uh_dport,
 792                         .maxpktsize = 0
 793                 };
 794
 795                 alias_address = GetAliasAddress(lnk);
 796                 alias_port = GetAliasPort(lnk);
 797
 798                 /* Walk out chain. */
 799                 error = find_handler(OUT, UDP, la, pip, &ad);
 800
 801 /* If UDP checksum is not zero, adjust since source port is */
 802 /* being aliased and source address is being altered            */
 803                 if (ud->uh_sum != 0) {
 804                         int accumulate;
 805
 806                         accumulate = ud->uh_sport;
 807                         accumulate -= alias_port;
 808                         accumulate += twowords(&pip->ip_src);
 809                         accumulate -= twowords(&alias_address);
 810                         ADJUST_CHECKSUM(accumulate, ud->uh_sum);
 811                 }
 812 /* Put alias port in UDP header */
 813                 ud->uh_sport = alias_port;
 814
 815 /* Change source address */
 816                 DifferentialChecksum(&pip->ip_sum,
 817                         &alias_address, &pip->ip_src, 2);
 818                 pip->ip_src = alias_address;
 819
 820                 return (PKT_ALIAS_OK);
 821         }
 822         return (PKT_ALIAS_IGNORED);
 823 }
 824
 825
 826
 827 static int
 828 TcpAliasIn(struct libalias *la, struct ip *pip)
 829 {
 830         struct tcphdr *tc;
 831         struct alias_link *lnk;
 832
 833         LIBALIAS_LOCK_ASSERT(la);
 834         tc = (struct tcphdr *)ip_next(pip);
 835
 836         lnk = FindUdpTcpIn(la, pip->ip_src, pip->ip_dst,
 837                 tc->th_sport, tc->th_dport,
 838                 IPPROTO_TCP,
 839                 !(la->packetAliasMode & PKT_ALIAS_PROXY_ONLY));
 840         if (lnk != NULL) {
 841                 struct in_addr alias_address;
 842                 struct in_addr original_address;
 843                 struct in_addr proxy_address;
 844                 u_short alias_port;
 845                 u_short proxy_port;
 846                 int accumulate, error;
 847
 848                 /*
 849                  * The init of MANY vars is a bit below, but aliashandlepptpin
 850                  * seems to need the destination port that came within the
 851                  * packet and not the original one looks below [*].
 852                  */
 853
 854                 struct alias_data ad = {
 855                         .lnk = lnk,
 856                         .oaddr = NULL,
 857                         .aaddr = NULL,
 858                         .aport = NULL,
 859                         .sport = &tc->th_sport,
 860                         .dport = &tc->th_dport,
 861                         .maxpktsize = 0
 862                 };
 863
 864                 /* Walk out chain. */
 865                 error = find_handler(IN, TCP, la, pip, &ad);
 866
 867                 alias_address = GetAliasAddress(lnk);
 868                 original_address = GetOriginalAddress(lnk);
 869                 proxy_address = GetProxyAddress(lnk);
 870                 alias_port = tc->th_dport;
 871                 tc->th_dport = GetOriginalPort(lnk);
 872                 proxy_port = GetProxyPort(lnk);
 873
 874                 /*
 875                  * Look above, if anyone is going to add find_handler AFTER
 876                  * this aliashandlepptpin/point, please redo alias_data too.
 877                  * Uncommenting the piece here below should be enough.
 878                  */
 879 #if 0
 880                                  struct alias_data ad = {
 881                                         .lnk = lnk,
 882                                         .oaddr = &original_address,
 883                                         .aaddr = &alias_address,
 884                                         .aport = &alias_port,
 885                                         .sport = &ud->uh_sport,
 886                                         .dport = &ud->uh_dport,
 887                                         .maxpktsize = 0
 888                                 };
 889
 890                                 /* Walk out chain. */
 891                                 error = find_handler(la, pip, &ad);
 892                                 if (error == EHDNOF)
 893                                         kprintf("Protocol handler not found\n");
 894 #endif
 895
 896 /* Adjust TCP checksum since destination port is being unaliased */
 897 /* and destination port is being altered.                                               */
 898                 accumulate = alias_port;
 899                 accumulate -= tc->th_dport;
 900                 accumulate += twowords(&alias_address);
 901                 accumulate -= twowords(&original_address);
 902
 903 /* If this is a proxy, then modify the TCP source port and
 904    checksum accumulation */
 905                 if (proxy_port != 0) {
 906                         accumulate += tc->th_sport;
 907                         tc->th_sport = proxy_port;
 908                         accumulate -= tc->th_sport;
 909                         accumulate += twowords(&pip->ip_src);
 910                         accumulate -= twowords(&proxy_address);
 911                 }
 912 /* See if ACK number needs to be modified */
 913                 if (GetAckModified(lnk) == 1) {
 914                         int delta;
 915
 916                         delta = GetDeltaAckIn(pip, lnk);
 917                         if (delta != 0) {
 918                                 accumulate += twowords(&tc->th_ack);
 919                                 tc->th_ack = htonl(ntohl(tc->th_ack) - delta);
 920                                 accumulate -= twowords(&tc->th_ack);
 921                         }
 922                 }
 923                 ADJUST_CHECKSUM(accumulate, tc->th_sum);
 924
 925 /* Restore original IP address */
 926                 accumulate = twowords(&pip->ip_dst);
 927                 pip->ip_dst = original_address;
 928                 accumulate -= twowords(&pip->ip_dst);
 929
 930 /* If this is a transparent proxy packet, then modify the source
 931    address */
 932                 if (proxy_address.s_addr != 0) {
 933                         accumulate += twowords(&pip->ip_src);
 934                         pip->ip_src = proxy_address;
 935                         accumulate -= twowords(&pip->ip_src);
 936                 }
 937                 ADJUST_CHECKSUM(accumulate, pip->ip_sum);
 938
 939 /* Monitor TCP connection state */
 940                 TcpMonitorIn(pip, lnk);
 941
 942                 return (PKT_ALIAS_OK);
 943         }
 944         return (PKT_ALIAS_IGNORED);
 945 }
 946
 947 static int
 948 TcpAliasOut(struct libalias *la, struct ip *pip, int maxpacketsize, int create)
 949 {
 950         int proxy_type, error;
 951         u_short dest_port;
 952         u_short proxy_server_port;
 953         struct in_addr dest_address;
 954         struct in_addr proxy_server_address;
 955         struct tcphdr *tc;
 956         struct alias_link *lnk;
 957
 958         LIBALIAS_LOCK_ASSERT(la);
 959         tc = (struct tcphdr *)ip_next(pip);
 960
 961         if (create)
 962                 proxy_type =
 963                         ProxyCheck(la, pip, &proxy_server_address, &proxy_server_port);
 964         else
 965                 proxy_type = 0;
 966
 967         if (proxy_type == 0 && (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY))
 968                 return (PKT_ALIAS_OK);
 969
 970 /* If this is a transparent proxy, save original destination,
 971    then alter the destination and adjust checksums */
 972         dest_port = tc->th_dport;
 973         dest_address = pip->ip_dst;
 974         if (proxy_type != 0) {
 975                 int accumulate;
 976
 977                 accumulate = tc->th_dport;
 978                 tc->th_dport = proxy_server_port;
 979                 accumulate -= tc->th_dport;
 980                 accumulate += twowords(&pip->ip_dst);
 981                 accumulate -= twowords(&proxy_server_address);
 982                 ADJUST_CHECKSUM(accumulate, tc->th_sum);
 983
 984                 accumulate = twowords(&pip->ip_dst);
 985                 pip->ip_dst = proxy_server_address;
 986                 accumulate -= twowords(&pip->ip_dst);
 987                 ADJUST_CHECKSUM(accumulate, pip->ip_sum);
 988         }
 989         lnk = FindUdpTcpOut(la, pip->ip_src, pip->ip_dst,
 990                 tc->th_sport, tc->th_dport,
 991                 IPPROTO_TCP, create);
 992         if (lnk == NULL)
 993                 return (PKT_ALIAS_IGNORED);
 994         if (lnk != NULL) {
 995                 u_short alias_port;
 996                 struct in_addr alias_address;
 997                 int accumulate;
 998                 struct alias_data ad = {
 999                         .lnk = lnk,
1000                         .oaddr = NULL,
1001                         .aaddr = &alias_address,
1002                         .aport = &alias_port,
1003                         .sport = &tc->th_sport,
1004                         .dport = &tc->th_dport,
1005                         .maxpktsize = maxpacketsize
1006                 };
1007
1008 /* Save original destination address, if this is a proxy packet.
1009    Also modify packet to include destination encoding.  This may
1010    change the size of IP header. */
1011                 if (proxy_type != 0) {
1012                         SetProxyPort(lnk, dest_port);
1013                         SetProxyAddress(lnk, dest_address);
1014                         ProxyModify(la, lnk, pip, maxpacketsize, proxy_type);
1015                         tc = (struct tcphdr *)ip_next(pip);
1016                 }
1017 /* Get alias address and port */
1018                 alias_port = GetAliasPort(lnk);
1019                 alias_address = GetAliasAddress(lnk);
1020
1021 /* Monitor TCP connection state */
1022                 TcpMonitorOut(pip, lnk);
1023
1024                 /* Walk out chain. */
1025                 error = find_handler(OUT, TCP, la, pip, &ad);
1026
1027 /* Adjust TCP checksum since source port is being aliased */
1028 /* and source address is being altered                                  */
1029                 accumulate = tc->th_sport;
1030                 tc->th_sport = alias_port;
1031                 accumulate -= tc->th_sport;
1032                 accumulate += twowords(&pip->ip_src);
1033                 accumulate -= twowords(&alias_address);
1034
1035 /* Modify sequence number if necessary */
1036                 if (GetAckModified(lnk) == 1) {
1037                         int delta;
1038
1039                         delta = GetDeltaSeqOut(pip, lnk);
1040                         if (delta != 0) {
1041                                 accumulate += twowords(&tc->th_seq);
1042                                 tc->th_seq = htonl(ntohl(tc->th_seq) + delta);
1043                                 accumulate -= twowords(&tc->th_seq);
1044                         }
1045                 }
1046                 ADJUST_CHECKSUM(accumulate, tc->th_sum);
1047
1048 /* Change source address */
1049                 accumulate = twowords(&pip->ip_src);
1050                 pip->ip_src = alias_address;
1051                 accumulate -= twowords(&pip->ip_src);
1052                 ADJUST_CHECKSUM(accumulate, pip->ip_sum);
1053
1054                 return (PKT_ALIAS_OK);
1055         }
1056         return (PKT_ALIAS_IGNORED);
1057 }
1058
1059
1060
1061
1062 /* Fragment Handling
1063
1064         FragmentIn()
1065         FragmentOut()
1066
1067 The packet aliasing module has a limited ability for handling IP
1068 fragments.  If the ICMP, TCP or UDP header is in the first fragment
1069 received, then the ID number of the IP packet is saved, and other
1070 fragments are identified according to their ID number and IP address
1071 they were sent from.  Pointers to unresolved fragments can also be
1072 saved and recalled when a header fragment is seen.
1073 */
1074
1075 /* Local prototypes */
1076 static int      FragmentIn(struct libalias *, struct ip *);
1077 static int      FragmentOut(struct libalias *, struct ip *);
1078
1079
1080 static int
1081 FragmentIn(struct libalias *la, struct ip *pip)
1082 {
1083         struct alias_link *lnk;
1084
1085         LIBALIAS_LOCK_ASSERT(la);
1086         lnk = FindFragmentIn2(la, pip->ip_src, pip->ip_dst, pip->ip_id);
1087         if (lnk != NULL) {
1088                 struct in_addr original_address;
1089
1090                 GetFragmentAddr(lnk, &original_address);
1091                 DifferentialChecksum(&pip->ip_sum,
1092                         &original_address, &pip->ip_dst, 2);
1093                 pip->ip_dst = original_address;
1094
1095                 return (PKT_ALIAS_OK);
1096         }
1097         return (PKT_ALIAS_UNRESOLVED_FRAGMENT);
1098 }
1099
1100
1101 static int
1102 FragmentOut(struct libalias *la, struct ip *pip)
1103 {
1104         struct in_addr alias_address;
1105
1106         LIBALIAS_LOCK_ASSERT(la);
1107         alias_address = FindAliasAddress(la, pip->ip_src);
1108         DifferentialChecksum(&pip->ip_sum,
1109                 &alias_address, &pip->ip_src, 2);
1110         pip->ip_src = alias_address;
1111
1112         return (PKT_ALIAS_OK);
1113 }
1114
1115
1116
1117
1118
1119
1120 /* Outside World Access
1121
1122         PacketAliasSaveFragment()
1123         PacketAliasGetFragment()
1124         PacketAliasFragmentIn()
1125         PacketAliasIn()
1126         PacketAliasOut()
1127         PacketUnaliasOut()
1128
1129 (prototypes in alias.h)
1130 */
1131
1132
1133 int
1134 LibAliasSaveFragment(struct libalias *la, char *ptr)
1135 {
1136         int iresult;
1137         struct alias_link *lnk;
1138         struct ip *pip;
1139
1140         LIBALIAS_LOCK(la);
1141         pip = (struct ip *)ptr;
1142         lnk = AddFragmentPtrLink(la, pip->ip_src, pip->ip_id);
1143         iresult = PKT_ALIAS_ERROR;
1144         if (lnk != NULL) {
1145                 SetFragmentPtr(lnk, ptr);
1146                 iresult = PKT_ALIAS_OK;
1147         }
1148         LIBALIAS_UNLOCK(la);
1149         return (iresult);
1150 }
1151
1152
1153 char               *
1154 LibAliasGetFragment(struct libalias *la, char *ptr)
1155 {
1156         struct alias_link *lnk;
1157         char *fptr;
1158         struct ip *pip;
1159
1160         LIBALIAS_LOCK(la);
1161         pip = (struct ip *)ptr;
1162         lnk = FindFragmentPtr(la, pip->ip_src, pip->ip_id);
1163         if (lnk != NULL) {
1164                 GetFragmentPtr(lnk, &fptr);
1165                 SetFragmentPtr(lnk, NULL);
1166                 SetExpire(lnk, 0);      /* Deletes link */
1167         } else
1168                 fptr = NULL;
1169
1170         LIBALIAS_UNLOCK(la);
1171         return (fptr);
1172 }
1173
1174
1175 void
1176 LibAliasFragmentIn(struct libalias *la, char *ptr,      /* Points to correctly
1177                                                          * de-aliased header
1178                                                          * fragment */
1179         char *ptr_fragment              /* Points to fragment which must be
1180                                  * de-aliased   */
1181 )
1182 {
1183         struct ip *pip;
1184         struct ip *fpip;
1185
1186         LIBALIAS_LOCK(la);
1187         (void)la;
1188         pip = (struct ip *)ptr;
1189         fpip = (struct ip *)ptr_fragment;
1190
1191         DifferentialChecksum(&fpip->ip_sum,
1192                 &pip->ip_dst, &fpip->ip_dst, 2);
1193         fpip->ip_dst = pip->ip_dst;
1194         LIBALIAS_UNLOCK(la);
1195 }
1196
1197 /* Local prototypes */
1198 static int
1199 LibAliasOutLocked(struct libalias *la, char *ptr,
1200                   int maxpacketsize, int create);
1201 static int
1202 LibAliasInLocked(struct libalias *la, char *ptr,
1203                   int maxpacketsize);
1204
1205 int
1206 LibAliasIn(struct libalias *la, char *ptr, int maxpacketsize)
1207 {
1208         int res;
1209
1210         LIBALIAS_LOCK(la);
1211         res = LibAliasInLocked(la, ptr, maxpacketsize);
1212         LIBALIAS_UNLOCK(la);
1213         return (res);
1214 }
1215
1216 static int
1217 LibAliasInLocked(struct libalias *la, char *ptr, int maxpacketsize)
1218 {
1219         struct in_addr alias_addr;
1220         struct ip *pip;
1221         int iresult;
1222
1223         if (la->packetAliasMode & PKT_ALIAS_REVERSE) {
1224                 la->packetAliasMode &= ~PKT_ALIAS_REVERSE;
1225                 iresult = LibAliasOutLocked(la, ptr, maxpacketsize, 1);
1226                 la->packetAliasMode |= PKT_ALIAS_REVERSE;
1227                 goto getout;
1228         }
1229         HouseKeeping(la);
1230         ClearCheckNewLink(la);
1231         pip = (struct ip *)ptr;
1232         alias_addr = pip->ip_dst;
1233
1234         /* Defense against mangled packets */
1235         if (ntohs(pip->ip_len) > maxpacketsize
1236                 || (pip->ip_hl << 2) > maxpacketsize) {
1237                 iresult = PKT_ALIAS_IGNORED;
1238                 goto getout;
1239         }
1240
1241         iresult = PKT_ALIAS_IGNORED;
1242         if ((ntohs(pip->ip_off) & IP_OFFMASK) == 0) {
1243                 switch (pip->ip_p) {
1244                 case IPPROTO_ICMP:
1245                         iresult = IcmpAliasIn(la, pip);
1246                         break;
1247                 case IPPROTO_UDP:
1248                         iresult = UdpAliasIn(la, pip);
1249                         break;
1250                 case IPPROTO_TCP:
1251                         iresult = TcpAliasIn(la, pip);
1252                         break;
1253                 case IPPROTO_GRE: {
1254                         int error;
1255                         struct alias_data ad = {
1256                                 .lnk = NULL,
1257                                 .oaddr = NULL,
1258                                 .aaddr = NULL,
1259                                 .aport = NULL,
1260                                 .sport = NULL,
1261                                 .dport = NULL,
1262                                 .maxpktsize = 0
1263                         };
1264
1265                         /* Walk out chain. */
1266                         error = find_handler(IN, IP, la, pip, &ad);
1267                         if (error ==  0)
1268                                 iresult = PKT_ALIAS_OK;
1269                         else
1270                                 iresult = ProtoAliasIn(la, pip);
1271                 }
1272                         break;
1273                 default:
1274                         iresult = ProtoAliasIn(la, pip);
1275                         break;
1276                 }
1277
1278                 if (ntohs(pip->ip_off) & IP_MF) {
1279                         struct alias_link *lnk;
1280
1281                         lnk = FindFragmentIn1(la, pip->ip_src, alias_addr, pip->ip_id);
1282                         if (lnk != NULL) {
1283                                 iresult = PKT_ALIAS_FOUND_HEADER_FRAGMENT;
1284                                 SetFragmentAddr(lnk, pip->ip_dst);
1285                         } else {
1286                                 iresult = PKT_ALIAS_ERROR;
1287                         }
1288                 }
1289         } else {
1290                 iresult = FragmentIn(la, pip);
1291         }
1292
1293 getout:
1294         return (iresult);
1295 }
1296
1297
1298
1299 /* Unregistered address ranges */
1300
1301 /* 10.0.0.0   ->   10.255.255.255 */
1302 #define UNREG_ADDR_A_LOWER 0x0a000000
1303 #define UNREG_ADDR_A_UPPER 0x0affffff
1304
1305 /* 172.16.0.0  ->  172.31.255.255 */
1306 #define UNREG_ADDR_B_LOWER 0xac100000
1307 #define UNREG_ADDR_B_UPPER 0xac1fffff
1308
1309 /* 192.168.0.0 -> 192.168.255.255 */
1310 #define UNREG_ADDR_C_LOWER 0xc0a80000
1311 #define UNREG_ADDR_C_UPPER 0xc0a8ffff
1312
1313 int
1314 LibAliasOut(struct libalias *la, char *ptr, int maxpacketsize)
1315 {
1316         int res;
1317
1318         LIBALIAS_LOCK(la);
1319         res = LibAliasOutLocked(la, ptr, maxpacketsize, 1);
1320         LIBALIAS_UNLOCK(la);
1321         return (res);
1322 }
1323
1324 int
1325 LibAliasOutTry(struct libalias *la, char *ptr, int maxpacketsize, int create)
1326 {
1327         int res;
1328
1329         LIBALIAS_LOCK(la);
1330         res = LibAliasOutLocked(la, ptr, maxpacketsize, create);
1331         LIBALIAS_UNLOCK(la);
1332         return (res);
1333 }
1334
1335 static int
1336 LibAliasOutLocked(struct libalias *la, char *ptr,       /* valid IP packet */
1337         int maxpacketsize,              /* How much the packet data may grow (FTP
1338                                  * and IRC inline changes) */
1339         int create                                /* Create new entries ? */
1340 )
1341 {
1342         int iresult;
1343         struct in_addr addr_save;
1344         struct ip *pip;
1345
1346         if (la->packetAliasMode & PKT_ALIAS_REVERSE) {
1347                 la->packetAliasMode &= ~PKT_ALIAS_REVERSE;
1348                 iresult = LibAliasInLocked(la, ptr, maxpacketsize);
1349                 la->packetAliasMode |= PKT_ALIAS_REVERSE;
1350                 goto getout;
1351         }
1352         HouseKeeping(la);
1353         ClearCheckNewLink(la);
1354         pip = (struct ip *)ptr;
1355
1356         /* Defense against mangled packets */
1357         if (ntohs(pip->ip_len) > maxpacketsize
1358                 || (pip->ip_hl << 2) > maxpacketsize) {
1359                 iresult = PKT_ALIAS_IGNORED;
1360                 goto getout;
1361         }
1362
1363         addr_save = GetDefaultAliasAddress(la);
1364         if (la->packetAliasMode & PKT_ALIAS_UNREGISTERED_ONLY) {
1365                 u_long addr;
1366                 int iclass;
1367
1368                 iclass = 0;
1369                 addr = ntohl(pip->ip_src.s_addr);
1370                 if (addr >= UNREG_ADDR_C_LOWER && addr <= UNREG_ADDR_C_UPPER)
1371                         iclass = 3;
1372                 else if (addr >= UNREG_ADDR_B_LOWER && addr <= UNREG_ADDR_B_UPPER)
1373                         iclass = 2;
1374                 else if (addr >= UNREG_ADDR_A_LOWER && addr <= UNREG_ADDR_A_UPPER)
1375                         iclass = 1;
1376
1377                 if (iclass == 0) {
1378                         SetDefaultAliasAddress(la, pip->ip_src);
1379                 }
1380         } else if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY) {
1381                 SetDefaultAliasAddress(la, pip->ip_src);
1382         }
1383         iresult = PKT_ALIAS_IGNORED;
1384         if ((ntohs(pip->ip_off) & IP_OFFMASK) == 0) {
1385                 switch (pip->ip_p) {
1386                 case IPPROTO_ICMP:
1387                         iresult = IcmpAliasOut(la, pip, create);
1388                         break;
1389                 case IPPROTO_UDP:
1390                         iresult = UdpAliasOut(la, pip, create);
1391                         break;
1392                         case IPPROTO_TCP:
1393                         iresult = TcpAliasOut(la, pip, maxpacketsize, create);
1394                         break;
1395                 case IPPROTO_GRE: {
1396                         int error;
1397                         struct alias_data ad = {
1398                                 .lnk = NULL,
1399                                 .oaddr = NULL,
1400                                 .aaddr = NULL,
1401                                 .aport = NULL,
1402                                 .sport = NULL,
1403                                 .dport = NULL,
1404                                 .maxpktsize = 0
1405                         };
1406                         /* Walk out chain. */
1407                         error = find_handler(OUT, IP, la, pip, &ad);
1408                         if (error == 0)
1409                                 iresult = PKT_ALIAS_OK;
1410                         else
1411                                 iresult = ProtoAliasOut(la, pip, create);
1412                 }
1413                         break;
1414                 default:
1415                         iresult = ProtoAliasOut(la, pip, create);
1416                         break;
1417                 }
1418         } else {
1419                 iresult = FragmentOut(la, pip);
1420         }
1421
1422         SetDefaultAliasAddress(la, addr_save);
1423 getout:
1424         return (iresult);
1425 }
1426
1427 int
1428 LibAliasUnaliasOut(struct libalias *la, char *ptr,      /* valid IP packet */
1429         int maxpacketsize               /* for error checking */
1430 )
1431 {
1432         struct ip *pip;
1433         struct icmp *ic;
1434         struct udphdr *ud;
1435         struct tcphdr *tc;
1436         struct alias_link *lnk;
1437         int iresult = PKT_ALIAS_IGNORED;
1438
1439         LIBALIAS_LOCK(la);
1440         pip = (struct ip *)ptr;
1441
1442         /* Defense against mangled packets */
1443         if (ntohs(pip->ip_len) > maxpacketsize
1444                 || (pip->ip_hl << 2) > maxpacketsize)
1445                 goto getout;
1446
1447         ud = (struct udphdr *)ip_next(pip);
1448         tc = (struct tcphdr *)ip_next(pip);
1449         ic = (struct icmp *)ip_next(pip);
1450
1451         /* Find a link */
1452         if (pip->ip_p == IPPROTO_UDP)
1453                 lnk = FindUdpTcpIn(la, pip->ip_dst, pip->ip_src,
1454                         ud->uh_dport, ud->uh_sport,
1455                         IPPROTO_UDP, 0);
1456         else if (pip->ip_p == IPPROTO_TCP)
1457                 lnk = FindUdpTcpIn(la, pip->ip_dst, pip->ip_src,
1458                         tc->th_dport, tc->th_sport,
1459                         IPPROTO_TCP, 0);
1460         else if (pip->ip_p == IPPROTO_ICMP)
1461                 lnk = FindIcmpIn(la, pip->ip_dst, pip->ip_src, ic->icmp_id, 0);
1462         else
1463                 lnk = NULL;
1464
1465         /* Change it from an aliased packet to an unaliased packet */
1466         if (lnk != NULL) {
1467                 if (pip->ip_p == IPPROTO_UDP || pip->ip_p == IPPROTO_TCP) {
1468                         int accumulate;
1469                         struct in_addr original_address;
1470                         u_short original_port;
1471
1472                         original_address = GetOriginalAddress(lnk);
1473                         original_port = GetOriginalPort(lnk);
1474
1475                         /* Adjust TCP/UDP checksum */
1476                         accumulate = twowords(&pip->ip_src);
1477                         accumulate -= twowords(&original_address);
1478
1479                         if (pip->ip_p == IPPROTO_UDP) {
1480                                 accumulate += ud->uh_sport;
1481                                 accumulate -= original_port;
1482                                 ADJUST_CHECKSUM(accumulate, ud->uh_sum);
1483                         } else {
1484                                 accumulate += tc->th_sport;
1485                                 accumulate -= original_port;
1486                                 ADJUST_CHECKSUM(accumulate, tc->th_sum);
1487                         }
1488
1489                         /* Adjust IP checksum */
1490                         DifferentialChecksum(&pip->ip_sum,
1491                                 &original_address, &pip->ip_src, 2);
1492
1493                         /* Un-alias source address and port number */
1494                         pip->ip_src = original_address;
1495                         if (pip->ip_p == IPPROTO_UDP)
1496                                 ud->uh_sport = original_port;
1497                         else
1498                                 tc->th_sport = original_port;
1499
1500                         iresult = PKT_ALIAS_OK;
1501
1502                 } else if (pip->ip_p == IPPROTO_ICMP) {
1503
1504                         int accumulate;
1505                         struct in_addr original_address;
1506                         u_short original_id;
1507
1508                         original_address = GetOriginalAddress(lnk);
1509                         original_id = GetOriginalPort(lnk);
1510
1511                         /* Adjust ICMP checksum */
1512                         accumulate = twowords(&pip->ip_src);
1513                         accumulate -= twowords(&original_address);
1514                         accumulate += ic->icmp_id;
1515                         accumulate -= original_id;
1516                         ADJUST_CHECKSUM(accumulate, ic->icmp_cksum);
1517
1518                         /* Adjust IP checksum */
1519                         DifferentialChecksum(&pip->ip_sum,
1520                                 &original_address, &pip->ip_src, 2);
1521
1522                         /* Un-alias source address and port number */
1523                         pip->ip_src = original_address;
1524                         ic->icmp_id = original_id;
1525
1526                         iresult = PKT_ALIAS_OK;
1527                 }
1528         }
1529 getout:
1530         LIBALIAS_UNLOCK(la);
1531         return (iresult);
1532
1533 }
1534
1535 #ifndef _KERNEL
1536
1537 int
1538 LibAliasRefreshModules(void)
1539 {
1540         char buf[256], conf[] = "/etc/libalias.conf";
1541         FILE *fd;
1542         int i, len;
1543
1544         fd = fopen(conf, "r");
1545         if (fd == NULL)
1546                 err(1, "fopen(%s)", conf);
1547
1548         LibAliasUnLoadAllModule();
1549
1550         for (;;) {
1551                 fgets(buf, 256, fd);
1552                 if feof(fd)
1553                                 break;
1554                 len = strlen(buf);
1555                 if (len > 1) {
1556                         for (i = 0; i < len; i++)
1557                                 if (!isspace(buf[i]))
1558                                         break;
1559                         if (buf[i] == '#')
1560                                 continue;
1561                         buf[len - 1] = '\0';
1562                         kprintf("Loading %s\n", buf);
1563                         LibAliasLoadModule(buf);
1564                 }
1565         }
1566         return (0);
1567 }
1568
1569 int
1570 LibAliasLoadModule(char *path)
1571 {
1572         struct dll *t;
1573         void *handle;
1574         struct proto_handler *m;
1575                 const char *error;
1576         moduledata_t *p;
1577
1578                 handle = dlopen (path, RTLD_LAZY);
1579                 if (!handle) {
1580                 fkprintf(stderr, "%s\n", dlerror());
1581                 return (EINVAL);
1582                 }
1583
1584         p = dlsym(handle, "alias_mod");
1585                 if ((error = dlerror()) != NULL)  {
1586                 fkprintf(stderr, "%s\n", dlerror());
1587                 return (EINVAL);
1588                 }
1589
1590         t = kmalloc(sizeof(struct dll),M_ALIAS, M_WAITOK | M_ZERO);
1591         if (t == NULL)
1592                 return (ENOMEM);
1593         strncpy(t->name, p->name, DLL_LEN);
1594         t->handle = handle;
1595         if (attach_dll(t) == EEXIST) {
1596                 kfree(t,M_ALIAS);
1597                 fkprintf(stderr, "dll conflict\n");
1598                 return (EEXIST);
1599         }
1600
1601                 m = dlsym(t->handle, "handlers");
1602                 if ((error = dlerror()) != NULL)  {
1603                 fkprintf(stderr, "%s\n", error);
1604                 return (EINVAL);
1605         }
1606
1607         LibAliasAttachHandlers(m);
1608         return (0);
1609 }
1610
1611 int
1612 LibAliasUnLoadAllModule(void)
1613 {
1614         struct dll *t;
1615         struct proto_handler *p;
1616
1617         /* Unload all modules then reload everything. */
1618         while ((p = first_handler()) != NULL) {
1619                 detach_handler(p);
1620         }
1621         while ((t = walk_dll_chain()) != NULL) {
1622                 dlclose(t->handle);
1623                 kfree(t,M_ALIAS);
1624         }
1625         return (1);
1626 }
1627
1628 #endif
1629
1630 #ifdef _KERNEL
1631 /*
1632  * m_megapullup() - this function is a big hack.
1633  * Thankfully, it's only used in ng_nat and ipfw+nat.
1634  *
1635  * It allocates an mbuf with cluster and copies the specified part of the chain
1636  * into cluster, so that it is all contiguous and can be accessed via a plain
1637  * (char *) pointer. This is required, because libalias doesn't know how to
1638  * handle mbuf chains.
1639  *
1640  * On success, m_megapullup returns an mbuf (possibly with cluster) containing
1641  * the input packet, on failure NULL. The input packet is always consumed.
1642  */
1643 struct mbuf *
1644 m_megapullup(struct mbuf *m, int len) {
1645         struct mbuf *mcl;
1646
1647         if (len > m->m_pkthdr.len)
1648                 goto bad;
1649
1650         /* Do not reallocate packet if it is sequentional,
1651          * writable and has some extra space for expansion.
1652          * XXX: Constant 100bytes is completely empirical. */
1653 #define RESERVE 100
1654         if (m->m_next == NULL && M_WRITABLE(m) && M_TRAILINGSPACE(m) >= RESERVE)
1655                 return (m);
1656         /*
1657         if (len <= MCLBYTES - RESERVE) {
1658                 mcl = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
1659         } else if (len < MJUM16BYTES) {
1660                 int size;
1661                 if (len <= MJUMPAGESIZE - RESERVE) {
1662                         size = MJUMPAGESIZE;
1663                 } else if (len <= MJUM9BYTES - RESERVE) {
1664                         size = MJUM9BYTES;
1665                 } else {
1666                         size = MJUM16BYTES;
1667                 };
1668                 mcl = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, size);
1669         } else {
1670                 goto bad;
1671         }
1672         */
1673         mcl = NULL;
1674         if (mcl == NULL)
1675                 goto bad;
1676
1677         m_move_pkthdr(mcl, m);
1678         m_copydata(m, 0, len, mtod(mcl, caddr_t));
1679         mcl->m_len = mcl->m_pkthdr.len = len;
1680         m_freem(m);
1681
1682         return (mcl);
1683 bad:
1684         m_freem(m);
1685         return (NULL);
1686 }
1687 #endif