[Minor] Fix some warnings

diff --git a/contrib/librdns/upstream.h b/contrib/librdns/upstream.h
index 9646f89aa7311e06e45211cde238d7d443ddfa84..a384155fe6f7aed63c9b4053ecd8b3bcb2bfeaae 100644 (file)
--- a/contrib/librdns/upstream.h
+++ b/contrib/librdns/upstream.h
@@ -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_ */

diff --git a/src/libserver/symcache/symcache_impl.cxx b/src/libserver/symcache/symcache_impl.cxx
index 6fd705be156001b676ce5d75242785661d2365e8..93675ac1604ae1827ede26b508755540ced61635 100644 (file)
--- a/src/libserver/symcache/symcache_impl.cxx
+++ b/src/libserver/symcache/symcache_impl.cxx
@@ -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);
+                                                               }
                                                        }
                                                }
                                        }

diff --git a/src/libserver/symcache/symcache_item.cxx b/src/libserver/symcache/symcache_item.cxx
index 24e198dd310cec22a41d306275c50797d3c5b0db..ac901f5cf563009fc13cc6828712fd417df48cd8 100644 (file)
--- a/src/libserver/symcache/symcache_item.cxx
+++ b/src/libserver/symcache/symcache_item.cxx
@@ -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);
+                                       }
                                }
                        }
                }

diff --git a/src/libserver/symcache/symcache_item.hxx b/src/libserver/symcache/symcache_item.hxx
index c159e7c478556d153e0daf8ceec8a4c8b2eb87e8..a60213a610808806eb2e45c16bf280d852b85b0f 100644 (file)
--- a/src/libserver/symcache/symcache_item.hxx
+++ b/src/libserver/symcache/symcache_item.hxx
@@ -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:

diff --git a/src/lua/lua_kann.c b/src/lua/lua_kann.c
index ace47dd70a3bab73086f6ee9b4ac678b9a42d470..e42fbfbc5b10a3247608c1a0549dd15912378ea8 100644 (file)
--- a/src/lua/lua_kann.c
+++ b/src/lua/lua_kann.c
@@ -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);