自学教程：C++ trim_len函数代码示例

/* looks for the MAX FORWARDS header	* returns its value, -1 if is not present or -2 for error */int is_maxfwd_present( struct sip_msg* msg , str *foo){	int x, err;	/* lookup into the message for MAX FORWARDS header*/	if ( !msg->maxforwards ) {		if  ( parse_headers( msg , HDR_MAXFORWARDS_F, 0 )==-1 ){			LM_ERR("parsing MAX_FORWARD header failed!/n");			return -2;		}		if (!msg->maxforwards) {			LM_DBG("max_forwards header not found!/n");			return -1;		}	} else if (IS_MAXWD_STORED(msg)) {		trim_len( foo->len , foo->s , msg->maxforwards->body );		return FETCH_MAXWD_VAL(msg);	}	/* if header is present, trim to get only the string containing numbers */	trim_len( foo->len , foo->s , msg->maxforwards->body );	/* convert from string to number */	x = str2s( foo->s,foo->len,&err);	if (err){		LM_ERR("unable to parse the max forwards number/n");		return -2;	}	/* store the parsed values */	STORE_MAXWD_VAL(msg, x);	LM_DBG("value = %d /n",x);	return x;}

unsigned int new_hash( str call_id, str cseq_nr ){	unsigned int hash_code = 0;	int i,j, k, third;	int ci_len, cs_len;	char *ci, *cs;	/* trim EoLs *//*	ci_len = call_id.len;	while (ci_len && ((c=call_id.s[ci_len-1])==0 || c=='/r' || c=='/n'))		ci_len--;	cs_len = cseq_nr.len;	while (cs_len && ((c=cseq_nr.s[cs_len-1])==0 || c=='/r' || c=='/n'))		cs_len--;*/	trim_len( ci_len, ci, call_id );	trim_len( cs_len, cs, cseq_nr );	/* run the cycle from the end ... we are interested in the	   most-right digits ... and just take the %10 value of it	*/	third=(ci_len-1)/3;	for ( i=ci_len-1, j=2*third, k=third;		k>0 ; i--, j--, k-- ) {		hash_code+=crc_16_tab[(unsigned char)(*(ci+i)) /*+7*/ ]+			ccitt_tab[(unsigned char)*(ci+k)+63]+			ccitt_tab[(unsigned char)*(ci+j)+13];	}	for( i=0 ; i<cs_len ; i++ )		//hash_code+=crc_32_tab[(cseq_nr.s[i]+hash_code)%243];		hash_code+=ccitt_tab[(unsigned char)*(cs+i)+123];	/* hash_code conditioning */#ifdef _BUG	/* not flat ... % 111b has shorter period than       & 111b by one and results in different distribution;	   ( 7 % 7 == 0, 7 %7 == 1 ) 	   % is used as a part of the hash function too, not only	   for rounding; & is not flat; whoever comes up with	   a nicer flat hash function which does not take	   costly division is welcome; feel free to verify	   distribution using hashtest()    */	hash_code &= (TABLE_ENTRIES-1); /* TABLE_ENTRIES = 2^k */#endif	hash_code=hash_code%(TABLE_ENTRIES-1)+1;	return hash_code;}

int extract_bwidth(str *body, str *bwtype, str *bwwitdth){	char *cp, *cp1;	int len;	cp1 = NULL;	for (cp = body->s; (len = body->s + body->len - cp) > 0;) {		cp1 = (char*)ser_memmem(cp, "b=", len, 2);		if (cp1 == NULL || cp1[-1] == '/n' || cp1[-1] == '/r')			break;		cp = cp1 + 2;	}	if (cp1 == NULL)		return -1;	bwtype->s = cp1 + 2;	bwtype->len = eat_line(bwtype->s, body->s + body->len - bwtype->s) - bwtype->s;	trim_len(bwtype->len, bwtype->s, *bwtype);	cp = bwtype->s;	len = bwtype->len;	cp1 = (char*)ser_memmem(cp, ":", len, 1);	len -= cp1 - cp;	if (len <= 0) {		LM_ERR("invalid encoding in `b=%.*s'/n", bwtype->len, bwtype->s);		return -1;	}	bwtype->len = cp1 - cp;	/* skip ':' */	bwwitdth->s = cp1 + 1;	bwwitdth->len = len - 1;		return 0;}

static intextract_mediaport(str *body, str *mediaport){	char *cp, *cp1;	int len;	cp1 = NULL;	for (cp = body->s; (len = body->s + body->len - cp) > 0;) {		cp1 = ser_memmem(cp, "m=", len, 2);		if (cp1 == NULL || cp1[-1] == '/n' || cp1[-1] == '/r')			break;		cp = cp1 + 2;	}	if (cp1 == NULL) {		LOG(L_ERR, "ERROR: extract_mediaport: no `m=' in SDP/n");		return -1;	}	mediaport->s = cp1 + 2;	mediaport->len = eat_line(mediaport->s, body->s + body->len -	  mediaport->s) - mediaport->s;	trim_len(mediaport->len, mediaport->s, *mediaport);	if (mediaport->len < 7 || memcmp(mediaport->s, "audio", 5) != 0 ||	  !isspace((int)mediaport->s[5])) {		LOG(L_ERR, "ERROR: extract_mediaport: can't parse `m=' in SDP/n");		return -1;	}	cp = eat_space_end(mediaport->s + 5, mediaport->s + mediaport->len);	mediaport->len = eat_token_end(cp, mediaport->s + mediaport->len) - cp;	mediaport->s = cp;	return 1;}

/* TODO - altough in most of the cases the targetted key is the 2nd query string,	that's not always the case ! - make this 100% */int redis_raw_query_extract_key(str *attr,str *query_key){	int len;	char *p,*q,*r;	if (!attr || attr->s == NULL || query_key == NULL)		return -1;	trim_len(len,p,*attr);	q = memchr(p,' ',len);	if (q == NULL) {		LM_ERR("Malformed Redis RAW query /n");		return -1;	}	query_key->s = q+1;	r = memchr(query_key->s,' ',len - (query_key->s - p));	if (r == NULL) {		query_key->len = (p+len) - query_key->s;	} else {		query_key->len = r-query_key->s;	}	return 0;}

int extract_mediaip(str *body, str *mediaip, int *pf, char *line){	char *cp, *cp1;	int len, nextisip;	cp1 = NULL;	for (cp = body->s; (len = body->s + body->len - cp) > 0;) {		cp1 = (char*)ser_memmem(cp, line, len, 2);		if (cp1 == NULL || cp1[-1] == '/n' || cp1[-1] == '/r')			break;		cp = cp1 + 2;	}	if (cp1 == NULL)		return -1;	mediaip->s = cp1 + 2;	mediaip->len = eat_line(mediaip->s, body->s + body->len - mediaip->s) - mediaip->s;	trim_len(mediaip->len, mediaip->s, *mediaip);	nextisip = 0;	for (cp = mediaip->s; cp < mediaip->s + mediaip->len;) {		len = eat_token_end(cp, mediaip->s + mediaip->len) - cp;		if (nextisip == 1) {			mediaip->s = cp;			mediaip->len = len;			nextisip++;			break;		}		if (len == 3 && memcmp(cp, "IP", 2) == 0) {			switch (cp[2]) {			case '4':				nextisip = 1;				*pf = AF_INET;				break;			case '6':				nextisip = 1;				*pf = AF_INET6;				break;			default:				break;			}		}		/* consume all spaces starting from the second char after the token		   First char after the token is the char that stoped the token		   parsing, so it is space or /r / /n, so we simply skip it */		cp = eat_space_end(cp + len + 1, mediaip->s + mediaip->len);	}	if (nextisip != 2 || mediaip->len == 0) {		LM_ERR("no `IP[4|6]' in `%s' field/n",line);		return -1;	}	return 1;}

static intextract_mediaip(str *body, str *mediaip, int *pf){	char *cp, *cp1;	int len, nextisip;	cp1 = NULL;	for (cp = body->s; (len = body->s + body->len - cp) > 0;) {		cp1 = ser_memmem(cp, "c=", len, 2);		if (cp1 == NULL || cp1[-1] == '/n' || cp1[-1] == '/r')			break;		cp = cp1 + 2;	}	if (cp1 == NULL) {		LOG(L_ERR, "ERROR: extract_mediaip: no `c=' in SDP/n");		return -1;	}	mediaip->s = cp1 + 2;	mediaip->len = eat_line(mediaip->s, body->s + body->len - mediaip->s) - mediaip->s;	trim_len(mediaip->len, mediaip->s, *mediaip);	nextisip = 0;	for (cp = mediaip->s; cp < mediaip->s + mediaip->len;) {		len = eat_token_end(cp, mediaip->s + mediaip->len) - cp;		if (nextisip == 1) {			mediaip->s = cp;			mediaip->len = len;			nextisip++;			break;		}		if (len == 3 && memcmp(cp, "IP", 2) == 0) {			switch (cp[2]) {			case '4':				nextisip = 1;				*pf = AF_INET;				break;			case '6':				nextisip = 1;				*pf = AF_INET6;				break;			default:				break;			}		}		cp = eat_space_end(cp + len, mediaip->s + mediaip->len);	}	if (nextisip != 2 || mediaip->len == 0) {		LOG(L_ERR, "ERROR: extract_mediaip: "		    "no `IP[4|6]' in `c=' field/n");		return -1;	}	return 1;}

int extract_fmtp( str *body, str *fmtp_payload, str *fmtp_string ){	char *cp, *cp1;	int len;	if (strncasecmp(body->s, "a=fmtp:", 7) !=0) {		/*LM_DBG("We are not pointing to an a=fmtp: attribute =>`%.*s'/n", body->len, body->s); */		return -1;	}	cp1 = body->s;	fmtp_payload->s = cp1 + 7; /* skip `a=fmtp:' */	fmtp_payload->len = eat_line(fmtp_payload->s, body->s + body->len -		fmtp_payload->s) - fmtp_payload->s;	trim_len(fmtp_payload->len, fmtp_payload->s, *fmtp_payload);	len = fmtp_payload->len;	/* */	cp = eat_token_end(fmtp_payload->s, fmtp_payload->s + fmtp_payload->len);	fmtp_payload->len = cp - fmtp_payload->s;	if (fmtp_payload->len <= 0 || cp == fmtp_payload->s) {		LM_ERR("no encoding in `a=fmtp:'/n");		return -1;	}	len -= fmtp_payload->len;	fmtp_string->s = cp;	cp = eat_space_end(fmtp_string->s, fmtp_string->s + len);	len -= cp - fmtp_string->s;	if (len <= 0 || cp == fmtp_string->s) {		LM_ERR("no encoding in `a=fmtp:'/n");		return -1;	}	fmtp_string->s = cp;	fmtp_string->len = eat_line(fmtp_string->s, body->s + body->len -		fmtp_string->s) - fmtp_string->s;	trim_len(fmtp_string->len, fmtp_string->s, *fmtp_string);	return 0;}

/* generic method for attribute extraction * field must has format "a=attrname:" */int extract_field(str *body, str *value, str field){	if (strncmp(body->s, field.s, field.len < body->len ? field.len : body->len) !=0) {		/*LM_DBG("We are not pointing to an %.* attribute =>`%.*s'/n", field.len, field.s, body->len, body->s); */		return -1;	}	value->s = body->s + field.len; /* skip `a=attrname:' */	value->len = eat_line(value->s, body->s + body->len -	          value->s) - value->s;	trim_len(value->len, value->s, *value);	return 0;}

/*! /brief */static struct socket_info *get_sock_hdr(struct sip_msg *msg){	struct socket_info *sock;	struct hdr_field *hf;	str socks;	str hosts;	int port;	int proto;	char c;	if (parse_headers( msg, HDR_EOH_F, 0) == -1) {		LM_ERR("failed to parse message/n");		return 0;	}	for (hf=msg->headers; hf; hf=hf->next) {		if (cmp_hdrname_str(&hf->name, &sock_hdr_name)==0)			break;	}	/* hdr found? */	if (hf==0)		return 0;	trim_len( socks.len, socks.s, hf->body );	if (socks.len==0)		return 0;	/*FIXME: This is a hack */	c = socks.s[socks.len];	socks.s[socks.len] = '/0';	if (parse_phostport( socks.s, &hosts.s, &hosts.len,	&port, &proto)!=0) {		socks.s[socks.len] = c;		LM_ERR("bad socket <%.*s> in /n",			socks.len, socks.s);		return 0;	}	socks.s[socks.len] = c;	sock = grep_sock_info(&hosts,(unsigned short)port,(unsigned short)proto);	if (sock==0) {		LM_ERR("non-local socket <%.*s>/n",	socks.len, socks.s);		return 0;	}	LM_DBG("%d:<%.*s>:%d -> p=%p/n", proto,socks.len,socks.s,port_no,sock );	return sock;}

/*! /brief  * Calculate a MD5 digests over a string array and stores  * the result in the destination char array.  * This function assumes 32 bytes in the destination buffer.  * /param dest destination  * /param src string input array  * /param size elements in the input array  */void MD5StringArray(char *dest, str src[], unsigned int size){	MD5_CTX context;	unsigned char digest[16];	int i, len;	char *tmp;	MD5Init (&context);	for (i=0; i < size; i++) {		trim_len(len, tmp, src[i]);		MD5Update(&context, tmp, len);	}	MD5Final(digest, &context);	string2hex(digest, 16, dest);	LM_DBG("MD5 calculated: %.*s/n", MD5_LEN, dest);}

/*! /brief */static int set_sock_hdr(struct sip_msg *msg, ucontact_info_t *ci,                        unsigned int reg_flags){	struct socket_info *sock;	struct hdr_field *hf;	str socks;	str hosts;	int port;	int proto;	if (!msg || !(reg_flags & REG_SAVE_SOCKET_FLAG))		return 1;	if (parse_headers( msg, HDR_EOH_F, 0) == -1) {		LM_ERR("failed to parse message/n");		return 1;	}	hf = get_header_by_name( msg, sock_hdr_name.s, sock_hdr_name.len);	if (hf==0)		return 1;	trim_len( socks.len, socks.s, hf->body );	if (socks.len==0)		return 1;	if (parse_phostport( socks.s, socks.len, &hosts.s, &hosts.len,	&port, &proto)!=0) {		LM_ERR("bad socket <%.*s> in /n",			socks.len, socks.s);		return 1;	}	set_sip_defaults( port, proto);	sock = grep_sock_info(&hosts,(unsigned short)port,(unsigned short)proto);	if (sock==0) {		LM_ERR("non-local socket <%.*s>/n",	socks.len, socks.s);		return 1;	}	LM_DBG("%d:<%.*s>:%d -> p=%p/n", proto,socks.len,socks.s,port,sock );	ci->sock = sock;	return 0;}

/* Digests a string array and store the result in dst; assumes  32 bytes in dst */void MD5StringArray (char *dst, str src[], int size){	MD_CTX context;	unsigned char digest[16]; 	int i;	int len;	char *s;/*#	ifdef EXTRA_DEBUG	int j;	int sum;#endif*/	MDInit (&context);	for (i=0; i<size; i++) {		trim_len( len, s, src[i] );/*#		ifdef EXTRA_DEBUG		fprintf(stderr, "EXTRA_DEBUG: %d. (%d) {", i+1, len);		sum=0;		for (j=0; j<len; j++) {			fprintf( stderr, "%c ", *(s+j));			sum+=*(s+j);		}		for (j=0; j<len; j++) {			fprintf( stderr, "%d ", *(s+j));			sum+=*(s+j);		}		fprintf(stderr, " [%d]/n", sum );	#		endif*/		if (len > 0)  			MDUpdate (&context, s, len);  }  MDFinal (digest, &context);  string2hex(digest, 16, dst );  DBG("DEBUG: MD5 calculated: %.*s/n", MD5_LEN, dst );}

/*!  * /brief Calculate a MD5 digests over a string array  *   * Calculate a MD5 digests over a string array and stores the result in the  * destination char array. This function assumes 32 bytes in the destination  * buffer.  * /param dst destination  * /param src string input array  * /param size elements in the input array  */void MD5StringArray (char *dst, str src[], int size){	MD5_CTX context;	unsigned char digest[16]; 	int i;	int len;	char *s;	MD5Init (&context);	for (i=0; i<size; i++) {		trim_len( len, s, src[i] );		if (len > 0)  			MD5Update (&context, s, len);  }  U_MD5Final (digest, &context);  string2hex(digest, 16, dst );  DBG("DEBUG: MD5 calculated: %.*s/n", MD5_LEN, dst );}

int check_content_type(struct sip_msg *msg){	static unsigned int appl[16] = {		0x6c707061/*appl*/,0x6c707041/*Appl*/,0x6c705061/*aPpl*/,		0x6c705041/*APpl*/,0x6c507061/*apPl*/,0x6c507041/*ApPl*/,		0x6c505061/*aPPl*/,0x6c505041/*APPl*/,0x4c707061/*appL*/,		0x4c707041/*AppL*/,0x4c705061/*aPpL*/,0x4c705041/*APpL*/,		0x4c507061/*apPL*/,0x4c507041/*ApPL*/,0x4c505061/*aPPL*/,		0x4c505041/*APPL*/};	static unsigned int icat[16] = {		0x74616369/*icat*/,0x74616349/*Icat*/,0x74614369/*iCat*/,		0x74614349/*ICat*/,0x74416369/*icAt*/,0x74416349/*IcAt*/,		0x74414369/*iCAt*/,0x74414349/*ICAt*/,0x54616369/*icaT*/,		0x54616349/*IcaT*/,0x54614369/*iCaT*/,0x54614349/*ICaT*/,		0x54416369/*icAT*/,0x54416349/*IcAT*/,0x54414369/*iCAT*/,		0x54414349/*ICAT*/};	static unsigned int ion_[8] = {		0x006e6f69/*ion_*/,0x006e6f49/*Ion_*/,0x006e4f69/*iOn_*/,		0x006e4f49/*IOn_*/,0x004e6f69/*ioN_*/,0x004e6f49/*IoN_*/,		0x004e4f69/*iON_*/,0x004e4f49/*ION_*/};	static unsigned int sdp_[8] = {		0x00706473/*sdp_*/,0x00706453/*Sdp_*/,0x00704473/*sDp_*/,		0x00704453/*SDp_*/,0x00506473/*sdP_*/,0x00506453/*SdP_*/,		0x00504473/*sDP_*/,0x00504453/*SDP_*/};	str           str_type;	unsigned int  x;	char          *p;	if (!msg->content_type)	{		LM_WARN("the header Content-TYPE is absent!"			"let's assume the content is text/plain ;-)/n");		return 1;	}	trim_len(str_type.len,str_type.s,msg->content_type->body);	p = str_type.s;	advance(p,4,str_type,error_1);	x = READ(p-4);	if (!one_of_16(x,appl))		goto other;	advance(p,4,str_type,error_1);	x = READ(p-4);	if (!one_of_16(x,icat))		goto other;	advance(p,3,str_type,error_1);	x = READ(p-3) & 0x00ffffff;	if (!one_of_8(x,ion_))		goto other;	/* skip spaces and tabs if any */	while (*p==' ' || *p=='/t')		advance(p,1,str_type,error_1);	if (*p!='/')	{		LM_ERR("no / found after primary type/n");		goto error;	}	advance(p,1,str_type,error_1);	while ((*p==' ' || *p=='/t') && p+1<str_type.s+str_type.len)		advance(p,1,str_type,error_1);	advance(p,3,str_type,error_1);	x = READ(p-3) & 0x00ffffff;	if (!one_of_8(x,sdp_))		goto other;	if (*p==';'||*p==' '||*p=='/t'||*p=='/n'||*p=='/r'||*p==0) {		LM_DBG("type <%.*s> found valid/n", (int)(p-str_type.s), str_type.s);		return 1;	} else {		LM_ERR("bad end for type!/n");		return -1;	}error_1:	LM_ERR("body ended :-(!/n");error:	return -1;other:	LM_ERR("invalid type for a message/n");	return -1;}

int extract_media_attr(str *body, str *mediamedia, str *mediaport, str *mediatransport, str *mediapayload, int *is_rtp){	char *cp, *cp1;	int len, i;	cp1 = NULL;	for (cp = body->s; (len = body->s + body->len - cp) > 0;) {		cp1 = (char*)ser_memmem(cp, "m=", len, 2);		if (cp1 == NULL || cp1[-1] == '/n' || cp1[-1] == '/r')			break;		cp = cp1 + 2;	}	if (cp1 == NULL) {		LM_ERR("no `m=' in SDP/n");		return -1;	}	mediaport->s = cp1 + 2; /* skip `m=' */	mediaport->len = eat_line(mediaport->s, body->s + body->len -	  mediaport->s) - mediaport->s;	trim_len(mediaport->len, mediaport->s, *mediaport);	mediapayload->len = mediaport->len;	mediamedia->s = mediaport->s;	/* Skip media supertype and spaces after it */	cp = eat_token_end(mediaport->s, mediaport->s + mediaport->len);	mediaport->len -= cp - mediaport->s;	mediamedia->len = mediapayload->len - mediaport->len;	if (mediaport->len <= 0 || cp == mediaport->s) {		LM_ERR("no port in `m='/n");		return -1;	}	mediaport->s = cp;	cp = eat_space_end(mediaport->s, mediaport->s + mediaport->len);	mediaport->len -= cp - mediaport->s;	if (mediaport->len <= 0 || cp == mediaport->s) {		LM_ERR("no port in `m='/n");		return -1;	}	/* Extract port */	mediaport->s = cp;	cp = eat_token_end(mediaport->s, mediaport->s + mediaport->len);	mediatransport->len = mediaport->len - (cp - mediaport->s);	if (mediatransport->len <= 0 || cp == mediaport->s) {		LM_ERR("no port in `m='/n");		return -1;	}	mediatransport->s = cp;	mediaport->len = cp - mediaport->s;	/* Skip spaces after port */	cp = eat_space_end(mediatransport->s, mediatransport->s + mediatransport->len);	mediatransport->len -= cp - mediatransport->s;	if (mediatransport->len <= 0 || cp == mediatransport->s) {		LM_ERR("no protocol type in `m='/n");		return -1;	}	/* Extract protocol type */	mediatransport->s = cp;	cp = eat_token_end(mediatransport->s, mediatransport->s + mediatransport->len);	if (cp == mediatransport->s) {		LM_ERR("no protocol type in `m='/n");		return -1;	}	mediatransport->len = cp - mediatransport->s;	mediapayload->s = mediatransport->s + mediatransport->len;	mediapayload->len -= mediapayload->s - mediamedia->s;	cp = eat_space_end(mediapayload->s, mediapayload->s + mediapayload->len);	mediapayload->len -= cp - mediapayload->s;	mediapayload->s = cp;	for (i = 0; sup_ptypes[i].s != NULL; i++)		if (mediatransport->len == sup_ptypes[i].len &&		    strncasecmp(mediatransport->s, sup_ptypes[i].s, mediatransport->len) == 0) {			*is_rtp = sup_ptypes[i].is_rtp;			return 0;		}	/* Unproxyable protocol type. Generally it isn't error. */	return 0;}

int extract_mediaip(str *body, str *mediaip, int *pf, char *line){	char *cp, *cp1;	int len;	cp1 = NULL;	for (cp = body->s; (len = body->s + body->len - cp) > 0;) {		cp1 = (char*)ser_memmem(cp, line, len, 2);		if (cp1 == NULL || cp1[-1] == '/n' || cp1[-1] == '/r')			break;		cp = cp1 + 2;	}	if (cp1 == NULL)		return -1;	mediaip->s = cp1 + 2;	mediaip->len = eat_line(mediaip->s, body->s + body->len - mediaip->s) - mediaip->s;	trim_len(mediaip->len, mediaip->s, *mediaip);	if (mediaip->len == 0) {		LM_ERR("no [%s] line in SDP/n",line);		return -1;	}	/* search reverse for IP[4|6] in c=/o= line */	cp = (char*)ser_memrmem(mediaip->s, " IP", mediaip->len, 3);	if (cp == NULL) {		LM_ERR("no `IP[4|6]' in `%s' field/n",line);		return -1;	}	/* safety checks:	 * - for length, at least 6: ' IP[4|6] x...'	 * - white space after	 */	if(cp + 6 > mediaip->s + mediaip->len && cp[4]!=' ') {		LM_ERR("invalid content for `%s' line/n",line);		return -1;	}	switch(cp[3]) {		case '4':			*pf = AF_INET;		break;		case '6':			*pf = AF_INET6;		break;		default:			LM_ERR("invalid addrtype IPx for `%s' line/n",line);			return -1;	}	cp += 5;	/* next token is the IP address */	cp = eat_space_end(cp, mediaip->s + mediaip->len);	len = eat_token_end(cp, mediaip->s + mediaip->len) - cp;	mediaip->s = cp;	mediaip->len = len;	if (mediaip->len == 0) {		LM_ERR("no `IP[4|6]' address in `%s' field/n",line);		return -1;	}	LM_DBG("located IP address [%.*s] in `%s' field/n",			mediaip->len, mediaip->s, line);	return 1;}

static inline char* append2buf( char *buf, int len, struct sip_msg *req, 				struct hdr_avp *ha){	struct hdr_field *hdr;	struct usr_avp   *avp;	int_str          avp_val;	int_str          avp_name;	char  *end;	str   foo;	int   msg_parsed;	end = buf+len;	msg_parsed = 0;	while(ha) {		if (ha->type==ELEM_IS_AVP) {			/* search for the AVP */			if (ha->sval.s) {				avp_name.s=ha->sval;				avp = search_first_avp( AVP_NAME_STR, avp_name, &avp_val, 0);				DBG("AVP <%.*s>: %p/n",avp_name.s.len, avp_name.s.s, avp);			} else {				avp_name.n=ha->ival;				avp = search_first_avp( 0, avp_name, &avp_val, 0);				DBG("AVP <%i>: %p/n",avp_name.n,avp);			}			if (avp) {				if (avp->flags&AVP_VAL_STR) {					buf=add2buf( buf, end, ha->title.s, ha->title.len,						avp_val.s.s , avp_val.s.len);					if (!buf)						goto overflow_err;				} else {					foo.s=int2str( (unsigned long)avp_val.n, &foo.len);					buf=add2buf( buf, end, ha->title.s, ha->title.len,						foo.s , foo.len);					if (!buf)						goto overflow_err;				}			}		} else if (ha->type==ELEM_IS_HDR) {			/* parse the HDRs */			if (!msg_parsed) {				if (parse_headers( req, HDR_EOH_F, 0)!=0) {					LOG(L_ERR,"ERROR:tm:append2buf: parsing hdrs failed/n");					goto error;				}				msg_parsed = 1;			}			/* search the HDR */			if (ha->ival==HDR_OTHER_T) {				for(hdr=req->headers;hdr;hdr=hdr->next)					if (ha->sval.len==hdr->name.len &&					strncasecmp( ha->sval.s, hdr->name.s, hdr->name.len)==0)						break;			} else {				for(hdr=req->headers;hdr;hdr=hdr->next)					if (ha->ival==hdr->type)						break;			}			if (hdr) {				trim_len( foo.len, foo.s, hdr->body);				buf=add2buf( buf, end, ha->title.s, ha->title.len,					foo.s , foo.len);				if (!buf)					goto overflow_err;			}		} else {			LOG(L_ERR,"BUG:tm:append2buf: unknown element type %d/n",				ha->type);			goto error;		}		ha = ha->next;	}	return buf;overflow_err:	LOG(L_ERR,"ERROR:tm:append2buf: overflow -> append exceeded %d len/n",len);error:	return 0;}

/** * rfc4566: * a=rtpmap:<payload type> <encoding name>/<clock rate> [/<encoding parameters>] */int extract_rtpmap(str *body,	str *rtpmap_payload, str *rtpmap_encoding, str *rtpmap_clockrate, str *rtpmap_parmas){	char *cp, *cp1;	int len;	if (strncasecmp(body->s, "a=rtpmap:", 9) !=0) {		/*LM_DBG("We are not pointing to an a=rtpmap: attribute =>`%.*s'/n", body->len, body->s); */		return -1;	}	cp1 = body->s;	rtpmap_payload->s = cp1 + 9; /* skip `a=rtpmap:' */	rtpmap_payload->len = eat_line(rtpmap_payload->s, body->s + body->len -	          rtpmap_payload->s) - rtpmap_payload->s;	trim_len(rtpmap_payload->len, rtpmap_payload->s, *rtpmap_payload);	len = rtpmap_payload->len;	/* */	cp = eat_token_end(rtpmap_payload->s, rtpmap_payload->s + rtpmap_payload->len);	rtpmap_payload->len = cp - rtpmap_payload->s;	if (rtpmap_payload->len <= 0 || cp == rtpmap_payload->s) {		LM_ERR("no encoding in `a=rtpmap'/n");		return -1;	}	len -= rtpmap_payload->len;	rtpmap_encoding->s = cp;	cp = eat_space_end(rtpmap_encoding->s, rtpmap_encoding->s + len);	len -= cp - rtpmap_encoding->s;	if (len <= 0 || cp == rtpmap_encoding->s) {		LM_ERR("no encoding in `a=rtpmap:'/n");		return -1;	}	rtpmap_encoding->s = cp;	cp1 = (char*)ser_memmem(cp, "/", len, 1);	if(cp1==NULL) {		LM_ERR("invalid encoding in `a=rtpmap' at [%.*s]/n", len, cp);		return -1;	}	len -= cp1 - cp;	rtpmap_encoding->len = cp1 - cp;	cp = cp1+1;  /* skip '/' */	len--;	rtpmap_clockrate->s = cp;	cp1 = (char*)ser_memmem(cp, "/", len, 1);	if(cp1==NULL) {		/* no encoding parameters */		rtpmap_clockrate->len = len;		rtpmap_parmas->s = NULL;		rtpmap_parmas->len = 0;		return 0;	}	rtpmap_clockrate->len = cp1 - cp;	len -= cp1 - cp;	rtpmap_parmas->s = cp1 + 1;  /* skip '/' */	rtpmap_parmas->len = len - 1;	return 0;}

static int extract_mediaport(str *body, str *mediaport){	char *cp, *cp1;	int len, i;	str ptype;	cp1 = NULL;	for (cp = body->s; (len = body->s + body->len - cp) > 0;) {		cp1 = ser_memmem(cp, "m=", len, 2);		if (cp1 == NULL || cp1[-1] == '/n' || cp1[-1] == '/r')			break;		cp = cp1 + 2;	}	if (cp1 == NULL) {		LOG(L_ERR, "ERROR: extract_mediaport: no `m=' in SDP/n");		return -1;	}	mediaport->s = cp1 + 2; /* skip `m=' */	mediaport->len = eat_line(mediaport->s, body->s + body->len -	  mediaport->s) - mediaport->s;	trim_len(mediaport->len, mediaport->s, *mediaport);	/* Skip media supertype and spaces after it */	cp = eat_token_end(mediaport->s, mediaport->s + mediaport->len);	mediaport->len -= cp - mediaport->s;	if (mediaport->len <= 0 || cp == mediaport->s) {		LOG(L_ERR, "ERROR: extract_mediaport: no port in `m='/n");		return -1;	}	mediaport->s = cp;	cp = eat_space_end(mediaport->s, mediaport->s + mediaport->len);	mediaport->len -= cp - mediaport->s;	if (mediaport->len <= 0 || cp == mediaport->s) {		LOG(L_ERR, "ERROR: extract_mediaport: no port in `m='/n");		return -1;	}	/* Extract port */	mediaport->s = cp;	cp = eat_token_end(mediaport->s, mediaport->s + mediaport->len);	ptype.len = mediaport->len - (cp - mediaport->s);	if (ptype.len <= 0 || cp == mediaport->s) {		LOG(L_ERR, "ERROR: extract_mediaport: no port in `m='/n");		return -1;	}	ptype.s = cp;	mediaport->len = cp - mediaport->s;	/* Skip spaces after port */	cp = eat_space_end(ptype.s, ptype.s + ptype.len);	ptype.len -= cp - ptype.s;	if (ptype.len <= 0 || cp == ptype.s) {		LOG(L_ERR, "ERROR: extract_mediaport: no protocol type in `m='/n");		return -1;	}	/* Extract protocol type */	ptype.s = cp;	cp = eat_token_end(ptype.s, ptype.s + ptype.len);	if (cp == ptype.s) {		LOG(L_ERR, "ERROR: extract_mediaport: no protocol type in `m='/n");		return -1;	}	ptype.len = cp - ptype.s;	for (i = 0; sup_ptypes[i].s != NULL; i++)		if (ptype.len == sup_ptypes[i].len &&		    strncasecmp(ptype.s, sup_ptypes[i].s, ptype.len) == 0)			return 0;	/* Unproxyable protocol type. Generally it isn't error. */	return -1;}

/*! /brief*/static struct socket_info *get_sock_val(struct sip_msg *msg){	struct socket_info *sock;	struct hdr_field *hf;	str xsockname = str_init("socket");	sr_xavp_t *vavp = NULL;	str socks;	str hosts;	int port;	int proto;	char c = 0;	if(sock_hdr_name.len>0) {		if (parse_headers( msg, HDR_EOH_F, 0) == -1) {			LM_ERR("failed to parse message/n");			return 0;		}		for (hf=msg->headers; hf; hf=hf->next) {			if (cmp_hdrname_str(&hf->name, &sock_hdr_name)==0)				break;		}		/* hdr found? */		if (hf==0)			return 0;		trim_len( socks.len, socks.s, hf->body );		if (socks.len==0)			return 0;		/*FIXME: This is a hack */		c = socks.s[socks.len];		socks.s[socks.len] = '/0';	} else {		/* xavp */		if(reg_xavp_cfg.s!=NULL)			vavp = xavp_get_child_with_sval(&reg_xavp_cfg, &xsockname);		if(vavp==NULL || vavp->val.v.s.len<=0)			return 0;		socks = vavp->val.v.s;	}	if (parse_phostport( socks.s, &hosts.s, &hosts.len,				&port, &proto)!=0) {		socks.s[socks.len] = c;		LM_ERR("bad socket <%.*s> in /n",				socks.len, socks.s);		return 0;	}	if(sock_hdr_name.len>0 && c!=0) {		socks.s[socks.len] = c;	}	sock = grep_sock_info(&hosts,(unsigned short)port,(unsigned short)proto);	if (sock==0) {		LM_ERR("non-local socket <%.*s>/n",	socks.len, socks.s);		return 0;	}	LM_DBG("%d:<%.*s>:%d -> p=%p/n", proto,socks.len,socks.s,port_no,sock );	return sock;}