void as_namespace_get_bins_info(as_namespace *ns, cf_dyn_buf *db, bool show_ns) { if (show_ns) { cf_dyn_buf_append_string(db, ns->name); cf_dyn_buf_append_char(db, ':'); } if (ns->single_bin) { cf_dyn_buf_append_string(db, "[single-bin]"); } else { uint32_t bin_count = cf_vmapx_count(ns->p_bin_name_vmap); cf_dyn_buf_append_string(db, "num-bin-names="); cf_dyn_buf_append_uint32(db, bin_count); cf_dyn_buf_append_string(db, ",bin-names-quota="); cf_dyn_buf_append_uint32(db, BIN_NAMES_QUOTA); for (uint32_t i = 0; i < bin_count; i++) { cf_dyn_buf_append_char(db, ','); cf_dyn_buf_append_string(db, as_bin_get_name_from_id(ns, (uint16_t)i)); } } if (show_ns) { cf_dyn_buf_append_char(db, ';'); } }
void info_append_indexed_uint32(cf_dyn_buf *db, const char *name, uint32_t ix, const char *attr, uint32_t value) { append_indexed_name(db, name, ix, attr); cf_dyn_buf_append_uint32(db, value); cf_dyn_buf_append_char(db, ';'); }
void info_append_uint32(cf_dyn_buf *db, const char *name, uint32_t value) { cf_dyn_buf_append_string(db, name); cf_dyn_buf_append_char(db, '='); cf_dyn_buf_append_uint32(db, value); cf_dyn_buf_append_char(db, ';'); }
static inline void append_indexed_name(cf_dyn_buf *db, const char *name, uint32_t ix, const char *attr) { cf_dyn_buf_append_string(db, name); cf_dyn_buf_append_char(db, '['); cf_dyn_buf_append_uint32(db, ix); cf_dyn_buf_append_char(db, ']'); if (attr) { cf_dyn_buf_append_char(db, '.'); cf_dyn_buf_append_string(db, attr); } cf_dyn_buf_append_char(db, '='); }
static void append_set_props(as_set *p_set, cf_dyn_buf *db) { cf_dyn_buf_append_string(db, "n_objects="); cf_dyn_buf_append_uint64(db, cf_atomic64_get(p_set->num_elements)); cf_dyn_buf_append_char(db, ':'); cf_dyn_buf_append_string(db, "n-bytes-memory="); cf_dyn_buf_append_uint64(db, cf_atomic64_get(p_set->n_bytes_memory)); cf_dyn_buf_append_char(db, ':'); cf_dyn_buf_append_string(db, "stop-writes-count="); cf_dyn_buf_append_uint64(db, cf_atomic64_get(p_set->stop_writes_count)); cf_dyn_buf_append_char(db, ':'); cf_dyn_buf_append_string(db, "set-enable-xdr="); if (cf_atomic32_get(p_set->enable_xdr) == AS_SET_ENABLE_XDR_TRUE) { cf_dyn_buf_append_string(db, "true"); } else if (cf_atomic32_get(p_set->enable_xdr) == AS_SET_ENABLE_XDR_FALSE) { cf_dyn_buf_append_string(db, "false"); } else if (cf_atomic32_get(p_set->enable_xdr) == AS_SET_ENABLE_XDR_DEFAULT) { cf_dyn_buf_append_string(db, "use-default"); } else { cf_dyn_buf_append_uint32(db, cf_atomic32_get(p_set->enable_xdr)); } cf_dyn_buf_append_char(db, ':'); cf_dyn_buf_append_string(db, "disable-eviction="); if (IS_SET_EVICTION_DISABLED(p_set)) { cf_dyn_buf_append_string(db, "true"); } else { cf_dyn_buf_append_string(db, "false"); } cf_dyn_buf_append_char(db, ':'); cf_dyn_buf_append_string(db, "set-delete="); if (IS_SET_DELETED(p_set)) { cf_dyn_buf_append_string(db, "true"); } else { cf_dyn_buf_append_string(db, "false"); } cf_dyn_buf_append_char(db, ';'); }
int udf_cask_info_put(char *name, char * params, cf_dyn_buf * out) { cf_debug(AS_INFO, "UDF CASK INFO PUT"); int rc = 0; char filename[128] = {0}; int filename_len = sizeof(filename); // Content_len from the client and its expected size char content_len[32] = {0}; int clen = sizeof(content_len); // Udf content from the client and its expected length char *udf_content = NULL; int udf_content_len = 0; // Udf type from the client and its expected size char type[8] = {0}; int type_len = sizeof(type); // get (required) script filename char *tmp_char; if ( as_info_parameter_get(params, "filename", filename, &filename_len) || !(tmp_char = strchr(filename, '.')) // No extension in filename || tmp_char == filename // '.' at the begining of filename || strlen (tmp_char) <= 1) { // '.' in filename, but no extnsion e.g. "abc." cf_info(AS_INFO, "invalid or missing filename"); cf_dyn_buf_append_string(out, "error=invalid_filename"); return 0; } if ( as_info_parameter_get(params, "content-len", content_len, &(clen)) ) { cf_info(AS_INFO, "invalid or missing content-len"); cf_dyn_buf_append_string(out, "error=invalid_content_len"); return 0; } if ( as_info_parameter_get(params, "udf-type", type, &type_len) ) { // Replace with DEFAULT IS LUA strcpy(type, as_udf_type_name[0]); } // check type field if (-1 == udf_type_getid(type)) { cf_info(AS_INFO, "invalid or missing udf-type : %s not valid", type); cf_dyn_buf_append_string(out, "error=invalid_udf_type"); return 0; } // get b64 encoded script udf_content_len = atoi(content_len) + 1; udf_content = (char *) cf_malloc(udf_content_len); if ( udf_content == NULL ) { cf_info(AS_UDF, "internal allocation error"); cf_dyn_buf_append_string(out, "error=internal_error"); // As memory is not allocated. // It should not continue. return 0; } // cf_info(AS_UDF, "content_len = %s", content_len); // cf_info(AS_UDF, "udf_content_len = %d", udf_content_len); // get (required) script content - base64 encoded here. if ( as_info_parameter_get(params, "content", udf_content, &(udf_content_len)) ) { cf_info(AS_UDF, "invalid content"); cf_dyn_buf_append_string(out, "error=invalid_content"); cf_free(udf_content); return 0; } // base 64 decode it uint32_t encoded_len = strlen(udf_content); uint32_t decoded_len = cf_b64_decoded_buf_size(encoded_len) + 1; // Don't allow UDF file size > 1MB if ( decoded_len > MAX_UDF_CONTENT_LENGTH) { cf_info(AS_INFO, "lua file size:%d > 1MB", decoded_len); cf_dyn_buf_append_string(out, "error=invalid_udf_content_len, lua file size > 1MB"); return 0; } char * decoded_str = cf_malloc(decoded_len); if ( ! cf_b64_validate_and_decode(udf_content, encoded_len, (uint8_t*)decoded_str, &decoded_len) ) { cf_info(AS_UDF, "invalid base64 content %s", filename); cf_dyn_buf_append_string(out, "error=invalid_base64_content"); cf_free(decoded_str); return 0; } decoded_str[decoded_len] = '\0'; as_module_error err; rc = as_module_validate(&mod_lua, NULL, filename, decoded_str, decoded_len, &err); cf_free(decoded_str); decoded_str = NULL; decoded_len = 0; if ( rc ) { cf_warning(AS_UDF, "udf-put: compile error: [%s:%d] %s", err.file, err.line, err.message); cf_dyn_buf_append_string(out, "error=compile_error"); cf_dyn_buf_append_string(out, ";file="); cf_dyn_buf_append_string(out, err.file); cf_dyn_buf_append_string(out, ";line="); cf_dyn_buf_append_uint32(out, err.line); uint32_t message_len = strlen(err.message); uint32_t enc_message_len = cf_b64_encoded_len(message_len); char enc_message[enc_message_len]; cf_b64_encode((const uint8_t*)err.message, message_len, enc_message); cf_dyn_buf_append_string(out, ";message="); cf_dyn_buf_append_buf(out, (uint8_t *)enc_message, enc_message_len); cf_free(udf_content); return 0; } // Create an empty JSON object json_t *udf_obj = 0; if (!(udf_obj = json_object())) { cf_warning(AS_UDF, "failed to create JSON array for receiving UDF"); if (udf_content) cf_free(udf_content); return -1; } int e = 0; e += json_object_set_new(udf_obj, "content64", json_string(udf_content)); e += json_object_set_new(udf_obj, "type", json_string(type)); e += json_object_set_new(udf_obj, "name", json_string(filename)); if (e) { cf_warning(AS_UDF, "could not encode UDF object, error %d", e); json_decref(udf_obj); if (udf_content) cf_free(udf_content); return(-1); } // make it into a string, yet another buffer copy char *udf_obj_str = json_dumps(udf_obj, 0/*flags*/); json_decref(udf_obj); udf_obj = 0; cf_debug(AS_UDF, "created json object %s", udf_obj_str); // how do I know whether to call create or add? e = as_smd_set_metadata(udf_smd_module_name, filename, udf_obj_str); if (e) { cf_warning(AS_UDF, "could not add UDF metadata, error %d", e); cf_free(udf_obj_str); if (udf_content) cf_free(udf_content); return(-1); } cf_info(AS_UDF, "UDF module '%s' (%s/%s) registered", filename, g_config.mod_lua.user_path, filename); // free the metadata cf_free(udf_obj_str); udf_obj_str = 0; if (udf_content) cf_free(udf_content); return 0; }