END_TEST
START_TEST (netaddr_dup_test) {
pr_netaddr_t *res, *addr;
res = pr_netaddr_dup(NULL, NULL);
fail_unless(res == NULL, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
res = pr_netaddr_dup(p, NULL);
fail_unless(res == NULL, "Failed to handle null addr");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
addr = pr_netaddr_alloc(p);
pr_netaddr_set_family(addr, AF_INET);
res = pr_netaddr_dup(NULL, addr);
fail_unless(res == NULL, "Failed to handle null pool");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
res = pr_netaddr_dup(p, addr);
fail_unless(res != NULL, "Failed to dup netaddr: %s", strerror(errno));
fail_unless(res->na_family == addr->na_family, "Expected family %d, got %d",
addr->na_family, res->na_family);
}
const pr_netaddr_t *proxy_ftp_msg_parse_ext_addr(pool *p, const char *msg,
const pr_netaddr_t *addr, int cmd_id, const char *net_proto) {
pr_netaddr_t *res = NULL, na;
int family = 0;
unsigned short port = 0;
char delim, *msg_str, *ptr;
size_t msglen;
if (p == NULL ||
msg == NULL ||
addr == NULL) {
errno = EINVAL;
return NULL;
}
if (cmd_id == PR_CMD_EPSV_ID) {
/* First, find the opening '(' character. */
ptr = strchr(msg, '(');
if (ptr == NULL) {
pr_trace_msg(trace_channel, 12,
"missing starting '(' character for extended address in '%s'", msg);
errno = EINVAL;
return NULL;
}
/* Make sure that the last character is a closing ')'. */
msglen = strlen(ptr);
if (ptr[msglen-1] != ')') {
pr_trace_msg(trace_channel, 12,
"missing ending ')' character for extended address in '%s'", msg);
errno = EINVAL;
return NULL;
}
msg_str = pstrndup(p, ptr+1, msglen-2);
} else {
msg_str = pstrdup(p, msg);
}
/* Format is <d>proto<d>ip address<d>port<d> (ASCII in network order),
* where <d> is an arbitrary delimiter character.
*/
delim = *msg_str++;
/* If the network protocol string (e.g. sent by client in EPSV command) is
* null, then determine the protocol family from the address family we were
* given.
*/
/* XXX Hack to skip "all", e.g. "EPSV ALL" commands. */
if (net_proto != NULL) {
if (strncasecmp(net_proto, "all", 4) == 0) {
net_proto = NULL;
}
}
if (net_proto == NULL) {
if (*msg_str == delim) {
switch (pr_netaddr_get_family(addr)) {
case AF_INET:
family = 1;
break;
#ifdef PR_USE_IPV6
case AF_INET6:
if (pr_netaddr_use_ipv6()) {
family = 2;
break;
}
#endif /* PR_USE_IPV6 */
default:
break;
}
} else {
family = atoi(msg_str);
}
} else {
family = atoi(net_proto);
}
switch (family) {
case 1:
pr_trace_msg(trace_channel, 19, "parsed IPv4 address from '%s'", msg);
break;
#ifdef PR_USE_IPV6
case 2:
pr_trace_msg(trace_channel, 19, "parsed IPv6 address from '%s'", msg);
if (pr_netaddr_use_ipv6()) {
break;
}
#endif /* PR_USE_IPV6 */
default:
pr_trace_msg(trace_channel, 12,
"unsupported network protocol %d", family);
errno = EPROTOTYPE;
return NULL;
}
/* Now, skip past those numeric characters that atoi() used. */
while (PR_ISDIGIT(*msg_str)) {
msg_str++;
}
/* If the next character is not the delimiter, it's a badly formatted
* parameter.
*/
if (*msg_str == delim) {
msg_str++;
} else {
pr_trace_msg(trace_channel, 17, "rejecting badly formatted message '%s'",
msg_str);
errno = EPERM;
return NULL;
}
pr_netaddr_clear(&na);
/* If the next character IS the delimiter, then the address portion is
* omitted (which is permissible).
*/
if (*msg_str == delim) {
pr_netaddr_set_family(&na, pr_netaddr_get_family(addr));
pr_netaddr_set_sockaddr(&na, pr_netaddr_get_sockaddr(addr));
msg_str++;
} else {
ptr = strchr(msg_str, delim);
if (ptr == NULL) {
/* Badly formatted message. */
errno = EINVAL;
return NULL;
}
/* Twiddle the string so that just the address portion will be processed
* by pr_inet_pton().
*/
*ptr = '\0';
/* Use pr_inet_pton() to translate the address string into the address
* value.
*/
switch (family) {
case 1: {
struct sockaddr *sa = NULL;
pr_netaddr_set_family(&na, AF_INET);
sa = pr_netaddr_get_sockaddr(&na);
if (sa) {
sa->sa_family = AF_INET;
}
if (pr_inet_pton(AF_INET, msg_str, pr_netaddr_get_inaddr(&na)) <= 0) {
pr_trace_msg(trace_channel, 2,
"error converting IPv4 address '%s': %s", msg_str, strerror(errno));
errno = EPERM;
return NULL;
}
break;
}
case 2: {
struct sockaddr *sa = NULL;
pr_netaddr_set_family(&na, AF_INET6);
sa = pr_netaddr_get_sockaddr(&na);
if (sa) {
sa->sa_family = AF_INET6;
}
if (pr_inet_pton(AF_INET6, msg_str, pr_netaddr_get_inaddr(&na)) <= 0) {
pr_trace_msg(trace_channel, 2,
"error converting IPv6 address '%s': %s", msg_str, strerror(errno));
errno = EPERM;
return NULL;
}
break;
}
}
/* Advance past the address portion of the argument. */
msg_str = ++ptr;
}
port = atoi(msg_str);
while (PR_ISDIGIT(*msg_str)) {
msg_str++;
}
/* If the next character is not the delimiter, it's a badly formatted
* parameter.
*/
if (*msg_str != delim) {
pr_trace_msg(trace_channel, 17, "rejecting badly formatted message '%s'",
msg_str);
errno = EPERM;
return NULL;
}
/* XXX Use a pool other than session.pool here, in the future. */
res = pr_netaddr_dup(session.pool, &na);
pr_netaddr_set_port(res, htons(port));
return res;
}
conn_t *pr_ipbind_get_listening_conn(server_rec *server, pr_netaddr_t *addr,
unsigned int port) {
conn_t *l;
pool *p;
struct listener_rec *lr;
if (listening_conn_list) {
for (lr = (struct listener_rec *) listening_conn_list->xas_list; lr;
lr = lr->next) {
int use_elt = FALSE;
pr_signals_handle();
if (addr != NULL &&
lr->addr != NULL) {
const char *lr_ipstr = NULL;
lr_ipstr = pr_netaddr_get_ipstr(lr->addr);
/* Note: lr_ipstr should never be null. If it is, it means that
* the lr->addr object never had its IP address resolved/stashed,
* and in attempting to do, getnameinfo(3) failed for some reason.
*
* The IP address on which it's listening, if not available via
* lr->addr, should thus be available via lr->conn->local_addr.
*/
if (lr_ipstr == NULL &&
lr->conn != NULL) {
lr_ipstr = pr_netaddr_get_ipstr(lr->conn->local_addr);
}
if (lr_ipstr != NULL) {
if (strcmp(pr_netaddr_get_ipstr(addr), lr_ipstr) == 0 &&
port == lr->port) {
use_elt = TRUE;
}
}
} else if (addr == NULL &&
port == lr->port) {
use_elt = TRUE;
}
if (use_elt) {
lr->claimed = TRUE;
return lr->conn;
}
}
}
if (listening_conn_pool == NULL) {
listening_conn_pool = make_sub_pool(permanent_pool);
pr_pool_tag(listening_conn_pool, "Listening Connection Pool");
listening_conn_list = xaset_create(listening_conn_pool, NULL);
}
p = make_sub_pool(listening_conn_pool);
pr_pool_tag(p, "Listening conn subpool");
l = pr_inet_create_conn(p, -1, addr, port, FALSE);
if (l == NULL) {
return NULL;
}
/* Inform any interested listeners that this socket was opened. */
pr_inet_generate_socket_event("core.ctrl-listen", server, l->local_addr,
l->listen_fd);
lr = pcalloc(p, sizeof(struct listener_rec));
lr->pool = p;
lr->conn = l;
lr->addr = pr_netaddr_dup(p, addr);
if (lr->addr == NULL &&
errno != EINVAL) {
return NULL;
}
lr->port = port;
lr->claimed = TRUE;
xaset_insert(listening_conn_list, (xasetmember_t *) lr);
return l;
}
