GNUnet  0.10.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 {
77 
81  struct PrintContext *next;
82 
86  struct PrintContext *prev;
87 
92 
97 
101  unsigned int num_addresses;
102 
106  unsigned int address_list_size;
107 
111  unsigned int off;
112 
117 
118 };
119 
120 
124 static int no_resolve;
125 
129 static int be_quiet;
130 
135 
139 static int get_self;
140 
144 static int get_uri;
145 
149 static int default_operation;
150 
154 static int get_info;
155 
159 static char *put_uri;
160 
164 static char *dump_hello;
165 
170 
174 static const struct GNUNET_CONFIGURATION_Handle *cfg;
175 
179 static struct GNUNET_SCHEDULER_Task *tt;
180 
185 
190 
195 
199 static struct PrintContext *pc_head;
200 
204 static struct PrintContext *pc_tail;
205 
209 static struct GNUNET_MQ_Envelope *ac;
210 
215 
216 
223 static void
224 state_machine (void *cls);
225 
226 
227 /* ********************* 'get_info' ******************* */
228 
234 static void
236 {
237  unsigned int i;
238 
239  printf (_("%sPeer `%s'\n"),
240  (GNUNET_YES == pc->friend_only) ? "F2F: " : "",
241  GNUNET_i2s_full (&pc->peer));
242  for (i = 0; i < pc->num_addresses; i++)
243  {
244  if (NULL != pc->address_list[i].result)
245  {
246  printf (_("\tExpires: %s \t %s\n"),
248  pc->address_list[i].result);
250  }
251  }
252  printf ("\n");
255  pc_tail,
256  pc);
257  GNUNET_free (pc);
258  if ( (NULL == pc_head) &&
259  (NULL == pic) )
261  NULL);
262 }
263 
264 
265 /* ************************* list all known addresses **************** */
266 
267 
278 static void
280  const char *address,
281  int res)
282 {
283  struct AddressRecord *ar = cls;
284  struct PrintContext *pc = ar->pc;
285 
286  if (NULL != address)
287  {
288  if (0 != strlen (address))
289  {
290  if (NULL != ar->result)
291  GNUNET_free (ar->result);
292  ar->result = GNUNET_strdup (address);
293  }
294  return;
295  }
296  ar->atsc = NULL;
297  if (GNUNET_SYSERR == res)
299  _("Failure: Cannot convert address to string for peer `%s'\n"),
300  GNUNET_i2s (&ar->pc->peer));
301  pc->num_addresses++;
302  if (pc->num_addresses == pc->address_list_size)
303  dump_pc (pc);
304 }
305 
306 
315 static int
316 count_address (void *cls,
317  const struct GNUNET_HELLO_Address *address,
319 {
320  struct PrintContext *pc = cls;
321 
322  pc->off++;
323  return GNUNET_OK;
324 }
325 
326 
335 static int
336 print_address (void *cls,
337  const struct GNUNET_HELLO_Address *address,
339 {
340  struct PrintContext *pc = cls;
341  struct AddressRecord *ar;
342 
343  GNUNET_assert (0 < pc->off);
344  ar = &pc->address_list[--pc->off];
345  ar->pc = pc;
346  ar->expiration = expiration;
347  GNUNET_asprintf (&ar->result,
348  "%s:%u:%u",
349  address->transport_name,
350  address->address_length,
351  address->local_info);
353  address,
354  no_resolve,
355  TIMEOUT,
357  return GNUNET_OK;
358 }
359 
360 
370 static void
371 print_peer_info (void *cls,
372  const struct GNUNET_PeerIdentity *peer,
373  const struct GNUNET_HELLO_Message *hello,
374  const char *err_msg)
375 {
376  struct PrintContext *pc;
377  int friend_only;
378 
379  if (NULL == peer)
380  {
381  pic = NULL; /* end of iteration */
382  if (NULL != err_msg)
383  {
384  FPRINTF (stderr,
385  _("Error in communication with PEERINFO service: %s\n"),
386  err_msg);
387  }
388  if (NULL == pc_head)
390  return;
391  }
392  friend_only = GNUNET_NO;
393  if (NULL != hello)
394  friend_only = GNUNET_HELLO_is_friend_only (hello);
395  if ( (GNUNET_YES == be_quiet) ||
396  (NULL == hello) )
397  {
398  printf ("%s%s\n",
399  (GNUNET_YES == friend_only) ? "F2F: " : "",
400  GNUNET_i2s_full (peer));
401  return;
402  }
403  pc = GNUNET_new (struct PrintContext);
405  pc_tail,
406  pc);
407  pc->peer = *peer;
408  pc->friend_only = friend_only;
410  GNUNET_NO,
411  &count_address,
412  pc);
413  if (0 == pc->off)
414  {
415  dump_pc (pc);
416  return;
417  }
418  pc->address_list_size = pc->off;
419  pc->address_list = GNUNET_malloc (sizeof (struct AddressRecord) * pc->off);
421  GNUNET_NO,
422  &print_address,
423  pc);
424 }
425 
426 /* ************************* DUMP Hello ************************** */
427 
436 static int
437 count_addr (void *cls,
438  const struct GNUNET_HELLO_Address *address,
440 {
441  int *c = cls;
442 
443  (*c)++;
444  return GNUNET_OK;
445 }
446 
447 
456 static void
458 {
459  unsigned int size;
460  unsigned int c_addr;
461 
462  size = GNUNET_HELLO_size (my_hello);
463  if (0 == size)
464  {
465  FPRINTF (stderr,
466  _("Failure: Received invalid %s\n"),
467  "HELLO");
468  return;
469  }
470  if (GNUNET_SYSERR ==
472  my_hello,
473  size,
478  {
479  FPRINTF (stderr,
480  _("Failed to write HELLO with %u bytes to file `%s'\n"),
481  size,
482  dump_hello);
483  if (0 != UNLINK (dump_hello))
486  "unlink",
487  dump_hello);
488 
489  }
490  c_addr = 0;
492  GNUNET_NO,
493  count_addr,
494  &c_addr);
495 
496  if (! be_quiet)
497  {
498  FPRINTF (stderr,
499  _("Wrote %s HELLO containing %u addresses with %u bytes to file `%s'\n"),
500  (GNUNET_YES == GNUNET_HELLO_is_friend_only (my_hello)) ? "friend-only": "public",
501  c_addr,
502  size,
503  dump_hello);
504  }
506  dump_hello = NULL;
507 }
508 
509 
510 /* ************************* GET URI ************************** */
511 
512 
521 static void
522 print_my_uri (void *cls,
523  const struct GNUNET_PeerIdentity *peer,
524  const struct GNUNET_HELLO_Message *hello,
525  const char *err_msg)
526 {
527  char *uri;
528 
529  if (NULL == peer)
530  {
531  pic = NULL;
532  if (NULL != err_msg)
533  FPRINTF (stderr,
534  _("Error in communication with PEERINFO service: %s\n"),
535  err_msg);
537  return;
538  }
539 
540  if (NULL == hello)
541  return;
542  uri = GNUNET_HELLO_compose_uri (hello,
544  if (NULL != uri)
545  {
546  printf ("%s\n",
547  (const char *) uri);
548  GNUNET_free (uri);
549  }
550 }
551 
552 
553 /* ************************* import HELLO by URI ********************* */
554 
555 
561 static void
562 add_continuation (void *cls)
563 {
564  ac = NULL;
566 }
567 
568 
578 static int
580 {
581  struct GNUNET_HELLO_Message *hello = NULL;
582 
583  int ret = GNUNET_HELLO_parse_uri (put_uri,
585  &hello,
587 
588  if (NULL != hello)
589  {
590  /* WARNING: this adds the address from URI WITHOUT verification! */
591  if (GNUNET_OK == ret)
592  ac = GNUNET_PEERINFO_add_peer (peerinfo,
593  hello,
595  NULL);
596  else
598  GNUNET_free (hello);
599  }
600  return ret;
601 }
602 
603 
604 /* ************************ Main state machine ********************* */
605 
606 
613 static void
614 shutdown_task (void *cls)
615 {
616  struct PrintContext *pc;
617  struct AddressRecord *ar;
618  unsigned int i;
619 
620  if (NULL != ac)
621  {
623  ac = NULL;
624  }
625  if (NULL != tt)
626  {
628  tt = NULL;
629  }
630  if (NULL != pic)
631  {
633  pic = NULL;
634  }
635  if (NULL != gh)
636  {
638  gh = NULL;
639  }
640  while (NULL != (pc = pc_head))
641  {
643  pc_tail,
644  pc);
645  for (i=0;i<pc->address_list_size;i++)
646  {
647  ar = &pc->address_list[i];
649  if (NULL != ar->atsc)
650  {
652  ar->atsc = NULL;
653  }
654  }
656  GNUNET_free (pc);
657  }
659  if (NULL != peerinfo)
660  {
661  GNUNET_PEERINFO_disconnect (peerinfo);
662  peerinfo = NULL;
663  }
664  if (NULL != my_hello)
665  {
666  GNUNET_free (my_hello);
667  my_hello = NULL;
668  }
669 }
670 
671 
679 static void
680 hello_callback (void *cls,
681  const struct GNUNET_MessageHeader *hello)
682 {
683  if (NULL == hello)
684  {
685  fprintf (stderr,
686  "Failed to get my own HELLO from this peer!\n");
688  return;
689  }
690  my_hello = (struct GNUNET_HELLO_Message *) GNUNET_copy_message (hello);
692  GNUNET_HELLO_get_id (my_hello,
693  &my_peer_identity));
695  gh = NULL;
696  if (NULL != dump_hello)
697  dump_my_hello ();
699 }
700 
701 
710 static void
711 run (void *cls,
712  char *const *args,
713  const char *cfgfile,
714  const struct GNUNET_CONFIGURATION_Handle *c)
715 {
716  cfg = c;
717  if ( (NULL != args[0]) &&
718  (NULL == put_uri) &&
719  (args[0] == strcasestr (args[0],
720  "gnunet://hello/")) )
721  {
722  put_uri = GNUNET_strdup (args[0]);
723  args++;
724  }
725  if (NULL != args[0])
726  {
727  FPRINTF (stderr,
728  _("Invalid command line argument `%s'\n"),
729  args[0]);
730  return;
731  }
732  if (NULL == (peerinfo = GNUNET_PEERINFO_connect (cfg)))
733  {
734  FPRINTF (stderr,
735  "%s",
736  "Could not access PEERINFO service. Exiting.\n");
737  return;
738  }
739  if ( (GNUNET_YES == get_self) ||
740  (GNUNET_YES == get_uri) ||
741  (NULL != dump_hello) )
742  {
743  gh = GNUNET_TRANSPORT_hello_get (cfg,
746  NULL);
747  }
748  else
749  {
751  NULL);
752  }
754  NULL);
755 }
756 
757 
764 static void
765 state_machine (void *cls)
766 {
767  tt = NULL;
768 
769  if (NULL != put_uri)
770  {
771  GPI_plugins_load (cfg);
773  {
774  fprintf (stderr,
775  _("Invalid URI `%s'\n"),
776  put_uri);
778  }
780  put_uri = NULL;
781  }
782  else if (GNUNET_YES == get_info)
783  {
785  GPI_plugins_load (cfg);
786  pic = GNUNET_PEERINFO_iterate (peerinfo,
788  NULL,
790  NULL);
791  }
792  else if (GNUNET_YES == get_self)
793  {
795  if (be_quiet)
796  printf ("%s\n",
798  else
799  printf (_("I am peer `%s'.\n"),
802  NULL);
803  }
804  else if (GNUNET_YES == get_uri)
805  {
806  GPI_plugins_load (cfg);
807  pic = GNUNET_PEERINFO_iterate (peerinfo,
810  &print_my_uri,
811  NULL);
812  get_uri = GNUNET_NO;
813  }
814  else if (GNUNET_YES == default_operation)
815  {
816  /* default operation list all */
820  NULL);
821  }
822  else
823  {
825  }
827 }
828 
829 
837 int
838 main (int argc, char *const *argv)
839 {
840  struct GNUNET_GETOPT_CommandLineOption options[] = {
842  "numeric",
843  gettext_noop ("don't resolve host names"),
844  &no_resolve),
845 
847  "quiet",
848  gettext_noop ("output only the identity strings"),
849  &be_quiet),
851  "friends",
852  gettext_noop ("include friend-only information"),
854 
856  "self",
857  gettext_noop ("output our own identity only"),
858  &get_self),
859 
861  "info",
862  gettext_noop ("list all known peers"),
863  &get_info),
864 
866  "dump-hello",
867  NULL,
868  gettext_noop ("dump hello to file"),
869  &dump_hello),
870 
872  "get-hello",
873  gettext_noop ("also output HELLO uri(s)"),
874  &get_uri),
875 
877  "put-hello",
878  "HELLO",
879  gettext_noop ("add given HELLO uri to the database"),
880  &put_uri),
881 
883  };
884  int ret;
885 
888  argv,
889  &argc,
890  &argv))
891  return 2;
892 
893  ret = (GNUNET_OK ==
894  GNUNET_PROGRAM_run (argc,
895  argv,
896  "gnunet-peerinfo",
897  gettext_noop ("Print information about peers."),
898  options,
899  &run,
900  NULL)) ? 0 : 1;
901  GNUNET_free ((void*) argv);
902  return ret;
903 }
904 
905 /* end of gnunet-peerinfo.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
size_t address_length
Number of bytes in address.
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:668
static int default_operation
Option.
enum GNUNET_HELLO_AddressInfo local_info
Extended information about address.
static void add_continuation(void *cls)
Continuation called from GNUNET_PEERINFO_add_peer()
static int be_quiet
Option &#39;-q&#39;.
struct GNUNET_PeerIdentity peer
Identity of the peer.
static int print_address(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
Iterator callback to go over all addresses.
Handle to the peerinfo service.
Definition: peerinfo_api.c:86
A HELLO message is used to exchange information about transports with other peers.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static void shutdown_task(void *cls)
Main state machine that goes over all options and runs the next requested function.
struct GNUNET_PEERINFO_Handle * GNUNET_PEERINFO_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the peerinfo service.
Definition: peerinfo_api.c:133
#define FPRINTF
Definition: plibc.h:683
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, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1293
struct PrintContext * pc
Print context this address record belongs to.
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:1028
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1521
Structure we use to collect printable address information.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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 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 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 const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration handle.
static struct GNUNET_SCHEDULER_Task * tt
Main state machine task (if active).
static int include_friend_only
Option &#39;-f&#39;.
#define GNUNET_NO
Definition: gnunet_common.h:81
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition of a command line option.
#define TIMEOUT
How long until we time out during address lookup?
struct PrintContext * next
Kept in DLL.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static char * put_uri
Option.
Context for an iteration request.
Definition: peerinfo_api.c:37
static char * dump_hello
Option -d.
ssize_t GNUNET_DISK_fn_write(const char *fn, const void *buffer, size_t n, enum GNUNET_DISK_AccessPermissions mode)
Write a buffer to a file.
Definition: disk.c:1203
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
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.
#define UNLINK(f)
Definition: plibc.h:666
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
static int get_uri
Option.
int main(int argc, char *const *argv)
The main function to obtain peer information.
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:491
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
unsigned int num_addresses
Number of completed addresses in address_list.
static struct GNUNET_PEERINFO_Handle * peerinfo
Handle to peerinfo service.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static struct GNUNET_PEERINFO_IteratorContext * pic
Current iterator context (if active, otherwise NULL).
void GNUNET_PEERINFO_iterate_cancel(struct GNUNET_PEERINFO_IteratorContext *ic)
Cancel an iteration over peer information.
Definition: peerinfo_api.c:524
Record we keep for each printable address.
static void state_machine(void *cls)
Main state machine that goes over all options and runs the next requested function.
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
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
void GNUNET_TRANSPORT_address_to_string_cancel(struct GNUNET_TRANSPORT_AddressToStringContext *alc)
Cancel request for address conversion.
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:1213
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:1273
const char * transport_name
Name of the transport plugin enabling the communication using this address.
plugin management API
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 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.
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:557
static void hello_callback(void *cls, const struct GNUNET_MessageHeader *hello)
Function called with our peer&#39;s HELLO message.
struct PrintContext * prev
Kept in DLL.
static int res
static struct PrintContext * pc_head
Head of list of print contexts.
void GPI_plugins_unload()
Unload all plugins.
static struct GNUNET_HELLO_Message * my_hello
Hello of this peer (if initialized).
struct GNUNET_TIME_Absolute expiration
Address expiration time.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static unsigned int size
Size of the "table".
Definition: peer.c:67
static int no_resolve
Option &#39;-n&#39;.
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.
int GNUNET_HELLO_is_friend_only(const struct GNUNET_HELLO_Message *h)
Return HELLO type.
Definition: hello.c:89
static struct GNUNET_MQ_Envelope * ac
Handle to current GNUNET_PEERINFO_add_peer() operation.
static struct GNUNET_PeerIdentity my_peer_identity
My peer identity.
struct GNUNET_TRANSPORT_AddressToStringContext * atsc
Current address-to-string context (if active, otherwise NULL).
char * result
Printable address.
static void dump_pc(struct PrintContext *pc)
Print the collected address information to the console and free pc.
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.
Everybody can read.
The identity of the host (wraps the signing key of the peer).
unsigned int off
Current offset in address_list (counted down).
configuration data
Definition: configuration.c:85
static struct PrintContext * pc_tail
Tail of list of print contexts.
void GPI_plugins_load(const struct GNUNET_CONFIGURATION_Handle *cfg)
Load and initialize all plugins.
An address for communicating with a peer.
static int get_self
Option &#39;-s&#39;.
struct GNUNET_TRANSPORT_PluginFunctions * GPI_plugins_find(const char *name)
Obtain the plugin API based on a plugin name.
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_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.
static struct GNUNET_TRANSPORT_HelloGetHandle * gh
Pending GNUNET_TRANSPORT_hello_get() operation.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:649
void GNUNET_PEERINFO_disconnect(struct GNUNET_PEERINFO_Handle *h)
Disconnect from the peerinfo service.
Definition: peerinfo_api.c:159
int 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, parse options).
Definition: program.c:361
Functions to call with this peer&#39;s HELLO.
Header for all communications.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:80
int friend_only
Hello was friend only, GNUNET_YES or GNUNET_NO.
static void process_resolved_address(void *cls, const char *address, int res)
Function to call with a human-readable format of an address.
struct AddressRecord * address_list
List of printable addresses.
static void dump_my_hello()
Write HELLO of my peer to a file.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:792
unsigned int address_list_size
Number of addresses allocated in address_list.
static char * address
GNS address for this phone.
void GNUNET_MQ_send_cancel(struct GNUNET_MQ_Envelope *ev)
Cancel sending the message.
Definition: mq.c:916
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_TRANSPORT_hello_get_cancel(struct GNUNET_TRANSPORT_HelloGetHandle *ghh)
Stop receiving updates about changes to our HELLO message.
#define GNUNET_malloc(size)
Wrapper around malloc.
static int get_info
Option &#39;-i&#39;.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965