/**
* @brief Constructor
* @param name The name of the ComboSource block instance
* @param invocation Invocation type of the block (Indirect, Direct, Async)
*/
ComboSource(const std::string &name)
:Block(name, invocation_type::Async), //ignore options
m_mem_block(new MemoryBatch(4096*4))
{
sze = NULL;
m_pktcnt = 0;
m_pktagg = 1;
register_variable("pktcnt",make_rd_var(no_mutex_t(), m_pktcnt));
register_variable("pktagg",make_wr_var(no_mutex_t(), m_pktagg));
}
/**
* @brief Constructor
* @param name The name of the source block
* @param invocation Invocation type of the block (Indirect, Direct, Async).
* This block can only be async invoked,
* and will ignore any contrary configuration.
*/
TweetReader(const std::string &name, invocation_type invocation)
:Block(name, invocation_type::Async),
next_out_port(0)
{
if (invocation != invocation_type::Async) {
blocklog("TweetReader must be Async, ignoring configuration", log_warning);
}
m_msg_sent = 0;
m_msg_recv = 0;
outgate_basename = "out_tweet";
m_msg_type = type_to_id<Tweet>::id();
register_variable("msg_sent",make_rd_var(no_mutex_t(), m_msg_sent));
register_variable("msg_recv",make_rd_var(no_mutex_t(), m_msg_recv));
}
void HttpProtocol::DecodeCookies(Variant &variables, char *data) {
ASSERT(data && *data);
char *strtok_buf = NULL;
char *var = strtok_r(data, ";", &strtok_buf);
while (var) {
char *val = strchr(var, '=');
// Remove leading spaces from cookie names, needed for multi-cookie
// header where ; can be followed by a space */
while (isspace(*var)) {
var++;
}
if (var != val && *var != '\0') {
if (val) { /* have a value */
int len = val - var;
char *name = url_decode(var, len);
String sname(name, len, AttachString);
++val;
len = strlen(val);
char *value = url_decode(val, len);
if (RuntimeOption::EnableMagicQuotesGpc) {
char *slashedvalue = string_addslashes(value, len);
free(value);
value = slashedvalue;
}
String svalue(value, len, AttachString);
register_variable(variables, (char*)sname.data(), svalue, false);
} else {
int len = strlen(var);
char *name = url_decode(var, len);
String sname(name, len, AttachString);
register_variable(variables, (char*)sname.data(), "", false);
}
}
var = strtok_r(NULL, ";", &strtok_buf);
}
}
/**
* @brief Constructor
* @param name The name of the packet counter block
* @param invocation Invocation type of the block (Indirect, Direct, Async)
*/
PassthroughPacketCounter(const std::string &name, invocation_type invocation)
: Block(name, invocation),
m_pkt_cnt(0),
m_byte_cnt(0),
m_pkt_rate(0),
m_byte_rate(0),
m_reset(0),
m_pkt_cnt_prev(0),
m_byte_cnt_prev(0),
m_last_t(std::chrono::system_clock::now()),
m_timer(true),
m_ingate_id(register_input_gate("in_pkt")),
m_outgate_id(register_output_gate("out_pkt"))
{
register_variable("byterate",make_rd_var(no_mutex_t(), m_byte_rate));
register_variable("pktrate",make_rd_var(no_mutex_t(), m_pkt_rate));
register_variable("pktcnt",make_rd_var(no_mutex_t(), m_pkt_cnt));
register_variable("bytecnt",make_rd_var(no_mutex_t(), m_byte_cnt));
register_variable("reset",make_wr_var(no_mutex_t(), m_reset));
}
void HttpProtocol::DecodeParameters(Variant &variables, const char *data,
int size, bool post /* = false */) {
if (data == NULL || size == 0) {
return;
}
const char *s = data;
const char *e = s + size;
const char *p, *val;
while (s < e && (p = (const char *)memchr(s, '&', (e - s)))) {
last_value:
if ((val = (const char *)memchr(s, '=', (p - s)))) {
int len = val - s;
char *name = url_decode(s, len);
String sname(name, len, AttachString);
val++;
len = p - val;
char *value = url_decode(val, len);
if (RuntimeOption::EnableMagicQuotesGpc) {
char *slashedvalue = string_addslashes(value, len);
free(value);
value = slashedvalue;
}
String svalue(value, len, AttachString);
register_variable(variables, (char*)sname.data(), svalue);
} else if (!post) {
int len = p - s;
char *name = url_decode(s, len);
String sname(name, len, AttachString);
register_variable(variables, (char*)sname.data(), "");
}
s = p + 1;
}
if (s < e) {
p = e;
goto last_value;
}
}
static char *
ngx_http_aws_auth_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
register_variable(cf);
ngx_http_aws_auth_conf_t *prev = parent;
ngx_http_aws_auth_conf_t *conf = child;
ngx_conf_merge_str_value(conf->access_key, prev->access_key, "");
ngx_conf_merge_str_value(conf->secret, prev->secret, "");
ngx_conf_merge_str_value(conf->chop_prefix, prev->chop_prefix, "");
return NGX_CONF_OK;
}
exprtree*
make_assignment (scanner_ident_t *name_ident, exprtree *value)
{
char *name = name_ident->str;
scanner_region_t region = name_ident->region;
exprtree *tree = alloc_exprtree();
variable_t *var = lookup_variable(the_mathmap->current_filter->v.mathmap.variables, name, &tree->result);
if (var == NULL)
{
if (lookup_internal(the_mathmap->current_filter->v.mathmap.internals, name, TRUE) != NULL
|| lookup_variable_macro(name, NULL) != NULL)
{
sprintf(error_string, _("Cannot assign to internal variable `%s'."), name);
error_region = region;
JUMP(1);
}
if (lookup_userval(the_mathmap->current_filter->userval_infos, name) != NULL)
{
sprintf(error_string, _("Cannot assign to filter argument `%s'."), name);
error_region = region;
JUMP(1);
}
var = register_variable(&the_mathmap->current_filter->v.mathmap.variables, name, value->result);
tree->result = value->result;
}
if (tree->result.number != value->result.number || tree->result.length != value->result.length)
{
sprintf(error_string, _("Variable %s is being assigned two different types."), name);
error_region = region;
JUMP(1);
}
tree->type = EXPR_ASSIGNMENT;
tree->val.assignment.var = var;
tree->val.assignment.value = value;
tree->region = region;
return tree;
}
