|
|
|
|
@ -48,6 +48,12 @@ struct streamhandler {
|
|
|
|
|
const struct streamhandler_io *in;
|
|
|
|
|
const struct streamhandler_io *out;
|
|
|
|
|
};
|
|
|
|
|
struct intf_rr {
|
|
|
|
|
struct logical_intf hash_key;
|
|
|
|
|
mutex_t lock;
|
|
|
|
|
GQueue logical_intfs;
|
|
|
|
|
struct logical_intf *singular; // set iff only one is present in the list - no lock needed
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void determine_handler(struct packet_stream *in, const struct packet_stream *out);
|
|
|
|
|
@ -74,6 +80,9 @@ static int call_savpf2avp_rtcp(str *s, struct packet_stream *, struct stream_fd
|
|
|
|
|
//static int call_savpf2savp_rtcp(str *s, struct packet_stream *);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static struct logical_intf *__get_logical_interface(const str *name, sockfamily_t *fam);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@ -256,13 +265,12 @@ static const struct rtpengine_srtp __res_null = {
|
|
|
|
|
static GQueue *__interface_list_for_family(sockfamily_t *fam);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static GHashTable *__logical_intf_name_family_hash;
|
|
|
|
|
static GHashTable *__intf_spec_addr_type_hash;
|
|
|
|
|
static GHashTable *__local_intf_addr_type_hash; // hash of lists
|
|
|
|
|
static GHashTable *__logical_intf_name_family_hash; // name + family -> struct logical_intf
|
|
|
|
|
static GHashTable *__logical_intf_name_family_rr_hash; // name + family -> struct intf_rr
|
|
|
|
|
static GHashTable *__intf_spec_addr_type_hash; // addr + type -> struct intf_spec
|
|
|
|
|
static GHashTable *__local_intf_addr_type_hash; // addr + type -> GList of struct local_intf
|
|
|
|
|
static GQueue __preferred_lists_for_family[__SF_LAST];
|
|
|
|
|
|
|
|
|
|
static __thread unsigned int selection_index = 0;
|
|
|
|
|
static __thread unsigned int selection_count = 0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* checks for free no_ports on a local interface */
|
|
|
|
|
@ -272,7 +280,7 @@ static int has_free_ports_loc(struct local_intf *loc, unsigned int num_ports) {
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (num_ports > loc->spec->port_pool.free_ports) {
|
|
|
|
|
if (num_ports > g_atomic_int_get(&loc->spec->port_pool.free_ports)) {
|
|
|
|
|
ilog(LOG_ERR, "Didn't found %d ports available for %.*s/%s",
|
|
|
|
|
num_ports, loc->logical->name.len, loc->logical->name.s,
|
|
|
|
|
sockaddr_print_buf(&loc->spec->local_address.addr));
|
|
|
|
|
@ -332,64 +340,49 @@ static int has_free_ports_log_all(struct logical_intf *log, unsigned int num_por
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* run round-robin-calls algorithm */
|
|
|
|
|
static struct logical_intf* run_round_robin_calls(GQueue *q, unsigned int num_ports) {
|
|
|
|
|
static struct logical_intf* run_round_robin_calls(struct intf_rr *rr, unsigned int num_ports) {
|
|
|
|
|
struct logical_intf *log = NULL;
|
|
|
|
|
volatile unsigned int nr_tries = 0;
|
|
|
|
|
unsigned int nr_logs = 0;
|
|
|
|
|
|
|
|
|
|
nr_logs = g_queue_get_length(q);
|
|
|
|
|
mutex_lock(&rr->lock);
|
|
|
|
|
|
|
|
|
|
select_log:
|
|
|
|
|
// choose the next logical interface
|
|
|
|
|
log = g_queue_peek_nth(q, selection_index);
|
|
|
|
|
if (!log) {
|
|
|
|
|
if (selection_index == 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
selection_index = 0;
|
|
|
|
|
goto select_log;
|
|
|
|
|
}
|
|
|
|
|
__C_DBG("Trying %d ports on logical interface %.*s", num_ports, log->name.len, log->name.s);
|
|
|
|
|
unsigned int max_tries = rr->logical_intfs.length;
|
|
|
|
|
unsigned int num_tries = 0;
|
|
|
|
|
|
|
|
|
|
// test for free ports for the logical interface
|
|
|
|
|
if(!has_free_ports_log_all(log, num_ports)) {
|
|
|
|
|
// count the logical interfaces tried
|
|
|
|
|
nr_tries++;
|
|
|
|
|
while (num_tries++ < max_tries) {
|
|
|
|
|
log = g_queue_pop_head(&rr->logical_intfs);
|
|
|
|
|
g_queue_push_tail(&rr->logical_intfs, log);
|
|
|
|
|
|
|
|
|
|
// the logical interface selected has no ports available, try another one
|
|
|
|
|
selection_index ++;
|
|
|
|
|
selection_index = selection_index % nr_logs;
|
|
|
|
|
mutex_unlock(&rr->lock);
|
|
|
|
|
|
|
|
|
|
// all the logical interfaces have no ports available
|
|
|
|
|
if (nr_tries == nr_logs) {
|
|
|
|
|
ilog(LOG_ERR, "No logical interface with free ports found; fallback to default behaviour");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
__C_DBG("Trying %d ports on logical interface " STR_FORMAT, num_ports, STR_FMT(&log->name));
|
|
|
|
|
|
|
|
|
|
if (has_free_ports_log_all(log, num_ports))
|
|
|
|
|
goto done;
|
|
|
|
|
log = NULL;
|
|
|
|
|
|
|
|
|
|
goto select_log;
|
|
|
|
|
mutex_lock(&rr->lock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
__C_DBG("Round Robin Calls algorithm found logical %.*s; count=%u index=%u", log->name.len, log->name.s, selection_count, selection_index);
|
|
|
|
|
mutex_unlock(&rr->lock);
|
|
|
|
|
|
|
|
|
|
// 1 stream => 2 x get_logical_interface calls at offer
|
|
|
|
|
// 2 streams => 4 x get_logical_interface calls at offer
|
|
|
|
|
selection_count ++;
|
|
|
|
|
if (selection_count % (num_ports / 2) == 0) {
|
|
|
|
|
selection_count = 0;
|
|
|
|
|
selection_index ++;
|
|
|
|
|
selection_index = selection_index % nr_logs;
|
|
|
|
|
done:
|
|
|
|
|
if (!log) {
|
|
|
|
|
ilog(LOG_ERR, "No logical interface with free ports found; fallback to default behaviour");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
__C_DBG("Round Robin Calls algorithm found logical " STR_FORMAT, STR_FMT(&log->name));
|
|
|
|
|
return log;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// 'fam' may only be NULL if 'name' is also NULL
|
|
|
|
|
struct logical_intf *get_logical_interface(const str *name, sockfamily_t *fam, int num_ports) {
|
|
|
|
|
struct logical_intf d, *log = NULL;
|
|
|
|
|
struct logical_intf *log = NULL;
|
|
|
|
|
|
|
|
|
|
__C_DBG("Get logical interface for %d ports", num_ports);
|
|
|
|
|
|
|
|
|
|
if (G_UNLIKELY(!name || !name->s ||
|
|
|
|
|
str_cmp(name, ALGORITHM_ROUND_ROBIN_CALLS) == 0)) {
|
|
|
|
|
|
|
|
|
|
if (G_UNLIKELY(!name || !name->s)) {
|
|
|
|
|
// trivial case: no interface given. just pick one suitable for the address family.
|
|
|
|
|
// always used for legacy TCP and UDP protocols.
|
|
|
|
|
GQueue *q;
|
|
|
|
|
if (fam)
|
|
|
|
|
q = __interface_list_for_family(fam);
|
|
|
|
|
@ -404,35 +397,46 @@ got_some:
|
|
|
|
|
;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// round-robin-calls behaviour - return next interface with free ports
|
|
|
|
|
if (name && name->s && str_cmp(name, ALGORITHM_ROUND_ROBIN_CALLS) == 0 && num_ports > 0) {
|
|
|
|
|
log = run_round_robin_calls(q, num_ports);
|
|
|
|
|
if (log) {
|
|
|
|
|
__C_DBG("Choose logical interface %.*s because of direction %.*s",
|
|
|
|
|
log->name.len, log->name.s,
|
|
|
|
|
name->len, name->s);
|
|
|
|
|
} else {
|
|
|
|
|
__C_DBG("Choose logical interface NULL because of direction %.*s",
|
|
|
|
|
name->len, name->s);
|
|
|
|
|
}
|
|
|
|
|
return log;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// default behaviour - return first logical interface
|
|
|
|
|
return q->head ? q->head->data : NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// check if round-robin is desired
|
|
|
|
|
struct logical_intf key;
|
|
|
|
|
key.name = *name;
|
|
|
|
|
key.preferred_family = fam;
|
|
|
|
|
struct intf_rr *rr = g_hash_table_lookup(__logical_intf_name_family_rr_hash, &key);
|
|
|
|
|
if (!rr)
|
|
|
|
|
return __get_logical_interface(name, fam);
|
|
|
|
|
if (rr->singular) {
|
|
|
|
|
__C_DBG("Returning non-RR logical interface '" STR_FORMAT "' based on direction '" \
|
|
|
|
|
STR_FORMAT "'",
|
|
|
|
|
STR_FMT(&rr->singular->name),
|
|
|
|
|
STR_FMT(name));
|
|
|
|
|
return rr->singular;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
__C_DBG("Running RR interface selection for direction '" STR_FORMAT "'",
|
|
|
|
|
STR_FMT(name));
|
|
|
|
|
|
|
|
|
|
log = run_round_robin_calls(rr, num_ports);
|
|
|
|
|
if (log)
|
|
|
|
|
return log;
|
|
|
|
|
return __get_logical_interface(name, fam);
|
|
|
|
|
}
|
|
|
|
|
static struct logical_intf *__get_logical_interface(const str *name, sockfamily_t *fam) {
|
|
|
|
|
struct logical_intf d, *log = NULL;
|
|
|
|
|
|
|
|
|
|
d.name = *name;
|
|
|
|
|
d.preferred_family = fam;
|
|
|
|
|
|
|
|
|
|
log = g_hash_table_lookup(__logical_intf_name_family_hash, &d);
|
|
|
|
|
if (log) {
|
|
|
|
|
__C_DBG("Choose logical interface %.*s because of direction %.*s",
|
|
|
|
|
log->name.len, log->name.s,
|
|
|
|
|
name->len, name->s);
|
|
|
|
|
__C_DBG("Choose logical interface " STR_FORMAT " because of direction " STR_FORMAT,
|
|
|
|
|
STR_FMT(&log->name),
|
|
|
|
|
STR_FMT(name));
|
|
|
|
|
} else {
|
|
|
|
|
__C_DBG("Choose logical interface NULL because of direction %.*s",
|
|
|
|
|
name->len, name->s);
|
|
|
|
|
__C_DBG("Choose logical interface NULL because of direction " STR_FORMAT,
|
|
|
|
|
STR_FMT(name));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return log;
|
|
|
|
|
@ -482,26 +486,50 @@ int is_local_endpoint(const struct intf_address *addr, unsigned int port) {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// called during single-threaded startup only
|
|
|
|
|
static void __add_intf_rr_1(struct logical_intf *lif, str *name_base, sockfamily_t *fam) {
|
|
|
|
|
struct logical_intf key;
|
|
|
|
|
key.name = *name_base;
|
|
|
|
|
key.preferred_family = fam;
|
|
|
|
|
struct intf_rr *rr = g_hash_table_lookup(__logical_intf_name_family_rr_hash, &key);
|
|
|
|
|
if (!rr) {
|
|
|
|
|
rr = g_slice_alloc0(sizeof(*rr));
|
|
|
|
|
rr->hash_key = key;
|
|
|
|
|
mutex_init(&rr->lock);
|
|
|
|
|
g_hash_table_insert(__logical_intf_name_family_rr_hash, &rr->hash_key, rr);
|
|
|
|
|
}
|
|
|
|
|
g_queue_push_tail(&rr->logical_intfs, lif);
|
|
|
|
|
rr->singular = (rr->logical_intfs.length == 1) ? lif : NULL;
|
|
|
|
|
g_hash_table_insert(lif->rr_specs, &rr->hash_key.name, lif);
|
|
|
|
|
}
|
|
|
|
|
static void __add_intf_rr(struct logical_intf *lif, str *name_base, sockfamily_t *fam) {
|
|
|
|
|
__add_intf_rr_1(lif, name_base, fam);
|
|
|
|
|
static str legacy_rr_str = STR_CONST_INIT("round-robin-calls");
|
|
|
|
|
__add_intf_rr_1(lif, &legacy_rr_str, fam);
|
|
|
|
|
}
|
|
|
|
|
static GQueue *__interface_list_for_family(sockfamily_t *fam) {
|
|
|
|
|
return &__preferred_lists_for_family[fam->idx];
|
|
|
|
|
}
|
|
|
|
|
// called during single-threaded startup only
|
|
|
|
|
static void __interface_append(struct intf_config *ifa, sockfamily_t *fam) {
|
|
|
|
|
struct logical_intf *lif;
|
|
|
|
|
GQueue *q;
|
|
|
|
|
struct local_intf *ifc;
|
|
|
|
|
struct intf_spec *spec;
|
|
|
|
|
|
|
|
|
|
lif = get_logical_interface(&ifa->name, fam, 0);
|
|
|
|
|
lif = __get_logical_interface(&ifa->name, fam);
|
|
|
|
|
|
|
|
|
|
if (!lif) {
|
|
|
|
|
lif = g_slice_alloc0(sizeof(*lif));
|
|
|
|
|
lif->name = ifa->name;
|
|
|
|
|
lif->preferred_family = fam;
|
|
|
|
|
lif->addr_hash = g_hash_table_new(__addr_type_hash, __addr_type_eq);
|
|
|
|
|
lif->rr_specs = g_hash_table_new(str_hash, str_equal);
|
|
|
|
|
g_hash_table_insert(__logical_intf_name_family_hash, lif, lif);
|
|
|
|
|
if (ifa->local_address.addr.family == fam) {
|
|
|
|
|
q = __interface_list_for_family(fam);
|
|
|
|
|
g_queue_push_tail(q, lif);
|
|
|
|
|
__add_intf_rr(lif, &ifa->name_base, fam);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -527,6 +555,7 @@ static void __interface_append(struct intf_config *ifa, sockfamily_t *fam) {
|
|
|
|
|
__insert_local_intf_addr_type(&ifc->advertised_address, ifc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// called during single-threaded startup only
|
|
|
|
|
void interfaces_init(GQueue *interfaces) {
|
|
|
|
|
int i;
|
|
|
|
|
GList *l;
|
|
|
|
|
@ -535,6 +564,7 @@ void interfaces_init(GQueue *interfaces) {
|
|
|
|
|
|
|
|
|
|
/* init everything */
|
|
|
|
|
__logical_intf_name_family_hash = g_hash_table_new(__name_family_hash, __name_family_eq);
|
|
|
|
|
__logical_intf_name_family_rr_hash = g_hash_table_new(__name_family_hash, __name_family_eq);
|
|
|
|
|
__intf_spec_addr_type_hash = g_hash_table_new(__addr_type_hash, __addr_type_eq);
|
|
|
|
|
__local_intf_addr_type_hash = g_hash_table_new(__addr_type_hash, __addr_type_eq);
|
|
|
|
|
|
|
|
|
|
|
Richard Fuchs
8 years ago