vos/corelibs/vos/remotesocketsite.hh

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001, 2002 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <tetron@interreality.org>
*/
#ifndef _REMOTESOCKETSITE_HH_
#define _REMOTESOCKETSITE_HH_

/** @file
    Defines RemoteSocketSite.
*/

#include <vos/corelibs/vos/vosdefs.hh>
#include <vos/corelibs/vos/remotesite.hh>
#include <vos/corelibs/vos/localsocketsite.hh> // Needed for friend declaration

namespace VOS
{
    class RemoteSocketSite;
    class LocalSite;

/**
     Connects to a remote site sort of asynchronously.  It starts the
     connection process in separate kernel thread so that a call to
     gethostbyname() or connect() does not hang the entire application
     process.  Meanwhile, the main thread repeatedly calls
     flushIncomingBuffers() while waiting for the worker thread to
     come back with the results of the connection.

     @internal
 */
class AsyncConnect
{
public:
    bool* done;
    RemoteSocketSite** remotesite;
    LocalSite* localpeer;
    string remotehost;
    unsigned short int remoteport;
    string exstring;
    bool spooftest;

    AsyncConnect(bool* isdone, RemoteSocketSite** rs, LocalSite* localpeer,
                 const string& host, unsigned short int port, bool isspooftest);
    void operator()();
    static RemoteSocketSite* connect(const string& h, unsigned short int p, LocalSite* defaultPeer, bool isspooftest);
};

/** A message filter that denies (and drops) all outgoing messages except for
    anti-spoof checking and errors.
 */
class OutgoingLock : public MessageFilter
{
public:
    virtual bool checkMessage(Message* m);
};

/** A message filter that enqueues all outgoing messages except for
    anti-spoof checking and errors.
 */
class EnqueueOutgoing : public MessageFilter
{
public:
    queue< pair<Message*, MessageBlock*> > outgoingQueue;
    virtual bool checkMessage(Message* m);
    virtual bool checkMessage(MessageBlock* m);
};

/** A message filter that rewrites the To: field of messages.
 */
class RewriteTo : public MessageFilter
{
public:
    string hostandport;
    RewriteTo(string hnp) : hostandport(hnp) { }
    virtual bool checkMessage(Message* m);
};


/** @class RemoteSocketSite remotesocketsite.hh vos/corelibs/vos/remotesocketsite.hh
 *
 * This class manages a connection to a remote site and the
    objects bound to that site.
 */
class VOS_API RemoteSocketSite : public virtual RemoteSite
{
protected:
    unsigned short int remoteport;
    int readingFD;
    int writingFD;
    bool usingSOCKS;
    SSL* ssl;
    MessageBlock* partialMessage;

    void init(const string& hostname, unsigned short int port) throw (SiteConnectionError);

    RemoteSocketSite(const string& hostname, unsigned short int port) throw (SiteConnectionError);
    RemoteSocketSite(const string& hostname) throw (SiteConnectionError);
    RemoteSocketSite(int fd, struct sockaddr_in* peeraddr);

    virtual int readStream(char* data, unsigned int datasize);
    virtual int writeStream(const char* data, unsigned int datasize);
    //virtual void takeOver(RemoteSocketSite* rs);

    OutgoingLock outgoinglock;
    EnqueueOutgoing enqueueOutgoing;

    int sockSendBufSz;
    string outputBuffer;

public:
    virtual ~RemoteSocketSite();

    /** @return the socket file descriptor over which we may read from this site */
    virtual int getReadingFD() const { return readingFD; }

    /** @return the socket file descriptor over which we may send to this site */
    virtual int getWritingFD() const { return writingFD; }

    virtual bool isConnected();

    /** Prevent messages from being sent along the underlying
        transport layer.
        @param enqueue true to save the messages in a queue, false to drop them
     */
    virtual void suppressOutgoing(bool enqueue);

    /** Reenable message sending after a call to suppressOutgoing()
        @param sendqueue true to send the queued messages, false to discard the queue
     */
    virtual void enableOutgoing(bool sendqueue, const string& rewriteTo = "?");

    virtual void sendMessage(Message* m);
    virtual void sendMessage(MessageBlock* m);

    /** Attempt to secure the connection using some transport-layer
        encryption.
        @param protocol the protocol to use.  Currently valid
        protocols are "SSLv3" and "TLSv1".  The latter protocol,
        "TLSv1" is a more recent standard based on SSL and should be
        preferred.
        @throw LocalSocketSite::SSLError on an error from OpenSSL
        @throw RemoteError if something went wrong or SSL support was not compiled in
    */
    void secureConnection(const string& protocol);

    /** Immediately try to switch to using a secure protocol.  Don't
        use this! (the other side needs to be told you want to switch)
        Use secureConnection() instead.
     */
    void switchProtocol(SSL_CTX* context);

    /** Get the remote site's X509 certificate.  You need to use the
        OpenSSL X509 API to access its fields.
     */
    X509* getCertificate();
    virtual void handleDisconnection();
    virtual void flushIncomingBuffers();
    virtual void flushOutgoingBuffers(const char* data = 0, unsigned int sz = 0);

    virtual void excise();

    //friend Site& Site::findSite(const string& s) throw (NoSuchSiteError);
    friend void LocalSocketSite::acceptConnectionRequests();
    friend class LocalSite;
    friend class AsyncConnect;
};
}

#endif

---