transform-common.h

   1
   2 #ifndef TRANSFORM_COMMON_H
   3 #define TRANSFORM_COMMON_H
   4
   5 #include "magic.h"
   6
   7 #define KEYED_CHECK do{                         \
   8         if (!ti->keyed) {                       \
   9             *errmsg="transform unkeyed";        \
  10             return 1;                           \
  11         }                                       \
  12     }while(0)
  13
  14 #define SEQNUM_CHECK(seqnum, p) do{                     \
  15         uint32_t skew=seqnum-ti->lastrecvseq;           \
  16         if (skew<0x8fffffff) {                          \
  17             /* Ok */                                    \
  18             ti->lastrecvseq=seqnum;                     \
  19             if (skew < 32)                              \
  20                 ti->recvbitmap <<= skew;                \
  21             else                                        \
  22                 ti->recvbitmap=0;                       \
  23             skew=0;                                     \
  24         } else if ((0-skew)<(p)->max_seq_skew) {        \
  25             /* Ok */                                    \
  26         } else {                                        \
  27             /* Too much skew */                         \
  28             *errmsg="seqnum: too much skew";            \
  29             return 2;                                   \
  30         }                                               \
  31         if ((p)->dedupe) {                              \
  32             uint32_t recvbit=(uint32_t)1 << skew;       \
  33             if (ti->recvbitmap & recvbit) {             \
  34                 *errmsg="seqnum: duplicate";            \
  35                 return 2;                               \
  36             }                                           \
  37             ti->recvbitmap |= recvbit;                  \
  38         }                                               \
  39     }while(0)
  40
  41 #define SEQNUM_KEYED_FIELDS                                             \
  42     uint32_t sendseq;                                                   \
  43     uint32_t lastrecvseq;                                               \
  44     uint32_t recvbitmap; /* 1<<0 is lastrecvseq (i.e., most recent) */  \
  45     bool_t keyed
  46
  47 #define SEQNUM_KEYED_INIT(initlastrecvseq,initsendseq)  \
  48     (ti->lastrecvseq=(initlastrecvseq),                 \
  49      ti->sendseq=(initsendseq),                         \
  50      ti->recvbitmap=0,                                  \
  51      ti->keyed=True)
  52
  53 #define TRANSFORM_VALID                         \
  54     static bool_t transform_valid(void *sst)    \
  55     {                                           \
  56         struct transform_inst *ti=sst;          \
  57                                                 \
  58         return ti->keyed;                       \
  59     }
  60
  61 #define TRANSFORM_DESTROY                               \
  62     static void transform_destroy(void *sst)            \
  63     {                                                   \
  64         struct transform_inst *st=sst;                  \
  65                                                         \
  66         FILLZERO(*st); /* Destroy key material */       \
  67         free(st);                                       \
  68     }
  69
  70 #define SET_CAPAB_TRANSFORMNUM(def) do{                                 \
  71         st->ops.capab_transformnum=dict_read_number(dict, "capab-num",  \
  72                                      False, "transform", loc, def);     \
  73         if (st->ops.capab_transformnum > CAPAB_TRANSFORMNUM_MAX)        \
  74             cfgfatal(loc,"transform","capab-num out of range 0..%d\n",  \
  75                      CAPAB_TRANSFORMNUM_MAX);                           \
  76     }while(0)
  77
  78 #define TRANSFORM_CREATE_CORE                           \
  79         struct transform_inst *ti;                      \
  80         ti=safe_malloc(sizeof(*ti),"transform_create"); \
  81         /* mlock XXX */                                 \
  82         ti->ops.st=ti;                                  \
  83         ti->ops.setkey=transform_setkey;                \
  84         ti->ops.valid=transform_valid;                  \
  85         ti->ops.delkey=transform_delkey;                \
  86         ti->ops.forwards=transform_forward;             \
  87         ti->ops.reverse=transform_reverse;              \
  88         ti->ops.destroy=transform_destroy;              \
  89         ti->keyed=False;
  90
  91 #define SEQNUM_PARAMS_FIELDS                    \
  92     uint32_t max_seq_skew;                      \
  93     bool_t dedupe;
  94
  95 #define SEQNUM_PARAMS_INIT(dict,p,desc,loc)                             \
  96     (p)->max_seq_skew=dict_read_number((dict), "max-sequence-skew",     \
  97                                         False, (desc), (loc), 10);      \
  98     bool_t can_dedupe=(p)->max_seq_skew < 32;                           \
  99     (p)->dedupe=dict_read_bool((dict), "dedupe",                        \
 100                                False,(desc),(loc), can_dedupe);         \
 101     if ((p)->dedupe && !can_dedupe)                                     \
 102         cfgfatal(loc,"transform",                                       \
 103                  "cannot dedupe with max-sequence-skew>=32");           \
 104     else (void)0
 105
 106 #endif /*TRANSFORM_COMMON_H*/