lliosocket.h

Go to the documentation of this file.

#ifndef LL_LLIOSOCKET_H
#define LL_LLIOSOCKET_H

#include "lliopipe.h"
#include "apr-1/apr_pools.h"
#include "apr-1/apr_network_io.h"
#include "llchainio.h"

class LLHost;

class LLSocket
{
public:
        typedef boost::shared_ptr<LLSocket> ptr_t;

        enum EType
        {
                STREAM_TCP,
                DATAGRAM_UDP,
        };

        enum
        {
                PORT_INVALID = (U16)-1,
                PORT_EPHEMERAL = 0,
        };

        static ptr_t create(
                apr_pool_t* pool,
                EType type,
                U16 port = PORT_EPHEMERAL);

        static ptr_t create(apr_socket_t* socket, apr_pool_t* pool);

        bool blockingConnect(const LLHost& host);

        //EType getType() const { return mType; }

        U16 getPort() const { return mPort; }

        apr_socket_t* getSocket() const { return mSocket; }

protected:
        LLSocket(apr_socket_t* socket, apr_pool_t* pool);

        void setOptions();

public:
        ~LLSocket();

protected:
        // The apr socket.
        apr_socket_t* mSocket;

        // our memory pool
        apr_pool_t* mPool;

        // The port if we know it.
        U16 mPort;

        //EType mType;
};

class LLIOSocketReader : public LLIOPipe
{
public:
        LLIOSocketReader(LLSocket::ptr_t socket);
        ~LLIOSocketReader();

protected:
        /* @name LLIOPipe virtual implementations
         */

        virtual EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);

protected:
        LLSocket::ptr_t mSource;
        std::vector<U8> mBuffer;
        bool mInitialized;
};

class LLIOSocketWriter : public LLIOPipe
{
public:
        LLIOSocketWriter(LLSocket::ptr_t socket);
        ~LLIOSocketWriter();

protected:
        /* @name LLIOPipe virtual implementations
         */

        virtual EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);

protected:
        LLSocket::ptr_t mDestination;
        U8* mLastWritten;
        bool mInitialized;
};

class LLIOServerSocket : public LLIOPipe
{
public:
        typedef LLSocket::ptr_t socket_t;
        typedef boost::shared_ptr<LLChainIOFactory> factory_t;
        LLIOServerSocket(apr_pool_t* pool, socket_t listener, factory_t reactor);
        virtual ~LLIOServerSocket();

        void setResponseTimeout(F32 timeout_secs);

        /* @name LLIOPipe virtual implementations
         */
protected:
        virtual EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);

protected:
        apr_pool_t* mPool;
        socket_t mListenSocket;
        factory_t mReactor;
        bool mInitialized;
        F32 mResponseTimeout;
};

#if 0

class LLIODataSocket : public LLIOSocket
{
public:
        LLIODataSocket(
                U16 suggested_port,
                U16 start_discovery_port,
                apr_pool_t* pool);
        virtual ~LLIODataSocket();

protected:

private:
        apr_socket_t* mSocket;
};
#endif

#endif // LL_LLIOSOCKET_H

---