mirrors
/
rspamd
mirror of https://github.com/vstakhov/rspamd.git
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 159 Wiki Activity
Browse Source

[Minor] Fix some warnings

tags/3.7.1
Vsevolod Stakhov 8 months ago
parent
558e103941
commit
0835db27a1
No account linked to committer's email address
5 changed files with 225 additions and 190 deletions
Split View Show Diff Stats
  1. 196
    171
      contrib/librdns/upstream.h
  2. 15
    8
      src/libserver/symcache/symcache_impl.cxx
  3. 7
    4
      src/libserver/symcache/symcache_item.cxx
  4. 3
    3
      src/libserver/symcache/symcache_item.hxx
  5. 4
    4
      src/lua/lua_kann.c

+ 196
- 171
contrib/librdns/upstream.h View File

@@ -1,3 +1,19 @@
/*
* Copyright 2023 Vsevolod Stakhov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/*
* Copyright (c) 2014, Vsevolod Stakhov
*
@@ -35,15 +51,19 @@
*/

#ifndef upstream_fatal
#define upstream_fatal(msg) do { perror (msg); exit (-1); } while (0)
#define upstream_fatal(msg) \
do { \
perror(msg); \
exit(-1); \
} while (0)
#endif

#ifndef upstream_malloc
#define upstream_malloc(size) malloc (size)
#define upstream_malloc(size) malloc(size)
#endif

#ifndef upstream_free
#define upstream_free(size, ptr) free (ptr)
#define upstream_free(size, ptr) free(ptr)
#endif

struct upstream_entry_s;
@@ -55,14 +75,14 @@ struct upstream_common_data {
};

typedef struct upstream_entry_s {
unsigned short errors; /**< errors for this upstream */
unsigned short errors; /**< errors for this upstream */
unsigned short dead;
unsigned short priority;
unsigned short weight;
time_t time; /**< time of marking */
void *parent; /**< parent object */
struct upstream_common_data *common; /**< common data */
void *next; /**< link to the next */
time_t time; /**< time of marking */
void *parent; /**< parent object */
struct upstream_common_data *common; /**< common data */
void *next; /**< link to the next */
} upstream_entry_t;

/*
@@ -82,176 +102,181 @@ typedef struct upstream_entry_s {
#define UPSTREAM_MAX_ERRORS 10
#endif

#define UPSTREAM_FAIL(u, now) do { \
if ((u)->up.time != 0) { \
if ((now) - (u)->up.time >= UPSTREAM_ERROR_TIME) { \
if ((u)->up.errors >= UPSTREAM_MAX_ERRORS) { \
(u)->up.dead = 1; \
(u)->up.time = now; \
(u)->up.common->alive --; \
} \
else { \
(u)->up.errors = 1; \
(u)->up.time = (now); \
} \
} \
else { \
(u)->up.errors ++; \
} \
} \
else { \
(u)->up.errors ++; \
(u)->up.time = (now); \
} \
} while (0)
#define UPSTREAM_FAIL(u, now) \
do { \
if ((u)->up.time != 0) { \
if ((now) - (u)->up.time >= UPSTREAM_ERROR_TIME) { \
if ((u)->up.errors >= UPSTREAM_MAX_ERRORS) { \
(u)->up.dead = 1; \
(u)->up.time = now; \
(u)->up.common->alive--; \
} \
else { \
(u)->up.errors = 1; \
(u)->up.time = (now); \
} \
} \
else { \
(u)->up.errors++; \
} \
} \
else { \
(u)->up.errors++; \
(u)->up.time = (now); \
} \
} while (0)

#define UPSTREAM_OK(u) do { \
(u)->up.errors = 0; \
(u)->up.time = 0; \
} while (0)
#define UPSTREAM_OK(u) \
do { \
(u)->up.errors = 0; \
(u)->up.time = 0; \
} while (0)

#define UPSTREAM_ADD(head, u, priority) do { \
if (head == NULL) { \
struct upstream_common_data *cd; \
cd = upstream_malloc (sizeof (struct upstream_common_data)); \
if (cd == NULL) { \
upstream_fatal ("malloc failed"); \
} \
cd->upstreams = upstream_malloc (sizeof (void *) * 8); \
if (cd == NULL) { \
upstream_fatal ("malloc failed"); \
} \
cd->allocated_nelts = 8; \
cd->nelts = 1; \
cd->alive = 1; \
cd->upstreams[0] = (u); \
(u)->up.common = cd; \
} \
else { \
struct upstream_common_data *cd = (head)->up.common; \
(u)->up.common = cd; \
if (cd->nelts == cd->allocated_nelts) { \
void **nup; \
nup = upstream_malloc (sizeof (void *) * cd->nelts * 2); \
if (nup == NULL) { \
upstream_fatal ("malloc failed"); \
} \
memcpy (nup, cd->upstreams, cd->nelts * sizeof (void *)); \
upstream_free (cd->nelts * sizeof (void *), cd->upstreams); \
cd->upstreams = nup; \
cd->allocated_nelts *= 2; \
} \
cd->upstreams[cd->nelts++] = (u); \
cd->alive ++; \
} \
(u)->up.next = (head); \
(head) = (u); \
if (priority > 0) { \
(u)->up.priority = (u)->up.weight = (priority); \
} \
else { \
(u)->up.priority = (u)->up.weight = 65535; \
} \
(u)->up.time = 0; \
(u)->up.errors = 0; \
(u)->up.dead = 0; \
(u)->up.parent = (u); \
} while (0)
#define UPSTREAM_ADD(head, u, priority) \
do { \
if (head == NULL) { \
struct upstream_common_data *cd; \
cd = upstream_malloc(sizeof(struct upstream_common_data)); \
if (cd == NULL) { \
upstream_fatal("malloc failed"); \
} \
cd->upstreams = upstream_malloc(sizeof(void *) * 8); \
if (cd == NULL) { \
upstream_fatal("malloc failed"); \
} \
cd->allocated_nelts = 8; \
cd->nelts = 1; \
cd->alive = 1; \
cd->upstreams[0] = (u); \
(u)->up.common = cd; \
} \
else { \
struct upstream_common_data *cd = (head)->up.common; \
(u)->up.common = cd; \
if (cd->nelts == cd->allocated_nelts) { \
void **nup; \
nup = upstream_malloc(sizeof(void *) * cd->nelts * 2); \
if (nup == NULL) { \
upstream_fatal("malloc failed"); \
} \
memcpy(nup, cd->upstreams, cd->nelts * sizeof(void *)); \
upstream_free(cd->nelts * sizeof(void *), cd->upstreams); \
cd->upstreams = nup; \
cd->allocated_nelts *= 2; \
} \
cd->upstreams[cd->nelts++] = (u); \
cd->alive++; \
} \
(u)->up.next = (head); \
(head) = (u); \
if (priority > 0) { \
(u)->up.priority = (u)->up.weight = (priority); \
} \
else { \
(u)->up.priority = (u)->up.weight = 65535; \
} \
(u)->up.time = 0; \
(u)->up.errors = 0; \
(u)->up.dead = 0; \
(u)->up.parent = (u); \
} while (0)

#define UPSTREAM_DEL(head, u) do { \
if (head != NULL) { \
struct upstream_common_data *cd = (head)->up.common; \
if ((u)->up.next != NULL) { \
(head) = (u)->up.next; \
cd->nelts --; \
cd->alive --; \
} \
else { \
upstream_free (cd->allocated_nelts * sizeof (void *), \
cd->upstreams); \
upstream_free (sizeof (struct upstream_common_data), cd); \
(head) = NULL; \
} \
} \
} while (0)
#define UPSTREAM_DEL(head, u) \
do { \
if (head != NULL) { \
struct upstream_common_data *cd = (head)->up.common; \
if ((u)->up.next != NULL) { \
(head) = (u)->up.next; \
cd->nelts--; \
cd->alive--; \
} \
else { \
upstream_free(cd->allocated_nelts * sizeof(void *), \
cd->upstreams); \
upstream_free(sizeof(struct upstream_common_data), cd); \
(head) = NULL; \
} \
} \
} while (0)

#define UPSTREAM_FOREACH(head, u) for ((u) = (head); (u) != NULL; (u) = (u)->up.next)
#define UPSTREAM_FOREACH_SAFE(head, u, tmp) \
for ((u) = (head); \
(u) != NULL && ((tmp = (u)->up.next) || true); \
(u) = (tmp))
#define UPSTREAM_FOREACH_SAFE(head, u, tmp) \
for ((u) = (head); \
(u) != NULL && ((tmp = (u)->up.next) || true); \
(u) = (tmp))

#define UPSTREAM_REVIVE_ALL(head) do { \
__typeof(head) elt = (head); \
while (elt != NULL) { \
elt->up.dead = 0; \
elt->up.errors = 0; \
elt->up.time = 0; \
elt = elt->up.next; \
} \
(head)->up.common->alive = (head)->up.common->nelts; \
} while (0)
#define UPSTREAM_REVIVE_ALL(head) \
do { \
__typeof(head) elt = (head); \
while (elt != NULL) { \
elt->up.dead = 0; \
elt->up.errors = 0; \
elt->up.time = 0; \
elt = elt->up.next; \
} \
(head)->up.common->alive = (head)->up.common->nelts; \
} while (0)

#define UPSTREAM_RESCAN(head, now) do { \
__typeof(head) elt = (head); \
if ((head)->up.common->alive == 0) { \
UPSTREAM_REVIVE_ALL((head)); \
} \
else { \
while (elt != NULL) { \
if (elt->up.dead) { \
if ((now) - elt->up.time >= UPSTREAM_REVIVE_TIME) { \
elt->up.dead = 0; \
elt->up.errors = 0; \
elt->up.weight = elt->up.priority; \
(head)->up.common->alive ++; \
} \
} \
else { \
if ((now) - elt->up.time >= UPSTREAM_ERROR_TIME && \
elt->up.errors >= UPSTREAM_MAX_ERRORS) { \
elt->up.dead = 1; \
elt->up.time = now; \
(head)->up.common->alive --; \
} \
} \
elt = elt->up.next; \
} \
} \
} while (0)
#define UPSTREAM_RESCAN(head, now) \
do { \
__typeof(head) elt = (head); \
if ((head)->up.common->alive == 0) { \
UPSTREAM_REVIVE_ALL((head)); \
} \
else { \
while (elt != NULL) { \
if (elt->up.dead) { \
if ((now) -elt->up.time >= UPSTREAM_REVIVE_TIME) { \
elt->up.dead = 0; \
elt->up.errors = 0; \
elt->up.weight = elt->up.priority; \
(head)->up.common->alive++; \
} \
} \
else { \
if ((now) -elt->up.time >= UPSTREAM_ERROR_TIME && \
elt->up.errors >= UPSTREAM_MAX_ERRORS) { \
elt->up.dead = 1; \
elt->up.time = now; \
(head)->up.common->alive--; \
} \
} \
elt = elt->up.next; \
} \
} \
} while (0)

#define UPSTREAM_SELECT_ROUND_ROBIN(head, selected) do { \
__typeof(head) elt = (head); \
(selected) = NULL; \
int alive = 0; \
unsigned max_weight = 0; \
if ((head)->up.common->alive == 0){ \
UPSTREAM_REVIVE_ALL(head); \
} \
while (elt != NULL) { \
if (!elt->up.dead) { \
if (elt->up.weight > max_weight) { \
max_weight = elt->up.weight; \
(selected) = elt; \
} \
alive ++; \
} \
elt = elt->up.next; \
} \
if (max_weight == 0) { \
elt = (head); \
while (elt != NULL) { \
elt->up.weight = elt->up.priority; \
if (!elt->up.dead) { \
if (elt->up.priority > max_weight) { \
max_weight = elt->up.priority; \
(selected) = elt; \
} \
} \
elt = elt->up.next; \
} \
} \
(selected)->up.weight --; \
} while (0)
#define UPSTREAM_SELECT_ROUND_ROBIN(head, selected) \
do { \
__typeof(head) elt = (head); \
(selected) = NULL; \
unsigned max_weight = 0; \
if ((head)->up.common->alive == 0) { \
UPSTREAM_REVIVE_ALL(head); \
} \
while (elt != NULL) { \
if (!elt->up.dead) { \
if (elt->up.weight > max_weight) { \
max_weight = elt->up.weight; \
(selected) = elt; \
} \
} \
elt = elt->up.next; \
} \
if (max_weight == 0) { \
elt = (head); \
while (elt != NULL) { \
elt->up.weight = elt->up.priority; \
if (!elt->up.dead) { \
if (elt->up.priority > max_weight) { \
max_weight = elt->up.priority; \
(selected) = elt; \
} \
} \
elt = elt->up.next; \
} \
} \
(selected)->up.weight--; \
} while (0)

#endif /* UPSTREAM_H_ */

+ 15
- 8
src/libserver/symcache/symcache_impl.cxx View File

@@ -81,19 +81,26 @@ auto symcache::init() -> bool
if (real_elt) {
disabled_ids.insert(real_elt->id);

for (const auto &cld: real_elt->get_children().value().get()) {
msg_debug_cache("symbol %s is a virtual sibling of the disabled symbol %s",
cld->get_name().c_str(), it->get_name().c_str());
disabled_ids.insert(cld->id);
const auto *children = real_elt->get_children();
if (children != nullptr) {
for (const auto &cld: *children) {
msg_debug_cache("symbol %s is a virtual sibling of the disabled symbol %s",
cld->get_name().c_str(), it->get_name().c_str());
disabled_ids.insert(cld->id);
}
}
}
}
else {
/* Also disable all virtual children of this element */
for (const auto &cld: it->get_children().value().get()) {
msg_debug_cache("symbol %s is a virtual child of the disabled symbol %s",
cld->get_name().c_str(), it->get_name().c_str());
disabled_ids.insert(cld->id);
const auto *children = it->get_children();

if (children != nullptr) {
for (const auto &cld: *children) {
msg_debug_cache("symbol %s is a virtual child of the disabled symbol %s",
cld->get_name().c_str(), it->get_name().c_str());
disabled_ids.insert(cld->id);
}
}
}
}

+ 7
- 4
src/libserver/symcache/symcache_item.cxx View File

@@ -263,10 +263,13 @@ auto cache_item::inc_frequency(const char *sym_name, symcache &cache) -> void
{
if (sym_name && symbol != sym_name) {
if (is_filter()) {
/* Likely a callback symbol with some virtual symbol that needs to be adjusted */
for (const auto &cld: get_children().value().get()) {
if (cld->get_name() == sym_name) {
cld->inc_frequency(sym_name, cache);
const auto *children = get_children();
if (children) {
/* Likely a callback symbol with some virtual symbol that needs to be adjusted */
for (const auto &cld: *children) {
if (cld->get_name() == sym_name) {
cld->inc_frequency(sym_name, cache);
}
}
}
}

+ 3
- 3
src/libserver/symcache/symcache_item.hxx View File

@@ -483,15 +483,15 @@ public:
* @param ptr
* @return
*/
auto get_children() const -> std::optional<std::reference_wrapper<const std::vector<cache_item *>>>
auto get_children() const -> const std::vector<cache_item *> *
{
if (std::holds_alternative<normal_item>(specific)) {
const auto &filter_data = std::get<normal_item>(specific);

return std::cref(filter_data.get_childen());
return &filter_data.get_childen();
}

return std::nullopt;
return nullptr;
}

private:

+ 4
- 4
src/lua/lua_kann.c View File

@@ -1,11 +1,11 @@
/*-
* Copyright 2019 Vsevolod Stakhov
/*
* Copyright 2023 Vsevolod Stakhov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
@@ -824,7 +824,7 @@ lua_kann_new_leaf(lua_State *L)
kad_node_t *t;

if (dim >= 1 && dim < KAD_MAX_DIM && lua_istable(L, 2)) {
ar = g_new0(int, dim);
ar = g_new0(int, KAD_MAX_DIM);

for (i = 0; i < dim; i++) {
lua_rawgeti(L, 2, i + 1);

Write Preview
Loading…
Cancel
Save