static void
adapter_property_changed(void *data, const char *path, uint64_t mask)
{
struct context *ctx = data;
if (!ctx->adapter_path)
return;
if (mask & (1 << ADAPTER_PROPERTY_POWERED)) {
struct sol_bt_session *s;
uint16_t i;
bool powered;
powered = ctx->current_state == ADAPTER_STATE_ON;
SOL_DBG("Adapter %s powered %s", ctx->adapter_path,
powered ? "on" : "off");
SOL_PTR_VECTOR_FOREACH_IDX (&ctx->sessions, s, i)
s->enabled((void *)s->user_data, powered);
/* Also notify about current devices */
if (powered) {
struct device_info *d;
SOL_PTR_VECTOR_FOREACH_IDX (&ctx->devices, d, i)
notify_scan_device(ctx, d);
}
}
}
static bool
on_stdin(void *data, int fd, uint32_t flags)
{
uint16_t i;
struct sol_http_progressive_response *sse;
struct sol_buffer value = SOL_BUFFER_INIT_EMPTY;
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;
struct sol_blob *blob;
/* 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 */
printf("no data on stdin, quitting.\n");
should_quit = true;
SOL_PTR_VECTOR_FOREACH_IDX (&responses, sse, i)
sol_http_progressive_response_del(sse, true);
goto end;
}
blob = sol_buffer_to_blob(&value);
if (!blob) {
fprintf(stderr, "Could not alloc the blob data\n");
goto err;
}
SOL_PTR_VECTOR_FOREACH_IDX (&responses, sse, i)
sol_http_progressive_response_sse_feed(sse, blob);
sol_blob_unref(blob);
}
sol_buffer_fini(&value);
return true;
err:
sol_quit_with_code(EXIT_FAILURE);
end:
stdin_watch = NULL;
sol_buffer_fini(&value);
return false;
}
static void
close_files(struct runner *r)
{
struct sol_file_reader *fr;
uint16_t i;
SOL_PTR_VECTOR_FOREACH_IDX (&r->file_readers, fr, i)
sol_file_reader_close(fr);
sol_ptr_vector_clear(&r->file_readers);
}
static void
thingspeak_add_close(struct sol_flow_node *node, void *data)
{
struct thingspeak_add_data *mdata = data;
struct sol_http_client_connection *connection;
uint16_t i;
free_talkback(&mdata->talkback);
SOL_PTR_VECTOR_FOREACH_IDX (&mdata->pending_conns, connection, i)
sol_http_client_connection_cancel(connection);
sol_ptr_vector_clear(&mdata->pending_conns);
}
SOL_API void
sol_arena_del(struct sol_arena *arena)
{
char *s;
uint16_t i;
SOL_NULL_CHECK(arena);
SOL_PTR_VECTOR_FOREACH_IDX (&arena->str_vector, s, i)
free(s);
sol_ptr_vector_clear(&arena->str_vector);
free(arena);
}
static void
notify_scan_device(const struct context *ctx, const struct device_info *d)
{
const uint64_t min_info = (1 << DEVICE_PROPERTY_ADDRESS) |
(1 << DEVICE_PROPERTY_NAME) |
(1 << DEVICE_PROPERTY_PAIRED);
const struct sol_bt_device_info *info = &d->info;
const struct sol_bt_scan_pending *scan;
uint16_t i;
if ((d->mask & min_info) != min_info)
return;
SOL_PTR_VECTOR_FOREACH_IDX (&ctx->scans, scan, i)
scan->callback((void *)scan->user_data, info);
}
static void
http_composed_client_close(struct sol_flow_node *node, void *data)
{
struct sol_http_client_connection *connection;
struct http_composed_client_data *cdata = data;
uint16_t i;
for (i = 0; i < cdata->inputs_len; i++)
if (cdata->inputs[i])
sol_flow_packet_del(cdata->inputs[i]);
SOL_PTR_VECTOR_FOREACH_IDX (&cdata->pending_conns, connection, i)
sol_http_client_connection_cancel(connection);
sol_ptr_vector_clear(&cdata->pending_conns);
free(cdata->url);
free(cdata->inputs);
}
static void
thingspeak_channel_update_close(struct sol_flow_node *node, void *data)
{
struct thingspeak_channel_update_data *mdata = data;
struct sol_http_client_connection *connection;
uint16_t i;
for (i = 0; i < ARRAY_SIZE(mdata->fields); i++)
free(mdata->fields[i]);
free(mdata->status);
free(mdata->api_key);
free(mdata->endpoint);
sol_timeout_del(mdata->timeout);
SOL_PTR_VECTOR_FOREACH_IDX (&mdata->pending_conns, connection, i)
sol_http_client_connection_cancel(connection);
sol_ptr_vector_clear(&mdata->pending_conns);
}
