#include "platform.h"
#include "gnunet_util_lib.h"
+#include "gnunet_crypto_lib.h"
#include "gnunet_constants.h"
#include "gnunet_arm_service.h"
+#include "gnunet_signatures.h"
#include "gnunet_namestore_service.h"
#include "namestore.h"
+
#define DEBUG_GNS_API GNUNET_EXTRA_LOGGING
#define LOG(kind,...) GNUNET_log_from (kind, "gns-api",__VA_ARGS__)
struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key;
char *name;
- struct GNUNET_NAMESTORE_RecordData *rd = NULL;
+ char * rd_tmp;
+
struct GNUNET_CRYPTO_RsaSignature *signature = NULL;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded dummy;
struct GNUNET_TIME_Absolute expire;
- unsigned int rd_count = 0;
+ size_t exp_msg_len;
size_t msg_len = 0;
size_t name_len = 0;
+ size_t rd_len = 0;
int contains_sig = GNUNET_NO;
+ int rd_count = 0;
- rd_count = ntohl (msg->rc_count);
- msg_len = ntohs (msg->header.size);
+ rd_len = ntohs (msg->rd_len);
+ rd_count = ntohs (msg->rd_count);
+ msg_len = ntohs (msg->gns_header.header.size);
name_len = ntohs (msg->name_len);
contains_sig = ntohs (msg->contains_sig);
expire = GNUNET_TIME_absolute_ntoh(msg->expire);
- if (msg_len != sizeof (struct LookupNameResponseMessage) +
+ exp_msg_len = sizeof (struct LookupNameResponseMessage) +
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
name_len +
- rd_count * sizeof (struct GNUNET_NAMESTORE_RecordData) +
- contains_sig * sizeof (struct GNUNET_CRYPTO_RsaSignature))
+ rd_len +
+ contains_sig * sizeof (struct GNUNET_CRYPTO_RsaSignature);
+
+ if (msg_len != exp_msg_len)
{
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Message size describes with `%u' bytes but calculated size is %u bytes \n",
+ msg_len, exp_msg_len);
GNUNET_break_op (0);
return;
}
zone_key = (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) &msg[1];
name = (char *) &zone_key[1];
- rd = (struct GNUNET_NAMESTORE_RecordData *) &name[name_len];
+ rd_tmp = &name[name_len];
+
+ struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ GNUNET_NAMESTORE_records_deserialize(rd_len, rd_tmp, rd_count, rd);
/* reset values if values not contained */
if (contains_sig == GNUNET_NO)
signature = NULL;
else
- signature = (struct GNUNET_CRYPTO_RsaSignature *) &rd[rd_count];
- if (rd_count == 0)
- rd = NULL;
+ signature = (struct GNUNET_CRYPTO_RsaSignature *) &rd_tmp[rd_len];
if (name_len == 0)
name = NULL;
if (qe->proc != NULL)
{
- qe->proc (qe->proc_cls, zone_key, expire, name, rd_count, rd, signature);
+ qe->proc (qe->proc_cls, zone_key, expire, name, rd_count, (rd_count > 0) ? rd : NULL, signature);
}
+
/* Operation done, remove */
GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
GNUNET_free (qe);
"RECORD_CREATE_RESPONSE");
struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
- int res = GNUNET_OK;
- if (ntohs (msg->op_result) == GNUNET_OK)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' %i\n",
+ "RECORD_CREATE_RESPONSE", ntohs (msg->op_result));
+ if (ntohs (msg->op_result) == GNUNET_YES)
{
- res = GNUNET_OK;
if (qe->cont != NULL)
{
- qe->cont (qe->cont_cls, res, _("Namestore added record successfully"));
+ qe->cont (qe->cont_cls, GNUNET_YES, _("Namestore added record successfully"));
}
}
else if (ntohs (msg->op_result) == GNUNET_NO)
{
- res = GNUNET_SYSERR;
if (qe->cont != NULL)
{
- qe->cont (qe->cont_cls, res, _("Namestore failed to add record"));
+ qe->cont (qe->cont_cls, GNUNET_NO, _("Namestore record already existed"));
}
}
else
{
- GNUNET_break_op (0);
- return;
+ if (qe->cont != NULL)
+ {
+ qe->cont (qe->cont_cls, GNUNET_SYSERR, _("Namestore failed to add record\n"));
+ }
+ }
+
+ /* Operation done, remove */
+ GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, qe);
+
+ GNUNET_free (qe);
+}
+
+
+static void
+handle_record_remove_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
+ struct RecordRemoveResponseMessage* msg,
+ size_t size)
+{
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' \n",
+ "RECORD_REMOVE_RESPONSE");
+
+ struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
+ int res = ntohs (msg->op_result);
+
+ /**
+ * result:
+ * 0 : successful
+ * 1 : No records for entry
+ * 2 : Could not find record to remove
+ * 3 : Failed to create new signature
+ * 4 : Failed to put new set of records in database
+ */
+ switch (res) {
+ case 0:
+ if (qe->cont != NULL)
+ {
+ qe->cont (qe->cont_cls, GNUNET_YES, _("Namestore removed record successfully"));
+ }
+
+ break;
+ case 1:
+ if (qe->cont != NULL)
+ {
+ qe->cont (qe->cont_cls, GNUNET_NO, _("No records for entry"));
+ }
+
+ break;
+ case 2:
+ if (qe->cont != NULL)
+ {
+ qe->cont (qe->cont_cls, GNUNET_NO, _("Could not find record to remove"));
+ }
+
+ break;
+ case 3:
+ if (qe->cont != NULL)
+ {
+ qe->cont (qe->cont_cls, GNUNET_SYSERR, _("Failed to create new signature"));
+ }
+
+ break;
+ case 4:
+ if (qe->cont != NULL)
+ {
+ qe->cont (qe->cont_cls, GNUNET_SYSERR, _("Failed to put new set of records in database"));
+ }
+ break;
+ default:
+ GNUNET_break_op (0);
+ break;
}
/* Operation done, remove */
}
handle_record_create_response (qe, (struct RecordCreateResponseMessage *) msg, size);
break;
+ case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_REMOVE_RESPONSE:
+ if (size != sizeof (struct RecordRemoveResponseMessage))
+ {
+ GNUNET_break_op (0);
+ break;
+ }
+ handle_record_remove_response (qe, (struct RecordRemoveResponseMessage *) msg, size);
+ break;
default:
GNUNET_break_op (0);
break;
process_namestore_message (void *cls, const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_NAMESTORE_Handle *h = cls;
- struct GenericMessage * gm;
+ struct GNUNET_NAMESTORE_Header * gm;
struct GNUNET_NAMESTORE_QueueEntry *qe;
struct GNUNET_NAMESTORE_ZoneIterator *ze;
uint16_t size;
uint16_t type;
- uint32_t op_id = UINT32_MAX;
+ uint32_t r_id = UINT32_MAX;
if (NULL == msg)
{
size = ntohs (msg->size);
type = ntohs (msg->type);
- if (size < sizeof (struct GenericMessage))
+ if (size < sizeof (struct GNUNET_NAMESTORE_Header))
{
GNUNET_break_op (0);
GNUNET_CLIENT_receive (h->client, &process_namestore_message, h,
return;
}
- gm = (struct GenericMessage *) msg;
- op_id = ntohl (gm->op_id);
+ gm = (struct GNUNET_NAMESTORE_Header *) msg;
+ r_id = ntohl (gm->r_id);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received message type %i size %i op %u\n", type, size, op_id);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received message type %i size %i op %u\n", type, size, r_id);
/* Find matching operation */
- if (op_id > h->op_id)
+ if (r_id > h->op_id)
{
/* No matching pending operation found */
GNUNET_break_op (0);
/* Is it a record related operation ? */
for (qe = h->op_head; qe != NULL; qe = qe->next)
{
- if (qe->op_id == op_id)
+ if (qe->op_id == r_id)
break;
}
if (qe != NULL)
/* Is it a zone iteration operation ? */
for (ze = h->z_head; ze != NULL; ze = ze->next)
{
- if (ze->op_id == op_id)
+ if (ze->op_id == r_id)
break;
}
if (ze != NULL)
return h;
}
+struct DisconnectContext
+{
+ struct GNUNET_NAMESTORE_Handle *h;
+ int drop;
+};
-/**
- * Disconnect from the namestore service (and free associated
- * resources).
- *
- * @param h handle to the namestore
- * @param drop set to GNUNET_YES to delete all data in namestore (!)
- */
-void
-GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h, int drop)
+static void
+clean_up_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct PendingMessage *p;
struct GNUNET_NAMESTORE_QueueEntry *q;
struct GNUNET_NAMESTORE_ZoneIterator *z;
-
+ struct GNUNET_NAMESTORE_Handle *h = cls;
GNUNET_assert (h != NULL);
-
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
while (NULL != (p = h->pending_head))
{
GNUNET_CONTAINER_DLL_remove (h->pending_head, h->pending_tail, p);
while (NULL != (q = h->op_head))
{
+ GNUNET_break (0);
GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, q);
GNUNET_free (q);
}
}
GNUNET_free(h);
h = NULL;
+};
+
+static size_t
+transmit_disconnect_to_namestore (void *cls, size_t size, void *buf)
+{
+ struct DisconnectContext * d_ctx = cls;
+ struct DisconnectMessage d_msg;
+ struct GNUNET_NAMESTORE_Handle *h = d_ctx->h;
+ int res;
+
+ d_msg.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_DISCONNECT);
+ d_msg.header.size = htons (sizeof (struct DisconnectMessage));
+ d_msg.drop = htonl (d_ctx->drop);
+
+ h->th = NULL;
+ if ((size == 0) || (buf == NULL) || (size < sizeof (struct DisconnectMessage)))
+ {
+ GNUNET_break (0);
+ res = 0;
+ }
+ else
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message to service \n", "NAMESTORE_DISCONNECT");
+ memcpy (buf, &d_msg, sizeof (struct DisconnectMessage));
+ res = sizeof (struct DisconnectMessage);
+ }
+
+ GNUNET_SCHEDULER_add_now (&clean_up_task, h);
+ GNUNET_free (d_ctx);
+ return res;
+}
+
+/**
+ * Disconnect from the namestore service (and free associated
+ * resources).
+ *
+ * @param h handle to the namestore
+ * @param drop set to GNUNET_YES to delete all data in namestore (!)
+ */
+void
+GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h, int drop)
+{
+ if (h->th != NULL)
+ {
+ GNUNET_CLIENT_notify_transmit_ready_cancel(h->th);
+ h->th = NULL;
+ }
+ if (h->client != NULL)
+ {
+ struct DisconnectContext *d_ctx = GNUNET_malloc (sizeof (struct DisconnectContext));
+ d_ctx->h = h;
+ d_ctx->drop = drop;
+
+ h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, sizeof (struct DisconnectMessage),
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_NO, &transmit_disconnect_to_namestore,
+ d_ctx);
+ }
+ else
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Could not send disconnect notification to namestore service, we are not connected!\n");
+ if (GNUNET_YES == drop)
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "NAMESTORE will not drop content\n");
+ GNUNET_SCHEDULER_add_now (&clean_up_task, h);
+ }
}
struct PendingMessage *pe;
/* pointer to elements */
- struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key_tmp;
- struct GNUNET_NAMESTORE_RecordData *rd_tmp;
+ char * zone_key_tmp;
+ char * rd_tmp;
char * name_tmp;
size_t msg_size = 0;
- size_t name_len = strlen(name) + 1;
- uint32_t id = 0;
+ size_t name_len = 0;
+ size_t rd_ser_len = 0;
+ size_t pubkey_len = 0;
+ uint32_t rid = 0;
GNUNET_assert (NULL != h);
- id = get_op_id(h);
+ GNUNET_assert (NULL != zone_key);
+ GNUNET_assert (NULL != name);
+ GNUNET_assert (NULL != rd);
+ GNUNET_assert (NULL != signature);
+
+ name_len = strlen(name) + 1;
+ if (name_len > 256)
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+
+ rid = get_op_id(h);
qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry));
qe->nsh = h;
qe->cont = cont;
qe->cont_cls = cont_cls;
- qe->op_id = id;
+ qe->op_id = rid;
GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, qe);
/* set msg_size*/
+ rd_ser_len = GNUNET_NAMESTORE_records_get_size(rd_count, rd);
+ char rd_ser[rd_ser_len];
+ GNUNET_NAMESTORE_records_serialize(rd_count, rd, rd_ser_len, rd_ser);
+
+ pubkey_len = sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);
struct RecordPutMessage * msg;
- msg_size = sizeof (struct RecordPutMessage) + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) + name_len + rd_count * (sizeof (struct GNUNET_NAMESTORE_RecordData));
+ msg_size = sizeof (struct RecordPutMessage) + pubkey_len + name_len + rd_ser_len;
/* create msg here */
pe = GNUNET_malloc(sizeof (struct PendingMessage) + msg_size);
pe->size = msg_size;
pe->is_init = GNUNET_NO;
msg = (struct RecordPutMessage *) &pe[1];
- zone_key_tmp = (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *) &msg[1];
- name_tmp = (char *) &zone_key_tmp[1];
- rd_tmp = (struct GNUNET_NAMESTORE_RecordData *) &name_tmp[name_len];
-
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_PUT);
- msg->header.size = htons (msg_size);
- msg->op_id = htonl (id);
- memcpy (zone_key_tmp, zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+ zone_key_tmp = (char *) &msg[1];
+ name_tmp = (char *) &zone_key_tmp[pubkey_len];
+ rd_tmp = &name_tmp[name_len];
+
+ msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_PUT);
+ msg->gns_header.header.size = htons (msg_size);
+ msg->gns_header.r_id = htonl (rid);
+ msg->key_len = htons (pubkey_len);
+ memcpy (zone_key_tmp, zone_key, pubkey_len);
msg->signature = *signature;
msg->name_len = htons (name_len);
memcpy (name_tmp, name, name_len);
msg->expire = GNUNET_TIME_absolute_hton (expire);
- msg->rd_count = htonl(rd_count);
- memcpy (rd_tmp, rd, rd_count * (sizeof (struct GNUNET_NAMESTORE_RecordData)));
+ msg->rd_len = htons (rd_ser_len);
+ msg->rd_count = htons (rd_count);
+
+ memcpy (rd_tmp, rd_ser, rd_ser_len);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for name `%s' with size %u\n", "NAMESTORE_RECORD_PUT", name, msg_size);
const struct GNUNET_NAMESTORE_RecordData *rd,
const struct GNUNET_CRYPTO_RsaSignature *signature)
{
- return GNUNET_SYSERR;
+ int res = GNUNET_SYSERR;
+ size_t rd_ser_len = 0;
+ size_t name_len = 0;
+ char * name_tmp;
+ char * rd_tmp;
+ struct GNUNET_CRYPTO_RsaSignaturePurpose *sig_purpose;
+
+ GNUNET_assert (public_key != NULL);
+ GNUNET_assert (name != NULL);
+ GNUNET_assert (signature != NULL);
+
+ rd_ser_len = GNUNET_NAMESTORE_records_get_size(rd_count, rd);
+ char rd_ser[rd_ser_len];
+ GNUNET_NAMESTORE_records_serialize(rd_count, rd, rd_ser_len, rd_ser);
+
+ name_len = strlen (name) + 1;
+
+ sig_purpose = GNUNET_malloc(sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) + rd_ser_len + name_len);
+ sig_purpose->size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose)+ rd_ser_len + name_len);
+ sig_purpose->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
+ name_tmp = (char *) &sig_purpose[1];
+ rd_tmp = &name_tmp[name_len];
+ memcpy (name_tmp, name, name_len);
+ memcpy (rd_tmp, rd_ser, rd_ser_len);
+
+ res = GNUNET_CRYPTO_rsa_verify(GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN, sig_purpose, signature, public_key);
+
+ GNUNET_free (sig_purpose);
+
+ return res;
}
/**
{
struct GNUNET_NAMESTORE_QueueEntry *qe;
struct PendingMessage *pe;
- struct GNUNET_NAMESTORE_RecordData * rd_tmp;
char * name_tmp;
+ char * pkey_tmp;
+ char * rd_tmp;
+ size_t rd_ser_len = 0;
size_t msg_size = 0;
size_t name_len = 0;
- uint32_t id = 0;
+ size_t key_len = 0;
+ uint32_t rid = 0;
GNUNET_assert (NULL != h);
+ GNUNET_assert (NULL != pkey);
+ GNUNET_assert (NULL != name);
+ GNUNET_assert (NULL != rd);
- id = get_op_id(h);
+ name_len = strlen(name) + 1;
+ if (name_len > 256)
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+
+ rid = get_op_id(h);
qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry));
qe->nsh = h;
qe->cont = cont;
qe->cont_cls = cont_cls;
- qe->op_id = id;
+ qe->op_id = rid;
+ GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, qe);
/* set msg_size*/
+ struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded * pkey_enc = GNUNET_CRYPTO_rsa_encode_key (pkey);
+ GNUNET_assert (pkey_enc != NULL);
+ key_len = ntohs (pkey_enc->len);
+
+ rd_ser_len = GNUNET_NAMESTORE_records_get_size(1, rd);
+ char rd_ser[rd_ser_len];
+ GNUNET_NAMESTORE_records_serialize(1, rd, rd_ser_len, rd_ser);
+
struct RecordCreateMessage * msg;
- msg_size = sizeof (struct RecordCreateMessage) + name_len + sizeof (struct GNUNET_NAMESTORE_RecordData);
+ msg_size = sizeof (struct RecordCreateMessage) + key_len + name_len + rd_ser_len;
/* create msg here */
pe = GNUNET_malloc(sizeof (struct PendingMessage) + msg_size);
pe->is_init = GNUNET_NO;
msg = (struct RecordCreateMessage *) &pe[1];
- name_tmp = (char *) &msg[1];
- rd_tmp = (struct GNUNET_NAMESTORE_RecordData *) &name_tmp[name_len];
+ pkey_tmp = (char *) &msg[1];
+ name_tmp = &pkey_tmp[key_len];
+ rd_tmp = &name_tmp[name_len];
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_CREATE);
- msg->header.size = htons (msg_size);
- msg->op_id = htonl (id);
- //msg->signature = *signature;
+ msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_CREATE);
+ msg->gns_header.header.size = htons (msg_size);
+ msg->gns_header.r_id = htonl (rid);
msg->name_len = htons (name_len);
+ msg->rd_count = htons (1);
+ msg->rd_len = htons (rd_ser_len);
+ msg->pkey_len = htons (key_len);
+ memcpy (pkey_tmp, pkey_enc, key_len);
memcpy (name_tmp, name, name_len);
- memcpy (rd_tmp, rd, sizeof (struct GNUNET_NAMESTORE_RecordData));
+ memcpy (rd_tmp, rd_ser, rd_ser_len);
+ GNUNET_free (pkey_enc);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for name `%s' with size %u\n", "NAMESTORE_RECORD_CREATE", name, msg_size);
{
struct GNUNET_NAMESTORE_QueueEntry *qe;
struct PendingMessage *pe;
- struct GNUNET_NAMESTORE_RecordData * rd_tmp;
- char * name_tmp;
+ char *pkey_tmp;
+ char *rd_tmp;
+ char *name_tmp;
+ size_t rd_ser_len = 0;
size_t msg_size = 0;
size_t name_len = 0;
- uint32_t id = 0;
+ size_t key_len = 0;
+ uint32_t rid = 0;
GNUNET_assert (NULL != h);
- id = get_op_id(h);
+ rid = get_op_id(h);
qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry));
qe->nsh = h;
qe->cont = cont;
qe->cont_cls = cont_cls;
- qe->op_id = id;
+ qe->op_id = rid;
+ GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, qe);
/* set msg_size*/
+ struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded * pkey_enc = GNUNET_CRYPTO_rsa_encode_key (pkey);
+ GNUNET_assert (pkey_enc != NULL);
+ key_len = ntohs (pkey_enc->len);
+
+ rd_ser_len = GNUNET_NAMESTORE_records_get_size(1, rd);
+ char rd_ser[rd_ser_len];
+ GNUNET_NAMESTORE_records_serialize(1, rd, rd_ser_len, rd_ser);
+
+ name_len = strlen (name) + 1;
+
struct RecordRemoveMessage * msg;
- msg_size = sizeof (struct RecordRemoveMessage) + name_len + sizeof (struct GNUNET_NAMESTORE_RecordData);
+ msg_size = sizeof (struct RecordRemoveMessage) + key_len + name_len + rd_ser_len;
/* create msg here */
pe = GNUNET_malloc(sizeof (struct PendingMessage) + msg_size);
pe->is_init = GNUNET_NO;
msg = (struct RecordRemoveMessage *) &pe[1];
- name_tmp = (char *) &msg[1];
- rd_tmp = (struct GNUNET_NAMESTORE_RecordData *) &name_tmp[name_len];
+ pkey_tmp = (char *) &msg[1];
+ name_tmp = &pkey_tmp[key_len];
+ rd_tmp = &name_tmp[name_len];
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_REMOVE);
- msg->header.size = htons (msg_size);
- msg->op_id = htonl (id);
- //msg->signature = *signature;
+ msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_REMOVE);
+ msg->gns_header.header.size = htons (msg_size);
+ msg->gns_header.r_id = htonl (rid);
msg->name_len = htons (name_len);
+ msg->rd_len = htons (rd_ser_len);
+ msg->rd_count = htons (1);
+ msg->key_len = htons (key_len);
+ memcpy (pkey_tmp, pkey_enc, key_len);
memcpy (name_tmp, name, name_len);
- memcpy (rd_tmp, rd, sizeof (struct GNUNET_NAMESTORE_RecordData));
+ memcpy (rd_tmp, rd_ser, rd_ser_len);
+
+ GNUNET_free (pkey_enc);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for name `%s' with size %u\n", "NAMESTORE_RECORD_REMOVE", name, msg_size);
struct PendingMessage *pe;
size_t msg_size = 0;
size_t name_len = 0;
- uint32_t id = 0;
+ uint32_t rid = 0;
GNUNET_assert (NULL != h);
GNUNET_assert (NULL != zone);
return NULL;
}
- id = get_op_id(h);
+ rid = get_op_id(h);
qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry));
qe->nsh = h;
qe->proc = proc;
qe->proc_cls = proc_cls;
- qe->op_id = id;
+ qe->op_id = rid;
GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, qe);
/* set msg_size*/
pe->size = msg_size;
pe->is_init = GNUNET_NO;
msg = (struct LookupNameMessage *) &pe[1];
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME);
- msg->header.size = htons (msg_size);
- msg->op_id = htonl (id);
+ msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME);
+ msg->gns_header.header.size = htons (msg_size);
+ msg->gns_header.r_id = htonl (rid);
msg->record_type = htonl (record_type);
msg->zone = *zone;
msg->name_len = htonl (name_len);
struct GNUNET_NAMESTORE_ZoneIterator *it;
struct PendingMessage *pe;
size_t msg_size = 0;
- uint32_t id = 0;
+ uint32_t rid = 0;
GNUNET_assert (NULL != h);
GNUNET_assert (NULL != zone);
- id = get_op_id(h);
+ rid = get_op_id(h);
it = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_ZoneIterator));
it->h = h;
it->proc = proc;
it->proc_cls = proc;
- it->op_id = id;
+ it->op_id = rid;
it->zone = *zone;
GNUNET_CONTAINER_DLL_insert_tail(h->z_head, h->z_tail, it);
pe->size = msg_size;
pe->is_init = GNUNET_NO;
msg = (struct ZoneIterationStartMessage *) &pe[1];
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START);
- msg->header.size = htons (msg_size);
- msg->op_id = htonl (id);
+ msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START);
+ msg->gns_header.header.size = htons (msg_size);
+ msg->gns_header.r_id = htonl (rid);
msg->zone = *zone;
msg->must_have_flags = ntohs (must_have_flags);
msg->must_not_have_flags = ntohs (must_not_have_flags);
pe->size = msg_size;
pe->is_init = GNUNET_NO;
msg = (struct ZoneIterationNextMessage *) &pe[1];
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT);
- msg->header.size = htons (msg_size);
- msg->op_id = htonl (it->op_id);
+ msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT);
+ msg->gns_header.header.size = htons (msg_size);
+ msg->gns_header.r_id = htonl (it->op_id);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for name `%s'\n", "ZONE_ITERATION_NEXT", GNUNET_h2s(&it->zone));
pe->size = msg_size;
pe->is_init = GNUNET_NO;
msg = (struct ZoneIterationStopMessage *) &pe[1];
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP);
- msg->header.size = htons (msg_size);
- msg->op_id = htonl (it->op_id);
+ msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP);
+ msg->gns_header.header.size = htons (msg_size);
+ msg->gns_header.r_id = htonl (it->op_id);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' message for name `%s'\n", "ZONE_ITERATION_STOP", GNUNET_h2s(&it->zone));
projects / oweals / gnunet.git / blobdiff