/// @brief dumps branch elems /// @param[in] branch pointer to node static void node_dump_branch(node_ptr branch) { const node_ref *elem_end = branch->b_elems + branch->hdr.cnt; for (const node_ref *elem = branch->b_elems; elem < elem_end; ++elem) { fprintf(stderr, " branch %-4" PRIdPTR " %s addr 0x%" PRIx32 "\n", (elem - branch->b_elems), key_str(&elem->key), elem->addr); } }
store::Item_t get_json_value( store::Item_t const &object, char const *key ) { zstring key_str( key ); store::Item_t key_item; GENV_ITEMFACTORY->createString( key_item, key_str ); return object->getObjectValue( key_item ); }
/// @brief dumps leaf elems /// @param[in] leaf pointer to node static void node_dump_leaf(node_ptr leaf) { const item_ref *elem_end = leaf->l_elems + leaf->hdr.cnt; for (const item_ref *elem = leaf->l_elems; elem < elem_end; ++elem) { fprintf(stderr, " item %-4" PRIdPTR " %s len %" PRIu32 "\n", (elem - leaf->l_elems), key_str(&elem->key), elem->len); if (elem->len != 0) { uint16_t idx = (elem - leaf->l_elems); dump_mem(leaf_elem_data(leaf, idx), elem->len); } } }
system_call_wrapper_error_t CSystemCallWrapper::generate_ssh_key(const char *comment, const char *file_path) { std::string key_str(file_path); std::string str_command = CSettingsManager::Instance().ssh_keygen_path().toStdString() + std::string(" -t rsa") + std::string(" -f ") + key_str + std::string(" -C ") + std::string(comment) + std::string(" -N \'\'"); std::vector<std::string> lst_out; int exit_code; return ssystem_th(str_command.c_str(), lst_out, exit_code, true); //todo check exit_code. }
std::ostream& to_stream( std::ostream& str, const prop_node& pn, int depth, int align ) { if ( align == 0 ) align = get_align_width( pn, depth ); for ( auto& child : pn ) { string key_str( depth * 2, ' ' ); key_str += child.first; str << std::left << std::setw( align ) << key_str; if ( child.second.has_value() || child.second.size() == 0 ) str << std::setw( 0 ) << " = " << child.second.get_value(); str << std::endl; to_stream( str, child.second, depth + 1, align ); } return str; }
// Intended to be a mad fast parser. It's not THAT fast currently, there's still // things to optimize, but meh. int RequestHeader::ParseHttpHeader(const char *buffer) { if (first_header_) { // Step 1: Method first_header_ = false; if (!memcmp(buffer, "GET ", 4)) { method = GET; buffer += 4; } else if (!memcmp(buffer, "HEAD ", 5)) { method = HEAD; buffer += 5; } else if (!memcmp(buffer, "POST ", 5)) { method = POST; buffer += 5; } else { method = UNSUPPORTED; status = 405; return -1; } SkipSpace(&buffer); // Step 2: Resource, params (what's after the ?, if any) const char *endptr = strchr(buffer, ' '); const char *q_ptr = strchr(buffer, '?'); int resource_name_len; if (q_ptr) resource_name_len = q_ptr - buffer; else resource_name_len = endptr - buffer; if (!resource_name_len) { status = 400; return -1; } resource = new char[resource_name_len + 1]; memcpy(resource, buffer, resource_name_len); resource[resource_name_len] = '\0'; if (q_ptr) { int param_length = endptr - q_ptr - 1; params = new char[param_length + 1]; memcpy(params, q_ptr + 1, param_length); params[param_length] = '\0'; } if (strstr(buffer, "HTTP/")) type = FULL; else type = SIMPLE; return 0; } // We have a real header to parse. const char *colon = strchr(buffer, ':'); if (!colon) { status = 400; return -1; } // The header is formatted as key: value. int key_len = colon - buffer; const char *key = buffer; // Go to after the colon to get the value. buffer = colon + 1; SkipSpace(&buffer); int value_len = (int)strlen(buffer); if (!strncasecmp(key, "User-Agent", key_len)) { user_agent = new char[value_len + 1]; memcpy(user_agent, buffer, value_len + 1); ILOG("user-agent: %s", user_agent); } else if (!strncasecmp(key, "Referer", key_len)) { referer = new char[value_len + 1]; memcpy(referer, buffer, value_len + 1); } else if (!strncasecmp(key, "Content-Length", key_len)) { content_length = atoi(buffer); ILOG("Content-Length: %i", (int)content_length); } else { std::string key_str(key, key_len); std::transform(key_str.begin(), key_str.end(), key_str.begin(), tolower); other[key_str] = buffer; } return 0; }
bool command_line_params::parse(const dynamic_string_array ¶ms, uint32_t total_param_descs, const command_line_param_desc *pParam_desc, const command_line_params::parse_config &config) { m_params = params; command_line_param_desc desc; desc.m_num_values = 0; desc.m_support_listing_file = false; desc.m_pName = ""; desc.m_pDesc = NULL; uint32_t arg_index = 0; while (arg_index < params.size()) { const uint32_t cur_arg_index = arg_index; const dynamic_string &src_param = params[arg_index++]; if (src_param.is_empty()) continue; bool is_param = false; uint32_t param_prefix_chars = 1; #if VOGL_CMD_LINE_ALLOW_SLASH_PARAMS is_param = (src_param[0] == '/'); #endif if ((src_param[0] == '-') && ((config.m_single_minus_params) || (config.m_double_minus_params))) { is_param = true; bool double_minus = (src_param[1] == '-'); if (double_minus) { if (config.m_double_minus_params) { param_prefix_chars = 2; } else { if (config.m_ignore_unrecognized_params) continue; console::error("Unrecognized command line parameter: \"%s\"\n", src_param.get_ptr()); return false; } } } if (is_param) { if (src_param.get_len() < (param_prefix_chars + 1)) { console::warning("Skipping invalid command line parameter: \"%s\"\n", src_param.get_ptr()); continue; } dynamic_string key_str(src_param); key_str.right(param_prefix_chars); if (config.m_pParam_ignore_prefix) { if (key_str.begins_with(config.m_pParam_ignore_prefix, true)) continue; } if (config.m_pParam_accept_prefix) { if (!key_str.begins_with(config.m_pParam_accept_prefix, true)) continue; } int modifier = 0; char c = key_str[key_str.get_len() - 1]; if (c == '+') modifier = 1; else if (c == '-') modifier = -1; if (modifier) key_str.left(key_str.get_len() - 1); if (total_param_descs) { uint32_t param_index; for (param_index = 0; param_index < total_param_descs; param_index++) if (key_str == pParam_desc[param_index].m_pName) break; if (param_index == total_param_descs) { if (config.m_ignore_unrecognized_params) continue; console::error("Unrecognized command line parameter: \"%s\"\n", src_param.get_ptr()); return false; } desc = pParam_desc[param_index]; } const uint32_t cMaxValues = 16; dynamic_string val_str[cMaxValues]; uint32_t num_val_strs = 0; if (desc.m_num_values) { VOGL_ASSERT(desc.m_num_values <= cMaxValues); if ((arg_index + desc.m_num_values) > params.size()) { console::error("Expected %u value(s) after command line parameter: \"%s\"\n", desc.m_num_values, src_param.get_ptr()); return false; } for (uint32_t v = 0; v < desc.m_num_values; v++) { val_str[num_val_strs++] = params[arg_index++]; } } dynamic_string_array strings; if ((desc.m_support_listing_file) && (val_str[0].get_len() >= 2) && (val_str[0][0] == '@')) { dynamic_string filename(val_str[0]); filename.right(1); filename.unquote(); if (!load_string_file(filename.get_ptr(), strings)) { console::error("Failed loading listing file \"%s\"!\n", filename.get_ptr()); return false; } } else { for (uint32_t v = 0; v < num_val_strs; v++) { val_str[v].unquote(); strings.push_back(val_str[v]); } } param_value pv; pv.m_values.swap(strings); pv.m_split_param_index = cur_arg_index; pv.m_modifier = (int8_t)modifier; m_param_map.insert(std::make_pair(key_str, pv)); } else if (!config.m_ignore_non_params) { if ((config.m_fail_on_non_params) && (cur_arg_index)) { console::error("Unrecognized command line argument: \"%s\"!\n", src_param.get_ptr()); return false; } param_value pv; pv.m_values.push_back(src_param); pv.m_values.back().unquote(); pv.m_split_param_index = cur_arg_index; m_param_map.insert(std::make_pair(get_empty_dynamic_string(), pv)); } } return true; }
/// Helper function to set attributes, since we override the __setattr__ function. This behaves exactly like boost::python::setattr, /// except that it calls the generic python setattr and thus does not recurse on components inline void generic_setattr(boost::python::object const& target, char const* key, boost::python::object const& value) { boost::python::str key_str(key); if(PyObject_GenericSetAttr(target.ptr(), key_str.ptr(), value.ptr()) == -1) boost::python::throw_error_already_set(); }
bool command_line_params::parse(const dynamic_wstring_array& params, uint n, const param_desc* pParam_desc) { CRNLIB_ASSERT(n && pParam_desc); m_params = params; uint arg_index = 0; while (arg_index < params.size()) { const uint cur_arg_index = arg_index; const dynamic_wstring& src_param = params[arg_index++]; if (src_param.is_empty()) continue; if ((src_param[0] == L'/') || (src_param[0] == L'-')) { if (src_param.get_len() < 2) { console::error(L"Invalid command line parameter: \"%s\"", src_param.get_ptr()); return false; } dynamic_wstring key_str(src_param); key_str.right(1); int modifier = 0; wchar_t c = key_str[key_str.get_len() - 1]; if (c == L'+') modifier = 1; else if (c == L'-') modifier = -1; if (modifier) key_str.left(key_str.get_len() - 1); uint param_index; for (param_index = 0; param_index < n; param_index++) if (key_str == pParam_desc[param_index].m_pName) break; if (param_index == n) { console::error(L"Unrecognized command line parameter: \"%s\"", src_param.get_ptr()); return false; } const param_desc& desc = pParam_desc[param_index]; const uint cMaxValues = 16; dynamic_wstring val_str[cMaxValues]; uint num_val_strs = 0; if (desc.m_num_values) { CRNLIB_ASSERT(desc.m_num_values <= cMaxValues); if ((arg_index + desc.m_num_values) > params.size()) { console::error(L"Expected %u value(s) after command line parameter: \"%s\"", desc.m_num_values, src_param.get_ptr()); return false; } for (uint v = 0; v < desc.m_num_values; v++) val_str[num_val_strs++] = params[arg_index++]; } dynamic_wstring_array strings; if ((desc.m_support_listing_file) && (val_str[0].get_len() >= 2) && (val_str[0][0] == L'@')) { dynamic_wstring filename(val_str[0]); filename.right(1); filename.unquote(); if (!load_string_file(filename.get_ptr(), strings)) { console::error(L"Failed loading listing file \"%s\"!", filename.get_ptr()); return false; } } else { for (uint v = 0; v < num_val_strs; v++) { val_str[v].unquote(); strings.push_back(val_str[v]); } } param_value pv; pv.m_values.swap(strings); pv.m_index = cur_arg_index; pv.m_modifier = (int8)modifier; m_param_map.insert(std::make_pair(key_str, pv)); } else { param_value pv; pv.m_values.push_back(src_param); pv.m_values.back().unquote(); pv.m_index = cur_arg_index; m_param_map.insert(std::make_pair(g_empty_dynamic_wstring, pv)); } } return true; }