rlp: add eth_rlp_uint

docs/rlp.rst

@@ -6,6 +6,7 @@ RLP functions
 .. doxygenfunction:: eth_rlp_uint16
 .. doxygenfunction:: eth_rlp_uint32
 .. doxygenfunction:: eth_rlp_uint64
+.. doxygenfunction:: eth_rlp_uint
 .. doxygenfunction:: eth_rlp_address
 .. doxygenfunction:: eth_rlp_array
 .. doxygenfunction:: eth_rlp_array_end

include/ethc/rlp.h

@@ -31,6 +31,18 @@ ETHC_EXPORT int eth_rlp_uint8(struct eth_rlp *rlp, uint8_t *d);
 ETHC_EXPORT int eth_rlp_uint16(struct eth_rlp *rlp, uint16_t *d);
 ETHC_EXPORT int eth_rlp_uint32(struct eth_rlp *rlp, uint32_t *d);
 ETHC_EXPORT int eth_rlp_uint64(struct eth_rlp *rlp, uint64_t *d);
+
+/*!
+ * @brief Encodes/decodes at most 64 bit unsigned integer.
+ * @details The difference between this function and `eth_rlp_uint64` is that,
+ *          `eth_rlp_uint64` reads exactly 8 bytes from the integer, while this
+ *          function will read bytes based on the size of the integer.
+ *
+ * @param[in] rlp Target rlp.
+ * @param[inout] d Ponter to uint64_t to read/write the data from/to.
+ * @return `1` on success, `-1` otherwise.
+ */
+ETHC_EXPORT int eth_rlp_uint(struct eth_rlp *rlp, uint64_t *d);
 ETHC_EXPORT int eth_rlp_address(struct eth_rlp *rlp, char **addr);
 ETHC_EXPORT int eth_rlp_array(struct eth_rlp *rlp);
 ETHC_EXPORT int eth_rlp_array_end(struct eth_rlp *rlp);

src/rlp.c

@@ -432,6 +432,47 @@ int eth_rlp_uint64(struct eth_rlp *rlp, uint64_t *d) {
   return -1;
 }
 
+int eth_rlp_uint(struct eth_rlp *rlp, uint64_t *d) {
+  size_t offset, len;
+  uint8_t base;
+
+  if (rlp->m == ETH_RLP_ENCODE) {
+    if (*d <= 0xff) {
+      return eth_rlp_uint8(rlp, (uint8_t*)d);
+    } else if (*d <= 0xffff) {
+      return eth_rlp_uint16(rlp, (uint16_t*)d);
+    } else if (*d <= 0xffffffff) {
+      return eth_rlp_uint32(rlp, (uint32_t*)d);
+    } else if (*d <= 0xffffffffffffffff) {
+      return eth_rlp_uint64(rlp, d);
+    }
+
+    return -1;
+  }
+
+  if (rlp->m == ETH_RLP_DECODE) {
+    offset = rlp->cframe->offset;
+
+    if (eth_rlp_len(rlp, &len, &base) <= 0)
+      return -1;
+
+    rlp->cframe->offset = offset;
+
+    if (len <= 1)
+      return eth_rlp_uint8(rlp, (uint8_t*)d);
+    else if (len <= 2)
+      return eth_rlp_uint16(rlp, (uint16_t*)d);
+    else if (len <= 4)
+      return eth_rlp_uint32(rlp, (uint32_t*)d);
+    else if (len <= 8)
+      return eth_rlp_uint64(rlp, (uint64_t*)d);
+
+    return -1;
+  }
+
+  return -1;
+}
+
 int eth_rlp_address(struct eth_rlp *rlp, char **addr) {
   int hexlen;
 

test/run-tests.c

@@ -51,6 +51,7 @@ int main() {
   test_eth_rlp_uint16();
   test_eth_rlp_uint32();
   test_eth_rlp_uint64();
+  test_eth_rlp_uint();
   test_eth_rlp_bytes();
   test_eth_rlp_hex();
   test_eth_rlp_address();

test/test-eth-rlp.c

@@ -106,6 +106,30 @@ void test_eth_rlp_uint64(void) {
   ok(d1 == 0x79d27c6d2d1fb824);
 }
 
+void test_eth_rlp_uint(void) {
+  struct eth_rlp rlp0, rlp1;
+  uint64_t d0=0x9c797e11, d1 = 0;
+  char *hex;
+
+  ok(eth_rlp_init(&rlp0, ETH_RLP_ENCODE) == 1);
+
+  ok(eth_rlp_array(&rlp0) == 1);
+    ok(eth_rlp_uint(&rlp0, &d0) == 1);
+  ok(eth_rlp_array_end(&rlp0) == 1);
+
+  ok(eth_rlp_to_hex(&hex, &rlp0) == 12);
+  is(hex, "c5849c797e11");
+  ok(eth_rlp_free(&rlp0) == 1);
+  free(hex);
+
+  ok(eth_rlp_from_hex(&rlp1, "0xc38101", -1) == 1);
+  ok(eth_rlp_array(&rlp1) == 1);
+    ok(eth_rlp_uint(&rlp1, &d1) == 1);
+  ok(eth_rlp_array_end(&rlp1) == 1);
+  ok(eth_rlp_free(&rlp1) == 1);
+  ok(d1 == 0x01);
+}
+
 void test_eth_rlp_bytes(void) {
   struct eth_rlp rlp0, rlp1;
   uint8_t d0[] = {0x8f, 0x70}, *b0 = d0, *b1,

test/test.h

@@ -52,6 +52,7 @@ void test_eth_rlp_uint8(void);
 void test_eth_rlp_uint16(void);
 void test_eth_rlp_uint32(void);
 void test_eth_rlp_uint64(void);
+void test_eth_rlp_uint(void);
 void test_eth_rlp_address(void);
 void test_eth_rlp_bytes(void);
 void test_eth_rlp_hex(void);