GCC Code Coverage Report

Directory: src/gate/
File: src/gate/net/sockets.c
Date: 2025-12-12 23:40:09
Exec Total Coverage
Lines: 500 662 75.5%
Functions: 39 41 95.1%
Branches: 157 292 53.8%
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 68 int gate_compare_socket(void const* item1, void const* item2)
45 {
46 68 gate_socket_t const* sock1 = (gate_socket_t const*)item1;
47 68 gate_socket_t const* sock2 = (gate_socket_t const*)item2;
48
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 38 times.
 68 if (*sock1 == *sock2)
49 {
50 30 return 0;
51 }
52
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 36 times.
 38 else if (*sock1 < *sock2)
53 {
54 2 return -1;
55 }
56 else
57 {
58 36 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 11 static gate_result_t gate_socket_set_blocking(gate_socket_t sock, gate_bool_t blocking)
143 {
144 gate_result_t ret;
145 11 sock_fd_t s = (sock_fd_t)sock;
146 11 long flags = fcntl(s, F_GETFL, NULL);
147
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (-1 == flags)
148 {
149 ✗ ret = GATE_RESULT_FAILED;
150 }
151 else
152 {
153
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 5 times.
 11 if (blocking)
154 {
155 6 flags &= ~(long)O_NONBLOCK;
156 }
157 else
158 {
159 5 flags |= O_NONBLOCK;
160 }
161
162
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
 11 if (-1 == fcntl(s, F_SETFL, flags))
163 {
164 ✗ ret = GATE_RESULT_FAILED;
165 }
166 else
167 {
168 11 ret = GATE_RESULT_OK;
169 }
170 }
171 11 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 28 gate_result_t gate_socket_init()
197 {
198 28 gate_result_t ret = gate_socket_api_load(&api);
199 28 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 8 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 5 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.
 8 switch (type)
225 {
226 5 case GATE_SOCKET_TYPE_TCP4:
227 {
228 5 ret = gate_socket_create_ex(GATE_SOCKET_FAMILY_INET4, GATE_SOCKET_MSGTYPE_STREAM, GATE_SOCKET_PROTOCOL_TCP, sock);
229 5 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 8 return ret;
262 }
263
264 #ifndef AF_BTH
265 # define AF_BTH 32
266 #endif
267
268 21 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 gate_result_t ret;
271
272 21 ret = gate_socket_init();
273
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
 21 if (GATE_FAILED(ret))
274 {
275 ✗ return ret;
276 }
277 21 ret = gate_socket_session_init();
278
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
 21 if (GATE_FAILED(ret))
279 {
280 ✗ return ret;
281 }
282
283
284 do
285 {
286 int af;
287 int type;
288 int proto;
289 int tmp;
290 sock_fd_t s;
291
292
2/8
✗ Branch 0 not taken.
✓ Branch 1 taken 17 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.
 21 switch (family)
293 {
294 ✗ case GATE_SOCKET_FAMILY_UNIX: af = AF_UNIX; break;
295 17 case GATE_SOCKET_FAMILY_INET4: af = AF_INET; break;
296 ✗ case GATE_SOCKET_FAMILY_IPX: af = AF_IPX; break;
297 ✗ case GATE_SOCKET_FAMILY_APPLETALK: af = AF_APPLETALK; break;
298 #if defined(AF_NETBIOS)
299 case GATE_SOCKET_FAMILY_NETBIOS: af = AF_NETBIOS; break;
300 #endif
301 #if defined(AF_ATM)
302 case GATE_SOCKET_FAMILY_ATM: af = AF_ATM; break;
303 #endif
304 #if defined(AF_INET6)
305 4 case GATE_SOCKET_FAMILY_INET6: af = AF_INET6; break;
306 #endif
307 #if defined(AF_IRDA)
308 ✗ case GATE_SOCKET_FAMILY_IRDA: af = AF_IRDA; break;
309 #endif
310 ✗ case GATE_SOCKET_FAMILY_BTH: af = AF_BTH; break;
311 ✗ default: af = -1; break;
312 }
313
314
2/4
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 21 switch (msgtype)
315 {
316 17 case GATE_SOCKET_MSGTYPE_STREAM: type = SOCK_STREAM; break;
317 4 case GATE_SOCKET_MSGTYPE_DATAGRAM: type = SOCK_DGRAM; break;
318 ✗ case GATE_SOCKET_MSGTYPE_RAW: type = SOCK_RAW; break;
319 ✗ default: type = -1; break;
320 }
321
322
3/8
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 11 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 21 switch (protocol)
323 {
324 6 case GATE_SOCKET_PROTOCOL_IP: proto = IPPROTO_IP; break;
325 ✗ case GATE_SOCKET_PROTOCOL_ICMP: proto = IPPROTO_ICMP; break;
326 #if defined(IPPROTO_IGMP)
327 ✗ case GATE_SOCKET_PROTOCOL_IGMP: proto = IPPROTO_IGMP; break;
328 #endif
329 11 case GATE_SOCKET_PROTOCOL_TCP: proto = IPPROTO_TCP; break;
330 4 case GATE_SOCKET_PROTOCOL_UDP: proto = IPPROTO_UDP; break;
331 #if defined(IPPROTO_IPV6)
332 ✗ case GATE_SOCKET_PROTOCOL_IP6: proto = IPPROTO_IPV6; break;
333 #endif
334 ✗ case GATE_SOCKET_PROTOCOL_ICMP6: proto = IPPROTO_ICMP; break;
335 ✗ default: proto = -1; break;
336 }
337
338
3/6
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 21 times.
 21 if ((af == -1) || (type == -1) || (proto == -1))
339 {
340 ✗ ret = GATE_RESULT_NOTSUPPORTED;
341 ✗ break;
342 }
343
344 21 s = api.sock_socket(af, type, proto);
345
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
 21 if (s == INVALID_SOCKET)
346 {
347 ✗ GATE_DEBUG_TRACE("socket() failed");
348 ✗ gate_socket_session_uninit();
349 ✗ ret = GATE_RESULT_NOTSUPPORTED;
350 ✗ break;
351 }
352
353 21 *sock = (gate_socket_t)s;
354
355 #if defined(GATE_SYS_WIN) && !defined(GATE_SYS_WINCE) && !defined(GATE_SYS_WINSTORE) && !defined(GATE_SYS_WIN16)
356 /* disable socket inheritage to child processes */
357 SetHandleInformation((HANDLE)s, HANDLE_FLAG_INHERIT, 0);
358 #endif
359
360 #if defined(SO_EXCLUSIVEADDRUSE)
361 /* Windows: disable SO_REUSEADDR on this socket */
362 tmp = 1;
363 api.sock_setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char*)&tmp, sizeof(tmp));
364 #endif
365
366 #if defined(IPV6_V6ONLY) && defined(IPPROTO_IPV6)
367
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 17 times.
 21 if (family == GATE_SOCKET_FAMILY_INET6)
368 {
369 /* disable automatic binding to IPv4 address, if IPv6 was specified */
370 4 tmp = 1;
371 4 api.sock_setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&tmp, sizeof(tmp));
372 }
373 #endif
374
375 } while (0);
376
377 #if defined(GATE_DEBUG_MODE)
378
1/2
✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
 21 if (GATE_SUCCEEDED(ret))
379 {
380 21 gate_int32_t sockets_created_counter = gate_atomic_int_inc(&sockets_created);
381 21 GATE_DEBUG_TRACE_VALUE(sockets_created_counter);
382 }
383 #endif
384 21 return ret;
385 }
386
387 17 static gate_size_t gate_socket_build_addr_ip4(gate_socket_ip4endpoint_t const* src, struct sockaddr_in* dst)
388 {
389 34 gate_uint32_t ip = ((gate_uint32_t)(src->address.item[0]) << 24)
390 17 | ((gate_uint32_t)(src->address.item[1]) << 16)
391 17 | ((gate_uint32_t)(src->address.item[2]) << 8)
392 17 | ((gate_uint32_t)(src->address.item[3]))
393 ;
394 17 gate_mem_clear(dst, sizeof(struct sockaddr_in));
395 17 dst->sin_family = AF_INET;
396 17 dst->sin_port = api.sock_htons(src->port);
397 17 dst->sin_addr.s_addr = api.sock_htonl(ip);
398 17 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 9 gate_result_t gate_socket_connect(gate_socket_t sock, gate_socket_endpoint_t const* ep)
460 {
461 9 gate_result_t ret = GATE_RESULT_FAILED;
462 9 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 9 times.
 9 if (ep == NULL)
467 {
468 ✗ ret = GATE_RESULT_INVALIDARG;
469 ✗ break;
470 }
471
2/3
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 9 switch (ep->family)
472 {
473 8 case GATE_SOCKET_FAMILY_INET4:
474 {
475 8 const sock_socklen_t addrlen = (sock_socklen_t)gate_socket_build_addr_ip4(&ep->ip4, &addr.addr4);
476
477
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 4 times.
 8 if (0 == api.sock_connect(s, (struct sockaddr const*)&addr.addr4, addrlen))
478 {
479 4 ret = GATE_RESULT_OK;
480 }
481 else
482 {
483
1/2
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
 4 if (SOCKET_ERROR_WOULDBLOCK == api.sock_errno())
484 {
485 4 ret = GATE_RESULT_OK;
486 }
487 else
488 {
489 ✗ GATE_DEBUG_TRACE("connect() failed");
490 }
491 }
492 8 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 9 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 11 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 8 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 11 switch (ep->family)
548 {
549 8 case GATE_SOCKET_FAMILY_INET4:
550 {
551 8 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 8 times.
 8 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 8 ret = GATE_RESULT_OK;
560 }
561 8 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 11 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 6 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 6 times.
 6 if (backlog == GATE_SOCKET_BACKLOG_DEFAULT)
606 {
607 ✗ backlog = SOMAXCONN;
608 }
609
610
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 if (0 != api.sock_listen((sock_fd_t)sock, (int)backlog))
611 {
612 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_listen() failed");
613 ✗ ret = GATE_RESULT_FAILED;
614 }
615 else
616 {
617 6 ret = GATE_RESULT_OK;
618 }
619 6 return ret;
620 }
621 7 gate_result_t gate_socket_accept(gate_socket_t sock, gate_socket_t* newsock)
622 {
623 gate_result_t ret;
624 7 sock_fd_t sockaccepted = api.sock_accept((sock_fd_t)sock, NULL, 0);
625
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
 7 if (sockaccepted == -1)
626 {
627 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_accept() failed");
628 ✗ ret = GATE_RESULT_FAILED;
629 }
630 else
631 {
632 7 ret = GATE_RESULT_OK;
633
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
 7 if (newsock == NULL)
634 {
635 ✗ api.sock_close(sockaccepted);
636 }
637 else
638 {
639 7 *newsock = (gate_socket_t)sockaccepted;
640 #if defined(GATE_DEBUG_MODE)
641
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
 7 if (GATE_SUCCEEDED(ret))
642 {
643 7 gate_int32_t sockets_created_counter = gate_atomic_int_inc(&sockets_created);
644 7 GATE_DEBUG_TRACE_VALUE(sockets_created_counter);
645 }
646 #endif
647 }
648 #if defined(GATE_SYS_WIN) && !defined(GATE_SYS_WINCE) && !defined(GATE_SYS_WINSTORE) && !defined(GATE_SYS_WIN16)
649 SetHandleInformation((HANDLE)sockaccepted, HANDLE_FLAG_INHERIT, 0);
650 #endif
651 }
652 7 return ret;
653 }
654 154 gate_result_t gate_socket_receive(gate_socket_t sock, char* buffer, gate_size_t bufferlen, gate_size_t* bufferused)
655 {
656 gate_result_t ret;
657
658 154 int received = api.sock_recv((sock_fd_t)sock, buffer, (socklen_t)bufferlen, 0);
659
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 154 times.
 154 if (received == -1)
660 {
661 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_recv() failed");
662 ✗ ret = GATE_RESULT_FAILED;
663 #if defined(GATE_SYS_WIN)
664 /* Windows may return errors in case of closed connections */
665 switch (api.sock_errno())
666 {
667 case WSAECONNRESET:
668 case WSAECONNABORTED:
669 case WSAESHUTDOWN:
670 {
671 /* equals End-Of-Stream, which is not an error */
672 if (bufferused != NULL)
673 {
674 *bufferused = 0;
675 }
676 ret = GATE_RESULT_OK;
677 }
678 }
679 #endif
680 }
681 else
682 {
683 154 ret = GATE_RESULT_OK;
684
1/2
✓ Branch 0 taken 154 times.
✗ Branch 1 not taken.
 154 if (bufferused != NULL)
685 {
686 154 *bufferused = (gate_size_t)received;
687 }
688 }
689 154 return ret;
690 }
691 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)
692 {
693 gate_result_t ret;
694 gate_socket_addr_storage_t addr;
695 2 socklen_t addrlen = sizeof(addr);
696 2 int fl = 0;
697 int received;
698
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_PEEK)) fl |= MSG_PEEK;
699
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_OOB)) fl |= MSG_OOB;
700
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_DONTROUTE)) fl |= MSG_DONTROUTE;
701 #if defined(MSG_WAITALL)
702
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_WAITALL)) fl |= MSG_WAITALL;
703 #endif
704 #if defined(MSG_EOR)
705
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_WAITALL)) fl |= MSG_EOR;
706 #endif
707 2 gate_mem_clear(&addr, sizeof(addr));
708 2 received = api.sock_recvfrom((sock_fd_t)sock, buffer, (socklen_t)bufferlen, fl, (struct sockaddr*)&addr, &addrlen);
709
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (received == -1)
710 {
711 ✗ ret = GATE_RESULT_FAILED;
712 #if defined(GATE_SYS_WIN)
713 /* Windows may return errors in case of closed connections */
714 switch (api.sock_errno())
715 {
716 case WSAECONNRESET:
717 case WSAECONNABORTED:
718 case WSAESHUTDOWN:
719 {
720 /* equals End-Of-Stream, which is not an error */
721 if (bufferused != NULL)
722 {
723 *bufferused = 0;
724 }
725 ret = GATE_RESULT_OK;
726 }
727 }
728 #endif
729 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_recvfrom() failed");
730 }
731 else
732 {
733 2 ret = GATE_RESULT_OK;
734
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (bufferused != NULL)
735 {
736 2 *bufferused = (gate_size_t)received;
737 }
738
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (ep != NULL)
739 {
740 2 gate_socket_load_endpoint(&addr.addr, ep);
741 }
742 }
743
744 2 return ret;
745 }
746 14 gate_result_t gate_socket_send(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
747 {
748 gate_result_t ret;
749 int sentbytes;
750
751 #if defined(GATE_SYS_POSIX)
752 gate_posix_sigblocker_t blocker;
753 14 gate_posix_block_signals(&blocker, SIGPIPE, 0);
754 #endif
755
756 14 sentbytes = api.sock_send((sock_fd_t)sock, buffer, (socklen_t)bufferlen, 0);
757
758 #if defined(GATE_SYS_POSIX)
759 14 gate_posix_unblock_signals(&blocker);
760 #endif
761
762
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
 14 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 14 ret = GATE_RESULT_OK;
771
1/2
✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
 14 if (bufferprocessed != NULL)
772 {
773 14 *bufferprocessed = (gate_size_t)sentbytes;
774 }
775 }
776
777 14 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
802 #if defined(GATE_SYS_POSIX)
803 gate_posix_sigblocker_t blocker;
804 2 gate_posix_block_signals(&blocker, SIGPIPE, 0);
805 #endif
806
807 do
808 {
809 int sentbytes;
810 gate_socket_addr_storage_t addr;
811 2 gate_size_t addrlen = 0;
812 2 int fl = 0;
813
814
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_DONTROUTE)) fl |= MSG_DONTROUTE;
815
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (GATE_FLAG_ENABLED(flags, GATE_SOCKET_FLAG_OOB)) fl |= MSG_OOB;
816
817
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (to == NULL)
818 {
819 ✗ ret = GATE_RESULT_INVALIDARG;
820 ✗ break;
821 }
822
823 2 ret = gate_socket_save_endpoint(to, &addr.addr, &addrlen);
824
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 GATE_BREAK_IF_FAILED(ret);
825
826 2 sentbytes = api.sock_sendto((sock_fd_t)sock, buffer, (socklen_t)bufferlen, fl,
827 &addr.addr, (sock_socklen_t)addrlen);
828
829
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (sentbytes == -1)
830 {
831 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_sendto() failed");
832 ✗ ret = GATE_RESULT_FAILED;
833 }
834 else
835 {
836 2 ret = GATE_RESULT_OK;
837
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (bufferprocessed != NULL)
838 {
839 2 *bufferprocessed = (gate_size_t)sentbytes;
840 }
841 }
842 } while (0);
843
844 #if defined(GATE_SYS_POSIX)
845 2 gate_posix_unblock_signals(&blocker);
846 #endif
847
848 2 return ret;
849 }
850 38 static int gate_socket_get_nfds(sock_fd_t highest_socket_id)
851 {
852 #if defined(GATE_SYS_WIN)
853 GATE_UNUSED_ARG(highest_socket_id);
854 return 0;
855 #else
856 38 return (int)(highest_socket_id + 1);
857 #endif
858 }
859 38 gate_result_t gate_socket_select(gate_socket_t const* socks, gate_size_t sockcount, gate_uint8_t* statusflags, gate_uint32_t timeout)
860 {
861 gate_result_t ret;
862 TIMEVAL to;
863 gate_size_t ndx;
864 fd_set fds_read;
865 fd_set fds_write;
866 fd_set fds_except;
867 38 sock_fd_t highestsocket = 0;
868
869 #if defined(GATE_SYS_POSIX)
870 gate_posix_sigblocker_t blocker;
871 38 gate_posix_block_signals(&blocker, SIGPIPE, 0);
872 #endif
873
874 38 FD_ZERO(&fds_read);
875 38 FD_ZERO(&fds_write);
876 38 FD_ZERO(&fds_except);
877
878 38 to.tv_sec = timeout / 1000;
879 38 to.tv_usec = (timeout % 1000) * 1000;
880
881
2/2
✓ Branch 0 taken 96 times.
✓ Branch 1 taken 38 times.
 134 for (ndx = 0; ndx < sockcount; ++ndx)
882 {
883
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 46 times.
 96 if (highestsocket < (sock_fd_t)socks[ndx])
884 {
885 50 highestsocket = (sock_fd_t)socks[ndx];
886 }
887
2/2
✓ Branch 0 taken 86 times.
✓ Branch 1 taken 10 times.
 96 if (GATE_FLAG_ENABLED(statusflags[ndx], GATE_SOCKET_SELECT_FLAG_RECEIVE))
888 {
889 86 FD_SET((sock_fd_t)socks[ndx], &fds_read);
890 }
891
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 80 times.
 96 if (GATE_FLAG_ENABLED(statusflags[ndx], GATE_SOCKET_SELECT_FLAG_SEND))
892 {
893 16 FD_SET((sock_fd_t)socks[ndx], &fds_write);
894 }
895
1/2
✓ Branch 0 taken 96 times.
✗ Branch 1 not taken.
 96 if (GATE_FLAG_ENABLED(statusflags[ndx], GATE_SOCKET_SELECT_FLAG_ERROR))
896 {
897 96 FD_SET((sock_fd_t)socks[ndx], &fds_except);
898 }
899 }
900
901
1/2
✗ Branch 2 not taken.
✓ Branch 3 taken 38 times.
 38 if (-1 == api.sock_select(gate_socket_get_nfds(highestsocket), &fds_read, &fds_write, &fds_except, &to))
902 {
903 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_select() failed");
904 ✗ ret = GATE_RESULT_FAILED;
905 }
906 else
907 {
908 38 ret = GATE_RESULT_OK;
909
2/2
✓ Branch 0 taken 96 times.
✓ Branch 1 taken 38 times.
 134 for (ndx = 0; ndx < sockcount; ++ndx)
910 {
911 96 gate_uint8_t tmp = 0;
912
2/2
✓ Branch 1 taken 41 times.
✓ Branch 2 taken 55 times.
 96 if (api.sock_isset((sock_fd_t)socks[ndx], &fds_read))
913 {
914 41 tmp |= GATE_SOCKET_SELECT_FLAG_RECEIVE;
915 }
916
2/2
✓ Branch 1 taken 14 times.
✓ Branch 2 taken 82 times.
 96 if (api.sock_isset((sock_fd_t)socks[ndx], &fds_write))
917 {
918 14 tmp |= GATE_SOCKET_SELECT_FLAG_SEND;
919 }
920
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 96 times.
 96 if (api.sock_isset((sock_fd_t)socks[ndx], &fds_except))
921 {
922 ✗ tmp |= GATE_SOCKET_SELECT_FLAG_ERROR;
923 }
924 96 statusflags[ndx] = tmp;
925 }
926 }
927
928 #if defined(GATE_SYS_POSIX)
929 38 gate_posix_unblock_signals(&blocker);
930 #endif
931
932 38 return ret;
933 }
934
935 10 gate_result_t gate_socket_shutdown(gate_socket_t sock, gate_bool_t shutdownreceive, gate_bool_t shutdownsend)
936 {
937 gate_result_t ret;
938
939 do
940 {
941 10 int sh = 0;
942
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 10 if (shutdownreceive && shutdownsend)
943 {
944 ✗ sh = SD_BOTH;
945 }
946
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 else if (shutdownreceive)
947 {
948 ✗ sh = SD_RECEIVE;
949 }
950
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
 10 else if (shutdownsend)
951 {
952 10 sh = SD_SEND;
953 }
954 else
955 {
956 ✗ ret = GATE_RESULT_INVALIDARG;
957 ✗ break;
958 }
959
960
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
 10 if (0 != api.sock_shutdown((sock_fd_t)sock, sh))
961 {
962 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_shutdown() failed");
963 ✗ ret = GATE_RESULT_FAILED;
964 }
965 else
966 {
967 10 ret = GATE_RESULT_OK;
968 }
969 } while (0);
970
971 10 return ret;
972 }
973 24 gate_result_t gate_socket_close(gate_socket_t sock)
974 {
975 24 gate_result_t ret = GATE_RESULT_INVALIDARG;
976
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 if (sock != GATE_SOCKET_INVALID)
977 {
978
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
 24 if (-1 == api.sock_close((sock_fd_t)sock))
979 {
980 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_close() failed");
981 ✗ ret = GATE_RESULT_FAILED;
982 }
983 else
984 {
985 24 ret = GATE_RESULT_OK;
986 #if defined(GATE_DEBUG_MODE)
987
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 if (GATE_SUCCEEDED(ret))
988 {
989 24 gate_int32_t sockets_released_counter = gate_atomic_int_inc(&sockets_released);
990 24 GATE_DEBUG_TRACE_VALUE(sockets_released_counter);
991 }
992 #endif
993 }
994 }
995 24 return ret;
996 }
997 3 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)
998 {
999 gate_result_t ret;
1000 socklen_t len;
1001 do
1002 {
1003
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (bufferlen == NULL)
1004 {
1005 ✗ len = 0;
1006 }
1007 else
1008 {
1009 3 len = (socklen_t)*bufferlen;
1010 }
1011
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
 3 if (-1 == api.sock_getsockopt((sock_fd_t)sock, (int)level, (int)option, (char*)buffer, &len))
1012 {
1013 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_getsockopt() failed");
1014 ✗ ret = GATE_RESULT_FAILED;
1015 }
1016 else
1017 {
1018 3 ret = GATE_RESULT_OK;
1019 }
1020
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (bufferlen != NULL)
1021 {
1022 3 *bufferlen = (gate_size_t)len;
1023 }
1024 } while (0);
1025 3 return ret;
1026 }
1027 3 gate_result_t gate_socket_has_error(gate_socket_t sock, gate_bool_t* ptr_errorflag)
1028 {
1029 3 int err_code = 0;
1030 3 gate_size_t err_code_size = sizeof(err_code);
1031 3 gate_result_t result = gate_socket_get_option(sock, SOL_SOCKET, SO_ERROR, &err_code, &err_code_size);
1032
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 if (GATE_SUCCEEDED(result) && (ptr_errorflag != NULL))
1033 {
1034 3 *ptr_errorflag = err_code != 0;
1035 }
1036 3 return result;
1037 }
1038
1039 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)
1040 {
1041 gate_result_t ret;
1042
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))
1043 {
1044 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_setsockopt()");
1045 ✗ ret = GATE_RESULT_FAILED;
1046 }
1047 else
1048 {
1049 8 ret = GATE_RESULT_OK;
1050 }
1051 8 return ret;
1052 }
1053 19 gate_result_t gate_socket_set(gate_socket_t sock, GATE_SOCKET_OPTION option, gate_int32_t value)
1054 {
1055 gate_int32_t level;
1056 gate_int32_t opt;
1057 19 void* ptr = NULL;
1058 19 gate_size_t len = 0;
1059 19 int opt_val = 0;
1060 #if !defined(GATE_SYS_WIN)
1061 TIMEVAL opt_tv;
1062 #endif
1063
1064
3/7
✓ Branch 0 taken 11 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.
 19 switch (option)
1065 {
1066 11 case GATE_SOCKET_OPTION_BLOCKING:
1067 {
1068 11 return gate_socket_set_blocking(sock, value ? true : false);
1069 }
1070 ✗ case GATE_SOCKET_OPTION_TCPNODELAY:
1071 {
1072 ✗ level = IPPROTO_TCP;
1073 ✗ opt = TCP_NODELAY;
1074 ✗ opt_val = value ? 1 : 0;
1075 ✗ ptr = &opt_val;
1076 ✗ len = sizeof(opt_val);
1077 ✗ break;
1078 }
1079 ✗ case GATE_SOCKET_OPTION_KEEPALIVE:
1080 {
1081 ✗ level = SOL_SOCKET;
1082 ✗ opt = SO_KEEPALIVE;
1083 ✗ opt_val = value ? 1 : 0;
1084 ✗ ptr = &opt_val;
1085 ✗ len = sizeof(opt_val);
1086 ✗ break;
1087 }
1088 ✗ case GATE_SOCKET_OPTION_BROADCAST:
1089 {
1090 ✗ level = SOL_SOCKET;
1091 ✗ opt = SO_BROADCAST;
1092 ✗ opt_val = value ? 1 : 0;
1093 ✗ ptr = &opt_val;
1094 ✗ len = sizeof(opt_val);
1095 ✗ break;
1096 }
1097 5 case GATE_SOCKET_OPTION_RECEIVETIMEOUT:
1098 {
1099 5 level = SOL_SOCKET;
1100 5 opt = SO_RCVTIMEO;
1101 #if defined(GATE_SYS_WIN)
1102 opt_val = value;
1103 ptr = &opt_val;
1104 len = sizeof(opt_val);
1105 #else
1106 5 opt_tv.tv_usec = (value % 1000) * 1000;
1107 5 opt_tv.tv_sec = value / 1000;
1108 5 ptr = &opt_tv;
1109 5 len = sizeof(opt_tv);
1110 #endif
1111 5 break;
1112 }
1113 3 case GATE_SOCKET_OPTION_SENDTIMEOUT:
1114 {
1115 3 level = SOL_SOCKET;
1116 3 opt = SO_SNDTIMEO;
1117 #if defined(GATE_SYS_WIN)
1118 opt_val = value;
1119 ptr = &opt_val;
1120 len = sizeof(opt_val);
1121 #else
1122 3 opt_tv.tv_usec = (value % 1000) * 1000;
1123 3 opt_tv.tv_sec = value / 1000;
1124 3 ptr = &opt_tv;
1125 3 len = sizeof(opt_tv);
1126 #endif
1127 3 break;
1128 }
1129 ✗ default:
1130 {
1131 ✗ return GATE_RESULT_NOTSUPPORTED;
1132 }
1133 }
1134
1135 8 return gate_socket_set_option(sock, level, opt, ptr, len);
1136 }
1137
1138 2 gate_result_t gate_socket_get_local_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
1139 {
1140 gate_result_t ret;
1141 gate_socket_addr_storage_t addr;
1142 2 socklen_t addrlen = sizeof(addr);
1143
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (ep == NULL)
1144 {
1145 ✗ ret = GATE_RESULT_INVALIDARG;
1146 }
1147 else
1148 {
1149
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if (0 != api.sock_getsockname((sock_fd_t)sock, &addr.addr, &addrlen))
1150 {
1151 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_getsockname() failed");
1152 ✗ ret = GATE_RESULT_FAILED;
1153 }
1154 else
1155 {
1156 2 ret = gate_socket_load_endpoint(&addr.addr, ep);
1157 }
1158 }
1159 2 return ret;
1160 }
1161 2 gate_result_t gate_socket_get_local_address(gate_socket_t sock, gate_string_t* address)
1162 {
1163 gate_result_t ret;
1164 gate_socket_endpoint_t ep;
1165 2 ret = gate_socket_get_local_endpoint(sock, &ep);
1166
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (GATE_SUCCEEDED(ret))
1167 {
1168 2 ret = gate_socket_print_endpoint(&ep, address);
1169 }
1170 2 return ret;
1171 }
1172 2 gate_result_t gate_socket_get_remote_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
1173 {
1174 gate_result_t ret;
1175 gate_socket_addr_storage_t addr;
1176 2 socklen_t addrlen = sizeof(addr);
1177
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (ep == NULL)
1178 {
1179 ✗ ret = GATE_RESULT_INVALIDARG;
1180 }
1181 else
1182 {
1183
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if (0 != api.sock_getpeername((sock_fd_t)sock, &addr.addr, &addrlen))
1184 {
1185 ✗ GATE_DEBUG_TRACE_PLATFORM_ERROR("sock_getpeername() failed");
1186 ✗ ret = GATE_RESULT_FAILED;
1187 }
1188 else
1189 {
1190 2 ret = gate_socket_load_endpoint(&addr.addr, ep);
1191 }
1192 }
1193 2 return ret;
1194 }
1195 2 gate_result_t gate_socket_get_remote_address(gate_socket_t sock, gate_string_t* address)
1196 {
1197 gate_result_t ret;
1198 gate_socket_endpoint_t ep;
1199 2 ret = gate_socket_get_remote_endpoint(sock, &ep);
1200
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (GATE_SUCCEEDED(ret))
1201 {
1202 2 ret = gate_socket_print_endpoint(&ep, address);
1203 }
1204 2 return ret;
1205 }
1206
1207 static gate_string_t const ipv6_begin = GATE_STRING_INIT_STATIC("[");
1208 static gate_string_t const ipv6_end = GATE_STRING_INIT_STATIC("]");
1209 static gate_string_t const ip_any = GATE_STRING_INIT_STATIC("*");
1210 static gate_string_t const ip6_any = GATE_STRING_INIT_STATIC("::");
1211 static gate_string_t const ip_port_separator = GATE_STRING_INIT_STATIC(":");
1212
1213 15 gate_result_t gate_socket_parse_ip4(gate_string_t const* ip4text, gate_socket_ip4address_t* ip4address)
1214 {
1215 15 gate_result_t ret = GATE_RESULT_FAILED;
1216 gate_size_t start, ndx, pos;
1217 gate_uint64_t num;
1218
1219 do
1220 {
1221
2/4
✓ Branch 1 taken 15 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 15 times.
 15 if (gate_string_equals(ip4text, &ip_any) || gate_string_is_empty(ip4text))
1222 {
1223 /* ANY-IP -> "0.0.0.0", already set by gate_mem_clear() */
1224 ✗ ret = GATE_RESULT_OK;
1225 ✗ break;
1226 }
1227
1228 15 start = 0;
1229
2/2
✓ Branch 0 taken 45 times.
✓ Branch 1 taken 15 times.
 60 for (ndx = 0; ndx != 3; ++ndx)
1230 {
1231 45 pos = gate_string_char_pos(ip4text, '.', start);
1232
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 45 times.
 45 if (pos == GATE_STR_NPOS)
1233 {
1234 ✗ break;
1235 }
1236
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 45 times.
 45 if (0 == gate_str_parse_uint64(ip4text->str + start, ip4text->length - pos, &num))
1237 {
1238 /* failed to parse number */
1239 ✗ ret = GATE_RESULT_INVALIDINPUT;
1240 ✗ pos = GATE_STR_NPOS;
1241 ✗ break;
1242 }
1243 45 ip4address->item[ndx] = (gate_uint8_t)num;
1244 45 start = pos + 1;
1245 }
1246
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
 15 if (pos == GATE_STR_NPOS) break;
1247
1248 15 gate_str_parse_uint64(ip4text->str + start, ip4text->length - start, &num);
1249 15 ip4address->item[ndx] = (gate_uint8_t)num;
1250
1251 15 ret = GATE_RESULT_OK;
1252 } while (0);
1253
1254 15 return ret;
1255 }
1256
1257 8 gate_result_t gate_socket_parse_ip6(gate_string_t const* ip6text, gate_socket_ip6address_t* ip6address)
1258 {
1259 8 gate_result_t ret = GATE_RESULT_FAILED;
1260 8 gate_string_t ip = GATE_STRING_INIT_EMPTY;
1261 gate_size_t ndx;
1262 gate_size_t pos, start;
1263 gate_uint64_t num;
1264
1265 do
1266 {
1267 8 gate_mem_clear(ip6address, sizeof(gate_socket_ip6address_t));
1268
1269
1/4
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 8 if (gate_string_starts_with(ip6text, &ipv6_begin) && gate_string_ends_with(ip6text, &ipv6_end))
1270 {
1271 ✗ gate_string_substr(&ip, ip6text, 1, ip6text->length - 2);
1272 }
1273 else
1274 {
1275 8 gate_string_duplicate(&ip, ip6text);
1276 }
1277
1278
3/6
✓ Branch 1 taken 8 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 8 times.
 8 if (gate_string_equals(&ip, &ip_any) || gate_string_equals(&ip, &ip6_any) || gate_string_is_empty(&ip))
1279 {
1280 /* ANY-IP -> "[::]", already set by gate_mem_clear() */
1281 ✗ ret = GATE_RESULT_OK;
1282 ✗ break;
1283 }
1284 8 start = 0;
1285
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 2 times.
 22 for (ndx = 0; ndx != 7; ++ndx)
1286 {
1287 20 pos = gate_string_char_pos(&ip, ':', start);
1288
4/4
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 4 times.
 20 if ((pos == GATE_STR_NPOS) || (pos == start))
1289 {
1290 break;
1291 }
1292 14 gate_str_parse_hex_int(ip.str + start, ip.length - pos, &num);
1293 14 ip6address->item[ndx] = (gate_uint16_t)num;
1294 14 start = pos + 1;
1295 }
1296
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 6 times.
 8 if (pos == GATE_STR_NPOS)
1297 {
1298 2 GATE_DEBUG_TRACE("Invalid IPv6 address");
1299 2 break;
1300 }
1301
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
 6 if (pos == start)
1302 {
1303 /* double-colon detected */
1304
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 for (ndx = 0; ndx != 7; ++ndx)
1305 {
1306 8 pos = gate_string_char_pos_last(&ip, ':');
1307
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (pos == GATE_STR_NPOS) break;
1308
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
 8 if (pos == ip.length - 1) break; /* double-colon reached */
1309 4 gate_str_parse_hex_int(ip.str + pos + 1, ip.length - pos - 1, &num);
1310 4 ip6address->item[7 - ndx] = (gate_uint16_t)num;
1311 /* r-trim extracted data from ip-address string: */
1312 4 gate_string_substr(&ip, &ip, 0, pos);
1313 }
1314 }
1315 else
1316 {
1317 /* extract last ip number */
1318 2 gate_str_parse_uint64(ip.str + start, ip.length - start, &num);
1319 2 ip6address->item[ndx] = (gate_uint16_t)num;
1320 }
1321 6 ret = GATE_RESULT_OK;
1322
1323 } while (0);
1324
1325 8 gate_string_release(&ip);
1326
1327 8 return ret;
1328 }
1329
1330
1331
1332 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)
1333 {
1334 1 gate_result_t ret = GATE_RESULT_INVALIDDATA;
1335 gate_size_t pos;
1336 1 gate_string_t address_ip = GATE_STRING_INIT_EMPTY;
1337 1 gate_string_t tail = GATE_STRING_INIT_EMPTY;
1338 1 gate_uint64_t address_port = 0;
1339 gate_size_t len;
1340
1341 do
1342 {
1343
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if (gate_string_starts_with(address, &ipv6_begin))
1344 {
1345 /* IP v6 */
1346 ✗ pos = gate_string_pos(address, &ipv6_end, 1);
1347 ✗ if (GATE_STR_NPOS == pos)
1348 {
1349 ✗ break;
1350 }
1351 ✗ gate_string_substr(&address_ip, address, 0, pos + 1);
1352 ✗ gate_string_substr(&tail, address, pos + 1, GATE_STR_NPOS);
1353 ✗ if (family)
1354 {
1355 ✗ *family = GATE_SOCKET_FAMILY_INET6;
1356 }
1357 }
1358 else
1359 {
1360 /* IP v4 */
1361 1 pos = gate_string_find_last_of(address, &ip_port_separator);
1362
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (pos == GATE_STR_NPOS)
1363 {
1364 1 gate_string_duplicate(&address_ip, address);
1365 }
1366 else
1367 {
1368 ✗ gate_string_substr(&address_ip, address, 0, pos);
1369 ✗ gate_string_substr(&tail, address, pos, GATE_STR_NPOS);
1370 }
1371
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (family)
1372 {
1373 1 *family = GATE_SOCKET_FAMILY_INET4;
1374 }
1375 }
1376
1377
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 if (gate_string_is_empty(&tail))
1378 {
1379 1 address_port = 0;
1380 }
1381 else
1382 {
1383 ✗ if (!gate_string_starts_with(&tail, &ip_port_separator))
1384 {
1385 ✗ break;
1386 }
1387 else
1388 {
1389 ✗ gate_string_substr(&tail, &tail, 1, GATE_STR_NPOS);
1390 ✗ len = gate_string_parse_uint(&tail, &address_port);
1391 ✗ if (len != gate_string_length(&tail))
1392 {
1393 ✗ break;
1394 }
1395 }
1396 }
1397
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (host)
1398 {
1399 1 gate_string_duplicate(host, &address_ip);
1400 }
1401
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (port)
1402 {
1403 1 *port = (gate_uint16_t)address_port;
1404 }
1405 1 ret = GATE_RESULT_OK;
1406 } while (0);
1407
1408 1 gate_string_release(&tail);
1409 1 gate_string_release(&address_ip);
1410 1 return ret;
1411 }
1412
1413
1414 19 gate_result_t gate_socket_parse_endpoint(gate_string_t const* address, gate_socket_endpoint_t* endpoint)
1415 {
1416 19 gate_result_t ret = GATE_RESULT_INVALIDDATA;
1417 gate_size_t pos, len;
1418 19 gate_uint64_t num = 0;
1419 19 gate_string_t ip = GATE_STRING_INIT_EMPTY;
1420 do
1421 {
1422 /* address format is "IP:PORT",
1423 * eg. "1.2.3.4:8080" or "[1:2:a:b:c:d:e:f]:8080"
1424 */
1425 19 gate_mem_clear(endpoint, sizeof(gate_socket_endpoint_t));
1426
1427 19 pos = gate_str_char_pos_last(address->str, address->length, ':');
1428
2/4
✓ Branch 0 taken 19 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19 times.
 19 if ((pos == GATE_STR_NPOS) || (pos == address->length - 1))
1429 {
1430 ✗ GATE_DEBUG_TRACE("Invalid endpoint: No port suffix");
1431 ✗ break;
1432 }
1433
1434 19 len = address->length - pos - 1;
1435
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
 19 if (len != gate_str_parse_uint64(address->str + pos + 1, len, &num))
1436 {
1437 ✗ GATE_DEBUG_TRACE("Invalid endpoint: Invalid port format");
1438 ✗ break;
1439 }
1440
1441
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 19 times.
 19 if (NULL == gate_string_substr(&ip, address, 0, pos))
1442 {
1443 ✗ ret = GATE_RESULT_OUTOFMEMORY;
1444 ✗ break;
1445 }
1446
1447
3/4
✓ Branch 1 taken 5 times.
✓ Branch 2 taken 14 times.
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
 19 if (gate_string_starts_with(&ip, &ipv6_begin) && gate_string_ends_with(&ip, &ipv6_end))
1448 {
1449 /* ip v6 address */
1450 5 endpoint->ip6.family = GATE_SOCKET_FAMILY_INET6;
1451 5 endpoint->ip6.port = (gate_uint16_t)num;
1452 5 endpoint->ip6.scope = 0;
1453 5 gate_string_substr(&ip, &ip, 1, ip.length - 2);
1454
1455 5 ret = gate_socket_parse_ip6(&ip, &endpoint->ip6.address);
1456 }
1457 else
1458 {
1459 /* ip v4 address */
1460 14 endpoint->ip4.family = GATE_SOCKET_FAMILY_INET4;
1461 14 endpoint->ip4.port = (gate_uint16_t)num;
1462 14 ret = gate_socket_parse_ip4(&ip, &endpoint->ip4.address);
1463 }
1464
1465 } while (0);
1466
1467 19 gate_string_release(&ip);
1468
1469
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
 19 GATE_DEBUG_TRACE_FAILED(ret, "gate_socket_parse_endpoint() failed");
1470
1471 19 return ret;
1472 }
1473
1474 7 gate_result_t gate_socket_print_endpoint(gate_socket_endpoint_t const* endpoint, gate_string_t* address)
1475 {
1476 gate_result_t ret;
1477 7 gate_strbuilder8_t builder = GATE_INIT_EMPTY;
1478 gate_char8_t hexbuffer[8];
1479 gate_size_t hexbufferused;
1480
2/3
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 7 switch (endpoint->family)
1481 {
1482 4 case GATE_SOCKET_FAMILY_INET4:
1483 {
1484 4 gate_strbuilder_create(&builder, 16);
1485 4 gate_strbuilder_append_uint16(&builder, endpoint->ip4.address.item[0]);
1486 4 gate_strbuilder_append_text(&builder, ".", 1);
1487 4 gate_strbuilder_append_uint16(&builder, endpoint->ip4.address.item[1]);
1488 4 gate_strbuilder_append_text(&builder, ".", 1);
1489 4 gate_strbuilder_append_uint16(&builder, endpoint->ip4.address.item[2]);
1490 4 gate_strbuilder_append_text(&builder, ".", 1);
1491 4 gate_strbuilder_append_uint16(&builder, endpoint->ip4.address.item[3]);
1492
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
 4 if (endpoint->ip4.port)
1493 {
1494 3 gate_strbuilder_append_text(&builder, ":", 1);
1495 3 gate_strbuilder_append_uint16(&builder, endpoint->ip4.port);
1496 }
1497 4 ret = GATE_RESULT_OK;
1498 4 break;
1499 }
1500 3 case GATE_SOCKET_FAMILY_INET6:
1501 {
1502 3 gate_strbuilder_create(&builder, 50);
1503 3 gate_strbuilder_append_text(&builder, "[", 1);
1504
1505 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[0], false);
1506 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1507
1508 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[1], false);
1509 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1510
1511 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[2], false);
1512 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1513
1514 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[3], false);
1515 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1516
1517 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[4], false);
1518 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1519
1520 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[5], false);
1521 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1522
1523 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[6], false);
1524 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused); gate_strbuilder_append_text(&builder, ":", 1);
1525
1526 3 hexbufferused = gate_str_print_hex_uint16(hexbuffer, sizeof(hexbuffer), endpoint->ip6.address.item[7], false);
1527 3 gate_strbuilder_append_text(&builder, hexbuffer, hexbufferused);
1528
1529
1530 3 gate_strbuilder_append_text(&builder, "]", 1);
1531
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (endpoint->ip6.port)
1532 {
1533 3 gate_strbuilder_append_text(&builder, ":", 1);
1534 3 gate_strbuilder_append_uint16(&builder, endpoint->ip6.port);
1535 }
1536
1537 3 ret = GATE_RESULT_OK;
1538 3 break;
1539 }
1540 ✗ default:
1541 {
1542 ✗ ret = GATE_RESULT_NOTSUPPORTED;
1543 ✗ break;
1544 }
1545 }
1546
1547
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
 7 if (NULL == gate_strbuilder_to_string(&builder, address))
1548 {
1549 ✗ ret = GATE_RESULT_OUTOFMEMORY;
1550 }
1551
1552 7 gate_strbuilder_release(&builder);
1553
1554
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
 7 GATE_DEBUG_TRACE_FAILED(ret, "gate_socket_print_endpoint() failed");
1555
1556 7 return ret;
1557 }
1558
1559 12 gate_result_t gate_socket_load_endpoint(void const* ptr_in_native_sock_addr, gate_socket_endpoint_t* ptr_out_endpoint)
1560 {
1561 12 gate_socket_addr_storage_t const* ptr_addr_storage = (gate_socket_addr_storage_t const*)ptr_in_native_sock_addr;
1562
1563
2/3
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 12 switch (ptr_addr_storage->addr.sa_family)
1564 {
1565 9 case AF_INET:
1566 {
1567 9 ptr_out_endpoint->family = GATE_SOCKET_FAMILY_INET4;
1568 9 gate_socket_build_ip4address(&ptr_addr_storage->addr4, &ptr_out_endpoint->ip4);
1569 9 return GATE_RESULT_OK;
1570 }
1571 3 case AF_INET6:
1572 {
1573 #if defined(GATE_NET_SOCKET_NO_IPV6)
1574 return GATE_RESULT_NOTSUPPORTED;
1575 #else
1576 3 ptr_out_endpoint->family = GATE_SOCKET_FAMILY_INET6;
1577 3 gate_socket_build_ip6address(&ptr_addr_storage->addr6, &ptr_out_endpoint->ip6);
1578 3 return GATE_RESULT_OK;
1579 #endif
1580 }
1581 #if !defined(GATE_NET_SOCKET_NO_UNIX)
1582 case AF_UNIX:
1583 {
1584 gate_size_t len = gate_str_length_max(ptr_addr_storage->unix.sun_path, sizeof(ptr_addr_storage->unix.sun_path));
1585 ptr_out_endpoint->family = GATE_SOCKET_FAMILY_UNIX;
1586 gate_str_print_text(ptr_out_endpoint->unix_domain.path, sizeof(ptr_out_endpoint->unix_domain.path),
1587 ptr_addr_storage->unix.sun_path, len);
1588 return GATE_RESULT_OK;
1589 }
1590 #endif
1591 ✗ default:
1592 {
1593 ✗ ptr_out_endpoint->family = GATE_SOCKET_FAMILY_NONE;
1594 ✗ return GATE_RESULT_NOTSUPPORTED;
1595 }
1596 }
1597
1598 }
1599
1600 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)
1601 {
1602 2 gate_socket_addr_storage_t* ptr_addr_storage = (gate_socket_addr_storage_t*)ptr_out_native_sock_addr;
1603
1604
2/3
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 2 switch (ptr_src_endpoint->family)
1605 {
1606 1 case GATE_SOCKET_FAMILY_INET4:
1607 {
1608 1 const gate_size_t addrlen = gate_socket_build_addr_ip4(&ptr_src_endpoint->ip4, &ptr_addr_storage->addr4);
1609
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (ptr_out_native_sock_addr_len)
1610 {
1611 1 *ptr_out_native_sock_addr_len = addrlen;
1612 }
1613 1 return GATE_RESULT_OK;
1614 }
1615 1 case GATE_SOCKET_FAMILY_INET6:
1616 {
1617 #if defined(GATE_NET_SOCKET_NO_IPV6)
1618 return GATE_RESULT_NOTSUPPORTED;
1619 #else
1620 1 const gate_size_t addrlen = gate_socket_build_addr_ip6(&ptr_src_endpoint->ip6, &ptr_addr_storage->addr6);
1621
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (ptr_out_native_sock_addr_len)
1622 {
1623 1 *ptr_out_native_sock_addr_len = addrlen;
1624 }
1625 1 return GATE_RESULT_OK;
1626 #endif
1627 }
1628 #if !defined(GATE_NET_SOCKET_NO_UNIX)
1629 case GATE_SOCKET_FAMILY_UNIX:
1630 {
1631 gate_size_t len = gate_str_length_max(ptr_src_endpoint->unix_domain.path, sizeof(ptr_src_endpoint->unix_domain.path));
1632 ptr_addr_storage->unix.sun_family = AF_UNIX;
1633 gate_str_print_text(ptr_addr_storage->unix.sun_path, sizeof(ptr_addr_storage->unix.sun_path),
1634 ptr_src_endpoint->unix_domain.path, len);
1635 if (ptr_out_native_sock_addr_len)
1636 {
1637 *ptr_out_native_sock_addr_len = sizeof(sockaddr_un);
1638 }
1639 return GATE_RESULT_OK;
1640 }
1641 #endif
1642 ✗ default:
1643 {
1644 ✗ return GATE_RESULT_NOTSUPPORTED;
1645 }
1646 }
1647 }
1648
1649 #endif /* GATE_NET_SOCKETS_BSDIMPL */
1650
1651
1652
1653 #if defined(GATE_NET_SOCKETS_EFI)
1654
1655 gate_result_t gate_socket_init()
1656 {
1657 return GATE_RESULT_NOTIMPLEMENTED;
1658 }
1659
1660 gate_bool_t gate_socket_support(gate_int16_t family)
1661 {
1662 GATE_UNUSED_ARG(family);
1663 return false;
1664 }
1665
1666 gate_result_t gate_socket_create(gate_int16_t type, gate_socket_t* sock)
1667 {
1668 GATE_UNUSED_ARG(type);
1669 GATE_UNUSED_ARG(sock);
1670 return GATE_RESULT_NOTIMPLEMENTED;
1671 }
1672 gate_result_t gate_socket_create_ex(gate_int16_t family, gate_int16_t msgtype, gate_int16_t protocol, gate_socket_t* sock)
1673 {
1674 GATE_UNUSED_ARG(family);
1675 GATE_UNUSED_ARG(msgtype);
1676 GATE_UNUSED_ARG(protocol);
1677 GATE_UNUSED_ARG(sock);
1678 return GATE_RESULT_NOTIMPLEMENTED;
1679 }
1680 gate_result_t gate_socket_connect(gate_socket_t sock, gate_socket_endpoint_t const* ep)
1681 {
1682 GATE_UNUSED_ARG(sock);
1683 GATE_UNUSED_ARG(ep);
1684 return GATE_RESULT_NOTIMPLEMENTED;
1685 }
1686 gate_result_t gate_socket_connect_address(gate_socket_t sock, gate_string_t const* address)
1687 {
1688 GATE_UNUSED_ARG(sock);
1689 GATE_UNUSED_ARG(address);
1690 return GATE_RESULT_NOTIMPLEMENTED;
1691 }
1692 gate_result_t gate_socket_bind(gate_socket_t sock, gate_socket_endpoint_t const* ep)
1693 {
1694 GATE_UNUSED_ARG(sock);
1695 GATE_UNUSED_ARG(ep);
1696 return GATE_RESULT_NOTIMPLEMENTED;
1697 }
1698 gate_result_t gate_socket_bind_address(gate_socket_t sock, gate_string_t const* address)
1699 {
1700 GATE_UNUSED_ARG(sock);
1701 GATE_UNUSED_ARG(address);
1702 return GATE_RESULT_NOTIMPLEMENTED;
1703 }
1704 gate_result_t gate_socket_listen(gate_socket_t sock, gate_int32_t backlog)
1705 {
1706 GATE_UNUSED_ARG(sock);
1707 GATE_UNUSED_ARG(backlog);
1708 return GATE_RESULT_NOTIMPLEMENTED;
1709 }
1710 gate_result_t gate_socket_accept(gate_socket_t sock, gate_socket_t* newsock)
1711 {
1712 GATE_UNUSED_ARG(sock);
1713 GATE_UNUSED_ARG(newsock);
1714 return GATE_RESULT_NOTIMPLEMENTED;
1715 }
1716 gate_result_t gate_socket_receive(gate_socket_t sock, char* buffer, gate_size_t bufferlen, gate_size_t* bufferused)
1717 {
1718 GATE_UNUSED_ARG(sock);
1719 GATE_UNUSED_ARG(buffer);
1720 GATE_UNUSED_ARG(bufferlen);
1721 GATE_UNUSED_ARG(bufferused);
1722 return GATE_RESULT_NOTIMPLEMENTED;
1723 }
1724 gate_result_t gate_socket_receive_from(gate_socket_t sock, gate_socket_endpoint_t* ep, char* buffer,
1725 gate_size_t bufferlen, gate_size_t* bufferused, gate_uint16_t flags)
1726 {
1727 GATE_UNUSED_ARG(sock);
1728 GATE_UNUSED_ARG(ep);
1729 GATE_UNUSED_ARG(buffer);
1730 GATE_UNUSED_ARG(bufferlen);
1731 GATE_UNUSED_ARG(bufferused);
1732 GATE_UNUSED_ARG(flags);
1733 return GATE_RESULT_NOTIMPLEMENTED;
1734 }
1735 gate_result_t gate_socket_send(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
1736 {
1737 GATE_UNUSED_ARG(sock);
1738 GATE_UNUSED_ARG(buffer);
1739 GATE_UNUSED_ARG(bufferlen);
1740 GATE_UNUSED_ARG(bufferprocessed);
1741 return GATE_RESULT_NOTIMPLEMENTED;
1742 }
1743 gate_result_t gate_socket_send_block(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
1744 {
1745 GATE_UNUSED_ARG(sock);
1746 GATE_UNUSED_ARG(buffer);
1747 GATE_UNUSED_ARG(bufferlen);
1748 GATE_UNUSED_ARG(bufferprocessed);
1749 return GATE_RESULT_NOTIMPLEMENTED;
1750 }
1751 gate_result_t gate_socket_send_to(gate_socket_t sock, gate_socket_endpoint_t const* to, char const* buffer,
1752 gate_size_t bufferlen, gate_size_t* bufferprocessed, gate_uint16_t flags)
1753 {
1754 GATE_UNUSED_ARG(sock);
1755 GATE_UNUSED_ARG(to);
1756 GATE_UNUSED_ARG(buffer);
1757 GATE_UNUSED_ARG(bufferlen);
1758 GATE_UNUSED_ARG(bufferprocessed);
1759 GATE_UNUSED_ARG(flags);
1760 return GATE_RESULT_NOTIMPLEMENTED;
1761 }
1762 gate_result_t gate_socket_select(gate_socket_t const* socks, gate_size_t sockcount, gate_uint8_t* statusflags, gate_uint32_t timeout)
1763 {
1764 GATE_UNUSED_ARG(socks);
1765 GATE_UNUSED_ARG(sockcount);
1766 GATE_UNUSED_ARG(statusflags);
1767 GATE_UNUSED_ARG(timeout);
1768 return GATE_RESULT_NOTIMPLEMENTED;
1769 }
1770 gate_result_t gate_socket_shutdown(gate_socket_t sock, gate_bool_t shutdownreceive, gate_bool_t shutdownsend)
1771 {
1772 GATE_UNUSED_ARG(sock);
1773 GATE_UNUSED_ARG(shutdownreceive);
1774 GATE_UNUSED_ARG(shutdownsend);
1775 return GATE_RESULT_NOTIMPLEMENTED;
1776 }
1777 gate_result_t gate_socket_close(gate_socket_t sock)
1778 {
1779 GATE_UNUSED_ARG(sock);
1780 return GATE_RESULT_NOTIMPLEMENTED;
1781 }
1782 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)
1783 {
1784 GATE_UNUSED_ARG(sock);
1785 GATE_UNUSED_ARG(level);
1786 GATE_UNUSED_ARG(option);
1787 GATE_UNUSED_ARG(buffer);
1788 GATE_UNUSED_ARG(bufferlen);
1789 return GATE_RESULT_NOTIMPLEMENTED;
1790 }
1791 gate_result_t gate_socket_has_error(gate_socket_t sock, gate_bool_t* ptr_errorflag)
1792 {
1793 GATE_UNUSED_ARG(sock);
1794 GATE_UNUSED_ARG(ptr_errorflag);
1795 return GATE_RESULT_NOTIMPLEMENTED;
1796 }
1797 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)
1798 {
1799 GATE_UNUSED_ARG(sock);
1800 GATE_UNUSED_ARG(level);
1801 GATE_UNUSED_ARG(option);
1802 GATE_UNUSED_ARG(buffer);
1803 GATE_UNUSED_ARG(bufferlen);
1804 return GATE_RESULT_NOTIMPLEMENTED;
1805 }
1806 gate_result_t gate_socket_get_local_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
1807 {
1808 GATE_UNUSED_ARG(sock);
1809 GATE_UNUSED_ARG(ep);
1810 return GATE_RESULT_NOTIMPLEMENTED;
1811 }
1812 gate_result_t gate_socket_get_local_address(gate_socket_t sock, gate_string_t* address)
1813 {
1814 GATE_UNUSED_ARG(sock);
1815 GATE_UNUSED_ARG(address);
1816 return GATE_RESULT_NOTIMPLEMENTED;
1817 }
1818 gate_result_t gate_socket_get_remote_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
1819 {
1820 GATE_UNUSED_ARG(sock);
1821 GATE_UNUSED_ARG(ep);
1822 return GATE_RESULT_NOTIMPLEMENTED;
1823 }
1824 gate_result_t gate_socket_get_remote_address(gate_socket_t sock, gate_string_t* address)
1825 {
1826 GATE_UNUSED_ARG(sock);
1827 GATE_UNUSED_ARG(address);
1828 return GATE_RESULT_NOTIMPLEMENTED;
1829 }
1830 gate_result_t gate_socket_parse_address(gate_string_t const* address, gate_string_t* host, gate_uint16_t* port, gate_int16_t* family)
1831 {
1832 GATE_UNUSED_ARG(address);
1833 GATE_UNUSED_ARG(host);
1834 GATE_UNUSED_ARG(port);
1835 GATE_UNUSED_ARG(family);
1836 return GATE_RESULT_NOTIMPLEMENTED;
1837 }
1838 gate_result_t gate_socket_parse_endpoint(gate_string_t const* address, gate_socket_endpoint_t* endpoint)
1839 {
1840 GATE_UNUSED_ARG(address);
1841 GATE_UNUSED_ARG(endpoint);
1842 return GATE_RESULT_NOTIMPLEMENTED;
1843 }
1844 gate_result_t gate_socket_print_endpoint(gate_socket_endpoint_t const* endpoint, gate_string_t* address)
1845 {
1846 GATE_UNUSED_ARG(endpoint);
1847 GATE_UNUSED_ARG(address);
1848 return GATE_RESULT_NOTIMPLEMENTED;
1849 }
1850
1851 gate_result_t gate_socket_set(gate_socket_t sock, GATE_SOCKET_OPTION option, gate_int32_t value)
1852 {
1853 GATE_UNUSED_ARG(sock);
1854 GATE_UNUSED_ARG(option);
1855 GATE_UNUSED_ARG(value);
1856 return GATE_RESULT_NOTIMPLEMENTED;
1857 }
1858
1859 gate_result_t gate_socket_parse_ip4(gate_string_t const* ip4text, gate_socket_ip4address_t* ip4address)
1860 {
1861 GATE_UNUSED_ARG(ip4text);
1862 GATE_UNUSED_ARG(ip4address);
1863 return GATE_RESULT_NOTIMPLEMENTED;
1864 }
1865
1866 gate_result_t gate_socket_parse_ip6(gate_string_t const* ip6text, gate_socket_ip6address_t* ip6address)
1867 {
1868 GATE_UNUSED_ARG(ip6text);
1869 GATE_UNUSED_ARG(ip6address);
1870 return GATE_RESULT_NOTIMPLEMENTED;
1871 }
1872
1873 gate_result_t gate_socket_load_endpoint(void const* ptr_in_native_sock_addr, gate_socket_endpoint_t* ptr_out_endpoint)
1874 {
1875 GATE_UNUSED_ARG(ptr_in_native_sock_addr);
1876 GATE_UNUSED_ARG(ptr_out_endpoint);
1877 return GATE_RESULT_NOTIMPLEMENTED;
1878 }
1879 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)
1880 {
1881 GATE_UNUSED_ARG(ptr_src_endpoint);
1882 GATE_UNUSED_ARG(ptr_out_native_sock_addr);
1883 GATE_UNUSED_ARG(ptr_out_native_sock_addr_len);
1884 return GATE_RESULT_NOTIMPLEMENTED;
1885 }
1886
1887 #endif /* GATE_NET_SOCKETS_EFI */
1888
1889
1890
1891 #if defined(GATE_NET_SOCKETS_NOIMPL)
1892
1893 gate_result_t gate_socket_init()
1894 {
1895 return GATE_RESULT_NOTIMPLEMENTED;
1896 }
1897
1898 gate_bool_t gate_socket_support(gate_int16_t family)
1899 {
1900 GATE_UNUSED_ARG(family);
1901 return false;
1902 }
1903
1904 gate_result_t gate_socket_create(gate_int16_t type, gate_socket_t* sock)
1905 {
1906 GATE_UNUSED_ARG(type);
1907 GATE_UNUSED_ARG(sock);
1908 return GATE_RESULT_NOTIMPLEMENTED;
1909 }
1910 gate_result_t gate_socket_create_ex(gate_int16_t family, gate_int16_t msgtype, gate_int16_t protocol, gate_socket_t* sock)
1911 {
1912 GATE_UNUSED_ARG(family);
1913 GATE_UNUSED_ARG(msgtype);
1914 GATE_UNUSED_ARG(protocol);
1915 GATE_UNUSED_ARG(sock);
1916 return GATE_RESULT_NOTIMPLEMENTED;
1917 }
1918 gate_result_t gate_socket_connect(gate_socket_t sock, gate_socket_endpoint_t const* ep)
1919 {
1920 GATE_UNUSED_ARG(sock);
1921 GATE_UNUSED_ARG(ep);
1922 return GATE_RESULT_NOTIMPLEMENTED;
1923 }
1924 gate_result_t gate_socket_connect_address(gate_socket_t sock, gate_string_t const* address)
1925 {
1926 GATE_UNUSED_ARG(sock);
1927 GATE_UNUSED_ARG(address);
1928 return GATE_RESULT_NOTIMPLEMENTED;
1929 }
1930 gate_result_t gate_socket_bind(gate_socket_t sock, gate_socket_endpoint_t const* ep)
1931 {
1932 GATE_UNUSED_ARG(sock);
1933 GATE_UNUSED_ARG(ep);
1934 return GATE_RESULT_NOTIMPLEMENTED;
1935 }
1936 gate_result_t gate_socket_bind_address(gate_socket_t sock, gate_string_t const* address)
1937 {
1938 GATE_UNUSED_ARG(sock);
1939 GATE_UNUSED_ARG(address);
1940 return GATE_RESULT_NOTIMPLEMENTED;
1941 }
1942 gate_result_t gate_socket_listen(gate_socket_t sock, gate_int32_t backlog)
1943 {
1944 GATE_UNUSED_ARG(sock);
1945 GATE_UNUSED_ARG(backlog);
1946 return GATE_RESULT_NOTIMPLEMENTED;
1947 }
1948 gate_result_t gate_socket_accept(gate_socket_t sock, gate_socket_t* newsock)
1949 {
1950 GATE_UNUSED_ARG(sock);
1951 GATE_UNUSED_ARG(newsock);
1952 return GATE_RESULT_NOTIMPLEMENTED;
1953 }
1954 gate_result_t gate_socket_receive(gate_socket_t sock, char* buffer, gate_size_t bufferlen, gate_size_t* bufferused)
1955 {
1956 GATE_UNUSED_ARG(sock);
1957 GATE_UNUSED_ARG(buffer);
1958 GATE_UNUSED_ARG(bufferlen);
1959 GATE_UNUSED_ARG(bufferused);
1960 return GATE_RESULT_NOTIMPLEMENTED;
1961 }
1962 gate_result_t gate_socket_receive_from(gate_socket_t sock, gate_socket_endpoint_t* ep, char* buffer,
1963 gate_size_t bufferlen, gate_size_t* bufferused, gate_uint16_t flags)
1964 {
1965 GATE_UNUSED_ARG(sock);
1966 GATE_UNUSED_ARG(ep);
1967 GATE_UNUSED_ARG(buffer);
1968 GATE_UNUSED_ARG(bufferlen);
1969 GATE_UNUSED_ARG(bufferused);
1970 GATE_UNUSED_ARG(flags);
1971 return GATE_RESULT_NOTIMPLEMENTED;
1972 }
1973 gate_result_t gate_socket_send(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
1974 {
1975 GATE_UNUSED_ARG(sock);
1976 GATE_UNUSED_ARG(buffer);
1977 GATE_UNUSED_ARG(bufferlen);
1978 GATE_UNUSED_ARG(bufferprocessed);
1979 return GATE_RESULT_NOTIMPLEMENTED;
1980 }
1981 gate_result_t gate_socket_send_block(gate_socket_t sock, char const* buffer, gate_size_t bufferlen, gate_size_t* bufferprocessed)
1982 {
1983 GATE_UNUSED_ARG(sock);
1984 GATE_UNUSED_ARG(buffer);
1985 GATE_UNUSED_ARG(bufferlen);
1986 GATE_UNUSED_ARG(bufferprocessed);
1987 return GATE_RESULT_NOTIMPLEMENTED;
1988 }
1989 gate_result_t gate_socket_send_to(gate_socket_t sock, gate_socket_endpoint_t const* to, char const* buffer,
1990 gate_size_t bufferlen, gate_size_t* bufferprocessed, gate_uint16_t flags)
1991 {
1992 GATE_UNUSED_ARG(sock);
1993 GATE_UNUSED_ARG(to);
1994 GATE_UNUSED_ARG(buffer);
1995 GATE_UNUSED_ARG(bufferlen);
1996 GATE_UNUSED_ARG(bufferprocessed);
1997 GATE_UNUSED_ARG(flags);
1998 return GATE_RESULT_NOTIMPLEMENTED;
1999 }
2000 gate_result_t gate_socket_select(gate_socket_t const* socks, gate_size_t sockcount, gate_uint8_t* statusflags, gate_uint32_t timeout)
2001 {
2002 GATE_UNUSED_ARG(socks);
2003 GATE_UNUSED_ARG(sockcount);
2004 GATE_UNUSED_ARG(statusflags);
2005 GATE_UNUSED_ARG(timeout);
2006 return GATE_RESULT_NOTIMPLEMENTED;
2007 }
2008 gate_result_t gate_socket_shutdown(gate_socket_t sock, gate_bool_t shutdownreceive, gate_bool_t shutdownsend)
2009 {
2010 GATE_UNUSED_ARG(sock);
2011 GATE_UNUSED_ARG(shutdownreceive);
2012 GATE_UNUSED_ARG(shutdownsend);
2013 return GATE_RESULT_NOTIMPLEMENTED;
2014 }
2015 gate_result_t gate_socket_close(gate_socket_t sock)
2016 {
2017 GATE_UNUSED_ARG(sock);
2018 return GATE_RESULT_NOTIMPLEMENTED;
2019 }
2020 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)
2021 {
2022 GATE_UNUSED_ARG(sock);
2023 GATE_UNUSED_ARG(level);
2024 GATE_UNUSED_ARG(option);
2025 GATE_UNUSED_ARG(buffer);
2026 GATE_UNUSED_ARG(bufferlen);
2027 return GATE_RESULT_NOTIMPLEMENTED;
2028 }
2029 gate_result_t gate_socket_has_error(gate_socket_t sock, gate_bool_t* ptr_errorflag)
2030 {
2031 GATE_UNUSED_ARG(sock);
2032 GATE_UNUSED_ARG(ptr_errorflag);
2033 return GATE_RESULT_NOTIMPLEMENTED;
2034 }
2035 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)
2036 {
2037 GATE_UNUSED_ARG(sock);
2038 GATE_UNUSED_ARG(level);
2039 GATE_UNUSED_ARG(option);
2040 GATE_UNUSED_ARG(buffer);
2041 GATE_UNUSED_ARG(bufferlen);
2042 return GATE_RESULT_NOTIMPLEMENTED;
2043 }
2044 gate_result_t gate_socket_get_local_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
2045 {
2046 GATE_UNUSED_ARG(sock);
2047 GATE_UNUSED_ARG(ep);
2048 return GATE_RESULT_NOTIMPLEMENTED;
2049 }
2050 gate_result_t gate_socket_get_local_address(gate_socket_t sock, gate_string_t* address)
2051 {
2052 GATE_UNUSED_ARG(sock);
2053 GATE_UNUSED_ARG(address);
2054 return GATE_RESULT_NOTIMPLEMENTED;
2055 }
2056 gate_result_t gate_socket_get_remote_endpoint(gate_socket_t sock, gate_socket_endpoint_t* ep)
2057 {
2058 GATE_UNUSED_ARG(sock);
2059 GATE_UNUSED_ARG(ep);
2060 return GATE_RESULT_NOTIMPLEMENTED;
2061 }
2062 gate_result_t gate_socket_get_remote_address(gate_socket_t sock, gate_string_t* address)
2063 {
2064 GATE_UNUSED_ARG(sock);
2065 GATE_UNUSED_ARG(address);
2066 return GATE_RESULT_NOTIMPLEMENTED;
2067 }
2068 gate_result_t gate_socket_parse_address(gate_string_t const* address, gate_string_t* host, gate_uint16_t* port, gate_int16_t* family)
2069 {
2070 GATE_UNUSED_ARG(address);
2071 GATE_UNUSED_ARG(host);
2072 GATE_UNUSED_ARG(port);
2073 GATE_UNUSED_ARG(family);
2074 return GATE_RESULT_NOTIMPLEMENTED;
2075 }
2076 gate_result_t gate_socket_parse_endpoint(gate_string_t const* address, gate_socket_endpoint_t* endpoint)
2077 {
2078 GATE_UNUSED_ARG(address);
2079 GATE_UNUSED_ARG(endpoint);
2080 return GATE_RESULT_NOTIMPLEMENTED;
2081 }
2082 gate_result_t gate_socket_print_endpoint(gate_socket_endpoint_t const* endpoint, gate_string_t* address)
2083 {
2084 GATE_UNUSED_ARG(endpoint);
2085 GATE_UNUSED_ARG(address);
2086 return GATE_RESULT_NOTIMPLEMENTED;
2087 }
2088
2089 gate_result_t gate_socket_set(gate_socket_t sock, GATE_SOCKET_OPTION option, gate_int32_t value)
2090 {
2091 GATE_UNUSED_ARG(sock);
2092 GATE_UNUSED_ARG(option);
2093 GATE_UNUSED_ARG(value);
2094 return GATE_RESULT_NOTIMPLEMENTED;
2095 }
2096
2097 gate_result_t gate_socket_parse_ip4(gate_string_t const* ip4text, gate_socket_ip4address_t* ip4address)
2098 {
2099 GATE_UNUSED_ARG(ip4text);
2100 GATE_UNUSED_ARG(ip4address);
2101 return GATE_RESULT_NOTIMPLEMENTED;
2102 }
2103
2104 gate_result_t gate_socket_parse_ip6(gate_string_t const* ip6text, gate_socket_ip6address_t* ip6address)
2105 {
2106 GATE_UNUSED_ARG(ip6text);
2107 GATE_UNUSED_ARG(ip6address);
2108 return GATE_RESULT_NOTIMPLEMENTED;
2109 }
2110
2111 gate_result_t gate_socket_load_endpoint(void const* ptr_in_native_sock_addr, gate_socket_endpoint_t* ptr_out_endpoint)
2112 {
2113 GATE_UNUSED_ARG(ptr_in_native_sock_addr);
2114 GATE_UNUSED_ARG(ptr_out_endpoint);
2115 return GATE_RESULT_NOTIMPLEMENTED;
2116 }
2117 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)
2118 {
2119 GATE_UNUSED_ARG(ptr_src_endpoint);
2120 GATE_UNUSED_ARG(ptr_out_native_sock_addr);
2121 GATE_UNUSED_ARG(ptr_out_native_sock_addr_len);
2122 return GATE_RESULT_NOTIMPLEMENTED;
2123 }
2124
2125 #endif /* GATE_NET_SOCKETS_NOIMPL */
2126
2127