k3socketbase.h

/*  -*- C++ -*-
 *  Copyright (C) 2003,2005 Thiago Macieira <[email protected]>
 *
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included
 *  in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

/*
 * Even before our #ifdef, clean up the namespace
 */
#ifdef socket
#undef socket
#endif

#ifdef bind
#undef bind
#endif

#ifdef listen
#undef listen
#endif

#ifdef connect
#undef connect
#endif

#ifdef accept
#undef accept
#endif

#ifdef getpeername
#undef getpeername
#endif

#ifdef getsockname
#undef getsockname
#endif

#ifndef KSOCKETBASE_H
#define KSOCKETBASE_H

#include <QIODevice>
#include <QString>

#include <kdelibs4support_export.h>
#include "k3socketaddress.h"

class QMutex;

namespace KNetwork
{

class KResolverEntry;
class KSocketDevice;

class KSocketBasePrivate;
class KDELIBS4SUPPORT_DEPRECATED_EXPORT KSocketBase
{
public:
    enum SocketOptions {
        Blocking = 0x01,
        AddressReuseable = 0x02,
        IPv6Only = 0x04,
        Keepalive = 0x08,
        Broadcast = 0x10,
        NoDelay = 0x20
    };

    enum SocketError {
        NoError = 0,
        LookupFailure,
        AddressInUse,
        AlreadyCreated,
        AlreadyBound,
        AlreadyConnected,
        NotConnected,
        NotBound,
        NotCreated,
        WouldBlock,
        ConnectionRefused,
        ConnectionTimedOut,
        InProgress,
        NetFailure,
        NotSupported,
        Timeout,
        UnknownError,
        RemotelyDisconnected
    };

public:
    KSocketBase();

    virtual ~KSocketBase();

    /*
     * The following functions are shared by all descended classes and will have
     * to be reimplemented.
     */

protected:
    virtual bool setSocketOptions(int opts);

    virtual int socketOptions() const;

public:
    virtual bool setBlocking(bool enable);

    bool blocking() const;

    virtual bool setAddressReuseable(bool enable);

    bool addressReuseable() const;

    virtual bool setIPv6Only(bool enable);

    bool isIPv6Only() const;

    virtual bool setBroadcast(bool enable);

    bool broadcast() const;

    virtual bool setNoDelay(bool enable);

    bool noDelay() const;

    KSocketDevice *socketDevice() const;

    virtual void setSocketDevice(KSocketDevice *device);

    int setRequestedCapabilities(int add, int remove = 0);

protected:
    bool hasDevice() const;

    void setError(SocketError error);

    void resetError();

public:
    SocketError error() const;

    QString errorString() const;

    QMutex *mutex() const;

public:
    static QString errorString(SocketError code);

    static bool isFatalError(int code);

private:
    void unsetSocketDevice();

    KSocketBase(const KSocketBase &);
    KSocketBase &operator =(const KSocketBase &);

    KSocketBasePrivate *const d;

    friend class KSocketDevice;
};

class KDELIBS4SUPPORT_DEPRECATED_EXPORT KActiveSocketBase: public QIODevice, virtual public KSocketBase
{
    Q_OBJECT
public:
    KActiveSocketBase(QObject *parent);

    virtual ~KActiveSocketBase();

    QString errorString() const;

    void setSocketDevice(KSocketDevice *device) override;

    bool open(OpenMode mode) override;

    virtual bool bind(const KResolverEntry &address) = 0;

    virtual bool connect(const KResolverEntry &address,
                         OpenMode mode = ReadWrite) = 0;

    virtual bool disconnect() = 0;

    bool isSequential() const override;

    qint64 size() const override;

    qint64 pos() const override;

    bool seek(qint64) override;

    bool atEnd() const override;

    qint64 read(char *data, qint64 maxlen);

    QByteArray read(qint64 len);

    qint64 read(char *data, qint64 maxlen, KSocketAddress &from);

    qint64 peek(char *data, qint64 maxlen);

    qint64 peek(char *data, qint64 maxlen, KSocketAddress &from);

    qint64 write(const char *data, qint64 len);

    qint64 write(const QByteArray &data);

    qint64 write(const char *data, qint64 len, const KSocketAddress &to);

    virtual qint64 waitForMore(int msecs, bool *timeout = nullptr) = 0;

    void ungetChar(char);

    virtual KSocketAddress localAddress() const = 0;

    virtual KSocketAddress peerAddress() const = 0;

    // FIXME KDE 4.0:
    // enable this function
#if 0

    virtual KSocketAddress externalAddress() const = 0;
#endif

protected:
    qint64 readData(char *data, qint64 len) override;

    virtual qint64 readData(char *data, qint64 maxlen, KSocketAddress *from) = 0;

    virtual qint64 peekData(char *data, qint64 maxlen, KSocketAddress *from) = 0;

    qint64 writeData(const char *data, qint64 len) override;

    virtual qint64 writeData(const char *data, qint64 len, const KSocketAddress *to) = 0;

    void setError(SocketError error);

    void resetError();
};

class KDELIBS4SUPPORT_DEPRECATED_EXPORT KPassiveSocketBase: virtual public KSocketBase
{
public:
    KPassiveSocketBase();

    virtual ~KPassiveSocketBase();

    virtual bool bind(const KResolverEntry &address) = 0;

    virtual bool listen(int backlog) = 0;

    virtual void close() = 0;

    virtual KActiveSocketBase *accept() = 0;

    virtual KSocketAddress localAddress() const = 0;

    virtual KSocketAddress externalAddress() const = 0;

private:
    KPassiveSocketBase(const KPassiveSocketBase &);
    KPassiveSocketBase &operator = (const KPassiveSocketBase &);
};

}               // namespace KNetwork

#endif