static int
cmp_orig_l4proto(const struct nf_conntrack *ct1,
const struct nf_conntrack *ct2,
unsigned int flags)
{
if (ct1->head.orig.protonum != ct2->head.orig.protonum)
return 0;
switch(ct1->head.orig.protonum) {
case IPPROTO_ICMP:
case IPPROTO_ICMPV6:
if (!__cmp(ATTR_ICMP_ID, ct1, ct2, flags, cmp_icmp_id))
return 0;
if (!__cmp(ATTR_ICMP_CODE, ct1, ct2, flags, cmp_icmp_code))
return 0;
if (!__cmp(ATTR_ICMP_TYPE, ct1, ct2, flags, cmp_icmp_type))
return 0;
break;
case IPPROTO_TCP:
case IPPROTO_UDP:
case IPPROTO_UDPLITE:
case IPPROTO_DCCP:
case IPPROTO_SCTP:
if (!__cmp(ATTR_ORIG_PORT_SRC, ct1, ct2,
flags, cmp_orig_port_src))
return 0;
if (!__cmp(ATTR_ORIG_PORT_DST, ct1, ct2,
flags, cmp_orig_port_dst))
return 0;
break;
}
return 1;
}
template<class A, class B> typename A::for_in_unit ___max(int, B (*key)(typename A::for_in_unit), A *iter) {
typename A::for_in_unit max;
B maxkey, maxkey2;
max = __zero<typename A::for_in_unit>();
maxkey = __zero<B>();
maxkey2 = __zero<B>();;
int first = 1;
typename A::for_in_unit e;
typename A::for_in_loop __3;
int __2;
A *__1;
FOR_IN(e,iter,1,2,3)
if(key) {
maxkey2 = key(e);
if(first || __cmp(maxkey2, maxkey) == 1) {
max = e;
maxkey = maxkey2;
}
} else if(first || __cmp(e, max) == 1)
max = e;
if(first)
first = 0;
END_FOR
return max;
}
template<class A, class B> typename A::for_in_unit ___min(int, B (*key)(typename A::for_in_unit), A *iter) {
typename A::for_in_unit min;
B minkey, minkey2;
min = __zero<typename A::for_in_unit>();
minkey = __zero<B>();
minkey2 = __zero<B>();
int first = 1;
typename A::for_in_unit e;
typename A::for_in_loop __3;
int __2;
A *__1;
FOR_IN(e,iter,1,2,3)
if(key) {
minkey2 = key(e);
if(first || __cmp(minkey2, minkey) == -1) {
min = e;
minkey = minkey2;
}
} else if(first || __cmp(e, min) == -1)
min = e;
if(first)
first = 0;
END_FOR
return min;
}
static int cmp_meta(const struct nf_conntrack *ct1,
const struct nf_conntrack *ct2,
unsigned int flags)
{
if (!__cmp(ATTR_ID, ct1, ct2, flags, cmp_id))
return 0;
if (!__cmp(ATTR_MARK, ct1, ct2, flags, cmp_mark))
return 0;
if (!__cmp(ATTR_TIMEOUT, ct1, ct2, flags, cmp_timeout))
return 0;
if (!__cmp(ATTR_STATUS, ct1, ct2, flags, cmp_status))
return 0;
if (!__cmp(ATTR_TCP_STATE, ct1, ct2, flags, cmp_tcp_state))
return 0;
if (!__cmp(ATTR_SCTP_STATE, ct1, ct2, flags, cmp_sctp_state))
return 0;
if (!__cmp(ATTR_DCCP_STATE, ct1, ct2, flags, cmp_dccp_state))
return 0;
if (!__cmp(ATTR_ZONE, ct1, ct2, flags, cmp_zone))
return 0;
if (!__cmp(ATTR_SECCTX, ct1, ct2, flags, cmp_secctx))
return 0;
return 1;
}
static void __cmpTest(int only)
{
if (only && (1 != only)) {
return;
}
std::cout << "\n****************************" << __func__ << "()\n";
__cmp("2016-09-01 00:00:00", "2016-09-02 00:00:00", -86400);
__cmp("2016-09-02 00:00:00", "2016-09-02 00:00:00", 0);
__cmp("2016-09-02 00:00:00", "2016-09-01 00:00:00", 86400);
__microCmp("2016-09-01 00:00:00.222222", "2016-09-02 00:00:00.111111", -86399999888);
__microCmp("2016-09-01 00:00:00.222222", "2016-09-01 00:00:00.222222", 0);
__microCmp("2016-09-02 00:00:00.111111", "2016-09-01 00:00:00.222222", 86399999888);
}
template<class T> T ___max(int n, int key, T a, T b, T c, ...) {
T m = ___max(2, key, ___max(2, key, a, b), c);
va_list ap;
va_start(ap, c);
for(int i=0; i<n-3; i++) {
T t = va_arg(ap, T);
if(__cmp(t,m)==1) m=t;
}
va_end(ap);
return m;
}
template<class T, class B> T ___max(int n, B (*key)(T), T a, T b, T c, ...) {
T m = ___max(2, key, ___max(2, key, a, b), c);
B maxkey = key(m);
va_list ap;
va_start(ap, c);
for(int i=0; i<n-3; i++) {
T t = va_arg(ap, T);
if(__cmp(key(t),maxkey)==1)
m=t;
}
va_end(ap);
return m;
}
/* XXX copy-pasto */
template<class A, class B> typename A::for_in_unit ___max(int, pycall1<B, typename A::for_in_unit> *key, A *iter) {
typename A::for_in_unit max;
B maxkey, maxkey2;
int first = 1;
typename A::for_in_unit e;
typename A::for_in_loop __3;
int __2;
A *__1;
FOR_IN(e,iter,1,2,3)
if(key) {
maxkey2 = key->__call__(e);
if(first || __cmp(maxkey2, maxkey) == 1) {
max = e;
maxkey = maxkey2;
}
} else if(first || __cmp(e, max) == 1)
max = e;
if(first)
first = 0;
END_FOR
return max;
}
template <class A> __ss_int bisect_left(list<A> *a, A x, __ss_int lo, __ss_int hi) {
__ss_int mid;
__pos_check(lo, hi);
while((lo<hi)) {
mid = (lo+hi)/2;
if (__cmp(a->units[mid], x)==-1) {
lo = (mid+1);
}
else {
hi = mid;
}
}
return lo;
}
template <class A> void *insort_left(list<A> *a, A x, __ss_int lo, __ss_int hi) {
__ss_int mid;
__pos_check(lo, hi);
while((lo<hi)) {
mid = (lo+hi)/2;
if (__cmp(a->units[mid], x)==-1) {
lo = (mid+1);
}
else {
hi = mid;
}
}
a->insert(lo, x);
return NULL;
}
static int cmp_repl(const struct nf_conntrack *ct1,
const struct nf_conntrack *ct2,
unsigned int flags)
{
if (!__cmp(ATTR_REPL_L3PROTO, ct1, ct2, flags, cmp_repl_l3proto))
return 0;
if (!__cmp(ATTR_REPL_L4PROTO, ct1, ct2, flags, cmp_repl_l4proto))
return 0;
if (!__cmp(ATTR_REPL_IPV4_SRC, ct1, ct2, flags, cmp_repl_ipv4_src))
return 0;
if (!__cmp(ATTR_REPL_IPV4_DST, ct1, ct2, flags, cmp_repl_ipv4_dst))
return 0;
if (!__cmp(ATTR_REPL_IPV6_SRC, ct1, ct2, flags, cmp_repl_ipv6_src))
return 0;
if (!__cmp(ATTR_REPL_IPV6_DST, ct1, ct2, flags, cmp_repl_ipv6_dst))
return 0;
return 1;
}
int __cmp_orig(const struct nf_conntrack *ct1,
const struct nf_conntrack *ct2,
unsigned int flags)
{
if (!__cmp(ATTR_ORIG_L3PROTO, ct1, ct2, flags, cmp_orig_l3proto))
return 0;
if (!__cmp(ATTR_ORIG_L4PROTO, ct1, ct2, flags, cmp_orig_l4proto))
return 0;
if (!__cmp(ATTR_ORIG_IPV4_SRC, ct1, ct2, flags, cmp_orig_ipv4_src))
return 0;
if (!__cmp(ATTR_ORIG_IPV4_DST, ct1, ct2, flags, cmp_orig_ipv4_dst))
return 0;
if (!__cmp(ATTR_ORIG_IPV6_SRC, ct1, ct2, flags, cmp_orig_ipv6_src))
return 0;
if (!__cmp(ATTR_ORIG_IPV6_DST, ct1, ct2, flags, cmp_orig_ipv6_dst))
return 0;
return 1;
}
template<class A, class B> __ss_int tuple2<A, B>::__cmp__(pyobj *p) {
if (!p) return 1;
tuple2<A,B> *b = (tuple2<A,B> *)p;
if(int c = __cmp(first, b->first)) return c;
return __cmp(second, b->second);
}
template<class T> inline T ___max(int, int, T a, T b) { return (__cmp(a, b)==1)?a:b; }
template<class T, class B> inline T ___max(int, B (*key)(T), T a, T b) { return (__cmp(key(a), key(b))==1)?a:b; }
static bool
dexkv_matches_p(const_dexkv_t dkv, struct dt_dt_s d)
{
signed int cmp;
bool res;
if (dkv->sp.spfl == DT_SPFL_N_STD) {
if ((cmp = __cmp(d, dkv->d)) == -2) {
return false;
}
switch (dkv->op) {
case OP_UNK:
case OP_EQ:
res = cmp == 0;
break;
case OP_LT:
res = cmp < 0;
break;
case OP_LE:
res = cmp <= 0;
break;
case OP_GT:
res = cmp > 0;
break;
case OP_GE:
res = cmp >= 0;
break;
case OP_NE:
res = cmp != 0;
break;
case OP_TRUE:
res = true;
break;
default:
res = false;
break;
}
return res;
}
/* otherwise it's stuff that uses the S slot */
switch (dkv->sp.spfl) {
case DT_SPFL_N_YEAR:
cmp = dt_get_year(d.d);
break;
case DT_SPFL_N_MON:
case DT_SPFL_S_MON:
cmp = dt_get_mon(d.d);
break;
case DT_SPFL_N_DCNT_MON:
cmp = dt_get_mday(d.d);
break;
case DT_SPFL_N_DCNT_WEEK:
case DT_SPFL_S_WDAY:
cmp = dt_get_wday(d.d);
break;
case DT_SPFL_N_WCNT_MON:
/* exotic function, needs extern'ing */
cmp = /*dt_get_count(d)*/0;
break;
case DT_SPFL_N_DCNT_YEAR:
cmp = dt_get_yday(d.d);
break;
case DT_SPFL_N_WCNT_YEAR:
/* %C/%W week count */
switch (d.d.typ) {
case DT_YMD:
if (dkv->sp.cnt_weeks_iso) {
cmp = __ymd_get_wcnt_iso(d.d.ymd);
} else {
cmp = __ymd_get_wcnt(
d.d.ymd, dkv->sp.cnt_wdays_from);
}
break;
case DT_YMCW:
cmp = __ymcw_get_yday(d.d.ymcw);
break;
default:
cmp = 0;
break;
}
break;
case DT_SPFL_N_STD:
default:
return false;
}
/* now do the actual comparison */
switch (dkv->op) {
case OP_EQ:
res = dkv->s == cmp;
break;
case OP_LT:
res = dkv->s < cmp;
break;
case OP_LE:
res = dkv->s <= cmp;
break;
case OP_GT:
res = dkv->s > cmp;
break;
case OP_GE:
res = dkv->s >= cmp;
break;
case OP_NE:
res = dkv->s != cmp;
break;
case OP_TRUE:
res = true;
break;
default:
case OP_UNK:
res = false;
break;
}
return res;
}
