libqaeda

commit 4ffcbd833ad5bd206e5c7860e91ae015e414ee97
parent 5def2300e1a3052a8e32d4928a82994d97344831
Author: lash <dev@holbrook.no>
Date:   Sat, 19 Apr 2025 13:34:44 +0100

Add method to set literal state

Diffstat:
M
src/lq/msg.c
 | 
24
++++++++++++++----------
M
src/lq/msg.h
 | 
10
++++++++++
M
src/test/test_msg.c
 | 
41
++++++++++++++++++++++++++++++++++++++++-

3 files changed, 64 insertions(+), 11 deletions(-)
diff --git a/src/lq/msg.c b/src/lq/msg.c
@@ -32,12 +32,19 @@ LQMsg* lq_msg_new(const char *msg_data, size_t msg_len) {
 	msg->data = lq_alloc(msg_len);
 	lq_cpy(msg->data, msg_data, msg_len);
 	msg->len = msg_len;
-	//msg->state = LQ_MSG_INIT;
-	msg->state = LQ_MSG_INIT | LQ_MSG_LITERAL;
+	msg->state = LQ_MSG_INIT;
 
 	return msg;
 }
 
+int lq_msg_literal(LQMsg *msg) {
+	if (msg->state & LQ_MSG_LITERAL) {
+		return ERR_NOOP;
+	}
+	msg->state |= LQ_MSG_LITERAL;
+	return ERR_OK;
+}
+
 LQSig* lq_msg_sign(LQMsg *msg, LQPrivKey *pk, const char *salt) {
 	return lq_msg_sign_extra(msg, pk, salt, NULL, 0);
 }
@@ -198,7 +205,6 @@ int lq_msg_serialize(LQMsg *msg, LQResolve *resolve, char *out, size_t *out_len)
 		c = 1;
 	}
 
-
 	r = asn1_write_value(item, "Msg.data", tmp, c);
 	if (r != ASN1_SUCCESS) {
 		return asn_except(&item, ERR_WRITE);
@@ -262,11 +268,10 @@ int lq_msg_deserialize(LQMsg **msg, LQResolve *resolve, const char *in, size_t i
 	int r;
 	size_t c;
 	size_t l;
-	char v[6];
 	char resolved;
 	char err[LQ_ERRSIZE];
-	char z[LQ_DIGEST_LEN];
 	char tmp[LQ_BLOCKSIZE];
+	char z[LQ_DIGEST_LEN];
 	char *p;
 	char msg_state;
 	asn1_node item;
@@ -288,18 +293,17 @@ int lq_msg_deserialize(LQMsg **msg, LQResolve *resolve, const char *in, size_t i
 	}
 
 	c = 6;
-	r = asn1_read_value(item, "literal", v, (int*)&c);
+	r = asn1_read_value(item, "literal", tmp, (int*)&c);
 	if (r != ASN1_SUCCESS) {
 		debug_logerr(LLOG_WARNING, ERR_READ, (char*)asn1_strerror(r));
 		return asn_except(&item, ERR_READ);
 	}
-	if (lq_cmp(v, "F", 1)) {
+	if (lq_cmp(tmp, "F", 1)) {
 		msg_state |= LQ_MSG_LITERAL;
 	}
 
-	//c = LQ_DIGEST_LEN;
 	c = LQ_BLOCKSIZE;
-	r = asn1_read_value(item, "data", z, (int*)&c);
+	r = asn1_read_value(item, "data", tmp, (int*)&c);
 	if (r != ASN1_SUCCESS) {
 		debug_logerr(LLOG_WARNING, ERR_READ, (char*)asn1_strerror(r));
 		return asn_except(&item, ERR_READ);
@@ -313,9 +317,9 @@ int lq_msg_deserialize(LQMsg **msg, LQResolve *resolve, const char *in, size_t i
 
 	if (!(msg_state & LQ_MSG_LITERAL)) {
 		resolve_active = resolve;
-		lq_cpy(tmp, z, c);
 		l = c;
 		c = LQ_BLOCKSIZE;
+		lq_cpy(z, tmp, LQ_DIGEST_LEN);
 		while (resolve_active != NULL) {
 			r = resolve_active->store->get(LQ_CONTENT_MSG, resolve_active->store, z, LQ_DIGEST_LEN, tmp, &c);
 			if (r != ERR_OK) {
diff --git a/src/lq/msg.h b/src/lq/msg.h
@@ -113,6 +113,16 @@ int lq_msg_serialize(LQMsg *msg, LQResolve *resolve, char *out, size_t *out_len)
 int lq_msg_deserialize(LQMsg **msg, LQResolve *resolve, const char *in, size_t in_len);
 
 /**
+ * \brief Mark message content as literal.
+ *
+ * In this case, the data of the message will be stored directly, instead of its hash.
+ *
+ * \param[in] Message to manipulate.
+ * \return ERR_OK if succesfully set, ERR_NOOP if already set.
+ */
+int lq_msg_literal(LQMsg *msg);
+
+/**
  * \brief Free an instantiated message.
  *
  * \param[in] Message to free.
diff --git a/src/test/test_msg.c b/src/test/test_msg.c
@@ -7,6 +7,7 @@
 #include "lq/io.h"
 #include "lq/mem.h"
 #include "lq/base.h"
+#include "lq/err.h"
 
 extern LQStore LQDummyContent;
 extern LQStore LQFileContent;
@@ -52,13 +53,51 @@ START_TEST(check_msg_symmetric) {
 }
 END_TEST
 
+START_TEST(check_msg_symmetric_literal) {
+	int r;
+	size_t c;
+	char buf[4096];
+	char path[1024];
+	char *p;
+	LQMsg *msg;
+	LQResolve resolve;
+	LQResolve resolve_dummy;
+	LQStore *store;
+
+	lq_cpy(path, "/tmp/lqstore_file_XXXXXX", 25);
+	p = mktempdir(path);
+	*(p+24) = '/';
+	*(p+25) = 0x0;
+	store = lq_store_new(p);
+	ck_assert_ptr_nonnull(store->userdata);
+
+	msg = lq_msg_new(data, strlen(data) + 1);
+	r = lq_msg_literal(msg);
+	ck_assert_int_eq(r, ERR_OK);
+	r = lq_msg_literal(msg);
+	ck_assert_int_eq(r, ERR_NOOP);
+	msg->pubkey = lq_publickey_new(data);
+
+	c = LQ_BLOCKSIZE;
+	r = lq_msg_serialize(msg, &resolve, buf, &c);
+	ck_assert_int_eq(r, 0);
+	lq_msg_free(msg);
+
+	r = lq_msg_deserialize(&msg, &resolve, buf, c);
+	ck_assert_ptr_nonnull(msg);
+	ck_assert_mem_eq(msg->data, data, strlen(data) + 1);
+	ck_assert_int_eq(r, 0);
+	lq_msg_free(msg);
+}
+END_TEST
 Suite * common_suite(void) {
 	Suite *s;
 	TCase *tc;
 
 	s = suite_create("msg");
 	tc = tcase_create("serialize");
-	tcase_add_test(tc, check_msg_symmetric);
+//	tcase_add_test(tc, check_msg_symmetric);
+	tcase_add_test(tc, check_msg_symmetric_literal);
 	suite_add_tcase(s, tc);
 
 	return s;