mirrors/byedpi
0
0
Fork 0
mirror of https://github.com/hufrea/byedpi.git synced 2025-06-29 18:21:14 +00:00
Code

Change sorting algorithm

Browse Source
This commit is contained in:
ruti 2025-06-18 14:23:20 +03:00
parent f91fb39908
commit a3a98c72f6
5 changed files with 72 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
conev.h
View File

@ -84,6 +84,7 @@ struct eval {
struct desync_params *dp; struct desync_params *dp;
uint64_t dp_mask; uint64_t dp_mask;
int detect;
bool mark; // bool mark; //
bool restore_ttl; bool restore_ttl;

124
extend.c
View File

@ -73,7 +73,7 @@ static struct elem_i *cache_get(const union sockaddr_u *dst)
return 0; return 0;
} }
time_t t = time(0); time_t t = time(0);
if (t > val->time + params.cache_ttl || val->dp == params.dp) { if (t > val->time + params.cache_ttl) {
LOG(LOG_S, "time=%jd, now=%jd, ignore\n", (intmax_t)val->time, (intmax_t)t); LOG(LOG_S, "time=%jd, now=%jd, ignore\n", (intmax_t)val->time, (intmax_t)t);
mem_delete(params.mempool, (char *)&key, len); mem_delete(params.mempool, (char *)&key, len);
return 0; return 0;
@ -114,25 +114,25 @@ static struct elem_i *cache_add(
int connect_hook(struct poolhd *pool, struct eval *val, int connect_hook(struct poolhd *pool, struct eval *val,
const union sockaddr_u *dst, evcb_t next) const union sockaddr_u *dst, evcb_t next)
{ {
struct desync_params *dp = val->dp, *init_dp; struct desync_params *dp = params.dp;
if (!dp) {
if (!val->dp_mask) {
struct elem_i *e = cache_get(dst); struct elem_i *e = cache_get(dst);
if (e) { if (e) {
val->dp_mask = e->dp_mask; val->dp_mask = e->dp_mask;
dp = e->dp; val->detect = e->detect;
} else }
dp = params.dp;
} }
init_dp = dp;
for (; ; dp = dp->next) { for (; ; dp = dp->next) {
if (!dp) { if (!dp) {
return -1; return -1;
} }
if ((!dp->detect || dp == init_dp) if (!(dp->bit & val->dp_mask)
&& (!dp->detect || (val->detect & dp->detect))
&& check_l34(dp, SOCK_STREAM, dst)) { && check_l34(dp, SOCK_STREAM, dst)) {
break; break;
} }
val->dp_mask |= dp->bit;
} }
val->dp = dp; val->dp = dp;
@ -160,12 +160,11 @@ int socket_mod(int fd)
} }
static int reconnect(struct poolhd *pool, struct eval *val, struct desync_params *dp) static int reconnect(struct poolhd *pool, struct eval *val)
{ {
assert(val->flag == FLAG_CONN); assert(val->flag == FLAG_CONN);
struct eval *client = val->pair; struct eval *client = val->pair;
client->dp = dp;
if (connect_hook(pool, client, &val->addr, &on_tunnel)) { if (connect_hook(pool, client, &val->addr, &on_tunnel)) {
return -1; return -1;
@ -274,9 +273,6 @@ static bool check_round(const int *nr, int r)
static void swop_groups(struct desync_params *dpc, struct desync_params *dpn) static void swop_groups(struct desync_params *dpc, struct desync_params *dpn)
{ {
if (dpc->fail_count <= dpn->fail_count) {
return;
}
LOG(LOG_S, "swop: %d <-> %d\n", dpc->id, dpn->id); LOG(LOG_S, "swop: %d <-> %d\n", dpc->id, dpn->id);
struct desync_params dpc_cp = *dpc; struct desync_params dpc_cp = *dpc;
@ -306,55 +302,65 @@ static void swop_groups(struct desync_params *dpc, struct desync_params *dpn)
if (params.dp == dpc) params.dp = dpn; if (params.dp == dpc) params.dp = dpn;
} }
static int on_trigger(int type, struct poolhd *pool, struct eval *val) static int on_trigger(int type, struct poolhd *pool, struct eval *val)
{ {
struct desync_params *dp = val->pair->dp; struct eval *lav = val->pair;
dp->fail_count++;
val->pair->dp_mask |= dp->bit;
struct buffer *pair_buff = val->pair->sq_buff; bool can_reconn = (lav->sq_buff
bool can_reconn = ( && (params.auto_level & AUTO_RECONN)
pair_buff && pair_buff->lock
&& !val->recv_count
&& (params.auto_level & AUTO_RECONN)
); );
if (!can_reconn && !(params.auto_level & AUTO_POST)) { if (!can_reconn && !(params.auto_level & AUTO_POST)) {
return -1; return -1;
} }
INIT_ADDR_STR((val->addr)); INIT_ADDR_STR((val->addr));
for (dp = dp->next; dp; dp = dp->next) { struct elem_i *cache = cache_add(&val->addr, &lav->host, lav->host_len);
if (!dp->detect) { if (!cache) {
break;
}
if (!(dp->detect & type)) {
continue;
}
if (params.auto_level & AUTO_SORT) {
if (dp->bit & val->pair->dp_mask)
continue;
else
swop_groups(val->pair->dp, dp);
}
LOG(LOG_S, "save: ip=%s, id=%d\n", ADDR_STR, dp->id);
struct elem_i *e = cache_add(&val->addr, &val->pair->host, val->pair->host_len);
if (e) {
e->dp = dp;
e->dp_mask = val->pair->dp_mask;
}
if (can_reconn) {
return reconnect(pool, val, dp);
}
return -1; return -1;
} }
LOG(LOG_S, "unreach ip: %s\n", ADDR_STR); lav->dp->fail_count++;
lav->dp_mask |= lav->dp->bit;
lav->detect = type;
struct elem_i *e = cache_add(&val->addr, &val->pair->host, val->pair->host_len); uint64_t uncheked = lav->dp_mask;
if (e) { struct desync_params *dp = params.dp, *next = 0;
e->dp = params.dp;
e->dp_mask = 0; for (; dp; dp = dp->next) {
if (!uncheked && !dp->detect) {
break;
}
if (!(dp->bit & lav->dp_mask)
&& (!dp->detect || (dp->detect & type))) {
next = dp;
break;
}
uncheked &= ~dp->bit;
lav->dp_mask |= dp->bit;
}
if ((params.auto_level & AUTO_SORT)
&& !(lav->dp->bit & (cache->dp_mask | uncheked)))
{
if (next && lav->dp->pri > next->pri)
swop_groups(lav->dp, next);
else
lav->dp->pri++;
}
if (!next) {
LOG(LOG_S, "unreach ip: %s\n", ADDR_STR);
cache->dp_mask = 0;
cache->detect = 0;
cache->dp = params.dp;
return -1;
}
LOG(LOG_S, "save: ip=%s, id=%d\n", ADDR_STR, next->id);
cache->dp_mask |= lav->dp_mask;
cache->detect = lav->detect;
cache->dp = next;
if (can_reconn) {
return reconnect(pool, val);
} }
return -1; return -1;
} }
@ -389,14 +395,16 @@ static int on_fin(struct poolhd *pool, struct eval *val)
static int on_response(struct poolhd *pool, struct eval *val, static int on_response(struct poolhd *pool, struct eval *val,
const char *resp, ssize_t sn) const char *resp, ssize_t sn)
{ {
struct desync_params *dp = val->pair->dp->next; struct desync_params *dp = params.dp;
char *req = val->pair->sq_buff->data; char *req = val->pair->sq_buff->data;
ssize_t qn = val->pair->sq_buff->size; ssize_t qn = val->pair->sq_buff->size;
val->pair->dp_mask |= val->pair->dp->bit;
for (; dp; dp = dp->next) { for (; dp; dp = dp->next) {
if (!dp->detect) { if (dp->bit & val->pair->dp_mask) {
return -1; continue;
} }
if ((dp->detect & DETECT_HTTP_LOCAT) if ((dp->detect & DETECT_HTTP_LOCAT)
&& is_http_redirect(req, qn, resp, sn)) { && is_http_redirect(req, qn, resp, sn)) {
@ -409,7 +417,7 @@ static int on_response(struct poolhd *pool, struct eval *val,
} }
} }
if (dp) { if (dp) {
return reconnect(pool, val, dp); return on_trigger(dp->detect, pool, val);
} }
return -1; return -1;
} }
@ -447,15 +455,17 @@ static int setup_conn(struct eval *client, const char *buffer, ssize_t n)
if (params.cache_file) { if (params.cache_file) {
save_hostname(client, buffer, n); save_hostname(client, buffer, n);
} }
struct desync_params *dp = client->dp, *init_dp = dp; struct desync_params *dp = client->dp, *init_dp = client->dp;
for (; dp; dp = dp->next) { for (; dp; dp = dp->next) {
if ((!dp->detect || dp == init_dp) if (!(dp->bit & client->dp_mask)
&& (!dp->detect || (client->detect & dp->detect))
&& (dp == init_dp || check_l34(dp, SOCK_STREAM, &client->pair->addr)) && (dp == init_dp || check_l34(dp, SOCK_STREAM, &client->pair->addr))
&& check_proto_tcp(dp->proto, buffer, n) && check_proto_tcp(dp->proto, buffer, n)
&& (!dp->hosts || check_host(dp->hosts, buffer, n))) { && (!dp->hosts || check_host(dp->hosts, buffer, n))) {
break; break;
} }
client->dp_mask |= dp->bit;
} }
if (!dp) { if (!dp) {
LOG(LOG_E, "drop connection\n"); LOG(LOG_E, "drop connection\n");

4
main.c
View File

@ -1189,7 +1189,7 @@ int main(int argc, char **argv)
return -1; return -1;
} }
} }
if ((params.auto_level & AUTO_SORT) && params.dp_n > 64) { if ((size_t )params.dp_n > sizeof(dp->bit) * 8) {
LOG(LOG_E, "too many groups!\n"); LOG(LOG_E, "too many groups!\n");
} }
if (params.baddr.sa.sa_family != AF_INET6) { if (params.baddr.sa.sa_family != AF_INET6) {
@ -1222,7 +1222,7 @@ int main(int argc, char **argv)
int status = run(&params.laddr); int status = run(&params.laddr);
for (dp = params.dp; dp; dp = dp->next) { for (dp = params.dp; dp; dp = dp->next) {
LOG(LOG_S, "group: %d, triggered: %d\n", dp->id, dp->fail_count); LOG(LOG_S, "group: %d, triggered: %d, pri: %d\n", dp->id, dp->fail_count, dp->pri);
} }
if (params.cache_file) { if (params.cache_file) {
FILE *f; FILE *f;

1
mpool.h
View File

@ -47,6 +47,7 @@ struct elem_i {
struct desync_params *dp; struct desync_params *dp;
uint64_t dp_mask; uint64_t dp_mask;
int detect;
time_t time; time_t time;
}; };

1
params.h
View File

@ -115,6 +115,7 @@ struct desync_params {
int id; int id;
uint64_t bit; uint64_t bit;
int fail_count; int fail_count;
int pri;
struct desync_params *prev; struct desync_params *prev;
struct desync_params *next; struct desync_params *next;