mirror of
https://github.com/zeromq/libzmq.git
synced 2024-12-25 22:30:51 +08:00
aa885c5a15
This fixes several instances where _MSC_VER was used to determine whether to use afunix.h or not. For example, MinGW requires the use of afunix.h but does not define _MSC_VER. The correct behavior is checking ZMQ_HAVE_WINDOWS. Signed-off-by: Stephan Lachnit <stephanlachnit@debian.org>
597 lines
17 KiB
C++
597 lines
17 KiB
C++
/* SPDX-License-Identifier: MPL-2.0 */
|
|
#include "testutil.hpp"
|
|
#include "testutil_unity.hpp"
|
|
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
|
|
#if defined _WIN32
|
|
#include "../src/windows.hpp"
|
|
#if defined ZMQ_HAVE_WINDOWS
|
|
#if defined ZMQ_HAVE_IPC
|
|
#include <direct.h>
|
|
#include <afunix.h>
|
|
#endif
|
|
#include <crtdbg.h>
|
|
#pragma warning(disable : 4996)
|
|
// iphlpapi is needed for if_nametoindex (not on Windows XP)
|
|
#if _WIN32_WINNT > _WIN32_WINNT_WINXP
|
|
#pragma comment(lib, "iphlpapi")
|
|
#endif
|
|
#endif
|
|
#else
|
|
#include <pthread.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <stdlib.h>
|
|
#include <grp.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/types.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <net/if.h>
|
|
#include <netdb.h>
|
|
#include <sys/un.h>
|
|
#include <dirent.h>
|
|
#if defined(ZMQ_HAVE_AIX)
|
|
#include <sys/types.h>
|
|
#include <sys/socketvar.h>
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef PATH_MAX
|
|
#define PATH_MAX 1024
|
|
#endif
|
|
|
|
const char *SEQ_END = (const char *) 1;
|
|
|
|
const char bounce_content[] = "12345678ABCDEFGH12345678abcdefgh";
|
|
|
|
static void send_bounce_msg (void *socket_)
|
|
{
|
|
send_string_expect_success (socket_, bounce_content, ZMQ_SNDMORE);
|
|
send_string_expect_success (socket_, bounce_content, 0);
|
|
}
|
|
|
|
static void recv_bounce_msg (void *socket_)
|
|
{
|
|
recv_string_expect_success (socket_, bounce_content, 0);
|
|
int rcvmore;
|
|
size_t sz = sizeof (rcvmore);
|
|
TEST_ASSERT_SUCCESS_ERRNO (
|
|
zmq_getsockopt (socket_, ZMQ_RCVMORE, &rcvmore, &sz));
|
|
TEST_ASSERT_TRUE (rcvmore);
|
|
recv_string_expect_success (socket_, bounce_content, 0);
|
|
TEST_ASSERT_SUCCESS_ERRNO (
|
|
zmq_getsockopt (socket_, ZMQ_RCVMORE, &rcvmore, &sz));
|
|
TEST_ASSERT_FALSE (rcvmore);
|
|
}
|
|
|
|
void bounce (void *server_, void *client_)
|
|
{
|
|
// Send message from client to server
|
|
send_bounce_msg (client_);
|
|
|
|
// Receive message at server side and
|
|
// check that message is still the same
|
|
recv_bounce_msg (server_);
|
|
|
|
// Send two parts back to client
|
|
send_bounce_msg (server_);
|
|
|
|
// Receive the two parts at the client side
|
|
recv_bounce_msg (client_);
|
|
}
|
|
|
|
static void send_bounce_msg_may_fail (void *socket_)
|
|
{
|
|
int timeout = 250;
|
|
TEST_ASSERT_SUCCESS_ERRNO (
|
|
zmq_setsockopt (socket_, ZMQ_SNDTIMEO, &timeout, sizeof (int)));
|
|
int rc = zmq_send (socket_, bounce_content, 32, ZMQ_SNDMORE);
|
|
TEST_ASSERT_TRUE ((rc == 32) || ((rc == -1) && (errno == EAGAIN)));
|
|
rc = zmq_send (socket_, bounce_content, 32, 0);
|
|
TEST_ASSERT_TRUE ((rc == 32) || ((rc == -1) && (errno == EAGAIN)));
|
|
}
|
|
|
|
static void recv_bounce_msg_fail (void *socket_)
|
|
{
|
|
int timeout = 250;
|
|
char buffer[32];
|
|
TEST_ASSERT_SUCCESS_ERRNO (
|
|
zmq_setsockopt (socket_, ZMQ_RCVTIMEO, &timeout, sizeof (int)));
|
|
TEST_ASSERT_FAILURE_ERRNO (EAGAIN, zmq_recv (socket_, buffer, 32, 0));
|
|
}
|
|
|
|
void expect_bounce_fail (void *server_, void *client_)
|
|
{
|
|
// Send message from client to server
|
|
send_bounce_msg_may_fail (client_);
|
|
|
|
// Receive message at server side (should not succeed)
|
|
recv_bounce_msg_fail (server_);
|
|
|
|
// Send message from server to client to test other direction
|
|
// If connection failed, send may block, without a timeout
|
|
send_bounce_msg_may_fail (server_);
|
|
|
|
// Receive message at client side (should not succeed)
|
|
recv_bounce_msg_fail (client_);
|
|
}
|
|
|
|
char *s_recv (void *socket_)
|
|
{
|
|
char buffer[256];
|
|
int size = zmq_recv (socket_, buffer, 255, 0);
|
|
if (size == -1)
|
|
return NULL;
|
|
if (size > 255)
|
|
size = 255;
|
|
buffer[size] = 0;
|
|
return strdup (buffer);
|
|
}
|
|
|
|
void s_send_seq (void *socket_, ...)
|
|
{
|
|
va_list ap;
|
|
va_start (ap, socket_);
|
|
const char *data = va_arg (ap, const char *);
|
|
while (true) {
|
|
const char *prev = data;
|
|
data = va_arg (ap, const char *);
|
|
bool end = data == SEQ_END;
|
|
|
|
if (!prev) {
|
|
TEST_ASSERT_SUCCESS_ERRNO (
|
|
zmq_send (socket_, 0, 0, end ? 0 : ZMQ_SNDMORE));
|
|
} else {
|
|
TEST_ASSERT_SUCCESS_ERRNO (zmq_send (
|
|
socket_, prev, strlen (prev) + 1, end ? 0 : ZMQ_SNDMORE));
|
|
}
|
|
if (end)
|
|
break;
|
|
}
|
|
va_end (ap);
|
|
}
|
|
|
|
void s_recv_seq (void *socket_, ...)
|
|
{
|
|
zmq_msg_t msg;
|
|
zmq_msg_init (&msg);
|
|
|
|
int more;
|
|
size_t more_size = sizeof (more);
|
|
|
|
va_list ap;
|
|
va_start (ap, socket_);
|
|
const char *data = va_arg (ap, const char *);
|
|
|
|
while (true) {
|
|
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&msg, socket_, 0));
|
|
|
|
if (!data)
|
|
TEST_ASSERT_EQUAL_INT (0, zmq_msg_size (&msg));
|
|
else
|
|
TEST_ASSERT_EQUAL_STRING (data, (const char *) zmq_msg_data (&msg));
|
|
|
|
data = va_arg (ap, const char *);
|
|
bool end = data == SEQ_END;
|
|
|
|
TEST_ASSERT_SUCCESS_ERRNO (
|
|
zmq_getsockopt (socket_, ZMQ_RCVMORE, &more, &more_size));
|
|
|
|
TEST_ASSERT_TRUE (!more == end);
|
|
if (end)
|
|
break;
|
|
}
|
|
va_end (ap);
|
|
|
|
zmq_msg_close (&msg);
|
|
}
|
|
|
|
void close_zero_linger (void *socket_)
|
|
{
|
|
int linger = 0;
|
|
int rc = zmq_setsockopt (socket_, ZMQ_LINGER, &linger, sizeof (linger));
|
|
TEST_ASSERT_TRUE (rc == 0 || errno == ETERM);
|
|
TEST_ASSERT_SUCCESS_ERRNO (zmq_close (socket_));
|
|
}
|
|
|
|
void setup_test_environment (int timeout_seconds_)
|
|
{
|
|
#if defined _WIN32
|
|
#if defined _MSC_VER
|
|
_set_abort_behavior (0, _WRITE_ABORT_MSG);
|
|
_CrtSetReportMode (_CRT_ASSERT, _CRTDBG_MODE_FILE);
|
|
_CrtSetReportFile (_CRT_ASSERT, _CRTDBG_FILE_STDERR);
|
|
#endif
|
|
#else
|
|
#if defined ZMQ_HAVE_CYGWIN
|
|
// abort test after 121 seconds
|
|
alarm (121);
|
|
#else
|
|
#if !defined ZMQ_DISABLE_TEST_TIMEOUT
|
|
// abort test after timeout_seconds_ seconds
|
|
alarm (timeout_seconds_);
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#if defined __MVS__
|
|
// z/OS UNIX System Services: Ignore SIGPIPE during test runs, as a
|
|
// workaround for no SO_NOGSIGPIPE socket option.
|
|
signal (SIGPIPE, SIG_IGN);
|
|
#endif
|
|
}
|
|
|
|
void msleep (int milliseconds_)
|
|
{
|
|
#ifdef ZMQ_HAVE_WINDOWS
|
|
Sleep (milliseconds_);
|
|
#else
|
|
usleep (static_cast<useconds_t> (milliseconds_) * 1000);
|
|
#endif
|
|
}
|
|
|
|
int is_ipv6_available ()
|
|
{
|
|
#if defined(ZMQ_HAVE_WINDOWS) && (_WIN32_WINNT < 0x0600)
|
|
return 0;
|
|
#else
|
|
int rc, ipv6 = 1;
|
|
struct sockaddr_in6 test_addr;
|
|
|
|
memset (&test_addr, 0, sizeof (test_addr));
|
|
test_addr.sin6_family = AF_INET6;
|
|
inet_pton (AF_INET6, "::1", &(test_addr.sin6_addr));
|
|
|
|
fd_t fd = socket (AF_INET6, SOCK_STREAM, IPPROTO_IP);
|
|
if (fd == retired_fd)
|
|
ipv6 = 0;
|
|
else {
|
|
#ifdef ZMQ_HAVE_WINDOWS
|
|
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const char *) &ipv6,
|
|
sizeof (int));
|
|
rc = setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, (const char *) &ipv6,
|
|
sizeof (int));
|
|
if (rc == SOCKET_ERROR)
|
|
ipv6 = 0;
|
|
else {
|
|
rc = bind (fd, (struct sockaddr *) &test_addr, sizeof (test_addr));
|
|
if (rc == SOCKET_ERROR)
|
|
ipv6 = 0;
|
|
}
|
|
#else
|
|
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &ipv6, sizeof (int));
|
|
rc = setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &ipv6, sizeof (int));
|
|
if (rc != 0)
|
|
ipv6 = 0;
|
|
else {
|
|
rc = bind (fd, reinterpret_cast<struct sockaddr *> (&test_addr),
|
|
sizeof (test_addr));
|
|
if (rc != 0)
|
|
ipv6 = 0;
|
|
}
|
|
#endif
|
|
close (fd);
|
|
}
|
|
|
|
return ipv6;
|
|
#endif // _WIN32_WINNT < 0x0600
|
|
}
|
|
|
|
int is_tipc_available ()
|
|
{
|
|
#ifndef ZMQ_HAVE_TIPC
|
|
return 0;
|
|
#else
|
|
int tipc = 0;
|
|
|
|
void *ctx = zmq_init (1);
|
|
TEST_ASSERT_NOT_NULL (ctx);
|
|
void *rep = zmq_socket (ctx, ZMQ_REP);
|
|
TEST_ASSERT_NOT_NULL (rep);
|
|
tipc = zmq_bind (rep, "tipc://{5560,0,0}");
|
|
|
|
zmq_close (rep);
|
|
zmq_ctx_term (ctx);
|
|
|
|
return tipc == 0;
|
|
#endif // ZMQ_HAVE_TIPC
|
|
}
|
|
|
|
int test_inet_pton (int af_, const char *src_, void *dst_)
|
|
{
|
|
#if defined(ZMQ_HAVE_WINDOWS) && (_WIN32_WINNT < 0x0600)
|
|
if (af_ == AF_INET) {
|
|
struct in_addr *ip4addr = (struct in_addr *) dst_;
|
|
|
|
ip4addr->s_addr = inet_addr (src_);
|
|
|
|
// INADDR_NONE is -1 which is also a valid representation for IP
|
|
// 255.255.255.255
|
|
if (ip4addr->s_addr == INADDR_NONE
|
|
&& strcmp (src_, "255.255.255.255") != 0) {
|
|
return 0;
|
|
}
|
|
|
|
// Success
|
|
return 1;
|
|
} else {
|
|
// Not supported.
|
|
return 0;
|
|
}
|
|
#else
|
|
return inet_pton (af_, src_, dst_);
|
|
#endif
|
|
}
|
|
|
|
sockaddr_in bind_bsd_socket (int socket_)
|
|
{
|
|
struct sockaddr_in saddr;
|
|
memset (&saddr, 0, sizeof (saddr));
|
|
saddr.sin_family = AF_INET;
|
|
saddr.sin_addr.s_addr = INADDR_ANY;
|
|
#if !defined(_WIN32_WINNT) || (_WIN32_WINNT >= 0x0600)
|
|
saddr.sin_port = 0;
|
|
#else
|
|
saddr.sin_port = htons (PORT_6);
|
|
#endif
|
|
|
|
TEST_ASSERT_SUCCESS_RAW_ERRNO (
|
|
bind (socket_, (struct sockaddr *) &saddr, sizeof (saddr)));
|
|
|
|
#if !defined(_WIN32_WINNT) || (_WIN32_WINNT >= 0x0600)
|
|
socklen_t saddr_len = sizeof (saddr);
|
|
TEST_ASSERT_SUCCESS_RAW_ERRNO (
|
|
getsockname (socket_, (struct sockaddr *) &saddr, &saddr_len));
|
|
#endif
|
|
|
|
return saddr;
|
|
}
|
|
|
|
fd_t connect_socket (const char *endpoint_, const int af_, const int protocol_)
|
|
{
|
|
struct sockaddr_storage addr;
|
|
// OSX is very opinionated and wants the size to match the AF family type
|
|
socklen_t addr_len;
|
|
const fd_t s_pre = socket (af_, SOCK_STREAM,
|
|
protocol_ == IPPROTO_UDP ? IPPROTO_UDP
|
|
: protocol_ == IPPROTO_TCP ? IPPROTO_TCP
|
|
: 0);
|
|
#ifdef ZMQ_HAVE_WINDOWS
|
|
TEST_ASSERT_NOT_EQUAL (INVALID_SOCKET, s_pre);
|
|
#else
|
|
TEST_ASSERT_NOT_EQUAL (-1, s_pre);
|
|
#endif
|
|
|
|
if (af_ == AF_INET || af_ == AF_INET6) {
|
|
const char *port = strrchr (endpoint_, ':') + 1;
|
|
char address[MAX_SOCKET_STRING];
|
|
// getaddrinfo does not like [x:y::z]
|
|
if (*strchr (endpoint_, '/') + 2 == '[') {
|
|
strcpy (address, strchr (endpoint_, '[') + 1);
|
|
address[strlen (address) - strlen (port) - 2] = '\0';
|
|
} else {
|
|
strcpy (address, strchr (endpoint_, '/') + 2);
|
|
address[strlen (address) - strlen (port) - 1] = '\0';
|
|
}
|
|
|
|
struct addrinfo *in, hint;
|
|
memset (&hint, 0, sizeof (struct addrinfo));
|
|
hint.ai_flags = AI_NUMERICSERV;
|
|
hint.ai_family = af_;
|
|
hint.ai_socktype = protocol_ == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
|
|
hint.ai_protocol = protocol_ == IPPROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;
|
|
|
|
TEST_ASSERT_SUCCESS_RAW_ZERO_ERRNO (
|
|
getaddrinfo (address, port, &hint, &in));
|
|
TEST_ASSERT_NOT_NULL (in);
|
|
memcpy (&addr, in->ai_addr, in->ai_addrlen);
|
|
addr_len = (socklen_t) in->ai_addrlen;
|
|
freeaddrinfo (in);
|
|
} else {
|
|
#if defined(ZMQ_HAVE_IPC)
|
|
// Cannot cast addr as gcc 4.4 will fail with strict aliasing errors
|
|
(*(struct sockaddr_un *) &addr).sun_family = AF_UNIX;
|
|
strcpy ((*(struct sockaddr_un *) &addr).sun_path, endpoint_);
|
|
addr_len = sizeof (struct sockaddr_un);
|
|
#else
|
|
return retired_fd;
|
|
#endif
|
|
}
|
|
|
|
TEST_ASSERT_SUCCESS_RAW_ERRNO (
|
|
connect (s_pre, (struct sockaddr *) &addr, addr_len));
|
|
|
|
return s_pre;
|
|
}
|
|
|
|
fd_t bind_socket_resolve_port (const char *address_,
|
|
const char *port_,
|
|
char *my_endpoint_,
|
|
const int af_,
|
|
const int protocol_)
|
|
{
|
|
struct sockaddr_storage addr;
|
|
// OSX is very opinionated and wants the size to match the AF family type
|
|
socklen_t addr_len;
|
|
const fd_t s_pre = socket (af_, SOCK_STREAM,
|
|
protocol_ == IPPROTO_UDP ? IPPROTO_UDP
|
|
: protocol_ == IPPROTO_TCP ? IPPROTO_TCP
|
|
: 0);
|
|
#ifdef ZMQ_HAVE_WINDOWS
|
|
TEST_ASSERT_NOT_EQUAL (INVALID_SOCKET, s_pre);
|
|
#else
|
|
TEST_ASSERT_NOT_EQUAL (-1, s_pre);
|
|
#endif
|
|
|
|
if (af_ == AF_INET || af_ == AF_INET6) {
|
|
#ifdef ZMQ_HAVE_WINDOWS
|
|
const char flag = '\1';
|
|
#elif defined ZMQ_HAVE_VXWORKS
|
|
char flag = '\1';
|
|
#else
|
|
int flag = 1;
|
|
#endif
|
|
struct addrinfo *in, hint;
|
|
memset (&hint, 0, sizeof (struct addrinfo));
|
|
hint.ai_flags = AI_NUMERICSERV;
|
|
hint.ai_family = af_;
|
|
hint.ai_socktype = protocol_ == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM;
|
|
hint.ai_protocol = protocol_ == IPPROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP;
|
|
|
|
TEST_ASSERT_SUCCESS_RAW_ERRNO (
|
|
setsockopt (s_pre, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof (int)));
|
|
TEST_ASSERT_SUCCESS_RAW_ZERO_ERRNO (
|
|
getaddrinfo (address_, port_, &hint, &in));
|
|
TEST_ASSERT_NOT_NULL (in);
|
|
memcpy (&addr, in->ai_addr, in->ai_addrlen);
|
|
addr_len = (socklen_t) in->ai_addrlen;
|
|
freeaddrinfo (in);
|
|
} else {
|
|
#if defined(ZMQ_HAVE_IPC)
|
|
// Cannot cast addr as gcc 4.4 will fail with strict aliasing errors
|
|
(*(struct sockaddr_un *) &addr).sun_family = AF_UNIX;
|
|
addr_len = sizeof (struct sockaddr_un);
|
|
#if defined ZMQ_HAVE_WINDOWS
|
|
char buffer[MAX_PATH] = "";
|
|
|
|
TEST_ASSERT_SUCCESS_RAW_ERRNO (tmpnam_s (buffer));
|
|
TEST_ASSERT_SUCCESS_RAW_ERRNO (_mkdir (buffer));
|
|
strcat (buffer, "/ipc");
|
|
#else
|
|
char buffer[PATH_MAX] = "";
|
|
strcpy (buffer, "tmpXXXXXX");
|
|
#ifdef HAVE_MKDTEMP
|
|
TEST_ASSERT_TRUE (mkdtemp (buffer));
|
|
strcat (buffer, "/socket");
|
|
#else
|
|
int fd = mkstemp (buffer);
|
|
TEST_ASSERT_TRUE (fd != -1);
|
|
close (fd);
|
|
#endif
|
|
#endif
|
|
strcpy ((*(struct sockaddr_un *) &addr).sun_path, buffer);
|
|
memcpy (my_endpoint_, "ipc://", 7);
|
|
strcat (my_endpoint_, buffer);
|
|
|
|
// TODO check return value of unlink
|
|
unlink (buffer);
|
|
#else
|
|
return retired_fd;
|
|
#endif
|
|
}
|
|
|
|
TEST_ASSERT_SUCCESS_RAW_ERRNO (
|
|
bind (s_pre, (struct sockaddr *) &addr, addr_len));
|
|
TEST_ASSERT_SUCCESS_RAW_ERRNO (listen (s_pre, SOMAXCONN));
|
|
|
|
if (af_ == AF_INET || af_ == AF_INET6) {
|
|
addr_len = sizeof (struct sockaddr_storage);
|
|
TEST_ASSERT_SUCCESS_RAW_ERRNO (
|
|
getsockname (s_pre, (struct sockaddr *) &addr, &addr_len));
|
|
snprintf (
|
|
my_endpoint_, 6 + strlen (address_) + 7 * sizeof (char), "%s://%s:%u",
|
|
protocol_ == IPPROTO_TCP ? "tcp"
|
|
: protocol_ == IPPROTO_UDP ? "udp"
|
|
: protocol_ == IPPROTO_WSS ? "wss"
|
|
: "ws",
|
|
address_,
|
|
af_ == AF_INET ? ntohs ((*(struct sockaddr_in *) &addr).sin_port)
|
|
: ntohs ((*(struct sockaddr_in6 *) &addr).sin6_port));
|
|
}
|
|
|
|
return s_pre;
|
|
}
|
|
|
|
bool streq (const char *lhs_, const char *rhs_)
|
|
{
|
|
return strcmp (lhs_, rhs_) == 0;
|
|
}
|
|
|
|
bool strneq (const char *lhs_, const char *rhs_)
|
|
{
|
|
return strcmp (lhs_, rhs_) != 0;
|
|
}
|
|
|
|
#if defined _WIN32
|
|
int fuzzer_corpus_encode (const char *dirname,
|
|
uint8_t ***data,
|
|
size_t **len,
|
|
size_t *num_cases)
|
|
{
|
|
(void) dirname;
|
|
(void) data;
|
|
(void) len;
|
|
(void) num_cases;
|
|
|
|
return -1;
|
|
}
|
|
|
|
#else
|
|
|
|
int fuzzer_corpus_encode (const char *dirname,
|
|
uint8_t ***data,
|
|
size_t **len,
|
|
size_t *num_cases)
|
|
{
|
|
TEST_ASSERT_NOT_NULL (dirname);
|
|
TEST_ASSERT_NOT_NULL (data);
|
|
TEST_ASSERT_NOT_NULL (len);
|
|
|
|
struct dirent *ent;
|
|
DIR *dir = opendir (dirname);
|
|
if (!dir)
|
|
return -1;
|
|
|
|
*len = NULL;
|
|
*data = NULL;
|
|
*num_cases = 0;
|
|
|
|
while ((ent = readdir (dir)) != NULL) {
|
|
if (!strcmp (ent->d_name, ".") || !strcmp (ent->d_name, ".."))
|
|
continue;
|
|
|
|
char *filename =
|
|
(char *) malloc (strlen (dirname) + strlen (ent->d_name) + 2);
|
|
TEST_ASSERT_NOT_NULL (filename);
|
|
strcpy (filename, dirname);
|
|
strcat (filename, "/");
|
|
strcat (filename, ent->d_name);
|
|
FILE *f = fopen (filename, "r");
|
|
free (filename);
|
|
if (!f)
|
|
continue;
|
|
|
|
fseek (f, 0, SEEK_END);
|
|
size_t file_len = ftell (f);
|
|
fseek (f, 0, SEEK_SET);
|
|
if (file_len == 0) {
|
|
fclose (f);
|
|
continue;
|
|
}
|
|
|
|
*len = (size_t *) realloc (*len, (*num_cases + 1) * sizeof (size_t));
|
|
TEST_ASSERT_NOT_NULL (*len);
|
|
*(*len + *num_cases) = file_len;
|
|
*data =
|
|
(uint8_t **) realloc (*data, (*num_cases + 1) * sizeof (uint8_t *));
|
|
TEST_ASSERT_NOT_NULL (*data);
|
|
*(*data + *num_cases) =
|
|
(uint8_t *) malloc (file_len * sizeof (uint8_t));
|
|
TEST_ASSERT_NOT_NULL (*(*data + *num_cases));
|
|
size_t read_bytes = 0;
|
|
read_bytes = fread (*(*data + *num_cases), 1, file_len, f);
|
|
TEST_ASSERT_EQUAL (file_len, read_bytes);
|
|
(*num_cases)++;
|
|
|
|
fclose (f);
|
|
}
|
|
|
|
closedir (dir);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|