/*

 * Soft:        Keepalived is a failover program for the LVS project

 *              <www.linuxvirtualserver.org>. It monitor & manipulate

 *              a loadbalanced server pool using multi-layer checks.

 *

 * Part:        Manipulation functions for IPVS & IPFW wrappers.

 *

 * Author:      Alexandre Cassen, <acassen@linux-vs.org>

 *

 *              This program 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.

 *

 *              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 of the License, or (at your option) any later version.

 *

 * Copyright (C) 2001-2017 Alexandre Cassen, <acassen@gmail.com>

 */

#include "config.h"

#include <unistd.h>

#include "ipwrapper.h"

#include "check_api.h"

#include "logger.h"

#include "utils.h"

#include "main.h"

#ifdef _WITH_SNMP_CHECKER_

  #include "check_snmp.h"

#endif

#include "global_data.h"

#include "smtp.h"

#include "check_daemon.h"

/* Returns the sum of all alive RS weight in a virtual server. */

static unsigned long

weigh_live_realservers(virtual_server_t * vs)

{

	element e;

	real_server_t *svr;

	long count = 0;

	for (e = LIST_HEAD(vs->rs); e; ELEMENT_NEXT(e)) {

		svr = ELEMENT_DATA(e);

		if (ISALIVE(svr))

			count += svr->weight;

	}

	return count;

}

static void

notify_fifo_vs(virtual_server_t* vs)

{

	char *state = vs->quorum_state_up ? "UP" : "DOWN";

	size_t size;

	char *line;

	char *vs_str;

	if (global_data->notify_fifo.fd == -1 &&

	    global_data->lvs_notify_fifo.fd == -1)

		return;

	vs_str = FMT_VS(vs);

	size = strlen(vs_str) + strlen(state) + 6;

	line = MALLOC(size);

	if (!line)

		return;

	snprintf(line, size, "VS %s %s\n", vs_str, state);

	if (global_data->notify_fifo.fd != -1) {

		if (write(global_data->notify_fifo.fd, line, size - 1) == -1) {}

	}

	if (global_data->lvs_notify_fifo.fd != -1) {

		if (write(global_data->lvs_notify_fifo.fd, line, size - 1) == -1) {}

	}

	FREE(line);

}

static void

notify_fifo_rs(virtual_server_t* vs, real_server_t* rs)

{

	char *state = rs->alive ? "UP" : "DOWN";

	size_t size;

	char *line;

	char *str;

	char *rs_str;

	char *vs_str;

	if (global_data->notify_fifo.fd == -1 &&

	    global_data->lvs_notify_fifo.fd == -1)

		return;

	str = FMT_RS(rs, vs);

	rs_str = MALLOC(strlen(str)+1);

	strcpy(rs_str, str);

	vs_str = FMT_VS(vs);

	size = strlen(rs_str) + strlen(vs_str) + strlen(state) + 7;

	line = MALLOC(size);

	if (!line)

		return;

	snprintf(line, size, "RS %s %s %s\n", rs_str, vs_str, state);

	FREE(rs_str);

	if (global_data->notify_fifo.fd != -1) {

		if (write(global_data->notify_fifo.fd, line, size - 1) == - 1) {}

	}

	if (global_data->lvs_notify_fifo.fd != -1) {

		if (write(global_data->lvs_notify_fifo.fd, line, size - 1) == -1) {}

	}

	FREE(line);

}

static void

do_vs_notifies(virtual_server_t* vs, bool init, long threshold, long weight_sum, bool stopping)

{

	notify_script_t *notify_script = vs->quorum_state_up ? vs->notify_quorum_up : vs->notify_quorum_down;

	char message[80];

#ifdef _WITH_SNMP_CHECKER_

	check_snmp_quorum_trap(vs, stopping);

#endif

	/* Only send non SNMP notifies when stopping if omega set */

	if (stopping && !vs->omega)

		return;

	if (notify_script) {

		if (stopping)

			system_call_script(master, child_killed_thread, NULL, TIMER_HZ, notify_script);

		else

			notify_exec(notify_script);

	}

	notify_fifo_vs(vs);

	if (vs->smtp_alert) {

		if (stopping)

			snprintf(message, sizeof(message), "=> Shutting down <=");

		else

			snprintf(message, sizeof(message), "=> %s %u+%u=%ld <= %ld <=",

				    vs->quorum_state_up ?

						   init ? "Starting with quorum up" :

							  "Gained quorum" :

						   init ? "Starting with quorum down" :

							  "Lost quorum",

				    vs->quorum,

				    vs->hysteresis,

				    threshold,

				    weight_sum);

		smtp_alert(SMTP_MSG_VS, vs, vs->quorum_state_up ? "UP" : "DOWN", message);

	}

}

static void

do_rs_notifies(virtual_server_t* vs, real_server_t* rs, bool stopping)

{

	notify_script_t *notify_script = rs->alive ? rs->notify_up : rs->notify_down;

	if (notify_script) {

		if (stopping)

			system_call_script(master, child_killed_thread, NULL, TIMER_HZ, notify_script);

		else

			notify_exec(notify_script);

	}

	notify_fifo_rs(vs, rs);

	/* The sending of smtp_alerts is handled by the individual checker

	 * so that the message can have context for the checker */

#ifdef _WITH_SNMP_CHECKER_

	check_snmp_rs_trap(rs, vs, stopping);

#endif

}

/* Remove a realserver IPVS rule */

static void

clear_service_rs(virtual_server_t * vs, list l, bool stopping)

{

	element e;

	real_server_t *rs;

	long weight_sum;

	long threshold = vs->quorum - vs->hysteresis;

	bool sav_inhibit;

	smtp_rs rs_info = { .vs = vs };

	LIST_FOREACH(l, rs, e) {

		if (rs->set || stopping)

			log_message(LOG_INFO, "%s %sservice %s from VS %s",

					stopping ? "Shutting down" : "Removing",

					rs->inhibit && !rs->alive ? "(inhibited) " : "",

					FMT_RS(rs, vs),

					FMT_VS(vs));

		if (!rs->set)

			continue;

		/* Force removal of real servers with inhibit_on_failure set */

		sav_inhibit = rs->inhibit;

		rs->inhibit = false;

		ipvs_cmd(LVS_CMD_DEL_DEST, vs, rs);

		rs->inhibit = sav_inhibit;	/* Restore inhibit flag */

		if (!rs->alive)

			continue;

		UNSET_ALIVE(rs);

		/* We always want to send SNMP messages on shutdown */

		if (!vs->omega && stopping) {

#ifdef _WITH_SNMP_CHECKER_

			check_snmp_rs_trap(rs, vs, true);

#endif

			continue;

		}

		/* In Omega mode we call VS and RS down notifiers

		 * all the way down the exit, as necessary.

		 */

		do_rs_notifies(vs, rs, stopping);

		/* Send SMTP alert */

		if (rs->smtp_alert) {

			rs_info.rs = rs;

			smtp_alert(SMTP_MSG_RS_SHUT, &rs_info, "DOWN", stopping ? "=> Shutting down <=" : "=> Removing <=");

		}

	}

	/* Sooner or later VS will lose the quorum (if any). However,

	 * we don't push in a sorry server then, hence the regression

	 * is intended.

	 */

	weight_sum = weigh_live_realservers(vs);

	if (stopping ||

	    (vs->quorum_state_up &&

	     (!weight_sum || weight_sum < threshold))) {

		vs->quorum_state_up = false;

		do_vs_notifies(vs, false, threshold, weight_sum, stopping);

	}

}

/* Remove a virtualserver IPVS rule */

static void

clear_service_vs(virtual_server_t * vs, bool stopping)

{

	bool sav_inhibit;

	/* Processing real server queue */

	if (vs->s_svr && vs->s_svr->set) {

		/* Ensure removed if inhibit_on_failure set */

		sav_inhibit = vs->s_svr->inhibit;

		vs->s_svr->inhibit = false;

		ipvs_cmd(LVS_CMD_DEL_DEST, vs, vs->s_svr);

		vs->s_svr->inhibit = sav_inhibit;

		UNSET_ALIVE(vs->s_svr);

	}

	/* Even if the sorry server was configured, if we are using

	 * inhibit_on_failure, then real servers may be configured. */

	clear_service_rs(vs, vs->rs, stopping);

	/* The above will handle Omega case for VS as well. */

	ipvs_cmd(LVS_CMD_DEL, vs, NULL);

	UNSET_ALIVE(vs);

}

/* IPVS cleaner processing */

void

clear_services(void)

{

	element e;

	virtual_server_t *vs;

	if (!check_data || !check_data->vs)

		return;

	LIST_FOREACH(check_data->vs, vs, e) {

		/* Remove the real servers, and clear the vs unless it is

		 * using a VS group and it is not the last vs of the same

		 * protocol or address family using the group. */

		clear_service_vs(vs, true);

	}

}

/* Set a realserver IPVS rules */

static bool

init_service_rs(virtual_server_t * vs)

{

	element e;

	real_server_t *rs;

	LIST_FOREACH(vs->rs, rs, e) {

		if (rs->reloaded) {

			if (rs->iweight != rs->pweight)

				update_svr_wgt(rs->iweight, vs, rs, false);

			/* Do not re-add failed RS instantly on reload */

			continue;

		}

		/* In alpha mode, be pessimistic (or realistic?) and don't

		 * add real servers into the VS pool unless inhibit_on_failure.

		 * They will get there later upon healthchecks recovery (if ever).

		 */

		if ((!rs->num_failed_checkers && !ISALIVE(rs)) ||

		    (rs->inhibit && !rs->set)) {

			ipvs_cmd(LVS_CMD_ADD_DEST, vs, rs);

			if (!rs->num_failed_checkers) {

				SET_ALIVE(rs);

				if (global_data->rs_init_notifies)

					do_rs_notifies(vs, rs, false);

			}

		}

	}

	return true;

}

static void

sync_service_vsg(virtual_server_t * vs)

{

	virtual_server_group_t *vsg;

	virtual_server_group_entry_t *vsge;

	list *l;

	element e;

	vsg = vs->vsg;

	list ll[] = {

		vsg->addr_range,

		vsg->vfwmark,

		NULL,

	};

	for (l = ll; *l; l++)

		for (e = LIST_HEAD(*l); e; ELEMENT_NEXT(e)) {

			vsge = ELEMENT_DATA(e);

			if (vs->reloaded && !vsge->reloaded) {

				log_message(LOG_INFO, "VS [%s:%d:%u] added into group %s"

// Does this work with no address?

						    , inet_sockaddrtotrio(&vsge->addr, vs->service_type)

						    , vsge->range

						    , vsge->vfwmark

						    , vs->vsgname);

				/* add all reloaded and alive/inhibit-set dests

				 * to the newly created vsg item */

				ipvs_group_sync_entry(vs, vsge);

			}

		}

}

/* add or remove _alive_ real servers from a virtual server */

static void

perform_quorum_state(virtual_server_t *vs, bool add)

{

	element e;

	real_server_t *rs;

	log_message(LOG_INFO, "%s the pool for VS %s"

			    , add?"Adding alive servers to":"Removing alive servers from"

			    , FMT_VS(vs));

	LIST_FOREACH(vs->rs, rs, e) {

		if (!ISALIVE(rs)) /* We only handle alive servers */

			continue;

// ??? The following seems unnecessary

		if (add)

			rs->alive = false;

		ipvs_cmd(add?LVS_CMD_ADD_DEST:LVS_CMD_DEL_DEST, vs, rs);

		rs->alive = true;

	}

}

void

set_quorum_states(void)

{

	virtual_server_t *vs;

	element e;

	if (LIST_ISEMPTY(check_data->vs))

		return;

	for (e = LIST_HEAD(check_data->vs); e; ELEMENT_NEXT(e)) {

		vs = ELEMENT_DATA(e);

		vs->quorum_state_up = (weigh_live_realservers(vs) >= vs->quorum + vs->hysteresis);

	}

}

/* set quorum state depending on current weight of real servers */

static void

update_quorum_state(virtual_server_t * vs, bool init)

{

	long weight_sum = weigh_live_realservers(vs);

	long threshold;

	threshold = vs->quorum + (vs->quorum_state_up ? -1 : 1) * vs->hysteresis;

	/* If we have just gained quorum, it's time to consider notify_up. */

	if (!vs->quorum_state_up &&

	    weight_sum >= threshold) {

		vs->quorum_state_up = true;

		log_message(LOG_INFO, "Gained quorum %u+%u=%ld <= %ld for VS %s"

				    , vs->quorum

				    , vs->hysteresis

				    , threshold

				    , weight_sum

				    , FMT_VS(vs));

		if (vs->s_svr && ISALIVE(vs->s_svr)) {

			/* Adding back alive real servers */

			perform_quorum_state(vs, true);

			log_message(LOG_INFO, "%s sorry server %s from VS %s"

					    , (vs->s_svr->inhibit ? "Disabling" : "Removing")

					    , FMT_RS(vs->s_svr, vs)

					    , FMT_VS(vs));

			ipvs_cmd(LVS_CMD_DEL_DEST, vs, vs->s_svr);

			vs->s_svr->alive = false;

		}

		do_vs_notifies(vs, init, threshold, weight_sum, false);

		return;

	}

	else if ((vs->quorum_state_up &&

		  (!weight_sum || weight_sum < threshold)) ||

		 (init && !vs->quorum_state_up &&

		  vs->s_svr && !ISALIVE(vs->s_svr))) {

		/* We have just lost quorum for the VS, we need to consider

		 * VS notify_down and sorry_server cases

		 *   or

		 * We are starting up and need to add the sorry server

		 */

		vs->quorum_state_up = false;

		log_message(LOG_INFO, "%s %u-%u=%ld > %ld for VS %s"

				    , init ? "Starting with quorum down" : "Lost quorum"

				    , vs->quorum

				    , vs->hysteresis

				    , threshold

				    , weight_sum

				    , FMT_VS(vs));

		if (vs->s_svr && !ISALIVE(vs->s_svr)) {

			log_message(LOG_INFO, "%s sorry server %s to VS %s"

					    , (vs->s_svr->inhibit ? "Enabling" : "Adding")

					    , FMT_RS(vs->s_svr, vs)

					    , FMT_VS(vs));

			/* the sorry server is now up in the pool, we flag it alive */

			ipvs_cmd(LVS_CMD_ADD_DEST, vs, vs->s_svr);

			vs->s_svr->alive = true;

			/* Remove remaining alive real servers */

			perform_quorum_state(vs, false);

		}

		do_vs_notifies(vs, init, threshold, weight_sum, false);

	}

}

/* manipulate add/remove rs according to alive state */

static bool

perform_svr_state(bool alive, checker_t *checker)

{

	/*

	 * | ISALIVE(rs) | alive | context

	 * | false       | false | first check failed under alpha mode, unreachable here

	 * | false       | true  | RS went up, add it to the pool

	 * | true        | false | RS went down, remove it from the pool

	 * | true        | true  | first check succeeded w/o alpha mode, unreachable here

	 */

	virtual_server_t * vs = checker->vs;

	real_server_t * rs = checker->rs;

	if (ISALIVE(rs) == alive)

		return true;

	log_message(LOG_INFO, "%sing service %s to VS %s"

			    , alive ? (rs->inhibit) ? "Enabl" : "Add" :

				      (rs->inhibit) ? "Disabl" : "Remov"

			    , FMT_RS(rs, vs)

			    , FMT_VS(vs));

	/* Change only if we have quorum or no sorry server */

	if (vs->quorum_state_up || !vs->s_svr || !ISALIVE(vs->s_svr)) {

		if (ipvs_cmd(alive ? LVS_CMD_ADD_DEST : LVS_CMD_DEL_DEST, vs, rs))

			return false;

	}

	rs->alive = alive;

	do_rs_notifies(vs, rs, false);

	/* We may have changed quorum state. If the quorum wasn't up

	 * but is now up, this is where the rs is added. */

	update_quorum_state(vs, false);

	return true;

}

/* Set a virtualserver IPVS rules */

static bool

init_service_vs(virtual_server_t * vs)

{

	/* Init the VS root */

	if (!ISALIVE(vs) || vs->vsg) {

		ipvs_cmd(LVS_CMD_ADD, vs, NULL);

		SET_ALIVE(vs);

	}

	/* Processing real server queue */

	if (!init_service_rs(vs))

		return false;

	if (vs->reloaded && vs->vsgname) {

		/* add reloaded dests into new vsg entries */

		sync_service_vsg(vs);

	}

	/* we may have got/lost quorum due to quorum setting changed */

	/* also update, in case we need the sorry server in alpha mode */

	update_quorum_state(vs, true);

	/* If we have a sorry server with inhibit, add it now */

	if (vs->s_svr && vs->s_svr->inhibit && !vs->s_svr->set) {

		/* Make sure the sorry server is configured with weight 0 */

		vs->s_svr->num_failed_checkers = 1;

		ipvs_cmd(LVS_CMD_ADD_DEST, vs, vs->s_svr);

		vs->s_svr->num_failed_checkers = 0;

	}

	return true;

}

/* Set IPVS rules */

bool

init_services(void)

{

	element e;

	virtual_server_t *vs;

	LIST_FOREACH(check_data->vs, vs, e) {

		if (!init_service_vs(vs))

			return false;

	}

	return true;

}

/* Store new weight in real_server struct and then update kernel. */

void

update_svr_wgt(int weight, virtual_server_t * vs, real_server_t * rs

		, bool update_quorum)

{

	if (weight != rs->weight) {

		log_message(LOG_INFO, "Changing weight from %d to %d for %s service %s of VS %s"

				    , rs->weight

				    , weight

				    , ISALIVE(rs) ? "active" : "inactive"

				    , FMT_RS(rs, vs)

				    , FMT_VS(vs));

		rs->weight = weight;

		/*

		 * Have weight change take effect now only if rs is in

		 * the pool and alive and the quorum is met (or if

		 * there is no sorry server). If not, it will take

		 * effect later when it becomes alive.

		 */

		if (rs->set && ISALIVE(rs) &&

		    (vs->quorum_state_up || !vs->s_svr || !ISALIVE(vs->s_svr)))

			ipvs_cmd(LVS_CMD_EDIT_DEST, vs, rs);

		if (update_quorum)

			update_quorum_state(vs, false);

	}

}

void

set_checker_state(checker_t *checker, bool up)

{

	if (checker->is_up == up)

		return;

	checker->is_up = up;

	if (!up)

		checker->rs->num_failed_checkers++;

	else if (checker->rs->num_failed_checkers)

		checker->rs->num_failed_checkers--;

}

/* Update checker's state */

void

update_svr_checker_state(bool alive, checker_t *checker)

{

	if (checker->is_up == alive) {

		if (!checker->has_run) {

			if (checker->alpha || !alive)

				do_rs_notifies(checker->vs, checker->rs, false);

			checker->has_run = true;

		}

		return;

	}

	checker->has_run = true;

	if (alive) {

		/* call the UP handler unless any more failed checks found */

		if (checker->rs->num_failed_checkers <= 1) {

			if (!perform_svr_state(true, checker))

				return;

		}

	}

	else {

		/* Handle not alive state */

		if (checker->rs->num_failed_checkers == 0) {

			if (!perform_svr_state(false, checker))

				return;

		}

	}

	set_checker_state(checker, alive);

}

/* Check if a vsg entry is in new data */

static virtual_server_group_entry_t *

vsge_exist(virtual_server_group_entry_t *vsg_entry, list l)

{

	element e;

	virtual_server_group_entry_t *vsge;

	for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {

		vsge = ELEMENT_DATA(e);

		if (VSGE_ISEQ(vsg_entry, vsge))

			return vsge;

	}

	return NULL;

}

/* Clear the diff vsge of old group */

static void

clear_diff_vsge(list old, list new, virtual_server_t * old_vs)

{

	virtual_server_group_entry_t *vsge, *new_vsge;

	element e;

	for (e = LIST_HEAD(old); e; ELEMENT_NEXT(e)) {

		vsge = ELEMENT_DATA(e);

		new_vsge = vsge_exist(vsge, new);

		if (new_vsge) {

			new_vsge->tcp_alive = vsge->tcp_alive;

			new_vsge->udp_alive = vsge->udp_alive;

			new_vsge->sctp_alive = vsge->sctp_alive;

			new_vsge->fwm4_alive = vsge->fwm4_alive;

			new_vsge->fwm6_alive = vsge->fwm6_alive;

			new_vsge->reloaded = true;

		}

		else {

			log_message(LOG_INFO, "VS [%s:%d:%u] in group %s no longer exists"

					    , inet_sockaddrtotrio(&vsge->addr, old_vs->service_type)

					    , vsge->range

					    , vsge->vfwmark

					    , old_vs->vsgname);

			ipvs_group_remove_entry(old_vs, vsge);

		}

	}

}

/* Clear the diff vsg of the old vs */

static void

clear_diff_vsg(virtual_server_t * old_vs, virtual_server_t * new_vs)

{

	virtual_server_group_t *old = old_vs->vsg;

	virtual_server_group_t *new = new_vs->vsg;

	/* Diff the group entries */

	clear_diff_vsge(old->addr_range, new->addr_range, old_vs);

	clear_diff_vsge(old->vfwmark, new->vfwmark, old_vs);

}

/* Check if a vs exist in new data and returns pointer to it */

static virtual_server_t*

vs_exist(virtual_server_t * old_vs)

{

	element e;

	list l = check_data->vs;

	virtual_server_t *vs;

	if (LIST_ISEMPTY(l))

		return NULL;

	for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {

		vs = ELEMENT_DATA(e);

		if (VS_ISEQ(old_vs, vs))

			return vs;

	}

	return NULL;

}

/* Check if rs is in new vs data */

static real_server_t *

rs_exist(real_server_t * old_rs, list l)

{

	element e;

	real_server_t *rs;

	if (LIST_ISEMPTY(l))

		return NULL;

	for (e = LIST_HEAD(l); e; ELEMENT_NEXT(e)) {

		rs = ELEMENT_DATA(e);

		if (RS_ISEQ(rs, old_rs))

			return rs;

	}

	return NULL;

}

static void

migrate_checkers(real_server_t *old_rs, real_server_t *new_rs, list old_checkers_queue)

{

	list l;

	element e, e1;

	checker_t *old_c, *new_c;

	l = alloc_list(NULL, NULL);

	LIST_FOREACH(old_checkers_queue, old_c, e) {

		if (old_c->rs == old_rs)

			list_add(l, old_c);

	}

	if (!LIST_ISEMPTY(l)) {

		LIST_FOREACH(checkers_queue, new_c, e) {

			if (new_c->rs != new_rs || !new_c->compare)

				continue;

			LIST_FOREACH(l, old_c, e1) {

				if (old_c->compare == new_c->compare && new_c->compare(old_c, new_c)) {

					/* Update status if different */

					if (old_c->is_up != new_c->is_up)

						set_checker_state(new_c, old_c->is_up);

					/* Transfer some other state flags */

					new_c->has_run = old_c->has_run;

					new_c->retry_it = old_c->retry_it;

					break;

				}

			}

		}

		if (!new_rs->num_failed_checkers)

			SET_ALIVE(new_rs);

	}

	free_list(&l);

}

/* Clear the diff rs of the old vs */

static void

clear_diff_rs(virtual_server_t *old_vs, virtual_server_t *new_vs, list old_checkers_queue)

{

	element e;

	real_server_t *rs, *new_rs;

	list rs_to_remove;

	/* If old vs didn't own rs then nothing return */

	if (LIST_ISEMPTY(old_vs->rs))

		return;

	/* remove RS from old vs which are not found in new vs */

	rs_to_remove = alloc_list (NULL, NULL);

	LIST_FOREACH(old_vs->rs, rs, e) {

		new_rs = rs_exist(rs, new_vs->rs);

		if (!new_rs) {

			log_message(LOG_INFO, "service %s no longer exist"

					    , FMT_RS(rs, old_vs));

			list_add (rs_to_remove, rs);

		} else {

			/*

			 * We reflect the previous alive

			 * flag value to not try to set

			 * already set IPVS rule.

			 */

			if (new_rs->alive)

				new_rs->alive = rs->alive;

			new_rs->set = rs->set;

			new_rs->weight = rs->weight;

			new_rs->pweight = rs->iweight;

			new_rs->reloaded = true;

			/*

			 * We must migrate the state of the old checkers.

			 * If we do not, the new RS is in a state where it’s reported

			 * as down with no check failed. As a result, the server will never

			 * be put back up when it’s alive again in check_tcp.c#83 because

			 * of the check that put a rs up only if it was not previously up.

			 * For alpha mode checkers, if it was up, we don't need another

			 * success to say it is now up.

			 */

			migrate_checkers(rs, new_rs, old_checkers_queue);

		}

	}

	clear_service_rs(old_vs, rs_to_remove, false);

	free_list(&rs_to_remove);

}

/* clear sorry server, but only if changed */

static void

clear_diff_s_srv(virtual_server_t *old_vs, real_server_t *new_rs)

{

	real_server_t *old_rs = old_vs->s_svr;

	if (!old_rs)

		return;

	if (new_rs && RS_ISEQ(old_rs, new_rs)) {

		/* which fields are really used on s_svr? */

		new_rs->alive = old_rs->alive;

		new_rs->set = old_rs->set;

		new_rs->weight = old_rs->weight;

		new_rs->pweight = old_rs->iweight;

		new_rs->reloaded = true;

	}

	else {

		if (old_rs->inhibit) {

			if (!ISALIVE(old_rs) && old_rs->set)

				SET_ALIVE(old_rs);

			old_rs->inhibit = 0;

		}

		if (ISALIVE(old_rs)) {

			log_message(LOG_INFO, "Removing sorry server %s from VS %s"

					    , FMT_RS(old_rs, old_vs)

					    , FMT_VS(old_vs));

			ipvs_cmd(LVS_CMD_DEL_DEST, old_vs, old_rs);

		}

	}

}

/* When reloading configuration, remove negative diff entries

 * and copy status of existing entries to the new ones */

void

clear_diff_services(list old_checkers_queue)

{

	element e;

	virtual_server_t *vs, *new_vs;

	/* Remove diff entries from previous IPVS rules */

	LIST_FOREACH(old_check_data->vs, vs, e) {

		/*

		 * Try to find this vs into the new conf data

		 * reloaded.

		 */

		new_vs = vs_exist(vs);

		if (!new_vs) {

			if (vs->vsgname)

				log_message(LOG_INFO, "Removing Virtual Server Group [%s]", vs->vsgname);

			else

				log_message(LOG_INFO, "Removing Virtual Server %s", FMT_VS(vs));

			/* Clear VS entry */

			clear_service_vs(vs, false);

		} else {