static bool
reply_cb(struct sol_coap_server *server, struct sol_coap_packet *req,
const struct sol_network_link_addr *cliaddr, void *data)
{
struct sol_str_slice *path = data;
static int count;
struct sol_buffer *buf;
size_t offset;
SOL_BUFFER_DECLARE_STATIC(addr, SOL_INET_ADDR_STRLEN);
if (!req || !cliaddr) //timeout
return false;
sol_network_link_addr_to_str(cliaddr, &addr);
SOL_INF("Got response from %.*s\n", SOL_STR_SLICE_PRINT(sol_buffer_get_slice(&addr)));
sol_coap_packet_get_payload(req, &buf, &offset);
SOL_INF("Payload: %.*s\n", (int)(buf->used - offset),
(char *)sol_buffer_at(buf, offset));
if (++count == 10)
disable_observing(req, server, path, cliaddr);
return true;
}
static int
drange_to_string_convert(struct sol_flow_node *node,
void *data,
uint16_t port,
uint16_t conn_id,
const struct sol_flow_packet *packet)
{
int r;
struct sol_drange in_value;
struct string_converter *mdata = data;
struct sol_buffer out = SOL_BUFFER_INIT_EMPTY;
mdata->node = node;
r = sol_flow_packet_get_drange(packet, &in_value);
SOL_INT_CHECK(r, < 0, r);
r = do_float_markup(node, mdata->format, in_value, &out);
SOL_INT_CHECK_GOTO(r, < 0, end);
r = sol_flow_send_string_slice_packet(node,
SOL_FLOW_NODE_TYPE_FORMAT_FLOAT_TO_STRING__OUT__OUT,
sol_buffer_get_slice(&out));
end:
sol_buffer_fini(&out);
return r;
}
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);
}
static bool
on_stdin(void *data, int fd, uint32_t flags)
{
if (flags & (SOL_FD_FLAGS_ERR | SOL_FD_FLAGS_HUP)) {
fprintf(stderr, "ERROR: Something wrong happened with file descriptor: %d\n", fd);
goto err;
}
if (flags & SOL_FD_FLAGS_IN) {
int err;
value.used = 0;
/* this will loop trying to read as much data as possible to buffer. */
err = sol_util_load_file_fd_buffer(fd, &value);
if (err < 0) {
fprintf(stderr, "ERROR: failed to read from stdin: %s\n", sol_util_strerrora(-err));
goto err;
}
if (value.used == 0) {
/* no data usually means ^D on the terminal, quit the application */
puts("no data on stdin, quitting.");
sol_quit();
} else {
printf("Now serving %zd bytes:\n--BEGIN--\n%.*s\n--END--\n",
value.used, SOL_STR_SLICE_PRINT(sol_buffer_get_slice(&value)));
}
}
return true;
err:
sol_quit_with_code(EXIT_FAILURE);
return false;
}
static void
test_append_slice(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char *str = "Hello";
const char *expected_str = "HelloHello";
char *backend;
int err;
backend = strdup(str);
slice = sol_str_slice_from_str(backend);
sol_buffer_init(&buf);
err = sol_buffer_set_slice(&buf, slice);
ASSERT(err >= 0);
ASSERT_INT_EQ(buf.used, strlen(backend));
ASSERT_STR_EQ(buf.data, backend);
err = sol_buffer_append_slice(&buf, slice);
ASSERT(err >= 0);
ASSERT_INT_EQ(buf.used, strlen(expected_str));
backend[1] = 'a';
ASSERT_STR_NE(buf.data, backend);
ASSERT_STR_EQ(buf.data, expected_str);
slice = sol_buffer_get_slice(&buf);
ASSERT_INT_EQ(slice.len, buf.used);
ASSERT_STR_EQ(slice.data, buf.data);
slice = sol_buffer_get_slice_at(&buf, 2);
ASSERT_INT_EQ(slice.len, buf.used - 2);
ASSERT_STR_EQ(slice.data, (char *)buf.data + 2);
sol_buffer_fini(&buf);
free(backend);
}
//! [uart read]
static ssize_t
consumer_read_available(void *data, struct sol_uart *uart, const struct sol_buffer *buf)
{
struct sol_str_slice slice = sol_buffer_get_slice(buf);
char *sep;
sep = memchr(slice.data, '\0', slice.len);
if (!sep)
return 0; //Bytes will not be removed fom the rx buffer
//Close the UART!
if (sol_str_slice_str_contains(slice, "close")) {
sol_uart_close(uart); //This is completely safe
consumer = NULL;
printf("\n\n** Consumer **: Received the close command\n\n");
sol_quit();
} else {
printf("\n\n** Consumer ** : Received UUID %.*s\n\n",
SOL_STR_SLICE_PRINT(slice));
}
return slice.len; //slice.len bytes will be removed from the rx buffer
}
static void
test_escape_quotes(void)
{
static const struct {
const struct sol_str_slice input;
const struct sol_str_slice output;
ssize_t int_result;
enum sol_buffer_flags flags;
} escape_tests[] = {
//Cases where that copy is not necessary.
{ SOL_STR_SLICE_LITERAL("x"), SOL_STR_SLICE_LITERAL("x"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL(" x"), SOL_STR_SLICE_LITERAL("x"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL("x "), SOL_STR_SLICE_LITERAL("x"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL("'x'"), SOL_STR_SLICE_LITERAL("x"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL("\"x\""), SOL_STR_SLICE_LITERAL("x"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL(" \"x\""), SOL_STR_SLICE_LITERAL("x"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL("\"x\" "), SOL_STR_SLICE_LITERAL("x"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL(" \"x\" "), SOL_STR_SLICE_LITERAL("x"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL("'Locale'"), SOL_STR_SLICE_LITERAL("Locale"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL("\"My String\""), SOL_STR_SLICE_LITERAL("My String"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL(" \"My Stri ng\" "), SOL_STR_SLICE_LITERAL("My Stri ng"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL(" "), SOL_STR_SLICE_LITERAL(""), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL("I'm good"), SOL_STR_SLICE_LITERAL("I'm good"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL("Hello"), SOL_STR_SLICE_LITERAL("Hello"), 0,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED },
{ SOL_STR_SLICE_LITERAL("I 'like' you"), SOL_STR_SLICE_LITERAL("I like you"), 0,
SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("x'y'"), SOL_STR_SLICE_LITERAL("xy"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("x\\\"y"), SOL_STR_SLICE_LITERAL("x\"y"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("\\\'x"), SOL_STR_SLICE_LITERAL("'x"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("\\\"x"), SOL_STR_SLICE_LITERAL("\"x"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL(" \\\"x"), SOL_STR_SLICE_LITERAL("\"x"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("x\\\'y\\\"zd"), SOL_STR_SLICE_LITERAL("x'y\"zd"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("x\"y\""), SOL_STR_SLICE_LITERAL("xy"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("x\"y\"z\\\"f"), SOL_STR_SLICE_LITERAL("xyz\"f"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("\\'Locale\\'"), SOL_STR_SLICE_LITERAL("'Locale'"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("MyQuo\\\"tes"), SOL_STR_SLICE_LITERAL("MyQuo\"tes"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("MyQuo\\'tes2"), SOL_STR_SLICE_LITERAL("MyQuo'tes2"), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("\\\"Hi, I'm good\\\" "), SOL_STR_SLICE_LITERAL("\"Hi, I'm good\""), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL(" \\\"Hi, I'm good\\\" "), SOL_STR_SLICE_LITERAL("\"Hi, I'm good\""), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL(" \\\"Hi, I'm good\\\" "), SOL_STR_SLICE_LITERAL("\"Hi, I'm good\""), 0, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("\\\"Hi, I'm good\\\""), SOL_STR_SLICE_LITERAL("\"Hi, I'm good\""), 0, SOL_BUFFER_FLAGS_DEFAULT },
//Cases that should fail
{ SOL_STR_SLICE_LITERAL("Wrong\\a"), SOL_STR_SLICE_LITERAL(""), -EINVAL, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("Wrong\\ba"), SOL_STR_SLICE_LITERAL(""), -EINVAL, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("'x\""), SOL_STR_SLICE_LITERAL(""), -EINVAL, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("\"x'"), SOL_STR_SLICE_LITERAL(""), -EINVAL, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("\"x'"), SOL_STR_SLICE_LITERAL(""), -EINVAL, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("'x\""), SOL_STR_SLICE_LITERAL(""), -EINVAL, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("'x"), SOL_STR_SLICE_LITERAL(""), -EINVAL, SOL_BUFFER_FLAGS_DEFAULT },
{ SOL_STR_SLICE_LITERAL("\"x"), SOL_STR_SLICE_LITERAL(""), -EINVAL, SOL_BUFFER_FLAGS_DEFAULT },
};
size_t i;
for (i = 0; i < sol_util_array_size(escape_tests); i++) {
struct sol_buffer buf;
int r;
r = sol_util_unescape_quotes(escape_tests[i].input, &buf);
ASSERT_INT_EQ(r, escape_tests[i].int_result);
if (r < 0)
continue;
ASSERT(sol_str_slice_eq(escape_tests[i].output, sol_buffer_get_slice(&buf)));
ASSERT(buf.flags == escape_tests[i].flags);
sol_buffer_fini(&buf);
}
}
static void
test_split_urls(void)
{
#define SET_PARAMS(_url, _scheme, _user, _pass, _host, _path, _query, _fragment, _port, _result, _check_url) \
{ SOL_STR_SLICE_LITERAL(_url), { SOL_STR_SLICE_LITERAL(_scheme), SOL_STR_SLICE_LITERAL(_user), SOL_STR_SLICE_LITERAL(_pass), \
SOL_STR_SLICE_LITERAL(_host), SOL_STR_SLICE_LITERAL(_path), \
SOL_STR_SLICE_LITERAL(_query), SOL_STR_SLICE_LITERAL(_fragment), _port }, _result, _check_url }
size_t i;
int r;
static const struct {
struct sol_str_slice url;
struct sol_http_url splitted_url;
int result;
bool check_url;
} test_split[] = {
SET_PARAMS("http://[2001:db8::1]", "http", "", "", "2001:db8::1", "", "", "", 0, 0, true),
SET_PARAMS("http://*****:*****@[::1]:123/a/b?p=1&c=2#/a/b", "foo", "user", "pass", "::1", "/a/b", "p=1&c=2", "/a/b", 123, 0, true),
SET_PARAMS("foo://user@[::1]:123/a/b?p=1&c=2#/a/b", "foo", "user", "", "::1", "/a/b", "p=1&c=2", "/a/b", 123, 0, true),
SET_PARAMS("foo://user:@[::1]:123/a/b?p=1&c=2#/a/b", "foo", "user", "", "::1", "/a/b", "p=1&c=2", "/a/b", 123, 0, false),
SET_PARAMS("foo://[::1]:123/a/b?p=1&c=2#/a/b", "foo", "", "", "::1", "/a/b", "p=1&c=2", "/a/b", 123, 0, true),
SET_PARAMS("foo://[::1]/a/b?p=1&c=2#/a/b", "foo", "", "", "::1", "/a/b", "p=1&c=2", "/a/b", 0, 0, true),
SET_PARAMS("foo://[::1]/?p=1&c=2#/a/b", "foo", "", "", "::1", "/", "p=1&c=2", "/a/b", 0, 0, true),
SET_PARAMS("foo://[::1]/?p=1&c=2", "foo", "", "", "::1", "/", "p=1&c=2", "", 0, 0, true),
SET_PARAMS("foo://[::1]/#/a/b", "foo", "", "", "::1", "/", "", "/a/b", 0, 0, true),
SET_PARAMS("foo://[::1]?p=1&c=2", "foo", "", "", "::1", "", "p=1&c=2", "", 0, 0, true),
SET_PARAMS("foo://[::1]#/a/b", "foo", "", "", "::1", "", "", "/a/b", 0, 0, true),
SET_PARAMS("foo://[::1]:123/#/a/b", "foo", "", "", "::1", "/", "", "/a/b", 123, 0, true),
SET_PARAMS("file://[::1]/usr/home/user/hi.txt", "file", "", "", "::1", "/usr/home/user/hi.txt", "", "", 0, 0, true),
SET_PARAMS("foo://[::1]/?go", "foo", "", "", "::1", "/", "go", "", 0, 0, true),
SET_PARAMS("foo://:password@[::1]", "foo", "", "password", "::1", "", "", "", 0, 0, true),
SET_PARAMS("foo://:@[::1]", "foo", "", "", "::1", "", "", "", 0, 0, false),
SET_PARAMS("foo://@[::1]", "foo", "", "", "::1", "", "", "", 0, 0, false),
SET_PARAMS("www.intel.com.br", "", "", "", "", "", "", "", 0, -EINVAL, false),
SET_PARAMS(":www.intel.com", "", "", "", "", "", "", "", 0, -EINVAL, false),
SET_PARAMS("//www.intel.com", "", "", "", "", "", "", "", 0, -EINVAL, false),
SET_PARAMS("://www.intel.com", "", "", "", "", "", "", "", 0, -EINVAL, false),
SET_PARAMS("/a/b", "", "", "", "", "", "", "", 0, -EINVAL, false),
SET_PARAMS("//a/b", "", "", "", "", "", "", "", 0, -EINVAL, false),
SET_PARAMS("http://", "", "", "", "", "", "", "", 0, -EINVAL, false),
SET_PARAMS("http://www.intel.com:/", "http", "", "", "www.intel.com", "/", "", "", 0, 0, false),
SET_PARAMS("http://intel.com/?go=2", "http", "", "", "intel.com", "/", "go=2", "", 0, 0, true),
SET_PARAMS("http://www.intel.com:8080", "http", "", "", "www.intel.com", "", "", "", 8080, 0, true),
SET_PARAMS("http://www.intel.com:1234/", "http", "", "", "www.intel.com", "/", "", "", 1234, 0, true),
SET_PARAMS("http://www.intel.com/a/b/d?go=2#fragment", "http", "", "", "www.intel.com", "/a/b/d", "go=2", "fragment", 0, 0, true),
SET_PARAMS("foo://*****:*****@server.com:123/a/b?p=1&c=2#/a/b", "foo", "user", "pass", "server.com", "/a/b", "p=1&c=2", "/a/b", 123, 0, true),
SET_PARAMS("foo://[email protected]:123/a/b?p=1&c=2#/a/b", "foo", "user", "", "server.com", "/a/b", "p=1&c=2", "/a/b", 123, 0, true),
/* Do not check the created url for this one, Altought the created one will be correct it will not match,
as the create url will be foo://user:@server.com:123/a/b?p=1&c=2#/a/b
This behaviour is acceptable, since ':' can be ommited if the password is not provided.
*/
SET_PARAMS("foo://user:@server.com:123/a/b?p=1&c=2#/a/b", "foo", "user", "", "server.com", "/a/b", "p=1&c=2", "/a/b", 123, 0, false),
SET_PARAMS("foo://server.com:123/a/b?p=1&c=2#/a/b", "foo", "", "", "server.com", "/a/b", "p=1&c=2", "/a/b", 123, 0, true),
SET_PARAMS("foo://server.com/a/b?p=1&c=2#/a/b", "foo", "", "", "server.com", "/a/b", "p=1&c=2", "/a/b", 0, 0, true),
SET_PARAMS("foo://server.com/?p=1&c=2#/a/b", "foo", "", "", "server.com", "/", "p=1&c=2", "/a/b", 0, 0, true),
SET_PARAMS("foo://server.com/?p=1&c=2", "foo", "", "", "server.com", "/", "p=1&c=2", "", 0, 0, true),
SET_PARAMS("foo://server.com/#/a/b", "foo", "", "", "server.com", "/", "", "/a/b", 0, 0, true),
SET_PARAMS("foo://server.com?p=1&c=2", "foo", "", "", "server.com", "", "p=1&c=2", "", 0, 0, true),
SET_PARAMS("foo://server.com#/a/b", "foo", "", "", "server.com", "", "", "/a/b", 0, 0, true),
SET_PARAMS("foo://192.3.3.3:123/#/a/b", "foo", "", "", "192.3.3.3", "/", "", "/a/b", 123, 0, true),
SET_PARAMS("mailto:[email protected]", "mailto", "", "", "", "*****@*****.**", "", "", 0, 0, true),
SET_PARAMS("file://localhost/usr/home/user/hi.txt", "file", "", "", "localhost", "/usr/home/user/hi.txt", "", "", 0, 0, true),
SET_PARAMS("foo://localhost/?go", "foo", "", "", "localhost", "/", "go", "", 0, 0, true),
SET_PARAMS("foo://:password@localhost", "foo", "", "password", "localhost", "", "", "", 0, 0, true),
SET_PARAMS("foo://:@localhost", "foo", "", "", "localhost", "", "", "", 0, 0, false),
SET_PARAMS("foo://@localhost", "foo", "", "", "localhost", "", "", "", 0, 0, false),
};
for (i = 0; i < SOL_UTIL_ARRAY_SIZE(test_split); i++) {
struct sol_http_url splitted;
struct sol_http_params params;
struct sol_buffer out_uri = SOL_BUFFER_INIT_EMPTY;
r = sol_http_split_uri(test_split[i].url, &splitted);
ASSERT_INT_EQ(r, test_split[i].result);
if (test_split[i].result < 0)
continue;
ASSERT(sol_str_slice_eq(splitted.scheme, test_split[i].splitted_url.scheme));
ASSERT(sol_str_slice_eq(splitted.host, test_split[i].splitted_url.host));
ASSERT(sol_str_slice_eq(splitted.path, test_split[i].splitted_url.path));
ASSERT(sol_str_slice_eq(splitted.fragment, test_split[i].splitted_url.fragment));
ASSERT(sol_str_slice_eq(splitted.query, test_split[i].splitted_url.query));
ASSERT(sol_str_slice_eq(splitted.user, test_split[i].splitted_url.user));
ASSERT(sol_str_slice_eq(splitted.password, test_split[i].splitted_url.password));
ASSERT_INT_EQ(splitted.port, test_split[i].splitted_url.port);
if (!test_split[i].check_url)
continue;
sol_http_params_init(¶ms);
r = sol_http_decode_params(splitted.query, SOL_HTTP_PARAM_QUERY_PARAM, ¶ms);
ASSERT_INT_EQ(r, 0);
r = sol_http_create_uri(&out_uri, splitted, ¶ms);
ASSERT_INT_EQ(r, 0);
ASSERT(sol_str_slice_eq(test_split[i].url, sol_buffer_get_slice(&out_uri)));
sol_http_params_clear(¶ms);
sol_buffer_fini(&out_uri);
}
#undef SET_PARAMS
}
