ip.cpp 6.21 KB
Newer Older
Martin Sustrik's avatar
Martin Sustrik committed
1
/*
2
    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
Martin Sustrik's avatar
Martin Sustrik committed
3

4
    This file is part of libzmq, the ZeroMQ core engine in C++.
Martin Sustrik's avatar
Martin Sustrik committed
5

6 7 8
    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
Martin Sustrik's avatar
Martin Sustrik committed
9 10
    (at your option) any later version.

11 12 13 14 15 16 17 18 19 20 21 22 23 24
    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.
Martin Sustrik's avatar
Martin Sustrik committed
25

26
    You should have received a copy of the GNU Lesser General Public License
Martin Sustrik's avatar
Martin Sustrik committed
27 28 29
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

30
#include "precompiled.hpp"
Martin Sustrik's avatar
Martin Sustrik committed
31 32
#include "ip.hpp"
#include "err.hpp"
33
#include "macros.hpp"
Martin Sustrik's avatar
Martin Sustrik committed
34

35
#if !defined ZMQ_HAVE_WINDOWS
36
#include <fcntl.h>
37 38
#include <sys/types.h>
#include <sys/socket.h>
39
#include <netdb.h>
40
#include <netinet/in.h>
41
#include <netinet/tcp.h>
42 43 44 45 46 47
#endif

#if defined ZMQ_HAVE_OPENVMS
#include <ioctl.h>
#endif

48 49
zmq::fd_t zmq::open_socket (int domain_, int type_, int protocol_)
{
50 51
    int rc;

52 53
    //  Setting this option result in sane behaviour when exec() functions
    //  are used. Old sockets are closed and don't block TCP ports etc.
54
#if defined ZMQ_HAVE_SOCK_CLOEXEC
55 56 57 58
    type_ |= SOCK_CLOEXEC;
#endif

    fd_t s = socket (domain_, type_, protocol_);
59 60
#ifdef ZMQ_HAVE_WINDOWS
    if (s == INVALID_SOCKET)
jdc8's avatar
jdc8 committed
61
        return INVALID_SOCKET;
62 63 64 65
#else
    if (s == -1)
        return -1;
#endif
66 67 68 69

    //  If there's no SOCK_CLOEXEC, let's try the second best option. Note that
    //  race condition can cause socket not to be closed (if fork happens
    //  between socket creation and this point).
70
#if !defined ZMQ_HAVE_SOCK_CLOEXEC && defined FD_CLOEXEC
71
    rc = fcntl (s, F_SETFD, FD_CLOEXEC);
72 73 74
    errno_assert (rc != -1);
#endif

75 76 77 78 79 80
    //  On Windows, preventing sockets to be inherited by child processes.
#if defined ZMQ_HAVE_WINDOWS && defined HANDLE_FLAG_INHERIT
    BOOL brc = SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
    win_assert (brc);
#endif

81 82 83 84
    //  Socket is not yet connected so EINVAL is not a valid networking error
    rc = zmq::set_nosigpipe (s);
    errno_assert (rc == 0);

85 86 87
    return s;
}

88 89
void zmq::unblock_socket (fd_t s_)
{
90
#if defined ZMQ_HAVE_WINDOWS
91 92 93
    u_long nonblock = 1;
    int rc = ioctlsocket (s_, FIONBIO, &nonblock);
    wsa_assert (rc != SOCKET_ERROR);
94
#elif defined ZMQ_HAVE_OPENVMS
95 96
    int nonblock = 1;
    int rc = ioctl (s_, FIONBIO, &nonblock);
97 98
    errno_assert (rc != -1);
#else
99 100
    int flags = fcntl (s_, F_GETFL, 0);
    if (flags == -1)
101
        flags = 0;
102
    int rc = fcntl (s_, F_SETFL, flags | O_NONBLOCK);
103 104 105 106
    errno_assert (rc != -1);
#endif
}

107 108
void zmq::enable_ipv4_mapping (fd_t s_)
{
Matt Arsenault's avatar
Matt Arsenault committed
109 110
  (void) s_;

111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
#ifdef IPV6_V6ONLY
#ifdef ZMQ_HAVE_WINDOWS
    DWORD flag = 0;
#else
    int flag = 0;
#endif
    int rc = setsockopt (s_, IPPROTO_IPV6, IPV6_V6ONLY, (const char*) &flag,
        sizeof (flag));
#ifdef ZMQ_HAVE_WINDOWS
    wsa_assert (rc != SOCKET_ERROR);
#else
    errno_assert (rc == 0);
#endif
#endif
}
Matt Arsenault's avatar
Matt Arsenault committed
126

127
int zmq::get_peer_ip_address (fd_t sockfd_, std::string &ip_addr_)
128 129 130 131 132 133 134 135 136 137 138 139
{
    int rc;
    struct sockaddr_storage ss;

#if defined ZMQ_HAVE_HPUX || defined ZMQ_HAVE_WINDOWS
    int addrlen = static_cast <int> (sizeof ss);
#else
    socklen_t addrlen = sizeof ss;
#endif
    rc = getpeername (sockfd_, (struct sockaddr*) &ss, &addrlen);
#ifdef ZMQ_HAVE_WINDOWS
    if (rc == SOCKET_ERROR) {
140
        const int last_error = WSAGetLastError();
141 142 143 144
        wsa_assert (last_error != WSANOTINITIALISED &&
                    last_error != WSAEFAULT &&
                    last_error != WSAEINPROGRESS &&
                    last_error != WSAENOTSOCK);
145
        return 0;
146 147 148 149 150 151
    }
#else
    if (rc == -1) {
        errno_assert (errno != EBADF &&
                      errno != EFAULT &&
                      errno != ENOTSOCK);
152
        return 0;
153 154 155 156 157 158 159
    }
#endif

    char host [NI_MAXHOST];
    rc = getnameinfo ((struct sockaddr*) &ss, addrlen, host, sizeof host,
        NULL, 0, NI_NUMERICHOST);
    if (rc != 0)
160
        return 0;
161 162

    ip_addr_ = host;
163 164 165 166 167 168 169 170

    union {
        struct sockaddr sa;
        struct sockaddr_storage sa_stor;
    } u;

    u.sa_stor = ss;
    return (int) u.sa.sa_family;
171
}
172 173 174

void zmq::set_ip_type_of_service (fd_t s_, int iptos)
{
175
    int rc = setsockopt(s_, IPPROTO_IP, IP_TOS, reinterpret_cast<const char*>(&iptos), sizeof(iptos));
176

177 178 179 180 181 182
#ifdef ZMQ_HAVE_WINDOWS
    wsa_assert (rc != SOCKET_ERROR);
#else
    errno_assert (rc == 0);
#endif

183 184
    //  Windows and Hurd do not support IPV6_TCLASS
#if !defined (ZMQ_HAVE_WINDOWS) && defined (IPV6_TCLASS)
185 186 187 188 189 190 191
    rc = setsockopt(
        s_,
        IPPROTO_IPV6,
        IPV6_TCLASS,
        reinterpret_cast<const char*>(&iptos),
        sizeof(iptos));

192 193
    //  If IPv6 is not enabled ENOPROTOOPT will be returned on Linux and
    //  EINVAL on OSX
194 195 196 197
    if (rc == -1) {
        errno_assert (errno == ENOPROTOOPT ||
                      errno == EINVAL);
    }
198 199
#endif
}
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219

int zmq::set_nosigpipe (fd_t s_)
{
#ifdef SO_NOSIGPIPE
    //  Make sure that SIGPIPE signal is not generated when writing to a
    //  connection that was already closed by the peer.
    //  As per POSIX spec, EINVAL will be returned if the socket was valid but
    //  the connection has been reset by the peer. Return an error so that the
    //  socket can be closed and the connection retried if necessary.
    int set = 1;
    int rc = setsockopt (s_, SOL_SOCKET, SO_NOSIGPIPE, &set, sizeof (int));
    if (rc != 0 && errno == EINVAL)
        return -1;
    errno_assert (rc == 0);
#else
    LIBZMQ_UNUSED (s_);
#endif

    return 0;
}