GCC Code Coverage Report

Directory: src/gate/
File: src/gate/net/sockets.c
Date: 2025-09-14 13:10:38
Exec Total Coverage
Lines: 485 656 73.9%
Functions: 37 40 92.5%
Branches: 151 288 52.4%
Line Branch Exec Source
1 /* GATE PROJECT LICENSE:
2 +----------------------------------------------------------------------------+
3 | Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at> |
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 are met:|
8 | |
9 | 1. Redistributions of source code must retain the above copyright notice, |
10 | this list of conditions and the following disclaimer. |
11 | 2. Redistributions in binary form must reproduce the above copyright |
12 | notice, this list of conditions and the following disclaimer in the |
13 | documentation and/or other materials provided with the distribution. |
14 | |
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
16 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
17 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
18 | ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
19 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
20 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
21 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
22 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
23 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
24 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
25 | THE POSSIBILITY OF SUCH DAMAGE. |
26 +----------------------------------------------------------------------------+
27 */
28
29 #include "gate/net/sockets.h"
30 #include "gate/results.h"
31 #include "gate/debugging.h"
32
33 #if defined(GATE_SYS_EFI)
34 # define GATE_NET_SOCKETS_EFI 1
35 #elif defined(GATE_SYS_WIN) || defined(GATE_SYS_POSIX)
36 # define GATE_NET_SOCKETS_BSDIMPL 1
37 #else
38 # define GATE_NET_SOCKETS_NOIMPL 1
39 #endif
40
41
42 /* GENERIC Implementations: */
43
44 25 int gate_compare_socket(void const* item1, void const* item2)
45 {
46 25 gate_socket_t const* sock1 = (gate_socket_t const*)item1;
47 25 gate_socket_t const* sock2 = (gate_socket_t const*)item2;
48
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 13 times.
 25 if (*sock1 == *sock2)
49 {
50 12 return 0;
51 }
52
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
 13 else if (*sock1 < *sock2)
53 {
54 ✗ return -1;
55 }
56 else
57 {
58 13 return +1;
59 }
60 }
61
62
63
64
65 #if defined(GATE_NET_SOCKETS_BSDIMPL)
66
67 #include "gate/net/platform/socket_api.h"
68
69 static gate_net_platform_socket_api_t api;
70
71 #if defined(GATE_SYS_WIN)
72
73 #if defined(GATE_WIN32_ANSI)
74 # define GATE_NET_SOCKET_NO_IPV6 1
75 # define GATE_NET_SOCKET_NO_UNIX 1
76 #else
77 # if !defined(GATE_COMPILER_MSVC2017)
78 # define GATE_NET_SOCKET_NO_UNIX 1
79 # endif
80 #endif
81
82 # if !defined(GATE_NET_SOCKET_NO_UNIX)
83 # include <afunix.h>
84 # endif
85
86
87 # ifndef SD_RECEIVE
88 # define SD_RECEIVE 0x00
89 # endif
90 # ifndef SD_SEND
91 # define SD_SEND 0x01
92 # endif
93 # ifndef SD_BOTH
94 # define SD_BOTH 0x02
95 # endif
96
97
98 static gate_result_t gate_socket_set_blocking(gate_socket_t sock, gate_bool_t blocking)
99 {
100 gate_result_t ret;
101 sock_fd_t s = (sock_fd_t)sock;
102 u_long ctl = blocking ? 0 : 1;
103 if (-1 == api.sock_ioctl(s, FIONBIO, &ctl))
104 {
105 ret = GATE_RESULT_FAILED;
106 }
107 else
108 {
109 ret = GATE_RESULT_OK;
110 }
111 return ret;
112 }
113
114 gate_bool_t gate_socket_ipv6_support();
115
116
117 #endif /* defined(GATE_SYS_WIN) */
118
119 #if defined(GATE_SYS_POSIX)
120
121 # define GATE_NET_SOCKET_NO_UNIX
122
123 typedef struct timeval TIMEVAL;
124
125 # define SOCKET_ERROR_WOULDBLOCK ((int)EINPROGRESS)
126 # if !defined(INVALID_SOCKET)
127 # define INVALID_SOCKET ((int)-1)
128 # endif
129 # if !defined(SOCKET_ERROR)
130 # define SOCKET_ERROR (-1)
131 # endif
132 # if !defined(SD_RECEIVE)
133 # define SD_RECEIVE SHUT_RD
134 # endif
135 # if !defined(SD_SEND)
136 # define SD_SEND SHUT_WR
137 # endif
138 # if !defined(SD_BOTH)
139 # define SD_BOTH SHUT_RDWR
140 # endif
141
142 5 static gate_result_t gate_socket_set_blocking(gate_socket_t sock, gate_bool_t blocking)
143 {
144 gate_result_t ret;
145 5 sock_fd_t s = (sock_fd_t)sock;
146 5 long flags = fcntl(s, F_GETFL, NULL);
147
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 if (-1 == flags)
148 {
149 ✗ ret = GATE_RESULT_FAILED;
150 }
151 else
152 {
153
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
 5 if (blocking)
154 {
155 3 flags &= ~(long)O_NONBLOCK;
156 }
157 else
158 {
159 2 flags |= O_NONBLOCK;
160 }
161
162
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
 5 if (-1 == fcntl(s, F_SETFL, flags))
163 {
164 ✗ ret = GATE_RESULT_FAILED;
165 }
166 else
167 {
168 5 ret = GATE_RESULT_OK;
169 }
170 }
171 5 return ret;
172 }
173 ✗ static int gate_socket_last_error()
174 {
175 ✗ return errno;
176 }
177
178 #endif /*defined(GATE_SYS_POSIX)*/
179
180
181 typedef union gate_socket_addr_storage
182 {
183 struct sockaddr addr;
184 struct sockaddr_in addr4;
185 #if !defined(GATE_NET_SOCKET_NO_IPV6)
186 struct sockaddr_in6 addr6;
187 #endif
188 #if !defined(GATE_NET_SOCKET_NO_UNIX)
189 struct sockaddr_un unix;
190 #endif
191 } gate_socket_addr_storage_t;
192
193 static gate_atomic_int_t sockets_created = 0;
194 static gate_atomic_int_t sockets_released = 0;
195
196 21 gate_result_t gate_socket_init()
197 {
198 21 gate_result_t ret = gate_socket_api_load(&api);
199 21 return ret;
200 }
201
202 2 gate_bool_t gate_socket_support(gate_int16_t family)
203 {
204
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 2 switch (family)
205 {
206
207 #if !defined(GATE_NET_SOCKET_NO_UNIX)
208 case GATE_SOCKET_FAMILY_UNIX: return true;
209 #endif
210
211 ✗ case GATE_SOCKET_FAMILY_INET4: return true;
212
213 #if !defined(GATE_NET_SOCKET_NO_IPV6)
214 2 case GATE_SOCKET_FAMILY_INET6: return true;
215 #endif
216 }
217 ✗ return false;
218 }
219
220
221 6 gate_result_t gate_socket_create(gate_int16_t type, gate_socket_t* sock)
222 {
223 gate_result_t ret;
224
4/7
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
 6 switch (type)
225 {
226 3 case GATE_SOCKET_TYPE_TCP4:
227 {
228 3 ret = gate_socket_create_ex(GATE_SOCKET_FAMILY_INET4, GATE_SOCKET_MSGTYPE_STREAM, GATE_SOCKET_PROTOCOL_TCP, sock);
229 3 break;
230 }
231 1 case GATE_SOCKET_TYPE_UDP4:
232 {
233 1 ret = gate_socket_create_ex(GATE_SOCKET_FAMILY_INET4, GATE_SOCKET_MSGTYPE_DATAGRAM, GATE_SOCKET_PROTOCOL_UDP, sock);
234 1 break;
235 }
236 ✗ case GATE_SOCKET_TYPE_ICMP4:
237 {
238 ✗ ret = gate_socket_create_ex(GATE_SOCKET_FAMILY_INET4, GATE_SOCKET_MSGTYPE_RAW, GATE_SOCKET_PROTOCOL_ICMP, sock);
239 ✗ break;
240 }
241 1 case GATE_SOCKET_TYPE_TCP6:
242 {
243 1 ret = gate_socket_create_ex(GATE_SOCKET_FAMILY_INET6, GATE_SOCKET_MSGTYPE_STREAM, GATE_SOCKET_PROTOCOL_TCP, sock);
244 1 break;
245 }
246 1 case GATE_SOCKET_TYPE_UDP6:
247 {
248 1 ret = gate_socket_create_ex(GATE_SOCKET_FAMILY_INET6, GATE_SOCKET_MSGTYPE_DATAGRAM, GATE_SOCKET_PROTOCOL_UDP, sock);
249 1 break;
250 }
251 ✗ case GATE_SOCKET_TYPE_ICMP6:
252 {
253 ✗ ret = gate_socket_create_ex(GATE_SOCKET_FAMILY_INET6, GATE_SOCKET_MSGTYPE_RAW, GATE_SOCKET_PROTOCOL_ICMP6, sock);
254 ✗ break;
255 }
256 ✗ default:
257 {
258 ✗ ret = GATE_RESULT_NOTSUPPORTED;
259 }
260 }
261 6 return ret;
262 }
263
264 #ifndef AF_BTH
265 # define AF_BTH 32
266 #endif
267
268 14 gate_result_t gate_socket_create_ex(gate_int16_t family, gate_int16_t msgtype, gate_int16_t protocol, gate_socket_t* sock)
269 {
270 int af;
271 int type;
272 int proto;
273 int tmp;
274 14 sock_fd_t s = INVALID_SOCKET;
275 gate_result_t ret;
276
277 14 ret = gate_socket_init();
278
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
 14 if (GATE_FAILED(ret))
279 {
280 ✗ return ret;
281 }
282 14 ret = gate_socket_session_init();
283
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
 14 if (GATE_FAILED(ret))
284 {
285 ✗ return ret;
286 }
287
288
289 do
290 {
291
2/8
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 14 switch (family)
292 {
293 ✗ case GATE_SOCKET_FAMILY_UNIX: af = AF_UNIX; break;
294 10 case GATE_SOCKET_FAMILY_INET4: af = AF_INET; break;
295 ✗ case GATE_SOCKET_FAMILY_IPX: af = AF_IPX; break;
296 ✗ case GATE_SOCKET_FAMILY_APPLETALK: af = AF_APPLETALK; break;
297 #if defined(AF_NETBIOS)
298 case GATE_SOCKET_FAMILY_NETBIOS: af = AF_NETBIOS; break;
299 #endif
300 #if defined(AF_ATM)
301 case GATE_SOCKET_FAMILY_ATM: af = AF_ATM; break;
302 #endif
303 #if defined(AF_INET6)
304 4 case GATE_SOCKET_FAMILY_INET6: af = AF_INET6; break;
305 #endif
306 #if defined(AF_IRDA)
307 ✗ case GATE_SOCKET_FAMILY_IRDA: af = AF_IRDA; break;
308 #endif
309 ✗ case GATE_SOCKET_FAMILY_BTH: af = AF_BTH; break;
310 ✗ default: af = -1; break;
311 }
312
313
2/4
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 14 switch (msgtype)
314 {
315 10 case GATE_SOCKET_MSGTYPE_STREAM: type = SOCK_STREAM; break;
316 4 case GATE_SOCKET_MSGTYPE_DATAGRAM: type = SOCK_DGRAM; break;
317 ✗ case GATE_SOCKET_MSGTYPE_RAW: type = SOCK_RAW; break;
318 ✗ default: type = -1; break;
319 }
320
321
3/8
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 14 switch (protocol)
322 {
323 1 case GATE_SOCKET_PROTOCOL_IP: proto = IPPROTO_IP; break;
324 ✗ case GATE_SOCKET_PROTOCOL_ICMP: proto = IPPROTO_ICMP; break;
325 #if defined(IPPROTO_IGMP)
326 ✗ case GATE_SOCKET_PROTOCOL_IGMP: proto = IPPROTO_IGMP; break;
327 #endif
328 9 case GATE_SOCKET_PROTOCOL_TCP: proto = IPPROTO_TCP; break;
329 4 case GATE_SOCKET_PROTOCOL_UDP: proto = IPPROTO_UDP; break;
330 #if defined(IPPROTO_IPV6)
331 ✗ case GATE_SOCKET_PROTOCOL_IP6: proto = IPPROTO_IPV6; break;
332 #endif
333 ✗ case GATE_SOCKET_PROTOCOL_ICMP6: proto = IPPROTO_ICMP; break;
334 ✗ default: proto = -1; break;
335 }
336
337
3/6
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 14 times.
 14 if ((af == -1) || (type == -1) || (proto == -1))
338 {
339 ✗ ret = GATE_RESULT_NOTSUPPORTED;
340 ✗ break;
341 }
342
343 14 s = api.sock_socket(af, type, proto);
344
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
 14 if (s == INVALID_SOCKET)
345 {
346 ✗ GATE_DEBUG_TRACE("socket() failed");
347 ✗ gate_socket_session_uninit();
348 ✗ ret = GATE_RESULT_NOTSUPPORTED;
349 }
350 else
351 {
352 14 *sock = (gate_socket_t)s;
353
354 #if defined(GATE_SYS_WIN) && !defined(GATE_SYS_WINCE) && !defined(GATE_SYS_WINSTORE) && !defined(GATE_SYS_WIN16)
355 /* disable socket inheritage to child processes */
356 SetHandleInformation((HANDLE)s, HANDLE_FLAG_INHERIT, 0);
357 #endif
358
359 #if defined(SO_EXCLUSIVEADDRUSE)
360 /* Windows: disable SO_REUSEADDR on this socket */
361 tmp = 1;
362 api.sock_setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&tmp, sizeof(tmp));
363 #endif
364
365 #if defined(IPV6_V6ONLY) && defined(IPPROTO_IPV6)
366
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 10 times.
 14 if (family == GATE_SOCKET_FAMILY_INET6)
367 {
368 /* disable automatic binding to IPv4 address, if IPv6 was specified */
369 4 tmp = 1;
370 4 api.sock_setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&tmp, sizeof(tmp));
371 }
372 #endif
373 }
374
375 } while (0);
376
377 #if defined(GATE_DEBUG_MODE)
378
1/2
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
 14 if (GATE_SUCCEEDED(ret))
379 {
380 14 gate_int32_t sockets_created_counter = gate_atomic_int_inc(&sockets_created);
381 14 GATE_DEBUG_TRACE_VALUE(sockets_created_counter);
382 }
383 #endif
384 14 return ret;
385 }
386
387 10 static gate_size_t gate_socket_build_addr_ip4(gate_socket_ip4endpoint_t const* src, struct sockaddr_in* dst)
388 {
389 20 gate_uint32_t ip = ((gate_uint32_t)(src->address.item[0]) << 24)
390 10 | ((gate_uint32_t)(src->address.item[1]) << 16)
391 10 | ((gate_uint32_t)(src->address.item[2]) << 8)
392 10 | ((gate_uint32_t)(src->address.item[3]))
393 ;
394 10 gate_mem_clear(dst, sizeof(struct sockaddr_in));
395 10 dst->sin_family = AF_INET;
396 10 dst->sin_port = api.sock_htons(src->port);
397 10 dst->sin_addr.s_addr = api.sock_htonl(ip);
398 10 return sizeof(struct sockaddr_in);
399 }
400
401 9 static void gate_socket_build_ip4address(struct sockaddr_in const* src, gate_socket_ip4endpoint_t* dst)
402 {
403 9 gate_uint32_t ip = api.sock_ntohl(src->sin_addr.s_addr);
404 9 dst->family = GATE_SOCKET_FAMILY_INET4;
405 9 dst->port = api.sock_ntohs(src->sin_port);
406 9 dst->address.item[0] = (gate_uint8_t)((ip >> 24) & 0x0ff);
407 9 dst->address.item[1] = (gate_uint8_t)((ip >> 16) & 0x0ff);
408 9 dst->address.item[2] = (gate_uint8_t)((ip >> 8) & 0x0ff);
409 9 dst->address.item[3] = (gate_uint8_t)((ip) & 0x0ff);
410 9 }
411
412 #if !defined(GATE_NET_SOCKET_NO_IPV6)
413 5 static gate_size_t gate_socket_build_addr_ip6(gate_socket_ip6endpoint_t const* src, struct sockaddr_in6* dst)
414 {
415 5 gate_mem_clear(dst, sizeof(struct sockaddr_in6));
416 5 dst->sin6_family = AF_INET6;
417 5 dst->sin6_port = api.sock_htons(src->port);
418 #if !defined(GATE_COMPILER_MSVC98)
419 5 dst->sin6_scope_id = src->scope;
420 #endif
421 5 dst->sin6_flowinfo = 0;
422 5 dst->sin6_addr.s6_addr[0] = (gate_uint8_t)((src->address.item[0] >> 8) & 0x0ff);
423 5 dst->sin6_addr.s6_addr[1] = (gate_uint8_t)((src->address.item[0]) & 0x0ff);
424 5 dst->sin6_addr.s6_addr[2] = (gate_uint8_t)((src->address.item[1] >> 8) & 0x0ff);
425 5 dst->sin6_addr.s6_addr[3] = (gate_uint8_t)((src->address.item[1]) & 0x0ff);
426 5 dst->sin6_addr.s6_addr[4] = (gate_uint8_t)((src->address.item[2] >> 8) & 0x0ff);
427 5 dst->sin6_addr.s6_addr[5] = (gate_uint8_t)((src->address.item[2]) & 0x0ff);
428 5 dst->sin6_addr.s6_addr[6] = (gate_uint8_t)((src->address.item[3] >> 8) & 0x0ff);
429 5 dst->sin6_addr.s6_addr[7] = (gate_uint8_t)((src->address.item[3]) & 0x0ff);
430 5 dst->sin6_addr.s6_addr[8] = (gate_uint8_t)((src->address.item[4] >> 8) & 0x0ff);
431 5 dst->sin6_addr.s6_addr[9] = (gate_uint8_t)((src->address.item[4]) & 0x0ff);
432 5 dst->sin6_addr.s6_addr[10] = (gate_uint8_t)((src->address.item[5] >> 8) & 0x0ff);
433 5 dst->sin6_addr.s6_addr[11] = (gate_uint8_t)((src->address.item[5]) & 0x0ff);
434 5 dst->sin6_addr.s6_addr[12] = (gate_uint8_t)((src->address.item[6] >> 8) & 0x0ff);
435 5 dst->sin6_addr.s6_addr[13] = (gate_uint8_t)((src->address.item[6]) & 0x0ff);
436 5 dst->sin6_addr.s6_addr[14] = (gate_uint8_t)((src->address.item[7] >> 8) & 0x0ff);
437 5 dst->sin6_addr.s6_addr[15] = (gate_uint8_t)((src->address.item[7]) & 0x0ff);
438 5 return sizeof(struct sockaddr_in6);
439 }
440 3 static void gate_socket_build_ip6address(struct sockaddr_in6 const* src, gate_socket_ip6endpoint_t* dst)
441 {
442 3 dst->family = GATE_SOCKET_FAMILY_INET6;
443 3 dst->port = api.sock_ntohs(src->sin6_port);
444 #if !defined(GATE_COMPILER_MSVC98)
445 3 dst->scope = src->sin6_scope_id;
446 #endif
447 3 dst->address.item[0] = (((gate_uint16_t)src->sin6_addr.s6_addr[0]) << 8) | ((gate_uint16_t)src->sin6_addr.s6_addr[1]);
448 3 dst->address.item[1] = (((gate_uint16_t)src->sin6_addr.s6_addr[2]) << 8) | ((gate_uint16_t)src->sin6_addr.s6_addr[3]);
449 3 dst->address.item[2] = (((gate_uint16_t)src->sin6_addr.s6_addr[4]) << 8) | ((gate_uint16_t)src->sin6_addr.s6_addr[5]);
450 3 dst->address.item[3] = (((gate_uint16_t)src->sin6_addr.s6_addr[6]) << 8) | ((gate_uint16_t)src->sin6_addr.s6_addr[7]);
451 3 dst->address.item[4] = (((gate_uint16_t)src->sin6_addr.s6_addr[8]) << 8) | ((gate_uint16_t)src->sin6_addr.s6_addr[9]);
452 3 dst->address.item[5] = (((gate_uint16_t)src->sin6_addr.s6_addr[10]) << 8) | ((gate_uint16_t)src->sin6_addr.s6_addr[11]);
453 3 dst->address.item[6] = (((gate_uint16_t)src->sin6_addr.s6_addr[12]) << 8) | ((gate_uint16_t)src->sin6_addr.s6_addr[13]);
454 3 dst->address.item[7] = (((gate_uint16_t)src->sin6_addr.s6_addr[14]) << 8) | ((gate_uint16_t)src->sin6_addr.s6_addr[15]);
455 3 }
456 #endif
457
458
459 5 gate_result_t gate_socket_connect(gate_socket_t sock, gate_socket_endpoint_t const* ep)
460 {
461 5 gate_result_t ret = GATE_RESULT_FAILED;
462 5 sock_fd_t s = (sock_fd_t)sock;
463 gate_socket_addr_storage_t addr;
464 do
465 {
466
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 if (ep == NULL)
467 {
468 ✗ ret = GATE_RESULT_INVALIDARG;
469 ✗ break;
470 }
471
2/3
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 5 switch (ep->family)
472 {
473 4 case GATE_SOCKET_FAMILY_INET4:
474 {
475 4 const sock_socklen_t addrlen = (sock_socklen_t)gate_socket_build_addr_ip4(&ep->ip4, &addr.addr4);
476
477
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1 times.
 4 if (0 == api.sock_connect(s, (struct sockaddr const*)&addr.addr4, addrlen))
478 {
479 3 ret = GATE_RESULT_OK;
480 }
481 else
482 {
483
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 if (SOCKET_ERROR_WOULDBLOCK == api.sock_errno())
484 {
485 1 ret = GATE_RESULT_OK;
486 }
487 else
488 {
489 ✗ GATE_DEBUG_TRACE("connect() failed");
490 }
491 }
492 4 break;
493 }
494 1 case GATE_SOCKET_FAMILY_INET6:
495 {
496 #if defined(GATE_NET_SOCKET_NO_IPV6)
497 ret = GATE_RESULT_NOTSUPPORTED;
498 #else
499 1 const sock_socklen_t addrlen = (sock_socklen_t)gate_socket_build_addr_ip6(&ep->ip6, &addr.addr6);
500
501
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if (0 == api.sock_connect(s, (struct sockaddr const*)&addr.addr6, addrlen))
502 {
503 ✗ ret = GATE_RESULT_OK;
504 }
505 else
506 {
507
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 if (SOCKET_ERROR_WOULDBLOCK == api.sock_errno())
508 {
509 1 ret = GATE_RESULT_OK;
510 }
511 else
512 {
513 ✗ GATE_DEBUG_TRACE("connect() failed");
514 }
515 }
516 #endif
517 1 break;
518 }
519 ✗ default:
520 {
521 ✗ GATE_DEBUG_TRACE("Unsupported socket family");
522 ✗ ret = GATE_RESULT_NOTSUPPORTED;
523 ✗ break;
524 }
525 }
526
527 } while (0);
528
529 5 return ret;
530 }
531
532 2 gate_result_t gate_socket_connect_address(gate_socket_t sock, gate_string_t const* address)
533 {
534 2 gate_socket_endpoint_t ep = GATE_INIT_EMPTY;
535 2 gate_result_t ret = gate_socket_parse_endpoint(address, &ep);
536
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (GATE_SUCCEEDED(ret))
537 {
538 2 ret = gate_socket_connect(sock, &ep);
539 }
540 2 return ret;
541 }
542
543 8 gate_result_t gate_socket_bind(gate_socket_t sock, gate_socket_endpoint_t const* ep)
544 {
545 gate_result_t ret;
546 gate_socket_addr_storage_t addr;
547
2/3
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 8 switch (ep->family)
548 {
549 5 case GATE_SOCKET_FAMILY_INET4:
550 {
551 5 const sock_socklen_t addrlen = (sock_socklen_t)gate_socket_build_addr_ip4(&ep->ip4, &addr.addr4);
552
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
 5 if (0 != api.sock_bind((sock_fd_t)sock, (struct sockaddr const*)&addr.addr4, addrlen))
553 {
554 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_bind(IPv4) failed");
555 ✗ ret = GATE_RESULT_FAILED;
556 }
557 else
558 {
559 5 ret = GATE_RESULT_OK;
560 }
561 5 break;
562 }
563 3 case GATE_SOCKET_FAMILY_INET6:
564 {
565 #if defined(GATE_NET_SOCKET_NO_IPV6)
566 ret = GATE_RESULT_NOTSUPPORTED;
567 #else
568 3 const sock_socklen_t addrlen = (sock_socklen_t)gate_socket_build_addr_ip6(&ep->ip6, &addr.addr6);
569
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 if (0 != api.sock_bind((sock_fd_t)sock, (struct sockaddr const*)&addr.addr6, addrlen))
570 {
571 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_bind(IPv6) failed");
572 ✗ ret = GATE_RESULT_FAILED;
573 }
574 else
575 {
576 3 ret = GATE_RESULT_OK;
577 }
578 #endif
579 3 break;
580 }
581 ✗ default:
582 {
583 ✗ ret = GATE_RESULT_NOTSUPPORTED;
584 ✗ break;
585 }
586 }
587 8 return ret;
588 }
589
590 4 gate_result_t gate_socket_bind_address(gate_socket_t sock, gate_string_t const* address)
591 {
592 gate_socket_endpoint_t ep;
593 4 gate_result_t ret = gate_socket_parse_endpoint(address, &ep);
594
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 if (GATE_SUCCEEDED(ret))
595 {
596 4 ret = gate_socket_bind(sock, &ep);
597 }
598 4 return ret;
599 }
600
601 3 gate_result_t gate_socket_listen(gate_socket_t sock, gate_int32_t backlog)
602 {
603 gate_result_t ret;
604
605
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (backlog == GATE_SOCKET_BACKLOG_DEFAULT)
606 {
607 ✗ backlog = SOMAXCONN;
608 }
609
610
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 if (0 != api.sock_listen((sock_fd_t)sock, (int)backlog))
611 {
612 ✗ const int error_code = api.sock_errno();
613 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_listen() failed");
614 ✗ ret = GATE_RESULT_FAILED;
615 }
616 else
617 {
618 3 ret = GATE_RESULT_OK;
619 }
620 3 return ret;
621 }
622 4 gate_result_t gate_socket_accept(gate_socket_t sock, gate_socket_t* newsock)
623 {
624 gate_result_t ret;
625 4 sock_fd_t sockaccepted = api.sock_accept((sock_fd_t)sock, NULL, 0);
626
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (sockaccepted == -1)
627 {
628 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_accept() failed");
629 ✗ ret = GATE_RESULT_FAILED;
630 }
631 else
632 {
633 4 ret = GATE_RESULT_OK;
634
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (newsock == NULL)
635 {
636 ✗ api.sock_close(sockaccepted);
637 }
638 else
639 {
640 4 *newsock = (gate_socket_t)sockaccepted;
641 #if defined(GATE_DEBUG_MODE)
642
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 if (GATE_SUCCEEDED(ret))
643 {
644 4 gate_int32_t sockets_created_counter = gate_atomic_int_inc(&sockets_created);
645 4 GATE_DEBUG_TRACE_VALUE(sockets_created_counter);
646 }
647 #endif
648 }
649 #if defined(GATE_SYS_WIN) && !defined(GATE_SYS_WINCE) && !defined(GATE_SYS_WINSTORE) && !defined(GATE_SYS_WIN16)
650 SetHandleInformation((HANDLE)sockaccepted, HANDLE_FLAG_INHERIT, 0);
651 #endif
652 }
653 4 return ret;
654 }
655 85 gate_result_t gate_socket_receive(gate_socket_t sock, char* buffer, gate_size_t bufferlen, gate_size_t* bufferused)
656 {
657 gate_result_t ret;
658
659 85 int received = api.sock_recv((sock_fd_t)sock, buffer, (socklen_t)bufferlen, 0);
660
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
 85 if (received == -1)
661 {
662 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_recv() failed");
663 ✗ ret = GATE_RESULT_FAILED;
664 #if defined(GATE_SYS_WIN)
665 /* Windows may return errors in case of closed connections */
666 switch (api.sock_errno())
667 {
668 case WSAECONNRESET:
669 case WSAECONNABORTED:
670 case WSAESHUTDOWN:
671 {
672 /* equals End-Of-Stream, which is not an error */
673 if (bufferused != NULL)
674 {
675 *bufferused = 0;
676 }
677 ret = GATE_RESULT_OK;
678 }
679 }
680 #endif
681 }
682 else
683 {
684 85 ret = GATE_RESULT_OK;
685
1/2
✓ Branch 0 taken 85 times.
✗ Branch 1 not taken.
 85 if (bufferused != NULL)
686 {
687 85 *bufferused = (gate_size_t)received;
688 }
689 }
690 85 return ret;
691 }
692 2 gate_result_t gate_socket_receive_from(gate_socket_t sock, gate_socket_endpoint_t* ep, char* buffer, gate_size_t bufferlen, gate_size_t* bufferused, gate_uint16_t flags)
693 {
694 gate_result_t ret;
695 gate_socket_addr_storage_t addr;
696 2 socklen_t addrlen = sizeof(addr);
697 2 int fl = 0;
698 int received;
699
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_PEEK)) fl |= MSG_PEEK;
700
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_OOB)) fl |= MSG_OOB;
701
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_DONTROUTE)) fl |= MSG_DONTROUTE;
702 #if defined(MSG_WAITALL)
703
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_WAITALL)) fl |= MSG_WAITALL;
704 #endif
705 #if defined(MSG_EOR)
706
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_WAITALL)) fl |= MSG_EOR;
707 #endif
708 2 gate_mem_clear(&addr, sizeof(addr));
709 2 received = api.sock_recvfrom((sock_fd_t)sock, buffer, (socklen_t)bufferlen, fl, (struct sockaddr*)&addr, &addrlen);
710
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (received == -1)
711 {
712 ✗ ret = GATE_RESULT_FAILED;
713 #if defined(GATE_SYS_WIN)
714 /* Windows may return errors in case of closed connections */
715 switch (api.sock_errno())
716 {
717 case WSAECONNRESET:
718 case WSAECONNABORTED:
719 case WSAESHUTDOWN:
720 {
721 /* equals End-Of-Stream, which is not an error */
722 if (bufferused != NULL)
723 {
724 *bufferused = 0;
725 }
726 ret = GATE_RESULT_OK;
727 }
728 }
729 #endif
730 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_recvfrom() failed");
731 }
732 else
733 {
734 2 ret = GATE_RESULT_OK;
735
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (bufferused != NULL)
736 {
737 2 *bufferused = (gate_size_t)received;
738 }
739
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (ep != NULL)
740 {
741 2 gate_socket_load_endpoint(&addr.addr, ep);
742 }
743 }
744
745 2 return ret;
746 }
747 9 gate_result_t gate_socket_send(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
748 {
749 gate_result_t ret;
750 int sentbytes;
751
752 #if defined(GATE_SYS_POSIX)
753 9 gate_posix_sigblocker_t blocker = gate_posix_block_signals(SIGPIPE, 0);
754 #endif
755
756 9 sentbytes = api.sock_send((sock_fd_t)sock, buffer, (socklen_t)bufferlen, 0);
757
758 #if defined(GATE_SYS_POSIX)
759 9 gate_posix_unblock_signals(blocker);
760 #endif
761
762
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (sentbytes == -1)
763 {
764 ✗ sentbytes = api.sock_errno();
765 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_send() failed");
766 ✗ ret = GATE_RESULT_FAILED;
767 }
768 else
769 {
770 9 ret = GATE_RESULT_OK;
771
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
 9 if (bufferprocessed != NULL)
772 {
773 9 *bufferprocessed = (gate_size_t)sentbytes;
774 }
775 }
776
777 9 return ret;
778 }
779 ✗ gate_result_t gate_socket_send_block(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
780 {
781 ✗ gate_result_t ret = GATE_RESULT_OK;
782 ✗ gate_size_t pos = 0;
783 gate_size_t bytes_sent;
784 ✗ while (pos < bufferlen)
785 {
786 ✗ ret = gate_socket_send(sock, &buffer[pos], bufferlen - pos, &bytes_sent);
787 ✗ GATE_BREAK_IF_FAILED(ret);
788
789 ✗ pos += bytes_sent;
790 }
791 ✗ if (bufferprocessed != NULL)
792 {
793 ✗ *bufferprocessed = pos;
794 }
795 ✗ return ret;
796 }
797
798 2 gate_result_t gate_socket_send_to(gate_socket_t sock, gate_socket_endpoint_t const* to, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed, gate_uint16_t flags)
799 {
800 2 gate_result_t ret = GATE_RESULT_FAILED;
801 int sentbytes;
802 2 int fl = 0;
803 gate_socket_addr_storage_t addr;
804 2 gate_size_t addrlen = 0;
805
806 #if defined(GATE_SYS_POSIX)
807 2 gate_posix_sigblocker_t blocker = gate_posix_block_signals(SIGPIPE, 0);
808 #endif
809
810
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_DONTROUTE)) fl |= MSG_DONTROUTE;
811
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_OOB)) fl |= MSG_OOB;
812
813 do
814 {
815
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (to == NULL)
816 {
817 ✗ ret = GATE_RESULT_INVALIDARG;
818 ✗ break;
819 }
820
821 2 ret = gate_socket_save_endpoint(to, &addr.addr, &addrlen);
822
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 GATE_BREAK_IF_FAILED(ret);
823
824 2 sentbytes = api.sock_sendto((sock_fd_t)sock, buffer, (socklen_t)bufferlen, fl,
825 &addr.addr, (sock_socklen_t)addrlen);
826
827
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (sentbytes == -1)
828 {
829 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_sendto() failed");
830 ✗ ret = GATE_RESULT_FAILED;
831 }
832 else
833 {
834 2 ret = GATE_RESULT_OK;
835
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (bufferprocessed != NULL)
836 {
837 2 *bufferprocessed = (gate_size_t)sentbytes;
838 }
839 }
840 } while (0);
841
842 #if defined(GATE_SYS_POSIX)
843 2 gate_posix_unblock_signals(blocker);
844 #endif
845
846 2 return ret;
847 }
848 17 static int gate_socket_get_nfds(sock_fd_t highest_socket_id)
849 {
850 #if defined(GATE_SYS_WIN)
851 GATE_UNUSED_ARG(highest_socket_id);
852 return 0;
853 #else
854 17 return (int)(highest_socket_id + 1);
855 #endif
856 }
857 17 gate_result_t gate_socket_select(gate_socket_t const* socks, gate_size_t sockcount, gate_uint8_t* statusflags, gate_uint32_t timeout)
858 {
859 gate_result_t ret;
860 TIMEVAL to;
861 gate_size_t ndx;
862 fd_set fds_read;
863 fd_set fds_write;
864 fd_set fds_except;
865 17 sock_fd_t highestsocket = 0;
866 gate_uint8_t tmp;
867
868 #if defined(GATE_SYS_POSIX)
869 17 gate_posix_sigblocker_t blocker = gate_posix_block_signals(SIGPIPE, 0);
870 #endif
871
872 17 FD_ZERO(&fds_read);
873 17 FD_ZERO(&fds_write);
874 17 FD_ZERO(&fds_except);
875
876 17 to.tv_sec = timeout / 1000;
877 17 to.tv_usec = (timeout % 1000) * 1000;
878
879
2/2
✓ Branch 0 taken 37 times.
✓ Branch 1 taken 17 times.
 54 for (ndx = 0; ndx < sockcount; ++ndx)
880 {
881
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 18 times.
 37 if (highestsocket < (sock_fd_t)socks[ndx])
882 {
883 19 highestsocket = (sock_fd_t)socks[ndx];
884 }
885
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 4 times.
 37 if (GATE_FLAG_ENABLED(statusflags[ndx], GATE_SOCKET_SELECT_FLAG_RECEIVE))
886 {
887 33 FD_SET((sock_fd_t)socks[ndx], &fds_read);
888 }
889
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 29 times.
 37 if (GATE_FLAG_ENABLED(statusflags[ndx], GATE_SOCKET_SELECT_FLAG_SEND))
890 {
891 8 FD_SET((sock_fd_t)socks[ndx], &fds_write);
892 }
893
1/2
✓ Branch 0 taken 37 times.
✗ Branch 1 not taken.
 37 if (GATE_FLAG_ENABLED(statusflags[ndx], GATE_SOCKET_SELECT_FLAG_ERROR))
894 {
895 37 FD_SET((sock_fd_t)socks[ndx], &fds_except);
896 }
897 }
898
899
1/2
✗ Branch 2 not taken.
✓ Branch 3 taken 17 times.
 17 if (-1 == api.sock_select(gate_socket_get_nfds(highestsocket), &fds_read, &fds_write, &fds_except, &to))
900 {
901 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_select() failed");
902 ✗ ret = GATE_RESULT_FAILED;
903 }
904 else
905 {
906 17 ret = GATE_RESULT_OK;
907
2/2
✓ Branch 0 taken 37 times.
✓ Branch 1 taken 17 times.
 54 for (ndx = 0; ndx < sockcount; ++ndx)
908 {
909 37 tmp = 0;
910
2/2
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 20 times.
 37 if (api.sock_isset((sock_fd_t)socks[ndx], &fds_read))
911 {
912 17 tmp |= GATE_SOCKET_SELECT_FLAG_RECEIVE;
913 }
914
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 31 times.
 37 if (api.sock_isset((sock_fd_t)socks[ndx], &fds_write))
915 {
916 6 tmp |= GATE_SOCKET_SELECT_FLAG_SEND;
917 }
918
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 37 times.
 37 if (api.sock_isset((sock_fd_t)socks[ndx], &fds_except))
919 {
920 ✗ tmp |= GATE_SOCKET_SELECT_FLAG_ERROR;
921 }
922 37 statusflags[ndx] = tmp;
923 }
924 }
925
926 #if defined(GATE_SYS_POSIX)
927 17 gate_posix_unblock_signals(blocker);
928 #endif
929
930 17 return ret;
931 }
932
933 6 gate_result_t gate_socket_shutdown(gate_socket_t sock, gate_bool_t shutdownreceive, gate_bool_t shutdownsend)
934 {
935 gate_result_t ret;
936 6 int sh = 0;
937
938 do
939 {
940
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 6 if (shutdownreceive && shutdownsend)
941 {
942 ✗ sh = SD_BOTH;
943 }
944
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 else if (shutdownreceive)
945 {
946 ✗ sh = SD_RECEIVE;
947 }
948
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 else if (shutdownsend)
949 {
950 6 sh = SD_SEND;
951 }
952 else
953 {
954 ✗ ret = GATE_RESULT_INVALIDARG;
955 ✗ break;
956 }
957
958
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 if (0 != api.sock_shutdown((sock_fd_t)sock, sh))
959 {
960 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_shutdown() failed");
961 ✗ ret = GATE_RESULT_FAILED;
962 }
963 else
964 {
965 6 ret = GATE_RESULT_OK;
966 }
967
968 } while (0);
969
970 6 return ret;
971 }
972 18 gate_result_t gate_socket_close(gate_socket_t sock)
973 {
974 18 gate_result_t ret = GATE_RESULT_INVALIDARG;
975
1/2
✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
 18 if (sock != GATE_SOCKET_INVALID)
976 {
977
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
 18 if (-1 == api.sock_close((sock_fd_t)sock))
978 {
979 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_close() failed");
980 ✗ ret = GATE_RESULT_FAILED;
981 }
982 else
983 {
984 18 ret = GATE_RESULT_OK;
985 #if defined(GATE_DEBUG_MODE)
986
1/2
✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
 18 if (GATE_SUCCEEDED(ret))
987 {
988 18 gate_int32_t sockets_released_counter = gate_atomic_int_inc(&sockets_released);
989 18 GATE_DEBUG_TRACE_VALUE(sockets_released_counter);
990 }
991 #endif
992 }
993 }
994 18 return ret;
995 }
996 ✗ gate_result_t gate_socket_get_option(gate_socket_t sock, gate_int32_t level, gate_int32_t option, void* buffer, gate_size_t* bufferlen)
997 {
998 gate_result_t ret;
999 socklen_t len;
1000 do
1001 {
1002 ✗ if (bufferlen == NULL)
1003 {
1004 ✗ len = 0;
1005 }
1006 else
1007 {
1008 ✗ len = (socklen_t)*bufferlen;
1009 }
1010 ✗ if (-1 == api.sock_getsockopt((sock_fd_t)sock, (int)level, (int)option, (char*)buffer, &len))
1011 {
1012 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_getsockopt() failed");
1013 ✗ ret = GATE_RESULT_FAILED;
1014 }
1015 else
1016 {
1017 ✗ ret = GATE_RESULT_OK;
1018 }
1019 ✗ if (bufferlen != NULL)
1020 {
1021 ✗ *bufferlen = (gate_size_t)len;
1022 }
1023 } while (0);
1024 ✗ return ret;
1025 }
1026 8 gate_result_t gate_socket_set_option(gate_socket_t sock, gate_int32_t level, gate_int32_t option, void const* buffer, gate_size_t bufferlen)
1027 {
1028 gate_result_t ret;
1029
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
 8 if (0 != api.sock_setsockopt((sock_fd_t)sock, (int)level, (int)option, (char const*)buffer, (socklen_t)bufferlen))
1030 {
1031 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_setsockopt()");
1032 ✗ ret = GATE_RESULT_FAILED;
1033 }
1034 else
1035 {
1036 8 ret = GATE_RESULT_OK;
1037 }
1038 8 return ret;
1039 }
1040 13 gate_result_t gate_socket_set(gate_socket_t sock, GATE_SOCKET_OPTION option, gate_int32_t value)
1041 {
1042 gate_int32_t level;
1043 gate_int32_t opt;
1044 13 void* ptr = NULL;
1045 13 gate_size_t len = 0;
1046 13 int opt_val = 0;
1047 #if !defined(GATE_SYS_WIN)
1048 TIMEVAL opt_tv;
1049 #endif
1050
1051
3/7
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✓ Branch 5 taken 3 times.
✗ Branch 6 not taken.
 13 switch (option)
1052 {
1053 5 case GATE_SOCKET_OPTION_BLOCKING:
1054 {
1055 5 return gate_socket_set_blocking(sock, value ? true : false);
1056 }
1057 ✗ case GATE_SOCKET_OPTION_TCPNODELAY:
1058 {
1059 ✗ level = IPPROTO_TCP;
1060 ✗ opt = TCP_NODELAY;
1061 ✗ opt_val = value ? 1 : 0;
1062 ✗ ptr = &opt_val;
1063 ✗ len = sizeof(opt_val);
1064 ✗ break;
1065 }
1066 ✗ case GATE_SOCKET_OPTION_KEEPALIVE:
1067 {
1068 ✗ level = SOL_SOCKET;
1069 ✗ opt = SO_KEEPALIVE;
1070 ✗ opt_val = value ? 1 : 0;
1071 ✗ ptr = &opt_val;
1072 ✗ len = sizeof(opt_val);
1073 ✗ break;
1074 }
1075 ✗ case GATE_SOCKET_OPTION_BROADCAST:
1076 {
1077 ✗ level = SOL_SOCKET;
1078 ✗ opt = SO_BROADCAST;
1079 ✗ opt_val = value ? 1 : 0;
1080 ✗ ptr = &opt_val;
1081 ✗ len = sizeof(opt_val);
1082 ✗ break;
1083 }
1084 5 case GATE_SOCKET_OPTION_RECEIVETIMEOUT:
1085 {
1086 5 level = SOL_SOCKET;
1087 5 opt = SO_RCVTIMEO;
1088 #if defined(GATE_SYS_WIN)
1089 opt_val = value;
1090 ptr = &opt_val;
1091 len = sizeof(opt_val);
1092 #else
1093 5 opt_tv.tv_usec = (value % 1000) * 1000;
1094 5 opt_tv.tv_sec = value / 1000;
1095 5 ptr = &opt_tv;
1096 5 len = sizeof(opt_tv);
1097 #endif
1098 5 break;
1099 }
1100 3 case GATE_SOCKET_OPTION_SENDTIMEOUT:
1101 {
1102 3 level = SOL_SOCKET;
1103 3 opt = SO_SNDTIMEO;
1104 #if defined(GATE_SYS_WIN)
1105 opt_val = value;
1106 ptr = &opt_val;
1107 len = sizeof(opt_val);
1108 #else
1109 3 opt_tv.tv_usec = (value % 1000) * 1000;
1110 3 opt_tv.tv_sec = value / 1000;
1111 3 ptr = &opt_tv;
1112 3 len = sizeof(opt_tv);
1113 #endif
1114 3 break;
1115 }
1116 ✗ default:
1117 {
1118 ✗ return GATE_RESULT_NOTSUPPORTED;
1119 }
1120 }
1121
1122 8 return gate_socket_set_option(sock, level, opt, ptr, len);
1123 }
1124
1125 2 gate_result_t gate_socket_get_local_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
1126 {
1127 gate_result_t ret;
1128 gate_socket_addr_storage_t addr;
1129 2 socklen_t addrlen = sizeof(addr);
1130
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (ep == NULL)
1131 {
1132 ✗ ret = GATE_RESULT_INVALIDARG;
1133 }
1134 else
1135 {
1136
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if (0 != api.sock_getsockname((sock_fd_t)sock, &addr.addr, &addrlen))
1137 {
1138 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_getsockname() failed");
1139 ✗ ret = GATE_RESULT_FAILED;
1140 }
1141 else
1142 {
1143 2 ret = gate_socket_load_endpoint(&addr.addr, ep);
1144 }
1145 }
1146 2 return ret;
1147 }
1148 2 gate_result_t gate_socket_get_local_address(gate_socket_t sock, gate_string_t* address)
1149 {
1150 gate_result_t ret;
1151 gate_socket_endpoint_t ep;
1152 2 ret = gate_socket_get_local_endpoint(sock, &ep);
1153
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (GATE_SUCCEEDED(ret))
1154 {
1155 2 ret = gate_socket_print_endpoint(&ep, address);
1156 }
1157 2 return ret;
1158 }
1159 2 gate_result_t gate_socket_get_remote_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
1160 {
1161 gate_result_t ret;
1162 gate_socket_addr_storage_t addr;
1163 2 socklen_t addrlen = sizeof(addr);
1164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (ep == NULL)
1165 {
1166 ✗ ret = GATE_RESULT_INVALIDARG;
1167 }
1168 else
1169 {
1170
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if (0 != api.sock_getpeername((sock_fd_t)sock, &addr.addr, &addrlen))
1171 {
1172 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_getpeername() failed");
1173 ✗ ret = GATE_RESULT_FAILED;
1174 }
1175 else
1176 {
1177 2 ret = gate_socket_load_endpoint(&addr.addr, ep);
1178 }
1179 }
1180 2 return ret;
1181 }
1182 2 gate_result_t gate_socket_get_remote_address(gate_socket_t sock, gate_string_t* address)
1183 {
1184 gate_result_t ret;
1185 gate_socket_endpoint_t ep;
1186 2 ret = gate_socket_get_remote_endpoint(sock, &ep);
1187
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (GATE_SUCCEEDED(ret))
1188 {
1189 2 ret = gate_socket_print_endpoint(&ep, address);
1190 }
1191 2 return ret;
1192 }
1193
1194 static gate_string_t const ipv6_begin = GATE_STRING_INIT_STATIC("[");
1195 static gate_string_t const ipv6_end = GATE_STRING_INIT_STATIC("]");
1196 static gate_string_t const ip_any = GATE_STRING_INIT_STATIC("*");
1197 static gate_string_t const ip6_any = GATE_STRING_INIT_STATIC("::");
1198 static gate_string_t const ip_port_separator = GATE_STRING_INIT_STATIC(":");
1199
1200 8 gate_result_t gate_socket_parse_ip4(gate_string_t const* ip4text, gate_socket_ip4address_t* ip4address)
1201 {
1202 8 gate_result_t ret = GATE_RESULT_FAILED;
1203 gate_size_t start, ndx, pos;
1204 gate_uint64_t num;
1205
1206 do
1207 {
1208
2/4
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 8 times.
 8 if (gate_string_equals(ip4text, &ip_any) || gate_string_is_empty(ip4text))
1209 {
1210 /* ANY-IP -> "0.0.0.0", already set by gate_mem_clear() */
1211 ✗ ret = GATE_RESULT_OK;
1212 ✗ break;
1213 }
1214
1215 8 start = 0;
1216
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 8 times.
 32 for (ndx = 0; ndx != 3; ++ndx)
1217 {
1218 24 pos = gate_string_char_pos(ip4text, '.', start);
1219
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
 24 if (pos == GATE_STR_NPOS)
1220 {
1221 ✗ break;
1222 }
1223
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
 24 if (0 == gate_str_parse_uint64(ip4text->str + start, ip4text->length - pos, &num))
1224 {
1225 /* failed to parse number */
1226 ✗ ret = GATE_RESULT_INVALIDINPUT;
1227 ✗ pos = GATE_STR_NPOS;
1228 ✗ break;
1229 }
1230 24 ip4address->item[ndx] = (gate_uint8_t)num;
1231 24 start = pos + 1;
1232 }
1233
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (pos == GATE_STR_NPOS) break;
1234
1235 8 gate_str_parse_uint64(ip4text->str + start, ip4text->length - start, &num);
1236 8 ip4address->item[ndx] = (gate_uint8_t)num;
1237
1238 8 ret = GATE_RESULT_OK;
1239 } while (0);
1240
1241 8 return ret;
1242 }
1243
1244 6 gate_result_t gate_socket_parse_ip6(gate_string_t const* ip6text, gate_socket_ip6address_t* ip6address)
1245 {
1246 6 gate_result_t ret = GATE_RESULT_FAILED;
1247 6 gate_string_t ip = GATE_STRING_INIT_EMPTY;
1248 gate_size_t ndx;
1249 gate_size_t pos, start;
1250 gate_uint64_t num;
1251
1252 do
1253 {
1254 6 gate_mem_clear(ip6address, sizeof(gate_socket_ip6address_t));
1255
1256
1/4
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 6 if (gate_string_starts_with(ip6text, &ipv6_begin) && gate_string_ends_with(ip6text, &ipv6_end))
1257 {
1258 ✗ gate_string_substr(&ip, ip6text, 1, ip6text->length - 2);
1259 }
1260 else
1261 {
1262 6 gate_string_duplicate(&ip, ip6text);
1263 }
1264
1265
3/6
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
 6 if (gate_string_equals(&ip, &ip_any) || gate_string_equals(&ip, &ip6_any) || gate_string_is_empty(&ip))
1266 {
1267 /* ANY-IP -> "[::]", already set by gate_mem_clear() */
1268 ✗ ret = GATE_RESULT_OK;
1269 ✗ break;
1270 }
1271 6 start = 0;
1272
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 1 times.
 13 for (ndx = 0; ndx != 7; ++ndx)
1273 {
1274 12 pos = gate_string_char_pos(&ip, ':', start);
1275
4/4
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 7 times.
✓ Branch 3 taken 4 times.
 12 if ((pos == GATE_STR_NPOS) || (pos == start))
1276 {
1277 break;
1278 }
1279 7 gate_str_parse_hex_int(ip.str + start, ip.length - pos, &num);
1280 7 ip6address->item[ndx] = (gate_uint16_t)num;
1281 7 start = pos + 1;
1282 }
1283
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 5 times.
 6 if (pos == GATE_STR_NPOS)
1284 {
1285 1 GATE_DEBUG_TRACE("Invalid IPv6 address");
1286 1 break;
1287 }
1288
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1 times.
 5 if (pos == start)
1289 {
1290 /* double-colon detected */
1291
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 for (ndx = 0; ndx != 7; ++ndx)
1292 {
1293 8 pos = gate_string_char_pos_last(&ip, ':');
1294
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (pos == GATE_STR_NPOS) break;
1295
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
 8 if (pos == ip.length - 1) break; /* double-colon reached */
1296 4 gate_str_parse_hex_int(ip.str + pos + 1, ip.length - pos - 1, &num);
1297 4 ip6address->item[7 - ndx] = (gate_uint16_t)num;
1298 /* r-trim extracted data from ip-address string: */
1299 4 gate_string_substr(&ip, &ip, 0, pos);
1300 }
1301 }
1302 else
1303 {
1304 /* extract last ip number */
1305 1 gate_str_parse_uint64(ip.str + start, ip.length - start, &num);
1306 1 ip6address->item[ndx] = (gate_uint16_t)num;
1307 }
1308 5 ret = GATE_RESULT_OK;
1309
1310 } while (0);
1311
1312 6 gate_string_release(&ip);
1313
1314 6 return ret;
1315 }
1316
1317
1318
1319 1 gate_result_t gate_socket_parse_address(gate_string_t const* address, gate_string_t* host, gate_uint16_t* port, gate_int16_t* family)
1320 {
1321 1 gate_result_t ret = GATE_RESULT_INVALIDDATA;
1322 gate_size_t pos;
1323 1 gate_string_t address_ip = GATE_STRING_INIT_EMPTY;
1324 1 gate_string_t tail = GATE_STRING_INIT_EMPTY;
1325 1 gate_uint64_t address_port = 0;
1326 gate_size_t len;
1327
1328 do
1329 {
1330
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if (gate_string_starts_with(address, &ipv6_begin))
1331 {
1332 /* IP v6 */
1333 ✗ pos = gate_string_pos(address, &ipv6_end, 1);
1334 ✗ if (GATE_STR_NPOS == pos)
1335 {
1336 ✗ break;
1337 }
1338 ✗ gate_string_substr(&address_ip, address, 0, pos + 1);
1339 ✗ gate_string_substr(&tail, address, pos + 1, GATE_STR_NPOS);
1340 ✗ if (family)
1341 {
1342 ✗ *family = GATE_SOCKET_FAMILY_INET6;
1343 }
1344 }
1345 else
1346 {
1347 /* IP v4 */
1348 1 pos = gate_string_find_last_of(address, &ip_port_separator);
1349
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (pos == GATE_STR_NPOS)
1350 {
1351 1 gate_string_duplicate(&address_ip, address);
1352 }
1353 else
1354 {
1355 ✗ gate_string_substr(&address_ip, address, 0, pos);
1356 ✗ gate_string_substr(&tail, address, pos, GATE_STR_NPOS);
1357 }
1358
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (family)
1359 {
1360 1 *family = GATE_SOCKET_FAMILY_INET4;
1361 }
1362 }
1363
1364
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 if (gate_string_is_empty(&tail))
1365 {
1366 1 address_port = 0;
1367 }
1368 else
1369 {
1370 ✗ if (!gate_string_starts_with(&tail, &ip_port_separator))
1371 {
1372 ✗ break;
1373 }
1374 else
1375 {
1376 ✗ gate_string_substr(&tail, &tail, 1, GATE_STR_NPOS);
1377 ✗ len = gate_string_parse_uint(&tail, &address_port);
1378 ✗ if (len != gate_string_length(&tail))
1379 {
1380 ✗ break;
1381 }
1382 }
1383 }
1384
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (host)
1385 {
1386 1 gate_string_duplicate(host, &address_ip);
1387 }
1388
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (port)
1389 {
1390 1 *port = (gate_uint16_t)address_port;
1391 }
1392 1 ret = GATE_RESULT_OK;
1393 } while (0);
1394
1395 1 gate_string_release(&tail);
1396 1 gate_string_release(&address_ip);
1397 1 return ret;
1398 }
1399
1400
1401 12 gate_result_t gate_socket_parse_endpoint(gate_string_t const* address, gate_socket_endpoint_t* endpoint)
1402 {
1403 12 gate_result_t ret = GATE_RESULT_INVALIDDATA;
1404 gate_size_t pos, len;
1405 12 gate_uint64_t num = 0;
1406 12 gate_string_t ip = GATE_STRING_INIT_EMPTY;
1407 do
1408 {
1409 /* address format is "IP:PORT",
1410 * eg. "1.2.3.4:8080" or "[1:2:a:b:c:d:e:f]:8080"
1411 */
1412 12 gate_mem_clear(endpoint, sizeof(gate_socket_endpoint_t));
1413
1414 12 pos = gate_str_char_pos_last(address->str, address->length, ':');
1415
2/4
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12 times.
 12 if ((pos == GATE_STR_NPOS) || (pos == address->length - 1))
1416 {
1417 ✗ GATE_DEBUG_TRACE("Invalid endpoint: No port suffix");
1418 ✗ break;
1419 }
1420
1421 12 len = address->length - pos - 1;
1422
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
 12 if (len != gate_str_parse_uint64(address->str + pos + 1, len, &num))
1423 {
1424 ✗ GATE_DEBUG_TRACE("Invalid endpoint: Invalid port format");
1425 ✗ break;
1426 }
1427
1428
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
 12 if (NULL == gate_string_substr(&ip, address, 0, pos))
1429 {
1430 ✗ ret = GATE_RESULT_OUTOFMEMORY;
1431 ✗ break;
1432 }
1433
1434
3/4
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 7 times.
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
 12 if (gate_string_starts_with(&ip, &ipv6_begin) && gate_string_ends_with(&ip, &ipv6_end))
1435 {
1436 /* ip v6 address */
1437 5 endpoint->ip6.family = GATE_SOCKET_FAMILY_INET6;
1438 5 endpoint->ip6.port = (gate_uint16_t)num;
1439 5 endpoint->ip6.scope = 0;
1440 5 gate_string_substr(&ip, &ip, 1, ip.length - 2);
1441
1442 5 ret = gate_socket_parse_ip6(&ip, &endpoint->ip6.address);
1443 }
1444 else
1445 {
1446 /* ip v4 address */
1447 7 endpoint->ip4.family = GATE_SOCKET_FAMILY_INET4;
1448 7 endpoint->ip4.port = (gate_uint16_t)num;
1449 7 ret = gate_socket_parse_ip4(&ip, &endpoint->ip4.address);
1450 }
1451
1452 } while (0);
1453
1454 12 gate_string_release(&ip);
1455
1456
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
 12 GATE_DEBUG_TRACE_FAILED(ret, "gate_socket_parse_endpoint() failed");
1457
1458 12 return ret;
1459 }
1460
1461 7 gate_result_t gate_socket_print_endpoint(gate_socket_endpoint_t const* endpoint, gate_string_t* address)
1462 {
1463 gate_result_t ret;
1464 7 gate_strbuilder8_t builder = GATE_INIT_EMPTY;
1465 gate_char8_t hexbuffer[8];
1466 gate_size_t hexbufferused;
1467
2/3
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 7 switch (endpoint->family)
1468 {
1469 4 case GATE_SOCKET_FAMILY_INET4:
1470 {
1471 4 gate_strbuilder_create(&builder, 16);
1472 4 gate_strbuilder_append_uint16(&builder, endpoint->ip4.address.item[0]);
1473 4 gate_strbuilder_append_text(&builder, ".", 1);
1474 4 gate_strbuilder_append_uint16(&builder, endpoint->ip4.address.item[1]);
1475 4 gate_strbuilder_append_text(&builder, ".", 1);
1476 4 gate_strbuilder_append_uint16(&builder, endpoint->ip4.address.item[2]);
1477 4 gate_strbuilder_append_text(&builder, ".", 1);
1478 4 gate_strbuilder_append_uint16(&builder, endpoint->ip4.address.item[3]);
1479
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
 4 if (endpoint->ip4.port)
1480 {
1481 3 gate_strbuilder_append_text(&builder, ":", 1);
1482 3 gate_strbuilder_append_uint16(&builder, endpoint->ip4.port);
1483 }
1484 4 ret = GATE_RESULT_OK;
1485 4 break;
1486 }
1487 3 case GATE_SOCKET_FAMILY_INET6:
1488 {
1489 3 gate_strbuilder_create(&builder, 50);
1490 3 gate_strbuilder_append_text(&builder, "[", 1);
1491
1492 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[0], false);
1493 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1494
1495 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[1], false);
1496 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1497
1498 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[2], false);
1499 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1500
1501 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[3], false);
1502 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1503
1504 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[4], false);
1505 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1506
1507 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[5], false);
1508 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1509
1510 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[6], false);
1511 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1512
1513 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[7], false);
1514 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused);
1515
1516
1517 3 gate_strbuilder_append_text(&builder, "]", 1);
1518
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (endpoint->ip6.port)
1519 {
1520 3 gate_strbuilder_append_text(&builder, ":", 1);
1521 3 gate_strbuilder_append_uint16(&builder, endpoint->ip6.port);
1522 }
1523
1524 3 ret = GATE_RESULT_OK;
1525 3 break;
1526 }
1527 ✗ default:
1528 {
1529 ✗ ret = GATE_RESULT_NOTSUPPORTED;
1530 ✗ break;
1531 }
1532 }
1533
1534
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
 7 if (NULL == gate_strbuilder_to_string(&builder, address))
1535 {
1536 ✗ ret = GATE_RESULT_OUTOFMEMORY;
1537 }
1538
1539 7 gate_strbuilder_release(&builder);
1540
1541
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
 7 GATE_DEBUG_TRACE_FAILED(ret, "gate_socket_print_endpoint() failed");
1542
1543 7 return ret;
1544 }
1545
1546 12 gate_result_t gate_socket_load_endpoint(void const* ptr_in_native_sock_addr, gate_socket_endpoint_t* ptr_out_endpoint)
1547 {
1548 12 gate_socket_addr_storage_t const* ptr_addr_storage = (gate_socket_addr_storage_t const*)ptr_in_native_sock_addr;
1549
1550
2/3
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 12 switch (ptr_addr_storage->addr.sa_family)
1551 {
1552 9 case AF_INET:
1553 {
1554 9 ptr_out_endpoint->family = GATE_SOCKET_FAMILY_INET4;
1555 9 gate_socket_build_ip4address(&ptr_addr_storage->addr4, &ptr_out_endpoint->ip4);
1556 9 return GATE_RESULT_OK;
1557 }
1558 3 case AF_INET6:
1559 {
1560 #if defined(GATE_NET_SOCKET_NO_IPV6)
1561 return GATE_RESULT_NOTSUPPORTED;
1562 #else
1563 3 ptr_out_endpoint->family = GATE_SOCKET_FAMILY_INET6;
1564 3 gate_socket_build_ip6address(&ptr_addr_storage->addr6, &ptr_out_endpoint->ip6);
1565 3 return GATE_RESULT_OK;
1566 #endif
1567 }
1568 #if !defined(GATE_NET_SOCKET_NO_UNIX)
1569 case AF_UNIX:
1570 {
1571 gate_size_t len = gate_str_length_max(ptr_addr_storage->unix.sun_path, sizeof(ptr_addr_storage->unix.sun_path));
1572 ptr_out_endpoint->family = GATE_SOCKET_FAMILY_UNIX;
1573 gate_str_print_text(ptr_out_endpoint->unix_domain.path, sizeof(ptr_out_endpoint->unix_domain.path),
1574 ptr_addr_storage->unix.sun_path, len);
1575 return GATE_RESULT_OK;
1576 }
1577 #endif
1578 ✗ default:
1579 {
1580 ✗ ptr_out_endpoint->family = GATE_SOCKET_FAMILY_NONE;
1581 ✗ return GATE_RESULT_NOTSUPPORTED;
1582 }
1583 }
1584
1585 }
1586
1587 2 gate_result_t gate_socket_save_endpoint(gate_socket_endpoint_t const* ptr_src_endpoint, void* ptr_out_native_sock_addr, gate_size_t* ptr_out_native_sock_addr_len)
1588 {
1589 2 gate_socket_addr_storage_t* ptr_addr_storage = (gate_socket_addr_storage_t*)ptr_out_native_sock_addr;
1590
1591
2/3
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 2 switch (ptr_src_endpoint->family)
1592 {
1593 1 case GATE_SOCKET_FAMILY_INET4:
1594 {
1595 1 const gate_size_t addrlen = gate_socket_build_addr_ip4(&ptr_src_endpoint->ip4, &ptr_addr_storage->addr4);
1596
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (ptr_out_native_sock_addr_len)
1597 {
1598 1 *ptr_out_native_sock_addr_len = addrlen;
1599 }
1600 1 return GATE_RESULT_OK;
1601 }
1602 1 case GATE_SOCKET_FAMILY_INET6:
1603 {
1604 #if defined(GATE_NET_SOCKET_NO_IPV6)
1605 return GATE_RESULT_NOTSUPPORTED;
1606 #else
1607 1 const gate_size_t addrlen = gate_socket_build_addr_ip6(&ptr_src_endpoint->ip6, &ptr_addr_storage->addr6);
1608
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (ptr_out_native_sock_addr_len)
1609 {
1610 1 *ptr_out_native_sock_addr_len = addrlen;
1611 }
1612 1 return GATE_RESULT_OK;
1613 #endif
1614 }
1615 #if !defined(GATE_NET_SOCKET_NO_UNIX)
1616 case GATE_SOCKET_FAMILY_UNIX:
1617 {
1618 gate_size_t len = gate_str_length_max(ptr_src_endpoint->unix_domain.path, sizeof(ptr_src_endpoint->unix_domain.path));
1619 ptr_addr_storage->unix.sun_family = AF_UNIX;
1620 gate_str_print_text(ptr_addr_storage->unix.sun_path, sizeof(ptr_addr_storage->unix.sun_path),
1621 ptr_src_endpoint->unix_domain.path, len);
1622 if (ptr_out_native_sock_addr_len)
1623 {
1624 *ptr_out_native_sock_addr_len = sizeof(sockaddr_un);
1625 }
1626 return GATE_RESULT_OK;
1627 }
1628 #endif
1629 ✗ default:
1630 {
1631 ✗ return GATE_RESULT_NOTSUPPORTED;
1632 }
1633 }
1634 }
1635
1636 #endif /* GATE_NET_SOCKETS_BSDIMPL */
1637
1638
1639
1640 #if defined(GATE_NET_SOCKETS_EFI)
1641
1642 gate_result_t gate_socket_init()
1643 {
1644 return GATE_RESULT_NOTIMPLEMENTED;
1645 }
1646
1647 gate_bool_t gate_socket_support(gate_int16_t family)
1648 {
1649 GATE_UNUSED_ARG(family);
1650 return false;
1651 }
1652
1653 gate_result_t gate_socket_create(gate_int16_t type, gate_socket_t* sock)
1654 {
1655 GATE_UNUSED_ARG(type);
1656 GATE_UNUSED_ARG(sock);
1657 return GATE_RESULT_NOTIMPLEMENTED;
1658 }
1659 gate_result_t gate_socket_create_ex(gate_int16_t family, gate_int16_t msgtype, gate_int16_t protocol, gate_socket_t* sock)
1660 {
1661 GATE_UNUSED_ARG(family);
1662 GATE_UNUSED_ARG(msgtype);
1663 GATE_UNUSED_ARG(protocol);
1664 GATE_UNUSED_ARG(sock);
1665 return GATE_RESULT_NOTIMPLEMENTED;
1666 }
1667 gate_result_t gate_socket_connect(gate_socket_t sock, gate_socket_endpoint_t const* ep)
1668 {
1669 GATE_UNUSED_ARG(sock);
1670 GATE_UNUSED_ARG(ep);
1671 return GATE_RESULT_NOTIMPLEMENTED;
1672 }
1673 gate_result_t gate_socket_connect_address(gate_socket_t sock, gate_string_t const* address)
1674 {
1675 GATE_UNUSED_ARG(sock);
1676 GATE_UNUSED_ARG(address);
1677 return GATE_RESULT_NOTIMPLEMENTED;
1678 }
1679 gate_result_t gate_socket_bind(gate_socket_t sock, gate_socket_endpoint_t const* ep)
1680 {
1681 GATE_UNUSED_ARG(sock);
1682 GATE_UNUSED_ARG(ep);
1683 return GATE_RESULT_NOTIMPLEMENTED;
1684 }
1685 gate_result_t gate_socket_bind_address(gate_socket_t sock, gate_string_t const* address)
1686 {
1687 GATE_UNUSED_ARG(sock);
1688 GATE_UNUSED_ARG(address);
1689 return GATE_RESULT_NOTIMPLEMENTED;
1690 }
1691 gate_result_t gate_socket_listen(gate_socket_t sock, gate_int32_t backlog)
1692 {
1693 GATE_UNUSED_ARG(sock);
1694 GATE_UNUSED_ARG(backlog);
1695 return GATE_RESULT_NOTIMPLEMENTED;
1696 }
1697 gate_result_t gate_socket_accept(gate_socket_t sock, gate_socket_t* newsock)
1698 {
1699 GATE_UNUSED_ARG(sock);
1700 GATE_UNUSED_ARG(newsock);
1701 return GATE_RESULT_NOTIMPLEMENTED;
1702 }
1703 gate_result_t gate_socket_receive(gate_socket_t sock, char* buffer, gate_size_t bufferlen, gate_size_t* bufferused)
1704 {
1705 GATE_UNUSED_ARG(sock);
1706 GATE_UNUSED_ARG(buffer);
1707 GATE_UNUSED_ARG(bufferlen);
1708 GATE_UNUSED_ARG(bufferused);
1709 return GATE_RESULT_NOTIMPLEMENTED;
1710 }
1711 gate_result_t gate_socket_receive_from(gate_socket_t sock, gate_socket_endpoint_t* ep, char* buffer,
1712 gate_size_t bufferlen, gate_size_t* bufferused, gate_uint16_t flags)
1713 {
1714 GATE_UNUSED_ARG(sock);
1715 GATE_UNUSED_ARG(ep);
1716 GATE_UNUSED_ARG(buffer);
1717 GATE_UNUSED_ARG(bufferlen);
1718 GATE_UNUSED_ARG(bufferused);
1719 GATE_UNUSED_ARG(flags);
1720 return GATE_RESULT_NOTIMPLEMENTED;
1721 }
1722 gate_result_t gate_socket_send(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
1723 {
1724 GATE_UNUSED_ARG(sock);
1725 GATE_UNUSED_ARG(buffer);
1726 GATE_UNUSED_ARG(bufferlen);
1727 GATE_UNUSED_ARG(bufferprocessed);
1728 return GATE_RESULT_NOTIMPLEMENTED;
1729 }
1730 gate_result_t gate_socket_send_block(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
1731 {
1732 GATE_UNUSED_ARG(sock);
1733 GATE_UNUSED_ARG(buffer);
1734 GATE_UNUSED_ARG(bufferlen);
1735 GATE_UNUSED_ARG(bufferprocessed);
1736 return GATE_RESULT_NOTIMPLEMENTED;
1737 }
1738 gate_result_t gate_socket_send_to(gate_socket_t sock, gate_socket_endpoint_t const* to, char const* buffer,
1739 gate_size_t bufferlen, gate_size_t* bufferprocessed, gate_uint16_t flags)
1740 {
1741 GATE_UNUSED_ARG(sock);
1742 GATE_UNUSED_ARG(to);
1743 GATE_UNUSED_ARG(buffer);
1744 GATE_UNUSED_ARG(bufferlen);
1745 GATE_UNUSED_ARG(bufferprocessed);
1746 GATE_UNUSED_ARG(flags);
1747 return GATE_RESULT_NOTIMPLEMENTED;
1748 }
1749 gate_result_t gate_socket_select(gate_socket_t const* socks, gate_size_t sockcount, gate_uint8_t* statusflags, gate_uint32_t timeout)
1750 {
1751 GATE_UNUSED_ARG(socks);
1752 GATE_UNUSED_ARG(sockcount);
1753 GATE_UNUSED_ARG(statusflags);
1754 GATE_UNUSED_ARG(timeout);
1755 return GATE_RESULT_NOTIMPLEMENTED;
1756 }
1757 gate_result_t gate_socket_shutdown(gate_socket_t sock, gate_bool_t shutdownreceive, gate_bool_t shutdownsend)
1758 {
1759 GATE_UNUSED_ARG(sock);
1760 GATE_UNUSED_ARG(shutdownreceive);
1761 GATE_UNUSED_ARG(shutdownsend);
1762 return GATE_RESULT_NOTIMPLEMENTED;
1763 }
1764 gate_result_t gate_socket_close(gate_socket_t sock)
1765 {
1766 GATE_UNUSED_ARG(sock);
1767 return GATE_RESULT_NOTIMPLEMENTED;
1768 }
1769 gate_result_t gate_socket_get_option(gate_socket_t sock, gate_int32_t level, gate_int32_t option, void* buffer, gate_size_t* bufferlen)
1770 {
1771 GATE_UNUSED_ARG(sock);
1772 GATE_UNUSED_ARG(level);
1773 GATE_UNUSED_ARG(option);
1774 GATE_UNUSED_ARG(buffer);
1775 GATE_UNUSED_ARG(bufferlen);
1776 return GATE_RESULT_NOTIMPLEMENTED;
1777 }
1778 gate_result_t gate_socket_set_option(gate_socket_t sock, gate_int32_t level, gate_int32_t option, void const* buffer, gate_size_t bufferlen)
1779 {
1780 GATE_UNUSED_ARG(sock);
1781 GATE_UNUSED_ARG(level);
1782 GATE_UNUSED_ARG(option);
1783 GATE_UNUSED_ARG(buffer);
1784 GATE_UNUSED_ARG(bufferlen);
1785 return GATE_RESULT_NOTIMPLEMENTED;
1786 }
1787 gate_result_t gate_socket_get_local_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
1788 {
1789 GATE_UNUSED_ARG(sock);
1790 GATE_UNUSED_ARG(ep);
1791 return GATE_RESULT_NOTIMPLEMENTED;
1792 }
1793 gate_result_t gate_socket_get_local_address(gate_socket_t sock, gate_string_t* address)
1794 {
1795 GATE_UNUSED_ARG(sock);
1796 GATE_UNUSED_ARG(address);
1797 return GATE_RESULT_NOTIMPLEMENTED;
1798 }
1799 gate_result_t gate_socket_get_remote_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
1800 {
1801 GATE_UNUSED_ARG(sock);
1802 GATE_UNUSED_ARG(ep);
1803 return GATE_RESULT_NOTIMPLEMENTED;
1804 }
1805 gate_result_t gate_socket_get_remote_address(gate_socket_t sock, gate_string_t* address)
1806 {
1807 GATE_UNUSED_ARG(sock);
1808 GATE_UNUSED_ARG(address);
1809 return GATE_RESULT_NOTIMPLEMENTED;
1810 }
1811 gate_result_t gate_socket_parse_address(gate_string_t const* address, gate_string_t* host, gate_uint16_t* port, gate_int16_t* family)
1812 {
1813 GATE_UNUSED_ARG(address);
1814 GATE_UNUSED_ARG(host);
1815 GATE_UNUSED_ARG(port);
1816 GATE_UNUSED_ARG(family);
1817 return GATE_RESULT_NOTIMPLEMENTED;
1818 }
1819 gate_result_t gate_socket_parse_endpoint(gate_string_t const* address, gate_socket_endpoint_t* endpoint)
1820 {
1821 GATE_UNUSED_ARG(address);
1822 GATE_UNUSED_ARG(endpoint);
1823 return GATE_RESULT_NOTIMPLEMENTED;
1824 }
1825 gate_result_t gate_socket_print_endpoint(gate_socket_endpoint_t const* endpoint, gate_string_t* address)
1826 {
1827 GATE_UNUSED_ARG(endpoint);
1828 GATE_UNUSED_ARG(address);
1829 return GATE_RESULT_NOTIMPLEMENTED;
1830 }
1831
1832 gate_result_t gate_socket_set(gate_socket_t sock, GATE_SOCKET_OPTION option, gate_int32_t value)
1833 {
1834 GATE_UNUSED_ARG(sock);
1835 GATE_UNUSED_ARG(option);
1836 GATE_UNUSED_ARG(value);
1837 return GATE_RESULT_NOTIMPLEMENTED;
1838 }
1839
1840 gate_result_t gate_socket_parse_ip4(gate_string_t const* ip4text, gate_socket_ip4address_t* ip4address)
1841 {
1842 GATE_UNUSED_ARG(ip4text);
1843 GATE_UNUSED_ARG(ip4address);
1844 return GATE_RESULT_NOTIMPLEMENTED;
1845 }
1846
1847 gate_result_t gate_socket_parse_ip6(gate_string_t const* ip6text, gate_socket_ip6address_t* ip6address)
1848 {
1849 GATE_UNUSED_ARG(ip6text);
1850 GATE_UNUSED_ARG(ip6address);
1851 return GATE_RESULT_NOTIMPLEMENTED;
1852 }
1853
1854 gate_result_t gate_socket_load_endpoint(void const* ptr_in_native_sock_addr, gate_socket_endpoint_t* ptr_out_endpoint)
1855 {
1856 GATE_UNUSED_ARG(ptr_in_native_sock_addr);
1857 GATE_UNUSED_ARG(ptr_out_endpoint);
1858 return GATE_RESULT_NOTIMPLEMENTED;
1859 }
1860 gate_result_t gate_socket_save_endpoint(gate_socket_endpoint_t const* ptr_src_endpoint, void* ptr_out_native_sock_addr, gate_size_t* ptr_out_native_sock_addr_len)
1861 {
1862 GATE_UNUSED_ARG(ptr_src_endpoint);
1863 GATE_UNUSED_ARG(ptr_out_native_sock_addr);
1864 GATE_UNUSED_ARG(ptr_out_native_sock_addr_len);
1865 return GATE_RESULT_NOTIMPLEMENTED;
1866 }
1867
1868 #endif /* GATE_NET_SOCKETS_EFI */
1869
1870
1871
1872 #if defined(GATE_NET_SOCKETS_NOIMPL)
1873
1874 gate_result_t gate_socket_init()
1875 {
1876 return GATE_RESULT_NOTIMPLEMENTED;
1877 }
1878
1879 gate_bool_t gate_socket_support(gate_int16_t family)
1880 {
1881 GATE_UNUSED_ARG(family);
1882 return false;
1883 }
1884
1885 gate_result_t gate_socket_create(gate_int16_t type, gate_socket_t* sock)
1886 {
1887 GATE_UNUSED_ARG(type);
1888 GATE_UNUSED_ARG(sock);
1889 return GATE_RESULT_NOTIMPLEMENTED;
1890 }
1891 gate_result_t gate_socket_create_ex(gate_int16_t family, gate_int16_t msgtype, gate_int16_t protocol, gate_socket_t* sock)
1892 {
1893 GATE_UNUSED_ARG(family);
1894 GATE_UNUSED_ARG(msgtype);
1895 GATE_UNUSED_ARG(protocol);
1896 GATE_UNUSED_ARG(sock);
1897 return GATE_RESULT_NOTIMPLEMENTED;
1898 }
1899 gate_result_t gate_socket_connect(gate_socket_t sock, gate_socket_endpoint_t const* ep)
1900 {
1901 GATE_UNUSED_ARG(sock);
1902 GATE_UNUSED_ARG(ep);
1903 return GATE_RESULT_NOTIMPLEMENTED;
1904 }
1905 gate_result_t gate_socket_connect_address(gate_socket_t sock, gate_string_t const* address)
1906 {
1907 GATE_UNUSED_ARG(sock);
1908 GATE_UNUSED_ARG(address);
1909 return GATE_RESULT_NOTIMPLEMENTED;
1910 }
1911 gate_result_t gate_socket_bind(gate_socket_t sock, gate_socket_endpoint_t const* ep)
1912 {
1913 GATE_UNUSED_ARG(sock);
1914 GATE_UNUSED_ARG(ep);
1915 return GATE_RESULT_NOTIMPLEMENTED;
1916 }
1917 gate_result_t gate_socket_bind_address(gate_socket_t sock, gate_string_t const* address)
1918 {
1919 GATE_UNUSED_ARG(sock);
1920 GATE_UNUSED_ARG(address);
1921 return GATE_RESULT_NOTIMPLEMENTED;
1922 }
1923 gate_result_t gate_socket_listen(gate_socket_t sock, gate_int32_t backlog)
1924 {
1925 GATE_UNUSED_ARG(sock);
1926 GATE_UNUSED_ARG(backlog);
1927 return GATE_RESULT_NOTIMPLEMENTED;
1928 }
1929 gate_result_t gate_socket_accept(gate_socket_t sock, gate_socket_t* newsock)
1930 {
1931 GATE_UNUSED_ARG(sock);
1932 GATE_UNUSED_ARG(newsock);
1933 return GATE_RESULT_NOTIMPLEMENTED;
1934 }
1935 gate_result_t gate_socket_receive(gate_socket_t sock, char* buffer, gate_size_t bufferlen, gate_size_t* bufferused)
1936 {
1937 GATE_UNUSED_ARG(sock);
1938 GATE_UNUSED_ARG(buffer);
1939 GATE_UNUSED_ARG(bufferlen);
1940 GATE_UNUSED_ARG(bufferused);
1941 return GATE_RESULT_NOTIMPLEMENTED;
1942 }
1943 gate_result_t gate_socket_receive_from(gate_socket_t sock, gate_socket_endpoint_t* ep, char* buffer,
1944 gate_size_t bufferlen, gate_size_t* bufferused, gate_uint16_t flags)
1945 {
1946 GATE_UNUSED_ARG(sock);
1947 GATE_UNUSED_ARG(ep);
1948 GATE_UNUSED_ARG(buffer);
1949 GATE_UNUSED_ARG(bufferlen);
1950 GATE_UNUSED_ARG(bufferused);
1951 GATE_UNUSED_ARG(flags);
1952 return GATE_RESULT_NOTIMPLEMENTED;
1953 }
1954 gate_result_t gate_socket_send(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
1955 {
1956 GATE_UNUSED_ARG(sock);
1957 GATE_UNUSED_ARG(buffer);
1958 GATE_UNUSED_ARG(bufferlen);
1959 GATE_UNUSED_ARG(bufferprocessed);
1960 return GATE_RESULT_NOTIMPLEMENTED;
1961 }
1962 gate_result_t gate_socket_send_block(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
1963 {
1964 GATE_UNUSED_ARG(sock);
1965 GATE_UNUSED_ARG(buffer);
1966 GATE_UNUSED_ARG(bufferlen);
1967 GATE_UNUSED_ARG(bufferprocessed);
1968 return GATE_RESULT_NOTIMPLEMENTED;
1969 }
1970 gate_result_t gate_socket_send_to(gate_socket_t sock, gate_socket_endpoint_t const* to, char const* buffer,
1971 gate_size_t bufferlen, gate_size_t* bufferprocessed, gate_uint16_t flags)
1972 {
1973 GATE_UNUSED_ARG(sock);
1974 GATE_UNUSED_ARG(to);
1975 GATE_UNUSED_ARG(buffer);
1976 GATE_UNUSED_ARG(bufferlen);
1977 GATE_UNUSED_ARG(bufferprocessed);
1978 GATE_UNUSED_ARG(flags);
1979 return GATE_RESULT_NOTIMPLEMENTED;
1980 }
1981 gate_result_t gate_socket_select(gate_socket_t const* socks, gate_size_t sockcount, gate_uint8_t* statusflags, gate_uint32_t timeout)
1982 {
1983 GATE_UNUSED_ARG(socks);
1984 GATE_UNUSED_ARG(sockcount);
1985 GATE_UNUSED_ARG(statusflags);
1986 GATE_UNUSED_ARG(timeout);
1987 return GATE_RESULT_NOTIMPLEMENTED;
1988 }
1989 gate_result_t gate_socket_shutdown(gate_socket_t sock, gate_bool_t shutdownreceive, gate_bool_t shutdownsend)
1990 {
1991 GATE_UNUSED_ARG(sock);
1992 GATE_UNUSED_ARG(shutdownreceive);
1993 GATE_UNUSED_ARG(shutdownsend);
1994 return GATE_RESULT_NOTIMPLEMENTED;
1995 }
1996 gate_result_t gate_socket_close(gate_socket_t sock)
1997 {
1998 GATE_UNUSED_ARG(sock);
1999 return GATE_RESULT_NOTIMPLEMENTED;
2000 }
2001 gate_result_t gate_socket_get_option(gate_socket_t sock, gate_int32_t level, gate_int32_t option, void* buffer, gate_size_t* bufferlen)
2002 {
2003 GATE_UNUSED_ARG(sock);
2004 GATE_UNUSED_ARG(level);
2005 GATE_UNUSED_ARG(option);
2006 GATE_UNUSED_ARG(buffer);
2007 GATE_UNUSED_ARG(bufferlen);
2008 return GATE_RESULT_NOTIMPLEMENTED;
2009 }
2010 gate_result_t gate_socket_set_option(gate_socket_t sock, gate_int32_t level, gate_int32_t option, void const* buffer, gate_size_t bufferlen)
2011 {
2012 GATE_UNUSED_ARG(sock);
2013 GATE_UNUSED_ARG(level);
2014 GATE_UNUSED_ARG(option);
2015 GATE_UNUSED_ARG(buffer);
2016 GATE_UNUSED_ARG(bufferlen);
2017 return GATE_RESULT_NOTIMPLEMENTED;
2018 }
2019 gate_result_t gate_socket_get_local_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
2020 {
2021 GATE_UNUSED_ARG(sock);
2022 GATE_UNUSED_ARG(ep);
2023 return GATE_RESULT_NOTIMPLEMENTED;
2024 }
2025 gate_result_t gate_socket_get_local_address(gate_socket_t sock, gate_string_t* address)
2026 {
2027 GATE_UNUSED_ARG(sock);
2028 GATE_UNUSED_ARG(address);
2029 return GATE_RESULT_NOTIMPLEMENTED;
2030 }
2031 gate_result_t gate_socket_get_remote_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
2032 {
2033 GATE_UNUSED_ARG(sock);
2034 GATE_UNUSED_ARG(ep);
2035 return GATE_RESULT_NOTIMPLEMENTED;
2036 }
2037 gate_result_t gate_socket_get_remote_address(gate_socket_t sock, gate_string_t* address)
2038 {
2039 GATE_UNUSED_ARG(sock);
2040 GATE_UNUSED_ARG(address);
2041 return GATE_RESULT_NOTIMPLEMENTED;
2042 }
2043 gate_result_t gate_socket_parse_address(gate_string_t const* address, gate_string_t* host, gate_uint16_t* port, gate_int16_t* family)
2044 {
2045 GATE_UNUSED_ARG(address);
2046 GATE_UNUSED_ARG(host);
2047 GATE_UNUSED_ARG(port);
2048 GATE_UNUSED_ARG(family);
2049 return GATE_RESULT_NOTIMPLEMENTED;
2050 }
2051 gate_result_t gate_socket_parse_endpoint(gate_string_t const* address, gate_socket_endpoint_t* endpoint)
2052 {
2053 GATE_UNUSED_ARG(address);
2054 GATE_UNUSED_ARG(endpoint);
2055 return GATE_RESULT_NOTIMPLEMENTED;
2056 }
2057 gate_result_t gate_socket_print_endpoint(gate_socket_endpoint_t const* endpoint, gate_string_t* address)
2058 {
2059 GATE_UNUSED_ARG(endpoint);
2060 GATE_UNUSED_ARG(address);
2061 return GATE_RESULT_NOTIMPLEMENTED;
2062 }
2063
2064 gate_result_t gate_socket_set(gate_socket_t sock, GATE_SOCKET_OPTION option, gate_int32_t value)
2065 {
2066 GATE_UNUSED_ARG(sock);
2067 GATE_UNUSED_ARG(option);
2068 GATE_UNUSED_ARG(value);
2069 return GATE_RESULT_NOTIMPLEMENTED;
2070 }
2071
2072 gate_result_t gate_socket_parse_ip4(gate_string_t const* ip4text, gate_socket_ip4address_t* ip4address)
2073 {
2074 GATE_UNUSED_ARG(ip4text);
2075 GATE_UNUSED_ARG(ip4address);
2076 return GATE_RESULT_NOTIMPLEMENTED;
2077 }
2078
2079 gate_result_t gate_socket_parse_ip6(gate_string_t const* ip6text, gate_socket_ip6address_t* ip6address)
2080 {
2081 GATE_UNUSED_ARG(ip6text);
2082 GATE_UNUSED_ARG(ip6address);
2083 return GATE_RESULT_NOTIMPLEMENTED;
2084 }
2085
2086 gate_result_t gate_socket_load_endpoint(void const* ptr_in_native_sock_addr, gate_socket_endpoint_t* ptr_out_endpoint)
2087 {
2088 GATE_UNUSED_ARG(ptr_in_native_sock_addr);
2089 GATE_UNUSED_ARG(ptr_out_endpoint);
2090 return GATE_RESULT_NOTIMPLEMENTED;
2091 }
2092 gate_result_t gate_socket_save_endpoint(gate_socket_endpoint_t const* ptr_src_endpoint, void* ptr_out_native_sock_addr, gate_size_t* ptr_out_native_sock_addr_len)
2093 {
2094 GATE_UNUSED_ARG(ptr_src_endpoint);
2095 GATE_UNUSED_ARG(ptr_out_native_sock_addr);
2096 GATE_UNUSED_ARG(ptr_out_native_sock_addr_len);
2097 return GATE_RESULT_NOTIMPLEMENTED;
2098 }
2099
2100 #endif /* GATE_NET_SOCKETS_NOIMPL */
2101
2102