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

Changeset View

Standalone View

sys/netinet/libalias/alias_db.c

Show First 20 Lines • Show All 213 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;		/* Never matches a real address. Address is known to be ignored. */
		static struct in_addr const NO_ADDR = { 0xfffeefff };

/* 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 795 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;
}		}

/* Set up pointers for output lookup table */		/* Set up pointers for lookup tables */
		if (lnk->flags & LINK_PARTIALLY_SPECIFIED) {
		LIST_INSERT_HEAD(&la->linkPartial, lnk, list_out);
		} else {
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 */		start_point = StartPointIn(alias_addr,
start_point = StartPointIn(alias_addr, lnk->alias_port, link_type);		lnk->alias_port, link_type);
LIST_INSERT_HEAD(&la->linkTableIn[start_point], lnk, list_in);		LIST_INSERT_HEAD(&la->linkTableIn[start_point],
		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 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	_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,
int link_type,		int link_type,
int replace_partial_links)		int replace_partial_links)
{		{
u_int i;		u_int i;
struct alias_link *lnk;		struct alias_link *lnk;
		struct alias_link *lnk_addr = NULL;
		struct alias_link *lnk_port = NULL;
		struct alias_link *lnk_any = NULL;

LIBALIAS_LOCK_ASSERT(la);		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 &&		if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->src_addr.s_addr == src_addr.s_addr &&		lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->src_port == src_port &&		lnk->src_port == src_port &&
lnk->dst_port == dst_port &&		lnk->dst_port == dst_port &&
lnk->link_type == link_type &&		lnk->link_type == link_type &&
lnk->server == NULL) {		lnk->server == NULL) {
lnk->timestamp = la->timeStamp;		lnk->timestamp = la->timeStamp;
break;		return (lnk);
}		}
}		}

		if (!replace_partial_links)
		return (lnk);

/* Search for partially specified links. */		/* Search for partially specified links. */
if (lnk == NULL && replace_partial_links) {		LIST_FOREACH(lnk, &la->linkPartial, list_out) {
if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) {		if (lnk->src_port != src_port \|\|
lnk = _FindLinkOut(la, src_addr, dst_addr, src_port, 0,		lnk->src_addr.s_addr != src_addr.s_addr \|\|
link_type, 0);		lnk->link_type != link_type \|\|
if (lnk == NULL)		lnk->server != NULL)
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port,		continue;
dst_port, link_type, 0);
		if (lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_port == 0) {
		lnk_addr = lnk;
		break;
}		}
if (lnk == NULL &&
(dst_port != 0 \|\| dst_addr.s_addr != INADDR_ANY)) {		if (lnk->dst_addr.s_addr == INADDR_ANY && lnk->dst_port == dst_port)
lnk = _FindLinkOut(la, src_addr, NO_ADDR, src_port, 0,		lnk_port = lnk;
link_type, 0);
		if (lnk->dst_addr.s_addr == INADDR_ANY && lnk->dst_port == 0)
		lnk_any = lnk;
}		}

		lnk = (lnk_addr != NULL) ? lnk_addr
		: (lnk_port != NULL) ? lnk_port
		: lnk_any;

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 = 0;
u_int start_point;		u_int start_point;
struct alias_link *lnk;		struct alias_link *lnk;
struct alias_link *lnk_fully_specified;		struct alias_link *lnk_unknown_all = NULL;
struct alias_link *lnk_unknown_all;		struct alias_link *lnk_unknown_dst_addr = NULL;
struct alias_link *lnk_unknown_dst_addr;		struct alias_link *lnk_unknown_dst_port = NULL;
struct alias_link *lnk_unknown_dst_port;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
/* Initialize pointers */
lnk_fully_specified = NULL;
lnk_unknown_all = NULL;
lnk_unknown_dst_addr = 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;
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);		#define INCMP(f) { \
LIST_FOREACH(lnk, &la->linkTableIn[start_point], list_in) {		int flags = f; \
int flags;		\
		if (lnk->alias_port != alias_port \|\| \
		lnk->link_type != link_type \|\| \
		lnk->alias_addr.s_addr != alias_addr.s_addr)\
		continue; \
		\
		if ((flags & LINK_UNKNOWN_DEST_ADDR) && \
		(flags & LINK_UNKNOWN_DEST_PORT) && \
		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 == NULL) \
		lnk_unknown_dst_port = lnk; \
		}

flags = flags_in \| lnk->flags;		start_point = StartPointIn(alias_addr, alias_port, link_type);
if (!(flags & LINK_PARTIALLY_SPECIFIED)) {		if (!(flags_in & LINK_PARTIALLY_SPECIFIED)) {
		LIST_FOREACH(lnk, &la->linkTableIn[start_point], list_in)
if (lnk->alias_addr.s_addr == alias_addr.s_addr		if (lnk->alias_addr.s_addr == alias_addr.s_addr
&& lnk->alias_port == alias_port		&& lnk->alias_port == alias_port
&& 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
&& lnk->link_type == link_type) {		&& lnk->link_type == link_type) {
lnk_fully_specified = lnk;		lnk->timestamp = la->timeStamp;
break;		return (lnk);
}		}
} else if ((flags & LINK_UNKNOWN_DEST_ADDR)		} else {
&& (flags & LINK_UNKNOWN_DEST_PORT)) {		LIST_FOREACH(lnk, &la->linkTableIn[start_point], list_in)
if (lnk->alias_addr.s_addr == alias_addr.s_addr		INCMP(flags_in);
&& 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) {		LIST_FOREACH(lnk, &la->linkPartial, list_in)
if (lnk->alias_addr.s_addr == alias_addr.s_addr		INCMP(flags_in \| lnk->flags);
&& lnk->alias_port == alias_port		#undef INCMP
&& lnk->link_type == link_type
&& lnk->dst_port == dst_port) {
if (lnk_unknown_dst_addr == NULL)
lnk_unknown_dst_addr = lnk;
}
} else if (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
&& lnk->dst_addr.s_addr == dst_addr.s_addr) {
if (lnk_unknown_dst_port == NULL)
lnk_unknown_dst_port = lnk;
}
}
}

if (lnk_fully_specified != NULL) {		if (lnk_unknown_dst_port != NULL)
lnk_fully_specified->timestamp = la->timeStamp;
lnk = lnk_fully_specified;
} else if (lnk_unknown_dst_port != NULL)
lnk = lnk_unknown_dst_port;		lnk = lnk_unknown_dst_port;
else if (lnk_unknown_dst_addr != NULL)		else if (lnk_unknown_dst_addr != NULL)
lnk = lnk_unknown_dst_addr;		lnk = lnk_unknown_dst_addr;
else if (lnk_unknown_all != NULL)		else if (lnk_unknown_all != NULL)
lnk = lnk_unknown_all;		lnk = lnk_unknown_all;
else		else
return (NULL);		return (NULL);

▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 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 88 Lines • ▼ Show 20 Lines	return FindLinkIn(la, dst_addr, alias_addr,
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, NO_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 243 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 580 Lines • ▼ Show 20 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 106 Lines • ▼ Show 20 Lines	#else
gettimeofday(&tv, NULL);		gettimeofday(&tv, NULL);
la->timeStamp = tv.tv_sec;		la->timeStamp = tv.tv_sec;
#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->linkTableIn[i]);
		LIST_INIT(&la->linkPartial);
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