Function handshake_succeeded

connectd/handshake.c:355–410

	handshake_failed_((conn), (h), __func__, __LINE__)

static struct io_plan *handshake_succeeded(struct io_conn *conn,
					   struct handshake *h)
{
	struct crypto_state cs;
	struct io_plan *(*cb)(struct io_conn *conn,
			      const struct pubkey *their_id,
			      const struct wireaddr_internal *addr,
			      struct crypto_state *cs,
			      struct oneshot *timeout,
			      enum is_websocket is_websocket,
			      struct timemono starttime,
			      void *cbarg);
	void *cbarg;
	struct pubkey their_id;
	struct wireaddr_internal addr;
	struct oneshot *timeout;
	enum is_websocket is_websocket;
	struct timemono starttime;

	/* BOLT #8:
	 *
	 * 9. `rk, sk = HKDF(ck, zero)`
	 *      * where `zero` is a zero-length plaintext, `rk` is the key to
	 *        be used by the responder to decrypt the messages sent by the
	 *        initiator, and `sk` is the key to be used by the responder
	 *        to encrypt messages to the initiator
	 *
	 *      * The final encryption keys, to be used for sending and
	 *        receiving messages for the duration of the session, are
	 *        generated.
	 */
	if (h->side == RESPONDER)
		hkdf_two_keys(&cs.rk, &cs.sk, &h->ck, NULL, 0);
	else
		hkdf_two_keys(&cs.sk, &cs.rk, &h->ck, NULL, 0);

	cs.rn = cs.sn = 0;
	/* BOLT #8:
	 *
	 * 11. `rck = sck = ck`
	 *      * The sending and receiving chaining keys are initialized the same.
	 */

	cs.r_ck = cs.s_ck = h->ck;

	cb = h->cb;
	cbarg = h->cbarg;
	their_id = h->their_id;
	addr = h->addr;
	timeout = h->timeout;
	is_websocket = h->is_websocket;
	starttime = h->starttime;

	tal_free(h);
	return cb(conn, &their_id, &addr, &cs, timeout, is_websocket, starttime, cbarg);
}

static struct handshake *new_handshake(const tal_t *ctx,