GNUnet  0.10.x
peerinfo_api_notify.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2001, 2002, 2004, 2005, 2007, 2009, 2010 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 
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
29 #include "gnunet_protocols.h"
30 #include "peerinfo.h"
31 
32 #define LOG(kind, ...) GNUNET_log_from(kind, "peerinfo-api", __VA_ARGS__)
33 
42 
47 
51  void *callback_cls;
52 
57 
62 
67 };
68 
69 
75 static void
76 reconnect(void *cls);
77 
78 
84 static void
86 {
87  GNUNET_MQ_destroy(nc->mq);
88  nc->mq = NULL;
90  nc);
91 }
92 
93 
101 static void
103  enum GNUNET_MQ_Error error)
104 {
105  struct GNUNET_PEERINFO_NotifyContext *nc = cls;
106 
107  do_reconnect(nc);
108 }
109 
110 
118 static int
120  const struct InfoMessage *im)
121 {
122  uint16_t ms = ntohs(im->header.size) - sizeof(*im);
123 
124  if (ms >= sizeof(struct GNUNET_MessageHeader))
125  {
126  const struct GNUNET_HELLO_Message *hello;
127 
128  hello = (const struct GNUNET_HELLO_Message *)&im[1];
129  if (ms != GNUNET_HELLO_size(hello))
130  {
131  GNUNET_break(0);
132  return GNUNET_SYSERR;
133  }
134  return GNUNET_OK;
135  }
136  if (0 != ms)
137  {
138  GNUNET_break(0);
139  return GNUNET_SYSERR;
140  }
141  return GNUNET_OK; /* odd... */
142 }
143 
144 
151 static void
153  const struct InfoMessage *im)
154 {
155  struct GNUNET_PEERINFO_NotifyContext *nc = cls;
156  const struct GNUNET_HELLO_Message *hello;
157  uint16_t ms = ntohs(im->header.size) - sizeof(struct InfoMessage);
158 
159  if (0 == ms)
160  return;
161  hello = (const struct GNUNET_HELLO_Message *)&im[1];
163  "Received information about peer `%s' from peerinfo database\n",
164  GNUNET_i2s(&im->peer));
165  nc->callback(nc->callback_cls,
166  &im->peer,
167  hello,
168  NULL);
169 }
170 
171 
181 static void
183  const struct GNUNET_MessageHeader *msg)
184 {
185  /* these are ignored by the notify API */
186 }
187 
188 
194 static void
195 reconnect(void *cls)
196 {
197  struct GNUNET_PEERINFO_NotifyContext *nc = cls;
198  struct GNUNET_MQ_MessageHandler handlers[] = {
199  GNUNET_MQ_hd_var_size(notification,
201  struct InfoMessage,
202  nc),
203  GNUNET_MQ_hd_fixed_size(end_iteration,
205  struct GNUNET_MessageHeader,
206  nc),
208  };
209  struct GNUNET_MQ_Envelope *env;
210  struct NotifyMessage *nm;
211 
212  nc->task = NULL;
213  nc->mq = GNUNET_CLIENT_connect(nc->cfg,
214  "peerinfo",
215  handlers,
217  nc);
218  if (NULL == nc->mq)
219  return;
220  env = GNUNET_MQ_msg(nm,
222  nm->include_friend_only = htonl(nc->include_friend_only);
223  GNUNET_MQ_send(nc->mq,
224  env);
225 }
226 
227 
247  void *callback_cls)
248 {
250 
252  nc->cfg = cfg;
253  nc->callback = callback;
256  reconnect(nc);
257  if (NULL == nc->mq)
258  {
260  "Could not connect to PEERINFO service.\n");
261  GNUNET_free(nc);
262  return NULL;
263  }
264  return nc;
265 }
266 
267 
273 void
275 {
276  if (NULL != nc->mq)
277  {
278  GNUNET_MQ_destroy(nc->mq);
279  nc->mq = NULL;
280  }
281  if (NULL != nc->task)
282  {
284  nc->task = NULL;
285  }
286  GNUNET_free(nc);
287 }
288 
289 /* end of peerinfo_api_notify.c */
void(* GNUNET_PEERINFO_Processor)(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello, const char *err_msg)
Type of an iterator over the hosts.
static void do_reconnect(struct GNUNET_PEERINFO_NotifyContext *nc)
We encountered an error, reconnect to the service.
A HELLO message is used to exchange information about transports with other peers.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint32_t include_friend_only
Include friend only HELLOs and peers in callbacks.
Definition: peerinfo.h:89
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:900
Context for the info handler.
static void reconnect(void *cls)
Task to re-try connecting to peerinfo.
GNUNET_MQ_Error
Error codes for the queue.
Message used to inform the client about a particular peer; this message is optionally followed by a H...
Definition: peerinfo.h:100
void GNUNET_PEERINFO_notify_cancel(struct GNUNET_PEERINFO_NotifyContext *nc)
Stop notifying about changes.
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
We got a disconnect after asking regex to do the announcement.
#define GNUNET_MESSAGE_TYPE_PEERINFO_NOTIFY
Start notifying this client about all changes to the known peers until it disconnects.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
int include_friend_only
Include friend only HELLOs in callbacks.
struct GNUNET_MQ_Handle * mq
Our connection to the PEERINFO service.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void * callback_cls
Closure for callback.
static void handle_end_iteration(void *cls, const struct GNUNET_MessageHeader *msg)
Type of a function to call when we receive a message from the service.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_PEERINFO_NotifyContext * GNUNET_PEERINFO_notify(const struct GNUNET_CONFIGURATION_Handle *cfg, int include_friend_only, GNUNET_PEERINFO_Processor callback, void *callback_cls)
Call a method whenever our known information about peers changes.
struct GNUNET_PeerIdentity peer
About which peer are we talking here?
Definition: peerinfo.h:114
static void handle_notification(void *cls, const struct InfoMessage *im)
Receive a peerinfo information message, process it.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
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:1264
#define LOG(kind,...)
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_PEERINFO_INFO.
Definition: peerinfo.h:104
Message handler for a specific message type.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
common internal definitions for peerinfo service
static int check_notification(void *cls, const struct InfoMessage *im)
Check that a peerinfo information message is well-formed.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_MESSAGE_TYPE_PEERINFO_INFO
Information about one of the peers.
Handle to a message queue.
Definition: mq.c:84
struct GNUNET_SCHEDULER_Task * task
Tasked used for delayed re-connection attempt.
configuration data
Definition: configuration.c:83
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration.
Entry in list of pending tasks.
Definition: scheduler.c:131
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:643
Header for all communications.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:821
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:351
#define GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END
End of information about other peers.
GNUNET_PEERINFO_Processor callback
Function to call with information.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_free(ptr)
Wrapper around free.
Header for all communications.
Definition: peerinfo.h:80
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956