/*
This file is part of GNUnet.
- (C) 2006-2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2006-2013 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
#include <stdarg.h>
#endif
+#ifdef HAVE_BYTESWAP_H
+#include <byteswap.h>
+#endif
+
#ifdef __cplusplus
extern "C"
{
/**
* Version of the API (for entire gnunetutil.so library).
*/
-#define GNUNET_UTIL_VERSION 0x00090501
+#define GNUNET_UTIL_VERSION 0x000A0100
+
/**
- * Named constants for return values. The following
- * invariants hold: "GNUNET_NO == 0" (to allow "if (GNUNET_NO)")
- * "GNUNET_OK != GNUNET_SYSERR", "GNUNET_OK != GNUNET_NO", "GNUNET_NO != GNUNET_SYSERR"
- * and finally "GNUNET_YES != GNUNET_NO".
+ * Named constants for return values. The following invariants hold:
+ * `GNUNET_NO == 0` (to allow `if (GNUNET_NO)`) `GNUNET_OK !=
+ * GNUNET_SYSERR`, `GNUNET_OK != GNUNET_NO`, `GNUNET_NO !=
+ * GNUNET_SYSERR` and finally `GNUNET_YES != GNUNET_NO`.
*/
#define GNUNET_OK 1
#define GNUNET_SYSERR -1
/**
* @ingroup logging
- * define GNUNET_EXTRA_LOGGING if using this header outside the GNUnet source
+ * define #GNUNET_EXTRA_LOGGING if using this header outside the GNUnet source
* tree where gnunet_config.h is unavailable
*/
#ifndef GNUNET_EXTRA_LOGGING
/**
* Define as empty, GNUNET_PACKED should suffice, but this won't work on W32
*/
-#define GNUNET_NETWORK_STRUCT_BEGIN
+#define GNUNET_NETWORK_STRUCT_BEGIN
/**
* Define as empty, GNUNET_PACKED should suffice, but this won't work on W32;
};
+
+/**
+ * Answer from service to client about last operation.
+ */
+struct GNUNET_OperationResultMessage
+{
+ struct GNUNET_MessageHeader header;
+
+ uint32_t reserved GNUNET_PACKED;
+
+ /**
+ * Operation ID.
+ */
+ uint64_t op_id GNUNET_PACKED;
+
+ /**
+ * Status code for the operation.
+ */
+ uint64_t result_code GNUNET_PACKED;
+
+ /* Followed by data. */
+};
+
GNUNET_NETWORK_STRUCT_END
/**
* #GNUNET_NO to stop iteration with no error,
* #GNUNET_SYSERR to abort iteration with error!
*/
-typedef int (*GNUNET_FileNameCallback) (void *cls, const char *filename);
+typedef int
+(*GNUNET_FileNameCallback) (void *cls,
+ const char *filename);
+
+
+/**
+ * Generic continuation callback.
+ *
+ * @param cls Closure.
+ */
+typedef void
+(*GNUNET_ContinuationCallback) (void *cls);
+
+
+/**
+ * Function called with the result of an asynchronous operation.
+ *
+ * @param cls
+ * Closure.
+ * @param result_code
+ * Result code for the operation.
+ * @param data
+ * Data result for the operation.
+ * @param data_size
+ * Size of @a data.
+ */
+typedef void
+(*GNUNET_ResultCallback) (void *cls, int64_t result_code,
+ const void *data, uint16_t data_size);
/* ****************************** logging ***************************** */
* @param date when was the message logged?
* @param message what is the message
*/
-typedef void (*GNUNET_Logger) (void *cls, enum GNUNET_ErrorType kind,
- const char *component, const char *date,
- const char *message);
+typedef void
+(*GNUNET_Logger) (void *cls,
+ enum GNUNET_ErrorType kind,
+ const char *component,
+ const char *date,
+ const char *message);
/**
* @return number of log calls to be ignored
*/
int
-GNUNET_get_log_skip ();
+GNUNET_get_log_skip (void);
+
#if !defined(GNUNET_CULL_LOGGING)
int
-GNUNET_get_log_call_status (int caller_level,
+GNUNET_get_log_call_status (int caller_level,
const char *comp,
- const char *file,
- const char *function, int line);
+ const char *file,
+ const char *function,
+ int line);
#endif
}\
} while (0)
-#define GNUNET_log(kind,...) do { int log_line = __LINE__;\
+ #define GNUNET_log(kind,...) do { int log_line = __LINE__;\
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))\
* @param option name of missing option
*/
void
-GNUNET_log_config_missing (enum GNUNET_ErrorType kind,
+GNUNET_log_config_missing (enum GNUNET_ErrorType kind,
const char *section,
const char *option);
* @param required what is required that is invalid about the option
*/
void
-GNUNET_log_config_invalid (enum GNUNET_ErrorType kind,
+GNUNET_log_config_invalid (enum GNUNET_ErrorType kind,
const char *section,
const char *option,
const char *required);
/**
* @ingroup logging
* Abort the process, generate a core dump if possible.
+ * Most code should use `GNUNET_assert (0)` instead to
+ * first log the location of the failure.
*/
void
-GNUNET_abort (void) GNUNET_NORETURN;
+GNUNET_abort_ (void) GNUNET_NORETURN;
/**
* Ignore the next @a n calls to the log function.
*
* @param n number of log calls to ignore (could be negative)
- * @param check_reset GNUNET_YES to assert that the log skip counter is currently zero
+ * @param check_reset #GNUNET_YES to assert that the log skip counter is currently zero
*/
void
-GNUNET_log_skip (int n, int check_reset);
+GNUNET_log_skip (int n,
+ int check_reset);
/**
* @return #GNUNET_OK on success, #GNUNET_SYSERR if logfile could not be opened
*/
int
-GNUNET_log_setup (const char *comp, const char *loglevel, const char *logfile);
+GNUNET_log_setup (const char *comp,
+ const char *loglevel,
+ const char *logfile);
/**
* @param logger_cls closure for @a logger
*/
void
-GNUNET_logger_add (GNUNET_Logger logger, void *logger_cls);
+GNUNET_logger_add (GNUNET_Logger logger,
+ void *logger_cls);
/**
* Remove a custom logger.
*
* @param logger log function
- * @param logger_cls closure for logger
+ * @param logger_cls closure for @a logger
*/
void
-GNUNET_logger_remove (GNUNET_Logger logger, void *logger_cls);
+GNUNET_logger_remove (GNUNET_Logger logger,
+ void *logger_cls);
/**
*
* @param pid the peer identity
* @return string form of the pid; will be overwritten by next
- * call to #GNUNET_i2s.
+ * call to #GNUNET_i2s().
*/
const char *
GNUNET_i2s (const struct GNUNET_PeerIdentity *pid);
*
* @param pid the peer identity
* @return string form of the pid; will be overwritten by next
- * call to #GNUNET_i2s.
+ * call to #GNUNET_i2s_full().
*/
const char *
GNUNET_i2s_full (const struct GNUNET_PeerIdentity *pid);
* in the entire API that is NOT reentrant!
*
* @param addr the address
- * @param addrlen the length of the address
+ * @param addrlen the length of the @a addr
* @return nicely formatted string for the address
- * will be overwritten by next call to GNUNET_a2s.
+ * will be overwritten by next call to #GNUNET_a2s().
*/
const char *
-GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen);
+GNUNET_a2s (const struct sockaddr *addr,
+ socklen_t addrlen);
/**
* @ingroup logging
* Use this for fatal errors that cannot be handled
*/
-#define GNUNET_assert(cond) do { if (! (cond)) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Assertion failed at %s:%d.\n"), __FILE__, __LINE__); GNUNET_abort(); } } while(0)
+#define GNUNET_assert(cond) do { if (! (cond)) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Assertion failed at %s:%d.\n"), __FILE__, __LINE__); GNUNET_abort_(); } } while(0)
/**
* @ingroup logging
* Use this for fatal errors that cannot be handled
*/
-#define GNUNET_assert_at(cond, f, l) do { if (! (cond)) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Assertion failed at %s:%d.\n"), f, l); 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.\n"), f, l); GNUNET_abort_(); } } while(0)
/**
/* ************************* endianess conversion ****************** */
/**
- * Convert unsigned 64-bit integer to host-byte-order.
- * @param n the value in network byte order
- * @return the same value in host byte order
+ * Convert unsigned 64-bit integer to network byte order.
+ *
+ * @param n
+ * The value in host byte order.
+ *
+ * @return The same value in network byte order.
*/
uint64_t
-GNUNET_ntohll (uint64_t n);
+GNUNET_htonll (uint64_t n);
+
/**
- * Convert unsigned 64-bit integer to network-byte-order.
- * @param n the value in host byte order
- * @return the same value in network byte order
+ * Convert unsigned 64-bit integer to host byte order.
+ *
+ * @param n
+ * The value in network byte order.
+ *
+ * @return The same value in host byte order.
*/
uint64_t
-GNUNET_htonll (uint64_t n);
+GNUNET_ntohll (uint64_t n);
+
/**
- * Convert double to network-byte-order.
- * @param d the value in network byte order
- * @return the same value in host byte order
+ * Convert double to network byte order.
+ *
+ * @param d
+ * The value in host byte order.
+ *
+ * @return The same value in network byte order.
*/
-double
+double
GNUNET_hton_double (double d);
+
/**
- * Convert double to host-byte-order
- * @param d the value in network byte order
- * @return the same value in host byte order
+ * Convert double to host byte order
+ *
+ * @param d
+ * The value in network byte order.
+ *
+ * @return The same value in host byte order.
*/
-double
+double
GNUNET_ntoh_double (double d);
+
/* ************************* allocation functions ****************** */
/**
*/
#define GNUNET_new(type) (type *) GNUNET_malloc (sizeof (type))
+/**
+ * @ingroup memory
+ * Allocate a size @a n array with structs or unions of the given @a type.
+ * Wrapper around #GNUNET_malloc that returns a pointer
+ * to the newly created objects of the correct type.
+ *
+ * @param n number of elements in the array
+ * @param type name of the struct or union, i.e. pass 'struct Foo'.
+ */
+#define GNUNET_new_array(n, type) (type *) GNUNET_malloc ((n) * sizeof (type))
+
/**
* @ingroup memory
* Wrapper around malloc. Allocates size bytes of memory.
#endif
+/**
+ * Valid task priorities. Use these, do not pass random integers!
+ * For various reasons (#3862 -- building with QT Creator, and
+ * our restricted cross-compilation with emscripten) this cannot
+ * be in gnunet_scheduler_lib.h, but it works if we declare it here.
+ * Naturally, logically this is part of the scheduler.
+ */
+enum GNUNET_SCHEDULER_Priority
+{
+ /**
+ * Run with the same priority as the current job.
+ */
+ GNUNET_SCHEDULER_PRIORITY_KEEP = 0,
+
+ /**
+ * Run when otherwise idle.
+ */
+ GNUNET_SCHEDULER_PRIORITY_IDLE = 1,
+
+ /**
+ * Run as background job (higher than idle,
+ * lower than default).
+ */
+ GNUNET_SCHEDULER_PRIORITY_BACKGROUND = 2,
+
+ /**
+ * Run with the default priority (normal
+ * P2P operations). Any task that is scheduled
+ * without an explicit priority being specified
+ * will run with this priority.
+ */
+ GNUNET_SCHEDULER_PRIORITY_DEFAULT = 3,
+
+ /**
+ * Run with high priority (important requests).
+ * Higher than DEFAULT.
+ */
+ GNUNET_SCHEDULER_PRIORITY_HIGH = 4,
+
+ /**
+ * Run with priority for interactive tasks.
+ * Higher than "HIGH".
+ */
+ GNUNET_SCHEDULER_PRIORITY_UI = 5,
+
+ /**
+ * Run with priority for urgent tasks. Use
+ * for things like aborts and shutdowns that
+ * need to preempt "UI"-level tasks.
+ * Higher than "UI".
+ */
+ GNUNET_SCHEDULER_PRIORITY_URGENT = 6,
+
+ /**
+ * This is an internal priority level that is only used for tasks
+ * that are being triggered due to shutdown (they have automatically
+ * highest priority). User code must not use this priority level
+ * directly. Tasks run with this priority level that internally
+ * schedule other tasks will see their original priority level
+ * be inherited (unless otherwise specified).
+ */
+ GNUNET_SCHEDULER_PRIORITY_SHUTDOWN = 7,
+
+ /**
+ * Number of priorities (must be the last priority).
+ * This priority must not be used by clients.
+ */
+ GNUNET_SCHEDULER_PRIORITY_COUNT = 8
+};
#if 0 /* keep Emacsens' auto-indent happy */
projects / oweals / gnunet.git / blobdiff