resolver.h

Go to the documentation of this file.

/*
 * Copyrights
 * 
 * Copyright (c) 2008 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>

namespace xmppd {
    namespace resolver {

        class resend_service {
            public:
                resend_service(xmlnode resend);

                bool is_explicit_service() const;

                Glib::ustring const& get_service_prefix() const;

                xmppd::jabberid get_resend_host() const;
            private:
                Glib::ustring service;

                std::list< std::pair<int, xmppd::jabberid> > resend_hosts;

                int weight_sum;
        };

        // forward declaration
        class resolver;

        class resolver_job {
            public:
                resolver_job(resolver& owner, dpacket dp);

                ~resolver_job();

                void add_packet(dpacket dp);

                std::list<dpacket> const& get_packets() const;

                sigc::connection register_result_callback(sigc::signal<void, resolver_job&>::slot_type const& callback);

                Glib::ustring get_result() const;

                xmppd::jabberid get_resend_host() const;


            private:
                Glib::ustring destination;

                resolver& owner;

                std::list<dpacket> waiting_packets;

                std::list<resend_service> resend_services;

                std::list<resend_service>::const_iterator current_service;

                void start_resolving_service();

                std::list< std::pair<Glib::ustring, Glib::ustring> > providing_hosts;

                std::list< std::pair<Glib::ustring, Glib::ustring> >::const_iterator current_providing_host;

                void resolve_providing_hosts();

                void resolve_current_providing_host();

                void resolve_current_providing_host_a();

                std::list<sigc::connection> connected_signals;

                void on_srv_query_result(xmppd::lwresc::lwresult const& result);

                void on_aaaa_query_result(xmppd::lwresc::lwresult const& result);

                void on_a_query_result(xmppd::lwresc::lwresult const& result);

                std::ostringstream result_buffer;

                std::list<sigc::signal<void, resolver_job&> > result_listeners;

                time_t timestamp;

                long serial;

                static long next_serial;

                friend std::ostream& operator<<(std::ostream& out, resolver_job& job);
        };

        std::ostream& operator<<(std::ostream& out, resolver_job& job);

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

                std::list<resend_service> const& get_resend_services();

                void send_query(xmppd::lwresc::lwquery const& query);

                sigc::connection register_result_callback(uint32_t serial, sigc::signal<void, xmppd::lwresc::lwresult const&>::slot_type const& callback);

            private:
                void resend_packet(xmlnode pkt, Glib::ustring ips, Glib::ustring to);

                void handle_completed_job(resolver_job& job);

                result on_stanza_packet(dpacket dp);

                result on_route_packet(dpacket dp);

                void open_lwresd_socket();

                static void mio_callback(mio m, int state, void* arg, xmlnode x, char* buffer, int bufsz);

                void mio_event(mio m, int state, std::string const& buffer);

                void mio_event_buffer(mio m, std::string const& buffer);

                void mio_event_closed(mio m);

                void mio_event_error(mio m);

                mio lwresd_socket;

                void configurate();

                std::list<resend_service> resend_services;

                int queue_timeout;

                Glib::ustring lwresd_host;

                Glib::ustring lwresd_service;

                xmppd::xhash< xmppd::pointer<resolver_job> > pending_jobs;

                std::map<uint32_t, std::pair<time_t, sigc::signal<void, xmppd::lwresc::lwresult const&> > > result_listeners;
        };
    }
}