void *run_upd_listen(void* arg) {
int *portno = (int *)arg;
g_print("[I] udp server thread running, listening on port number %i\n", *portno);
udp_listen(*portno);
return NULL;
}
static int start(struct allocation *alloc)
{
struct sa laddr;
int err = 0;
if (!alloc)
return EINVAL;
sa_init(&laddr, sa_af(&alloc->srv));
switch (alloc->proto) {
case IPPROTO_UDP:
err = udp_listen(&alloc->us, &laddr, udp_recv, alloc);
if (err) {
re_fprintf(stderr, "allocation: failed to"
" create UDP socket"
" (%m)\n", err);
goto out;
}
udp_sockbuf_set(alloc->us, 524288);
if (alloc->secure) {
/* note: re-using UDP socket for DTLS-traffic */
err = dtls_listen(&alloc->dtls_sock, NULL, alloc->us,
2, DTLS_LAYER, NULL, NULL);
if (err) {
re_fprintf(stderr, "dtls_listen error: %m\n",
err);
goto out;
}
err = dtls_connect(&alloc->tlsc, alloc->tls,
alloc->dtls_sock, &alloc->srv,
dtls_estab_handler,
dtls_recv_handler,
dtls_close_handler, alloc);
if (err) {
re_fprintf(stderr, "dtls_connect error: %m\n",
err);
goto out;
}
}
else {
err = turnc_alloc(&alloc->turnc, NULL, IPPROTO_UDP,
alloc->us, TURN_LAYER, &alloc->srv,
alloc->user, alloc->pass,
TURN_DEFAULT_LIFETIME,
turnc_handler, alloc);
if (err) {
re_fprintf(stderr, "allocation: failed to"
" create TURN client"
" (%m)\n", err);
goto out;
}
}
break;
case IPPROTO_TCP:
err = tcp_connect(&alloc->tc, &alloc->srv, tcp_estab_handler,
tcp_recv_handler, tcp_close_handler, alloc);
if (err)
break;
if (alloc->secure) {
err = tls_start_tcp(&alloc->tlsc, alloc->tls,
alloc->tc, 0);
if (err)
break;
}
break;
default:
err = EPROTONOSUPPORT;
goto out;
}
out:
return err;
}
static void udp_read(struct udp_sock *us, int fd)
{
struct mbuf *mb = mbuf_alloc(us->rxsz);
struct sa src;
struct le *le;
int err = 0;
ssize_t n;
if (!mb)
return;
src.len = sizeof(src.u);
n = recvfrom(fd, BUF_CAST mb->buf + us->rx_presz,
mb->size - us->rx_presz, 0,
&src.u.sa, &src.len);
if (n < 0) {
err = errno;
if (EAGAIN == err)
goto out;
#ifdef EWOULDBLOCK
if (EWOULDBLOCK == err)
goto out;
#endif
#if TARGET_OS_IPHONE
if (ENOTCONN == err) {
struct udp_sock *us_new;
struct sa laddr;
err = udp_local_get(us, &laddr);
if (err)
goto out;
if (-1 != us->fd) {
fd_close(us->fd);
(void)close(us->fd);
us->fd = -1;
}
if (-1 != us->fd6) {
fd_close(us->fd6);
(void)close(us->fd6);
us->fd6 = -1;
}
err = udp_listen(&us_new, &laddr, NULL, NULL);
if (err)
goto out;
us->fd = us_new->fd;
us->fd6 = us_new->fd6;
us_new->fd = -1;
us_new->fd6 = -1;
mem_deref(us_new);
udp_thread_attach(us);
goto out;
}
#endif
/* cache error code */
us->err = err;
goto out;
}
mb->pos = us->rx_presz;
mb->end = n + us->rx_presz;
(void)mbuf_resize(mb, mb->end);
/* call helpers */
le = us->helpers.head;
while (le) {
struct udp_helper *uh = le->data;
bool hdld;
le = le->next;
hdld = uh->recvh(&src, mb, uh->arg);
if (hdld)
goto out;
}
us->rh(&src, mb, us->arg);
out:
mem_deref(mb);
}
/*
* you can call this at any time
*
* @param addr HOST: SA_ADDR portion is used
* non-HOST: SA_ADDR + SA_PORT portion is used
*
* @param base_addr Optional
* @param rel_addr Optional
*
* @param layer mandatory for HOST and RELAY candidates
*/
int trice_lcand_add(struct ice_lcand **lcandp, struct trice *icem,
unsigned compid, int proto,
uint32_t prio, const struct sa *addr,
const struct sa *base_addr,
enum ice_cand_type type, const struct sa *rel_addr,
enum ice_tcptype tcptype,
void *sock, int layer)
{
struct ice_lcand *lcand;
int err = 0;
if (!icem || !compid || !proto || !addr)
return EINVAL;
if (!sa_isset(addr, SA_ADDR)) {
DEBUG_WARNING("lcand_add: SA_ADDR is not set\n");
return EINVAL;
}
if (type != ICE_CAND_TYPE_HOST) {
if (!sa_isset(addr, SA_PORT)) {
DEBUG_WARNING("lcand_add: %s: SA_PORT"
" must be set (%J)\n",
ice_cand_type2name(type), addr);
return EINVAL;
}
}
/* lookup candidate, replace if PRIO is higher */
/* TODO: dont look up TCP-ACTIVE types for now (port is zero) */
if (proto == IPPROTO_UDP) {
lcand = trice_lcand_find(icem, -1, compid, proto, addr);
if (lcand) {
trice_printf(icem,
"add_local[%s.%J] --"
" candidate already exists"
" (%H)\n",
ice_cand_type2name(type), addr,
trice_cand_print, lcand);
if (prio > lcand->attr.prio)
lcand = mem_deref(lcand);
else {
goto out;
}
}
}
err = trice_add_lcandidate(&lcand, icem, &icem->lcandl, compid, NULL,
proto, prio, addr, base_addr,
type, rel_addr, tcptype);
if (err)
return err;
if (type == ICE_CAND_TYPE_HOST) {
switch (proto) {
case IPPROTO_UDP:
if (sock) {
struct sa laddr;
lcand->us = mem_ref(sock);
err = udp_local_get(lcand->us,
&laddr);
if (err)
goto out;
lcand->attr.addr = *addr;
sa_set_port(&lcand->attr.addr,
sa_port(&laddr));
}
else {
err = udp_listen(&lcand->us, addr,
dummy_udp_recv, lcand);
if (err)
goto out;
err = udp_local_get(lcand->us,
&lcand->attr.addr);
if (err)
goto out;
}
err = udp_register_helper(&lcand->uh, lcand->us,
layer,
udp_helper_send_handler,
udp_helper_recv_handler,
lcand);
if (err)
goto out;
break;
case IPPROTO_TCP:
/* TCP-transport has 3 variants:
active, passive, so */
if (lcand->attr.tcptype == ICE_TCP_ACTIVE) {
/* the port MUST be set to 9 (i.e., Discard) */
/*sa_set_port(&lcand->attr.addr, 9); */
}
else if (lcand->attr.tcptype == ICE_TCP_PASSIVE ||
lcand->attr.tcptype == ICE_TCP_SO) {
err = tcp_listen(&lcand->ts, addr,
tcp_conn_handler, lcand);
if (err)
goto out;
err = tcp_local_get(lcand->ts,
&lcand->attr.addr);
if (err)
goto out;
}
else {
err = EPROTONOSUPPORT;
goto out;
}
break;
default:
err = EPROTONOSUPPORT;
goto out;
}
}
else if (type == ICE_CAND_TYPE_RELAY) {
switch (proto) {
case IPPROTO_UDP:
if (sock) {
lcand->us = mem_ref(sock);
}
else {
err = udp_listen(&lcand->us, NULL,
dummy_udp_recv, lcand);
if (err)
goto out;
}
err = udp_register_helper(&lcand->uh, lcand->us,
layer,
udp_helper_send_handler,
udp_helper_recv_handler,
lcand);
if (err)
goto out;
break;
default:
err = EPROTONOSUPPORT;
goto out;
}
}
else if (type == ICE_CAND_TYPE_SRFLX ||
type == ICE_CAND_TYPE_PRFLX) {
/* Special case for SRFLX UDP candidates, if he has
* its own UDP-socket that can be used.
*/
if (proto == IPPROTO_UDP && sock) {
lcand->us = mem_ref(sock);
err = udp_register_helper(&lcand->uh, lcand->us,
layer,
udp_helper_send_handler,
udp_helper_recv_handler,
lcand);
if (err)
goto out;
}
}
lcand->layer = layer;
/* pair this local-candidate with all existing remote-candidates */
err = trice_candpair_with_local(icem, lcand);
if (err)
goto out;
/* new pair -- refresh the checklist timer */
trice_checklist_refresh(icem);
out:
if (err)
mem_deref(lcand);
else if (lcandp)
*lcandp = lcand;
return err;
}
/**
* Allocate a new NAT Mapping Behaviour Discovery session
*
* @param nmp Pointer to allocated NAT Mapping object
* @param laddr Local IP address
* @param srv STUN Server IP address and port
* @param proto Transport protocol
* @param conf STUN configuration (Optional)
* @param mh Mapping handler
* @param arg Handler argument
*
* @return 0 if success, errorcode if failure
*/
int nat_mapping_alloc(struct nat_mapping **nmp, const struct sa *laddr,
const struct sa *srv, int proto,
const struct stun_conf *conf,
nat_mapping_h *mh, void *arg)
{
struct nat_mapping *nm;
int i, err;
if (!nmp || !laddr || !srv || !mh)
return EINVAL;
nm = mem_zalloc(sizeof(*nm), mapping_destructor);
if (!nm)
return ENOMEM;
err = stun_alloc(&nm->stun, conf, NULL, NULL);
if (err)
goto out;
nm->proto = proto;
sa_cpy(&nm->laddr, laddr);
switch (proto) {
case IPPROTO_UDP:
err = udp_listen(&nm->us, &nm->laddr, udp_recv_handler, nm);
if (err)
goto out;
err = udp_local_get(nm->us, &nm->laddr);
if (err)
goto out;
break;
case IPPROTO_TCP:
/* Allocate and bind 3 TCP Sockets */
for (i=0; i<3; i++) {
err = tcp_conn_alloc(&nm->tcv[i], srv,
tcp_estab_handler,
tcp_recv_handler,
tcp_close_handler, nm);
if (err)
goto out;
err = tcp_conn_bind(nm->tcv[i], &nm->laddr);
if (err)
goto out;
err = tcp_conn_local_get(nm->tcv[i], &nm->laddr);
if (err)
goto out;
}
break;
default:
err = EPROTONOSUPPORT;
goto out;
}
sa_cpy(&nm->srv, srv);
nm->mh = mh;
nm->arg = arg;
*nmp = nm;
out:
if (err)
mem_deref(nm);
return err;
}
static int test_stun_request(int proto, bool natted)
{
struct stunserver *srv = NULL;
struct stun_ctrans *ct = NULL;
struct nat *nat = NULL;
struct test test;
struct sa laddr, public_addr;
int err;
memset(&test, 0, sizeof(test));
err = stunserver_alloc(&srv);
if (err)
goto out;
err = stun_alloc(&test.stun, NULL, NULL, NULL);
if (err)
goto out;
if (proto == IPPROTO_UDP) {
err = sa_set_str(&laddr, "127.0.0.1", 0);
TEST_ERR(err);
err = udp_listen(&test.us, &laddr, udp_recv_handler, &test);
if (err)
goto out;
err = udp_local_get(test.us, &laddr);
TEST_ERR(err);
}
if (natted) {
err = sa_set_str(&public_addr, "4.5.6.7", 0);
TEST_ERR(err);
err = nat_alloc(&nat, srv->us, &public_addr);
if (err)
goto out;
sa_set_port(&public_addr, sa_port(&laddr));
}
else {
public_addr = laddr;
}
err = stun_request(&ct, test.stun, proto, test.us,
stunserver_addr(srv, proto), 0,
STUN_METHOD_BINDING, NULL, 0, true,
stun_resp_handler, &test, 0);
if (err)
goto out;
TEST_ASSERT(ct != NULL);
err = re_main_timeout(100);
if (err)
goto out;
if (srv->err) {
err = srv->err;
goto out;
}
if (test.err) {
err = test.err;
goto out;
}
/* verify results */
TEST_ASSERT(srv->nrecv >= 1);
TEST_EQUALS(1, test.n_resp);
if (proto == IPPROTO_UDP) {
TEST_SACMP(&public_addr, &test.mapped_addr, SA_ALL);
}
out:
mem_deref(test.stun);
mem_deref(test.us);
mem_deref(nat);
mem_deref(srv);
return err;
}
/**
* Add a SIP transport
*
* @param sip SIP stack instance
* @param tp SIP Transport
* @param laddr Local network address
* @param ... Optional transport parameters such as TLS context
*
* @return 0 if success, otherwise errorcode
*/
int sip_transp_add(struct sip *sip, enum sip_transp tp,
const struct sa *laddr, ...)
{
struct sip_transport *transp;
struct tls *tls;
va_list ap;
int err;
if (!sip || !laddr || !sa_isset(laddr, SA_ADDR))
return EINVAL;
transp = mem_zalloc(sizeof(*transp), transp_destructor);
if (!transp)
return ENOMEM;
list_append(&sip->transpl, &transp->le, transp);
transp->sip = sip;
transp->tp = tp;
va_start(ap, laddr);
switch (tp) {
case SIP_TRANSP_UDP:
err = udp_listen((struct udp_sock **)&transp->sock, laddr,
udp_recv_handler, transp);
if (err)
break;
err = udp_local_get(transp->sock, &transp->laddr);
break;
case SIP_TRANSP_TLS:
tls = va_arg(ap, struct tls *);
if (!tls) {
err = EINVAL;
break;
}
transp->tls = mem_ref(tls);
/*@fallthrough@*/
case SIP_TRANSP_TCP:
err = tcp_listen((struct tcp_sock **)&transp->sock, laddr,
tcp_connect_handler, transp);
if (err)
break;
err = tcp_sock_local_get(transp->sock, &transp->laddr);
break;
default:
err = EPROTONOSUPPORT;
break;
}
va_end(ap);
if (err)
mem_deref(transp);
return err;
}
static void process_msg(struct turnserver *turn, int proto, void *sock,
const struct sa *src, struct mbuf *mb)
{
struct stun_msg *msg = NULL;
struct sa laddr;
int err = 0;
if (stun_msg_decode(&msg, mb, NULL)) {
uint16_t numb, len;
struct channel *chan;
if (!turn->us_relay)
return;
++turn->n_raw;
numb = ntohs(mbuf_read_u16(mb));
len = ntohs(mbuf_read_u16(mb));
if (mbuf_get_left(mb) < len) {
DEBUG_WARNING("short length: %zu < %u\n",
mbuf_get_left(mb), len);
}
chan = find_channel_numb(turn, numb);
if (!chan) {
DEBUG_WARNING("channel not found: numb=%u\n", numb);
return;
}
/* relay data from channel to peer */
(void)udp_send(turn->us_relay, &chan->peer, mb);
return;
}
#if 0
re_printf("process: %s:%p:%J %s\n",
net_proto2name(proto), sock, src,
stun_method_name(stun_msg_method(msg)));
#endif
switch (stun_msg_method(msg)) {
case STUN_METHOD_ALLOCATE:
/* Max 1 allocation for now */
++turn->n_allocate;
if (turn->us_relay) {
err = EALREADY;
goto out;
}
turn->cli = *src;
err = sa_set_str(&laddr, "127.0.0.1", 0);
if (err)
goto out;
err = udp_listen(&turn->us_relay, &laddr,
relay_udp_recv, turn);
if (err)
goto out;
err = udp_local_get(turn->us_relay, &turn->relay);
if (err)
goto out;
udp_rxbuf_presz_set(turn->us_relay, 4);
err = stun_reply(proto, sock, src, 0,
msg, NULL, 0, false,
2,
STUN_ATTR_XOR_MAPPED_ADDR, src,
STUN_ATTR_XOR_RELAY_ADDR, &turn->relay);
break;
case STUN_METHOD_CREATEPERM: {
struct stun_attr *peer;
++turn->n_createperm;
peer = stun_msg_attr(msg, STUN_ATTR_XOR_PEER_ADDR);
TEST_ASSERT(peer != NULL);
add_permission(turn, &peer->v.xor_peer_addr);
/* todo: install permissions and check them */
err = stun_reply(proto, sock, src, 0,
msg, NULL, 0, false,
0);
}
break;
case STUN_METHOD_CHANBIND: {
struct stun_attr *chnr, *peer;
++turn->n_chanbind;
TEST_ASSERT(turn->us_relay != NULL);
chnr = stun_msg_attr(msg, STUN_ATTR_CHANNEL_NUMBER);
peer = stun_msg_attr(msg, STUN_ATTR_XOR_PEER_ADDR);
if (!chnr || !peer) {
DEBUG_WARNING("CHANBIND: missing chnr/peer attrib\n");
}
TEST_ASSERT(turn->chanc < ARRAY_SIZE(turn->chanv));
turn->chanv[turn->chanc].nr = chnr->v.channel_number;
turn->chanv[turn->chanc].peer = peer->v.xor_peer_addr;
++turn->chanc;
err = stun_reply(proto, sock, src, 0,
msg, NULL, 0, false,
0);
}
break;
case STUN_METHOD_SEND: {
struct stun_attr *peer, *data;
++turn->n_send;
TEST_ASSERT(turn->us_relay != NULL);
peer = stun_msg_attr(msg, STUN_ATTR_XOR_PEER_ADDR);
data = stun_msg_attr(msg, STUN_ATTR_DATA);
if (!peer || !data) {
DEBUG_WARNING("SEND: missing peer/data attrib\n");
goto out;
}
/* check for valid Permission */
if (!find_permission(turn, &peer->v.xor_peer_addr)) {
DEBUG_NOTICE("no permission to peer %j\n",
&peer->v.xor_peer_addr);
goto out;
}
err = udp_send(turn->us_relay, &peer->v.xor_peer_addr,
&data->v.data);
}
break;
default:
DEBUG_WARNING("unknown STUN method: %s\n",
stun_method_name(stun_msg_method(msg)));
err = EPROTO;
break;
}
if (err)
goto out;
out:
if (err && stun_msg_class(msg) == STUN_CLASS_REQUEST) {
(void)stun_ereply(proto, sock, src, 0, msg,
500, "Server Error",
NULL, 0, false, 0);
}
mem_deref(msg);
}