1 | // Copyright (C) 2021 The Qt Company Ltd. |
---|---|
2 | // Copyright (C) 2016 Intel Corporation. |
3 | // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only |
4 | |
5 | //#define QNATIVESOCKETENGINE_DEBUG |
6 | #include "qnativesocketengine_p_p.h" |
7 | #include "private/qnet_unix_p.h" |
8 | #include "qdeadlinetimer.h" |
9 | #include "qiodevice.h" |
10 | #include "qhostaddress.h" |
11 | #include "qvarlengtharray.h" |
12 | #include "qnetworkinterface.h" |
13 | #include "qendian.h" |
14 | #ifdef Q_OS_WASM |
15 | #include <private/qeventdispatcher_wasm_p.h> |
16 | #endif |
17 | #include <time.h> |
18 | #include <errno.h> |
19 | #include <fcntl.h> |
20 | #ifdef Q_OS_INTEGRITY |
21 | #include <sys/uio.h> |
22 | #endif |
23 | |
24 | #if defined QNATIVESOCKETENGINE_DEBUG |
25 | #include <private/qdebug_p.h> |
26 | #endif |
27 | |
28 | #include <netinet/tcp.h> |
29 | #ifndef QT_NO_SCTP |
30 | #include <sys/types.h> |
31 | #include <sys/socket.h> |
32 | #include <netinet/sctp.h> |
33 | #endif |
34 | #ifdef Q_OS_BSD4 |
35 | # include <net/if_dl.h> |
36 | #endif |
37 | |
38 | QT_BEGIN_NAMESPACE |
39 | |
40 | /* |
41 | Extracts the port and address from a sockaddr, and stores them in |
42 | \a port and \a addr if they are non-null. |
43 | */ |
44 | static inline void qt_socket_getPortAndAddress(const qt_sockaddr *s, quint16 *port, QHostAddress *addr) |
45 | { |
46 | if (s->a.sa_family == AF_INET6) { |
47 | Q_IPV6ADDR tmp; |
48 | memcpy(dest: &tmp, src: &s->a6.sin6_addr, n: sizeof(tmp)); |
49 | if (addr) { |
50 | QHostAddress tmpAddress; |
51 | tmpAddress.setAddress(tmp); |
52 | *addr = tmpAddress; |
53 | #if QT_CONFIG(networkinterface) |
54 | if (s->a6.sin6_scope_id) |
55 | addr->setScopeId(QNetworkInterface::interfaceNameFromIndex(index: s->a6.sin6_scope_id)); |
56 | #endif |
57 | } |
58 | if (port) |
59 | *port = ntohs(netshort: s->a6.sin6_port); |
60 | return; |
61 | } |
62 | |
63 | if (port) |
64 | *port = ntohs(netshort: s->a4.sin_port); |
65 | if (addr) { |
66 | QHostAddress tmpAddress; |
67 | tmpAddress.setAddress(ntohl(netlong: s->a4.sin_addr.s_addr)); |
68 | *addr = tmpAddress; |
69 | } |
70 | } |
71 | |
72 | static void convertToLevelAndOption(QNativeSocketEngine::SocketOption opt, |
73 | QAbstractSocket::NetworkLayerProtocol socketProtocol, int &level, int &n) |
74 | { |
75 | n = -1; |
76 | level = SOL_SOCKET; // default |
77 | |
78 | switch (opt) { |
79 | case QNativeSocketEngine::NonBlockingSocketOption: // fcntl, not setsockopt |
80 | case QNativeSocketEngine::BindExclusively: // not handled on Unix |
81 | case QNativeSocketEngine::MaxStreamsSocketOption: |
82 | Q_UNREACHABLE(); |
83 | |
84 | case QNativeSocketEngine::BroadcastSocketOption: |
85 | n = SO_BROADCAST; |
86 | break; |
87 | case QNativeSocketEngine::ReceiveBufferSocketOption: |
88 | n = SO_RCVBUF; |
89 | break; |
90 | case QNativeSocketEngine::SendBufferSocketOption: |
91 | n = SO_SNDBUF; |
92 | break; |
93 | case QNativeSocketEngine::AddressReusable: |
94 | n = SO_REUSEADDR; |
95 | break; |
96 | case QNativeSocketEngine::ReceiveOutOfBandData: |
97 | n = SO_OOBINLINE; |
98 | break; |
99 | case QNativeSocketEngine::LowDelayOption: |
100 | level = IPPROTO_TCP; |
101 | n = TCP_NODELAY; |
102 | break; |
103 | case QNativeSocketEngine::KeepAliveOption: |
104 | n = SO_KEEPALIVE; |
105 | break; |
106 | case QNativeSocketEngine::MulticastTtlOption: |
107 | if (socketProtocol == QAbstractSocket::IPv6Protocol || socketProtocol == QAbstractSocket::AnyIPProtocol) { |
108 | level = IPPROTO_IPV6; |
109 | n = IPV6_MULTICAST_HOPS; |
110 | } else |
111 | { |
112 | level = IPPROTO_IP; |
113 | n = IP_MULTICAST_TTL; |
114 | } |
115 | break; |
116 | case QNativeSocketEngine::MulticastLoopbackOption: |
117 | if (socketProtocol == QAbstractSocket::IPv6Protocol || socketProtocol == QAbstractSocket::AnyIPProtocol) { |
118 | level = IPPROTO_IPV6; |
119 | n = IPV6_MULTICAST_LOOP; |
120 | } else |
121 | { |
122 | level = IPPROTO_IP; |
123 | n = IP_MULTICAST_LOOP; |
124 | } |
125 | break; |
126 | case QNativeSocketEngine::TypeOfServiceOption: |
127 | if (socketProtocol == QAbstractSocket::IPv4Protocol) { |
128 | level = IPPROTO_IP; |
129 | n = IP_TOS; |
130 | } |
131 | break; |
132 | case QNativeSocketEngine::ReceivePacketInformation: |
133 | if (socketProtocol == QAbstractSocket::IPv6Protocol || socketProtocol == QAbstractSocket::AnyIPProtocol) { |
134 | level = IPPROTO_IPV6; |
135 | n = IPV6_RECVPKTINFO; |
136 | } else if (socketProtocol == QAbstractSocket::IPv4Protocol) { |
137 | level = IPPROTO_IP; |
138 | #ifdef IP_PKTINFO |
139 | n = IP_PKTINFO; |
140 | #elif defined(IP_RECVDSTADDR) |
141 | // variant found in QNX and FreeBSD; it will get us only the |
142 | // destination address, not the interface; we need IP_RECVIF for that. |
143 | n = IP_RECVDSTADDR; |
144 | #endif |
145 | } |
146 | break; |
147 | case QNativeSocketEngine::ReceiveHopLimit: |
148 | if (socketProtocol == QAbstractSocket::IPv6Protocol || socketProtocol == QAbstractSocket::AnyIPProtocol) { |
149 | level = IPPROTO_IPV6; |
150 | n = IPV6_RECVHOPLIMIT; |
151 | } else if (socketProtocol == QAbstractSocket::IPv4Protocol) { |
152 | #ifdef IP_RECVTTL // IP_RECVTTL is a non-standard extension supported on some OS |
153 | level = IPPROTO_IP; |
154 | n = IP_RECVTTL; |
155 | #endif |
156 | } |
157 | break; |
158 | |
159 | case QNativeSocketEngine::PathMtuInformation: |
160 | if (socketProtocol == QAbstractSocket::IPv6Protocol || socketProtocol == QAbstractSocket::AnyIPProtocol) { |
161 | #ifdef IPV6_MTU |
162 | level = IPPROTO_IPV6; |
163 | n = IPV6_MTU; |
164 | #endif |
165 | } else { |
166 | #ifdef IP_MTU |
167 | level = IPPROTO_IP; |
168 | n = IP_MTU; |
169 | #endif |
170 | } |
171 | break; |
172 | } |
173 | } |
174 | |
175 | /*! \internal |
176 | |
177 | Creates and returns a new socket descriptor of type \a socketType |
178 | and \a socketProtocol. Returns -1 on failure. |
179 | */ |
180 | bool QNativeSocketEnginePrivate::createNewSocket(QAbstractSocket::SocketType socketType, |
181 | QAbstractSocket::NetworkLayerProtocol &socketProtocol) |
182 | { |
183 | #ifndef QT_NO_SCTP |
184 | int protocol = (socketType == QAbstractSocket::SctpSocket) ? IPPROTO_SCTP : 0; |
185 | #else |
186 | if (socketType == QAbstractSocket::SctpSocket) { |
187 | setError(error: QAbstractSocket::UnsupportedSocketOperationError, |
188 | errorString: ProtocolUnsupportedErrorString); |
189 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
190 | qDebug("QNativeSocketEnginePrivate::createNewSocket(%d, %d): unsupported protocol", |
191 | socketType, socketProtocol); |
192 | #endif |
193 | return false; |
194 | } |
195 | int protocol = 0; |
196 | #endif // QT_NO_SCTP |
197 | int domain = (socketProtocol == QAbstractSocket::IPv6Protocol |
198 | || socketProtocol == QAbstractSocket::AnyIPProtocol) ? AF_INET6 : AF_INET; |
199 | int type = (socketType == QAbstractSocket::UdpSocket) ? SOCK_DGRAM : SOCK_STREAM; |
200 | |
201 | int socket = qt_safe_socket(domain, type, protocol, O_NONBLOCK); |
202 | if (socket < 0 && socketProtocol == QAbstractSocket::AnyIPProtocol && errno == EAFNOSUPPORT) { |
203 | domain = AF_INET; |
204 | socket = qt_safe_socket(domain, type, protocol, O_NONBLOCK); |
205 | socketProtocol = QAbstractSocket::IPv4Protocol; |
206 | } |
207 | |
208 | if (socket < 0) { |
209 | int ecopy = errno; |
210 | switch (ecopy) { |
211 | case EPROTONOSUPPORT: |
212 | case EAFNOSUPPORT: |
213 | case EINVAL: |
214 | setError(error: QAbstractSocket::UnsupportedSocketOperationError, errorString: ProtocolUnsupportedErrorString); |
215 | break; |
216 | case ENFILE: |
217 | case EMFILE: |
218 | case ENOBUFS: |
219 | case ENOMEM: |
220 | setError(error: QAbstractSocket::SocketResourceError, errorString: ResourceErrorString); |
221 | break; |
222 | case EACCES: |
223 | setError(error: QAbstractSocket::SocketAccessError, errorString: AccessErrorString); |
224 | break; |
225 | default: |
226 | break; |
227 | } |
228 | |
229 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
230 | qDebug("QNativeSocketEnginePrivate::createNewSocket(%d, %d) == false (%s)", |
231 | socketType, socketProtocol, |
232 | strerror(ecopy)); |
233 | #endif |
234 | |
235 | return false; |
236 | } |
237 | |
238 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
239 | qDebug("QNativeSocketEnginePrivate::createNewSocket(%d, %d) == true", |
240 | socketType, socketProtocol); |
241 | #endif |
242 | |
243 | socketDescriptor = socket; |
244 | this->socketProtocol = socketProtocol; |
245 | this->socketType = socketType; |
246 | return true; |
247 | } |
248 | |
249 | /* |
250 | Returns the value of the socket option \a opt. |
251 | */ |
252 | int QNativeSocketEnginePrivate::option(QNativeSocketEngine::SocketOption opt) const |
253 | { |
254 | Q_Q(const QNativeSocketEngine); |
255 | if (!q->isValid()) |
256 | return -1; |
257 | |
258 | // handle non-getsockopt and specific cases first |
259 | switch (opt) { |
260 | case QNativeSocketEngine::BindExclusively: |
261 | case QNativeSocketEngine::NonBlockingSocketOption: |
262 | case QNativeSocketEngine::BroadcastSocketOption: |
263 | return -1; |
264 | case QNativeSocketEngine::MaxStreamsSocketOption: { |
265 | #ifndef QT_NO_SCTP |
266 | sctp_initmsg sctpInitMsg; |
267 | QT_SOCKOPTLEN_T sctpInitMsgSize = sizeof(sctpInitMsg); |
268 | if (::getsockopt(socketDescriptor, SOL_SCTP, SCTP_INITMSG, &sctpInitMsg, |
269 | &sctpInitMsgSize) == 0) |
270 | return int(qMin(sctpInitMsg.sinit_num_ostreams, sctpInitMsg.sinit_max_instreams)); |
271 | #endif |
272 | return -1; |
273 | } |
274 | |
275 | case QNativeSocketEngine::PathMtuInformation: |
276 | #if defined(IPV6_PATHMTU) && !defined(IPV6_MTU) |
277 | // Prefer IPV6_MTU (handled by convertToLevelAndOption), if available |
278 | // (Linux); fall back to IPV6_PATHMTU otherwise (FreeBSD): |
279 | if (socketProtocol == QAbstractSocket::IPv6Protocol) { |
280 | ip6_mtuinfo mtuinfo; |
281 | QT_SOCKOPTLEN_T len = sizeof(mtuinfo); |
282 | if (::getsockopt(socketDescriptor, IPPROTO_IPV6, IPV6_PATHMTU, &mtuinfo, &len) == 0) |
283 | return int(mtuinfo.ip6m_mtu); |
284 | return -1; |
285 | } |
286 | #endif |
287 | break; |
288 | |
289 | default: |
290 | break; |
291 | } |
292 | |
293 | int n, level; |
294 | int v = 0; |
295 | QT_SOCKOPTLEN_T len = sizeof(v); |
296 | |
297 | convertToLevelAndOption(opt, socketProtocol, level, n); |
298 | if (n != -1 && ::getsockopt(fd: socketDescriptor, level: level, optname: n, optval: (char *) &v, optlen: &len) != -1) |
299 | return len == 1 ? qFromUnaligned<quint8>(src: &v) : v; |
300 | |
301 | return -1; |
302 | } |
303 | |
304 | |
305 | /* |
306 | Sets the socket option \a opt to \a v. |
307 | */ |
308 | bool QNativeSocketEnginePrivate::setOption(QNativeSocketEngine::SocketOption opt, int v) |
309 | { |
310 | Q_Q(QNativeSocketEngine); |
311 | if (!q->isValid()) |
312 | return false; |
313 | |
314 | // handle non-setsockopt and specific cases first |
315 | switch (opt) { |
316 | case QNativeSocketEngine::NonBlockingSocketOption: { |
317 | // Make the socket nonblocking. |
318 | #if !defined(Q_OS_VXWORKS) |
319 | int flags = ::fcntl(fd: socketDescriptor, F_GETFL, 0); |
320 | if (flags == -1) { |
321 | #ifdef QNATIVESOCKETENGINE_DEBUG |
322 | perror("QNativeSocketEnginePrivate::setOption(): fcntl(F_GETFL) failed"); |
323 | #endif |
324 | return false; |
325 | } |
326 | if (::fcntl(fd: socketDescriptor, F_SETFL, flags | O_NONBLOCK) == -1) { |
327 | #ifdef QNATIVESOCKETENGINE_DEBUG |
328 | perror("QNativeSocketEnginePrivate::setOption(): fcntl(F_SETFL) failed"); |
329 | #endif |
330 | return false; |
331 | } |
332 | #else // Q_OS_VXWORKS |
333 | int onoff = 1; |
334 | |
335 | if (qt_safe_ioctl(socketDescriptor, FIONBIO, &onoff) < 0) { |
336 | |
337 | #ifdef QNATIVESOCKETENGINE_DEBUG |
338 | perror("QNativeSocketEnginePrivate::setOption(): ioctl(FIONBIO, 1) failed"); |
339 | #endif |
340 | return false; |
341 | } |
342 | #endif // Q_OS_VXWORKS |
343 | return true; |
344 | } |
345 | case QNativeSocketEngine::BindExclusively: |
346 | return true; |
347 | |
348 | case QNativeSocketEngine::MaxStreamsSocketOption: { |
349 | #ifndef QT_NO_SCTP |
350 | sctp_initmsg sctpInitMsg; |
351 | QT_SOCKOPTLEN_T sctpInitMsgSize = sizeof(sctpInitMsg); |
352 | if (::getsockopt(socketDescriptor, SOL_SCTP, SCTP_INITMSG, &sctpInitMsg, |
353 | &sctpInitMsgSize) == 0) { |
354 | sctpInitMsg.sinit_num_ostreams = sctpInitMsg.sinit_max_instreams = uint16_t(v); |
355 | return ::setsockopt(socketDescriptor, SOL_SCTP, SCTP_INITMSG, &sctpInitMsg, |
356 | sctpInitMsgSize) == 0; |
357 | } |
358 | #endif |
359 | return false; |
360 | } |
361 | |
362 | default: |
363 | break; |
364 | } |
365 | |
366 | int n, level; |
367 | convertToLevelAndOption(opt, socketProtocol, level, n); |
368 | #if defined(SO_REUSEPORT) && !defined(Q_OS_LINUX) |
369 | if (opt == QNativeSocketEngine::AddressReusable) { |
370 | // on OS X, SO_REUSEADDR isn't sufficient to allow multiple binds to the |
371 | // same port (which is useful for multicast UDP). SO_REUSEPORT is, but |
372 | // we most definitely do not want to use this for TCP. See QTBUG-6305. |
373 | if (socketType == QAbstractSocket::UdpSocket) |
374 | n = SO_REUSEPORT; |
375 | } |
376 | #endif |
377 | |
378 | if (n == -1) |
379 | return false; |
380 | return ::setsockopt(fd: socketDescriptor, level: level, optname: n, optval: (char *) &v, optlen: sizeof(v)) == 0; |
381 | } |
382 | |
383 | bool QNativeSocketEnginePrivate::nativeConnect(const QHostAddress &addr, quint16 port) |
384 | { |
385 | #ifdef QNATIVESOCKETENGINE_DEBUG |
386 | qDebug() << "QNativeSocketEnginePrivate::nativeConnect() "<< socketDescriptor; |
387 | #endif |
388 | |
389 | qt_sockaddr aa; |
390 | QT_SOCKLEN_T sockAddrSize; |
391 | setPortAndAddress(port, address: addr, aa: &aa, sockAddrSize: &sockAddrSize); |
392 | |
393 | int connectResult = qt_safe_connect(sockfd: socketDescriptor, addr: &aa.a, addrlen: sockAddrSize); |
394 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
395 | int ecopy = errno; |
396 | #endif |
397 | if (connectResult == -1) { |
398 | switch (errno) { |
399 | case EISCONN: |
400 | socketState = QAbstractSocket::ConnectedState; |
401 | break; |
402 | case ECONNREFUSED: |
403 | case EINVAL: |
404 | setError(error: QAbstractSocket::ConnectionRefusedError, errorString: ConnectionRefusedErrorString); |
405 | socketState = QAbstractSocket::UnconnectedState; |
406 | break; |
407 | case ETIMEDOUT: |
408 | setError(error: QAbstractSocket::NetworkError, errorString: ConnectionTimeOutErrorString); |
409 | break; |
410 | case EHOSTUNREACH: |
411 | setError(error: QAbstractSocket::NetworkError, errorString: HostUnreachableErrorString); |
412 | socketState = QAbstractSocket::UnconnectedState; |
413 | break; |
414 | case ENETUNREACH: |
415 | setError(error: QAbstractSocket::NetworkError, errorString: NetworkUnreachableErrorString); |
416 | socketState = QAbstractSocket::UnconnectedState; |
417 | break; |
418 | case EADDRINUSE: |
419 | setError(error: QAbstractSocket::NetworkError, errorString: AddressInuseErrorString); |
420 | break; |
421 | case EINPROGRESS: |
422 | case EALREADY: |
423 | setError(error: QAbstractSocket::UnfinishedSocketOperationError, errorString: InvalidSocketErrorString); |
424 | socketState = QAbstractSocket::ConnectingState; |
425 | break; |
426 | case EAGAIN: |
427 | setError(error: QAbstractSocket::UnfinishedSocketOperationError, errorString: InvalidSocketErrorString); |
428 | break; |
429 | case EACCES: |
430 | case EPERM: |
431 | setError(error: QAbstractSocket::SocketAccessError, errorString: AccessErrorString); |
432 | socketState = QAbstractSocket::UnconnectedState; |
433 | break; |
434 | case EAFNOSUPPORT: |
435 | case EBADF: |
436 | case EFAULT: |
437 | case ENOTSOCK: |
438 | socketState = QAbstractSocket::UnconnectedState; |
439 | break; |
440 | default: |
441 | break; |
442 | } |
443 | |
444 | if (socketState != QAbstractSocket::ConnectedState) { |
445 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
446 | qDebug("QNativeSocketEnginePrivate::nativeConnect(%s, %i) == false (%s)", |
447 | addr.toString().toLatin1().constData(), port, |
448 | socketState == QAbstractSocket::ConnectingState |
449 | ? "Connection in progress": strerror(ecopy)); |
450 | #endif |
451 | return false; |
452 | } |
453 | } |
454 | |
455 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
456 | qDebug("QNativeSocketEnginePrivate::nativeConnect(%s, %i) == true", |
457 | addr.toString().toLatin1().constData(), port); |
458 | #endif |
459 | |
460 | socketState = QAbstractSocket::ConnectedState; |
461 | return true; |
462 | } |
463 | |
464 | bool QNativeSocketEnginePrivate::nativeBind(const QHostAddress &address, quint16 port) |
465 | { |
466 | qt_sockaddr aa; |
467 | QT_SOCKLEN_T sockAddrSize; |
468 | setPortAndAddress(port, address, aa: &aa, sockAddrSize: &sockAddrSize); |
469 | |
470 | #ifdef IPV6_V6ONLY |
471 | if (aa.a.sa_family == AF_INET6) { |
472 | int ipv6only = 0; |
473 | if (address.protocol() == QAbstractSocket::IPv6Protocol) |
474 | ipv6only = 1; |
475 | //default value of this socket option varies depending on unix variant (or system configuration on BSD), so always set it explicitly |
476 | ::setsockopt(fd: socketDescriptor, IPPROTO_IPV6, IPV6_V6ONLY, optval: (char*)&ipv6only, optlen: sizeof(ipv6only) ); |
477 | } |
478 | #endif |
479 | |
480 | int bindResult = QT_SOCKET_BIND(fd: socketDescriptor, addr: &aa.a, len: sockAddrSize); |
481 | if (bindResult < 0 && errno == EAFNOSUPPORT && address.protocol() == QAbstractSocket::AnyIPProtocol) { |
482 | // retry with v4 |
483 | aa.a4.sin_family = AF_INET; |
484 | aa.a4.sin_port = htons(hostshort: port); |
485 | aa.a4.sin_addr.s_addr = htonl(hostlong: address.toIPv4Address()); |
486 | sockAddrSize = sizeof(aa.a4); |
487 | bindResult = QT_SOCKET_BIND(fd: socketDescriptor, addr: &aa.a, len: sockAddrSize); |
488 | } |
489 | |
490 | if (bindResult < 0) { |
491 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
492 | int ecopy = errno; |
493 | #endif |
494 | switch(errno) { |
495 | case EADDRINUSE: |
496 | setError(error: QAbstractSocket::AddressInUseError, errorString: AddressInuseErrorString); |
497 | break; |
498 | case EACCES: |
499 | setError(error: QAbstractSocket::SocketAccessError, errorString: AddressProtectedErrorString); |
500 | break; |
501 | case EINVAL: |
502 | setError(error: QAbstractSocket::UnsupportedSocketOperationError, errorString: OperationUnsupportedErrorString); |
503 | break; |
504 | case EADDRNOTAVAIL: |
505 | setError(error: QAbstractSocket::SocketAddressNotAvailableError, errorString: AddressNotAvailableErrorString); |
506 | break; |
507 | default: |
508 | break; |
509 | } |
510 | |
511 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
512 | qDebug("QNativeSocketEnginePrivate::nativeBind(%s, %i) == false (%s)", |
513 | address.toString().toLatin1().constData(), port, strerror(ecopy)); |
514 | #endif |
515 | |
516 | return false; |
517 | } |
518 | |
519 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
520 | qDebug("QNativeSocketEnginePrivate::nativeBind(%s, %i) == true", |
521 | address.toString().toLatin1().constData(), port); |
522 | #endif |
523 | socketState = QAbstractSocket::BoundState; |
524 | return true; |
525 | } |
526 | |
527 | bool QNativeSocketEnginePrivate::nativeListen(int backlog) |
528 | { |
529 | if (qt_safe_listen(s: socketDescriptor, backlog) < 0) { |
530 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
531 | int ecopy = errno; |
532 | #endif |
533 | switch (errno) { |
534 | case EADDRINUSE: |
535 | setError(error: QAbstractSocket::AddressInUseError, |
536 | errorString: PortInuseErrorString); |
537 | break; |
538 | default: |
539 | break; |
540 | } |
541 | |
542 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
543 | qDebug("QNativeSocketEnginePrivate::nativeListen(%i) == false (%s)", |
544 | backlog, strerror(ecopy)); |
545 | #endif |
546 | return false; |
547 | } |
548 | |
549 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
550 | qDebug("QNativeSocketEnginePrivate::nativeListen(%i) == true", backlog); |
551 | #endif |
552 | |
553 | socketState = QAbstractSocket::ListeningState; |
554 | return true; |
555 | } |
556 | |
557 | qintptr QNativeSocketEnginePrivate::nativeAccept() |
558 | { |
559 | int acceptedDescriptor = qt_safe_accept(s: socketDescriptor, addr: nullptr, addrlen: nullptr); |
560 | if (acceptedDescriptor == -1) { |
561 | switch (errno) { |
562 | case EBADF: |
563 | case EOPNOTSUPP: |
564 | setError(error: QAbstractSocket::UnsupportedSocketOperationError, errorString: InvalidSocketErrorString); |
565 | break; |
566 | case ECONNABORTED: |
567 | setError(error: QAbstractSocket::NetworkError, errorString: RemoteHostClosedErrorString); |
568 | break; |
569 | case EFAULT: |
570 | case ENOTSOCK: |
571 | setError(error: QAbstractSocket::SocketResourceError, errorString: NotSocketErrorString); |
572 | break; |
573 | case EPROTONOSUPPORT: |
574 | #if !defined(Q_OS_OPENBSD) |
575 | case EPROTO: |
576 | #endif |
577 | case EAFNOSUPPORT: |
578 | case EINVAL: |
579 | setError(error: QAbstractSocket::UnsupportedSocketOperationError, errorString: ProtocolUnsupportedErrorString); |
580 | break; |
581 | case ENFILE: |
582 | case EMFILE: |
583 | case ENOBUFS: |
584 | case ENOMEM: |
585 | setError(error: QAbstractSocket::SocketResourceError, errorString: ResourceErrorString); |
586 | break; |
587 | case EACCES: |
588 | case EPERM: |
589 | setError(error: QAbstractSocket::SocketAccessError, errorString: AccessErrorString); |
590 | break; |
591 | #if EAGAIN != EWOULDBLOCK |
592 | case EWOULDBLOCK: |
593 | #endif |
594 | case EAGAIN: |
595 | setError(error: QAbstractSocket::TemporaryError, errorString: TemporaryErrorString); |
596 | break; |
597 | default: |
598 | setError(error: QAbstractSocket::UnknownSocketError, errorString: UnknownSocketErrorString); |
599 | break; |
600 | } |
601 | } |
602 | |
603 | return qintptr(acceptedDescriptor); |
604 | } |
605 | |
606 | #ifndef QT_NO_NETWORKINTERFACE |
607 | |
608 | static bool multicastMembershipHelper(QNativeSocketEnginePrivate *d, |
609 | int how6, |
610 | int how4, |
611 | const QHostAddress &groupAddress, |
612 | const QNetworkInterface &interface) |
613 | { |
614 | int level = 0; |
615 | int sockOpt = 0; |
616 | void *sockArg; |
617 | int sockArgSize; |
618 | |
619 | ip_mreq mreq4; |
620 | ipv6_mreq mreq6; |
621 | |
622 | if (groupAddress.protocol() == QAbstractSocket::IPv6Protocol) { |
623 | level = IPPROTO_IPV6; |
624 | sockOpt = how6; |
625 | sockArg = &mreq6; |
626 | sockArgSize = sizeof(mreq6); |
627 | memset(s: &mreq6, c: 0, n: sizeof(mreq6)); |
628 | Q_IPV6ADDR ip6 = groupAddress.toIPv6Address(); |
629 | memcpy(dest: &mreq6.ipv6mr_multiaddr, src: &ip6, n: sizeof(ip6)); |
630 | mreq6.ipv6mr_interface = interface.index(); |
631 | } else if (groupAddress.protocol() == QAbstractSocket::IPv4Protocol) { |
632 | level = IPPROTO_IP; |
633 | sockOpt = how4; |
634 | sockArg = &mreq4; |
635 | sockArgSize = sizeof(mreq4); |
636 | memset(s: &mreq4, c: 0, n: sizeof(mreq4)); |
637 | mreq4.imr_multiaddr.s_addr = htonl(hostlong: groupAddress.toIPv4Address()); |
638 | |
639 | if (interface.isValid()) { |
640 | const QList<QNetworkAddressEntry> addressEntries = interface.addressEntries(); |
641 | bool found = false; |
642 | for (const QNetworkAddressEntry &entry : addressEntries) { |
643 | const QHostAddress ip = entry.ip(); |
644 | if (ip.protocol() == QAbstractSocket::IPv4Protocol) { |
645 | mreq4.imr_interface.s_addr = htonl(hostlong: ip.toIPv4Address()); |
646 | found = true; |
647 | break; |
648 | } |
649 | } |
650 | if (!found) { |
651 | d->setError(error: QAbstractSocket::NetworkError, |
652 | errorString: QNativeSocketEnginePrivate::NetworkUnreachableErrorString); |
653 | return false; |
654 | } |
655 | } else { |
656 | mreq4.imr_interface.s_addr = INADDR_ANY; |
657 | } |
658 | } else { |
659 | // unreachable |
660 | d->setError(error: QAbstractSocket::UnsupportedSocketOperationError, |
661 | errorString: QNativeSocketEnginePrivate::ProtocolUnsupportedErrorString); |
662 | return false; |
663 | } |
664 | |
665 | int res = setsockopt(fd: d->socketDescriptor, level: level, optname: sockOpt, optval: sockArg, optlen: sockArgSize); |
666 | if (res == -1) { |
667 | switch (errno) { |
668 | case ENOPROTOOPT: |
669 | d->setError(error: QAbstractSocket::UnsupportedSocketOperationError, |
670 | errorString: QNativeSocketEnginePrivate::OperationUnsupportedErrorString); |
671 | break; |
672 | case EADDRNOTAVAIL: |
673 | d->setError(error: QAbstractSocket::SocketAddressNotAvailableError, |
674 | errorString: QNativeSocketEnginePrivate::AddressNotAvailableErrorString); |
675 | break; |
676 | default: |
677 | d->setError(error: QAbstractSocket::UnknownSocketError, |
678 | errorString: QNativeSocketEnginePrivate::UnknownSocketErrorString); |
679 | break; |
680 | } |
681 | return false; |
682 | } |
683 | return true; |
684 | } |
685 | |
686 | bool QNativeSocketEnginePrivate::nativeJoinMulticastGroup(const QHostAddress &groupAddress, |
687 | const QNetworkInterface &interface) |
688 | { |
689 | return multicastMembershipHelper(d: this, |
690 | IPV6_JOIN_GROUP, |
691 | IP_ADD_MEMBERSHIP, |
692 | groupAddress, |
693 | interface); |
694 | } |
695 | |
696 | bool QNativeSocketEnginePrivate::nativeLeaveMulticastGroup(const QHostAddress &groupAddress, |
697 | const QNetworkInterface &interface) |
698 | { |
699 | return multicastMembershipHelper(d: this, |
700 | IPV6_LEAVE_GROUP, |
701 | IP_DROP_MEMBERSHIP, |
702 | groupAddress, |
703 | interface); |
704 | } |
705 | |
706 | QNetworkInterface QNativeSocketEnginePrivate::nativeMulticastInterface() const |
707 | { |
708 | if (socketProtocol == QAbstractSocket::IPv6Protocol || socketProtocol == QAbstractSocket::AnyIPProtocol) { |
709 | uint v; |
710 | QT_SOCKOPTLEN_T sizeofv = sizeof(v); |
711 | if (::getsockopt(fd: socketDescriptor, IPPROTO_IPV6, IPV6_MULTICAST_IF, optval: &v, optlen: &sizeofv) == -1) |
712 | return QNetworkInterface(); |
713 | return QNetworkInterface::interfaceFromIndex(index: v); |
714 | } |
715 | |
716 | #if defined(Q_OS_SOLARIS) |
717 | struct in_addr v = { 0, 0, 0, 0}; |
718 | #else |
719 | struct in_addr v = { .s_addr: 0 }; |
720 | #endif |
721 | QT_SOCKOPTLEN_T sizeofv = sizeof(v); |
722 | if (::getsockopt(fd: socketDescriptor, IPPROTO_IP, IP_MULTICAST_IF, optval: &v, optlen: &sizeofv) == -1) |
723 | return QNetworkInterface(); |
724 | if (v.s_addr != 0 && sizeofv >= QT_SOCKOPTLEN_T(sizeof(v))) { |
725 | QHostAddress ipv4(ntohl(netlong: v.s_addr)); |
726 | QList<QNetworkInterface> ifaces = QNetworkInterface::allInterfaces(); |
727 | for (int i = 0; i < ifaces.size(); ++i) { |
728 | const QNetworkInterface &iface = ifaces.at(i); |
729 | QList<QNetworkAddressEntry> entries = iface.addressEntries(); |
730 | for (int j = 0; j < entries.size(); ++j) { |
731 | const QNetworkAddressEntry &entry = entries.at(i: j); |
732 | if (entry.ip() == ipv4) |
733 | return iface; |
734 | } |
735 | } |
736 | } |
737 | return QNetworkInterface(); |
738 | } |
739 | |
740 | bool QNativeSocketEnginePrivate::nativeSetMulticastInterface(const QNetworkInterface &iface) |
741 | { |
742 | if (socketProtocol == QAbstractSocket::IPv6Protocol || socketProtocol == QAbstractSocket::AnyIPProtocol) { |
743 | uint v = iface.index(); |
744 | return (::setsockopt(fd: socketDescriptor, IPPROTO_IPV6, IPV6_MULTICAST_IF, optval: &v, optlen: sizeof(v)) != -1); |
745 | } |
746 | |
747 | struct in_addr v; |
748 | if (iface.isValid()) { |
749 | QList<QNetworkAddressEntry> entries = iface.addressEntries(); |
750 | for (int i = 0; i < entries.size(); ++i) { |
751 | const QNetworkAddressEntry &entry = entries.at(i); |
752 | const QHostAddress &ip = entry.ip(); |
753 | if (ip.protocol() == QAbstractSocket::IPv4Protocol) { |
754 | v.s_addr = htonl(hostlong: ip.toIPv4Address()); |
755 | int r = ::setsockopt(fd: socketDescriptor, IPPROTO_IP, IP_MULTICAST_IF, optval: &v, optlen: sizeof(v)); |
756 | if (r != -1) |
757 | return true; |
758 | } |
759 | } |
760 | return false; |
761 | } |
762 | |
763 | v.s_addr = INADDR_ANY; |
764 | return (::setsockopt(fd: socketDescriptor, IPPROTO_IP, IP_MULTICAST_IF, optval: &v, optlen: sizeof(v)) != -1); |
765 | } |
766 | |
767 | #endif // QT_NO_NETWORKINTERFACE |
768 | |
769 | qint64 QNativeSocketEnginePrivate::nativeBytesAvailable() const |
770 | { |
771 | int nbytes = 0; |
772 | // gives shorter than true amounts on Unix domain sockets. |
773 | qint64 available = -1; |
774 | |
775 | #if defined (SO_NREAD) |
776 | if (socketType == QAbstractSocket::UdpSocket) { |
777 | socklen_t sz = sizeof nbytes; |
778 | if (!::getsockopt(socketDescriptor, SOL_SOCKET, SO_NREAD, &nbytes, &sz)) |
779 | available = nbytes; |
780 | } |
781 | #endif |
782 | |
783 | if (available == -1 && qt_safe_ioctl(sockfd: socketDescriptor, FIONREAD, arg: (char *) &nbytes) >= 0) |
784 | available = nbytes; |
785 | |
786 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
787 | qDebug("QNativeSocketEnginePrivate::nativeBytesAvailable() == %lli", available); |
788 | #endif |
789 | return available > 0 ? available : 0; |
790 | } |
791 | |
792 | bool QNativeSocketEnginePrivate::nativeHasPendingDatagrams() const |
793 | { |
794 | // Peek 1 bytes into the next message. |
795 | ssize_t readBytes; |
796 | char c; |
797 | QT_EINTR_LOOP(readBytes, ::recv(socketDescriptor, &c, 1, MSG_PEEK)); |
798 | |
799 | // If there's no error, or if our buffer was too small, there must be a |
800 | // pending datagram. |
801 | bool result = (readBytes != -1) || errno == EMSGSIZE; |
802 | |
803 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
804 | qDebug("QNativeSocketEnginePrivate::nativeHasPendingDatagrams() == %s", |
805 | result ? "true": "false"); |
806 | #endif |
807 | return result; |
808 | } |
809 | |
810 | qint64 QNativeSocketEnginePrivate::nativePendingDatagramSize() const |
811 | { |
812 | ssize_t recvResult = -1; |
813 | #ifdef Q_OS_LINUX |
814 | // Linux can return the actual datagram size if we use MSG_TRUNC |
815 | char c; |
816 | QT_EINTR_LOOP(recvResult, ::recv(socketDescriptor, &c, 1, MSG_PEEK | MSG_TRUNC)); |
817 | #elif defined(SO_NREAD) |
818 | // macOS can return the actual datagram size if we use SO_NREAD |
819 | int value; |
820 | socklen_t valuelen = sizeof(value); |
821 | recvResult = getsockopt(socketDescriptor, SOL_SOCKET, SO_NREAD, &value, &valuelen); |
822 | if (recvResult != -1) |
823 | recvResult = value; |
824 | #else |
825 | // We need to grow the buffer to fit the entire datagram. |
826 | // We start at 1500 bytes (the MTU for Ethernet V2), which should catch |
827 | // almost all uses (effective MTU for UDP under IPv4 is 1468), except |
828 | // for localhost datagrams and those reassembled by the IP layer. |
829 | char udpMessagePeekBuffer[1500]; |
830 | struct msghdr msg; |
831 | struct iovec vec; |
832 | |
833 | memset(&msg, 0, sizeof(msg)); |
834 | msg.msg_iov = &vec; |
835 | msg.msg_iovlen = 1; |
836 | vec.iov_base = udpMessagePeekBuffer; |
837 | vec.iov_len = sizeof(udpMessagePeekBuffer); |
838 | |
839 | for (;;) { |
840 | // the data written to udpMessagePeekBuffer is discarded, so |
841 | // this function is still reentrant although it might not look |
842 | // so. |
843 | recvResult = ::recvmsg(socketDescriptor, &msg, MSG_PEEK); |
844 | if (recvResult == -1 && errno == EINTR) |
845 | continue; |
846 | |
847 | // was the result truncated? |
848 | if ((msg.msg_flags & MSG_TRUNC) == 0) |
849 | break; |
850 | |
851 | // grow by 16 times |
852 | msg.msg_iovlen *= 16; |
853 | if (msg.msg_iov != &vec) |
854 | delete[] msg.msg_iov; |
855 | msg.msg_iov = new struct iovec[msg.msg_iovlen]; |
856 | std::fill_n(msg.msg_iov, msg.msg_iovlen, vec); |
857 | } |
858 | |
859 | if (msg.msg_iov != &vec) |
860 | delete[] msg.msg_iov; |
861 | #endif |
862 | |
863 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
864 | qDebug("QNativeSocketEnginePrivate::nativePendingDatagramSize() == %zd", recvResult); |
865 | #endif |
866 | |
867 | return qint64(recvResult); |
868 | } |
869 | |
870 | qint64 QNativeSocketEnginePrivate::nativeReceiveDatagram(char *data, qint64 maxSize, QIpPacketHeader *header, |
871 | QAbstractSocketEngine::PacketHeaderOptions options) |
872 | { |
873 | // we use quintptr to force the alignment |
874 | quintptr cbuf[(CMSG_SPACE(sizeof(struct in6_pktinfo)) + CMSG_SPACE(sizeof(int)) |
875 | #if !defined(IP_PKTINFO) && defined(IP_RECVIF) && defined(Q_OS_BSD4) |
876 | + CMSG_SPACE(sizeof(sockaddr_dl)) |
877 | #endif |
878 | #ifndef QT_NO_SCTP |
879 | + CMSG_SPACE(sizeof(struct sctp_sndrcvinfo)) |
880 | #endif |
881 | + sizeof(quintptr) - 1) / sizeof(quintptr)]; |
882 | |
883 | struct msghdr msg; |
884 | struct iovec vec; |
885 | qt_sockaddr aa; |
886 | char c; |
887 | memset(s: &msg, c: 0, n: sizeof(msg)); |
888 | memset(s: &aa, c: 0, n: sizeof(aa)); |
889 | |
890 | // we need to receive at least one byte, even if our user isn't interested in it |
891 | vec.iov_base = maxSize ? data : &c; |
892 | vec.iov_len = maxSize ? maxSize : 1; |
893 | msg.msg_iov = &vec; |
894 | msg.msg_iovlen = 1; |
895 | if (options & QAbstractSocketEngine::WantDatagramSender) { |
896 | msg.msg_name = &aa; |
897 | msg.msg_namelen = sizeof(aa); |
898 | } |
899 | if (options & (QAbstractSocketEngine::WantDatagramHopLimit | QAbstractSocketEngine::WantDatagramDestination |
900 | | QAbstractSocketEngine::WantStreamNumber)) { |
901 | msg.msg_control = cbuf; |
902 | msg.msg_controllen = sizeof(cbuf); |
903 | } |
904 | |
905 | ssize_t recvResult = 0; |
906 | do { |
907 | recvResult = ::recvmsg(fd: socketDescriptor, message: &msg, flags: 0); |
908 | } while (recvResult == -1 && errno == EINTR); |
909 | |
910 | if (recvResult == -1) { |
911 | switch (errno) { |
912 | #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN |
913 | case EWOULDBLOCK: |
914 | #endif |
915 | case EAGAIN: |
916 | // No datagram was available for reading |
917 | recvResult = -2; |
918 | break; |
919 | case ECONNREFUSED: |
920 | setError(error: QAbstractSocket::ConnectionRefusedError, errorString: ConnectionRefusedErrorString); |
921 | break; |
922 | default: |
923 | setError(error: QAbstractSocket::NetworkError, errorString: ReceiveDatagramErrorString); |
924 | } |
925 | if (header) |
926 | header->clear(); |
927 | } else if (options != QAbstractSocketEngine::WantNone) { |
928 | Q_ASSERT(header); |
929 | qt_socket_getPortAndAddress(s: &aa, port: &header->senderPort, addr: &header->senderAddress); |
930 | header->destinationPort = localPort; |
931 | header->endOfRecord = (msg.msg_flags & MSG_EOR) != 0; |
932 | |
933 | // parse the ancillary data |
934 | struct cmsghdr *cmsgptr; |
935 | QT_WARNING_PUSH |
936 | QT_WARNING_DISABLE_CLANG("-Wsign-compare") |
937 | for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != nullptr; |
938 | cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) { |
939 | QT_WARNING_POP |
940 | if (cmsgptr->cmsg_level == IPPROTO_IPV6 && cmsgptr->cmsg_type == IPV6_PKTINFO |
941 | && cmsgptr->cmsg_len >= CMSG_LEN(sizeof(in6_pktinfo))) { |
942 | in6_pktinfo *info = reinterpret_cast<in6_pktinfo *>(CMSG_DATA(cmsgptr)); |
943 | |
944 | header->destinationAddress.setAddress(reinterpret_cast<quint8 *>(&info->ipi6_addr)); |
945 | header->ifindex = info->ipi6_ifindex; |
946 | if (header->ifindex) |
947 | header->destinationAddress.setScopeId(QString::number(info->ipi6_ifindex)); |
948 | } |
949 | |
950 | #ifdef IP_PKTINFO |
951 | if (cmsgptr->cmsg_level == IPPROTO_IP && cmsgptr->cmsg_type == IP_PKTINFO |
952 | && cmsgptr->cmsg_len >= CMSG_LEN(sizeof(in_pktinfo))) { |
953 | in_pktinfo *info = reinterpret_cast<in_pktinfo *>(CMSG_DATA(cmsgptr)); |
954 | |
955 | header->destinationAddress.setAddress(ntohl(netlong: info->ipi_addr.s_addr)); |
956 | header->ifindex = info->ipi_ifindex; |
957 | } |
958 | #else |
959 | # ifdef IP_RECVDSTADDR |
960 | if (cmsgptr->cmsg_level == IPPROTO_IP && cmsgptr->cmsg_type == IP_RECVDSTADDR |
961 | && cmsgptr->cmsg_len >= CMSG_LEN(sizeof(in_addr))) { |
962 | in_addr *addr = reinterpret_cast<in_addr *>(CMSG_DATA(cmsgptr)); |
963 | |
964 | header->destinationAddress.setAddress(ntohl(addr->s_addr)); |
965 | } |
966 | # endif |
967 | # if defined(IP_RECVIF) && defined(Q_OS_BSD4) |
968 | if (cmsgptr->cmsg_level == IPPROTO_IP && cmsgptr->cmsg_type == IP_RECVIF |
969 | && cmsgptr->cmsg_len >= CMSG_LEN(sizeof(sockaddr_dl))) { |
970 | sockaddr_dl *sdl = reinterpret_cast<sockaddr_dl *>(CMSG_DATA(cmsgptr)); |
971 | header->ifindex = sdl->sdl_index; |
972 | } |
973 | # endif |
974 | #endif |
975 | |
976 | if (cmsgptr->cmsg_len == CMSG_LEN(sizeof(int)) |
977 | && ((cmsgptr->cmsg_level == IPPROTO_IPV6 && cmsgptr->cmsg_type == IPV6_HOPLIMIT) |
978 | || (cmsgptr->cmsg_level == IPPROTO_IP && cmsgptr->cmsg_type == IP_TTL))) { |
979 | static_assert(sizeof(header->hopLimit) == sizeof(int)); |
980 | memcpy(dest: &header->hopLimit, CMSG_DATA(cmsgptr), n: sizeof(header->hopLimit)); |
981 | } |
982 | |
983 | #ifndef QT_NO_SCTP |
984 | if (cmsgptr->cmsg_level == IPPROTO_SCTP && cmsgptr->cmsg_type == SCTP_SNDRCV |
985 | && cmsgptr->cmsg_len >= CMSG_LEN(sizeof(sctp_sndrcvinfo))) { |
986 | sctp_sndrcvinfo *rcvInfo = reinterpret_cast<sctp_sndrcvinfo *>(CMSG_DATA(cmsgptr)); |
987 | |
988 | header->streamNumber = int(rcvInfo->sinfo_stream); |
989 | } |
990 | #endif |
991 | } |
992 | } |
993 | |
994 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
995 | qDebug("QNativeSocketEnginePrivate::nativeReceiveDatagram(%p \"%s\", %lli, %s, %i) == %lli", |
996 | data, QtDebugUtils::toPrintable(data, recvResult, 16).constData(), maxSize, |
997 | (recvResult != -1 && options != QAbstractSocketEngine::WantNone) |
998 | ? header->senderAddress.toString().toLatin1().constData() : "(unknown)", |
999 | (recvResult != -1 && options != QAbstractSocketEngine::WantNone) |
1000 | ? header->senderPort : 0, (qint64) recvResult); |
1001 | #endif |
1002 | |
1003 | return qint64((maxSize || recvResult < 0) ? recvResult : Q_INT64_C(0)); |
1004 | } |
1005 | |
1006 | qint64 QNativeSocketEnginePrivate::nativeSendDatagram(const char *data, qint64 len, const QIpPacketHeader &header) |
1007 | { |
1008 | // we use quintptr to force the alignment |
1009 | quintptr cbuf[(CMSG_SPACE(sizeof(struct in6_pktinfo)) + CMSG_SPACE(sizeof(int)) |
1010 | #ifndef QT_NO_SCTP |
1011 | + CMSG_SPACE(sizeof(struct sctp_sndrcvinfo)) |
1012 | #endif |
1013 | + sizeof(quintptr) - 1) / sizeof(quintptr)]; |
1014 | |
1015 | struct cmsghdr *cmsgptr = reinterpret_cast<struct cmsghdr *>(cbuf); |
1016 | struct msghdr msg; |
1017 | struct iovec vec; |
1018 | qt_sockaddr aa; |
1019 | |
1020 | memset(s: &msg, c: 0, n: sizeof(msg)); |
1021 | memset(s: &aa, c: 0, n: sizeof(aa)); |
1022 | vec.iov_base = const_cast<char *>(data); |
1023 | vec.iov_len = len; |
1024 | msg.msg_iov = &vec; |
1025 | msg.msg_iovlen = 1; |
1026 | msg.msg_control = &cbuf; |
1027 | |
1028 | if (header.destinationPort != 0) { |
1029 | msg.msg_name = &aa.a; |
1030 | setPortAndAddress(port: header.destinationPort, address: header.destinationAddress, |
1031 | aa: &aa, sockAddrSize: &msg.msg_namelen); |
1032 | } |
1033 | |
1034 | if (msg.msg_namelen == sizeof(aa.a6)) { |
1035 | if (header.hopLimit != -1) { |
1036 | msg.msg_controllen += CMSG_SPACE(sizeof(int)); |
1037 | cmsgptr->cmsg_len = CMSG_LEN(sizeof(int)); |
1038 | cmsgptr->cmsg_level = IPPROTO_IPV6; |
1039 | cmsgptr->cmsg_type = IPV6_HOPLIMIT; |
1040 | memcpy(CMSG_DATA(cmsgptr), src: &header.hopLimit, n: sizeof(int)); |
1041 | cmsgptr = reinterpret_cast<cmsghdr *>(reinterpret_cast<char *>(cmsgptr) + CMSG_SPACE(sizeof(int))); |
1042 | } |
1043 | if (header.ifindex != 0 || !header.senderAddress.isNull()) { |
1044 | struct in6_pktinfo *data = reinterpret_cast<in6_pktinfo *>(CMSG_DATA(cmsgptr)); |
1045 | memset(s: data, c: 0, n: sizeof(*data)); |
1046 | msg.msg_controllen += CMSG_SPACE(sizeof(*data)); |
1047 | cmsgptr->cmsg_len = CMSG_LEN(sizeof(*data)); |
1048 | cmsgptr->cmsg_level = IPPROTO_IPV6; |
1049 | cmsgptr->cmsg_type = IPV6_PKTINFO; |
1050 | data->ipi6_ifindex = header.ifindex; |
1051 | |
1052 | QIPv6Address tmp = header.senderAddress.toIPv6Address(); |
1053 | memcpy(dest: &data->ipi6_addr, src: &tmp, n: sizeof(tmp)); |
1054 | cmsgptr = reinterpret_cast<cmsghdr *>(reinterpret_cast<char *>(cmsgptr) + CMSG_SPACE(sizeof(*data))); |
1055 | } |
1056 | } else { |
1057 | if (header.hopLimit != -1) { |
1058 | msg.msg_controllen += CMSG_SPACE(sizeof(int)); |
1059 | cmsgptr->cmsg_len = CMSG_LEN(sizeof(int)); |
1060 | cmsgptr->cmsg_level = IPPROTO_IP; |
1061 | cmsgptr->cmsg_type = IP_TTL; |
1062 | memcpy(CMSG_DATA(cmsgptr), src: &header.hopLimit, n: sizeof(int)); |
1063 | cmsgptr = reinterpret_cast<cmsghdr *>(reinterpret_cast<char *>(cmsgptr) + CMSG_SPACE(sizeof(int))); |
1064 | } |
1065 | |
1066 | #if defined(IP_PKTINFO) || defined(IP_SENDSRCADDR) |
1067 | if (header.ifindex != 0 || !header.senderAddress.isNull()) { |
1068 | # ifdef IP_PKTINFO |
1069 | struct in_pktinfo *data = reinterpret_cast<in_pktinfo *>(CMSG_DATA(cmsgptr)); |
1070 | memset(s: data, c: 0, n: sizeof(*data)); |
1071 | cmsgptr->cmsg_type = IP_PKTINFO; |
1072 | data->ipi_ifindex = header.ifindex; |
1073 | data->ipi_addr.s_addr = htonl(hostlong: header.senderAddress.toIPv4Address()); |
1074 | # elif defined(IP_SENDSRCADDR) |
1075 | struct in_addr *data = reinterpret_cast<in_addr *>(CMSG_DATA(cmsgptr)); |
1076 | cmsgptr->cmsg_type = IP_SENDSRCADDR; |
1077 | data->s_addr = htonl(header.senderAddress.toIPv4Address()); |
1078 | # endif |
1079 | cmsgptr->cmsg_level = IPPROTO_IP; |
1080 | msg.msg_controllen += CMSG_SPACE(sizeof(*data)); |
1081 | cmsgptr->cmsg_len = CMSG_LEN(sizeof(*data)); |
1082 | cmsgptr = reinterpret_cast<cmsghdr *>(reinterpret_cast<char *>(cmsgptr) + CMSG_SPACE(sizeof(*data))); |
1083 | } |
1084 | #endif |
1085 | } |
1086 | |
1087 | #ifndef QT_NO_SCTP |
1088 | if (header.streamNumber != -1) { |
1089 | struct sctp_sndrcvinfo *data = reinterpret_cast<sctp_sndrcvinfo *>(CMSG_DATA(cmsgptr)); |
1090 | memset(data, 0, sizeof(*data)); |
1091 | msg.msg_controllen += CMSG_SPACE(sizeof(sctp_sndrcvinfo)); |
1092 | cmsgptr->cmsg_len = CMSG_LEN(sizeof(sctp_sndrcvinfo)); |
1093 | cmsgptr->cmsg_level = IPPROTO_SCTP; |
1094 | cmsgptr->cmsg_type = SCTP_SNDRCV; |
1095 | data->sinfo_stream = uint16_t(header.streamNumber); |
1096 | cmsgptr = reinterpret_cast<cmsghdr *>(reinterpret_cast<char *>(cmsgptr) + CMSG_SPACE(sizeof(*data))); |
1097 | } |
1098 | #endif |
1099 | |
1100 | if (msg.msg_controllen == 0) |
1101 | msg.msg_control = nullptr; |
1102 | ssize_t sentBytes = qt_safe_sendmsg(sockfd: socketDescriptor, msg: &msg, flags: 0); |
1103 | |
1104 | if (sentBytes < 0) { |
1105 | switch (errno) { |
1106 | #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN |
1107 | case EWOULDBLOCK: |
1108 | #endif |
1109 | case EAGAIN: |
1110 | sentBytes = -2; |
1111 | break; |
1112 | case EMSGSIZE: |
1113 | setError(error: QAbstractSocket::DatagramTooLargeError, errorString: DatagramTooLargeErrorString); |
1114 | break; |
1115 | case ECONNRESET: |
1116 | setError(error: QAbstractSocket::RemoteHostClosedError, errorString: RemoteHostClosedErrorString); |
1117 | break; |
1118 | default: |
1119 | setError(error: QAbstractSocket::NetworkError, errorString: SendDatagramErrorString); |
1120 | } |
1121 | } |
1122 | |
1123 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
1124 | qDebug("QNativeSocketEngine::sendDatagram(%p \"%s\", %lli, \"%s\", %i) == %lli", data, |
1125 | QtDebugUtils::toPrintable(data, len, 16).constData(), len, |
1126 | header.destinationAddress.toString().toLatin1().constData(), |
1127 | header.destinationPort, (qint64) sentBytes); |
1128 | #endif |
1129 | |
1130 | return qint64(sentBytes); |
1131 | } |
1132 | |
1133 | bool QNativeSocketEnginePrivate::fetchConnectionParameters() |
1134 | { |
1135 | localPort = 0; |
1136 | localAddress.clear(); |
1137 | peerPort = 0; |
1138 | peerAddress.clear(); |
1139 | inboundStreamCount = outboundStreamCount = 0; |
1140 | |
1141 | if (socketDescriptor == -1) |
1142 | return false; |
1143 | |
1144 | qt_sockaddr sa; |
1145 | QT_SOCKLEN_T sockAddrSize = sizeof(sa); |
1146 | |
1147 | // Determine local address |
1148 | memset(s: &sa, c: 0, n: sizeof(sa)); |
1149 | if (::getsockname(fd: socketDescriptor, addr: &sa.a, len: &sockAddrSize) == 0) { |
1150 | qt_socket_getPortAndAddress(s: &sa, port: &localPort, addr: &localAddress); |
1151 | |
1152 | // Determine protocol family |
1153 | switch (sa.a.sa_family) { |
1154 | case AF_INET: |
1155 | socketProtocol = QAbstractSocket::IPv4Protocol; |
1156 | break; |
1157 | case AF_INET6: |
1158 | socketProtocol = QAbstractSocket::IPv6Protocol; |
1159 | break; |
1160 | default: |
1161 | socketProtocol = QAbstractSocket::UnknownNetworkLayerProtocol; |
1162 | break; |
1163 | } |
1164 | |
1165 | } else if (errno == EBADF) { |
1166 | setError(error: QAbstractSocket::UnsupportedSocketOperationError, errorString: InvalidSocketErrorString); |
1167 | return false; |
1168 | } |
1169 | |
1170 | #if defined (IPV6_V6ONLY) |
1171 | // determine if local address is dual mode |
1172 | // On linux, these are returned as "::" (==AnyIPv6) |
1173 | // On OSX, these are returned as "::FFFF:0.0.0.0" (==AnyIPv4) |
1174 | // in either case, the IPV6_V6ONLY option is cleared |
1175 | int ipv6only = 0; |
1176 | socklen_t optlen = sizeof(ipv6only); |
1177 | if (socketProtocol == QAbstractSocket::IPv6Protocol |
1178 | && (localAddress == QHostAddress::AnyIPv4 || localAddress == QHostAddress::AnyIPv6) |
1179 | && !getsockopt(fd: socketDescriptor, IPPROTO_IPV6, IPV6_V6ONLY, optval: (char*)&ipv6only, optlen: &optlen )) { |
1180 | if (optlen != sizeof(ipv6only)) |
1181 | qWarning(msg: "unexpected size of IPV6_V6ONLY socket option"); |
1182 | if (!ipv6only) { |
1183 | socketProtocol = QAbstractSocket::AnyIPProtocol; |
1184 | localAddress = QHostAddress::Any; |
1185 | } |
1186 | } |
1187 | #endif |
1188 | |
1189 | // Determine the remote address |
1190 | bool connected = ::getpeername(fd: socketDescriptor, addr: &sa.a, len: &sockAddrSize) == 0; |
1191 | if (connected) { |
1192 | qt_socket_getPortAndAddress(s: &sa, port: &peerPort, addr: &peerAddress); |
1193 | inboundStreamCount = outboundStreamCount = 1; |
1194 | } |
1195 | |
1196 | // Determine the socket type (UDP/TCP/SCTP) |
1197 | int value = 0; |
1198 | QT_SOCKOPTLEN_T valueSize = sizeof(int); |
1199 | if (::getsockopt(fd: socketDescriptor, SOL_SOCKET, SO_TYPE, optval: &value, optlen: &valueSize) == 0) { |
1200 | if (value == SOCK_STREAM) { |
1201 | #ifndef QT_NO_SCTP |
1202 | if (option(QNativeSocketEngine::MaxStreamsSocketOption) != -1) { |
1203 | socketType = QAbstractSocket::SctpSocket; |
1204 | if (connected) { |
1205 | sctp_status sctpStatus; |
1206 | QT_SOCKOPTLEN_T sctpStatusSize = sizeof(sctpStatus); |
1207 | sctp_event_subscribe sctpEvents; |
1208 | |
1209 | memset(&sctpEvents, 0, sizeof(sctpEvents)); |
1210 | sctpEvents.sctp_data_io_event = 1; |
1211 | if (::getsockopt(socketDescriptor, SOL_SCTP, SCTP_STATUS, &sctpStatus, |
1212 | &sctpStatusSize) == 0 && |
1213 | ::setsockopt(socketDescriptor, SOL_SCTP, SCTP_EVENTS, &sctpEvents, |
1214 | sizeof(sctpEvents)) == 0) { |
1215 | inboundStreamCount = int(sctpStatus.sstat_instrms); |
1216 | outboundStreamCount = int(sctpStatus.sstat_outstrms); |
1217 | } else { |
1218 | setError(QAbstractSocket::UnsupportedSocketOperationError, |
1219 | InvalidSocketErrorString); |
1220 | return false; |
1221 | } |
1222 | } |
1223 | } else { |
1224 | socketType = QAbstractSocket::TcpSocket; |
1225 | } |
1226 | #else |
1227 | socketType = QAbstractSocket::TcpSocket; |
1228 | #endif |
1229 | } else { |
1230 | if (value == SOCK_DGRAM) |
1231 | socketType = QAbstractSocket::UdpSocket; |
1232 | else |
1233 | socketType = QAbstractSocket::UnknownSocketType; |
1234 | } |
1235 | } |
1236 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
1237 | QString socketProtocolStr = QStringLiteral("UnknownProtocol"); |
1238 | if (socketProtocol == QAbstractSocket::IPv4Protocol) socketProtocolStr = QStringLiteral("IPv4Protocol"); |
1239 | else if (socketProtocol == QAbstractSocket::IPv6Protocol || socketProtocol == QAbstractSocket::AnyIPProtocol) socketProtocolStr = QStringLiteral("IPv6Protocol"); |
1240 | |
1241 | QString socketTypeStr = QStringLiteral("UnknownSocketType"); |
1242 | if (socketType == QAbstractSocket::TcpSocket) socketTypeStr = QStringLiteral("TcpSocket"); |
1243 | else if (socketType == QAbstractSocket::UdpSocket) socketTypeStr = QStringLiteral("UdpSocket"); |
1244 | else if (socketType == QAbstractSocket::SctpSocket) socketTypeStr = QStringLiteral("SctpSocket"); |
1245 | |
1246 | qDebug("QNativeSocketEnginePrivate::fetchConnectionParameters() local == %s:%i," |
1247 | " peer == %s:%i, socket == %s - %s, inboundStreamCount == %i, outboundStreamCount == %i", |
1248 | localAddress.toString().toLatin1().constData(), localPort, |
1249 | peerAddress.toString().toLatin1().constData(), peerPort,socketTypeStr.toLatin1().constData(), |
1250 | socketProtocolStr.toLatin1().constData(), inboundStreamCount, outboundStreamCount); |
1251 | #endif |
1252 | return true; |
1253 | } |
1254 | |
1255 | void QNativeSocketEnginePrivate::nativeClose() |
1256 | { |
1257 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
1258 | qDebug("QNativeSocketEngine::nativeClose()"); |
1259 | #endif |
1260 | |
1261 | qt_safe_close(fd: socketDescriptor); |
1262 | } |
1263 | |
1264 | qint64 QNativeSocketEnginePrivate::nativeWrite(const char *data, qint64 len) |
1265 | { |
1266 | Q_Q(QNativeSocketEngine); |
1267 | |
1268 | ssize_t writtenBytes; |
1269 | writtenBytes = qt_safe_write_nosignal(fd: socketDescriptor, data, len); |
1270 | |
1271 | if (writtenBytes < 0) { |
1272 | switch (errno) { |
1273 | case EPIPE: |
1274 | case ECONNRESET: |
1275 | writtenBytes = -1; |
1276 | setError(error: QAbstractSocket::RemoteHostClosedError, errorString: RemoteHostClosedErrorString); |
1277 | q->close(); |
1278 | break; |
1279 | #if EWOULDBLOCK != EAGAIN |
1280 | case EWOULDBLOCK: |
1281 | #endif |
1282 | case EAGAIN: |
1283 | writtenBytes = 0; |
1284 | break; |
1285 | case EMSGSIZE: |
1286 | setError(error: QAbstractSocket::DatagramTooLargeError, errorString: DatagramTooLargeErrorString); |
1287 | break; |
1288 | default: |
1289 | break; |
1290 | } |
1291 | } |
1292 | |
1293 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
1294 | qDebug("QNativeSocketEnginePrivate::nativeWrite(%p \"%s\", %llu) == %i", data, |
1295 | QtDebugUtils::toPrintable(data, len, 16).constData(), len, (int) writtenBytes); |
1296 | #endif |
1297 | |
1298 | return qint64(writtenBytes); |
1299 | } |
1300 | /* |
1301 | */ |
1302 | qint64 QNativeSocketEnginePrivate::nativeRead(char *data, qint64 maxSize) |
1303 | { |
1304 | Q_Q(QNativeSocketEngine); |
1305 | if (!q->isValid()) { |
1306 | qWarning(msg: "QNativeSocketEngine::nativeRead: Invalid socket"); |
1307 | return -1; |
1308 | } |
1309 | |
1310 | ssize_t r = 0; |
1311 | r = qt_safe_read(fd: socketDescriptor, data, maxlen: maxSize); |
1312 | |
1313 | if (r < 0) { |
1314 | r = -1; |
1315 | switch (errno) { |
1316 | #if EWOULDBLOCK-0 && EWOULDBLOCK != EAGAIN |
1317 | case EWOULDBLOCK: |
1318 | #endif |
1319 | case EAGAIN: |
1320 | // No data was available for reading |
1321 | r = -2; |
1322 | break; |
1323 | case ECONNRESET: |
1324 | #if defined(Q_OS_VXWORKS) |
1325 | case ESHUTDOWN: |
1326 | #endif |
1327 | r = 0; |
1328 | break; |
1329 | case ETIMEDOUT: |
1330 | socketError = QAbstractSocket::SocketTimeoutError; |
1331 | break; |
1332 | default: |
1333 | socketError = QAbstractSocket::NetworkError; |
1334 | break; |
1335 | } |
1336 | |
1337 | if (r == -1) { |
1338 | hasSetSocketError = true; |
1339 | socketErrorString = qt_error_string(); |
1340 | } |
1341 | } |
1342 | |
1343 | #if defined (QNATIVESOCKETENGINE_DEBUG) |
1344 | qDebug("QNativeSocketEnginePrivate::nativeRead(%p \"%s\", %llu) == %zd", data, |
1345 | QtDebugUtils::toPrintable(data, r, 16).constData(), maxSize, r); |
1346 | #endif |
1347 | |
1348 | return qint64(r); |
1349 | } |
1350 | |
1351 | int QNativeSocketEnginePrivate::nativeSelect(QDeadlineTimer deadline, bool selectForRead) const |
1352 | { |
1353 | bool dummy; |
1354 | return nativeSelect(deadline, checkRead: selectForRead, checkWrite: !selectForRead, selectForRead: &dummy, selectForWrite: &dummy); |
1355 | } |
1356 | |
1357 | #ifndef Q_OS_WASM |
1358 | |
1359 | int QNativeSocketEnginePrivate::nativeSelect(QDeadlineTimer deadline, bool checkRead, |
1360 | bool checkWrite, bool *selectForRead, |
1361 | bool *selectForWrite) const |
1362 | { |
1363 | pollfd pfd = qt_make_pollfd(fd: socketDescriptor, events: 0); |
1364 | |
1365 | if (checkRead) |
1366 | pfd.events |= POLLIN; |
1367 | |
1368 | if (checkWrite) |
1369 | pfd.events |= POLLOUT; |
1370 | |
1371 | const int ret = qt_safe_poll(fds: &pfd, nfds: 1, deadline); |
1372 | |
1373 | if (ret <= 0) |
1374 | return ret; |
1375 | |
1376 | if (pfd.revents & POLLNVAL) { |
1377 | errno = EBADF; |
1378 | return -1; |
1379 | } |
1380 | |
1381 | static const short read_flags = POLLIN | POLLHUP | POLLERR; |
1382 | static const short write_flags = POLLOUT | POLLERR; |
1383 | |
1384 | *selectForRead = ((pfd.revents & read_flags) != 0); |
1385 | *selectForWrite = ((pfd.revents & write_flags) != 0); |
1386 | |
1387 | return ret; |
1388 | } |
1389 | |
1390 | #else |
1391 | |
1392 | int QNativeSocketEnginePrivate::nativeSelect(QDeadlineTimer deadline, bool checkRead, |
1393 | bool checkWrite, bool *selectForRead, |
1394 | bool *selectForWrite) const |
1395 | { |
1396 | *selectForRead = checkRead; |
1397 | *selectForWrite = checkWrite; |
1398 | bool socketDisconnect = false; |
1399 | QEventDispatcherWasm::socketSelect(deadline.remainingTime(), socketDescriptor, checkRead, |
1400 | checkWrite, selectForRead, selectForWrite, |
1401 | &socketDisconnect); |
1402 | |
1403 | // The disconnect/close handling code in QAbstractsScket::canReadNotification() |
1404 | // does not detect remote disconnect properly; do that here as a workardound. |
1405 | if (socketDisconnect) |
1406 | receiver->closeNotification(); |
1407 | |
1408 | return 1; |
1409 | } |
1410 | |
1411 | #endif // Q_OS_WASM |
1412 | |
1413 | QT_END_NAMESPACE |
1414 |
Definitions
- qt_socket_getPortAndAddress
- convertToLevelAndOption
- createNewSocket
- option
- setOption
- nativeConnect
- nativeBind
- nativeListen
- nativeAccept
- multicastMembershipHelper
- nativeJoinMulticastGroup
- nativeLeaveMulticastGroup
- nativeMulticastInterface
- nativeSetMulticastInterface
- nativeBytesAvailable
- nativeHasPendingDatagrams
- nativePendingDatagramSize
- nativeReceiveDatagram
- nativeSendDatagram
- fetchConnectionParameters
- nativeClose
- nativeWrite
- nativeRead
- nativeSelect
Learn to use CMake with our Intro Training
Find out more