static void
test_no_nul_byte(void)
{
struct sol_buffer buf;
int32_t backend;
int32_t value = 0xdeadbeef;
int err;
sol_buffer_init_flags(&buf, &backend, sizeof(backend),
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED | SOL_BUFFER_FLAGS_NO_NUL_BYTE);
err = sol_buffer_ensure(&buf, sizeof(int32_t));
ASSERT_INT_EQ(err, 0);
err = sol_buffer_append_slice(&buf, SOL_STR_SLICE_STR((const char *)&value, sizeof(value)));
ASSERT_INT_EQ(err, 0);
err = sol_buffer_append_slice(&buf, SOL_STR_SLICE_STR((const char *)&value, sizeof(value)));
ASSERT_INT_NE(err, 0);
sol_buffer_fini(&buf);
sol_buffer_init_flags(&buf, NULL, 0, SOL_BUFFER_FLAGS_NO_NUL_BYTE);
err = sol_buffer_append_printf(&buf, "123");
ASSERT_INT_EQ(err, 0);
err = sol_buffer_append_printf(&buf, "4");
ASSERT_INT_EQ(err, 0);
ASSERT(sol_str_slice_eq(sol_buffer_get_slice(&buf),
SOL_STR_SLICE_STR("1234", 4)));
sol_buffer_fini(&buf);
}
SOL_API int
sol_bt_uuid_to_str(const struct sol_bt_uuid *uuid, struct sol_buffer *buffer)
{
uint32_t tmp0, tmp4;
uint16_t tmp1, tmp2, tmp3, tmp5;
struct sol_bt_uuid u = BASE_UUID;
int r;
SOL_NULL_CHECK(uuid, -EINVAL);
SOL_NULL_CHECK(buffer, -EINVAL);
uuid_to_uuid128(uuid, &u);
memcpy(&tmp0, &u.val128[0], sizeof(tmp0));
memcpy(&tmp1, &u.val128[4], sizeof(tmp1));
memcpy(&tmp2, &u.val128[6], sizeof(tmp2));
memcpy(&tmp3, &u.val128[8], sizeof(tmp3));
memcpy(&tmp4, &u.val128[10], sizeof(tmp4));
memcpy(&tmp5, &u.val128[14], sizeof(tmp5));
r = sol_buffer_append_printf(buffer, "%.8" PRIx32 "-%.4" PRIx16 "-%.4" PRIx16 "-%.4" PRIx16 "-%.8" PRIx32 "%.4" PRIx16,
sol_util_cpu_to_be32(tmp0), sol_util_cpu_to_be16(tmp1),
sol_util_cpu_to_be16(tmp2), sol_util_cpu_to_be16(tmp3),
sol_util_cpu_to_be32(tmp4), sol_util_cpu_to_be16(tmp5));
return r ? -errno : 0;
}
SOL_API int
sol_json_double_to_str(const double value, struct sol_buffer *buf)
{
int ret;
char *decimal_point, *end;
size_t used;
#ifdef HAVE_LOCALE
struct lconv *lc = localeconv();
#endif
SOL_NULL_CHECK(buf, -EINVAL);
used = buf->used;
ret = sol_buffer_append_printf(buf, "%g", value);
SOL_INT_CHECK(ret, < 0, ret);
#ifdef HAVE_LOCALE
if (lc->decimal_point && streq(lc->decimal_point, "."))
return 0;
end = (char *)buf->data + used;
if ((decimal_point = strstr(end, lc->decimal_point))) {
size_t decimal_len = strlen(lc->decimal_point);
size_t offset = decimal_point - (char *)buf->data + 1;
*decimal_point = '.';
ret = sol_buffer_remove_data(buf, offset, decimal_len - 1);
SOL_INT_CHECK(ret, < 0, ret);
}
static void
test_append_printf(void)
{
struct sol_buffer buf;
int err;
sol_buffer_init(&buf);
err = sol_buffer_append_printf(&buf, "[%03d]", 1);
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "[001]");
err = sol_buffer_append_printf(&buf, "'%s'", "This is a longer string, bla bla bla, bla bla bla");
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "[001]'This is a longer string, bla bla bla, bla bla bla'");
err = sol_buffer_append_printf(&buf, ".");
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "[001]'This is a longer string, bla bla bla, bla bla bla'.");
sol_buffer_fini(&buf);
}
SOL_API const char *
sol_network_link_addr_to_str(const struct sol_network_link_addr *addr,
struct sol_buffer *buf)
{
char *p;
int i;
bool sep = false, skipping = false, treated_zeroes = false;
SOL_NULL_CHECK(addr, NULL);
SOL_NULL_CHECK(buf, NULL);
if (sol_bluetooth_is_family(addr->family))
return sol_bluetooth_addr_to_str(addr, buf);
if (addr->family != SOL_NETWORK_FAMILY_INET6)
return NULL;
if (buf->capacity - buf->used < SOL_NETWORK_INET_ADDR_STR_LEN)
return NULL;
p = sol_buffer_at_end(buf);
for (i = 0; i < 16; i += 2) {
uint16_t part;
part = ((uint16_t)addr->addr.in6[i] << 8) | addr->addr.in6[i + 1];
if (part && skipping) {
skipping = false;
treated_zeroes = true;
sep = true;
}
if (!part && !treated_zeroes) {
if (!skipping) {
skipping = true;
sep = true;
}
}
if (sep) {
sol_buffer_append_char(buf, ':');
if (skipping)
sep = false;
}
if (skipping)
continue;
sol_buffer_append_printf(buf, "%" PRIx16, part);
sep = true;
}
if (skipping)
sol_buffer_append_char(buf, ':');
return p;
}
// 37 = 2 * 16 (chars) + 4 (hyphens) + 1 (\0)
SOL_API int
sol_util_uuid_gen(bool upcase,
bool with_hyphens,
char id[SOL_STATIC_ARRAY_SIZE(37)])
{
static struct sol_str_slice hyphen = SOL_STR_SLICE_LITERAL("-");
/* hyphens on positions 8, 13, 18, 23 (from 0) */
static const int hyphens_pos[] = { 8, 13, 18, 23 };
struct sol_uuid uuid = { { 0 } };
unsigned i;
int r;
struct sol_buffer buf = { 0 };
sol_buffer_init_flags(&buf, id, 37,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED);
r = uuid_gen(&uuid);
SOL_INT_CHECK(r, < 0, r);
for (i = 0; i < SOL_UTIL_ARRAY_SIZE(uuid.bytes); i++) {
r = sol_buffer_append_printf(&buf, upcase ? "%02hhX" : "%02hhx",
uuid.bytes[i]);
SOL_INT_CHECK_GOTO(r, < 0, err);
}
if (with_hyphens) {
for (i = 0; i < SOL_UTIL_ARRAY_SIZE(hyphens_pos); i++) {
r = sol_buffer_insert_slice(&buf, hyphens_pos[i], hyphen);
SOL_INT_CHECK_GOTO(r, < 0, err);
}
}
err:
sol_buffer_fini(&buf);
return r;
}
static int
light_resource_to_rep(const struct sol_coap_resource *resource,
bool state, struct sol_buffer *buf)
{
SOL_BUFFER_DECLARE_STATIC(buffer, 64);
int r;
r = sol_coap_uri_path_to_buf(resource->path, &buffer, 0, NULL);
SOL_INT_CHECK(r, < 0, r);
r = sol_buffer_append_printf(buf,
OC_CORE_ELEM_JSON_START, (char *)sol_buffer_steal(&buffer, NULL));
SOL_INT_CHECK(r, < 0, r);
r = sol_buffer_append_printf(buf,
OC_CORE_PROP_JSON_NUMBER, "power", 100);
SOL_INT_CHECK(r, < 0, r);
r = sol_buffer_append_printf(buf, OC_CORE_JSON_SEPARATOR);
SOL_INT_CHECK(r, < 0, r);
r = sol_buffer_append_printf(buf,
OC_CORE_PROP_JSON_STRING, "name", "Soletta LAMP!");
SOL_INT_CHECK(r, < 0, r);
r = sol_buffer_append_printf(buf, OC_CORE_JSON_SEPARATOR);
SOL_INT_CHECK(r, < 0, r);
r = sol_buffer_append_printf(buf,
OC_CORE_PROP_JSON_BOOLEAN, "state", state ? "true" : "false" );
SOL_INT_CHECK(r, < 0, r);
r = sol_buffer_append_printf(buf, OC_CORE_ELEM_JSON_END);
SOL_INT_CHECK(r, < 0, r);
return 0;
}
