/**
* Allocate and initialize memory. Checks the return value, aborts if no more
* memory is available. Don't use GNUNET_xmemdup_ directly. Use the
* GNUNET_memdup macro.
*
* @param buf buffer to initialize from (must contain size bytes)
* @param size number of bytes to allocate
* @param filename where is this call being made (for debugging)
* @param linenumber line where this call is being made (for debugging)
* @return allocated memory, never NULL
*/
void *
GNUNET_xmemdup_ (const void *buf, size_t size, const char *filename,
int linenumber)
{
void *ret;
/* As a security precaution, we generally do not allow very large
* allocations here */
GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
#ifdef W32_MEM_LIMIT
size += sizeof (size_t);
if (mem_used + size > W32_MEM_LIMIT)
return NULL;
#endif
GNUNET_assert_at (size < INT_MAX, filename, linenumber);
ret = malloc (size);
if (ret == NULL)
{
LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
GNUNET_abort ();
}
#ifdef W32_MEM_LIMIT
*((size_t *) ret) = size;
ret = &((size_t *) ret)[1];
mem_used += size;
#endif
memcpy (ret, buf, size);
return ret;
}
/**
* Allocate memory. Checks the return value, aborts if no more
* memory is available.
*
* @param size how many bytes of memory to allocate, do NOT use
* this function (or GNUNET_malloc) to allocate more than several MB
* of memory, if you are possibly needing a very large chunk use
* GNUNET_xmalloc_unchecked_ instead.
* @param filename where in the code was the call to GNUNET_malloc
* @param linenumber where in the code was the call to GNUNET_malloc
* @return pointer to size bytes of memory
*/
void *
GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
{
void *ret;
/* As a security precaution, we generally do not allow very large
* allocations using the default 'GNUNET_malloc' macro */
GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
ret = GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
if (ret == NULL)
{
LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
GNUNET_abort ();
}
return ret;
}
/**
* Reallocate memory. Checks the return value, aborts if no more
* memory is available.
*
* @param ptr the pointer to reallocate
* @param n how many bytes of memory to allocate
* @param filename where in the code was the call to GNUNET_realloc
* @param linenumber where in the code was the call to GNUNET_realloc
* @return pointer to size bytes of memory
*/
void *
GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
{
#ifdef W32_MEM_LIMIT
n += sizeof (size_t);
ptr = &((size_t *) ptr)[-1];
mem_used = mem_used - *((size_t *) ptr) + n;
#endif
ptr = realloc (ptr, n);
if ((NULL == ptr) && (n > 0))
{
LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "realloc");
GNUNET_abort ();
}
#ifdef W32_MEM_LIMIT
ptr = &((size_t *) ptr)[1];
#endif
return ptr;
}
static int
handle_test (void *cls,
const struct GNUNET_PeerIdentity *other,
const struct GNUNET_MessageHeader *message)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got test message %d\n", num_received);
num_received++;
if (NUM_MSG == num_received)
{
result = GNUNET_OK;
GNUNET_SCHEDULER_shutdown ();
return GNUNET_SYSERR;
}
if (num_received > NUM_MSG)
{
GNUNET_abort ();
return GNUNET_SYSERR;
}
return GNUNET_OK;
}
/**
* Initialize framework and start test
*
* @param cls Closure (unused).
* @param cfg Configuration handle.
* @param peer Testing peer handle.
*/
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
static const struct GNUNET_CORE_MessageHandler handlers[] = {
{&handle_test, GNUNET_MESSAGE_TYPE_TEST, 0},
{NULL, 0, 0}
};
core = GNUNET_CORE_connect (cfg,
NULL, &init_cb, &connect_cb, NULL,
NULL, GNUNET_NO, NULL,
GNUNET_NO, handlers);
if (NULL == core)
{
GNUNET_abort ();
return;
}
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task, NULL);
}
