vos/corelibs/vos/localsocketsite.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-2003 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 _LOCALSOCKETSITE_HH_
#define _LOCALSOCKETSITE_HH_

/** @file
    Defines LocalSite.
*/

#include <vos/corelibs/vos/vosdefs.hh>
#include <vos/corelibs/vos/localsite.hh>
#include <stdexcept>

namespace VOS
{
    class SiteAccessControl;

/** @class LocalSocketSite localsocketsite.hh vos/corelibs/vos/localsocketsite.hh
 *
 * A local site implemented using TCP sockets.  It binds a TCP socket
    and accepts connection requests.
*/
class VOS_API LocalSocketSite : public virtual LocalSite
{
public:
    /** An exception class thrown when there is an error initializing the listening socket */
    class PortBindingError : public runtime_error {
    public:
        PortBindingError(const string& s) : runtime_error(s) { }
    };
    /** An exception class thrown when there is an error initializing SSL */
    class SSLError : public runtime_error {
    public:
        SSLError(const string& s) : runtime_error(s) { };
    };

private:
    int listensocket;
    unsigned short int listenport;
    bool alreadyDoingFlushIncoming;
    bool usingSOCKS;

    SSL_CTX* TLSv1context;
    SSL_CTX* SSLv3context;

    map<int, pair<int, int> > extra_fds;

    void init(const string& defaultHostname, unsigned short int port) throw (PortBindingError);
    void acceptConnectionRequests();
    static int pemPasswordCallback(char *buf, int size, int rwflag, void *password);
    static int sslVerifyCallback(int preverify_ok, X509_STORE_CTX *ctx);

public:
    /** The usual constructor to use. Gets hostname from the system (gethostname), unless
     * "VOS_HOSTNAME" environment variable is present.
     * Uses the first free port number <= 4231 (VOS_DEFAULT_PORT)
     */
    LocalSocketSite(SiteAccessControl* ac) throw (PortBindingError);

    LocalSocketSite(const string& defaultHostname, unsigned short int port, SiteAccessControl* ac) throw (PortBindingError);
    LocalSocketSite(const string& defaultHostname, SiteAccessControl* ac) throw (PortBindingError);
    LocalSocketSite(unsigned short int port, SiteAccessControl* ac) throw (PortBindingError);

    //LocalSite() throw (PortBindingError);
    /** destructor */
    virtual ~LocalSocketSite();

    virtual void flushIncomingBuffers();

    /** Calculate the timeout value of the next call to select() and
        return an appropriate timeval structure.  If the time returned
        is less than the time set with setTimeoutOnSelect(), then it
        is amount of time to the next event (message delivery or timer
        callback).  If a null pointer is returned, the select is
        expected to block indefinitely.
        @return a pointer timeval structure allocated with 'new',
        which the user is expected to 'delete' when done; or may be
        null signifying an indefinitely wait.
     */
    struct timeval* calculateTimeout();

    /** On the supplied file descriptor sets, set all the file
        descriptors that a call to flushIncomingBuffers() would wait
        upon.
        @param readset the FDs to wait for reading
        @param writeset the FDs to wait for writing
        @param errorset the FDs to wait for errors
        @return the largest value file descriptor that was set
    */
    int getFDset(fd_set* readset, fd_set* writeset, fd_set* errorset);

    static const int SELECTREAD;
    static const int SELECTWRITE;
    static const int SELECTERROR;

    /** Add an extra file descriptor to our select() call.
        @param fd the file description
        @param which The OR'd together flags of
        LocalSocketSite::SELECTREAD, LocalSocketSite::SELECTWRITE and
        LocalSocketSite::SELECTERROR specifying which select set to
        add the file descriptor to.
     */
    void addFDtoSelect(int fd, int which);

    /** Remove an extra file descriptor to our select() call.
        @param fd the file description
        @param which The OR'd together flags of
        LocalSocketSite::SELECTREAD, LocalSocketSite::SELECTWRITE and
        LocalSocketSite::SELECTERROR specifying which select set to
        remove the file descriptor from.
    */
    void removeFDfromSelect(int fd, int which);

    /** Get most recent result for this file descriptor.
        @param fd the file description
        @return The result stored in the first three bits.  Do a
        boolean AND to get the result for each select set.  For example:
        @code
        x = lastSelectResultForFD(fd);
        if(x & LocalSocketSite::SELECTREAD) ...
        @endcode
    */
    int lastSelectResultForFD(int fd);

    virtual void sendMessage(Message* m);

    /** Get the OpenSSL context.  Will return NULL if there was an
        error or VOS was not compiled with SSL support.
    */
    SSL_CTX* getSSLContext(const string& protocol);

    /** Set up our SSL identity.
        @param certificateFile The filename the X509 certificate (public key)
        @param privateKeyFile The filename the private key
        @param password The password needed to decrypt the private key file
    */
    void setupSSL(const string& certificateFile, const string& privateKeyFile, const string& password);

    friend void Site::doSitePeering(LocalSite* localsite, RemoteSite* remotesite, bool isspooftest, bool waitforhello);

    /** Return the underlying system socket file descriptor on which
        this site is listening.  You are strongly advised NOT to read
        or write to this file descriptor, but you may find it rather
        useful to know for doing your own select() calls... */
    int getSocket() {
        return listensocket;
    }
};
}

#endif

---