lib/libalias/alias.c

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