[BUG] OpenSIPS 3.2 set_select_weight() cause the dialog destroyed when return index 0

[chenyw11]

OpenSIPS 3.2.15

version: opensips 3.2.15 (x86_64/linux)
flags: STATS: On, DISABLE_NAGLE, USE_MCAST, SHM_MMAP, PKG_MALLOC, Q_MALLOC, F_MALLOC, HP_MALLOC, DBG_MALLOC, FAST_LOCK-ADAPTIVE_WAIT
ADAPTIVE_WAIT_LOOPS=1024, MAX_RECV_BUFFER_SIZE 262144, MAX_LISTEN 16, MAX_URI_SIZE 1024, BUF_SIZE 65535
poll method support: poll, epoll, sigio_rt, select.
git revision: 77f3ca8
main.c compiled on 05:47:11 Nov 12 2025 with gcc 12

I use set_select_weight() to get weight index from a avp. But when the result index is 0, the dialog was destroyed.

...
$avp(sort) = 40;
$avp(sort) = 60;
set_select_weight($avp(sort));
xlog("L_INFO", "+++++++++++ $rc +++++++++++++++++++");
...

Log
index is 1:

Dec  8 18:01:02.157587 opensips[394]: DBG:cfgutils:pv_sel_weight: The interval is 60 - 100
Dec  8 18:01:02.157592 opensips[394]: +++++++++++ 1 +++++++++++++++++++ 

index is 0:

Dec  8 18:01:01.142385 opensips[394]: DBG:cfgutils:pv_sel_weight: The interval is 0 - 60
Dec  8 18:01:01.142392 opensips[394]: DBG:dialog:next_state_dlg: dialog 0x7f8eac235278 changed from state 1 to state 5, due event 1
Dec  8 18:01:01.142396 opensips[394]: DBG:dialog:dlg_onreply: dialog 0x7f8eac235278 failed (negative reply)
Dec  8 18:01:01.142403 opensips[394]: DBG:dialog:destroy_dlg: destroying dialog 0x7f8eac235278
Dec  8 18:01:01.142408 opensips[394]: DBG:dialog:destroy_dlg: dlg expired or not in list - dlg 0x7f8eac235278 [2736:1539084200] with clid '00900139d2ca41d9825eb8407f40af01' and tags '44874e28d6c34da88a0763f1d846fb93' 'NULL'
Dec  8 18:01:01.142414 opensips[394]: DBG:core:destroy_avp_list: destroying list 0x7f8eac236468
Dec  8 18:01:01.142418 opensips[394]: DBG:core:receive_msg: cleaning up
Dec  8 18:01:01.142424 opensips[394]: DBG:core:free_sdp_content: sdp = 0x7f8eec77bca8
Dec  8 18:01:01.142428 opensips[394]: DBG:core:free_sdp_content: sdp = 0x7f8eec77bca8 
Dec  8 18:01:01.142432 opensips[394]: DBG:core:free_sdp_content: session = 0x7f8eec77bcf0

[chenyw11]

I added some logs in set_select_weight():

static int pv_sel_weight(struct sip_msg* msg, pv_spec_t *pv_name)
{
...
	for(i = 0; i< size; i++)
	{
		if(rnd_val >= prev_val && rnd_val < vals[i])
			break;
		prev_val = vals[i];
	}
	//LM_DBG("The interval is %d - %d\n", prev_val, vals[i]);
	LM_INFO("The interval is %d - %d (chosen idx=%d, sum=%d)\n", prev_val, vals[i], i, sum);
	LM_INFO("DBG: before free, vals ptr=%p\n", (void*)vals);
	pkg_free(vals);
	LM_INFO("DBG: after free\n");

	LM_INFO("DBG: about to return %d\n", i);

	return i;
...
}

cfg:

$avp(sort) = 40;
$avp(sort) = 60;
set_select_weight($avp(sort));
xlog("L_INFO", "after set_select_weight");
xlog("L_INFO", "+++++++++++ $rc +++++++++++++++++++");

log:
index 1:

Dec  9 15:28:48.707935 opensips[393]: INFO:cfgutils:pv_sel_weight: The interval is 60 - 100 (chosen idx=1, sum=100)
Dec  9 15:28:48.707939 opensips[393]: INFO:cfgutils:pv_sel_weight: DBG: before free, vals ptr=0x7f727a77fd68
Dec  9 15:28:48.707942 opensips[393]: INFO:cfgutils:pv_sel_weight: DBG: after free
Dec  9 15:28:48.707946 opensips[393]: INFO:cfgutils:pv_sel_weight: DBG: about to return 1
Dec  9 15:28:48.707950 opensips[393]: after set_select_weight
Dec  9 15:28:48.707954 opensips[393]: +++++++++++ 1 +++++++++++++++++++

index 0:

Dec  9 15:28:37.735166 opensips[394]: INFO:cfgutils:pv_sel_weight: The interval is 0 - 60 (chosen idx=0, sum=100)
Dec  9 15:28:37.735170 opensips[394]: INFO:cfgutils:pv_sel_weight: DBG: before free, vals ptr=0x7f727a77d8f8
Dec  9 15:28:37.735174 opensips[394]: INFO:cfgutils:pv_sel_weight: DBG: after free
Dec  9 15:28:37.735177 opensips[394]: INFO:cfgutils:pv_sel_weight: DBG: about to return 0
Dec  9 15:28:37.735184 opensips[394]: DBG:dialog:next_state_dlg: dialog 0x7f723a2402e8 changed from state 1 to state 5, due event 1
Dec  9 15:28:37.735188 opensips[394]: DBG:dialog:dlg_onreply: dialog 0x7f723a2402e8 failed (negative reply)
Dec  9 15:28:37.735195 opensips[394]: DBG:dialog:destroy_dlg: destroying dialog 0x7f723a2402e8
Dec  9 15:28:37.735199 opensips[394]: DBG:dialog:destroy_dlg: dlg expired or not in list - dlg 0x7f723a2402e8 [1558:1741033308] with clid '3bd63211f63e409388cc88f63b489573' and tags 'b7a11f98d27a40a18cb0a7167c688ab6' 'NULL'
Dec  9 15:28:37.735205 opensips[394]: DBG:core:destroy_avp_list: destroying list 0x7f723a241340
Dec  9 15:28:37.735210 opensips[394]: DBG:core:receive_msg: cleaning up
Dec  9 15:28:37.735216 opensips[394]: DBG:core:free_sdp_content: sdp = 0x7f727a77eb70
Dec  9 15:28:37.735220 opensips[394]: DBG:core:free_sdp_content: sdp = 0x7f727a77eb70
Dec  9 15:28:37.735223 opensips[394]: DBG:core:free_sdp_content: session = 0x7f727a77e830

[chenyw11]

/* ret= 0! if action -> end of list(e.g DROP),
      > 0 to continue processing next actions
   and <0 on error */
int do_action(struct action* a, struct sip_msg* msg)
{
	int ret;
	int v;
	int i;
	int len;
	int cmatch;
	struct action *aitem;
	struct action *adefault;
	pv_spec_t *spec;
	pv_value_t val;
	struct timeval start;
	int end_time;
	cmd_export_t *cmd = NULL;
	acmd_export_t *acmd;
	void* cmdp[MAX_CMD_PARAMS];
	pv_value_t tmp_vals[MAX_CMD_PARAMS];
	pv_value_t *route_p;
	str sval;

	/* reset the value of error to E_UNSPEC so avoid unknowledgable
	   functions to return with error (status<0) and not setting it
	   leaving there previous error; cache the previous value though
	   for functions which want to process it */
	prev_ser_error=ser_error;
	ser_error=E_UNSPEC;

	start_expire_timer(start,execmsgthreshold);

	curr_action_line = a->line;
	curr_action_file = a->file;

	ret=E_BUG;
	switch ((unsigned char)a->type){
		case ASSERT_T:
				if (enable_asserts) {
					/* if null expr => ignore if? */
					if ((a->elem[0].type==EXPR_ST)&&a->elem[0].u.data){
						v=eval_expr((struct expr*)a->elem[0].u.data, msg, 0);

						ret=1;  /*default is continue */

						if (v<=0) {
							ret=0;

							LM_CRIT("ASSERTION FAILED - %s\n", a->elem[1].u.string);

							if (abort_on_assert) {
								abort();
							} else {
								set_err_info(OSER_EC_ASSERT, OSER_EL_CRITIC, "assertion failed");
								set_err_reply(500, "server error");

								run_error_route(msg, 0);
							}
						}
					}
				}
			break;
		case DROP_T:
				script_trace("core", "drop", msg, a->file, a->line) ;
				action_flags |= ACT_FL_DROP|ACT_FL_EXIT;
			break;
		case EXIT_T:
				script_trace("core", "exit", msg, a->file, a->line) ;
				ret=0;
				action_flags |= ACT_FL_EXIT;
			break;
		case RETURN_T:
				script_trace("core", "return", msg, a->file, a->line) ;
				if (a->elem[0].type == SCRIPTVAR_ST)
				{
					spec = (pv_spec_t*)a->elem[0].u.data;
					if(pv_get_spec_value(msg, spec, &val)!=0
						|| (val.flags&PV_VAL_NULL))
					{
						ret=-1;
					} else {
						if(!(val.flags&PV_VAL_INT))
							ret = 1;
						else
							ret = val.ri;
					}
					pv_value_destroy(&val);
				} else {
					ret=a->elem[0].u.number;
				}
				action_flags |= ACT_FL_RETURN;
			break;
		case LOG_T:
			script_trace("core", "log", msg, a->file, a->line) ;
			if ((a->elem[0].type!=NUMBER_ST)|(a->elem[1].type!=STRING_ST)){
				LM_ALERT("BUG in log() types %d, %d\n",
						a->elem[0].type, a->elem[1].type);
				ret=E_BUG;
				break;
			}
			LM_GEN1(a->elem[0].u.number, "%s", a->elem[1].u.string);
			ret=1;
			break;
		case LEN_GT_T:
			script_trace("core", "len_gt", msg, a->file, a->line) ;
			if (a->elem[0].type!=NUMBER_ST) {
				LM_ALERT("BUG in len_gt type %d\n",
					a->elem[0].type );
				ret=E_BUG;
				break;
			}
			ret = (msg->len >= (unsigned int)a->elem[0].u.number) ? 1 : -1;
			break;
		case ERROR_T:
			script_trace("core", "error", msg, a->file, a->line) ;
			if ((a->elem[0].type!=STRING_ST)|(a->elem[1].type!=STRING_ST)){
				LM_ALERT("BUG in error() types %d, %d\n",
						a->elem[0].type, a->elem[1].type);
				ret=E_BUG;
				break;
			}
			LM_ERR("error(\"%s\", \"%s\") not implemented yet\n",
				a->elem[0].u.string, a->elem[1].u.string);
			ret=1;
			break;
		case ROUTE_T:
			init_str(&sval, "unknown");
			switch (a->elem[0].type) {
				case NUMBER_ST:
					i = a->elem[0].u.number;
					break;
				case SCRIPTVAR_ST:
					if (pv_get_spec_value(msg, a->elem[0].u.item, &val) < 0) {
						LM_ERR("cannot print route name!\n");
						i = -1;
						break;
					}
					if (val.flags & PV_VAL_INT)
						sval.s = int2str(val.ri, &sval.len);
					else
						sval = val.rs;
					i = get_script_route_ID_by_name_str(&sval, sroutes->request, RT_NO);
					break;
				case SCRIPTVAR_ELEM_ST:
					if (pv_printf_s(msg, a->elem[0].u.data, &sval) < 0) {
						LM_ERR("cannot print route name!\n");
						i = -1;
						break;
					}
					i = get_script_route_ID_by_name_str(&sval, sroutes->request, RT_NO);
					break;
				default:
					i = -1;
					break;
			}
			if (i == -1) {
				LM_ALERT("unknown route(%.*s) (type %d)\n", sval.len, sval.s,
						a->elem[0].type);
				ret=E_BUG;
				break;
			}
			if ((i>=RT_NO)||(i<0)){
				LM_BUG("invalid routing table number in route(%u)\n", i);
				ret=E_CFG;
				break;
			}
			script_trace("route", sroutes->request[i].name,
				msg, a->file, a->line) ;
			/* check if the route has parameters */
			if (a->elem[1].type != 0) {
				if (a->elem[1].type != NUMBER_ST || a->elem[2].type != SCRIPTVAR_ST) {
					LM_ALERT("BUG in route() type %d/%d\n",
							a->elem[1].type, a->elem[2].type);
					ret=E_BUG;
					break;
				}
				len = a->elem[1].u.number;
				route_p = route_params_expand(msg, a->elem[2].u.data, len);
				if (!route_p) {
					LM_ERR("could not expand route params!\n");
					ret=E_OUT_OF_MEM;
					break;
				}
				route_params_push_level(sroutes->request[i].name,
						route_p, (void *)(unsigned long)len, route_param_get);
				return_code=run_actions(sroutes->request[i].a, msg);
				route_params_release(route_p, len);
				route_params_pop_level();
			} else {
				route_params_push_level(sroutes->request[i].name, NULL, 0, route_param_get);
				return_code=run_actions(sroutes->request[i].a, msg);
				route_params_pop_level();
			}
			ret=return_code;
			break;
		case IF_T:
			script_trace("core", "if", msg, a->file, a->line) ;
				/* if null expr => ignore if? */
				if ((a->elem[0].type==EXPR_ST)&&a->elem[0].u.data){
					v=eval_expr((struct expr*)a->elem[0].u.data, msg, 0);
					/* set return code to expr value */
					if (v<0 || (action_flags&ACT_FL_RETURN)
							|| (action_flags&ACT_FL_EXIT) ){
						if (v==EXPR_DROP || (action_flags&ACT_FL_RETURN)
								|| (action_flags&ACT_FL_EXIT) ){ /* hack to quit on DROP*/
							ret=0;
							return_code = 0;
							break;
						}else{
							LM_WARN("error in expression at %s:%d\n",
								a->file, a->line);
						}
					}

					ret=1;  /*default is continue */
					if (v>0) {
						if ((a->elem[1].type==ACTIONS_ST)&&a->elem[1].u.data){
							ret=run_action_list(
									(struct action*)a->elem[1].u.data,msg );
							return_code = ret;
						} else return_code = v;
					}else{
						if ((a->elem[2].type==ACTIONS_ST)&&a->elem[2].u.data){
							ret=run_action_list(
								(struct action*)a->elem[2].u.data,msg);
							return_code = ret;
						} else return_code = v;
					}
				}
			break;
		case WHILE_T:
			script_trace("core", "while", msg, a->file, a->line) ;
			/* if null expr => ignore if? */
			if ((a->elem[0].type==EXPR_ST)&&a->elem[0].u.data){
				len = 0;
				while(1)
				{
					if(len++ >= max_while_loops)
					{
						LM_ERR("max while loops reached (%d), increase the "
						       "'max_while_loops' global!\n", max_while_loops);
						break;
					}
					v=eval_expr((struct expr*)a->elem[0].u.data, msg, 0);
					/* set return code to expr value */
					if (v<0 || (action_flags&ACT_FL_RETURN)
							|| (action_flags&ACT_FL_EXIT) ){
						if (v==EXPR_DROP || (action_flags&ACT_FL_RETURN)
								|| (action_flags&ACT_FL_EXIT) ){
							ret=0;
							return_code = 0;
							break;
						}else{
							LM_WARN("error in expression at %s:%d\n",
									a->file, a->line);
						}
					}

					ret=1;  /*default is continue */
					if (v>0) {
						if ((a->elem[1].type==ACTIONS_ST)
								&&a->elem[1].u.data){
							ret=run_action_list(
								(struct action*)a->elem[1].u.data,msg );
							/* check if return was done */
							if (action_flags &
									(ACT_FL_RETURN|ACT_FL_EXIT|ACT_FL_BREAK)) {
								action_flags &= ~ACT_FL_BREAK;
								break;
							}
							return_code = ret;
						} else {
							/* we should not get here */
							return_code = v;
							break;
						}
					} else {
						/* condition was false */
						return_code = v;
						break;
					}
				}
			}
			break;
		case BREAK_T:
			script_trace("core", "break", msg, a->file, a->line) ;
			action_flags |= ACT_FL_BREAK;
			break;
		case FOR_EACH_T:
			script_trace("core", "for-each", msg, a->file, a->line) ;
			ret = for_each_handler(msg, a);
			break;
		case XDBG_T:
			script_trace("core", "xdbg", msg, a->file, a->line) ;
			if (a->elem[0].type == SCRIPTVAR_ELEM_ST)
			{
				ret = xdbg(msg, a->elem[0].u.data);
				if (ret < 0)
				{
					LM_ERR("error while printing xdbg message\n");
					break;
				}
			}
			else
			{
				LM_ALERT("BUG in xdbg() type %d\n", a->elem[0].type);
				ret=E_BUG;
			}
			break;
		case XLOG_T:
			script_trace("core", "xlog", msg, a->file, a->line) ;
			if (a->elem[1].u.data != NULL)
			{
				if (a->elem[1].type != SCRIPTVAR_ELEM_ST)
				{
					LM_ALERT("BUG in xlog() type %d\n", a->elem[1].type);
					ret=E_BUG;
					break;
				}
				if (a->elem[0].type != STR_ST)
				{
					LM_ALERT("BUG in xlog() type %d\n", a->elem[0].type);
					ret=E_BUG;
					break;
				}
				ret = xlog_2(msg,a->elem[0].u.data, a->elem[1].u.data);
				if (ret < 0)
				{
					LM_ERR("error while printing xlog message\n");
					break;
				}
			}
			else
			{
				if (a->elem[0].type != SCRIPTVAR_ELEM_ST)
				{
					LM_ALERT("BUG in xlog() type %d\n", a->elem[0].type);
					ret=E_BUG;
					break;
				}
				ret = xlog_1(msg,a->elem[0].u.data);
				if (ret < 0)
				{
					LM_ERR("error while printing xlog message\n");
					break;
				}
			}

			break;
		case SWITCH_T:
			script_trace("core", "switch", msg, a->file, a->line) ;
#ifdef EXTRA_DEBUG
			if (a->elem[0].type!=SCRIPTVAR_ST || a->elem[1].type!=ACTIONS_ST) {
				LM_ALERT("BUG in switch() type %d\n",
						a->elem[0].type);
				ret=E_BUG;
				break;
			}
#endif
			spec = (pv_spec_t*)a->elem[0].u.data;
			if(pv_get_spec_value(msg, spec, &val)!=0)
			{
				LM_ALERT("BUG - no value in switch()\n");
				ret=E_BUG;
				break;
			}

			return_code=1;
			adefault = NULL;
			aitem = (struct action*)a->elem[1].u.data;
			cmatch=0;
			while(aitem)
			{
				if((unsigned char)aitem->type==DEFAULT_T)
					adefault=aitem;
				if(cmatch==0)
				{
					if(aitem->elem[0].type==STR_ST)
					{
						if(val.flags&PV_VAL_STR
								&& val.rs.len==aitem->elem[0].u.s.len
								&& strncasecmp(val.rs.s, aitem->elem[0].u.s.s,
									val.rs.len)==0)
							cmatch = 1;
					} else { /* number */
						if(val.flags&PV_VAL_INT &&
								val.ri==aitem->elem[0].u.number)
							cmatch = 1;
					}
				}
				if(cmatch==1)
				{
					if(aitem->elem[1].u.data)
					{
						return_code=run_action_list(
							(struct action*)aitem->elem[1].u.data, msg);
						if (action_flags &
								(ACT_FL_RETURN | ACT_FL_EXIT | ACT_FL_BREAK)) {
							action_flags &= ~ACT_FL_BREAK;
							break;
						}
					}

					if (!aitem->next)
						cmatch = 0;
				}
				aitem = aitem->next;
			}
			if((cmatch==0) && (adefault!=NULL))
			{
				LM_DBG("switch: running default statement\n");
				if(adefault->elem[0].u.data)
					return_code=run_action_list(
						(struct action*)adefault->elem[0].u.data, msg);
				if (action_flags & ACT_FL_BREAK)
					action_flags &= ~ACT_FL_BREAK;
			}
			ret=return_code;
			break;
		case CMD_T:
			if (a->elem[0].type != CMD_ST ||
				((cmd = (cmd_export_t*)a->elem[0].u.data) == NULL)) {
				LM_ALERT("BUG in module call\n");
				break;
			}

			script_trace("module", cmd->name, msg, a->file, a->line);

			if ((ret = get_cmd_fixups(msg, cmd->params, a->elem, cmdp,
				tmp_vals)) < 0) {
				LM_ERR("Failed to get fixups for command <%s> in %s, line %d\n",
					cmd->name, a->file, a->line);
				break;
			}

			ret = cmd->function(msg,
				cmdp[0],cmdp[1],cmdp[2],
				cmdp[3],cmdp[4],cmdp[5],
				cmdp[6],cmdp[7]);

			if (free_cmd_fixups(cmd->params, a->elem, cmdp) < 0) {
				LM_ERR("Failed to free fixups for command <%s> in %s, line %d\n",
					cmd->name, a->file, a->line);
				break;
			}

			break;
		case ASYNC_T:
			/* first param - an ACTIONS_ST containing an ACMD_ST
			 * second param - a NUMBER_ST pointing to resume route
			 * third param - an optional NUMBER_ST with a timeout */
			aitem = (struct action *)(a->elem[0].u.data);
			acmd = (acmd_export_t *)aitem->elem[0].u.data;

			if (async_script_start_f==NULL || a->elem[0].type!=ACTIONS_ST ||
			a->elem[1].type!=NUMBER_ST || aitem->type!=AMODULE_T) {
				LM_ALERT("BUG in async expression "
				         "(is the 'tm' module loaded?)\n");
			} else {
				script_trace("async", acmd->name, msg, a->file, a->line);

				if ((ret = get_cmd_fixups(msg, acmd->params, aitem->elem, cmdp,
					tmp_vals)) < 0) {
					LM_ERR("Failed to get fixups for async command <%s> in %s,"
					       " line %d\n", acmd->name, a->file, a->line);
					break;
				}

				ret = async_script_start_f(msg, aitem, a->elem[1].u.number,
					(unsigned int)a->elem[2].u.number, cmdp);
				if (ret>=0)
					action_flags |= ACT_FL_TBCONT;

				if (free_cmd_fixups(acmd->params, aitem->elem, cmdp) < 0) {
					LM_ERR("Failed to free fixups for async command <%s> in %s,"
					       " line %d\n", acmd->name, a->file, a->line);
					break;
				}
			}
			ret = 0;
			break;
		case LAUNCH_T:
			/* first param - an ACTIONS_ST containing an ACMD_ST
			 * second param - an optional NUMBER_ST pointing to an end route */
			aitem = (struct action *)(a->elem[0].u.data);
			acmd = (acmd_export_t *)aitem->elem[0].u.data;

			if (async_script_start_f==NULL || a->elem[0].type!=ACTIONS_ST ||
			a->elem[1].type!=NUMBER_ST || aitem->type!=AMODULE_T) {
				LM_ALERT("BUG in launch expression\n");
			} else {
				script_trace("launch", acmd->name, msg, a->file, a->line);
				/* NOTE that the routeID (a->elem[1].u.number) is set to 
				 * -1 if no reporting route is set */

				if ((ret = get_cmd_fixups(msg, acmd->params, aitem->elem,
					cmdp, tmp_vals)) < 0) {
					LM_ERR("Failed to get fixups for launch command <%s> in %s,"
					       " line %d\n", acmd->name, a->file, a->line);
					break;
				}

				ret = async_script_launch( msg, aitem, a->elem[1].u.number, cmdp);

				if (free_cmd_fixups(acmd->params, aitem->elem, cmdp) < 0) {
					LM_ERR("Failed to free fixups for launch command <%s> in %s,"
					       " line %d\n", acmd->name, a->file, a->line);
					break;
				}
			}
			break;
		case EQ_T:
		case COLONEQ_T:
		case PLUSEQ_T:
		case MINUSEQ_T:
		case DIVEQ_T:
		case MULTEQ_T:
		case MODULOEQ_T:
		case BANDEQ_T:
		case BOREQ_T:
		case BXOREQ_T:
			ret = do_assign(msg, a);
			break;
		default:
			LM_ALERT("BUG - unknown type %d\n", a->type);
			goto error;
	}

	if((unsigned char)a->type!=IF_T && (unsigned char)a->type!=ROUTE_T)
		return_code = ret;
/*skip:*/

	update_longest_action(a);
	return ret;

error:
	LM_ERR("error in %s:%d\n", a->file, a->line);
	update_longest_action(a);
	return ret;
}

The return code can not be 0, so the index returned by set_select_weight() need to be added 1.

[bogdan-iancu]

Yes, there is a design issue with the function. No OpenSIPS script function should return 0, as this value is reserved for breaking the script execution.
Options:

• as you suggested, maybe the function should start counting the indexes from 1, but this is not OK, as the indexing for AVPs starts from 0...so it will not be consistent
• have the function taking a second output parameter, a variable to return the index.