gnunet_common.h

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2006-2022 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.
 
     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
 
#ifndef GNUNET_COMMON_H
#define GNUNET_COMMON_H
 
#include "gnunet_config.h"
 
#include <stdbool.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdint.h>
#include <stdarg.h>
#include <sys/types.h>
 
#if defined(__FreeBSD__)
 
#include <sys/endian.h>
#define bswap_32(x) bswap32 (x)
#define bswap_64(x) bswap64 (x)
 
#elif defined(__OpenBSD__)
 
#define bswap_32(x) swap32 (x)
#define bswap_64(x) swap64 (x)
 
#elif defined(__NetBSD__)
 
#include <machine/bswap.h>
#if defined(__BSWAP_RENAME) && ! defined(__bswap_32)
#define bswap_32(x) bswap32 (x)
#define bswap_64(x) bswap64 (x)
#endif
 
#elif defined(__linux__) || defined(GNU)
#include <byteswap.h>
#endif
 
 
/* This is also included in platform.h, but over there a couple of
   GNUnet-specific gettext-related macros are defined in addition to including
   the header file.  Because this header file uses gettext, this include
   statement makes sure gettext macros are defined even when platform.h is
   unavailable. */
#ifndef _LIBGETTEXT_H
#include "gettext.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#if 0 /* keep Emacsens' auto-indent happy */
}
#endif
#endif
 
#define GNUNET_UTIL_VERSION 0x000A0104
 
 
enum GNUNET_GenericReturnValue
{
  GNUNET_SYSERR = -1,
  GNUNET_NO = 0,
  GNUNET_OK = 1,
  /* intentionally identical to #GNUNET_OK! */
  GNUNET_YES = 1,
};
 
 
#define GNUNET_MIN(a, b) (((a) < (b)) ? (a) : (b))
 
#define GNUNET_MAX(a, b) (((a) > (b)) ? (a) : (b))
 
/* some systems use one underscore only, and mingw uses no underscore... */
#ifndef __BYTE_ORDER
#ifdef _BYTE_ORDER
#define __BYTE_ORDER _BYTE_ORDER
#else
#ifdef BYTE_ORDER
#define __BYTE_ORDER BYTE_ORDER
#endif
#endif
#endif
#ifndef __BIG_ENDIAN
#ifdef _BIG_ENDIAN
#define __BIG_ENDIAN _BIG_ENDIAN
#else
#ifdef BIG_ENDIAN
#define __BIG_ENDIAN BIG_ENDIAN
#endif
#endif
#endif
#ifndef __LITTLE_ENDIAN
#ifdef _LITTLE_ENDIAN
#define __LITTLE_ENDIAN _LITTLE_ENDIAN
#else
#ifdef LITTLE_ENDIAN
#define __LITTLE_ENDIAN LITTLE_ENDIAN
#endif
#endif
#endif
 
#ifndef GNUNET_EXTRA_LOGGING
#define GNUNET_EXTRA_LOGGING 1
#endif
 
#if defined(bswap_16) || defined(bswap_32) || defined(bswap_64)
#define BYTE_SWAP_16(x) bswap_16 (x)
#define BYTE_SWAP_32(x) bswap_32 (x)
#define BYTE_SWAP_64(x) bswap_64 (x)
#else
#define BYTE_SWAP_16(x) ((((x) & 0x00ff) << 8) | (((x) & 0xff00) >> 8))
 
#define BYTE_SWAP_32(x)                                   \
        ((((x) & 0x000000ffU) << 24) | (((x) & 0x0000ff00U) << 8)   \
         | (((x) & 0x00ff0000U) >> 8) | (((x) & 0xff000000U) >> 24))
 
#define BYTE_SWAP_64(x)                                                      \
        ((((x) & 0x00000000000000ffUL) << 56) | (((x) & 0x000000000000ff00UL) << \
                                                 40)   \
         | (((x) & 0x0000000000ff0000UL) << 24) | (((x) & 0x00000000ff000000UL) \
                                                   << 8)    \
         | (((x) & 0x000000ff00000000UL) >> 8) | (((x) & 0x0000ff0000000000UL) \
                                                  >> 24)    \
         | (((x) & 0x00ff000000000000UL) >> 40) | (((x) & 0xff00000000000000UL) \
                                                   >> \
                                                   56))
#endif
 
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define GNUNET_htobe16(x) BYTE_SWAP_16 (x)
#define GNUNET_htole16(x) (x)
#define GNUNET_be16toh(x) BYTE_SWAP_16 (x)
#define GNUNET_le16toh(x) (x)
 
#define GNUNET_htobe32(x) BYTE_SWAP_32 (x)
#define GNUNET_htole32(x) (x)
#define GNUNET_be32toh(x) BYTE_SWAP_32 (x)
#define GNUNET_le32toh(x) (x)
 
#define GNUNET_htobe64(x) BYTE_SWAP_64 (x)
#define GNUNET_htole64(x) (x)
#define GNUNET_be64toh(x) BYTE_SWAP_64 (x)
#define GNUNET_le64toh(x) (x)
#endif
#if __BYTE_ORDER == __BIG_ENDIAN
#define GNUNET_htobe16(x) (x)
#define GNUNET_htole16(x) BYTE_SWAP_16 (x)
#define GNUNET_be16toh(x) (x)
#define GNUNET_le16toh(x) BYTE_SWAP_16 (x)
 
#define GNUNET_htobe32(x) (x)
#define GNUNET_htole32(x) BYTE_SWAP_32 (x)
#define GNUNET_be32toh(x) (x)
#define GNUNET_le32toh(x) BYTE_SWAP_32 (x)
 
#define GNUNET_htobe64(x) (x)
#define GNUNET_htole64(x) BYTE_SWAP_64 (x)
#define GNUNET_be64toh(x) (x)
#define GNUNET_le64toh(x) BYTE_SWAP_64 (x)
#endif
 
 
#define GNUNET_NZL(l) GNUNET_MAX (1, l)
 
 
#define GNUNET_PACKED __attribute__ ((packed))
 
#define GNUNET_GCC_STRUCT_LAYOUT
 
#ifdef __BIGGEST_ALIGNMENT__
#define GNUNET_ALIGN __attribute__ ((aligned (__BIGGEST_ALIGNMENT__)))
#else
#define GNUNET_ALIGN __attribute__ ((aligned (8)))
#endif
 
#define GNUNET_UNUSED __attribute__ ((unused))
 
#define GNUNET_NORETURN __attribute__ ((noreturn))
 
#define GNUNET_NETWORK_STRUCT_BEGIN
 
#define GNUNET_NETWORK_STRUCT_END
 
/* ************************ super-general types *********************** */
 
GNUNET_NETWORK_STRUCT_BEGIN
 
struct GNUNET_HashCode
{
  uint32_t bits[512 / 8 / sizeof(uint32_t)];  /* = 16 */
};
 
 
struct GNUNET_ShortHashCode
{
  uint32_t bits[256 / 8 / sizeof(uint32_t)];  /* = 8 */
};
 
 
struct GNUNET_Uuid
{
  uint32_t value[4];
};
 
 
struct GNUNET_MessageHeader
{
  uint16_t size GNUNET_PACKED;
 
  uint16_t type GNUNET_PACKED;
};
 
 
struct GNUNET_AsyncScopeId
{
  uint32_t bits[16 / sizeof(uint32_t)];  /* = 16 bytes */
};
 
GNUNET_NETWORK_STRUCT_END
 
 
struct GNUNET_AsyncScopeSave
{
  struct GNUNET_AsyncScopeId scope_id;
 
  int have_scope;
};
 
 
typedef enum GNUNET_GenericReturnValue
(*GNUNET_FileNameCallback) (void *cls,
                            const char *filename);
 
 
typedef void
(*GNUNET_ContinuationCallback) (void *cls);
 
 
typedef void
(*GNUNET_ResultCallback) (void *cls,
                          int64_t result_code,
                          const void *data,
                          uint16_t data_size);
 
 
/* ****************************** logging ***************************** */
 
enum GNUNET_ErrorType
{
  GNUNET_ERROR_TYPE_UNSPECIFIED = -1,
  GNUNET_ERROR_TYPE_NONE = 0,
  GNUNET_ERROR_TYPE_ERROR = 1,
  GNUNET_ERROR_TYPE_WARNING = 2,
  /* UX: We need a message type that is output by
   * default without looking like there is a problem.
   */
  GNUNET_ERROR_TYPE_MESSAGE = 4,
  GNUNET_ERROR_TYPE_INFO = 8,
  GNUNET_ERROR_TYPE_DEBUG = 16,
  GNUNET_ERROR_TYPE_INVALID = 32,
  GNUNET_ERROR_TYPE_BULK = 64
};
 
 
typedef void
(*GNUNET_Logger) (void *cls,
                  enum GNUNET_ErrorType kind,
                  const char *component,
                  const char *date,
                  const char *message);
 
 
int
GNUNET_get_log_skip (void);
 
 
#if ! defined(GNUNET_CULL_LOGGING)
int
GNUNET_get_log_call_status (int caller_level,
                            const char *comp,
                            const char *file,
                            const char *function,
                            int line);
 
#endif
 
/* *INDENT-OFF* */
void
GNUNET_log_nocheck (enum GNUNET_ErrorType kind,
                    const char *message,
                    ...)
__attribute__ ((format (printf, 2, 3)));
 
/* from glib */
#if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)
#define _GNUNET_BOOLEAN_EXPR(expr) \
  __extension__ ({                 \
    int _gnunet_boolean_var_;      \
    if (expr)                      \
      _gnunet_boolean_var_ = 1;    \
    else                           \
      _gnunet_boolean_var_ = 0;    \
    _gnunet_boolean_var_;          \
  })
#define GN_LIKELY(expr) (__builtin_expect (_GNUNET_BOOLEAN_EXPR (expr), 1))
#define GN_UNLIKELY(expr) (__builtin_expect (_GNUNET_BOOLEAN_EXPR (expr), 0))
#else
#define GN_LIKELY(expr) (expr)
#define GN_UNLIKELY(expr) (expr)
#endif
 
#if ! defined(GNUNET_LOG_CALL_STATUS)
#define GNUNET_LOG_CALL_STATUS -1
#endif
/* *INDENT-ON* */
 
 
void
GNUNET_log_from_nocheck (enum GNUNET_ErrorType kind,
                         const char *comp,
                         const char *message,
                         ...)
__attribute__ ((format (printf, 3, 4)));
 
#if ! defined(GNUNET_CULL_LOGGING)
#define GNUNET_log_from(kind, comp, ...)                                  \
        do                                                                      \
        {                                                                       \
          static int log_call_enabled = GNUNET_LOG_CALL_STATUS;                 \
          if ((GNUNET_EXTRA_LOGGING > 0) ||                                     \
              ((GNUNET_ERROR_TYPE_DEBUG & (kind)) == 0))                        \
          {                                                                     \
            if (GN_UNLIKELY (log_call_enabled == -1))                           \
            log_call_enabled =                                                \
              GNUNET_get_log_call_status ((kind) & (~GNUNET_ERROR_TYPE_BULK), \
                                          (comp),                             \
                                          __FILE__,                           \
                                          __FUNCTION__,                       \
                                          __LINE__);                          \
            if (GN_UNLIKELY (GNUNET_get_log_skip () > 0))                       \
            {                                                                   \
              GNUNET_log_skip (-1, GNUNET_NO);                                  \
            }                                                                   \
            else                                                                \
            {                                                                   \
              if (GN_UNLIKELY (log_call_enabled))                               \
              GNUNET_log_from_nocheck ((kind), comp, __VA_ARGS__);            \
            }                                                                   \
          }                                                                     \
        } while (0)
 
#define GNUNET_log(kind, ...)                                             \
        do                                                                      \
        {                                                                       \
          static int log_call_enabled = GNUNET_LOG_CALL_STATUS;                 \
          if ((GNUNET_EXTRA_LOGGING > 0) ||                                     \
              ((GNUNET_ERROR_TYPE_DEBUG & (kind)) == 0))                        \
          {                                                                     \
            if (GN_UNLIKELY (log_call_enabled == -1))                           \
            log_call_enabled =                                                \
              GNUNET_get_log_call_status ((kind) & (~GNUNET_ERROR_TYPE_BULK), \
                                          NULL,                               \
                                          __FILE__,                           \
                                          __FUNCTION__,                       \
                                          __LINE__);                          \
            if (GN_UNLIKELY (GNUNET_get_log_skip () > 0))                       \
            {                                                                   \
              GNUNET_log_skip (-1, GNUNET_NO);                                  \
            }                                                                   \
            else                                                                \
            {                                                                   \
              if (GN_UNLIKELY (log_call_enabled))                               \
              GNUNET_log_nocheck ((kind), __VA_ARGS__);                       \
            }                                                                   \
          }                                                                     \
        } while (0)
#else
#define GNUNET_log(...)
#define GNUNET_log_from(...)
#endif
 
 
void
GNUNET_log_config_missing (enum GNUNET_ErrorType kind,
                           const char *section,
                           const char *option);
 
 
void
GNUNET_log_config_invalid (enum GNUNET_ErrorType kind,
                           const char *section,
                           const char *option,
                           const char *required);
 
 
void
GNUNET_abort_ (void) GNUNET_NORETURN;
 
 
const char *
GNUNET_b2s (const void *buf,
            size_t buf_size);
 
 
#define GNUNET_B2S(obj) GNUNET_b2s ((obj), sizeof (*(obj)))
 
 
void
GNUNET_log_skip (int n, int check_reset);
 
 
enum GNUNET_GenericReturnValue
GNUNET_log_setup (const char *comp,
                  const char *loglevel,
                  const char *logfile);
 
 
void
GNUNET_logger_add (GNUNET_Logger logger,
                   void *logger_cls);
 
 
void
GNUNET_logger_remove (GNUNET_Logger logger,
                      void *logger_cls);
 
 
const char *
GNUNET_sh2s (const struct GNUNET_ShortHashCode *shc);
 
 
const char *
GNUNET_uuid2s (const struct GNUNET_Uuid *uuid);
 
 
const char *
GNUNET_h2s (const struct GNUNET_HashCode *hc);
 
 
const char *
GNUNET_h2s2 (const struct GNUNET_HashCode *hc);
 
 
const char *
GNUNET_h2s_full (const struct GNUNET_HashCode *hc);
 
 
struct GNUNET_CRYPTO_EddsaPublicKey;
 
 
struct GNUNET_CRYPTO_EcdhePublicKey;
 
 
const char *
GNUNET_p2s (const struct GNUNET_CRYPTO_EddsaPublicKey *p);
 
 
const char *
GNUNET_p2s2 (const struct GNUNET_CRYPTO_EddsaPublicKey *p);
 
 
const char *
GNUNET_e2s (const struct GNUNET_CRYPTO_EcdhePublicKey *p);
 
 
const char *
GNUNET_e2s2 (const struct GNUNET_CRYPTO_EcdhePublicKey *p);
 
 
struct GNUNET_PeerIdentity;
 
 
const char *
GNUNET_i2s (const struct GNUNET_PeerIdentity *pid);
 
 
const char *
GNUNET_i2s2 (const struct GNUNET_PeerIdentity *pid);
 
 
const char *
GNUNET_i2s_full (const struct GNUNET_PeerIdentity *pid);
 
 
const char *
GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen);
 
size_t
GNUNET_hex2b (const char *src, void *dst, size_t dstlen, int invert);
 
void
GNUNET_print_bytes (const void *buf,
                    size_t buf_len,
                    int fold,
                    int in_be);
 
const char *
GNUNET_error_type_to_string (enum GNUNET_ErrorType kind);
 
 
#if __GNUC__ >= 6 || __clang_major__ >= 6
#define GNUNET_assert(cond)                                     \
        do                                                            \
        {                                                             \
          _Pragma("GCC diagnostic push")                                 \
          _Pragma("GCC diagnostic ignored \"-Wtautological-compare\"")   \
          if (! (cond))                                               \
          {                                                           \
          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                      \
          dgettext ("gnunet", "Assertion failed at %s:%d. Aborting.\n"), \
          __FILE__,                                     \
          __LINE__);                                    \
          GNUNET_abort_ ();                                         \
          }                                                           \
          _Pragma("GCC diagnostic pop")                                  \
          } while (0)
#else
/* older GCC/clangs do not support -Wtautological-compare */
#define GNUNET_assert(cond)                                     \
        do                                                            \
        {                                                             \
          if (! (cond))                                               \
          {                                                           \
            GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                      \
                        dgettext ("gnunet", \
                                  "Assertion failed at %s:%d. Aborting.\n"), \
                        __FILE__,                                     \
                        __LINE__);                                    \
            GNUNET_abort_ ();                                         \
          }                                                           \
        } while (0)
#endif
 
#define GNUNET_assert_at(cond, f, l)                            \
        do                                                            \
        {                                                             \
          if (! (cond))                                               \
          {                                                           \
            GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                      \
                        dgettext ("gnunet", \
                                  "Assertion failed at %s:%d. Aborting.\n"), \
                        f,                                            \
                        l);                                           \
            GNUNET_abort_ ();                                         \
          }                                                           \
        } while (0)
 
 
#define GNUNET_assert_from(cond, comp)                               \
        do                                                                 \
        {                                                                  \
          if (! (cond))                                                    \
          {                                                                \
            GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,                      \
                             comp,                                         \
                             dgettext ("gnunet", \
                                       "Assertion failed at %s:%d. Aborting.\n") \
                             , \
                             __FILE__,                                     \
                             __LINE__);                                    \
            GNUNET_abort_ ();                                              \
          }                                                                \
        } while (0)
 
 
#ifdef _Static_assert
#define GNUNET_static_assert(cond) _Static_assert (cond, "")
#else
#define GNUNET_static_assert(cond) GNUNET_assert (cond)
#endif
 
 
#define GNUNET_break(cond)                            \
        do                                                  \
        {                                                   \
          if (! (cond))                                     \
          {                                                 \
            GNUNET_log (GNUNET_ERROR_TYPE_ERROR,            \
                        dgettext ("gnunet", "Assertion failed at %s:%d.\n"),   \
                        __FILE__,                           \
                        __LINE__);                          \
          }                                                 \
        } while (0)
 
 
#define GNUNET_break_op(cond)                                             \
        do                                                                      \
        {                                                                       \
          if (! (cond))                                                         \
          {                                                                     \
            GNUNET_log (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,     \
                        dgettext ("gnunet", \
                                  "External protocol violation detected at %s:%d.\n"), \
                        __FILE__,                                               \
                        __LINE__);                                              \
          }                                                                     \
        } while (0)
 
 
#define GNUNET_log_strerror(level, cmd)                      \
        do                                                         \
        {                                                          \
          GNUNET_log (level,                                       \
                      dgettext ("gnunet", \
                                "`%s' failed at %s:%d with error: %s\n"), \
                      cmd,                                         \
                      __FILE__,                                    \
                      __LINE__,                                    \
                      strerror (errno));                           \
        } while (0)
 
 
#define GNUNET_log_from_strerror(level, component, cmd)           \
        do                                                              \
        {                                                               \
          GNUNET_log_from (level,                                       \
                           component,                                   \
                           dgettext ("gnunet", \
                                     "`%s' failed at %s:%d with error: %s\n"), \
                           cmd,                                         \
                           __FILE__,                                    \
                           __LINE__,                                    \
                           strerror (errno));                           \
        } while (0)
 
 
#define GNUNET_log_strerror_file(level, cmd, filename)                    \
        do                                                                      \
        {                                                                       \
          GNUNET_log (level,                                                    \
                      dgettext ("gnunet", \
                                "`%s' failed on file `%s' at %s:%d with error: %s\n"), \
                      cmd,                                                      \
                      filename,                                                 \
                      __FILE__,                                                 \
                      __LINE__,                                                 \
                      strerror (errno));                                        \
        } while (0)
 
 
#define GNUNET_log_from_strerror_file(level, component, cmd, filename)         \
        do                                                                           \
        {                                                                            \
          GNUNET_log_from (level,                                                    \
                           component,                                                \
                           dgettext ("gnunet", \
                                     "`%s' failed on file `%s' at %s:%d with error: %s\n"), \
                           cmd,                                                      \
                           filename,                                                 \
                           __FILE__,                                                 \
                           __LINE__,                                                 \
                           strerror (errno));                                        \
        } while (0)
 
/* ************************* endianness conversion ****************** */
 
#ifdef htobe64
 
#define GNUNET_htonll(n) htobe64 (n)
 
#else
uint64_t
GNUNET_htonll (uint64_t n);
 
#endif
 
 
#ifdef be64toh
 
#define GNUNET_ntohll(n) be64toh (n)
 
#else
uint64_t
GNUNET_ntohll (uint64_t n);
 
#endif
 
 
double
GNUNET_hton_double (double d);
 
 
double
GNUNET_ntoh_double (double d);
 
 
/* ************************* allocation functions ****************** */
 
#define GNUNET_MAX_MALLOC_CHECKED (1024 * 1024 * 40)
 
#define GNUNET_new(type) (type *) GNUNET_malloc (sizeof(type))
 
 
#define GNUNET_memcmp(a, b)       \
        ({                              \
    const typeof (*b) * _a = (a);  \
    const typeof (*a) * _b = (b);  \
    memcmp (_a, _b, sizeof(*a)); \
  })
 
 
int
GNUNET_memcmp_ct_ (const void *b1,
                   const void *b2,
                   size_t len);
 
#define GNUNET_memcmp_priv(a, b)       \
        ({                              \
    const typeof (*b) * _a = (a);  \
    const typeof (*a) * _b = (b);  \
    GNUNET_memcmp_ct_ (_a, _b, sizeof(*a)); \
  })
 
 
bool
GNUNET_is_zero_ (const void *a,
                 size_t n);
 
 
#define GNUNET_is_zero(a)           \
        GNUNET_is_zero_ ((a), sizeof (*(a)))
 
 
#define GNUNET_memcpy(dst, src, n) \
        do                               \
        {                                \
          if (0 != n)                    \
          {                              \
            (void) memcpy (dst, src, n); \
          }                              \
        } while (0)
 
 
/* *INDENT-OFF* */
#define GNUNET_new_array(n, type) ({ \
    GNUNET_assert (SIZE_MAX / sizeof (type) >= n);     \
    (type *) GNUNET_malloc ((n) * sizeof(type));   \
  })
/* *INDENT-ON* */
 
#define GNUNET_malloc(size) GNUNET_xmalloc_ (size, __FILE__, __LINE__)
 
#define GNUNET_memdup(buf, size) GNUNET_xmemdup_ (buf, size, __FILE__, __LINE__)
 
#define GNUNET_malloc_large(size) \
        GNUNET_xmalloc_unchecked_ (size, __FILE__, __LINE__)
 
 
#define GNUNET_realloc(ptr, size) \
        GNUNET_xrealloc_ (ptr, size, __FILE__, __LINE__)
 
 
#define GNUNET_free_nz(ptr) GNUNET_xfree_ (ptr, __FILE__, __LINE__)
 
 
#define GNUNET_free(ptr) do { \
          GNUNET_xfree_ (ptr, __FILE__, __LINE__); \
          ptr = NULL; \
} while (0)
 
 
#define GNUNET_strdup(a) GNUNET_xstrdup_ (a, __FILE__, __LINE__)
 
 
#define GNUNET_strndup(a, length) \
        GNUNET_xstrndup_ (a, length, __FILE__, __LINE__)
 
#define GNUNET_array_grow(arr, size, tsize) \
        GNUNET_xgrow_ ((void **) &(arr),          \
                       sizeof((arr)[0]),         \
                       &size,                     \
                       tsize,                     \
                       __FILE__,                  \
                       __LINE__)
 
#define GNUNET_array_append(arr, len, element) \
        do                                            \
        {                                             \
          GNUNET_assert ((len) + 1 > (len)); \
          GNUNET_array_grow (arr, len, len + 1);    \
          (arr) [len - 1] = element;                  \
        } while (0)
 
 
#define GNUNET_array_concatenate(arr1, len1, arr2, len2)   \
        do                                            \
        {                                             \
          const typeof (*arr2) * _a1 = (arr1);  \
          const typeof (*arr1) * _a2 = (arr2);  \
          GNUNET_assert ((len1) + (len2) >= (len1));                    \
          GNUNET_assert (SIZE_MAX / sizeof (*_a1) >= ((len1) + (len2))); \
          GNUNET_array_grow (arr1, len1, (len1) + (len2));            \
          memcpy (&(arr1) [(len1) - (len2)], _a2, (len2) * sizeof (*arr1));    \
        } while (0)
 
 
int
GNUNET_snprintf (char *buf,
                 size_t size,
                 const char *format,
                 ...)
__attribute__ ((format (printf, 3, 4)));
 
 
int
GNUNET_asprintf (char **buf,
                 const char *format,
                 ...)
__attribute__ ((format (printf, 2, 3)));
 
 
/* ************** internal implementations, use macros above! ************** */
 
void *
GNUNET_xmalloc_ (size_t size,
                 const char *filename,
                 int linenumber);
 
 
void *
GNUNET_xmemdup_ (const void *buf,
                 size_t size,
                 const char *filename,
                 int linenumber);
 
 
void *
GNUNET_xmalloc_unchecked_ (size_t size,
                           const char *filename,
                           int linenumber);
 
 
void *
GNUNET_xrealloc_ (void *ptr,
                  size_t n,
                  const char *filename,
                  int linenumber);
 
 
void
GNUNET_xfree_ (void *ptr,
               const char *filename,
               int linenumber);
 
 
char *
GNUNET_xstrdup_ (const char *str,
                 const char *filename,
                 int linenumber);
 
char *
GNUNET_xstrndup_ (const char *str,
                  size_t len,
                  const char *filename,
                  int linenumber);
 
void
GNUNET_xgrow_ (void **old,
               size_t elementSize,
               unsigned int *oldCount,
               unsigned int newCount,
               const char *filename,
               int linenumber);
 
 
struct GNUNET_MessageHeader *
GNUNET_copy_message (const struct GNUNET_MessageHeader *msg);
 
 
void
GNUNET_async_scope_enter (const struct GNUNET_AsyncScopeId *aid,
                          struct GNUNET_AsyncScopeSave *old_scope);
 
 
void
GNUNET_async_scope_restore (struct GNUNET_AsyncScopeSave *old_scope);
 
 
void
GNUNET_async_scope_get (struct GNUNET_AsyncScopeSave *scope_ret);
 
 
void
GNUNET_async_scope_fresh (struct GNUNET_AsyncScopeId *aid_ret);
 
 
#if __STDC_VERSION__ < 199901L
#if __GNUC__ >= 2
#define __func__ __FUNCTION__
#else
#define __func__ "<unknown>"
#endif
#endif
 
 
enum GNUNET_SCHEDULER_Priority
{
  GNUNET_SCHEDULER_PRIORITY_KEEP = 0,
 
  GNUNET_SCHEDULER_PRIORITY_IDLE = 1,
 
  GNUNET_SCHEDULER_PRIORITY_BACKGROUND = 2,
 
  GNUNET_SCHEDULER_PRIORITY_DEFAULT = 3,
 
  GNUNET_SCHEDULER_PRIORITY_HIGH = 4,
 
  GNUNET_SCHEDULER_PRIORITY_UI = 5,
 
  GNUNET_SCHEDULER_PRIORITY_URGENT = 6,
 
  GNUNET_SCHEDULER_PRIORITY_SHUTDOWN = 7,
 
  GNUNET_SCHEDULER_PRIORITY_COUNT = 8
};
 
 
/* *INDENT-OFF* */
 
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
#endif /* GNUNET_COMMON_H */