/*
* Callback upon receiving packet from network.
*/
static void on_read_complete(pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_read)
{
nat_detect_session *sess;
pj_status_t status;
sess = (nat_detect_session *) pj_ioqueue_get_user_data(key);
pj_assert(sess != NULL);
pj_grp_lock_acquire(sess->grp_lock);
/* Ignore packet when STUN session has been destroyed */
if (!sess->stun_sess)
goto on_return;
if (bytes_read < 0) {
if (-bytes_read != PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK) &&
-bytes_read != PJ_STATUS_FROM_OS(OSERR_EINPROGRESS) &&
-bytes_read != PJ_STATUS_FROM_OS(OSERR_ECONNRESET))
{
/* Permanent error */
end_session(sess, (pj_status_t)-bytes_read,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
goto on_return;
}
} else if (bytes_read > 0) {
pj_stun_session_on_rx_pkt(sess->stun_sess, sess->rx_pkt, bytes_read,
PJ_STUN_IS_DATAGRAM|PJ_STUN_CHECK_PACKET,
NULL, NULL,
&sess->src_addr, sess->src_addr_len);
}
sess->rx_pkt_len = sizeof(sess->rx_pkt);
sess->src_addr_len = sizeof(sess->src_addr);
status = pj_ioqueue_recvfrom(key, op_key, sess->rx_pkt, &sess->rx_pkt_len,
PJ_IOQUEUE_ALWAYS_ASYNC,
&sess->src_addr, &sess->src_addr_len);
if (status != PJ_EPENDING) {
pj_assert(status != PJ_SUCCESS);
end_session(sess, status, PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
}
on_return:
pj_grp_lock_release(sess->grp_lock);
}
static int client_thread(void *unused)
{
PJ_UNUSED_ARG(unused);
while (!client->quit) {
pj_fd_set_t readset;
pj_time_val delay = {0, 10};
/* Also poll the timer heap */
pj_timer_heap_poll(stun_cfg.timer_heap, NULL);
/* Poll client socket */
PJ_FD_ZERO(&readset);
PJ_FD_SET(client->sock, &readset);
if (pj_sock_select((int)client->sock+1, &readset, NULL, NULL, &delay)==1
&& PJ_FD_ISSET(client->sock, &readset))
{
char pkt[1000];
pj_ssize_t len;
pj_status_t status;
pj_sockaddr src_addr;
int src_addr_len;
len = sizeof(pkt);
src_addr_len = sizeof(src_addr);
status = pj_sock_recvfrom(client->sock, pkt, &len, 0, &src_addr, &src_addr_len);
if (status != PJ_SUCCESS)
continue;
/* Increment client's receive count */
client->recv_count++;
/* Only pass to client if we allow to respond */
if (!client->responding)
continue;
pj_stun_session_on_rx_pkt(client->sess, pkt, len,
PJ_STUN_CHECK_PACKET | PJ_STUN_IS_DATAGRAM,
NULL, NULL, &src_addr, src_addr_len);
}
}
return 0;
}
static int server_thread(void *unused)
{
PJ_UNUSED_ARG(unused);
PJ_LOG(5,("", " server thread started"));
while (!server->quit) {
pj_fd_set_t readset;
pj_time_val delay = {0, 10};
PJ_FD_ZERO(&readset);
PJ_FD_SET(server->sock, &readset);
if (pj_sock_select((int)server->sock+1, &readset, NULL, NULL, &delay)==1
&& PJ_FD_ISSET(server->sock, &readset))
{
char pkt[1000];
pj_ssize_t len;
pj_status_t status;
pj_sockaddr src_addr;
int src_addr_len;
len = sizeof(pkt);
src_addr_len = sizeof(src_addr);
status = pj_sock_recvfrom(server->sock, pkt, &len, 0, &src_addr, &src_addr_len);
if (status != PJ_SUCCESS)
continue;
/* Increment server's receive count */
server->recv_count++;
/* Only pass to server if we allow to respond */
if (!server->responding)
continue;
pj_stun_session_on_rx_pkt(server->sess, pkt, len,
PJ_STUN_CHECK_PACKET | PJ_STUN_IS_DATAGRAM,
NULL, NULL, &src_addr, src_addr_len);
}
}
return 0;
}
/*
* Handle incoming packet from client. This would have been called by
* server upon receiving packet from a listener.
*/
PJ_DEF(void) pj_turn_allocation_on_rx_client_pkt(pj_turn_allocation *alloc,
pj_turn_pkt *pkt)
{
pj_bool_t is_stun;
pj_status_t status;
/* Lock this allocation */
pj_lock_acquire(alloc->lock);
/* Quickly check if this is STUN message */
is_stun = ((*((pj_uint8_t*)pkt->pkt) & 0xC0) == 0);
if (is_stun) {
/*
* This could be an incoming STUN requests or indications.
* Pass this through to the STUN session, which will call
* our stun_on_rx_request() or stun_on_rx_indication()
* callbacks.
*
* Note: currently it is necessary to specify the
* PJ_STUN_NO_FINGERPRINT_CHECK otherwise the FINGERPRINT
* attribute inside STUN Send Indication message will mess up
* with fingerprint checking.
*/
unsigned options = PJ_STUN_CHECK_PACKET | PJ_STUN_NO_FINGERPRINT_CHECK;
pj_size_t parsed_len = 0;
if (pkt->transport->listener->tp_type == PJ_TURN_TP_UDP)
options |= PJ_STUN_IS_DATAGRAM;
status = pj_stun_session_on_rx_pkt(alloc->sess, pkt->pkt, pkt->len,
options, NULL, &parsed_len,
&pkt->src.clt_addr,
pkt->src_addr_len);
if (pkt->transport->listener->tp_type == PJ_TURN_TP_UDP) {
pkt->len = 0;
} else if (parsed_len > 0) {
if (parsed_len == pkt->len) {
pkt->len = 0;
} else {
pj_memmove(pkt->pkt, pkt->pkt+parsed_len,
pkt->len - parsed_len);
pkt->len -= parsed_len;
}
}
if (status != PJ_SUCCESS) {
alloc_err(alloc, "Error handling STUN packet", status);
goto on_return;
}
} else {
/*
* This is not a STUN packet, must be ChannelData packet.
*/
pj_turn_channel_data *cd = (pj_turn_channel_data*)pkt->pkt;
pj_turn_permission *perm;
pj_ssize_t len;
pj_assert(sizeof(*cd)==4);
/* For UDP check the packet length */
if (alloc->transport->listener->tp_type == PJ_TURN_TP_UDP) {
if (pkt->len < pj_ntohs(cd->length)+sizeof(*cd)) {
PJ_LOG(4,(alloc->obj_name,
"ChannelData from %s discarded: UDP size error",
alloc->info));
goto on_return;
}
} else {
pj_assert(!"Unsupported transport");
goto on_return;
}
perm = lookup_permission_by_chnum(alloc, pj_ntohs(cd->ch_number));
if (!perm) {
/* Discard */
PJ_LOG(4,(alloc->obj_name,
"ChannelData from %s discarded: ch#0x%x not found",
alloc->info, pj_ntohs(cd->ch_number)));
goto on_return;
}
/* Relay the data */
len = pj_ntohs(cd->length);
pj_sock_sendto(alloc->relay.tp.sock, cd+1, &len, 0,
&perm->hkey.peer_addr,
pj_sockaddr_get_len(&perm->hkey.peer_addr));
/* Refresh permission */
refresh_permission(perm);
}
on_return:
/* Release lock */
pj_lock_release(alloc->lock);
}
/* Callback from active socket when incoming packet is received */
static pj_bool_t on_data_recvfrom(pj_activesock_t *asock,
void *data,
pj_size_t size,
const pj_sockaddr_t *src_addr,
int addr_len,
pj_status_t status)
{
pj_stun_sock *stun_sock;
pj_stun_msg_hdr *hdr;
pj_uint16_t type;
stun_sock = (pj_stun_sock*) pj_activesock_get_user_data(asock);
/* Log socket error */
if (status != PJ_SUCCESS) {
PJ_PERROR(2,(stun_sock->obj_name, status, "recvfrom() error"));
return PJ_TRUE;
}
/* Check that this is STUN message */
status = pj_stun_msg_check((const pj_uint8_t*)data, size,
PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET);
if (status != PJ_SUCCESS) {
/* Not STUN -- give it to application */
goto process_app_data;
}
/* Treat packet as STUN header and copy the STUN message type.
* We don't want to access the type directly from the header
* since it may not be properly aligned.
*/
hdr = (pj_stun_msg_hdr*) data;
pj_memcpy(&type, &hdr->type, 2);
type = pj_ntohs(type);
/* If the packet is a STUN Binding response and part of the
* transaction ID matches our internal ID, then this is
* our internal STUN message (Binding request or keep alive).
* Give it to our STUN session.
*/
if (!PJ_STUN_IS_RESPONSE(type) ||
PJ_STUN_GET_METHOD(type) != PJ_STUN_BINDING_METHOD ||
pj_memcmp(hdr->tsx_id, stun_sock->tsx_id, 10) != 0)
{
/* Not STUN Binding response, or STUN transaction ID mismatch.
* This is not our message too -- give it to application.
*/
goto process_app_data;
}
/* This is our STUN Binding response. Give it to the STUN session */
status = pj_stun_session_on_rx_pkt(stun_sock->stun_sess, data, size,
PJ_STUN_IS_DATAGRAM, NULL, NULL,
src_addr, addr_len);
return status!=PJNATH_ESTUNDESTROYED ? PJ_TRUE : PJ_FALSE;
process_app_data:
if (stun_sock->cb.on_rx_data) {
pj_bool_t ret;
ret = (*stun_sock->cb.on_rx_data)(stun_sock, data, size,
src_addr, addr_len);
return ret;
}
return PJ_TRUE;
}
/*
* This callback is called by UDP listener on incoming packet. This is
* the first entry for incoming packet (from client) to the server. From
* here, the packet may be handed over to an allocation if an allocation
* is found for the client address, or handed over to owned STUN session
* if an allocation is not found.
*/
PJ_DEF(void) pj_turn_srv_on_rx_pkt(pj_turn_srv *srv,
pj_turn_pkt *pkt)
{
pj_turn_allocation *alloc;
/* Get TURN allocation from the source address */
pj_lock_acquire(srv->core.lock);
alloc = (pj_turn_allocation*)
pj_hash_get(srv->tables.alloc, &pkt->src, sizeof(pkt->src), NULL);
pj_lock_release(srv->core.lock);
/* If allocation is found, just hand over the packet to the
* allocation.
*/
if (alloc) {
pj_turn_allocation_on_rx_client_pkt(alloc, pkt);
} else {
/* Otherwise this is a new client */
unsigned options;
pj_size_t parsed_len;
pj_status_t status;
/* Check that this is a STUN message */
options = PJ_STUN_CHECK_PACKET | PJ_STUN_NO_FINGERPRINT_CHECK;
if (pkt->transport->listener->tp_type == PJ_TURN_TP_UDP)
options |= PJ_STUN_IS_DATAGRAM;
status = pj_stun_msg_check(pkt->pkt, pkt->len, options);
if (status != PJ_SUCCESS) {
/* If the first byte are not STUN, drop the packet. First byte
* of STUN message is always 0x00 or 0x01. Otherwise wait for
* more data as the data might have come from TCP.
*
* Also drop packet if it's unreasonably too big, as this might
* indicate invalid data that's building up in the buffer.
*
* Or if packet is a datagram.
*/
if ((*pkt->pkt != 0x00 && *pkt->pkt != 0x01) ||
pkt->len > 1600 ||
(options & PJ_STUN_IS_DATAGRAM))
{
char errmsg[PJ_ERR_MSG_SIZE];
char ip[PJ_INET6_ADDRSTRLEN+10];
pkt->len = 0;
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(5,(srv->obj_name,
"Non-STUN packet from %s is dropped: %s",
pj_sockaddr_print(&pkt->src.clt_addr, ip, sizeof(ip), 3),
errmsg));
}
return;
}
/* Special handling for Binding Request. We won't give it to the
* STUN session since this request is not authenticated.
*/
if (pkt->pkt[1] == 1) {
handle_binding_request(pkt, options);
return;
}
/* Hand over processing to STUN session. This will trigger
* on_rx_stun_request() callback to be called if the STUN
* message is a request.
*/
options &= ~PJ_STUN_CHECK_PACKET;
parsed_len = 0;
status = pj_stun_session_on_rx_pkt(srv->core.stun_sess, pkt->pkt,
pkt->len, options, pkt->transport,
&parsed_len, &pkt->src.clt_addr,
pkt->src_addr_len);
if (status != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
char ip[PJ_INET6_ADDRSTRLEN+10];
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(5,(srv->obj_name,
"Error processing STUN packet from %s: %s",
pj_sockaddr_print(&pkt->src.clt_addr, ip, sizeof(ip), 3),
errmsg));
}
if (pkt->transport->listener->tp_type == PJ_TURN_TP_UDP) {
pkt->len = 0;
} else if (parsed_len > 0) {
if (parsed_len == pkt->len) {
pkt->len = 0;
} else {
pj_memmove(pkt->pkt, pkt->pkt+parsed_len,
pkt->len - parsed_len);
pkt->len -= parsed_len;
}
}
}
}
/**
* Notify TCP client session upon receiving a packet from server.
* The packet maybe a STUN packet or ChannelData packet.
*/
PJ_DEF(pj_status_t) pj_tcp_session_on_rx_pkt(pj_tcp_session *sess,
void *pkt,
unsigned pkt_len,
pj_size_t *parsed_len)
{
pj_bool_t is_stun = PJ_FALSE;
pj_status_t stun_check;
pj_status_t status;
char buf[PJ_INET6_ADDRSTRLEN+20];
pj_uint16_t data_len;
/* Packet could be ChannelData or STUN message (response or
* indication).
*/
/* Start locking the session */
pj_lock_acquire(sess->lock);
/* Quickly check if this is STUN message */
//is_stun = (((pj_uint16_t*)pkt)[0] != NATNL_UDT_HEADER_MAGIC);
stun_check = pj_stun_msg_check((const pj_uint8_t*)pkt, pkt_len,
/*PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET*/ 0);
if (stun_check == PJ_SUCCESS)
is_stun = PJ_TRUE;
if (is_stun) {
#if 1
/* This looks like STUN, give it to the STUN session */
unsigned options;
pj_size_t msg_len;
options = PJ_STUN_CHECK_PACKET | PJ_STUN_NO_FINGERPRINT_CHECK;
msg_len = GETVAL16H((const pj_uint8_t*)pkt, 2);
*parsed_len = (msg_len+sizeof(pj_stun_msg_hdr) <= pkt_len) ?
msg_len+sizeof(struct pj_stun_msg_hdr) : 0;
/* Notify application */
if (sess->cb.on_rx_data) {
(*sess->cb.on_rx_data)(sess, pkt, pkt_len,
sess->peer_addr, sess->peer_addr_len);
}
//DumpPacket(pkt, pkt_len, 0, 5);
status = PJ_SUCCESS;
#else
/* This looks like STUN, give it to the STUN session */
unsigned options;
options = PJ_STUN_CHECK_PACKET | PJ_STUN_NO_FINGERPRINT_CHECK;
status=pj_stun_session_on_rx_pkt(sess->stun, pkt, pkt_len,
options, NULL, parsed_len,
sess->peer_addr, sess->peer_addr_len);
#endif
PJ_LOG(5, (THIS_FILE, "pj_tcp_session_on_rx_pkt() is_stun %s",
sess->peer_addr == NULL ? "NULL" :
pj_sockaddr_print(sess->peer_addr, buf, PJ_INET6_ADDRSTRLEN, 3)));
} else {
PJ_LOG(5, (THIS_FILE, "pj_tcp_session_on_rx_pkt() not_stun %s",
sess->peer_addr == NULL ? "NULL" :
pj_sockaddr_print(sess->peer_addr, buf, PJ_INET6_ADDRSTRLEN, 3)));
//DumpPacket(pkt, pkt_len, 0, 7);
if (((pj_uint16_t*)pkt)[0] != NATNL_UDT_HEADER_MAGIC) {
if (pkt_len < NATNL_DTLS_HEADER_SIZE) {
if (parsed_len) {
*parsed_len = 0;
}
return PJ_ETOOSMALL;
}
/* Check that size is sane */
data_len = pj_ntohs(((pj_uint16_t*)(((pj_uint8_t*)pkt)+11))[0]);
if (pkt_len < data_len+NATNL_DTLS_HEADER_SIZE) {
if (parsed_len) {
/* Insufficient fragment */
*parsed_len = 0;
}
status = PJ_ETOOSMALL;
goto on_return;
} else {
if (parsed_len) {
/* Apply padding too */
*parsed_len = data_len+NATNL_DTLS_HEADER_SIZE;
}
}
} else {
if (pkt_len < NATNL_UDT_HEADER_SIZE) {
if (parsed_len) {
*parsed_len = 0;
}
return PJ_ETOOSMALL;
}
/* Check that size is sane */
data_len = pj_ntohs(((pj_uint16_t*)pkt)[1]);
if (pkt_len < data_len+NATNL_UDT_HEADER_SIZE) {
if (parsed_len) {
/* Insufficient fragment */
*parsed_len = 0;
}
status = PJ_ETOOSMALL;
goto on_return;
} else {
if (parsed_len) {
/* Apply padding too */
*parsed_len = data_len+NATNL_UDT_HEADER_SIZE;
}
}
}
/* Notify application */
if (sess->cb.on_rx_data) {
(*sess->cb.on_rx_data)(sess, pkt, *parsed_len,
sess->peer_addr, sess->peer_addr_len);
}
//DumpPacket(pkt, pkt_len, 0, 6);
status = PJ_SUCCESS;
}
on_return:
pj_lock_release(sess->lock);
return status;
}
