[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] [gnunet] branch master updated (96f4f72bc -> 7cab5e7bd)
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] [gnunet] branch master updated (96f4f72bc -> 7cab5e7bd) |
|
Date: |
Thu, 17 May 2018 00:09:11 +0200 |
This is an automated email from the git hooks/post-receive script.
grothoff pushed a change to branch master
in repository gnunet.
from 96f4f72bc disable churn
new 215e607f6 optimize setting upload length if available
new da393a04d log key material hashes
new 7cab5e7bd sanitize KX logic by always having the same peer go first
The 3 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/gnunet-service-cadet_tunnels.c | 248 ++++++++++++++++---------------
src/gns/gnunet-gns-benchmark.c | 2 +-
src/gns/gnunet-gns-proxy.c | 34 +++++
src/gns/gnunet-service-gns.c | 19 +--
src/include/gnunet_common.h | 70 ++++++++-
src/util/common_logging.c | 100 +++++++++++++
6 files changed, 337 insertions(+), 136 deletions(-)
diff --git a/src/cadet/gnunet-service-cadet_tunnels.c
b/src/cadet/gnunet-service-cadet_tunnels.c
index 97c50dc90..2565b8f18 100644
--- a/src/cadet/gnunet-service-cadet_tunnels.c
+++ b/src/cadet/gnunet-service-cadet_tunnels.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2013, 2017 GNUnet e.V.
+ Copyright (C) 2013, 2017, 2018 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
@@ -459,6 +459,29 @@ struct CadetTunnel
/**
+ * Am I Alice or Bob, or talking to myself?
+ *
+ * @param other the other peer
+ * @return #GNUNET_YES for Alice, #GNUNET_NO for Bob, #GNUNET_SYSERR if
talking to myself
+ */
+static int
+alice_or_bob (const struct GNUNET_PeerIdentity *other)
+{
+ if (0 > GNUNET_CRYPTO_cmp_peer_identity (&my_full_id,
+ other))
+ return GNUNET_YES;
+ else if (0 < GNUNET_CRYPTO_cmp_peer_identity (&my_full_id,
+ other))
+ return GNUNET_NO;
+ else
+ {
+ GNUNET_break_op (0);
+ return GNUNET_SYSERR;
+ }
+}
+
+
+/**
* Connection @a ct is now unready, clear it's ready flag
* and move it from the ready DLL to the busy DLL.
*
@@ -1324,6 +1347,8 @@ send_kx (struct CadetTunnel *t,
struct GNUNET_CADET_TunnelKeyExchangeMessage *msg;
enum GNUNET_CADET_KX_Flags flags;
+ if (GNUNET_YES != alice_or_bob (GCP_get_id (t->destination)))
+ return; /* only Alice may send KX */
if ( (NULL == ct) ||
(GNUNET_NO == ct->is_ready) )
ct = get_ready_connection (t);
@@ -1337,11 +1362,6 @@ send_kx (struct CadetTunnel *t,
return;
}
cc = ct->cc;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Sending KX on %s via %s in state %s\n",
- GCT_2s (t),
- GCC_2s (cc),
- estate2s (t->estate));
env = GNUNET_MQ_msg (msg,
GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX);
flags = GNUNET_CADET_KX_FLAG_FORCE_REPLY; /* always for KX */
@@ -1404,11 +1424,6 @@ send_kx_auth (struct CadetTunnel *t,
}
t->kx_auth_requested = GNUNET_NO; /* clear flag */
cc = ct->cc;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Sending KX_AUTH on %s using %s\n",
- GCT_2s (t),
- GCC_2s (ct->cc));
-
env = GNUNET_MQ_msg (msg,
GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH);
flags = GNUNET_CADET_KX_FLAG_NONE;
@@ -1424,7 +1439,6 @@ send_kx_auth (struct CadetTunnel *t,
GNUNET_CRYPTO_hash (&ax->RK,
sizeof (ax->RK),
&msg->auth);
-
/* Compute when to be triggered again; actual job will
be scheduled via #connection_ready_cb() */
t->kx_retry_delay
@@ -1489,18 +1503,11 @@ update_ax_by_kx (struct CadetTunnelAxolotl *ax,
const char salt[] = "CADET Axolotl salt";
int am_I_alice;
- if (0 > GNUNET_CRYPTO_cmp_peer_identity (&my_full_id,
- pid))
- am_I_alice = GNUNET_YES;
- else if (0 < GNUNET_CRYPTO_cmp_peer_identity (&my_full_id,
- pid))
- am_I_alice = GNUNET_NO;
- else
+ if (GNUNET_SYSERR == (am_I_alice = alice_or_bob (pid)))
{
GNUNET_break_op (0);
return GNUNET_SYSERR;
}
-
if (0 == memcmp (&ax->DHRr,
ratchet_key,
sizeof (*ratchet_key)))
@@ -1519,36 +1526,34 @@ update_ax_by_kx (struct CadetTunnelAxolotl *ax,
/* ECDH A B0 */
if (GNUNET_YES == am_I_alice)
{
- GNUNET_CRYPTO_eddsa_ecdh (my_private_key, /* A */
+ GNUNET_CRYPTO_eddsa_ecdh (my_private_key, /* a */
ephemeral_key, /* B0 */
&key_material[0]);
}
else
{
- GNUNET_CRYPTO_ecdh_eddsa (&ax->kx_0, /* B0 */
+ GNUNET_CRYPTO_ecdh_eddsa (&ax->kx_0, /* b0 */
&pid->public_key, /* A */
&key_material[0]);
}
-
/* ECDH A0 B */
if (GNUNET_YES == am_I_alice)
{
- GNUNET_CRYPTO_ecdh_eddsa (&ax->kx_0, /* A0 */
+ GNUNET_CRYPTO_ecdh_eddsa (&ax->kx_0, /* a0 */
&pid->public_key, /* B */
&key_material[1]);
}
else
{
- GNUNET_CRYPTO_eddsa_ecdh (my_private_key, /* A */
- ephemeral_key, /* B0 */
+ GNUNET_CRYPTO_eddsa_ecdh (my_private_key, /* b */
+ ephemeral_key, /* A0 */
&key_material[1]);
}
/* ECDH A0 B0 */
- GNUNET_CRYPTO_ecc_ecdh (&ax->kx_0, /* A0 or B0 */
+ GNUNET_CRYPTO_ecc_ecdh (&ax->kx_0, /* a0 or b0 */
ephemeral_key, /* B0 or A0 */
&key_material[2]);
-
/* KDF */
GNUNET_CRYPTO_kdf (keys, sizeof (keys),
salt, sizeof (salt),
@@ -1560,7 +1565,7 @@ update_ax_by_kx (struct CadetTunnelAxolotl *ax,
sizeof (ax->RK)))
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Root key of handshake already known. Ignoring KX.\n");
+ "Root key already known. Ignoring KX.\n");
GNUNET_STATISTICS_update (stats,
"# Root key already known",
1,
@@ -1609,75 +1614,75 @@ retry_kx (void *cls)
GCT_2s (t),
estate2s (t->estate));
switch (t->estate)
- {
- case CADET_TUNNEL_KEY_UNINITIALIZED: /* first attempt */
- case CADET_TUNNEL_KEY_AX_SENT: /* trying again */
- send_kx (t,
- NULL,
- &t->ax);
- break;
- case CADET_TUNNEL_KEY_AX_RECV:
- case CADET_TUNNEL_KEY_AX_SENT_AND_RECV:
- /* We are responding, so only require reply
- if WE have a channel waiting. */
- if (NULL != t->unverified_ax)
- {
- /* Send AX_AUTH so we might get this one verified */
- ax = t->unverified_ax;
- }
- else
- {
- /* How can this be? */
- GNUNET_break (0);
- ax = &t->ax;
- }
- send_kx_auth (t,
- NULL,
- ax,
- (0 == GCT_count_channels (t))
- ? GNUNET_NO
- : GNUNET_YES);
- break;
- case CADET_TUNNEL_KEY_AX_AUTH_SENT:
- /* We are responding, so only require reply
- if WE have a channel waiting. */
- if (NULL != t->unverified_ax)
- {
- /* Send AX_AUTH so we might get this one verified */
- ax = t->unverified_ax;
- }
- else
- {
- /* How can this be? */
- GNUNET_break (0);
- ax = &t->ax;
- }
- send_kx_auth (t,
- NULL,
- ax,
- (0 == GCT_count_channels (t))
- ? GNUNET_NO
- : GNUNET_YES);
- break;
- case CADET_TUNNEL_KEY_OK:
- /* Must have been the *other* peer asking us to
- respond with a KX_AUTH. */
- if (NULL != t->unverified_ax)
{
- /* Sending AX_AUTH in response to AX so we might get this one verified */
- ax = t->unverified_ax;
- }
- else
- {
- /* Sending AX_AUTH in response to AX_AUTH */
- ax = &t->ax;
+ case CADET_TUNNEL_KEY_UNINITIALIZED: /* first attempt */
+ case CADET_TUNNEL_KEY_AX_SENT: /* trying again */
+ send_kx (t,
+ NULL,
+ &t->ax);
+ break;
+ case CADET_TUNNEL_KEY_AX_RECV:
+ case CADET_TUNNEL_KEY_AX_SENT_AND_RECV:
+ /* We are responding, so only require reply
+ if WE have a channel waiting. */
+ if (NULL != t->unverified_ax)
+ {
+ /* Send AX_AUTH so we might get this one verified */
+ ax = t->unverified_ax;
+ }
+ else
+ {
+ /* How can this be? */
+ GNUNET_break (0);
+ ax = &t->ax;
+ }
+ send_kx_auth (t,
+ NULL,
+ ax,
+ (0 == GCT_count_channels (t))
+ ? GNUNET_NO
+ : GNUNET_YES);
+ break;
+ case CADET_TUNNEL_KEY_AX_AUTH_SENT:
+ /* We are responding, so only require reply
+ if WE have a channel waiting. */
+ if (NULL != t->unverified_ax)
+ {
+ /* Send AX_AUTH so we might get this one verified */
+ ax = t->unverified_ax;
+ }
+ else
+ {
+ /* How can this be? */
+ GNUNET_break (0);
+ ax = &t->ax;
+ }
+ send_kx_auth (t,
+ NULL,
+ ax,
+ (0 == GCT_count_channels (t))
+ ? GNUNET_NO
+ : GNUNET_YES);
+ break;
+ case CADET_TUNNEL_KEY_OK:
+ /* Must have been the *other* peer asking us to
+ respond with a KX_AUTH. */
+ if (NULL != t->unverified_ax)
+ {
+ /* Sending AX_AUTH in response to AX so we might get this one
verified */
+ ax = t->unverified_ax;
+ }
+ else
+ {
+ /* Sending AX_AUTH in response to AX_AUTH */
+ ax = &t->ax;
+ }
+ send_kx_auth (t,
+ NULL,
+ ax,
+ GNUNET_NO);
+ break;
}
- send_kx_auth (t,
- NULL,
- ax,
- GNUNET_NO);
- break;
- }
}
@@ -1694,13 +1699,18 @@ GCT_handle_kx (struct CadetTConnection *ct,
const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg)
{
struct CadetTunnel *t = ct->t;
- struct CadetTunnelAxolotl *ax;
int ret;
GNUNET_STATISTICS_update (stats,
"# KX received",
1,
GNUNET_NO);
+ if (GNUNET_YES == alice_or_bob (GCP_get_id (t->destination)))
+ {
+ /* Bob is not allowed to send KX! */
+ GNUNET_break_op (0);
+ return;
+ }
#if 1
if ( (0 ==
memcmp (&t->ax.DHRr,
@@ -1711,19 +1721,17 @@ GCT_handle_kx (struct CadetTConnection *ct,
&msg->ephemeral_key,
sizeof (msg->ephemeral_key))) )
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Got duplicate KX. Firing back KX_AUTH.\n");
- GNUNET_STATISTICS_update (stats,
- "# Duplicate KX received",
- 1,
- GNUNET_NO);
- send_kx_auth (t,
- ct,
- &t->ax,
- GNUNET_NO);
- return;
- }
+ {
+ GNUNET_STATISTICS_update (stats,
+ "# Duplicate KX received",
+ 1,
+ GNUNET_NO);
+ send_kx_auth (t,
+ ct,
+ &t->ax,
+ GNUNET_NO);
+ return;
+ }
#endif
/* We only keep ONE unverified KX around, so if there is an existing one,
clean it up. */
@@ -1738,9 +1746,6 @@ GCT_handle_kx (struct CadetTConnection *ct,
&msg->ephemeral_key,
sizeof (msg->ephemeral_key))) )
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Got duplicate unverified KX on %s. Fire back KX_AUTH again.\n",
- GCT_2s (t));
GNUNET_STATISTICS_update (stats,
"# Duplicate unverified KX received",
1,
@@ -1754,8 +1759,7 @@ GCT_handle_kx (struct CadetTConnection *ct,
#endif
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Dropping old unverified KX state. Got a fresh KX for %s.\n",
- GCT_2s (t));
+ "Dropping old unverified KX state.\n");
GNUNET_STATISTICS_update (stats,
"# Unverified KX dropped for fresh KX",
1,
@@ -1764,32 +1768,29 @@ GCT_handle_kx (struct CadetTConnection *ct,
memset (t->unverified_ax,
0,
sizeof (struct CadetTunnelAxolotl));
- t->unverified_ax->DHRs = t->ax.DHRs;
- t->unverified_ax->kx_0 = t->ax.kx_0;
}
else
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Creating fresh unverified KX for %s.\n",
+ "Creating fresh unverified KX for %s\n",
GCT_2s (t));
GNUNET_STATISTICS_update (stats,
"# Fresh KX setup",
1,
GNUNET_NO);
t->unverified_ax = GNUNET_new (struct CadetTunnelAxolotl);
- t->unverified_ax->DHRs = t->ax.DHRs;
- t->unverified_ax->kx_0 = t->ax.kx_0;
}
/* Set as the 'current' RK/DHRr the one we are currently using,
so that the duplicate-detection logic of
#update_ax_by_kx can work. */
t->unverified_ax->RK = t->ax.RK;
t->unverified_ax->DHRr = t->ax.DHRr;
+ t->unverified_ax->DHRs = t->ax.DHRs;
+ t->unverified_ax->kx_0 = t->ax.kx_0;
t->unverified_attempts = 0;
- ax = t->unverified_ax;
/* Update 'ax' by the new key material */
- ret = update_ax_by_kx (ax,
+ ret = update_ax_by_kx (t->unverified_ax,
GCP_get_id (t->destination),
&msg->ephemeral_key,
&msg->ratchet_key);
@@ -1853,7 +1854,6 @@ GCT_handle_kx_auth (struct CadetTConnection *ct,
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Handling KX_AUTH message for %s\n",
GCT_2s (t));
-
/* We do everything in ax_tmp until we've checked the authentication
so we don't clobber anything we care about by accident. */
ax_tmp = t->ax;
@@ -1887,6 +1887,8 @@ GCT_handle_kx_auth (struct CadetTConnection *ct,
"# KX_AUTH not using our last KX received (auth
failure)",
1,
GNUNET_NO);
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "KX AUTH missmatch!\n");
send_kx (t,
ct,
&t->ax);
diff --git a/src/gns/gnunet-gns-benchmark.c b/src/gns/gnunet-gns-benchmark.c
index afa540c85..d5afae9f6 100644
--- a/src/gns/gnunet-gns-benchmark.c
+++ b/src/gns/gnunet-gns-benchmark.c
@@ -492,7 +492,7 @@ process_stdin (void *cls)
delta = GNUNET_TIME_absolute_get_duration (last);
last = GNUNET_TIME_absolute_get ();
fprintf (stderr,
- "Read 10000 domain names in %s\n",
+ "Read 100000 domain names in %s\n",
GNUNET_STRINGS_relative_time_to_string (delta,
GNUNET_YES));
}
diff --git a/src/gns/gnunet-gns-proxy.c b/src/gns/gnunet-gns-proxy.c
index 08663a57e..02ebcf0f1 100644
--- a/src/gns/gnunet-gns-proxy.c
+++ b/src/gns/gnunet-gns-proxy.c
@@ -1801,6 +1801,23 @@ create_response (void *cls,
curl_easy_setopt (s5r->curl, CURLOPT_WRITEDATA, s5r);
curl_easy_setopt (s5r->curl, CURLOPT_READFUNCTION, &curl_upload_cb);
curl_easy_setopt (s5r->curl, CURLOPT_READDATA, s5r);
+ {
+ const char *us;
+ long upload_size;
+
+ us = MHD_lookup_connection_value (con,
+ MHD_HEADER_KIND,
+ MHD_HTTP_HEADER_CONTENT_LENGTH);
+ if ( (1 == sscanf (us,
+ "%ld",
+ &upload_size)) &&
+ (upload_size >= 0) )
+ {
+ curl_easy_setopt (s5r->curl,
+ CURLOPT_INFILESIZE,
+ upload_size);
+ }
+ }
}
else if (0 == strcasecmp (meth, MHD_HTTP_METHOD_POST))
{
@@ -1810,6 +1827,23 @@ create_response (void *cls,
curl_easy_setopt (s5r->curl, CURLOPT_WRITEDATA, s5r);
curl_easy_setopt (s5r->curl, CURLOPT_READFUNCTION, &curl_upload_cb);
curl_easy_setopt (s5r->curl, CURLOPT_READDATA, s5r);
+ {
+ const char *us;
+ long upload_size;
+
+ us = MHD_lookup_connection_value (con,
+ MHD_HEADER_KIND,
+ MHD_HTTP_HEADER_CONTENT_LENGTH);
+ if ( (1 == sscanf (us,
+ "%ld",
+ &upload_size)) &&
+ (upload_size >= 0) )
+ {
+ curl_easy_setopt (s5r->curl,
+ CURLOPT_INFILESIZE,
+ upload_size);
+ }
+ }
}
else if (0 == strcasecmp (meth, MHD_HTTP_METHOD_HEAD))
{
diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c
index c376ddfcc..cffae824d 100644
--- a/src/gns/gnunet-service-gns.c
+++ b/src/gns/gnunet-service-gns.c
@@ -296,7 +296,6 @@ client_disconnect_cb (void *cls,
clh);
GNUNET_free (clh);
}
-
GNUNET_free (gc);
}
@@ -340,26 +339,29 @@ send_lookup_response (void* cls,
const struct GNUNET_GNSRECORD_Data *rd)
{
struct ClientLookupHandle *clh = cls;
- struct GNUNET_MQ_Envelope *env;
+ struct GnsClient *gc = clh->gc;
+ struct GNUNET_MQ_Envelope *env;
struct LookupResultMessage *rmsg;
size_t len;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending LOOKUP_RESULT message with %u results\n",
(unsigned int) rd_count);
-
- len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
+ len = GNUNET_GNSRECORD_records_get_size (rd_count,
+ rd);
env = GNUNET_MQ_msg_extra (rmsg,
len,
GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT);
rmsg->id = clh->request_id;
rmsg->rd_count = htonl (rd_count);
- GNUNET_GNSRECORD_records_serialize (rd_count, rd, len,
+ GNUNET_GNSRECORD_records_serialize (rd_count,
+ rd,
+ len,
(char*) &rmsg[1]);
- GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq(clh->gc->client),
+ GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (gc->client),
env);
- GNUNET_CONTAINER_DLL_remove (clh->gc->clh_head,
- clh->gc->clh_tail,
+ GNUNET_CONTAINER_DLL_remove (gc->clh_head,
+ gc->clh_tail,
clh);
GNUNET_free (clh);
GNUNET_STATISTICS_update (statistics,
@@ -428,7 +430,6 @@ handle_lookup (void *cls,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received LOOKUP `%s' message\n",
name);
-
clh = GNUNET_new (struct ClientLookupHandle);
GNUNET_CONTAINER_DLL_insert (gc->clh_head,
gc->clh_tail,
diff --git a/src/include/gnunet_common.h b/src/include/gnunet_common.h
index 0fb39575c..0c527e774 100644
--- a/src/include/gnunet_common.h
+++ b/src/include/gnunet_common.h
@@ -592,7 +592,7 @@ GNUNET_sh2s (const struct GNUNET_ShortHashCode *shc);
* @return string
*/
const char *
-GNUNET_h2s (const struct GNUNET_HashCode * hc);
+GNUNET_h2s (const struct GNUNET_HashCode *hc);
/**
@@ -607,7 +607,7 @@ GNUNET_h2s (const struct GNUNET_HashCode * hc);
* @return string
*/
const char *
-GNUNET_h2s2 (const struct GNUNET_HashCode * hc);
+GNUNET_h2s2 (const struct GNUNET_HashCode *hc);
/**
@@ -621,7 +621,71 @@ GNUNET_h2s2 (const struct GNUNET_HashCode * hc);
* @return string
*/
const char *
-GNUNET_h2s_full (const struct GNUNET_HashCode * hc);
+GNUNET_h2s_full (const struct GNUNET_HashCode *hc);
+
+
+/**
+ * Public key. Details in gnunet_util_crypto.h.
+ */
+struct GNUNET_CRYPTO_EddsaPublicKey;
+
+
+/**
+ * Public key. Details in gnunet_util_crypto.h.
+ */
+struct GNUNET_CRYPTO_EcdhePublicKey;
+
+
+/**
+ * @ingroup logging
+ * Convert a public key value to a string (for printing debug messages).
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
+ *
+ * @param hc the hash code
+ * @return string
+ */
+const char *
+GNUNET_p2s (const struct GNUNET_CRYPTO_EddsaPublicKey *p);
+
+
+/**
+ * @ingroup logging
+ * Convert a public key value to a string (for printing debug messages).
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
+ *
+ * @param hc the hash code
+ * @return string
+ */
+const char *
+GNUNET_p2s2 (const struct GNUNET_CRYPTO_EddsaPublicKey *p);
+
+
+/**
+ * @ingroup logging
+ * Convert a public key value to a string (for printing debug messages).
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
+ *
+ * @param hc the hash code
+ * @return string
+ */
+const char *
+GNUNET_e2s (const struct GNUNET_CRYPTO_EcdhePublicKey *p);
+
+
+/**
+ * @ingroup logging
+ * Convert a public key value to a string (for printing debug messages).
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
+ *
+ * @param hc the hash code
+ * @return string
+ */
+const char *
+GNUNET_e2s2 (const struct GNUNET_CRYPTO_EcdhePublicKey *p);
/**
diff --git a/src/util/common_logging.c b/src/util/common_logging.c
index ea5430191..df501fbcd 100644
--- a/src/util/common_logging.c
+++ b/src/util/common_logging.c
@@ -1192,6 +1192,106 @@ GNUNET_h2s2 (const struct GNUNET_HashCode * hc)
/**
* @ingroup logging
+ * Convert a public key value to a string (for printing debug messages).
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
+ *
+ * @param hc the hash code
+ * @return string
+ */
+const char *
+GNUNET_p2s (const struct GNUNET_CRYPTO_EddsaPublicKey *p)
+{
+ static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
+ struct GNUNET_HashCode hc;
+
+ GNUNET_CRYPTO_hash (p,
+ sizeof (*p),
+ &hc);
+ GNUNET_CRYPTO_hash_to_enc (&hc,
+ &ret);
+ ret.encoding[6] = '\0';
+ return (const char *) ret.encoding;
+}
+
+
+/**
+ * @ingroup logging
+ * Convert a public key value to a string (for printing debug messages).
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
+ *
+ * @param hc the hash code
+ * @return string
+ */
+const char *
+GNUNET_p2s2 (const struct GNUNET_CRYPTO_EddsaPublicKey *p)
+{
+ static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
+ struct GNUNET_HashCode hc;
+
+ GNUNET_CRYPTO_hash (p,
+ sizeof (*p),
+ &hc);
+ GNUNET_CRYPTO_hash_to_enc (&hc,
+ &ret);
+ ret.encoding[6] = '\0';
+ return (const char *) ret.encoding;
+}
+
+
+/**
+ * @ingroup logging
+ * Convert a public key value to a string (for printing debug messages).
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
+ *
+ * @param hc the hash code
+ * @return string
+ */
+const char *
+GNUNET_e2s (const struct GNUNET_CRYPTO_EcdhePublicKey *p)
+{
+ static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
+ struct GNUNET_HashCode hc;
+
+ GNUNET_CRYPTO_hash (p,
+ sizeof (*p),
+ &hc);
+ GNUNET_CRYPTO_hash_to_enc (&hc,
+ &ret);
+ ret.encoding[6] = '\0';
+ return (const char *) ret.encoding;
+}
+
+
+/**
+ * @ingroup logging
+ * Convert a public key value to a string (for printing debug messages).
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
+ *
+ * @param hc the hash code
+ * @return string
+ */
+const char *
+GNUNET_e2s2 (const struct GNUNET_CRYPTO_EcdhePublicKey *p)
+{
+ static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
+ struct GNUNET_HashCode hc;
+
+ GNUNET_CRYPTO_hash (p,
+ sizeof (*p),
+ &hc);
+ GNUNET_CRYPTO_hash_to_enc (&hc,
+ &ret);
+ ret.encoding[6] = '\0';
+ return (const char *) ret.encoding;
+}
+
+
+/**
+ * @ingroup logging
* Convert a short hash value to a string (for printing debug messages).
* This is one of the very few calls in the entire API that is
* NOT reentrant!
--
To stop receiving notification emails like this one, please contact
address@hidden
- [GNUnet-SVN] [gnunet] branch master updated (96f4f72bc -> 7cab5e7bd),
gnunet <=