1 files changed, 252 insertions, 0 deletions

diff --git a/testing/hstox/binary_encode.c b/testing/hstox/binary_encode.c
new file mode 100644
index 00000000..a39533c0
--- /dev/null
+++ b/testing/hstox/binary_encode.c
@@ -0,0 +1,252 @@
+#include "methods.h"
+
+#include "byteswap.h"
+#include "packet_kinds.h"
+
+#include <DHT.h>
+
+METHOD(bin, Binary_encode, CipherText)
+{
+    uint64_t length = be64toh(args.size);
+
+    SUCCESS {
+        msgpack_pack_bin(res, sizeof(uint64_t) + args.size);
+        msgpack_pack_bin_body(res, &length, sizeof(uint64_t));
+        msgpack_pack_bin_body(res, args.ptr, args.size);
+    }
+    return 0;
+}
+
+METHOD(array, Binary_encode, DhtPacket)
+{
+    return pending;
+}
+
+METHOD(array, Binary_encode, HostAddress)
+{
+    return pending;
+}
+
+METHOD(u64, Binary_encode, Word64)
+{
+    return pending;
+}
+
+METHOD(bin, Binary_encode, Key_PublicKey)
+{
+    return pending;
+}
+
+METHOD(array, Binary_encode, KeyPair)
+{
+    CHECK_SIZE(args, 2);
+    CHECK_TYPE(args.ptr[0], MSGPACK_OBJECT_BIN);
+    CHECK_TYPE(args.ptr[1], MSGPACK_OBJECT_BIN);
+
+    msgpack_object_bin secret_key = args.ptr[0].via.bin;
+    msgpack_object_bin public_key = args.ptr[1].via.bin;
+
+    CHECK_SIZE(secret_key, 32);
+    CHECK_SIZE(public_key, 32);
+
+    SUCCESS {
+        uint8_t data[64];
+        memcpy(data, secret_key.ptr, 32);
+        memcpy(data + 32, public_key.ptr, 32);
+        msgpack_pack_bin(res, 64);
+        msgpack_pack_bin_body(res, data, 64);
+    }
+
+    return 0;
+}
+
+#define PACKED_NODE_SIZE_IP6 (1 + SIZE_IP6 + sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES)
+METHOD(array, Binary_encode, NodeInfo)
+{
+    CHECK_SIZE(args, 3);
+
+    CHECK_TYPE(args.ptr[0], MSGPACK_OBJECT_POSITIVE_INTEGER);
+    uint64_t protocol = args.ptr[0].via.u64;
+
+    CHECK_TYPE(args.ptr[1], MSGPACK_OBJECT_ARRAY);
+    msgpack_object_array address = args.ptr[1].via.array;
+
+    CHECK_SIZE(address, 2);
+    CHECK_TYPE(address.ptr[0], MSGPACK_OBJECT_ARRAY);
+    msgpack_object_array host_address = address.ptr[0].via.array;
+
+    CHECK_TYPE(address.ptr[1], MSGPACK_OBJECT_POSITIVE_INTEGER);
+    uint64_t port_number = address.ptr[1].via.u64;
+
+    CHECK_SIZE(host_address, 2);
+    CHECK_TYPE(host_address.ptr[0], MSGPACK_OBJECT_POSITIVE_INTEGER);
+    uint64_t address_family = host_address.ptr[0].via.u64;
+
+    CHECK_TYPE(args.ptr[2], MSGPACK_OBJECT_BIN);
+    msgpack_object_bin public_key = args.ptr[2].via.bin;
+
+    CHECK_SIZE(public_key, crypto_box_PUBLICKEYBYTES);
+
+    IP_Port ipp;
+    ipp.port = htons(port_number);
+
+    switch (address_family) {
+        case 0: {
+            /* IPv4*/
+            if (protocol == 1) {
+                ipp.ip.family = TCP_INET;
+            } else {
+                ipp.ip.family = AF_INET;
+            }
+
+            CHECK_TYPE(host_address.ptr[1], MSGPACK_OBJECT_POSITIVE_INTEGER);
+            uint64_t addr = host_address.ptr[1].via.u64;
+
+            ipp.ip.ip4.uint32 = htonl(addr);
+            break;
+        }
+
+        case 1: {
+            /* IPv6 */
+            if (protocol == 1) {
+                ipp.ip.family = TCP_INET6;
+            } else {
+                ipp.ip.family = AF_INET6;
+            }
+
+            CHECK_TYPE(host_address.ptr[1], MSGPACK_OBJECT_ARRAY);
+            msgpack_object_array addr = host_address.ptr[1].via.array;
+
+            int i;
+
+            for (i = 0; i < 4; ++i) {
+                CHECK_TYPE(addr.ptr[i], MSGPACK_OBJECT_POSITIVE_INTEGER);
+                uint64_t component   = addr.ptr[i].via.u64;
+                ipp.ip.ip6.uint32[i] = htonl(component);
+            }
+
+            break;
+        }
+    }
+
+    Node_format node;
+    node.ip_port = ipp;
+    memcpy(&node.public_key, public_key.ptr, crypto_box_PUBLICKEYBYTES);
+
+    /* We assume IP6 because it's bigger */
+    uint8_t packed_node[PACKED_NODE_SIZE_IP6];
+
+    int len = pack_nodes(packed_node, sizeof packed_node, &node, 1);
+
+    if (len < 0) {
+        return failure;
+    }
+
+    SUCCESS {
+        msgpack_pack_bin(res, len);
+        msgpack_pack_bin_body(res, packed_node, len);
+    }
+    return 0;
+}
+
+METHOD(bin, Binary_encode, NodesRequest)
+{
+    return pending;
+}
+
+METHOD(array, Binary_encode, NodesResponse)
+{
+    return pending;
+}
+
+METHOD(array, Binary_encode, Packet_Word64)
+{
+    return pending;
+}
+
+METHOD(u64, Binary_encode, PacketKind)
+{
+    CHECK(args < sizeof packet_kinds / sizeof * packet_kinds);
+
+    SUCCESS {
+        uint8_t data[] = {packet_kinds[args]};
+        msgpack_pack_bin(res, sizeof data);
+        msgpack_pack_bin_body(res, data, sizeof data);
+    }
+    return 0;
+}
+
+METHOD(u64, Binary_encode, PingPacket)
+{
+    return pending;
+}
+
+METHOD(bin, Binary_encode, PlainText)
+{
+    return pending;
+}
+
+METHOD(u64, Binary_encode, PortNumber)
+{
+    SUCCESS {
+        if (args <= UINT16_MAX)
+        {
+            uint16_t port = ntohs(args);
+            msgpack_pack_bin(res, 2);
+            msgpack_pack_bin_body(res, &port, 2);
+        } else {
+            msgpack_pack_nil(res);
+        }
+    }
+    return 0;
+}
+
+METHOD(array, Binary_encode, RpcPacket_Word64)
+{
+    return pending;
+}
+
+METHOD(array, Binary_encode, SocketAddress)
+{
+    return pending;
+}
+
+METHOD(u64, Binary_encode, TransportProtocol)
+{
+    return pending;
+}
+
+METHOD(array, Binary, encode)
+{
+    CHECK_SIZE(args, 2);
+    CHECK_TYPE(args.ptr[0], MSGPACK_OBJECT_STR);
+
+    msgpack_object_str type = args.ptr[0].via.str;
+#define DISPATCH(TYPE, UTYPE, LTYPE)                                                    \
+  do {                                                                                  \
+    if (type.size == sizeof #TYPE - 1 && method_cmp(type.ptr, #TYPE, type.size) == 0) { \
+      CHECK_TYPE(args.ptr[1], MSGPACK_OBJECT_##UTYPE);                                  \
+      return Binary_encode_##TYPE(args.ptr[1].via.LTYPE, res);                          \
+    }                                                                                   \
+  } while (0)
+    DISPATCH(CipherText, BIN, bin);
+    DISPATCH(DhtPacket, ARRAY, array);
+    DISPATCH(HostAddress, ARRAY, array);
+    DISPATCH(Word64, POSITIVE_INTEGER, u64);
+    DISPATCH(Key_PublicKey, BIN, bin);
+    DISPATCH(KeyPair, ARRAY, array);
+    DISPATCH(NodeInfo, ARRAY, array);
+    DISPATCH(NodesRequest, BIN, bin);
+    DISPATCH(NodesResponse, ARRAY, array);
+    DISPATCH(Packet_Word64, ARRAY, array);
+    DISPATCH(PacketKind, POSITIVE_INTEGER, u64);
+    DISPATCH(PingPacket, POSITIVE_INTEGER, u64);
+    DISPATCH(PlainText, BIN, bin);
+    DISPATCH(PortNumber, POSITIVE_INTEGER, u64);
+    DISPATCH(RpcPacket_Word64, ARRAY, array);
+    DISPATCH(SocketAddress, ARRAY, array);
+    DISPATCH(TransportProtocol, POSITIVE_INTEGER, u64);
+#undef DISPATCH
+
+    return unimplemented;
+}