Page MenuHomeFreeBSD
Differential D15963

Add tests for pipe(2) and POSIX standardized IPC syscalls
ClosedPublic
Actions

Authored by aniketp on Jun 22 2018, 4:51 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Mar 29, 7:16 AM
Unknown Object (File)
Feb 20 2025, 5:49 PM
Unknown Object (File)
Feb 20 2025, 5:13 PM
Unknown Object (File)
Jan 20 2025, 8:37 AM
Unknown Object (File)
Jan 17 2025, 3:54 PM
Unknown Object (File)
Jan 13 2025, 2:14 AM
Unknown Object (File)
Dec 13 2024, 1:10 AM
Unknown Object (File)
Dec 7 2024, 2:47 PM
View All 96 Files
Subscribers
imp

Details

Reviewers
asomers
rwatson
gnn
Commits
rS335677: audit(4): add tests for pipe, posix_openpt, shm_open, and shm_unlink
Summary

This revision introduces test cases for following set of syscalls within inter-process
communication audit class.

  • shm_open(2)
  • shm_unlink(2)
  • posix_openpt(2)
  • pipe(2)
Test Plan

Execute make && make install from test/sys/audit.
Execute kyua test from /usr/tests/sys/audit. All testcases should succeed.

Diff Detail

Lint
Lint Passed
Unit
No Test Coverage
Build Status
Buildable 17555
Build 17375: arc lint + arc unit

Event Timeline

aniketp created this revision.Jun 22 2018, 4:51 AM
Harbormaster completed remote builds in B17535: Diff 44292.Jun 22 2018, 4:51 AM
asomers added a comment.Jun 22 2018, 3:55 PM

Do these complete the IPC set?

tests/sys/audit/inter-process.c
1414

New code should use strlcat instead of strncat.

1420

shared memory segments are actually persistent. So the unlink steps needs to go in the cleanup function. However, if you create the object with SHM_ANON for path, then it will be automatically destroyed.

1508

The file descriptors are outputs from pipe(2), not inputs to it. Don't initialize them with open.

1540

I'm surprised this doesn't segfault. Better to use NULL. Or, just use pipe2 with invalid flags. pipe(2) is actually a wrapper around pipe2(2). If you really want to test the pipe(2) syscall, you'll have to do it the same way you tested open(2), but using syscall(2). However, pipe and pipe2 both have the same audit event, AUE_PIPE.

aniketp updated this revision to Diff 44315.Jun 22 2018, 5:11 PM
aniketp marked 4 inline comments as done.

Changes as suggested in the inline comments

Harbormaster completed remote builds in B17547: Diff 44315.Jun 22 2018, 5:11 PM
asomers requested changes to this revision.Jun 22 2018, 10:29 PM
asomers added inline comments.
tests/sys/audit/inter-process.c
1459

No need for the -1.

This revision now requires changes to proceed.Jun 22 2018, 10:29 PM
aniketp updated this revision to Diff 44332.Jun 23 2018, 1:52 AM

Remove -1 from strlcat() in shm_inlink_success test case

Harbormaster completed remote builds in B17555: Diff 44332.Jun 23 2018, 1:52 AM
asomers accepted this revision.Jun 23 2018, 6:38 PM
This revision is now accepted and ready to land.Jun 23 2018, 6:38 PM
Closed by commit rS335677: audit(4): add tests for pipe, posix_openpt, shm_open, and shm_unlink (authored by asomers). · Explain WhyJun 26 2018, 7:26 PM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: imp. · View Herald TranscriptJun 26 2018, 7:26 PM

Revision Contents
Changeset List

PathSize
tests/
sys/
audit/
201 lines

Diff 44332

View Options

tests/sys/audit/inter-process.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 80 Lines • ▼ Show 20 Lines
/* flag bits */ /* flag bits */
#define LINK_UNKNOWN_DEST_PORT 0x01 #define LINK_UNKNOWN_DEST_PORT 0x01
#define LINK_UNKNOWN_DEST_ADDR 0x02 #define LINK_UNKNOWN_DEST_ADDR 0x02
#define LINK_PERMANENT 0x04 #define LINK_PERMANENT 0x04
#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 */
int expire_time; /* Expire time for link */
#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 {
TAILQ_ENTRY (alias_link) list_expire; LIST_ENTRY(alias_link) in;
LIST_ENTRY(alias_link) out;
} all;
struct {
LIST_ENTRY(alias_link) list;
} pptp;
};
struct {
TAILQ_ENTRY(alias_link) list;
int timeout; /* Expire time for link */
} 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;
} data; } data;
}; };
Show All 36 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 (grp->alias_port != alias_port || \
u_short alias_port, grp->link_type != link_type || \
int link_type) grp->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 *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;
return (n % LINK_TABLE_IN_SIZE); n %= LINK_TABLE_IN_SIZE;
LIST_FOREACH_SAFE(grp, &la->groupTableIn[n], group_in, tmp) {
/* Auto cleanup */
if (LIST_EMPTY(&grp->full) && LIST_EMPTY(&grp->partial)) {
LIST_REMOVE(grp, group_in);
free(grp);
} else {
INGUARD;
return (grp);
} }
}
if (!create || (grp = malloc(sizeof(*grp))) == NULL)
return (grp);
grp->alias_addr = alias_addr;
grp->alias_port = alias_port;
grp->link_type = link_type;
LIST_INIT(&grp->full);
LIST_INIT(&grp->partial);
LIST_INSERT_HEAD(&la->groupTableIn[n], grp, group_in);
return (grp);
}
#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;
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 85 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);
static struct alias_link * static struct alias_link *
FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int); FindLinkIn(struct libalias *, struct in_addr, struct in_addr, u_short, u_short, int, int);
#define ALIAS_PORT_BASE 0x08000 static u_short _RandomPort(struct libalias *la);
#define ALIAS_PORT_MASK 0x07fff
#define ALIAS_PORT_MASK_EVEN 0x07ffe
#define GET_NEW_PORT_MAX_ATTEMPTS 20 #define GET_NEW_PORT_MAX_ATTEMPTS 20
#define FIND_EVEN_ALIAS_BASE 1 /* get random port in network byte order */
static u_short
_RandomPort(struct libalias *la) {
u_short port;
port = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
return ntohs(port);
}
/* GetNewPort() allocates port numbers. Note that if a port number /* GetNewPort() allocates port numbers. Note that if a port number
is already in use, that does not mean that it cannot be used by is already in use, that does not mean that it cannot be used by
another link concurrently. This is because GetNewPort() looks for another link concurrently. This is because GetNewPort() looks for
unused triplets: (dest addr, dest port, alias port). */ unused triplets: (dest addr, dest port, alias port). */
static int static int
GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param) GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param)
{ {
int i; int i;
int max_trials; int max_trials;
u_short port_sys; u_short port;
u_short port_net;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Description of alias_port_param for GetNewPort(). When * Description of alias_port_param for GetNewPort(). When
* this parameter is zero or positive, it precisely specifies * this parameter is zero or positive, it precisely specifies
* the port number. GetNewPort() will return this number * the port number. GetNewPort() will return this number
* without check that it is in use. * without check that it is in use.
*
* The aliasing port is automatically selected by one of
* two methods below:
*
* When this parameter is GET_ALIAS_PORT, it indicates to get * When this parameter is GET_ALIAS_PORT, it indicates to get
* a randomly selected port number. * a randomly selected port number.
*/ */
if (alias_port_param == GET_ALIAS_PORT) { if (alias_port_param >= 0 && alias_port_param < 0x10000) {
/*
* The aliasing port is automatically selected by one of
* two methods below:
*/
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port_net = lnk->src_port;
port_sys = ntohs(port_net);
} else if (la->aliasPortLower) {
/* First trial is a random port in the aliasing range. */
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
/* First trial and all subsequent are random. */
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
} else if (alias_port_param >= 0 && alias_port_param < 0x10000) {
lnk->alias_port = (u_short) alias_port_param; lnk->alias_port = (u_short) alias_port_param;
return (0); return (0);
} else { }
if (alias_port_param != GET_ALIAS_PORT) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "input parameter error\n"); fprintf(stderr, "input parameter error\n");
#endif #endif
return (-1); return (-1);
} }
max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
/*
* When the PKT_ALIAS_SAME_PORTS option is chosen,
* the first try will be the actual source port. If
* this is already in use, the remainder of the
* trials will be random.
*/
port = (la->packetAliasMode & PKT_ALIAS_SAME_PORTS)
? lnk->src_port
: _RandomPort(la);
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
int go_ahead; struct group_in *grp;
struct alias_link *search_result; struct alias_link *search_result;
search_result = FindLinkIn(la, lnk->dst_addr, lnk->alias_addr, grp = StartPointIn(la, lnk->alias_addr, port, lnk->link_type, 0);
lnk->dst_port, port_net, if (grp == NULL)
lnk->link_type, 0); break;
LIST_FOREACH(search_result, &grp->full, all.in) {
if (lnk->dst_addr.s_addr == search_result->dst_addr.s_addr &&
lnk->dst_port == search_result->dst_port)
break; /* found match */
}
if (search_result == NULL) if (search_result == NULL)
go_ahead = 1; break;
else if (!(lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& (search_result->flags & LINK_PARTIALLY_SPECIFIED))
go_ahead = 1;
else
go_ahead = 0;
if (go_ahead) {
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS)
&& (lnk->flags & LINK_PARTIALLY_SPECIFIED)
&& ((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (GetSocket(la, port_net, &lnk->sockfd, lnk->link_type)) {
lnk->alias_port = port_net;
return (0);
} }
} else {
#endif
lnk->alias_port = port_net;
return (0);
#ifndef NO_USE_SOCKETS
}
#endif
}
if (la->aliasPortLower) {
port_sys = la->aliasPortLower +
(arc4random() % la->aliasPortLength);
port_net = htons(port_sys);
} else {
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
port_net = htons(port_sys);
}
}
if (i >= max_trials) {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/GetNewPort(): "); fprintf(stderr, "PacketAlias/GetNewPort(): ");
fprintf(stderr, "could not find free port\n"); fprintf(stderr, "could not find free port\n");
#endif #endif
return (-1);
}
#ifndef NO_USE_SOCKETS
if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS) &&
(lnk->flags & LINK_PARTIALLY_SPECIFIED) &&
((lnk->link_type == LINK_TCP) ||
(lnk->link_type == LINK_UDP))) {
if (!GetSocket(la, port, &lnk->sockfd, lnk->link_type)) {
return (-1); return (-1);
} }
}
#endif
lnk->alias_port = port;
return (0);
}
#ifndef NO_USE_SOCKETS #ifndef NO_USE_SOCKETS
static u_short static u_short
GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type) GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type)
{ {
int err; int err;
int sock; int sock;
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 LinesFindNewPortGroup(struct libalias *la,
u_short src_port, u_short src_port,
u_short dst_port, u_short dst_port,
u_short port_count, u_short port_count,
u_char proto, u_char proto,
u_char align) u_char align)
{ {
int i, j; int i, j;
int max_trials; int max_trials;
u_short port_sys; u_short port;
int link_type; int link_type;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
/* /*
* Get link_type from protocol * Get link_type from protocol
*/ */
switch (proto) { switch (proto) {
Show All 15 LinesFindNewPortGroup(struct libalias *la,
max_trials = GET_NEW_PORT_MAX_ATTEMPTS; max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) { if (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) {
/* /*
* When the ALIAS_SAME_PORTS option is chosen, the first * When the ALIAS_SAME_PORTS option is chosen, the first
* try will be the actual source port. If this is already * try will be the actual source port. If this is already
* in use, the remainder of the trials will be random. * in use, the remainder of the trials will be random.
*/ */
port_sys = ntohs(src_port); port = src_port;
} else { } else {
/* First trial and all subsequent are random. */ port = _RandomPort(la);
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
/* Port number search */ /* Port number search */
for (i = 0; i < max_trials; i++) { for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
struct alias_link *search_result; struct alias_link *search_result;
for (j = 0; j < port_count; j++) if (align)
port &= htons(0xfffe);
for (j = 0; j < port_count; j++) {
u_short port_j = ntohs(port) + j;
if ((search_result = FindLinkIn(la, dst_addr, if ((search_result = FindLinkIn(la, dst_addr,
alias_addr, dst_port, htons(port_sys + j), alias_addr, dst_port, htons(port_j),
link_type, 0)) != NULL) link_type, 0)) != NULL)
break; break;
}
/* Found a good range, return base */ /* Found a good range, return base */
if (j == port_count) if (j == port_count)
return (htons(port_sys)); return (port);
/* Find a new base to try */
if (align == FIND_EVEN_ALIAS_BASE)
port_sys = arc4random() & ALIAS_PORT_MASK_EVEN;
else
port_sys = arc4random() & ALIAS_PORT_MASK;
port_sys += ALIAS_PORT_BASE;
} }
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/FindNewPortGroup(): "); fprintf(stderr, "PacketAlias/FindNewPortGroup(): ");
fprintf(stderr, "could not find free port(s)\n"); fprintf(stderr, "could not find free port(s)\n");
#endif #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;
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, expire.list, lnk_tmp)
DeleteLink(&lnk); DeleteLink(&lnk);
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)
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.timeout) {
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), expire.list);
TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), list_expire); TAILQ_INSERT_TAIL(&la->checkExpire, (*lnk), expire.list);
} }
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 */
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 {
/* 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, list_expire); 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--;
close(lnk->sockfd); close(lnk->sockfd);
} }
#endif #endif
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
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;
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.timeout = ICMP_EXPIRE_TIME;
break; break;
case LINK_UDP: case LINK_UDP:
lnk->expire_time = UDP_EXPIRE_TIME; lnk->expire.timeout = UDP_EXPIRE_TIME;
break; break;
case LINK_TCP: case LINK_TCP:
lnk->expire_time = TCP_EXPIRE_INITIAL; lnk->expire.timeout = 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.timeout = FRAGMENT_ID_EXPIRE_TIME;
break; break;
case LINK_FRAGMENT_PTR: case LINK_FRAGMENT_PTR:
lnk->expire_time = FRAGMENT_PTR_EXPIRE_TIME; lnk->expire.timeout = FRAGMENT_PTR_EXPIRE_TIME;
break; break;
case LINK_ADDR: case LINK_ADDR:
break; break;
default: default:
lnk->expire_time = PROTO_EXPIRE_TIME; lnk->expire.timeout = 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: {
struct tcp_dat *aux_tcp;
int i;
aux_tcp = malloc(sizeof(struct tcp_dat)); aux_tcp = malloc(sizeof(struct tcp_dat));
if (aux_tcp != NULL) { if (aux_tcp != NULL) {
int i; #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;
} }
switch (link_type) {
case LINK_PPTP:
LIST_INSERT_HEAD(&la->pptpTable, 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);
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 */
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->partial, lnk, all.in);
else
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, list_expire); 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 19 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 *
_SearchLinkOut(struct libalias *la, struct in_addr src_addr,
struct in_addr dst_addr,
u_short src_port,
u_short dst_port,
int link_type) {
u_int i;
struct alias_link *lnk;
i = StartPointOut(src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], all.out) {
OUTGUARD;
return (UseLink(la, lnk));
}
return (NULL);
}
#undef OUTGUARD
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,
int link_type, int link_type,
int replace_partial_links) int replace_partial_links)
{ {
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, src_port, dst_port, link_type); lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type);
LIST_FOREACH(lnk, &la->linkTableOut[i], list_out) { if (lnk != NULL || !replace_partial_links)
if (lnk->dst_addr.s_addr == dst_addr.s_addr && return (lnk);
lnk->src_addr.s_addr == src_addr.s_addr &&
lnk->src_port == src_port &&
lnk->dst_port == dst_port &&
lnk->link_type == link_type &&
lnk->server == NULL)
break;
}
CleanupLink(la, &lnk);
if (lnk != NULL)
lnk->timestamp = LibAliasTime;
/* 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, all.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, all.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, all.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, all.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 LinesFindFragmentIn1(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 131 Lines • ▼ Show 20 LinesAddPptp(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->pptpTable, 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;
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;
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->pptpTable, 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;
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 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) LIST_FOREACH(lnk, &la->pptpTable, pptp.list)
if (lnk->link_type == LINK_PPTP && if (lnk->dst_port == dst_call_id &&
lnk->dst_addr.s_addr == dst_addr.s_addr && lnk->dst_addr.s_addr == dst_addr.s_addr &&
lnk->alias_addr.s_addr == alias_addr.s_addr && lnk->alias_addr.s_addr == alias_addr.s_addr)
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;
LIBALIAS_LOCK_ASSERT(la); LIBALIAS_LOCK_ASSERT(la);
lnk = FindLinkIn(la, dst_addr, alias_addr, LIST_FOREACH(lnk, &la->pptpTable, 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 All 30 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 42 Lines • ▼ Show 20 Lines
void void
SetStateIn(struct alias_link *lnk, int state) SetStateIn(struct alias_link *lnk, int state)
{ {
/* TCP input state */ /* TCP input state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateIn() unknown state"); panic("libalias:SetStateIn() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
lnk->data.tcp->state.in = state; lnk->data.tcp->state.in = state;
} }
void void
SetStateOut(struct alias_link *lnk, int state) SetStateOut(struct alias_link *lnk, int state)
{ {
/* TCP output state */ /* TCP output state */
switch (state) { switch (state) {
case ALIAS_TCP_STATE_DISCONNECTED: case ALIAS_TCP_STATE_DISCONNECTED:
if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_DEAD; lnk->expire.timeout = TCP_EXPIRE_DEAD;
else else
lnk->expire_time = TCP_EXPIRE_SINGLEDEAD; lnk->expire.timeout = TCP_EXPIRE_SINGLEDEAD;
break; break;
case ALIAS_TCP_STATE_CONNECTED: case ALIAS_TCP_STATE_CONNECTED:
if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED) if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED)
lnk->expire_time = TCP_EXPIRE_CONNECTED; lnk->expire.timeout = TCP_EXPIRE_CONNECTED;
break; break;
default: default:
#ifdef _KERNEL #ifdef _KERNEL
panic("libalias:SetStateOut() unknown state"); panic("libalias:SetStateOut() unknown state");
#else #else
abort(); abort();
#endif #endif
} }
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
SetExpire(struct alias_link *lnk, int expire) SetExpire(struct alias_link *lnk, int expire)
{ {
if (expire == 0) { if (expire == 0) {
lnk->flags &= ~LINK_PERMANENT; lnk->flags &= ~LINK_PERMANENT;
DeleteLink(&lnk); DeleteLink(&lnk);
} else if (expire == -1) { } else if (expire == -1) {
lnk->flags |= LINK_PERMANENT; lnk->flags |= LINK_PERMANENT;
} else if (expire > 0) { } else if (expire > 0) {
lnk->expire_time = expire; lnk->expire.timeout = expire;
} else { } else {
#ifdef LIBALIAS_DEBUG #ifdef LIBALIAS_DEBUG
fprintf(stderr, "PacketAlias/SetExpire(): "); fprintf(stderr, "PacketAlias/SetExpire(): ");
fprintf(stderr, "error in expire parameter\n"); fprintf(stderr, "error in expire parameter\n");
#endif #endif
} }
} }
▲ Show 20 Lines • Show All 187 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;
else { /* not usable for outgoing connections */
LIST_REMOVE(lnk, all.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]);
LIST_INIT(&la->pptpTable);
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);
la->deleteAllLinks = 1; la->deleteAllLinks = 1;
CleanupAliasData(la); CleanupAliasData(la);
la->deleteAllLinks = 0; la->deleteAllLinks = 0;
#ifdef _KERNEL #ifdef _KERNEL
AliasSctpTerm(la); AliasSctpTerm(la);
AliasSctpInit(la); AliasSctpInit(la);
#endif #endif
} }
la->aliasAddress.s_addr = INADDR_ANY; la->aliasAddress.s_addr = INADDR_ANY;
la->targetAddress.s_addr = INADDR_ANY; la->targetAddress.s_addr = INADDR_ANY;
la->aliasPortLower = 0x8000;
la->aliasPortLength = 0x8000;
la->icmpLinkCount = 0; la->icmpLinkCount = 0;
la->udpLinkCount = 0; la->udpLinkCount = 0;
la->tcpLinkCount = 0; la->tcpLinkCount = 0;
la->sctpLinkCount = 0; la->sctpLinkCount = 0;
la->pptpLinkCount = 0; la->pptpLinkCount = 0;
la->protoLinkCount = 0; la->protoLinkCount = 0;
la->fragmentIdLinkCount = 0; la->fragmentIdLinkCount = 0;
▲ Show 20 Lines • Show All 380 Lines • Show Last 20 Lines