[Home]	[About]
[Screenshots]	[Download]
[News]	[Community]
[Documentation]	[Manual]
[Bugs & Requests]	[Wiki]

/home/tetron/hack/vos/libs/vos/vos/localsocketsite.hh

Go to the documentation of this file.

#ifndef _LOCALSOCKETSITE_HH_
#define _LOCALSOCKETSITE_HH_

#include <stdexcept>
#include <set>

namespace VOS {
    class LocalSocketSiteExtension;
}

#include <vos/vos/siteextension.hh>
#include <vos/vos/remotesocketsite.hh>
#include <vos/vos/iterator.hh>
#include <vos/vos/sitepeering.hh>

#define VOS_DEFAULT_PORT 4231

namespace VOS {

    /** @class RSSEIterator localsocketsite.hh vos/vos/localsocketsite.hh
        @ingroup libvos

        Iterator subclass used to iterate over pointers to
        RemoteSocketSiteExtension objects.
    */
    class VOS_API RSSEIterator : public VUtil::Iterator<RemoteSocketSiteExtension*>
    {
    public:
        RSSEIterator(const RSSEIterator& i) : VUtil::Iterator<RemoteSocketSiteExtension*>(i) { }
        RSSEIterator(const std::set<RemoteSocketSiteExtension*>& rsses) {
            items->resize(rsses.size());
            int n = 0;
            for(std::set<RemoteSocketSiteExtension*>::const_iterator i = rsses.begin();
                i != rsses.end();
                i++)
            {
                (*items)[n] = *i;
                n++;
            }
        }

        RemoteSocketSiteExtension* operator*() {
            if(pos < items->size()) return (*items)[pos];
            else return 0;
        }
    };


    /** @class LocalSocketSiteExtension localsocketsite.hh vos/vos/localsocketsite.hh
        @ingroup libvos

        This class sets up the actual socket that the VOS site will
        listen on and manages a list of the remote sites we are
        connected to.
    */
    class VOS_API LocalSocketSiteExtension : public LocalSiteExtension
    {
    private:
        int listensocket;
        unsigned short int listenport;

        VUtil::read_write_mutex remoteSites_mutex;
        std::set<RemoteSocketSiteExtension*> remoteSites;

        bool listener_thread_quit;
        boost::thread* listener_thread;

        void init(const std::string& defaultHostname, unsigned short int port);
    public:
        /** When creating an outgoing connection, the remote site will
            be peered with this local site.
         */
        static LocalSocketSiteExtension* defaultLocalSocketSite;

        /** Default constructor.  This will attempt to autodetect your
            hostname.  It will listen on the first available port it
            finds, starting from 4231 and working its way upward.
            This will use the VOS_HOSTNAME environment variable (in
            the form hostname:port) to define the hostname and port.
         */
        LocalSocketSiteExtension();

        /** Use the supplied hostname and port.
            @param defaultHostname the canonical hostname for this site
            @param port the TCP port for the site to listen on
            @throw PortBindingError if the port is not available.
         */
        LocalSocketSiteExtension(const std::string& defaultHostname, unsigned short int port);

        /** Use the supplied hostname.  Will use the first available
            port, starting from 4231 and working upward.
            @param defaultHostname the canonical hostname for this site
         */
        LocalSocketSiteExtension(const std::string& defaultHostname);

        /** Use the supplied port.  Will autodetect hostname, or take
            the canonical hostname from VOS_HOSTNAME (ignoring the
            port!)

            @param port the TCP port to listen on
            @throw PortBindingError if the port is not available.
         */
        LocalSocketSiteExtension(unsigned short int port);

        /** Destructor */
        virtual ~LocalSocketSiteExtension();

        /** @return the socket file descriptor used to accept incoming
            connections */
        int getListenSocket() { return listensocket; }

        /** Add a remote site that we're peered with.
            @param rs the RemoteSocketSiteExtension object
            representing the connection to the remote site
         */
        virtual void addRemoteSite(RemoteSiteExtension* rs);

        /** Remove a remote site that we're peered with.
            @param rs the RemoteSocketSiteExtension object
            representing the connection to the remote site
         */
        virtual void removeRemoteSite(RemoteSiteExtension* rs);

        /** @return the remote sites we are peered with */
        RSSEIterator getRemoteSites();

        /** Called by the Site object indicating that this extension
            has been attached to that site.
        */
        virtual void siteExtensionAttachedTo(Site* st);
    };

#ifndef SWIG

    /** @class ListenerThread localsocketsite.hh vos/vos/localsocketsite.hh
        @ingroup libvos

        Internal thread started by LocalSocketSiteExtension.  This is
        the thread that actually reads incoming data from connected
        sockets, parses it into messages and sets them up for
        delivery.  It also handles output buffering and accepts
        incoming connections.
    */
    class VOS_API ListenerThread
    {
    private:
        Site* localsite;
        LocalSocketSiteExtension* lsse;
        bool* listener_thread_quit;
    public:
        /** Constructor
            @param ls the site we're receiving messages for
            @param l the local socket site extension that started this thread
            @param ltq a pointer to a boolean flag; when this
            is set to "true" the listener thread should quit
        */
        ListenerThread(Site* ls, LocalSocketSiteExtension* l, bool* ltq)
            : localsite(ls),
              lsse(l),
              listener_thread_quit(ltq)
            { };

        /** Entry point for thread. */
        void operator()();
    };


    class SocketSitePeeringThread : public SitePeeringThread
    {
    private:
        std::string host;
        int port;
        int newsock;
        sockaddr_in sockad;

    public:

        /** Construct object and initialize it so that
            SitePeeringThread::operator()() will use the supplied
            existing socket.

            @param l the local socket site that is the local peer
            @param sock the socket file descriptor
            @param sd the socket address of the remote site, used to
            do a reverse-lookup and figure out the hostname
            @param isClient are we a client?  default false
         */
        SocketSitePeeringThread(LocalSocketSiteExtension* l, int sock, sockaddr_in* sd,
                          bool isClient = false);

        /** Construct object and initialize it so that
            SitePeeringThread::operator()() will attempt an outgoing
            connection on the supplied host and port.

            @param l the local socket site that is the local peer
            @param host the host to connect to
            @param port the port to connect on
            @param isClient are we a client?  default true
         */
        SocketSitePeeringThread(LocalSocketSiteExtension* l, const std::string& host,
                          int port, bool isClient = true);

        /** Copy constructor, required because boost::thread makes a
            copy of the thread object it runs.
         */
        SocketSitePeeringThread(const SocketSitePeeringThread& spt);

        virtual void init();
        virtual void done() { }
    };

#endif // ifndef SWIG

}

#endif