avpops.c

来自「性能优秀的SIP Proxy」· C语言 代码 · 共 1,264 行 · 第 1/3 页

						" pseudo-variable [%s]\n", s);
				return E_OUT_OF_MEM;
			}
			if (ap->sval.type==XL_NULL)
			{
				LOG(L_ERR,"ERROR:avops:fixup_write_avp: bad param 1; "
					"expected : $pseudo-variable or int/str value\n");
				return E_UNSPEC;
			}
		} else {
			/* is value */
			if ( (ap=parse_intstr_value(s,strlen(s)))==0 )
			{
				LOG(L_ERR,"ERROR:avops:fixup_write_avp: bad param 1; "
					"expected : $[from|to|ruri] or int/str value\n");
				return E_UNSPEC;
			}
		}
	} else if (param_no==2) {
		if(s==0 || *s!='$')
		{
			LOG(L_ERR,"ERROR:avpops:fixup_write_avp: bad attribute name"
				" in param 2 <%s>\n", s);
			return E_UNSPEC;
		}
		
		/* is variable */
		ap = avpops_parse_pvar(s, 
			XL_THROW_ERROR|XL_DISABLE_MULTI|XL_DISABLE_COLORS);
		if (ap==0)
		{
			LOG(L_ERR,"ERROR:avpops:fixup_write_avp: unable to get"
					" pseudo-variable in param 2 [%s]\n", s);
			return E_OUT_OF_MEM;
		}
		if (ap->sval.type!=XL_AVP)
		{
			LOG(L_ERR,"ERROR:avops:fixup_write_avp: bad param 2 [%s]; "
				"expected : $avp(name)\n", s);
			return E_UNSPEC;
		}
	}

	*param=(void*)ap;
	return 0;
}


static int fixup_delete_avp(void** param, int param_no)
{
	struct fis_param *ap=NULL;
	char *p;
	char *s;
	unsigned int flags;
	str s0;

	s = (char*)(*param);
	if (param_no==1) {
		/* attribute name / alias */
		if ( (p=strchr(s,'/'))!=0 )
			*(p++)=0;
		
		if(*s=='$')
		{
			/* is variable */
			ap = avpops_parse_pvar(s, 
				XL_THROW_ERROR|XL_DISABLE_MULTI|XL_DISABLE_COLORS);
			if (ap==0)
			{
				LOG(L_ERR,"ERROR:avpops:fixup_delete_avp: unable to get"
					" pseudo-variable in param \n");
				return E_UNSPEC;
			}
			if (ap->sval.type!=XL_AVP)
			{
				LOG(L_ERR,"ERROR:avops:fixup_delete_avp: bad param; "
					"expected : $avp(name)\n");
				return E_UNSPEC;
			}
			ap->opd|=AVPOPS_VAL_PVAR;
		} else {
			if(strlen(s)<1)
			{
				LOG(L_ERR,"ERROR:avops:parse_avp_db: bad param - "
					"expected : $avp(name), *, s or i value\n");
				return E_UNSPEC;
			}
			ap = (struct fis_param*)pkg_malloc(sizeof(struct fis_param));
			if (ap==0)
			{
				LOG(L_ERR,"ERROR:avpops:fixup_delete_avp: no more "
					"pkg mem\n");
				return E_OUT_OF_MEM;
			}
			memset(ap, 0, sizeof(struct fis_param));
			ap->opd|=AVPOPS_VAL_NONE;
			switch(*s) {
				case 's': case 'S':
					ap->opd = AVPOPS_VAL_NONE|AVPOPS_VAL_STR;
				break;
				case 'i': case 'I':
					ap->opd = AVPOPS_VAL_NONE|AVPOPS_VAL_INT;
				break;
				case '*': case 'a': case 'A':
					ap->opd = AVPOPS_VAL_NONE;
				break;
				default:
					LOG(L_ERR,"ERROR:avpops:fixup_delete_avp: bad param - "
						"expected : *, s or i AVP flag\n");
					pkg_free(ap);
					return E_UNSPEC;
			}
			/* flags */
			flags = 0;
			if(*(s+1)!='\0')
			{
				s0.s = s+1;
				s0.len = strlen(s0.s);
				if(str2int(&s0, &flags)!=0)
				{
					LOG(L_ERR,
					"ERROR:avpops:fixup_delete_avp: error - bad avp flags\n");
					pkg_free(ap);
					return E_UNSPEC;
				}
			}
			ap->sval.flags |= flags<<24;
		}

		/* flags */
		for( ; p&&*p ; p++ )
		{
			switch (*p)
			{
				case 'g':
				case 'G':
					ap->ops|=AVPOPS_FLAG_ALL;
					break;
				default:
					LOG(L_ERR,"ERROR:avpops:fixup_delete_avp: bad flag "
						"<%c>\n",*p);
					if(ap!=NULL)
						pkg_free(ap);
					return E_UNSPEC;
			}
		}
		/* force some flags: if no avp name is given, force "all" flag */
		if (ap->opd&AVPOPS_VAL_NONE)
			ap->ops |= AVPOPS_FLAG_ALL;

		*param=(void*)ap;
	}

	return 0;
}

static int fixup_copy_avp(void** param, int param_no)
{
	struct fis_param *ap;
	char *s;
	char *p;

	s = (char*)*param;
	ap = 0;
	p = 0;

	if (param_no==2)
	{
		/* avp / flags */
		if ( (p=strchr(s,'/'))!=0 )
			*(p++)=0;
	}

	ap = avpops_parse_pvar(s, 
			XL_THROW_ERROR|XL_DISABLE_MULTI|XL_DISABLE_COLORS);
	if (ap==0)
	{
		LOG(L_ERR,"ERROR:avpops:fixup_copy_avp: unable to get"
				" pseudo-variable in P%d\n", param_no);
		return E_OUT_OF_MEM;
	}

	/* attr name is mandatory */
	if (ap->sval.type!=XL_AVP)
	{
		LOG(L_ERR,"ERROR:avpops:fixup_copy_avp: you must specify "
			"only AVP as parameter\n");
		return E_UNSPEC;
	}

	if (param_no==2)
	{
		/* flags */
		for( ; p&&*p ; p++ )
		{
			switch (*p) {
				case 'g':
				case 'G':
					ap->ops|=AVPOPS_FLAG_ALL;
					break;
				case 'd':
				case 'D':
					ap->ops|=AVPOPS_FLAG_DELETE;
					break;
				case 'n':
				case 'N':
					ap->ops|=AVPOPS_FLAG_CASTN;
					break;
				case 's':
				case 'S':
					ap->ops|=AVPOPS_FLAG_CASTS;
					break;
				default:
					LOG(L_ERR,"ERROR:avpops:fixup_copy_avp: bad flag "
						"<%c>\n",*p);
					return E_UNSPEC;
			}
		}
	}

	*param=(void*)ap;
	return 0;
}

static int fixup_pushto_avp(void** param, int param_no)
{
	struct fis_param *ap;
	char *s;
	char *p;

	s = (char*)*param;
	ap = 0;

	if (param_no==1)
	{
		if ( *s!='$')
		{
			LOG(L_ERR,"ERROR:avops:fixup_pushto_avp: bad param 1; expected : "
				"$ru $du ...\n");
			return E_UNSPEC;
		}
		/* compose the param structure */

		if ( (p=strchr(s,'/'))!=0 )
			*(p++)=0;
		ap = avpops_parse_pvar(s, 
			XL_THROW_ERROR|XL_DISABLE_MULTI|XL_DISABLE_COLORS);
		if (ap==0)
		{
			LOG(L_ERR,"ERROR:avpops:fixup_pushto_avp: unable to get"
					" pseudo-variable in param 1\n");
			return E_OUT_OF_MEM;
		}

		switch(ap->sval.type) {
			case XL_RURI:
				ap->opd = AVPOPS_VAL_NONE|AVPOPS_USE_RURI;
				if ( p && !(
					(!strcasecmp("username",p)
							&& (ap->opd|=AVPOPS_FLAG_USER0)) ||
					(!strcasecmp("domain",p)
							&& (ap->opd|=AVPOPS_FLAG_DOMAIN0)) ))
				{
					LOG(L_ERR,"ERROR:avpops:fixup_pushto_avp: unknown "
						" ruri flag \"%s\"!\n",p);
					return E_UNSPEC;
				}
			break;
			case XL_DSTURI:
				if ( p!=0 )
				{
					LOG(L_ERR,"ERROR:avpops:fixup_pushto_avp: unknown "
						" duri flag \"%s\"!\n",p);
					return E_UNSPEC;
				}
				ap->opd = AVPOPS_VAL_NONE|AVPOPS_USE_DURI;
			break;
			case XL_HDR:
				/* what's the hdr destination ? request or reply? */
				LOG(L_ERR,"ERROR:avpops:fixup_pushto_avp: push to header "
						" is obsoleted - use append_hf() or append_to_reply()"
						" from textops module!\n");
				return E_UNSPEC;
			break;
			case XL_BRANCH:
				if ( p!=0 )
				{
					LOG(L_ERR,"ERROR:avpops:fixup_pushto_avp: unknown "
						" branch flag \"%s\"!\n",p);
					return E_UNSPEC;
				}
				ap->opd = AVPOPS_VAL_NONE|AVPOPS_USE_BRANCH;
			break;
			default:
				LOG(L_ERR,"ERROR:avpops:fixup_pushto_avp: unsupported "
					" destination \"%s\"; expected $ru,$du,$br\n",s);
				return E_UNSPEC;
		}
	} else if (param_no==2) {
		/* attribute name*/
		if ( *s!='$')
		{
			LOG(L_ERR,"ERROR:avops:fixup_pushto_avp: bad param 1; expected : "
				"$pseudo-variable ...\n");
			return E_UNSPEC;
		}
		/* compose the param structure */

		if ( (p=strchr(s,'/'))!=0 )
			*(p++)=0;
		ap = avpops_parse_pvar(s, 
			XL_THROW_ERROR|XL_DISABLE_COLORS);
		if (ap==0)
		{
			LOG(L_ERR,"ERROR:avpops:fixup_pudhto_avp: unable to get"
					" pseudo-variable in param 2\n");
			return E_OUT_OF_MEM;
		}
		if (ap->sval.type==XL_NULL)
		{
			LOG(L_ERR,"ERROR:avops:fixup_pushto_avp: bad param 2; "
				"expected : $pseudo-variable ...\n");
			pkg_free(ap);
			return E_UNSPEC;
		}
		ap->opd |= AVPOPS_VAL_PVAR;

		/* flags */
		for( ; p&&*p ; p++ )
		{
			switch (*p) {
				case 'g':
				case 'G':
					ap->ops|=AVPOPS_FLAG_ALL;
					break;
				default:
					LOG(L_ERR,"ERROR:avpops:fixup_pushto_avp: bad flag "
						"<%c>\n",*p);
					pkg_free(ap);
					return E_UNSPEC;
			}
		}
	}

	*param=(void*)ap;
	return 0;
}

static int fixup_check_avp(void** param, int param_no)
{
	struct fis_param *ap;
	regex_t* re;
	char *s;

	s = (char*)*param;
	ap = 0;

	if (param_no==1)
	{
		ap = avpops_parse_pvar(s, 
			XL_THROW_ERROR|XL_DISABLE_MULTI|XL_DISABLE_COLORS);
		if (ap==0)
		{
			LOG(L_ERR,"ERROR:avpops:fixup_check_avp: unable to get"
					" pseudo-variable in P1\n");
			return E_OUT_OF_MEM;
		}
		/* attr name is mandatory */
		if (ap->sval.type==XL_NULL)
		{
			LOG(L_ERR,
				"ERROR:avpops:fixup_check_avp: NULL pseudo-variable in P1\n");
			return E_UNSPEC;
		}
	} else if (param_no==2) {
		if ( (ap=parse_check_value(s))==0 )
		{
			LOG(L_ERR,"ERROR:avpops:fixup_check_avp: failed to parse "
				"checked value \n");
			return E_UNSPEC;
		}
		/* if REGEXP op -> compile the expresion */
		if (ap->ops&AVPOPS_OP_RE)
		{
			if ( (ap->opd&AVPOPS_VAL_STR)==0 )
			{
				LOG(L_ERR,"ERROR:avpops:fixup_check_avp: regexp operation "
					"requires string value\n");
				return E_UNSPEC;
			}
			re = pkg_malloc(sizeof(regex_t));
			if (re==0)
			{
				LOG(L_ERR,"ERROR:avpops:fixup_check_avp: no more pkg mem\n");
				return E_OUT_OF_MEM;
			}
			DBG("DEBUG:avpops:fixup_check_avp: compiling regexp <%.*s>\n",
				ap->sval.p.val.len, ap->sval.p.val.s);
			if (regcomp(re, ap->sval.p.val.s,
						REG_EXTENDED|REG_ICASE|REG_NEWLINE))
			{
				pkg_free(re);
				LOG(L_ERR,"ERROR:avpops:fixip_check_avp: bad re <%.*s>\n",
					ap->sval.p.val.len, ap->sval.p.val.s);
				return E_BAD_RE;
			}
			/* free the string and link the regexp */
			// pkg_free(ap->sval.p.s);
			ap->sval.p.val.s = (char*)re;
		} else if (ap->ops&AVPOPS_OP_FM) {
			if ( !( ap->opd&AVPOPS_VAL_PVAR ||
			(!(ap->opd&AVPOPS_VAL_PVAR) && ap->opd&AVPOPS_VAL_STR) ) )
			{
				LOG(L_ERR,"ERROR:avpops:fixup_check_avp: fast_match operation "
					"requires string value or avp name/alias (%d/%d)\n",
					ap->opd, ap->ops);
				return E_UNSPEC;
			}
		}
	}

	*param=(void*)ap;