core-lightning/connectd/connectd_wiregen.c

/* This file was generated by generate-wire.py */
/* Do not modify this file! Modify the .csv file it was generated from. */
/* Original template can be found at tools/gen/impl_template */

#include <connectd/connectd_wiregen.h>
#include <assert.h>
#include <ccan/array_size/array_size.h>
#include <ccan/mem/mem.h>
#include <ccan/tal/str/str.h>
#include <common/utils.h>
#include <stdio.h>

#ifndef SUPERVERBOSE
#define SUPERVERBOSE(...)
#endif


const char *connectd_wire_name(int e)
{
	static char invalidbuf[sizeof("INVALID ") + STR_MAX_CHARS(e)];

	switch ((enum connectd_wire)e) {
	case WIRE_CONNECTD_INIT: return "WIRE_CONNECTD_INIT";
	case WIRE_CONNECTD_INIT_REPLY: return "WIRE_CONNECTD_INIT_REPLY";
	case WIRE_CONNECTD_ACTIVATE: return "WIRE_CONNECTD_ACTIVATE";
	case WIRE_CONNECTD_ACTIVATE_REPLY: return "WIRE_CONNECTD_ACTIVATE_REPLY";
	case WIRE_CONNECTD_RECONNECTED: return "WIRE_CONNECTD_RECONNECTED";
	case WIRE_CONNECTD_CONNECT_TO_PEER: return "WIRE_CONNECTD_CONNECT_TO_PEER";
	case WIRE_CONNECTD_CONNECT_FAILED: return "WIRE_CONNECTD_CONNECT_FAILED";
	case WIRE_CONNECTD_PEER_CONNECTED: return "WIRE_CONNECTD_PEER_CONNECTED";
	case WIRE_CONNECTD_PEER_DISCONNECTED: return "WIRE_CONNECTD_PEER_DISCONNECTED";
	case WIRE_CONNECTD_PEER_FINAL_MSG: return "WIRE_CONNECTD_PEER_FINAL_MSG";
	case WIRE_CONNECTD_DEV_MEMLEAK: return "WIRE_CONNECTD_DEV_MEMLEAK";
	case WIRE_CONNECTD_DEV_MEMLEAK_REPLY: return "WIRE_CONNECTD_DEV_MEMLEAK_REPLY";
	}

	snprintf(invalidbuf, sizeof(invalidbuf), "INVALID %i", e);
	return invalidbuf;
}

bool connectd_wire_is_defined(u16 type)
{
	switch ((enum connectd_wire)type) {
	case WIRE_CONNECTD_INIT:;
	case WIRE_CONNECTD_INIT_REPLY:;
	case WIRE_CONNECTD_ACTIVATE:;
	case WIRE_CONNECTD_ACTIVATE_REPLY:;
	case WIRE_CONNECTD_RECONNECTED:;
	case WIRE_CONNECTD_CONNECT_TO_PEER:;
	case WIRE_CONNECTD_CONNECT_FAILED:;
	case WIRE_CONNECTD_PEER_CONNECTED:;
	case WIRE_CONNECTD_PEER_DISCONNECTED:;
	case WIRE_CONNECTD_PEER_FINAL_MSG:;
	case WIRE_CONNECTD_DEV_MEMLEAK:;
	case WIRE_CONNECTD_DEV_MEMLEAK_REPLY:;
	      return true;
	}
	return false;
}





/* WIRE: CONNECTD_INIT */
u8 *towire_connectd_init(const tal_t *ctx, const struct chainparams *chainparams, const struct feature_set *our_features, const struct node_id *id, const struct wireaddr_internal *wireaddrs, const enum addr_listen_announce *listen_announce, const struct wireaddr *tor_proxyaddr, bool use_tor_proxy_always, bool dev_allow_localhost, bool use_dns, const wirestring *tor_password, bool use_v3_autotor, u32 timeout_secs)
{
	u16 num_wireaddrs = tal_count(listen_announce);
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_INIT);
	towire_chainparams(&p, chainparams);
	towire_feature_set(&p, our_features);
	towire_node_id(&p, id);
	towire_u16(&p, num_wireaddrs);
	for (size_t i = 0; i < num_wireaddrs; i++)
		towire_wireaddr_internal(&p, wireaddrs + i);
	for (size_t i = 0; i < num_wireaddrs; i++)
		towire_addr_listen_announce(&p, listen_announce[i]);
	if (!tor_proxyaddr)
		towire_bool(&p, false);
	else {
		towire_bool(&p, true);
		towire_wireaddr(&p, tor_proxyaddr);
	}
	towire_bool(&p, use_tor_proxy_always);
	towire_bool(&p, dev_allow_localhost);
	towire_bool(&p, use_dns);
	towire_wirestring(&p, tor_password);
	towire_bool(&p, use_v3_autotor);
	towire_u32(&p, timeout_secs);

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_init(const tal_t *ctx, const void *p, const struct chainparams **chainparams, struct feature_set **our_features, struct node_id *id, struct wireaddr_internal **wireaddrs, enum addr_listen_announce **listen_announce, struct wireaddr **tor_proxyaddr, bool *use_tor_proxy_always, bool *dev_allow_localhost, bool *use_dns, wirestring **tor_password, bool *use_v3_autotor, u32 *timeout_secs)
{
	u16 num_wireaddrs;

	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_INIT)
		return false;
 	fromwire_chainparams(&cursor, &plen, chainparams);
 	*our_features = fromwire_feature_set(ctx, &cursor, &plen);
 	fromwire_node_id(&cursor, &plen, id);
 	num_wireaddrs = fromwire_u16(&cursor, &plen);
 	// 2nd case wireaddrs
	*wireaddrs = num_wireaddrs ? tal_arr(ctx, struct wireaddr_internal, num_wireaddrs) : NULL;
	for (size_t i = 0; i < num_wireaddrs; i++)
		fromwire_wireaddr_internal(&cursor, &plen, *wireaddrs + i);
 	// 2nd case listen_announce
	*listen_announce = num_wireaddrs ? tal_arr(ctx, enum addr_listen_announce, num_wireaddrs) : NULL;
	for (size_t i = 0; i < num_wireaddrs; i++)
		(*listen_announce)[i] = fromwire_addr_listen_announce(&cursor, &plen);
 	if (!fromwire_bool(&cursor, &plen))
		*tor_proxyaddr = NULL;
	else {
		*tor_proxyaddr = tal(ctx, struct wireaddr);
		fromwire_wireaddr(&cursor, &plen, *tor_proxyaddr);
	}
 	*use_tor_proxy_always = fromwire_bool(&cursor, &plen);
 	*dev_allow_localhost = fromwire_bool(&cursor, &plen);
 	*use_dns = fromwire_bool(&cursor, &plen);
 	*tor_password = fromwire_wirestring(ctx, &cursor, &plen);
 	*use_v3_autotor = fromwire_bool(&cursor, &plen);
 	*timeout_secs = fromwire_u32(&cursor, &plen);
	return cursor != NULL;
}

/* WIRE: CONNECTD_INIT_REPLY */
/* Connectd->master */
u8 *towire_connectd_init_reply(const tal_t *ctx, const struct wireaddr_internal *bindings, const struct wireaddr *announcable)
{
	u16 num_bindings = tal_count(bindings);
	u16 num_announcable = tal_count(announcable);
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_INIT_REPLY);
	towire_u16(&p, num_bindings);
	for (size_t i = 0; i < num_bindings; i++)
		towire_wireaddr_internal(&p, bindings + i);
	towire_u16(&p, num_announcable);
	for (size_t i = 0; i < num_announcable; i++)
		towire_wireaddr(&p, announcable + i);

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_init_reply(const tal_t *ctx, const void *p, struct wireaddr_internal **bindings, struct wireaddr **announcable)
{
	u16 num_bindings;
	u16 num_announcable;

	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_INIT_REPLY)
		return false;
 	num_bindings = fromwire_u16(&cursor, &plen);
 	// 2nd case bindings
	*bindings = num_bindings ? tal_arr(ctx, struct wireaddr_internal, num_bindings) : NULL;
	for (size_t i = 0; i < num_bindings; i++)
		fromwire_wireaddr_internal(&cursor, &plen, *bindings + i);
 	num_announcable = fromwire_u16(&cursor, &plen);
 	// 2nd case announcable
	*announcable = num_announcable ? tal_arr(ctx, struct wireaddr, num_announcable) : NULL;
	for (size_t i = 0; i < num_announcable; i++)
		fromwire_wireaddr(&cursor, &plen, *announcable + i);
	return cursor != NULL;
}

/* WIRE: CONNECTD_ACTIVATE */
/* Activate the connect daemon */
u8 *towire_connectd_activate(const tal_t *ctx, bool listen)
{
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_ACTIVATE);
	/* Do we listen? */
	towire_bool(&p, listen);

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_activate(const void *p, bool *listen)
{
	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_ACTIVATE)
		return false;
 	/* Do we listen? */
	*listen = fromwire_bool(&cursor, &plen);
	return cursor != NULL;
}

/* WIRE: CONNECTD_ACTIVATE_REPLY */
/* Connectd->master */
u8 *towire_connectd_activate_reply(const tal_t *ctx)
{
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_ACTIVATE_REPLY);

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_activate_reply(const void *p)
{
	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_ACTIVATE_REPLY)
		return false;
	return cursor != NULL;
}

/* WIRE: CONNECTD_RECONNECTED */
/* connectd->master: disconnect this peer please (due to reconnect). */
u8 *towire_connectd_reconnected(const tal_t *ctx, const struct node_id *id)
{
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_RECONNECTED);
	towire_node_id(&p, id);

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_reconnected(const void *p, struct node_id *id)
{
	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_RECONNECTED)
		return false;
 	fromwire_node_id(&cursor, &plen, id);
	return cursor != NULL;
}

/* WIRE: CONNECTD_CONNECT_TO_PEER */
/* Master -> connectd: connect to a peer. */
u8 *towire_connectd_connect_to_peer(const tal_t *ctx, const struct node_id *id, u32 seconds_waited, const struct wireaddr_internal *addrhint)
{
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_CONNECT_TO_PEER);
	towire_node_id(&p, id);
	towire_u32(&p, seconds_waited);
	if (!addrhint)
		towire_bool(&p, false);
	else {
		towire_bool(&p, true);
		towire_wireaddr_internal(&p, addrhint);
	}

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_connect_to_peer(const tal_t *ctx, const void *p, struct node_id *id, u32 *seconds_waited, struct wireaddr_internal **addrhint)
{
	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_CONNECT_TO_PEER)
		return false;
 	fromwire_node_id(&cursor, &plen, id);
 	*seconds_waited = fromwire_u32(&cursor, &plen);
 	if (!fromwire_bool(&cursor, &plen))
		*addrhint = NULL;
	else {
		*addrhint = tal(ctx, struct wireaddr_internal);
		fromwire_wireaddr_internal(&cursor, &plen, *addrhint);
	}
	return cursor != NULL;
}

/* WIRE: CONNECTD_CONNECT_FAILED */
/* Connectd->master: connect failed. */
u8 *towire_connectd_connect_failed(const tal_t *ctx, const struct node_id *id, errcode_t failcode, const wirestring *failreason, u32 seconds_to_delay, const struct wireaddr_internal *addrhint)
{
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_CONNECT_FAILED);
	towire_node_id(&p, id);
	towire_errcode_t(&p, failcode);
	towire_wirestring(&p, failreason);
	towire_u32(&p, seconds_to_delay);
	if (!addrhint)
		towire_bool(&p, false);
	else {
		towire_bool(&p, true);
		towire_wireaddr_internal(&p, addrhint);
	}

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_connect_failed(const tal_t *ctx, const void *p, struct node_id *id, errcode_t *failcode, wirestring **failreason, u32 *seconds_to_delay, struct wireaddr_internal **addrhint)
{
	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_CONNECT_FAILED)
		return false;
 	fromwire_node_id(&cursor, &plen, id);
 	*failcode = fromwire_errcode_t(&cursor, &plen);
 	*failreason = fromwire_wirestring(ctx, &cursor, &plen);
 	*seconds_to_delay = fromwire_u32(&cursor, &plen);
 	if (!fromwire_bool(&cursor, &plen))
		*addrhint = NULL;
	else {
		*addrhint = tal(ctx, struct wireaddr_internal);
		fromwire_wireaddr_internal(&cursor, &plen, *addrhint);
	}
	return cursor != NULL;
}

/* WIRE: CONNECTD_PEER_CONNECTED */
/* Connectd -> master: we got a peer. Three fds: peer */
u8 *towire_connectd_peer_connected(const tal_t *ctx, const struct node_id *id, const struct wireaddr_internal *addr, bool incoming, const struct per_peer_state *pps, const u8 *features)
{
	u16 flen = tal_count(features);
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_PEER_CONNECTED);
	towire_node_id(&p, id);
	towire_wireaddr_internal(&p, addr);
	towire_bool(&p, incoming);
	towire_per_peer_state(&p, pps);
	towire_u16(&p, flen);
	towire_u8_array(&p, features, flen);

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_peer_connected(const tal_t *ctx, const void *p, struct node_id *id, struct wireaddr_internal *addr, bool *incoming, struct per_peer_state **pps, u8 **features)
{
	u16 flen;

	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_PEER_CONNECTED)
		return false;
 	fromwire_node_id(&cursor, &plen, id);
 	fromwire_wireaddr_internal(&cursor, &plen, addr);
 	*incoming = fromwire_bool(&cursor, &plen);
 	*pps = fromwire_per_peer_state(ctx, &cursor, &plen);
 	flen = fromwire_u16(&cursor, &plen);
 	// 2nd case features
	*features = flen ? tal_arr(ctx, u8, flen) : NULL;
	fromwire_u8_array(&cursor, &plen, *features, flen);
	return cursor != NULL;
}

/* WIRE: CONNECTD_PEER_DISCONNECTED */
/* master -> connectd: peer has disconnected. */
u8 *towire_connectd_peer_disconnected(const tal_t *ctx, const struct node_id *id)
{
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_PEER_DISCONNECTED);
	towire_node_id(&p, id);

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_peer_disconnected(const void *p, struct node_id *id)
{
	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_PEER_DISCONNECTED)
		return false;
 	fromwire_node_id(&cursor, &plen, id);
	return cursor != NULL;
}

/* WIRE: CONNECTD_PEER_FINAL_MSG */
/* master -> connectd: give message to peer and disconnect.  Three fds: peer */
u8 *towire_connectd_peer_final_msg(const tal_t *ctx, const struct node_id *id, const struct per_peer_state *pps, const u8 *msg)
{
	u16 len = tal_count(msg);
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_PEER_FINAL_MSG);
	towire_node_id(&p, id);
	towire_per_peer_state(&p, pps);
	towire_u16(&p, len);
	towire_u8_array(&p, msg, len);

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_peer_final_msg(const tal_t *ctx, const void *p, struct node_id *id, struct per_peer_state **pps, u8 **msg)
{
	u16 len;

	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_PEER_FINAL_MSG)
		return false;
 	fromwire_node_id(&cursor, &plen, id);
 	*pps = fromwire_per_peer_state(ctx, &cursor, &plen);
 	len = fromwire_u16(&cursor, &plen);
 	// 2nd case msg
	*msg = len ? tal_arr(ctx, u8, len) : NULL;
	fromwire_u8_array(&cursor, &plen, *msg, len);
	return cursor != NULL;
}

/* WIRE: CONNECTD_DEV_MEMLEAK */
/* master -> connectd: do you have a memleak? */
u8 *towire_connectd_dev_memleak(const tal_t *ctx)
{
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_DEV_MEMLEAK);

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_dev_memleak(const void *p)
{
	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_DEV_MEMLEAK)
		return false;
	return cursor != NULL;
}

/* WIRE: CONNECTD_DEV_MEMLEAK_REPLY */
u8 *towire_connectd_dev_memleak_reply(const tal_t *ctx, bool leak)
{
	u8 *p = tal_arr(ctx, u8, 0);

	towire_u16(&p, WIRE_CONNECTD_DEV_MEMLEAK_REPLY);
	towire_bool(&p, leak);

	return memcheck(p, tal_count(p));
}
bool fromwire_connectd_dev_memleak_reply(const void *p, bool *leak)
{
	const u8 *cursor = p;
	size_t plen = tal_count(p);

	if (fromwire_u16(&cursor, &plen) != WIRE_CONNECTD_DEV_MEMLEAK_REPLY)
		return false;
 	*leak = fromwire_bool(&cursor, &plen);
	return cursor != NULL;
}
// SHA256STAMP:7c9585941825eab65d734eb1c233eee5c78b5792e19ec68f0a9986abca2b0ffe