diff --git a/src/raft.c b/src/raft.c
index a267d54..38c75c9 100644
--- a/src/raft.c
+++ b/src/raft.c
@@ -1,776 +1,782 @@
 /*
  * Copyright (C) 2014 Philipp Marek <philipp.marek@linbit.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #include <stdlib.h>
 #include <inttypes.h>
 #include <string.h>
 #include <errno.h>
 #include <arpa/inet.h>
 #include "booth.h"
 #include "transport.h"
 #include "inline-fn.h"
 #include "config.h"
 #include "raft.h"
 #include "ticket.h"
 #include "log.h"
 
 
 
 inline static void clear_election(struct ticket_config *tk)
 {
 	int i;
 	struct booth_site *site;
 
 	log_debug("clear election");
 	tk->votes_received = 0;
 	foreach_node(i, site)
 		tk->votes_for[site->index] = NULL;
 }
 
 
 inline static void record_vote(struct ticket_config *tk,
 		struct booth_site *who,
 		struct booth_site *vote)
 {
 	log_debug("site %s votes for %s",
 			site_string(who),
 			site_string(vote));
 
 	if (!tk->votes_for[who->index]) {
 		tk->votes_for[who->index] = vote;
 		tk->votes_received |= who->bitmask;
 	} else {
 		if (tk->votes_for[who->index] != vote)
 			log_warn("voted previously (but in same term!) for %s...",
 					site_string(tk->votes_for[who->index]));
 	}
 }
 
 
 static int cmp_msg_ticket(struct ticket_config *tk,
 		struct boothc_ticket_msg *msg)
 {
 	if (tk->current_term != ntohl(msg->ticket.term)) {
 		return tk->current_term - ntohl(msg->ticket.term);
 	}
 	return tk->commit_index - ntohl(msg->ticket.leader_commit);
 }
 
 static void update_term_from_msg(struct ticket_config *tk,
 		struct boothc_ticket_msg *msg)
 {
 	uint32_t i;
 
 
 	i = ntohl(msg->ticket.term);
 	/* if we failed to start the election, then accept the term
 	 * from the leader
 	 * */
 	if (tk->state == ST_CANDIDATE) {
 		tk->current_term = i;
 	} else {
 		tk->current_term = max(i, tk->current_term);
 	}
 
 	/* § 5.3 */
 	i = ntohl(msg->ticket.leader_commit);
 	tk->commit_index = max(i, tk->commit_index);
 }
 
 
 static void update_ticket_from_msg(struct ticket_config *tk,
 		struct boothc_ticket_msg *msg)
 {
 	int duration;
 
 
 	duration = tk->term_duration;
 	if (msg)
 		duration = min(duration, ntohl(msg->ticket.term_valid_for));
 	tk->term_expires = time(NULL) + duration;
 
 
 	if (msg) {
 		update_term_from_msg(tk, msg);
 	}
 }
 
 static void become_follower(struct ticket_config *tk,
 		struct boothc_ticket_msg *msg)
 {
 	update_ticket_from_msg(tk, msg);
 	tk->state = ST_FOLLOWER;
 }
 
 
 struct booth_site *majority_votes(struct ticket_config *tk)
 {
 	int i, n;
 	struct booth_site *v;
 	int count[MAX_NODES] = { 0, };
 
 
 	for(i=0; i<booth_conf->site_count; i++) {
 		v = tk->votes_for[i];
 		if (!v)
 			continue;
 
 		n = v->index;
 		count[n]++;
 		log_debug("Majority: %d %s wants %d %s => %d",
 				i, site_string(&booth_conf->site[i]),
 				n, site_string(v),
 				count[n]);
 
 		if (count[n]*2 <= booth_conf->site_count)
 			continue;
 
 
 		log_debug("Majority reached: %d of %d for %s",
 				count[n], booth_conf->site_count,
 				site_string(v));
 		return v;
 	}
 
 	return NULL;
 }
 
 
 static int all_voted(struct ticket_config *tk)
 {
 	int i, cnt = 0;
 
 	for(i=0; i<booth_conf->site_count; i++) {
 		if (tk->votes_for[i]) {
 			cnt++;
 		}
 	}
 
 	return (cnt == booth_conf->site_count);
 }
 
 
 static int newer_term(struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg,
 		int in_election)
 {
 	uint32_t term;
 
 	term = ntohl(msg->ticket.term);
 	/* §5.1 */
 	if (term > tk->current_term) {
 		tk->state = ST_FOLLOWER;
 		if (!in_election) {
 			tk->leader = leader;
 			log_debug("from %s: higher term %d vs. %d, following %s",
 					site_string(sender),
 					term, tk->current_term,
 					ticket_leader_string(tk));
 		} else {
 			tk->leader = no_leader;
 			log_debug("from %s: higher term %d vs. %d (election)",
 					site_string(sender),
 					term, tk->current_term);
 		}
 
 		tk->term_expires = time(NULL) + tk->term_duration;
 		tk->current_term = term;
 		return 1;
 	}
 
 	return 0;
 }
 
 static int term_too_low(struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg)
 {
 	uint32_t term;
 
 	term = ntohl(msg->ticket.term);
 	/* §5.1 */
 	if (term < tk->current_term) {
 		log_info("sending reject to %s, its term too low "
 			"(%d vs. %d)", site_string(leader),
 			term, tk->current_term
 			);
 		send_reject(sender, tk, RLT_TERM_OUTDATED);
 		return 1;
 	}
 
 	return 0;
 }
 
 
 
 
 /* For follower. */
 static int answer_HEARTBEAT (
 		struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg
 	       )
 {
 	uint32_t term;
 	struct boothc_ticket_msg omsg;
 
 
 	term = ntohl(msg->ticket.term);
 	log_debug("leader: %s, have %s; term %d vs %d",
 			site_string(leader), ticket_leader_string(tk),
 			term, tk->current_term);
 
 	/* if we're candidate, it may be that we got a heartbeat from
 	 * a legitimate leader, so don't ignore a lower term
 	 */
 	if (tk->state != ST_CANDIDATE && term < tk->current_term) {
 		log_info("ignoring lower term %d vs. %d, from %s",
 				term, tk->current_term,
 				ticket_leader_string(tk));
 		return 0;
 	}
 
 	/* Needed? */
 	newer_term(tk, sender, leader, msg, 0);
 
 	become_follower(tk, msg);
 	/* Racy??? */
 	assert(sender == leader || !leader);
 
 	tk->leader = leader;
 
 	/* Ack the heartbeat (we comply). */
 	init_ticket_msg(&omsg, OP_HEARTBEAT, RLT_SUCCESS, tk);
 	return booth_udp_send(sender, &omsg, sizeof(omsg));
 }
 
 
 static int process_UPDATE (
 		struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg
 	       )
 {
 	uint32_t term;
 
 
 	term = ntohl(msg->ticket.term);
 	log_debug("leader: %s, have %s; term %d vs %d",
 			site_string(leader), ticket_leader_string(tk),
 			term, tk->current_term);
 
 	/* No reject. (?) */
 	if (term < tk->current_term) {
 		log_info("ignoring lower term %d vs. %d, from %s",
 				term, tk->current_term,
 				ticket_leader_string(tk));
 		return 0;
 	}
 
 	update_ticket_from_msg(tk, msg);
 	ticket_write(tk);
 
 	/* run ticket_cron if the ticket expires */
 	set_ticket_wakeup(tk);
 
 	return 0;
 }
 
 static int process_REVOKE (
 		struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg
 	       )
 {
 	if (tk->leader != sender) {
 		log_error("from %s: non-leader wants to revoke ticket %s (ignoring)",
 			site_string(sender), tk->name);
 		return 1;
 	} else if (tk->state != ST_FOLLOWER) {
 		log_error("from %s: unexpected ticket %s revoke in state %s (ignoring)",
 			site_string(sender),
 			state_to_string(tk->state),
 			tk->name);
 		return 1;
 	} else {
 		log_info("from %s: leader revokes ticket %s",
 			site_string(sender), tk->name);
 		reset_ticket(tk);
 		ticket_write(tk);
 	}
 
 	return 0;
 }
 
 /* update the ticket on the leader, write it to the CIB, and
    send out the update message to others with the new expiry
    time
 */
 static int leader_update_ticket(struct ticket_config *tk)
 {
 	struct boothc_ticket_msg msg;
 
 	tk->term_expires = time(NULL) + tk->term_duration;
 	tk->retry_number = 0;
 	ticket_write(tk);
 	set_ticket_wakeup(tk);
 	init_ticket_msg(&msg, OP_UPDATE, RLT_SUCCESS, tk);
 	return transport()->broadcast(&msg, sizeof(msg));
 }
 
 /* For leader. */
 static int process_HEARTBEAT(
 		struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg
 	       )
 {
 	uint32_t term;
 
 	term = ntohl(msg->ticket.term);
 
 	if (newer_term(tk, sender, leader, msg, 0)) {
 		/* unexpected higher term */
 		log_warn("got higher term from %s (%d vs. %d)",
 				site_string(sender),
 				term, tk->current_term);
 		return 0;
 	}
 
 	/* Don't send a reject. */
 	if (term < tk->current_term) {
 		/* Doesn't know what he's talking about - perhaps
 		 * doesn't receive our packets? */
 		log_warn("from %s: unexpected "
 				"term %d instead of %d (ignoring)",
 				site_string(sender),
 				term, tk->current_term);
 		return 0;
 	}
 
 
 	if (term == tk->current_term &&
 			leader == tk->leader) {
 		/* got an ack! */
 		tk->acks_received |= sender->bitmask;
 
 		log_debug("got heartbeat ACK from %s, %d/%d agree.",
 				site_string(sender),
 				count_bits(tk->acks_received),
 				booth_conf->site_count);
 
 
 		if (majority_of_bits(tk, tk->acks_received)) {
 			/* OK, at least half of the nodes are reachable;
 			 * Update the ticket and send update messages out
 			 */
 			if( !tk->majority_acks_received ) {
 			/* Write the ticket to the CIB and set the next
 			 * wakeup time (but do that only once) */
 				tk->majority_acks_received = 1;
 				return leader_update_ticket(tk);
 			}
 		}
 	}
 
 	return 0;
 }
 
 
 void leader_elected(
 		struct ticket_config *tk,
 		struct booth_site *new_leader
 		)
 {
 	if (new_leader) {
 		tk->leader = new_leader;
 
 		tk->term_expires = time(NULL) + tk->term_duration;
 		tk->election_end = 0;
 		tk->voted_for = NULL;
 
 		if (new_leader == local)  {
 			tk->commit_index++;
 			tk->state = ST_LEADER;
 			send_heartbeat(tk);
-		} else
+			ticket_activate_timeout(tk);
+		} else {
 			become_follower(tk, NULL);
+			set_ticket_wakeup(tk);
+		}
 	}
 }
 
 
 static int process_VOTE_FOR(
 		struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg
 		)
 {
 	if (term_too_low(tk, sender, leader, msg))
 		return 0;
 
 	if (newer_term(tk, sender, leader, msg, 0)) {
 		clear_election(tk);
 	}
 
 
 	record_vote(tk, sender, leader);
 
 
 	if (tk->state != ST_CANDIDATE) {
 		/* lost candidate status, somebody rejected our proposal */
 		return 0;
 	}
 
 
 	/* only if all voted can we take the ticket now, otherwise
 	 * wait for timeout in ticket_cron */
 	if (all_voted(tk)) {
 		/* §5.2 */
 		leader_elected(tk, majority_votes(tk));
-		set_ticket_wakeup(tk);
 	}
 
 	return 0;
 }
 
 
 static int process_REJECTED(
 		struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg
 		)
 {
 	uint32_t rv;
 
 	rv   = ntohl(msg->header.result);
 
 	if (tk->state == ST_CANDIDATE &&
 			rv == RLT_TERM_OUTDATED) {
 		log_warn("from %s: ticket %s outdated (term %d), following %s",
 				site_string(sender),
 				tk->name, ntohl(msg->ticket.term),
 				site_string(leader)
 				);
 		tk->leader = leader;
 		become_follower(tk, msg);
 		return 0;
 	}
 
 
 	if (tk->state == ST_CANDIDATE &&
 			rv == RLT_TERM_STILL_VALID) {
 		log_warn("from %s: there's a leader I didn't see: %s, following",
 				site_string(sender),
 				site_string(leader));
 		tk->leader = leader;
 		become_follower(tk, msg);
 		return 0;
 	}
 
 	log_warn("from %s: in state %s, got %s (unexpected reject)",
 			site_string(sender),
 			state_to_string(tk->state),
 			state_to_string(rv));
 	tk->leader = leader;
 	become_follower(tk, msg);
 	return 0;
 }
 
 
 static int send_ticket (
 		int cmd,
 		struct ticket_config *tk,
 		struct booth_site *to_site
 	       )
 {
 	struct boothc_ticket_msg omsg;
 
 
 	init_ticket_msg(&omsg, cmd, RLT_SUCCESS, tk);
 	return booth_udp_send(to_site, &omsg, sizeof(omsg));
 }
 
 
 /* §5.2 */
 static int answer_REQ_VOTE(
 		struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg
 		)
 {
 	uint32_t term;
 	int valid;
 	struct boothc_ticket_msg omsg;
 
 
 	term = ntohl(msg->ticket.term);
 	/* Important: Ignore duplicated packets! */
 	valid = term_time_left(tk);
 	if (valid &&
 			term == tk->current_term &&
 			sender == tk->leader) {
 		log_debug("Duplicate OP_VOTE_FOR ignored.");
 		return 0;
 	}
 
 	if (valid) {
 		log_warn("no election allowed for %s, term still valid for %d",
 			tk->name, valid);
 		return send_reject(sender, tk, RLT_TERM_STILL_VALID);
 	}
 
 	if (term_too_low(tk, sender, leader, msg))
 		return 0;
 
 	/* if it's a newer term or ... */
 	if (newer_term(tk, sender, leader, msg, 1)) {
 		clear_election(tk);
 		goto vote_for_sender;
 	}
 
 
 	/* ... we didn't vote yet, then vote for the sender */
 	/* §5.2, §5.4 */
 	if (!tk->voted_for) {
 vote_for_sender:
 		tk->voted_for = sender;
 		record_vote(tk, sender, leader);
 	}
 
 
 	init_ticket_msg(&omsg, OP_VOTE_FOR, RLT_SUCCESS, tk);
 	omsg.ticket.leader = htonl(get_node_id(tk->voted_for));
 	return booth_udp_send(sender, &omsg, sizeof(omsg));
 }
 
 
 int new_election(struct ticket_config *tk,
 	struct booth_site *preference, int update_term)
 {
 	struct booth_site *new_leader;
 	time_t now;
 
 
 	time(&now);
 	log_debug("start new election?, now=%" PRIi64 ", end %" PRIi64,
 			(int64_t)now, (int64_t)(tk->election_end));
 	if (now <= tk->election_end)
 		return 0;
 
 
 	/* §5.2 */
 	/* If there was _no_ answer, don't keep incrementing the term number
 	 * indefinitely. If there was no peer, there'll probably be no one
 	 * listening now either. However, we don't know if we were
 	 * invoked due to a timeout (caller does).
 	 */
 	if (update_term)
 		tk->current_term++;
 
 	tk->term_expires = 0;
 	tk->election_end = now + tk->term_duration;
 
 	log_debug("start new election! term=%d, until %" PRIi64,
 			tk->current_term, (int64_t)tk->election_end);
 	clear_election(tk);
 
 	if(preference)
 		new_leader = preference;
 	else
 		new_leader = (local->type == SITE) ? local : NULL;
 	record_vote(tk, local, new_leader);
 	tk->voted_for = new_leader;
 
 	tk->state = ST_CANDIDATE;
 
 	ticket_broadcast(tk, OP_REQ_VOTE, RLT_SUCCESS);
 	ticket_activate_timeout(tk);
 	return 0;
 }
 
 
 /* we were a leader and somebody says that they have a more up
  * to date ticket
  * there was probably connectivity loss
  * tricky
  */
 static int leader_handle_newer_ticket(
 		struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg
 	       )
 {
 	if (leader == no_leader || !leader || leader == local) {
 		/* at least nobody else owns the ticket */
 		/* it is not kosher to update from their copy, but since
 		 * they don't own the ticket, nothing bad can happen
 		 */
 		update_term_from_msg(tk, msg);
 		/* get the ticket again, if we can
 		 */
 		return acquire_ticket(tk);
 	}
 
 	/* eek, two leaders, split brain */
 	/* normally shouldn't happen; run election */
 	log_error("from %s: ticket %s at %s! (disowning ticket)",
 			site_string(sender),
 			tk->name, site_string(leader)
 			);
 	disown_ticket(tk);
 	ticket_write(tk);
 	log_error("Two ticket owners! Possible bug. Please report at https://github.com/ClusterLabs/booth/issues/new.");
 	return acquire_ticket(tk);
 }
 
 /* reply to STATUS */
 static int process_MY_INDEX (
 		struct ticket_config *tk,
 		struct booth_site *sender,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg
 	       )
 {
 	int i;
+	int rv;
 
 	if (!msg->ticket.term_valid_for) {
 		/* ticket not valid */
 		return 0;
 	}
 
 	i = cmp_msg_ticket(tk, msg);
 
 	if (i > 0) {
 		/* let them know about our newer ticket */
 		send_ticket(OP_MY_INDEX, tk, sender);
 		if (tk->state == ST_LEADER)
 			return send_ticket(OP_UPDATE, tk, sender);
 	}
 
 	if (i == 0) {
 		return 0;
 	}
 
 	/* they have a newer ticket, trouble if we're already leader
 	 * for it */
 	if (tk->state == ST_LEADER) {
 		log_warn("from %s: more uptodate ticket %s at %s",
 				site_string(sender),
 				tk->name,
 				site_string(leader)
 				);
 		return leader_handle_newer_ticket(tk, sender, leader, msg);
 	}
 
 	update_ticket_from_msg(tk, msg);
+	tk->leader = leader;
 	if (leader == local) {
 		/* if we were the leader but we rebooted in the
 		 * meantime; try to get the ticket again
 		 */
-		return acquire_ticket(tk);
+		tk->state = ST_LEADER;
+		rv = send_heartbeat(tk);
+		ticket_activate_timeout(tk);
+		return rv;
 	} else {
-		tk->leader = leader;
 		tk->state = (!leader || leader == no_leader) ?
 			ST_INIT : ST_FOLLOWER;
 	}
 	return 0;
 }
 
 
 int raft_answer(
 		struct ticket_config *tk,
 		struct booth_site *from,
 		struct booth_site *leader,
 		struct boothc_ticket_msg *msg
 	       )
 {
 	int cmd;
 	int rv;
 
 	rv = 0;
 	cmd = ntohl(msg->header.cmd);
 	R(tk);
 
 	log_debug("got message %s from %s",
 			state_to_string(cmd),
 			site_string(from));
 
 
 	switch (cmd) {
 	case OP_REQ_VOTE:
 		rv = answer_REQ_VOTE(tk, from, leader, msg);
 		break;
 	case OP_VOTE_FOR:
 		rv = process_VOTE_FOR(tk, from, leader, msg);
 		break;
 	case OP_HEARTBEAT:
 		if (tk->leader == local &&
 				tk->state == ST_LEADER)
 			rv = process_HEARTBEAT(tk, from, leader, msg);
 		else if (tk->leader != local &&
 				(tk->state == ST_FOLLOWER ||
 				tk->state == ST_CANDIDATE))
 			rv = answer_HEARTBEAT(tk, from, leader, msg);
 		else {
 			log_warn("unexpected message %s, from %s",
 				state_to_string(cmd),
 				site_string(from));
 			rv = -EINVAL;
 		}
 		break;
 	case OP_UPDATE:
 		if (tk->leader != local && tk->state == ST_FOLLOWER) {
 			rv = process_UPDATE(tk, from, leader, msg);
 		} else {
 			log_warn("unexpected message %s, from %s",
 				state_to_string(cmd),
 				site_string(from));
 			rv = -EINVAL;
 		}
 		break;
 	case OP_REJECTED:
 		rv = process_REJECTED(tk, from, leader, msg);
 		break;
 	case OP_REVOKE:
 		rv = process_REVOKE(tk, from, leader, msg);
 		break;
 	case OP_MY_INDEX:
 		rv = process_MY_INDEX(tk, from, leader, msg);
 		break;
 	case OP_STATUS:
 		rv = send_ticket(OP_MY_INDEX, tk, from);
 		break;
 	default:
 		log_error("unknown message %s, from %s",
 			state_to_string(cmd), site_string(from));
 		rv = -EINVAL;
 	}
 	R(tk);
 	return rv;
 }
diff --git a/src/ticket.c b/src/ticket.c
index 18efa3e..c69dcb4 100644
--- a/src/ticket.c
+++ b/src/ticket.c
@@ -1,661 +1,659 @@
 /* 
  * Copyright (C) 2011 Jiaju Zhang <jjzhang@suse.de>
  * Copyright (C) 2013-2014 Philipp Marek <philipp.marek@linbit.com>
  * 
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  * 
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  * 
  * You should have received a copy of the GNU General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <arpa/inet.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <assert.h>
 #include <time.h>
 #include "ticket.h"
 #include "config.h"
 #include "pacemaker.h"
 #include "inline-fn.h"
 #include "log.h"
 #include "booth.h"
 #include "raft.h"
 #include "handler.h"
 
 #define TK_LINE			256
 
 
 /* Untrusted input, must fit (incl. \0) in a buffer of max chars. */
 int check_max_len_valid(const char *s, int max)
 {
 	int i;
 	for(i=0; i<max; i++)
 		if (s[i] == 0)
 			return 1;
 	return 0;
 }
 
 int find_ticket_by_name(const char *ticket, struct ticket_config **found)
 {
 	int i;
 
 	if (found)
 		*found = NULL;
 
 	for (i = 0; i < booth_conf->ticket_count; i++) {
 		if (!strcmp(booth_conf->ticket[i].name, ticket)) {
 			if (found)
 				*found = booth_conf->ticket + i;
 			return 1;
 		}
 	}
 
 	return 0;
 }
 
 
 int check_ticket(char *ticket, struct ticket_config **found)
 {
 	if (found)
 		*found = NULL;
 	if (!booth_conf)
 		return 0;
 
 	if (!check_max_len_valid(ticket, sizeof(booth_conf->ticket[0].name)))
 		return 0;
 	return find_ticket_by_name(ticket, found);
 }
 
 int check_site(char *site, int *is_local)
 {
 	struct booth_site *node;
 
 	if (!check_max_len_valid(site, sizeof(node->addr_string)))
 		return 0;
 
 	if (find_site_by_name(site, &node, 0)) {
 		*is_local = node->local;
 		return 1;
 	}
 
 	return 0;
 }
 
 
 #if 0
 /** Find out what others think about this ticket.
  *
  * If we're a SITE, we can ask (and have to tell) Pacemaker.
  * An ARBITRATOR can only ask others. */
 static int ticket_send_catchup(struct ticket_config *tk)
 {
 	int i, rv = 0;
 	struct booth_site *site;
 	struct boothc_ticket_msg msg;
 
 	foreach_node(i, site) {
 		if (!site->local) {
 			init_ticket_msg(&msg, CMD_CATCHUP, RLT_SUCCESS, tk);
 
 			log_debug("attempting catchup from %s", site->addr_string);
 
 			rv = booth_udp_send(site, &msg, sizeof(msg));
 		}
 	}
 
 	ticket_activate_timeout(tk);
 
 	return rv;
 }
 #endif
 
 
 int ticket_write(struct ticket_config *tk)
 {
 	if (local->type != SITE)
 		return -EINVAL;
 
 	disown_if_expired(tk);
 
 	if (tk->leader == local) {
 		pcmk_handler.grant_ticket(tk);
 	} else {
 		pcmk_handler.revoke_ticket(tk);
 	}
 
 	return 0;
 }
 
 
 /* Ask an external program whether getting the ticket
  * makes sense.
 * Eg. if the services have a failcount of INFINITY,
 * we can't serve here anyway. */
 int acquire_ticket(struct ticket_config *tk)
 {
 	int rv;
 
 	if (!tk->ext_verifier)
 		goto get_it;
 
 	rv = run_handler(tk, tk->ext_verifier, 1);
 	if (rv) {
 		log_warn("we are not allowed to acquire ticket %s",
 			tk->name);
 
 		/* Give it to somebody else.
 		 * Just send a commit message, as the
 		 * others couldn't help anyway. */
 		if (leader_and_valid(tk)) {
 			disown_ticket(tk);
 #if 0
 			tk->proposed_owner = NULL;
 
 			/* Just go one further - others may easily override. */
 			tk->new_ballot++;
 
 			ticket_broadcast_proposed_state(tk, OP_COMMITTED);
 			tk->state = ST_STABLE;
 #endif
 			ticket_broadcast(tk, OP_VOTE_FOR, RLT_SUCCESS);
 		}
 
 		return rv;
 	}
 
 get_it:
 	rv = new_election(tk, local, 1);
 	return rv;
 }
 
 
 /** Try to get the ticket for the local site.
  * */
 int do_grant_ticket(struct ticket_config *tk)
 {
 	int rv;
 
 	if (tk->leader == local)
 		return RLT_SUCCESS;
 	if (is_owned(tk))
 		return RLT_OVERGRANT;
 
 	rv = acquire_ticket(tk);
 	return rv;
 }
 
 
 /** Ticket revoke.
  * Only to be started from the leader. */
 int do_revoke_ticket(struct ticket_config *tk)
 {
 	log_info("revoking ticket %s", tk->name);
 
 	reset_ticket(tk);
 	ticket_write(tk);
 	return ticket_broadcast(tk, OP_REVOKE, RLT_SUCCESS);
 }
 
 
 int list_ticket(char **pdata, unsigned int *len)
 {
 	struct ticket_config *tk;
 	char timeout_str[64];
 	char *data, *cp;
 	int i, alloc;
 
 	*pdata = NULL;
 	*len = 0;
 
 	alloc = 256 +
 		booth_conf->ticket_count * (BOOTH_NAME_LEN * 2 + 128);
 	data = malloc(alloc);
 	if (!data)
 		return -ENOMEM;
 
 	cp = data;
 	foreach_ticket(i, tk) {
 		if (tk->term_expires != 0)
 			strftime(timeout_str, sizeof(timeout_str), "%F %T",
 					localtime(&tk->term_expires));
 		else
 			strcpy(timeout_str, "INF");
 
 
 		cp += sprintf(cp,
 				"ticket: %s, leader: %s, expires: %s, commit: %d\n",
 				tk->name,
 				ticket_leader_string(tk),
 				timeout_str,
 				tk->commit_index);
 
 		*len = cp - data;
 		assert(*len < alloc);
 	}
 
 	*pdata = data;
 
 	return 0;
 }
 
 void reset_ticket(struct ticket_config *tk)
 {
 	disown_ticket(tk);
 	tk->current_term = 0;
 	tk->commit_index = 0;
 	tk->state = ST_INIT;
 }
 
 
 int setup_ticket(void)
 {
 	struct ticket_config *tk;
 	int i;
 
 	foreach_ticket(i, tk) {
 		reset_ticket(tk);
 
 		if (local->type == SITE) {
 			pcmk_handler.load_ticket(tk);
 			if (time(NULL) >= tk->term_expires) {
 				reset_ticket(tk);
 				ticket_write(tk);
 			}
 		}
 
 
-		/* we'll start election if the ticket seems to be
-		 * uptodate
+		/* if the ticket is uptodate and belongs to us, try with
+		 * the heartbeat
 		 */
 		if (tk->is_granted && tk->leader == local) {
-			tk->state = ST_FOLLOWER;
+			tk->state = ST_LEADER;
+			send_heartbeat(tk);
+			ticket_activate_timeout(tk);
 		} else {
 			/* otherwise, query status */
 			ticket_broadcast(tk, OP_STATUS, RLT_SUCCESS);
 		}
 	}
 
 	return 0;
 }
 
 
 int ticket_answer_list(int fd, struct boothc_ticket_msg *msg)
 {
 	char *data;
 	int olen, rv;
 	struct boothc_header hdr;
 
 	rv = list_ticket(&data, &olen);
 	if (rv < 0)
 		return rv;
 
 	init_header(&hdr, CMR_LIST, RLT_SUCCESS, sizeof(hdr) + olen);
 
 	return send_header_plus(fd, &hdr, data, olen);
 }
 
 
 int ticket_answer_grant(int fd, struct boothc_ticket_msg *msg)
 {
 	int rv;
 	struct ticket_config *tk;
 
 
 	if (!check_ticket(msg->ticket.id, &tk)) {
 		log_warn("client asked to grant unknown ticket %s",
 				msg->ticket.id);
 		rv = RLT_INVALID_ARG;
 		goto reply;
 	}
 
 	if (is_owned(tk)) {
 		log_warn("client wants to grant an (already granted!) ticket %s",
 				msg->ticket.id);
 		rv = RLT_OVERGRANT;
 		goto reply;
 	}
 
 	rv = do_grant_ticket(tk);
 
 reply:
 	init_header(&msg->header, CMR_GRANT, rv ?: RLT_ASYNC, sizeof(*msg));
 	return send_ticket_msg(fd, msg);
 }
 
 
 int ticket_answer_revoke(int fd, struct boothc_ticket_msg *msg)
 {
 	int rv;
 	struct ticket_config *tk;
 
 	if (!check_ticket(msg->ticket.id, &tk)) {
 		log_warn("client wants to revoke an unknown ticket %s",
 				msg->ticket.id);
 		rv = RLT_INVALID_ARG;
 		goto reply;
 	}
 
 	if (!is_owned(tk)) {
 		log_info("client wants to revoke a free ticket %s",
 				msg->ticket.id);
 		/* Return a different result code? */
 		rv = RLT_SUCCESS;
 		goto reply;
 	}
 
 	if (tk->leader != local) {
 		log_info("we do not own the ticket %s, "
 				"redirect to leader %s",
 				msg->ticket.id, ticket_leader_string(tk));
 		rv = RLT_REDIRECT;
 		goto reply;
 	}
 
 	rv = do_revoke_ticket(tk);
 	if (rv == 0)
 		rv = RLT_ASYNC;
 
 reply:
 	init_ticket_msg(msg, CMR_REVOKE, rv, tk);
 	return send_ticket_msg(fd, msg);
 }
 
 
 int ticket_broadcast(struct ticket_config *tk, cmd_request_t cmd, cmd_result_t res)
 {
 	struct boothc_ticket_msg msg;
 
 	init_ticket_msg(&msg, cmd, res, tk);
 	log_debug("broadcasting '%s' for ticket %s (term=%d, valid=%d)",
 			state_to_string(cmd), tk->name,
 			ntohl(msg.ticket.term),
 			ntohl(msg.ticket.term_valid_for));
 
 	return transport()->broadcast(&msg, sizeof(msg));
 }
 
 
 static void ticket_lost(struct ticket_config *tk)
 {
 	log_warn("LOST ticket: %s no longer at %s",
 			tk->name,
 			ticket_leader_string(tk));
 
 	/* Couldn't renew in time - ticket lost. */
 	disown_ticket(tk);
 
 	/* New vote round; §5.2 */
 	if (local->type == SITE) {
 		new_election(tk, NULL, 1);
 	}
 
 	ticket_write(tk);
 }
 
 
 static void ticket_cron(struct ticket_config *tk)
 {
 	time_t now;
 	int vote_cnt;
 	struct booth_site *new_leader;
 
 	now = time(NULL);
 
 
 	R(tk);
 	/* Has an owner, has an expiry date, and expiry date in the past?
 	 * Losing the ticket must happen in _every_ state. */
 	if (tk->term_expires &&
 			is_owned(tk) &&
 			now >= tk->term_expires) {
 		ticket_lost(tk);
 		return;
 	}
 	R(tk);
 
 	switch(tk->state) {
 	case ST_INIT:
 		/* init state, nothing to do */
 		break;
 
 	case ST_FOLLOWER:
-		/* in case we got restarted and this ticket belongs to
-		 * us */
-		if (tk->is_granted && tk->leader == local) {
-			acquire_ticket(tk);
-		}
+		/* nothing here either, ticket loss is caught earlier
+		 * */
 		break;
 
 	case ST_CANDIDATE:
 		/* §5.2 */
 		/* not everybody answered, but if we have majority... */
 		new_leader = majority_votes(tk);
 		if (new_leader) {
 			leader_elected(tk, new_leader);
-			set_ticket_wakeup(tk);
 		} else if (now > tk->election_end) {
 			/* This is previous election timed out */
 			new_election(tk, NULL, 0);
 		}
 		break;
 
 	case ST_LEADER:
 		/* we get here after we broadcasted a heartbeat;
 		 * by this time all sites should've acked the heartbeat
 		 */
 		vote_cnt = count_bits(tk->acks_received) - 1;
 		if ((vote_cnt+1) < booth_conf->site_count) {
 			if (!majority_of_bits(tk, tk->acks_received)) {
 				tk->retry_number ++;
 				if (!vote_cnt) {
 					log_warn("no answers to heartbeat for ticket %s on try #%d, "
 					"we are alone",
 					tk->name,
 					tk->retry_number);
 				} else {
 					log_warn("not enough answers to heartbeat for ticket %s on try #%d: "
 					"only got %d answers",
 					tk->name,
 					tk->retry_number,
 					vote_cnt);
 				}
 			/* Don't give up, though - there's still some time until leadership is lost. */
 			}
 		}
 
 		send_heartbeat(tk);
 		if (tk->retry_number < tk->retries) {
 			ticket_activate_timeout(tk);
 		} else {
 			set_ticket_wakeup(tk);
 		}
 		break;
 
 	default:
 		break;
 	}
 	R(tk);
 }
 
 
 void process_tickets(void)
 {
 	struct ticket_config *tk;
 	int i;
 	struct timeval now;
 	float sec_until;
 
 	gettimeofday(&now, NULL);
 
 	foreach_ticket(i, tk) {
 		sec_until = timeval_to_float(tk->next_cron) - timeval_to_float(now);
 		if (0)
 			log_debug("ticket %s next cron %" PRIx64 ".%03d, "
 					"now %" PRIx64 "%03d, in %f",
 					tk->name,
 					(uint64_t)tk->next_cron.tv_sec, timeval_msec(tk->next_cron),
 					(uint64_t)now.tv_sec, timeval_msec(now),
 					sec_until);
 		if (sec_until > 0.0)
 			continue;
 
 		log_debug("ticket cron: doing %s", tk->name);
 
 
 		/* Set next value, handler may override.
 		 * This should already be handled via the state logic;
 		 * but to be on the safe side the renew repetition is
 		 * duplicated here, too.  */
 		set_ticket_wakeup(tk);
 
 		ticket_cron(tk);
 	}
 }
 
 
 
 void tickets_log_info(void)
 {
 	struct ticket_config *tk;
 	int i;
 
 	foreach_ticket(i, tk) {
 		log_info("Ticket %s: state '%s' "
 				"commit index %d "
 				"leader %s "
 				"expires %-24.24s",
 				tk->name,
 				state_to_string(tk->state),
 				tk->commit_index,
 				ticket_leader_string(tk),
 				ctime(&tk->term_expires));
 	}
 }
 
 
 /* UDP message receiver. */
 int message_recv(struct boothc_ticket_msg *msg, int msglen)
 {
 	uint32_t from;
 	struct booth_site *source;
 	struct ticket_config *tk;
 	struct booth_site *leader;
 	uint32_t leader_u;
 
 
 	if (check_boothc_header(&msg->header, sizeof(*msg)) < 0 ||
 			msglen != sizeof(*msg)) {
 		log_error("message receive error");
 		return -1;
 	}
 
 	from = ntohl(msg->header.from);
 	if (!find_site_by_id(from, &source) || !source) {
 		log_error("unknown sender: %08x", from);
 		return -1;
 	}
 
 	if (!check_ticket(msg->ticket.id, &tk)) {
 		log_warn("got invalid ticket name %s from %s",
 				msg->ticket.id, site_string(source));
 		return -EINVAL;
 	}
 
 
 	leader_u = ntohl(msg->ticket.leader);
 	if (!find_site_by_id(leader_u, &leader)) {
 		log_error("Message with unknown owner %u received", leader_u);
 		return -EINVAL;
 	}
 
 
 	return raft_answer(tk, source, leader, msg);
 }
 
 
 void set_ticket_wakeup(struct ticket_config *tk)
 {
 	struct timeval tv, now;
 
 	/* At least every hour, perhaps sooner. */
 	ticket_next_cron_in(tk, 3600);
 
 	switch (tk->state) {
 	case ST_LEADER:
 		assert(tk->leader == local);
 		gettimeofday(&now, NULL);
 
 		tv = now;
 		tv.tv_sec = next_vote_starts_at(tk);
 
 		/* If timestamp is in the past, look again in one second. */
 		if (timeval_compare(tv, now) <= 0)
 			tv.tv_sec = now.tv_sec + 1;
 
 		ticket_next_cron_at(tk, tv);
 		break;
 
 	case ST_CANDIDATE:
 		assert(tk->election_end);
 		ticket_next_cron_at_coarse(tk, tk->election_end);
 		break;
 
 	case ST_INIT:
 	case ST_FOLLOWER:
 		/* If there is (or should be) some owner, check on it later on.
 		 * If no one is interested - don't care. */
 		if (is_owned(tk) &&
 				(local->type == SITE))
 			ticket_next_cron_at_coarse(tk,
 					tk->term_expires + tk->acquire_after);
 		break;
 
 	default:
 		log_error("unknown ticket state: %d", tk->state);
 	}
 }
 
 
 
 /* Given a state (in host byte order), return a human-readable (char*).
  * An array is used so that multiple states can be printed in a single printf(). */
 char *state_to_string(uint32_t state_ho)
 {
 	union mu { cmd_request_t s; char c[5]; };
 	static union mu cache[6] = { { 0 } }, *cur;
 	static int current = 0;
 
 	current ++;
 	if (current >= sizeof(cache)/sizeof(cache[0]))
 		current = 0;
 
 	cur = cache + current;
 
 	cur->s = htonl(state_ho);
 	/* Shouldn't be necessary, union array is initialized with zeroes, and
 	 * these bytes never get written. */
 	cur->c[4] = 0;
 	return cur->c;
 }
 
 
 int send_reject(struct booth_site *dest, struct ticket_config *tk, cmd_result_t code)
 {
 	struct boothc_ticket_msg msg;
 
 
 	init_ticket_msg(&msg, OP_REJECTED, code, tk);
 	return booth_udp_send(dest, &msg, sizeof(msg));
 }