608 lines
15 KiB
C
608 lines
15 KiB
C
/*
|
|
* This file is part of the Sofia-SIP package
|
|
*
|
|
* Copyright (C) 2005 Nokia Corporation.
|
|
*
|
|
* Contact: Pekka Pessi <pekka.pessi@nokia.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public License
|
|
* as published by the Free Software Foundation; either version 2.1 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
|
* 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
/**@CFILE sip_pref_util.c
|
|
*
|
|
* SIP callercaps and callerprefs utility functions.
|
|
*
|
|
* @author Pekka Pessi <Pekka.Pessi@nokia.com>.
|
|
*
|
|
* @date Created: Tue Nov 2 16:39:33 EET 2004 ppessi
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <float.h>
|
|
|
|
#include "sofia-sip/sip_parser.h"
|
|
#include <sofia-sip/sip_header.h>
|
|
#include <sofia-sip/sip_util.h>
|
|
#include <sofia-sip/sip_status.h>
|
|
|
|
static double parse_number(char const *str, char **return_end);
|
|
|
|
/** Parse a single preference */
|
|
int sip_prefs_parse(union sip_pref *sp,
|
|
char const **in_out_s,
|
|
int *return_negation)
|
|
{
|
|
char const *s;
|
|
size_t n;
|
|
enum sp_type old_type;
|
|
|
|
assert(sp && in_out_s && *in_out_s && return_negation);
|
|
|
|
old_type = sp->sp_type;
|
|
sp->sp_type = sp_error;
|
|
|
|
s = *in_out_s;
|
|
if (!s)
|
|
return 0;
|
|
|
|
if (old_type == sp_init) {
|
|
if (s[0] == '\0' ||
|
|
su_casematch(s, "TRUE") ||
|
|
su_casematch(s, "\"TRUE\"")) {
|
|
/* Boolean */
|
|
sp->sp_type = sp_literal;
|
|
sp->sp_literal.spl_value = "TRUE";
|
|
sp->sp_literal.spl_length = 4;
|
|
*return_negation = 0;
|
|
*in_out_s = s + strlen(s);
|
|
return 1;
|
|
} else if (su_casematch(s, "FALSE") ||
|
|
su_casematch(s, "\"FALSE\"")) {
|
|
/* Boolean */
|
|
sp->sp_type = sp_literal;
|
|
sp->sp_literal.spl_value = "FALSE";
|
|
sp->sp_literal.spl_length = 5;
|
|
*return_negation = 0;
|
|
*in_out_s = s + strlen(s);
|
|
return 1;
|
|
} else if (s[0] == '"' && s[1] != '\0') {
|
|
for (s++; IS_LWS(s[0]); s++)
|
|
{}
|
|
} else
|
|
old_type = sp_error;
|
|
} else if (!s[0]) {
|
|
sp->sp_type = sp_init;
|
|
return 0;
|
|
}
|
|
|
|
if (old_type == sp_error)
|
|
return 0;
|
|
|
|
if ((*return_negation = s[0] == '!'))
|
|
for (s++; IS_LWS(s[0]); s++)
|
|
{}
|
|
|
|
if (*s == '#') {
|
|
/* Numeric */
|
|
double n1, n2;
|
|
char s0, *e;
|
|
|
|
for (s++; IS_LWS(s[0]); s++)
|
|
{}
|
|
|
|
s0 = s[0];
|
|
|
|
if (s0 == '=')
|
|
sp->sp_type = sp_range, n1 = n2 = parse_number(s = s + 1, &e);
|
|
else if (s0 == '<' && s[1] == '=')
|
|
sp->sp_type = sp_range, n1 = -DBL_MAX, n2 = parse_number(s = s + 2, &e);
|
|
else if (s0 == '>' && s[1] == '=')
|
|
sp->sp_type = sp_range, n1 = parse_number(s = s + 2, &e), n2 = DBL_MAX;
|
|
else if (((n1 = parse_number(s, &e)) != 0.0 || s != e) && e[0] == ':')
|
|
sp->sp_type = sp_range, n2 = parse_number(s = e + 1, &e);
|
|
else
|
|
/* Error in conversion */
|
|
sp->sp_type = sp_error, n1 = DBL_MAX, n2 = -DBL_MAX;
|
|
|
|
if (s == e && (n1 == 0.0 || n2 == 0.0))
|
|
sp->sp_type = sp_error; /* Error in conversion */
|
|
|
|
sp->sp_range.spr_lower = n1;
|
|
sp->sp_range.spr_upper = n2;
|
|
|
|
s = e;
|
|
} else if (*s == '<') {
|
|
/* Quoted string */
|
|
n = strcspn(++s, ">");
|
|
sp->sp_type = sp_string;
|
|
sp->sp_string.sps_value = s;
|
|
sp->sp_string.sps_length = n;
|
|
s += n + 1;
|
|
} else if ((n = span_token(s))) {
|
|
/* Literal */
|
|
sp->sp_type = sp_literal;
|
|
sp->sp_literal.spl_value = s;
|
|
sp->sp_literal.spl_length = n;
|
|
s += n;
|
|
}
|
|
|
|
for (; IS_LWS(s[0]); s++)
|
|
{}
|
|
|
|
if (s[0] == ',' || (s[0] == '"' && s[1] == '\0'))
|
|
for (s++; IS_LWS(s[0]); s++)
|
|
{}
|
|
else
|
|
old_type = sp_error;
|
|
|
|
if (old_type != sp_init && old_type != sp->sp_type)
|
|
sp->sp_type = sp_error;
|
|
|
|
*in_out_s = s;
|
|
|
|
return sp->sp_type != sp_error;
|
|
}
|
|
|
|
/** Parse number:
|
|
* number = [ "+" / "-" ] 1*DIGIT ["." 0*DIGIT]
|
|
*/
|
|
static double parse_number(char const *str, char **return_end)
|
|
{
|
|
double value = 0.0;
|
|
double decimal = 0.1;
|
|
char d, sign = '+';
|
|
|
|
if (return_end)
|
|
*return_end = (char *)str;
|
|
|
|
d = *str;
|
|
|
|
if (d == '+' || d == '-')
|
|
sign = d, d = *++str;
|
|
|
|
if (!('0' <= d && d <= '9'))
|
|
return value;
|
|
|
|
for (; '0' <= d && d <= '9'; d = *++str)
|
|
value = value * 10 + (d - '0');
|
|
|
|
if (d == '.') for (d = *++str; '0' <= d && d <= '9'; d = *++str) {
|
|
value += (d - '0') * decimal; decimal *= 0.1;
|
|
}
|
|
|
|
if (value > DBL_MAX)
|
|
value = DBL_MAX;
|
|
|
|
if (sign == '-')
|
|
value = -value;
|
|
|
|
if (return_end)
|
|
*return_end = (char *)str;
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
/** Return true if preferences match */
|
|
int sip_prefs_match(union sip_pref const *a,
|
|
union sip_pref const *b)
|
|
{
|
|
if (!a || !b)
|
|
return 0;
|
|
if (a->sp_type != b->sp_type)
|
|
return 0;
|
|
switch (a->sp_type) {
|
|
default:
|
|
case sp_error:
|
|
return 0;
|
|
case sp_literal:
|
|
return
|
|
a->sp_literal.spl_length == b->sp_literal.spl_length &&
|
|
su_casenmatch(a->sp_literal.spl_value, b->sp_literal.spl_value,
|
|
a->sp_literal.spl_length);
|
|
case sp_string:
|
|
return
|
|
a->sp_string.sps_length == b->sp_string.sps_length &&
|
|
strncmp(a->sp_string.sps_value, b->sp_string.sps_value,
|
|
a->sp_string.sps_length) == 0;
|
|
case sp_range:
|
|
return
|
|
a->sp_range.spr_lower <= b->sp_range.spr_upper &&
|
|
a->sp_range.spr_upper >= b->sp_range.spr_lower;
|
|
}
|
|
}
|
|
|
|
/**Find a matching parameter-value pair from a parameter list.
|
|
*
|
|
* Check if the given feature values match with each other.
|
|
*
|
|
* @param pvalue first feature parameter
|
|
* @param nvalue second feature parameter
|
|
* @param return_parse_error return-value parameter for error (may be NULL)
|
|
*
|
|
* @retval 1 if given feature parameters match
|
|
* @retval 0 if there is no match or a parse or type error occurred.
|
|
*
|
|
* If there is a parsing or type error, 0 is returned and @a
|
|
* *return_parse_error is set to -1.
|
|
*
|
|
* @sa sip_prefs_parse(), sip_prefs_match(), union #sip_pref.
|
|
*/
|
|
int sip_prefs_matching(char const *pvalue,
|
|
char const *nvalue,
|
|
int *return_parse_error)
|
|
{
|
|
int error;
|
|
char const *p;
|
|
union sip_pref np[1], pp[1];
|
|
int n_negated, p_negated;
|
|
|
|
if (!return_parse_error)
|
|
return_parse_error = &error;
|
|
|
|
if (!pvalue || !nvalue)
|
|
return 0;
|
|
|
|
memset(np, 0, sizeof np);
|
|
|
|
/* Usually nvalue is from Accept/Reject-Contact,
|
|
pvalue is from Contact */
|
|
while (sip_prefs_parse(np, &nvalue, &n_negated)) {
|
|
memset(pp, 0, sizeof pp);
|
|
p = pvalue;
|
|
|
|
while (sip_prefs_parse(pp, &p, &p_negated)) {
|
|
if (pp->sp_type != np->sp_type) /* Types do not match */
|
|
return 0;
|
|
|
|
if (sip_prefs_match(np, pp) /* We found matching value */
|
|
? !p_negated /* without negative */
|
|
: p_negated) /* Negative did not match */
|
|
break;
|
|
}
|
|
|
|
if (pp->sp_type == sp_error)
|
|
return *return_parse_error = -1, 0;
|
|
|
|
if (pp->sp_type != sp_init /* We found matching value */
|
|
? !n_negated /* and we expected one */
|
|
: n_negated) /* We found none and expected none */
|
|
return 1;
|
|
}
|
|
|
|
if (np->sp_type == sp_error)
|
|
*return_parse_error = -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/** Check if the parameter is a valid feature tag.
|
|
*
|
|
* A feature tag is a parameter starting with a single plus, or a well-known
|
|
* feature tag listed in @RFC3841: "audio", "automata", "application",
|
|
* "class", "control", "duplex", "data", "description", "events", "isfocus",
|
|
* "language", "mobility", "methods", "priority", "schemes", "type", or
|
|
* "video". However, well-known feature tag can not start with plus. So,
|
|
* "+alarm" or "audio" is a feature tag, "alarm", "++alarm", or "+audio" are
|
|
* not.
|
|
*
|
|
* @retval 1 if string is a feature tag parameter
|
|
* @retval 0 otherwise
|
|
*/
|
|
int sip_is_callerpref(char const *param)
|
|
{
|
|
#define MATCH(s) \
|
|
(su_casenmatch(param + 1, s + 1, strlen(s) - 1) && \
|
|
(param[strlen(s)] == '=' || param[strlen(s)] == '\0'))
|
|
|
|
int xor = 0, base = 0;
|
|
|
|
if (!param || !param[0])
|
|
return 0;
|
|
|
|
if (param[0] == '+')
|
|
param++, xor = 1;
|
|
|
|
switch (param[0]) {
|
|
case 'a': case 'A':
|
|
base = MATCH("audio") || MATCH("automata") || MATCH("application") ||
|
|
MATCH("actor");
|
|
break;
|
|
case 'c': case 'C':
|
|
base = MATCH("class") || MATCH("control");
|
|
break;
|
|
case 'd': case 'D':
|
|
base = MATCH("duplex") || MATCH("data") || MATCH("description");
|
|
break;
|
|
case 'e': case 'E':
|
|
base = MATCH("events");
|
|
break;
|
|
case 'i': case 'I':
|
|
base = MATCH("isfocus");
|
|
break;
|
|
case 'l': case 'L':
|
|
base = MATCH("language");
|
|
break;
|
|
case 'm': case 'M':
|
|
base = MATCH("mobility") || MATCH("methods");
|
|
break;
|
|
case 'p': case 'P':
|
|
base = MATCH("priority");
|
|
break;
|
|
case 's': case 'S':
|
|
base = MATCH("schemes");
|
|
break;
|
|
case 't': case 'T':
|
|
base = MATCH("type");
|
|
break;
|
|
case 'v': case 'V':
|
|
base = MATCH("video");
|
|
break;
|
|
default:
|
|
base = 0;
|
|
break;
|
|
}
|
|
#undef MATCH
|
|
|
|
return base ^ xor;
|
|
}
|
|
|
|
/** Check if @Contact is immune to callerprefs. */
|
|
int sip_contact_is_immune(sip_contact_t const *m)
|
|
{
|
|
unsigned i;
|
|
|
|
if (m->m_params)
|
|
for (i = 0; m->m_params[i]; i++) {
|
|
if (sip_is_callerpref(m->m_params[i]))
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/**Check if @Contact matches by @AcceptContact.
|
|
*
|
|
* Matching @AcceptContact and @Contact headers is done as explained in
|
|
* @RFC3841 section 7.2.4. The caller score can be calculated from the
|
|
* returned S and N values.
|
|
*
|
|
* @par Matching
|
|
* The @AcceptContact header contains number of feature tag parameters. The
|
|
* count of feature tags is returned in @a return_N. For each feature tag in
|
|
* @AcceptContact, the feature tag with same name is searched from the
|
|
* @Contact header. If both headers contain the feature tag with same name,
|
|
* their values are compared. If the value in @AcceptContact does not match
|
|
* with the value in @Contact, there is mismatch and 0 is returned. If they
|
|
* match, S is increased by 1.
|
|
*
|
|
* @param m pointer to @Contact header structure
|
|
* @param cp pointer to @AcceptContact header structure
|
|
* @param return_N return-value parameter for number of
|
|
* feature tags in @AcceptContact
|
|
* @param return_S return-value parameter for number of
|
|
* matching feature tags
|
|
* @param return_error return-value parameter for parsing error
|
|
*
|
|
* For example,
|
|
* @code
|
|
* if (sip_contact_accept(contact, accept_contact, &S, &N, &error)) {
|
|
* if (N == 0)
|
|
* score == 1.0;
|
|
* else
|
|
* score = (double)S / (double)N;
|
|
* if (accept_contact->cp_explicit) {
|
|
* if (accept_contact->cp_require)
|
|
* goto drop;
|
|
* else
|
|
* score = 0.0;
|
|
* }
|
|
* }
|
|
* else if (!error) {
|
|
* score = 0.0;
|
|
* }
|
|
* @endcode
|
|
*
|
|
* @retval 1 if @Contact matches
|
|
* @return @a return_S contains number of matching feature tags
|
|
* @return @a return_N contains number of feature tags in @AcceptContact
|
|
* @retval 0 if @Contact does not match
|
|
* @return @a return_error contains -1 if feature tag value was malformed
|
|
*
|
|
* @sa @RFC3841 section 7.2.4, sip_contact_score(), sip_contact_reject(),
|
|
* sip_contact_is_immune(), sip_contact_immunize(), sip_is_callerpref(),
|
|
* sip_prefs_matching().
|
|
*/
|
|
int sip_contact_accept(sip_contact_t const *m,
|
|
sip_accept_contact_t const *cp,
|
|
unsigned *return_S,
|
|
unsigned *return_N,
|
|
int *return_error)
|
|
{
|
|
char const *cap, *acc;
|
|
unsigned i, S, N;
|
|
size_t eq;
|
|
|
|
if (!return_N) return_N = &N;
|
|
if (!return_S) return_S = &S;
|
|
|
|
*return_S = 0, *return_N = 0;
|
|
|
|
if (!m || !cp || !m->m_params || !cp->cp_params)
|
|
return 1;
|
|
|
|
for (i = 0, S = 0, N = 0; cp->cp_params[i]; i++) {
|
|
acc = cp->cp_params[i];
|
|
if (!sip_is_callerpref(acc))
|
|
continue;
|
|
|
|
N++;
|
|
|
|
cap = msg_params_find(m->m_params, acc);
|
|
|
|
if (cap) {
|
|
eq = strcspn(acc, "=");
|
|
acc += eq + (acc[eq] == '=');
|
|
|
|
if (!sip_prefs_matching(cap, acc, return_error))
|
|
return 0;
|
|
|
|
S++;
|
|
}
|
|
}
|
|
|
|
*return_S = S; /* Matched feature tags */
|
|
*return_N = N; /* Number of feature tags in @AcceptContact */
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
/** Check if @Contact is rejected by @RejectContact.
|
|
*
|
|
* @param m pointer to @Contact header
|
|
* @param reject pointer to @RejectContact header
|
|
*
|
|
* @retval 1 when rejecting
|
|
* @retval 0 when @Contact does not match with @RejectContact
|
|
*
|
|
* @sa sip_contact_score(), sip_contact_accept(), sip_contact_immunize(),
|
|
* sip_contact_is_immune(), @RFC3841, @RejectContact, @Contact
|
|
*/
|
|
int sip_contact_reject(sip_contact_t const *m,
|
|
sip_reject_contact_t const *reject)
|
|
{
|
|
unsigned S, N;
|
|
int error;
|
|
|
|
if (!m || !m->m_params || !reject || !reject->cp_params)
|
|
return 0;
|
|
|
|
return sip_contact_accept(m, reject, &S, &N, &error) && S == N && N > 0;
|
|
}
|
|
|
|
/**Immunize @Contact to callerprefs.
|
|
*
|
|
* Make a copy of @Contact header @a m and remove all parameters which
|
|
* affect caller preferences.
|
|
*
|
|
* @param home home object used when allocating copy
|
|
* @param m pointer to @Contact header structure to immunize
|
|
*
|
|
* @retval pointer to immunized copy if successful
|
|
* @retval NULL upon an error
|
|
*
|
|
* @sa @RFC3841, sip_is_callerpref(), sip_contact_score(),
|
|
* sip_contact_accept(), sip_contact_reject(), @Contact
|
|
*/
|
|
sip_contact_t *sip_contact_immunize(su_home_t *home, sip_contact_t const *m)
|
|
{
|
|
unsigned i, j;
|
|
sip_contact_t m0[1], *m1;
|
|
msg_param_t *params;
|
|
|
|
if (!m)
|
|
return NULL;
|
|
|
|
*m0 = *m, m0->m_next = NULL;
|
|
|
|
m1 = sip_contact_copy(home, m0);
|
|
|
|
if (m1 == NULL || !m1->m_params)
|
|
return m1;
|
|
|
|
params = (msg_param_t *)m1->m_params;
|
|
|
|
for (i = 0, j = 0; params[i]; i++) {
|
|
if (!sip_is_callerpref(params[i]))
|
|
params[j++] = params[i];
|
|
}
|
|
|
|
params[j] = NULL;
|
|
|
|
return m1;
|
|
}
|
|
|
|
/** Calculate score for contact.
|
|
*
|
|
* The caller preference score is an integer in range of 0 to 1000.
|
|
*
|
|
* @retval -1 if the contact is rejected
|
|
* @retval 1000 if contact is immune to caller preferences
|
|
* @retval 0..1000 reflecting @RFC3841 score in 0.000 - 1.000.
|
|
*
|
|
* @sa sip_q_value(),
|
|
* sip_contact_accept(), sip_contact_reject(), sip_contact_is_immune(),
|
|
* sip_contact_immunize(), sip_is_callerpref(), sip_prefs_matching(),
|
|
* @RFC3841, @AcceptContact, @RejectContact, @Contact
|
|
*/
|
|
int sip_contact_score(sip_contact_t const *m,
|
|
sip_accept_contact_t const *ac,
|
|
sip_reject_contact_t const *rc)
|
|
{
|
|
unsigned long S_total = 0;
|
|
unsigned M = 0, scale = 1000;
|
|
int error = 0;
|
|
|
|
if (sip_contact_is_immune(m))
|
|
return 1000; /* Immune */
|
|
|
|
for (; rc; rc = rc->cp_next)
|
|
if (sip_contact_reject(m, rc))
|
|
break;
|
|
if (rc)
|
|
return -1; /* Rejected */
|
|
|
|
for (; ac; ac = ac->cp_next) {
|
|
unsigned S, N;
|
|
|
|
if (!sip_contact_accept(m, ac, &S, &N, &error)) {
|
|
if (ac->cp_require)
|
|
return 0; /* Discarded */
|
|
continue;
|
|
}
|
|
|
|
M++;
|
|
|
|
/* Apply score */
|
|
if (S < N && ac->cp_explicit) {
|
|
S = 0;
|
|
if (ac->cp_require)
|
|
return 0; /* Dropped */
|
|
}
|
|
|
|
if (S > 0 && N > 0)
|
|
S_total += sip_q_value(ac->cp_q) * (scale * S / N + (2 * S >= N));
|
|
}
|
|
|
|
if (!M)
|
|
return 0;
|
|
|
|
S_total /= M;
|
|
|
|
if (S_total < scale * 1000)
|
|
return S_total / scale;
|
|
else
|
|
return 1000;
|
|
}
|