libjaylink/socket.c

   1 /*
   2  * This file is part of the libjaylink project.
   3  *
   4  * Copyright (C) 2016-2017 Marc Schink <jaylink-dev@marcschink.de>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <errno.h>
  21 #ifdef _WIN32
  22 #include <winsock2.h>
  23 #else
  24 #include <sys/types.h>
  25 #include <sys/socket.h>
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #endif
  29
  30 #include "libjaylink.h"
  31 #include "libjaylink-internal.h"
  32
  33 /**
  34  * @file
  35  *
  36  * Socket abstraction layer.
  37  */
  38
  39 /**
  40  * Initiate a connection on a socket.
  41  *
  42  * @param[in] sock Socket descriptor.
  43  * @param[in] address Address to establish the connection.
  44  * @param[in] length Length of the structure pointed to by @p address in bytes.
  45  * @param[in] timeout Connection timeout in milliseconds, 0 for no timeout.
  46  *
  47  * @retval JAYLINK_OK Success.
  48  * @retval JAYLINK_ERR_ARG Invalid arguments.
  49  * @retval JAYLINK_ERR_TIMEOUT A timeout occurred.
  50  * @retval JAYLINK_ERR Other error conditions.
  51  */
  52 JAYLINK_PRIV int socket_connect(int sock, const struct sockaddr *address,
  53                 size_t address_length, size_t timeout)
  54 {
  55         int ret;
  56         fd_set fds;
  57         struct timeval tv;
  58         int socket_error;
  59         size_t option_length;
  60
  61         if (!address)
  62                 return JAYLINK_ERR_ARG;
  63
  64         if (!socket_set_blocking(sock, false))
  65                 return JAYLINK_ERR;
  66 #ifdef _WIN32
  67         ret = connect(sock, address, address_length);
  68
  69         if (ret != 0 && WSAGetLastError() != WSAEWOULDBLOCK)
  70                 return JAYLINK_ERR;
  71 #else
  72         errno = 0;
  73         ret = connect(sock, address, address_length);
  74
  75         if (ret != 0 && errno != EINPROGRESS)
  76                 return JAYLINK_ERR;
  77 #endif
  78         if (!ret)
  79                 return JAYLINK_OK;
  80
  81         FD_ZERO(&fds);
  82         FD_SET(sock, &fds);
  83
  84         tv.tv_sec = timeout / 1000;
  85         tv.tv_usec = (timeout % 1000) * 1000;
  86
  87         ret = select(sock + 1, NULL, &fds, NULL, &tv);
  88
  89         socket_set_blocking(sock, true);
  90
  91         if (!ret)
  92                 return JAYLINK_ERR_TIMEOUT;
  93
  94         option_length = sizeof(socket_error);
  95
  96         if (!socket_get_option(sock, SOL_SOCKET, SO_ERROR, &socket_error,
  97                         &option_length))
  98                 return JAYLINK_ERR;
  99
 100         if (!socket_error)
 101                 return JAYLINK_OK;
 102
 103         return JAYLINK_ERR;
 104 }
 105
 106 /**
 107  * Close a socket.
 108  *
 109  * @param[in] sock Socket descriptor.
 110  *
 111  * @return Whether the socket was successfully closed.
 112  */
 113 JAYLINK_PRIV bool socket_close(int sock)
 114 {
 115         int ret;
 116
 117 #ifdef _WIN32
 118         ret = closesocket(sock);
 119 #else
 120         ret = close(sock);
 121 #endif
 122
 123         if (!ret)
 124                 return true;
 125
 126         return false;
 127 }
 128
 129 /**
 130  * Bind an address to a socket.
 131  *
 132  * @param[in] sock Socket descriptor.
 133  * @param[in] address Address to be bound to the socket.
 134  * @param[in] length Length of the structure pointed to by @p address in bytes.
 135  *
 136  * @return Whether the address was successfully assigned to the socket.
 137  */
 138 JAYLINK_PRIV bool socket_bind(int sock, const struct sockaddr *address,
 139                 size_t length)
 140 {
 141         int ret;
 142
 143         ret = bind(sock, address, length);
 144
 145 #ifdef _WIN32
 146         if (ret == SOCKET_ERROR)
 147                 return false;
 148 #else
 149         if (ret < 0)
 150                 return false;
 151 #endif
 152
 153         return true;
 154 }
 155
 156 /**
 157  * Send a message on a socket.
 158  *
 159  * @param[in] sock Socket descriptor.
 160  * @param[in] buffer Buffer of the message to be sent.
 161  * @param[in,out] length Length of the message in bytes. On success, the value
 162  *                       gets updated with the actual number of bytes sent. The
 163  *                       value is undefined on failure.
 164  * @param[in] flags Flags to modify the function behaviour. Use bitwise OR to
 165  *                  specify multiple flags.
 166  *
 167  * @return Whether the message was sent successfully.
 168  */
 169 JAYLINK_PRIV bool socket_send(int sock, const void *buffer, size_t *length,
 170                 int flags)
 171 {
 172         ssize_t ret;
 173
 174         ret = send(sock, buffer, *length, flags);
 175 #ifdef _WIN32
 176         if (ret == SOCKET_ERROR)
 177                 return false;
 178 #else
 179         if (ret < 0)
 180                 return false;
 181 #endif
 182         *length = ret;
 183
 184         return true;
 185 }
 186
 187 /**
 188  * Receive a message from a socket.
 189  *
 190  * @param[in] sock Socket descriptor.
 191  * @param[out] buffer Buffer to store the received message on success. Its
 192  *                    content is undefined on failure.
 193  * @param[in,out] length Maximum length of the message in bytes. On success,
 194  *                       the value gets updated with the actual number of
 195  *                       received bytes. The value is undefined on failure.
 196  * @param[in] flags Flags to modify the function behaviour. Use bitwise OR to
 197  *                  specify multiple flags.
 198  *
 199  * @return Whether a message was successfully received.
 200  */
 201 JAYLINK_PRIV bool socket_recv(int sock, void *buffer, size_t *length,
 202                 int flags)
 203 {
 204         ssize_t ret;
 205
 206         ret = recv(sock, buffer, *length, flags);
 207
 208 #ifdef _WIN32
 209         if (ret == SOCKET_ERROR)
 210                 return false;
 211 #else
 212         if (ret < 0)
 213                 return false;
 214 #endif
 215
 216         *length = ret;
 217
 218         return true;
 219 }
 220
 221 /**
 222  * Send a message on a socket.
 223  *
 224  * @param[in] sock Socket descriptor.
 225  * @param[in] buffer Buffer to send message from.
 226  * @param[in,out] length Number of bytes to send. On success, the value gets
 227  *                       updated with the actual number of bytes sent. The
 228  *                       value is undefined on failure.
 229  * @param[in] flags Flags to modify the function behaviour. Use bitwise OR to
 230  *                  specify multiple flags.
 231  * @param[in] address Destination address of the message.
 232  * @param[in] address_length Length of the structure pointed to by @p address
 233  *                           in bytes.
 234  *
 235  * @return Whether the message was successfully sent.
 236  */
 237 JAYLINK_PRIV bool socket_sendto(int sock, const void *buffer, size_t *length,
 238                 int flags, const struct sockaddr *address,
 239                 size_t address_length)
 240 {
 241         ssize_t ret;
 242
 243         ret = sendto(sock, buffer, *length, flags, address, address_length);
 244
 245 #ifdef _WIN32
 246         if (ret == SOCKET_ERROR)
 247                 return false;
 248 #else
 249         if (ret < 0)
 250                 return false;
 251 #endif
 252
 253         *length = ret;
 254
 255         return true;
 256 }
 257
 258 /**
 259  * Receive a message from a socket.
 260  *
 261  * @param[in] sock Socket descriptor.
 262  * @param[out] buffer Buffer to store the received message on success. Its
 263  *                    content is undefined on failure.
 264  * @param[in,out] length Maximum length of the message in bytes. On success,
 265  *                       the value gets updated with the actual number of
 266  *                       received bytes. The value is undefined on failure.
 267  * @param[in] flags Flags to modify the function behaviour. Use bitwise OR to
 268  *                  specify multiple flags.
 269  * @param[out] address Structure to store the source address of the message on
 270  *                     success. Its content is undefined on failure.
 271  *                     Can be NULL.
 272  * @param[in,out] address_length Length of the structure pointed to by
 273  *                               @p address in bytes. On success, the value
 274  *                               gets updated with the actual length of the
 275  *                               structure. The value is undefined on failure.
 276  *                               Should be NULL if @p address is NULL.
 277  *
 278  * @return Whether a message was successfully received.
 279  */
 280 JAYLINK_PRIV bool socket_recvfrom(int sock, void *buffer, size_t *length,
 281                 int flags, struct sockaddr *address, size_t *address_length)
 282 {
 283         ssize_t ret;
 284 #ifdef _WIN32
 285         int tmp;
 286
 287         tmp = *address_length;
 288         ret = recvfrom(sock, buffer, *length, flags, address, &tmp);
 289
 290         if (ret == SOCKET_ERROR)
 291                 return false;
 292 #else
 293         socklen_t tmp;
 294
 295         tmp = *address_length;
 296         ret = recvfrom(sock, buffer, *length, flags, address, &tmp);
 297
 298         if (ret < 0)
 299                 return false;
 300 #endif
 301
 302         *address_length = tmp;
 303         *length = ret;
 304
 305         return true;
 306 }
 307
 308 /**
 309  * Get the value of a socket option.
 310  *
 311  * @param[in] sock Socket descriptor.
 312  * @param[in] level Level at which the option is defined.
 313  * @param[in] option Option to get the value for.
 314  * @param[in] value Buffer to store the value.
 315  * @param[in] length Length of the value buffer in bytes.
 316  *
 317  * @return Whether the option value was retrieved successfully.
 318  */
 319 JAYLINK_PRIV bool socket_get_option(int sock, int level, int option,
 320                 void *value, size_t *length)
 321 {
 322         if (!getsockopt(sock, level, option, value, (socklen_t *)length))
 323                 return true;
 324
 325         return false;
 326 }
 327
 328 /**
 329  * Set the value of a socket option.
 330  *
 331  * @param[in] sock Socket descriptor.
 332  * @param[in] level Level at which the option is defined.
 333  * @param[in] option Option to set the value for.
 334  * @param[in] value Buffer of the value to be set.
 335  * @param[in] length Length of the value buffer in bytes.
 336  *
 337  * @return Whether the option value was set successfully.
 338  */
 339 JAYLINK_PRIV bool socket_set_option(int sock, int level, int option,
 340                 const void *value, size_t length)
 341 {
 342         if (!setsockopt(sock, level, option, value, length))
 343                 return true;
 344
 345         return false;
 346 }
 347
 348 /**
 349  * Set the blocking mode of a socket.
 350  *
 351  * @param[in] sock Socket descriptor.
 352  * @param[in] blocking Blocking mode.
 353  *
 354  * @return Whether the blocking mode was set successfully.
 355  */
 356 JAYLINK_PRIV bool socket_set_blocking(int sock, bool blocking)
 357 {
 358         int ret;
 359 #ifdef _WIN32
 360         u_long mode;
 361
 362         mode = !blocking;
 363         ret = ioctlsocket(sock, FIONBIO, &mode);
 364
 365         if (ret != NO_ERROR)
 366                 return false;
 367 #else
 368         int flags;
 369
 370         flags = fcntl(sock, F_GETFL, 0);
 371
 372         if (flags < 0)
 373                 return false;
 374
 375         if (blocking)
 376                 flags &= ~O_NONBLOCK;
 377         else
 378                 flags |= O_NONBLOCK;
 379
 380         ret = fcntl(sock, F_SETFL, flags);
 381
 382         if (ret != 0)
 383                 return false;
 384 #endif
 385         return true;
 386 }