Fix v4 long outgoing references blocking cjdroute

v3 change:

v3 we now abort if there is a broken peer.
(we leave the try-catch block in separate function,
otherwise gcc complains about clobbered variables)

Too long text of reference in outgoing peers
(in connectTo) is handled correctly:

We send to cjdroute (via UDP packet) only
the needed data, skipping the fields
that are not used.

Also, if anyway the reference is still too large
(e.g. had very long password), it will be skipped
with an error logged.

v4 change:

add login field

Author: Tigusoft

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);