/*

 * Copyright (C) 2019 OpenSIPS Solutions

 *

 * This file is part of opensips, a free SIP server.

 *

 * opensips is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version

 *

 * opensips is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

 *

 */

/*

 * Script functions exported by the OpenSIPS core

 */

#include "action.h"

#include "dprint.h"

#include "proxy.h"

#include "forward.h"

#include "parser/msg_parser.h"

#include "parser/parse_uri.h"

#include "ut.h"

#include "mem/mem.h"

#include "globals.h"

#include "dset.h"

#include "flags.h"

#include "serialize.h"

#include "blacklists.h"

#include "status_report.h"

#include "cachedb/cachedb.h"

#include "msg_translator.h"

#include "mod_fix.h"

/* needed by tcpconn_add_alias() */

#include "net/tcp_conn_defs.h"

static int fixup_forward_dest(void** param);

static int fixup_destination(void** param);

static int fixup_free_destination(void** param);

static int fixup_mflag(void** param);

static int fixup_bflag(void** param);

static int fixup_qvalue(void** param);

static int fixup_branch_keep(void** param);

static int fixup_branch_index(void** param);

static int fixup_f_send_sock(void** param);

static int fixup_blacklist_name(void** param);

static int fixup_blacklist(void** param);

static int fixup_blacklist_ip(void** param);

static int fixup_blacklist_free(void** param);

static int fixup_check_wrvar(void** param);

static int fixup_avp_list(void** param);

static int fixup_check_avp(void** param);

static int fixup_event_name(void** param);

static int fixup_event_name_subs(void** param);

static int fixup_format_string(void** param);

static int fixup_nt_string(void** param);

static int fixup_nt_str(void** param);

static int fixup_nt_str_free(void** param);

static int fixup_via_hdl(void** param);

static int fixup_append_mbranch_flags(void** param);

static int w_forward(struct sip_msg *msg, struct proxy_l *dest);

static int w_send(struct sip_msg *msg, struct proxy_l *dest, str *headers);

static int w_setflag(struct sip_msg *msg, void *flag);

static int w_resetflag(struct sip_msg *msg, void *flag);

static int w_isflagset(struct sip_msg *msg, void *flag);

static int w_setbflag(struct sip_msg *msg, void *flag, int *branch_idx);

static int w_resetbflag(struct sip_msg *msg, void *flag, int *branch_idx);

static int w_isbflagset(struct sip_msg *msg, void *flag, int *branch_idx);

static int w_sethost(struct sip_msg *msg, str *host);

static int w_sethostport(struct sip_msg *msg, str *hostport);

static int w_setuser(struct sip_msg *msg, str *user);

static int w_setuserpass(struct sip_msg *msg, str *userpass);

static int w_setport(struct sip_msg *msg, str *port);

static int w_seturi(struct sip_msg *msg, str *uri);

static int w_prefix(struct sip_msg *msg, str *prefix);

static int w_strip(struct sip_msg *msg, int *nchars);

static int w_strip_tail(struct sip_msg *msg, int *nchars);

static int w_append_branch_old(struct sip_msg *msg, str *uri, int *qvalue);

static int w_append_msg_branch(struct sip_msg *msg, str *uri, int *qvalue,

    void *flags);

static int w_remove_msg_branch(struct sip_msg *msg, int *branch);

static int w_move_msg_branch(struct sip_msg *msg,

    int *src_idx, int *dst_idx, int *keep);

static int w_swap_msg_branches(struct sip_msg *msg,

    int *src_idx, int *dst_idx);

static int w_pv_printf(struct sip_msg *msg, pv_spec_t *var, str *fmt_str);

static int w_revert_uri(struct sip_msg *msg);

static int w_setdsturi(struct sip_msg *msg, str *uri);

static int w_resetdsturi(struct sip_msg *msg);

static int w_isdsturiset(struct sip_msg *msg);

static int w_force_rport(struct sip_msg *msg);

static int w_add_local_rport(struct sip_msg *msg);

static int w_force_tcp_alias(struct sip_msg *msg, int *port);

static int w_set_adv_address(struct sip_msg *msg, str *adv_addr);

static int w_set_adv_port(struct sip_msg *msg, str *adv_port);

static int w_f_send_sock(struct sip_msg *msg, struct socket_info *si);

static int w_serialize_branches(struct sip_msg *msg, int *clear_prev,

          int *keep_ord);

static int w_next_branches(struct sip_msg *msg);

static int w_use_blacklist(struct sip_msg *msg, struct bl_head *list);

static int w_unuse_blacklist(struct sip_msg *msg, struct bl_head *list);

static int w_cache_store(struct sip_msg *msg, str *id, str *attr, str *val, 

          int *expire);

static int w_cache_remove(struct sip_msg *msg, str *id, str *attr);

static int w_cache_fetch(struct sip_msg *msg, str *id, str *attr,

          pv_spec_t *res);

static int w_cache_counter_fetch(struct sip_msg *msg, str *id, str *attr,

          pv_spec_t *res);

static int w_cache_add(struct sip_msg *msg, str *id, str *attr,

          int *inc, int *expire, pv_spec_t *new_val);

static int w_cache_sub(struct sip_msg *msg, str *id, str *attr,

          int *dec, int *expire, pv_spec_t *new_val);

static int w_cache_raw_query(struct sip_msg *msg, str *id, str *raw_query,

          pvname_list_t *avp_list);

static int w_raise_event(struct sip_msg *msg, void *ev_id, pv_spec_t *attrs_avp,

          pv_spec_t *vals_avp);

static int w_subscribe_event(struct sip_msg *msg, str *name, str *socket,

          int *expire);

static int w_construct_uri(struct sip_msg *msg, str *proto, str *user,

          str *domain, str *port, str *extra, pv_spec_t *result);

static int w_get_timestamp(struct sip_msg *msg, pv_spec_t *sec_avp,

          pv_spec_t *usec_avp);

static int w_script_trace(struct sip_msg *msg, int *log_level,

          pv_elem_t *fmt_string, void *info_str);

static int w_is_myself(struct sip_msg *msg, str *host, int *port);

static int w_print_avps(struct sip_msg* msg, char* foo, char *bar);

static int w_set_via_handling(struct sip_msg* msg, int flags);

#ifndef FUZZ_BUILD

static

#endif

const cmd_export_t core_cmds[]={

  {"forward", (cmd_function)w_forward, {

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_FIX_NULL,

      fixup_forward_dest, fixup_free_destination}, {0,0,0}},

    ALL_ROUTES},

  {"send", (cmd_function)w_send, {

    {CMD_PARAM_STR, fixup_destination, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"setflag", (cmd_function)w_setflag, {

    {CMD_PARAM_STR|CMD_PARAM_STATIC, fixup_mflag, 0}, {0,0,0}},

    ALL_ROUTES},

  {"resetflag", (cmd_function)w_resetflag, {

    {CMD_PARAM_STR|CMD_PARAM_STATIC, fixup_mflag, 0}, {0,0,0}},

    ALL_ROUTES},

  {"isflagset", (cmd_function)w_isflagset, {

    {CMD_PARAM_STR|CMD_PARAM_STATIC, fixup_mflag, 0}, {0,0,0}},

    ALL_ROUTES},

  {"setbflag", (cmd_function)w_setbflag, {

    {CMD_PARAM_STR|CMD_PARAM_STATIC, fixup_bflag, 0},

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"resetbflag", (cmd_function)w_resetbflag, {

    {CMD_PARAM_STR|CMD_PARAM_STATIC, fixup_bflag, 0},

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"isbflagset", (cmd_function)w_isbflagset, {

    {CMD_PARAM_STR|CMD_PARAM_STATIC, fixup_bflag, 0},

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"sethost", (cmd_function)w_sethost, {

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"sethostport", (cmd_function)w_sethostport, {

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"setuser", (cmd_function)w_setuser, {

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"setuserpass", (cmd_function)w_setuserpass, {

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"setport", (cmd_function)w_setport, {

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"seturi", (cmd_function)w_seturi, {

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"prefix", (cmd_function)w_prefix, {

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"strip", (cmd_function)w_strip, {

    {CMD_PARAM_INT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"strip_tail", (cmd_function)w_strip_tail, {

    {CMD_PARAM_INT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"append_branch_old", (cmd_function)w_append_branch_old, {

    {CMD_PARAM_STR|CMD_PARAM_OPT, 0, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_FIX_NULL,

      fixup_qvalue, 0}, {0,0,0}},

    ALL_ROUTES},

  {"append_msg_branch", (cmd_function)w_append_msg_branch, {

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_FIX_NULL,

      fixup_qvalue, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT,fixup_append_mbranch_flags,0},

    {0,0,0}},

    ALL_ROUTES},

  {"remove_msg_branch", (cmd_function)w_remove_msg_branch, {

    {CMD_PARAM_INT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"move_msg_branch", (cmd_function)w_move_msg_branch, {

    {CMD_PARAM_INT|CMD_PARAM_OPT, fixup_branch_index, 0},

    {CMD_PARAM_INT|CMD_PARAM_OPT, fixup_branch_index, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT, fixup_branch_keep, 0},

    {0,0,0}},

    ALL_ROUTES},

  {"swap_msg_branches", (cmd_function)w_swap_msg_branches, {

    {CMD_PARAM_INT|CMD_PARAM_OPT, fixup_branch_index, 0},

    {CMD_PARAM_INT|CMD_PARAM_OPT, fixup_branch_index, 0},

    {0,0,0}},

    ALL_ROUTES},

  {"pv_printf", (cmd_function)w_pv_printf, {

    {CMD_PARAM_VAR, 0, 0},

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"revert_uri", (cmd_function)w_revert_uri, {

    {0, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"setdsturi", (cmd_function)w_setdsturi, {

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"resetdsturi", (cmd_function)w_resetdsturi, {

    {0, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"isdsturiset", (cmd_function)w_isdsturiset, {

    {0, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"force_rport", (cmd_function)w_force_rport, {

    {0, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"add_local_rport", (cmd_function)w_add_local_rport, {

    {0, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"force_tcp_alias", (cmd_function)w_force_tcp_alias, {

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"set_advertised_address", (cmd_function)w_set_adv_address, {

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"set_advertised_port", (cmd_function)w_set_adv_port, {

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"force_send_socket", (cmd_function)w_f_send_sock, {

    {CMD_PARAM_STR, fixup_f_send_sock, 0}, {0,0,0}},

    ALL_ROUTES},

  {"serialize_branches", (cmd_function)w_serialize_branches, {

    {CMD_PARAM_INT, 0, 0},

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"next_branches", (cmd_function)w_next_branches, {

    {0, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"use_blacklist", (cmd_function)w_use_blacklist, {

    {CMD_PARAM_STR, fixup_blacklist, 0}, {0,0,0}},

    ALL_ROUTES},

  {"unuse_blacklist", (cmd_function)w_unuse_blacklist, {

    {CMD_PARAM_STR, fixup_blacklist, 0}, {0,0,0}},

    ALL_ROUTES},

  {"check_blacklist_rule", (cmd_function)w_check_blacklist, {

    {CMD_PARAM_STR, fixup_blacklist, 0},

    {CMD_PARAM_STR, fixup_blacklist_ip, fixup_blacklist_free}, /* ip */

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, /* port */

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_FIX_NULL,

      fixup_blacklist_proto, 0}, /* proto */

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_FIX_NULL,

      fixup_nt_str, fixup_nt_str_free}, /* pattern */

    {0,0,0}},

    ALL_ROUTES},

  {"add_blacklist_rule", (cmd_function)w_add_blacklist_rule, {

    {CMD_PARAM_STR, fixup_blacklist_name, 0},

    {CMD_PARAM_STR, fixup_blacklist_net, fixup_blacklist_net_free}, /* ip */

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, /* port */

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_FIX_NULL,

      fixup_blacklist_proto, 0}, /* proto */

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_FIX_NULL,

      fixup_nt_str, fixup_nt_str_free}, /* pattern */

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, /* expire */

    {0,0,0}},

    ALL_ROUTES},

  {"del_blacklist_rule", (cmd_function)w_del_blacklist_rule, {

    {CMD_PARAM_STR, fixup_blacklist_name, 0},

    {CMD_PARAM_STR, fixup_blacklist_net, fixup_blacklist_net_free}, /* ip */

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, /* port */

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_FIX_NULL,

      fixup_blacklist_proto, 0}, /* proto */

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_FIX_NULL,

      fixup_nt_str, fixup_nt_str_free}, /* pattern */

    {0,0,0}},

    ALL_ROUTES},

  {"cache_store", (cmd_function)w_cache_store, {

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"cache_remove", (cmd_function)w_cache_remove, {

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"cache_fetch", (cmd_function)w_cache_fetch, {

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_VAR, fixup_check_wrvar, 0}, {0,0,0}},

    ALL_ROUTES},

  {"cache_counter_fetch", (cmd_function)w_cache_counter_fetch, {

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_VAR, fixup_check_wrvar, 0}, {0,0,0}},

    ALL_ROUTES},

  {"cache_add", (cmd_function)w_cache_add, {

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_INT, 0, 0},

    {CMD_PARAM_INT, 0, 0},

    {CMD_PARAM_VAR|CMD_PARAM_OPT, fixup_check_wrvar, 0}, {0,0,0}},

    ALL_ROUTES},

  {"cache_sub", (cmd_function)w_cache_sub, {

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_INT, 0, 0},

    {CMD_PARAM_INT, 0, 0},

    {CMD_PARAM_VAR|CMD_PARAM_OPT, fixup_check_wrvar, 0}, {0,0,0}},

    ALL_ROUTES},

  {"cache_raw_query", (cmd_function)w_cache_raw_query, {

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_NO_EXPAND, fixup_avp_list, 0}, {0,0,0}},

    ALL_ROUTES},

  {"raise_event", (cmd_function)w_raise_event, {

    {CMD_PARAM_STR, fixup_event_name, 0},

    {CMD_PARAM_VAR|CMD_PARAM_OPT, fixup_check_avp, 0},

    {CMD_PARAM_VAR|CMD_PARAM_OPT, fixup_check_avp, 0}, {0,0,0}},

    ALL_ROUTES},

  {"subscribe_event", (cmd_function)w_subscribe_event, {

    {CMD_PARAM_STR, fixup_event_name_subs, 0},

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"construct_uri", (cmd_function)w_construct_uri, {

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT, 0, 0},

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT, 0, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT, 0, 0},

    {CMD_PARAM_VAR, fixup_check_avp, 0}, {0,0,0}},

    ALL_ROUTES},

  {"get_timestamp", (cmd_function)w_get_timestamp, {

    {CMD_PARAM_VAR, fixup_check_avp, 0},

    {CMD_PARAM_VAR, fixup_check_avp, 0}, {0,0,0}},

    ALL_ROUTES},

  {"script_trace", (cmd_function)w_script_trace, {

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_NO_EXPAND, fixup_format_string, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT|CMD_PARAM_STATIC, fixup_nt_string, 0},

    {0,0,0}},

    ALL_ROUTES},

  {"is_myself", (cmd_function)w_is_myself, {

    {CMD_PARAM_STR, 0, 0},

    {CMD_PARAM_INT|CMD_PARAM_OPT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"sr_check_status", (cmd_function)w_sr_check_status, {

    {CMD_PARAM_STR, fixup_sr_group, 0},

    {CMD_PARAM_STR|CMD_PARAM_OPT, 0, 0}, {0,0,0}},

    ALL_ROUTES},

  {"avp_print", (cmd_function)w_print_avps, {{0, 0, 0}},

    ALL_ROUTES},

  {"set_via_handling", (cmd_function)w_set_via_handling, {

    {CMD_PARAM_STR, fixup_via_hdl, 0}, {0,0,0}},

    ALL_ROUTES},

  {0,0,{{0,0,0}},0}

};

const cmd_export_t* find_core_cmd_export_t(const char* name, int flags)

{

  const cmd_export_t* cmd;

  for(cmd=core_cmds; cmd && cmd->name; cmd++){

    if((strcmp(name, cmd->name)==0)&&((cmd->flags & flags) == flags)){

      LM_DBG("found <%s> core function\n", name);

      return cmd;

    }

  }

  LM_DBG("<%s> not found \n", name);

  return 0;

}

static int fixup_destination(void** param)

{

  str *s = (str*)*param;

  str host;

  int proto=PROTO_NONE, port;

  if (parse_phostport(s->s, s->len, &host.s, &host.len, &port, &proto) != 0) {

    LM_ERR("Failed to parse destination\n");

    return E_CFG;

  }

  *param = mk_proxy(&host,(unsigned short)port, proto, 0);

  if (*param==0) {

    LM_ERR("Failed to create proxy struct\n");

    return E_CFG;

  }

  return 0;

}

static int fixup_free_destination(void** param)

{

  free_proxy(*param);

  pkg_free(*param);

  return 0;

}

static int fixup_forward_dest(void** param)

{

  if (sl_fwd_disabled>0) {

    LM_ERR("stateless forwarding disabled, but forward() "

      "is used!!\n");

    return E_CFG;

  }

  sl_fwd_disabled = 0;

  if (*param == NULL)

    return 0;

  return fixup_destination(param);

}

static int fixup_mflag(void** param)

{

  if ((*param = (void*)(long)fixup_flag(FLAG_TYPE_MSG, (str*)*param)) ==

    (void*)(long)NAMED_FLAG_ERROR) {

    LM_ERR("Fixup flag failed!\n");

    return E_CFG;

  }

  return 0;

}

static int fixup_bflag(void** param)

{

  if ((*param = (void*)(long)fixup_flag(FLAG_TYPE_BRANCH, (str*)*param)) ==

    (void*)(long)NAMED_FLAG_ERROR) {

    LM_ERR("Fixup flag failed!\n");

    return E_CFG;

  }

  return 0;

}

static int fixup_qvalue(void** param)

{

  int rc;

  qvalue_t q;

  str *s = (str*)*param;

  if (s==NULL) {

    *param = (void*)(long)Q_UNSPECIFIED;

    return 0;

  }

  if ((rc = str2q(&q, s->s, s->len)) < 0) {

    LM_ERR("Bad qvalue (%.*s): %s\n", s->len, s->s, qverr2str(rc));

    return E_CFG;

  }

  *param = (void*)(long)q;

  return 0;

}

static int fixup_branch_keep(void** param)

{

  str *s = (str*)*param;

  /* default value is to discard */

  *param = (void*)(long)0;

  if (!s)

    return 0;

  if (str_strcasecmp(s, _str("keep")) == 0)

    *param = (void*)(long)1;

  return 0;

}

static int fixup_branch_index(void** param)

{

  int *i = (int *)*param;

  /* default value is -1 */

  if (!i || *i < 0)

    *param = NULL; /* normalize to NULL */

  else if (*i >= MAX_BRANCHES) {

    LM_ERR("invalid branch index %d\n", *i);

    return -1;

  }

  /* else allow the branch provisioned */

  return 0;

}

static int fixup_f_send_sock(void** param)

{

  str *s = (str*)*param;

  str host, host_nt;

  int proto=PROTO_NONE, port;

  struct hostent* he;

  const struct socket_info* si;

  struct ip_addr ip;

  if (parse_phostport(s->s, s->len, &host.s, &host.len, &port, &proto) != 0) {

    LM_ERR("Failed to parse socket\n");

    return E_CFG;

  }

  if (pkg_nt_str_dup(&host_nt, &host) < 0) {

    LM_ERR("oom\n");

    return E_OUT_OF_MEM;

  }

  he=resolvehost(host_nt.s,0);

  if (he==0){

    LM_ERR(" could not resolve %s\n", host_nt.s);

    goto error;

  }

  hostent2ip_addr(&ip, he, 0);

  si=find_si(&ip, port, proto);

  if (si==0){

    LM_ERR("bad force_send_socket"

      " argument: %s:%d (opensips doesn't listen on it)\n",

      host_nt.s, port);

    goto error;

  }

  pkg_free(host_nt.s);

  const void **_param = (const void **)param;

  *_param = si;

  return 0;

error:

  pkg_free(host_nt.s);

  return E_BAD_ADDRESS;

}

static int fixup_blacklist_name(void** param)

{

  str *s = (str*)*param;

  *param = get_bl_head_by_name(s);

  if (!*param) {

    LM_ERR("blacklist %.*s not configured\n", s->len, s->s);

    return E_CFG;

  }

  return 0;

}

static int fixup_blacklist(void** param)

{

  str *s = (str*)*param;

  if (!str_strcasecmp(s, _str("all"))) {

    *param = NULL;

    return 0;

  } else {

    return fixup_blacklist_name(param);

  }

}

static int fixup_blacklist_free(void** param)

{

  pkg_free(*param);

  return 0;

}

static int fixup_blacklist_ip(void** param)

{

  str *s = (str*)*param;

  struct ip_addr *ip_pkg;

  struct ip_addr *ip = str2ip(s);

  if (!ip)

    return E_BAD_ADDRESS;

  ip_pkg = pkg_malloc(sizeof *ip_pkg);

  if (!ip_pkg)

    return E_OUT_OF_MEM;

  memcpy(ip_pkg, ip, sizeof *ip_pkg);

  *param = ip_pkg;

  return 0;

}

static int fixup_check_wrvar(void** param)

{

  if (((pv_spec_t *)*param)->setf == NULL) {

    LM_ERR("Output parameter must be a writable variable\n");

    return E_CFG;

  }

  return 0;

}

static int fixup_avp_list(void** param)

{

  str *s = (str*)*param;

  *param = parse_pvname_list(s, PVT_AVP);

  if (!*param) {

    LM_ERR("Failed to parse AVP list\n");

    return E_UNSPEC;

  }

  return 0;

}

static int fixup_check_avp(void** param)

{

  if (((pv_spec_t *)*param)->type != PVT_AVP) {

    LM_ERR("Parameter must be an AVP\n");

    return E_CFG;

  }

  return 0;

}

static int fixup_event_name(void** param)

{

  str *s = (str*)*param;

  event_id_t ev_id;

  ev_id = evi_get_id(s);

  if (ev_id == EVI_ERROR) {

    ev_id = evi_publish_event(*s);

    if (ev_id == EVI_ERROR) {

      LM_ERR("cannot subscribe event\n");

      return E_UNSPEC;

    }

  }

  *param = (void*)(long)ev_id;

  return 0;

}

static int fixup_event_name_subs(void** param)

{

  str *s = (str*)*param;

  event_id_t ev_id;

  ev_id = evi_get_id(s);

  if (ev_id == EVI_ERROR) {

    ev_id = evi_publish_event(*s);

    if (ev_id == EVI_ERROR) {

      LM_ERR("cannot subscribe event\n");

      return E_UNSPEC;

    }

  }

  return 0;

}

static int fixup_format_string(void** param)

{

  str *s = (str*)*param;

  if (pv_parse_format(s, (pv_elem_t**)param) < 0) {

    LM_ERR("Failed to parse format string\n");

    return E_CFG;

  }

  return 0;

}

static int fixup_nt_string(void** param)

{

  str *s = (str*)*param;

  str s_nt;

  if (pkg_nt_str_dup(&s_nt, s) < 0) {

    LM_ERR("oom\n");

    return E_OUT_OF_MEM;

  }

  *param = s_nt.s;

  return 0;

}

static int fixup_nt_str(void** param)

{

  str *s = (str*)*param;

  str *s_nt;

  s_nt = pkg_malloc(sizeof *s_nt + (s?s->len:0) + 1);

  if (!s_nt)

    return E_OUT_OF_MEM;

  s_nt->s = (char *)(s_nt + 1);

  if (s) {

    s_nt->len = s->len;

    memcpy(s_nt->s, s->s, s->len);

  } else {

    s_nt->len = 0;

  }

  s_nt->s[s_nt->len] = '\0';

  *param = s_nt;

  return 0;

}

static int fixup_nt_str_free(void** param)

{

  pkg_free(((str *)*param)->s);

  return 0;

}

static int w_forward(struct sip_msg *msg, struct proxy_l *dest)

{

  struct sip_uri next_hop, *u;

  struct proxy_l* p;

  int ret;

  if (!dest) {

    /* parse uri and build a proxy */

    if (msg->dst_uri.len) {

      ret = parse_uri(msg->dst_uri.s, msg->dst_uri.len,

        &next_hop);

      u = &next_hop;

    } else {

      ret = parse_sip_msg_uri(msg);

      u = &msg->parsed_uri;

    }

    if (ret<0) {

      LM_ERR("forward: bad_uri dropping packet\n");

      return E_BAD_ADDRESS;

    }

    /* create a temporary proxy*/

    p=mk_proxy(u->maddr_val.len?&u->maddr_val:&u->host,

      u->port_no, u->proto, (u->type==SIPS_URI_T)?1:0 );

    if (p==0){

      LM_ERR("bad host name in uri, dropping packet\n");

      return E_BAD_ADDRESS;

    }

  } else {

    if (0==(p=clone_proxy(dest))) {

      LM_ERR("failed to clone proxy, dropping packet\n");

      return E_OUT_OF_MEM;

    }

  }

  ret=forward_request(msg, p);

  free_proxy(p); /* frees only p content, not p itself */

  pkg_free(p);

  if (ret==0)

    ret=1;

  return ret;

}

static int w_send(struct sip_msg *msg, struct proxy_l *dest, str *headers)

{

  int ret;

  union sockaddr_union* to;

  struct proxy_l* p;

  int len;

  char* tmp;

  to=(union sockaddr_union*)

      pkg_malloc(sizeof(union sockaddr_union));

  if (to==0){

    LM_ERR("memory allocation failure\n");

    return E_OUT_OF_MEM;

  }

  if (0==(p=clone_proxy(dest))) {

    LM_ERR("failed to clone proxy, dropping packet\n");

    return E_OUT_OF_MEM;

  }

  ret=hostent2su(to, &p->host, p->addr_idx,

        (p->port)?p->port:SIP_PORT );

  if (ret==0){

    if (headers) {

      /* build new msg */

      tmp = pkg_malloc(msg->len + headers->len);

      if (!tmp) {

        LM_ERR("memory allocation failure\n");

        return E_OUT_OF_MEM;

      }

      LM_DBG("searching for first line %d\n",

          msg->first_line.len);

      /* search first line of previous msg */

      /* copy headers */

      len = msg->first_line.len;

      memcpy(tmp, msg->buf, len);

      memcpy(tmp + len, headers->s, headers->len);

      memcpy(tmp + len + headers->len,

          msg->buf + len, msg->len - len);

      ret = msg_send(0/*send_sock*/, p->proto, to, 0/*id*/,

          tmp, msg->len + headers->len, msg);

      pkg_free(tmp);

    } else {

      ret = msg_send(0/*send_sock*/, p->proto, to, 0/*id*/,

          msg->buf, msg->len, msg);

    }

    if (ret!=0 && p->host.h_addr_list[p->addr_idx+1])

      p->addr_idx++;

  }

  free_proxy(p); /* frees only p content, not p itself */

  pkg_free(p);

  pkg_free(to);

  if (ret==0)

    ret=1;

  return ret;

}

static int w_setflag(struct sip_msg *msg, void *flag)

{

  return setflag(msg, (flag_t)(long)flag);

}

static int w_resetflag(struct sip_msg *msg, void *flag)

{

  return resetflag(msg, (flag_t)(long)flag);

}

static int w_isflagset(struct sip_msg *msg, void *flag)

{

  return isflagset(msg, (flag_t)(long)flag);

}

static int w_setbflag(struct sip_msg *msg, void *flag, int *branch_idx)

{

  return setbflag(msg, branch_idx ? *branch_idx : 0, (flag_t)(long)flag);

}

static int w_resetbflag(struct sip_msg *msg, void *flag, int *branch_idx)

{

  return resetbflag(msg, branch_idx ? *branch_idx : 0, (flag_t)(long)flag);  

}

static int w_isbflagset(struct sip_msg *msg, void *flag, int *branch_idx)

{

  return isbflagset(msg, branch_idx ? *branch_idx : 0, (flag_t)(long)flag);

}

static int w_sethost(struct sip_msg *msg, str *host)

{

  return rewrite_ruri(msg, host, 0, RW_RURI_HOST) ? -1 : 1;

}

static int w_sethostport(struct sip_msg *msg, str *hostport)

{

  return rewrite_ruri(msg, hostport, 0, RW_RURI_HOSTPORT) ? -1 : 1;

}

static int w_setuser(struct sip_msg *msg, str *user)

{

  return rewrite_ruri(msg, user, 0, RW_RURI_USER) ? -1 : 1;

}

static int w_setuserpass(struct sip_msg *msg, str *userpass)

{

  return rewrite_ruri(msg, userpass, 0, RW_RURI_USERPASS) ? -1 : 1;

}

static int w_setport(struct sip_msg *msg, str *port)

{

  return rewrite_ruri(msg, port, 0, RW_RURI_PORT) ? -1 : 1;

}

static int w_seturi(struct sip_msg *msg, str *uri)

{

  if (set_ruri(msg, uri) ) {

    LM_ERR("failed to set new RURI\n");

    return E_OUT_OF_MEM;

  }

  return 1;

}

static int w_prefix(struct sip_msg *msg, str *prefix)

{

  return rewrite_ruri(msg, prefix, 0, RW_RURI_PREFIX) ? -1 : 1;

}

static int w_strip(struct sip_msg *msg, int *nchars)

{

  return rewrite_ruri(msg, 0, *nchars, RW_RURI_STRIP) ? -1 : 1;

}

static int w_strip_tail(struct sip_msg *msg, int *nchars)

{

  return rewrite_ruri(msg, 0, *nchars, RW_RURI_STRIP_TAIL) ? -1 : 1;

}

static int w_append_branch_old(struct sip_msg *msg, str *uri, int *qvalue)

{

  struct msg_branch branch;

  int ret;

  qvalue_t q = (int)(long)qvalue;

  memset( &branch, 0, sizeof branch);

  if (!uri) {

    branch.uri = *GET_RURI(msg);

    branch.dst_uri = msg->dst_uri;

    branch.path = msg->path_vec;

    branch.q = (q==Q_UNSPECIFIED) ? get_ruri_q(msg) : q;

    branch.force_send_socket = msg->force_send_socket;

    branch.bflags = msg->ruri_bflags;

    ret = append_msg_branch(&branch);

    /* reset all branch info */

    msg->force_send_socket = 0;

    setb0flags(msg,0);

    set_ruri_q(msg,Q_UNSPECIFIED);

    if(msg->dst_uri.s!=0)

      pkg_free(msg->dst_uri.s);

    msg->dst_uri.s = 0;

    msg->dst_uri.len = 0;

    if(msg->path_vec.s!=0)

      pkg_free(msg->path_vec.s);

    msg->path_vec.s = 0;

    msg->path_vec.len = 0;

    return ret;

  } else {

    branch.uri = *uri;

    branch.dst_uri = msg->dst_uri;

    branch.path = msg->path_vec;

    branch.q = q;

    branch.force_send_socket = msg->force_send_socket;

    branch.bflags = msg->ruri_bflags;

    return append_msg_branch(&branch);

  }

}

static str append_mbranch_flag_names[] =

{

  str_init("inherite"),

  STR_NULL

};