Function write_to_peer

connectd/multiplex.c:1214–1300

}

static struct io_plan *write_to_peer(struct io_conn *peer_conn,
				     struct peer *peer)
{
	bool do_flush;
	assert(peer->to_peer == peer_conn);

 	/* We always pad and send if we have an urgent msg or our
	 * non-urgent has gone off, or we're trying to close. */
	do_flush = (peer->peer_out_urgent != 0
		    || peer->flushing_nonurgent
		    || peer->draining_state == WRITING_TO_PEER);

	peer->flushing_nonurgent = false;

	/* We wrote out some bytes from membuf. */
	membuf_consume(&peer->encrypted_peer_out, peer->encrypted_peer_out_sent);
	peer->encrypted_peer_out_sent = 0;

	while (!have_full_encrypted_queue(peer)) {
		const u8 *msg;
		struct io_plan *dev_override;

		/* Pop tail of send queue (or gossip) */
		msg = next_msg_for_peer(peer);
		if (!msg) {
			/* Draining?  Shutdown socket (to avoid losing msgs) */
			if (have_empty_encrypted_queue(peer)
			    && peer->draining_state == WRITING_TO_PEER) {
				status_peer_debug(&peer->id, "draining done, shutting down");
				io_wake(&peer->peer_in);
				return io_sock_shutdown(peer_conn);
			}

			/* If no urgent message, and not draining, we wait. */
			if (!do_flush) {
				/* Tell them to read again, */
				io_wake(&peer->subds);
				io_wake(&peer->peer_in);

				/* Set up a timer if not already set */
				if (!have_empty_encrypted_queue(peer)
				    && !peer->nonurgent_flush_timer) {
					/* Bias towards larger values, but don't be too predictable */
					u32 max = pseudorand(1000);
					u32 msec = 1000 - pseudorand(1 + max);
					peer->nonurgent_flush_timer
						= new_reltimer(&peer->daemon->timers,
							       peer,
							       time_from_msec(msec),
							       nonurgent_flush, peer);
				}

				/* Wait for them to wake us */
				return msg_queue_wait(peer_conn, peer->peer_outq, write_to_peer, peer);
			}
			/* OK, add padding (only if supported). */
			if (use_uniform_writes(peer))
				pad_encrypted_queue(peer);