static bool
producer_make_data(void *data)
{
void *v;
size_t size;
struct sol_blob *blob;
struct sol_buffer buf = SOL_BUFFER_INIT_EMPTY;
static uint16_t packets_created = 0;
bool keep_running = true;
int r;
//Stop the production until the pendind blob is sent
if (pending_blob) {
printf("Waiting for blob data: %.*s to be transfered.\n",
SOL_STR_SLICE_PRINT(sol_str_slice_from_blob(pending_blob)));
return true;
}
packets_created++;
//Generate data
if (packets_created != MAX_PACKETS)
r = sol_util_uuid_gen(true, true, &buf);
else {
r = sol_buffer_append_slice(&buf, sol_str_slice_from_str("close"));
keep_running = false;
}
if (r < 0) {
fprintf(stderr, "Could not create the UUID - Reason: %s\n",
sol_util_strerrora(-r));
goto err_exit;
}
v = sol_buffer_steal(&buf, &size);
blob = sol_blob_new(&SOL_BLOB_TYPE_DEFAULT, NULL,
v, size + 1);
if (!blob) {
fprintf(stderr, "Could not alloc memory for the blob\n");
goto err_exit;
}
//Send it
if (!send_blob(blob))
goto err_exit;
if (!keep_running)
goto exit;
return true;
err_exit:
sol_quit();
exit:
producer_timeout = NULL;
return false;
}
static int
empty_writer_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct ipm_data *mdata = data;
struct sol_blob *blob = sol_blob_new(&SOL_BLOB_TYPE_DEFAULT, NULL, NULL, 0);
int r;
SOL_NULL_CHECK(blob, -ENOMEM);
SEND_BLOB(blob, mdata->id, node);
return 0;
}
static int
file_reader_load(struct file_reader_data *mdata)
{
struct sol_file_reader *reader;
struct sol_str_slice slice;
if (!mdata->path)
return 0;
reader = sol_file_reader_open(mdata->path);
if (!reader) {
sol_flow_send_error_packet(mdata->node, errno,
"Could not load \"%s\": %s", mdata->path, sol_util_strerrora(errno));
return -errno;
}
slice = sol_file_reader_get_all(reader);
SOL_DBG("loaded path=\"%s\", data=%p, len=%zd", mdata->path, slice.data, slice.len);
mdata->reader_blob = sol_blob_new(&file_reader_blob_type, NULL,
reader, sizeof(reader));
SOL_NULL_CHECK_GOTO(mdata->reader_blob, err_reader);
mdata->content_blob = sol_blob_new(SOL_BLOB_TYPE_NOFREE,
mdata->reader_blob,
slice.data, slice.len);
SOL_NULL_CHECK_GOTO(mdata->content_blob, err_content);
return sol_flow_send_blob_packet(mdata->node,
SOL_FLOW_NODE_TYPE_FILE_READER__OUT__OUT,
mdata->content_blob);
err_content:
sol_blob_unref(mdata->reader_blob);
err_reader:
sol_file_reader_close(reader);
return -ENOMEM;
}
static bool
timeout_send_cb(void *data)
{
int r;
struct sol_blob *message = sol_blob_new(&SOL_BLOB_TYPE_NO_FREE, NULL,
samples[count % 4], strlen(samples[count % 4]));
printf("x86 sending %p - %s\n", message->mem, (char *)message->mem);
r = sol_ipm_send(MESSAGE_ID, message);
if (r < 0) {
printf("x86 could not send message: %d\n", r);
}
count++;
return true;
}
static void
on_feed_done_cb(void *data, struct sol_message_digest *md, struct sol_blob *input)
{
struct update_get_hash_handle *handle = data;
char buf[CHUNK_SIZE], *blob_backend = NULL;
struct sol_blob *blob = NULL;
size_t size;
bool last;
int r;
size = fread(buf, 1, sizeof(buf), handle->file);
if (ferror(handle->file)) {
SOL_WRN("Could not read file for feed hash algorithm");
goto err;
}
last = feof(handle->file);
/* TODO Maybe this is a bug on sol_message_digest? Keeps calling on_feed_done
* after send last chunk */
if (!size && last && input) {
SOL_WRN("Nothing more to feed hash algorithm, ignoring on_feed_done request");
return;
}
blob_backend = malloc(size);
SOL_NULL_CHECK_GOTO(blob_backend, err);
blob = sol_blob_new(&SOL_BLOB_TYPE_DEFAULT, NULL, blob_backend, size);
SOL_NULL_CHECK_GOTO(blob, err);
memcpy(blob_backend, buf, size);
r = sol_message_digest_feed(md, blob, last);
SOL_INT_CHECK_GOTO(r, < 0, err);
sol_blob_unref(blob);
return;
err:
SOL_WRN("Could not feed data to check update file hash");
free(blob_backend);
sol_blob_unref(blob);
sol_message_digest_del(md);
handle->cb((void *)handle->user_data, -EINVAL, NULL);
delete_handle(handle);
}
static int
child_read(struct sol_blob **p_blob, bool *eof, int fd)
{
struct sol_buffer buf = SOL_BUFFER_INIT_EMPTY;
struct timespec start = sol_util_timespec_get_current();
size_t size;
void *v;
int ret = 0;
*eof = false;
do {
struct timespec now = sol_util_timespec_get_current();
struct timespec elapsed;
ssize_t r;
sol_util_timespec_sub(&now, &start, &elapsed);
if (elapsed.tv_sec > 0 ||
elapsed.tv_nsec > (time_t)CHUNK_MAX_TIME_NS)
break;
r = sol_util_fill_buffer(fd, &buf, CHUNK_READ_SIZE);
if (r == 0) {
*eof = true;
break;
} else if (r < 0) {
/* Not a problem if failed because buffer could not be increased */
if (r != -ENOMEM)
ret = -errno;
break;
}
} while (1);
if (ret < 0 && ret != -EAGAIN) {
sol_buffer_fini(&buf);
return ret;
}
v = sol_buffer_steal(&buf, &size);
*p_blob = sol_blob_new(&SOL_BLOB_TYPE_DEFAULT, NULL, v, size);
SOL_NULL_CHECK_GOTO(*p_blob, blob_error);
return 0;
blob_error:
sol_buffer_fini(&buf);
return -ENOMEM;
}
static bool
timeout_send_cb(void *data)
{
int r;
char *str = strdup(samples[count % 4]);
struct sol_blob *message = sol_blob_new(&SOL_BLOB_TYPE_DEFAULT, NULL,
str, strlen(str) + 1);
printf("ARC sending %s - %p\n", (char *)message->mem, message->mem);
r = sol_ipm_send(MESSAGE_ID, message);
if (r < 0) {
printf("ARC could not send message: %d\n", r);
}
sol_blob_unref(message); /* Unref as we don't care about when it's consumed.
Let blob be unref'ed and be happy happy*/
count++;
return true;
}
static void
startup(void)
{
const char *algorithm = "sha256";
const char *key = NULL;
char **argv = sol_argv();
int i, argc = sol_argc();
size_t chunk_size = -1;
if (argc < 2) {
fprintf(stderr,
"Usage:\n\t%s [-a <algorithm>] [-c chunk_size] [-k key] <file1> .. <fileN>\n", argv[0]);
sol_quit_with_code(EXIT_FAILURE);
return;
}
for (i = 1; i < argc; i++) {
struct feed_ctx *ctx;
struct sol_message_digest_config cfg = {
SOL_SET_API_VERSION(.api_version = SOL_MESSAGE_DIGEST_CONFIG_API_VERSION, )
.algorithm = algorithm,
.on_feed_done = on_feed_done,
.on_digest_ready = on_digest_ready,
};
struct sol_file_reader *fr;
struct sol_blob *blob;
struct sol_message_digest *mdh;
int r;
if (argv[i][0] == '-') {
if (argv[i][1] == 'a') {
if (i + 1 < argc) {
algorithm = argv[i + 1];
i++;
continue;
} else
fputs("ERROR: argument -a missing value.\n", stderr);
} else if (argv[i][1] == 'k') {
if (i + 1 < argc) {
key = argv[i + 1];
i++;
continue;
} else
fputs("ERROR: argument -a missing value.\n", stderr);
} else if (argv[i][1] == 'c') {
if (i + 1 < argc) {
chunk_size = atoi(argv[i + 1]);
i++;
continue;
} else
fputs("ERROR: argument -c missing value.\n", stderr);
} else
fprintf(stderr, "ERROR: unknown option %s\n", argv[i]);
sol_quit_with_code(EXIT_FAILURE);
return;
}
fr = sol_file_reader_open(argv[i]);
if (!fr) {
fprintf(stderr, "ERROR: could not open file '%s': %s\n",
argv[i], sol_util_strerrora(errno));
continue;
}
blob = sol_file_reader_to_blob(fr);
if (!blob) {
fprintf(stderr, "ERROR: could not create blob for file '%s'\n",
argv[i]);
continue;
}
cfg.data = ctx = calloc(1, sizeof(struct feed_ctx));
if (!ctx) {
fprintf(stderr, "ERROR: could not allocate context memory "
"to process file '%s'\n", argv[i]);
sol_blob_unref(blob);
continue;
}
ctx->file = argv[i];
ctx->start = sol_util_timespec_get_current();
ctx->done = 0;
ctx->chunk_size = chunk_size;
if (key)
cfg.key = sol_str_slice_from_str(key);
mdh = sol_message_digest_new(&cfg);
if (!mdh) {
fprintf(stderr, "ERROR: could not create message digest for "
" algorithm \"%s\": %s\n",
algorithm, sol_util_strerrora(errno));
sol_blob_unref(blob);
free(ctx);
continue;
}
if (chunk_size <= 0) {
r = sol_message_digest_feed(mdh, blob, true);
if (r < 0) {
fprintf(stderr, "ERROR: could not feed message for "
" algorithm \"%s\": %s\n",
algorithm, sol_util_strerrora(-r));
sol_blob_unref(blob);
sol_message_digest_del(mdh);
free(ctx);
continue;
}
} else {
size_t offset = 0;
while (offset < blob->size) {
size_t remaining = blob->size - offset;
size_t clen = remaining > chunk_size ? chunk_size : remaining;
uint8_t *cmem = (uint8_t *)blob->mem + offset;
bool is_last = offset + clen == blob->size;
struct sol_blob *chunk = sol_blob_new(&SOL_BLOB_TYPE_NO_FREE_DATA,
blob, cmem, clen);
if (!chunk) {
fprintf(stderr, "ERROR: could not create chunk blob at "
"mem %p, size=%zd\n", cmem, clen);
sol_blob_unref(blob);
sol_message_digest_del(mdh);
free(ctx);
continue;
}
r = sol_message_digest_feed(mdh, chunk, is_last);
if (r < 0) {
fprintf(stderr, "ERROR: could not feed chunk for "
" algorithm \"%s\": %s\n",
algorithm, sol_util_strerrora(-r));
sol_blob_unref(blob);
sol_blob_unref(chunk);
sol_message_digest_del(mdh);
free(ctx);
continue;
}
sol_blob_unref(chunk);
offset += clen;
}
}
sol_blob_unref(blob);
pending++;
}
