proxy65.h

Go to the documentation of this file.

/*
 * Copyrights
 * 
 * Copyright (c) 2007 Matthias Wimmer
 *
 * This file is part of jabberd14.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This software 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this software; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 */

#include <jabberd.h>
#include <sigc++/sigc++.h>
#include <map>
#include <set>

namespace xmppd {
    namespace proxy65 {

        // forward declaration
        class socks5stub;

        class connected_sockets {
            public:
                connected_sockets(socks5stub* socket1, socks5stub* socket2, const std::string& identifier);

                ~connected_sockets();

                sigc::signal<void, connected_sockets*>& event_closed() { return closed; }

                size_t get_forwarded_traffic() { return forwarded_traffic; }

                const std::string& get_identifier() { return identifier; }
            private:
                std::string identifier;

                size_t forwarded_traffic;

                mio sockets[2];

                static void mio_event_wrapper(mio m, int state, void *arg, xmlnode unused1, char* buffer, int bufferlen);

                void on_closed(int socketindex);

                void on_data(int socketindex, const std::string& received_data);

                sigc::signal<void, connected_sockets*> closed;

                void close_sockets();
        };

        class socks5stub {
            public:
                socks5stub(mio m);

                ~socks5stub();

                sigc::signal<void, socks5stub*>& event_protocol_done() { return protocol_done; }

                sigc::signal<void, socks5stub*>& event_disconnected() { return disconnected; }

                std::string get_connection_id() { return connection_id; }

            private:
                sigc::signal<void, socks5stub*> protocol_done;

                sigc::signal<void, socks5stub*> disconnected;

                enum state {
                    state_connected,            
                    state_accepted_auth,        
                    state_accepted_connect,     
                    state_error                 
                };

                state current_state;

                std::string unprocessed_data;

                void on_data(const std::string& received_data);

                void on_closed();

                static void mio_event_wrapper(mio m, int state, void *arg, xmlnode unused1, char* buffer, int bufferlen);

                mio m;

                std::string connection_id;

                void close_socket();

                friend class connected_sockets;
        };

        class proxy65 : public instance_base {
            public:
                proxy65(instance i, xmlnode x);

            private:
                void connecting_connection_disconnected(socks5stub* stub);

                void active_connection_disconnected(connected_sockets* conn);

                void connecting_connection_protocol_done(socks5stub* stub);

                std::map<socks5stub*, time_t> connecting_connections;

                std::multimap<std::string, std::pair<socks5stub*, time_t> > waiting_connections;

                std::set<connected_sockets*> active_connections;

                void connection_accepted(mio m);

                result on_iq_stanza(jpacket p);

                result iq_disco_info(jpacket p);

                result iq_disco_items(jpacket p);

                result iq_bytestreams(jpacket p);

                result iq_bytestreams_activate(jpacket p);

                static void conn_accepted_wrapper(mio m, int state, void *arg, xmlnode unused1, char* unused2, int unused3);

                xht std_namespace_prefixes;
        };
    }
}