mirror of https://github.com/bol-van/zapret/
bol-van
1 year ago
63 changed files with 1582 additions and 571 deletions
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -30,12 +30,7 @@ CUSTOM_SCRIPT="$ZAPRET_BASE/init.d/openwrt/custom" |
|||
IPSET_EXCLUDE="-m set ! --match-set nozapret" |
|||
IPSET_EXCLUDE6="-m set ! --match-set nozapret6" |
|||
|
|||
NFQWS_OPT_DESYNC_HTTP="${NFQWS_OPT_DESYNC_HTTP:-$NFQWS_OPT_DESYNC}" |
|||
NFQWS_OPT_DESYNC_HTTPS="${NFQWS_OPT_DESYNC_HTTPS:-$NFQWS_OPT_DESYNC}" |
|||
NFQWS_OPT_DESYNC_HTTP6="${NFQWS_OPT_DESYNC_HTTP6:-$NFQWS_OPT_DESYNC_HTTP}" |
|||
NFQWS_OPT_DESYNC_HTTPS6="${NFQWS_OPT_DESYNC_HTTPS6:-$NFQWS_OPT_DESYNC_HTTPS}" |
|||
NFQWS_OPT_DESYNC_QUIC6="${NFQWS_OPT_DESYNC_QUIC6:-$NFQWS_OPT_DESYNC_QUIC}" |
|||
|
|||
apply_unspecified_desync_modes |
|||
|
|||
|
|||
# can be multiple ipv6 outgoing interfaces |
|||
@ -60,6 +55,15 @@ network_find_wan6_all() |
|||
__network_ifstatus "$1" "" "[@.route[@.target='::' && [email protected]]].interface" "" 10 2>/dev/null && return |
|||
network_find_wan6 $1 |
|||
} |
|||
network_find_wanX_devices() |
|||
{ |
|||
# $1 - ip version: 4 or 6 |
|||
# $2 - variable to put result to |
|||
local ifaces |
|||
network_find_wan${1}_all ifaces |
|||
call_for_multiple_items network_get_device $2 "$ifaces" |
|||
} |
|||
|
|||
|
|||
dnat6_target() |
|||
{ |
|||
@ -87,25 +91,35 @@ set_route_localnet() |
|||
} |
|||
|
|||
|
|||
fw_nfqws_post_x() |
|||
fw_nfqws_prepost_x() |
|||
{ |
|||
# $1 - 1 - add, 0 - del |
|||
# $2 - filter |
|||
# $3 - queue number |
|||
# $4 - ip version : 4 or 6 |
|||
# $4 - 4/6 |
|||
# $5 - post/pre |
|||
|
|||
local ifaces DWAN |
|||
network_find_wan${4}_all ifaces |
|||
call_for_multiple_items network_get_device DWAN "$ifaces" |
|||
|
|||
[ -n "$DWAN" ] && _fw_nfqws_post${4} $1 "$2" $3 "$(unique $DWAN)" |
|||
[ -n "$DWAN" ] && _fw_nfqws_${5}${4} $1 "$2" $3 "$(unique $DWAN)" |
|||
} |
|||
fw_nfqws_post4() |
|||
{ |
|||
fw_nfqws_post_x $1 "$2" $3 4 |
|||
fw_nfqws_prepost_x $1 "$2" $3 4 post |
|||
} |
|||
fw_nfqws_post6() |
|||
{ |
|||
fw_nfqws_post_x $1 "$2" $3 6 |
|||
fw_nfqws_prepost_x $1 "$2" $3 6 post |
|||
} |
|||
fw_nfqws_pre4() |
|||
{ |
|||
fw_nfqws_prepost_x $1 "$2" $3 4 pre |
|||
} |
|||
fw_nfqws_pre6() |
|||
{ |
|||
fw_nfqws_prepost_x $1 "$2" $3 6 pre |
|||
} |
|||
fw_tpws_x() |
|||
{ |
|||
@ -146,10 +160,6 @@ list_nfqws_rules() |
|||
grep -E "NFQUEUE --queue-num $QNUM --queue-bypass|NFQUEUE --queue-num $(($QNUM+1)) --queue-bypass|NFQUEUE --queue-num $(($QNUM+2)) --queue-bypass|NFQUEUE --queue-num $(($QNUM+3)) --queue-bypass|NFQUEUE --queue-num $(($QNUM+10)) --queue-bypass|NFQUEUE --queue-num $(($QNUM+11)) --queue-bypass" | \ |
|||
sed -re 's/^-A POSTROUTING (.*) -j NFQUEUE.*$/\1/' -e "s/-m mark ! --mark $DESYNC_MARK\/$DESYNC_MARK//" |
|||
} |
|||
reverse_nfqws_rule() |
|||
{ |
|||
sed -e 's/-o /-i /g' -e 's/--dport /--sport /g' -e 's/--dports /--sports /g' -e 's/ dst$/ src/' -e 's/ dst / src /g' |
|||
} |
|||
apply_flow_offloading_enable_rule() |
|||
{ |
|||
# $1 = '' for ipv4, '6' for ipv6 |
|||
@ -171,14 +181,16 @@ apply_flow_offloading_exempt_rule() |
|||
} |
|||
flow_offloading_unexempt_v() |
|||
{ |
|||
ipt$1_del FORWARD -j forwarding_rule_zapret |
|||
# $1 = '' for ipv4, '6' for ipv6 |
|||
local DWAN |
|||
network_find_wanX_devices ${1:-4} DWAN |
|||
for i in $DWAN; do ipt$1_del FORWARD -o $i -j forwarding_rule_zapret ; done |
|||
ip$1tables -F forwarding_rule_zapret 2>/dev/null |
|||
ip$1tables -X forwarding_rule_zapret 2>/dev/null |
|||
} |
|||
flow_offloading_exempt_v() |
|||
{ |
|||
# $1 = '' for ipv4, '6' for ipv6 |
|||
|
|||
is_ipt_flow_offload_avail $1 || return 0 |
|||
|
|||
flow_offloading_unexempt_v $1 |
|||
@ -186,21 +198,19 @@ flow_offloading_exempt_v() |
|||
[ "$FLOWOFFLOAD" = 'software' -o "$FLOWOFFLOAD" = 'hardware' ] && { |
|||
ip$1tables -N forwarding_rule_zapret |
|||
|
|||
list_nfqws_rules $1 | |
|||
while read rule; do |
|||
apply_flow_offloading_exempt_rule "$1" $rule |
|||
done |
|||
|
|||
list_nfqws_rules $1 | grep -v "connbytes" | reverse_nfqws_rule | |
|||
# remove outgoing interface |
|||
list_nfqws_rules $1 | sed -re 's/-o +[^ ]+//g' | |
|||
while read rule; do |
|||
apply_flow_offloading_exempt_rule "$1" $rule |
|||
done |
|||
|
|||
apply_flow_offloading_enable_rule $1 |
|||
|
|||
ipt$1 FORWARD -j forwarding_rule_zapret |
|||
# only outgoing to WAN packets trigger flow offloading |
|||
local DWAN |
|||
network_find_wanX_devices ${1:-4} DWAN |
|||
for i in $DWAN; do ipt$1 FORWARD -o $i -j forwarding_rule_zapret; done |
|||
} |
|||
|
|||
return 0 |
|||
} |
|||
flow_offloading_exempt() |
|||
@ -252,3 +262,11 @@ nft_fw_nfqws_post6() |
|||
{ |
|||
_nft_fw_nfqws_post6 "$1" $2 always_apply_wan_filter |
|||
} |
|||
nft_fw_nfqws_pre4() |
|||
{ |
|||
_nft_fw_nfqws_pre4 "$1" $2 always_apply_wan_filter |
|||
} |
|||
nft_fw_nfqws_pre6() |
|||
{ |
|||
_nft_fw_nfqws_pre6 "$1" $2 always_apply_wan_filter |
|||
} |
|||
|
|||
@ -1,10 +1,11 @@ |
|||
#pragma once |
|||
|
|||
#include <stdbool.h> |
|||
#include "strpool.h" |
|||
#include "pools.h" |
|||
|
|||
bool AppendHostList(strpool **hostlist, char *filename); |
|||
bool LoadHostLists(strpool **hostlist, struct str_list_head *file_list); |
|||
bool NonEmptyHostlist(strpool **hostlist); |
|||
bool SearchHostList(strpool *hostlist, const char *host); |
|||
// return : true = apply fooling, false = do not apply
|
|||
bool HostlistCheck(strpool *hostlist, strpool *hostlist_exclude, const char *host); |
|||
bool HostlistCheck(strpool *hostlist, strpool *hostlist_exclude, const char *host, bool *excluded); |
|||
|
|||
@ -0,0 +1,152 @@ |
|||
#define _GNU_SOURCE |
|||
#include "pools.h" |
|||
#include <string.h> |
|||
#include <stdlib.h> |
|||
#include <stdio.h> |
|||
|
|||
#define DESTROY_STR_POOL(etype, ppool) \ |
|||
etype *elem, *tmp; \ |
|||
HASH_ITER(hh, *ppool, elem, tmp) { \ |
|||
free(elem->str); \ |
|||
HASH_DEL(*ppool, elem); \ |
|||
free(elem); \ |
|||
} |
|||
|
|||
#define ADD_STR_POOL(etype, ppool, keystr, keystr_len) \ |
|||
etype *elem; \ |
|||
if (!(elem = (etype*)malloc(sizeof(etype)))) \ |
|||
return false; \ |
|||
if (!(elem->str = malloc(keystr_len + 1))) \ |
|||
{ \ |
|||
free(elem); \ |
|||
return false; \ |
|||
} \ |
|||
memcpy(elem->str, keystr, keystr_len); \ |
|||
elem->str[keystr_len] = 0; \ |
|||
oom = false; \ |
|||
HASH_ADD_KEYPTR(hh, *ppool, elem->str, strlen(elem->str), elem); \ |
|||
if (oom) \ |
|||
{ \ |
|||
free(elem->str); \ |
|||
free(elem); \ |
|||
return false; \ |
|||
} |
|||
|
|||
|
|||
#undef uthash_nonfatal_oom |
|||
#define uthash_nonfatal_oom(elt) ut_oom_recover(elt) |
|||
static bool oom = false; |
|||
static void ut_oom_recover(void *elem) |
|||
{ |
|||
oom = true; |
|||
} |
|||
|
|||
// for not zero terminated strings
|
|||
bool StrPoolAddStrLen(strpool **pp, const char *s, size_t slen) |
|||
{ |
|||
ADD_STR_POOL(strpool, pp, s, slen) |
|||
return true; |
|||
} |
|||
// for zero terminated strings
|
|||
bool StrPoolAddStr(strpool **pp, const char *s) |
|||
{ |
|||
return StrPoolAddStrLen(pp, s, strlen(s)); |
|||
} |
|||
|
|||
bool StrPoolCheckStr(strpool *p, const char *s) |
|||
{ |
|||
strpool *elem; |
|||
HASH_FIND_STR(p, s, elem); |
|||
return elem != NULL; |
|||
} |
|||
|
|||
void StrPoolDestroy(strpool **pp) |
|||
{ |
|||
DESTROY_STR_POOL(strpool, pp) |
|||
} |
|||
|
|||
|
|||
|
|||
void HostFailPoolDestroy(hostfail_pool **pp) |
|||
{ |
|||
DESTROY_STR_POOL(hostfail_pool, pp) |
|||
} |
|||
hostfail_pool * HostFailPoolAdd(hostfail_pool **pp,const char *s,int fail_time) |
|||
{ |
|||
size_t slen = strlen(s); |
|||
ADD_STR_POOL(hostfail_pool, pp, s, slen) |
|||
elem->expire = time(NULL) + fail_time; |
|||
return elem; |
|||
} |
|||
hostfail_pool *HostFailPoolFind(hostfail_pool *p,const char *s) |
|||
{ |
|||
hostfail_pool *elem; |
|||
HASH_FIND_STR(p, s, elem); |
|||
return elem; |
|||
} |
|||
void HostFailPoolDel(hostfail_pool **p, hostfail_pool *elem) |
|||
{ |
|||
HASH_DEL(*p, elem); |
|||
free(elem); |
|||
} |
|||
void HostFailPoolPurge(hostfail_pool **pp) |
|||
{ |
|||
hostfail_pool *elem, *tmp; |
|||
time_t now = time(NULL); |
|||
HASH_ITER(hh, *pp, elem, tmp) |
|||
{ |
|||
if (now >= elem->expire) |
|||
{ |
|||
free(elem->str); |
|||
HASH_DEL(*pp, elem); |
|||
free(elem); |
|||
} |
|||
} |
|||
} |
|||
static time_t host_fail_purge_prev=0; |
|||
void HostFailPoolPurgeRateLimited(hostfail_pool **pp) |
|||
{ |
|||
time_t now = time(NULL); |
|||
// do not purge too often to save resources
|
|||
if (host_fail_purge_prev != now) |
|||
{ |
|||
HostFailPoolPurge(pp); |
|||
host_fail_purge_prev = now; |
|||
} |
|||
} |
|||
void HostFailPoolDump(hostfail_pool *p) |
|||
{ |
|||
hostfail_pool *elem, *tmp; |
|||
time_t now = time(NULL); |
|||
HASH_ITER(hh, p, elem, tmp) |
|||
printf("host=%s counter=%d time_left=%lld\n",elem->str,elem->counter,(long long int)elem->expire-now); |
|||
} |
|||
|
|||
|
|||
bool strlist_add(struct str_list_head *head, const char *filename) |
|||
{ |
|||
struct str_list *entry = malloc(sizeof(struct str_list)); |
|||
if (!entry) return false; |
|||
entry->str = strdup(filename); |
|||
if (!entry->str) |
|||
{ |
|||
free(entry); |
|||
return false; |
|||
} |
|||
LIST_INSERT_HEAD(head, entry, next); |
|||
return true; |
|||
} |
|||
static void strlist_entry_destroy(struct str_list *entry) |
|||
{ |
|||
if (entry->str) free(entry->str); |
|||
free(entry); |
|||
} |
|||
void strlist_destroy(struct str_list_head *head) |
|||
{ |
|||
struct str_list *entry; |
|||
while ((entry = LIST_FIRST(head))) |
|||
{ |
|||
LIST_REMOVE(entry, next); |
|||
strlist_entry_destroy(entry); |
|||
} |
|||
} |
|||
@ -0,0 +1,46 @@ |
|||
#pragma once |
|||
|
|||
#include <stdbool.h> |
|||
#include <ctype.h> |
|||
#include <sys/queue.h> |
|||
#include <time.h> |
|||
|
|||
//#define HASH_BLOOM 20
|
|||
#define HASH_NONFATAL_OOM 1 |
|||
#define HASH_FUNCTION HASH_BER |
|||
#include "uthash.h" |
|||
|
|||
typedef struct strpool { |
|||
char *str; /* key */ |
|||
UT_hash_handle hh; /* makes this structure hashable */ |
|||
} strpool; |
|||
|
|||
void StrPoolDestroy(strpool **pp); |
|||
bool StrPoolAddStr(strpool **pp,const char *s); |
|||
bool StrPoolAddStrLen(strpool **pp,const char *s,size_t slen); |
|||
bool StrPoolCheckStr(strpool *p,const char *s); |
|||
|
|||
struct str_list { |
|||
char *str; |
|||
LIST_ENTRY(str_list) next; |
|||
}; |
|||
LIST_HEAD(str_list_head, str_list); |
|||
|
|||
|
|||
typedef struct hostfail_pool { |
|||
char *str; /* key */ |
|||
int counter; /* value */ |
|||
time_t expire; /* when to expire record (unixtime) */ |
|||
UT_hash_handle hh; /* makes this structure hashable */ |
|||
} hostfail_pool; |
|||
|
|||
void HostFailPoolDestroy(hostfail_pool **pp); |
|||
hostfail_pool *HostFailPoolAdd(hostfail_pool **pp,const char *s,int fail_time); |
|||
hostfail_pool *HostFailPoolFind(hostfail_pool *p,const char *s); |
|||
void HostFailPoolDel(hostfail_pool **pp, hostfail_pool *elem); |
|||
void HostFailPoolPurge(hostfail_pool **pp); |
|||
void HostFailPoolPurgeRateLimited(hostfail_pool **pp); |
|||
void HostFailPoolDump(hostfail_pool *p); |
|||
|
|||
bool strlist_add(struct str_list_head *head, const char *filename); |
|||
void strlist_destroy(struct str_list_head *head); |
|||
@ -1,107 +0,0 @@ |
|||
#define _GNU_SOURCE |
|||
#include "strpool.h" |
|||
#include <string.h> |
|||
#include <stdlib.h> |
|||
|
|||
#undef uthash_nonfatal_oom |
|||
#define uthash_nonfatal_oom(elt) ut_oom_recover(elt) |
|||
|
|||
static bool oom = false; |
|||
static void ut_oom_recover(strpool *elem) |
|||
{ |
|||
oom = true; |
|||
} |
|||
|
|||
// for zero terminated strings
|
|||
bool StrPoolAddStr(strpool **pp, const char *s) |
|||
{ |
|||
strpool *elem; |
|||
if (!(elem = (strpool*)malloc(sizeof(strpool)))) |
|||
return false; |
|||
if (!(elem->str = strdup(s))) |
|||
{ |
|||
free(elem); |
|||
return false; |
|||
} |
|||
oom = false; |
|||
HASH_ADD_KEYPTR(hh, *pp, elem->str, strlen(elem->str), elem); |
|||
if (oom) |
|||
{ |
|||
free(elem->str); |
|||
free(elem); |
|||
return false; |
|||
} |
|||
return true; |
|||
} |
|||
// for not zero terminated strings
|
|||
bool StrPoolAddStrLen(strpool **pp, const char *s, size_t slen) |
|||
{ |
|||
strpool *elem; |
|||
if (!(elem = (strpool*)malloc(sizeof(strpool)))) |
|||
return false; |
|||
if (!(elem->str = malloc(slen + 1))) |
|||
{ |
|||
free(elem); |
|||
return false; |
|||
} |
|||
memcpy(elem->str, s, slen); |
|||
elem->str[slen] = 0; |
|||
oom = false; |
|||
HASH_ADD_KEYPTR(hh, *pp, elem->str, strlen(elem->str), elem); |
|||
if (oom) |
|||
{ |
|||
free(elem->str); |
|||
free(elem); |
|||
return false; |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
bool StrPoolCheckStr(strpool *p, const char *s) |
|||
{ |
|||
strpool *elem; |
|||
HASH_FIND_STR(p, s, elem); |
|||
return elem != NULL; |
|||
} |
|||
|
|||
void StrPoolDestroy(strpool **p) |
|||
{ |
|||
strpool *elem, *tmp; |
|||
HASH_ITER(hh, *p, elem, tmp) { |
|||
free(elem->str); |
|||
HASH_DEL(*p, elem); |
|||
free(elem); |
|||
} |
|||
*p = NULL; |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
bool strlist_add(struct str_list_head *head, const char *filename) |
|||
{ |
|||
struct str_list *entry = malloc(sizeof(struct str_list)); |
|||
if (!entry) return false; |
|||
entry->str = strdup(filename); |
|||
if (!entry->str) |
|||
{ |
|||
free(entry); |
|||
return false; |
|||
} |
|||
LIST_INSERT_HEAD(head, entry, next); |
|||
return true; |
|||
} |
|||
static void strlist_entry_destroy(struct str_list *entry) |
|||
{ |
|||
if (entry->str) free(entry->str); |
|||
free(entry); |
|||
} |
|||
void strlist_destroy(struct str_list_head *head) |
|||
{ |
|||
struct str_list *entry; |
|||
while ((entry = LIST_FIRST(head))) |
|||
{ |
|||
LIST_REMOVE(entry, next); |
|||
strlist_entry_destroy(entry); |
|||
} |
|||
} |
|||
@ -1,29 +0,0 @@ |
|||
#pragma once |
|||
|
|||
#include <stdbool.h> |
|||
#include <ctype.h> |
|||
#include <sys/queue.h> |
|||
|
|||
//#define HASH_BLOOM 20
|
|||
#define HASH_NONFATAL_OOM 1 |
|||
#define HASH_FUNCTION HASH_BER |
|||
#include "uthash.h" |
|||
|
|||
typedef struct strpool { |
|||
char *str; /* key */ |
|||
UT_hash_handle hh; /* makes this structure hashable */ |
|||
} strpool; |
|||
|
|||
void StrPoolDestroy(strpool **p); |
|||
bool StrPoolAddStr(strpool **pp,const char *s); |
|||
bool StrPoolAddStrLen(strpool **pp,const char *s,size_t slen); |
|||
bool StrPoolCheckStr(strpool *p,const char *s); |
|||
|
|||
struct str_list { |
|||
char *str; |
|||
LIST_ENTRY(str_list) next; |
|||
}; |
|||
LIST_HEAD(str_list_head, str_list); |
|||
|
|||
bool strlist_add(struct str_list_head *head, const char *filename); |
|||
void strlist_destroy(struct str_list_head *head); |
|||
@ -1,10 +1,11 @@ |
|||
#pragma once |
|||
|
|||
#include <stdbool.h> |
|||
#include "strpool.h" |
|||
#include "pools.h" |
|||
|
|||
bool AppendHostList(strpool **hostlist, char *filename); |
|||
bool LoadHostLists(strpool **hostlist, struct str_list_head *file_list); |
|||
bool NonEmptyHostlist(strpool **hostlist); |
|||
bool SearchHostList(strpool *hostlist, const char *host); |
|||
// return : true = apply fooling, false = do not apply
|
|||
bool HostlistCheck(strpool *hostlist, strpool *hostlist_exclude, const char *host); |
|||
bool HostlistCheck(strpool *hostlist, strpool *hostlist_exclude, const char *host, bool *excluded); |
|||
|
|||
@ -0,0 +1,152 @@ |
|||
#define _GNU_SOURCE |
|||
#include "pools.h" |
|||
#include <string.h> |
|||
#include <stdlib.h> |
|||
#include <stdio.h> |
|||
|
|||
#define DESTROY_STR_POOL(etype, ppool) \ |
|||
etype *elem, *tmp; \ |
|||
HASH_ITER(hh, *ppool, elem, tmp) { \ |
|||
free(elem->str); \ |
|||
HASH_DEL(*ppool, elem); \ |
|||
free(elem); \ |
|||
} |
|||
|
|||
#define ADD_STR_POOL(etype, ppool, keystr, keystr_len) \ |
|||
etype *elem; \ |
|||
if (!(elem = (etype*)malloc(sizeof(etype)))) \ |
|||
return false; \ |
|||
if (!(elem->str = malloc(keystr_len + 1))) \ |
|||
{ \ |
|||
free(elem); \ |
|||
return false; \ |
|||
} \ |
|||
memcpy(elem->str, keystr, keystr_len); \ |
|||
elem->str[keystr_len] = 0; \ |
|||
oom = false; \ |
|||
HASH_ADD_KEYPTR(hh, *ppool, elem->str, strlen(elem->str), elem); \ |
|||
if (oom) \ |
|||
{ \ |
|||
free(elem->str); \ |
|||
free(elem); \ |
|||
return false; \ |
|||
} |
|||
|
|||
|
|||
#undef uthash_nonfatal_oom |
|||
#define uthash_nonfatal_oom(elt) ut_oom_recover(elt) |
|||
static bool oom = false; |
|||
static void ut_oom_recover(void *elem) |
|||
{ |
|||
oom = true; |
|||
} |
|||
|
|||
// for not zero terminated strings
|
|||
bool StrPoolAddStrLen(strpool **pp, const char *s, size_t slen) |
|||
{ |
|||
ADD_STR_POOL(strpool, pp, s, slen) |
|||
return true; |
|||
} |
|||
// for zero terminated strings
|
|||
bool StrPoolAddStr(strpool **pp, const char *s) |
|||
{ |
|||
return StrPoolAddStrLen(pp, s, strlen(s)); |
|||
} |
|||
|
|||
bool StrPoolCheckStr(strpool *p, const char *s) |
|||
{ |
|||
strpool *elem; |
|||
HASH_FIND_STR(p, s, elem); |
|||
return elem != NULL; |
|||
} |
|||
|
|||
void StrPoolDestroy(strpool **pp) |
|||
{ |
|||
DESTROY_STR_POOL(strpool, pp) |
|||
} |
|||
|
|||
|
|||
|
|||
void HostFailPoolDestroy(hostfail_pool **pp) |
|||
{ |
|||
DESTROY_STR_POOL(hostfail_pool, pp) |
|||
} |
|||
hostfail_pool * HostFailPoolAdd(hostfail_pool **pp,const char *s,int fail_time) |
|||
{ |
|||
size_t slen = strlen(s); |
|||
ADD_STR_POOL(hostfail_pool, pp, s, slen) |
|||
elem->expire = time(NULL) + fail_time; |
|||
return elem; |
|||
} |
|||
hostfail_pool *HostFailPoolFind(hostfail_pool *p,const char *s) |
|||
{ |
|||
hostfail_pool *elem; |
|||
HASH_FIND_STR(p, s, elem); |
|||
return elem; |
|||
} |
|||
void HostFailPoolDel(hostfail_pool **p, hostfail_pool *elem) |
|||
{ |
|||
HASH_DEL(*p, elem); |
|||
free(elem); |
|||
} |
|||
void HostFailPoolPurge(hostfail_pool **pp) |
|||
{ |
|||
hostfail_pool *elem, *tmp; |
|||
time_t now = time(NULL); |
|||
HASH_ITER(hh, *pp, elem, tmp) |
|||
{ |
|||
if (now >= elem->expire) |
|||
{ |
|||
free(elem->str); |
|||
HASH_DEL(*pp, elem); |
|||
free(elem); |
|||
} |
|||
} |
|||
} |
|||
static time_t host_fail_purge_prev=0; |
|||
void HostFailPoolPurgeRateLimited(hostfail_pool **pp) |
|||
{ |
|||
time_t now = time(NULL); |
|||
// do not purge too often to save resources
|
|||
if (host_fail_purge_prev != now) |
|||
{ |
|||
HostFailPoolPurge(pp); |
|||
host_fail_purge_prev = now; |
|||
} |
|||
} |
|||
void HostFailPoolDump(hostfail_pool *p) |
|||
{ |
|||
hostfail_pool *elem, *tmp; |
|||
time_t now = time(NULL); |
|||
HASH_ITER(hh, p, elem, tmp) |
|||
printf("host=%s counter=%d time_left=%lld\n",elem->str,elem->counter,(long long int)elem->expire-now); |
|||
} |
|||
|
|||
|
|||
bool strlist_add(struct str_list_head *head, const char *filename) |
|||
{ |
|||
struct str_list *entry = malloc(sizeof(struct str_list)); |
|||
if (!entry) return false; |
|||
entry->str = strdup(filename); |
|||
if (!entry->str) |
|||
{ |
|||
free(entry); |
|||
return false; |
|||
} |
|||
LIST_INSERT_HEAD(head, entry, next); |
|||
return true; |
|||
} |
|||
static void strlist_entry_destroy(struct str_list *entry) |
|||
{ |
|||
if (entry->str) free(entry->str); |
|||
free(entry); |
|||
} |
|||
void strlist_destroy(struct str_list_head *head) |
|||
{ |
|||
struct str_list *entry; |
|||
while ((entry = LIST_FIRST(head))) |
|||
{ |
|||
LIST_REMOVE(entry, next); |
|||
strlist_entry_destroy(entry); |
|||
} |
|||
} |
|||
@ -0,0 +1,46 @@ |
|||
#pragma once |
|||
|
|||
#include <stdbool.h> |
|||
#include <ctype.h> |
|||
#include <sys/queue.h> |
|||
#include <time.h> |
|||
|
|||
//#define HASH_BLOOM 20
|
|||
#define HASH_NONFATAL_OOM 1 |
|||
#define HASH_FUNCTION HASH_BER |
|||
#include "uthash.h" |
|||
|
|||
typedef struct strpool { |
|||
char *str; /* key */ |
|||
UT_hash_handle hh; /* makes this structure hashable */ |
|||
} strpool; |
|||
|
|||
void StrPoolDestroy(strpool **pp); |
|||
bool StrPoolAddStr(strpool **pp,const char *s); |
|||
bool StrPoolAddStrLen(strpool **pp,const char *s,size_t slen); |
|||
bool StrPoolCheckStr(strpool *p,const char *s); |
|||
|
|||
struct str_list { |
|||
char *str; |
|||
LIST_ENTRY(str_list) next; |
|||
}; |
|||
LIST_HEAD(str_list_head, str_list); |
|||
|
|||
|
|||
typedef struct hostfail_pool { |
|||
char *str; /* key */ |
|||
int counter; /* value */ |
|||
time_t expire; /* when to expire record (unixtime) */ |
|||
UT_hash_handle hh; /* makes this structure hashable */ |
|||
} hostfail_pool; |
|||
|
|||
void HostFailPoolDestroy(hostfail_pool **pp); |
|||
hostfail_pool *HostFailPoolAdd(hostfail_pool **pp,const char *s,int fail_time); |
|||
hostfail_pool *HostFailPoolFind(hostfail_pool *p,const char *s); |
|||
void HostFailPoolDel(hostfail_pool **pp, hostfail_pool *elem); |
|||
void HostFailPoolPurge(hostfail_pool **pp); |
|||
void HostFailPoolPurgeRateLimited(hostfail_pool **pp); |
|||
void HostFailPoolDump(hostfail_pool *p); |
|||
|
|||
bool strlist_add(struct str_list_head *head, const char *filename); |
|||
void strlist_destroy(struct str_list_head *head); |
|||
@ -1,107 +0,0 @@ |
|||
#define _GNU_SOURCE |
|||
#include "strpool.h" |
|||
#include <string.h> |
|||
#include <stdlib.h> |
|||
|
|||
#undef uthash_nonfatal_oom |
|||
#define uthash_nonfatal_oom(elt) ut_oom_recover(elt) |
|||
|
|||
static bool oom = false; |
|||
static void ut_oom_recover(strpool *elem) |
|||
{ |
|||
oom = true; |
|||
} |
|||
|
|||
// for zero terminated strings
|
|||
bool StrPoolAddStr(strpool **pp, const char *s) |
|||
{ |
|||
strpool *elem; |
|||
if (!(elem = (strpool*)malloc(sizeof(strpool)))) |
|||
return false; |
|||
if (!(elem->str = strdup(s))) |
|||
{ |
|||
free(elem); |
|||
return false; |
|||
} |
|||
oom = false; |
|||
HASH_ADD_KEYPTR(hh, *pp, elem->str, strlen(elem->str), elem); |
|||
if (oom) |
|||
{ |
|||
free(elem->str); |
|||
free(elem); |
|||
return false; |
|||
} |
|||
return true; |
|||
} |
|||
// for not zero terminated strings
|
|||
bool StrPoolAddStrLen(strpool **pp, const char *s, size_t slen) |
|||
{ |
|||
strpool *elem; |
|||
if (!(elem = (strpool*)malloc(sizeof(strpool)))) |
|||
return false; |
|||
if (!(elem->str = malloc(slen + 1))) |
|||
{ |
|||
free(elem); |
|||
return false; |
|||
} |
|||
memcpy(elem->str, s, slen); |
|||
elem->str[slen] = 0; |
|||
oom = false; |
|||
HASH_ADD_KEYPTR(hh, *pp, elem->str, strlen(elem->str), elem); |
|||
if (oom) |
|||
{ |
|||
free(elem->str); |
|||
free(elem); |
|||
return false; |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
bool StrPoolCheckStr(strpool *p, const char *s) |
|||
{ |
|||
strpool *elem; |
|||
HASH_FIND_STR(p, s, elem); |
|||
return elem != NULL; |
|||
} |
|||
|
|||
void StrPoolDestroy(strpool **p) |
|||
{ |
|||
strpool *elem, *tmp; |
|||
HASH_ITER(hh, *p, elem, tmp) { |
|||
free(elem->str); |
|||
HASH_DEL(*p, elem); |
|||
free(elem); |
|||
} |
|||
*p = NULL; |
|||
} |
|||
|
|||
|
|||
|
|||
|
|||
bool strlist_add(struct str_list_head *head, const char *filename) |
|||
{ |
|||
struct str_list *entry = malloc(sizeof(struct str_list)); |
|||
if (!entry) return false; |
|||
entry->str = strdup(filename); |
|||
if (!entry->str) |
|||
{ |
|||
free(entry); |
|||
return false; |
|||
} |
|||
LIST_INSERT_HEAD(head, entry, next); |
|||
return true; |
|||
} |
|||
static void strlist_entry_destroy(struct str_list *entry) |
|||
{ |
|||
if (entry->str) free(entry->str); |
|||
free(entry); |
|||
} |
|||
void strlist_destroy(struct str_list_head *head) |
|||
{ |
|||
struct str_list *entry; |
|||
while ((entry = LIST_FIRST(head))) |
|||
{ |
|||
LIST_REMOVE(entry, next); |
|||
strlist_entry_destroy(entry); |
|||
} |
|||
} |
|||
@ -1,29 +0,0 @@ |
|||
#pragma once |
|||
|
|||
#include <stdbool.h> |
|||
#include <ctype.h> |
|||
#include <sys/queue.h> |
|||
|
|||
//#define HASH_BLOOM 20
|
|||
#define HASH_NONFATAL_OOM 1 |
|||
#define HASH_FUNCTION HASH_BER |
|||
#include "uthash.h" |
|||
|
|||
typedef struct strpool { |
|||
char *str; /* key */ |
|||
UT_hash_handle hh; /* makes this structure hashable */ |
|||
} strpool; |
|||
|
|||
void StrPoolDestroy(strpool **p); |
|||
bool StrPoolAddStr(strpool **pp,const char *s); |
|||
bool StrPoolAddStrLen(strpool **pp,const char *s,size_t slen); |
|||
bool StrPoolCheckStr(strpool *p,const char *s); |
|||
|
|||
struct str_list { |
|||
char *str; |
|||
LIST_ENTRY(str_list) next; |
|||
}; |
|||
LIST_HEAD(str_list_head, str_list); |
|||
|
|||
bool strlist_add(struct str_list_head *head, const char *filename); |
|||
void strlist_destroy(struct str_list_head *head); |
|||
Loading…
Reference in new issue