Replace the connection_tree with a connection_list.

[tinc] / src / protocol_auth.c

diff --git a/src/protocol_auth.c b/src/protocol_auth.c
index 057b88e..59917c6 100644 (file)
--- a/src/protocol_auth.c
+++ b/src/protocol_auth.c
@@ -20,7 +20,6 @@
 
 #include "system.h"
 
-#include "splay_tree.h"
 #include "conf.h"
 #include "connection.h"
 #include "control.h"
@@ -42,6 +41,92 @@
 #include "utils.h"
 #include "xalloc.h"
 
+static bool send_proxyrequest(connection_t *c) {
+       switch(proxytype) {
+               case PROXY_HTTP: {
+                       char *host;
+                       char *port;
+
+                       sockaddr2str(&c->address, &host, &port);
+                       send_request(c, "CONNECT %s:%s HTTP/1.1\r\n\r", host, port);
+                       free(host);
+                       free(port);
+                       return true;
+               }
+               case PROXY_SOCKS4: {
+                       if(c->address.sa.sa_family != AF_INET) {
+                               logger(DEBUG_ALWAYS, LOG_ERR, "Cannot connect to an IPv6 host through a SOCKS 4 proxy!");
+                               return false;
+                       }
+                       char s4req[9 + (proxyuser ? strlen(proxyuser) : 0)];
+                       s4req[0] = 4;
+                       s4req[1] = 1;
+                       memcpy(s4req + 2, &c->address.in.sin_port, 2);
+                       memcpy(s4req + 4, &c->address.in.sin_addr, 4);
+                       if(proxyuser)
+                               memcpy(s4req + 8, proxyuser, strlen(proxyuser));
+                       s4req[sizeof s4req - 1] = 0;
+                       c->tcplen = 8;
+                       return send_meta(c, s4req, sizeof s4req);
+               }
+               case PROXY_SOCKS5: {
+                       int len = 3 + 6 + (c->address.sa.sa_family == AF_INET ? 4 : 16);
+                       c->tcplen = 2;
+                       if(proxypass)
+                               len += 3 + strlen(proxyuser) + strlen(proxypass);
+                       char s5req[len];
+                       int i = 0;
+                       s5req[i++] = 5;
+                       s5req[i++] = 1;
+                       if(proxypass) {
+                               s5req[i++] = 2;
+                               s5req[i++] = 1;
+                               s5req[i++] = strlen(proxyuser);
+                               memcpy(s5req + i, proxyuser, strlen(proxyuser));
+                               i += strlen(proxyuser);
+                               s5req[i++] = strlen(proxypass);
+                               memcpy(s5req + i, proxypass, strlen(proxypass));
+                               i += strlen(proxypass);
+                               c->tcplen += 2;
+                       } else {
+                               s5req[i++] = 0;
+                       }
+                       s5req[i++] = 5;
+                       s5req[i++] = 1;
+                       s5req[i++] = 0;
+                       if(c->address.sa.sa_family == AF_INET) {
+                               s5req[i++] = 1;
+                               memcpy(s5req + i, &c->address.in.sin_addr, 4);
+                               i += 4;
+                               memcpy(s5req + i, &c->address.in.sin_port, 2);
+                               i += 2;
+                               c->tcplen += 10;
+                       } else if(c->address.sa.sa_family == AF_INET6) {
+                               s5req[i++] = 3;
+                               memcpy(s5req + i, &c->address.in6.sin6_addr, 16);
+                               i += 16;
+                               memcpy(s5req + i, &c->address.in6.sin6_port, 2);
+                               i += 2;
+                               c->tcplen += 22;
+                       } else {
+                               logger(DEBUG_ALWAYS, LOG_ERR, "Address family %hx not supported for SOCKS 5 proxies!", c->address.sa.sa_family);
+                               return false;
+                       }
+                       if(i > len)
+                               abort();
+                       return send_meta(c, s5req, sizeof s5req);
+               }
+               case PROXY_SOCKS4A:
+                       logger(DEBUG_ALWAYS, LOG_ERR, "Proxy type not implemented yet");
+                       return false;
+               case PROXY_EXEC:
+                       return true;
+               default:
+                       logger(DEBUG_ALWAYS, LOG_ERR, "Unknown proxy type");
+                       return false;
+       }
+}
+
 bool send_id(connection_t *c) {
        gettimeofday(&c->start, NULL);
 
@@ -54,6 +139,10 @@ bool send_id(connection_t *c) {
                        minor = myself->connection->protocol_minor;
        }
 
+       if(proxytype)
+               if(!send_proxyrequest(c))
+                       return false;
+
        return send_request(c, "%d %s %d.%d", ID, myself->connection->name, myself->connection->protocol_major, minor);
 }
 
@@ -122,9 +211,8 @@ bool id_h(connection_t *c, const char *request) {
        if(!c->config_tree) {
                init_configuration(&c->config_tree);
 
-               if(!read_connection_config(c)) {
-                       logger(DEBUG_ALWAYS, LOG_ERR, "Peer %s had unknown identity (%s)", c->hostname,
-                                  c->name);
+               if(!read_host_config(c->config_tree, c->name)) {
+                       logger(DEBUG_ALWAYS, LOG_ERR, "Peer %s had unknown identity (%s)", c->hostname, c->name);
                        return false;
                }
 
@@ -416,7 +504,7 @@ bool send_ack(connection_t *c) {
 
        get_config_int(lookup_config(c->config_tree, "Weight"), &c->estimated_weight);
 
-       return send_request(c, "%d %s %d %x", ACK, myport, c->estimated_weight, c->options);
+       return send_request(c, "%d %s %d %x", ACK, myport, c->estimated_weight, (c->options & 0xffffff) | (experimental ? (PROT_MINOR << 24) : 0));
 }
 
 static void send_everything(connection_t *c) {
@@ -536,9 +624,6 @@ bool ack_h(connection_t *c, const char *request) {
                        c->options &= ~OPTION_CLAMP_MSS;
        }
 
-       if(c->protocol_minor > 0)
-               c->node->status.ecdh = true;
-
        /* Activate this connection */
 
        c->allow_request = ALL;