QT4 TcpSocket bind问题

转自http://www.cnblogs.com/F-32/archive/2012/03/23/2414204.html

Author F32 (feng32@163.com)

The code is released under the terms of GNU Lesser General Public License version 2.1

Here's the code.

#ifndef Q_BOUND_TCP_SOCKET_H
#define Q_BOUND_TCP_SOCKET_H

#include <QTcpSocket>

/**
 * \brief The QBoundTcpSocket class adds binding support
 * to tcp client sockets.
 *
 * In Qt 4, it's impossible to bind a tcp client socket to
 * a specific port or ip address.
 *
 * This feature has been added to Qt 5, however with version 4, 
 * it's still possible to do binding while getting convenience from
 * the Qt framework.
 * 
 * Note:
 * 
 * Due to usage of native api, the class currently not supports
 * platforms other than Linux. If you are familiar with 
 * native programming interfaces like winsock, porting the code
 * to other operations systems may be just a piece of cake.
 * 
 * A QBoundTcpSocket object will bind and connect to the server
 * at the same time, because the only way to work around is to
 * create a socket, bind, connect to server with native API from the
 * OS, and then pass the socket to QTcpSocket::setSocketDescriptor
 * with a connected state.
 */

class QBoundTcpSocket : public QTcpSocket
{
public:
    /**
     * \brief Bind the socket and then connect to server
     *
     * Note:
     * 
     * Before calling, the socket must be in the unconnected state, 
     * otherwise a value of false is returned.
     * 
     * Typical usage:
     * \code
     * QBoundTcpSocket socket;
     * if (socket.bindAndConnect("192.168.1.10", 0, "10.0.0.1", 80))
     * {
     *     // Now bound and connected
     * }
     * else
     * {
     *     qDebug() << "An error occurred in QBoundTcpSocket::bindAndConnect";
     * }
     * \endcode
     *
     * \param localAddr Local IP address (e.g., "10.0.0.10").
     *                  A value of "0.0.0.0" indicates that 
     *                  the default ip address will be used.
     * \param localPort Local port (e.g., 12345). 
     *                  A value of 0 indicates that any port is acceptable.
     * \param serverAddr IP address of the server (e.g., "10.0.0.1")
     * \param serverPort Port of the server (e.g., 80)
     *
     * \return The return value is true when both binding and connecting 
     *         are successful, and false otherwise.
*/
     bool bindAndConnect(const QString &localAddr, quint16 localPort, 
                         const QString &serverAddr, quint16 serverPort);
};

#endif /* Q_BOUND_TCP_SOCKET_H */

#include "QBoundTcpSocket.h"

#ifdef Q_OS_LINUX
    #include <arpa/inet.h>
#endif

bool QBoundTcpSocket::bindAndConnect(const QString &localAddr, quint16 localPort, 
                                     const QString &serverAddr, quint16 serverPort)
{
#ifdef Q_OS_LINUX
    int sockfd;
    int result;
    struct sockaddr_in localSockAddr;
    struct sockaddr_in serverSockAddr;
    bzero(&localSockAddr, sizeof(localSockAddr));
    bzero(&serverSockAddr, sizeof(serverSockAddr));
    
    // create socket
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if( sockfd == -1 ) 
    {
        qDebug() << "QBoundTcpSocket: Cannot create socket";
        return false;
    }
    
    // bind
    localSockAddr.sin_family = AF_INET;
    localSockAddr.sin_port = htons(localPort);
    localSockAddr.sin_addr.s_addr = inet_addr(localAddr.toLocal8Bit().data());

    result = bind(sockfd, (struct sockaddr *)&localSockAddr, sizeof(localSockAddr));
    if( result == -1 ) 
    {
        qDebug() << "QBoundTcpSocket: Cannot bind socket";
        return false;
    }
    
    // connect
    serverSockAddr.sin_family = AF_INET;
    serverSockAddr.sin_port = htons(serverPort);
    serverSockAddr.sin_addr.s_addr = inet_addr(serverAddr.toLocal8Bit().data());

    result = ::connect(sockfd, (struct sockaddr *)&serverSockAddr, sizeof(serverSockAddr));
    if( result == -1 ) 
    {
        qDebug() << "QBoundTcpSocket: Cannot connect to server";
        return false;
    }
    
    // set socket descriptor
    if( !setSocketDescriptor(sockfd, QAbstractSocket::ConnectedState))
    {
        qDebug() << "QBoundTcpSocket: Cannot set socket descriptor";
        return false;
    }
    
    return true;
#else
    qDebug() << "QBoundTcpSocket for Windows/Mac OS is not implemented yet";
    return false;
#endif
}