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);
249  }
250  }
251  printf ("\n");
253  GNUNET_CONTAINER_DLL_remove (pc_head, pc_tail, pc);
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  }
386  friend_only = GNUNET_NO;
387  if (NULL != hello)
388  friend_only = GNUNET_HELLO_is_friend_only (hello);
389  if ((GNUNET_YES == be_quiet) || (NULL == hello))
390  {
391  printf ("%s%s\n",
392  (GNUNET_YES == friend_only) ? "F2F: " : "",
393  GNUNET_i2s_full (peer));
394  return;
395  }
396  pc = GNUNET_new (struct PrintContext);
397  GNUNET_CONTAINER_DLL_insert (pc_head, pc_tail, pc);
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 
448  size = GNUNET_HELLO_size (my_hello);
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 
563  int ret = GNUNET_HELLO_parse_uri (put_uri,
565  &hello,
567 
568  if (NULL != hello)
569  {
570  /* WARNING: this adds the address from URI WITHOUT verification! */
571  if (GNUNET_OK == ret)
572  ac = GNUNET_PEERINFO_add_peer (peerinfo, hello, &add_continuation, NULL);
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  {
619  GNUNET_CONTAINER_DLL_remove (pc_head, pc_tail, pc);
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  }
631  GNUNET_free (pc);
632  }
634  if (NULL != peerinfo)
635  {
636  GNUNET_PEERINFO_disconnect (peerinfo);
637  peerinfo = NULL;
638  }
639  if (NULL != my_hello)
640  {
641  GNUNET_free (my_hello);
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  }
663  my_hello = (struct GNUNET_HELLO_Message *) GNUNET_copy_message (hello);
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  {
708  gh = GNUNET_TRANSPORT_hello_get (cfg,
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  {
734  GPI_plugins_load (cfg);
736  {
737  fprintf (stderr, _ ("Invalid URI `%s'\n"), put_uri);
739  }
741  put_uri = NULL;
742  }
743  else if (GNUNET_YES == get_info)
744  {
746  GPI_plugins_load (cfg);
747  pic = GNUNET_PEERINFO_iterate (peerinfo,
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  {
764  GPI_plugins_load (cfg);
765  pic = GNUNET_PEERINFO_iterate (peerinfo,
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 {
797  struct GNUNET_GETOPT_CommandLineOption options[] =
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 */
#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:671
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:84
A HELLO message is used to exchange information about transports with other peers.
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, parse options).
Definition: program.c:363
#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:130
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:1331
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:1029
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1459
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 int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
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;.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#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:531
#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.
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 _(String)
GNU gettext support macro.
Definition: platform.h:184
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:487
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.
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:520
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:1217
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
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:553
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).
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
struct GNUNET_TIME_Absolute expiration
Address expiration time.
#define GNUNET_free_nz(ptr)
Wrapper around free.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
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).
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:705
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:84
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:652
void GNUNET_PEERINFO_disconnect(struct GNUNET_PEERINFO_Handle *h)
Disconnect from the peerinfo service.
Definition: peerinfo_api.c:156
Functions to call with this peer&#39;s HELLO.
Header for all communications.
Time for absolute times used by GNUnet, in microseconds.
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:758
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:929
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:972