GNUnet  0.11.x
gnunet-peerinfo.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2001-2014, 2016 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
29 #include "gnunet_hello_lib.h"
34 
38 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
39 
43 struct PrintContext;
44 
49 {
54 
59 
63  char *result;
64 
68  struct PrintContext *pc;
69 };
70 
71 
76 {
80  struct PrintContext *next;
81 
85  struct PrintContext *prev;
86 
91 
96 
100  unsigned int num_addresses;
101 
105  unsigned int address_list_size;
106 
110  unsigned int off;
111 
116 };
117 
118 
122 static int no_resolve;
123 
127 static int be_quiet;
128 
133 
137 static int get_self;
138 
142 static int get_uri;
143 
147 static int default_operation;
148 
152 static int get_info;
153 
157 static char *put_uri;
158 
162 static char *dump_hello;
163 
168 
172 static const struct GNUNET_CONFIGURATION_Handle *cfg;
173 
177 static struct GNUNET_SCHEDULER_Task *tt;
178 
183 
188 
193 
197 static struct PrintContext *pc_head;
198 
202 static struct PrintContext *pc_tail;
203 
207 static struct GNUNET_MQ_Envelope *ac;
208 
213 
214 
221 static void
222 state_machine (void *cls);
223 
224 
225 /* ********************* 'get_info' ******************* */
226 
232 static void
234 {
235  unsigned int i;
236 
237  printf (_ ("%sPeer `%s'\n"),
238  (GNUNET_YES == pc->friend_only) ? "F2F: " : "",
239  GNUNET_i2s_full (&pc->peer));
240  for (i = 0; i < pc->num_addresses; i++)
241  {
242  if (NULL != pc->address_list[i].result)
243  {
244  printf (_ ("\tExpires: %s \t %s\n"),
246  pc->address_list[i].expiration),
247  pc->address_list[i].result);
248  GNUNET_free (pc->address_list[i].result);
249  }
250  }
251  printf ("\n");
252  GNUNET_free (pc->address_list);
254  GNUNET_free (pc);
255  if ((NULL == pc_head) && (NULL == pic))
257 }
258 
259 
260 /* ************************* list all known addresses **************** */
261 
262 
273 static void
274 process_resolved_address (void *cls, const char *address, int res)
275 {
276  struct AddressRecord *ar = cls;
277  struct PrintContext *pc = ar->pc;
278 
279  if (NULL != address)
280  {
281  if (0 != strlen (address))
282  {
283  if (NULL != ar->result)
284  GNUNET_free (ar->result);
285  ar->result = GNUNET_strdup (address);
286  }
287  return;
288  }
289  ar->atsc = NULL;
290  if (GNUNET_SYSERR == res)
292  _ ("Failure: Cannot convert address to string for peer `%s'\n"),
293  GNUNET_i2s (&ar->pc->peer));
294  pc->num_addresses++;
295  if (pc->num_addresses == pc->address_list_size)
296  dump_pc (pc);
297 }
298 
299 
308 static int
309 count_address (void *cls,
310  const struct GNUNET_HELLO_Address *address,
312 {
313  struct PrintContext *pc = cls;
314 
315  pc->off++;
316  return GNUNET_OK;
317 }
318 
319 
328 static int
329 print_address (void *cls,
330  const struct GNUNET_HELLO_Address *address,
332 {
333  struct PrintContext *pc = cls;
334  struct AddressRecord *ar;
335 
336  GNUNET_assert (0 < pc->off);
337  ar = &pc->address_list[--pc->off];
338  ar->pc = pc;
339  ar->expiration = expiration;
340  GNUNET_asprintf (&ar->result,
341  "%s:%lu:%u",
342  address->transport_name,
343  (unsigned long) address->address_length,
344  address->local_info);
346  address,
347  no_resolve,
348  TIMEOUT,
350  ar);
351  return GNUNET_OK;
352 }
353 
354 
364 static void
365 print_peer_info (void *cls,
366  const struct GNUNET_PeerIdentity *peer,
367  const struct GNUNET_HELLO_Message *hello,
368  const char *err_msg)
369 {
370  struct PrintContext *pc;
371  int friend_only;
372 
373  if (NULL == peer)
374  {
375  pic = NULL; /* end of iteration */
376  if (NULL != err_msg)
377  {
378  fprintf (stderr,
379  _ ("Error in communication with PEERINFO service: %s\n"),
380  err_msg);
381  }
382  if (NULL == pc_head)
384  return;
385  }
387  if (NULL != hello)
389  if ((GNUNET_YES == be_quiet) || (NULL == hello))
390  {
391  printf ("%s%s\n",
392  (GNUNET_YES == friend_only) ? "F2F: " : "",
394  return;
395  }
396  pc = GNUNET_new (struct PrintContext);
398  pc->peer = *peer;
399  pc->friend_only = friend_only;
401  if (0 == pc->off)
402  {
403  dump_pc (pc);
404  return;
405  }
406  pc->address_list_size = pc->off;
407  pc->address_list = GNUNET_malloc (sizeof(struct AddressRecord) * pc->off);
409 }
410 
411 
412 /* ************************* DUMP Hello ************************** */
413 
422 static int
423 count_addr (void *cls,
424  const struct GNUNET_HELLO_Address *address,
426 {
427  int *c = cls;
428 
429  (*c)++;
430  return GNUNET_OK;
431 }
432 
433 
442 static void
444 {
445  unsigned int size;
446  unsigned int c_addr;
447 
449  if (0 == size)
450  {
451  fprintf (stderr, _ ("Failure: Received invalid %s\n"), "HELLO");
452  return;
453  }
454  if (GNUNET_SYSERR ==
456  my_hello,
457  size,
462  {
463  fprintf (stderr,
464  _ ("Failed to write HELLO with %u bytes to file `%s'\n"),
465  size,
466  dump_hello);
467  if (0 != unlink (dump_hello))
470  "unlink",
471  dump_hello);
472  }
473  c_addr = 0;
475 
476  if (! be_quiet)
477  {
478  fprintf (
479  stderr,
480  _ ("Wrote %s HELLO containing %u addresses with %u bytes to file `%s'\n"),
481  (GNUNET_YES == GNUNET_HELLO_is_friend_only (my_hello)) ? "friend-only"
482  : "public",
483  c_addr,
484  size,
485  dump_hello);
486  }
488  dump_hello = NULL;
489 }
490 
491 
492 /* ************************* GET URI ************************** */
493 
494 
503 static void
504 print_my_uri (void *cls,
505  const struct GNUNET_PeerIdentity *peer,
506  const struct GNUNET_HELLO_Message *hello,
507  const char *err_msg)
508 {
509  char *uri;
510 
511  if (NULL == peer)
512  {
513  pic = NULL;
514  if (NULL != err_msg)
515  fprintf (stderr,
516  _ ("Error in communication with PEERINFO service: %s\n"),
517  err_msg);
519  return;
520  }
521 
522  if (NULL == hello)
523  return;
525  if (NULL != uri)
526  {
527  printf ("%s\n", (const char *) uri);
528  GNUNET_free (uri);
529  }
530 }
531 
532 
533 /* ************************* import HELLO by URI ********************* */
534 
535 
541 static void
542 add_continuation (void *cls)
543 {
544  ac = NULL;
546 }
547 
548 
558 static int
560 {
561  struct GNUNET_HELLO_Message *hello = NULL;
562 
565  &hello,
567 
568  if (NULL != hello)
569  {
570  /* WARNING: this adds the address from URI WITHOUT verification! */
571  if (GNUNET_OK == ret)
573  else
575  GNUNET_free (hello);
576  }
577  return ret;
578 }
579 
580 
581 /* ************************ Main state machine ********************* */
582 
583 
590 static void
591 shutdown_task (void *cls)
592 {
593  struct PrintContext *pc;
594  struct AddressRecord *ar;
595  unsigned int i;
596 
597  if (NULL != ac)
598  {
600  ac = NULL;
601  }
602  if (NULL != tt)
603  {
605  tt = NULL;
606  }
607  if (NULL != pic)
608  {
610  pic = NULL;
611  }
612  if (NULL != gh)
613  {
615  gh = NULL;
616  }
617  while (NULL != (pc = pc_head))
618  {
620  for (i = 0; i < pc->address_list_size; i++)
621  {
622  ar = &pc->address_list[i];
623  GNUNET_free (ar->result);
624  if (NULL != ar->atsc)
625  {
627  ar->atsc = NULL;
628  }
629  }
630  GNUNET_free (pc->address_list);
631  GNUNET_free (pc);
632  }
634  if (NULL != peerinfo)
635  {
637  peerinfo = NULL;
638  }
639  if (NULL != my_hello)
640  {
642  my_hello = NULL;
643  }
644 }
645 
646 
654 static void
655 hello_callback (void *cls, const struct GNUNET_MessageHeader *hello)
656 {
657  if (NULL == hello)
658  {
659  fprintf (stderr, "Failed to get my own HELLO from this peer!\n");
661  return;
662  }
667  gh = NULL;
668  if (NULL != dump_hello)
669  dump_my_hello ();
671 }
672 
673 
682 static void
683 run (void *cls,
684  char *const *args,
685  const char *cfgfile,
686  const struct GNUNET_CONFIGURATION_Handle *c)
687 {
688  cfg = c;
689  if ((NULL != args[0]) && (NULL == put_uri) &&
690  (args[0] == strcasestr (args[0], "gnunet://hello/")))
691  {
692  put_uri = GNUNET_strdup (args[0]);
693  args++;
694  }
695  if (NULL != args[0])
696  {
697  fprintf (stderr, _ ("Invalid command line argument `%s'\n"), args[0]);
698  return;
699  }
700  if (NULL == (peerinfo = GNUNET_PEERINFO_connect (cfg)))
701  {
702  fprintf (stderr, "%s", "Could not access PEERINFO service. Exiting.\n");
703  return;
704  }
705  if ((GNUNET_YES == get_self) || (GNUNET_YES == get_uri) ||
706  (NULL != dump_hello))
707  {
711  NULL);
712  }
713  else
714  {
716  }
718 }
719 
720 
727 static void
728 state_machine (void *cls)
729 {
730  tt = NULL;
731 
732  if (NULL != put_uri)
733  {
736  {
737  fprintf (stderr, _ ("Invalid URI `%s'\n"), put_uri);
739  }
741  put_uri = NULL;
742  }
743  else if (GNUNET_YES == get_info)
744  {
749  NULL,
751  NULL);
752  }
753  else if (GNUNET_YES == get_self)
754  {
756  if (be_quiet)
757  printf ("%s\n", GNUNET_i2s_full (&my_peer_identity));
758  else
759  printf (_ ("I am peer `%s'.\n"), GNUNET_i2s_full (&my_peer_identity));
761  }
762  else if (GNUNET_YES == get_uri)
763  {
768  &print_my_uri,
769  NULL);
770  get_uri = GNUNET_NO;
771  }
772  else if (GNUNET_YES == default_operation)
773  {
774  /* default operation list all */
778  }
779  else
780  {
782  }
784 }
785 
786 
794 int
795 main (int argc, char *const *argv)
796 {
799  "numeric",
800  gettext_noop ("don't resolve host names"),
801  &no_resolve),
802 
804  "quiet",
805  gettext_noop (
806  "output only the identity strings"),
807  &be_quiet),
809  "friends",
810  gettext_noop (
811  "include friend-only information"),
813 
815  "self",
816  gettext_noop ("output our own identity only"),
817  &get_self),
818 
820  "info",
821  gettext_noop ("list all known peers"),
822  &get_info),
823 
825  "dump-hello",
826  NULL,
827  gettext_noop ("dump hello to file"),
828  &dump_hello),
829 
831  "get-hello",
832  gettext_noop ("also output HELLO uri(s)"),
833  &get_uri),
834 
836  "put-hello",
837  "HELLO",
838  gettext_noop (
839  "add given HELLO uri to the database"),
840  &put_uri),
841 
843  int ret;
844 
846  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
847  return 2;
848 
849  ret = (GNUNET_OK ==
850  GNUNET_PROGRAM_run (argc,
851  argv,
852  "gnunet-peerinfo",
853  gettext_noop ("Print information about peers."),
854  options,
855  &run,
856  NULL))
857  ? 0
858  : 1;
859  GNUNET_free_nz ((void *) argv);
860  return ret;
861 }
862 
863 
864 /* end of gnunet-peerinfo.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:69
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static int res
static char * address
GNS address for this phone.
static int be_quiet
Option '-q'.
static int parse_hello_uri(const char *put_uri)
Parse the PUT URI given at the command line and add it to our peerinfo database.
static struct PrintContext * pc_head
Head of list of print contexts.
static void print_my_uri(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello, const char *err_msg)
Print URI of the peer.
static struct GNUNET_TRANSPORT_HelloGetHandle * gh
Pending GNUNET_TRANSPORT_hello_get() operation.
static void dump_my_hello()
Write HELLO of my peer to a file.
static char * put_uri
Option.
static int no_resolve
Option '-n'.
#define TIMEOUT
How long until we time out during address lookup?
static struct GNUNET_PEERINFO_IteratorContext * pic
Current iterator context (if active, otherwise NULL).
static int default_operation
Option.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration handle.
static int get_uri
Option.
static int get_info
Option '-i'.
static void process_resolved_address(void *cls, const char *address, int res)
Function to call with a human-readable format of an address.
static int get_self
Option '-s'.
static struct GNUNET_PEERINFO_Handle * peerinfo
Handle to peerinfo service.
static void shutdown_task(void *cls)
Main state machine that goes over all options and runs the next requested function.
static char * dump_hello
Option -d.
static struct GNUNET_SCHEDULER_Task * tt
Main state machine task (if active).
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Main function that will be run by the scheduler.
static struct PrintContext * pc_tail
Tail of list of print contexts.
static int include_friend_only
Option '-f'.
static void state_machine(void *cls)
Main state machine that goes over all options and runs the next requested function.
static void add_continuation(void *cls)
Continuation called from GNUNET_PEERINFO_add_peer()
static int count_address(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
Iterator callback to go over all addresses and count them.
static struct GNUNET_HELLO_Message * my_hello
Hello of this peer (if initialized).
int main(int argc, char *const *argv)
The main function to obtain peer information.
static struct GNUNET_PeerIdentity my_peer_identity
My peer identity.
static void print_peer_info(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello, const char *err_msg)
Print information about the peer.
static void dump_pc(struct PrintContext *pc)
Print the collected address information to the console and free pc.
static int print_address(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
Iterator callback to go over all addresses.
static int count_addr(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
Count the number of addresses in the HELLO.
static void hello_callback(void *cls, const struct GNUNET_MessageHeader *hello)
Function called with our peer's HELLO message.
static struct GNUNET_MQ_Envelope * ac
Handle to current GNUNET_PEERINFO_add_peer() operation.
struct GNUNET_TRANSPORT_PluginFunctions * GPI_plugins_find(const char *name)
Obtain the plugin API based on a plugin name.
void GPI_plugins_load(const struct GNUNET_CONFIGURATION_Handle *cfg)
Load and initialize all plugins.
void GPI_plugins_unload()
Unload all plugins.
plugin management API
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
#define GNUNET_log(kind,...)
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
enum GNUNET_GenericReturnValue GNUNET_DISK_fn_write(const char *fn, const void *buf, size_t buf_size, enum GNUNET_DISK_AccessPermissions mode)
Write a buffer to a file atomically.
Definition: disk.c:725
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_GROUP_READ
Group can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
@ GNUNET_DISK_PERM_OTHER_READ
Everybody can read.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
int GNUNET_HELLO_get_id(const struct GNUNET_HELLO_Message *hello, struct GNUNET_PeerIdentity *peer)
Get the peer identity from a HELLO message.
Definition: hello.c:671
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:652
int GNUNET_HELLO_parse_uri(const char *uri, struct GNUNET_CRYPTO_EddsaPublicKey *pubkey, struct GNUNET_HELLO_Message **hello, GNUNET_HELLO_TransportPluginsFind plugins_find)
Parse a hello URI string to a hello message.
Definition: hello.c:1217
int GNUNET_HELLO_is_friend_only(const struct GNUNET_HELLO_Message *h)
Return HELLO type.
Definition: hello.c:89
char * GNUNET_HELLO_compose_uri(const struct GNUNET_HELLO_Message *hello, GNUNET_HELLO_TransportPluginsFind plugins_find)
Compose a hello URI string from a hello message.
Definition: hello.c:1029
struct GNUNET_HELLO_Message * GNUNET_HELLO_iterate_addresses(const struct GNUNET_HELLO_Message *msg, int return_modified, GNUNET_HELLO_AddressIterator it, void *it_cls)
Iterate over all of the addresses in the HELLO.
Definition: hello.c:254
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_BULK
@ GNUNET_ERROR_TYPE_INFO
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_free_nz(ptr)
Wrapper around free.
void GNUNET_MQ_send_cancel(struct GNUNET_MQ_Envelope *ev)
Cancel sending the message.
Definition: mq.c:929
struct GNUNET_MQ_Envelope * GNUNET_PEERINFO_add_peer(struct GNUNET_PEERINFO_Handle *h, const struct GNUNET_HELLO_Message *hello, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Add a host to the persistent list.
Definition: peerinfo_api.c:553
struct GNUNET_PEERINFO_Handle * GNUNET_PEERINFO_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the peerinfo service.
Definition: peerinfo_api.c:130
struct GNUNET_PEERINFO_IteratorContext * GNUNET_PEERINFO_iterate(struct GNUNET_PEERINFO_Handle *h, int include_friend_only, const struct GNUNET_PeerIdentity *peer, GNUNET_PEERINFO_Processor callback, void *callback_cls)
Call a method for each known matching host.
Definition: peerinfo_api.c:487
void GNUNET_PEERINFO_iterate_cancel(struct GNUNET_PEERINFO_IteratorContext *ic)
Cancel an iteration over peer information.
Definition: peerinfo_api.c:520
void GNUNET_PEERINFO_disconnect(struct GNUNET_PEERINFO_Handle *h)
Disconnect from the peerinfo service.
Definition: peerinfo_api.c:156
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:364
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1331
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1209
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:604
struct GNUNET_TRANSPORT_HelloGetHandle * GNUNET_TRANSPORT_hello_get(const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_TRANSPORT_AddressClass ac, GNUNET_TRANSPORT_HelloUpdateCallback rec, void *rec_cls)
Obtain updates on changes to the HELLO message for this peer.
struct GNUNET_TRANSPORT_AddressToStringContext * GNUNET_TRANSPORT_address_to_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_HELLO_Address *address, int numeric, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressToStringCallback aluc, void *aluc_cls)
Convert a binary address into a human readable address.
void GNUNET_TRANSPORT_hello_get_cancel(struct GNUNET_TRANSPORT_HelloGetHandle *ghh)
Stop receiving updates about changes to our HELLO message.
void GNUNET_TRANSPORT_address_to_string_cancel(struct GNUNET_TRANSPORT_AddressToStringContext *alc)
Cancel request for address conversion.
@ GNUNET_TRANSPORT_AC_ANY
Bitmask for "any" address.
static unsigned int size
Size of the "table".
Definition: peer.c:67
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
Record we keep for each printable address.
struct GNUNET_TIME_Absolute expiration
Address expiration time.
struct PrintContext * pc
Print context this address record belongs to.
struct GNUNET_TRANSPORT_AddressToStringContext * atsc
Current address-to-string context (if active, otherwise NULL).
char * result
Printable address.
Definition of a command line option.
An address for communicating with a peer.
A HELLO message is used to exchange information about transports with other peers.
Header for all communications.
Handle to the peerinfo service.
Definition: peerinfo_api.c:85
Context for an iteration request.
Definition: peerinfo_api.c:38
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Entry in list of pending tasks.
Definition: scheduler.c:135
Time for absolute times used by GNUnet, in microseconds.
Functions to call with this peer's HELLO.
Structure we use to collect printable address information.
struct AddressRecord * address_list
List of printable addresses.
unsigned int off
Current offset in address_list (counted down).
unsigned int num_addresses
Number of completed addresses in address_list.
unsigned int address_list_size
Number of addresses allocated in address_list.
struct GNUNET_PeerIdentity peer
Identity of the peer.
int friend_only
Hello was friend only, GNUNET_YES or GNUNET_NO.
struct PrintContext * next
Kept in DLL.
struct PrintContext * prev
Kept in DLL.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.