2010-08-27 21:13:45 +02:00
|
|
|
/*
|
2017-05-01 13:11:11 +02:00
|
|
|
Copyright (c) 2007-2017 Contributors as noted in the AUTHORS file
|
2010-08-27 21:13:45 +02:00
|
|
|
|
2015-06-02 22:33:55 +02:00
|
|
|
This file is part of libzmq, the ZeroMQ core engine in C++.
|
2010-08-27 21:13:45 +02:00
|
|
|
|
2015-06-02 22:33:55 +02:00
|
|
|
libzmq is free software; you can redistribute it and/or modify it under
|
|
|
|
the terms of the GNU Lesser General Public License (LGPL) as published
|
|
|
|
by the Free Software Foundation; either version 3 of the License, or
|
2010-08-27 21:13:45 +02:00
|
|
|
(at your option) any later version.
|
|
|
|
|
2015-06-02 22:33:55 +02:00
|
|
|
As a special exception, the Contributors give you permission to link
|
|
|
|
this library with independent modules to produce an executable,
|
|
|
|
regardless of the license terms of these independent modules, and to
|
|
|
|
copy and distribute the resulting executable under terms of your choice,
|
|
|
|
provided that you also meet, for each linked independent module, the
|
|
|
|
terms and conditions of the license of that module. An independent
|
|
|
|
module is a module which is not derived from or based on this library.
|
|
|
|
If you modify this library, you must extend this exception to your
|
|
|
|
version of the library.
|
|
|
|
|
|
|
|
libzmq is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
|
|
|
License for more details.
|
2010-08-27 21:13:45 +02:00
|
|
|
|
2010-10-30 15:08:28 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
2010-08-27 21:13:45 +02:00
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
#ifndef __TESTUTIL_HPP_INCLUDED__
|
|
|
|
#define __TESTUTIL_HPP_INCLUDED__
|
2010-08-27 21:13:45 +02:00
|
|
|
|
2016-02-12 11:31:38 +01:00
|
|
|
#if defined ZMQ_CUSTOM_PLATFORM_HPP
|
2015-09-11 22:42:26 +02:00
|
|
|
# include "platform.hpp"
|
|
|
|
#else
|
|
|
|
# include "../src/platform.hpp"
|
|
|
|
#endif
|
2016-05-02 20:39:13 +02:00
|
|
|
#include "../include/zmq.h"
|
|
|
|
#include "../src/stdint.hpp"
|
2013-08-17 14:43:45 +02:00
|
|
|
|
2013-11-06 13:30:41 +01:00
|
|
|
// This defines the settle time used in tests; raise this if we
|
|
|
|
// get test failures on slower systems due to binds/connects not
|
|
|
|
// settled. Tested to work reliably at 1 msec on a fast PC.
|
2016-02-13 15:33:58 +01:00
|
|
|
#define SETTLE_TIME 300 // In msec
|
2017-05-01 13:11:11 +02:00
|
|
|
// Commonly used buffer size for ZMQ_LAST_ENDPOINT
|
|
|
|
#define MAX_SOCKET_STRING sizeof("tcp://127.0.0.1:65536")
|
|
|
|
|
|
|
|
// We need to test codepaths with non-random bind ports. List them here to
|
|
|
|
// keep them unique, to allow parallel test runs.
|
|
|
|
#define ENDPOINT_0 "tcp://127.0.0.1:5555"
|
|
|
|
#define ENDPOINT_1 "tcp://127.0.0.1:5556"
|
|
|
|
#define ENDPOINT_2 "tcp://127.0.0.1:5557"
|
|
|
|
#define ENDPOINT_3 "tcp://127.0.0.1:5558"
|
|
|
|
#define ENDPOINT_4 "udp://127.0.0.1:5559"
|
|
|
|
#define ENDPOINT_5 "udp://127.0.0.1:5560"
|
2013-11-06 13:30:41 +01:00
|
|
|
|
2012-08-23 22:40:30 +02:00
|
|
|
#undef NDEBUG
|
2013-09-15 20:07:33 +02:00
|
|
|
#include <time.h>
|
2012-08-23 22:40:30 +02:00
|
|
|
#include <assert.h>
|
2013-07-02 15:04:31 +02:00
|
|
|
#include <stdarg.h>
|
2013-09-15 20:07:33 +02:00
|
|
|
#include <string>
|
2014-06-27 15:56:29 +02:00
|
|
|
#include <string.h>
|
2010-08-28 13:58:23 +02:00
|
|
|
|
2013-08-17 14:43:45 +02:00
|
|
|
#if defined _WIN32
|
2016-07-12 15:58:17 +02:00
|
|
|
# include "../src/windows.hpp"
|
2013-10-04 18:48:52 +02:00
|
|
|
# if defined _MSC_VER
|
|
|
|
# include <crtdbg.h>
|
|
|
|
# pragma warning(disable:4996)
|
2016-07-12 15:58:17 +02:00
|
|
|
// iphlpapi is needed for if_nametoindex (not on Windows XP)
|
|
|
|
# if !defined ZMQ_HAVE_WINDOWS_TARGET_XP
|
|
|
|
# pragma comment(lib,"iphlpapi")
|
|
|
|
# endif
|
2013-10-04 18:48:52 +02:00
|
|
|
# endif
|
2013-09-15 20:07:33 +02:00
|
|
|
#else
|
2016-02-13 18:42:19 +01:00
|
|
|
# include <pthread.h>
|
2013-09-15 20:07:33 +02:00
|
|
|
# include <unistd.h>
|
|
|
|
# include <signal.h>
|
|
|
|
# include <stdlib.h>
|
|
|
|
# include <sys/wait.h>
|
2016-04-18 17:20:58 +02:00
|
|
|
# include <sys/socket.h>
|
|
|
|
# include <netinet/in.h>
|
|
|
|
# include <arpa/inet.h>
|
2016-12-06 21:09:57 +01:00
|
|
|
# if defined (ZMQ_HAVE_AIX)
|
|
|
|
# include <sys/types.h>
|
|
|
|
# include <sys/socketvar.h>
|
|
|
|
# endif
|
2013-08-17 14:43:45 +02:00
|
|
|
#endif
|
|
|
|
|
2017-08-19 13:18:51 +02:00
|
|
|
#define LIBZMQ_UNUSED(object) (void)object
|
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
// Bounce a message from client to server and back
|
|
|
|
// For REQ/REP or DEALER/DEALER pairs only
|
2013-07-02 15:04:31 +02:00
|
|
|
void
|
2013-05-16 20:29:55 +02:00
|
|
|
bounce (void *server, void *client)
|
2010-08-27 21:13:45 +02:00
|
|
|
{
|
2011-03-24 10:03:49 +01:00
|
|
|
const char *content = "12345678ABCDEFGH12345678abcdefgh";
|
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
// Send message from client to server
|
|
|
|
int rc = zmq_send (client, content, 32, ZMQ_SNDMORE);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 32);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_send (client, content, 32, 0);
|
2011-03-24 11:53:55 +01:00
|
|
|
assert (rc == 32);
|
2011-03-24 10:03:49 +01:00
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
// Receive message at server side
|
|
|
|
char buffer [32];
|
|
|
|
rc = zmq_recv (server, buffer, 32, 0);
|
2011-03-24 11:53:55 +01:00
|
|
|
assert (rc == 32);
|
2013-09-12 18:17:31 +02:00
|
|
|
// Check that message is still the same
|
|
|
|
assert (memcmp (buffer, content, 32) == 0);
|
2011-06-20 11:16:10 +02:00
|
|
|
int rcvmore;
|
|
|
|
size_t sz = sizeof (rcvmore);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_getsockopt (server, ZMQ_RCVMORE, &rcvmore, &sz);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 0);
|
|
|
|
assert (rcvmore);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_recv (server, buffer, 32, 0);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 32);
|
2013-09-12 18:17:31 +02:00
|
|
|
// Check that message is still the same
|
|
|
|
assert (memcmp (buffer, content, 32) == 0);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_getsockopt (server, ZMQ_RCVMORE, &rcvmore, &sz);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 0);
|
|
|
|
assert (!rcvmore);
|
2015-07-19 16:11:22 +02:00
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
// Send two parts back to client
|
|
|
|
rc = zmq_send (server, buffer, 32, ZMQ_SNDMORE);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 32);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_send (server, buffer, 32, 0);
|
2011-03-24 11:53:55 +01:00
|
|
|
assert (rc == 32);
|
2011-03-24 10:03:49 +01:00
|
|
|
|
2013-05-16 20:29:55 +02:00
|
|
|
// Receive the two parts at the client side
|
|
|
|
rc = zmq_recv (client, buffer, 32, 0);
|
2011-03-24 11:53:55 +01:00
|
|
|
assert (rc == 32);
|
2013-09-12 18:17:31 +02:00
|
|
|
// Check that message is still the same
|
|
|
|
assert (memcmp (buffer, content, 32) == 0);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_getsockopt (client, ZMQ_RCVMORE, &rcvmore, &sz);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 0);
|
|
|
|
assert (rcvmore);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_recv (client, buffer, 32, 0);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 32);
|
2013-09-12 18:17:31 +02:00
|
|
|
// Check that message is still the same
|
|
|
|
assert (memcmp (buffer, content, 32) == 0);
|
2013-05-16 20:29:55 +02:00
|
|
|
rc = zmq_getsockopt (client, ZMQ_RCVMORE, &rcvmore, &sz);
|
2011-06-20 11:16:10 +02:00
|
|
|
assert (rc == 0);
|
|
|
|
assert (!rcvmore);
|
2010-08-27 21:13:45 +02:00
|
|
|
}
|
|
|
|
|
2013-08-31 02:56:59 +02:00
|
|
|
// Same as bounce, but expect messages to never arrive
|
|
|
|
// for security or subscriber reasons.
|
|
|
|
void
|
|
|
|
expect_bounce_fail (void *server, void *client)
|
|
|
|
{
|
|
|
|
const char *content = "12345678ABCDEFGH12345678abcdefgh";
|
|
|
|
char buffer [32];
|
2015-01-30 11:57:31 +01:00
|
|
|
int timeout = 250;
|
2013-08-31 02:56:59 +02:00
|
|
|
|
|
|
|
// Send message from client to server
|
2014-05-19 17:01:44 +02:00
|
|
|
int rc = zmq_setsockopt (client, ZMQ_SNDTIMEO, &timeout, sizeof (int));
|
|
|
|
assert (rc == 0);
|
|
|
|
rc = zmq_send (client, content, 32, ZMQ_SNDMORE);
|
|
|
|
assert ((rc == 32) || ((rc == -1) && (errno == EAGAIN)));
|
2013-08-31 02:56:59 +02:00
|
|
|
rc = zmq_send (client, content, 32, 0);
|
2014-05-19 17:01:44 +02:00
|
|
|
assert ((rc == 32) || ((rc == -1) && (errno == EAGAIN)));
|
2013-08-31 02:56:59 +02:00
|
|
|
|
|
|
|
// Receive message at server side (should not succeed)
|
2013-09-02 17:22:24 +02:00
|
|
|
rc = zmq_setsockopt (server, ZMQ_RCVTIMEO, &timeout, sizeof (int));
|
2013-08-31 02:56:59 +02:00
|
|
|
assert (rc == 0);
|
|
|
|
rc = zmq_recv (server, buffer, 32, 0);
|
|
|
|
assert (rc == -1);
|
2013-09-02 18:21:36 +02:00
|
|
|
assert (zmq_errno () == EAGAIN);
|
2013-08-31 02:56:59 +02:00
|
|
|
|
2013-09-02 18:21:36 +02:00
|
|
|
// Send message from server to client to test other direction
|
2014-05-18 11:11:57 +02:00
|
|
|
// If connection failed, send may block, without a timeout
|
2014-05-19 17:01:44 +02:00
|
|
|
rc = zmq_setsockopt (server, ZMQ_SNDTIMEO, &timeout, sizeof (int));
|
|
|
|
assert (rc == 0);
|
2013-08-31 02:56:59 +02:00
|
|
|
rc = zmq_send (server, content, 32, ZMQ_SNDMORE);
|
2014-05-18 11:11:57 +02:00
|
|
|
assert (rc == 32 || (rc == -1 && zmq_errno () == EAGAIN));
|
2013-08-31 02:56:59 +02:00
|
|
|
rc = zmq_send (server, content, 32, 0);
|
2014-05-18 11:11:57 +02:00
|
|
|
assert (rc == 32 || (rc == -1 && zmq_errno () == EAGAIN));
|
2013-08-31 02:56:59 +02:00
|
|
|
|
2013-09-02 18:21:36 +02:00
|
|
|
// Receive message at client side (should not succeed)
|
|
|
|
rc = zmq_setsockopt (client, ZMQ_RCVTIMEO, &timeout, sizeof (int));
|
|
|
|
assert (rc == 0);
|
2013-08-31 02:56:59 +02:00
|
|
|
rc = zmq_recv (client, buffer, 32, 0);
|
|
|
|
assert (rc == -1);
|
2013-09-02 18:21:36 +02:00
|
|
|
assert (zmq_errno () == EAGAIN);
|
2013-08-31 02:56:59 +02:00
|
|
|
}
|
|
|
|
|
2013-06-28 11:42:54 +02:00
|
|
|
// Receive 0MQ string from socket and convert into C string
|
|
|
|
// Caller must free returned string. Returns NULL if the context
|
|
|
|
// is being terminated.
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert C string to 0MQ string and send to socket
|
|
|
|
int
|
|
|
|
s_send (void *socket, const char *string) {
|
|
|
|
int size = zmq_send (socket, string, strlen (string), 0);
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sends string as 0MQ string, as multipart non-terminal
|
|
|
|
int
|
|
|
|
s_sendmore (void *socket, const char *string) {
|
|
|
|
int size = zmq_send (socket, string, strlen (string), ZMQ_SNDMORE);
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define streq(s1,s2) (!strcmp ((s1), (s2)))
|
|
|
|
#define strneq(s1,s2) (strcmp ((s1), (s2)))
|
|
|
|
|
2013-07-07 12:49:24 +02:00
|
|
|
const char *SEQ_END = (const char *) 1;
|
2013-07-02 15:04:31 +02:00
|
|
|
|
|
|
|
// Sends a message composed of frames that are C strings or null frames.
|
|
|
|
// The list must be terminated by SEQ_END.
|
|
|
|
// Example: s_send_seq (req, "ABC", 0, "DEF", SEQ_END);
|
2015-09-11 22:42:26 +02:00
|
|
|
|
|
|
|
void
|
|
|
|
s_send_seq (void *socket, ...)
|
2013-07-02 15:04:31 +02:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2013-07-07 12:49:24 +02:00
|
|
|
if (!prev) {
|
2013-07-02 15:04:31 +02:00
|
|
|
int rc = zmq_send (socket, 0, 0, end ? 0 : ZMQ_SNDMORE);
|
|
|
|
assert (rc != -1);
|
|
|
|
}
|
2013-07-07 12:49:24 +02:00
|
|
|
else {
|
2013-07-02 15:04:31 +02:00
|
|
|
int rc = zmq_send (socket, prev, strlen (prev)+1, end ? 0 : ZMQ_SNDMORE);
|
|
|
|
assert (rc != -1);
|
|
|
|
}
|
|
|
|
if (end)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
va_end (ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Receives message a number of frames long and checks that the frames have
|
|
|
|
// the given data which can be either C strings or 0 for a null frame.
|
|
|
|
// The list must be terminated by SEQ_END.
|
|
|
|
// Example: s_recv_seq (rep, "ABC", 0, "DEF", SEQ_END);
|
2015-09-11 22:42:26 +02:00
|
|
|
|
|
|
|
void
|
|
|
|
s_recv_seq (void *socket, ...)
|
2013-07-02 15:04:31 +02:00
|
|
|
{
|
|
|
|
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 *);
|
2015-07-19 16:11:22 +02:00
|
|
|
|
2013-07-07 12:49:24 +02:00
|
|
|
while (true) {
|
2013-07-02 15:04:31 +02:00
|
|
|
int rc = zmq_msg_recv (&msg, socket, 0);
|
|
|
|
assert (rc != -1);
|
|
|
|
|
|
|
|
if (!data)
|
|
|
|
assert (zmq_msg_size (&msg) == 0);
|
|
|
|
else
|
|
|
|
assert (strcmp (data, (const char *)zmq_msg_data (&msg)) == 0);
|
|
|
|
|
|
|
|
data = va_arg (ap, const char *);
|
|
|
|
bool end = data == SEQ_END;
|
|
|
|
|
|
|
|
rc = zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
|
|
|
|
assert (rc == 0);
|
|
|
|
|
|
|
|
assert (!more == end);
|
|
|
|
if (end)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
va_end (ap);
|
|
|
|
|
|
|
|
zmq_msg_close (&msg);
|
|
|
|
}
|
|
|
|
|
2013-07-05 17:58:01 +02:00
|
|
|
|
2014-04-28 11:30:04 +02:00
|
|
|
// Sets a zero linger period on a socket and closes it.
|
2015-09-11 22:42:26 +02:00
|
|
|
void
|
|
|
|
close_zero_linger (void *socket)
|
2013-07-05 17:58:01 +02:00
|
|
|
{
|
|
|
|
int linger = 0;
|
|
|
|
int rc = zmq_setsockopt (socket, ZMQ_LINGER, &linger, sizeof(linger));
|
2013-09-02 17:22:24 +02:00
|
|
|
assert (rc == 0 || errno == ETERM);
|
2013-07-05 17:58:01 +02:00
|
|
|
rc = zmq_close (socket);
|
|
|
|
assert (rc == 0);
|
|
|
|
}
|
|
|
|
|
2015-09-11 22:42:26 +02:00
|
|
|
void
|
|
|
|
setup_test_environment (void)
|
2013-08-17 14:43:45 +02:00
|
|
|
{
|
|
|
|
#if defined _WIN32
|
2013-10-04 18:48:52 +02:00
|
|
|
# if defined _MSC_VER
|
2013-08-17 14:43:45 +02:00
|
|
|
_set_abort_behavior( 0, _WRITE_ABORT_MSG);
|
2013-08-17 15:23:22 +02:00
|
|
|
_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
|
|
|
|
_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
|
2013-10-04 18:48:52 +02:00
|
|
|
# endif
|
2014-12-29 23:39:19 +01:00
|
|
|
#else
|
|
|
|
#if defined ZMQ_HAVE_CYGWIN
|
|
|
|
// abort test after 121 seconds
|
|
|
|
alarm(121);
|
2014-05-19 17:00:09 +02:00
|
|
|
#else
|
2015-07-28 22:37:16 +02:00
|
|
|
# if !defined ZMQ_DISABLE_TEST_TIMEOUT
|
2014-05-19 17:00:09 +02:00
|
|
|
// abort test after 60 seconds
|
|
|
|
alarm(60);
|
2015-07-28 22:37:16 +02:00
|
|
|
# endif
|
2013-08-17 14:43:45 +02:00
|
|
|
#endif
|
2014-12-29 23:39:19 +01:00
|
|
|
#endif
|
2014-07-23 03:39:45 +02:00
|
|
|
#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
|
2013-08-17 14:43:45 +02:00
|
|
|
}
|
|
|
|
|
2013-11-06 13:30:41 +01:00
|
|
|
// Provide portable millisecond sleep
|
2015-09-11 22:42:26 +02:00
|
|
|
// http://www.cplusplus.com/forum/unices/60161/
|
|
|
|
// http://en.cppreference.com/w/cpp/thread/sleep_for
|
|
|
|
|
|
|
|
void
|
|
|
|
msleep (int milliseconds)
|
2013-11-06 13:30:41 +01:00
|
|
|
{
|
2013-10-18 11:12:48 +02:00
|
|
|
#ifdef ZMQ_HAVE_WINDOWS
|
2013-11-06 13:30:41 +01:00
|
|
|
Sleep (milliseconds);
|
2013-10-18 11:12:48 +02:00
|
|
|
#else
|
2013-11-06 13:30:41 +01:00
|
|
|
usleep (static_cast <useconds_t> (milliseconds) * 1000);
|
2013-10-18 11:12:48 +02:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2016-04-18 17:20:58 +02:00
|
|
|
// check if IPv6 is available (0/false if not, 1/true if it is)
|
|
|
|
// only way to reliably check is to actually open a socket and try to bind it
|
|
|
|
int
|
|
|
|
is_ipv6_available(void)
|
|
|
|
{
|
2016-08-27 17:40:43 +02:00
|
|
|
#if defined (ZMQ_HAVE_WINDOWS) && (_WIN32_WINNT < 0x0600)
|
|
|
|
return 0;
|
|
|
|
#else
|
2016-04-18 17:20:58 +02:00
|
|
|
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));
|
|
|
|
|
|
|
|
#ifdef ZMQ_HAVE_WINDOWS
|
|
|
|
SOCKET fd = socket (AF_INET6, SOCK_STREAM, IPPROTO_IP);
|
|
|
|
if (fd == INVALID_SOCKET)
|
|
|
|
ipv6 = 0;
|
|
|
|
else {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
closesocket (fd);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
int fd = socket (AF_INET6, SOCK_STREAM, IPPROTO_IP);
|
|
|
|
if (fd == -1)
|
|
|
|
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, (struct sockaddr *)&test_addr, sizeof (test_addr));
|
|
|
|
if (rc != 0)
|
|
|
|
ipv6 = 0;
|
|
|
|
}
|
|
|
|
close (fd);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return ipv6;
|
2016-08-27 17:40:43 +02:00
|
|
|
#endif // _WIN32_WINNT < 0x0600
|
2016-04-18 17:20:58 +02:00
|
|
|
}
|
2013-10-18 11:12:48 +02:00
|
|
|
|
2017-08-22 20:22:39 +02:00
|
|
|
#if defined (ZMQ_HAVE_WINDOWS)
|
|
|
|
|
|
|
|
int close (int fd)
|
|
|
|
{
|
|
|
|
return closesocket (fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2010-08-27 21:13:45 +02:00
|
|
|
#endif
|