Merge pull request #80 from tigusoft/pr-long-reference-clean

Fix long outgoing references blocking cjdroute

Author: Lars Gierth

benc/serialization/standard/BencMessageWriter.c

@@ -18,6 +18,7 @@
 #include "benc/Dict.h"
 #include "benc/List.h"
 #include "exception/Except.h"
+#include "exception/Jmp.h"
 #include "wire/Message.h"
 #include "util/Base10.h"
 
@@ -66,6 +67,25 @@ static void writeDict(Dict* d, struct Message* msg, struct Except* eh)
     Message_push8(msg, 'd', eh);
 }
 
+/**
+ * Tries to send a message same as in writeDic() but in case of some problems
+ * where it would throw, it instead returns non-zero value to indicate error:
+ * return 1 - there was an error
+ * return 0 - no error was detected, but still no guarantee if message was sent,
+ * some errors like message not fitting UDP-admin-packet size are NOT detected
+ * (therefore you should detect them in caller function)
+ */
+int BencMessageWriter_writeDictTry(Dict* d, struct Message* msg, struct Except* eh)
+{
+    struct Jmp jmp;
+    Jmp_try(jmp) {
+        writeDict(d, msg, &jmp.handler);
+        return 0;
+    } Jmp_catch {
+        return 1;
+    }
+}
+
 static void writeGeneric(Object* obj, struct Message* msg, struct Except* eh)
 {
     switch (obj->type) {

benc/serialization/standard/BencMessageWriter.h

@@ -23,4 +23,11 @@ Linker_require("benc/serialization/standard/BencMessageWriter.c")
 
 void BencMessageWriter_write(Dict* toWrite, struct Message* msg, struct Except* eh);
 
+/**
+ * this function is a non-static wrapper for same function,
+ * so that we can use it from other places to estimate if reference
+ * will fit in admin UDP packet
+ */
+int BencMessageWriter_writeDictTry(Dict* d, struct Message* msg, struct Except* eh);
+
 #endif

client/Configurator.c

@@ -16,6 +16,7 @@
 #include "client/Configurator.h"
 #include "benc/String.h"
 #include "benc/Dict.h"
+#include "benc/serialization/standard/BencMessageWriter.h"
 #include "benc/Int.h"
 #include "benc/List.h"
 #include "memory/Allocator.h"
@@ -42,6 +43,8 @@ struct Context
     struct EventBase* base;
 };
 
+const int abort_if_invalid_ref = 1;
+
 static void rpcCallback(struct AdminClient_Promise* p, struct AdminClient_Result* res)
 {
     struct Context* ctx = p->userData;
@@ -211,7 +214,37 @@ static void udpInterface(Dict* config, struct Context* ctx)
                                                "is not a dictionary type.", key->bytes);
                     exit(-1);
                 }
-                Dict* value = entry->val->as.dictionary;
+                Dict* all =  entry->val->as.dictionary;
+                Dict* value = Dict_new(perCallAlloc);
+                String* pub_d = Dict_getString(all, String_CONST("publicKey"));
+                String* pss_d = Dict_getString(all, String_CONST("password"));
+                String* peerName_d = Dict_getString(all, String_CONST("peerName"));
+                String* login_d = Dict_getString(all, String_CONST("login"));
+
+                if ( !pub_d || !pss_d ) {
+                    const char * error_name = "(unknown)";
+                    if ( !pub_d ) {
+                        error_name = "publicKey";
+                    }
+                    if ( !pss_d ) {
+                        error_name = "password";
+                    }
+                    Log_warn(ctx->logger,
+                        "Skipping peer: missing %s for peer [%s]", error_name, key->bytes);
+                    if (abort_if_invalid_ref) {
+                        Assert_failure("Invalid peer reference");
+                    }
+                    else {
+                        entry = entry->next;
+                        continue;
+                    }
+                }
+
+                Dict_putString(value, String_CONST("publicKey"), pub_d, perCallAlloc);
+                Dict_putString(value, String_CONST("password"), pss_d, perCallAlloc);
+                Dict_putString(value, String_CONST("peerName"), peerName_d, perCallAlloc);
+                Dict_putString(value, String_CONST("login"), login_d, perCallAlloc);
+
                 Log_keys(ctx->logger, "Attempting to connect to node [%s].", key->bytes);
                 key = String_clone(key, perCallAlloc);
                 char* lastColon = CString_strrchr(key->bytes, ':');
@@ -236,6 +269,22 @@ static void udpInterface(Dict* config, struct Context* ctx)
                         continue;
                     }
                 }
+                struct Allocator* child = Allocator_child(ctx->alloc);
+                struct Message* msg = Message_new(0, AdminClient_MAX_MESSAGE_SIZE + 256, child);
+                int r = BencMessageWriter_writeDictTry(value, msg, NULL);
+
+                const int max_reference_size = 298;
+                if (r != 0 || msg->length > max_reference_size) {
+                    Log_warn(ctx->logger, "Peer skipped:");
+                    Log_warn(ctx->logger, "Too long peer reference for [%s]", key->bytes);
+                    if (abort_if_invalid_ref) {
+                        Assert_failure("Invalid peer reference");
+                    }
+                    else {
+                        entry = entry->next;
+                        continue;
+                    }
+                }
                 Dict_putInt(value, String_CONST("interfaceNumber"), ifNum, perCallAlloc);
                 Dict_putString(value, String_CONST("address"), key, perCallAlloc);
                 rpcCall(String_CONST("UDPInterface_beginConnection"), value, ctx, perCallAlloc);