static int get_string_by_port(const struct sol_flow_packet *packet, uint16_t port, UChar **string) { UChar *new_str = NULL; const char *in_value; UErrorCode err; int r; r = sol_flow_packet_get_string(packet, &in_value); SOL_INT_CHECK(r, < 0, r); r = icu_str_from_utf8(in_value, &new_str, &err); SOL_INT_CHECK(r, < 0, r); if (string[port] && !u_strCompare(string[port], -1, new_str, -1, r)) { free(new_str); return 0; } free(string[port]); string[port] = new_str; return 0; }
static int thingspeak_channel_update_field_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { struct thingspeak_channel_update_data *mdata = data; int n_field = port - SOL_FLOW_NODE_TYPE_THINGSPEAK_CHANNEL_UPDATE__IN__FIELD; const char *field; if (n_field < 0 || n_field >= (int)ARRAY_SIZE(mdata->fields)) { SOL_WRN("Invalid field ID: %d, expecting 0 to 7", n_field); return -EINVAL; } if (sol_flow_packet_get_string(packet, &field) < 0) { SOL_WRN("Could not get field <%d> string", n_field); return -EINVAL; } free(mdata->fields[n_field]); mdata->fields[n_field] = strdup(field); if (!mdata->fields[n_field]) { SOL_WRN("Could not store field <%d> value", n_field); return -ENOMEM; } thingspeak_channel_update_queue(mdata); return 0; }
static int platform_service_name_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { struct platform_service_data *mdata = data; const char *name; int r; r = sol_flow_packet_get_string(packet, &name); SOL_INT_CHECK(r, < 0, r); if (mdata->service_name) { sol_platform_del_service_monitor(on_service_state_changed, mdata->service_name, mdata); } r = sol_util_replace_str_if_changed(&mdata->service_name, name); SOL_INT_CHECK(r, < 0, r); sol_platform_add_service_monitor(on_service_state_changed, mdata->service_name, mdata); mdata->state = sol_platform_get_service_state(mdata->service_name); return sol_flow_send_boolean_packet(node, SOL_FLOW_NODE_TYPE_PLATFORM_SERVICE__OUT__ACTIVE, (mdata->state == SOL_PLATFORM_SERVICE_STATE_ACTIVE)); }
static int set_locale(enum sol_platform_locale_category category, const struct sol_flow_packet *packet) { int r; const char *locale; r = sol_flow_packet_get_string(packet, &locale); SOL_INT_CHECK(r, < 0, r); r = sol_platform_set_locale(category, locale); SOL_INT_CHECK(r, < 0, r); return 0; }
static int timezone_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { int r; const char *tz; r = sol_flow_packet_get_string(packet, &tz); SOL_INT_CHECK(r, < 0, r); r = sol_platform_set_timezone(tz); SOL_INT_CHECK(r, < 0, r); return 0; }
static int hostname_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { int r; const char *name; r = sol_flow_packet_get_string(packet, &name); SOL_INT_CHECK(r, < 0, r); r = sol_platform_set_hostname(name); SOL_INT_CHECK(r, < 0, r); return 0; }
int gtk_label_in_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { struct gtk_common_data *mdata = data; if (sol_flow_packet_get_type(packet) == SOL_FLOW_PACKET_TYPE_EMPTY) { gtk_label_set_text(GTK_LABEL(mdata->widget), "[empty]"); } else if (sol_flow_packet_get_type(packet) == SOL_FLOW_PACKET_TYPE_STRING) { const char *in_value; int r = sol_flow_packet_get_string(packet, &in_value); SOL_INT_CHECK(r, < 0, r); gtk_label_set_text(GTK_LABEL(mdata->widget), in_value); } else if (sol_flow_packet_get_type(packet) == SOL_FLOW_PACKET_TYPE_BOOLEAN) {
static int file_reader_path_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { struct file_reader_data *mdata = data; const char *path; int r; r = sol_flow_packet_get_string(packet, &path); SOL_INT_CHECK(r, < 0, r); if (path && mdata->path && streq(path, mdata->path)) return 0; file_reader_unload(mdata); mdata->path = path ? strdup(path) : NULL; return file_reader_load(mdata); }
static int string_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; const char *in_value; struct sol_blob *blob; int r; r = sol_flow_packet_get_string(packet, &in_value); SOL_INT_CHECK(r, < 0, r); blob = sol_blob_new_dup_str(in_value); SOL_NULL_CHECK(in_value, -ENOMEM); SEND_BLOB(blob, mdata->id, node); return 0; }
static int platform_target_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { int r; const char *target; r = sol_flow_packet_get_string(packet, &target); SOL_INT_CHECK(r, < 0, r); r = sol_platform_set_target(target); if (r < 0) { sol_flow_send_error_packet(node, r, "Could not change the system target to: %s", target); } return 0; }
static int string_writer_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { struct unix_socket_data *mdata = data; const char *val; size_t len; int r; r = sol_flow_packet_get_string(packet, &val); SOL_INT_CHECK(r, < 0, r); len = strlen(val); if (unix_socket_write(mdata->un_socket, &len, sizeof(len)) < 0) { SOL_WRN("Failed to write the string length"); return -1; } return unix_socket_write(mdata->un_socket, val, len); }
static int get_string_by_port(const struct sol_flow_packet *packet, uint16_t port, char **string) { const char *in_value; int r; r = sol_flow_packet_get_string(packet, &in_value); SOL_INT_CHECK(r, < 0, r); if (string[port] && !strcmp(string[port], in_value)) return 0; free(string[port]); string[port] = strdup(in_value); SOL_NULL_CHECK(string[port], -ENOMEM); return 0; }
static int thingspeak_channel_update_status_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { struct thingspeak_channel_update_data *mdata = data; const char *status; if (sol_flow_packet_get_string(packet, &status) < 0) { SOL_WRN("Could not get status string"); return -EINVAL; } free(mdata->status); mdata->status = strdup(status); if (!mdata->status) { SOL_WRN("Could not store status string"); return -ENOMEM; } thingspeak_channel_update_queue(mdata); return 0; }
static int convert_char(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { const char *in_value; int c_index, r; unsigned char byte = 0; r = sol_flow_packet_get_string(packet, &in_value); SOL_INT_CHECK(r, < 0, r); c_index = in_value[0]; if (c_index != '\0' && c_index != ' ') { byte = conversion_table[c_index]; if (!byte) { sol_flow_send_error_packet(node, EINVAL, "Char '%c' can't be represented with 7 segments.", c_index); return 0; } } return sol_flow_send_byte_packet(node, SOL_FLOW_NODE_TYPE_LED_7SEG_CHAR_TO_BYTE__OUT__OUT, byte); }
static int thingspeak_add_in_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet) { struct thingspeak_add_data *mdata = data; const char *cmd_str; struct sol_http_param params; struct sol_http_client_connection *connection; int error_code = 0; int r; r = sol_flow_packet_get_string(packet, &cmd_str); if (r < 0) { SOL_WRN("Could not get command string from packet"); return -EINVAL; } sol_http_param_init(¶ms); if (!sol_http_param_add(¶ms, SOL_HTTP_REQUEST_PARAM_POST_FIELD("api_key", mdata->talkback.api_key))) { SOL_WRN("Could not add API key"); error_code = -ENOMEM; goto out; } if (!sol_http_param_add(¶ms, SOL_HTTP_REQUEST_PARAM_POST_FIELD("command_string", cmd_str))) { SOL_WRN("Could not add command string"); error_code = -ENOMEM; goto out; } if (mdata->position >= 0) { char position_str[3 * sizeof(int)]; char *pos_str; r = snprintf(position_str, sizeof(position_str), "%d", mdata->position); if (r < 0 || r >= (int)sizeof(position_str)) { SOL_WRN("Could not convert position to string"); error_code = -ENOMEM; goto out; } /* Use pos_str at SOL_HTTP_REQUEST_PARAM_POST_FIELD macro, otherwise the compiler will complain about an "always true" comparison. */ pos_str = position_str; if (!sol_http_param_add(¶ms, SOL_HTTP_REQUEST_PARAM_POST_FIELD("position", pos_str))) { SOL_WRN("Could not add position"); error_code = -ENOMEM; goto out; } } connection = sol_http_client_request(SOL_HTTP_METHOD_POST, mdata->talkback.endpoint, ¶ms, thingspeak_add_request_finished, mdata); if (!connection) { SOL_WRN("Could not create HTTP request"); error_code = -EINVAL; goto out; } r = sol_ptr_vector_append(&mdata->pending_conns, connection); if (r < 0) { SOL_WRN("Failed to keep pending connection."); sol_http_client_connection_cancel(connection); error_code = -ENOMEM; } out: sol_http_param_free(¶ms); return error_code; }
static void inspector_show_packet_value(const struct sol_flow_packet *packet) { const struct sol_flow_packet_type *type = sol_flow_packet_get_type(packet); if (type == SOL_FLOW_PACKET_TYPE_EMPTY) { fputs("<empty>", stdout); return; } else if (type == SOL_FLOW_PACKET_TYPE_ANY) { fputs("<any>", stdout); return; } else if (type == SOL_FLOW_PACKET_TYPE_ERROR) { int code; const char *msg; if (sol_flow_packet_get_error(packet, &code, &msg) == 0) { fprintf(stdout, "<error:%d \"%s\">", code, msg ? msg : ""); return; } } else if (type == SOL_FLOW_PACKET_TYPE_BOOL) { bool v; if (sol_flow_packet_get_bool(packet, &v) == 0) { fprintf(stdout, "<%s>", v ? "true" : "false"); return; } } else if (type == SOL_FLOW_PACKET_TYPE_BYTE) { unsigned char v; if (sol_flow_packet_get_byte(packet, &v) == 0) { fprintf(stdout, "<%#x>", v); return; } } else if (type == SOL_FLOW_PACKET_TYPE_IRANGE) { struct sol_irange v; if (sol_flow_packet_get_irange(packet, &v) == 0) { fprintf(stdout, "<val:%d|min:%d|max:%d|step:%d>", v.val, v.min, v.max, v.step); return; } } else if (type == SOL_FLOW_PACKET_TYPE_DRANGE) { struct sol_drange v; if (sol_flow_packet_get_drange(packet, &v) == 0) { fprintf(stdout, "<val:%g|min:%g|max:%g|step:%g>", v.val, v.min, v.max, v.step); return; } } else if (type == SOL_FLOW_PACKET_TYPE_STRING) { const char *v; if (sol_flow_packet_get_string(packet, &v) == 0) { fprintf(stdout, "<\"%s\">", v); return; } } else if (type == SOL_FLOW_PACKET_TYPE_BLOB) { struct sol_blob *v; if (sol_flow_packet_get_blob(packet, &v) == 0) { fprintf(stdout, "<mem=%p|size=%zd|refcnt=%hu|type=%p|parent=%p>", v->mem, v->size, v->refcnt, v->type, v->parent); return; } } else if (type == SOL_FLOW_PACKET_TYPE_JSON_OBJECT) { struct sol_blob *v; if (sol_flow_packet_get_json_object(packet, &v) == 0) { fprintf(stdout, "<%.*s>", SOL_STR_SLICE_PRINT(sol_str_slice_from_blob(v))); return; } } else if (type == SOL_FLOW_PACKET_TYPE_JSON_ARRAY) { struct sol_blob *v; if (sol_flow_packet_get_json_array(packet, &v) == 0) { fprintf(stdout, "<%.*s>", SOL_STR_SLICE_PRINT(sol_str_slice_from_blob(v))); return; } } else if (type == SOL_FLOW_PACKET_TYPE_RGB) { struct sol_rgb v; if (sol_flow_packet_get_rgb(packet, &v) == 0) { fprintf(stdout, "<red=%u|green=%u|blue=%u" "|red_max=%u|green_max=%u|blue_max=%u>", v.red, v.green, v.blue, v.red_max, v.green_max, v.blue_max); return; } } else if (type == SOL_FLOW_PACKET_TYPE_DIRECTION_VECTOR) { struct sol_direction_vector v; if (sol_flow_packet_get_direction_vector(packet, &v) == 0) { fprintf(stdout, "<x=%g|y=%g|z=%g|min=%g|max=%g>", v.x, v.y, v.z, v.min, v.max); return; } } else if (type == SOL_FLOW_PACKET_TYPE_LOCATION) { struct sol_location v; if (sol_flow_packet_get_location(packet, &v) == 0) { fprintf(stdout, "<lat=%g|lon=%g|alt=%g>", v.lat, v.lon, v.alt); return; } } else if (type == SOL_FLOW_PACKET_TYPE_TIMESTAMP) { struct timespec v; if (sol_flow_packet_get_timestamp(packet, &v) == 0) { struct tm cur_time; char buf[32]; tzset(); if (gmtime_r(&v.tv_sec, &cur_time)) { if (strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%SZ", &cur_time) > 0) { fprintf(stdout, "<%s>", buf); return; } } } } else if (type == SOL_FLOW_PACKET_TYPE_HTTP_RESPONSE) { int code; const char *url, *content_type; const struct sol_blob *content; struct sol_vector headers, cookies; if (sol_flow_packet_get_http_response(packet, &code, &url, &content_type, &content, &cookies, &headers) == 0) { fprintf(stdout, "<response_code:%d|content type:%s|url:%s|", code, content_type, url); fprintf(stdout, "|cookies: {"); inpector_print_key_value_array(&cookies); fprintf(stdout, "}|headers:{"); inpector_print_key_value_array(&headers); fprintf(stdout, "}|content:{mem=%p|size=%zd|refcnt=%hu|type=%p|parent=%p}>", content->mem, content->size, content->refcnt, content->type, content->parent); } return; } fputs("<?>", stdout); }