/// @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;
}
