lib/roken/socket.c

   1 /*
   2  * Copyright (c) 1999 - 2000 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include <config.h>
  35
  36 #include "roken.h"
  37 #include <err.h>
  38
  39 /*
  40  * Set `sa' to the unitialized address of address family `af'
  41  */
  42
  43 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
  44 socket_set_any (struct sockaddr *sa, int af)
  45 {
  46     switch (af) {
  47     case AF_INET : {
  48         struct sockaddr_in *sin4 = (struct sockaddr_in *)sa;
  49
  50         memset (sin4, 0, sizeof(*sin4));
  51         sin4->sin_family = AF_INET;
  52         sin4->sin_port   = 0;
  53         sin4->sin_addr.s_addr = INADDR_ANY;
  54         break;
  55     }
  56 #ifdef HAVE_IPV6
  57     case AF_INET6 : {
  58         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
  59
  60         memset (sin6, 0, sizeof(*sin6));
  61         sin6->sin6_family = AF_INET6;
  62         sin6->sin6_port   = 0;
  63         sin6->sin6_addr   = in6addr_any;
  64         break;
  65     }
  66 #endif
  67     default :
  68         errx (1, "unknown address family %d", sa->sa_family);
  69         break;
  70     }
  71 }
  72
  73 /*
  74  * set `sa' to (`ptr', `port')
  75  */
  76
  77 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
  78 socket_set_address_and_port (struct sockaddr *sa, const void *ptr, int port)
  79 {
  80     switch (sa->sa_family) {
  81     case AF_INET : {
  82         struct sockaddr_in *sin4 = (struct sockaddr_in *)sa;
  83
  84         memset (sin4, 0, sizeof(*sin4));
  85         sin4->sin_family = AF_INET;
  86         sin4->sin_port   = port;
  87         memcpy (&sin4->sin_addr, ptr, sizeof(struct in_addr));
  88         break;
  89     }
  90 #ifdef HAVE_IPV6
  91     case AF_INET6 : {
  92         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
  93
  94         memset (sin6, 0, sizeof(*sin6));
  95         sin6->sin6_family = AF_INET6;
  96         sin6->sin6_port   = port;
  97         memcpy (&sin6->sin6_addr, ptr, sizeof(struct in6_addr));
  98         break;
  99     }
 100 #endif
 101     default :
 102         errx (1, "unknown address family %d", sa->sa_family);
 103         break;
 104     }
 105 }
 106
 107 /*
 108  * Return the size of an address of the type in `sa'
 109  */
 110
 111 ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
 112 socket_addr_size (const struct sockaddr *sa)
 113 {
 114     switch (sa->sa_family) {
 115     case AF_INET :
 116         return sizeof(struct in_addr);
 117 #ifdef HAVE_IPV6
 118     case AF_INET6 :
 119         return sizeof(struct in6_addr);
 120 #endif
 121     default :
 122         return 0;
 123     }
 124 }
 125
 126 /*
 127  * Return the size of a `struct sockaddr' in `sa'.
 128  */
 129
 130 ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
 131 socket_sockaddr_size (const struct sockaddr *sa)
 132 {
 133     switch (sa->sa_family) {
 134     case AF_INET :
 135         return sizeof(struct sockaddr_in);
 136 #ifdef HAVE_IPV6
 137     case AF_INET6 :
 138         return sizeof(struct sockaddr_in6);
 139 #endif
 140     default:
 141         return 0;
 142     }
 143 }
 144
 145 /*
 146  * Return the binary address of `sa'.
 147  */
 148
 149 ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL
 150 socket_get_address (const struct sockaddr *sa)
 151 {
 152     switch (sa->sa_family) {
 153     case AF_INET : {
 154         const struct sockaddr_in *sin4 = (const struct sockaddr_in *)sa;
 155         return rk_UNCONST(&sin4->sin_addr);
 156     }
 157 #ifdef HAVE_IPV6
 158     case AF_INET6 : {
 159         const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa;
 160         return rk_UNCONST(&sin6->sin6_addr);
 161     }
 162 #endif
 163     default:
 164         return NULL;
 165     }
 166 }
 167
 168 /*
 169  * Return the port number from `sa'.
 170  */
 171
 172 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
 173 socket_get_port (const struct sockaddr *sa)
 174 {
 175     switch (sa->sa_family) {
 176     case AF_INET : {
 177         const struct sockaddr_in *sin4 = (const struct sockaddr_in *)sa;
 178         return sin4->sin_port;
 179     }
 180 #ifdef HAVE_IPV6
 181     case AF_INET6 : {
 182         const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa;
 183         return sin6->sin6_port;
 184     }
 185 #endif
 186     default :
 187         return 0;
 188     }
 189 }
 190
 191 /*
 192  * Set the port in `sa' to `port'.
 193  */
 194
 195 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
 196 socket_set_port (struct sockaddr *sa, int port)
 197 {
 198     switch (sa->sa_family) {
 199     case AF_INET : {
 200         struct sockaddr_in *sin4 = (struct sockaddr_in *)sa;
 201         sin4->sin_port = port;
 202         break;
 203     }
 204 #ifdef HAVE_IPV6
 205     case AF_INET6 : {
 206         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
 207         sin6->sin6_port = port;
 208         break;
 209     }
 210 #endif
 211     default :
 212         errx (1, "unknown address family %d", sa->sa_family);
 213         break;
 214     }
 215 }
 216
 217 /*
 218  * Set the range of ports to use when binding with port = 0.
 219  */
 220 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
 221 socket_set_portrange (rk_socket_t sock, int restr, int af)
 222 {
 223 #if defined(IP_PORTRANGE)
 224     if (af == AF_INET) {
 225         int on = restr ? IP_PORTRANGE_HIGH : IP_PORTRANGE_DEFAULT;
 226         (void) setsockopt(sock, IPPROTO_IP, IP_PORTRANGE, &on, sizeof(on));
 227     }
 228 #endif
 229 #if defined(IPV6_PORTRANGE)
 230     if (af == AF_INET6) {
 231         int on = restr ? IPV6_PORTRANGE_HIGH : IPV6_PORTRANGE_DEFAULT;
 232         (void) setsockopt(sock, IPPROTO_IPV6, IPV6_PORTRANGE, &on, sizeof(on));
 233     }
 234 #endif
 235 }
 236
 237 /*
 238  * Enable debug on `sock'.
 239  */
 240
 241 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
 242 socket_set_debug (rk_socket_t sock)
 243 {
 244 #if defined(SO_DEBUG) && defined(HAVE_SETSOCKOPT)
 245     int on = 1;
 246     (void) setsockopt(sock, SOL_SOCKET, SO_DEBUG, (void *) &on, sizeof (on));
 247 #endif
 248 }
 249
 250 /*
 251  * Set the type-of-service of `sock' to `tos'.
 252  */
 253
 254 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
 255 socket_set_tos (rk_socket_t sock, int tos)
 256 {
 257 #if defined(IP_TOS) && defined(HAVE_SETSOCKOPT)
 258     (void) setsockopt (sock, IPPROTO_IP, IP_TOS, (void *) &tos, sizeof(int));
 259 #endif
 260 }
 261
 262 /*
 263  * Set the non-blocking-ness of the socket.
 264  */
 265
 266 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
 267 socket_set_nonblocking(rk_socket_t sock, int nonblock)
 268 {
 269 #if defined(O_NONBLOCK)
 270     int flags = fcntl(sock, F_GETFL, 0);
 271     if (flags == -1)
 272         return;
 273     if (nonblock)
 274         flags |= O_NONBLOCK;
 275     else
 276         flags &= ~O_NONBLOCK;
 277     (void) fcntl(sock, F_SETFL, flags);
 278 #elif defined(FIOBIO)
 279     int flags = !!nonblock;
 280
 281     (void) ioctl(sock, FIOBIO, &flags);
 282 #endif
 283 }
 284
 285 /*
 286  * set the reuse of addresses on `sock' to `val'.
 287  */
 288
 289 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
 290 socket_set_reuseaddr (rk_socket_t sock, int val)
 291 {
 292 #if defined(SO_REUSEADDR) && defined(HAVE_SETSOCKOPT)
 293     (void) setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&val,
 294                       sizeof(val));
 295 #endif
 296 }
 297
 298 /*
 299  * Set the that the `sock' should bind to only IPv6 addresses.
 300  */
 301
 302 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
 303 socket_set_ipv6only (rk_socket_t sock, int val)
 304 {
 305 #if defined(IPV6_V6ONLY) && defined(HAVE_SETSOCKOPT)
 306     (void) setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&val,
 307                       sizeof(val));
 308 #endif
 309 }
 310
 311 /*
 312  * Set the that the `sock' keepalive setting.
 313  */
 314
 315 ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
 316 socket_set_keepalive(rk_socket_t sock, int val)
 317 {
 318     (void) setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&val,
 319                       sizeof(val));
 320 }
 321
 322 /**
 323  * Create a file descriptor from a socket
 324  *
 325  * While the socket handle in \a sock can be used with WinSock
 326  * functions after calling socket_to_fd(), it should not be closed
 327  * with rk_closesocket().  The socket will be closed when the associated
 328  * file descriptor is closed.
 329  */
 330 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
 331 socket_to_fd(rk_socket_t sock, int flags)
 332 {
 333 #ifndef _WIN32
 334     return sock;
 335 #else
 336     return _open_osfhandle((intptr_t) sock, flags);
 337 #endif
 338 }
 339
 340 #ifdef HAVE_WINSOCK
 341 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
 342 rk_SOCK_IOCTL(SOCKET s, long cmd, int * argp) {
 343     u_long ul = (argp)? *argp : 0;
 344     int rv;
 345
 346     rv = ioctlsocket(s, cmd, &ul);
 347     if (argp)
 348         *argp = (int) ul;
 349     return rv;
 350 }
 351 #endif
 352
 353 #ifndef HEIMDAL_SMALLER
 354 #undef socket
 355
 356 int rk_socket(int, int, int);
 357
 358 int
 359 rk_socket(int domain, int type, int protocol)
 360 {
 361     int s;
 362     s = socket (domain, type, protocol);
 363 #ifdef SOCK_CLOEXEC
 364     if ((SOCK_CLOEXEC & type) && s < 0 && errno == EINVAL) {
 365         type &= ~SOCK_CLOEXEC;
 366         s = socket (domain, type, protocol);
 367     }
 368 #endif
 369     return s;
 370 }
 371
 372 #endif /* HEIMDAL_SMALLER */