Ejemplo n.º 1
0
static int
TcpAliasIn(struct libalias *la, struct ip *pip)
{
    struct tcphdr *tc;
    struct alias_link *lnk;

    LIBALIAS_LOCK_ASSERT(la);
    tc = (struct tcphdr *)ip_next(pip);

    lnk = FindUdpTcpIn(la, pip->ip_src, pip->ip_dst,
        tc->th_sport, tc->th_dport,
        IPPROTO_TCP,
        !(la->packetAliasMode & PKT_ALIAS_PROXY_ONLY));
    if (lnk != NULL) {
        struct in_addr alias_address;
        struct in_addr original_address;
        struct in_addr proxy_address;
        u_short alias_port;
        u_short proxy_port;
        int accumulate, error;

        /*
         * The init of MANY vars is a bit below, but aliashandlepptpin
         * seems to need the destination port that came within the
         * packet and not the original one looks below [*].
         */

        struct alias_data ad;
        ad.lnk = lnk;
        ad.oaddr = NULL;
        ad.aaddr = NULL;
        ad.aport = NULL;
        ad.sport = &tc->th_sport;
        ad.dport = &tc->th_dport;
        ad.maxpktsize = 0;

        /* Walk out chain. */
        error = find_handler(IN, TCP, la, pip, &ad);

        alias_address = GetAliasAddress(lnk);
        original_address = GetOriginalAddress(lnk);
        proxy_address = GetProxyAddress(lnk);
        alias_port = tc->th_dport;
        tc->th_dport = GetOriginalPort(lnk);
        proxy_port = GetProxyPort(lnk);

        /*
         * Look above, if anyone is going to add find_handler AFTER
         * this aliashandlepptpin/point, please redo alias_data too.
         * Uncommenting the piece here below should be enough.
         */
#if 0
                 struct alias_data ad = {
                    .lnk = lnk,
                    .oaddr = &original_address,
                    .aaddr = &alias_address,
                    .aport = &alias_port,
                    .sport = &ud->uh_sport,
                    .dport = &ud->uh_dport,
                    .maxpktsize = 0
                };

                /* Walk out chain. */
                error = find_handler(la, pip, &ad);
                if (error == EHDNOF)
                    printf("Protocol handler not found\n");
#endif

/* Adjust TCP checksum since destination port is being unaliased */
/* and destination port is being altered.                        */
        accumulate = alias_port;
        accumulate -= tc->th_dport;
        accumulate += twowords(&alias_address);
        accumulate -= twowords(&original_address);

/* If this is a proxy, then modify the TCP source port and
   checksum accumulation */
        if (proxy_port != 0) {
            accumulate += tc->th_sport;
            tc->th_sport = proxy_port;
            accumulate -= tc->th_sport;
            accumulate += twowords(&pip->ip_src);
            accumulate -= twowords(&proxy_address);
        }
/* See if ACK number needs to be modified */
        if (GetAckModified(lnk) == 1) {
            int delta;

            delta = GetDeltaAckIn(pip, lnk);
            if (delta != 0) {
                accumulate += twowords(&tc->th_ack);
                tc->th_ack = htonl(ntohl(tc->th_ack) - delta);
                accumulate -= twowords(&tc->th_ack);
            }
        }
        ADJUST_CHECKSUM(accumulate, tc->th_sum);

/* Restore original IP address */
        accumulate = twowords(&pip->ip_dst);
        pip->ip_dst = original_address;
        accumulate -= twowords(&pip->ip_dst);

/* If this is a transparent proxy packet, then modify the source
   address */
        if (proxy_address.s_addr != 0) {
            accumulate += twowords(&pip->ip_src);
            pip->ip_src = proxy_address;
            accumulate -= twowords(&pip->ip_src);
        }
        ADJUST_CHECKSUM(accumulate, pip->ip_sum);

/* Monitor TCP connection state */
        TcpMonitorIn(pip, lnk);

        return (PKT_ALIAS_OK);
    }
    return (PKT_ALIAS_IGNORED);
}

static int
TcpAliasOut(struct libalias *la, struct ip *pip, int maxpacketsize, int create)
{
    int proxy_type, error;
    u_short dest_port;
    u_short proxy_server_port;
    struct in_addr dest_address;
    struct in_addr proxy_server_address;
    struct tcphdr *tc;
    struct alias_link *lnk;

    LIBALIAS_LOCK_ASSERT(la);
    tc = (struct tcphdr *)ip_next(pip);

    if (create)
        proxy_type =
            ProxyCheck(la, pip, &proxy_server_address, &proxy_server_port);
    else
        proxy_type = 0;

    if (proxy_type == 0 && (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY))
        return (PKT_ALIAS_OK);

/* If this is a transparent proxy, save original destination,
   then alter the destination and adjust checksums */
    dest_port = tc->th_dport;
    dest_address = pip->ip_dst;
    if (proxy_type != 0) {
        int accumulate;

        accumulate = tc->th_dport;
        tc->th_dport = proxy_server_port;
        accumulate -= tc->th_dport;
        accumulate += twowords(&pip->ip_dst);
        accumulate -= twowords(&proxy_server_address);
        ADJUST_CHECKSUM(accumulate, tc->th_sum);

        accumulate = twowords(&pip->ip_dst);
        pip->ip_dst = proxy_server_address;
        accumulate -= twowords(&pip->ip_dst);
        ADJUST_CHECKSUM(accumulate, pip->ip_sum);
    }
    lnk = FindUdpTcpOut(la, pip->ip_src, pip->ip_dst,
        tc->th_sport, tc->th_dport,
        IPPROTO_TCP, create);
    if (lnk == NULL)
        return (PKT_ALIAS_IGNORED);
    if (lnk != NULL) {
        u_short alias_port;
        struct in_addr alias_address;
        int accumulate;
        struct alias_data ad;
        ad.lnk = lnk;
        ad.oaddr = NULL;
        ad.aaddr = &alias_address;
        ad.aport = &alias_port;
        ad.sport = &tc->th_sport;
        ad.dport = &tc->th_dport;
        ad.maxpktsize = maxpacketsize;

/* Save original destination address, if this is a proxy packet.
   Also modify packet to include destination encoding.  This may
   change the size of IP header. */
        if (proxy_type != 0) {
            SetProxyPort(lnk, dest_port);
            SetProxyAddress(lnk, dest_address);
            ProxyModify(la, lnk, pip, maxpacketsize, proxy_type);
            tc = (struct tcphdr *)ip_next(pip);
        }
/* Get alias address and port */
        alias_port = GetAliasPort(lnk);
        alias_address = GetAliasAddress(lnk);

/* Monitor TCP connection state */
        TcpMonitorOut(pip, lnk);

        /* Walk out chain. */
        error = find_handler(OUT, TCP, la, pip, &ad);

/* Adjust TCP checksum since source port is being aliased */
/* and source address is being altered                    */
        accumulate = tc->th_sport;
        tc->th_sport = alias_port;
        accumulate -= tc->th_sport;
        accumulate += twowords(&pip->ip_src);
        accumulate -= twowords(&alias_address);

/* Modify sequence number if necessary */
        if (GetAckModified(lnk) == 1) {
            int delta;

            delta = GetDeltaSeqOut(pip, lnk);
            if (delta != 0) {
                accumulate += twowords(&tc->th_seq);
                tc->th_seq = htonl(ntohl(tc->th_seq) + delta);
                accumulate -= twowords(&tc->th_seq);
            }
        }
        ADJUST_CHECKSUM(accumulate, tc->th_sum);

/* Change source address */
        accumulate = twowords(&pip->ip_src);
        pip->ip_src = alias_address;
        accumulate -= twowords(&pip->ip_src);
        ADJUST_CHECKSUM(accumulate, pip->ip_sum);

        return (PKT_ALIAS_OK);
    }
    return (PKT_ALIAS_IGNORED);
}
Ejemplo n.º 2
0
static int
UdpAliasIn(struct libalias *la, struct ip *pip)
{
	struct udphdr *ud;
	struct alias_link *lnk;

	LIBALIAS_LOCK_ASSERT(la);

	ud = (struct udphdr *)ip_next(pip);

	lnk = FindUdpTcpIn(la, pip->ip_src, pip->ip_dst,
	    ud->uh_sport, ud->uh_dport,
	    IPPROTO_UDP, !(la->packetAliasMode & PKT_ALIAS_PROXY_ONLY));
	if (lnk != NULL) {
		struct in_addr alias_address;
		struct in_addr original_address;
		struct in_addr proxy_address;
		u_short alias_port;
		u_short proxy_port;
		int accumulate;
		int error;
		struct alias_data ad = {
			.lnk = lnk, 
			.oaddr = &original_address, 
			.aaddr = &alias_address,
			.aport = &alias_port,
			.sport = &ud->uh_sport,
			.dport = &ud->uh_dport,
			.maxpktsize = 0
		};

		alias_address = GetAliasAddress(lnk);
		original_address = GetOriginalAddress(lnk);
		proxy_address = GetProxyAddress(lnk);
		alias_port = ud->uh_dport;
		ud->uh_dport = GetOriginalPort(lnk);
		proxy_port = GetProxyPort(lnk);

		/* Walk out chain. */		
		error = find_handler(IN, UDP, la, pip, &ad);
		/* If we cannot figure out the packet, ignore it. */
		if (error < 0)
			return (PKT_ALIAS_IGNORED);

/* If UDP checksum is not zero, then adjust since destination port */
/* is being unaliased and destination address is being altered.    */
		if (ud->uh_sum != 0) {
			accumulate = alias_port;
			accumulate -= ud->uh_dport;
			accumulate += twowords(&alias_address);
			accumulate -= twowords(&original_address);

/* If this is a proxy packet, modify checksum because of source change.*/
        		if (proxy_port != 0) {
		                accumulate += ud->uh_sport;
		                accumulate -= proxy_port;
	                }

	                if (proxy_address.s_addr != 0) {
				accumulate += twowords(&pip->ip_src);
				accumulate -= twowords(&proxy_address);
	                }

			ADJUST_CHECKSUM(accumulate, ud->uh_sum);
		}
/* XXX: Could the two if's below be concatenated to one ? */
/* Restore source port and/or address in case of proxying*/

    		if (proxy_port != 0)
        		ud->uh_sport = proxy_port;

    		if (proxy_address.s_addr != 0) {
        		DifferentialChecksum(&pip->ip_sum,
                	    &proxy_address, &pip->ip_src, 2);
	        	pip->ip_src = proxy_address;
    		}

/* Restore original IP address */
		DifferentialChecksum(&pip->ip_sum,
		    &original_address, &pip->ip_dst, 2);
		pip->ip_dst = original_address;

		return (PKT_ALIAS_OK);
	}
	return (PKT_ALIAS_IGNORED);
}

static int
UdpAliasOut(struct libalias *la, struct ip *pip, int maxpacketsize, int create)
{
	struct udphdr *ud;
	struct alias_link *lnk;
	struct in_addr dest_address;
	struct in_addr proxy_server_address;
	u_short dest_port;
	u_short proxy_server_port;
	int proxy_type;
	int error;

	LIBALIAS_LOCK_ASSERT(la);

/* Return if proxy-only mode is enabled and not proxyrule found.*/
	ud = (struct udphdr *)ip_next(pip);
	proxy_type = ProxyCheck(la, &proxy_server_address, 
		&proxy_server_port, pip->ip_src, pip->ip_dst, 
		ud->uh_dport, pip->ip_p);
	if (proxy_type == 0 && (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY))
		return (PKT_ALIAS_OK);

/* If this is a transparent proxy, save original destination,
 * then alter the destination and adjust checksums */
	dest_port = ud->uh_dport;
	dest_address = pip->ip_dst;

	if (proxy_type != 0) {
	        int accumulate;

		accumulate = twowords(&pip->ip_dst);
		accumulate -= twowords(&proxy_server_address);

	        ADJUST_CHECKSUM(accumulate, pip->ip_sum);

		if (ud->uh_sum != 0) {
			accumulate = twowords(&pip->ip_dst);
			accumulate -= twowords(&proxy_server_address);
    			accumulate += ud->uh_dport;
	        	accumulate -= proxy_server_port;
	    		ADJUST_CHECKSUM(accumulate, ud->uh_sum);
		}
	        pip->ip_dst = proxy_server_address;
	        ud->uh_dport = proxy_server_port;
	}
	lnk = FindUdpTcpOut(la, pip->ip_src, pip->ip_dst,
	    ud->uh_sport, ud->uh_dport,
	    IPPROTO_UDP, create);
	if (lnk != NULL) {
		u_short alias_port;
		struct in_addr alias_address;
		struct alias_data ad = {
			.lnk = lnk, 
			.oaddr = NULL,
			.aaddr = &alias_address,
			.aport = &alias_port,
			.sport = &ud->uh_sport,
			.dport = &ud->uh_dport,
			.maxpktsize = 0
		};

/* Save original destination address, if this is a proxy packet.
 * Also modify packet to include destination encoding.  This may
 * change the size of IP header. */
		if (proxy_type != 0) {
	                SetProxyPort(lnk, dest_port);
	                SetProxyAddress(lnk, dest_address);
	                ProxyModify(la, lnk, pip, maxpacketsize, proxy_type);
	                ud = (struct udphdr *)ip_next(pip);
	        }

		alias_address = GetAliasAddress(lnk);
		alias_port = GetAliasPort(lnk);

		/* Walk out chain. */		
		error = find_handler(OUT, UDP, la, pip, &ad);

/* If UDP checksum is not zero, adjust since source port is */
/* being aliased and source address is being altered        */
		if (ud->uh_sum != 0) {
			int accumulate;

			accumulate = ud->uh_sport;
			accumulate -= alias_port;
			accumulate += twowords(&pip->ip_src);
			accumulate -= twowords(&alias_address);
			ADJUST_CHECKSUM(accumulate, ud->uh_sum);
		}
/* Put alias port in UDP header */
		ud->uh_sport = alias_port;

/* Change source address */
		DifferentialChecksum(&pip->ip_sum,
		    &alias_address, &pip->ip_src, 2);
		pip->ip_src = alias_address;

		return (PKT_ALIAS_OK);
	}
	return (PKT_ALIAS_IGNORED);
}



static int
TcpAliasIn(struct libalias *la, struct ip *pip)
{
	struct tcphdr *tc;
	struct alias_link *lnk;

	LIBALIAS_LOCK_ASSERT(la);
	tc = (struct tcphdr *)ip_next(pip);

	lnk = FindUdpTcpIn(la, pip->ip_src, pip->ip_dst,
	    tc->th_sport, tc->th_dport,
	    IPPROTO_TCP,
	    !(la->packetAliasMode & PKT_ALIAS_PROXY_ONLY));
	if (lnk != NULL) {
		struct in_addr alias_address;
		struct in_addr original_address;
		struct in_addr proxy_address;
		u_short alias_port;
		u_short proxy_port;
		int accumulate, error;

		/* 
		 * The init of MANY vars is a bit below, but aliashandlepptpin 
		 * seems to need the destination port that came within the
		 * packet and not the original one looks below [*].
		 */

		struct alias_data ad = {
			.lnk = lnk, 
			.oaddr = NULL,
			.aaddr = NULL,
			.aport = NULL,
			.sport = &tc->th_sport,
			.dport = &tc->th_dport,
			.maxpktsize = 0
		};

		/* Walk out chain. */		
		error = find_handler(IN, TCP, la, pip, &ad);

		alias_address = GetAliasAddress(lnk);
		original_address = GetOriginalAddress(lnk);
		proxy_address = GetProxyAddress(lnk);
		alias_port = tc->th_dport;
		tc->th_dport = GetOriginalPort(lnk);
		proxy_port = GetProxyPort(lnk);

		/* 
		 * Look above, if anyone is going to add find_handler AFTER 
		 * this aliashandlepptpin/point, please redo alias_data too.
		 * Uncommenting the piece here below should be enough.
		 */
#if 0
				 struct alias_data ad = {
					.lnk = lnk,
					.oaddr = &original_address,
					.aaddr = &alias_address,
					.aport = &alias_port,
					.sport = &ud->uh_sport,
					.dport = &ud->uh_dport,
					.maxpktsize = 0
				};
		
				/* Walk out chain. */
				error = find_handler(la, pip, &ad);
				if (error == EHDNOF)
					printf("Protocol handler not found\n");
#endif

/* Adjust TCP checksum since destination port is being unaliased */
/* and destination port is being altered.                        */
		accumulate = alias_port;
		accumulate -= tc->th_dport;
		accumulate += twowords(&alias_address);
		accumulate -= twowords(&original_address);

/* If this is a proxy, then modify the TCP source port and
   checksum accumulation */
		if (proxy_port != 0) {
			accumulate += tc->th_sport;
			tc->th_sport = proxy_port;
			accumulate -= tc->th_sport;
			accumulate += twowords(&pip->ip_src);
			accumulate -= twowords(&proxy_address);
		}
/* See if ACK number needs to be modified */
		if (GetAckModified(lnk) == 1) {
			int delta;

			tc = (struct tcphdr *)ip_next(pip);
			delta = GetDeltaAckIn(tc->th_ack, lnk);
			if (delta != 0) {
				accumulate += twowords(&tc->th_ack);
				tc->th_ack = htonl(ntohl(tc->th_ack) - delta);
				accumulate -= twowords(&tc->th_ack);
			}
		}
		ADJUST_CHECKSUM(accumulate, tc->th_sum);

/* Restore original IP address */
		accumulate = twowords(&pip->ip_dst);
		pip->ip_dst = original_address;
		accumulate -= twowords(&pip->ip_dst);

/* If this is a transparent proxy packet, then modify the source
   address */
		if (proxy_address.s_addr != 0) {
			accumulate += twowords(&pip->ip_src);
			pip->ip_src = proxy_address;
			accumulate -= twowords(&pip->ip_src);
		}
		ADJUST_CHECKSUM(accumulate, pip->ip_sum);

/* Monitor TCP connection state */
		tc = (struct tcphdr *)ip_next(pip);
		TcpMonitorIn(tc->th_flags, lnk);

		return (PKT_ALIAS_OK);
	}
	return (PKT_ALIAS_IGNORED);
}

static int
TcpAliasOut(struct libalias *la, struct ip *pip, int maxpacketsize, int create)
{
	int proxy_type, error;
	u_short dest_port;
	u_short proxy_server_port;
	struct in_addr dest_address;
	struct in_addr proxy_server_address;
	struct tcphdr *tc;
	struct alias_link *lnk;

	LIBALIAS_LOCK_ASSERT(la);
	tc = (struct tcphdr *)ip_next(pip);

	if (create)
		proxy_type = ProxyCheck(la, &proxy_server_address, 
		    &proxy_server_port, pip->ip_src, pip->ip_dst, 
		    tc->th_dport, pip->ip_p);
	else
		proxy_type = 0;

	if (proxy_type == 0 && (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY))
		return (PKT_ALIAS_OK);

/* If this is a transparent proxy, save original destination,
   then alter the destination and adjust checksums */
	dest_port = tc->th_dport;
	dest_address = pip->ip_dst;
	if (proxy_type != 0) {
		int accumulate;

		accumulate = tc->th_dport;
		tc->th_dport = proxy_server_port;
		accumulate -= tc->th_dport;
		accumulate += twowords(&pip->ip_dst);
		accumulate -= twowords(&proxy_server_address);
		ADJUST_CHECKSUM(accumulate, tc->th_sum);

		accumulate = twowords(&pip->ip_dst);
		pip->ip_dst = proxy_server_address;
		accumulate -= twowords(&pip->ip_dst);
		ADJUST_CHECKSUM(accumulate, pip->ip_sum);
	}
	lnk = FindUdpTcpOut(la, pip->ip_src, pip->ip_dst,
	    tc->th_sport, tc->th_dport,
	    IPPROTO_TCP, create);
	if (lnk == NULL)
		return (PKT_ALIAS_IGNORED);
	if (lnk != NULL) {
		u_short alias_port;
		struct in_addr alias_address;
		int accumulate;
		struct alias_data ad = {
			.lnk = lnk, 
			.oaddr = NULL,
			.aaddr = &alias_address,
			.aport = &alias_port,
			.sport = &tc->th_sport,
			.dport = &tc->th_dport,
			.maxpktsize = maxpacketsize
		};

/* Save original destination address, if this is a proxy packet.
   Also modify packet to include destination encoding.  This may
   change the size of IP header. */
		if (proxy_type != 0) {
			SetProxyPort(lnk, dest_port);
			SetProxyAddress(lnk, dest_address);
			ProxyModify(la, lnk, pip, maxpacketsize, proxy_type);
			tc = (struct tcphdr *)ip_next(pip);
		}
/* Get alias address and port */
		alias_port = GetAliasPort(lnk);
		alias_address = GetAliasAddress(lnk);

/* Monitor TCP connection state */
		tc = (struct tcphdr *)ip_next(pip);
		TcpMonitorOut(tc->th_flags, lnk);
		
		/* Walk out chain. */		
		error = find_handler(OUT, TCP, la, pip, &ad);

/* Adjust TCP checksum since source port is being aliased */
/* and source address is being altered                    */
		accumulate = tc->th_sport;
		tc->th_sport = alias_port;
		accumulate -= tc->th_sport;
		accumulate += twowords(&pip->ip_src);
		accumulate -= twowords(&alias_address);

/* Modify sequence number if necessary */
		if (GetAckModified(lnk) == 1) {
			int delta;
			
			tc = (struct tcphdr *)ip_next(pip);
			delta = GetDeltaSeqOut(tc->th_seq, lnk);
			if (delta != 0) {
				accumulate += twowords(&tc->th_seq);
				tc->th_seq = htonl(ntohl(tc->th_seq) + delta);
				accumulate -= twowords(&tc->th_seq);
			}
		}
		ADJUST_CHECKSUM(accumulate, tc->th_sum);

/* Change source address */
		accumulate = twowords(&pip->ip_src);
		pip->ip_src = alias_address;
		accumulate -= twowords(&pip->ip_src);
		ADJUST_CHECKSUM(accumulate, pip->ip_sum);

		return (PKT_ALIAS_OK);
	}
	return (PKT_ALIAS_IGNORED);
}




/* Fragment Handling

    FragmentIn()
    FragmentOut()

The packet aliasing module has a limited ability for handling IP
fragments.  If the ICMP, TCP or UDP header is in the first fragment
received, then the ID number of the IP packet is saved, and other
fragments are identified according to their ID number and IP address
they were sent from.  Pointers to unresolved fragments can also be
saved and recalled when a header fragment is seen.
*/

/* Local prototypes */
static int	FragmentIn(struct libalias *la, struct in_addr ip_src, 
		    struct in_addr *ip_dst, u_short ip_id, u_short *ip_sum);		    
static int	FragmentOut(struct libalias *, struct in_addr *ip_src, 
		    u_short *ip_sum);

static int
FragmentIn(struct libalias *la, struct in_addr ip_src, struct in_addr *ip_dst,
    u_short ip_id, u_short *ip_sum)
{
	struct alias_link *lnk;

	LIBALIAS_LOCK_ASSERT(la);
	lnk = FindFragmentIn2(la, ip_src, *ip_dst, ip_id);
	if (lnk != NULL) {
		struct in_addr original_address;

		GetFragmentAddr(lnk, &original_address);
		DifferentialChecksum(ip_sum,
		    &original_address, ip_dst, 2);
		*ip_dst = original_address;

		return (PKT_ALIAS_OK);
	}
	return (PKT_ALIAS_UNRESOLVED_FRAGMENT);
}

static int
FragmentOut(struct libalias *la, struct in_addr *ip_src, u_short *ip_sum)
{
	struct in_addr alias_address;

	LIBALIAS_LOCK_ASSERT(la);
	alias_address = FindAliasAddress(la, *ip_src);
	DifferentialChecksum(ip_sum,
	    &alias_address, ip_src, 2);
	*ip_src = alias_address;

	return (PKT_ALIAS_OK);
}






/* Outside World Access

	PacketAliasSaveFragment()
	PacketAliasGetFragment()
	PacketAliasFragmentIn()
	PacketAliasIn()
	PacketAliasOut()
	PacketUnaliasOut()

(prototypes in alias.h)
*/

int
LibAliasSaveFragment(struct libalias *la, char *ptr)
{
	int iresult;
	struct alias_link *lnk;
	struct ip *pip;

	LIBALIAS_LOCK(la);
	pip = (struct ip *)ptr;
	lnk = AddFragmentPtrLink(la, pip->ip_src, pip->ip_id);
	iresult = PKT_ALIAS_ERROR;
	if (lnk != NULL) {
		SetFragmentPtr(lnk, ptr);
		iresult = PKT_ALIAS_OK;
	}
	LIBALIAS_UNLOCK(la);
	return (iresult);
}

char           *
LibAliasGetFragment(struct libalias *la, char *ptr)
{
	struct alias_link *lnk;
	char *fptr;
	struct ip *pip;

	LIBALIAS_LOCK(la);
	pip = (struct ip *)ptr;
	lnk = FindFragmentPtr(la, pip->ip_src, pip->ip_id);
	if (lnk != NULL) {
		GetFragmentPtr(lnk, &fptr);
		SetFragmentPtr(lnk, NULL);
		SetExpire(lnk, 0);	/* Deletes link */
	} else		
		fptr = NULL;

	LIBALIAS_UNLOCK(la);
	return (fptr);
}

void
LibAliasFragmentIn(struct libalias *la, char *ptr,	/* Points to correctly
							 * de-aliased header
							 * fragment */
    char *ptr_fragment		/* Points to fragment which must be
				 * de-aliased   */
)
{
	struct ip *pip;
	struct ip *fpip;

	LIBALIAS_LOCK(la);
	(void)la;
	pip = (struct ip *)ptr;
	fpip = (struct ip *)ptr_fragment;

	DifferentialChecksum(&fpip->ip_sum,
	    &pip->ip_dst, &fpip->ip_dst, 2);
	fpip->ip_dst = pip->ip_dst;
	LIBALIAS_UNLOCK(la);
}

/* Local prototypes */
static int
LibAliasOutLocked(struct libalias *la, char *ptr,
		  int maxpacketsize, int create);
static int
LibAliasInLocked(struct libalias *la, char *ptr,
		  int maxpacketsize);

int
LibAliasIn(struct libalias *la, char *ptr, int maxpacketsize)
{
	int res;

	LIBALIAS_LOCK(la);
	res = LibAliasInLocked(la, ptr, maxpacketsize);
	LIBALIAS_UNLOCK(la);
	return (res);
}
Ejemplo n.º 3
0
static int
TcpAliasOut(struct ip *pip, int maxpacketsize)
{
    int proxy_type;
    u_short dest_port;
    u_short proxy_server_port;
    struct in_addr dest_address;
    struct in_addr proxy_server_address;
    struct tcphdr *tc;
    struct alias_link *link;

    tc = (struct tcphdr *) ((char *) pip + (pip->ip_hl << 2));

    proxy_type = ProxyCheck(pip, &proxy_server_address, &proxy_server_port);

    if (proxy_type == 0 && (packetAliasMode & PKT_ALIAS_PROXY_ONLY))
        return PKT_ALIAS_OK;

/* If this is a transparent proxy, save original destination,
   then alter the destination and adjust checksums */
    dest_port = tc->th_dport;
    dest_address = pip->ip_dst;
    if (proxy_type != 0)
    {
        int accumulate;
        u_short *sptr;

        accumulate = tc->th_dport;
        tc->th_dport = proxy_server_port;
        accumulate -= tc->th_dport;

        sptr = (u_short *) &(pip->ip_dst);
        accumulate += *sptr++;
        accumulate += *sptr;
        sptr = (u_short *) &proxy_server_address;
        accumulate -= *sptr++;
        accumulate -= *sptr;

        ADJUST_CHECKSUM(accumulate, tc->th_sum);

        sptr = (u_short *) &(pip->ip_dst);
        accumulate  = *sptr++;
        accumulate += *sptr;
        pip->ip_dst = proxy_server_address;
        sptr = (u_short *) &(pip->ip_dst);
        accumulate -= *sptr++;
        accumulate -= *sptr;

        ADJUST_CHECKSUM(accumulate, pip->ip_sum);
    }

    link = FindUdpTcpOut(pip->ip_src, pip->ip_dst,
                         tc->th_sport, tc->th_dport,
                         IPPROTO_TCP, 1);
    if (link !=NULL)
    {
        u_short alias_port;
        struct in_addr alias_address;
        int accumulate;
        u_short *sptr;

/* Save original destination address, if this is a proxy packet.
   Also modify packet to include destination encoding.  This may
   change the size of IP header. */
        if (proxy_type != 0)
        {
            SetProxyPort(link, dest_port);
            SetProxyAddress(link, dest_address);
            ProxyModify(link, pip, maxpacketsize, proxy_type);
            tc = (struct tcphdr *) ((char *) pip + (pip->ip_hl << 2));
        }

/* Get alias address and port */
        alias_port = GetAliasPort(link);
        alias_address = GetAliasAddress(link);

/* Monitor TCP connection state */
        TcpMonitorOut(pip, link);

/* Special processing for IP encoding protocols */
        if (ntohs(tc->th_dport) == FTP_CONTROL_PORT_NUMBER
         || ntohs(tc->th_sport) == FTP_CONTROL_PORT_NUMBER)
            AliasHandleFtpOut(pip, link, maxpacketsize);
        else if (ntohs(tc->th_dport) == IRC_CONTROL_PORT_NUMBER_1
         || ntohs(tc->th_dport) == IRC_CONTROL_PORT_NUMBER_2)
            AliasHandleIrcOut(pip, link, maxpacketsize);
        else if (ntohs(tc->th_dport) == RTSP_CONTROL_PORT_NUMBER_1
         || ntohs(tc->th_sport) == RTSP_CONTROL_PORT_NUMBER_1
         || ntohs(tc->th_dport) == RTSP_CONTROL_PORT_NUMBER_2
         || ntohs(tc->th_sport) == RTSP_CONTROL_PORT_NUMBER_2) 
            AliasHandleRtspOut(pip, link, maxpacketsize);
        else if (ntohs(tc->th_dport) == PPTP_CONTROL_PORT_NUMBER
         || ntohs(tc->th_sport) == PPTP_CONTROL_PORT_NUMBER)
            AliasHandlePptpOut(pip, link);

/* Adjust TCP checksum since source port is being aliased */
/* and source address is being altered                    */
        accumulate  = tc->th_sport;
        tc->th_sport = alias_port;
        accumulate -= tc->th_sport;

        sptr = (u_short *) &(pip->ip_src);
        accumulate += *sptr++;
        accumulate += *sptr;
        sptr = (u_short *) &alias_address;
        accumulate -= *sptr++;
        accumulate -= *sptr;

/* Modify sequence number if necessary */
        if (GetAckModified(link) == 1)
        {
            int delta;

            delta = GetDeltaSeqOut(pip, link);
            if (delta != 0)
            {
                sptr = (u_short *) &tc->th_seq;
                accumulate += *sptr++;
                accumulate += *sptr;
                tc->th_seq = htonl(ntohl(tc->th_seq) + delta);
                sptr = (u_short *) &tc->th_seq;
                accumulate -= *sptr++;
                accumulate -= *sptr;
            }
        }

        ADJUST_CHECKSUM(accumulate, tc->th_sum);

/* Change source address */
        sptr = (u_short *) &(pip->ip_src);
        accumulate  = *sptr++;
        accumulate += *sptr;
        pip->ip_src = alias_address;
        sptr = (u_short *) &(pip->ip_src);
        accumulate -= *sptr++;
        accumulate -= *sptr;

        ADJUST_CHECKSUM(accumulate, pip->ip_sum);

        return(PKT_ALIAS_OK);
    }
    return(PKT_ALIAS_IGNORED);
}