[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] [gnunet] branch master updated (fc158da4c -> aae0e990d)
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] [gnunet] branch master updated (fc158da4c -> aae0e990d) |
|
Date: |
Mon, 09 Jan 2017 21:19:06 +0100 |
This is an automated email from the git hooks/post-receive script.
grothoff pushed a change to branch master
in repository gnunet.
from fc158da4c add entry for OpenWrt/LEDE along with my email address
new b92cddf9e out-of-order PIDs are not exactly protocol violations, hence
do not report as such
new 2024b175d cancel potentially dangling reconnect task
new fa960b4f0 handle transmissions initiated during disconnect callbacks
by dropping
new 4a99ca1c3 dead code elimination
new a03aea2e7 ignore zonefiles dir
new 2f45a7c96 remove legacy core api code (now dead)
new ea18976f5 rename new core API implementation to name of standard
implementation
new b60282144 rename new client API implementation to name of standard
implementation
new 17c50a3b4 log at DEBUG level
new e174c5ea5 fix link issue
new df3c092ec eliminate dead NAT options
new 4bf29b6e9 enable upnpc by default
new d829597ee cosmetics
new f12a7fb70 improve comments
new 07533da06 remove obsolete options
new e80db2f14 do not attempt to publish empty HELLOs
new aae0e990d cosmetics
The 17 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
src/cadet/cadet.h | 12 +-
src/cadet/cadet_common.c | 15 +-
src/cadet/gnunet-service-cadet_channel.c | 14 +-
src/cadet/gnunet-service-cadet_connection.c | 56 +-
src/cadet/gnunet-service-cadet_dht.c | 74 ++-
src/cadet/gnunet-service-cadet_peer.c | 3 +-
src/cadet/test_cadet.conf | 5 -
src/core/Makefile.am | 1 -
src/core/core_api.c | 773 +++++++++----------------
src/core/core_api_2.c | 865 ----------------------------
src/core/core_api_mq.c | 191 ------
src/core/test_core_defaults.conf | 6 -
src/dht/gnunet-service-dht_neighbours.c | 12 +-
src/dht/gnunet-service-dht_routing.c | 10 +-
src/dht/plugin_block_dht.c | 12 +-
src/gnsrecord/.gitignore | 1 +
src/namecache/.gitignore | 1 +
src/nat/gnunet-service-nat.c | 2 +-
src/nat/nat.conf.in | 33 +-
src/nat/nat_api.c | 5 +
src/util/Makefile.am | 2 +-
src/util/{client_new.c => client.c} | 0
22 files changed, 421 insertions(+), 1672 deletions(-)
delete mode 100644 src/core/core_api_2.c
delete mode 100644 src/core/core_api_mq.c
rename src/util/{client_new.c => client.c} (100%)
diff --git a/src/cadet/cadet.h b/src/cadet/cadet.h
index 049f3a85a..f3f6fb6b4 100644
--- a/src/cadet/cadet.h
+++ b/src/cadet/cadet.h
@@ -67,10 +67,16 @@ extern "C"
#define GNUNET_CADET_LOCAL_CHANNEL_ID_CLI 0x80000000
#define GNUNET_CADET_LOCAL_CHANNEL_ID_SERV 0xB0000000
-#define HIGH_PID 0xFFFF0000
-#define LOW_PID 0x0000FFFF
+#define HIGH_PID 0xFF000000
+#define LOW_PID 0x00FFFFFF
-#define PID_OVERFLOW(pid, max) (pid > HIGH_PID && max < LOW_PID)
+/**
+ * Test if the two PIDs (of type `uint32_t`) are in the range where we
+ * have to worry about overflows. This is the case when @a pid is
+ * large and @a max is small, useful when comparing @a pid smaller
+ * than @a max.
+ */
+#define PID_OVERFLOW(pid, max) (((pid) > HIGH_PID) && ((max) < LOW_PID))
/******************************************************************************/
/************************** MESSAGES
******************************/
diff --git a/src/cadet/cadet_common.c b/src/cadet/cadet_common.c
index a9d9a35be..20ee7e5c9 100644
--- a/src/cadet/cadet_common.c
+++ b/src/cadet/cadet_common.c
@@ -51,11 +51,20 @@ GC_f2s (int fwd)
}
}
+
+/**
+ * Test if @a bigger is larger than @a smaller.
+ * Considers the case that @a bigger just overflowed
+ * and is thus tiny while @a smaller is still below
+ * `UINT32_MAX`.
+ */
int
-GC_is_pid_bigger (uint32_t bigger, uint32_t smaller)
+GC_is_pid_bigger (uint32_t bigger,
+ uint32_t smaller)
{
- return (GNUNET_YES == PID_OVERFLOW (smaller, bigger) ||
- (bigger > smaller && GNUNET_NO == PID_OVERFLOW (bigger, smaller)));
+ return (PID_OVERFLOW (smaller, bigger) ||
+ ( (bigger > smaller) &&
+ (! PID_OVERFLOW (bigger, smaller))) );
}
diff --git a/src/cadet/gnunet-service-cadet_channel.c
b/src/cadet/gnunet-service-cadet_channel.c
index 11f23d38a..d2d176e83 100644
--- a/src/cadet/gnunet-service-cadet_channel.c
+++ b/src/cadet/gnunet-service-cadet_channel.c
@@ -1969,21 +1969,23 @@ GCCH_handle_data (struct CadetChannel *ch,
GC_m2s (GNUNET_MESSAGE_TYPE_CADET_DATA), GC_m2s (payload_type), mid,
GCCH_2s (ch), ch, GC_f2s (fwd), ntohs (msg->header.size));
- if (GNUNET_NO == ch->reliable ||
- ( !GC_is_pid_bigger (rel->mid_recv, mid) &&
- GC_is_pid_bigger (rel->mid_recv + 64, mid) ) )
+ if ( (GNUNET_NO == ch->reliable) ||
+ ( (! GC_is_pid_bigger (rel->mid_recv, mid)) &&
+ GC_is_pid_bigger (rel->mid_recv + 64, mid) ) )
{
if (GNUNET_YES == ch->reliable)
{
/* Is this the exact next expected messasge? */
if (mid == rel->mid_recv)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "as expected, sending to client\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "as expected, sending to client\n");
send_client_data (ch, msg, fwd);
}
else
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "save for later\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "save for later\n");
add_buffered_data (msg, rel);
}
}
@@ -2001,7 +2003,7 @@ GCCH_handle_data (struct CadetChannel *ch,
if (GC_is_pid_bigger (rel->mid_recv, mid))
{
GNUNET_break_op (0);
- LOG (GNUNET_ERROR_TYPE_INFO,
+ LOG (GNUNET_ERROR_TYPE_WARNING,
"MID %u on channel %s not expected (window: %u - %u). Dropping!\n",
mid, GCCH_2s (ch), rel->mid_recv, rel->mid_recv + 63);
}
diff --git a/src/cadet/gnunet-service-cadet_connection.c
b/src/cadet/gnunet-service-cadet_connection.c
index fa2bb962b..343e372b2 100644
--- a/src/cadet/gnunet-service-cadet_connection.c
+++ b/src/cadet/gnunet-service-cadet_connection.c
@@ -132,7 +132,8 @@ struct CadetFlowControl
uint32_t recv_bitmap;
/**
- * Last ACK sent to the peer (peer can't send more than this PID).
+ * Last ACK sent to the peer (peer is not allowed to send
+ * messages with PIDs higher than this value).
*/
uint32_t last_ack_sent;
@@ -540,7 +541,10 @@ send_poll (void *cls);
* @param force Don't optimize out.
*/
static void
-send_ack (struct CadetConnection *c, unsigned int buffer, int fwd, int force)
+send_ack (struct CadetConnection *c,
+ unsigned int buffer,
+ int fwd,
+ int force)
{
struct CadetFlowControl *next_fc;
struct CadetFlowControl *prev_fc;
@@ -598,7 +602,8 @@ send_ack (struct CadetConnection *c, unsigned int buffer,
int fwd, int force)
return;
}
}
-
+ GNUNET_break (GC_is_pid_bigger (ack,
+ prev_fc->last_ack_sent));
prev_fc->last_ack_sent = ack;
/* Build ACK message and send on conn */
@@ -607,7 +612,9 @@ send_ack (struct CadetConnection *c, unsigned int buffer,
int fwd, int force)
msg.ack = htonl (ack);
msg.cid = c->id;
- prev_fc->ack_msg = GCC_send_prebuilt_message (&msg.header, UINT16_MAX, ack,
+ prev_fc->ack_msg = GCC_send_prebuilt_message (&msg.header,
+ UINT16_MAX,
+ ack,
c, !fwd, GNUNET_YES,
NULL, NULL);
GNUNET_assert (NULL != prev_fc->ack_msg);
@@ -2310,8 +2317,8 @@ GCC_handle_ack (struct CadetPeer *peer,
fc->last_ack_recv = ack;
/* Cancel polling if the ACK is big enough. */
- if (NULL != fc->poll_task &&
- GC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent))
+ if ( (NULL != fc->poll_task) &
+ GC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent))
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " Cancel poll\n");
GNUNET_SCHEDULER_cancel (fc->poll_task);
@@ -2422,6 +2429,7 @@ check_message (const struct GNUNET_MessageHeader *message,
"%s on unknown connection %s\n",
GC_m2s (ntohs (message->type)),
GNUNET_h2s (GC_h2hc (cid)));
+ GNUNET_break_op (0);
send_broken_unknown (cid,
&my_full_id,
NULL,
@@ -2457,13 +2465,18 @@ check_message (const struct GNUNET_MessageHeader
*message,
{
fc = fwd ? &c->bck_fc : &c->fwd_fc;
LOG (GNUNET_ERROR_TYPE_DEBUG, " PID %u (expected %u - %u)\n",
- pid, fc->last_pid_recv + 1, fc->last_ack_sent);
+ pid,
+ fc->last_pid_recv + 1,
+ fc->last_ack_sent);
if (GC_is_pid_bigger (pid, fc->last_ack_sent))
{
- GNUNET_break_op (0);
- GNUNET_STATISTICS_update (stats, "# unsolicited message", 1, GNUNET_NO);
- LOG (GNUNET_ERROR_TYPE_WARNING, "Received PID %u, (prev %u), ACK %u\n",
- pid, fc->last_pid_recv, fc->last_ack_sent);
+ GNUNET_STATISTICS_update (stats,
+ "# unsolicited message",
+ 1,
+ GNUNET_NO);
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Received PID %u, (prev %u), ACK %u\n",
+ pid, fc->last_pid_recv, fc->last_ack_sent);
return GNUNET_SYSERR;
}
if (GC_is_pid_bigger (pid, fc->last_pid_recv))
@@ -2477,10 +2490,16 @@ check_message (const struct GNUNET_MessageHeader
*message,
}
else
{
- GNUNET_STATISTICS_update (stats, "# out of order PID", 1, GNUNET_NO);
- if (GNUNET_NO == is_ooo_ok (fc->last_pid_recv, pid, fc->recv_bitmap))
+ GNUNET_STATISTICS_update (stats,
+ "# out of order PID",
+ 1,
+ GNUNET_NO);
+ if (GNUNET_NO == is_ooo_ok (fc->last_pid_recv,
+ pid,
+ fc->recv_bitmap))
{
- LOG (GNUNET_ERROR_TYPE_WARNING, "PID %u unexpected (%u+), dropping!\n",
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "PID %u unexpected (%u+), dropping!\n",
pid, fc->last_pid_recv - 31);
return GNUNET_SYSERR;
}
@@ -2489,7 +2508,8 @@ check_message (const struct GNUNET_MessageHeader *message,
}
/* Count as connection confirmation. */
- if (CADET_CONNECTION_SENT == c->state || CADET_CONNECTION_ACK == c->state)
+ if ( (CADET_CONNECTION_SENT == c->state) ||
+ (CADET_CONNECTION_ACK == c->state) )
{
connection_change_state (c, CADET_CONNECTION_READY);
if (NULL != c->t)
@@ -2591,7 +2611,6 @@ GCC_handle_encrypted (struct CadetPeer *peer,
/* If something went wrong, discard message. */
if (GNUNET_SYSERR == fwd)
{
- GNUNET_break_op (0);
GCC_check_connections ();
return;
}
@@ -2953,8 +2972,9 @@ GCC_get_allowed (struct CadetConnection *c, int fwd)
struct CadetFlowControl *fc;
fc = fwd ? &c->fwd_fc : &c->bck_fc;
- if (CADET_CONNECTION_READY != c->state
- || GC_is_pid_bigger (fc->last_pid_recv, fc->last_ack_sent))
+ if ( (CADET_CONNECTION_READY != c->state) ||
+ GC_is_pid_bigger (fc->last_pid_recv,
+ fc->last_ack_sent) )
{
return 0;
}
diff --git a/src/cadet/gnunet-service-cadet_dht.c
b/src/cadet/gnunet-service-cadet_dht.c
index 9b11ebf18..43b1c8252 100644
--- a/src/cadet/gnunet-service-cadet_dht.c
+++ b/src/cadet/gnunet-service-cadet_dht.c
@@ -224,13 +224,16 @@ announce_id (void *cls)
announce_id_task = NULL;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Announce ID\n");
hello = GCH_get_mine ();
- size = NULL != hello ? GNUNET_HELLO_size (hello) : 0;
- if (NULL == hello || 0 == size)
+ size = (NULL != hello) ? GNUNET_HELLO_size (hello) : 0;
+ if ( (NULL == hello) || (0 == size) )
{
/* Peerinfo gave us no hello yet, try again soon. */
- LOG (GNUNET_ERROR_TYPE_INFO, " no hello, waiting!\n");
- GNUNET_STATISTICS_update (stats, "# DHT announce skipped (no hello)",
- 1, GNUNET_NO);
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ " no hello, waiting!\n");
+ GNUNET_STATISTICS_update (stats,
+ "# DHT announce skipped (no hello)",
+ 1,
+ GNUNET_NO);
expiration = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
announce_delay);
announce_delay = GNUNET_TIME_STD_BACKOFF (announce_delay);
@@ -241,29 +244,43 @@ announce_id (void *cls)
announce_delay = GNUNET_TIME_UNIT_SECONDS;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Hello %p size: %u\n", hello, size);
- GNUNET_STATISTICS_update (stats, "# DHT announce",
- 1, GNUNET_NO);
- memset (&phash, 0, sizeof (phash));
- GNUNET_memcpy (&phash, &my_full_id, sizeof (my_full_id));
- GNUNET_DHT_put (dht_handle, /* DHT handle */
- &phash, /* Key to use */
- dht_replication_level, /* Replication level */
- GNUNET_DHT_RO_RECORD_ROUTE
- | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, /* DHT options */
- GNUNET_BLOCK_TYPE_DHT_HELLO, /* Block type */
- size, /* Size of the data */
- (const char *) hello, /* Data itself */
- expiration, /* Data expiration */
- NULL, /* Continuation */
- NULL); /* Continuation closure */
-
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Hello %p size: %u\n",
+ hello,
+ size);
+ if (NULL != hello)
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# DHT announce",
+ 1, GNUNET_NO);
+ memset (&phash,
+ 0,
+ sizeof (phash));
+ GNUNET_memcpy (&phash,
+ &my_full_id,
+ sizeof (my_full_id));
+ GNUNET_DHT_put (dht_handle, /* DHT handle */
+ &phash, /* Key to use */
+ dht_replication_level, /* Replication level */
+ GNUNET_DHT_RO_RECORD_ROUTE
+ | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, /* DHT options */
+ GNUNET_BLOCK_TYPE_DHT_HELLO, /* Block type */
+ size, /* Size of the data */
+ (const char *) hello, /* Data itself */
+ expiration, /* Data expiration */
+ NULL, /* Continuation */
+ NULL); /* Continuation closure */
+ }
/* Call again in id_announce_time, unless HELLO expires first,
* but wait at least 1s. */
next_put = GNUNET_TIME_absolute_get_remaining (expiration);
- next_put = GNUNET_TIME_relative_min (next_put, id_announce_time);
- next_put = GNUNET_TIME_relative_max (next_put, GNUNET_TIME_UNIT_SECONDS);
- announce_id_task = GNUNET_SCHEDULER_add_delayed (next_put, &announce_id,
cls);
+ next_put = GNUNET_TIME_relative_min (next_put,
+ id_announce_time);
+ next_put = GNUNET_TIME_relative_max (next_put,
+ GNUNET_TIME_UNIT_SECONDS);
+ announce_id_task = GNUNET_SCHEDULER_add_delayed (next_put,
+ &announce_id,
+ cls);
}
/**
@@ -378,8 +395,11 @@ GCD_search (const struct GNUNET_PeerIdentity *peer_id,
GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
NULL, /* xquery */
0, /* xquery bits */
- &dht_get_id_handler, h);
- GNUNET_CONTAINER_multihashmap32_put (get_requests, h->peer_id, h,
+ &dht_get_id_handler,
+ h);
+ GNUNET_CONTAINER_multihashmap32_put (get_requests,
+ h->peer_id,
+ h,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
return h;
}
diff --git a/src/cadet/gnunet-service-cadet_peer.c
b/src/cadet/gnunet-service-cadet_peer.c
index c3701a39e..918bf4e0c 100644
--- a/src/cadet/gnunet-service-cadet_peer.c
+++ b/src/cadet/gnunet-service-cadet_peer.c
@@ -1224,7 +1224,8 @@ GCP_send (struct CadetPeer *peer,
{
if (GNUNET_YES == should_I_drop ())
{
- LOG (GNUNET_ERROR_TYPE_WARNING, "DD %s (%s %u) on conn %s %s\n",
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "DD %s (%s %u) on conn %s %s (random drop for testing)\n",
GC_m2s (q->type), GC_m2s (q->payload_type),
q->payload_id, GCC_2s (c), GC_f2s (q->c_fwd));
q->drop_task = GNUNET_SCHEDULER_add_now (&drop_cb,
diff --git a/src/cadet/test_cadet.conf b/src/cadet/test_cadet.conf
index b6ed64c58..e0c00858e 100644
--- a/src/cadet/test_cadet.conf
+++ b/src/cadet/test_cadet.conf
@@ -59,11 +59,6 @@ USE_EPHEMERAL_KEYS = NO
[PATHS]
GNUNET_TEST_HOME = /tmp/test-cadet/
-[nat]
-RETURN_LOCAL_ADDRESSES = YES
-DISABLEV6 = YES
-USE_LOCALADDR = YES
-
[peerinfo]
NO_IO = YES
diff --git a/src/core/Makefile.am b/src/core/Makefile.am
index aea64fa34..ed80bae73 100644
--- a/src/core/Makefile.am
+++ b/src/core/Makefile.am
@@ -23,7 +23,6 @@ lib_LTLIBRARIES = \
libgnunetcore_la_SOURCES = \
core_api.c core.h \
- core_api_2.c \
core_api_monitor_peers.c
libgnunetcore_la_LIBADD = \
$(top_builddir)/src/util/libgnunetutil.la \
diff --git a/src/core/core_api.c b/src/core/core_api.c
index fda49e259..cf7924a0d 100644
--- a/src/core/core_api.c
+++ b/src/core/core_api.c
@@ -33,79 +33,32 @@
/**
- * Handle for a transmission request.
+ * Information we track for each peer.
*/
-struct GNUNET_CORE_TransmitHandle
+struct PeerRecord
{
/**
- * Corresponding peer record.
- */
- struct PeerRecord *peer;
-
- /**
- * Function that will be called to get the actual request
- * (once we are ready to transmit this request to the core).
- * The function will be called with a NULL buffer to signal
- * timeout.
- */
- GNUNET_CONNECTION_TransmitReadyNotify get_message;
-
- /**
- * Closure for @e get_message.
- */
- void *get_message_cls;
-
- /**
- * Deadline for the transmission (the request does not get cancelled
- * at this time, this is merely how soon the application wants this out).
- */
- struct GNUNET_TIME_Absolute deadline;
-
- /**
- * When did this request get queued?
- */
- struct GNUNET_TIME_Absolute request_time;
-
- /**
- * How important is this message?
- */
- enum GNUNET_CORE_Priority priority;
-
- /**
- * Is corking allowed?
- */
- int cork;
-
- /**
- * Size of this request.
+ * Corresponding CORE handle.
*/
- uint16_t msize;
+ struct GNUNET_CORE_Handle *h;
/**
- * Send message request ID for this request.
+ * Message queue for the peer.
*/
- uint16_t smr_id;
-
-};
-
-
-/**
- * Information we track for each peer.
- */
-struct PeerRecord
-{
+ struct GNUNET_MQ_Handle *mq;
/**
- * Corresponding CORE handle.
+ * Message we are currently trying to pass to the CORE service
+ * for this peer (from @e mq).
*/
- struct GNUNET_CORE_Handle *ch;
+ struct GNUNET_MQ_Envelope *env;
/**
- * Pending request, if any. 'th->peer' is set to NULL if the
- * request is not active.
+ * Value the client returned when we connected, used
+ * as the closure in various places.
*/
- struct GNUNET_CORE_TransmitHandle th;
+ void *client_cls;
/**
* Peer the record is about.
@@ -144,27 +97,17 @@ struct GNUNET_CORE_Handle
/**
* Function to call whenever we're notified about a peer connecting.
*/
- GNUNET_CORE_ConnectEventHandler connects;
+ GNUNET_CORE_ConnecTEventHandler connects;
/**
* Function to call whenever we're notified about a peer disconnecting.
*/
- GNUNET_CORE_DisconnectEventHandler disconnects;
-
- /**
- * Function to call whenever we receive an inbound message.
- */
- GNUNET_CORE_MessageCallback inbound_notify;
-
- /**
- * Function to call whenever we receive an outbound message.
- */
- GNUNET_CORE_MessageCallback outbound_notify;
+ GNUNET_CORE_DisconnecTEventHandler disconnects;
/**
* Function handlers for messages of particular type.
*/
- struct GNUNET_CORE_MessageHandler *handlers;
+ struct GNUNET_MQ_MessageHandler *handlers;
/**
* Our message queue for transmissions to the service.
@@ -198,24 +141,6 @@ struct GNUNET_CORE_Handle
unsigned int hcnt;
/**
- * For inbound notifications without a specific handler, do
- * we expect to only receive headers?
- */
- int inbound_hdr_only;
-
- /**
- * For outbound notifications without a specific handler, do
- * we expect to only receive headers?
- */
- int outbound_hdr_only;
-
- /**
- * Are we currently disconnected and hence unable to forward
- * requests?
- */
- int currently_down;
-
- /**
* Did we ever get INIT?
*/
int have_init;
@@ -266,25 +191,19 @@ disconnect_and_free_peer_entry (void *cls,
void *value)
{
struct GNUNET_CORE_Handle *h = cls;
- struct GNUNET_CORE_TransmitHandle *th;
struct PeerRecord *pr = value;
+ GNUNET_assert (pr->h == h);
if (NULL != h->disconnects)
h->disconnects (h->cls,
- &pr->peer);
- /* all requests should have been cancelled, clean up anyway, just in case */
- th = &pr->th;
- if (NULL != th->peer)
- {
- GNUNET_break (0);
- th->peer = NULL;
- }
- /* done with 'voluntary' cleanups, now on to normal freeing */
+ &pr->peer,
+ pr->client_cls);
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multipeermap_remove (h->peers,
key,
pr));
- GNUNET_assert (pr->ch == h);
+ GNUNET_MQ_destroy (pr->mq);
+ GNUNET_assert (NULL == pr->mq);
GNUNET_free (pr);
return GNUNET_YES;
}
@@ -305,8 +224,7 @@ reconnect_later (struct GNUNET_CORE_Handle *h)
GNUNET_MQ_destroy (h->mq);
h->mq = NULL;
}
- h->currently_down = GNUNET_YES;
- GNUNET_assert (h->reconnect_task == NULL);
+ GNUNET_assert (NULL == h->reconnect_task);
h->reconnect_task =
GNUNET_SCHEDULER_add_delayed (h->retry_backoff,
&reconnect_task,
@@ -319,9 +237,8 @@ reconnect_later (struct GNUNET_CORE_Handle *h)
/**
- * Generic error handler, called with the appropriate error code and
- * the same closure specified at the creation of the message queue.
- * Not every message queue implementation supports an error handler.
+ * Error handler for the message queue to the CORE service.
+ * On errors, we reconnect.
*
* @param cls closure, a `struct GNUNET_CORE_Handle *`
* @param error error code
@@ -340,6 +257,209 @@ handle_mq_error (void *cls,
/**
+ * Inquire with CORE what options should be set for a message
+ * so that it is transmitted with the given @a priority and
+ * the given @a cork value.
+ *
+ * @param cork desired corking
+ * @param priority desired message priority
+ * @param[out] flags set to `flags` value for #GNUNET_MQ_set_options()
+ * @return `extra` argument to give to #GNUNET_MQ_set_options()
+ */
+const void *
+GNUNET_CORE_get_mq_options (int cork,
+ enum GNUNET_CORE_Priority priority,
+ uint64_t *flags)
+{
+ *flags = ((uint64_t) priority) + (((uint64_t) cork) << 32);
+ return NULL;
+}
+
+
+/**
+ * Implement sending functionality of a message queue for
+ * us sending messages to a peer.
+ *
+ * @param mq the message queue
+ * @param msg the message to send
+ * @param impl_state state of the implementation
+ */
+static void
+core_mq_send_impl (struct GNUNET_MQ_Handle *mq,
+ const struct GNUNET_MessageHeader *msg,
+ void *impl_state)
+{
+ struct PeerRecord *pr = impl_state;
+ struct GNUNET_CORE_Handle *h = pr->h;
+ struct SendMessageRequest *smr;
+ struct SendMessage *sm;
+ struct GNUNET_MQ_Envelope *env;
+ uint16_t msize;
+ uint64_t flags;
+ int cork;
+ enum GNUNET_CORE_Priority priority;
+
+ if (NULL == h->mq)
+ {
+ /* We're currently reconnecting, pretend this worked */
+ GNUNET_MQ_impl_send_continue (mq);
+ return;
+ }
+ GNUNET_assert (NULL == pr->env);
+ /* extract options from envelope */
+ env = GNUNET_MQ_get_current_envelope (mq);
+ GNUNET_break (NULL ==
+ GNUNET_MQ_env_get_options (env,
+ &flags));
+ cork = (int) (flags >> 32);
+ priority = (uint32_t) flags;
+
+ /* check message size for sanity */
+ msize = ntohs (msg->size);
+ if (msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct SendMessage))
+ {
+ GNUNET_break (0);
+ GNUNET_MQ_impl_send_continue (mq);
+ return;
+ }
+
+ /* ask core for transmission */
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Asking core for transmission of %u bytes to `%s'\n",
+ (unsigned int) msize,
+ GNUNET_i2s (&pr->peer));
+ env = GNUNET_MQ_msg (smr,
+ GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST);
+ smr->priority = htonl ((uint32_t) priority);
+ // smr->deadline = GNUNET_TIME_absolute_hton (deadline);
+ smr->peer = pr->peer;
+ smr->reserved = htonl (0);
+ smr->size = htons (msize);
+ smr->smr_id = htons (++pr->smr_id_gen);
+ GNUNET_MQ_send (h->mq,
+ env);
+
+ /* prepare message with actual transmission data */
+ pr->env = GNUNET_MQ_msg_nested_mh (sm,
+ GNUNET_MESSAGE_TYPE_CORE_SEND,
+ msg);
+ sm->priority = htonl ((uint32_t) priority);
+ // sm->deadline = GNUNET_TIME_absolute_hton (deadline);
+ sm->peer = pr->peer;
+ sm->cork = htonl ((uint32_t) cork);
+ sm->reserved = htonl (0);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Calling get_message with buffer of %u bytes (%s)\n",
+ (unsigned int) msize,
+ cork ? "corked" : "uncorked");
+}
+
+
+/**
+ * Handle destruction of a message queue. Implementations must not
+ * free @a mq, but should take care of @a impl_state.
+ *
+ * @param mq the message queue to destroy
+ * @param impl_state state of the implementation
+ */
+static void
+core_mq_destroy_impl (struct GNUNET_MQ_Handle *mq,
+ void *impl_state)
+{
+ struct PeerRecord *pr = impl_state;
+
+ GNUNET_assert (mq == pr->mq);
+ pr->mq = NULL;
+}
+
+
+/**
+ * Implementation function that cancels the currently sent message.
+ * Should basically undo whatever #mq_send_impl() did.
+ *
+ * @param mq message queue
+ * @param impl_state state specific to the implementation
+ */
+static void
+core_mq_cancel_impl (struct GNUNET_MQ_Handle *mq,
+ void *impl_state)
+{
+ struct PeerRecord *pr = impl_state;
+
+ GNUNET_assert (NULL != pr->env);
+ GNUNET_MQ_discard (pr->env);
+ pr->env = NULL;
+}
+
+
+/**
+ * We had an error processing a message we forwarded from a peer to
+ * the CORE service. We should just complain about it but otherwise
+ * continue processing.
+ *
+ * @param cls closure
+ * @param error error code
+ */
+static void
+core_mq_error_handler (void *cls,
+ enum GNUNET_MQ_Error error)
+{
+ /* struct PeerRecord *pr = cls; */
+
+ GNUNET_break_op (0);
+}
+
+
+/**
+ * Add the given peer to the list of our connected peers
+ * and create the respective data structures and notify
+ * the application.
+ *
+ * @param h the core handle
+ * @param peer the peer that is connecting to us
+ */
+static void
+connect_peer (struct GNUNET_CORE_Handle *h,
+ const struct GNUNET_PeerIdentity *peer)
+{
+ struct PeerRecord *pr;
+ uint64_t flags;
+ const void *extra;
+
+ pr = GNUNET_new (struct PeerRecord);
+ pr->peer = *peer;
+ pr->h = h;
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_put (h->peers,
+ &pr->peer,
+ pr,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ pr->mq = GNUNET_MQ_queue_for_callbacks (&core_mq_send_impl,
+ &core_mq_destroy_impl,
+ &core_mq_cancel_impl,
+ pr,
+ h->handlers,
+ &core_mq_error_handler,
+ pr);
+ /* get our default options */
+ extra = GNUNET_CORE_get_mq_options (GNUNET_NO,
+ GNUNET_CORE_PRIO_BEST_EFFORT,
+ &flags);
+ GNUNET_MQ_set_options (pr->mq,
+ flags,
+ extra);
+ if (NULL != h->connects)
+ {
+ pr->client_cls = h->connects (h->cls,
+ &pr->peer,
+ pr->mq);
+ GNUNET_MQ_set_handlers_closure (pr->mq,
+ pr->client_cls);
+ }
+}
+
+
+/**
* Handle init reply message received from CORE service. Notify
* application that we are now connected to the CORE. Also fake
* loopback connection.
@@ -353,11 +473,8 @@ handle_init_reply (void *cls,
{
struct GNUNET_CORE_Handle *h = cls;
GNUNET_CORE_StartupCallback init;
- struct PeerRecord *pr;
GNUNET_break (0 == ntohl (m->reserved));
- GNUNET_break (GNUNET_YES == h->currently_down);
- h->currently_down = GNUNET_NO;
h->retry_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
if (NULL != (init = h->init))
{
@@ -388,17 +505,8 @@ handle_init_reply (void *cls,
}
}
/* fake 'connect to self' */
- pr = GNUNET_new (struct PeerRecord);
- pr->peer = h->me;
- pr->ch = h;
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_put (h->peers,
- &h->me,
- pr,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
- if (NULL != h->connects)
- h->connects (h->cls,
- &pr->peer);
+ connect_peer (h,
+ &h->me);
}
@@ -416,7 +524,6 @@ handle_connect_notify (void *cls,
struct GNUNET_CORE_Handle *h = cls;
struct PeerRecord *pr;
- GNUNET_break (GNUNET_NO == h->currently_down);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received notification about connection from `%s'.\n",
GNUNET_i2s (&cnm->peer));
@@ -436,17 +543,8 @@ handle_connect_notify (void *cls,
reconnect_later (h);
return;
}
- pr = GNUNET_new (struct PeerRecord);
- pr->peer = cnm->peer;
- pr->ch = h;
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_put (h->peers,
- &cnm->peer,
- pr,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
- if (NULL != h->connects)
- h->connects (h->cls,
- &pr->peer);
+ connect_peer (h,
+ &cnm->peer);
}
@@ -459,17 +557,16 @@ handle_connect_notify (void *cls,
*/
static void
handle_disconnect_notify (void *cls,
- const struct DisconnectNotifyMessage * dnm)
+ const struct DisconnectNotifyMessage *dnm)
{
struct GNUNET_CORE_Handle *h = cls;
struct PeerRecord *pr;
- GNUNET_break (GNUNET_NO == h->currently_down);
if (0 == memcmp (&h->me,
&dnm->peer,
sizeof (struct GNUNET_PeerIdentity)))
{
- /* connection to self!? */
+ /* disconnect from self!? */
GNUNET_break (0);
return;
}
@@ -486,7 +583,7 @@ handle_disconnect_notify (void *cls,
return;
}
disconnect_and_free_peer_entry (h,
- &dnm->peer,
+ &pr->peer,
pr);
}
@@ -502,11 +599,9 @@ static int
check_notify_inbound (void *cls,
const struct NotifyTrafficMessage *ntm)
{
- struct GNUNET_CORE_Handle *h = cls;
uint16_t msize;
const struct GNUNET_MessageHeader *em;
- GNUNET_break (GNUNET_NO == h->currently_down);
msize = ntohs (ntm->header.size) - sizeof (struct NotifyTrafficMessage);
if (msize < sizeof (struct GNUNET_MessageHeader))
{
@@ -514,8 +609,7 @@ check_notify_inbound (void *cls,
return GNUNET_SYSERR;
}
em = (const struct GNUNET_MessageHeader *) &ntm[1];
- if ( (GNUNET_NO == h->inbound_hdr_only) &&
- (msize != ntohs (em->size)) )
+ if (msize != ntohs (em->size))
{
GNUNET_break (0);
return GNUNET_SYSERR;
@@ -538,120 +632,21 @@ handle_notify_inbound (void *cls,
struct GNUNET_CORE_Handle *h = cls;
const struct GNUNET_MessageHeader *em;
struct PeerRecord *pr;
- uint16_t et;
- GNUNET_break (GNUNET_NO == h->currently_down);
- em = (const struct GNUNET_MessageHeader *) &ntm[1];
- et = ntohs (em->type);
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received inbound message of type %d from `%s'.\n",
- (int) et,
+ "Received inbound message from `%s'.\n",
GNUNET_i2s (&ntm->peer));
- for (unsigned int hpos = 0; NULL != h->handlers[hpos].callback; hpos++)
- {
- const struct GNUNET_CORE_MessageHandler *mh;
-
- mh = &h->handlers[hpos];
- if (mh->type != et)
- continue;
- if ( (mh->expected_size != ntohs (em->size)) &&
- (0 != mh->expected_size) )
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Unexpected message size %u for message of type %u from peer
`%s'\n",
- htons (em->size),
- mh->type,
- GNUNET_i2s (&ntm->peer));
- GNUNET_break_op (0);
- continue;
- }
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- &ntm->peer);
- if (NULL == pr)
- {
- GNUNET_break (0);
- reconnect_later (h);
- return;
- }
- if (GNUNET_OK !=
- h->handlers[hpos].callback (h->cls,
- &ntm->peer,
- em))
- {
- /* error in processing, do not process other messages! */
- break;
- }
- }
- if (NULL != h->inbound_notify)
- h->inbound_notify (h->cls,
- &ntm->peer,
- em);
-}
-
-
-/**
- * Check that message received from CORE service is well-formed.
- *
- * @param cls the `struct GNUNET_CORE_Handle`
- * @param ntm the message we got
- * @return #GNUNET_OK if the message is well-formed
- */
-static int
-check_notify_outbound (void *cls,
- const struct NotifyTrafficMessage *ntm)
-{
- struct GNUNET_CORE_Handle *h = cls;
- uint16_t msize;
- const struct GNUNET_MessageHeader *em;
-
- GNUNET_break (GNUNET_NO == h->currently_down);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received outbound message from `%s'.\n",
- GNUNET_i2s (&ntm->peer));
- msize = ntohs (ntm->header.size) - sizeof (struct NotifyTrafficMessage);
- if (msize < sizeof (struct GNUNET_MessageHeader))
- {
- GNUNET_break (0);
- return GNUNET_SYSERR;
- }
- em = (const struct GNUNET_MessageHeader *) &ntm[1];
- if ( (GNUNET_NO == h->outbound_hdr_only) &&
- (msize != ntohs (em->size)) )
- {
- GNUNET_break (0);
- return GNUNET_SYSERR;
- }
- return GNUNET_OK;
-}
-
-
-/**
- * Handle outbound message received from CORE service. If applicable,
- * notify the application.
- *
- * @param cls the `struct GNUNET_CORE_Handle`
- * @param ntm the message we got
- */
-static void
-handle_notify_outbound (void *cls,
- const struct NotifyTrafficMessage *ntm)
-{
- struct GNUNET_CORE_Handle *h = cls;
- const struct GNUNET_MessageHeader *em;
-
- GNUNET_break (GNUNET_NO == h->currently_down);
em = (const struct GNUNET_MessageHeader *) &ntm[1];
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received notification about transmission to `%s'.\n",
- GNUNET_i2s (&ntm->peer));
- if (NULL == h->outbound_notify)
+ pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
+ &ntm->peer);
+ if (NULL == pr)
{
GNUNET_break (0);
+ reconnect_later (h);
return;
}
- h->outbound_notify (h->cls,
- &ntm->peer,
- em);
+ GNUNET_MQ_inject_message (pr->mq,
+ em);
}
@@ -661,7 +656,7 @@ handle_notify_outbound (void *cls,
* pending, put it into the queue to be transmitted.
*
* @param cls the `struct GNUNET_CORE_Handle`
- * @param ntm the message we got
+ * @param smr the message we got
*/
static void
handle_send_ready (void *cls,
@@ -669,16 +664,7 @@ handle_send_ready (void *cls,
{
struct GNUNET_CORE_Handle *h = cls;
struct PeerRecord *pr;
- struct GNUNET_CORE_TransmitHandle *th;
- struct SendMessage *sm;
- struct GNUNET_MQ_Envelope *env;
- struct GNUNET_TIME_Relative delay;
- struct GNUNET_TIME_Relative overdue;
- unsigned int ret;
- unsigned int priority;
- int cork;
- GNUNET_break (GNUNET_NO == h->currently_down);
pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
&smr->peer);
if (NULL == pr)
@@ -690,72 +676,24 @@ handle_send_ready (void *cls,
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received notification about transmission readiness to `%s'.\n",
GNUNET_i2s (&smr->peer));
- if (NULL == pr->th.peer)
+ if (NULL == pr->env)
{
/* request must have been cancelled between the original request
* and the response from CORE, ignore CORE's readiness */
return;
}
- th = &pr->th;
- if (ntohs (smr->smr_id) != th->smr_id)
+ if (ntohs (smr->smr_id) != pr->smr_id_gen)
{
/* READY message is for expired or cancelled message,
* ignore! (we should have already sent another request) */
return;
}
+
/* ok, all good, send message out! */
- th->peer = NULL;
- env = GNUNET_MQ_msg_extra (sm,
- th->msize,
- GNUNET_MESSAGE_TYPE_CORE_SEND);
- sm->priority = htonl ((uint32_t) th->priority);
- sm->deadline = GNUNET_TIME_absolute_hton (th->deadline);
- sm->peer = pr->peer;
- sm->cork = htonl ((uint32_t) (cork = th->cork));
- sm->reserved = htonl (0);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Calling get_message with buffer of %u bytes (%s)\n",
- (unsigned int) th->msize,
- cork ? "corked" : "uncorked");
- /* FIXME: this is ugly and a bit brutal, but "get_message"
- may call GNUNET_CORE_notify_transmit_ready() which
- may call GNUNET_MQ_send() as well, and we MUST get this
- message out before the next SEND_REQUEST. So we queue
- it (even though incomplete) and then---relying on MQ being
- nice and not actually touching 'env' until much later---
- fill it afterwards. This is horrible style, and once
- the core_api abandons GNUNET_CORE_notify_transmit_ready
- in favor of an MQ-style API, this hack should no longer
- be required */
GNUNET_MQ_send (h->mq,
- env);
- delay = GNUNET_TIME_absolute_get_duration (th->request_time);
- overdue = GNUNET_TIME_absolute_get_duration (th->deadline);
- priority = th->priority;
- ret = th->get_message (th->get_message_cls,
- th->msize,
- &sm[1]);
- /* after this point, 'th' should not be used anymore, it
- may now be about another message! */
- sm->header.size = htons (ret + sizeof (struct SendMessage));
- if (overdue.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Transmitting overdue %u bytes to `%s' at priority %u with %s delay
%s\n",
- ret,
- GNUNET_i2s (&pr->peer),
- priority,
- GNUNET_STRINGS_relative_time_to_string (delay,
- GNUNET_YES),
- (cork) ? " (corked)" : " (uncorked)");
- else
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Transmitting %u bytes to `%s' at priority %u with %s delay %s\n",
- ret,
- GNUNET_i2s (&pr->peer),
- priority,
- GNUNET_STRINGS_relative_time_to_string (delay,
- GNUNET_YES),
- (cork) ? " (corked)" : " (uncorked)");
+ pr->env);
+ pr->env = NULL;
+ GNUNET_MQ_impl_send_continue (pr->mq);
}
@@ -785,10 +723,6 @@ reconnect (struct GNUNET_CORE_Handle *h)
GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND,
struct NotifyTrafficMessage,
h),
- GNUNET_MQ_hd_var_size (notify_outbound,
- GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND,
- struct NotifyTrafficMessage,
- h),
GNUNET_MQ_hd_fixed_size (send_ready,
GNUNET_MESSAGE_TYPE_CORE_SEND_READY,
struct SendMessageReady,
@@ -797,11 +731,9 @@ reconnect (struct GNUNET_CORE_Handle *h)
};
struct InitMessage *init;
struct GNUNET_MQ_Envelope *env;
- uint32_t opt;
uint16_t *ts;
GNUNET_assert (NULL == h->mq);
- GNUNET_assert (GNUNET_YES == h->currently_down);
h->mq = GNUNET_CLIENT_connecT (h->cfg,
"core",
handlers,
@@ -815,25 +747,9 @@ reconnect (struct GNUNET_CORE_Handle *h)
env = GNUNET_MQ_msg_extra (init,
sizeof (uint16_t) * h->hcnt,
GNUNET_MESSAGE_TYPE_CORE_INIT);
- opt = GNUNET_CORE_OPTION_NOTHING;
- if (NULL != h->inbound_notify)
- {
- if (h->inbound_hdr_only)
- opt |= GNUNET_CORE_OPTION_SEND_HDR_INBOUND;
- else
- opt |= GNUNET_CORE_OPTION_SEND_FULL_INBOUND;
- }
- if (NULL != h->outbound_notify)
- {
- if (h->outbound_hdr_only)
- opt |= GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND;
- else
- opt |= GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND;
- }
LOG (GNUNET_ERROR_TYPE_INFO,
- "(Re)connecting to CORE service, monitoring messages of type %u\n",
- opt);
- init->options = htonl (opt);
+ "(Re)connecting to CORE service\n");
+ init->options = htonl (0);
ts = (uint16_t *) &init[1];
for (unsigned int hpos = 0; hpos < h->hcnt; hpos++)
ts[hpos] = htons (h->handlers[hpos].type);
@@ -852,29 +768,17 @@ reconnect (struct GNUNET_CORE_Handle *h)
* connected to the core service
* @param connects function to call on peer connect, can be NULL
* @param disconnects function to call on peer disconnect / timeout, can be
NULL
- * @param inbound_notify function to call for all inbound messages, can be NULL
- * @param inbound_hdr_only set to #GNUNET_YES if inbound_notify will only read
the
- * GNUNET_MessageHeader and hence we do not need to give it the
full message;
- * can be used to improve efficiency, ignored if @a
inbound_notify is NULL
- * @param outbound_notify function to call for all outbound messages, can be
NULL
- * @param outbound_hdr_only set to #GNUNET_YES if outbound_notify will only
read the
- * GNUNET_MessageHeader and hence we do not need to give it the
full message
- * can be used to improve efficiency, ignored if @a
outbound_notify is NULL
* @param handlers callbacks for messages we care about, NULL-terminated
* @return handle to the core service (only useful for disconnect until @a
init is called);
* NULL on error (in this case, init is never called)
*/
struct GNUNET_CORE_Handle *
-GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_connecT (const struct GNUNET_CONFIGURATION_Handle *cfg,
void *cls,
GNUNET_CORE_StartupCallback init,
- GNUNET_CORE_ConnectEventHandler connects,
- GNUNET_CORE_DisconnectEventHandler disconnects,
- GNUNET_CORE_MessageCallback inbound_notify,
- int inbound_hdr_only,
- GNUNET_CORE_MessageCallback outbound_notify,
- int outbound_hdr_only,
- const struct GNUNET_CORE_MessageHandler *handlers)
+ GNUNET_CORE_ConnecTEventHandler connects,
+ GNUNET_CORE_DisconnecTEventHandler disconnects,
+ const struct GNUNET_MQ_MessageHandler *handlers)
{
struct GNUNET_CORE_Handle *h;
unsigned int hcnt;
@@ -885,22 +789,18 @@ GNUNET_CORE_connect (const struct
GNUNET_CONFIGURATION_Handle *cfg,
h->init = init;
h->connects = connects;
h->disconnects = disconnects;
- h->inbound_notify = inbound_notify;
- h->outbound_notify = outbound_notify;
- h->inbound_hdr_only = inbound_hdr_only;
- h->outbound_hdr_only = outbound_hdr_only;
- h->currently_down = GNUNET_YES;
- h->peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
+ h->peers = GNUNET_CONTAINER_multipeermap_create (128,
+ GNUNET_NO);
hcnt = 0;
if (NULL != handlers)
- while (NULL != handlers[hcnt].callback)
+ while (NULL != handlers[hcnt].cb)
hcnt++;
h->handlers = GNUNET_new_array (hcnt + 1,
- struct GNUNET_CORE_MessageHandler);
+ struct GNUNET_MQ_MessageHandler);
if (NULL != handlers)
GNUNET_memcpy (h->handlers,
- handlers,
- hcnt * sizeof (struct GNUNET_CORE_MessageHandler));
+ handlers,
+ hcnt * sizeof (struct GNUNET_MQ_MessageHandler));
h->hcnt = hcnt;
GNUNET_assert (hcnt <
(GNUNET_SERVER_MAX_MESSAGE_SIZE -
@@ -910,7 +810,7 @@ GNUNET_CORE_connect (const struct
GNUNET_CONFIGURATION_Handle *cfg,
reconnect (h);
if (NULL == h->mq)
{
- GNUNET_CORE_disconnect (h);
+ GNUNET_CORE_disconnecT (h);
return NULL;
}
return h;
@@ -918,14 +818,12 @@ GNUNET_CORE_connect (const struct
GNUNET_CONFIGURATION_Handle *cfg,
/**
- * Disconnect from the core service. This function can only
- * be called *after* all pending #GNUNET_CORE_notify_transmit_ready()
- * requests have been explicitly canceled.
+ * Disconnect from the core service.
*
* @param handle connection to core to disconnect
*/
void
-GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
+GNUNET_CORE_disconnecT (struct GNUNET_CORE_Handle *handle)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Disconnecting from CORE service\n");
@@ -950,148 +848,23 @@ GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle
*handle)
/**
- * Ask the core to call @a notify once it is ready to transmit the
- * given number of bytes to the specified @a target. Must only be
- * called after a connection to the respective peer has been
- * established (and the client has been informed about this). You may
- * have one request of this type pending for each connected peer at
- * any time. If a peer disconnects, the application MUST call
- * #GNUNET_CORE_notify_transmit_ready_cancel on the respective
- * transmission request, if one such request is pending.
+ * Obtain the message queue for a connected peer.
*
- * @param handle connection to core service
- * @param cork is corking allowed for this transmission?
- * @param priority how important is the message?
- * @param maxdelay how long can the message wait? Only effective if @a cork is
#GNUNET_YES
- * @param target who should receive the message, never NULL (can be this
peer's identity for loopback)
- * @param notify_size how many bytes of buffer space does @a notify want?
- * @param notify function to call when buffer space is available;
- * will be called with NULL on timeout; clients MUST cancel
- * all pending transmission requests DURING the disconnect
- * handler
- * @param notify_cls closure for @a notify
- * @return non-NULL if the notify callback was queued,
- * NULL if we can not even queue the request (request already pending);
- * if NULL is returned, @a notify will NOT be called.
+ * @param h the core handle
+ * @param pid the identity of the peer to check if it has been connected to us
+ * @return NULL if peer is not connected
*/
-struct GNUNET_CORE_TransmitHandle *
-GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
- int cork,
- enum GNUNET_CORE_Priority priority,
- struct GNUNET_TIME_Relative maxdelay,
- const struct GNUNET_PeerIdentity *target,
- size_t notify_size,
- GNUNET_CONNECTION_TransmitReadyNotify
notify,
- void *notify_cls)
+struct GNUNET_MQ_Handle *
+GNUNET_CORE_get_mq (const struct GNUNET_CORE_Handle *h,
+ const struct GNUNET_PeerIdentity *pid)
{
struct PeerRecord *pr;
- struct GNUNET_CORE_TransmitHandle *th;
- struct SendMessageRequest *smr;
- struct GNUNET_MQ_Envelope *env;
- if (NULL == handle->mq)
- {
- GNUNET_break (0); /* SEE #4588: do not call NTR from disconnect
notification! */
- return NULL;
- }
- GNUNET_assert (NULL != notify);
- if ( (notify_size > GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE) ||
- (notify_size + sizeof (struct SendMessage) >=
GNUNET_SERVER_MAX_MESSAGE_SIZE) )
- {
- GNUNET_break (0);
- return NULL;
- }
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Asking core for transmission of %u bytes to `%s'%s\n",
- (unsigned int) notify_size,
- GNUNET_i2s (target),
- cork ? " (corked)" : "");
- pr = GNUNET_CONTAINER_multipeermap_get (handle->peers,
- target);
+ pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
+ pid);
if (NULL == pr)
- {
- /* attempt to send to peer that is not connected */
- GNUNET_break (0);
return NULL;
- }
- if (NULL != pr->th.peer)
- {
- /* attempting to queue a second request for the same destination */
- GNUNET_break (0);
- return NULL;
- }
- th = &pr->th;
- memset (th,
- 0,
- sizeof (struct GNUNET_CORE_TransmitHandle));
- th->peer = pr;
- th->get_message = notify;
- th->get_message_cls = notify_cls;
- th->request_time = GNUNET_TIME_absolute_get ();
- if (GNUNET_YES == cork)
- th->deadline = GNUNET_TIME_relative_to_absolute (maxdelay);
- else
- th->deadline = th->request_time;
- th->priority = priority;
- th->msize = notify_size;
- th->cork = cork;
- if (NULL == handle->mq)
- return th; /* see #4588 (hack until we transition core fully to MQ) */
- env = GNUNET_MQ_msg (smr,
- GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST);
- smr->priority = htonl ((uint32_t) th->priority);
- smr->deadline = GNUNET_TIME_absolute_hton (th->deadline);
- smr->peer = pr->peer;
- smr->reserved = htonl (0);
- smr->size = htons (th->msize);
- smr->smr_id = htons (th->smr_id = pr->smr_id_gen++);
- GNUNET_MQ_send (handle->mq,
- env);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Transmission request added to queue\n");
- return th;
-}
-
-
-/**
- * Cancel the specified transmission-ready notification.
- *
- * @param th handle that was returned by #GNUNET_CORE_notify_transmit_ready().
- */
-void
-GNUNET_CORE_notify_transmit_ready_cancel (struct GNUNET_CORE_TransmitHandle
*th)
-{
- struct PeerRecord *pr = th->peer;
-
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Aborting transmission request to core for %u bytes to `%s'\n",
- (unsigned int) th->msize,
- GNUNET_i2s (&pr->peer));
- th->peer = NULL;
-}
-
-
-/**
- * Check if the given peer is currently connected. This function is for special
- * cirumstances (GNUNET_TESTBED uses it), normal users of the CORE API are
- * expected to track which peers are connected based on the connect/disconnect
- * callbacks from #GNUNET_CORE_connect(). This function is NOT part of the
- * 'versioned', 'official' API. The difference between this function and the
- * function GNUNET_CORE_is_peer_connected() is that this one returns
- * synchronously after looking in the CORE API cache. The function
- * GNUNET_CORE_is_peer_connected() sends a message to the CORE service and
hence
- * its response is given asynchronously.
- *
- * @param h the core handle
- * @param pid the identity of the peer to check if it has been connected to us
- * @return #GNUNET_YES if the peer is connected to us; #GNUNET_NO if not
- */
-int
-GNUNET_CORE_is_peer_connected_sync (const struct GNUNET_CORE_Handle *h,
- const struct GNUNET_PeerIdentity *pid)
-{
- return GNUNET_CONTAINER_multipeermap_contains (h->peers,
- pid);
+ return pr->mq;
}
diff --git a/src/core/core_api_2.c b/src/core/core_api_2.c
deleted file mode 100644
index d810bf2ec..000000000
--- a/src/core/core_api_2.c
+++ /dev/null
@@ -1,865 +0,0 @@
-/*
- This file is part of GNUnet.
- Copyright (C) 2009-2016 GNUnet e.V.
-
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
-
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
-*/
-/**
- * @file core/core_api_2.c
- * @brief core service; this is the main API for encrypted P2P
- * communications
- * @author Christian Grothoff
- */
-#include "platform.h"
-#include "gnunet_util_lib.h"
-#include "gnunet_constants.h"
-#include "gnunet_core_service.h"
-#include "core.h"
-
-#define LOG(kind,...) GNUNET_log_from (kind, "core-api",__VA_ARGS__)
-
-
-/**
- * Information we track for each peer.
- */
-struct PeerRecord
-{
-
- /**
- * Corresponding CORE handle.
- */
- struct GNUNET_CORE_Handle *h;
-
- /**
- * Message queue for the peer.
- */
- struct GNUNET_MQ_Handle *mq;
-
- /**
- * Message we are currently trying to pass to the CORE service
- * for this peer (from @e mq).
- */
- struct GNUNET_MQ_Envelope *env;
-
- /**
- * Value the client returned when we connected, used
- * as the closure in various places.
- */
- void *client_cls;
-
- /**
- * Peer the record is about.
- */
- struct GNUNET_PeerIdentity peer;
-
- /**
- * SendMessageRequest ID generator for this peer.
- */
- uint16_t smr_id_gen;
-
-};
-
-
-/**
- * Context for the core service connection.
- */
-struct GNUNET_CORE_Handle
-{
-
- /**
- * Configuration we're using.
- */
- const struct GNUNET_CONFIGURATION_Handle *cfg;
-
- /**
- * Closure for the various callbacks.
- */
- void *cls;
-
- /**
- * Function to call once we've handshaked with the core service.
- */
- GNUNET_CORE_StartupCallback init;
-
- /**
- * Function to call whenever we're notified about a peer connecting.
- */
- GNUNET_CORE_ConnecTEventHandler connects;
-
- /**
- * Function to call whenever we're notified about a peer disconnecting.
- */
- GNUNET_CORE_DisconnecTEventHandler disconnects;
-
- /**
- * Function handlers for messages of particular type.
- */
- struct GNUNET_MQ_MessageHandler *handlers;
-
- /**
- * Our message queue for transmissions to the service.
- */
- struct GNUNET_MQ_Handle *mq;
-
- /**
- * Hash map listing all of the peers that we are currently
- * connected to.
- */
- struct GNUNET_CONTAINER_MultiPeerMap *peers;
-
- /**
- * Identity of this peer.
- */
- struct GNUNET_PeerIdentity me;
-
- /**
- * ID of reconnect task (if any).
- */
- struct GNUNET_SCHEDULER_Task *reconnect_task;
-
- /**
- * Current delay we use for re-trying to connect to core.
- */
- struct GNUNET_TIME_Relative retry_backoff;
-
- /**
- * Number of entries in the handlers array.
- */
- unsigned int hcnt;
-
- /**
- * Did we ever get INIT?
- */
- int have_init;
-
-};
-
-
-/**
- * Our current client connection went down. Clean it up
- * and try to reconnect!
- *
- * @param h our handle to the core service
- */
-static void
-reconnect (struct GNUNET_CORE_Handle *h);
-
-
-/**
- * Task schedule to try to re-connect to core.
- *
- * @param cls the `struct GNUNET_CORE_Handle`
- * @param tc task context
- */
-static void
-reconnect_task (void *cls)
-{
- struct GNUNET_CORE_Handle *h = cls;
-
- h->reconnect_task = NULL;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Connecting to CORE service after delay\n");
- reconnect (h);
-}
-
-
-/**
- * Notify clients about disconnect and free the entry for connected
- * peer.
- *
- * @param cls the `struct GNUNET_CORE_Handle *`
- * @param key the peer identity (not used)
- * @param value the `struct PeerRecord` to free.
- * @return #GNUNET_YES (continue)
- */
-static int
-disconnect_and_free_peer_entry (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
-{
- struct GNUNET_CORE_Handle *h = cls;
- struct PeerRecord *pr = value;
-
- GNUNET_assert (pr->h == h);
- if (NULL != h->disconnects)
- h->disconnects (h->cls,
- &pr->peer,
- pr->client_cls);
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (h->peers,
- key,
- pr));
- GNUNET_MQ_destroy (pr->mq);
- GNUNET_assert (NULL == pr->mq);
- GNUNET_free (pr);
- return GNUNET_YES;
-}
-
-
-/**
- * Close down any existing connection to the CORE service and
- * try re-establishing it later.
- *
- * @param h our handle
- */
-static void
-reconnect_later (struct GNUNET_CORE_Handle *h)
-{
- GNUNET_assert (NULL == h->reconnect_task);
- if (NULL != h->mq)
- {
- GNUNET_MQ_destroy (h->mq);
- h->mq = NULL;
- }
- GNUNET_assert (NULL == h->reconnect_task);
- h->reconnect_task =
- GNUNET_SCHEDULER_add_delayed (h->retry_backoff,
- &reconnect_task,
- h);
- GNUNET_CONTAINER_multipeermap_iterate (h->peers,
- &disconnect_and_free_peer_entry,
- h);
- h->retry_backoff = GNUNET_TIME_STD_BACKOFF (h->retry_backoff);
-}
-
-
-/**
- * Error handler for the message queue to the CORE service.
- * On errors, we reconnect.
- *
- * @param cls closure, a `struct GNUNET_CORE_Handle *`
- * @param error error code
- */
-static void
-handle_mq_error (void *cls,
- enum GNUNET_MQ_Error error)
-{
- struct GNUNET_CORE_Handle *h = cls;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "MQ ERROR: %d\n",
- error);
- reconnect_later (h);
-}
-
-
-/**
- * Inquire with CORE what options should be set for a message
- * so that it is transmitted with the given @a priority and
- * the given @a cork value.
- *
- * @param cork desired corking
- * @param priority desired message priority
- * @param[out] flags set to `flags` value for #GNUNET_MQ_set_options()
- * @return `extra` argument to give to #GNUNET_MQ_set_options()
- */
-const void *
-GNUNET_CORE_get_mq_options (int cork,
- enum GNUNET_CORE_Priority priority,
- uint64_t *flags)
-{
- *flags = ((uint64_t) priority) + (((uint64_t) cork) << 32);
- return NULL;
-}
-
-
-/**
- * Implement sending functionality of a message queue for
- * us sending messages to a peer.
- *
- * @param mq the message queue
- * @param msg the message to send
- * @param impl_state state of the implementation
- */
-static void
-core_mq_send_impl (struct GNUNET_MQ_Handle *mq,
- const struct GNUNET_MessageHeader *msg,
- void *impl_state)
-{
- struct PeerRecord *pr = impl_state;
- struct GNUNET_CORE_Handle *h = pr->h;
- struct SendMessageRequest *smr;
- struct SendMessage *sm;
- struct GNUNET_MQ_Envelope *env;
- uint16_t msize;
- uint64_t flags;
- int cork;
- enum GNUNET_CORE_Priority priority;
-
- GNUNET_assert (NULL == pr->env);
- /* extract options from envelope */
- env = GNUNET_MQ_get_current_envelope (mq);
- GNUNET_break (NULL ==
- GNUNET_MQ_env_get_options (env,
- &flags));
- cork = (int) (flags >> 32);
- priority = (uint32_t) flags;
-
- /* check message size for sanity */
- msize = ntohs (msg->size);
- if (msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct SendMessage))
- {
- GNUNET_break (0);
- GNUNET_MQ_impl_send_continue (mq);
- return;
- }
-
- /* ask core for transmission */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Asking core for transmission of %u bytes to `%s'\n",
- (unsigned int) msize,
- GNUNET_i2s (&pr->peer));
- env = GNUNET_MQ_msg (smr,
- GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST);
- smr->priority = htonl ((uint32_t) priority);
- // smr->deadline = GNUNET_TIME_absolute_hton (deadline);
- smr->peer = pr->peer;
- smr->reserved = htonl (0);
- smr->size = htons (msize);
- smr->smr_id = htons (++pr->smr_id_gen);
- GNUNET_MQ_send (h->mq,
- env);
-
- /* prepare message with actual transmission data */
- pr->env = GNUNET_MQ_msg_nested_mh (sm,
- GNUNET_MESSAGE_TYPE_CORE_SEND,
- msg);
- sm->priority = htonl ((uint32_t) priority);
- // sm->deadline = GNUNET_TIME_absolute_hton (deadline);
- sm->peer = pr->peer;
- sm->cork = htonl ((uint32_t) cork);
- sm->reserved = htonl (0);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Calling get_message with buffer of %u bytes (%s)\n",
- (unsigned int) msize,
- cork ? "corked" : "uncorked");
-}
-
-
-/**
- * Handle destruction of a message queue. Implementations must not
- * free @a mq, but should take care of @a impl_state.
- *
- * @param mq the message queue to destroy
- * @param impl_state state of the implementation
- */
-static void
-core_mq_destroy_impl (struct GNUNET_MQ_Handle *mq,
- void *impl_state)
-{
- struct PeerRecord *pr = impl_state;
-
- GNUNET_assert (mq == pr->mq);
- pr->mq = NULL;
-}
-
-
-/**
- * Implementation function that cancels the currently sent message.
- * Should basically undo whatever #mq_send_impl() did.
- *
- * @param mq message queue
- * @param impl_state state specific to the implementation
- */
-static void
-core_mq_cancel_impl (struct GNUNET_MQ_Handle *mq,
- void *impl_state)
-{
- struct PeerRecord *pr = impl_state;
-
- GNUNET_assert (NULL != pr->env);
- GNUNET_MQ_discard (pr->env);
- pr->env = NULL;
-}
-
-
-/**
- * We had an error processing a message we forwarded from a peer to
- * the CORE service. We should just complain about it but otherwise
- * continue processing.
- *
- * @param cls closure
- * @param error error code
- */
-static void
-core_mq_error_handler (void *cls,
- enum GNUNET_MQ_Error error)
-{
- /* struct PeerRecord *pr = cls; */
-
- GNUNET_break_op (0);
-}
-
-
-/**
- * Add the given peer to the list of our connected peers
- * and create the respective data structures and notify
- * the application.
- *
- * @param h the core handle
- * @param peer the peer that is connecting to us
- */
-static void
-connect_peer (struct GNUNET_CORE_Handle *h,
- const struct GNUNET_PeerIdentity *peer)
-{
- struct PeerRecord *pr;
- uint64_t flags;
- const void *extra;
-
- pr = GNUNET_new (struct PeerRecord);
- pr->peer = *peer;
- pr->h = h;
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_put (h->peers,
- &pr->peer,
- pr,
-
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
- pr->mq = GNUNET_MQ_queue_for_callbacks (&core_mq_send_impl,
- &core_mq_destroy_impl,
- &core_mq_cancel_impl,
- pr,
- h->handlers,
- &core_mq_error_handler,
- pr);
- /* get our default options */
- extra = GNUNET_CORE_get_mq_options (GNUNET_NO,
- GNUNET_CORE_PRIO_BEST_EFFORT,
- &flags);
- GNUNET_MQ_set_options (pr->mq,
- flags,
- extra);
- if (NULL != h->connects)
- {
- pr->client_cls = h->connects (h->cls,
- &pr->peer,
- pr->mq);
- GNUNET_MQ_set_handlers_closure (pr->mq,
- pr->client_cls);
- }
-}
-
-
-/**
- * Handle init reply message received from CORE service. Notify
- * application that we are now connected to the CORE. Also fake
- * loopback connection.
- *
- * @param cls the `struct GNUNET_CORE_Handle`
- * @param m the init reply
- */
-static void
-handle_init_reply (void *cls,
- const struct InitReplyMessage *m)
-{
- struct GNUNET_CORE_Handle *h = cls;
- GNUNET_CORE_StartupCallback init;
-
- GNUNET_break (0 == ntohl (m->reserved));
- h->retry_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
- if (NULL != (init = h->init))
- {
- /* mark so we don't call init on reconnect */
- h->init = NULL;
- h->me = m->my_identity;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Connected to core service of peer `%s'.\n",
- GNUNET_i2s (&h->me));
- h->have_init = GNUNET_YES;
- init (h->cls,
- &h->me);
- }
- else
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Successfully reconnected to core service.\n");
- if (GNUNET_NO == h->have_init)
- {
- h->me = m->my_identity;
- h->have_init = GNUNET_YES;
- }
- else
- {
- GNUNET_break (0 == memcmp (&h->me,
- &m->my_identity,
- sizeof (struct GNUNET_PeerIdentity)));
- }
- }
- /* fake 'connect to self' */
- connect_peer (h,
- &h->me);
-}
-
-
-/**
- * Handle connect message received from CORE service.
- * Notify the application about the new connection.
- *
- * @param cls the `struct GNUNET_CORE_Handle`
- * @param cnm the connect message
- */
-static void
-handle_connect_notify (void *cls,
- const struct ConnectNotifyMessage *cnm)
-{
- struct GNUNET_CORE_Handle *h = cls;
- struct PeerRecord *pr;
-
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received notification about connection from `%s'.\n",
- GNUNET_i2s (&cnm->peer));
- if (0 == memcmp (&h->me,
- &cnm->peer,
- sizeof (struct GNUNET_PeerIdentity)))
- {
- /* connect to self!? */
- GNUNET_break (0);
- return;
- }
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- &cnm->peer);
- if (NULL != pr)
- {
- GNUNET_break (0);
- reconnect_later (h);
- return;
- }
- connect_peer (h,
- &cnm->peer);
-}
-
-
-/**
- * Handle disconnect message received from CORE service.
- * Notify the application about the lost connection.
- *
- * @param cls the `struct GNUNET_CORE_Handle`
- * @param dnm message about the disconnect event
- */
-static void
-handle_disconnect_notify (void *cls,
- const struct DisconnectNotifyMessage *dnm)
-{
- struct GNUNET_CORE_Handle *h = cls;
- struct PeerRecord *pr;
-
- if (0 == memcmp (&h->me,
- &dnm->peer,
- sizeof (struct GNUNET_PeerIdentity)))
- {
- /* disconnect from self!? */
- GNUNET_break (0);
- return;
- }
- GNUNET_break (0 == ntohl (dnm->reserved));
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received notification about disconnect from `%s'.\n",
- GNUNET_i2s (&dnm->peer));
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- &dnm->peer);
- if (NULL == pr)
- {
- GNUNET_break (0);
- reconnect_later (h);
- return;
- }
- disconnect_and_free_peer_entry (h,
- &pr->peer,
- pr);
-}
-
-
-/**
- * Check that message received from CORE service is well-formed.
- *
- * @param cls the `struct GNUNET_CORE_Handle`
- * @param ntm the message we got
- * @return #GNUNET_OK if the message is well-formed
- */
-static int
-check_notify_inbound (void *cls,
- const struct NotifyTrafficMessage *ntm)
-{
- uint16_t msize;
- const struct GNUNET_MessageHeader *em;
-
- msize = ntohs (ntm->header.size) - sizeof (struct NotifyTrafficMessage);
- if (msize < sizeof (struct GNUNET_MessageHeader))
- {
- GNUNET_break (0);
- return GNUNET_SYSERR;
- }
- em = (const struct GNUNET_MessageHeader *) &ntm[1];
- if (msize != ntohs (em->size))
- {
- GNUNET_break (0);
- return GNUNET_SYSERR;
- }
- return GNUNET_OK;
-}
-
-
-/**
- * Handle inbound message received from CORE service. If applicable,
- * notify the application.
- *
- * @param cls the `struct GNUNET_CORE_Handle`
- * @param ntm the message we got from CORE.
- */
-static void
-handle_notify_inbound (void *cls,
- const struct NotifyTrafficMessage *ntm)
-{
- struct GNUNET_CORE_Handle *h = cls;
- const struct GNUNET_MessageHeader *em;
- struct PeerRecord *pr;
-
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received inbound message from `%s'.\n",
- GNUNET_i2s (&ntm->peer));
- em = (const struct GNUNET_MessageHeader *) &ntm[1];
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- &ntm->peer);
- if (NULL == pr)
- {
- GNUNET_break (0);
- reconnect_later (h);
- return;
- }
- GNUNET_MQ_inject_message (pr->mq,
- em);
-}
-
-
-/**
- * Handle message received from CORE service notifying us that we are
- * now allowed to send a message to a peer. If that message is still
- * pending, put it into the queue to be transmitted.
- *
- * @param cls the `struct GNUNET_CORE_Handle`
- * @param smr the message we got
- */
-static void
-handle_send_ready (void *cls,
- const struct SendMessageReady *smr)
-{
- struct GNUNET_CORE_Handle *h = cls;
- struct PeerRecord *pr;
-
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- &smr->peer);
- if (NULL == pr)
- {
- GNUNET_break (0);
- reconnect_later (h);
- return;
- }
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received notification about transmission readiness to `%s'.\n",
- GNUNET_i2s (&smr->peer));
- if (NULL == pr->env)
- {
- /* request must have been cancelled between the original request
- * and the response from CORE, ignore CORE's readiness */
- return;
- }
- if (ntohs (smr->smr_id) != pr->smr_id_gen)
- {
- /* READY message is for expired or cancelled message,
- * ignore! (we should have already sent another request) */
- return;
- }
-
- /* ok, all good, send message out! */
- GNUNET_MQ_send (h->mq,
- pr->env);
- pr->env = NULL;
- GNUNET_MQ_impl_send_continue (pr->mq);
-}
-
-
-/**
- * Our current client connection went down. Clean it up and try to
- * reconnect!
- *
- * @param h our handle to the core service
- */
-static void
-reconnect (struct GNUNET_CORE_Handle *h)
-{
- struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_fixed_size (init_reply,
- GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY,
- struct InitReplyMessage,
- h),
- GNUNET_MQ_hd_fixed_size (connect_notify,
- GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT,
- struct ConnectNotifyMessage,
- h),
- GNUNET_MQ_hd_fixed_size (disconnect_notify,
- GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT,
- struct DisconnectNotifyMessage,
- h),
- GNUNET_MQ_hd_var_size (notify_inbound,
- GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND,
- struct NotifyTrafficMessage,
- h),
- GNUNET_MQ_hd_fixed_size (send_ready,
- GNUNET_MESSAGE_TYPE_CORE_SEND_READY,
- struct SendMessageReady,
- h),
- GNUNET_MQ_handler_end ()
- };
- struct InitMessage *init;
- struct GNUNET_MQ_Envelope *env;
- uint16_t *ts;
-
- GNUNET_assert (NULL == h->mq);
- h->mq = GNUNET_CLIENT_connecT (h->cfg,
- "core",
- handlers,
- &handle_mq_error,
- h);
- if (NULL == h->mq)
- {
- reconnect_later (h);
- return;
- }
- env = GNUNET_MQ_msg_extra (init,
- sizeof (uint16_t) * h->hcnt,
- GNUNET_MESSAGE_TYPE_CORE_INIT);
- LOG (GNUNET_ERROR_TYPE_INFO,
- "(Re)connecting to CORE service\n");
- init->options = htonl (0);
- ts = (uint16_t *) &init[1];
- for (unsigned int hpos = 0; hpos < h->hcnt; hpos++)
- ts[hpos] = htons (h->handlers[hpos].type);
- GNUNET_MQ_send (h->mq,
- env);
-}
-
-
-/**
- * Connect to the core service. Note that the connection may complete
- * (or fail) asynchronously.
- *
- * @param cfg configuration to use
- * @param cls closure for the various callbacks that follow (including
handlers in the handlers array)
- * @param init callback to call once we have successfully
- * connected to the core service
- * @param connects function to call on peer connect, can be NULL
- * @param disconnects function to call on peer disconnect / timeout, can be
NULL
- * @param handlers callbacks for messages we care about, NULL-terminated
- * @return handle to the core service (only useful for disconnect until @a
init is called);
- * NULL on error (in this case, init is never called)
- */
-struct GNUNET_CORE_Handle *
-GNUNET_CORE_connecT (const struct GNUNET_CONFIGURATION_Handle *cfg,
- void *cls,
- GNUNET_CORE_StartupCallback init,
- GNUNET_CORE_ConnecTEventHandler connects,
- GNUNET_CORE_DisconnecTEventHandler disconnects,
- const struct GNUNET_MQ_MessageHandler *handlers)
-{
- struct GNUNET_CORE_Handle *h;
- unsigned int hcnt;
-
- h = GNUNET_new (struct GNUNET_CORE_Handle);
- h->cfg = cfg;
- h->cls = cls;
- h->init = init;
- h->connects = connects;
- h->disconnects = disconnects;
- h->peers = GNUNET_CONTAINER_multipeermap_create (128,
- GNUNET_NO);
- hcnt = 0;
- if (NULL != handlers)
- while (NULL != handlers[hcnt].cb)
- hcnt++;
- h->handlers = GNUNET_new_array (hcnt + 1,
- struct GNUNET_MQ_MessageHandler);
- if (NULL != handlers)
- GNUNET_memcpy (h->handlers,
- handlers,
- hcnt * sizeof (struct GNUNET_MQ_MessageHandler));
- h->hcnt = hcnt;
- GNUNET_assert (hcnt <
- (GNUNET_SERVER_MAX_MESSAGE_SIZE -
- sizeof (struct InitMessage)) / sizeof (uint16_t));
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Connecting to CORE service\n");
- reconnect (h);
- if (NULL == h->mq)
- {
- GNUNET_CORE_disconnect (h);
- return NULL;
- }
- return h;
-}
-
-
-/**
- * Disconnect from the core service.
- *
- * @param handle connection to core to disconnect
- */
-void
-GNUNET_CORE_disconnecT (struct GNUNET_CORE_Handle *handle)
-{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Disconnecting from CORE service\n");
- GNUNET_CONTAINER_multipeermap_iterate (handle->peers,
- &disconnect_and_free_peer_entry,
- handle);
- GNUNET_CONTAINER_multipeermap_destroy (handle->peers);
- handle->peers = NULL;
- if (NULL != handle->reconnect_task)
- {
- GNUNET_SCHEDULER_cancel (handle->reconnect_task);
- handle->reconnect_task = NULL;
- }
- if (NULL != handle->mq)
- {
- GNUNET_MQ_destroy (handle->mq);
- handle->mq = NULL;
- }
- GNUNET_free (handle->handlers);
- GNUNET_free (handle);
-}
-
-
-/**
- * Obtain the message queue for a connected peer.
- *
- * @param h the core handle
- * @param pid the identity of the peer to check if it has been connected to us
- * @return NULL if peer is not connected
- */
-struct GNUNET_MQ_Handle *
-GNUNET_CORE_get_mq (const struct GNUNET_CORE_Handle *h,
- const struct GNUNET_PeerIdentity *pid)
-{
- struct PeerRecord *pr;
-
- pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
- pid);
- if (NULL == pr)
- return NULL;
- return pr->mq;
-}
-
-
-/* end of core_api.c */
diff --git a/src/core/core_api_mq.c b/src/core/core_api_mq.c
deleted file mode 100644
index 12c7a3bdd..000000000
--- a/src/core/core_api_mq.c
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- This file is part of GNUnet.
- Copyright (C) 2009-2014 GNUnet e.V.
-
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
-
- GNUnet is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
-*/
-/**
- * @file core/core_api_mq.c
- * @brief MQ support for core service
- * @author Christian Grothoff
- * @author Florian Dold
- */
-#include "platform.h"
-#include "gnunet_util_lib.h"
-#include "gnunet_constants.h"
-#include "gnunet_core_service.h"
-#include "core.h"
-
-#define LOG(kind,...) GNUNET_log_from (kind, "core-api",__VA_ARGS__)
-
-
-/**
- * Internal state of a GNUNET-MQ queue for CORE.
- */
-struct CoreMQState
-{
- /**
- * Which peer does this queue target?
- */
- struct GNUNET_PeerIdentity target;
-
- /**
- * Handle to the CORE service used by this MQ.
- */
- struct GNUNET_CORE_Handle *core;
-
- /**
- * Transmission handle (if in use).
- */
- struct GNUNET_CORE_TransmitHandle *th;
-};
-
-
-/**
- * Function called to notify a client about the connection
- * begin ready to queue more data. @a buf will be
- * NULL and @a size zero if the connection was closed for
- * writing in the meantime.
- *
- * @param cls closure
- * @param size number of bytes available in @a buf
- * @param buf where the callee should write the message
- * @return number of bytes written to @a buf
- */
-static size_t
-core_mq_ntr (void *cls, size_t size,
- void *buf)
-{
- struct GNUNET_MQ_Handle *mq = cls;
- struct CoreMQState *mqs = GNUNET_MQ_impl_state (mq);
- const struct GNUNET_MessageHeader *mh = GNUNET_MQ_impl_current (mq);
- size_t msg_size = ntohs (mh->size);
-
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "ntr called (size %u, type %u)\n",
- msg_size,
- ntohs (mh->type));
- mqs->th = NULL;
- if (NULL == buf)
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "send error\n");
- GNUNET_MQ_inject_error (mq, GNUNET_MQ_ERROR_WRITE);
- return 0;
- }
- GNUNET_memcpy (buf, mh, msg_size);
- GNUNET_MQ_impl_send_continue (mq);
- return msg_size;
-}
-
-
-/**
- * Signature of functions implementing the
- * sending functionality of a message queue.
- *
- * @param mq the message queue
- * @param msg the message to send
- * @param impl_state state of the implementation
- */
-static void
-core_mq_send (struct GNUNET_MQ_Handle *mq,
- const struct GNUNET_MessageHeader *msg,
- void *impl_state)
-{
- struct CoreMQState *mqs = impl_state;
-
- GNUNET_assert (NULL == mqs->th);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Sending queued message (size %u)\n",
- ntohs (msg->size));
- mqs->th = GNUNET_CORE_notify_transmit_ready (mqs->core, GNUNET_YES, 0,
- GNUNET_TIME_UNIT_FOREVER_REL,
- &mqs->target,
- ntohs (msg->size),
- &core_mq_ntr, mq);
-}
-
-
-/**
- * Signature of functions implementing the
- * destruction of a message queue.
- * Implementations must not free @a mq, but should
- * take care of @a impl_state.
- *
- * @param mq the message queue to destroy
- * @param impl_state state of the implementation
- */
-static void
-core_mq_destroy (struct GNUNET_MQ_Handle *mq,
- void *impl_state)
-{
- struct CoreMQState *mqs = impl_state;
-
- if (NULL != mqs->th)
- {
- GNUNET_CORE_notify_transmit_ready_cancel (mqs->th);
- mqs->th = NULL;
- }
- GNUNET_free (mqs);
-}
-
-
-/**
- * Implementation function that cancels the currently sent message.
- *
- * @param mq message queue
- * @param impl_state state specific to the implementation
- */
-static void
-core_mq_cancel (struct GNUNET_MQ_Handle *mq,
- void *impl_state)
-{
- struct CoreMQState *mqs = impl_state;
-
- GNUNET_assert (NULL != mqs->th);
- GNUNET_CORE_notify_transmit_ready_cancel (mqs->th);
-}
-
-
-/**
- * Create a message queue for sending messages to a peer with CORE.
- * Messages may only be queued with #GNUNET_MQ_send once the init callback has
- * been called for the given handle.
- * There must only be one queue per peer for each core handle.
- * The message queue can only be used to transmit messages,
- * not to receive them.
- *
- * @param h the core handle
- * @param target the target peer for this queue, may not be NULL
- * @return a message queue for sending messages over the core handle
- * to the target peer
- */
-struct GNUNET_MQ_Handle *
-GNUNET_CORE_mq_create (struct GNUNET_CORE_Handle *h,
- const struct GNUNET_PeerIdentity *target)
-{
- struct CoreMQState *mqs = GNUNET_new (struct CoreMQState);
-
- mqs->core = h;
- mqs->target = *target;
- return GNUNET_MQ_queue_for_callbacks (&core_mq_send,
- &core_mq_destroy,
- &core_mq_cancel,
- mqs,
- NULL, NULL, NULL);
-}
-
-/* end of core_api_mq.c */
diff --git a/src/core/test_core_defaults.conf b/src/core/test_core_defaults.conf
index eb9a1c379..4c956987c 100644
--- a/src/core/test_core_defaults.conf
+++ b/src/core/test_core_defaults.conf
@@ -5,13 +5,7 @@
GNUNET_TEST_HOME = /tmp/test-gnunet-core/
[nat]
-DISABLEV6 = YES
ENABLE_UPNP = NO
-BEHIND_NAT = NO
-ALLOW_NAT = NO
-INTERNAL_ADDRESS = 127.0.0.1
-EXTERNAL_ADDRESS = 127.0.0.1
-USE_LOCALADDR = NO
[ats]
WAN_QUOTA_IN = 1 GB
diff --git a/src/dht/gnunet-service-dht_neighbours.c
b/src/dht/gnunet-service-dht_neighbours.c
index 574ed9ad0..0d3594d1a 100644
--- a/src/dht/gnunet-service-dht_neighbours.c
+++ b/src/dht/gnunet-service-dht_neighbours.c
@@ -1830,10 +1830,16 @@ handle_find_peer (const struct GNUNET_PeerIdentity
*sender,
/* first, check about our own HELLO */
if (NULL != GDS_my_hello)
{
- GNUNET_BLOCK_mingle_hash (&my_identity_hash, bf_mutator, &mhash);
+ GNUNET_BLOCK_mingle_hash (&my_identity_hash,
+ bf_mutator,
+ &mhash);
if ((NULL == bf) ||
(GNUNET_YES != GNUNET_CONTAINER_bloomfilter_test (bf, &mhash)))
{
+ size_t hello_size;
+
+ hello_size = GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
GDS_my_hello);
+ GNUNET_break (hello_size >= sizeof (struct GNUNET_MessageHeader));
GDS_NEIGHBOURS_handle_reply (sender,
GNUNET_BLOCK_TYPE_DHT_HELLO,
GNUNET_TIME_relative_to_absolute
@@ -1844,9 +1850,7 @@ handle_find_peer (const struct GNUNET_PeerIdentity
*sender,
0,
NULL,
GDS_my_hello,
- GNUNET_HELLO_size ((const struct
- GNUNET_HELLO_Message *)
- GDS_my_hello));
+ hello_size);
}
else
{
diff --git a/src/dht/gnunet-service-dht_routing.c
b/src/dht/gnunet-service-dht_routing.c
index 48bece35e..38e5fc1c7 100644
--- a/src/dht/gnunet-service-dht_routing.c
+++ b/src/dht/gnunet-service-dht_routing.c
@@ -183,15 +183,17 @@ process (void *cls, const struct GNUNET_HashCode * key,
void *value)
gpl = 0;
ppl = 0;
}
- if ((0 != (rr->options & GNUNET_DHT_RO_FIND_PEER)) &&
- (pc->type == GNUNET_BLOCK_TYPE_DHT_HELLO))
+ if ( (0 != (rr->options & GNUNET_DHT_RO_FIND_PEER)) &&
+ (pc->type == GNUNET_BLOCK_TYPE_DHT_HELLO) )
{
/* key may not match HELLO, which is OK since
* the search is approximate. Still, the evaluation
* would fail since the match is not exact. So
* we fake it by changing the key to the actual PID ... */
- GNUNET_BLOCK_get_key (GDS_block_context, GNUNET_BLOCK_TYPE_DHT_HELLO,
- pc->data, pc->data_size, &hc);
+ GNUNET_BLOCK_get_key (GDS_block_context,
+ GNUNET_BLOCK_TYPE_DHT_HELLO,
+ pc->data, pc->data_size,
+ &hc);
eval_key = &hc;
}
else
diff --git a/src/dht/plugin_block_dht.c b/src/dht/plugin_block_dht.c
index 17594efcb..4256a0fe6 100644
--- a/src/dht/plugin_block_dht.c
+++ b/src/dht/plugin_block_dht.c
@@ -70,7 +70,7 @@ block_plugin_dht_evaluate (void *cls,
if (type != GNUNET_BLOCK_TYPE_DHT_HELLO)
return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
- if (xquery_size != 0)
+ if (0 != xquery_size)
{
GNUNET_break_op (0);
return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
@@ -121,14 +121,16 @@ block_plugin_dht_evaluate (void *cls,
* @param type block type
* @param block block to get the key for
* @param block_size number of bytes @a block
- * @param key set to the key (query) for the given block
+ * @param[out] key set to the key (query) for the given block
* @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported
* (or if extracting a key from a block of this type does not work)
*/
static int
-block_plugin_dht_get_key (void *cls, enum GNUNET_BLOCK_Type type,
- const void *block, size_t block_size,
- struct GNUNET_HashCode * key)
+block_plugin_dht_get_key (void *cls,
+ enum GNUNET_BLOCK_Type type,
+ const void *block,
+ size_t block_size,
+ struct GNUNET_HashCode *key)
{
const struct GNUNET_MessageHeader *msg;
const struct GNUNET_HELLO_Message *hello;
diff --git a/src/gnsrecord/.gitignore b/src/gnsrecord/.gitignore
index 7b5ba6449..374abdb60 100644
--- a/src/gnsrecord/.gitignore
+++ b/src/gnsrecord/.gitignore
@@ -1,3 +1,4 @@
test_gnsrecord_block_expiration
test_gnsrecord_crypto
test_gnsrecord_serialization
+zonefiles
diff --git a/src/namecache/.gitignore b/src/namecache/.gitignore
index cd4286ff2..6d2d8488a 100644
--- a/src/namecache/.gitignore
+++ b/src/namecache/.gitignore
@@ -3,3 +3,4 @@ gnunet-namecache
test_namecache_api_cache_block
test_plugin_namecache_postgres
test_plugin_namecache_sqlite
+zonefiles
diff --git a/src/nat/gnunet-service-nat.c b/src/nat/gnunet-service-nat.c
index 6ef0dce5e..8f9e9f7fe 100644
--- a/src/nat/gnunet-service-nat.c
+++ b/src/nat/gnunet-service-nat.c
@@ -1053,7 +1053,7 @@ run_scan (void *cls)
const struct sockaddr_in *s4
= (const struct sockaddr_in *) &pos->addr;
- GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Found NATed local address %s, starting NAT server\n",
GNUNET_a2s ((void *) &pos->addr, sizeof (*s4)));
pos->hc = GN_start_gnunet_nat_server_ (&s4->sin_addr,
diff --git a/src/nat/nat.conf.in b/src/nat/nat.conf.in
index 88975c424..87fe29d9c 100644
--- a/src/nat/nat.conf.in
+++ b/src/nat/nat.conf.in
@@ -9,42 +9,13 @@ UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-nat.sock
UNIX_MATCH_UID = YES
UNIX_MATCH_GID = YES
-# Are we behind NAT?
-BEHIND_NAT = NO
-
-# Is the NAT hole-punched?
-PUNCHED_NAT = NO
-
# Enable UPNP by default?
-ENABLE_UPNP = NO
-
-# Use addresses from the local network interfaces (inluding loopback, but also
others)
-USE_LOCALADDR = YES
-
-# Use address obtained from a DNS lookup of our hostname
-USE_HOSTNAME = NO
-
-# External IP address of the NAT box (if known); IPv4 dotted-decimal ONLY at
this time (should allow DynDNS!)
-# normal interface IP address for non-NATed peers;
-# possibly auto-detected (using UPnP) if possible if not specified
-# EXTERNAL_ADDRESS =
-
-# Should we use ICMP-based NAT traversal to try connect to NATed peers
-# or, if we are behind NAT, to allow connections to us?
-ENABLE_ICMP_CLIENT = NO
-ENABLE_ICMP_SERVER = NO
-
-# IP address of the interface connected to the NAT box; IPv4 dotted-decimal
ONLY;
-# normal interface IP address for non-NATed peers;
-# likely auto-detected (via interface list) if not specified (!)
-# INTERNAL_ADDRESS =
+ENABLE_UPNP = YES
# Disable IPv6 support
+# FIXME: move entirely to transport plugins!
DISABLEV6 = NO
-# Do we use addresses from localhost address ranges? (::1, 127.0.0.0/8)
-RETURN_LOCAL_ADDRESSES = NO
-
# How often do we query the DNS resolver
# for our hostname (to get our own IP)
HOSTNAME_DNS_FREQUENCY = 20 min
diff --git a/src/nat/nat_api.c b/src/nat/nat_api.c
index 5b4c39682..810d35649 100644
--- a/src/nat/nat_api.c
+++ b/src/nat/nat_api.c
@@ -714,6 +714,11 @@ GNUNET_NAT_unregister (struct GNUNET_NAT_Handle *nh)
GNUNET_MQ_destroy (nh->mq);
nh->mq = NULL;
}
+ if (NULL != nh->reconnect_task)
+ {
+ GNUNET_SCHEDULER_cancel (nh->reconnect_task);
+ nh->reconnect_task = NULL;
+ }
GNUNET_free (nh->reg);
GNUNET_free (nh);
}
diff --git a/src/util/Makefile.am b/src/util/Makefile.am
index 65818640c..c7f069206 100644
--- a/src/util/Makefile.am
+++ b/src/util/Makefile.am
@@ -59,7 +59,7 @@ test_common_logging_dummy_LDADD = \
libgnunetutil_la_SOURCES = \
bandwidth.c \
bio.c \
- client_new.c \
+ client.c \
common_allocation.c \
common_endian.c \
common_logging.c \
diff --git a/src/util/client_new.c b/src/util/client.c
similarity index 100%
rename from src/util/client_new.c
rename to src/util/client.c
--
To stop receiving notification emails like this one, please contact
address@hidden
- [GNUnet-SVN] [gnunet] branch master updated (fc158da4c -> aae0e990d),
gnunet <=
- [GNUnet-SVN] [gnunet] 15/17: remove obsolete options, gnunet, 2017/01/09
- [GNUnet-SVN] [gnunet] 13/17: cosmetics, gnunet, 2017/01/09
- [GNUnet-SVN] [gnunet] 05/17: ignore zonefiles dir, gnunet, 2017/01/09
- [GNUnet-SVN] [gnunet] 07/17: rename new core API implementation to name of standard implementation, gnunet, 2017/01/09
- [GNUnet-SVN] [gnunet] 08/17: rename new client API implementation to name of standard implementation, gnunet, 2017/01/09
- [GNUnet-SVN] [gnunet] 04/17: dead code elimination, gnunet, 2017/01/09
- [GNUnet-SVN] [gnunet] 03/17: handle transmissions initiated during disconnect callbacks by dropping, gnunet, 2017/01/09
- [GNUnet-SVN] [gnunet] 12/17: enable upnpc by default, gnunet, 2017/01/09
- [GNUnet-SVN] [gnunet] 01/17: out-of-order PIDs are not exactly protocol violations, hence do not report as such, gnunet, 2017/01/09
- [GNUnet-SVN] [gnunet] 10/17: fix link issue, gnunet, 2017/01/09