gnunet_common.h

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2006-2013 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

#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#if HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif
#ifdef HAVE_STDARG_H
#include <stdarg.h>
#endif

#ifdef HAVE_BYTESWAP_H
#include <byteswap.h>
#endif

#ifdef __cplusplus
extern "C" {
#if 0 /* keep Emacsens' auto-indent happy */
}
#endif
#endif

#define GNUNET_UTIL_VERSION 0x000A0103


#define GNUNET_OK 1
#define GNUNET_SYSERR -1
#define GNUNET_YES 1
#define GNUNET_NO 0

#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

#define GNUNET_VA_ARG_ENUM(va, X) ((enum X)va_arg(va, int))


#ifndef GNUNET_EXTRA_LOGGING
#define GNUNET_EXTRA_LOGGING 0
#endif

#if __BYTE_ORDER == __LITTLE_ENDIAN
#define GNUNET_htobe16(x) __bswap_16(x)
#define GNUNET_htole16(x) (x)
#define GNUNET_be16toh(x) __bswap_16(x)
#define GNUNET_le16toh(x) (x)

#define GNUNET_htobe32(x) __bswap_32(x)
#define GNUNET_htole32(x) (x)
#define GNUNET_be32toh(x) __bswap_32(x)
#define GNUNET_le32toh(x) (x)

#define GNUNET_htobe64(x) __bswap_64(x)
#define GNUNET_htole64(x) (x)
#define GNUNET_be64toh(x) __bswap_64(x)
#define GNUNET_le64toh(x) (x)
#endif
#if __BYTE_ORDER == __BIG_ENDIAN
#define GNUNET_htobe16(x) (x)
#define GNUNET_htole16(x) __bswap_16(x)
#define GNUNET_be16toh(x) (x)
#define GNUNET_le16toh(x) __bswap_16(x)

#define GNUNET_htobe32(x) (x)
#define GNUNET_htole32(x) __bswap_32(x)
#define GNUNET_be32toh(x) (x)
#define GNUNET_le32toh(x) __bswap_32(x)

#define GNUNET_htobe64(x) (x)
#define GNUNET_htole64(x) __bswap_64(x)
#define GNUNET_be64toh(x) (x)
#define GNUNET_le64toh(x) __bswap_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_OperationResultMessage {
  struct GNUNET_MessageHeader header;

  uint32_t reserved GNUNET_PACKED;

  uint64_t op_id GNUNET_PACKED;

  uint64_t result_code GNUNET_PACKED;

  /* Followed by data. */
};


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 int (*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


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


void
GNUNET_log_from_nocheck(enum GNUNET_ErrorType kind,
                        const char *comp,
                        const char *message,
                        ...);

#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;


void
GNUNET_log_skip(int n, int check_reset);


int
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);


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);


const char *
GNUNET_error_type_to_string(enum GNUNET_ErrorType kind);


#define GNUNET_assert(cond)                                     \
  do                                                            \
  {                                                             \
    if (!(cond))                                               \
    {                                                           \
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,                      \
                 _("Assertion failed at %s:%d. Aborting.\n"), \
                 __FILE__,                                     \
                 __LINE__);                                    \
      GNUNET_abort_();                                         \
    }                                                           \
  } while (0)


#define GNUNET_assert_at(cond, f, l)                            \
  do                                                            \
  {                                                             \
    if (!(cond))                                               \
    {                                                           \
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,                      \
                 _("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,                                         \
                      _("Assertion failed at %s:%d. Aborting.\n"), \
                      __FILE__,                                     \
                      __LINE__);                                    \
      GNUNET_abort_();                                              \
    }                                                                \
  } while (0)


#define GNUNET_break(cond)                            \
  do                                                  \
  {                                                   \
    if (!(cond))                                     \
    {                                                 \
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,            \
                 _("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,     \
                 _("External protocol violation detected at %s:%d.\n"), \
                 __FILE__,                                               \
                 __LINE__);                                              \
    }                                                                     \
  } while (0)


#define GNUNET_log_strerror(level, cmd)                      \
  do                                                         \
  {                                                          \
    GNUNET_log(level,                                       \
               _("`%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,                                   \
                    _("`%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,                                                    \
               _("`%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,                                                \
                    _("`%s' failed on file `%s' at %s:%d with error: %s\n"), \
                    cmd,                                                      \
                    filename,                                                 \
                    __FILE__,                                                 \
                    __LINE__,                                                 \
                    strerror(errno));                                        \
  } while (0)

/* ************************* endianess conversion ****************** */

uint64_t
GNUNET_htonll(uint64_t n);


uint64_t
GNUNET_ntohll(uint64_t n);


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)); \
  })


#define GNUNET_is_zero(a)           \
  ({                                \
    static const typeof (*a) _z;    \
    memcmp((a), &_z, sizeof(_z)); \
  })


#define GNUNET_memcpy(dst, src, n) \
  do                               \
  {                                \
    if (0 != n)                    \
    {                              \
      (void)memcpy(dst, src, n); \
    }                              \
  } while (0)


#define GNUNET_new_array(n, type) (type *)GNUNET_malloc((n) * sizeof(type))

#define GNUNET_new_array_2d(n, m, type) \
  (type **)GNUNET_xnew_array_2d_(n, m, sizeof(type), __FILE__, __LINE__)

#define GNUNET_new_array_3d(n, m, o, type) \
  (type ***)GNUNET_xnew_array_3d_(n, m, o, sizeof(type), __FILE__, __LINE__)

#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(ptr) GNUNET_xfree_(ptr, __FILE__, __LINE__)

#define GNUNET_free_non_null(ptr) \
  do                              \
  {                               \
    void *__x__ = ptr;            \
    if (__x__ != NULL)            \
    {                             \
      GNUNET_free(__x__);        \
    }                             \
  } 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, size, element) \
  do                                            \
  {                                             \
    GNUNET_array_grow(arr, size, size + 1);    \
    (arr)[size - 1] = element;                  \
  } while (0)

int
GNUNET_snprintf(char *buf, size_t size, const char *format, ...);


int
GNUNET_asprintf(char **buf, const char *format, ...);


/* ************** internal implementations, use macros above! ************** */

void *
GNUNET_xmalloc_(size_t size, const char *filename, int linenumber);


void **
GNUNET_xnew_array_2d_(size_t n,
                      size_t m,
                      size_t elementSize,
                      const char *filename,
                      int linenumber);


void ***
GNUNET_xnew_array_3d_(size_t n,
                      size_t m,
                      size_t o,
                      size_t elementSize,
                      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
};


#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif

#endif /* GNUNET_COMMON_H */