static void
riemann_dd_disconnect(LogThrDestDriver *s)
{
RiemannDestDriver *self = (RiemannDestDriver *)s;
riemann_client_disconnect(self->client);
self->client = NULL;
}
void
riemann_client_free (riemann_client_t *client)
{
if (!client)
{
errno = EINVAL;
return;
}
errno = -riemann_client_disconnect (client);
free (client);
}
END_TEST
START_TEST (test_riemann_simple_communicate_query)
{
riemann_client_t *client;
riemann_message_t *response;
client = riemann_client_create (RIEMANN_CLIENT_TCP, "127.0.0.1", 5555);
response = riemann_communicate_query (client, "true");
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events > 0);
riemann_message_free (response);
riemann_client_disconnect (client);
client = riemann_client_create (RIEMANN_CLIENT_UDP, "127.0.0.1", 5555);
response = riemann_communicate_query (client, "true");
ck_assert (response == NULL);
ck_assert_errno (-errno, ENOTSUP);
riemann_client_disconnect (client);
riemann_client_free (client);
}
END_TEST
START_TEST (test_riemann_simple_communicate)
{
riemann_client_t *client, *dummy_client;
riemann_message_t *message, *response;
client = riemann_client_create (RIEMANN_CLIENT_TCP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
ck_assert (riemann_communicate (NULL, NULL) == NULL);
ck_assert_errno (-errno, ENOTCONN);
ck_assert (riemann_communicate (client, NULL) == NULL);
ck_assert_errno (-errno, EINVAL);
ck_assert (riemann_communicate (NULL, message) == NULL);
ck_assert_errno (-errno, ENOTCONN);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
dummy_client = riemann_client_new ();
ck_assert (riemann_communicate (dummy_client, message) == NULL);
ck_assert_errno (-errno, ENOTCONN);
riemann_client_free (dummy_client);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
riemann_message_free (response);
response = riemann_communicate
(client,
riemann_message_create_with_query
(riemann_query_new ("true")));
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events > 0);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_connect (client, RIEMANN_CLIENT_UDP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_connect (client, RIEMANN_CLIENT_TCP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate #2",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
riemann_message_set_query (message,
riemann_query_new ("true"));
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events > 0);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_connect (client, RIEMANN_CLIENT_UDP, "127.0.0.1", 5555);
message = riemann_message_create_with_events
(riemann_event_create (RIEMANN_EVENT_FIELD_HOST, "localhost",
RIEMANN_EVENT_FIELD_SERVICE, "test_riemann_simple_communicate #2",
RIEMANN_EVENT_FIELD_STATE, "ok",
RIEMANN_EVENT_FIELD_NONE),
NULL);
riemann_message_set_query (message,
riemann_query_new ("true"));
response = riemann_communicate (client, message);
ck_assert (response != NULL);
ck_assert_int_eq (response->ok, 1);
ck_assert (response->n_events == 0);
riemann_message_free (response);
riemann_client_disconnect (client);
riemann_client_free (client);
}
END_TEST
START_TEST (test_riemann_client_connect)
{
riemann_client_t *client;
client = riemann_client_new ();
ck_assert_errno (riemann_client_connect (NULL, RIEMANN_CLIENT_TCP,
"127.0.0.1", 5555), EINVAL);
ck_assert_errno (riemann_client_connect (client, RIEMANN_CLIENT_NONE,
"127.0.0.1", 5555), EINVAL);
ck_assert_errno (riemann_client_connect (client, RIEMANN_CLIENT_TCP,
NULL, 5555), EINVAL);
ck_assert_errno (riemann_client_connect (client, RIEMANN_CLIENT_TCP,
"127.0.0.1", -1), ERANGE);
if (network_tests_enabled ())
{
ck_assert_errno (riemann_client_connect (client, RIEMANN_CLIENT_TCP,
"127.0.0.1", 5559), ECONNREFUSED);
ck_assert (riemann_client_connect (client, RIEMANN_CLIENT_TCP,
"127.0.0.1", 5555) == 0);
ck_assert_errno (riemann_client_disconnect (client), 0);
ck_assert (riemann_client_connect (client, RIEMANN_CLIENT_TCP,
"127.0.0.1", 5555,
RIEMANN_CLIENT_OPTION_NONE) == 0);
ck_assert_errno (riemann_client_disconnect (client), 0);
ck_assert_errno (riemann_client_connect (client, RIEMANN_CLIENT_TCP,
"non-existent.example.com", 5555),
EADDRNOTAVAIL);
mock (socket, mock_enosys_int_always_fail);
ck_assert_errno (riemann_client_connect (client, RIEMANN_CLIENT_TCP,
"127.0.0.1", 5555),
ENOSYS);
restore (socket);
/** TLS tests **/
#if HAVE_GNUTLS
ck_assert_errno
(riemann_client_connect
(client, RIEMANN_CLIENT_TLS,
"127.0.0.1", 5554,
RIEMANN_CLIENT_OPTION_NONE),
EINVAL);
ck_assert_errno
(riemann_client_connect
(client, RIEMANN_CLIENT_TLS,
"127.0.0.1", 5554,
256,
RIEMANN_CLIENT_OPTION_NONE),
EINVAL);
ck_assert_errno
(riemann_client_connect
(client, RIEMANN_CLIENT_TLS,
"127.0.0.1", 5554,
RIEMANN_CLIENT_OPTION_TLS_CA_FILE, "tests/data/cacert.pem",
RIEMANN_CLIENT_OPTION_TLS_CERT_FILE, "tests/data/client.crt",
RIEMANN_CLIENT_OPTION_TLS_KEY_FILE, "tests/data/client.key",
RIEMANN_CLIENT_OPTION_NONE),
0);
riemann_client_disconnect (client);
ck_assert_errno
(riemann_client_connect
(client, RIEMANN_CLIENT_TLS,
"127.0.0.1", 5554,
RIEMANN_CLIENT_OPTION_TLS_CA_FILE, "tests/data/cacert-invalid.pem",
RIEMANN_CLIENT_OPTION_TLS_CERT_FILE, "tests/data/client.crt",
RIEMANN_CLIENT_OPTION_TLS_KEY_FILE, "tests/data/client.key",
RIEMANN_CLIENT_OPTION_NONE),
EPROTO);
ck_assert_errno
(riemann_client_connect
(client, RIEMANN_CLIENT_TLS,
"127.0.0.1", 5555,
RIEMANN_CLIENT_OPTION_TLS_CA_FILE, "tests/data/cacert.pem",
RIEMANN_CLIENT_OPTION_TLS_CERT_FILE, "tests/data/client.crt",
RIEMANN_CLIENT_OPTION_TLS_KEY_FILE, "tests/data/client.key",
RIEMANN_CLIENT_OPTION_TLS_HANDSHAKE_TIMEOUT, 1000,
RIEMANN_CLIENT_OPTION_NONE),
EPROTO);
#endif
}
ck_assert (client != NULL);
riemann_client_free (client);
}
static int
riemann_client_connect_va (riemann_client_t *client,
riemann_client_type_t type,
const char *hostname, int port,
va_list aq)
{
struct addrinfo hints, *res;
int sock;
riemann_client_tls_options_t tls_options;
if (!client || !hostname)
return -EINVAL;
if (port <= 0)
return -ERANGE;
memset (&hints, 0, sizeof (hints));
hints.ai_family = AF_UNSPEC;
switch (type)
{
case RIEMANN_CLIENT_TCP:
_riemann_client_connect_setup_tcp (client, &hints);
break;
case RIEMANN_CLIENT_UDP:
_riemann_client_connect_setup_udp (client, &hints);
break;
case RIEMANN_CLIENT_TLS:
{
va_list ap;
int e;
va_copy (ap, aq);
e = _riemann_client_connect_setup_tls (client, &hints, ap, &tls_options);
va_end (ap);
if (e != 0)
return e;
break;
}
default:
return -EINVAL;
}
if (getaddrinfo (hostname, NULL, &hints, &res) != 0)
return -EADDRNOTAVAIL;
sock = socket (res->ai_family, res->ai_socktype, 0);
if (sock == -1)
{
int e = errno;
freeaddrinfo (res);
return -e;
}
((struct sockaddr_in *)res->ai_addr)->sin_port = htons (port);
if (connect (sock, res->ai_addr, res->ai_addrlen) != 0)
{
int e = errno;
freeaddrinfo (res);
close (sock);
return -e;
}
riemann_client_disconnect (client);
client->sock = sock;
client->srv_addr = res;
if (type == RIEMANN_CLIENT_TLS)
return _riemann_client_connect_tls_handshake (client, &tls_options);
return 0;
}
