示例#1
0
int reginfo_handle_notify(struct sip_msg* msg, char* domain, char* s2) {
 	str body;
	int result = 1;

  	/* If not done yet, parse the whole message now: */
  	if (parse_headers(msg, HDR_EOH_F, 0) == -1) {
  		LM_ERR("Error parsing headers\n");
  		return -1;
  	}
	if (get_content_length(msg) == 0) {
   		LM_DBG("Content length = 0\n");
		/* No Body? Then there is no published information available, which is ok. */
   		return 1;
   	} else {
   		body.s=get_body(msg);
   		if (body.s== NULL) {
   			LM_ERR("cannot extract body from msg\n");
   			return -1;
   		}
   		body.len = get_content_length(msg);
   	}

	LM_DBG("Body is %.*s\n", body.len, body.s);
	
	result = process_body(body, (udomain_t*)domain);

	return result;
}
示例#2
0
static void
w_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
{
  client_t *client = ( client_t *)(cb_arg);
  int ret;
#ifdef DEBUG
  printf("call w_callback \n");
#endif
  if ((events & PICOEV_TIMEOUT) != 0) {
#ifdef DEBUG
    printf("** w_callback timeout ** \n");
#endif
    //timeout
    client->keep_alive = 0;
    close_conn(client, loop);

  } else if ((events & PICOEV_WRITE) != 0) {
    ret = process_body(client);
    picoev_set_timeout(loop, client->fd, WRITE_TIMEOUT_SECS);
#ifdef DEBUG
    printf("process_body ret %d \n", ret);
#endif
    if(ret != 0){
      //ok or die
      close_conn(client, loop);
    }
  }
}
示例#3
0
static void
w_callback(picoev_loop* loop, int fd, int events, void* cb_arg)
{
    client_t *client = ( client_t *)(cb_arg);
    int ret;
#ifdef DEBUG
    printf("call w_callback \n");
#endif
    if(client->environ){
        current_client = PyDict_GetItem(client->environ, client_key);
    }
    if ((events & PICOEV_TIMEOUT) != 0) {

#ifdef DEBUG
        printf("** w_callback timeout ** \n");
#endif

        //timeout
        client->keep_alive = 0;
        close_conn(client, loop);
    
    } else if ((events & PICOEV_WRITE) != 0) {
        ret = process_body(client);
#ifdef DEBUG
        printf("process_body ret %d \n", ret);
#endif
        if(ret != 0){
            //ok or die
            close_conn(client, loop);
        }
    }
}
示例#4
0
argument_macro_input::argument_macro_input(const char *body, int ac, char **av)
: ap(0), argc(ac)
{
  for (int i = 0; i < argc; i++)
    argv[i] = av[i];
  p = s = process_body(body);
}
示例#5
0
copy_thru_input::copy_thru_input(const char *b, const char *u)
: done(0)
{
  ap = 0;
  body = process_body(b);
  p = 0;
  until = strsave(u);
}
示例#6
0
	bool parser::process_if(executable_unit & output)
	{
		lexeme_container & lexemes = get_lexemes();
		if(!is_if_statement())
			return false;

		parse_tree_node conditional;
		process_composite_term(conditional);

		executable_units if_body;
		process_body(&if_body);

		bool is_if_else = false;

		if(line_offset < line_end)
		{
			lexeme_container & lexemes = get_lexemes();
			if(is_if_statement() && lexemes.size() == 1)
			{
				is_if_else = true;

				executable_units else_body;
				process_body(&else_body);

				output.type = executable_unit_type::if_else_statement;
				if_else_statement * & if_else_pointer = output.if_else_pointer;
				if_else_pointer = new if_else_statement;
				if_else_pointer->conditional_term = conditional;
				if_else_pointer->if_body = if_body;
				if_else_pointer->else_body = else_body;
			}
		}

		if(!is_if_else)
		{
			output.type = executable_unit_type::if_statement;
			if_statement * & if_pointer = output.if_pointer;
			if_pointer = new if_statement;
			if_pointer->conditional_term = conditional;
			if_pointer->body = if_body;
		}

		return true;
	}
示例#7
0
	bool parser::process_while(executable_unit & output)
	{
		lexeme_container & lexemes = get_lexemes();
		if(lexemes[0].type != lexeme_type::while_operator)
			return false;

		parse_tree_node conditional;
		process_composite_term(conditional);

		output.type = executable_unit_type::while_statement;
		while_statement * & while_pointer = output.while_pointer;
		while_pointer = new while_statement;
		while_pointer->conditional_term = conditional;

		process_body(&while_pointer->body);

		return true;
	}
示例#8
0
	bool parser::process_for(executable_unit & output)
	{
		lexeme_container & lexemes = get_lexemes();
		if(lexemes[0].type != lexeme_type::iteration)
			return false;

		if(lexemes.size() == 1)
		{
			//three part for

			if(lines.size() - line_offset < 4)
				throw ail::exception("Incomplete for statement");

			line_offset++;

			for(std::size_t i = line_offset, end = i + 3; i < end; i++)
			{
				if(lines[i].indentation_level != indentation_level)
					throw ail::exception("Invalid indentation level in a for statement");
			}

			output.type = executable_unit_type::for_statement;
			for_statement * & for_pointer = output.for_pointer;
			for_pointer = new for_statement;
			process_offset_atomic_statement(for_pointer->initialisation);
			process_offset_atomic_statement(for_pointer->conditional);
			process_offset_atomic_statement(for_pointer->iteration);
		}
		else
		{
			//for each statement

			output.type = executable_unit_type::for_each_statement;
			for_each_statement * & for_each_pointer = output.for_each_pointer;
			for_each_pointer = new for_each_statement;
			process_composite_term(for_each_pointer->container);

			process_body(&for_each_pointer->body);
		}

		return true;
	}
示例#9
0
inline size_t request::consume(char const * buf, size_t len) {
    size_t bytes_processed;
    
    if (m_ready) {return 0;}
    
    if (m_body_bytes_needed > 0) {
        bytes_processed = process_body(buf,len);
        if (body_ready()) {
            m_ready = true;
        }
        return bytes_processed;
    }

    // copy new header bytes into buffer
    m_buf->append(buf,len);

    // Search for delimiter in buf. If found read until then. If not read all
    std::string::iterator begin = m_buf->begin();
    std::string::iterator end;

    for (;;) {
        // search for line delimiter
        end = std::search(
            begin,
            m_buf->end(),
            header_delimiter,
            header_delimiter+sizeof(header_delimiter)-1
        );
        
        m_header_bytes += (end-begin+sizeof(header_delimiter));
        
        if (m_header_bytes > max_header_size) {
            // exceeded max header size
            throw exception("Maximum header size exceeded.",
                status_code::request_header_fields_too_large);
        }

        if (end == m_buf->end()) {
            // we are out of bytes. Discard the processed bytes and copy the
            // remaining unprecessed bytes to the beginning of the buffer
            std::copy(begin,end,m_buf->begin());
            m_buf->resize(static_cast<std::string::size_type>(end-begin));
            m_header_bytes -= m_buf->size();

            return len;
        }

        //the range [begin,end) now represents a line to be processed.
        if (end-begin == 0) {
            // we got a blank line
            if (m_method.empty() || get_header("Host") == "") {
                throw exception("Incomplete Request",status_code::bad_request);
            }

            bytes_processed = (
                len - static_cast<std::string::size_type>(m_buf->end()-end)
                    + sizeof(header_delimiter) - 1
            );

            // frees memory used temporarily during request parsing
            m_buf.reset();

            // if this was not an upgrade request and has a content length
            // continue capturing content-length bytes and expose them as a 
            // request body.
            
            if (prepare_body()) {
                bytes_processed += process_body(buf+bytes_processed,len-bytes_processed);
                if (body_ready()) {
                    m_ready = true;
                }
                return bytes_processed;
            } else {
                m_ready = true;

                // return number of bytes processed (starting bytes - bytes left)
                return bytes_processed;
            }
        } else {
            if (m_method.empty()) {
                this->process(begin,end);
            } else {
                this->process_header(begin,end);
            }
        }

        begin = end+(sizeof(header_delimiter)-1);
    }
}