// $Id: active.c,v 1.395 2008/04/01 09:38:26 lynx Exp $ // vim:syntax=lpc:ts=8

#include <net.h>
#include <sys/time.h>
#include <url.h>

// a jabber thing which actively connects something
#define NO_INHERIT
#include "jabber.h"
#undef NO_INHERIT

#ifdef ERQ_WITHOUT_SRV
# define hostname host	// hostname contains the name before SRV resolution
#endif

inherit NET_PATH "jabber/mixin_render";

// a derivate of circuit which knows JABBER
inherit NET_PATH "circuit";
inherit NET_PATH "name";

#if 0	// apparently unused
// virtual inherit of textc.c thus output.c isnt really working
#define NO_INHERIT
#include <text.h>
#undef NO_INHERIT
#endif

#include "interserver.c" // interserver stuff

volatile mixed gateways;
volatile mixed *dialback_queue;

volatile string streamid;
volatile float streamversion;
volatile int authenticated;
volatile int ready; // finished with sasl, starttls and such
volatile int dialback_outgoing;

tls_logon(); // prototype

#ifdef NOT_EXPERIMENTAL // not strictly necessary, but more spec conformant
quit() {
	emit("</stream:stream>");
#ifdef _flag_log_sockets_XMPP
	D0( log_file("RAW_XMPP", "\n%O: shutting down, quit called\n", ME); )
#endif
	remove_interactive(ME);	// not XEP-0190 conformant, but shouldn't
				// matter on an outgoing-only socket
	//destruct(ME);
}
#endif

sGateway(gw, ho, id) {
    // TODO: ho is obsolete
    P2(("%O: setting %O as gateway for %O, id %O\n", ME, gw, ho, id))
    unless (gateways) gateways = ([ ]);
    gateways[id] = gw; 
    return ME; // set myself as active for this gateway
}

removeGateway(gw, id) {
    if (gateways[id] == gw) {
	m_delete(gateways, id);
    }
}

start_dialback() {
    string source_host, key;

    source_host = NAMEPREP(JABBER_HOST);
    key = DIALBACK_KEY(streamid, hostname, source_host);

    P3(("%O: starting dialback from %O to %O\n", ME, source_host, hostname))
    
    dialback_outgoing = 1;
    emit(sprintf("<db:result to='%s' from='%s'>%s</db:result>",
		 hostname, source_host, key));
}

process_dialback_queue() {
    mixed *t;
    ready = 1;
    if (pointerp(dialback_queue)) 
	foreach (t : dialback_queue) 
	    render(t[1], t[2], t[3], t[0]);
    dialback_queue = ({ });
}

handle_starttls(XMLNode node) {
    if (node["@xmlns"] != NS_XMPP "xmpp-tls") {
	P0(("%O: expecting xmpp-tls proceed or failure, got %O:%O\n",
	    ME, node[Tag], node["@xmlns"]))
#ifdef _flag_log_sockets_XMPP
	D0( log_file("RAW_XMPP", "\n%O: expecting xmpp-tls proceed or failure, got %O:%O\t%O", ME, node[Tag], node["@xmlns"], ctime()); )
#endif
	nodeHandler = #'jabberMsg;
	return jabberMsg(node);
    }
    nodeHandler = #'jabberMsg;
    if (node[Tag] == "proceed") {
	tls_init_connection(ME, #'tls_logon);
    } else { // treat everything else as a failure
	P0(("%O got a tls failure\n", ME))
    }
}

handle_stream_features(XMLNode node) {
    unless (node[Tag] == "stream:features") {
	// this should not happen!
	P0(("%O: expecting stream:features, got %O\n", ME, node[Tag]))
	nodeHandler = #'jabberMsg;
	// TODO
	// be careful, usually there are not many nodes which an active 
	// may get, mostly errors, so it might not be a good idea
	// to do dialback if this happens

	start_dialback(); 
	process_dialback_queue();
#ifdef _flag_log_sockets_XMPP
	D0( log_file("RAW_XMPP", "\nprocessing dialback queue, expecting stream features but not found" ); ) 
#endif
	return jabberMsg(node);
    }
    unless (streamversion >= 1.0) {
	P0(("%O unexpected stream:features with stream:version %O\n",
	    ME, streamversion))
	return;
    }
    nodeHandler = #'jabberMsg;
#ifdef WANT_S2S_TLS
    // should only happen if stream version is >= "1.0"
    if (node["/starttls"] && tls_available() 
	    && !tls_query_connection_state(ME)
	    // dont starttls to hosts that are known to have 
	    // invalid tls certificates
//		&& !config(XMPP + hostname, "_tls_invalid")
       ){
	// may use tls unless we already do so
	emit("<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>");
	nodeHandler = #'handle_starttls;
	return;
    }
#else
    if (node["/starttls"] 
	    && node["/starttls"]["/required"]) {
	P0(("%O requires <starttls/> but we can't provide that\n", ME))
	connect_failure("_encrypt_necessary", "Encryption required but unable to provide that");
	return;
    }
#endif
#ifdef WANT_S2S_SASL
    // possibly authenticated via sasl?
    if (authenticated && !node["/switch"]) {
	P2(("%O running Q after getting stream:features and having "
	    "authenticated via sasl\n", ME))
	process_dialback_queue();
	return runQ();
    }
    if (node["/mechanisms"] 
	    && node["/mechanisms"]["/mechanism"]){
	XMLNode tx;
	mixed mechs = ([ ]);

	// get the mechanismsm
	tx = node["/mechanisms"]["/mechanism"];

	if (nodelistp(tx)) 
	    foreach (XMLNode tx2 : tx) 
		mechs[tx2[Cdata]] = 1;
	else 
	    mechs[tx[Cdata]] = 1;

	// choose a mechanism
	P2(("available SASL mechanisms: %O\n", mechs))

#ifndef _flag_disable_authentication_external_XMPP
	if (mechs["EXTERNAL"]) {
	    // TODO we should check that the name in our 
	    // certificate is equal to JABBER_HOST
	    // but so should the other side!
	    emit("<auth mechanism='EXTERNAL' "
		 "xmlns='" NS_XMPP "xmpp-sasl'>" +
		 encode_base64(JABBER_HOST)
		 + "</auth>");
	    return;
	} else
#endif
	if (mechs["DIGEST-MD5"] 
		   && config(XMPP + hostname, "_secret_shared")) { 
	    PT(("jabber/active requesting to do digest md5\n"))
	    emit("<auth mechanism='DIGEST-MD5' "
		 "xmlns='" NS_XMPP "xmpp-sasl>" +
		 encode_base64(JABBER_HOST) +
		 "</auth>");
	    return;

	}
    }
#endif
#ifdef SWITCH2PSYC
    else if (node["/switch"]) {	// should check scheme
	PT(("upgrading %O from XMPP to PSYC.\n", ME))
	emit("<switching xmlns='http://switch.psyced.org'>"
		"<scheme>psyc</scheme>"
	     "</switching>");
	return;
    }
#endif
    // send dialback request (step 4) here if nothing else
    // is done
    if (dialback_outgoing == 0 && qSize(me)) {
	start_dialback();
    }
    process_dialback_queue();
}

disconnected(remainder) {
    P2(("active %O disconnected\n", ME))
#ifdef _flag_log_sockets_XMPP
    D0( log_file("RAW_XMPP", "\n%O disc\t%O", ME, ctime()); )
#endif
    authenticated = 0;
    ready = 0;
    if (dialback_outgoing != 0) {
	// just saw that happen twice with jabber.org
	// should we trigger a reconnect then?
	P0(("%O got disconnected with dialback outgoing != 0\n", ME))
	// TODO: reconnect koennte sinnvoll sein
#ifdef _flag_log_sockets_XMPP
	D0( log_file("RAW_XMPP", "\n%O disconnected with dialback outgoing != 0\t%O", ME, ctime()); )
#endif
	dialback_outgoing = 0;
    }
    // nothing else happening here? no reconnect?
    // TODO: what about the dialback Q if any?
    ::disconnected(remainder);
    return flags & TCP_PENDING_DISCONNECT;
}

// we love multiple inheritance.. rock'n'roll!
static int logon(int failure) {
    // TODO: it seems that it is bad to call this from tls_logon
    // 	 for a second time
// 1. Originating Server establishes TCP connection to Receiving Server.
    if (NET_PATH "circuit"::logon(failure)) {
	set_combine_charset(COMBINE_CHARSET);
#ifdef INPUT_NO_TELNET
	input_to(#'feed, INPUT_IGNORE_BANG | INPUT_CHARMODE | INPUT_NO_TELNET);
#else
	enable_telnet(0, ME);
	input_to(#'feed, INPUT_IGNORE_BANG | INPUT_CHARMODE);
#endif
	sTextPath(0, "en", "jabber");
#ifdef _flag_log_sockets_XMPP
	D0( log_file("RAW_XMPP", "\n%O logon\t%O", ME, ctime()); )
#endif
/* 2. Originating Server sends a stream header to Receiving Server */
	emit("<stream:stream xmlns:stream='http://etherx.jabber.org/streams' "
	     "xmlns='jabber:server' xmlns:db='jabber:server:dialback' "
	     "to='" + hostname + "' "
	     "from='" + NAMEPREP(JABBER_HOST) + "' "
	     "xml:lang='en' "
	     "version='1.0'>");
#ifdef NOT_EXPERIMENTAL // not strictly necessary, but more spec conformant
    } else if (!qSize(me)) { // no retry for dialback-only
	P0(("notify gateways %O of failure\n", gateways))
	if (sizeof(dialback_queue) > 1) {
	    P0(("tell fippo that sizeof(dialback queue) was > 1\n"))
	}
	foreach(string id, mixed gw : gateways) {
	    if (objectp(gw)) {
		gw->remote_connection_failed();
	    }
	}
	dialback_queue = 0;
	destruct(ME);
#endif
    }
    unless (gateways) {
	gateways = ([ ]);
    }
    return 1;
}

#ifdef WANT_S2S_TLS
tls_logon(result) {
    if (result < 0) {
	PT(("%O tls_logon %d\n", ME, result))
	connect_failure("_encrypt", "Problems setting up an encrypted circuit");
    } else if (result == 0) {
	// we need to check the certificate
	// selfsigned certs are ok, but we need dialback then
	//
	// if the cert is ok, we can set authenticated to 1
	// to skip dialback
	mixed cert = tls_certificate(ME, 0);
	P3(("active::certinfo %O\n", cert))
	if (mappingp(cert)) {
	    unless (certificate_check_jabbername(hostname, cert)) {
#ifdef _flag_report_bogus_certificates
		monitor_report("_error_invalid_certificate_identity",
			       sprintf("%O presented a certificate that "
				       "contains %O/%O",
				       hostname, cert["2.5.4.3"],
				       cert["2.5.29.17:1.3.6.1.5.5.7.8.5"]));
#else
		P1(("TLS: %s presented a certificate with unexpected identity.\n", hostname))
		P2(("%O\n", cert))
#endif
#ifdef _flag_log_bogus_certificates
		log_file("CERTS", S("%O %O %O id?\n", ME, hostname, cert));
#endif
#if 0 //def _flag_reject_bogus_certificates
		QUIT
		return 1;
#endif
	    } 
	    else if (cert[0] != 0) {
#ifdef _flag_report_bogus_certificates
		monitor_report("_error_untrusted_certificate",
			       sprintf("%O certificate could not be verified",
				       hostname));
#else
		P1(("TLS: %s presented untrusted certificate.\n", hostname))
		P2(("%O\n", cert))
#endif
#ifdef _flag_log_bogus_certificates
		log_file("CERTS", S("%O %O %O\n", ME, hostname, cert));
#endif
#if 0 //def _flag_reject_bogus_certificates
		// QUIT is wrong...
		QUIT
		return 1;
#endif
	    }
	} else {
	    P0(("%O: no tls_certificate() for %O\n", ME, hostname))
	}
	logon(0);
    } else {
	// should not happen, if it does the driver is doing sth wrong
	PT(("%O tls_logon %d - MUST NOT HAPPEN\n", ME, result))
    }
}
#endif

// this one is completly specific to active.c
jabberMsg(XMLNode node) {
    /* this will be rarely used if we do dialback
     * due to active part beeing virtually write-only
     */
    P2(("%O jabber/active got %O\n", ME, node[Tag])) 
    object o;
    string t;
    switch (node[Tag]) {
    case "db:result":
	/* 10: Receiving Server informs Originating Server of the result
	 * we are originating server and are informed of the result
	 */
	dialback_outgoing = 0;
	if (node["@type"] == "valid") {
#ifdef LOG_XMPP_AUTH
	    D0( log_file("XMPP_AUTH", "\n%O auth dialback", ME); )
#endif 
	    authenticated = 1;
	    runQ();
	} else {
	    // else: queue failed
	    P0(("%O something gone wrong in active db:result: %O\n", ME, node))
	    authenticated = 0;
	    /* Note: At this point, the connection has either been 
	     * validated via a type='valid', or reported as invalid.
	     * If the connection is invalid, then the Receiving 
	     * Server MUST terminate both the XML stream and the 
	     * underlying TCP connection. 
	     */
	    emit("</stream:stream>");
	    remove_interactive(ME);
	    connect_failure("_dialback", "dialback gone wrong");
	}
	break;
    case "db:verify": // receiving step 9
	// t = NAMEPREP(node["@to"]) + ";" + node["@id"];
	t = node["@id"];
	o = gateways[t];
	if (objectp(o)) {
	    o -> verify_connection(node["@to"],
				   node["@from"],
				   node["@type"]);
	    // probably we can delete this...
	    m_delete(gateways, t);
#ifdef NOT_EXPERIMENTAL // not strictly necessary, but more spec conformant
	} else if (member(gateways, t)) {
	    P0(("%O found gateway for %O, but it is not an object: %O\n",
		ME, t, o))
	    m_delete(gateways, t);
#endif
	} else {
	    // wir haben keinen Gateway zu der ID... 
	    // was machen wir? loggen und ignorieren!
	    P0(("%O could not find %O in %O\n", ME, 
		t, gateways));
	}
	break;
#ifdef WANT_S2S_SASL
    case "success":
	if (node["@xmlns"] == NS_XMPP "xmpp-sasl") {
# ifdef LOG_XMPP_AUTH
	    D0( log_file("XMPP_AUTH", "\n%O auth SASL", ME); )
# endif 
	    // TODO: for digest-md5 we should check rspauth
	    emit("<stream:stream xmlns:stream='http://etherx.jabber.org/streams' "
		 "xmlns='jabber:server' xmlns:db='jabber:server:dialback' "
		 "to='" + hostname + "' "
		 "from='" + NAMEPREP(JABBER_HOST) + "' "
		 "xml:lang='en' "
		 "version='1.0'>");
	    authenticated = 1;
	}
	break;
    case "challenge":
	PT(("%O got a sasl challenge\n", ME))
	if (node["@xmlns"] == NS_XMPP "xmpp-sasl") {
	    unless(t = node[Cdata]) {
		// none given
	    } else unless (t = to_string(decode_base64(t))) {
		// base64 decode error?
	    } else {
		// this one is shared across all those digest md5's
		mixed data;
		string secret;
		string response;
		PT(("decoded challenge: %O\n", t))
		data = sasl_parse(t);
		PT(("extracted %O\n", data))

		data["username"] = JABBER_HOST;
		secret = config(XMPP + hostname, "_secret_shared");
		unless(secret) {
		    // mh... this is a problem!
		    // we only started doing this if we have a secret,
		    // so this cant be empty
		}
		data["cnonce"] = RANDHEXSTRING;
		data["nc"] = "00000001";
		data["digest-uri"] = "xmpp/" JABBER_HOST;

		response = sasl_calculate_digestMD5(data, secret, 0);

		// ok, the username is our hostname
		// note: qop must not be quoted, as we are 'client'
		t = "username=\"" JABBER_HOST "\","
		    "realm=\"" + data["realm"] + "\","
		    "nonce=\"" + data["nonce"] + "\","
		    "cnonce=\"" + data["cnonce"] + "\","
		    "nc=" + data["nc"] + ",qop=auth,"
		    "digest-uri=\"" + data["digest-uri"] + "\","
		    "response=" + response + ",charset=utf-8";
		PT(("%O sent rspauth %O\n", ME, response))
		emit("<response xmlns='" NS_XMPP "xmpp-sasl'>"
		     + encode_base64(t) + 
		     "</response>");
	    }
	}
	break;
    case "failure":
	// the other side has to close the stream
	monitor_report("_error_invalid_authentication_XMPP", sprintf("%O got a failure with xml namespace %O\n", ME, node["@xmlns"]));
	connect_failure("_invalid_authentication", "counterpart did not like our authorization");
	break;
#endif
    case "stream:error":
	if (ME) remove_interactive(ME);
	authenticated = 0;
	if (node["/connection-timeout"]) {
	    // this is normal, unless we had something to say,
	    // but we are an event-oriented system, so this
	    // "if" should never happen. then again, i've seen
	    // plenty of should-never-happens to happen, so..
	    // to put it in brian wilson words, god only knows  ;)
	    if (qSize(me)) 
		connect_failure("_timeout", "counterpart sent timeout");
	} else if (node["/not-authorized"]) {
	    connect_failure("_illegal_source",
			    "counterpart claims we are not authorized");
	} else if (node["/system-shutdown"]) {
	    connect_failure("_unavailable_restart",
			    "counterpart is doing a system shutdown");
	} else if (node["/host-unknown"]) {
	    // remote side runs a jabber server, but does not
	    // accept hostname
	    connect_failure("_host_unknown",
			    "counterpart does not recognize hostname");
	} else {
	    P0(("%O stream error, other side said %O\n", ME, node))
	    connect_failure("_unknown",
			    "counterpart stopped transaction for unknown reason");
	}
	break;
#ifdef SWITCH2PSYC
    case "switched":
# ifdef QUEUE_WITH_SCHEME
	o = ("psyc:" + host) -> circuit();
# else
	o = ("psyc:" + host) -> circuit(0, 0, 0, 0, host);  // whoami
# endif
	P1(("%O switched to %O for %O\n", ME, o, host))
	exec(o, ME);
	o -> logon();
	destruct(ME);
	return;
#endif
    default:
	P0(("%O: unexpected %O:%O\n", ME, node["@tag"], 
	    node["@xmlns"]))
	break;
    }
}

// prototype
int msg(string source, string mc, string data,
	    mapping vars, int showingLog, string target) {
    mixed t;
    string template, output;

    P2(("%O jabber/active:msg(%O,%O..)\n", ME, source, mc))
    /* TODO: use the language, i.e. sTextPath if _language is not
     * 	the current language 
     * 	sTextPath is quite expensive (string object lookup), 
     * 	but as we're parsing xml anyway...
     */ 
    vars = copy(vars);
#ifdef DEFLANG
    unless(vars["_language"]) vars["_language"] = DEFLANG;
#else
    unless(vars["_language"]) vars["_language"] = "en";
#endif
    /* another note:
     * instead of queuing the msg()-calls we could simply queue
     * the output from emit (use the new net/outputb ?)
     * this avoids bugs with destructed objects
     */
#ifdef PREFIXES
    // completely skip these methods
    if (abbrev("_prefix", mc)) return 1;
#endif
#if 0 // !EXPERIMENTAL
    /* currently, we want _status_person_absent
     * this may change...
     */
    else if (abbrev("_status_person_absent", mc)) return 1;
#endif
    switch (mc){
    case "_message_echo_private":
	return 1;
    }
    // desperate hack
    unless (vars["_INTERNAL_mood_jabber"])
	    vars["_INTERNAL_mood_jabber"] = "neutral";

    // TODO: only _dialback_request_verify sollte hier betroffen sein
    if (abbrev("_dialback", mc)) {
	unless (interactive()) connect(); // ?
	if (ready) {
	    render(mc, data, vars, source);
	} else {
	    unless (dialback_queue) dialback_queue = ({ });
	    dialback_queue += ({ ({ source, mc, data, vars, target }) });
	}
	return 1;
    }

    // this should be part of render()/w()
    // but it has to happen before enqueuing (otherwise we had
    // problems with destructed objects)
    // "late enqueu" could be a solution to that problem
    determine_sourcejid(source, vars);
    determine_targetjid(target, vars);
    if (vars["_place"]) vars["_place"] = mkjid(vars["_place"]);

    // component needs to set authenticated as needed
    unless (authenticated) {
	if (interactive() && ready && dialback_outgoing == 0) {
	    start_dialback();
	}
#if JABBER_HOST == SERVER_HOST
      // we can only do this if mkjid patches the psyc host into jabber host
      // but that is terrifically complicated and requires parsing of things
      // we already knew.. so let's simply enqueue with object id and reject
      // if the object got lost in the meantime
	vars["_source"] = UNIFORM(source);
	// hmm.. actually no.. since we also set _INTERNAL_source_jabber
	// this variable should never get used for anything anyway.. so
	// leaving it out should be completely harmless
#else
	// is this a bad idea? not sure.. we'll see..
	// if i don't have this here, a "tell lynX where it happened" will
	// be triggered from here -- best to never use JABBER_HOST really ;)
	vars["_source"] = source;
	// behaviour has changed.. so maybe we don't need this any longer TODO
#endif
	return enqueue(source, mc, data, vars, showingLog, target);
    }
    return ::msg(source, mc, data, vars, showingLog, target);
}

open_stream(XMLNode node)
{
    mixed *t;
    string key;

    P2(("%O active for %O.\n", ME, hostname))
    D1( unless (interactive(ME))
	PP(("%O open_stream: should be interactive!\n", ME)); 
    )
    streamid = node["@id"];

    // actually, this is incorrect, als both parts of the version
    // are to be treated as separte ints ($4.4.1)
    // but as long as we only have 0 and 1.0...
    streamversion = to_float(node["@version"]);
    // note: flushing this Q should wait until stream features is completed	
    if (streamversion < 1.0) {
	process_dialback_queue();
	if (qSize(me)) 
	    start_dialback();
    } else { 
	// wait for stream:features
	nodeHandler = #'handle_stream_features;
    }
    return;
}