/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtNetwork module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <winsock2.h>
#include "qnativesocketengine_p.h"
#include <qabstracteventdispatcher.h>
#include <qsocketnotifier.h>
#include <qdebug.h>
#include <qdatetime.h>
//#define QNATIVESOCKETENGINE_DEBUG
#if defined(QNATIVESOCKETENGINE_DEBUG)
# include <qstring.h>
# include <qbytearray.h>
#endif
QT_BEGIN_NAMESPACE
#if defined(QNATIVESOCKETENGINE_DEBUG)
void verboseWSErrorDebug(int r)
{
switch (r) {
case WSANOTINITIALISED : qDebug("WSA error : WSANOTINITIALISED"); break;
case WSAEINTR: qDebug("WSA error : WSAEINTR"); break;
case WSAEBADF: qDebug("WSA error : WSAEBADF"); break;
case WSAEACCES: qDebug("WSA error : WSAEACCES"); break;
case WSAEFAULT: qDebug("WSA error : WSAEFAULT"); break;
case WSAEINVAL: qDebug("WSA error : WSAEINVAL"); break;
case WSAEMFILE: qDebug("WSA error : WSAEMFILE"); break;
case WSAEWOULDBLOCK: qDebug("WSA error : WSAEWOULDBLOCK"); break;
case WSAEINPROGRESS: qDebug("WSA error : WSAEINPROGRESS"); break;
case WSAEALREADY: qDebug("WSA error : WSAEALREADY"); break;
case WSAENOTSOCK: qDebug("WSA error : WSAENOTSOCK"); break;
case WSAEDESTADDRREQ: qDebug("WSA error : WSAEDESTADDRREQ"); break;
case WSAEMSGSIZE: qDebug("WSA error : WSAEMSGSIZE"); break;
case WSAEPROTOTYPE: qDebug("WSA error : WSAEPROTOTYPE"); break;
case WSAENOPROTOOPT: qDebug("WSA error : WSAENOPROTOOPT"); break;
case WSAEPROTONOSUPPORT: qDebug("WSA error : WSAEPROTONOSUPPORT"); break;
case WSAESOCKTNOSUPPORT: qDebug("WSA error : WSAESOCKTNOSUPPORT"); break;
case WSAEOPNOTSUPP: qDebug("WSA error : WSAEOPNOTSUPP"); break;
case WSAEPFNOSUPPORT: qDebug("WSA error : WSAEPFNOSUPPORT"); break;
case WSAEAFNOSUPPORT: qDebug("WSA error : WSAEAFNOSUPPORT"); break;
case WSAEADDRINUSE: qDebug("WSA error : WSAEADDRINUSE"); break;
case WSAEADDRNOTAVAIL: qDebug("WSA error : WSAEADDRNOTAVAIL"); break;
case WSAENETDOWN: qDebug("WSA error : WSAENETDOWN"); break;
case WSAENETUNREACH: qDebug("WSA error : WSAENETUNREACH"); break;
case WSAENETRESET: qDebug("WSA error : WSAENETRESET"); break;
case WSAECONNABORTED: qDebug("WSA error : WSAECONNABORTED"); break;
case WSAECONNRESET: qDebug("WSA error : WSAECONNRESET"); break;
case WSAENOBUFS: qDebug("WSA error : WSAENOBUFS"); break;
case WSAEISCONN: qDebug("WSA error : WSAEISCONN"); break;
case WSAENOTCONN: qDebug("WSA error : WSAENOTCONN"); break;
case WSAESHUTDOWN: qDebug("WSA error : WSAESHUTDOWN"); break;
case WSAETOOMANYREFS: qDebug("WSA error : WSAETOOMANYREFS"); break;
case WSAETIMEDOUT: qDebug("WSA error : WSAETIMEDOUT"); break;
case WSAECONNREFUSED: qDebug("WSA error : WSAECONNREFUSED"); break;
case WSAELOOP: qDebug("WSA error : WSAELOOP"); break;
case WSAENAMETOOLONG: qDebug("WSA error : WSAENAMETOOLONG"); break;
case WSAEHOSTDOWN: qDebug("WSA error : WSAEHOSTDOWN"); break;
case WSAEHOSTUNREACH: qDebug("WSA error : WSAEHOSTUNREACH"); break;
case WSAENOTEMPTY: qDebug("WSA error : WSAENOTEMPTY"); break;
case WSAEPROCLIM: qDebug("WSA error : WSAEPROCLIM"); break;
case WSAEUSERS: qDebug("WSA error : WSAEUSERS"); break;
case WSAEDQUOT: qDebug("WSA error : WSAEDQUOT"); break;
case WSAESTALE: qDebug("WSA error : WSAESTALE"); break;
case WSAEREMOTE: qDebug("WSA error : WSAEREMOTE"); break;
case WSAEDISCON: qDebug("WSA error : WSAEDISCON"); break;
default: qDebug("WSA error : Unknown"); break;
}
qErrnoWarning(r, "more details");
}
/*
Returns a human readable representation of the first \a len
characters in \a data.
*/
static QByteArray qt_prettyDebug(const char *data, int len, int maxLength)
{
if (!data) return "(null)";
QByteArray out;
for (int i = 0; i < len; ++i) {
char c = data[i];
if (isprint(int(uchar(c)))) {
out += c;
} else switch (c) {
case '\n': out += "\\n"; break;
case '\r': out += "\\r"; break;
case '\t': out += "\\t"; break;
default:
QString tmp;
tmp.sprintf("\\%o", c);
out += tmp.toLatin1().constData();
}
}
if (len < maxLength)
out += "...";
return out;
}
#define WS_ERROR_DEBUG(x) verboseWSErrorDebug(x);
#else
#define WS_ERROR_DEBUG(x) Q_UNUSED(x)
#endif
#ifndef AF_INET6
#define AF_INET6 23 /* Internetwork Version 6 */
#endif
#ifndef SO_EXCLUSIVEADDRUSE
#define SO_EXCLUSIVEADDRUSE ((int)(~SO_REUSEADDR)) /* disallow local address reuse */
#endif
//###
#define QT_SOCKLEN_T int
#define QT_SOCKOPTLEN_T int
/*
Extracts the port and address from a sockaddr, and stores them in
\a port and \a addr if they are non-null.
*/
static inline void qt_socket_getPortAndAddress(SOCKET socketDescriptor, const qt_sockaddr *sa, quint16 *port, QHostAddress *address)
{
#if !defined (QT_NO_IPV6)
if (sa->a.sa_family == AF_INET6) {
const qt_sockaddr_in6 *sa6 = &sa->a6;
Q_IPV6ADDR tmp;
for (int i = 0; i < 16; ++i)
tmp.c[i] = sa6->sin6_addr.qt_s6_addr[i];
QHostAddress a;
a.setAddress(tmp);
if (address)
*address = a;
if (port)
WSANtohs(socketDescriptor, sa6->sin6_port, port);
} else
#endif
if (sa->a.sa_family == AF_INET) {
const sockaddr_in *sa4 = &sa->a4;
unsigned long addr;
WSANtohl(socketDescriptor, sa4->sin_addr.s_addr, &addr);
QHostAddress a;
a.setAddress(addr);
if (address)
*address = a;
if (port)
WSANtohs(socketDescriptor, sa4->sin_port, port);
}
}
/*! \internal
Sets the port and address to a sockaddr. Requires that sa point to the IPv6 struct if the address is IPv6.
*/
static inline void qt_socket_setPortAndAddress(SOCKET socketDescriptor, sockaddr_in * sockAddrIPv4, qt_sockaddr_in6 * sockAddrIPv6,
quint16 port, const QHostAddress & address, sockaddr ** sockAddrPtr, QT_SOCKLEN_T *sockAddrSize)
{
#if !defined(QT_NO_IPV6)
if (address.protocol() == QAbstractSocket::IPv6Protocol) {
memset(sockAddrIPv6, 0, sizeof(qt_sockaddr_in6));
sockAddrIPv6->sin6_family = AF_INET6;
WSAHtons(socketDescriptor, port, &(sockAddrIPv6->sin6_port));
Q_IPV6ADDR tmp = address.toIPv6Address();
memcpy(&(sockAddrIPv6->sin6_addr.qt_s6_addr), &tmp, sizeof(tmp));
*sockAddrSize = sizeof(qt_sockaddr_in6);
*sockAddrPtr = (struct sockaddr *) sockAddrIPv6;
} else
#endif
if (address.protocol() == QAbstractSocket::IPv4Protocol
|| address.protocol() == QAbstractSocket::UnknownNetworkLayerProtocol) {
memset(sockAddrIPv4, 0, sizeof(sockaddr_in));
sockAddrIPv4->sin_family = AF_INET;
WSAHtons(socketDescriptor, port, &(sockAddrIPv4->sin_port));
WSAHtonl(socketDescriptor, address.toIPv4Address(), &(sockAddrIPv4->sin_addr.s_addr));
*sockAddrSize = sizeof(sockaddr_in);
*sockAddrPtr = (struct sockaddr *) sockAddrIPv4;
} else {
// unreachable
}
}
/*! \internal
*/
static inline QAbstractSocket::SocketType qt_socket_getType(int socketDescriptor)
{
int value = 0;
QT_SOCKLEN_T valueSize = sizeof(value);
if (::getsockopt(socketDescriptor, SOL_SOCKET, SO_TYPE, (char *) &value, &valueSize) != 0) {
WS_ERROR_DEBUG(WSAGetLastError());
} else {
if (value == SOCK_STREAM)
return QAbstractSocket::TcpSocket;
else if (value == SOCK_DGRAM)
return QAbstractSocket::UdpSocket;
}
return QAbstractSocket::UnknownSocketType;
}
/*! \internal
*/
static inline int qt_socket_getMaxMsgSize(int socketDescriptor)
{
int value = 0;
QT_SOCKLEN_T valueSize = sizeof(value);
if (::getsockopt(socketDescriptor, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *) &value, &valueSize) != 0) {
WS_ERROR_DEBUG(WSAGetLastError());
}
return value;
}
QWindowsSockInit::QWindowsSockInit()
: version(0)
{
//### should we try for 2.2 on all platforms ??
WSAData wsadata;
// IPv6 requires Winsock v2.0 or better.
if (WSAStartup(MAKEWORD(2,0), &wsadata) != 0) {
qWarning("QTcpSocketAPI: WinSock v2.0 initialization failed.");
} else {
version = 0x20;
}
}
QWindowsSockInit::~QWindowsSockInit()
{
WSACleanup();
}
// MS Transport Provider IOCTL to control
// reporting PORT_UNREACHABLE messages
// on UDP sockets via recv/WSARecv/etc.
// Path TRUE in input buffer to enable (default if supported),
// FALSE to disable.
#ifndef SIO_UDP_CONNRESET
# ifndef IOC_VENDOR
# define IOC_VENDOR 0x18000000
# endif
# ifndef _WSAIOW
# define _WSAIOW(x,y) (IOC_IN|(x)|(y))
# endif
# define SIO_UDP_CONNRESET _WSAIOW(IOC_VENDOR,12)
#endif
bool QNativeSocketEnginePrivate::createNewSocket(QAbstractSocket::SocketType socketType, QAbstractSocket::NetworkLayerProtocol socketProtocol)
{
//### no ip6 support on winsocket 1.1 but we will try not to use this !!!!!!!!!!!!1
/*
if (winsockVersion < 0x20 && socketProtocol == QAbstractSocket::IPv6Protocol) {
//### no ip6 support
return -1;
}
*/
int protocol = (socketProtocol == QAbstractSocket::IPv6Protocol) ? AF_INET6 : AF_INET;
int type = (socketType == QAbstractSocket::UdpSocket) ? SOCK_DGRAM : SOCK_STREAM;
// MSDN KB179942 states that on winnt 4 WSA_FLAG_OVERLAPPED is needed if socket is to be non blocking
// and recomends alwasy doing it for cross windows version comapablity.
SOCKET socket = ::WSASocket(protocol, type, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
if (socket == INVALID_SOCKET) {
int err = WSAGetLastError();
WS_ERROR_DEBUG(err);
switch (err) {
case WSANOTINITIALISED:
//###
break;
case WSAEAFNOSUPPORT:
case WSAESOCKTNOSUPPORT:
case WSAEPROTOTYPE:
case WSAEINVAL:
setError(QAbstractSocket::UnsupportedSocketOperationError, ProtocolUnsupportedErrorString);
break;
case WSAEMFILE:
case WSAENOBUFS:
setError(QAbstractSocket::SocketResourceError, ResourceErrorString);
break;
default:
break;
}
return false;
}
#if !defined(Q_OS_WINCE)
// enable new behavior using
// SIO_UDP_CONNRESET
DWORD dwBytesReturned = 0;
int bNewBehavior = 1;
if (::WSAIoctl(socket, SIO_UDP_CONNRESET, &bNewBehavior, sizeof(bNewBehavior),
NULL, 0, &dwBytesReturned, NULL, NULL) == SOCKET_ERROR) {
// not to worry isBogusUdpReadNotification() should handle this otherwise
int err = WSAGetLastError();
WS_ERROR_DEBUG(err);
}
#endif
socketDescriptor = socket;
return true;
}
/*! \internal
Returns the value of the socket option \a opt.
*/
int QNativeSocketEnginePrivate::option(QNativeSocketEngine::SocketOption opt) const
{
Q_Q(const QNativeSocketEngine);
if (!q->isValid())
return -1;
int n = -1;
int level = SOL_SOCKET; // default
switch (opt) {
case QNativeSocketEngine::ReceiveBufferSocketOption:
n = SO_RCVBUF;
break;
case QNativeSocketEngine::SendBufferSocketOption:
n = SO_SNDBUF;
break;
case QNativeSocketEngine::BroadcastSocketOption:
n = SO_BROADCAST;
break;
case QNativeSocketEngine::NonBlockingSocketOption: {
unsigned long buf = 0;
if (WSAIoctl(socketDescriptor, FIONBIO, 0,0, &buf, sizeof(buf), 0,0,0) == 0)
return buf;
else
return -1;
break;
}
case QNativeSocketEngine::AddressReusable:
n = SO_REUSEADDR;
break;
case QNativeSocketEngine::BindExclusively:
n = SO_EXCLUSIVEADDRUSE;
break;
case QNativeSocketEngine::ReceiveOutOfBandData:
n = SO_OOBINLINE;
break;
case QNativeSocketEngine::LowDelayOption:
level = IPPROTO_TCP;
n = TCP_NODELAY;
break;
case QNativeSocketEngine::KeepAliveOption:
n = SO_KEEPALIVE;
break;
}
int v = -1;
QT_SOCKOPTLEN_T len = sizeof(v);
if (getsockopt(socketDescriptor, level, n, (char *) &v, &len) != -1)
return v;
return -1;
}
/*! \internal
Sets the socket option \a opt to \a v.
*/
bool QNativeSocketEnginePrivate::setOption(QNativeSocketEngine::SocketOption opt, int v)
{
Q_Q(const QNativeSocketEngine);
if (!q->isValid())
return false;
int n = 0;
int level = SOL_SOCKET; // default
switch (opt) {
case QNativeSocketEngine::ReceiveBufferSocketOption:
n = SO_RCVBUF;
break;
case QNativeSocketEngine::SendBufferSocketOption:
n = SO_SNDBUF;
break;
case QNativeSocketEngine::BroadcastSocketOption:
n = SO_BROADCAST;
break;
case QNativeSocketEngine::NonBlockingSocketOption:
{
unsigned long buf = v;
unsigned long outBuf;
DWORD sizeWritten = 0;
if (::WSAIoctl(socketDescriptor, FIONBIO, &buf, sizeof(unsigned long), &outBuf, sizeof(unsigned long), &sizeWritten, 0,0) == SOCKET_ERROR) {
WS_ERROR_DEBUG(WSAGetLastError());
return false;
}
return true;
break;
}
case QNativeSocketEngine::AddressReusable:
n = SO_REUSEADDR;
break;
case QNativeSocketEngine::BindExclusively:
n = SO_EXCLUSIVEADDRUSE;
break;
case QNativeSocketEngine::ReceiveOutOfBandData:
n = SO_OOBINLINE;
break;
case QNativeSocketEngine::LowDelayOption:
level = IPPROTO_TCP;
n = TCP_NODELAY;
break;
case QNativeSocketEngine::KeepAliveOption:
n = SO_KEEPALIVE;
break;
}
if (::setsockopt(socketDescriptor, level, n, (char*)&v, sizeof(v)) != 0) {
WS_ERROR_DEBUG(WSAGetLastError());
return false;
}
return true;
}
/*!
Fetches information about both ends of the connection: whatever is
available.
*/
bool QNativeSocketEnginePrivate::fetchConnectionParameters()
{
localPort = 0;
localAddress.clear();
peerPort = 0;
peerAddress.clear();
if (socketDescriptor == -1)
return false;
qt_sockaddr sa;
QT_SOCKLEN_T sockAddrSize = sizeof(sa);
// Determine local address
memset(&sa, 0, sizeof(sa));
if (::getsockname(socketDescriptor, &sa.a, &sockAddrSize) == 0) {
qt_socket_getPortAndAddress(socketDescriptor, &sa, &localPort, &localAddress);
// Determine protocol family
switch (sa.a.sa_family) {
case AF_INET:
socketProtocol = QAbstractSocket::IPv4Protocol;
break;
#if !defined (QT_NO_IPV6)
case AF_INET6:
socketProtocol = QAbstractSocket::IPv6Protocol;
break;
#endif
default:
socketProtocol = QAbstractSocket::UnknownNetworkLayerProtocol;
break;
}
} else {
int err = WSAGetLastError();
WS_ERROR_DEBUG(err);
if (err == WSAENOTSOCK) {
setError(QAbstractSocket::UnsupportedSocketOperationError,
InvalidSocketErrorString);
return false;
}
}
memset(&sa, 0, sizeof(sa));
if (::getpeername(socketDescriptor, &sa.a, &sockAddrSize) == 0) {
qt_socket_getPortAndAddress(socketDescriptor, &sa, &peerPort, &peerAddress);
} else {
WS_ERROR_DEBUG(WSAGetLastError());
}
socketType = qt_socket_getType(socketDescriptor);
#if defined (QNATIVESOCKETENGINE_DEBUG)
QString socketProtocolStr = "UnknownProtocol";
if (socketProtocol == QAbstractSocket::IPv4Protocol) socketProtocolStr = "IPv4Protocol";
else if (socketProtocol == QAbstractSocket::IPv6Protocol) socketProtocolStr = "IPv6Protocol";
QString socketTypeStr = "UnknownSocketType";
if (socketType == QAbstractSocket::TcpSocket) socketTypeStr = "TcpSocket";
else if (socketType == QAbstractSocket::UdpSocket) socketTypeStr = "UdpSocket";
qDebug("QNativeSocketEnginePrivate::fetchConnectionParameters() localAddress == %s, localPort = %i, peerAddress == %s, peerPort = %i, socketProtocol == %s, socketType == %s", localAddress.toString().toLatin1().constData(), localPort, peerAddress.toString().toLatin1().constData(), peerPort, socketProtocolStr.toLatin1().constData(), socketTypeStr.toLatin1().constData());
#endif
return true;
}
bool QNativeSocketEnginePrivate::nativeConnect(const QHostAddress &address, quint16 port)
{
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeConnect() to %s :: %i", address.toString().toLatin1().constData(), port);
#endif
struct sockaddr_in sockAddrIPv4;
qt_sockaddr_in6 sockAddrIPv6;
struct sockaddr *sockAddrPtr = 0;
QT_SOCKLEN_T sockAddrSize = 0;
qt_socket_setPortAndAddress(socketDescriptor, &sockAddrIPv4, &sockAddrIPv6, port, address, &sockAddrPtr, &sockAddrSize);
forever {
int connectResult = ::WSAConnect(socketDescriptor, sockAddrPtr, sockAddrSize, 0,0,0,0);
if (connectResult == SOCKET_ERROR) {
int err = WSAGetLastError();
WS_ERROR_DEBUG(err);
switch (err) {
case WSANOTINITIALISED:
//###
break;
case WSAEISCONN:
socketState = QAbstractSocket::ConnectedState;
break;
case WSAEWOULDBLOCK: {
// If WSAConnect returns WSAEWOULDBLOCK on the second
// connection attempt, we have to check SO_ERROR's
// value to detect ECONNREFUSED. If we don't get
// ECONNREFUSED, we'll have to treat it as an
// unfinished operation.
int value = 0;
QT_SOCKLEN_T valueSize = sizeof(value);
if (::getsockopt(socketDescriptor, SOL_SOCKET, SO_ERROR, (char *) &value, &valueSize) == 0) {
if (value == WSAECONNREFUSED) {
setError(QAbstractSocket::ConnectionRefusedError, ConnectionRefusedErrorString);
socketState = QAbstractSocket::UnconnectedState;
break;
}
if (value == WSAETIMEDOUT) {
setError(QAbstractSocket::NetworkError, ConnectionTimeOutErrorString);
socketState = QAbstractSocket::UnconnectedState;
break;
}
if (value == WSAEHOSTUNREACH) {
setError(QAbstractSocket::NetworkError, HostUnreachableErrorString);
socketState = QAbstractSocket::UnconnectedState;
break;
}
}
// fall through
}
case WSAEINPROGRESS:
setError(QAbstractSocket::UnfinishedSocketOperationError, InvalidSocketErrorString);
socketState = QAbstractSocket::ConnectingState;
break;
case WSAEADDRINUSE:
setError(QAbstractSocket::NetworkError, AddressInuseErrorString);
break;
case WSAECONNREFUSED:
setError(QAbstractSocket::ConnectionRefusedError, ConnectionRefusedErrorString);
socketState = QAbstractSocket::UnconnectedState;
break;
case WSAETIMEDOUT:
setError(QAbstractSocket::NetworkError, ConnectionTimeOutErrorString);
break;
case WSAEACCES:
setError(QAbstractSocket::SocketAccessError, AccessErrorString);
socketState = QAbstractSocket::UnconnectedState;
break;
case WSAEHOSTUNREACH:
setError(QAbstractSocket::NetworkError, HostUnreachableErrorString);
socketState = QAbstractSocket::UnconnectedState;
break;
case WSAENETUNREACH:
setError(QAbstractSocket::NetworkError, NetworkUnreachableErrorString);
socketState = QAbstractSocket::UnconnectedState;
break;
case WSAEINVAL:
case WSAEALREADY:
setError(QAbstractSocket::UnfinishedSocketOperationError, InvalidSocketErrorString);
break;
default:
break;
}
if (socketState != QAbstractSocket::ConnectedState) {
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeConnect(%s, %i) == false (%s)",
address.toString().toLatin1().constData(), port,
socketState == QAbstractSocket::ConnectingState
? "Connection in progress" : socketErrorString.toLatin1().constData());
#endif
return false;
}
}
break;
}
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeConnect(%s, %i) == true",
address.toString().toLatin1().constData(), port);
#endif
socketState = QAbstractSocket::ConnectedState;
return true;
}
bool QNativeSocketEnginePrivate::nativeBind(const QHostAddress &address, quint16 port)
{
struct sockaddr_in sockAddrIPv4;
qt_sockaddr_in6 sockAddrIPv6;
struct sockaddr *sockAddrPtr = 0;
QT_SOCKLEN_T sockAddrSize = 0;
qt_socket_setPortAndAddress(socketDescriptor, &sockAddrIPv4, &sockAddrIPv6, port, address, &sockAddrPtr, &sockAddrSize);
int bindResult = ::bind(socketDescriptor, sockAddrPtr, sockAddrSize);
if (bindResult == SOCKET_ERROR) {
int err = WSAGetLastError();
WS_ERROR_DEBUG(err);
switch (err) {
case WSANOTINITIALISED:
//###
break;
case WSAEADDRINUSE:
case WSAEINVAL:
setError(QAbstractSocket::AddressInUseError, AddressInuseErrorString);
break;
case WSAEACCES:
setError(QAbstractSocket::SocketAccessError, AddressProtectedErrorString);
break;
case WSAEADDRNOTAVAIL:
setError(QAbstractSocket::SocketAddressNotAvailableError, AddressNotAvailableErrorString);
break;
default:
break;
}
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeBind(%s, %i) == false (%s)",
address.toString().toLatin1().constData(), port, socketErrorString.toLatin1().constData());
#endif
return false;
}
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeBind(%s, %i) == true",
address.toString().toLatin1().constData(), port);
#endif
socketState = QAbstractSocket::BoundState;
return true;
}
bool QNativeSocketEnginePrivate::nativeListen(int backlog)
{
if (::listen(socketDescriptor, backlog) == SOCKET_ERROR) {
int err = WSAGetLastError();
WS_ERROR_DEBUG(err);
switch (err) {
case WSANOTINITIALISED:
//###
break;
case WSAEADDRINUSE:
setError(QAbstractSocket::AddressInUseError,
PortInuseErrorString);
break;
default:
break;
}
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeListen(%i) == false (%s)",
backlog, socketErrorString.toLatin1().constData());
#endif
return false;
}
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeListen(%i) == true", backlog);
#endif
socketState = QAbstractSocket::ListeningState;
return true;
}
int QNativeSocketEnginePrivate::nativeAccept()
{
int acceptedDescriptor = WSAAccept(socketDescriptor, 0,0,0,0);
if (acceptedDescriptor != -1 && QAbstractEventDispatcher::instance()) {
// Becuase of WSAAsyncSelect() WSAAccept returns a non blocking socket
// with the same attributes as the listening socket including the current
// WSAAsyncSelect(). To be able to change the socket to blocking mode the
// WSAAsyncSelect() call must be cancled.
QSocketNotifier n(acceptedDescriptor, QSocketNotifier::Read);
n.setEnabled(true);
n.setEnabled(false);
}
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeAccept() == %i", acceptedDescriptor);
#endif
return acceptedDescriptor;
}
qint64 QNativeSocketEnginePrivate::nativeBytesAvailable() const
{
unsigned long nbytes = 0;
unsigned long dummy = 0;
DWORD sizeWritten = 0;
if (::WSAIoctl(socketDescriptor, FIONREAD, &dummy, sizeof(dummy), &nbytes, sizeof(nbytes), &sizeWritten, 0,0) == SOCKET_ERROR) {
WS_ERROR_DEBUG(WSAGetLastError());
return -1;
}
// ioctlsocket sometimes reports 1 byte available for datagrams
// while the following recvfrom returns -1 and claims connection
// was reset (udp is connectionless). so we peek one byte to
// catch this case and return 0 bytes available if recvfrom
// fails.
if (nbytes == 1 && socketType == QAbstractSocket::UdpSocket) {
char c;
WSABUF buf;
buf.buf = &c;
buf.len = sizeof(c);
DWORD flags = MSG_PEEK;
if (::WSARecvFrom(socketDescriptor, &buf, 1, 0, &flags, 0,0,0,0) == SOCKET_ERROR)
return 0;
}
return nbytes;
}
bool QNativeSocketEnginePrivate::nativeHasPendingDatagrams() const
{
#if !defined(Q_OS_WINCE)
// Create a sockaddr struct and reset its port number.
qt_sockaddr storage;
QT_SOCKLEN_T storageSize = sizeof(storage);
memset(&storage, 0, storageSize);
bool result = false;
// Peek 0 bytes into the next message. The size of the message may
// well be 0, so we check if there was a sender.
char c;
WSABUF buf;
buf.buf = &c;
buf.len = sizeof(c);
DWORD available = 0;
DWORD flags = MSG_PEEK;
int ret = ::WSARecvFrom(socketDescriptor, &buf, 1, &available, &flags, &storage.a, &storageSize,0,0);
int err = WSAGetLastError();
if (ret == SOCKET_ERROR && err != WSAEMSGSIZE) {
WS_ERROR_DEBUG(err);
if (err == WSAECONNRESET) {
// Discard error message to prevent QAbstractSocket from
// getting this message repeatedly after reenabling the
// notifiers.
flags = 0;
::WSARecvFrom(socketDescriptor, &buf, 1, &available, &flags,
&storage.a, &storageSize, 0, 0);
}
} else {
// If there's no error, or if our buffer was too small, there must be
// a pending datagram.
result = true;
}
#else // Q_OS_WINCE
bool result = false;
fd_set readS;
FD_ZERO(&readS);
FD_SET(socketDescriptor, &readS);
timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 5000;
int available = ::select(1, &readS, 0, 0, &timeout);
result = available > 0 ? true : false;
#endif
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeHasPendingDatagrams() == %s",
result ? "true" : "false");
#endif
return result;
}
qint64 QNativeSocketEnginePrivate::nativePendingDatagramSize() const
{
qint64 ret = -1;
#if !defined(Q_OS_WINCE)
int recvResult = 0;
DWORD flags;
DWORD bufferCount = 5;
WSABUF * buf = 0;
for (;;) {
// the data written to udpMessagePeekBuffer is discarded, so
// this function is still reentrant although it might not look
// so.
static char udpMessagePeekBuffer[8192];
buf = new WSABUF[bufferCount];
for (DWORD i=0; i<bufferCount; i++) {
buf[i].buf = udpMessagePeekBuffer;
buf[i].len = sizeof(udpMessagePeekBuffer);
}
flags = MSG_PEEK;
DWORD bytesRead = 0;
recvResult = ::WSARecv(socketDescriptor, buf, bufferCount, &bytesRead, &flags, 0,0);
int err = WSAGetLastError();
if (recvResult != SOCKET_ERROR) {
ret = qint64(bytesRead);
break;
} else if (recvResult == SOCKET_ERROR && err == WSAEMSGSIZE) {
bufferCount += 5;
delete[] buf;
} else if (recvResult == SOCKET_ERROR) {
WS_ERROR_DEBUG(err);
ret = -1;
break;
}
}
if (buf)
delete[] buf;
#else // Q_OS_WINCE
DWORD size = -1;
DWORD bytesReturned;
int ioResult = WSAIoctl(socketDescriptor, FIONREAD, 0,0, &size, sizeof(size), &bytesReturned, 0, 0);
if (ioResult == SOCKET_ERROR) {
int err = WSAGetLastError();
WS_ERROR_DEBUG(err);
} else {
ret = qint64(size);
}
#endif
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativePendingDatagramSize() == %li", ret);
#endif
return ret;
}
qint64 QNativeSocketEnginePrivate::nativeReceiveDatagram(char *data, qint64 maxLength,
QHostAddress *address, quint16 *port)
{
qint64 ret = 0;
qt_sockaddr aa;
memset(&aa, 0, sizeof(aa));
QT_SOCKLEN_T sz;
sz = sizeof(aa);
WSABUF buf;
buf.buf = data;
buf.len = maxLength;
#if !defined(Q_OS_WINCE)
buf.buf = data;
buf.len = maxLength;
#else
char tmpChar;
buf.buf = data ? data : &tmpChar;
buf.len = maxLength;
#endif
DWORD flags = 0;
DWORD bytesRead = 0;
int wsaRet = ::WSARecvFrom(socketDescriptor, &buf, 1, &bytesRead, &flags, &aa.a, &sz,0,0);
if (wsaRet == SOCKET_ERROR) {
int err = WSAGetLastError();
if (err == WSAEMSGSIZE) {
// it is ok the buffer was to small if bytesRead is larger than
// maxLength then assume bytes read is really maxLenth
ret = qint64(bytesRead) > maxLength ? maxLength : qint64(bytesRead);
} else {
WS_ERROR_DEBUG(err);
setError(QAbstractSocket::NetworkError, ReceiveDatagramErrorString);
ret = -1;
}
} else {
ret = qint64(bytesRead);
}
qt_socket_getPortAndAddress(socketDescriptor, &aa, port, address);
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeReceiveDatagram(%p \"%s\", %li, %s, %i) == %li",
data, qt_prettyDebug(data, qMin<qint64>(ret, 16), ret).data(), maxLength,
address ? address->toString().toLatin1().constData() : "(nil)",
port ? *port : 0, ret);
#endif
return ret;
}
qint64 QNativeSocketEnginePrivate::nativeSendDatagram(const char *data, qint64 len,
const QHostAddress &address, quint16 port)
{
qint64 ret = -1;
struct sockaddr_in sockAddrIPv4;
qt_sockaddr_in6 sockAddrIPv6;
struct sockaddr *sockAddrPtr = 0;
QT_SOCKLEN_T sockAddrSize = 0;
qt_socket_setPortAndAddress(socketDescriptor, &sockAddrIPv4, &sockAddrIPv6, port, address, &sockAddrPtr, &sockAddrSize);
WSABUF buf;
#if !defined(Q_OS_WINCE)
buf.buf = len ? (char*)data : 0;
#else
char tmp;
buf.buf = len ? (char*)data : &tmp;
#endif
buf.len = len;
DWORD flags = 0;
DWORD bytesSent = 0;
if (::WSASendTo(socketDescriptor, &buf, 1, &bytesSent, flags, sockAddrPtr, sockAddrSize, 0,0) == SOCKET_ERROR) {
int err = WSAGetLastError();
WS_ERROR_DEBUG(err);
switch (err) {
case WSAEMSGSIZE:
setError(QAbstractSocket::DatagramTooLargeError, DatagramTooLargeErrorString);
break;
default:
setError(QAbstractSocket::NetworkError, SendDatagramErrorString);
break;
}
ret = -1;
} else {
ret = qint64(bytesSent);
}
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeSendDatagram(%p \"%s\", %li, \"%s\", %i) == %li", data,
qt_prettyDebug(data, qMin<qint64>(len, 16), len).data(), 0, address.toString().toLatin1().constData(),
port, ret);
#endif
return ret;
}
qint64 QNativeSocketEnginePrivate::nativeWrite(const char *data, qint64 len)
{
Q_Q(QNativeSocketEngine);
qint64 ret = 0;
qint64 bytesToSend = len;
for (;;) {
WSABUF buf;
buf.buf = (char*)data + ret;
buf.len = bytesToSend;
DWORD flags = 0;
DWORD bytesWritten = 0;
int socketRet = ::WSASend(socketDescriptor, &buf, 1, &bytesWritten, flags, 0,0);
ret += qint64(bytesWritten);
int err;
if (socketRet != SOCKET_ERROR) {
if (ret == len)
break;
else
continue;
} else if ((err = WSAGetLastError()) == WSAEWOULDBLOCK) {
break;
} else if (err == WSAENOBUFS) {
// this function used to not send more than 49152 per call to WSASendTo
// to avoid getting a WSAENOBUFS. However this is a performance regression
// and we think it only appears with old windows versions. We now handle the
// WSAENOBUFS and hope it never appears anyway.
// just go on, the next loop run we will try a smaller number
} else {
WS_ERROR_DEBUG(err);
switch (err) {
case WSAECONNRESET:
case WSAECONNABORTED:
ret = -1;
setError(QAbstractSocket::NetworkError, WriteErrorString);
q->close();
break;
default:
break;
}
break;
}
// for next send:
bytesToSend = qMin<qint64>(49152, len - ret);
}
#if defined (QNATIVESOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeWrite(%p \"%s\", %li) == %li",
data, qt_prettyDebug(data, qMin((int)ret, 16), (int)ret).data(), (int)len, (int)ret);
#endif
return ret;
}
qint64 QNativeSocketEnginePrivate::nativeRead(char *data, qint64 maxLength)
{
qint64 ret = -1;
WSABUF buf;
buf.buf = data;
buf.len = maxLength;
DWORD flags = 0;
DWORD bytesRead = 0;
#if defined(Q_OS_WINCE)
WSASetLastError(0);
#endif
if (::WSARecv(socketDescriptor, &buf, 1, &bytesRead, &flags, 0,0) == SOCKET_ERROR) {
int err = WSAGetLastError();
WS_ERROR_DEBUG(err);
switch (err) {
case WSAEWOULDBLOCK:
ret = -2;
break;
case WSAEBADF:
case WSAEINVAL:
//error string is now set in read(), not here in nativeRead()
break;
case WSAECONNRESET:
case WSAECONNABORTED:
// for tcp sockets this will be handled in QNativeSocketEngine::read
ret = 0;
break;
default:
break;
}
} else {
if (WSAGetLastError() == WSAEWOULDBLOCK)
ret = -2;
else
ret = qint64(bytesRead);
}
#if defined (QNATIVESOCKETENGINE_DEBUG)
if (ret != -2) {
qDebug("QNativeSocketEnginePrivate::nativeRead(%p \"%s\", %l) == %li",
data, qt_prettyDebug(data, qMin((int)bytesRead, 16), (int)bytesRead).data(), (int)maxLength, (int)ret);
} else {
qDebug("QNativeSocketEnginePrivate::nativeRead(%p, %l) == -2 (WOULD BLOCK)",
data, int(maxLength));
}
#endif
return ret;
}
int QNativeSocketEnginePrivate::nativeSelect(int timeout, bool selectForRead) const
{
bool readEnabled = selectForRead && readNotifier && readNotifier->isEnabled();
if (readEnabled)
readNotifier->setEnabled(false);
fd_set fds;
int ret = 0;
memset(&fds, 0, sizeof(fd_set));
fds.fd_count = 1;
fds.fd_array[0] = socketDescriptor;
struct timeval tv;
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
if (selectForRead) {
ret = select(0, &fds, 0, 0, timeout < 0 ? 0 : &tv);
} else {
// select for write
// Windows needs this to report errors when connecting a socket ...
fd_set fdexception;
FD_ZERO(&fdexception);
FD_SET(socketDescriptor, &fdexception);
ret = select(0, 0, &fds, &fdexception, timeout < 0 ? 0 : &tv);
// ... but if it is actually set, pretend it did not happen
if (ret > 0 && FD_ISSET(socketDescriptor, &fdexception))
ret--;
}
if (readEnabled)
readNotifier->setEnabled(true);
return ret;
}
int QNativeSocketEnginePrivate::nativeSelect(int timeout,
bool checkRead, bool checkWrite,
bool *selectForRead, bool *selectForWrite) const
{
bool readEnabled = checkRead && readNotifier && readNotifier->isEnabled();
if (readEnabled)
readNotifier->setEnabled(false);
fd_set fdread;
fd_set fdwrite;
fd_set fdexception;
int ret = 0;
memset(&fdread, 0, sizeof(fd_set));
if (checkRead) {
fdread.fd_count = 1;
fdread.fd_array[0] = socketDescriptor;
}
memset(&fdwrite, 0, sizeof(fd_set));
FD_ZERO(&fdexception);
if (checkWrite) {
fdwrite.fd_count = 1;
fdwrite.fd_array[0] = socketDescriptor;
// Windows needs this to report errors when connecting a socket
FD_SET(socketDescriptor, &fdexception);
}
struct timeval tv;
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
#if !defined(Q_OS_WINCE)
ret = select(socketDescriptor + 1, &fdread, &fdwrite, &fdexception, timeout < 0 ? 0 : &tv);
#else
ret = select(1, &fdread, &fdwrite, &fdexception, timeout < 0 ? 0 : &tv);
#endif
//... but if it is actually set, pretend it did not happen
if (ret > 0 && FD_ISSET(socketDescriptor, &fdexception))
ret--;
if (readEnabled)
readNotifier->setEnabled(true);
if (ret <= 0)
return ret;
*selectForRead = FD_ISSET(socketDescriptor, &fdread);
*selectForWrite = FD_ISSET(socketDescriptor, &fdwrite);
return ret;
}
void QNativeSocketEnginePrivate::nativeClose()
{
#if defined (QTCPSOCKETENGINE_DEBUG)
qDebug("QNativeSocketEnginePrivate::nativeClose()");
#endif
// We were doing a setsockopt here before with SO_DONTLINGER. (However with kind of wrong
// usage of parameters, it wants a BOOL but we used a struct and pretended it to be bool).
// We don't think setting this option should be done here, if a user wants it she/he can
// do it manually with socketDescriptor()/setSocketDescriptor();
::closesocket(socketDescriptor);
}
QT_END_NAMESPACE