END_TEST
START_TEST (inet_connect_ipv4_test) {
int sockfd = -1, port = INPORT_ANY, res;
conn_t *conn;
const pr_netaddr_t *addr;
res = pr_inet_connect(NULL, NULL, NULL, port);
fail_unless(res < 0, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
conn = pr_inet_create_conn(p, sockfd, NULL, port, FALSE);
fail_unless(conn != NULL, "Failed to create conn: %s", strerror(errno));
res = pr_inet_connect(p, conn, NULL, 80);
fail_unless(res < 0, "Failed to handle null address");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
addr = pr_netaddr_get_addr(p, "127.0.0.1", NULL);
fail_unless(addr != NULL, "Failed to resolve '127.0.0.1': %s",
strerror(errno));
res = pr_inet_connect(p, conn, addr, 80);
fail_unless(res < 0, "Connected to 127.0.0.1#80 unexpectedly");
fail_unless(errno == ECONNREFUSED, "Expected ECONNREFUSED (%d), got %s (%d)",
ECONNREFUSED, strerror(errno), errno);
/* Try connecting to Google's DNS server. */
addr = pr_netaddr_get_addr(p, "8.8.8.8", NULL);
fail_unless(addr != NULL, "Failed to resolve '8.8.8.8': %s",
strerror(errno));
res = pr_inet_connect(p, conn, addr, 53);
if (res < 0) {
/* Note: We get EINVAL here because the socket already tried (and failed)
* to connect to a different address. Interestingly, trying to connect(2)
* using that same fd to a different address yields EINVAL.
*/
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
}
pr_inet_close(p, conn);
conn = pr_inet_create_conn(p, sockfd, NULL, port, FALSE);
fail_unless(conn != NULL, "Failed to create conn: %s", strerror(errno));
res = pr_inet_connect(p, conn, addr, 53);
fail_if(res < 0, "Failed to connect to 8.8.8.8#53: %s", strerror(errno));
res = pr_inet_connect(p, conn, addr, 53);
fail_unless(res < 0, "Failed to connect to 8.8.8.8#53: %s",
strerror(errno));
fail_unless(errno == EISCONN, "Expected EISCONN (%d), got %s (%d)",
EISCONN, strerror(errno), errno);
pr_inet_close(p, conn);
}
END_TEST
START_TEST (netaddr_set_sockaddr_test) {
pr_netaddr_t *addr;
int res;
struct sockaddr sa;
const char *name;
#ifdef PR_USE_IPV6
int family;
#endif /* PR_USE_IPV6 */
res = pr_netaddr_set_sockaddr(NULL, NULL);
fail_unless(res < 0, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
name = "127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_set_sockaddr(addr, NULL);
fail_unless(res < 0, "Failed to handle null sockaddr");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
memset(&sa, 0, sizeof(sa));
res = pr_netaddr_set_sockaddr(addr, &sa);
fail_unless(res == 0, "Failed to set sockaddr: %s", strerror(errno));
#ifdef PR_USE_IPV6
name = "::1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_set_sockaddr(addr, &sa);
fail_unless(res == 0, "Failed to set sockaddr: %s", strerror(errno));
pr_netaddr_disable_ipv6();
res = pr_netaddr_set_sockaddr(addr, &sa);
fail_unless(res < 0, "Set sockaddr unexpectedly");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
pr_netaddr_enable_ipv6();
family = addr->na_family;
addr->na_family = 777;
res = pr_netaddr_set_sockaddr(addr, &sa);
addr->na_family = family;
fail_unless(res < 0, "Set sockaddr unexpectedly");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
#endif /* PR_USE_IPV6 */
}
END_TEST
START_TEST (netaddr_ncmp_test) {
pr_netaddr_t *addr, *addr2;
int res;
unsigned int nbits = 0;
const char *name;
res = pr_netaddr_ncmp(NULL, NULL, nbits);
fail_unless(res == 0, "Expected 0, got %d", res);
name = "127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_ncmp(addr, NULL, nbits);
fail_unless(res == 1, "Expected 1, got %d", res);
res = pr_netaddr_ncmp(NULL, addr, nbits);
fail_unless(res == -1, "Expected -1, got %d", res);
res = pr_netaddr_ncmp(NULL, addr, nbits);
fail_unless(res == -1, "Expected -1, got %d", res);
nbits = 48;
res = pr_netaddr_ncmp(addr, addr, nbits);
fail_unless(res == -1, "Expected -1, got %d", res);
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
name = "::1";
addr2 = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr2 != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
nbits = 0;
res = pr_netaddr_ncmp(addr, addr2, nbits);
fail_unless(res == -1, "Expected -1, got %d", res);
res = pr_netaddr_ncmp(addr2, addr, nbits);
fail_unless(res == -1, "Expected -1, got %d", res);
name = "::ffff:127.0.0.1";
addr2 = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr2 != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_ncmp(addr, addr2, nbits);
fail_unless(res == 0, "Expected 0, got %d", res);
res = pr_netaddr_ncmp(addr2, addr, nbits);
fail_unless(res == 0, "Expected 0, got %d", res);
nbits = 24;
res = pr_netaddr_ncmp(addr2, addr, nbits);
fail_unless(res == 0, "Expected 0, got %d", res);
}
END_TEST
START_TEST (inet_connect_ipv6_test) {
#ifdef PR_USE_IPV6
int res;
conn_t *conn;
const pr_netaddr_t *addr;
unsigned char use_ipv6;
use_ipv6 = pr_netaddr_use_ipv6();
pr_netaddr_enable_ipv6();
pr_inet_set_default_family(p, AF_INET6);
conn = pr_inet_create_conn(p, -1, NULL, INPORT_ANY, FALSE);
fail_unless(conn != NULL, "Failed to create conn: %s", strerror(errno));
addr = pr_netaddr_get_addr(p, "::1", NULL);
fail_unless(addr != NULL, "Failed to resolve '::1': %s", strerror(errno));
mark_point();
res = proxy_inet_connect(p, conn, addr, 80);
fail_unless(res < 0, "Connected to 127.0.0.1#80 unexpectedly");
fail_unless(errno == ECONNREFUSED || errno == ENETUNREACH,
"Expected ECONNREFUSED (%d) or ENETUNREACH (%d), got %s (%d)",
ECONNREFUSED, ENETUNREACH, strerror(errno), errno);
proxy_inet_close(p, conn);
/* Try connecting to Google's DNS server. */
conn = pr_inet_create_conn(p, -1, NULL, INPORT_ANY, FALSE);
fail_unless(conn != NULL, "Failed to create conn: %s", strerror(errno));
addr = pr_netaddr_get_addr(p, "2001:4860:4860::8888", NULL);
fail_unless(addr != NULL, "Failed to resolve '2001:4860:4860::8888': %s",
strerror(errno));
mark_point();
res = proxy_inet_connect(p, conn, addr, 53);
if (res < 0) {
/* This could be expected, e.g. if there's no route. */
fail_unless(errno == EHOSTUNREACH || errno == ENETUNREACH,
"Expected EHOSTUNREACH (%d) or ENETUNREACH (%d), got %s (%d)",
EHOSTUNREACH, ENETUNREACH, strerror(errno), errno);
}
mark_point();
proxy_inet_close(p, conn);
pr_inet_set_default_family(p, AF_INET);
if (use_ipv6 == FALSE) {
pr_netaddr_disable_ipv6();
}
#endif /* PR_USE_IPV6 */
}
END_TEST
START_TEST (netaddr_is_rfc1918_test) {
int res;
const char *name;
pr_netaddr_t *addr;
res = pr_netaddr_is_rfc1918(NULL);
fail_unless(res == -1, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
name = "127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to get addr for '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_rfc1918(addr);
fail_unless(res == FALSE, "Failed to handle non-RFC1918 IPv4 address");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL, got %s (%d)",
strerror(errno), errno);
name = "::1";
addr = pr_netaddr_get_addr(p, name, NULL);
#ifdef PR_USE_IPV6
fail_unless(addr != NULL, "Failed to get addr for '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_rfc1918(addr);
fail_unless(res == FALSE, "Failed to handle IPv6 address");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
#else
fail_unless(addr == NULL,
"IPv6 support disabled, should not be able to get addr for '%s'", name);
#endif /* PR_USE_IPV6 */
name = "10.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to get addr for '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_rfc1918(addr);
fail_unless(res == TRUE, "Expected 'true' for address '%s'", name);
name = "192.168.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to get addr for '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_rfc1918(addr);
fail_unless(res == TRUE, "Expected 'true' for address '%s'", name);
name = "172.31.200.55";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to get addr for '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_rfc1918(addr);
fail_unless(res == TRUE, "Expected 'true' for address '%s'", name);
}
END_TEST
START_TEST (netaddr_is_v4mappedv6_test) {
int res;
const char *name;
pr_netaddr_t *addr;
res = pr_netaddr_is_v4mappedv6(NULL);
fail_unless(res == -1, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
name = "127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to get addr for '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_v4mappedv6(addr);
fail_unless(res == -1, "Expected -1 for IPv4 address '%s', got %d",
name, res);
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL; got %d [%s]",
errno, strerror(errno));
name = "::1";
addr = pr_netaddr_get_addr(p, name, NULL);
#ifdef PR_USE_IPV6
fail_unless(addr != NULL, "Failed to get addr for '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_v4mappedv6(addr);
fail_unless(res == FALSE, "Expected 'false' for IPv6 address '%s', got %d",
name, res);
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL; got %d [%s]",
errno, strerror(errno));
#else
fail_unless(addr == NULL,
"IPv6 support disabled, should not be able to get addr for '%s'", name);
#endif /* PR_USE_IPV6 */
name = "::ffff:127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to get addr for '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_v4mappedv6(addr);
#ifdef PR_USE_IPV6
fail_unless(res == TRUE,
"Expected 'true' for IPv4-mapped IPv6 address '%s', got %d", name, res);
#else
fail_unless(res == -1,
"Expected -1 for IPv4-mapped IPv6 address '%s' (--disable-ipv6 used)");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL; got %d [%s]",
errno, strerror(errno));
#endif /* PR_USE_IPV6 */
}
END_TEST
START_TEST (netaddr_get_sockaddr_len_test) {
pr_netaddr_t *addr;
size_t res;
const char *name;
#ifdef PR_USE_IPV6
int family;
#endif /* PR_USE_IPV6 */
res = pr_netaddr_get_sockaddr_len(NULL);
fail_unless(res == (size_t) -1, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
name = "127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_get_sockaddr_len(addr);
fail_unless(res > 0, "Failed to get sockaddr len: %s", strerror(errno));
#ifdef PR_USE_IPV6
name = "::1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_get_sockaddr_len(addr);
fail_unless(res > 0, "Failed to get sockaddr len: %s", strerror(errno));
pr_netaddr_disable_ipv6();
res = pr_netaddr_get_sockaddr_len(addr);
fail_unless(res == (size_t) -1, "Got sockaddr len unexpectedly");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
pr_netaddr_enable_ipv6();
family = addr->na_family;
addr->na_family = 777;
res = pr_netaddr_get_sockaddr_len(addr);
addr->na_family = family;
fail_unless(res == (size_t) -1, "Got sockaddr len unexpectedly");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
#endif /* PR_USE_IPV6 */
}
END_TEST
START_TEST (netaddr_get_inaddr_test) {
pr_netaddr_t *addr;
int family;
void *inaddr;
const char *name;
inaddr = pr_netaddr_get_inaddr(NULL);
fail_unless(inaddr == NULL, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
family = AF_INET;
name = "127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
inaddr = pr_netaddr_get_inaddr(addr);
fail_unless(inaddr != NULL, "Failed to get inaddr: %s", strerror(errno));
#ifdef PR_USE_IPV6
family = AF_INET6;
name = "::1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
inaddr = pr_netaddr_get_inaddr(addr);
fail_unless(inaddr != NULL, "Failed to get inaddr: %s", strerror(errno));
pr_netaddr_disable_ipv6();
inaddr = pr_netaddr_get_inaddr(addr);
fail_unless(inaddr == NULL, "Got inaddr unexpectedly");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
pr_netaddr_enable_ipv6();
family = addr->na_family;
addr->na_family = 777;
inaddr = pr_netaddr_get_inaddr(addr);
addr->na_family = family;
fail_unless(inaddr == NULL, "Got inaddr unexpectedly");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
#endif /* PR_USE_IPV6 */
}
END_TEST
START_TEST (netaddr_fnmatch_test) {
pr_netaddr_t *addr;
int flags, res;
const char *name;
res = pr_netaddr_fnmatch(NULL, NULL, 0);
fail_unless(res < 0, "Failed to handle null address");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
name = "localhost";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_fnmatch(addr, NULL, 0);
fail_unless(res < 0, "Failed to handle null pattern");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
flags = PR_NETADDR_MATCH_DNS;
res = pr_netaddr_fnmatch(addr, "foo", flags);
fail_unless(res == FALSE, "Expected FALSE, got %d", res);
res = pr_netaddr_fnmatch(addr, "LOCAL*", flags);
fail_unless(res == TRUE, "Expected TRUE, got %d", res);
flags = PR_NETADDR_MATCH_IP;
res = pr_netaddr_fnmatch(addr, "foo", flags);
fail_unless(res == FALSE, "Expected FALSE, got %d", res);
res = pr_netaddr_fnmatch(addr, "127.0*", flags);
fail_unless(res == TRUE, "Expected TRUE, got %d", res);
#ifdef PR_USE_IPV6
name = "::ffff:127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_fnmatch(addr, "foo", flags);
fail_unless(res == FALSE, "Expected FALSE, got %d", res);
res = pr_netaddr_fnmatch(addr, "127.0.*", flags);
fail_unless(res == TRUE, "Expected TRUE, got %d", res);
#endif /* PR_USE_IPV6 */
}
END_TEST
START_TEST (netaddr_get_sockaddr_test) {
pr_netaddr_t *addr;
struct sockaddr *sockaddr;
const char *name;
#ifdef PR_USE_IPV6
int family;
#endif /* PR_USE_IPV6 */
sockaddr = pr_netaddr_get_sockaddr(NULL);
fail_unless(sockaddr == NULL, "Failed to handle null argument");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
name = "127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
sockaddr = pr_netaddr_get_sockaddr(addr);
fail_unless(sockaddr != NULL, "Failed to get sock addr: %s", strerror(errno));
#ifdef PR_USE_IPV6
name = "::1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
sockaddr = pr_netaddr_get_sockaddr(addr);
fail_unless(sockaddr != NULL, "Failed to get sock addr: %s", strerror(errno));
pr_netaddr_disable_ipv6();
sockaddr = pr_netaddr_get_sockaddr(addr);
fail_unless(sockaddr == NULL, "Got sock addr for IPv6 addr", strerror(errno));
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
pr_netaddr_enable_ipv6();
family = addr->na_family;
addr->na_family = 777;
sockaddr = pr_netaddr_get_sockaddr(addr);
fail_unless(sockaddr == NULL, "Got sock addr for IPv6 addr", strerror(errno));
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
addr->na_family = family;
#endif /* PR_USE_IPV6 */
}
END_TEST
START_TEST (inet_openrw_test) {
int sockfd = -1, port = INPORT_ANY;
conn_t *conn, *res;
pr_netaddr_t *addr;
res = pr_inet_openrw(NULL, NULL, NULL, PR_NETIO_STRM_CTRL, -1, -1, -1, FALSE);
fail_unless(res == NULL, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
conn = pr_inet_create_conn(p, sockfd, NULL, port, FALSE);
fail_unless(conn != NULL, "Failed to create conn: %s", strerror(errno));
res = pr_inet_openrw(p, conn, NULL, PR_NETIO_STRM_CTRL, -1, -1, -1, FALSE);
fail_unless(res == NULL, "Opened rw conn unexpectedly");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
addr = pr_netaddr_get_addr(p, "127.0.0.1", NULL);
fail_unless(addr != NULL, "Failed to resolve 127.0.0.1: %s", strerror(errno));
res = pr_inet_openrw(p, conn, addr, PR_NETIO_STRM_CTRL, -1, -1, -1, FALSE);
fail_unless(res != NULL, "Failed to open rw conn: %s", strerror(errno));
(void) pr_inet_close(p, res);
res = pr_inet_openrw(p, conn, addr, PR_NETIO_STRM_CTRL, -1, -1, -1, TRUE);
fail_unless(res != NULL, "Failed to open rw conn: %s", strerror(errno));
}
END_TEST
START_TEST (inet_connect_nowait_test) {
int sockfd = -1, port = INPORT_ANY, res;
conn_t *conn;
pr_netaddr_t *addr;
res = pr_inet_connect_nowait(NULL, NULL, NULL, port);
fail_unless(res < 0, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
conn = pr_inet_create_conn(p, sockfd, NULL, port, FALSE);
fail_unless(conn != NULL, "Failed to create conn: %s", strerror(errno));
res = pr_inet_connect_nowait(p, conn, NULL, 80);
fail_unless(res < 0, "Failed to handle null connection");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
addr = pr_netaddr_get_addr(p, "127.0.0.1", NULL);
fail_unless(addr != NULL, "Failed to resolve '127.0.0.1': %s",
strerror(errno));
res = pr_inet_connect_nowait(p, conn, addr, 80);
fail_unless(res < 0, "Connected to 127.0.0.1#80 unexpectedly");
pr_inet_close(p, conn);
}
END_TEST
START_TEST (netaddr_set_family_test) {
pr_netaddr_t *addr;
int res;
res = pr_netaddr_set_family(NULL, 0);
fail_unless(res == -1, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
addr = pr_netaddr_get_addr(p, "127.0.0.1", NULL);
fail_unless(addr != NULL, "Failed to get addr for '127.0.0.1': %s",
strerror(errno));
res = pr_netaddr_set_family(addr, -1);
fail_unless(res == -1, "Failed to handle bad family");
#ifdef EAFNOSUPPORT
fail_unless(errno == EAFNOSUPPORT, "Failed to set errno to EAFNOSUPPORT");
#else
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
#endif
res = pr_netaddr_set_family(addr, AF_INET);
fail_unless(res == 0, "Failed to set family to AF_INET: %s", strerror(errno));
}
END_TEST
START_TEST (listen_test) {
conn_t *res;
const pr_netaddr_t *bind_addr = NULL;
res = proxy_ftp_conn_listen(NULL, NULL, FALSE);
fail_unless(res == NULL, "Failed to handle null pool");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got '%s' (%d)", EINVAL,
strerror(errno), errno);
res = proxy_ftp_conn_listen(p, NULL, FALSE);
fail_unless(res == NULL, "Failed to handle null bind address");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got '%s' (%d)", EINVAL,
strerror(errno), errno);
bind_addr = pr_netaddr_get_addr(p, "127.0.0.1", NULL);
fail_unless(bind_addr != NULL, "Failed to address for 127.0.0.1: %s",
strerror(errno));
pr_netaddr_set_port((pr_netaddr_t *) bind_addr, htons(0));
mark_point();
res = proxy_ftp_conn_listen(p, bind_addr, FALSE);
fail_unless(res != NULL, "Failed to listen: %s", strerror(errno));
pr_inet_close(p, res);
mark_point();
res = proxy_ftp_conn_listen(p, bind_addr, TRUE);
fail_unless(res != NULL, "Failed to listen: %s", strerror(errno));
pr_inet_close(p, res);
}
END_TEST
START_TEST (netaddr_set_port_test) {
pr_netaddr_t *addr;
unsigned int port;
int res;
res = pr_netaddr_set_port(NULL, 0);
fail_unless(res == -1, "Failed to handle null addr");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
addr = pr_netaddr_get_addr(p, "127.0.0.1", NULL);
fail_unless(addr != NULL, "Failed to get addr for '127.0.0.1': %s",
strerror(errno));
addr->na_family = -1;
res = pr_netaddr_set_port(addr, 1);
fail_unless(res == -1, "Failed to handle bad family");
fail_unless(errno == EPERM, "Failed to set errno to EPERM");
addr->na_family = AF_INET;
res = pr_netaddr_set_port(addr, 1);
fail_unless(res == 0, "Failed to set port: %s", strerror(errno));
port = pr_netaddr_get_port(addr);
fail_unless(port == 1, "Expected port %u, got %u", 1, port);
}
END_TEST
#endif /* PR_USE_IPV6 */
START_TEST (netaddr_get_ipstr_test) {
pr_netaddr_t *addr;
const char *res;
res = pr_netaddr_get_ipstr(NULL);
fail_unless(res == NULL, "Failed to handle null argument");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
addr = pr_netaddr_get_addr(p, "localhost", NULL);
fail_unless(addr != NULL, "Failed to get addr for 'localhost': %s",
strerror(errno));
res = pr_netaddr_get_ipstr(addr);
fail_unless(res != NULL, "Failed to get IP str for addr: %s",
strerror(errno));
fail_unless(strcmp(res, "127.0.0.1") == 0, "Expected '%s', got '%s'",
"127.0.0.1", res);
fail_unless(addr->na_have_ipstr == 1, "addr should have cached IP str");
pr_netaddr_clear(addr);
res = pr_netaddr_get_ipstr(addr);
fail_unless(res == NULL, "Expected null, got '%s'", res);
}
END_TEST
START_TEST (netaddr_is_loopback_test) {
pr_netaddr_t *addr;
int res;
const char *name;
res = pr_netaddr_is_loopback(NULL);
fail_unless(res < 0, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
name = "www.google.com";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_loopback(addr);
fail_unless(res == FALSE, "Expected FALSE, got %d", res);
name = "127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_loopback(addr);
fail_unless(res == TRUE, "Expected TRUE, got %d", res);
#ifdef PR_USE_IPV6
name = "::1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_loopback(addr);
fail_unless(res == TRUE, "Expected TRUE, got %d", res);
name = "::ffff:127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_is_loopback(addr);
fail_unless(res == TRUE, "Expected TRUE, got %d", res);
#endif /* PR_USE_IPV6 */
}
END_TEST
START_TEST (inet_connect_nowait_test) {
int sockfd = -1, port = INPORT_ANY, res;
conn_t *conn;
const pr_netaddr_t *addr;
res = pr_inet_connect_nowait(NULL, NULL, NULL, port);
fail_unless(res < 0, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
conn = pr_inet_create_conn(p, sockfd, NULL, port, FALSE);
fail_unless(conn != NULL, "Failed to create conn: %s", strerror(errno));
res = pr_inet_connect_nowait(p, conn, NULL, 80);
fail_unless(res < 0, "Failed to handle null address");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
addr = pr_netaddr_get_addr(p, "127.0.0.1", NULL);
fail_unless(addr != NULL, "Failed to resolve '127.0.0.1': %s",
strerror(errno));
res = pr_inet_connect_nowait(p, conn, addr, 80);
fail_unless(res != -1, "Connected to 127.0.0.1#80 unexpectedly");
/* Try connecting to Google's DNS server. */
addr = pr_netaddr_get_addr(p, "8.8.8.8", NULL);
fail_unless(addr != NULL, "Failed to resolve '8.8.8.8': %s",
strerror(errno));
res = pr_inet_connect_nowait(p, conn, addr, 53);
if (res < 0 &&
errno != ECONNREFUSED) {
fail_unless(res != -1, "Failed to connect to 8.8.8.8#53: %s",
strerror(errno));
}
pr_inet_close(p, conn);
/* Restore the default family to AF_INET, for other tests. */
pr_inet_set_default_family(p, AF_INET);
}
END_TEST
START_TEST (netaddr_cmp_test) {
pr_netaddr_t *addr, *addr2;
int res;
const char *name;
res = pr_netaddr_cmp(NULL, NULL);
fail_unless(res == 0, "Expected 0, got %d", res);
name = "127.0.0.1";
addr = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_cmp(addr, NULL);
fail_unless(res == 1, "Expected 1, got %d", res);
res = pr_netaddr_cmp(NULL, addr);
fail_unless(res == -1, "Expected -1, got %d", res);
name = "::1";
addr2 = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr2 != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_cmp(addr, addr2);
fail_unless(res == -1, "Expected -1, got %d", res);
res = pr_netaddr_cmp(addr2, addr);
fail_unless(res == -1, "Expected -1, got %d", res);
name = "::ffff:127.0.0.1";
addr2 = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr2 != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
res = pr_netaddr_cmp(addr, addr2);
fail_unless(res == 0, "Expected 0, got %d", res);
res = pr_netaddr_cmp(addr2, addr);
fail_unless(res == 0, "Expected 0, got %d", res);
}
END_TEST
START_TEST (netaddr_v6tov4_test) {
pr_netaddr_t *addr, *addr2;
const char *name, *ipstr;
addr = pr_netaddr_v6tov4(NULL, NULL);
fail_unless(addr == NULL, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
addr = pr_netaddr_v6tov4(p, NULL);
fail_unless(addr == NULL, "Failed to handle null address");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
name = "127.0.0.1";
addr2 = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr2 != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
addr = pr_netaddr_v6tov4(p, addr2);
fail_unless(addr == NULL, "Converted '%s' to IPv4 address unexpectedly",
name);
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
name = "::ffff:127.0.0.1";
addr2 = pr_netaddr_get_addr(p, name, NULL);
fail_unless(addr2 != NULL, "Failed to resolve '%s': %s", name,
strerror(errno));
addr = pr_netaddr_v6tov4(p, addr2);
fail_unless(addr != NULL, "Failed to convert '%s' to IPv4 addres: %s",
name, strerror(errno));
fail_unless(pr_netaddr_get_family(addr) == AF_INET,
"Expected %d, got %d", AF_INET, pr_netaddr_get_family(addr));
ipstr = pr_netaddr_get_ipstr(addr);
fail_unless(strcmp(ipstr, "127.0.0.1") == 0,
"Expected '127.0.0.1', got '%s'", ipstr);
}
static void dynmasq_refresh(void) {
server_rec *s;
pr_log_debug(DEBUG2, MOD_DYNMASQ_VERSION
": resolving all MasqueradeAddress directives (could take a little while)");
for (s = (server_rec *) server_list->xas_list; s; s = s->next) {
config_rec *c;
c = find_config(s->conf, CONF_PARAM, "MasqueradeAddress", FALSE);
if (c != NULL) {
const char *masq_addr;
pr_netaddr_t *na;
masq_addr = c->argv[1];
pr_netaddr_clear_ipcache(masq_addr);
na = pr_netaddr_get_addr(s->pool, masq_addr, NULL);
if (na != NULL) {
/* Compare the obtained netaddr with the one already present.
* Only update the "live" netaddr if they differ.
*/
pr_log_debug(DEBUG2, MOD_DYNMASQ_VERSION
": resolved MasqueradeAddress '%s' to IP address %s", masq_addr,
pr_netaddr_get_ipstr(na));
if (pr_netaddr_cmp(c->argv[0], na) != 0) {
pr_log_pri(PR_LOG_DEBUG, MOD_DYNMASQ_VERSION
": MasqueradeAddress '%s' updated for new address %s (was %s)",
masq_addr, pr_netaddr_get_ipstr(na),
pr_netaddr_get_ipstr(c->argv[0]));
/* Overwrite the old netaddr pointer. Note that this constitutes
* a minor memory leak, as there currently isn't a way to free
* the memory used by a netaddr object. Hrm.
*/
c->argv[0] = na;
} else {
pr_log_debug(DEBUG2, MOD_DYNMASQ_VERSION
": MasqueradeAddress '%s' has not changed addresses", masq_addr);
}
} else {
pr_log_pri(PR_LOG_INFO, MOD_DYNMASQ_VERSION
": unable to resolve '%s', keeping previous address", masq_addr);
}
}
}
return;
}
int pr_ipbind_add_binds(server_rec *serv) {
int res = 0;
config_rec *c = NULL;
conn_t *listen_conn = NULL;
const pr_netaddr_t *addr = NULL;
if (serv == NULL) {
errno = EINVAL;
return -1;
}
c = find_config(serv->conf, CONF_PARAM, "_bind_", FALSE);
while (c != NULL) {
listen_conn = NULL;
pr_signals_handle();
addr = pr_netaddr_get_addr(serv->pool, c->argv[0], NULL);
if (addr == NULL) {
pr_log_pri(PR_LOG_WARNING,
"notice: unable to determine IP address of '%s'", (char *) c->argv[0]);
c = find_config_next(c, c->next, CONF_PARAM, "_bind_", FALSE);
continue;
}
/* If the SocketBindTight directive is in effect, create a separate
* listen socket for this address, and add it to the binding list.
*/
if (SocketBindTight &&
serv->ServerPort) {
listen_conn = pr_ipbind_get_listening_conn(serv, addr, serv->ServerPort);
if (listen_conn == NULL) {
return -1;
}
PR_CREATE_IPBIND(serv, addr, serv->ServerPort);
PR_OPEN_IPBIND(addr, serv->ServerPort, listen_conn, FALSE, FALSE, TRUE);
} else {
PR_CREATE_IPBIND(serv, addr, serv->ServerPort);
PR_OPEN_IPBIND(addr, serv->ServerPort, serv->listen, FALSE, FALSE, TRUE);
}
c = find_config_next(c, c->next, CONF_PARAM, "_bind_", FALSE);
}
return 0;
}
END_TEST
START_TEST (trace_msg_test) {
int res;
char *channel, msg[16384];
res = pr_trace_msg(NULL, -1, NULL);
fail_unless(res < 0, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
channel = "testsuite";
res = pr_trace_msg(channel, -1, NULL);
fail_unless(res < 0, "Failed to handle bad level");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
res = pr_trace_msg(channel, 1, NULL);
fail_unless(res < 0, "Failed to handle null message");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
pr_trace_set_levels(channel, 1, 10);
memset(msg, 'A', sizeof(msg)-1);
msg[sizeof(msg)-1] = '\0';
pr_trace_msg(channel, 5, "%s", msg);
session.c = pr_inet_create_conn(p, -1, NULL, INPORT_ANY, FALSE);
fail_unless(session.c != NULL, "Failed to create conn: %s", strerror(errno));
session.c->local_addr = session.c->remote_addr =
pr_netaddr_get_addr(p, "127.0.0.1", NULL);
res = pr_trace_set_options(PR_TRACE_OPT_LOG_CONN_IPS|PR_TRACE_OPT_USE_TIMESTAMP_MILLIS);
fail_unless(res == 0, "Failed to set options: %s", strerror(errno));
pr_trace_msg(channel, 5, "%s", "alef bet vet?");
res = pr_trace_set_options(0);
fail_unless(res == 0, "Failed to set options: %s", strerror(errno));
pr_trace_msg(channel, 5, "%s", "alef bet vet?");
pr_inet_close(p, session.c);
session.c = NULL;
pr_trace_set_levels(channel, 0, 0);
}
END_TEST
START_TEST (netaddr_get_family_test) {
pr_netaddr_t *addr;
int res;
res = pr_netaddr_get_family(NULL);
fail_unless(res == -1, "Failed to handle null argument");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
addr = pr_netaddr_get_addr(p, "localhost", NULL);
fail_unless(addr != NULL, "Failed to get addr for 'localhost': %s",
strerror(errno));
res = pr_netaddr_get_family(addr);
fail_unless(res == AF_INET, "Expected family %d, got %d", AF_INET,
res);
}
END_TEST
START_TEST (inet_openrw_test) {
conn_t *res, *conn;
const pr_netaddr_t *addr;
res = proxy_inet_openrw(NULL, NULL, NULL, PR_NETIO_STRM_CTRL, -1, -1, -1,
FALSE);
fail_unless(res == NULL, "Failed to handle null arguments");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got '%s' (%d)", EINVAL,
strerror(errno), errno);
res = proxy_inet_openrw(p, NULL, NULL, PR_NETIO_STRM_CTRL, -1, -1, -1,
FALSE);
fail_unless(res == NULL, "Failed to handle null conn");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got '%s' (%d)", EINVAL,
strerror(errno), errno);
conn = pr_inet_create_conn(p, -2, NULL, INPORT_ANY, FALSE);
fail_unless(conn != NULL, "Failed to create conn: %s", strerror(errno));
res = proxy_inet_openrw(p, conn, NULL, PR_NETIO_STRM_OTHR, -1, -1, -1,
FALSE);
fail_unless(res == NULL, "Failed to handle null addr");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got '%s' (%d)", EINVAL,
strerror(errno), errno);
proxy_inet_close(p, conn);
addr = pr_netaddr_get_addr(p, "127.0.0.1", NULL);
fail_unless(addr != NULL, "Failed to resolve '127.0.0.1': %s",
strerror(errno));
res = proxy_inet_openrw(p, conn, addr, PR_NETIO_STRM_OTHR, -1, -1, -1,
FALSE);
fail_unless(res != NULL, "Failed to open rw conn: %s", strerror(errno));
proxy_inet_close(p, conn);
}
const pr_netaddr_t *proxy_ftp_msg_parse_addr(pool *p, const char *msg,
int addr_family) {
int valid_fmt = FALSE;
const char *ptr;
char *addr_buf;
unsigned int h1, h2, h3, h4, p1, p2;
unsigned short port;
size_t addrlen;
pr_netaddr_t *addr;
if (p == NULL ||
msg == NULL) {
errno = EINVAL;
return NULL;
}
/* Have to scan the message for the encoded address/port. Note that we may
* see some strange formats for PASV responses from FTP servers here.
*
* We can't predict where the expected address/port numbers start in the
* string, so start from the beginning.
*/
for (ptr = msg; *ptr; ptr++) {
if (sscanf(ptr, "%u,%u,%u,%u,%u,%u", &h1, &h2, &h3, &h4, &p1, &p2) == 6) {
valid_fmt = TRUE;
break;
}
}
if (valid_fmt == FALSE) {
pr_trace_msg(trace_channel, 12,
"unable to find PORT/PASV address/port format in '%s'", msg);
errno = EPERM;
return NULL;
}
if (h1 > 255 || h2 > 255 || h3 > 255 || h4 > 255 ||
p1 > 255 || p2 > 255 ||
(h1|h2|h3|h4) == 0 ||
(p1|p2) == 0) {
pr_trace_msg(trace_channel, 9,
"message '%s' has invalid address/port value(s)", msg);
errno = EINVAL;
return NULL;
}
/* A dotted quad address has a maximum size of 16 bytes: 4 numbers of 3 digits
* (max), 3 periods, and 1 terminating NUL.
*/
addrlen = 16;
#ifdef PR_USE_IPV6
/* Allow extra room for any necessary "::ffff:" prefix, for IPv6 sessions. */
addrlen += 7;
#endif /* PR_USE_IPV6 */
addr_buf = pcalloc(p, addrlen);
#ifdef PR_USE_IPV6
if (pr_netaddr_use_ipv6()) {
if (addr_family == AF_INET6) {
snprintf(addr_buf, addrlen-1, "::ffff:%u.%u.%u.%u", h1, h2, h3, h4);
} else {
snprintf(addr_buf, addrlen-1, "%u.%u.%u.%u", h1, h2, h3, h4);
}
} else {
snprintf(addr_buf, addrlen-1, "%u.%u.%u.%u", h1, h2, h3, h4);
}
#else
snprintf(addr_buf, addrlen-1, "%u.%u.%u.%u", h1, h2, h3, h4);
#endif /* PR_USE_IPV6 */
/* XXX Ideally we would NOT be using session pool here, but some other
* pool. These objects can't be destroyed (they have no pools of their own),
* so they will just clutter up the session pool. Perhaps we could have
* a pool of addrs in this API, for reusing.
*/
addr = (pr_netaddr_t *) pr_netaddr_get_addr(session.pool, addr_buf, NULL);
if (addr == NULL) {
int xerrno = errno;
pr_trace_msg(trace_channel, 7,
"unable to resolve '%s' from message '%s': %s", addr_buf, msg,
strerror(xerrno));
errno = xerrno;
return NULL;
}
port = (p1 << 8) + p2;
pr_netaddr_set_port2(addr, port);
return addr;
}
END_TEST
START_TEST (fmt_ext_addr_test) {
const char *res, *expected;
const pr_netaddr_t *addr;
unsigned short port = 2121;
mark_point();
res = proxy_ftp_msg_fmt_ext_addr(NULL, NULL, 0, 0, FALSE);
fail_unless(res == NULL, "Failed to handle null pool");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got '%s' (%d)", EINVAL,
strerror(errno), errno);
mark_point();
res = proxy_ftp_msg_fmt_ext_addr(p, NULL, 0, 0, FALSE);
fail_unless(res == NULL, "Failed to handle null addr");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got '%s' (%d)", EINVAL,
strerror(errno), errno);
addr = pr_netaddr_get_addr(p, "127.0.0.1", NULL);
fail_unless(addr != NULL, "Failed to get addr for 127.0.0.1: %s",
strerror(errno));
mark_point();
res = proxy_ftp_msg_fmt_ext_addr(p, addr, port, 0, FALSE);
fail_unless(res == NULL, "Failed to handle null addr");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got '%s' (%d)", EINVAL,
strerror(errno), errno);
mark_point();
res = proxy_ftp_msg_fmt_ext_addr(p, addr, port, PR_CMD_EPRT_ID, FALSE);
fail_unless(res != NULL, "Failed to format addr: %s", strerror(errno));
expected = "|1|127.0.0.1|2121|";
fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'",
expected, res);
mark_point();
res = proxy_ftp_msg_fmt_ext_addr(p, addr, port, PR_CMD_EPSV_ID, FALSE);
fail_unless(res != NULL, "Failed to format addr: %s", strerror(errno));
expected = "|||2121|";
fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'",
expected, res);
#if PR_USE_IPV6
addr = pr_netaddr_get_addr(p, "::1", NULL);
fail_unless(addr != NULL, "Failed to get addr for ::1: %s",
strerror(errno));
mark_point();
res = proxy_ftp_msg_fmt_ext_addr(p, addr, port, PR_CMD_EPRT_ID, FALSE);
fail_unless(res != NULL, "Failed to format addr: %s", strerror(errno));
expected = "|2|::1|2121|";
fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'",
expected, res);
mark_point();
res = proxy_ftp_msg_fmt_ext_addr(p, addr, port, PR_CMD_EPSV_ID, FALSE);
fail_unless(res != NULL, "Failed to format addr: %s", strerror(errno));
expected = "|||2121|";
fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'",
expected, res);
#endif /* PR_USE_IPV6 */
}
END_TEST
START_TEST (parse_ext_addr_test) {
const pr_netaddr_t *addr, *res;
const char *msg;
res = proxy_ftp_msg_parse_ext_addr(NULL, NULL, NULL, 0, NULL);
fail_unless(res == NULL, "Failed to handle null pool");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got '%s' (%d)", EINVAL,
strerror(errno), errno);
res = proxy_ftp_msg_parse_ext_addr(p, NULL, NULL, 0, NULL);
fail_unless(res == NULL, "Failed to handle null msg");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got '%s' (%d)", EINVAL,
strerror(errno), errno);
msg = "foo";
res = proxy_ftp_msg_parse_ext_addr(p, msg, NULL, 0, NULL);
fail_unless(res == NULL, "Failed to handle null addr");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
addr = pr_netaddr_get_addr(p, "127.0.0.1", NULL);
fail_unless(addr != NULL, "Failed to get address for 127.0.0.1: %s",
strerror(errno));
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, 0, NULL);
fail_unless(res == NULL, "Failed to handle bad network protocol");
fail_unless(errno == EPROTOTYPE, "Expected EPROTOTYPE (%d), got '%s' (%d)",
EPROTOTYPE, strerror(errno), errno);
/* EPSV response formats */
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle bad EPSV response");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
msg = "(foo";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle bad EPSV response");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
msg = "(foo)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle bad network protocol");
fail_unless(errno == EPROTOTYPE, "Expected EPROTOTYPE (%d), got '%s' (%d)",
EPROTOTYPE, strerror(errno), errno);
msg = "(1)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle bad network protocol");
fail_unless(errno == EPROTOTYPE, "Expected EPROTOTYPE (%d), got '%s' (%d)",
EPROTOTYPE, strerror(errno), errno);
msg = "(|4)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle bad network protocol");
fail_unless(errno == EPROTOTYPE, "Expected EPROTOTYPE (%d), got '%s' (%d)",
EPROTOTYPE, strerror(errno), errno);
msg = "(|0)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle bad network protocol");
fail_unless(errno == EPROTOTYPE, "Expected EPROTOTYPE (%d), got '%s' (%d)",
EPROTOTYPE, strerror(errno), errno);
msg = "(|1)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle bad network protocol");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
msg = "(|2)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle bad network protocol");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
/* Where the network protocol matches that of the address... */
msg = "(|1|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle badly formatted message");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
msg = "(|1|1.2.3.4)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle badly formatted message");
fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
strerror(errno), errno);
msg = "(|1|1.2.3.4|5)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle badly formatted message");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
msg = "(|1|1.2.3.4|5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res != NULL, "Failed to handle formatted message '%s': %s", msg,
strerror(errno));
msg = "(||1.2.3.4|5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res != NULL, "Failed to handle formatted message '%s': %s", msg,
strerror(errno));
msg = "(||1.2.3.4|5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, "all");
fail_unless(res != NULL, "Failed to handle formatted message '%s': %s", msg,
strerror(errno));
msg = "(||1.2.3.4|5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, "1");
fail_unless(res != NULL, "Failed to handle formatted message '%s': %s", msg,
strerror(errno));
msg = "(|||5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res != NULL, "Failed to handle formatted message '%s': %s", msg,
strerror(errno));
fail_unless(
strcmp(pr_netaddr_get_ipstr(addr), pr_netaddr_get_ipstr(res)) == 0,
"Expected '%s', got '%s'", pr_netaddr_get_ipstr(addr),
pr_netaddr_get_ipstr(res));
/* ...and where the network protocol does not match that of the address. */
msg = "(||::1|5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle network protocol mismatch");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
msg = "(|2|1.2.3.4|5)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle network protocol mismatch");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
#ifdef PR_USE_IPV6
addr = pr_netaddr_get_addr(p, "::1", NULL);
fail_unless(addr != NULL, "Failed to get address for ::1: %s",
strerror(errno));
msg = "(|2|1.2.3.4|5)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle network protocol mismatch");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
msg = "(|1|::1|5)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle network protocol mismatch");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
msg = "(|2|::1|5)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle network protocol mismatch");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
msg = "(|2|::1|5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res != NULL, "Failed to handle formatted message '%s': %s", msg,
strerror(errno));
msg = "(|2|::1|5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, "ALL");
fail_unless(res != NULL, "Failed to handle formatted message '%s': %s", msg,
strerror(errno));
msg = "(||::1|5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, "2");
fail_unless(res != NULL, "Failed to handle formatted message '%s': %s", msg,
strerror(errno));
msg = "(||::1|5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res != NULL, "Failed to handle formatted message '%s': %s", msg,
strerror(errno));
msg = "(|||5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res != NULL, "Failed to handle formatted message '%s': %s", msg,
strerror(errno));
fail_unless(
strcmp(pr_netaddr_get_ipstr(addr), pr_netaddr_get_ipstr(res)) == 0,
"Expected '%s', got '%s'", pr_netaddr_get_ipstr(addr),
pr_netaddr_get_ipstr(res));
msg = "(||1.2.3.4|5|)";
res = proxy_ftp_msg_parse_ext_addr(p, msg, addr, PR_CMD_EPSV_ID, NULL);
fail_unless(res == NULL, "Failed to handle network protocol mismatch");
fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
strerror(errno), errno);
#endif /* PR_USE_IPV6 */
}
int main(int argc, char *argv[]) {
pool *p;
const char *remote_name;
pr_netaddr_t *remote_addr;
conn_t *client_conn, *ctrl_conn, *data_conn;
unsigned int connect_timeout, remote_port;
struct proxy_ftp_client *ftp;
int res, timerno;
char buf[1024];
/* Seed the random number generator. */
/* XXX Use random(3) in the future? */
srand((unsigned int) (time(NULL) * getpid()));
init_pools();
init_privs();
init_log();
init_regexp();
init_inet();
init_netio();
init_netaddr();
init_fs();
init_class();
init_config();
init_stash();
pr_log_setdebuglevel(10);
log_stderr(TRUE);
pr_trace_use_stderr(TRUE);
pr_trace_set_levels("DEFAULT", 1, 20);
p = make_sub_pool(permanent_pool);
pr_pool_tag(p, "FTP Client Pool");
remote_name = "ftp.proftpd.org";
remote_addr = pr_netaddr_get_addr(p, remote_name, NULL);
if (remote_addr == NULL) {
fprintf(stderr, "Failed to get addr for '%s': %s\n", remote_name,
strerror(errno));
destroy_pool(p);
return 1;
}
fprintf(stdout, "Resolved name '%s' to IP address '%s'\n", remote_name,
pr_netaddr_get_ipstr(remote_addr));
remote_port = 21;
connect_timeout = 5;
ftp = proxy_ftp_connect(p, remote_addr, remote_port, connect_timeout, NULL);
if (ftp == NULL) {
fprintf(stderr, "Error connecting to FTP server: %s\n", strerror(errno));
destroy_pool(p);
return 1;
}
fprintf(stdout, "Successfully connected to %s:%d from %s:%d\n", remote_name,
remote_port, pr_netaddr_get_ipstr(client_conn->local_addr),
ntohs(pr_netaddr_get_port(client_conn->local_addr)));
res = proxy_ftp_disconnect(ftp);
if (res < 0) {
fprintf(stderr, "Error disconnecting from FTP server: %s\n",
strerror(errno));
destroy_pool(p);
return 1;
}
ctrl_conn = pr_inet_openrw(p, client_conn, NULL, PR_NETIO_STRM_OTHR,
-1, -1, -1, FALSE);
if (ctrl_conn == NULL) {
fprintf(stderr, "Error opening control connection: %s\n", strerror(errno));
pr_inet_close(p, client_conn);
destroy_pool(p);
return 1;
}
fprintf(stdout, "Reading response from %s:%d\n", remote_name, remote_port);
/* Read the response */
memset(buf, '\0', sizeof(buf));
/* XXX We need to write our own version of netio_telnet_gets(), with
* the buffering to handle reassembly of a full FTP response out of
* multiple TCP packets. Not sure why the existing netio_telnet_gets()
* is not sufficient. But we don't need the handling of Telnet codes
* in our reading. But DO generate the 'core.ctrl-read' event, so that
* any event listeners get a chance to process the data we've received.
* (Or maybe use 'mod_proxy.server-read', and differentiate between
* client and server reads/writes?)
*/
if (pr_netio_read(ctrl_conn->instrm, buf, sizeof(buf)-1, 5) < 0) {
fprintf(stderr, "Error reading response from server: %s\n",
strerror(errno));
} else {
fprintf(stdout, "Response: \"%s\"\n", buf);
}
/* Disconnect */
res = pr_netio_printf(ctrl_conn->outstrm, "%s\r\n", C_QUIT);
if (res < 0) {
fprintf(stderr, "Error writing command to server: %s", strerror(errno));
}
pr_inet_close(p, ctrl_conn);
pr_inet_close(p, client_conn);
destroy_pool(p);
return 0;
}
END_TEST
START_TEST (netacl_match_test) {
pr_netacl_t *acl;
pr_netaddr_t *addr;
char *acl_str;
int have_localdomain = FALSE, res;
res = pr_netacl_match(NULL, NULL);
fail_unless(res == -2, "Failed to handle NULL arguments");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
acl_str = "all";
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, NULL);
fail_unless(res == -2, "Failed to handle NULL addr");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
addr = pr_netaddr_get_addr(p, "localhost", NULL);
fail_unless(addr != NULL, "Failed to get addr for '%s': %s", "localhost",
strerror(errno));
/* It's possible that the DNS name for 'localhost' that is used will
* actually be 'localhost.localdomain', depending on the contents of
* the host's /etc/hosts file.
*/
if (strcmp(pr_netaddr_get_dnsstr(addr), "localhost.localdomain") == 0) {
have_localdomain = TRUE;
}
res = pr_netacl_match(NULL, addr);
fail_unless(res == -2, "Failed to handle NULL ACL");
fail_unless(errno == EINVAL, "Failed to set errno to EINVAL");
res = pr_netacl_match(acl, addr);
fail_unless(res == 1, "Failed to positively match ACL to addr: %s",
strerror(errno));
acl_str = "none";
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == -1, "Failed to negatively match ACL to addr: %s",
strerror(errno));
acl_str = pstrdup(p, "127.0.0.1");
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == 1, "Failed to positively match ACL to addr: %s",
strerror(errno));
acl_str = pstrdup(p, "!127.0.0.1");
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == -1, "Failed to negatively match ACL to addr: %s",
strerror(errno));
acl_str = pstrdup(p, "192.168.0.1");
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == 0, "Failed to match ACL to addr: %s", strerror(errno));
acl_str = pstrdup(p, "!192.168.0.1");
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == 1, "Failed to positively match ACL to addr: %s",
strerror(errno));
acl_str = pstrdup(p, "127.0.0.0/24");
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == 1, "Failed to positively match ACL to addr: %s",
strerror(errno));
acl_str = pstrdup(p, "!127.0.0.0/24");
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == -1, "Failed to negatively match ACL to addr: %s",
strerror(errno));
acl_str = pstrdup(p, "127.0.0.");
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == 1, "Failed to positively match ACL to addr: %s",
strerror(errno));
acl_str = pstrdup(p, "!127.0.0.");
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == -1, "Failed to negatively match ACL to addr: %s",
strerror(errno));
if (!have_localdomain) {
acl_str = pstrdup(p, "localhost");
} else {
acl_str = pstrdup(p, "localhost.localdomain");
}
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == 1, "Failed to positively match ACL to addr: %s",
strerror(errno));
if (!have_localdomain) {
acl_str = pstrdup(p, "!localhost");
} else {
acl_str = pstrdup(p, "!localhost.localdomain");
}
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == -1, "Failed to negatively match ACL to addr: %s",
strerror(errno));
if (!have_localdomain) {
acl_str = pstrdup(p, "loc*st");
} else {
acl_str = pstrdup(p, "loc*st.loc*in");
}
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == 1, "Failed to positively match ACL to addr: %s",
strerror(errno));
if (!have_localdomain) {
acl_str = pstrdup(p, "!loc*st");
} else {
acl_str = pstrdup(p, "!loc*st.loc*in");
}
acl = pr_netacl_create(p, acl_str);
fail_unless(acl != NULL, "Failed to handle ACL string '%s': %s", acl_str,
strerror(errno));
res = pr_netacl_match(acl, addr);
fail_unless(res == -1, "Failed to negatively match ACL to addr: %s",
strerror(errno));
}