GNUnet 0.22.0
rps-test_util.c File Reference

Some utils facilitating the view into the internals for the sampler needed for evaluation. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "rps-test_util.h"
#include <inttypes.h>
Include dependency graph for rps-test_util.c:

Go to the source code of this file.

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "rps-test_util", __VA_ARGS__)
 
#define B2B_PAT   "%c%c%c%c%c%c%c%c"
 
#define B2B(byte)
 

Functions

struct GNUNET_DISK_FileHandleget_file_handle (const char *name)
 Get file handle. More...
 
int close_files_iter (void *cls, const struct GNUNET_HashCode *key, void *value)
 Closes the file of the current entry. More...
 
int close_all_files ()
 Close all files that were opened with get_file_handle. More...
 
void to_file_raw (const char *file_name, const char *buf, size_t size_buf)
 
void to_file_raw_unaligned (const char *file_name, const char *buf, size_t size_buf, unsigned bits_needed)
 
char * auth_key_to_string (struct GNUNET_CRYPTO_AuthKey auth_key)
 
struct GNUNET_CRYPTO_AuthKey string_to_auth_key (const char *str)
 
static int ensure_folder_exist (void)
 Try to ensure that /tmp/rps exists. More...
 
char * store_prefix_file_name (const unsigned int index, const char *prefix)
 
uint32_t fac (uint32_t x)
 Factorial. More...
 
uint32_t binom (uint32_t n, uint32_t k)
 Binomial coefficient (n choose k) More...
 

Variables

static char buf_unaligned
 buffer for storing the unaligned bits for the next write More...
 
static unsigned num_bits_buf_unaligned
 number of bits in unaligned buffer More...
 
static struct GNUNET_CONTAINER_MultiHashMapopen_files
 

Detailed Description

Some utils facilitating the view into the internals for the sampler needed for evaluation.

Author
Julius Bünger

Definition in file rps-test_util.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "rps-test_util", __VA_ARGS__)

Definition at line 35 of file rps-test_util.c.

◆ B2B_PAT

#define B2B_PAT   "%c%c%c%c%c%c%c%c"

Definition at line 37 of file rps-test_util.c.

◆ B2B

#define B2B (   byte)
Value:
(byte & 0x80 ? '1' : '0'), \
(byte & 0x40 ? '1' : '0'), \
(byte & 0x20 ? '1' : '0'), \
(byte & 0x10 ? '1' : '0'), \
(byte & 0x08 ? '1' : '0'), \
(byte & 0x04 ? '1' : '0'), \
(byte & 0x02 ? '1' : '0'), \
(byte & 0x01 ? '1' : '0')

Definition at line 38 of file rps-test_util.c.

Function Documentation

◆ get_file_handle()

struct GNUNET_DISK_FileHandle * get_file_handle ( const char *  name)

Get file handle.

If necessary, create file handle and store it with the other file handles.

Parameters
nameName of the file
Returns
File handle

Definition at line 74 of file rps-test_util.c.

75{
76 struct GNUNET_HashCode hash;
77 struct GNUNET_DISK_FileHandle *fh;
78
79 if (NULL == open_files)
80 {
82 GNUNET_NO);
84 "Created map of open files.\n");
85 }
87 strlen (name),
88 &hash);
90 &hash)))
91 return fh;
99 if (NULL == fh)
100 {
102 "Opening file `%s' failed.\n",
103 name);
104 GNUNET_assert (0);
105 }
108 &hash,
109 fh,
111 return fh;
112}
static char * name
Name (label) of the records to list.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1238
@ GNUNET_DISK_OPEN_WRITE
Open the file for writing.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.
@ GNUNET_DISK_OPEN_APPEND
Append to the file.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_GROUP_READ
Group can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
@ GNUNET_YES
@ GNUNET_NO
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
static struct GNUNET_CONTAINER_MultiHashMap * open_files
Definition: rps-test_util.c:61
#define LOG(kind,...)
Definition: rps-test_util.c:35
Handle used to access files (and pipes).
A 512-bit hashcode.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_APPEND, GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_NO, GNUNET_YES, LOG, name, and open_files.

Here is the call graph for this function:

◆ close_files_iter()

int close_files_iter ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)

Closes the file of the current entry.

Implements #GNUNET_CONTAINER_HashMapIterator

Parameters
clsunused
keyunused
valuethe file handle
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 129 of file rps-test_util.c.

132{
133 (void) cls;
134 (void) key;
135 struct GNUNET_DISK_FileHandle *fh = value;
136
137 if (NULL != fh)
138 {
140 }
141 return GNUNET_YES;
142}
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1309

References GNUNET_DISK_file_close(), GNUNET_YES, key, and value.

Referenced by close_all_files().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ close_all_files()

int close_all_files ( )

Close all files that were opened with get_file_handle.

Returns
Success of iterating over files

Definition at line 151 of file rps-test_util.c.

152{
153 int ret;
154
155 if (NULL != open_files)
156 {
159 NULL);
161 open_files = NULL;
162 return ret;
163 }
164 return GNUNET_YES;
165}
static int ret
Final status code.
Definition: gnunet-arm.c:93
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
int close_files_iter(void *cls, const struct GNUNET_HashCode *key, void *value)
Closes the file of the current entry.

References close_files_iter(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_YES, open_files, and ret.

Referenced by shutdown_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ to_file_raw()

void to_file_raw ( const char *  file_name,
const char *  buf,
size_t  size_buf 
)

Definition at line 169 of file rps-test_util.c.

170{
172 size_t size_written;
173
174 if (NULL == (f = GNUNET_DISK_file_open (file_name,
182 {
184 "Not able to open file %s\n",
185 file_name);
186 return;
187 }
188
189 size_written = GNUNET_DISK_file_write (f, buf, size_buf);
190 if (size_buf != size_written)
191 {
193 "Unable to write to file! (Size: %llu, size_written: %llu)\n",
194 (unsigned long long) size_buf,
195 (unsigned long long) size_written);
196
199 "Unable to close file\n");
200
201 return;
202 }
204 "Wrote %llu bytes raw.\n",
205 (unsigned long long) size_written);
208 "Unable to close file\n");
209}
static char * file_name
Dump file name.
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:687
@ GNUNET_DISK_PERM_OTHER_READ
Everybody can read.
@ GNUNET_ERROR_TYPE_WARNING

References removetrailingwhitespace::f, file_name, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_APPEND, GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_OTHER_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_WARNING, GNUNET_YES, and LOG.

Referenced by to_file_raw_unaligned().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ to_file_raw_unaligned()

void to_file_raw_unaligned ( const char *  file_name,
const char *  buf,
size_t  size_buf,
unsigned  bits_needed 
)

Definition at line 213 of file rps-test_util.c.

217{
218 // TODO endianness!
219 GNUNET_assert (size_buf >= (bits_needed / 8));
220 // if (0 == num_bits_buf_unaligned)
221 // {
222 // if (0 == (bits_needed % 8))
223 // {
224 // to_file_raw (file_name, buf, size_buf);
225 // return;
226 // }
227 // to_file_raw (file_name, buf, size_buf - 1);
228 // buf_unaligned = buf[size_buf - 1];
229 // num_bits_buf_unaligned = bits_needed % 8;
230 // return;
231 // }
233 "Was asked to write %u bits\n", bits_needed);
234
235 char buf_write[size_buf + 1];
236 const unsigned bytes_iter = (0 != bits_needed % 8 ?
237 (bits_needed / 8) + 1 :
238 bits_needed / 8);
239 // TODO what if no iteration happens?
240 unsigned size_buf_write = 0;
242 "num_bits_buf_unaligned: %u\n",
245 "ua args: size_buf: %llu, bits_needed: %u -> iter: %u\n",
246 (unsigned long long) size_buf,
247 bits_needed,
248 bytes_iter);
249 buf_write[0] = buf_unaligned;
250 /* Iterate over input bytes */
251 for (unsigned i = 0; i < bytes_iter; i++)
252 {
253 /* Number of bits needed in this iteration - 8 for all except last iter */
254 unsigned num_bits_needed_iter;
255 /* Mask for bits to actually use */
256 unsigned mask_bits_needed_iter;
257 char byte_input;
258 /* Number of bits needed to align unaligned byte */
259 unsigned num_bits_to_align;
260 /* Number of bits that are to be moved */
261 unsigned num_bits_to_move;
262 /* Mask for bytes to be moved */
263 char mask_input_to_move;
264 /* Masked bits to be moved */
265 char bits_to_move;
266 /* The amount of bits needed to fit the bits to shift to the nearest spot */
267 unsigned distance_shift_bits;
268 /* Shifted bits on the move */
269 char bits_moving;
270 /* (unaligned) byte being filled with bits */
271 char byte_to_fill;
272 /* mask for needed bits of the input byte that have not been moved */
273 char mask_input_leftover;
274 /* needed bits of the input byte that have not been moved */
275 char byte_input_leftover;
276 unsigned num_bits_leftover;
277 // unsigned num_bits_discard;
278 char byte_unaligned_new;
279
280 if ((bits_needed - (i * 8)) <= 8)
281 {
282 /* last iteration */
283 num_bits_needed_iter = bits_needed - (i * 8);
284 }
285 else
286 {
287 num_bits_needed_iter = 8;
288 }
290 "number of bits needed in this iteration: %u\n",
291 num_bits_needed_iter);
292 mask_bits_needed_iter = ((char) 1 << num_bits_needed_iter) - 1;
294 "mask needed bits (current iter): "B2B_PAT "\n",
295 B2B (mask_bits_needed_iter));
297 "Unaligned byte: "B2B_PAT " (%u bits)\n",
300 byte_input = buf[i];
302 "next whole input byte: "B2B_PAT "\n",
303 B2B (byte_input));
304 byte_input &= mask_bits_needed_iter;
305 num_bits_to_align = 8 - num_bits_buf_unaligned;
307 "input byte, needed bits: "B2B_PAT "\n",
308 B2B (byte_input));
310 "number of bits needed to align unaligned bit: %u\n",
311 num_bits_to_align);
312 num_bits_to_move = GNUNET_MIN (num_bits_to_align, num_bits_needed_iter);
314 "number of bits of new byte to move: %u\n",
315 num_bits_to_move);
316 mask_input_to_move = ((char) 1 << num_bits_to_move) - 1;
318 "mask of bits of new byte to take for moving: "B2B_PAT "\n",
319 B2B (mask_input_to_move));
320 bits_to_move = byte_input & mask_input_to_move;
322 "masked bits of new byte to take for moving: "B2B_PAT "\n",
323 B2B (bits_to_move));
324 distance_shift_bits = num_bits_buf_unaligned;
326 "distance needed to shift bits to their correct spot: %u\n",
327 distance_shift_bits);
328 bits_moving = bits_to_move << distance_shift_bits;
330 "shifted, masked bits of new byte being moved: "B2B_PAT "\n",
331 B2B (bits_moving));
332 byte_to_fill = buf_unaligned | bits_moving;
334 "byte being filled: "B2B_PAT "\n",
335 B2B (byte_to_fill));
337 "pending bytes: %u\n",
338 num_bits_buf_unaligned + num_bits_needed_iter);
339 if (num_bits_buf_unaligned + num_bits_needed_iter >= 8)
340 {
341 /* buf_unaligned was aligned by filling
342 * -> can be written to storage */
343 buf_write[i] = byte_to_fill;
344 size_buf_write++;
345
346 /* store the leftover, unaligned bits in buffer */
347 mask_input_leftover = mask_bits_needed_iter & (~mask_input_to_move);
349 "mask of leftover bits of new byte: "B2B_PAT "\n",
350 B2B (mask_input_leftover));
351 byte_input_leftover = byte_input & mask_input_leftover;
353 "masked, leftover bits of new byte: "B2B_PAT "\n",
354 B2B (byte_input_leftover));
355 num_bits_leftover = num_bits_needed_iter - num_bits_to_move;
357 "number of unaligned bits left: %u\n",
358 num_bits_leftover);
359 // num_bits_discard = 8 - num_bits_needed_iter;
360 byte_unaligned_new = byte_input_leftover >> num_bits_to_move;
362 "new unaligned byte: "B2B_PAT "\n",
363 B2B (byte_unaligned_new));
364 buf_unaligned = byte_unaligned_new;
365 num_bits_buf_unaligned = num_bits_leftover % 8;
366 }
367 else
368 {
369 /* unaligned buffer still unaligned but 'fuller' */
370 buf_unaligned = byte_to_fill;
372 }
373 }
374 to_file_raw (file_name, buf_write, size_buf_write);
376}
#define GNUNET_MIN(a, b)
static char buf_unaligned
buffer for storing the unaligned bits for the next write
Definition: rps-test_util.c:54
#define B2B_PAT
Definition: rps-test_util.c:37
#define B2B(byte)
Definition: rps-test_util.c:38
void to_file_raw(const char *file_name, const char *buf, size_t size_buf)
static unsigned num_bits_buf_unaligned
number of bits in unaligned buffer
Definition: rps-test_util.c:59

References B2B, B2B_PAT, buf_unaligned, file_name, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MIN, LOG, num_bits_buf_unaligned, and to_file_raw().

Here is the call graph for this function:

◆ auth_key_to_string()

char * auth_key_to_string ( struct GNUNET_CRYPTO_AuthKey  auth_key)

Definition at line 380 of file rps-test_util.c.

381{
382 int size;
383 size_t name_buf_size;
384 char *end;
385 char *buf;
386 char *name_buf;
387 size_t keylen = (sizeof(struct GNUNET_CRYPTO_AuthKey)) * 8;
388
389 name_buf_size = 512 * sizeof(char);
390 name_buf = GNUNET_malloc (name_buf_size);
391
392 if (keylen % 5 > 0)
393 keylen += 5 - keylen % 5;
394 keylen /= 5;
395 buf = GNUNET_malloc (keylen + 1);
396
398 sizeof(struct GNUNET_CRYPTO_AuthKey),
399 buf,
400 keylen);
401
402 if (NULL == end)
403 {
404 GNUNET_free (buf);
405 GNUNET_break (0);
406 }
407 else
408 {
409 *end = '\0';
410 }
411
412 size = GNUNET_snprintf (name_buf, name_buf_size, "sampler_el-%s", buf);
413 if (0 > size)
414 LOG (GNUNET_ERROR_TYPE_WARNING, "Failed to create name_buf\n");
415
416 GNUNET_free (buf);
417
418 return name_buf;
419}
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:33
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
char * GNUNET_STRINGS_data_to_string(const void *data, size_t size, char *out, size_t out_size)
Convert binary data to ASCII encoding using CrockfordBase32.
Definition: strings.c:732
static unsigned int size
Size of the "table".
Definition: peer.c:68
type for (message) authentication keys
unsigned char key[(512/8)]

References end, GNUNET_break, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_malloc, GNUNET_snprintf(), GNUNET_STRINGS_data_to_string(), GNUNET_CRYPTO_AuthKey::key, LOG, and size.

Here is the call graph for this function:

◆ string_to_auth_key()

struct GNUNET_CRYPTO_AuthKey string_to_auth_key ( const char *  str)

Definition at line 426 of file rps-test_util.c.

427{
428 struct GNUNET_CRYPTO_AuthKey auth_key;
429
430 if (GNUNET_OK !=
432 strlen (str),
433 &auth_key.key,
434 sizeof(struct GNUNET_CRYPTO_AuthKey)))
435 {
436 LOG (GNUNET_ERROR_TYPE_WARNING, "Failed to convert string to data\n");
437 }
438
439 return auth_key;
440}
@ GNUNET_OK
enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
Definition: strings.c:812

References GNUNET_ERROR_TYPE_WARNING, GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_CRYPTO_AuthKey::key, and LOG.

Here is the call graph for this function:

◆ ensure_folder_exist()

static int ensure_folder_exist ( void  )
static

Try to ensure that /tmp/rps exists.

Returns
GNUNET_YES on success GNUNET_SYSERR on failure

Definition at line 450 of file rps-test_util.c.

451{
452 if (GNUNET_OK !=
453 GNUNET_DISK_directory_create ("/tmp/rps"))
454 {
456 "Could not create directory `/tmp/rps'\n");
457 return GNUNET_SYSERR;
458 }
459 return GNUNET_YES;
460}
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:497
@ GNUNET_SYSERR

References GNUNET_DISK_directory_create(), GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, and LOG.

Referenced by store_prefix_file_name().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ store_prefix_file_name()

char * store_prefix_file_name ( const unsigned int  index,
const char *  prefix 
)

Definition at line 464 of file rps-test_util.c.

466{
467 int len_file_name;
468 int out_size;
469 char *file_name;
470 char index_str[64];
471
473 return NULL;
474 out_size = GNUNET_snprintf (index_str,
475 64,
476 "%u",
477 index);
478 if ((64 < out_size) ||
479 (0 > out_size) )
480 {
482 "Failed to write string to buffer (size: %i, out_size: %i)\n",
483 64,
484 out_size);
485 }
486 len_file_name = (strlen (prefix)
487 + strlen (index_str)
488 + 11)
489 * sizeof(char);
490 file_name = GNUNET_malloc (len_file_name);
491 out_size = GNUNET_snprintf (file_name,
492 len_file_name,
493 "/tmp/rps/%s-%s",
494 prefix,
495 index_str);
496 if ((len_file_name < out_size) ||
497 (0 > out_size) )
498 {
500 "Failed to write string to buffer (size: %i, out_size: %i)\n",
501 len_file_name,
502 out_size);
503 }
504 return file_name;
505}
static int prefix
If printing the value of PREFIX has been requested.
Definition: gnunet-config.c:66
#define GNUNET_log(kind,...)
static int ensure_folder_exist(void)
Try to ensure that /tmp/rps exists.

References ensure_folder_exist(), file_name, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_malloc, GNUNET_snprintf(), GNUNET_SYSERR, and prefix.

Here is the call graph for this function:

◆ fac()

uint32_t fac ( uint32_t  x)

Factorial.

Parameters
xNumber of which to compute the factorial
Returns
Factorial of x

Definition at line 516 of file rps-test_util.c.

517{
518 if (1 >= x)
519 {
520 return x;
521 }
522 return x * fac (x - 1);
523}
uint32_t fac(uint32_t x)
Factorial.

References fac().

Referenced by binom(), and fac().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ binom()

uint32_t binom ( uint32_t  n,
uint32_t  k 
)

Binomial coefficient (n choose k)

Parameters
n
k
Returns
Binomial coefficient of n and k

Definition at line 535 of file rps-test_util.c.

536{
537 // GNUNET_assert (n >= k);
538 if (k > n)
539 return 0;
540 /* if (0 > n) return 0; - always false */
541 /* if (0 > k) return 0; - always false */
542 if (0 == k)
543 return 1;
544 return fac (n)
545 /
546 fac (k) * fac (n - k);
547}

References fac().

Here is the call graph for this function:

Variable Documentation

◆ buf_unaligned

char buf_unaligned
static

buffer for storing the unaligned bits for the next write

Definition at line 54 of file rps-test_util.c.

Referenced by to_file_raw_unaligned().

◆ num_bits_buf_unaligned

unsigned num_bits_buf_unaligned
static

number of bits in unaligned buffer

Definition at line 59 of file rps-test_util.c.

Referenced by to_file_raw_unaligned().

◆ open_files

struct GNUNET_CONTAINER_MultiHashMap* open_files
static

Definition at line 61 of file rps-test_util.c.

Referenced by close_all_files(), and get_file_handle().