General uint encoding

Author: PJK

misc/bytes.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+puts $*[0][2..-1].split('').each_slice(2).map {|_| '0x%02X' % _.join.to_i(16) }.join(', ')

src/cbor_encoders.c

@@ -50,17 +50,44 @@ size_t cbor_encode_uint32(uint32_t value, unsigned char * buffer, size_t buffer_
 		buffer[4] = value;
 	#endif
 
-		return 3;
+		return 5;
 	} else
 		return 0;
 }
 
 size_t cbor_encode_uint64(uint64_t value, unsigned char * buffer, size_t buffer_size)
 {
+	if (buffer_size >= 9) {
+		buffer[0] = 0x1B;
+
+	#if defined(__clang__) || defined(__GNUC__)
+		*(uint64_t *)&buffer[1] = __builtin_bswap64(value);
+	#else
+		buffer[1] = value >> 56;
+		buffer[2] = value >> 48;
+		buffer[3] = value >> 40;
+		buffer[4] = value >> 32;
+		buffer[5] = value >> 24;
+		buffer[6] = value >> 16;
+		buffer[7] = value >> 8;
+		buffer[8] = value;
+	#endif
 
+		return 9;
+	} else
+		return 0;
 }
 
 size_t cbor_encode_uint(uint64_t value, unsigned char * buffer, size_t buffer_size)
 {
-
+	if (value <= UINT16_MAX)
+		if (value <= UINT8_MAX)
+			return cbor_encode_uint8((uint8_t)value, buffer, buffer_size);
+		else
+			return cbor_encode_uint16((uint16_t)value, buffer, buffer_size);
+	else
+		if (value <= UINT32_MAX)
+			return cbor_encode_uint32((uint32_t)value, buffer, buffer_size);
+		else
+			return cbor_encode_uint64((uint64_t)value, buffer, buffer_size);
 }

test/type_0_encoders_test.c

@@ -10,19 +10,53 @@
 unsigned char buffer[512];
 
 static void test_embedded_uint8(void **state) {
-	cbor_encode_uint8(14, buffer, 512);
+	assert_int_equal(1, cbor_encode_uint8(14, buffer, 512));
 	assert_memory_equal(buffer, (unsigned char[]){ 0x0E }, 1);
 }
 
+static void test_uint8(void **state) {
+	assert_int_equal(0, cbor_encode_uint8(180, buffer, 1));
+	assert_int_equal(2, cbor_encode_uint8(255, buffer, 512));
+	assert_memory_equal(buffer, ((unsigned char[]){ 0x18, 0xFF }), 2);
+}
+
 static void test_uint16(void **state) {
-	cbor_encode_uint16(1000, buffer, 512);
+	assert_int_equal(0, cbor_encode_uint16(1000, buffer, 2));
+	assert_int_equal(3, cbor_encode_uint16(1000, buffer, 512));
+	assert_memory_equal(buffer, ((unsigned char[]){ 0x19, 0x03, 0xE8 }), 3);
+}
+
+static void test_uint32(void **state) {
+	assert_int_equal(0, cbor_encode_uint32(1000000, buffer, 4));
+	assert_int_equal(5, cbor_encode_uint32(1000000, buffer, 512));
+	assert_memory_equal(buffer, ((unsigned char[]){ 0x1A, 0x00, 0x0F, 0x42, 0x40 }), 5);
+}
+
+static void test_uint64(void **state) {
+	assert_int_equal(0, cbor_encode_uint64(18446744073709551615ULL, buffer, 8));
+	assert_int_equal(9, cbor_encode_uint64(18446744073709551615ULL, buffer, 512));
+	assert_memory_equal(buffer, ((unsigned char[]){ 0x1B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }), 9);
+}
+
+static void test_unspecified(void **state) {
+	assert_int_equal(9, cbor_encode_uint(18446744073709551615ULL, buffer, 512));
+	assert_memory_equal(buffer, ((unsigned char[]){ 0x1B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }), 9);
+	assert_int_equal(5, cbor_encode_uint(1000000, buffer, 512));
+	assert_memory_equal(buffer, ((unsigned char[]){ 0x1A, 0x00, 0x0F, 0x42, 0x40 }), 5);
+	assert_int_equal(3, cbor_encode_uint(1000, buffer, 512));
 	assert_memory_equal(buffer, ((unsigned char[]){ 0x19, 0x03, 0xE8 }), 3);
+	assert_int_equal(2, cbor_encode_uint(255, buffer, 512));
+	assert_memory_equal(buffer, ((unsigned char[]){ 0x18, 0xFF }), 2);
 }
 
 int main(void) {
 	const UnitTest tests[] = {
 		unit_test(test_embedded_uint8),
-		unit_test(test_uint16)
+		unit_test(test_uint8),
+		unit_test(test_uint16),
+		unit_test(test_uint32),
+		unit_test(test_uint64),
+		unit_test(test_unspecified)
 	};
 	return run_tests(tests);
 }