Remove deprecated things for next release

common/base64.c

@@ -1,15 +1,16 @@
+#include "config.h"
+#include <assert.h>
+#include <ccan/base64/base64.h>
 #include <common/base64.h>
-#include <sodium/utils.h>
 
-/* Decode/encode from/to base64, base64 helper functions.
- * We import base64 from libsodium to generate tor V3 ED25519-V3 onions from blobs
-*/
-
-char *b64_encode(const tal_t *ctx, const u8 *data, size_t len)
+/* Decode/encode from/to base64, base64 helper functions.*/
+char *b64_encode(const tal_t *ctx, const void *data, size_t len)
 {
-	char *str = tal_arr(ctx, char, sodium_base64_encoded_len(len, sodium_base64_VARIANT_ORIGINAL) + 1);
+	size_t slen = base64_encoded_length(len), enclen;
+	char *str = tal_arr(ctx, char, slen + 1);
+	enclen = base64_encode(str, slen, data, len);
+	assert(enclen == slen);
 
-	str = sodium_bin2base64(str,  tal_count(str), data,
-								len, sodium_base64_VARIANT_ORIGINAL);
+	str[enclen] = '\0';
 	return str;
 }

common/base64.h

@@ -4,6 +4,6 @@
 #include <ccan/short_types/short_types.h>
 #include <ccan/tal/tal.h>
 
-char *b64_encode(const tal_t *ctx, const u8 *data, size_t len);
+char *b64_encode(const tal_t *ctx, const void *data, size_t len);
 
 #endif /* LIGHTNING_COMMON_BASE64_H */

common/json_helpers.c

@@ -273,7 +273,7 @@ void json_add_address(struct json_stream *response, const char *fieldname,
 		json_add_string(response, "type", "ipv6");
 		json_add_string(response, "address", addrstr);
 		json_add_num(response, "port", addr->port);
-	} else if (addr->type == ADDR_TYPE_TOR_V2) {
+	} else if (addr->type == ADDR_TYPE_TOR_V2_REMOVED) {
 		json_add_string(response, "type", "torv2");
 		json_add_string(response, "address", fmt_wireaddr_without_port(tmpctx, addr));
 		json_add_num(response, "port", addr->port);

common/test/run-base64.c

@@ -0,0 +1,134 @@
+#include "../base64.c"
+#include <assert.h>
+#include <ccan/base64/base64.h>
+#include <common/amount.h>
+#include <common/setup.h>
+#include <common/utils.h>
+#include <sodium/utils.h>
+#include <stdio.h>
+#include <wire/wire.h>
+
+/* AUTOGENERATED MOCKS START */
+/* Generated stub for amount_asset_is_main */
+bool amount_asset_is_main(struct amount_asset *asset UNNEEDED)
+{ fprintf(stderr, "amount_asset_is_main called!\n"); abort(); }
+/* Generated stub for amount_asset_to_sat */
+struct amount_sat amount_asset_to_sat(struct amount_asset *asset UNNEEDED)
+{ fprintf(stderr, "amount_asset_to_sat called!\n"); abort(); }
+/* Generated stub for amount_sat */
+struct amount_sat amount_sat(u64 satoshis UNNEEDED)
+{ fprintf(stderr, "amount_sat called!\n"); abort(); }
+/* Generated stub for amount_sat_add */
+ bool amount_sat_add(struct amount_sat *val UNNEEDED,
+				       struct amount_sat a UNNEEDED,
+				       struct amount_sat b UNNEEDED)
+{ fprintf(stderr, "amount_sat_add called!\n"); abort(); }
+/* Generated stub for amount_sat_eq */
+bool amount_sat_eq(struct amount_sat a UNNEEDED, struct amount_sat b UNNEEDED)
+{ fprintf(stderr, "amount_sat_eq called!\n"); abort(); }
+/* Generated stub for amount_sat_greater_eq */
+bool amount_sat_greater_eq(struct amount_sat a UNNEEDED, struct amount_sat b UNNEEDED)
+{ fprintf(stderr, "amount_sat_greater_eq called!\n"); abort(); }
+/* Generated stub for amount_sat_sub */
+ bool amount_sat_sub(struct amount_sat *val UNNEEDED,
+				       struct amount_sat a UNNEEDED,
+				       struct amount_sat b UNNEEDED)
+{ fprintf(stderr, "amount_sat_sub called!\n"); abort(); }
+/* Generated stub for amount_sat_to_asset */
+struct amount_asset amount_sat_to_asset(struct amount_sat *sat UNNEEDED, const u8 *asset UNNEEDED)
+{ fprintf(stderr, "amount_sat_to_asset called!\n"); abort(); }
+/* Generated stub for amount_tx_fee */
+struct amount_sat amount_tx_fee(u32 fee_per_kw UNNEEDED, size_t weight UNNEEDED)
+{ fprintf(stderr, "amount_tx_fee called!\n"); abort(); }
+/* Generated stub for fromwire */
+const u8 *fromwire(const u8 **cursor UNNEEDED, size_t *max UNNEEDED, void *copy UNNEEDED, size_t n UNNEEDED)
+{ fprintf(stderr, "fromwire called!\n"); abort(); }
+/* Generated stub for fromwire_amount_sat */
+struct amount_sat fromwire_amount_sat(const u8 **cursor UNNEEDED, size_t *max UNNEEDED)
+{ fprintf(stderr, "fromwire_amount_sat called!\n"); abort(); }
+/* Generated stub for fromwire_bool */
+bool fromwire_bool(const u8 **cursor UNNEEDED, size_t *max UNNEEDED)
+{ fprintf(stderr, "fromwire_bool called!\n"); abort(); }
+/* Generated stub for fromwire_fail */
+void *fromwire_fail(const u8 **cursor UNNEEDED, size_t *max UNNEEDED)
+{ fprintf(stderr, "fromwire_fail called!\n"); abort(); }
+/* Generated stub for fromwire_secp256k1_ecdsa_signature */
+void fromwire_secp256k1_ecdsa_signature(const u8 **cursor UNNEEDED, size_t *max UNNEEDED,
+					secp256k1_ecdsa_signature *signature UNNEEDED)
+{ fprintf(stderr, "fromwire_secp256k1_ecdsa_signature called!\n"); abort(); }
+/* Generated stub for fromwire_sha256 */
+void fromwire_sha256(const u8 **cursor UNNEEDED, size_t *max UNNEEDED, struct sha256 *sha256 UNNEEDED)
+{ fprintf(stderr, "fromwire_sha256 called!\n"); abort(); }
+/* Generated stub for fromwire_tal_arrn */
+u8 *fromwire_tal_arrn(const tal_t *ctx UNNEEDED,
+		       const u8 **cursor UNNEEDED, size_t *max UNNEEDED, size_t num UNNEEDED)
+{ fprintf(stderr, "fromwire_tal_arrn called!\n"); abort(); }
+/* Generated stub for fromwire_u16 */
+u16 fromwire_u16(const u8 **cursor UNNEEDED, size_t *max UNNEEDED)
+{ fprintf(stderr, "fromwire_u16 called!\n"); abort(); }
+/* Generated stub for fromwire_u32 */
+u32 fromwire_u32(const u8 **cursor UNNEEDED, size_t *max UNNEEDED)
+{ fprintf(stderr, "fromwire_u32 called!\n"); abort(); }
+/* Generated stub for fromwire_u64 */
+u64 fromwire_u64(const u8 **cursor UNNEEDED, size_t *max UNNEEDED)
+{ fprintf(stderr, "fromwire_u64 called!\n"); abort(); }
+/* Generated stub for fromwire_u8 */
+u8 fromwire_u8(const u8 **cursor UNNEEDED, size_t *max UNNEEDED)
+{ fprintf(stderr, "fromwire_u8 called!\n"); abort(); }
+/* Generated stub for fromwire_u8_array */
+void fromwire_u8_array(const u8 **cursor UNNEEDED, size_t *max UNNEEDED, u8 *arr UNNEEDED, size_t num UNNEEDED)
+{ fprintf(stderr, "fromwire_u8_array called!\n"); abort(); }
+/* Generated stub for towire */
+void towire(u8 **pptr UNNEEDED, const void *data UNNEEDED, size_t len UNNEEDED)
+{ fprintf(stderr, "towire called!\n"); abort(); }
+/* Generated stub for towire_amount_sat */
+void towire_amount_sat(u8 **pptr UNNEEDED, const struct amount_sat sat UNNEEDED)
+{ fprintf(stderr, "towire_amount_sat called!\n"); abort(); }
+/* Generated stub for towire_bool */
+void towire_bool(u8 **pptr UNNEEDED, bool v UNNEEDED)
+{ fprintf(stderr, "towire_bool called!\n"); abort(); }
+/* Generated stub for towire_secp256k1_ecdsa_signature */
+void towire_secp256k1_ecdsa_signature(u8 **pptr UNNEEDED,
+			      const secp256k1_ecdsa_signature *signature UNNEEDED)
+{ fprintf(stderr, "towire_secp256k1_ecdsa_signature called!\n"); abort(); }
+/* Generated stub for towire_sha256 */
+void towire_sha256(u8 **pptr UNNEEDED, const struct sha256 *sha256 UNNEEDED)
+{ fprintf(stderr, "towire_sha256 called!\n"); abort(); }
+/* Generated stub for towire_u16 */
+void towire_u16(u8 **pptr UNNEEDED, u16 v UNNEEDED)
+{ fprintf(stderr, "towire_u16 called!\n"); abort(); }
+/* Generated stub for towire_u32 */
+void towire_u32(u8 **pptr UNNEEDED, u32 v UNNEEDED)
+{ fprintf(stderr, "towire_u32 called!\n"); abort(); }
+/* Generated stub for towire_u64 */
+void towire_u64(u8 **pptr UNNEEDED, u64 v UNNEEDED)
+{ fprintf(stderr, "towire_u64 called!\n"); abort(); }
+/* Generated stub for towire_u8 */
+void towire_u8(u8 **pptr UNNEEDED, u8 v UNNEEDED)
+{ fprintf(stderr, "towire_u8 called!\n"); abort(); }
+/* Generated stub for towire_u8_array */
+void towire_u8_array(u8 **pptr UNNEEDED, const u8 *arr UNNEEDED, size_t num UNNEEDED)
+{ fprintf(stderr, "towire_u8_array called!\n"); abort(); }
+/* AUTOGENERATED MOCKS END */
+
+int main(int argc, char *argv[])
+{
+	u8 data[1024];
+
+	common_setup(argv[0]);
+
+	for (size_t i = 0; i < sizeof(data); i++) {
+		char *sodium, *ours, *ccan;
+		memset(data, i, i);
+
+		ours = b64_encode(tmpctx, data, i);
+		ccan = tal_arr(tmpctx, char, base64_encoded_length(i) + 1);
+		ccan[base64_encode(ccan, base64_encoded_length(i), (char *)data, i)] = '\0';
+		sodium = tal_arr(tmpctx, char, sodium_base64_encoded_len(i, sodium_base64_VARIANT_ORIGINAL) + 1);
+		sodium = sodium_bin2base64(sodium, tal_count(sodium), data, i, sodium_base64_VARIANT_ORIGINAL);
+
+		assert(streq(ccan, sodium));
+		assert(streq(ccan, ours));
+	}
+	common_shutdown();
+}

common/test/run-ip_port_parsing.c

@@ -182,19 +182,17 @@ int main(int argc, char *argv[])
 	assert(parse_wireaddr("4ruvswpqec5i2gogopxl4vm5bruzknbvbylov2awbo4rxiq4cimdldad.onion", &addr, 1, false, NULL));
 	assert(addr.port == 1);
 
-	assert(parse_wireaddr("odpzvneidqdf5hdq.onion:49150", &addr, 1, false, NULL));
-	assert(addr.port == 49150);
-
-	assert(parse_wireaddr("odpzvneidqdf5hdq.onion", &addr, 1, false, NULL));
-	assert(addr.port == 1);
+	/* We don't accept torv2 any more */
+	assert(!parse_wireaddr("odpzvneidqdf5hdq.onion:49150", &addr, 1, false, NULL));
+	assert(!parse_wireaddr("odpzvneidqdf5hdq.onion", &addr, 1, false, NULL));
 
-	// Don't accept legacy hidden services with deprecated APIs on
+	/* Neither allow_deprecated = true nor false will parse it now */
+	assert(!parse_wireaddr_internal("odpzvneidqdf5hdq.onion", &addr_int, 1,
+				        false, false, false, false, NULL));
 	assert(!parse_wireaddr_internal("odpzvneidqdf5hdq.onion", &addr_int, 1,
-				        false, false, false, /* allow_deprecated = */ false, NULL));
-	assert(parse_wireaddr_internal("odpzvneidqdf5hdq.onion", &addr_int, 1,
-				       false, false, false, /* allow_deprecated = */ true, NULL));
+					false, false, false, true, NULL));
 
-	assert(tal_count(wireaddr_from_hostname(tmpctx, "odpzvneidqdf5hdq.onion", 1, NULL, NULL, NULL)) > 0);
+	assert(wireaddr_from_hostname(tmpctx, "odpzvneidqdf5hdq.onion", 1, NULL, NULL, NULL) == NULL);
 	assert(wireaddr_from_hostname(tmpctx, "aaa.onion", 1, NULL, NULL, NULL) == NULL);
 
 	common_shutdown();

common/test/run-wireaddr.c

@@ -112,39 +112,6 @@ void towire_u8_array(u8 **pptr UNNEEDED, const u8 *arr UNNEEDED, size_t num UNNE
 { fprintf(stderr, "towire_u8_array called!\n"); abort(); }
 /* AUTOGENERATED MOCKS END */
 
-static bool wireaddr_internal_eq(const struct wireaddr_internal *a,
-				 const struct wireaddr_internal *b,
-				 bool cmp_torservice_blob)
-{
-	if (a->itype != b->itype)
-		return false;
-
-	switch (a->itype) {
-	case ADDR_INTERNAL_SOCKNAME:
-		return streq(a->u.sockname, b->u.sockname);
-	case ADDR_INTERNAL_ALLPROTO:
-		return a->u.port == b->u.port;
-	case ADDR_INTERNAL_AUTOTOR:
-	case ADDR_INTERNAL_STATICTOR:
-		if (!wireaddr_eq(&a->u.torservice.address,
-				 &b->u.torservice.address))
-			return false;
-		if (a->u.torservice.port != b->u.torservice.port)
-			return false;
-		if (!cmp_torservice_blob)
-			return true;
-		return memeq(a->u.torservice.blob, sizeof(a->u.torservice.blob),
-			     b->u.torservice.blob, sizeof(b->u.torservice.blob));
-	case ADDR_INTERNAL_FORPROXY:
-		if (!streq(a->u.unresolved.name, b->u.unresolved.name))
-			return false;
-		return a->u.unresolved.port == b->u.unresolved.port;
-	case ADDR_INTERNAL_WIREADDR:
-		return wireaddr_eq(&a->u.wireaddr, &b->u.wireaddr);
-	}
-	abort();
-}
-
 int main(int argc, char *argv[])
 {
 	const char *err;
@@ -155,87 +122,98 @@ int main(int argc, char *argv[])
 	assert(parse_wireaddr_internal("127.0.0.1", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_WIREADDR;
 	assert(parse_wireaddr("127.0.0.1:9735", &expect->u.wireaddr, 0, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* IPv4 address with port. */
 	assert(parse_wireaddr_internal("127.0.0.1:1", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_WIREADDR;
 	assert(parse_wireaddr("127.0.0.1:1", &expect->u.wireaddr, 0, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* Simple IPv6 address. */
 	assert(parse_wireaddr_internal("::1", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_WIREADDR;
 	assert(parse_wireaddr("::1", &expect->u.wireaddr, DEFAULT_PORT, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* IPv6 address with port. */
 	assert(parse_wireaddr_internal("[::1]:1", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_WIREADDR;
 	assert(parse_wireaddr("::1", &expect->u.wireaddr, 1, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* autotor address */
 	assert(parse_wireaddr_internal("autotor:127.0.0.1", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_AUTOTOR;
 	expect->u.torservice.port = DEFAULT_PORT;
 	assert(parse_wireaddr("127.0.0.1", &expect->u.torservice.address, 9051, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* autotor address with port */
 	assert(parse_wireaddr_internal("autotor:127.0.0.1:9055", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_AUTOTOR;
 	expect->u.torservice.port = DEFAULT_PORT;
 	assert(parse_wireaddr("127.0.0.1", &expect->u.torservice.address, 9055, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* autotor address with torport */
 	assert(parse_wireaddr_internal("autotor:127.0.0.1/torport=9055", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_AUTOTOR;
 	expect->u.torservice.port = 9055;
 	assert(parse_wireaddr("127.0.0.1", &expect->u.torservice.address, 9051, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* autotor address with port and torport */
 	assert(parse_wireaddr_internal("autotor:127.0.0.1:9055/torport=10055", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_AUTOTOR;
 	expect->u.torservice.port = 10055;
 	assert(parse_wireaddr("127.0.0.1", &expect->u.torservice.address, 9055, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* statictor address */
 	assert(parse_wireaddr_internal("statictor:127.0.0.1", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_STATICTOR;
 	expect->u.torservice.port = DEFAULT_PORT;
+	memset(expect->u.torservice.blob, 0, sizeof(expect->u.torservice.blob));
+	strcpy((char *)expect->u.torservice.blob, STATIC_TOR_MAGIC_STRING);
 	assert(parse_wireaddr("127.0.0.1", &expect->u.torservice.address, 9051, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* statictor address with port */
 	assert(parse_wireaddr_internal("statictor:127.0.0.1:9055", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_STATICTOR;
 	expect->u.torservice.port = DEFAULT_PORT;
 	assert(parse_wireaddr("127.0.0.1", &expect->u.torservice.address, 9055, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* statictor address with torport */
 	assert(parse_wireaddr_internal("statictor:127.0.0.1/torport=9055", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_STATICTOR;
 	expect->u.torservice.port = 9055;
 	assert(parse_wireaddr("127.0.0.1", &expect->u.torservice.address, 9051, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* statictor address with port and torport */
 	assert(parse_wireaddr_internal("statictor:127.0.0.1:9055/torport=10055", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_STATICTOR;
 	expect->u.torservice.port = 10055;
 	assert(parse_wireaddr("127.0.0.1", &expect->u.torservice.address, 9055, NULL, &err));
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
+
+	/* statictor address with port and torport and torblob */
+	assert(parse_wireaddr_internal("statictor:127.0.0.1:9055/torport=10055/torblob=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", &addr, DEFAULT_PORT, false, false, false, false, &err));
+	expect->itype = ADDR_INTERNAL_STATICTOR;
+	expect->u.torservice.port = 10055;
+	/* This is actually nul terminated */
+	memset(expect->u.torservice.blob, 'x', sizeof(expect->u.torservice.blob)-1);
+	assert(parse_wireaddr("127.0.0.1", &expect->u.torservice.address, 9055, NULL, &err));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* local socket path */
 	assert(parse_wireaddr_internal("/tmp/foo.sock", &addr, DEFAULT_PORT, false, false, false, false, &err));
 	expect->itype = ADDR_INTERNAL_SOCKNAME;
 	strcpy(expect->u.sockname, "/tmp/foo.sock");
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* Unresolved */
 	assert(!parse_wireaddr_internal("ozlabs.org", &addr, DEFAULT_PORT, false, false, false, false, &err));
@@ -244,7 +222,7 @@ int main(int argc, char *argv[])
 	expect->itype = ADDR_INTERNAL_FORPROXY;
 	strcpy(expect->u.unresolved.name, "ozlabs.org");
 	expect->u.unresolved.port = DEFAULT_PORT;
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	/* Unresolved with port */
 	assert(!parse_wireaddr_internal("ozlabs.org:1234", &addr, DEFAULT_PORT, false, false, false, false, &err));
@@ -253,7 +231,7 @@ int main(int argc, char *argv[])
 	expect->itype = ADDR_INTERNAL_FORPROXY;
 	strcpy(expect->u.unresolved.name, "ozlabs.org");
 	expect->u.unresolved.port = 1234;
-	assert(wireaddr_internal_eq(&addr, expect, false));
+	assert(wireaddr_internal_eq(&addr, expect));
 
 	tal_free(expect);
 	common_shutdown();