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:%u:%u",
342  address->transport_name,
343  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  }
455  my_hello,
456  size,
461  {
462  fprintf (stderr,
463  _ ("Failed to write HELLO with %u bytes to file `%s'\n"),
464  size,
465  dump_hello);
466  if (0 != unlink (dump_hello))
469  "unlink",
470  dump_hello);
471  }
472  c_addr = 0;
474 
475  if (! be_quiet)
476  {
477  fprintf (
478  stderr,
479  _ ("Wrote %s HELLO containing %u addresses with %u bytes to file `%s'\n"),
480  (GNUNET_YES == GNUNET_HELLO_is_friend_only (my_hello)) ? "friend-only"
481  : "public",
482  c_addr,
483  size,
484  dump_hello);
485  }
487  dump_hello = NULL;
488 }
489 
490 
491 /* ************************* GET URI ************************** */
492 
493 
502 static void
503 print_my_uri (void *cls,
504  const struct GNUNET_PeerIdentity *peer,
505  const struct GNUNET_HELLO_Message *hello,
506  const char *err_msg)
507 {
508  char *uri;
509 
510  if (NULL == peer)
511  {
512  pic = NULL;
513  if (NULL != err_msg)
514  fprintf (stderr,
515  _ ("Error in communication with PEERINFO service: %s\n"),
516  err_msg);
518  return;
519  }
520 
521  if (NULL == hello)
522  return;
524  if (NULL != uri)
525  {
526  printf ("%s\n", (const char *) uri);
527  GNUNET_free (uri);
528  }
529 }
530 
531 
532 /* ************************* import HELLO by URI ********************* */
533 
534 
540 static void
541 add_continuation (void *cls)
542 {
543  ac = NULL;
545 }
546 
547 
557 static int
559 {
560  struct GNUNET_HELLO_Message *hello = NULL;
561 
562  int ret = GNUNET_HELLO_parse_uri (put_uri,
564  &hello,
566 
567  if (NULL != hello)
568  {
569  /* WARNING: this adds the address from URI WITHOUT verification! */
570  if (GNUNET_OK == ret)
571  ac = GNUNET_PEERINFO_add_peer (peerinfo, hello, &add_continuation, NULL);
572  else
574  GNUNET_free (hello);
575  }
576  return ret;
577 }
578 
579 
580 /* ************************ Main state machine ********************* */
581 
582 
589 static void
590 shutdown_task (void *cls)
591 {
592  struct PrintContext *pc;
593  struct AddressRecord *ar;
594  unsigned int i;
595 
596  if (NULL != ac)
597  {
599  ac = NULL;
600  }
601  if (NULL != tt)
602  {
604  tt = NULL;
605  }
606  if (NULL != pic)
607  {
609  pic = NULL;
610  }
611  if (NULL != gh)
612  {
614  gh = NULL;
615  }
616  while (NULL != (pc = pc_head))
617  {
618  GNUNET_CONTAINER_DLL_remove (pc_head, pc_tail, pc);
619  for (i = 0; i < pc->address_list_size; i++)
620  {
621  ar = &pc->address_list[i];
623  if (NULL != ar->atsc)
624  {
626  ar->atsc = NULL;
627  }
628  }
630  GNUNET_free (pc);
631  }
633  if (NULL != peerinfo)
634  {
635  GNUNET_PEERINFO_disconnect (peerinfo);
636  peerinfo = NULL;
637  }
638  if (NULL != my_hello)
639  {
640  GNUNET_free (my_hello);
641  my_hello = NULL;
642  }
643 }
644 
645 
653 static void
654 hello_callback (void *cls, const struct GNUNET_MessageHeader *hello)
655 {
656  if (NULL == hello)
657  {
658  fprintf (stderr, "Failed to get my own HELLO from this peer!\n");
660  return;
661  }
662  my_hello = (struct GNUNET_HELLO_Message *) GNUNET_copy_message (hello);
666  gh = NULL;
667  if (NULL != dump_hello)
668  dump_my_hello ();
670 }
671 
672 
681 static void
682 run (void *cls,
683  char *const *args,
684  const char *cfgfile,
685  const struct GNUNET_CONFIGURATION_Handle *c)
686 {
687  cfg = c;
688  if ((NULL != args[0]) && (NULL == put_uri) &&
689  (args[0] == strcasestr (args[0], "gnunet://hello/")))
690  {
691  put_uri = GNUNET_strdup (args[0]);
692  args++;
693  }
694  if (NULL != args[0])
695  {
696  fprintf (stderr, _ ("Invalid command line argument `%s'\n"), args[0]);
697  return;
698  }
699  if (NULL == (peerinfo = GNUNET_PEERINFO_connect (cfg)))
700  {
701  fprintf (stderr, "%s", "Could not access PEERINFO service. Exiting.\n");
702  return;
703  }
704  if ((GNUNET_YES == get_self) || (GNUNET_YES == get_uri) ||
705  (NULL != dump_hello))
706  {
707  gh = GNUNET_TRANSPORT_hello_get (cfg,
710  NULL);
711  }
712  else
713  {
715  }
717 }
718 
719 
726 static void
727 state_machine (void *cls)
728 {
729  tt = NULL;
730 
731  if (NULL != put_uri)
732  {
733  GPI_plugins_load (cfg);
735  {
736  fprintf (stderr, _ ("Invalid URI `%s'\n"), put_uri);
738  }
740  put_uri = NULL;
741  }
742  else if (GNUNET_YES == get_info)
743  {
745  GPI_plugins_load (cfg);
746  pic = GNUNET_PEERINFO_iterate (peerinfo,
748  NULL,
750  NULL);
751  }
752  else if (GNUNET_YES == get_self)
753  {
755  if (be_quiet)
756  printf ("%s\n", GNUNET_i2s_full (&my_peer_identity));
757  else
758  printf (_ ("I am peer `%s'.\n"), GNUNET_i2s_full (&my_peer_identity));
760  }
761  else if (GNUNET_YES == get_uri)
762  {
763  GPI_plugins_load (cfg);
764  pic = GNUNET_PEERINFO_iterate (peerinfo,
767  &print_my_uri,
768  NULL);
769  get_uri = GNUNET_NO;
770  }
771  else if (GNUNET_YES == default_operation)
772  {
773  /* default operation list all */
777  }
778  else
779  {
781  }
783 }
784 
785 
793 int
794 main (int argc, char *const *argv)
795 {
796  struct GNUNET_GETOPT_CommandLineOption options[] =
798  "numeric",
799  gettext_noop ("don't resolve host names"),
800  &no_resolve),
801 
803  "quiet",
804  gettext_noop (
805  "output only the identity strings"),
806  &be_quiet),
808  "friends",
809  gettext_noop (
810  "include friend-only information"),
812 
814  "self",
815  gettext_noop ("output our own identity only"),
816  &get_self),
817 
819  "info",
820  gettext_noop ("list all known peers"),
821  &get_info),
822 
824  "dump-hello",
825  NULL,
826  gettext_noop ("dump hello to file"),
827  &dump_hello),
828 
830  "get-hello",
831  gettext_noop ("also output HELLO uri(s)"),
832  &get_uri),
833 
835  "put-hello",
836  "HELLO",
837  gettext_noop (
838  "add given HELLO uri to the database"),
839  &put_uri),
840 
842  int ret;
843 
845  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
846  return 2;
847 
848  ret = (GNUNET_OK ==
849  GNUNET_PROGRAM_run (argc,
850  argv,
851  "gnunet-peerinfo",
852  gettext_noop ("Print information about peers."),
853  options,
854  &run,
855  NULL))
856  ? 0
857  : 1;
858  GNUNET_free ((void *) argv);
859  return ret;
860 }
861 
862 
863 /* 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.
#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:1300
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:1438
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;.
#define GNUNET_NO
Definition: gnunet_common.h:78
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:75
#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:526
#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:880
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:181
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.
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: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:1280
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).
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:76
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:652
void GNUNET_PEERINFO_disconnect(struct GNUNET_PEERINFO_Handle *h)
Disconnect from the peerinfo service.
Definition: peerinfo_api.c:156
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:367
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:77
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:742
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:966