Add support for Jingle SOCKS5 bytestreams (XEP-0260)
This commit is contained in:
hrxi
parent
811408fcb5
commit
642dac9aa0
|
|
@ -78,8 +78,10 @@ public class ModuleManager {
|
|||
module_map[account].add(new StreamError.Module());
|
||||
module_map[account].add(new Xep.InBandRegistration.Module());
|
||||
module_map[account].add(new Xep.HttpFileUpload.Module());
|
||||
module_map[account].add(new Xep.Socks5Bytestreams.Module());
|
||||
module_map[account].add(new Xep.InBandBytestreams.Module());
|
||||
module_map[account].add(new Xep.Jingle.Module());
|
||||
module_map[account].add(new Xep.JingleSocks5Bytestreams.Module());
|
||||
module_map[account].add(new Xep.JingleInBandBytestreams.Module());
|
||||
module_map[account].add(new Xep.JingleFileTransfer.Module());
|
||||
initialize_account_modules(account, module_map[account]);
|
||||
|
|
|
|||
|
|
@ -55,6 +55,7 @@ SOURCES
|
|||
"src/module/xep/0049_private_xml_storage.vala"
|
||||
"src/module/xep/0054_vcard/module.vala"
|
||||
"src/module/xep/0060_pubsub.vala"
|
||||
"src/module/xep/0065_socks5_bytestreams.vala"
|
||||
"src/module/xep/0066_out_of_band_data.vala"
|
||||
"src/module/xep/0077_in_band_registration.vala"
|
||||
"src/module/xep/0082_date_time_profiles.vala"
|
||||
|
|
@ -68,6 +69,7 @@ SOURCES
|
|||
"src/module/xep/0199_ping.vala"
|
||||
"src/module/xep/0203_delayed_delivery.vala"
|
||||
"src/module/xep/0234_jingle_file_transfer.vala"
|
||||
"src/module/xep/0260_jingle_socks5_bytestreams.vala"
|
||||
"src/module/xep/0261_jingle_in_band_bytestreams.vala"
|
||||
"src/module/xep/0280_message_carbons.vala"
|
||||
"src/module/xep/0313_message_archive_management.vala"
|
||||
|
|
|
|||
83
xmpp-vala/src/module/xep/0065_socks5_bytestreams.vala
Normal file
83
xmpp-vala/src/module/xep/0065_socks5_bytestreams.vala
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
using Gee;
|
||||
using Xmpp;
|
||||
using Xmpp.Xep;
|
||||
|
||||
namespace Xmpp.Xep.Socks5Bytestreams {
|
||||
|
||||
internal const string NS_URI = "http://jabber.org/protocol/bytestreams";
|
||||
|
||||
public class Proxy : Object {
|
||||
public string host { get; private set; }
|
||||
public Jid jid { get; private set; }
|
||||
public int port { get; private set; }
|
||||
|
||||
public Proxy(string host, Jid jid, int port) {
|
||||
this.host = host;
|
||||
this.jid = jid;
|
||||
this.port = port;
|
||||
}
|
||||
}
|
||||
|
||||
public class Module : XmppStreamModule, Iq.Handler {
|
||||
public static Xmpp.ModuleIdentity<Module> IDENTITY = new Xmpp.ModuleIdentity<Module>(NS_URI, "0065_socks5_bytestreams");
|
||||
|
||||
public override void attach(XmppStream stream) {
|
||||
stream.add_flag(new Flag());
|
||||
query_availability(stream);
|
||||
}
|
||||
public override void detach(XmppStream stream) { }
|
||||
|
||||
public void on_iq_set(XmppStream stream, Iq.Stanza iq) { }
|
||||
|
||||
public Gee.List<Proxy> get_proxies(XmppStream stream) {
|
||||
return stream.get_flag(Flag.IDENTITY).proxies;
|
||||
}
|
||||
|
||||
private void query_availability(XmppStream stream) {
|
||||
stream.get_module(ServiceDiscovery.Module.IDENTITY).request_items(stream, stream.remote_name, (stream, items_result) => {
|
||||
foreach (Xep.ServiceDiscovery.Item item in items_result.items) {
|
||||
stream.get_module(ServiceDiscovery.Module.IDENTITY).request_info(stream, item.jid, (stream, info_result) => {
|
||||
foreach (string feature in info_result.features) {
|
||||
if (feature == NS_URI) {
|
||||
StanzaNode query_ = new StanzaNode.build("query", NS_URI).add_self_xmlns();
|
||||
Iq.Stanza iq = new Iq.Stanza.get(query_) { to=item.jid };
|
||||
stream.get_module(Iq.Module.IDENTITY).send_iq(stream, iq, (stream, iq) => {
|
||||
if (iq.is_error()) {
|
||||
return;
|
||||
}
|
||||
StanzaNode? query = iq.stanza.get_subnode("query", NS_URI);
|
||||
StanzaNode? stream_host = query != null ? query.get_subnode("streamhost", NS_URI) : null;
|
||||
if (query == null || stream_host == null) {
|
||||
return;
|
||||
}
|
||||
string? host = stream_host.get_attribute("host");
|
||||
string? jid_str = stream_host.get_attribute("jid");
|
||||
Jid? jid = jid_str != null ? Jid.parse(jid_str) : null;
|
||||
int port = stream_host.get_attribute_int("port");
|
||||
if (host == null || jid == null || port <= 0 || port > 65535) {
|
||||
return;
|
||||
}
|
||||
stream.get_flag(Flag.IDENTITY).proxies.add(new Proxy(host, jid, port));
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public override string get_ns() { return NS_URI; }
|
||||
public override string get_id() { return IDENTITY.id; }
|
||||
}
|
||||
|
||||
public class Flag : XmppStreamFlag {
|
||||
public static FlagIdentity<Flag> IDENTITY = new FlagIdentity<Flag>(NS_URI, "socks5_bytestreams");
|
||||
|
||||
public Gee.List<Proxy> proxies = new ArrayList<Proxy>();
|
||||
|
||||
public override string get_ns() { return NS_URI; }
|
||||
public override string get_id() { return IDENTITY.id; }
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -11,7 +11,9 @@ public errordomain IqError {
|
|||
BAD_REQUEST,
|
||||
NOT_ACCEPTABLE,
|
||||
NOT_IMPLEMENTED,
|
||||
UNSUPPORTED_INFO,
|
||||
OUT_OF_ORDER,
|
||||
RESOURCE_CONSTRAINT,
|
||||
}
|
||||
|
||||
void send_iq_error(IqError iq_error, XmppStream stream, Iq.Stanza iq) {
|
||||
|
|
@ -22,9 +24,14 @@ void send_iq_error(IqError iq_error, XmppStream stream, Iq.Stanza iq) {
|
|||
error = new ErrorStanza.not_acceptable(iq_error.message);
|
||||
} else if (iq_error is IqError.NOT_IMPLEMENTED) {
|
||||
error = new ErrorStanza.feature_not_implemented(iq_error.message);
|
||||
} else if (iq_error is IqError.UNSUPPORTED_INFO) {
|
||||
StanzaNode unsupported_info = new StanzaNode.build("unsupported-info", ERROR_NS_URI).add_self_xmlns();
|
||||
error = new ErrorStanza.build(ErrorStanza.TYPE_CANCEL, ErrorStanza.CONDITION_FEATURE_NOT_IMPLEMENTED, iq_error.message, unsupported_info);
|
||||
} else if (iq_error is IqError.OUT_OF_ORDER) {
|
||||
StanzaNode out_of_order = new StanzaNode.build("out-of-order", ERROR_NS_URI).add_self_xmlns();
|
||||
error = new ErrorStanza.build(ErrorStanza.TYPE_MODIFY, ErrorStanza.CONDITION_UNEXPECTED_REQUEST, iq_error.message, out_of_order);
|
||||
} else if (iq_error is IqError.RESOURCE_CONSTRAINT) {
|
||||
error = new ErrorStanza.resource_constraint(iq_error.message);
|
||||
} else {
|
||||
assert_not_reached();
|
||||
}
|
||||
|
|
@ -40,7 +47,7 @@ public errordomain Error {
|
|||
TRANSPORT_ERROR,
|
||||
}
|
||||
|
||||
StanzaNode get_single_node_anyns(StanzaNode parent, string node_name) throws IqError {
|
||||
StanzaNode? get_single_node_anyns(StanzaNode parent, string node_name) throws IqError {
|
||||
StanzaNode? result = null;
|
||||
foreach (StanzaNode child in parent.get_all_subnodes()) {
|
||||
if (child.name == node_name) {
|
||||
|
|
@ -50,12 +57,51 @@ StanzaNode get_single_node_anyns(StanzaNode parent, string node_name) throws IqE
|
|||
result = child;
|
||||
}
|
||||
}
|
||||
if (result == null) {
|
||||
throw new IqError.BAD_REQUEST(@"missing $(node_name) node");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
class ContentNode {
|
||||
public Role creator;
|
||||
public string name;
|
||||
public StanzaNode? description;
|
||||
public StanzaNode? transport;
|
||||
}
|
||||
|
||||
ContentNode get_single_content_node(StanzaNode jingle) throws IqError {
|
||||
Gee.List<StanzaNode> contents = jingle.get_subnodes("content");
|
||||
if (contents.size == 0) {
|
||||
throw new IqError.BAD_REQUEST("missing content node");
|
||||
}
|
||||
if (contents.size > 1) {
|
||||
throw new IqError.NOT_IMPLEMENTED("can't process multiple content nodes");
|
||||
}
|
||||
StanzaNode content = contents[0];
|
||||
string? creator_str = content.get_attribute("creator");
|
||||
// Vala can't typecheck the ternary operator here.
|
||||
Role? creator = null;
|
||||
if (creator_str != null) {
|
||||
creator = Role.parse(creator_str);
|
||||
} else {
|
||||
// TODO(hrxi): now, is the creator attribute optional or not (XEP-0166
|
||||
// Jingle)?
|
||||
creator = Role.INITIATOR;
|
||||
}
|
||||
|
||||
string? name = content.get_attribute("name");
|
||||
StanzaNode? description = get_single_node_anyns(content, "description");
|
||||
StanzaNode? transport = get_single_node_anyns(content, "transport");
|
||||
if (name == null || creator == null) {
|
||||
throw new IqError.BAD_REQUEST("missing name or creator");
|
||||
}
|
||||
|
||||
return new ContentNode() {
|
||||
creator=creator,
|
||||
name=name,
|
||||
description=description,
|
||||
transport=transport
|
||||
};
|
||||
}
|
||||
|
||||
public class Module : XmppStreamModule, Iq.Handler {
|
||||
public static Xmpp.ModuleIdentity<Module> IDENTITY = new Xmpp.ModuleIdentity<Module>(NS_URI, "0166_jingle");
|
||||
|
||||
|
|
@ -88,16 +134,21 @@ public class Module : XmppStreamModule, Iq.Handler {
|
|||
return transports[ns_uri];
|
||||
}
|
||||
public Transport? select_transport(XmppStream stream, TransportType type, Jid receiver_full_jid) {
|
||||
Transport? result = null;
|
||||
foreach (Transport transport in transports.values) {
|
||||
if (transport.transport_type() != type) {
|
||||
continue;
|
||||
}
|
||||
// TODO(hrxi): prioritization
|
||||
if (transport.is_transport_available(stream, receiver_full_jid)) {
|
||||
return transport;
|
||||
if (result != null) {
|
||||
if (result.transport_priority() >= transport.transport_priority()) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
result = transport;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private bool is_jingle_available(XmppStream stream, Jid full_jid) {
|
||||
|
|
@ -121,8 +172,8 @@ public class Module : XmppStreamModule, Iq.Handler {
|
|||
if (my_jid == null) {
|
||||
throw new Error.GENERAL("Couldn't determine own JID");
|
||||
}
|
||||
TransportParameters transport_params = transport.create_transport_parameters();
|
||||
Session session = new Session.initiate_sent(random_uuid(), type, transport_params, receiver_full_jid, content_name, stream);
|
||||
TransportParameters transport_params = transport.create_transport_parameters(stream, my_jid, receiver_full_jid);
|
||||
Session session = new Session.initiate_sent(random_uuid(), type, transport_params, my_jid, receiver_full_jid, content_name, stream);
|
||||
StanzaNode content = new StanzaNode.build("content", NS_URI)
|
||||
.put_attribute("creator", "initiator")
|
||||
.put_attribute("name", content_name)
|
||||
|
|
@ -146,38 +197,31 @@ public class Module : XmppStreamModule, Iq.Handler {
|
|||
}
|
||||
|
||||
public void handle_session_initiate(XmppStream stream, string sid, StanzaNode jingle, Iq.Stanza iq) throws IqError {
|
||||
Gee.List<StanzaNode> contents = jingle.get_subnodes("content");
|
||||
if (contents.size == 0) {
|
||||
throw new IqError.BAD_REQUEST("missing content node");
|
||||
ContentNode content = get_single_content_node(jingle);
|
||||
if (content.description == null || content.transport == null) {
|
||||
throw new IqError.BAD_REQUEST("missing description or transport node");
|
||||
}
|
||||
if (contents.size > 1) {
|
||||
throw new IqError.NOT_IMPLEMENTED("can't process multiple content nodes");
|
||||
Jid? my_jid = stream.get_flag(Bind.Flag.IDENTITY).my_jid;
|
||||
if (my_jid == null) {
|
||||
throw new IqError.RESOURCE_CONSTRAINT("Couldn't determine own JID");
|
||||
}
|
||||
StanzaNode content = contents[0];
|
||||
string? name = content.get_attribute("name");
|
||||
StanzaNode description = get_single_node_anyns(content, "description");
|
||||
StanzaNode transport_node = get_single_node_anyns(content, "transport");
|
||||
if (name == null) {
|
||||
throw new IqError.BAD_REQUEST("missing name");
|
||||
}
|
||||
|
||||
Transport? transport = get_transport(transport_node.ns_uri);
|
||||
Transport? transport = get_transport(content.transport.ns_uri);
|
||||
TransportParameters? transport_params = null;
|
||||
if (transport != null) {
|
||||
transport_params = transport.parse_transport_parameters(transport_node);
|
||||
transport_params = transport.parse_transport_parameters(stream, my_jid, iq.from, content.transport);
|
||||
} else {
|
||||
// terminate the session below
|
||||
}
|
||||
|
||||
ContentType? content_type = get_content_type(description.ns_uri);
|
||||
ContentType? content_type = get_content_type(content.description.ns_uri);
|
||||
if (content_type == null) {
|
||||
// TODO(hrxi): how do we signal an unknown content type?
|
||||
throw new IqError.NOT_IMPLEMENTED("unknown content type");
|
||||
}
|
||||
ContentParameters content_params = content_type.parse_content_parameters(description);
|
||||
ContentParameters content_params = content_type.parse_content_parameters(content.description);
|
||||
|
||||
TransportType type = content_type.content_type_transport_type();
|
||||
Session session = new Session.initiate_received(sid, type, transport_params, iq.from, name, stream);
|
||||
Session session = new Session.initiate_received(sid, type, transport_params, my_jid, iq.from, content.name, stream);
|
||||
stream.get_flag(Flag.IDENTITY).add_session(session);
|
||||
stream.get_module(Iq.Module.IDENTITY).send_iq(stream, new Iq.Stanza.result(iq));
|
||||
|
||||
|
|
@ -254,15 +298,20 @@ public interface Transport : Object {
|
|||
public abstract string transport_ns_uri();
|
||||
public abstract bool is_transport_available(XmppStream stream, Jid full_jid);
|
||||
public abstract TransportType transport_type();
|
||||
public abstract TransportParameters create_transport_parameters();
|
||||
public abstract TransportParameters parse_transport_parameters(StanzaNode transport) throws IqError;
|
||||
public abstract int transport_priority();
|
||||
public abstract TransportParameters create_transport_parameters(XmppStream stream, Jid local_full_jid, Jid peer_full_jid);
|
||||
public abstract TransportParameters parse_transport_parameters(XmppStream stream, Jid local_full_jid, Jid peer_full_jid, StanzaNode transport) throws IqError;
|
||||
}
|
||||
|
||||
|
||||
// Gets a null `stream` if connection setup was unsuccessful and another
|
||||
// transport method should be tried.
|
||||
public interface TransportParameters : Object {
|
||||
public abstract string transport_ns_uri();
|
||||
public abstract StanzaNode to_transport_stanza_node();
|
||||
public abstract void update_transport(StanzaNode transport) throws IqError;
|
||||
public abstract IOStream create_transport_connection(XmppStream stream, Jid peer_full_jid, Role role);
|
||||
public abstract void on_transport_accept(StanzaNode transport) throws IqError;
|
||||
public abstract void on_transport_info(StanzaNode transport) throws IqError;
|
||||
public abstract void create_transport_connection(XmppStream stream, Session session);
|
||||
}
|
||||
|
||||
public enum Role {
|
||||
|
|
@ -276,6 +325,14 @@ public enum Role {
|
|||
}
|
||||
assert_not_reached();
|
||||
}
|
||||
|
||||
public static Role parse(string role) throws IqError {
|
||||
switch (role) {
|
||||
case "initiator": return INITIATOR;
|
||||
case "responder": return RESPONDER;
|
||||
}
|
||||
throw new IqError.BAD_REQUEST(@"invalid role $(role)");
|
||||
}
|
||||
}
|
||||
|
||||
public interface ContentType : Object {
|
||||
|
|
@ -290,11 +347,12 @@ public interface ContentParameters : Object {
|
|||
|
||||
|
||||
public class Session {
|
||||
// INITIATE_SENT -> ACTIVE -> ENDED
|
||||
// INITIATE_RECEIVED -> ACTIVE -> ENDED
|
||||
// INITIATE_SENT -> CONNECTING -> ACTIVE -> ENDED
|
||||
// INITIATE_RECEIVED -> CONNECTING -> ACTIVE -> ENDED
|
||||
public enum State {
|
||||
INITIATE_SENT,
|
||||
INITIATE_RECEIVED,
|
||||
CONNECTING,
|
||||
ACTIVE,
|
||||
ENDED,
|
||||
}
|
||||
|
|
@ -303,38 +361,39 @@ public class Session {
|
|||
|
||||
public string sid { get; private set; }
|
||||
public Type type_ { get; private set; }
|
||||
public Jid local_full_jid { get; private set; }
|
||||
public Jid peer_full_jid { get; private set; }
|
||||
public Role content_creator { get; private set; }
|
||||
public string content_name { get; private set; }
|
||||
|
||||
// INITIATE_SENT | INITIATE_RECEIVED
|
||||
private Connection connection;
|
||||
public IOStream conn { get { return connection; } }
|
||||
|
||||
// INITIATE_SENT | INITIATE_RECEIVED | CONNECTING
|
||||
TransportParameters? transport = null;
|
||||
|
||||
// ACTIVE
|
||||
private Connection? connection;
|
||||
public IOStream? conn { get { return connection; } }
|
||||
|
||||
// Only interesting in INITIATE_SENT.
|
||||
// Signals that the session has been accepted by the peer.
|
||||
public signal void accepted(XmppStream stream);
|
||||
|
||||
XmppStream hack;
|
||||
|
||||
public Session.initiate_sent(string sid, Type type, TransportParameters transport, Jid peer_full_jid, string content_name, XmppStream hack) {
|
||||
public Session.initiate_sent(string sid, Type type, TransportParameters transport, Jid local_full_jid, Jid peer_full_jid, string content_name, XmppStream hack) {
|
||||
this.state = State.INITIATE_SENT;
|
||||
this.sid = sid;
|
||||
this.type_ = type;
|
||||
this.local_full_jid = local_full_jid;
|
||||
this.peer_full_jid = peer_full_jid;
|
||||
this.content_creator = Role.INITIATOR;
|
||||
this.content_name = content_name;
|
||||
this.transport = transport;
|
||||
this.connection = new Connection(this);
|
||||
this.hack = hack;
|
||||
}
|
||||
|
||||
public Session.initiate_received(string sid, Type type, TransportParameters? transport, Jid peer_full_jid, string content_name, XmppStream hack) {
|
||||
public Session.initiate_received(string sid, Type type, TransportParameters? transport, Jid local_full_jid, Jid peer_full_jid, string content_name, XmppStream hack) {
|
||||
this.state = State.INITIATE_RECEIVED;
|
||||
this.sid = sid;
|
||||
this.type_ = type;
|
||||
this.local_full_jid = local_full_jid;
|
||||
this.peer_full_jid = peer_full_jid;
|
||||
this.content_creator = Role.INITIATOR;
|
||||
this.content_name = content_name;
|
||||
this.transport = transport;
|
||||
this.connection = new Connection(this);
|
||||
|
|
@ -352,6 +411,9 @@ public class Session {
|
|||
case "session-terminate":
|
||||
handle_session_terminate(stream, jingle, iq);
|
||||
break;
|
||||
case "transport-info":
|
||||
handle_transport_info(stream, jingle, iq);
|
||||
return;
|
||||
case "content-accept":
|
||||
case "content-add":
|
||||
case "content-modify":
|
||||
|
|
@ -359,7 +421,6 @@ public class Session {
|
|||
case "content-remove":
|
||||
case "security-info":
|
||||
case "transport-accept":
|
||||
case "transport-info":
|
||||
case "transport-reject":
|
||||
case "transport-replace":
|
||||
throw new IqError.NOT_IMPLEMENTED(@"$(action) is not implemented");
|
||||
|
|
@ -379,36 +440,83 @@ public class Session {
|
|||
if (!responder.is_full()) {
|
||||
throw new IqError.BAD_REQUEST("invalid responder JID");
|
||||
}
|
||||
Gee.List<StanzaNode> contents = jingle.get_subnodes("content");
|
||||
if (contents.size == 0) {
|
||||
// TODO(hrxi): here and below, should we terminate the session?
|
||||
throw new IqError.BAD_REQUEST("missing content node");
|
||||
ContentNode content = get_single_content_node(jingle);
|
||||
verify_content(content);
|
||||
if (content.description == null || content.transport == null) {
|
||||
throw new IqError.BAD_REQUEST("missing description or transport node");
|
||||
}
|
||||
if (contents.size > 1) {
|
||||
throw new IqError.NOT_IMPLEMENTED("can't process multiple content nodes");
|
||||
}
|
||||
StanzaNode content = contents[0];
|
||||
StanzaNode description = get_single_node_anyns(content, "description");
|
||||
StanzaNode transport_node = get_single_node_anyns(content, "transport");
|
||||
if (transport_node.ns_uri != transport.transport_ns_uri()) {
|
||||
if (content.transport.ns_uri != transport.transport_ns_uri()) {
|
||||
throw new IqError.BAD_REQUEST("session-accept with unnegotiated transport method");
|
||||
}
|
||||
transport.update_transport(transport_node);
|
||||
connection.set_inner(transport.create_transport_connection(stream, peer_full_jid, Role.INITIATOR));
|
||||
transport = null;
|
||||
transport.on_transport_accept(content.transport);
|
||||
StanzaNode description = content.description; // TODO(hrxi): handle this :P
|
||||
state = State.CONNECTING;
|
||||
stream.get_module(Iq.Module.IDENTITY).send_iq(stream, new Iq.Stanza.result(iq));
|
||||
transport.create_transport_connection(stream, this);
|
||||
}
|
||||
void connection_created(XmppStream stream, IOStream? conn) {
|
||||
if (state != State.CONNECTING) {
|
||||
return;
|
||||
}
|
||||
if (conn != null) {
|
||||
state = State.ACTIVE;
|
||||
accepted(stream);
|
||||
transport = null;
|
||||
connection.set_inner(conn);
|
||||
} else {
|
||||
// TODO(hrxi): try negotiating other transports…
|
||||
StanzaNode reason = new StanzaNode.build("reason", NS_URI)
|
||||
.put_node(new StanzaNode.build("failed-transport", NS_URI));
|
||||
terminate(stream, reason, "failed transport");
|
||||
}
|
||||
}
|
||||
void handle_session_terminate(XmppStream stream, StanzaNode jingle, Iq.Stanza iq) throws IqError {
|
||||
connection.on_terminated_by_jingle("remote terminated jingle session");
|
||||
state = ENDED;
|
||||
state = State.ENDED;
|
||||
stream.get_flag(Flag.IDENTITY).remove_session(sid);
|
||||
|
||||
stream.get_module(Iq.Module.IDENTITY).send_iq(stream, new Iq.Stanza.result(iq));
|
||||
// TODO(hrxi): also handle presence type=unavailable
|
||||
}
|
||||
|
||||
void handle_transport_info(XmppStream stream, StanzaNode jingle, Iq.Stanza iq) throws IqError {
|
||||
if (state != State.INITIATE_RECEIVED && state != State.INITIATE_SENT && state != State.CONNECTING) {
|
||||
stream.get_module(Iq.Module.IDENTITY).send_iq(stream, new Iq.Stanza.result(iq));
|
||||
throw new IqError.UNSUPPORTED_INFO("transport-info unsupported after connection setup");
|
||||
}
|
||||
ContentNode content = get_single_content_node(jingle);
|
||||
verify_content(content);
|
||||
if (content.description != null || content.transport == null) {
|
||||
throw new IqError.BAD_REQUEST("unexpected description node or missing transport node");
|
||||
}
|
||||
transport.on_transport_info(content.transport);
|
||||
stream.get_module(Iq.Module.IDENTITY).send_iq(stream, new Iq.Stanza.result(iq));
|
||||
}
|
||||
void verify_content(ContentNode content) throws IqError {
|
||||
if (content.name != content_name || content.creator != content_creator) {
|
||||
throw new IqError.BAD_REQUEST("unknown content");
|
||||
}
|
||||
}
|
||||
public void set_transport_connection(XmppStream stream, IOStream? conn) {
|
||||
if (state != State.CONNECTING) {
|
||||
return;
|
||||
}
|
||||
connection_created(stream, conn);
|
||||
}
|
||||
public void send_transport_info(XmppStream stream, StanzaNode transport) {
|
||||
if (state != State.CONNECTING) {
|
||||
return;
|
||||
}
|
||||
StanzaNode jingle = new StanzaNode.build("jingle", NS_URI)
|
||||
.add_self_xmlns()
|
||||
.put_attribute("action", "transport-info")
|
||||
.put_attribute("sid", sid)
|
||||
.put_node(new StanzaNode.build("content", NS_URI)
|
||||
.put_attribute("creator", "initiator")
|
||||
.put_attribute("name", content_name)
|
||||
.put_node(transport)
|
||||
);
|
||||
Iq.Stanza iq = new Iq.Stanza.set(jingle) { to=peer_full_jid };
|
||||
stream.get_module(Iq.Module.IDENTITY).send_iq(stream, iq);
|
||||
}
|
||||
public void accept(XmppStream stream, StanzaNode description) {
|
||||
if (state != State.INITIATE_RECEIVED) {
|
||||
return; // TODO(hrxi): what to do?
|
||||
|
|
@ -426,10 +534,8 @@ public class Session {
|
|||
Iq.Stanza iq = new Iq.Stanza.set(jingle) { to=peer_full_jid };
|
||||
stream.get_module(Iq.Module.IDENTITY).send_iq(stream, iq);
|
||||
|
||||
connection.set_inner(transport.create_transport_connection(stream, peer_full_jid, Role.RESPONDER));
|
||||
transport = null;
|
||||
|
||||
state = State.ACTIVE;
|
||||
state = State.CONNECTING;
|
||||
transport.create_transport_connection(stream, this);
|
||||
}
|
||||
|
||||
public void reject(XmppStream stream) {
|
||||
|
|
@ -607,7 +713,6 @@ public class Connection : IOStream {
|
|||
try {
|
||||
return yield inner.input_stream.read_async(buffer, io_priority, cancellable);
|
||||
} catch (IOError e) {
|
||||
print("read_async error\n");
|
||||
handle_connection_error(e);
|
||||
throw e;
|
||||
}
|
||||
|
|
@ -617,7 +722,6 @@ public class Connection : IOStream {
|
|||
try {
|
||||
return yield inner.output_stream.write_async(buffer, io_priority, cancellable);
|
||||
} catch (IOError e) {
|
||||
print("write_async error\n");
|
||||
handle_connection_error(e);
|
||||
throw e;
|
||||
}
|
||||
|
|
@ -641,7 +745,6 @@ public class Connection : IOStream {
|
|||
try {
|
||||
result = yield inner.input_stream.close_async(io_priority, cancellable);
|
||||
} catch (IOError e) {
|
||||
print("input_stream.close_async error\n");
|
||||
if (error == null) {
|
||||
error = e;
|
||||
}
|
||||
|
|
@ -649,7 +752,6 @@ public class Connection : IOStream {
|
|||
try {
|
||||
result = (yield close_if_both_closed(io_priority, cancellable)) && result;
|
||||
} catch (IOError e) {
|
||||
print("close_if_both_closed error\n");
|
||||
if (error == null) {
|
||||
error = e;
|
||||
}
|
||||
|
|
@ -679,7 +781,6 @@ public class Connection : IOStream {
|
|||
try {
|
||||
result = yield inner.output_stream.close_async(io_priority, cancellable);
|
||||
} catch (IOError e) {
|
||||
print("output_stream.close_async error\n");
|
||||
if (error == null) {
|
||||
error = e;
|
||||
}
|
||||
|
|
@ -687,7 +788,6 @@ public class Connection : IOStream {
|
|||
try {
|
||||
result = (yield close_if_both_closed(io_priority, cancellable)) && result;
|
||||
} catch (IOError e) {
|
||||
print("close_if_both_closed error\n");
|
||||
if (error == null) {
|
||||
error = e;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -162,7 +162,7 @@ public class FileTransfer : Object {
|
|||
this.stream = new FileTransferInputStream(session.conn.input_stream, parameters.size);
|
||||
}
|
||||
|
||||
public void accept(XmppStream stream) {
|
||||
public void accept(XmppStream stream) throws IOError {
|
||||
session.accept(stream, parameters.original_description);
|
||||
session.conn.output_stream.close();
|
||||
}
|
||||
|
|
|
|||
505
xmpp-vala/src/module/xep/0260_jingle_socks5_bytestreams.vala
Normal file
505
xmpp-vala/src/module/xep/0260_jingle_socks5_bytestreams.vala
Normal file
|
|
@ -0,0 +1,505 @@
|
|||
using Gee;
|
||||
using Xmpp;
|
||||
using Xmpp.Xep;
|
||||
|
||||
namespace Xmpp.Xep.JingleSocks5Bytestreams {
|
||||
|
||||
private const string NS_URI = "urn:xmpp:jingle:transports:s5b:1";
|
||||
|
||||
public class Module : Jingle.Transport, XmppStreamModule {
|
||||
public static Xmpp.ModuleIdentity<Module> IDENTITY = new Xmpp.ModuleIdentity<Module>(NS_URI, "0260_jingle_socks5_bytestreams");
|
||||
|
||||
public override void attach(XmppStream stream) {
|
||||
stream.get_module(Jingle.Module.IDENTITY).register_transport(this);
|
||||
stream.get_module(ServiceDiscovery.Module.IDENTITY).add_feature(stream, NS_URI);
|
||||
}
|
||||
public override void detach(XmppStream stream) { }
|
||||
|
||||
public override string get_ns() { return NS_URI; }
|
||||
public override string get_id() { return IDENTITY.id; }
|
||||
|
||||
public bool is_transport_available(XmppStream stream, Jid full_jid) {
|
||||
bool? result = stream.get_flag(ServiceDiscovery.Flag.IDENTITY).has_entity_feature(full_jid, NS_URI);
|
||||
return result != null && result;
|
||||
}
|
||||
|
||||
public string transport_ns_uri() {
|
||||
return NS_URI;
|
||||
}
|
||||
public Jingle.TransportType transport_type() {
|
||||
return Jingle.TransportType.STREAMING;
|
||||
}
|
||||
public int transport_priority() {
|
||||
return 1;
|
||||
}
|
||||
private Gee.List<Candidate> get_local_candidates(XmppStream stream) {
|
||||
Gee.List<Candidate> result = new ArrayList<Candidate>();
|
||||
int i = 1 << 15;
|
||||
foreach (Socks5Bytestreams.Proxy proxy in stream.get_module(Socks5Bytestreams.Module.IDENTITY).get_proxies(stream)) {
|
||||
result.add(new Candidate.proxy(random_uuid(), proxy, i));
|
||||
i -= 1;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
public Jingle.TransportParameters create_transport_parameters(XmppStream stream, Jid local_full_jid, Jid peer_full_jid) {
|
||||
Parameters result = new Parameters.create(local_full_jid, peer_full_jid, random_uuid());
|
||||
result.local_candidates.add_all(get_local_candidates(stream));
|
||||
return result;
|
||||
}
|
||||
public Jingle.TransportParameters parse_transport_parameters(XmppStream stream, Jid local_full_jid, Jid peer_full_jid, StanzaNode transport) throws Jingle.IqError {
|
||||
Parameters result = Parameters.parse(local_full_jid, peer_full_jid, transport);
|
||||
result.local_candidates.add_all(get_local_candidates(stream));
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
public enum CandidateType {
|
||||
ASSISTED,
|
||||
DIRECT,
|
||||
PROXY,
|
||||
TUNNEL;
|
||||
|
||||
public static CandidateType parse(string type) throws Jingle.IqError {
|
||||
switch (type) {
|
||||
case "assisted": return CandidateType.ASSISTED;
|
||||
case "direct": return CandidateType.DIRECT;
|
||||
case "proxy": return CandidateType.PROXY;
|
||||
case "tunnel": return CandidateType.TUNNEL;
|
||||
}
|
||||
throw new Jingle.IqError.BAD_REQUEST(@"unknown candidate type $(type)");
|
||||
}
|
||||
|
||||
public string to_string() {
|
||||
switch (this) {
|
||||
case ASSISTED: return "assisted";
|
||||
case DIRECT: return "direct";
|
||||
case PROXY: return "proxy";
|
||||
case TUNNEL: return "tunnel";
|
||||
}
|
||||
assert_not_reached();
|
||||
}
|
||||
|
||||
private int type_preference_impl() {
|
||||
switch (this) {
|
||||
case ASSISTED: return 120;
|
||||
case DIRECT: return 126;
|
||||
case PROXY: return 10;
|
||||
case TUNNEL: return 110;
|
||||
}
|
||||
assert_not_reached();
|
||||
}
|
||||
public int type_preference() {
|
||||
return type_preference_impl() << 16;
|
||||
}
|
||||
}
|
||||
|
||||
public class Candidate : Socks5Bytestreams.Proxy {
|
||||
public string cid { get; private set; }
|
||||
public int priority { get; private set; }
|
||||
public CandidateType type_ { get; private set; }
|
||||
|
||||
private Candidate(string cid, string host, Jid jid, int port, int priority, CandidateType type) {
|
||||
base(host, jid, port);
|
||||
this.cid = cid;
|
||||
this.priority = priority;
|
||||
this.type_ = type;
|
||||
}
|
||||
|
||||
public Candidate.build(string cid, string host, Jid jid, int port, int local_priority, CandidateType type) {
|
||||
this(cid, host, jid, port, type.type_preference() + local_priority, type);
|
||||
}
|
||||
public Candidate.proxy(string cid, Socks5Bytestreams.Proxy proxy, int local_priority) {
|
||||
this.build(cid, proxy.host, proxy.jid, proxy.port, local_priority, CandidateType.PROXY);
|
||||
}
|
||||
|
||||
public static Candidate parse(StanzaNode candidate) throws Jingle.IqError {
|
||||
string? cid = candidate.get_attribute("cid");
|
||||
string? host = candidate.get_attribute("host");
|
||||
string? jid_str = candidate.get_attribute("jid");
|
||||
Jid? jid = jid_str != null ? Jid.parse(jid_str) : null;
|
||||
int port = candidate.get_attribute("port") != null ? candidate.get_attribute_int("port") : 1080;
|
||||
int priority = candidate.get_attribute_int("priority");
|
||||
string? type_str = candidate.get_attribute("type");
|
||||
CandidateType type = type_str != null ? CandidateType.parse(type_str) : CandidateType.DIRECT;
|
||||
|
||||
if (cid == null || host == null || jid == null || port <= 0 || priority <= 0) {
|
||||
throw new Jingle.IqError.BAD_REQUEST("missing or invalid cid, host, jid or port");
|
||||
}
|
||||
|
||||
return new Candidate(cid, host, jid, port, priority, type);
|
||||
}
|
||||
public StanzaNode to_xml() {
|
||||
return new StanzaNode.build("candidate", NS_URI)
|
||||
.put_attribute("cid", cid)
|
||||
.put_attribute("host", host)
|
||||
.put_attribute("jid", jid.to_string())
|
||||
.put_attribute("port", port.to_string())
|
||||
.put_attribute("priority", priority.to_string())
|
||||
.put_attribute("type", type_.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
bool bytes_equal(uint8[] a, uint8[] b) {
|
||||
if (a.length != b.length) {
|
||||
return false;
|
||||
}
|
||||
for (int i = 0; i < a.length; i++) {
|
||||
if (a[i] != b[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
class Parameters : Jingle.TransportParameters, Object {
|
||||
public Jingle.Role role { get; private set; }
|
||||
public string sid { get; private set; }
|
||||
public string remote_dstaddr { get; private set; }
|
||||
public string local_dstaddr { get; private set; }
|
||||
public Gee.List<Candidate> local_candidates = new ArrayList<Candidate>();
|
||||
public Gee.List<Candidate> remote_candidates = new ArrayList<Candidate>();
|
||||
|
||||
Jid peer_full_jid;
|
||||
|
||||
bool remote_sent_selected_candidate = false;
|
||||
Candidate? remote_selected_candidate = null;
|
||||
bool local_determined_selected_candidate = false;
|
||||
Candidate? local_selected_candidate = null;
|
||||
SocketConnection? local_selected_candidate_conn = null;
|
||||
weak Jingle.Session? session = null;
|
||||
XmppStream? hack = null;
|
||||
|
||||
string? waiting_for_activation_cid = null;
|
||||
SourceFunc waiting_for_activation_callback;
|
||||
|
||||
private static string calculate_dstaddr(string sid, Jid first_jid, Jid second_jid) {
|
||||
string hashed = sid + first_jid.to_string() + second_jid.to_string();
|
||||
return Checksum.compute_for_string(ChecksumType.SHA1, hashed);
|
||||
}
|
||||
private Parameters(Jingle.Role role, string sid, Jid local_full_jid, Jid peer_full_jid, string? remote_dstaddr) {
|
||||
this.role = role;
|
||||
this.sid = sid;
|
||||
this.local_dstaddr = calculate_dstaddr(sid, local_full_jid, peer_full_jid);
|
||||
this.remote_dstaddr = remote_dstaddr ?? calculate_dstaddr(sid, peer_full_jid, local_full_jid);
|
||||
|
||||
this.peer_full_jid = peer_full_jid;
|
||||
}
|
||||
public Parameters.create(Jid local_full_jid, Jid peer_full_jid, string sid) {
|
||||
this(Jingle.Role.INITIATOR, sid, local_full_jid, peer_full_jid, null);
|
||||
}
|
||||
public static Parameters parse(Jid local_full_jid, Jid peer_full_jid, StanzaNode transport) throws Jingle.IqError {
|
||||
string? dstaddr = transport.get_attribute("dstaddr");
|
||||
string? mode = transport.get_attribute("mode");
|
||||
string? sid = transport.get_attribute("sid");
|
||||
if (mode != null && mode != "tcp") {
|
||||
throw new Jingle.IqError.BAD_REQUEST(@"unknown transport method $(mode)");
|
||||
}
|
||||
if (dstaddr != null && dstaddr.length > 255) {
|
||||
throw new Jingle.IqError.BAD_REQUEST("too long dstaddr");
|
||||
}
|
||||
Parameters result = new Parameters(Jingle.Role.RESPONDER, sid, local_full_jid, peer_full_jid, dstaddr);
|
||||
//result.remote_candidates.add(new Candidate("b", "0.0.0.0", new Jid("a@b/c"), 1234, 2000000000, CandidateType.PROXY));
|
||||
foreach (StanzaNode candidate in transport.get_subnodes("candidate", NS_URI)) {
|
||||
result.remote_candidates.add(Candidate.parse(candidate));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
public string transport_ns_uri() {
|
||||
return NS_URI;
|
||||
}
|
||||
public StanzaNode to_transport_stanza_node() {
|
||||
StanzaNode transport = new StanzaNode.build("transport", NS_URI)
|
||||
.add_self_xmlns()
|
||||
.put_attribute("dstaddr", local_dstaddr);
|
||||
|
||||
if (role == Jingle.Role.INITIATOR) {
|
||||
// Must not be included by the responder according to XEP-0260.
|
||||
transport.put_attribute("mode", "tcp");
|
||||
}
|
||||
|
||||
transport.put_attribute("sid", sid);
|
||||
foreach (Candidate candidate in local_candidates) {
|
||||
transport.put_node(candidate.to_xml());
|
||||
}
|
||||
return transport;
|
||||
}
|
||||
public void on_transport_accept(StanzaNode transport) throws Jingle.IqError {
|
||||
throw new Jingle.IqError.BAD_REQUEST("blurb");
|
||||
}
|
||||
public void on_transport_info(StanzaNode transport) throws Jingle.IqError {
|
||||
StanzaNode? candidate_error = transport.get_subnode("candidate-error", NS_URI);
|
||||
StanzaNode? candidate_used = transport.get_subnode("candidate-used", NS_URI);
|
||||
StanzaNode? activated = transport.get_subnode("activated", NS_URI);
|
||||
int num_children = 0;
|
||||
if (candidate_error != null) { num_children += 1; }
|
||||
if (candidate_used != null) { num_children += 1; }
|
||||
if (activated != null) { num_children += 1; }
|
||||
if (num_children == 0) {
|
||||
throw new Jingle.IqError.UNSUPPORTED_INFO("unknown transport-info");
|
||||
} else if (num_children > 1) {
|
||||
throw new Jingle.IqError.BAD_REQUEST("transport-info with more than one child");
|
||||
}
|
||||
if (candidate_error != null) {
|
||||
handle_remote_candidate(null);
|
||||
}
|
||||
if (candidate_used != null) {
|
||||
string? cid = candidate_used.get_attribute("cid");
|
||||
if (cid == null) {
|
||||
throw new Jingle.IqError.BAD_REQUEST("missing cid");
|
||||
}
|
||||
handle_remote_candidate(cid);
|
||||
}
|
||||
if (activated != null) {
|
||||
string? cid = activated.get_attribute("cid");
|
||||
if (cid == null) {
|
||||
throw new Jingle.IqError.BAD_REQUEST("missing cid");
|
||||
}
|
||||
handle_activated(cid);
|
||||
}
|
||||
}
|
||||
private void handle_remote_candidate(string? cid) throws Jingle.IqError {
|
||||
if (remote_sent_selected_candidate) {
|
||||
throw new Jingle.IqError.BAD_REQUEST("remote candidate already specified");
|
||||
}
|
||||
Candidate? candidate = null;
|
||||
if (cid != null) {
|
||||
foreach (Candidate c in local_candidates) {
|
||||
if (c.cid == cid) {
|
||||
candidate = c;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (candidate == null) {
|
||||
throw new Jingle.IqError.BAD_REQUEST("unknown cid");
|
||||
}
|
||||
}
|
||||
remote_sent_selected_candidate = true;
|
||||
remote_selected_candidate = candidate;
|
||||
try_completing_negotiation();
|
||||
}
|
||||
private void handle_activated(string cid) throws Jingle.IqError {
|
||||
if (waiting_for_activation_cid == null || cid != waiting_for_activation_cid) {
|
||||
throw new Jingle.IqError.BAD_REQUEST("unexpected proxy activation message");
|
||||
}
|
||||
Idle.add((owned)waiting_for_activation_callback);
|
||||
waiting_for_activation_cid = null;
|
||||
}
|
||||
private void try_completing_negotiation() {
|
||||
if (!remote_sent_selected_candidate || !local_determined_selected_candidate) {
|
||||
return;
|
||||
}
|
||||
|
||||
Candidate? remote = remote_selected_candidate;
|
||||
Candidate? local = local_selected_candidate;
|
||||
|
||||
int num_candidates = 0;
|
||||
if (remote != null) { num_candidates += 1; }
|
||||
if (local != null) { num_candidates += 1; }
|
||||
|
||||
if (num_candidates == 0) {
|
||||
// Notify Jingle of the failed transport.
|
||||
session.set_transport_connection(hack, null);
|
||||
return;
|
||||
}
|
||||
|
||||
bool remote_wins;
|
||||
if (num_candidates == 1) {
|
||||
remote_wins = remote != null;
|
||||
} else {
|
||||
if (local.priority < remote.priority) {
|
||||
remote_wins = true;
|
||||
} else if (local.priority > remote.priority) {
|
||||
remote_wins = false;
|
||||
} else {
|
||||
// equal priority -> XEP-0260 says that the initiator wins
|
||||
remote_wins = role != Jingle.Role.INITIATOR;
|
||||
}
|
||||
}
|
||||
|
||||
if (!remote_wins) {
|
||||
if (local_selected_candidate.type_ != CandidateType.PROXY) {
|
||||
Jingle.Session? strong = session;
|
||||
if (strong == null) {
|
||||
return;
|
||||
}
|
||||
strong.set_transport_connection(hack, local_selected_candidate_conn);
|
||||
} else {
|
||||
wait_for_remote_activation.begin(local_selected_candidate, local_selected_candidate_conn);
|
||||
}
|
||||
} else {
|
||||
connect_to_local_candidate.begin(remote_selected_candidate);
|
||||
}
|
||||
}
|
||||
public async void wait_for_remote_activation(Candidate candidate, SocketConnection conn) {
|
||||
waiting_for_activation_cid = candidate.cid;
|
||||
waiting_for_activation_callback = wait_for_remote_activation.callback;
|
||||
yield;
|
||||
|
||||
Jingle.Session? strong = session;
|
||||
if (strong == null) {
|
||||
return;
|
||||
}
|
||||
strong.set_transport_connection(hack, conn);
|
||||
}
|
||||
public async void connect_to_local_candidate(Candidate candidate) {
|
||||
try {
|
||||
SocketConnection conn = yield connect_to_socks5(candidate, local_dstaddr);
|
||||
|
||||
bool activation_error = false;
|
||||
SourceFunc callback = connect_to_local_candidate.callback;
|
||||
StanzaNode query = new StanzaNode.build("query", Socks5Bytestreams.NS_URI)
|
||||
.add_self_xmlns()
|
||||
.put_attribute("sid", sid)
|
||||
.put_node(new StanzaNode.build("activate", Socks5Bytestreams.NS_URI)
|
||||
.put_node(new StanzaNode.text(peer_full_jid.to_string()))
|
||||
);
|
||||
Iq.Stanza iq = new Iq.Stanza.set(query) { to=candidate.jid };
|
||||
hack.get_module(Iq.Module.IDENTITY).send_iq(hack, iq, (stream, iq) => {
|
||||
activation_error = iq.is_error();
|
||||
Idle.add((owned)callback);
|
||||
});
|
||||
yield;
|
||||
|
||||
if (activation_error) {
|
||||
throw new IOError.PROXY_FAILED("activation iq error");
|
||||
}
|
||||
|
||||
Jingle.Session? strong = session;
|
||||
if (strong == null) {
|
||||
return;
|
||||
}
|
||||
strong.send_transport_info(hack, new StanzaNode.build("transport", NS_URI)
|
||||
.add_self_xmlns()
|
||||
.put_attribute("sid", sid)
|
||||
.put_node(new StanzaNode.build("activated", NS_URI)
|
||||
.put_attribute("cid", candidate.cid)
|
||||
)
|
||||
);
|
||||
|
||||
strong.set_transport_connection(hack, conn);
|
||||
} catch (Error e) {
|
||||
Jingle.Session? strong = session;
|
||||
if (strong == null) {
|
||||
return;
|
||||
}
|
||||
strong.send_transport_info(hack, new StanzaNode.build("transport", NS_URI)
|
||||
.add_self_xmlns()
|
||||
.put_attribute("sid", sid)
|
||||
.put_node(new StanzaNode.build("proxy-error", NS_URI))
|
||||
);
|
||||
strong.set_transport_connection(hack, null);
|
||||
}
|
||||
}
|
||||
public async SocketConnection connect_to_socks5(Candidate candidate, string dstaddr) throws Error {
|
||||
SocketClient socket_client = new SocketClient() { timeout=3 };
|
||||
|
||||
string address = @"[$(candidate.host)]:$(candidate.port)";
|
||||
|
||||
size_t written;
|
||||
size_t read;
|
||||
uint8[] read_buffer = new uint8[1024];
|
||||
ByteArray write_buffer = new ByteArray();
|
||||
|
||||
SocketConnection conn = yield socket_client.connect_to_host_async(address, 0);
|
||||
|
||||
// 05 SOCKS version 5
|
||||
// 01 number of authentication methods: 1
|
||||
// 00 nop authentication
|
||||
yield conn.output_stream.write_all_async({0x05, 0x01, 0x00}, GLib.Priority.DEFAULT, null, out written);
|
||||
|
||||
yield conn.input_stream.read_all_async(read_buffer[0:2], GLib.Priority.DEFAULT, null, out read);
|
||||
// 05 SOCKS version 5
|
||||
// 01 success
|
||||
if (read_buffer[0] != 0x05 || read_buffer[1] != 0x00) {
|
||||
throw new IOError.PROXY_FAILED("wanted 05 00, got %02x %02x".printf(read_buffer[0], read_buffer[1]));
|
||||
}
|
||||
|
||||
// 05 SOCKS version 5
|
||||
// 01 connect
|
||||
// 00 reserved
|
||||
// 03 address type: domain name
|
||||
// ?? length of the domain
|
||||
// .. domain
|
||||
// 00 port 0 (upper half)
|
||||
// 00 port 0 (lower half)
|
||||
write_buffer.append({0x05, 0x01, 0x00, 0x03});
|
||||
write_buffer.append({(uint8)dstaddr.length});
|
||||
write_buffer.append(dstaddr.data);
|
||||
write_buffer.append({0x00, 0x00});
|
||||
yield conn.output_stream.write_all_async(write_buffer.data, GLib.Priority.DEFAULT, null, out written);
|
||||
|
||||
yield conn.input_stream.read_all_async(read_buffer[0:write_buffer.len], GLib.Priority.DEFAULT, null, out read);
|
||||
// 05 SOCKS version 5
|
||||
// 00 success
|
||||
// 00 reserved
|
||||
// 03 address type: domain name
|
||||
// ?? length of the domain
|
||||
// .. domain
|
||||
// 00 port 0 (upper half)
|
||||
// 00 port 0 (lower half)
|
||||
if (read_buffer[0] != 0x05 || read_buffer[1] != 0x00 || read_buffer[3] != 0x03) {
|
||||
throw new IOError.PROXY_FAILED("wanted 05 00 ?? 03, got %02x %02x %02x %02x".printf(read_buffer[0], read_buffer[1], read_buffer[2], read_buffer[3]));
|
||||
}
|
||||
if (read_buffer[4] != (uint8)dstaddr.length) {
|
||||
throw new IOError.PROXY_FAILED("wanted %02x for length, got %02x".printf(dstaddr.length, read_buffer[4]));
|
||||
}
|
||||
if (!bytes_equal(read_buffer[5:5+dstaddr.length], dstaddr.data)) {
|
||||
string repr = ((string)read_buffer[5:5+dstaddr.length]).make_valid().escape();
|
||||
throw new IOError.PROXY_FAILED(@"wanted dstaddr $(dstaddr), got $(repr)");
|
||||
}
|
||||
if (read_buffer[5+dstaddr.length] != 0x00 || read_buffer[5+dstaddr.length+1] != 0x00) {
|
||||
throw new IOError.PROXY_FAILED("wanted port 00 00, got %02x %02x".printf(read_buffer[5+dstaddr.length], read_buffer[5+dstaddr.length+1]));
|
||||
}
|
||||
|
||||
return conn;
|
||||
}
|
||||
public async void try_connecting_to_candidates(XmppStream stream, Jingle.Session session) throws Error {
|
||||
remote_candidates.sort((c1, c2) => {
|
||||
// sort from priorities from high to low
|
||||
if (c1.priority < c2.priority) { return 1; }
|
||||
if (c1.priority > c2.priority) { return -1; }
|
||||
return 0;
|
||||
});
|
||||
foreach (Candidate candidate in remote_candidates) {
|
||||
if (remote_selected_candidate != null && remote_selected_candidate.priority > candidate.priority) {
|
||||
// Don't try candidates with lower priority than the one the
|
||||
// peer already selected.
|
||||
break;
|
||||
}
|
||||
try {
|
||||
SocketConnection conn = yield connect_to_socks5(candidate, remote_dstaddr);
|
||||
|
||||
local_determined_selected_candidate = true;
|
||||
local_selected_candidate = candidate;
|
||||
local_selected_candidate_conn = conn;
|
||||
session.send_transport_info(stream, new StanzaNode.build("transport", NS_URI)
|
||||
.add_self_xmlns()
|
||||
.put_attribute("sid", sid)
|
||||
.put_node(new StanzaNode.build("candidate-used", NS_URI)
|
||||
.put_attribute("cid", candidate.cid)
|
||||
)
|
||||
);
|
||||
try_completing_negotiation();
|
||||
return;
|
||||
} catch (Error e) {
|
||||
// An error in the connection establishment isn't fatal, just
|
||||
// try the next candidate or respond that none of the
|
||||
// candidates work.
|
||||
}
|
||||
}
|
||||
local_determined_selected_candidate = true;
|
||||
local_selected_candidate = null;
|
||||
session.send_transport_info(stream, new StanzaNode.build("transport", NS_URI)
|
||||
.add_self_xmlns()
|
||||
.put_attribute("sid", sid)
|
||||
.put_node(new StanzaNode.build("candidate-error", NS_URI))
|
||||
);
|
||||
}
|
||||
public void create_transport_connection(XmppStream stream, Jingle.Session session) {
|
||||
this.session = session;
|
||||
this.hack = stream;
|
||||
try_connecting_to_candidates.begin(stream, session);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -30,28 +30,38 @@ public class Module : Jingle.Transport, XmppStreamModule {
|
|||
public Jingle.TransportType transport_type() {
|
||||
return Jingle.TransportType.STREAMING;
|
||||
}
|
||||
public Jingle.TransportParameters create_transport_parameters() {
|
||||
return new Parameters(random_uuid(), DEFAULT_BLOCKSIZE);
|
||||
public int transport_priority() {
|
||||
return 0;
|
||||
}
|
||||
public Jingle.TransportParameters parse_transport_parameters(StanzaNode transport) throws Jingle.IqError {
|
||||
return Parameters.parse(transport);
|
||||
public Jingle.TransportParameters create_transport_parameters(XmppStream stream, Jid local_full_jid, Jid peer_full_jid) {
|
||||
return new Parameters.create(peer_full_jid, random_uuid());
|
||||
}
|
||||
public Jingle.TransportParameters parse_transport_parameters(XmppStream stream, Jid local_full_jid, Jid peer_full_jid, StanzaNode transport) throws Jingle.IqError {
|
||||
return Parameters.parse(peer_full_jid, transport);
|
||||
}
|
||||
}
|
||||
|
||||
class Parameters : Jingle.TransportParameters, Object {
|
||||
public Jingle.Role role { get; private set; }
|
||||
public Jid peer_full_jid { get; private set; }
|
||||
public string sid { get; private set; }
|
||||
public int block_size { get; private set; }
|
||||
public Parameters(string sid, int block_size) {
|
||||
private Parameters(Jingle.Role role, Jid peer_full_jid, string sid, int block_size) {
|
||||
this.role = role;
|
||||
this.peer_full_jid = peer_full_jid;
|
||||
this.sid = sid;
|
||||
this.block_size = block_size;
|
||||
}
|
||||
public static Parameters parse(StanzaNode transport) throws Jingle.IqError {
|
||||
public Parameters.create(Jid peer_full_jid, string sid) {
|
||||
this(Jingle.Role.INITIATOR, peer_full_jid, sid, DEFAULT_BLOCKSIZE);
|
||||
}
|
||||
public static Parameters parse(Jid peer_full_jid, StanzaNode transport) throws Jingle.IqError {
|
||||
string? sid = transport.get_attribute("sid");
|
||||
int block_size = transport.get_attribute_int("block-size");
|
||||
if (sid == null || block_size <= 0 || block_size > MAX_BLOCKSIZE) {
|
||||
throw new Jingle.IqError.BAD_REQUEST("missing or invalid sid or blocksize");
|
||||
}
|
||||
return new Parameters(sid, block_size);
|
||||
return new Parameters(Jingle.Role.RESPONDER, peer_full_jid, sid, block_size);
|
||||
}
|
||||
public string transport_ns_uri() {
|
||||
return NS_URI;
|
||||
|
|
@ -62,15 +72,18 @@ class Parameters : Jingle.TransportParameters, Object {
|
|||
.put_attribute("block-size", block_size.to_string())
|
||||
.put_attribute("sid", sid);
|
||||
}
|
||||
public void update_transport(StanzaNode transport) throws Jingle.IqError {
|
||||
Parameters other = Parameters.parse(transport);
|
||||
public void on_transport_accept(StanzaNode transport) throws Jingle.IqError {
|
||||
Parameters other = Parameters.parse(peer_full_jid, transport);
|
||||
if (other.sid != sid || other.block_size > block_size) {
|
||||
throw new Jingle.IqError.NOT_ACCEPTABLE("invalid IBB sid or block_size");
|
||||
}
|
||||
block_size = other.block_size;
|
||||
}
|
||||
public IOStream create_transport_connection(XmppStream stream, Jid peer_full_jid, Jingle.Role role) {
|
||||
return InBandBytestreams.Connection.create(stream, peer_full_jid, sid, block_size, role == Jingle.Role.INITIATOR);
|
||||
public void on_transport_info(StanzaNode transport) throws Jingle.IqError {
|
||||
throw new Jingle.IqError.UNSUPPORTED_INFO("transport-info not supported for IBBs");
|
||||
}
|
||||
public void create_transport_connection(XmppStream stream, Jingle.Session session) {
|
||||
session.set_transport_connection(stream, InBandBytestreams.Connection.create(stream, peer_full_jid, sid, block_size, role == Jingle.Role.INITIATOR));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue