@@ -1,3 +1,4 @@

+

 /*

  * $Id$

  *

@@ -714,6 +715,12 @@ int do_action(struct action* a, struct sip_msg* msg)

 	        case ADD_T:

 	        case ASSIGN_T:

+		

+			/* If the left attr was specified withou indexing brackets delete

+			 * existing AVPs before adding new ones

+			 */

+			if ((a->p1.attr->type & AVP_INDEX_ALL) != AVP_INDEX_ALL) delete_avp(a->p1.attr->type, a->p1.attr->name);

+			

 			if (a->p2_type == STRING_ST) {

 				value.s = a->p2.str;

 				flags = a->p1.attr->type | AVP_VAL_STR;

@@ -750,27 +757,45 @@ int do_action(struct action* a, struct sip_msg* msg)

 			} else if (a->p2_type == AVP_ST) {

 				struct search_state st;

 				avp_t* avp; 

+				avp_t* avp_mark;

-				     /* If the action is assign then remove the old avp value before adding

-				      * new ones

-				      */

-				if ((unsigned char)a->type == ASSIGN_T) delete_avp(a->p1.attr->type, a->p1.attr->name);

-

-				avp = search_first_avp(a->p2.attr->type, a->p2.attr->name, &value, &st);

-				while(avp) {

-					     /* We take only the type of value and name from the source avp

-					      * and reset class and track flags

-					      */

-					flags = a->p1.attr->type | (avp->flags & ~(AVP_CLASS_ALL|AVP_TRACK_ALL));

-					if (add_avp(flags, name, value) < 0) {

-						LOG(L_CRIT, "ERROR: Failed to assign value to attribute\n");

-					 	ret=E_UNSPEC;

+				avp_mark = NULL;

+				if ((a->p2.attr->type & AVP_INDEX_ALL) == AVP_INDEX_ALL) {

+					avp = search_first_avp(a->p2.attr->type, a->p2.attr->name, &value, &st);

+					while(avp) {

+						     /* We take only the type of value and name from the source avp

+						      * and reset class and track flags

+						      */

+						flags = (a->p1.attr->type & ~AVP_INDEX_ALL) | (avp->flags & ~(AVP_CLASS_ALL|AVP_TRACK_ALL));

+						

+						if (add_avp_before(avp_mark, flags, a->p1.attr->name, value) < 0) {

+							LOG(L_CRIT, "ERROR: Failed to assign value to attribute\n");

+							ret=E_UNSPEC;

+							break;

+						}

+						

+						/* move the mark, so the next found AVP will come before the one currently added

+						 * so they will have the same order as in the source list

+						 */

+						if (avp_mark) {

+							avp_mark=avp_mark->next;

+						} else {

+							avp_mark=search_first_avp(flags, a->p1.attr->name, NULL, NULL);

+						}

+							

+						avp = search_next_avp(&st, &value);

+					}

+					ret = 1;

+					break;

+				} else {

+					avp = search_avp_by_index(a->p2.attr->type, a->p2.attr->name, &value, a->p2.attr->index);

+					if (avp) {

+						flags = a->p1.attr->type | (avp->flags & ~(AVP_CLASS_ALL|AVP_TRACK_ALL));

+					} else {

+						ret = E_UNSPEC;

 						break;

 					}

-					avp = search_next_avp(&st, &value);

 				}

-				ret = 1;

-				break;

 			} else if (a->p2_type == SELECT_ST) {

 				int r;

 				r = run_select(&value.s, a->p2.select, msg);

@@ -793,8 +818,8 @@ int do_action(struct action* a, struct sip_msg* msg)

 			/* If the action is assign then remove the old avp value

 			 * before adding new ones */

-			if ((unsigned char)a->type == ASSIGN_T) delete_avp(flags, name);

-			if (add_avp(flags, name, value) < 0) {

+//			if ((unsigned char)a->type == ASSIGN_T) delete_avp(flags, name);

+			if (add_avp(flags & ~AVP_INDEX_ALL, name, value) < 0) {

 				LOG(L_CRIT, "ERROR: Failed to assign value to attribute\n");

 				ret=E_UNSPEC;

 				break;

@@ -510,6 +510,10 @@ EAT_ABLE	[\ \t\b\r]

 <ATTR>{ATTR_TODOMAIN}   { count(); return ATTR_TODOMAIN; }

 <ATTR>{ATTR_GLOBAL}     { count(); return ATTR_GLOBAL; }

 <ATTR>{DOT}             { count(); return DOT; }

+<ATTR>{LBRACK}          { count(); return LBRACK; }

+<ATTR>{RBRACK}          { count(); return RBRACK; }

+<ATTR>{STAR}		{ count(); return STAR; }

+<ATTR>{DECNUMBER}	{ count(); yylval.intval=atoi(yytext);return NUMBER; }

 <ATTR>{ID}		{ count(); addstr(&s_buf, yytext, yyleng); 

                            yylval.strval=s_buf.s;

 			   memset(&s_buf, 0, sizeof(s_buf));

@@ -67,6 +67,7 @@

  * 2005-12-11  added onsend_route support, fcmd (filtered cmd),

  *             snd_{ip,port,proto,af}, to_{ip,proto} (andrei)

  * 2005-12-19  select framework (mma)

+ * 2006-01-06  AVP index support (mma)

  *

  */

@@ -336,6 +337,11 @@ static struct socket_id* mk_listen_id(char*, int, int);

 %type <strval> host_sep

 %type <intval> uri_type

 %type <attr> attr_id

+%type <attr> attr_id_num_idx

+%type <attr> attr_id_no_idx

+%type <attr> attr_id_ass

+%type <attr> attr_id_val

+%type <attr> attr_id_any

 //%type <intval> class_id

 %type <intval> assign_op

 %type <select> select_id

@@ -957,7 +963,7 @@ uri_type:	URI			{$$=URI_O;}

 		;

 exp_elem:	METHOD strop STRING	{$$= mk_elem($2, METHOD_O, 0, STRING_ST, $3);}

-                | METHOD strop attr_id  {$$ = mk_elem($2, METHOD_O, 0, AVP_ST, $3); }

+                | METHOD strop attr_id_val  {$$ = mk_elem($2, METHOD_O, 0, AVP_ST, $3); }

                 | METHOD strop select_id {$$ = mk_elem($2, METHOD_O, 0, SELECT_ST, $3); }

 		| METHOD strop  ID	{$$ = mk_elem($2, METHOD_O, 0, STRING_ST,$3); }

 		| METHOD strop error { $$=0; yyerror("string expected"); }

@@ -966,7 +972,7 @@ exp_elem:	METHOD strop STRING	{$$= mk_elem($2, METHOD_O, 0, STRING_ST, $3);}

 						}

 		| uri_type strop STRING	{$$ = mk_elem($2, $1, 0, STRING_ST, $3); }

                 | uri_type strop host 	{$$ = mk_elem($2, $1, 0, STRING_ST, $3); }

-                | uri_type strop attr_id {$$ = mk_elem($2, $1, 0, AVP_ST, $3); }

+                | uri_type strop attr_id_val {$$ = mk_elem($2, $1, 0, AVP_ST, $3); }

                 | uri_type strop select_id {$$ = mk_elem($2, $1, 0, SELECT_ST, $3); }

                 | uri_type equalop MYSELF {$$=mk_elem($2, $1, 0, MYSELF_ST, 0); }

 		| uri_type strop error { $$=0; yyerror("string or MYSELF expected"); }

@@ -974,19 +980,19 @@ exp_elem:	METHOD strop STRING	{$$= mk_elem($2, METHOD_O, 0, STRING_ST, $3);}

 									" == , != or =~ expected");

 					}

 		| SRCPORT intop NUMBER	{ $$=mk_elem($2, SRCPORT_O, 0, NUMBER_ST, (void*)$3 ); }

-		| SRCPORT intop attr_id { $$=mk_elem($2, SRCPORT_O, 0, AVP_ST, (void*)$3 ); }

+		| SRCPORT intop attr_id_val { $$=mk_elem($2, SRCPORT_O, 0, AVP_ST, (void*)$3 ); }

 		| SRCPORT intop error { $$=0; yyerror("number expected"); }

 		| SRCPORT error { $$=0; yyerror("==, !=, <,>, >= or <=  expected"); }

 		| DSTPORT intop NUMBER	{ $$=mk_elem($2, DSTPORT_O, 0, NUMBER_ST, (void*)$3 ); }

-		| DSTPORT intop attr_id	{ $$=mk_elem($2, DSTPORT_O, 0, AVP_ST, (void*)$3 ); }

+		| DSTPORT intop attr_id_val	{ $$=mk_elem($2, DSTPORT_O, 0, AVP_ST, (void*)$3 ); }

 		| DSTPORT intop error { $$=0; yyerror("number expected"); }

 		| DSTPORT error { $$=0; yyerror("==, !=, <,>, >= or <=  expected"); }

 		| SNDPORT intop NUMBER	{	onsend_check("snd_port");

 									$$=mk_elem($2, SNDPORT_O, 0, NUMBER_ST,

 												(void*)$3 ); }

-		| SNDPORT intop attr_id {	onsend_check("snd_port");

+		| SNDPORT intop attr_id_val {	onsend_check("snd_port");

 									$$=mk_elem($2, SNDPORT_O, 0, AVP_ST,

 												(void*)$3 ); }

 		| SNDPORT intop error { $$=0; yyerror("number expected"); }

@@ -995,14 +1001,14 @@ exp_elem:	METHOD strop STRING	{$$= mk_elem($2, METHOD_O, 0, STRING_ST, $3);}

 		| TOPORT intop NUMBER	{	onsend_check("to_port");

 									$$=mk_elem($2, TOPORT_O, 0, NUMBER_ST,

 												(void*)$3 ); }

-		| TOPORT intop attr_id {	onsend_check("to_port");

+		| TOPORT intop attr_id_val {	onsend_check("to_port");

 									$$=mk_elem($2, TOPORT_O, 0, AVP_ST,

 												(void*)$3 ); }

 		| TOPORT intop error { $$=0; yyerror("number expected"); }

 		| TOPORT error { $$=0; yyerror("==, !=, <,>, >= or <=  expected"); }

 		| PROTO intop proto	{ $$=mk_elem($2, PROTO_O, 0, NUMBER_ST, (void*)$3 ); }

-		| PROTO intop attr_id	{ $$=mk_elem($2, PROTO_O, 0, AVP_ST, (void*)$3 ); }

+		| PROTO intop attr_id_val	{ $$=mk_elem($2, PROTO_O, 0, AVP_ST, (void*)$3 ); }

 		| PROTO intop error { $$=0;

 								yyerror("protocol expected (udp, tcp or tls)");

 							}

@@ -1011,7 +1017,7 @@ exp_elem:	METHOD strop STRING	{$$= mk_elem($2, METHOD_O, 0, STRING_ST, $3);}

 		| SNDPROTO intop proto	{	onsend_check("snd_proto");

 									$$=mk_elem($2, SNDPROTO_O, 0, NUMBER_ST,

 										(void*)$3 ); }

-		| SNDPROTO intop attr_id {	onsend_check("snd_proto");

+		| SNDPROTO intop attr_id_val {	onsend_check("snd_proto");

 									$$=mk_elem($2, SNDPROTO_O, 0, AVP_ST,

 										(void*)$3 ); }

 		| SNDPROTO intop error { $$=0;

@@ -1020,28 +1026,28 @@ exp_elem:	METHOD strop STRING	{$$= mk_elem($2, METHOD_O, 0, STRING_ST, $3);}

 		| SNDPROTO error { $$=0; yyerror("equal/!= operator expected"); }

 		| AF intop NUMBER	{ $$=mk_elem($2, AF_O, 0, NUMBER_ST,(void *) $3 ); }

-		| AF intop attr_id	{ $$=mk_elem($2, AF_O, 0, AVP_ST,(void *) $3 ); }

+		| AF intop attr_id_val	{ $$=mk_elem($2, AF_O, 0, AVP_ST,(void *) $3 ); }

 		| AF intop error { $$=0; yyerror("number expected"); }

 		| AF error { $$=0; yyerror("equal/!= operator expected"); }

 		| SNDAF intop NUMBER	{	onsend_check("snd_af");

 									$$=mk_elem($2, SNDAF_O, 0, NUMBER_ST,

 										(void *) $3 ); }

-		| SNDAF intop attr_id	{	onsend_check("snd_af");

+		| SNDAF intop attr_id_val	{	onsend_check("snd_af");

 									$$=mk_elem($2, SNDAF_O, 0, AVP_ST,

 										(void *) $3 ); }

 		| SNDAF intop error { $$=0; yyerror("number expected"); }

 		| SNDAF error { $$=0; yyerror("equal/!= operator expected"); }

 		| MSGLEN intop NUMBER	{ $$=mk_elem($2, MSGLEN_O, 0, NUMBER_ST, (void *) $3 ); }

-		| MSGLEN intop attr_id	{ $$=mk_elem($2, MSGLEN_O, 0, AVP_ST, (void *) $3 ); }

+		| MSGLEN intop attr_id_val	{ $$=mk_elem($2, MSGLEN_O, 0, AVP_ST, (void *) $3 ); }

 		| MSGLEN intop MAX_LEN	{ $$=mk_elem($2, MSGLEN_O, 0, NUMBER_ST, (void *) BUF_SIZE); }

 		| MSGLEN intop error { $$=0; yyerror("number expected"); }

 		| MSGLEN error { $$=0; yyerror("equal/!= operator expected"); }

 		| RETCODE intop NUMBER	{ $$=mk_elem($2, RETCODE_O, 0,

 												NUMBER_ST, (void *) $3 ); }

-		| RETCODE intop attr_id	{ $$=mk_elem($2, RETCODE_O, 0,

+		| RETCODE intop attr_id_val	{ $$=mk_elem($2, RETCODE_O, 0,

 												AVP_ST, (void *) $3 ); }

 		| RETCODE intop error { $$=0; yyerror("number expected"); }

 		| RETCODE error { $$=0; yyerror("equal/!= operator expected"); }

@@ -1172,16 +1178,16 @@ exp_elem:	METHOD strop STRING	{$$= mk_elem($2, METHOD_O, 0, STRING_ST, $3);}

 		| exp_stm			{ $$=mk_elem( NO_OP, ACTION_O, 0, ACTIONS_ST, $1);  }

 		| NUMBER		{$$=mk_elem( NO_OP, NUMBER_O, 0, NUMBER_ST, (void*)$1 ); }

-		| attr_id		{$$=mk_elem( NO_OP, AVP_O, (void*)$1, 0, 0); }

-		| attr_id strop STRING	{$$=mk_elem( $2, AVP_O, (void*)$1, STRING_ST, $3); }

-		| attr_id strop select_id {$$=mk_elem( $2, AVP_O, (void*)$1, SELECT_ST, $3); }

-		| attr_id intop NUMBER	{$$=mk_elem( $2, AVP_O, (void*)$1, NUMBER_ST, (void*)$3); }

-		| attr_id binop NUMBER	{$$=mk_elem( $2, AVP_O, (void*)$1, NUMBER_ST, (void*)$3); }

-                | attr_id strop attr_id {$$=mk_elem( $2, AVP_O, (void*)$1, AVP_ST, (void*)$3); }

+		| attr_id_val		{$$=mk_elem( NO_OP, AVP_O, (void*)$1, 0, 0); }

+		| attr_id_val strop STRING	{$$=mk_elem( $2, AVP_O, (void*)$1, STRING_ST, $3); }

+		| attr_id_val strop select_id {$$=mk_elem( $2, AVP_O, (void*)$1, SELECT_ST, $3); }

+		| attr_id_val intop NUMBER	{$$=mk_elem( $2, AVP_O, (void*)$1, NUMBER_ST, (void*)$3); }

+		| attr_id_val binop NUMBER	{$$=mk_elem( $2, AVP_O, (void*)$1, NUMBER_ST, (void*)$3); }

+                | attr_id_val strop attr_id_val {$$=mk_elem( $2, AVP_O, (void*)$1, AVP_ST, (void*)$3); }

                 | select_id                 { $$=mk_elem( NO_OP, SELECT_O, $1, 0, 0); }

 		| select_id strop STRING    { $$=mk_elem( $2, SELECT_O, $1, STRING_ST, $3); }

-		| select_id strop attr_id   { $$=mk_elem( $2, SELECT_O, $1, AVP_ST, (void*)$3); }

+		| select_id strop attr_id_val   { $$=mk_elem( $2, SELECT_O, $1, AVP_ST, (void*)$3); }

 		| select_id strop select_id { $$=mk_elem( $2, SELECT_O, $1, SELECT_ST, $3); }

 ;

@@ -1334,67 +1340,62 @@ select_id : SELECT_MARK { sel.n = 0; sel.f = 0; } select_params {

 }

 ;

+attr_class_spec: ATTR_FROMUSER { s_attr->type |= AVP_TRACK_FROM | AVP_CLASS_USER; } 

+		|ATTR_TOUSER { s_attr->type |= AVP_TRACK_TO | AVP_CLASS_USER; } 

+		|ATTR_FROMDOMAIN { s_attr->type |= AVP_TRACK_FROM | AVP_CLASS_DOMAIN; } 

+		|ATTR_TODOMAIN { s_attr->type |= AVP_TRACK_TO | AVP_CLASS_DOMAIN; } 

+		|ATTR_GLOBAL { s_attr->type |= AVP_TRACK_ALL | AVP_CLASS_GLOBAL; } 

-attr_id : ATTR_MARK ID { s_attr = (struct avp_spec*)pkg_malloc(sizeof(struct avp_spec));

-                         if (!s_attr) { yyerror("No memory left"); }

-                         s_attr->type = AVP_NAME_STR;                   

-                         s_attr->name.s.s = $2; s_attr->name.s.len = strlen($2); 

-                         $$ = s_attr; 

-                       }

-//        | ATTR_MARK class_id DOT ID { s_attr = (struct avp_spec*)pkg_malloc(sizeof(struct avp_spec));

-//                                      if (!s_attr) { yyerror("No memory left"); }

-//                                      s_attr->type = AVP_NAME_STR | $2;

-//                                      s_attr->name.s.s = $4; s_attr->name.s.len = strlen($4); 

-//                                      $$ = s_attr; 

-//                                    }

-        | ATTR_MARK ATTR_FROMUSER DOT ID { s_attr = (struct avp_spec*)pkg_malloc(sizeof(struct avp_spec));

-                                       if (!s_attr) { yyerror("No memory left"); }

-                                       s_attr->type = AVP_NAME_STR | AVP_TRACK_FROM | AVP_CLASS_USER;

-                                       s_attr->name.s.s = $4; s_attr->name.s.len = strlen($4);

-                                       $$ = s_attr;

-                                     }

-        | ATTR_MARK ATTR_TOUSER DOT ID { s_attr = (struct avp_spec*)pkg_malloc(sizeof(struct avp_spec));

-                                       if (!s_attr) { yyerror("No memory left"); }

-                                       s_attr->type = AVP_NAME_STR | AVP_TRACK_TO | AVP_CLASS_USER;

-                                       s_attr->name.s.s = $4; s_attr->name.s.len = strlen($4);

-                                       $$ = s_attr;

-                                     }

-        | ATTR_MARK ATTR_FROMDOMAIN DOT ID { s_attr = (struct avp_spec*)pkg_malloc(sizeof(struct avp_spec));

-                                       if (!s_attr) { yyerror("No memory left"); }

-                                       s_attr->type = AVP_NAME_STR | AVP_TRACK_FROM | AVP_CLASS_DOMAIN;

-                                       s_attr->name.s.s = $4; s_attr->name.s.len = strlen($4);

-                                       $$ = s_attr;

-                                     }

-        | ATTR_MARK ATTR_TODOMAIN DOT ID { s_attr = (struct avp_spec*)pkg_malloc(sizeof(struct avp_spec));

-                                       if (!s_attr) { yyerror("No memory left"); }

-                                       s_attr->type = AVP_NAME_STR | AVP_TRACK_TO | AVP_CLASS_DOMAIN;

-                                       s_attr->name.s.s = $4; s_attr->name.s.len = strlen($4);

-                                       $$ = s_attr;

-                                     }

-        | ATTR_MARK ATTR_GLOBAL DOT ID { s_attr = (struct avp_spec*)pkg_malloc(sizeof(struct avp_spec));

-                                       if (!s_attr) { yyerror("No memory left"); }

-                                       s_attr->type = AVP_NAME_STR | AVP_CLASS_GLOBAL;

-                                       s_attr->name.s.s = $4; s_attr->name.s.len = strlen($4);

-                                       $$ = s_attr;

-                                     }

-//        | ATTR_MARK ATTR_TO class_id DOT ID { s_attr = (struct avp_spec*)pkg_malloc(sizeof(struct avp_spec));

-//                                              if (!s_attr) { yyerror("No memory left"); }

-//                                              s_attr->type = AVP_NAME_STR | AVP_TRACK_TO | $3;

-//                                              s_attr->name.s.s = $5; s_attr->name.s.len = strlen($5);

-//                                             $$ = s_attr;

-//                                            }

+attr_name_spec : ID { s_attr->type |= AVP_NAME_STR; s_attr->name.s.s = $1; s_attr->name.s.len = strlen ($1); }

+;

+	       

+attr_spec : attr_name_spec |

+	    attr_class_spec DOT attr_name_spec

+;

+

+attr_mark : ATTR_MARK 

+	{	s_attr = (struct avp_spec*)pkg_malloc(sizeof(struct avp_spec));

+                if (!s_attr) { yyerror("No memory left"); }

+                s_attr->type = 0;  

+	}

+;

+

+attr_id : attr_mark attr_spec { $$ = s_attr; }	  

+;

+

+attr_id_num_idx : attr_mark attr_spec LBRACK NUMBER RBRACK

+	       	{	s_attr->type|= (AVP_NAME_STR | ($4<0?AVP_INDEX_BACKWARD:AVP_INDEX_FORWARD)); 

+			s_attr->index = ($4<0?-$4:$4);

+	       		$$ = s_attr; 

+	       	}	  

+;

+

+attr_id_no_idx : attr_mark attr_spec LBRACK RBRACK

+	       	{	s_attr->type|= AVP_INDEX_ALL; 

+	       		$$ = s_attr;

+		}	  

+;

+

+attr_id_ass : attr_id | attr_id_no_idx

+;

+

+attr_id_val : attr_id | attr_id_num_idx

+;

+

+attr_id_any : attr_id | attr_id_no_idx | attr_id_num_idx

 ;

-assign_op : ADDEQ { $$ = ADD_T; }

-          | EQUAL { $$ = ASSIGN_T; }

+//assign_op : ADDEQ { $$ = ADD_T; }

+//          | EQUAL { $$ = ASSIGN_T; }

+assign_op : EQUAL { $$ = ASSIGN_T; }

 ;

-assign_action:   attr_id assign_op STRING  { $$=mk_action($2, AVP_ST, STRING_ST, $1, $3); }

-               | attr_id assign_op NUMBER  { $$=mk_action($2, AVP_ST, NUMBER_ST, $1, (void*)$3); }

-               | attr_id assign_op fcmd    { $$=mk_action($2, AVP_ST, ACTION_ST, $1, $3); }

-               | attr_id assign_op attr_id { $$=mk_action($2, AVP_ST, AVP_ST, $1, $3); }

-               | attr_id assign_op select_id { $$=mk_action($2, AVP_ST, SELECT_ST, (void*)$1, (void*)$3); }

-               | attr_id assign_op LPAREN exp RPAREN { $$ = mk_action($2, AVP_ST, EXPR_ST, $1, $4); }

+assign_action:   attr_id_ass assign_op STRING  { $$=mk_action($2, AVP_ST, STRING_ST, $1, $3); }

+               | attr_id_ass assign_op NUMBER  { $$=mk_action($2, AVP_ST, NUMBER_ST, $1, (void*)$3); }

+               | attr_id_ass assign_op fcmd    { $$=mk_action($2, AVP_ST, ACTION_ST, $1, $3); }

+               | attr_id_ass assign_op attr_id_any { $$=mk_action($2, AVP_ST, AVP_ST, $1, $3); }

+               | attr_id_ass assign_op select_id { $$=mk_action($2, AVP_ST, SELECT_ST, (void*)$1, (void*)$3); }

+               | attr_id_ass assign_op LPAREN exp RPAREN { $$ = mk_action($2, AVP_ST, EXPR_ST, $1, $4); }

 ;

 cmd:		FORWARD LPAREN host RPAREN	{ $$=mk_action(	FORWARD_T,

@@ -198,6 +198,7 @@ int parse_tw_append( modparam_t type, void* val)

 	char bar;

 	str foo;

 	int n;

+	int index;

 	if (val==0 || ((char*)val)[0]==0)

 		return 0;

@@ -314,7 +315,7 @@ int parse_tw_append( modparam_t type, void* val)

 		/* process and optimize the element name */

 		if (ha->type==ELEM_IS_AVP) {

 			/* element is AVP */

-			if ( parse_avp_spec( &foo, &n, &avp_name)!=0 ) {

+			if ( parse_avp_spec( &foo, &n, &avp_name, &index)!=0 ) {

 				LOG(L_ERR,"ERROR:tm:parse_tw_append: bad alias spec "

 					"<%.*s>\n",foo.len, foo.s);

 				goto error;

@@ -67,9 +67,11 @@

 static int     fr_timer_avp_type = 0;

 static int_str fr_timer_avp = {0};

 static str     fr_timer_str;

+static int     fr_timer_index = 0;

 static int     fr_inv_timer_avp_type = 0;

 static int_str fr_inv_timer_avp = {0};

 static str     fr_inv_timer_str;

+static int     fr_inv_timer_index = 0;

 /* ----------------------------------------------------- */

@@ -298,7 +300,7 @@ int init_avp_params(char *fr_timer_param, char *fr_inv_timer_param)

 		fr_timer_str.s = fr_timer_param;

 		fr_timer_str.len = strlen(fr_timer_str.s);

 		if (parse_avp_spec( &fr_timer_str, &fr_timer_avp_type,

-		&fr_timer_avp)<0) {

+		&fr_timer_avp, &fr_timer_index)<0) {

 			LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid fr_timer "

 				"AVP specs \"%s\"\n", fr_timer_param);

 			return -1;

@@ -309,7 +311,7 @@ int init_avp_params(char *fr_timer_param, char *fr_inv_timer_param)

 		fr_inv_timer_str.s = fr_inv_timer_param;

 		fr_inv_timer_str.len = strlen(fr_inv_timer_str.s);

 		if (parse_avp_spec( &fr_inv_timer_str, &fr_inv_timer_avp_type, 

-		&fr_inv_timer_avp)<0) {

+		&fr_inv_timer_avp, &fr_inv_timer_index)<0) {

 			LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid fr_inv_timer "

 				"AVP specs \"%s\"\n", fr_inv_timer_param);

 			return -1;

@@ -367,7 +367,7 @@ inline static int comp_num(int op, long left, int rtype, union exp_op* r)

 	long right;

 	if (rtype == AVP_ST) {

-		avp = search_first_avp(r->attr->type, r->attr->name, &val, 0);

+		avp = search_avp_by_index(r->attr->type, r->attr->name, &val, r->attr->index);

 		if (avp && !(avp->flags & AVP_VAL_STR)) right = val.n;

 		else return 0; /* Always fail */

 	} else if (rtype == NUMBER_ST) {

@@ -406,7 +406,7 @@ inline static int comp_str(int op, str* left, int rtype, union exp_op* r, struct

 	right=0; /* warning fix */

 	if (rtype == AVP_ST) {

-		avp = search_first_avp(r->attr->type, r->attr->name, &val, 0);

+		avp = search_avp_by_index(r->attr->type, r->attr->name, &val, r->attr->index);

 		if (avp && (avp->flags & AVP_VAL_STR)) right = &val.s;

 		else return 0;

 	} else if (rtype == SELECT_ST) {

@@ -531,7 +531,7 @@ inline static int comp_avp(int op, avp_spec_t* spec, int rtype, union exp_op* r,

 	avp_t* avp;

 	int_str val;

-	avp = search_first_avp(spec->type, spec->name, &val, 0);

+	avp = search_avp_by_index(spec->type, spec->name, &val, spec->index);

 	if (!avp) return 0;

 	switch(op) {

@@ -30,6 +30,7 @@

  *  2004-10-09  interface more flexible - more function available (bogdan)

  *  2004-11-07  AVP string values are kept 0 terminated (bogdan)

  *  2004-11-14  global aliases support added

+ *  2005-01-05  parse avp name according new syntax

  */

@@ -131,7 +132,7 @@ inline static unsigned short compute_ID( str *name )

 }

-int add_avp_list(avp_list_t* list, unsigned short flags, int_str name, int_str val)

+avp_t *create_avp (unsigned short flags, int_str name, int_str val)

 {

 	avp_t *avp;

 	str *s;

@@ -139,13 +140,11 @@ int add_avp_list(avp_list_t* list, unsigned short flags, int_str name, int_str v

 	struct str_str_data *ssd;

 	int len;

-	assert(list != 0);

-

 	if (name.s.s == 0 && name.s.len == 0) {

 		LOG(L_ERR,"ERROR:avp:add_avp: 0 ID or NULL NAME AVP!");

 		goto error;

 	}

-

+	

 	/* compute the required mem size */

 	len = sizeof(struct usr_avp);

 	if (flags&AVP_NAME_STR) {

@@ -168,14 +167,12 @@ int add_avp_list(avp_list_t* list, unsigned short flags, int_str name, int_str v

 	avp = (struct usr_avp*)shm_malloc( len );

 	if (avp==0) {

 		LOG(L_ERR,"ERROR:avp:add_avp: no more shm mem\n");

-		goto error;

+		return 0;

 	}

 	avp->flags = flags;

 	avp->id = (flags&AVP_NAME_STR)? compute_ID(&name.s) : name.n ;

-

-	avp->next = *list;

-	*list = avp;

+	avp->next = NULL;

 	switch ( flags&(AVP_NAME_STR|AVP_VAL_STR) )

 	{

@@ -213,9 +210,23 @@ int add_avp_list(avp_list_t* list, unsigned short flags, int_str name, int_str v

 			ssd->val.s[ssd->val.len] = 0;

 			break;

 	}

-

-	return 0;

+	return avp;

 error:

+	return 0;

+}

+

+int add_avp_list(avp_list_t* list, unsigned short flags, int_str name, int_str val)

+{

+	avp_t *avp;

+

+	assert(list != 0);

+

+	if ((avp = create_avp(flags, name, val))) {

+		avp->next = *list;

+		*list = avp;

+		return 0;

+	}

+	

 	return -1;

 }

@@ -242,6 +253,28 @@ int add_avp(unsigned short flags, int_str name, int_str val)

 	return add_avp_list(list, flags & (~(AVP_CLASS_ALL) | avp_class), name, val);

 }

+int add_avp_before(avp_t *avp, unsigned short flags, int_str name, int_str val)

+{

+	avp_t *new_avp;

+	

+	if (!avp) {

+		return add_avp(flags, name, val);

+	}

+

+	if ((flags & AVP_CLASS_ALL) == 0) flags |= (avp->flags & AVP_CLASS_ALL);

+	if ((flags & AVP_TRACK_ALL) == 0) flags |= (avp->flags & AVP_TRACK_ALL);

+	

+	if ((avp->flags & (AVP_CLASS_ALL|AVP_TRACK_ALL)) != (flags & (AVP_CLASS_ALL|AVP_TRACK_ALL))) {

+		ERR("add_avp_before:Source and target AVPs have different CLASS/TRACK\n");

+		return -1;

+	}

+	if ((new_avp=create_avp(flags, name, val))) {

+		new_avp->next=avp->next;

+		avp->next=new_avp;

+		return 0;

+	}

+	return -1;

+}

 /* get value functions */

 inline str* get_avp_name(avp_t *avp)

@@ -358,6 +391,13 @@ avp_t *search_first_avp(unsigned short flags, int_str name, int_str *val, struct

 		LOG(L_ERR,"ERROR:avp:search_first_avp: 0 ID or NULL NAME AVP!");

 		return 0;

 	}

+	

+	switch (flags & AVP_INDEX_ALL) {

+		case AVP_INDEX_BACKWARD:

+		case AVP_INDEX_FORWARD:

+			WARN("AVP specified with index, but not used for search\n");

+			break;

+	}

 	if (!s) s = &st;

@@ -366,6 +406,17 @@ avp_t *search_first_avp(unsigned short flags, int_str name, int_str *val, struct

 		      * all of them by default

 		      */

 		flags |= AVP_CLASS_ALL;

+		

+		if ((flags & AVP_TRACK_ALL) == 0) {

+		    /* The caller did not specify even the track to search in, so try

+		     * track_from first, and if not found try track_to

+		     */

+		     	ret = search_first_avp(flags | AVP_TRACK_FROM, name, val, s);

+		     	if (ret) {

+		     		return ret;

+		     	}

+		     	flags |= AVP_TRACK_TO;

+		}

 	}

 	list = select_list(flags);

@@ -399,6 +450,13 @@ avp_t *search_next_avp(struct search_state* s, int_str *val )

 		return 0;

 	}

+	switch (s->flags & AVP_INDEX_ALL) {

+		case AVP_INDEX_BACKWARD:

+		case AVP_INDEX_FORWARD:

+			WARN("AVP specified with index, but not used for search\n");

+			break;

+	}

+

 	while(1) {

 		for( ; s->avp; s->avp = s->avp->next) {

 			if (s->flags & AVP_NAME_RE) {

@@ -431,6 +489,54 @@ avp_t *search_next_avp(struct search_state* s, int_str *val )

 	return 0;

 }

+int search_reverse( avp_t *cur, struct search_state* st,

+                     unsigned short index, avp_list_t *ret)

+{

+	unsigned short lvl;

+	

+	if (!cur)

+		return 0;

+	lvl = search_reverse(search_next_avp(st, NULL), st, index, ret)+1;

+	if (index==lvl)

+		*ret=cur;

+	return lvl;

+}

+                            

+avp_t *search_avp_by_index( unsigned short flags, int_str name,

+                            int_str *val, unsigned short index) 	

+{

+	avp_t *ret, *cur;

+	struct search_state st;

+	

+	if (flags & AVP_NAME_RE) {

+		BUG("search_by_index not supported for AVP_NAME_RE\n");

+		return 0;

+	}

+	switch (flags & AVP_INDEX_ALL) {

+		case 0:

+			ret = search_first_avp(flags, name, val, &st);

+			if (!ret || search_next_avp(&st, NULL))

+				return 0;

+			else

+				return ret;

+		case AVP_INDEX_ALL:

+			BUG("search_by_index not supported for anonymous index []\n");

+			return 0;

+		case AVP_INDEX_FORWARD:

+			ret = NULL;

+			cur = search_first_avp(flags & ~AVP_INDEX_ALL, name, NULL, &st);

+			search_reverse(cur, &st, index, &ret);

+			if (ret && val)

+				get_avp_val(ret, val);

+			return ret;

+		case AVP_INDEX_BACKWARD:

+			ret = search_first_avp(flags & ~AVP_INDEX_ALL, name, val, &st);

+			for (index--; (ret && index); ret=search_next_avp(&st, val), index--);

+			return ret;

+	}

+		

+	return 0;

+}                            

 /* FIXME */

 /********* free functions ********/

@@ -647,16 +753,28 @@ int lookup_avp_galias(str *alias, int *type, int_str *avp_name)

 /* parsing functions */

+#define ERR_IF_CONTAINS(name,chr) \

+	if (memchr(name->s,chr,name->len)) { \

+		ERR("Unexpected control character '%c' in AVP name\n", chr); \

+		goto error; \

+	}

-int parse_avp_name( str *name, int *type, int_str *avp_name)

+int parse_avp_name( str *name, int *type, int_str *avp_name, int *index)

 {

 	unsigned int id;

 	char c;

+	char *p;

+	str s;

-	if (name==0 || name->s==0 || name->len==0)

+	if (name==0 || name->s==0 || name->len==0) {

+		ERR("NULL name or name->s or name->len\n");

 		goto error;

+	}

-	if (name->len>=2 && name->s[1]==':') {

+	if (index) *index = 0;

+	ERR("Parsing '%.*s'\n", name->len, name->s);

+	if (name->len>=2 && name->s[1]==':') { // old fashion i: or s:

+		WARN("i: and s: avp name syntax is deprecated!\n");

 		c = name->s[0];

 		name->s += 2;

 		name->len -= 2;

@@ -670,17 +788,108 @@ int parse_avp_name( str *name, int *type, int_str *avp_name)

 			case 'i': case 'I':

 				*type = 0;

 				if (str2int( name, &id)!=0) {

-					LOG(L_ERR, "ERROR:parse_avp_name: invalid ID "

+					ERR("invalid ID "

 						"<%.*s> - not a number\n", name->len, name->s);

 					goto error;

 				}

 				avp_name->n = (int)id;

 				break;

 			default:

-				LOG(L_ERR, "ERROR:parse_avp_name: unsupported type "

+				ERR("unsupported type "

 					"[%c]\n", c);

 				goto error;

 		}

+	} else if ((p=memchr(name->s, '.', name->len))) {

+		if (p-name->s==1) {

+			id=name->s[0];

+			name->s +=2;

+			name->len -=2;

+		} else if (p-name->s==2) {

+			id=name->s[0]<<8 | name->s[1];

+			name->s +=3;

+			name->len -=3;

+		} else {

+			ERR("AVP unknown class prefix '%.*s'\n", p-name->s,name->s);

+			goto error;

+		}

+		if (name->len==0) {

+			ERR("AVP name not specified after the prefix separator\n");

+			goto error;

+		}

+		switch (id) {

+			case 'f':

+				*type = AVP_TRACK_FROM | AVP_CLASS_USER;

+				break;

+			case 't':

+				*type = AVP_TRACK_TO | AVP_CLASS_USER;

+				break;

+			case 0x6664: //'fd'

+				*type = AVP_TRACK_FROM | AVP_CLASS_DOMAIN;

+				break;

+			case 0x7464: // 'td'

+				*type = AVP_TRACK_TO | AVP_CLASS_DOMAIN;

+				break;

+			case 'g':

+				*type = AVP_TRACK_ALL | AVP_CLASS_GLOBAL;

+				break;

+			default:

+				if (id < 1<<8)

+					ERR("AVP unknown class prefix '%c'\n", id);

+				else

+					ERR("AVP unknown class prefix '%c%c'\n", id>>8,id);

+				goto error;

+		}

+		if (name->s[name->len-1]==']') {

+			p=memchr(name->s, '[', name->len);

+			if (!p) {

+				ERR("missing '[' for AVP index\n");

+				goto error; 

+			}

+			s.s=p+1;

+			s.len=name->len-(p-name->s)-2; // [ and ]

+			if (s.len == 0) {

+				*type |= AVP_INDEX_ALL;

+			} else {

+				if (s.s[0]=='-') {

+					*type |= AVP_INDEX_BACKWARD;

+					s.s++;s.len--;

+				} else {

+					*type |= AVP_INDEX_FORWARD;

+				}	

+				if ((str2int(&s, &id) != 0)||(id==0)) {

+					ERR("Invalid AVP index '%.*s'\n", s.len, s.s);

+					goto error;

+				}

+				if (index){

+					*index = id;

+				} else {

+					WARN("AVP index correcly specified, but called without placeholed\n");

+				}

+			}

+			name->len=p-name->s;

+		}

+		ERR_IF_CONTAINS(name,'.');

+		ERR_IF_CONTAINS(name,'[');

+		ERR_IF_CONTAINS(name,']');

+		if ((name->len > 2) && (name->s[0]=='/') && (name->s[name->len-1]=='/')) {

+			avp_name->re=pkg_malloc(sizeof(regex_t));

+			if (!avp_name->re) {

+				BUG("No free memory to allocate AVP_NAME_RE regex\n");

+				goto error;

+			}

+			c=name->s[name->len];

+			name->s[name->len]=0;

+			if (regcomp(avp_name->re, name->s, REG_EXTENDED|REG_NOSUB|REG_ICASE)) {

+				pkg_free(avp_name->re);

+				name->s[name->len] = c;

+				goto error;

+			}

+			*type |= AVP_NAME_RE;

+		} else {

+			ERR_IF_CONTAINS(name,'/');

+			*type |= AVP_NAME_STR;

+		}

+		avp_name->s = *name;

 	} else {

 		/*default is string name*/

 		*type = AVP_NAME_STR;

@@ -693,7 +902,7 @@ error:

 }

-int parse_avp_spec( str *name, int *type, int_str *avp_name)

+int parse_avp_spec( str *name, int *type, int_str *avp_name, int *index)

 {

 	str alias;

@@ -710,10 +919,15 @@ int parse_avp_spec( str *name, int *type, int_str *avp_name)

 		alias.len = name->len-1;

 		return lookup_avp_galias( &alias, type, avp_name);

 	} else {

-		return parse_avp_name( name, type, avp_name);

+		return parse_avp_name( name, type, avp_name, index);

 	}

 }

+void free_avp_name( int *type, int_str *avp_name)

+{

+	if ((*type & AVP_NAME_RE) && (avp_name->re))

+		pkg_free(avp_name->re);

+}

 int add_avp_galias_str(char *alias_definition)

 {

@@ -722,7 +936,8 @@ int add_avp_galias_str(char *alias_definition)

 	str  name;

 	str  alias;

 	int  type;

-

+	int  index;

+	

 	s = alias_definition;

 	while(*s && isspace((int)*s))

 		s++;

@@ -761,7 +976,7 @@ int add_avp_galias_str(char *alias_definition)

 				goto parse_error;

 		}

-		if (parse_avp_name( &name, &type, &avp_name)!=0) {

+		if (parse_avp_name( &name, &type, &avp_name, &index)!=0) {

 			LOG(L_ERR, "ERROR:add_avp_galias_str: <%.*s> not a valid AVP "

 				"name\n", name.len, name.s);

 			goto error;

@@ -52,7 +52,8 @@

  *     7        core              avp is in global list

  *     8        core              avp is in the from avp list

  *     9        core              avp is in the to avp list

- *

+ *    10	core		  avp name with positive index

+ *    11	core		  avp name with negative index

  */

 #include "str.h"

@@ -65,6 +66,7 @@

 #define AVP_FR_INV_TIMER "fr_inv_timer"  /* Value of final response invite timer */

 #define AVP_RPID         "rpid"          /* Remote-Party-ID */

 #define AVP_GFLAGS       "gflags"        /* global flags */

+#define AVP_FLAGS	 "flags"	 /* message flags */

 struct str_int_data {

 	str name;

@@ -109,6 +111,7 @@ struct search_state {

 typedef struct avp_spec {

 	int type;

 	int_str name;

+	int index;

 } avp_spec_t;

 /* AVP types */

@@ -128,6 +131,11 @@ typedef struct avp_spec {

 #define AVP_CLASS_ALL (AVP_CLASS_USER|AVP_CLASS_DOMAIN|AVP_CLASS_GLOBAL)

+/* AVP name index */

+#define AVP_INDEX_FORWARD	(1<<10)

+#define AVP_INDEX_BACKWARD	(1<<11)

+#define AVP_INDEX_ALL		(AVP_INDEX_FORWARD | AVP_INDEX_BACKWARD)

+

 #define GALIAS_CHAR_MARKER  '$'

 /* Initialize memory structures */

@@ -135,6 +143,7 @@ int init_avps(void);

 /* add avp to the list of avps */

 int add_avp(unsigned short flags, int_str name, int_str val);

+int add_avp_before(avp_t *avp, unsigned short flags, int_str name, int_str val);

 int add_avp_list(avp_list_t* list, unsigned short flags, int_str name, int_str val);

 /* Delete avps with given type and name */

@@ -145,6 +154,8 @@ avp_t *search_first_avp( unsigned short flags, int_str name,

 			 int_str *val, struct search_state* state);

 avp_t *search_next_avp(struct search_state* state, int_str *val);