mirrors
/
xrdp
mirror of https://github.com/neutrinolabs/xrdp
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
xrdp/tests/libipm/test_libipm_recv_calls.c

922 lines
28 KiB
C
Raw Blame History

#if defined(HAVE_CONFIG_H)
#include "config_ac.h"
#endif
#include <unistd.h>
#include "libipm.h"
#include "os_calls.h"
#include "string_calls.h"
#include "trans.h"
#include "test_libipm.h"
/* Random(ish) values for test_libipm_send_recv_all_test */
#define TEST_y_VALUE 89
#define TEST_b_VALUE 1
#define TEST_n_VALUE -143
#define TEST_q_VALUE 329
#define TEST_i_VALUE -150000
#define TEST_u_VALUE 150000
#define TEST_x_VALUE -4500000000L
#define TEST_t_VALUE 8500000000L
#define TEST_s_VALUE "libipm recv test"
#define TEST_B_VALUE 'b', 'y', 'B', 'Y', '8', '2', '/'
/**
* Type for fields in the message header
*
* The type value is the offset of the field within the header
*/
enum header_field
{
HDR_IPM_VER = 0,
HDR_MSG_LEN = 2,
HDR_FACILITY = 4,
HDR_MSGNO = 6,
HDR_RESERVED = 8
};
/**
* Gets a message header field value */
static unsigned int
get_header_field(struct stream *s, enum header_field field)
{
unsigned int res;
char *saved_p = s->p;
s->p = s->data + (unsigned short)field;
if (field == HDR_RESERVED)
{
in_uint32_le(s, res);
}
else
{
in_uint16_le(s, res);
}
s->p = saved_p;
return res;
}
/**
* Sets a message header field value */
static void
set_header_field(struct stream *s, enum header_field field, unsigned int val)
{
char *saved_p = s->p;
s->p = s->data + (unsigned short)field;
if (field == HDR_RESERVED)
{
out_uint32_le(s, val);
}
else
{
out_uint16_le(s, val);
}
s->p = saved_p;
}
/**
* Flushes input on a non-blocking socket
*
* Returns number of bytes read
*/
static unsigned int
flush_socket(int sck)
{
char buff[1024];
unsigned int result = 0;
int status;
while (1)
{
status = g_sck_recv(g_t_in->sck, buff, sizeof(buff), 0);
if (status < 0)
{
break;
}
result += status;
}
return result;
}
/**
* Waits for an expected incoming message */
static void
check_for_incoming_message(unsigned short expected_msgno)
{
enum libipm_status status;
unsigned short msgno;
/* Get the message at the other end */
libipm_msg_in_reset(g_t_in);
status = libipm_msg_in_wait_available(g_t_in);
ck_assert_int_eq(status, E_LI_SUCCESS);
msgno = libipm_msg_in_get_msgno(g_t_in);
ck_assert_int_eq(msgno, expected_msgno);
}
/**
* Test for input truncated by a number of bytes
*
* This call assumes the output buffer contains a message of a single
* type that has already been successfully sent and checked.
*
* The send size is truncated, and the message is sent again. This
* lets us check the input parser won't accept a type for which
* there is insufficient data.
*/
static void
test_truncated_input_type(char typechar, void *valueptr,
int truncate_value,
enum libipm_status expected_status)
{
const char format[] = {typechar, '\0'};
enum libipm_status status;
int istatus;
unsigned int msg_size;
/* The same message is still in the buffer.
*
* reduce the payload length by the truncate value...*/
msg_size = get_header_field(g_t_out->out_s, HDR_MSG_LEN);
set_header_field(g_t_out->out_s, HDR_MSG_LEN, msg_size - truncate_value);
/* ...and re-send it */
istatus = trans_force_write(g_t_out);
ck_assert_int_eq(istatus, 0);
/* Catch the message at the other end */
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
switch (typechar)
{
case 'B':
/* For this type, the descriptor is critical to read
* the value */
status = libipm_msg_in_parse(g_t_in, format,
(struct fsb_type *)valueptr);
break;
default:
/* For other types, the value shouldn't be needed, as
* it's only written to if the parse is successful */
status = libipm_msg_in_parse(g_t_in, format,
(struct fsb_type *)NULL);
break;
}
ck_assert_int_eq(status, expected_status);
/* There should be 'truncate_value' extra octets left on the input
* socket which wasn't read when we shrunk the header */
istatus = flush_socket(g_t_in->sck);
ck_assert_int_eq(istatus, truncate_value);
/* Put the message size back to its original value, for further tests */
set_header_field(g_t_out->out_s, HDR_MSG_LEN, msg_size);
}
/**
* Test for bad header values
*
* This call assumes the output buffer contains a message containing
* a single 'u' type that has already been send and checked
*
* The specified header field is overwritten, and the message is
* sent. On the receive side we check for a 'bad header' error, and
* then put everything back to its starting place.
*/
static void
test_bad_header_value(enum header_field field, unsigned int test_val)
{
unsigned int old_val;
enum libipm_status status;
int istatus;
/* The same message is still in the buffer.
*
* Save the field value we are going to change, and replace it */
old_val = get_header_field(g_t_out->out_s, field);
set_header_field(g_t_out->out_s, field, test_val);
/* re-send the message */
istatus = trans_force_write(g_t_out);
ck_assert_int_eq(istatus, 0);
/* Catch the message at the other end. The error is
* reported when we wait for the incoming message */
libipm_msg_in_reset(g_t_in);
status = libipm_msg_in_wait_available(g_t_in);
ck_assert_int_eq(status, E_LI_BAD_HEADER);
/* There should be 5 extra octets ('u' + 32-bit value) left on the input
* socket which wasn't read when we broke the header */
istatus = flush_socket(g_t_in->sck);
ck_assert_int_eq(istatus, 1 + sizeof(uint32_t));
/* Put the message size back to its original value, for further tests */
set_header_field(g_t_out->out_s, field, old_val);
}
/***************************************************************************//**
* As the 'append all' test, but data is sent across a link, demarshalled,
* and validated */
START_TEST(test_libipm_send_recv_all_test)
{
ck_assert_ptr_ne(g_t_out, NULL);
ck_assert_ptr_ne(g_t_in, NULL);
static char bin_out[] = { TEST_B_VALUE };
struct libipm_fsb binary_desc = { (void *)bin_out, sizeof(bin_out) };
enum libipm_status status;
/* variables for received values */
uint8_t y;
int b;
int16_t n;
uint16_t q;
int32_t i;
uint32_t u;
int64_t x;
uint64_t t;
char *s;
int h = -1;
char B[sizeof(bin_out)];
char c;
/* The message is small enough to fit in the socket buffer */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO,
"ybnqiuxtshB",
TEST_y_VALUE,
TEST_b_VALUE,
TEST_n_VALUE,
TEST_q_VALUE,
TEST_i_VALUE,
TEST_u_VALUE,
TEST_x_VALUE,
TEST_t_VALUE,
TEST_s_VALUE,
g_fd,
&binary_desc);
ck_assert_int_eq(status, E_LI_SUCCESS);
/* Catch the message at the other end */
check_for_incoming_message(TEST_MESSAGE_NO);
/* Re-use our descriptor for the receive operation */
binary_desc.data = (void *)&B;
binary_desc.datalen = sizeof(B);
status = libipm_msg_in_parse(
g_t_in,
"ybnqiuxtshB",
&y, &b, &n, &q, &i, &u, &x, &t, &s, &h, &binary_desc);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(y, TEST_y_VALUE);
ck_assert_int_eq(b, TEST_b_VALUE);
ck_assert_int_eq(n, TEST_n_VALUE);
ck_assert_int_eq(q, TEST_q_VALUE);
ck_assert_int_eq(i, TEST_i_VALUE);
ck_assert_int_eq(u, TEST_u_VALUE);
ck_assert_int_eq(x, TEST_x_VALUE);
ck_assert_int_eq(t, TEST_t_VALUE);
check_binary_data_eq(TEST_s_VALUE, sizeof(TEST_s_VALUE) - 1,
s, g_strlen(s));
/* The file descriptor should not be -1, neither should it be
* the value we sent. It should also point to /dev/zero */
ck_assert_int_ne(h, -1);
ck_assert_int_ne(h, g_fd);
check_fd_is_dev_zero(h);
g_file_close(h);
check_binary_data_eq(bin_out, sizeof(bin_out), B, sizeof(B));
/* Check we're at the end of the message */
c = libipm_msg_in_peek_type(g_t_in);
ck_assert_int_eq(c, '\0');
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 'y'
*/
START_TEST(test_libipm_receive_y_type)
{
enum libipm_status status;
uint8_t y;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "y", TEST_y_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "y", &y);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(y, TEST_y_VALUE);
test_truncated_input_type('y', &y, 1, E_LI_BUFFER_OVERFLOW);
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 'b'
*/
START_TEST(test_libipm_receive_b_type)
{
enum libipm_status status;
int b;
int istatus;
char c;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "b", TEST_b_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "b", &b);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(b, TEST_b_VALUE);
test_truncated_input_type('b', &b, 1, E_LI_BUFFER_OVERFLOW);
/* Resend and re-catch the message */
istatus = trans_force_write(g_t_out);
ck_assert_int_eq(istatus, 0);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Modify the message to contain a '2' for the boolean */
c = libipm_msg_in_peek_type(g_t_in);
ck_assert_int_eq(c, 'b'); /* Next type should be a 'b' */
c = *(g_t_in->in_s->p + 1); /* This should be the test value */
ck_assert_int_eq(c, TEST_b_VALUE); /* Check it */
*(g_t_in->in_s->p + 1) = 2;
status = libipm_msg_in_parse( g_t_in, "b", &b);
ck_assert_int_eq(status, E_LI_BAD_VALUE);
/* Resend and re-catch the message */
istatus = trans_force_write(g_t_out);
ck_assert_int_eq(istatus, 0);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Modify the message to contain a '-1' for the boolean */
*(g_t_in->in_s->p + 1) = (char) -1;
status = libipm_msg_in_parse( g_t_in, "b", &b);
ck_assert_int_eq(status, E_LI_BAD_VALUE);
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 'n'
*/
START_TEST(test_libipm_receive_n_type)
{
enum libipm_status status;
int16_t n;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "n", TEST_n_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "n", &n);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(n, TEST_n_VALUE);
test_truncated_input_type('n', &n, 1, E_LI_BUFFER_OVERFLOW);
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 'q'
*/
START_TEST(test_libipm_receive_q_type)
{
enum libipm_status status;
uint16_t q;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "q", TEST_q_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "q", &q);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(q, TEST_q_VALUE);
test_truncated_input_type('q', &q, 1, E_LI_BUFFER_OVERFLOW);
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 'i'
*/
START_TEST(test_libipm_receive_i_type)
{
enum libipm_status status;
int32_t i;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "i", TEST_i_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "i", &i);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(i, TEST_i_VALUE);
test_truncated_input_type('i', &i, 1, E_LI_BUFFER_OVERFLOW);
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 'u'
*/
START_TEST(test_libipm_receive_u_type)
{
enum libipm_status status;
uint32_t u;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "u", TEST_u_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "u", &u);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(u, TEST_u_VALUE);
test_truncated_input_type('u', &u, 1, E_LI_BUFFER_OVERFLOW);
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 'x'
*/
START_TEST(test_libipm_receive_x_type)
{
enum libipm_status status;
int64_t x;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "x", TEST_x_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "x", &x);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(x, TEST_x_VALUE);
test_truncated_input_type('x', &x, 1, E_LI_BUFFER_OVERFLOW);
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 't'
*/
START_TEST(test_libipm_receive_t_type)
{
enum libipm_status status;
uint64_t t;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "t", TEST_t_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "t", &t);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(t, TEST_t_VALUE);
test_truncated_input_type('t', &t, 1, E_LI_BUFFER_OVERFLOW);
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 's'
*/
START_TEST(test_libipm_receive_s_type)
{
enum libipm_status status;
char *s;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "s", TEST_s_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "s", &s);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_binary_data_eq(TEST_s_VALUE, sizeof(TEST_s_VALUE) - 1,
s, g_strlen(s));
/* This effectively tests that unterminated strings are not
* passed back to the user */
test_truncated_input_type('s', &s, 1, E_LI_BAD_VALUE);
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 'h'
*/
START_TEST(test_libipm_receive_h_type)
{
enum libipm_status status;
int istatus;
unsigned int i;
int fd_count;
/* Get the number of open file descriptors */
int base_fd_count = get_open_fd_count();
ck_assert_int_gt(base_fd_count, 0);
/* Send the max number of copies of the /dev/zero
* file descriptor */
status = libipm_msg_out_init(g_t_out, TEST_MESSAGE_NO, NULL);
ck_assert_int_eq(status, E_LI_SUCCESS);
for (i = 0 ; i < LIBIPM_MAX_FD_PER_MSG; ++i)
{
status = libipm_msg_out_append(g_t_out, "h", g_fd);
ck_assert_int_eq(status, E_LI_SUCCESS);
}
libipm_msg_out_mark_end(g_t_out);
istatus = trans_force_write(g_t_out);
ck_assert_int_eq(istatus, 0);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the number of file descriptors has gone up as expected */
fd_count = get_open_fd_count();
ck_assert_int_eq(fd_count, base_fd_count + LIBIPM_MAX_FD_PER_MSG);
/* Check half the descriptors work */
for (i = 0 ; i < LIBIPM_MAX_FD_PER_MSG / 2; ++i)
{
int h = -1;
status = libipm_msg_in_parse(g_t_in, "h", &h);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_fd_is_dev_zero(h);
g_file_close(h);
}
/* Close the message without reading the other descriptors */
libipm_msg_in_reset(g_t_in);
/* Check all the file descriptors we received have been closed */
fd_count = get_open_fd_count();
ck_assert_int_eq(fd_count, base_fd_count);
}
END_TEST
/***************************************************************************//**
* Checks various receive errors for 'B'
*/
START_TEST(test_libipm_receive_B_type)
{
enum libipm_status status;
static char bin_out[] = { TEST_B_VALUE };
char bin_in[sizeof(bin_out)];
struct libipm_fsb binary_desc = { (void *)bin_out, sizeof(bin_out) };
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "B", &binary_desc);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
binary_desc.data = (void *)bin_in;
binary_desc.datalen = sizeof(bin_in);
status = libipm_msg_in_parse( g_t_in, "B", &binary_desc);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_binary_data_eq(bin_out, sizeof(bin_out),
bin_in, sizeof(bin_in));
/* Check a truncated binary object is rejected */
test_truncated_input_type('B', &binary_desc, 1, E_LI_BUFFER_OVERFLOW);
/* Check a binary object without a complete length field is rejected */
test_truncated_input_type('B', &binary_desc, sizeof(bin_out) + 1,
E_LI_BUFFER_OVERFLOW);
/* Check a binary object with a mismatching FSB length field is rejected */
--binary_desc.datalen;
test_truncated_input_type('B', &binary_desc, 0, E_LI_BAD_VALUE);
++binary_desc.datalen;
/* Check a binary object with a null FSB data field is rejected */
binary_desc.data = NULL;
test_truncated_input_type('B', &binary_desc, 0, E_LI_PROGRAM_ERROR);
test_truncated_input_type('B', NULL, 0, E_LI_PROGRAM_ERROR);
}
END_TEST
/***************************************************************************//**
* Checks for a message with a completely missing type
*/
START_TEST(test_libipm_receive_no_type)
{
enum libipm_status status;
uint32_t u;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "u", TEST_u_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "u", &u);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(u, TEST_u_VALUE);
/* Completely remove the type flag and the value from the message */
test_truncated_input_type('u', &u, sizeof(uint32_t) + 1,
E_LI_BUFFER_OVERFLOW);
}
END_TEST
/***************************************************************************//**
* Checks for a message with an unexpected type
*/
START_TEST(test_libipm_receive_unexpected_type)
{
enum libipm_status status;
int istatus;
uint32_t u;
int32_t i;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "u", TEST_u_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "u", &u);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(u, TEST_u_VALUE);
/* Resend and re-catch the message */
istatus = trans_force_write(g_t_out);
ck_assert_int_eq(istatus, 0);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Try parsing with a type mismatch */
status = libipm_msg_in_parse( g_t_in, "i", &i);
ck_assert_int_eq(status, E_LI_UNEXPECTED_TYPE);
}
END_TEST
/***************************************************************************//**
* Checks for a message with an unsupported type
*/
START_TEST(test_libipm_receive_unsupported_type)
{
enum libipm_status status;
int istatus;
uint32_t u;
char c;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "u", TEST_u_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "u", &u);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(u, TEST_u_VALUE);
/* Resend and re-catch the message */
istatus = trans_force_write(g_t_out);
ck_assert_int_eq(istatus, 0);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Modify the message to contain an unsupported type */
c = libipm_msg_in_peek_type(g_t_in);
ck_assert_int_eq(c, 'u'); /* Next type should be a 'u' */
*g_t_in->in_s->p = 'A'; /* unsupported type */
c = libipm_msg_in_peek_type(g_t_in);
ck_assert_int_eq(c, '?'); /* peek should say this is an error */
status = libipm_msg_in_parse( g_t_in, "A", NULL); /* Parse it anyway */
ck_assert_int_eq(status, E_LI_UNSUPPORTED_TYPE);
}
END_TEST
/***************************************************************************//**
* Checks for a message with an unimplemented type
*/
START_TEST(test_libipm_receive_unimplemented_type)
{
enum libipm_status status;
int istatus;
uint32_t u;
char c;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO_STRING_NO, "u", TEST_u_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO_STRING_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "u", &u);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(u, TEST_u_VALUE);
/* Resend and re-catch the message */
istatus = trans_force_write(g_t_out);
ck_assert_int_eq(istatus, 0);
check_for_incoming_message(TEST_MESSAGE_NO_STRING_NO);
/* Try parsing with an unimplemented type.
* To do this we need to modify the type marker in the input stream */
c = libipm_msg_in_peek_type(g_t_in);
ck_assert_int_eq(c, 'u'); /* Next type should be a 'u' */
*g_t_in->in_s->p = 'd'; /* reserved type */
c = libipm_msg_in_peek_type(g_t_in);
ck_assert_int_eq(c, 'd');
status = libipm_msg_in_parse( g_t_in, "d", NULL);
ck_assert_int_eq(status, E_LI_UNIMPLEMENTED_TYPE);
}
END_TEST
/***************************************************************************//**
* Checks for bad header values
*/
START_TEST(test_libipm_receive_bad_header)
{
enum libipm_status status;
uint32_t u;
unsigned short hdr_ipm_ver;
unsigned short hdr_facility;
unsigned int i;
/* First, a simple send... */
status = libipm_msg_out_simple_send(
g_t_out, TEST_MESSAGE_NO, "u", TEST_u_VALUE);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
/* Check the value */
status = libipm_msg_in_parse( g_t_in, "u", &u);
ck_assert_int_eq(status, E_LI_SUCCESS);
ck_assert_int_eq(u, TEST_u_VALUE);
/* Save existing header values */
hdr_ipm_ver = get_header_field(g_t_out->out_s, HDR_IPM_VER);
hdr_facility = get_header_field(g_t_out->out_s, HDR_FACILITY);
test_bad_header_value(HDR_IPM_VER, hdr_ipm_ver + 1);
test_bad_header_value(HDR_FACILITY, hdr_facility - 1);
test_bad_header_value(HDR_RESERVED, 0xff);
test_bad_header_value(HDR_MSG_LEN, LIBIPM_MAX_MESSAGE_SIZE + 1);
test_bad_header_value(HDR_MSG_LEN, 0xffff);
for (i = 0 ; i < LIBIPM_HEADER_SIZE; ++i)
{
test_bad_header_value(HDR_MSG_LEN, i);
}
}
END_TEST
/***************************************************************************//**
* Checks message erase works as expected
*/
START_TEST(test_libipm_receive_msg_erase)
{
enum libipm_status status;
int istatus;
const char *username = "username";
const char *password = "password";
/* Send a message containing sensitive information */
status = libipm_msg_out_simple_send(g_t_out, TEST_MESSAGE_NO, "ss",
username, password);
ck_assert_int_eq(status, E_LI_SUCCESS);
check_for_incoming_message(TEST_MESSAGE_NO);
libipm_set_flags(g_t_in, LIBIPM_E_MSG_IN_ERASE_AFTER_USE);
ck_assert_int_ne(does_stream_contain_string(g_t_in->in_s, password), 0);
libipm_msg_in_reset(g_t_in);
ck_assert_msg(does_stream_contain_string(g_t_in->in_s, password) == 0,
"Auto buffer reset on input not working");
/* The flag should be reset automatically */
/* Resend and re-catch the message */
istatus = trans_force_write(g_t_out);
ck_assert_int_eq(istatus, 0);
check_for_incoming_message(TEST_MESSAGE_NO);
ck_assert_int_ne(does_stream_contain_string(g_t_in->in_s, password), 0);
libipm_msg_in_reset(g_t_in);
ck_assert_msg(does_stream_contain_string(g_t_in->in_s, password) != 0,
"LIBIPM_E_MSG_IN_ERASE_AFTER_USE not automatically cleared");
}
END_TEST
/***************************************************************************//**
* Exercises codepaths that shouldn't be called (programming errors)
*/
START_TEST(test_libipm_receive_programming_errors)
{
enum libipm_status status;
int available;
int32_t dummy;
status = libipm_msg_in_wait_available(g_t_vanilla);
ck_assert_int_eq(status, E_LI_PROGRAM_ERROR);
status = libipm_msg_in_check_available(g_t_vanilla, &available);
ck_assert_int_eq(status, E_LI_PROGRAM_ERROR);
status = libipm_msg_in_parse(g_t_vanilla, "i", &dummy);
ck_assert_int_eq(status, E_LI_PROGRAM_ERROR);
libipm_msg_in_reset(g_t_vanilla); /* No status to check */
}
END_TEST
/******************************************************************************/
Suite *
make_suite_test_libipm_recv_calls(void)
{
Suite *s;
TCase *tc;
s = suite_create("libipm_recv");
tc = tcase_create("libipm_recv");
suite_add_tcase(s, tc);
tcase_add_test(tc, test_libipm_send_recv_all_test);
tcase_add_test(tc, test_libipm_receive_y_type);
tcase_add_test(tc, test_libipm_receive_b_type);
tcase_add_test(tc, test_libipm_receive_n_type);
tcase_add_test(tc, test_libipm_receive_q_type);
tcase_add_test(tc, test_libipm_receive_i_type);
tcase_add_test(tc, test_libipm_receive_u_type);
tcase_add_test(tc, test_libipm_receive_x_type);
tcase_add_test(tc, test_libipm_receive_t_type);
tcase_add_test(tc, test_libipm_receive_s_type);
tcase_add_test(tc, test_libipm_receive_h_type);
tcase_add_test(tc, test_libipm_receive_B_type);
tcase_add_test(tc, test_libipm_receive_no_type);
tcase_add_test(tc, test_libipm_receive_unexpected_type);
tcase_add_test(tc, test_libipm_receive_unsupported_type);
tcase_add_test(tc, test_libipm_receive_unimplemented_type);
tcase_add_test(tc, test_libipm_receive_bad_header);
tcase_add_test(tc, test_libipm_receive_msg_erase);
tcase_add_test(tc, test_libipm_receive_programming_errors);
return s;
}
Reference in New Issue View Git Blame Copy Permalink