msocketdevice.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the Qt3Support module of the Qt Toolkit.
**
** This file may be used under the terms of the GNU General Public
** License versions 2.0 or 3.0 as published by the Free Software
** Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file.  Alternatively you may (at
** your option) use any later version of the GNU General Public
** License if such license has been publicly approved by Trolltech ASA
** (or its successors, if any) and the KDE Free Qt Foundation. In
** addition, as a special exception, Trolltech gives you certain
** additional rights. These rights are described in the Trolltech GPL
** Exception version 1.2, which can be found at
** http://www.trolltech.com/products/qt/gplexception/ and in the file
** GPL_EXCEPTION.txt in this package.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/. If
** you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** In addition, as a special exception, Trolltech, as the sole
** copyright holder for Qt Designer, grants users of the Qt/Eclipse
** Integration plug-in the right for the Qt/Eclipse Integration to
** link to functionality provided by Qt Designer and its related
** libraries.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not expressly
** granted herein.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include "msocketdevice.h"

#include "qwindowdefs.h"
#include <string.h>

//#define MSOCKETDEVICE_DEBUG


class MSocketDevicePrivate
{

public:
    MSocketDevicePrivate(MSocketDevice::Protocol p)
            : protocol(p)
    { }

    MSocketDevice::Protocol protocol;
};


MSocketDevice::MSocketDevice(int socket, Type type)
        : fd(socket), t(type), p(0), pp(0), e(NoError),
        d(new MSocketDevicePrivate(Unknown))
{
#if defined(MSOCKETDEVICE_DEBUG)
    qDebug("MSocketDevice: Created MSocketDevice %p (socket %x, type %d)",
           this, socket, type);
#endif
    init();
    setSocket(socket, type);
}

MSocketDevice::MSocketDevice(Type type)
        : fd(-1), t(type), p(0), pp(0), e(NoError),
        d(new MSocketDevicePrivate(Unknown))
{
#if defined(MSOCKETDEVICE_DEBUG)
    qDebug("MSocketDevice: Created MSocketDevice object %p, type %d",
           this, type);
#endif
    init();
    setSocket(createNewSocket(), type);
}

MSocketDevice::MSocketDevice(Type type, Protocol protocol, int)
        : fd(-1), t(type), p(0), pp(0), e(NoError),
        d(new MSocketDevicePrivate(protocol))
{
#if defined(MSOCKETDEVICE_DEBUG)
    qDebug("MSocketDevice: Created MSocketDevice object %p, type %d",
           this, type);
#endif
    init();
    setSocket(createNewSocket(), type);
}

MSocketDevice::~MSocketDevice()
{
    close();
    delete d;
    d = 0;
#if defined(MSOCKETDEVICE_DEBUG)
    qDebug("MSocketDevice: Destroyed MSocketDevice %p", this);
#endif
}


bool MSocketDevice::isValid() const
{
    return fd != -1;
}


MSocketDevice::Type MSocketDevice::type() const
{
    return t;
}

MSocketDevice::Protocol MSocketDevice::protocol() const
{
    if (d->protocol == Unknown)
        d->protocol = getProtocol();

    return d->protocol;
}

void MSocketDevice::setProtocol(Protocol protocol)
{
    d->protocol = protocol;
}

int MSocketDevice::socket() const
{
    return fd;
}


void MSocketDevice::setSocket(int socket, Type type)
{
    if (fd != -1)     // close any open socket
        close();

#if defined(MSOCKETDEVICE_DEBUG)
    qDebug("MSocketDevice::setSocket: socket %x, type %d", socket, type);

#endif
    t = type;

    fd = socket;

    d->protocol = Unknown;

    e = NoError;

    //resetStatus();
    open(ReadWrite);

    fetchConnectionParameters();
}


bool MSocketDevice::open(OpenMode mode)
{
    if (isOpen() || !isValid())
        return false;

#if defined(MSOCKETDEVICE_DEBUG)
    qDebug("MSocketDevice::open: mode %x", mode);

#endif
    setOpenMode((mode & ReadWrite) | Unbuffered);

    return true;
}

bool MSocketDevice::flush()
{
    return true;
}


qint64 MSocketDevice::size() const
{
    return 0;
}


qint64 MSocketDevice::pos() const
{
    return 0;
}


bool MSocketDevice::seek(qint64 /* pos */)
{
    return true;
}


bool MSocketDevice::atEnd() const
{
    return bytesAvailable() <= 0;
}

bool MSocketDevice::broadcast() const
{
    return option(Broadcast);
}

void MSocketDevice::setBroadcast(bool enable)
{
    setOption(Broadcast, enable);
}

bool MSocketDevice::addressReusable() const
{
    return option(ReuseAddress);
}


void MSocketDevice::setAddressReusable(bool enable)
{
    setOption(ReuseAddress, enable);
}


bool MSocketDevice::keepalive() const
{
    return option(Keepalive);
}

void MSocketDevice::setKeepalive(bool enable)
{
    setOption(Keepalive, enable);
}


int MSocketDevice::receiveBufferSize() const
{
    return option(ReceiveBuffer);
}


void MSocketDevice::setReceiveBufferSize(uint size)
{
    setOption(ReceiveBuffer, size);
}


int MSocketDevice::sendBufferSize() const
{
    return option(SendBuffer);
}


void MSocketDevice::setSendBufferSize(uint size)
{
    setOption(SendBuffer, size);
}


quint16 MSocketDevice::port() const
{
    return p;
}


QHostAddress MSocketDevice::address() const
{

    QString ipaddress;

    if (a.toString().startsWith("0:0:0:0:0:FFFF:"))
    {
        Q_IPV6ADDR addr = a.toIPv6Address();
        // addr contains 16 unsigned characters

        ipaddress = QString("%1.%2.%3.%4").arg(addr[12]).arg(addr[13]).arg(addr[14]).arg(addr[15]);
    }
    else
        ipaddress = a.toString();

    return QHostAddress(ipaddress);
}


MSocketDevice::Error MSocketDevice::error() const
{
    return e;
}


void MSocketDevice::setError(Error err)
{
    e = err;
}

---