Differential D30580 Diff 91116 sys/netinet/libalias/alias_db.c

Changeset View

Standalone View

sys/netinet/libalias/alias_db.c

Show First 20 Lines • Show All 316 Lines • ▼ Show 20 Lines
#define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */		#define LINK_PARTIALLY_SPECIFIED 0x03 /* logical-or of first two bits */
#define LINK_UNFIREWALLED 0x08		#define LINK_UNFIREWALLED 0x08

int timestamp; /* Time link was last accessed */		int timestamp; /* Time link was last accessed */
#ifndef NO_USE_SOCKETS		#ifndef NO_USE_SOCKETS
int sockfd; /* socket descriptor */		int sockfd; /* socket descriptor */
#endif		#endif
/* Linked list of pointers for input and output lookup tables */		/* Linked list of pointers for input and output lookup tables */
LIST_ENTRY (alias_link) list_out;		union {
LIST_ENTRY (alias_link) list_in;
struct {		struct {
		LIST_ENTRY(alias_link) in;
		LIST_ENTRY(alias_link) out;
		} all;
		struct {
		LIST_ENTRY(alias_link) list;
		} pptp;
		};
		struct {
TAILQ_ENTRY(alias_link) list;		TAILQ_ENTRY(alias_link) list;
int time; /* Expire time for link */		int time; /* Expire time for link */
} expire;		} expire;
/* Auxiliary data */		/* Auxiliary data */
union {		union {
char *frag_ptr;		char *frag_ptr;
struct in_addr frag_addr;		struct in_addr frag_addr;
struct tcp_dat *tcp;		struct tcp_dat *tcp;
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
StartPointIn(struct libalias *la,		StartPointIn(struct libalias *la,
struct in_addr alias_addr, u_short alias_port, int link_type,		struct in_addr alias_addr, u_short alias_port, int link_type,
int create)		int create)
{		{
u_int n;		u_int n;
struct group_in grp, tmp;		struct group_in grp, tmp;

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

LIST_FOREACH_SAFE(grp, &la->groupTableIn[n], group_in, tmp) {		LIST_FOREACH_SAFE(grp, &la->groupTableIn[n], group_in, tmp) {
/* Auto cleanup */		/* Auto cleanup */
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {		if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);		LIST_REMOVE(grp, group_in);
free(grp);		free(grp);
Show All 17 Lines
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;
n += dst_addr.s_addr;		n += dst_addr.s_addr;
if (link_type != LINK_PPTP) {
n += src_port;		n += src_port;
n += dst_port;		n += dst_port;
}
n += link_type;		n += link_type;

return (n % LINK_TABLE_OUT_SIZE);		return (n % LINK_TABLE_OUT_SIZE);
}		}

static int		static int
SeqDiff(u_long x, u_long y)		SeqDiff(u_long x, u_long y)
{		{
▲ Show 20 Lines • Show All 364 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;		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, expire.list, lnk_tmp)		TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, expire.list, lnk_tmp)
DeleteLink(&lnk);		DeleteLink(&lnk);

for (i = 0; i < LINK_TABLE_IN_SIZE; i++)		for (i = 0; i < LINK_TABLE_IN_SIZE; i++) {
		struct group_in grp, grp_tmp;

LIST_FOREACH_SAFE(grp, &la->groupTableIn[i], group_in, grp_tmp)		LIST_FOREACH_SAFE(grp, &la->groupTableIn[i], group_in, grp_tmp)
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {		if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);		LIST_REMOVE(grp, group_in);
free(grp);		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;
Show All 29 Lines	DeleteLink(struct alias_link **plnk)
if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT)		if (la->deleteAllLinks == 0 && lnk->flags & LINK_PERMANENT)
return;		return;

#ifndef NO_FW_PUNCH		#ifndef NO_FW_PUNCH
/* Delete associated firewall hole, if any */		/* Delete associated firewall hole, if any */
ClearFWHole(lnk);		ClearFWHole(lnk);
#endif		#endif

		switch (lnk->link_type) {
		case LINK_PPTP:
		LIST_REMOVE(lnk, pptp.list);
		break;
		default:
/* Free memory allocated for LSNAT server pool */		/* Free memory allocated for LSNAT server pool */
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 {		} else {
/* Adjust output table pointers */		/* Adjust output table pointers */
LIST_REMOVE(lnk, list_out);		LIST_REMOVE(lnk, all.out);
}		}

/* Adjust input table pointers */		/* Adjust input table pointers */
LIST_REMOVE(lnk, list_in);		LIST_REMOVE(lnk, all.in);
		break;
		}

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

#ifndef NO_USE_SOCKETS		#ifndef NO_USE_SOCKETS
/* Close socket, if one has been allocated */		/* Close socket, if one has been allocated */
if (lnk->sockfd != -1) {		if (lnk->sockfd != -1) {
la->sockCount--;		la->sockCount--;
▲ Show 20 Lines • Show All 42 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) {
		#ifdef LIBALIAS_DEBUG
		fprintf(stderr, "PacketAlias/AddLink(): ");
		fprintf(stderr, "malloc() call failed.\n");
		#endif
		return (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;
lnk->src_port = src_port;		lnk->src_port = src_port;
lnk->dst_port = dst_port;		lnk->dst_port = dst_port;
lnk->proxy_port = 0;		lnk->proxy_port = 0;
lnk->server = NULL;		lnk->server = NULL;
lnk->link_type = link_type;		lnk->link_type = link_type;
#ifndef NO_USE_SOCKETS		#ifndef NO_USE_SOCKETS
lnk->sockfd = -1;		lnk->sockfd = -1;
#endif		#endif
lnk->flags = 0;		lnk->flags = 0;
lnk->pflags = 0;		lnk->pflags = 0;
lnk->timestamp = LibAliasTime;		lnk->timestamp = LibAliasTime;

/* Expiration time */		/* Expiration time */
switch (link_type) {		switch (link_type) {
case LINK_ICMP:		case LINK_ICMP:
lnk->expire.time = ICMP_EXPIRE_TIME;		lnk->expire.time = ICMP_EXPIRE_TIME;
break;		break;
case LINK_UDP:		case LINK_UDP:
lnk->expire.time = UDP_EXPIRE_TIME;		lnk->expire.time = UDP_EXPIRE_TIME;
break;		break;
case LINK_TCP:		case LINK_TCP:
lnk->expire.time = TCP_EXPIRE_INITIAL;		lnk->expire.time = TCP_EXPIRE_INITIAL;
break;		break;
case LINK_PPTP:
lnk->flags \|= LINK_PERMANENT; /* no timeout. */
break;
case LINK_FRAGMENT_ID:		case LINK_FRAGMENT_ID:
lnk->expire.time = FRAGMENT_ID_EXPIRE_TIME;		lnk->expire.time = FRAGMENT_ID_EXPIRE_TIME;
break;		break;
case LINK_FRAGMENT_PTR:		case LINK_FRAGMENT_PTR:
lnk->expire.time = FRAGMENT_PTR_EXPIRE_TIME;		lnk->expire.time = FRAGMENT_PTR_EXPIRE_TIME;
break;		break;
case LINK_ADDR:		case LINK_ADDR:
break;		break;
default:		default:
lnk->expire.time = PROTO_EXPIRE_TIME;		lnk->expire.time = PROTO_EXPIRE_TIME;
break;		break;
}		}

/* Determine alias flags */		/* Determine alias flags */
if (dst_addr.s_addr == INADDR_ANY)		if (dst_addr.s_addr == INADDR_ANY)
lnk->flags \|= LINK_UNKNOWN_DEST_ADDR;		lnk->flags \|= LINK_UNKNOWN_DEST_ADDR;
if (dst_port == 0)		if (dst_port == 0)
lnk->flags \|= LINK_UNKNOWN_DEST_PORT;		lnk->flags \|= LINK_UNKNOWN_DEST_PORT;

/* Determine alias port */		/* Determine alias port */
if (GetNewPort(la, lnk, alias_port_param) != 0) {		if (GetNewPort(la, lnk, alias_port_param) != 0) {
free(lnk);		free(lnk);
return (NULL);		return (NULL);
}		}
/* Link-type dependent initialization */		/* Link-type dependent initialization */
switch (link_type) {		switch (link_type) {
struct tcp_dat *aux_tcp;

case LINK_ICMP:		case LINK_ICMP:
la->icmpLinkCount++;		la->icmpLinkCount++;
break;		break;
case LINK_UDP:		case LINK_UDP:
la->udpLinkCount++;		la->udpLinkCount++;
break;		break;
case LINK_TCP:		case LINK_TCP: {
aux_tcp = malloc(sizeof(struct tcp_dat));		struct tcp_dat *aux_tcp;
if (aux_tcp != NULL) {
int i;		int i;

		aux_tcp = malloc(sizeof(struct tcp_dat));
		if (aux_tcp == NULL) {
		#ifdef LIBALIAS_DEBUG
		fprintf(stderr, "PacketAlias/AddLink: ");
		fprintf(stderr, " cannot allocate auxiliary TCP data\n");
		#endif
		free(lnk);
		return (NULL);
		}

la->tcpLinkCount++;		la->tcpLinkCount++;
aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED;		aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED;		aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED;
aux_tcp->state.index = 0;		aux_tcp->state.index = 0;
aux_tcp->state.ack_modified = 0;		aux_tcp->state.ack_modified = 0;
for (i = 0; i < N_LINK_TCP_DATA; i++)		for (i = 0; i < N_LINK_TCP_DATA; i++)
aux_tcp->ack[i].active = 0;		aux_tcp->ack[i].active = 0;
aux_tcp->fwhole = -1;		aux_tcp->fwhole = -1;
lnk->data.tcp = aux_tcp;		lnk->data.tcp = aux_tcp;
} else {
#ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/AddLink: ");
fprintf(stderr, " cannot allocate auxiliary TCP data\n");
#endif
free(lnk);
return (NULL);
}		}
break;		break;
case LINK_PPTP:		case LINK_PPTP:
la->pptpLinkCount++;		la->pptpLinkCount++;
break;		break;
case LINK_FRAGMENT_ID:		case LINK_FRAGMENT_ID:
la->fragmentIdLinkCount++;		la->fragmentIdLinkCount++;
break;		break;
case LINK_FRAGMENT_PTR:		case LINK_FRAGMENT_PTR:
la->fragmentPtrLinkCount++;		la->fragmentPtrLinkCount++;
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);		switch (link_type) {
if (grp_in == NULL) {		case LINK_PPTP:
		LIST_INSERT_HEAD(&la->pptpList, lnk, pptp.list);
		break;
		default: {
		struct group_in *grp;

		grp = StartPointIn(la, alias_addr, lnk->alias_port, link_type, 1);
		if (grp == NULL) {
free(lnk);		free(lnk);
return (NULL);		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, all.out);

/* Set up pointers for input lookup table */		/* Set up pointers for input lookup table */
if (lnk->flags & LINK_PARTIALLY_SPECIFIED) {		if (lnk->flags & LINK_PARTIALLY_SPECIFIED)
LIST_INSERT_HEAD(&grp_in->partial, lnk, list_in);		LIST_INSERT_HEAD(&grp->partial, lnk, all.in);
} else {		else
LIST_INSERT_HEAD(&grp_in->full, lnk, list_in);		LIST_INSERT_HEAD(&grp->full, lnk, all.in);
}		}
		break;
		}

/* Include the element into the housekeeping list */		/* Include the element into the housekeeping list */
TAILQ_INSERT_TAIL(&la->checkExpire, lnk, expire.list);		TAILQ_INSERT_TAIL(&la->checkExpire, lnk, expire.list);
} else {
#ifdef LIBALIAS_DEBUG		if (la->packetAliasMode & PKT_ALIAS_LOG)
fprintf(stderr, "PacketAlias/AddLink(): ");
fprintf(stderr, "malloc() call failed.\n");
#endif
}
if (la->packetAliasMode & PKT_ALIAS_LOG) {
ShowAliasStats(la);		ShowAliasStats(la);
}
return (lnk);		return (lnk);
}		}

/*		/*
* If alias_port_param is less than zero, alias port will be automatically		* If alias_port_param is less than zero, alias port will be automatically
* chosen. If greater than zero, equal to alias port		* chosen. If greater than zero, equal to alias port
*/		*/
static struct alias_link *		static struct alias_link *
Show All 38 Lines	_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) {
u_int i;		u_int i;
struct alias_link *lnk;		struct alias_link *lnk;

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], all.out) {
OUTGUARD;		OUTGUARD;
return (UseLink(la, lnk));		return (UseLink(la, lnk));
}		}

return (NULL);		return (NULL);
}		}

#undef OUTGUARD		#undef OUTGUARD
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines	_FindLinkIn(struct libalias *la, struct in_addr dst_addr,

/* Search loop */		/* Search loop */
grp = StartPointIn(la, alias_addr, alias_port, link_type, 0);		grp = StartPointIn(la, alias_addr, alias_port, link_type, 0);
if (grp == NULL)		if (grp == NULL)
return (NULL);		return (NULL);

switch (flags_in) {		switch (flags_in) {
case 0:		case 0:
LIST_FOREACH(lnk, &grp->full, list_in) {		LIST_FOREACH(lnk, &grp->full, all.in) {
if (lnk->dst_addr.s_addr == dst_addr.s_addr &&		if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->dst_port == dst_port)		lnk->dst_port == dst_port)
return (UseLink(la, lnk));		return (UseLink(la, lnk));
}		}
break;		break;
case LINK_UNKNOWN_DEST_PORT:		case LINK_UNKNOWN_DEST_PORT:
LIST_FOREACH(lnk, &grp->full, list_in) {		LIST_FOREACH(lnk, &grp->full, all.in) {
if(lnk->dst_addr.s_addr == dst_addr.s_addr) {		if(lnk->dst_addr.s_addr == dst_addr.s_addr) {
lnk_unknown_dst_port = lnk;		lnk_unknown_dst_port = lnk;
break;		break;
}		}
}		}
break;		break;
case LINK_UNKNOWN_DEST_ADDR:		case LINK_UNKNOWN_DEST_ADDR:
LIST_FOREACH(lnk, &grp->full, list_in) {		LIST_FOREACH(lnk, &grp->full, all.in) {
if(lnk->dst_port == dst_port) {		if(lnk->dst_port == dst_port) {
lnk_unknown_dst_addr = lnk;		lnk_unknown_dst_addr = lnk;
break;		break;
}		}
}		}
break;		break;
case LINK_PARTIALLY_SPECIFIED:		case LINK_PARTIALLY_SPECIFIED:
lnk_unknown_all = LIST_FIRST(&grp->full);		lnk_unknown_all = LIST_FIRST(&grp->full);
break;		break;
}		}

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

if (flags == LINK_PARTIALLY_SPECIFIED &&		if (flags == LINK_PARTIALLY_SPECIFIED &&
lnk_unknown_all == NULL)		lnk_unknown_all == NULL)
lnk_unknown_all = lnk;		lnk_unknown_all = lnk;
if (flags == LINK_UNKNOWN_DEST_ADDR &&		if (flags == LINK_UNKNOWN_DEST_ADDR &&
lnk->dst_port == dst_port &&		lnk->dst_port == dst_port &&
lnk_unknown_dst_addr == NULL)		lnk_unknown_dst_addr == NULL)
▲ Show 20 Lines • Show All 315 Lines • ▼ Show 20 Lines	AddPptp(struct libalias *la, struct in_addr src_addr,
return (lnk);		return (lnk);
}		}

struct alias_link *		struct alias_link *
FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr,		FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,		struct in_addr dst_addr,
u_int16_t src_call_id)		u_int16_t src_call_id)
{		{
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);		LIST_FOREACH(lnk, &la->pptpList, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out)		if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
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;

return (UseLink(la, lnk));		return (UseLink(la, 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;
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);		LIST_FOREACH(lnk, &la->pptpList, pptp.list)
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out)		if (lnk->src_addr.s_addr == src_addr.s_addr &&
if (lnk->link_type == LINK_PPTP &&
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;

return (UseLink(la, lnk));		return (UseLink(la, 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)
{		{
struct group_in *grp;
struct alias_link *lnk;		struct alias_link *lnk;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);

grp = StartPointIn(la, alias_addr, 0, LINK_PPTP, 0);		LIST_FOREACH(lnk, &la->pptpList, pptp.list)
if (grp == NULL)		if (lnk->dst_port == dst_call_id &&
return (NULL);		lnk->dst_addr.s_addr == dst_addr.s_addr &&
		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)
break;		break;

return (UseLink(la, lnk));		return (UseLink(la, 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;

LIBALIAS_LOCK_ASSERT(la);		LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr,		LIST_FOREACH(lnk, &la->pptpList, pptp.list)
0 /* any */ , alias_call_id,		if (lnk->alias_port == alias_call_id &&
LINK_PPTP, 0);		lnk->dst_addr.s_addr == dst_addr.s_addr &&
		lnk->alias_addr.s_addr == alias_addr.s_addr)
		break;

return (lnk);		return (lnk);
}		}

struct alias_link *		struct alias_link *
FindRtspOut(struct libalias *la, struct in_addr src_addr,		FindRtspOut(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,
▲ Show 20 Lines • Show All 608 Lines • ▼ Show 20 Lines
LibAliasAddServer(struct libalias la, struct alias_link lnk, struct in_addr addr, u_short port)		LibAliasAddServer(struct libalias la, struct alias_link lnk, struct in_addr addr, u_short port)
{		{
struct server *server;		struct server *server;
int res;		int res;

LIBALIAS_LOCK(la);		LIBALIAS_LOCK(la);
(void)la;		(void)la;

		switch (lnk->link_type) {
		case LINK_PPTP:
		server = NULL;
		break;
		default:
server = malloc(sizeof(struct server));		server = malloc(sizeof(struct server));
		break;
		}

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;
/* not usable for outgoing connections */		/* not usable for outgoing connections */
LIST_REMOVE(lnk, list_out);		LIST_REMOVE(lnk, all.out);
} else {		} 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;
}		}
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines
#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->groupTableIn[i]);		LIST_INIT(&la->groupTableIn[i]);
		LIST_INIT(&la->pptpList);
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 386 Lines • Show Last 20 Lines