Differential D30283 Diff 89946 sys/netinet/libalias/alias_db.c

Changeset View

Standalone View

sys/netinet/libalias/alias_db.c

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines

/* Dummy port number codes used for FindLinkIn/Out() and AddLink().		/* Dummy port number codes used for FindLinkIn/Out() and AddLink().
These constants can be anything except zero, which indicates an		These constants can be anything except zero, which indicates an
unknown port number. */		unknown port number. */

#define NO_DEST_PORT 1		#define NO_DEST_PORT 1
#define NO_SRC_PORT 1		#define NO_SRC_PORT 1

/* Dummy address used for FindLinkIn/Out() and AddLink().		/* Matches any/unknown address in FindLinkIn/Out() and AddLink(). */
The value of this variable is never used. */		static struct in_addr const ANY_ADDR = { INADDR_ANY };
static struct in_addr const NO_ADDR;

/* Data Structures		/* Data Structures

The fundamental data structure used in this program is		The fundamental data structure used in this program is
"struct alias_link". Whenever a TCP connection is made,		"struct alias_link". Whenever a TCP connection is made,
a UDP datagram is sent out, or an ICMP echo request is made,		a UDP datagram is sent out, or an ICMP echo request is made,
a link record is made (if it has not already been created).		a link record is made (if it has not already been created).
The link record is identified by the source address/port		The link record is identified by the source address/port
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines	StartPointOut() -- link table initial search point for
outgoing packets		outgoing packets

Miscellaneous:		Miscellaneous:
SeqDiff() -- difference between two TCP sequences		SeqDiff() -- difference between two TCP sequences
ShowAliasStats() -- send alias statistics to a monitor file		ShowAliasStats() -- send alias statistics to a monitor file
*/		*/

/* Local prototypes */		/* Local prototypes */
static u_int StartPointIn(struct in_addr, u_short, int);		static struct group_in *
		StartPointIn(struct libalias *, struct in_addr, u_short, int, int);
static u_int		static u_int
StartPointOut(struct in_addr, struct in_addr,		StartPointOut(struct in_addr, struct in_addr, u_short, u_short, int);
u_short, u_short, int);

static int SeqDiff(u_long, u_long);		static int SeqDiff(u_long, u_long);

#ifndef NO_FW_PUNCH		#ifndef NO_FW_PUNCH
/* Firewall control */		/* Firewall control */
static void InitPunchFW(struct libalias *);		static void InitPunchFW(struct libalias *);
static void UninitPunchFW(struct libalias *);		static void UninitPunchFW(struct libalias *);
static void ClearFWHole(struct alias_link *);		static void ClearFWHole(struct alias_link *);

#endif		#endif

/* Log file control */		/* Log file control */
static void ShowAliasStats(struct libalias *);		static void ShowAliasStats(struct libalias *);
static int InitPacketAliasLog(struct libalias *);		static int InitPacketAliasLog(struct libalias *);
static void UninitPacketAliasLog(struct libalias *);		static void UninitPacketAliasLog(struct libalias *);

void SctpShowAliasStats(struct libalias *la);		void SctpShowAliasStats(struct libalias *la);

static u_int		#define INGUARD \
StartPointIn(struct in_addr alias_addr,		if (lnk->alias_port != alias_port \|\| \
u_short alias_port,		lnk->link_type != link_type \|\| \
int link_type)		lnk->alias_addr.s_addr != alias_addr.s_addr) \
		continue;

		static struct group_in *
		StartPointIn(struct libalias *la,
		struct in_addr alias_addr, u_short alias_port, int link_type,
		int create)
{		{
u_int n;		u_int n;
		struct group_in lnk, tmp;

n = alias_addr.s_addr;		n = alias_addr.s_addr;
if (link_type != LINK_PPTP)		if (link_type != LINK_PPTP)
n += alias_port;		n += alias_port;
n += link_type;		n += link_type;
return (n % LINK_TABLE_IN_SIZE);		n %= LINK_TABLE_IN_SIZE;

		LIST_FOREACH_SAFE(lnk, &la->groupTableIn[n], group_in, tmp) {
		/* Auto cleanup */
		if (LIST_EMPTY(&lnk->full) && LIST_EMPTY(&lnk->partial)) {
		LIST_REMOVE(lnk, group_in);
		free(tmp);
		} else {
		INGUARD;
		return (lnk);
}		}
		}
		if (!create \|\| (lnk = malloc(sizeof(*lnk))) == NULL)
		return (lnk);
		lnk->alias_addr = alias_addr;
		lnk->alias_port = alias_port;
		lnk->link_type = link_type;
		LIST_INIT(&lnk->full);
		LIST_INIT(&lnk->partial);
		LIST_INSERT_HEAD(&la->groupTableIn[n], lnk, group_in);
		return (lnk);
		}
		#undef INGUARD

static u_int		static u_int
StartPointOut(struct in_addr src_addr, struct in_addr dst_addr,		StartPointOut(struct in_addr src_addr, struct in_addr dst_addr,
u_short src_port, u_short dst_port, int link_type)		u_short src_port, u_short dst_port, int link_type)
{		{
u_int n;		u_int n;

n = src_addr.s_addr;		n = src_addr.s_addr;
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines
/* Local prototypes */		/* Local prototypes */
static int GetNewPort(struct libalias , struct alias_link , int);		static int GetNewPort(struct libalias , struct alias_link , int);
#ifndef NO_USE_SOCKETS		#ifndef NO_USE_SOCKETS
static u_short GetSocket(struct libalias , u_short, int , int);		static u_short GetSocket(struct libalias , u_short, int , int);
#endif		#endif
static void CleanupAliasData(struct libalias *);		static void CleanupAliasData(struct libalias *);
static void CleanupLink(struct libalias , struct alias_link *);		static void CleanupLink(struct libalias , struct alias_link *);
static void DeleteLink(struct alias_link **);		static void DeleteLink(struct alias_link **);
		static struct alias_link *
		UseLink(struct libalias , struct alias_link );

static struct alias_link *		static struct alias_link *
ReLink(struct alias_link *,		ReLink(struct alias_link *,
struct in_addr, struct in_addr, struct in_addr,		struct in_addr, struct in_addr, struct in_addr,
u_short, u_short, int, int);		u_short, u_short, int, int);

static struct alias_link *		static struct alias_link *
FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);		FindLinkOut(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
▲ Show 20 Lines • Show All 261 Lines • ▼ Show 20 Lines	#endif

return (0);		return (0);
}		}

static void		static void
CleanupAliasData(struct libalias *la)		CleanupAliasData(struct libalias *la)
{		{
struct alias_link lnk, lnk_tmp;		struct alias_link lnk, lnk_tmp;
		struct group_in grp, grp_tmp;
		u_int i;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);

/* permanent entries may stay */		/* permanent entries may stay */
TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, list_expire, lnk_tmp)		TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, list_expire, lnk_tmp)
DeleteLink(&lnk);		DeleteLink(&lnk);

		for (i = 0; i < LINK_TABLE_IN_SIZE; i++)
		LIST_FOREACH_SAFE(grp, &la->groupTableIn[i], group_in, grp_tmp)
		if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
		LIST_REMOVE(grp, group_in);
		free(grp);
}		}
		}

static void		static void
CleanupLink(struct libalias la, struct alias_link *lnk)		CleanupLink(struct libalias la, struct alias_link *lnk)
{		{
LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);

if (lnk == NULL \|\| *lnk == NULL)		if (lnk == NULL \|\| *lnk == NULL)
return;		return;

if (LibAliasTime - (lnk)->timestamp > (lnk)->expire_time) {		if (LibAliasTime - (lnk)->timestamp > (lnk)->expire_time) {
DeleteLink(lnk);		DeleteLink(lnk);
if ((*lnk) == NULL)		if ((*lnk) == NULL)
return;		return;
}		}

/* move to end, swap may fail on a single entry list */		/* move to end, swap may fail on a single entry list */
TAILQ_REMOVE(&la->checkExpire, (*lnk), list_expire);		TAILQ_REMOVE(&la->checkExpire, (*lnk), list_expire);
TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), list_expire);		TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), list_expire);
}		}

		static struct alias_link *
		UseLink(struct libalias la, struct alias_link lnk)
		{
		CleanupLink(la, &lnk);
		if (lnk != NULL)
		lnk->timestamp = LibAliasTime;
		return (lnk);
		}

static void		static void
DeleteLink(struct alias_link **plnk)		DeleteLink(struct alias_link **plnk)
{		{
struct alias_link lnk = plnk;		struct alias_link lnk = plnk;
struct libalias *la = lnk->la;		struct libalias *la = lnk->la;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
/* Don't do anything if the link is marked permanent */		/* Don't do anything if the link is marked permanent */
Show All 9 Lines	#endif
if (lnk->server != NULL) {		if (lnk->server != NULL) {
struct server head, curr, *next;		struct server head, curr, *next;

head = curr = lnk->server;		head = curr = lnk->server;
do {		do {
next = curr->next;		next = curr->next;
free(curr);		free(curr);
} while ((curr = next) != head);		} while ((curr = next) != head);
}		} else {
/* Adjust output table pointers */		/* Adjust output table pointers */
LIST_REMOVE(lnk, list_out);		LIST_REMOVE(lnk, list_out);
		}

/* Adjust input table pointers */		/* Adjust input table pointers */
LIST_REMOVE(lnk, list_in);		LIST_REMOVE(lnk, list_in);

/* remove from housekeeping */		/* remove from housekeeping */
TAILQ_REMOVE(&la->checkExpire, lnk, list_expire);		TAILQ_REMOVE(&la->checkExpire, lnk, list_expire);

#ifndef NO_USE_SOCKETS		#ifndef NO_USE_SOCKETS
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines

struct alias_link *		struct alias_link *
AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr,		AddLink(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr,
struct in_addr alias_addr, u_short src_port, u_short dst_port,		struct in_addr alias_addr, u_short src_port, u_short dst_port,
int alias_port_param, int link_type)		int alias_port_param, int link_type)
{		{
u_int start_point;		u_int start_point;
struct alias_link *lnk;		struct alias_link *lnk;
		struct group_in *grp_in;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);

lnk = malloc(sizeof(struct alias_link));		lnk = malloc(sizeof(struct alias_link));
if (lnk != NULL) {		if (lnk != NULL) {
/* Basic initialization */		/* Basic initialization */
lnk->la = la;		lnk->la = la;
lnk->src_addr = src_addr;		lnk->src_addr = src_addr;
lnk->dst_addr = dst_addr;		lnk->dst_addr = dst_addr;
lnk->alias_addr = alias_addr;		lnk->alias_addr = alias_addr;
lnk->proxy_addr.s_addr = INADDR_ANY;		lnk->proxy_addr.s_addr = INADDR_ANY;
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines	case LINK_FRAGMENT_PTR:
break;		break;
case LINK_ADDR:		case LINK_ADDR:
break;		break;
default:		default:
la->protoLinkCount++;		la->protoLinkCount++;
break;		break;
}		}

		grp_in = StartPointIn(la, alias_addr, lnk->alias_port, link_type, 1);
		if (grp_in == NULL) {
		free(lnk);
		return (NULL);
		}

/* Set up pointers for output lookup table */		/* Set up pointers for output lookup table */
start_point = StartPointOut(src_addr, dst_addr,		start_point = StartPointOut(src_addr, dst_addr,
src_port, dst_port, link_type);		src_port, dst_port, link_type);
LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, list_out);		LIST_INSERT_HEAD(&la->linkTableOut[start_point], lnk, list_out);

/* Set up pointers for input lookup table */		/* Set up pointers for input lookup table */
start_point = StartPointIn(alias_addr, lnk->alias_port, link_type);		if (lnk->flags & LINK_PARTIALLY_SPECIFIED) {
LIST_INSERT_HEAD(&la->linkTableIn[start_point], lnk, list_in);		LIST_INSERT_HEAD(&grp_in->partial, lnk, list_in);
		} else {
		LIST_INSERT_HEAD(&grp_in->full, lnk, list_in);
		}

/* Include the element into the housekeeping list */		/* Include the element into the housekeeping list */
TAILQ_INSERT_TAIL(&la->checkExpire, lnk, list_expire);		TAILQ_INSERT_TAIL(&la->checkExpire, lnk, list_expire);
} else {		} else {
#ifdef LIBALIAS_DEBUG		#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink(): ");		fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");		fprintf(stderr, "malloc() call failed.\n");
#endif		#endif
Show All 31 Lines	if (new_lnk != NULL &&
old_lnk->data.tcp->fwhole > 0) {		old_lnk->data.tcp->fwhole > 0) {
PunchFWHole(new_lnk);		PunchFWHole(new_lnk);
}		}
#endif		#endif
DeleteLink(&old_lnk);		DeleteLink(&old_lnk);
return (new_lnk);		return (new_lnk);
}		}


		#define OUTGUARD \
		if (lnk->src_port != src_port \|\| \
		lnk->src_addr.s_addr != src_addr.s_addr \|\| \
		lnk->dst_addr.s_addr != dst_addr.s_addr \|\| \
		lnk->dst_port != dst_port \|\| \
		lnk->link_type != link_type) \
		continue;

static struct alias_link *		static struct alias_link *
_FindLinkOut(struct libalias *la, struct in_addr src_addr,		_SearchLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,		struct in_addr dst_addr,
u_short src_port,		u_short src_port,
u_short dst_port,		u_short dst_port,
int link_type,		int link_type) {
int replace_partial_links)
{
u_int i;		u_int i;
struct alias_link *lnk;		struct alias_link *lnk;

LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type);		i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) {		LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) {
if (lnk->dst_addr.s_addr == dst_addr.s_addr &&		OUTGUARD;
lnk->src_addr.s_addr == src_addr.s_addr &&		return (UseLink(la, lnk));
lnk->src_port == src_port &&
lnk->dst_port == dst_port &&
lnk->link_type == link_type &&
lnk->server == NULL)
break;
}		}

CleanupLink(la, &lnk);		return (NULL);
if (lnk != NULL)		}
lnk->timestamp = LibAliasTime;

		#undef OUTGUARD

		static struct alias_link *
		_FindLinkOut(struct libalias *la, struct in_addr src_addr,
		struct in_addr dst_addr,
		u_short src_port,
		u_short dst_port,
		int link_type,
		int replace_partial_links)
		{
		struct alias_link *lnk;

		LIBALIAS_LOCK_ASSERT(la);
		lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type);
		if (lnk != NULL \|\| !replace_partial_links)
		return (lnk);

/* Search for partially specified links. */		/* Search for partially specified links. */
if (lnk == NULL && replace_partial_links) {
if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) {		if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) {
lnk = _FindLinkOut(la, src_addr, dst_addr, src_port, 0,		lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, 0,
link_type, 0);		link_type);
if (lnk == NULL)		if (lnk == NULL)
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port,		lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port,
dst_port, link_type, 0);		dst_port, link_type);
}		}
if (lnk == NULL &&		if (lnk == NULL &&
(dst_port != 0 \|\| dst_addr.s_addr != INADDR_ANY)) {		(dst_port != 0 \|\| dst_addr.s_addr != INADDR_ANY)) {
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, 0,		lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port, 0,
link_type, 0);		link_type);
}		}
if (lnk != NULL) {		if (lnk != NULL) {
lnk = ReLink(lnk,		lnk = ReLink(lnk,
src_addr, dst_addr, lnk->alias_addr,		src_addr, dst_addr, lnk->alias_addr,
src_port, dst_port, lnk->alias_port,		src_port, dst_port, lnk->alias_port,
link_type);		link_type);
}		}
}
return (lnk);		return (lnk);
}		}

static struct alias_link *		static struct alias_link *
FindLinkOut(struct libalias *la, struct in_addr src_addr,		FindLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,		struct in_addr dst_addr,
u_short src_port,		u_short src_port,
u_short dst_port,		u_short dst_port,
Show All 10 Lines	if (lnk == NULL) {
/*		/*
* The following allows permanent links to be specified as		* The following allows permanent links to be specified as
* using the default source address (i.e. device interface		* using the default source address (i.e. device interface
* address) without knowing in advance what that address		* address) without knowing in advance what that address
* is.		* is.
*/		*/
if (la->aliasAddress.s_addr != INADDR_ANY &&		if (la->aliasAddress.s_addr != INADDR_ANY &&
src_addr.s_addr == la->aliasAddress.s_addr) {		src_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkOut(la, NO_ADDR, dst_addr, src_port, dst_port,		lnk = _FindLinkOut(la, ANY_ADDR, dst_addr, src_port, dst_port,
link_type, replace_partial_links);		link_type, replace_partial_links);
}		}
}		}
return (lnk);		return (lnk);
}		}

static struct alias_link *		static struct alias_link *
_FindLinkIn(struct libalias *la, struct in_addr dst_addr,		_FindLinkIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr,		struct in_addr alias_addr,
u_short dst_port,		u_short dst_port,
u_short alias_port,		u_short alias_port,
int link_type,		int link_type,
int replace_partial_links)		int replace_partial_links)
{		{
int flags_in;		int flags_in;
u_int start_point;		struct group_in *grp;
struct alias_link *lnk;		struct alias_link *lnk;
struct alias_link *lnk_fully_specified;
struct alias_link *lnk_unknown_all;		struct alias_link *lnk_unknown_all;
struct alias_link *lnk_unknown_dst_addr;		struct alias_link *lnk_unknown_dst_addr;
struct alias_link *lnk_unknown_dst_port;		struct alias_link *lnk_unknown_dst_port;
		struct in_addr src_addr;
		u_short src_port;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
/* Initialize pointers */		/* Initialize pointers */
lnk_fully_specified = NULL;
lnk_unknown_all = NULL;		lnk_unknown_all = NULL;
lnk_unknown_dst_addr = NULL;		lnk_unknown_dst_addr = NULL;
lnk_unknown_dst_port = NULL;		lnk_unknown_dst_port = NULL;

/* If either the dest addr or port is unknown, the search		/* If either the dest addr or port is unknown, the search
* loop will have to know about this. */		* loop will have to know about this. */
flags_in = 0;		flags_in = 0;
if (dst_addr.s_addr == INADDR_ANY)		if (dst_addr.s_addr == INADDR_ANY)
flags_in \|= LINK_UNKNOWN_DEST_ADDR;		flags_in \|= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0)		if (dst_port == 0)
flags_in \|= LINK_UNKNOWN_DEST_PORT;		flags_in \|= LINK_UNKNOWN_DEST_PORT;

/* Search loop */		/* Search loop */
start_point = StartPointIn(alias_addr, alias_port, link_type);		grp = StartPointIn(la, alias_addr, alias_port, link_type, 0);
LIST_FOREACH(lnk, &la->linkTableIn[start_point], list_in) {		if (grp == NULL)
int flags;		return (NULL);

flags = flags_in \| lnk->flags;		switch (flags_in) {
if (!(flags & LINK_PARTIALLY_SPECIFIED)) {		case 0:
if (lnk->alias_addr.s_addr == alias_addr.s_addr		LIST_FOREACH(lnk, &grp->full, list_in) {
&& lnk->alias_port == alias_port		if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
&& lnk->dst_addr.s_addr == dst_addr.s_addr		lnk->dst_port == dst_port)
&& lnk->dst_port == dst_port		return (UseLink(la, lnk));
&& lnk->link_type == link_type) {		}
lnk_fully_specified = lnk;
break;		break;
		case LINK_UNKNOWN_DEST_PORT:
		LIST_FOREACH(lnk, &grp->full, list_in) {
		if(lnk->dst_addr.s_addr == dst_addr.s_addr) {
		lnk_unknown_dst_port = lnk;
		break;
}		}
} else if ((flags & LINK_UNKNOWN_DEST_ADDR)
&& (flags & LINK_UNKNOWN_DEST_PORT)) {
if (lnk->alias_addr.s_addr == alias_addr.s_addr
&& lnk->alias_port == alias_port
&& lnk->link_type == link_type) {
if (lnk_unknown_all == NULL)
lnk_unknown_all = lnk;
}		}
} else if (flags & LINK_UNKNOWN_DEST_ADDR) {		break;
if (lnk->alias_addr.s_addr == alias_addr.s_addr		case LINK_UNKNOWN_DEST_ADDR:
&& lnk->alias_port == alias_port		LIST_FOREACH(lnk, &grp->full, list_in) {
&& lnk->link_type == link_type		if(lnk->dst_port == dst_port) {
&& lnk->dst_port == dst_port) {
if (lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk;		lnk_unknown_dst_addr = lnk;
		break;
}		}
} else if (flags & LINK_UNKNOWN_DEST_PORT) {		}
if (lnk->alias_addr.s_addr == alias_addr.s_addr		break;
&& lnk->alias_port == alias_port		case LINK_PARTIALLY_SPECIFIED:
&& lnk->link_type == link_type		lnk_unknown_all = LIST_FIRST(&grp->full);
&& lnk->dst_addr.s_addr == dst_addr.s_addr) {		break;
if (lnk_unknown_dst_port == NULL)		}

		if (lnk_unknown_dst_port == NULL) {
		LIST_FOREACH(lnk, &grp->partial, list_in) {
		int flags = (flags_in \| lnk->flags) & LINK_PARTIALLY_SPECIFIED;

		if (flags == LINK_PARTIALLY_SPECIFIED &&
		lnk_unknown_all == NULL)
		lnk_unknown_all = lnk;
		if (flags == LINK_UNKNOWN_DEST_ADDR &&
		lnk->dst_port == dst_port &&
		lnk_unknown_dst_addr == NULL)
		lnk_unknown_dst_addr = lnk;
		if (flags == LINK_UNKNOWN_DEST_PORT &&
		lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk;		lnk_unknown_dst_port = lnk;
		break;
}		}
}		}
}		}

CleanupLink(la, &lnk_fully_specified);		lnk = (lnk_unknown_dst_port != NULL) ? lnk_unknown_dst_port
if (lnk_fully_specified != NULL) {		: (lnk_unknown_dst_addr != NULL) ? lnk_unknown_dst_addr
lnk_fully_specified->timestamp = LibAliasTime;		: lnk_unknown_all;
lnk = lnk_fully_specified;
} else if (lnk_unknown_dst_port != NULL)
lnk = lnk_unknown_dst_port;
else if (lnk_unknown_dst_addr != NULL)
lnk = lnk_unknown_dst_addr;
else if (lnk_unknown_all != NULL)
lnk = lnk_unknown_all;
else
return (NULL);

if (replace_partial_links &&		if (lnk == NULL \|\| !replace_partial_links)
(lnk->flags & LINK_PARTIALLY_SPECIFIED \|\| lnk->server != NULL)) {		return (lnk);
struct in_addr src_addr;
u_short src_port;

if (lnk->server != NULL) { /* LSNAT link */		if (lnk->server != NULL) { /* LSNAT link */
src_addr = lnk->server->addr;		src_addr = lnk->server->addr;
src_port = lnk->server->port;		src_port = lnk->server->port;
lnk->server = lnk->server->next;		lnk->server = lnk->server->next;
} else {		} else {
src_addr = lnk->src_addr;		src_addr = lnk->src_addr;
src_port = lnk->src_port;		src_port = lnk->src_port;
}		}

if (link_type == LINK_SCTP) {		if (link_type == LINK_SCTP) {
lnk->src_addr = src_addr;		lnk->src_addr = src_addr;
lnk->src_port = src_port;		lnk->src_port = src_port;
return (lnk);		} else {
}
lnk = ReLink(lnk,		lnk = ReLink(lnk,
src_addr, dst_addr, alias_addr,		src_addr, dst_addr, alias_addr,
src_port, dst_port, alias_port,		src_port, dst_port, alias_port,
link_type);		link_type);
}		}
return (lnk);		return (lnk);
}		}

Show All 15 Lines	if (lnk == NULL) {
/*		/*
* The following allows permanent links to be specified as		* The following allows permanent links to be specified as
* using the default aliasing address (i.e. device		* using the default aliasing address (i.e. device
* interface address) without knowing in advance what that		* interface address) without knowing in advance what that
* address is.		* address is.
*/		*/
if (la->aliasAddress.s_addr != INADDR_ANY &&		if (la->aliasAddress.s_addr != INADDR_ANY &&
alias_addr.s_addr == la->aliasAddress.s_addr) {		alias_addr.s_addr == la->aliasAddress.s_addr) {
lnk = _FindLinkIn(la, dst_addr, NO_ADDR, dst_port, alias_port,		lnk = _FindLinkIn(la, dst_addr, ANY_ADDR, dst_port, alias_port,
link_type, replace_partial_links);		link_type, replace_partial_links);
}		}
}		}
return (lnk);		return (lnk);
}		}

/* External routines for finding/adding links		/* External routines for finding/adding links

▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines	FindFragmentIn1(struct libalias *la, struct in_addr dst_addr,
struct alias_link *lnk;		struct alias_link *lnk;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr,		lnk = FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id,		NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0);		LINK_FRAGMENT_ID, 0);

if (lnk == NULL) {		if (lnk == NULL) {
lnk = AddLink(la, NO_ADDR, dst_addr, alias_addr,		lnk = AddLink(la, ANY_ADDR, dst_addr, alias_addr,
NO_SRC_PORT, NO_DEST_PORT, ip_id,		NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID);		LINK_FRAGMENT_ID);
}		}
return (lnk);		return (lnk);
}		}

/* Doesn't add a link if one is not found. */		/* Doesn't add a link if one is not found. */
struct alias_link *		struct alias_link *
FindFragmentIn2(struct libalias *la, struct in_addr dst_addr,		FindFragmentIn2(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr, u_short ip_id)		struct in_addr alias_addr, u_short ip_id)
{		{
LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, alias_addr,		return FindLinkIn(la, dst_addr, alias_addr,
NO_DEST_PORT, ip_id,		NO_DEST_PORT, ip_id,
LINK_FRAGMENT_ID, 0);		LINK_FRAGMENT_ID, 0);
}		}

struct alias_link *		struct alias_link *
AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr,		AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr,
u_short ip_id)		u_short ip_id)
{		{
LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
return AddLink(la, NO_ADDR, dst_addr, NO_ADDR,		return AddLink(la, ANY_ADDR, dst_addr, ANY_ADDR,
NO_SRC_PORT, NO_DEST_PORT, ip_id,		NO_SRC_PORT, NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR);		LINK_FRAGMENT_PTR);
}		}

struct alias_link *		struct alias_link *
FindFragmentPtr(struct libalias *la, struct in_addr dst_addr,		FindFragmentPtr(struct libalias *la, struct in_addr dst_addr,
u_short ip_id)		u_short ip_id)
{		{
LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
return FindLinkIn(la, dst_addr, NO_ADDR,		return FindLinkIn(la, dst_addr, ANY_ADDR,
NO_DEST_PORT, ip_id,		NO_DEST_PORT, ip_id,
LINK_FRAGMENT_PTR, 0);		LINK_FRAGMENT_PTR, 0);
}		}

struct alias_link *		struct alias_link *
FindProtoIn(struct libalias *la, struct in_addr dst_addr,		FindProtoIn(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr,		struct in_addr alias_addr,
u_char proto)		u_char proto)
▲ Show 20 Lines • Show All 143 Lines • ▼ Show 20 Lines	FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr,
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP);		i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP);
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out)		LIST_FOREACH(lnk, &la->linkTableOut[i], list_out)
if (lnk->link_type == LINK_PPTP &&		if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&		lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr &&		lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->src_port == src_call_id)		lnk->src_port == src_call_id)
break;		break;

CleanupLink(la, &lnk);		return (UseLink(la, lnk));
return (lnk);
}		}

struct alias_link *		struct alias_link *
FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr,		FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,		struct in_addr dst_addr,
u_int16_t dst_call_id)		u_int16_t dst_call_id)
{		{
u_int i;		u_int i;
struct alias_link *lnk;		struct alias_link *lnk;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP);		i = StartPointOut(src_addr, dst_addr, 0, 0, LINK_PPTP);
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out)		LIST_FOREACH(lnk, &la->linkTableOut[i], list_out)
if (lnk->link_type == LINK_PPTP &&		if (lnk->link_type == LINK_PPTP &&
lnk->src_addr.s_addr == src_addr.s_addr &&		lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->dst_addr.s_addr == dst_addr.s_addr &&		lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->dst_port == dst_call_id)		lnk->dst_port == dst_call_id)
break;		break;

CleanupLink(la, &lnk);		return (UseLink(la, lnk));
return (lnk);
}		}

struct alias_link *		struct alias_link *
FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr,		FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr,		struct in_addr alias_addr,
u_int16_t dst_call_id)		u_int16_t dst_call_id)
{		{
u_int i;		struct group_in *grp;
struct alias_link *lnk;		struct alias_link *lnk;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
i = StartPointIn(alias_addr, 0, LINK_PPTP);
LIST_FOREACH(lnk, &la->linkTableIn[i], list_in)		grp = StartPointIn(la, alias_addr, 0, LINK_PPTP, 0);
if (lnk->link_type == LINK_PPTP &&		if (grp == NULL)
lnk->dst_addr.s_addr == dst_addr.s_addr &&		return (NULL);
lnk->alias_addr.s_addr == alias_addr.s_addr &&
		LIST_FOREACH(lnk, &grp->full, list_in)
		if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->dst_port == dst_call_id)		lnk->dst_port == dst_call_id)
break;		break;

CleanupLink(la, &lnk);		return (UseLink(la, lnk));
return (lnk);
}		}

struct alias_link *		struct alias_link *
FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr,		FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr,
struct in_addr alias_addr,		struct in_addr alias_addr,
u_int16_t alias_call_id)		u_int16_t alias_call_id)
{		{
struct alias_link *lnk;		struct alias_link *lnk;
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
}		}

struct in_addr		struct in_addr
FindOriginalAddress(struct libalias *la, struct in_addr alias_addr)		FindOriginalAddress(struct libalias *la, struct in_addr alias_addr)
{		{
struct alias_link *lnk;		struct alias_link *lnk;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, NO_ADDR, alias_addr,		lnk = FindLinkIn(la, ANY_ADDR, alias_addr,
0, 0, LINK_ADDR, 0);		0, 0, LINK_ADDR, 0);
if (lnk == NULL) {		if (lnk == NULL) {
la->newDefaultLink = 1;		la->newDefaultLink = 1;
if (la->targetAddress.s_addr == INADDR_ANY)		if (la->targetAddress.s_addr == INADDR_ANY)
return (alias_addr);		return (alias_addr);
else if (la->targetAddress.s_addr == INADDR_NONE)		else if (la->targetAddress.s_addr == INADDR_NONE)
return (la->aliasAddress.s_addr != INADDR_ANY) ?		return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : alias_addr;		la->aliasAddress : alias_addr;
Show All 15 Lines
}		}

struct in_addr		struct in_addr
FindAliasAddress(struct libalias *la, struct in_addr original_addr)		FindAliasAddress(struct libalias *la, struct in_addr original_addr)
{		{
struct alias_link *lnk;		struct alias_link *lnk;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkOut(la, original_addr, NO_ADDR,		lnk = FindLinkOut(la, original_addr, ANY_ADDR,
0, 0, LINK_ADDR, 0);		0, 0, LINK_ADDR, 0);
if (lnk == NULL) {		if (lnk == NULL) {
return (la->aliasAddress.s_addr != INADDR_ANY) ?		return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr;		la->aliasAddress : original_addr;
} else {		} else {
if (lnk->alias_addr.s_addr == INADDR_ANY)		if (lnk->alias_addr.s_addr == INADDR_ANY)
return (la->aliasAddress.s_addr != INADDR_ANY) ?		return (la->aliasAddress.s_addr != INADDR_ANY) ?
la->aliasAddress : original_addr;		la->aliasAddress : original_addr;
▲ Show 20 Lines • Show All 535 Lines • ▼ Show 20 Lines	LibAliasAddServer(struct libalias la, struct alias_link lnk, struct in_addr addr, u_short port)

if (server != NULL) {		if (server != NULL) {
struct server *head;		struct server *head;

server->addr = addr;		server->addr = addr;
server->port = port;		server->port = port;

head = lnk->server;		head = lnk->server;
if (head == NULL)		if (head == NULL) {
server->next = server;		server->next = server;
else {		/* not usable for outgoing connections */
		LIST_REMOVE(lnk, list_out);
		} else {
struct server *s;		struct server *s;

for (s = head; s->next != head; s = s->next)		for (s = head; s->next != head; s = s->next)
;		;
s->next = server;		s->next = server;
server->next = head;		server->next = head;
}		}
lnk->server = server;		lnk->server = server;
Show All 37 Lines
/* Static address translation */		/* Static address translation */
struct alias_link *		struct alias_link *
LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr,		LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr,
struct in_addr alias_addr)		struct in_addr alias_addr)
{		{
struct alias_link *lnk;		struct alias_link *lnk;

LIBALIAS_LOCK(la);		LIBALIAS_LOCK(la);
lnk = AddLink(la, src_addr, NO_ADDR, alias_addr,		lnk = AddLink(la, src_addr, ANY_ADDR, alias_addr,
0, 0, 0,		0, 0, 0,
LINK_ADDR);		LINK_ADDR);

if (lnk != NULL) {		if (lnk != NULL) {
lnk->flags \|= LINK_PERMANENT;		lnk->flags \|= LINK_PERMANENT;
}		}
#ifdef LIBALIAS_DEBUG		#ifdef LIBALIAS_DEBUG
else {		else {
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines	#ifdef _KERNEL
LibAliasTime = time_uptime;		LibAliasTime = time_uptime;
#else		#else
LibAliasTime = time(NULL);		LibAliasTime = time(NULL);
#endif		#endif

for (i = 0; i < LINK_TABLE_OUT_SIZE; i++)		for (i = 0; i < LINK_TABLE_OUT_SIZE; i++)
LIST_INIT(&la->linkTableOut[i]);		LIST_INIT(&la->linkTableOut[i]);
for (i = 0; i < LINK_TABLE_IN_SIZE; i++)		for (i = 0; i < LINK_TABLE_IN_SIZE; i++)
LIST_INIT(&la->linkTableIn[i]);		LIST_INIT(&la->groupTableIn[i]);
TAILQ_INIT(&la->checkExpire);		TAILQ_INIT(&la->checkExpire);
#ifdef _KERNEL		#ifdef _KERNEL
AliasSctpInit(la);		AliasSctpInit(la);
#endif		#endif
LIBALIAS_LOCK_INIT(la);		LIBALIAS_LOCK_INIT(la);
LIBALIAS_LOCK(la);		LIBALIAS_LOCK(la);
} else {		} else {
LIBALIAS_LOCK(la);		LIBALIAS_LOCK(la);
▲ Show 20 Lines • Show All 399 Lines • Show Last 20 Lines