fwsync/driver/fwsync.c - diff

Return to fwsync.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / fwsync / driver

Diff for /fwsync/driver/fwsync.c between versions 1.8 and 1.12.2.2

version 1.8, 2022/08/10 00:03:49	version 1.12.2.2, 2022/08/26 14:40:32
Line 1	Line 1
/*************************************************************************	/*-
* (C) 2022 CloudSigma AG - Sofia/Bulgaria	* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
* by Michael Pounov <misho@elwix.org>	*
**************************************************************************/	* Copyright (c) 2022 Michael Pounov <misho@elwix.org>, CloudSigma AG
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	*/
#include "fwsync.h"	#include "fwsync.h"


Line 37 fwsync_edge_proc(void *arg)	Line 59 fwsync_edge_proc(void *arg)
return;	return;
}	}

printf("%u...-> %s version=%c\n", m->m_len, m->m_data, pkt->fws_version);

switch (pkt->fws_version) {	switch (pkt->fws_version) {
case FWS_PKTVER_STATE:	case FWS_PKTVER_STATE:
fwsync_add_state(pkt);	fwsync_add_state(pkt);
Line 164 fwsync_destroy(struct ip_fw_chain *ch, ip_fw3_opheader	Line 184 fwsync_destroy(struct ip_fw_chain *ch, ip_fw3_opheader

n = (int*) (oh + 1);	n = (int*) (oh + 1);
if (*n & CFG_SYNC_EDGE) {	if (*n & CFG_SYNC_EDGE) {
	if (fws_ctx.config & CTX_EDGE_ONLINE) {
	ipfw_unregister_state_sync();
	ipfw_unregister_alias_sync();
	}

	callout_drain(&fws_co);

fws_cfg.cfg.on &= ~CFG_SYNC_EDGE;	fws_cfg.cfg.on &= ~CFG_SYNC_EDGE;
fws_cfg.cfg.edge = 0;	fws_cfg.cfg.edge = 0;
fws_cfg.cfg.addrs = 0;	fws_cfg.cfg.addrs = 0;
memset(fws_cfg.cfg_addr, 0, sizeof fws_cfg.cfg_addr[0]);	memset(fws_cfg.cfg_addr, 0, sizeof fws_cfg.cfg_addr[0]);

if (fws_ctx.config & CTX_EDGE_ONLINE) {	soshutdown(fws_ctx.sockz[CFG_SYNC_ADDR_EDGE], SHUT_RD);
callout_drain(&fws_co);	soclose(fws_ctx.sockz[CFG_SYNC_ADDR_EDGE]);
ipfw_unregister_state_sync();
soshutdown(fws_ctx.sockz[CFG_SYNC_ADDR_EDGE], SHUT_RD);
soclose(fws_ctx.sockz[CFG_SYNC_ADDR_EDGE]);
}
}	}
if (*n & CFG_SYNC_COLLECTOR) {	if (*n & CFG_SYNC_COLLECTOR) {
if (fws_ctx.config & (CTX_COLLECTOR_1_ONLINE \| CTX_COLLECTOR_2_ONLINE)) {	if (fws_ctx.config & (CTX_COLLECTOR_1_ONLINE \| CTX_COLLECTOR_2_ONLINE)) {
Line 197 fwsync_destroy(struct ip_fw_chain *ch, ip_fw3_opheader	Line 220 fwsync_destroy(struct ip_fw_chain *ch, ip_fw3_opheader

fws_ctx.config ^= fws_ctx.config;	fws_ctx.config ^= fws_ctx.config;

	memset(&fws_acct, 0, sizeof fws_acct);

return 0;	return 0;
}	}

Line 241 fwsync_get_cfg(struct ip_fw_chain *ch, ip_fw3_opheader	Line 266 fwsync_get_cfg(struct ip_fw_chain *ch, ip_fw3_opheader
int	int
fwsync_list(struct ip_fw_chain ch, ip_fw3_opheader op3, struct sockopt_data *sd)	fwsync_list(struct ip_fw_chain ch, ip_fw3_opheader op3, struct sockopt_data *sd)
{	{
	ipfw_obj_header *oh;
	struct ipfw_sync_cfg *ucfg;
	size_t sz;

DTRACE();	DTRACE();

	sz = sizeof(oh) + sizeof(ucfg);
	/* Check minimum header size */
	if (sd->valsize < sz)
	return (EINVAL);

	oh = (struct _ipfw_obj_header*) ipfw_get_sopt_header(sd, sz);

	/* Basic length checks for TLVs */
	if (oh->ntlv.head.length != sizeof(oh->ntlv))
	return (EINVAL);

	ucfg = (struct ipfw_sync_cfg*) (oh + 1);

	/* Check if name is properly terminated */
	if (strnlen(ucfg->name, sizeof(ucfg->name)) == sizeof(ucfg->name))
	return (EINVAL);

	ucfg->mode = 0;
	if (fws_cfg.cfg.edge)
	ucfg->mode \|= CFG_SYNC_EDGE;
	if (fws_cfg.cfg.collector)
	ucfg->mode \|= CFG_SYNC_COLLECTOR;
	ucfg->addrs = 2;
	memcpy(ucfg->addr[0].ip6.sin6_addr.s6_addr, &fws_acct.states[0], sizeof(uint64_t));
	memcpy(ucfg->addr[0].ip6.sin6_addr.s6_addr + 8, &fws_acct.states[1], sizeof(uint64_t));
	memcpy(ucfg->addr[1].ip6.sin6_addr.s6_addr, &fws_acct.aliases[0], sizeof(uint64_t));
	memcpy(ucfg->addr[1].ip6.sin6_addr.s6_addr + 8, &fws_acct.aliases[1], sizeof(uint64_t));

return 0;	return 0;
}	}

Line 273 fwsync_start(struct ip_fw_chain ch, ip_fw3_opheader	Line 330 fwsync_start(struct ip_fw_chain ch, ip_fw3_opheader

callout_reset(&fws_co, hz, fwsync_edge_proc, NULL);	callout_reset(&fws_co, hz, fwsync_edge_proc, NULL);

if (!(fws_ctx.config & CTX_EDGE_ONLINE))	if (!(fws_ctx.config & CTX_EDGE_ONLINE)) {
ipfw_register_state_sync(fwsync_state_sync);	ipfw_register_state_sync(fwsync_state_sync);
	ipfw_register_alias_sync(fwsync_alias_sync);
	}

fws_ctx.config \|= CTX_EDGE_ONLINE;	fws_ctx.config \|= CTX_EDGE_ONLINE;
}	}
Line 333 fwsync_stop(struct ip_fw_chain ch, ip_fw3_opheader o	Line 392 fwsync_stop(struct ip_fw_chain ch, ip_fw3_opheader o
callout_drain(&fws_co);	callout_drain(&fws_co);

ipfw_unregister_state_sync();	ipfw_unregister_state_sync();
	ipfw_unregister_alias_sync();
}	}

if ((*n & CFG_SYNC_COLLECTOR) && (fws_ctx.config & CTX_COLLECTOR_2_ONLINE))	if ((*n & CFG_SYNC_COLLECTOR) && (fws_ctx.config & CTX_COLLECTOR_2_ONLINE))

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.8
changed lines
	Added in v.1.12.2.2