[secnet] / transform-common.h

/*
 * This file is part of secnet.
 * See README for full list of copyright holders.
 *
 * secnet 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 d of the License, or
 * (at your option) any later version.
 * 
 * secnet 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
 * version 3 along with secnet; if not, see
 * https://www.gnu.org/licenses/gpl.html.
 */

#ifndef TRANSFORM_COMMON_H
#define TRANSFORM_COMMON_H

#include "magic.h"

#define KEYED_CHECK do{				\
	if (!ti->keyed) {			\
	    *errmsg="transform unkeyed";	\
	    return 1;				\
	}					\
    }while(0)

#define RECVBITMAP_SIZE 32
typedef uint32_t recvbitmap_type;

#define SEQNUM_CHECK(seqnum, p) do{				\
	uint32_t skew=seqnum-ti->lastrecvseq;			\
	if (skew<0x8fffffff) {					\
	    /* Ok */						\
	    ti->lastrecvseq=seqnum;				\
	    if (skew < RECVBITMAP_SIZE)				\
                ti->recvbitmap <<= skew;			\
            else						\
                ti->recvbitmap=0;				\
            skew=0;						\
	} else if ((0-skew)<(p)->max_seq_skew) {		\
	    /* Ok */						\
	} else {						\
	    /* Too much skew */					\
	    *errmsg="seqnum: too much skew";			\
	    return 2;						\
	}							\
	if ((p)->dedupe) {					\
	    recvbitmap_type recvbit=(uint32_t)1 << skew;	\
	    if (ti->recvbitmap & recvbit) {			\
		*errmsg="seqnum: duplicate";			\
		return 2;					\
	    }							\
	    ti->recvbitmap |= recvbit;				\
	}							\
    }while(0)

#define SEQNUM_KEYED_FIELDS						\
    uint32_t sendseq;							\
    uint32_t lastrecvseq;						\
    recvbitmap_type recvbitmap; /* 1<<0 is lastrecvseq (i.e., most recent) */ \
    bool_t keyed

#define SEQNUM_KEYED_INIT(initlastrecvseq,initsendseq)	\
    (ti->lastrecvseq=(initlastrecvseq),			\
     ti->sendseq=(initsendseq),				\
     ti->recvbitmap=0,					\
     ti->keyed=True)

#define TRANSFORM_VALID				\
    static bool_t transform_valid(void *sst)	\
    {						\
	struct transform_inst *ti=sst;		\
						\
	return ti->keyed;			\
    }

#define TRANSFORM_DESTROY				\
    static void transform_destroy(void *sst)		\
    {							\
	struct transform_inst *st=sst;			\
							\
	FILLZERO(*st); /* Destroy key material */	\
	free(st);					\
    }

#define SET_CAPAB_TRANSFORMNUM(def) do{					\
        st->ops.capab_transformnum=dict_read_number(dict, "capab-num",	\
                                     False, "transform", loc, (def));	\
        if (st->ops.capab_transformnum > CAPAB_TRANSFORMNUM_MAX)	\
	    cfgfatal(loc,"transform","capab-num out of range 0..%d\n",	\
		     CAPAB_TRANSFORMNUM_MAX);				\
    }while(0)

#define TRANSFORM_CREATE_CORE				\
	struct transform_inst *ti;			\
	NEW(ti);					\
	/* mlock XXX */					\
	ti->ops.st=ti;					\
	ti->ops.setkey=transform_setkey;		\
	ti->ops.valid=transform_valid;			\
	ti->ops.delkey=transform_delkey;		\
	ti->ops.forwards=transform_forward;		\
	ti->ops.reverse=transform_reverse;		\
	ti->ops.destroy=transform_destroy;		\
	ti->keyed=False;

#define SEQNUM_PARAMS_FIELDS			\
    uint32_t max_seq_skew;			\
    bool_t dedupe;

#define SEQNUM_PARAMS_INIT(dict,p,desc,loc)				\
    (p)->max_seq_skew=dict_read_number((dict), "max-sequence-skew",	\
					False, (desc), (loc), 10);	\
    bool_t can_dedupe=(p)->max_seq_skew < RECVBITMAP_SIZE;		\
    (p)->dedupe=dict_read_bool((dict), "dedupe",			\
			       False,(desc),(loc), can_dedupe);		\
    if ((p)->dedupe && !can_dedupe)					\
	cfgfatal(loc,"transform",					\
                 "cannot dedupe with max-sequence-skew>=32");		\
    else (void)0

#endif /*TRANSFORM_COMMON_H*/
Commit	Line	Data
c215a4bc IJ	1	/*
	2	* This file is part of secnet.
	3	* See README for full list of copyright holders.
	4	*
	5	* secnet is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version d of the License, or
	8	* (at your option) any later version.
	9	*
	10	* secnet is distributed in the hope that it will be useful, but
	11	* WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* version 3 along with secnet; if not, see
	17	* https://www.gnu.org/licenses/gpl.html.
	18	*/
92a7d254 IJ	19
	20	#ifndef TRANSFORM_COMMON_H
	21	#define TRANSFORM_COMMON_H
	22
5b5f297f IJ	23	#include "magic.h"
5b5f297f IJ	24
92a7d254 IJ	25	#define KEYED_CHECK do{ \
	26	if (!ti->keyed) { \
	27	*errmsg="transform unkeyed"; \
	28	return 1; \
	29	} \
	30	}while(0)
	31
83692003 IJ	32	#define RECVBITMAP_SIZE 32
	33	typedef uint32_t recvbitmap_type;
	34
	35	#define SEQNUM_CHECK(seqnum, p) do{ \
	36	uint32_t skew=seqnum-ti->lastrecvseq; \
	37	if (skew<0x8fffffff) { \
	38	/* Ok */ \
	39	ti->lastrecvseq=seqnum; \
	40	if (skew < RECVBITMAP_SIZE) \
	41	ti->recvbitmap <<= skew; \
	42	else \
	43	ti->recvbitmap=0; \
	44	skew=0; \
	45	} else if ((0-skew)<(p)->max_seq_skew) { \
	46	/* Ok */ \
	47	} else { \
	48	/* Too much skew */ \
	49	*errmsg="seqnum: too much skew"; \
	50	return 2; \
	51	} \
	52	if ((p)->dedupe) { \
	53	recvbitmap_type recvbit=(uint32_t)1 << skew; \
	54	if (ti->recvbitmap & recvbit) { \
	55	*errmsg="seqnum: duplicate"; \
	56	return 2; \
	57	} \
	58	ti->recvbitmap \|= recvbit; \
	59	} \
92a7d254 IJ	60	}while(0)
92a7d254 IJ	61
35d30aa3 IJ	62	#define SEQNUM_KEYED_FIELDS \
	63	uint32_t sendseq; \
	64	uint32_t lastrecvseq; \
83692003	65	recvbitmap_type recvbitmap; /* 1<<0 is lastrecvseq (i.e., most recent) */ \
35d30aa3 IJ	66	bool_t keyed
	67
	68	#define SEQNUM_KEYED_INIT(initlastrecvseq,initsendseq) \
	69	(ti->lastrecvseq=(initlastrecvseq), \
	70	ti->sendseq=(initsendseq), \
83692003	71	ti->recvbitmap=0, \
35d30aa3 IJ	72	ti->keyed=True)
35d30aa3 IJ	73
92a7d254 IJ	74	#define TRANSFORM_VALID \
	75	static bool_t transform_valid(void *sst) \
	76	{ \
	77	struct transform_inst *ti=sst; \
	78	\
	79	return ti->keyed; \
	80	}
	81
	82	#define TRANSFORM_DESTROY \
	83	static void transform_destroy(void *sst) \
	84	{ \
	85	struct transform_inst *st=sst; \
	86	\
	87	FILLZERO(st); / Destroy key material */ \
	88	free(st); \
	89	}
	90
5b5f297f IJ	91	#define SET_CAPAB_TRANSFORMNUM(def) do{ \
5b5f297f IJ	92	st->ops.capab_transformnum=dict_read_number(dict, "capab-num", \
35d30aa3	93	False, "transform", loc, (def)); \
5b5f297f IJ	94	if (st->ops.capab_transformnum > CAPAB_TRANSFORMNUM_MAX) \
	95	cfgfatal(loc,"transform","capab-num out of range 0..%d\n", \
	96	CAPAB_TRANSFORMNUM_MAX); \
	97	}while(0)
	98
92a7d254 IJ	99	#define TRANSFORM_CREATE_CORE \
92a7d254 IJ	100	struct transform_inst *ti; \
952f601f	101	NEW(ti); \
92a7d254 IJ	102	/* mlock XXX */ \
	103	ti->ops.st=ti; \
	104	ti->ops.setkey=transform_setkey; \
	105	ti->ops.valid=transform_valid; \
	106	ti->ops.delkey=transform_delkey; \
	107	ti->ops.forwards=transform_forward; \
	108	ti->ops.reverse=transform_reverse; \
	109	ti->ops.destroy=transform_destroy; \
	110	ti->keyed=False;
	111
35d30aa3	112	#define SEQNUM_PARAMS_FIELDS \
83692003 IJ	113	uint32_t max_seq_skew; \
83692003 IJ	114	bool_t dedupe;
35d30aa3 IJ	115
	116	#define SEQNUM_PARAMS_INIT(dict,p,desc,loc) \
	117	(p)->max_seq_skew=dict_read_number((dict), "max-sequence-skew", \
83692003 IJ	118	False, (desc), (loc), 10); \
	119	bool_t can_dedupe=(p)->max_seq_skew < RECVBITMAP_SIZE; \
	120	(p)->dedupe=dict_read_bool((dict), "dedupe", \
	121	False,(desc),(loc), can_dedupe); \
	122	if ((p)->dedupe && !can_dedupe) \
	123	cfgfatal(loc,"transform", \
	124	"cannot dedupe with max-sequence-skew>=32"); \
	125	else (void)0
35d30aa3	126
92a7d254	127	#endif /TRANSFORM_COMMON_H/