gnunet_common.h

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2006-2020 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 <stdlib.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_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.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 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

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


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,
                         ...)
__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;


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


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


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)


#if HAVE_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,            \
                  _ ("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)

/* ************************* endianness conversion ****************** */

#ifdef htonbe64

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


enum GNUNET_GenericReturnValue
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)


#define GNUNET_new_array(n, type) ({ \
    GNUNET_assert (SIZE_MAX / sizeof (type) >= n);     \
    (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_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_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 */