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++; }