/*
* this function sends the received packet to the corresponding port
* if port not found, drops the packet i.e. frees it and returns
*/
void network_handler(void *a)
{
if (!a) {
return;
}
int old_level = set_interrupt_level(DISABLED);
network_interrupt_arg_t *arg = (network_interrupt_arg_t *) a;
if (arg->size < sizeof(mini_header_t))
{
free(a);
set_interrupt_level(old_level);
return;
}
mini_header_t *header = (mini_header_t *) (arg->buffer);
//Handle UDP Packet
if (header->protocol-'0' == PROTOCOL_MINIDATAGRAM) {
handle_udp_packet(arg);
set_interrupt_level(old_level);
return;
}
//Handle TCP Packet
else if (header->protocol-'0' == PROTOCOL_MINISTREAM)
{
minisocket_handle_tcp_packet(arg);
set_interrupt_level(old_level);
return;
}
free(arg);
set_interrupt_level(old_level);
return;
}
static void udp_server_input_handler(evutil_socket_t fd, short what, void* arg)
{
int cycle = 0;
dtls_listener_relay_server_type* server = (dtls_listener_relay_server_type*) arg;
FUNCSTART;
if (!(what & EV_READ)) {
return;
}
ioa_network_buffer_handle *elem = NULL;
start_udp_cycle:
elem = (ioa_network_buffer_handle *)ioa_network_buffer_allocate(server->e);
server->sm.m.sm.nd.nbh = elem;
server->sm.m.sm.nd.recv_ttl = TTL_IGNORE;
server->sm.m.sm.nd.recv_tos = TOS_IGNORE;
int slen = server->slen0;
ssize_t bsize = 0;
int flags = 0;
do {
bsize = recvfrom(fd, ioa_network_buffer_data(elem), ioa_network_buffer_get_capacity(), flags, (struct sockaddr*) &(server->sm.m.sm.nd.src_addr), (socklen_t*) &slen);
} while (bsize < 0 && (errno == EINTR));
int conn_reset = is_connreset();
int to_block = would_block();
if (bsize < 0) {
if(to_block) {
ioa_network_buffer_delete(server->e, server->sm.m.sm.nd.nbh);
server->sm.m.sm.nd.nbh = NULL;
FUNCEND;
return;
}
#if defined(MSG_ERRQUEUE)
//Linux
int eflags = MSG_ERRQUEUE | MSG_DONTWAIT;
static s08bits buffer[65535];
u32bits errcode = 0;
ioa_addr orig_addr;
int ttl = 0;
int tos = 0;
udp_recvfrom(fd, &orig_addr, &(server->addr), buffer,
(int) sizeof(buffer), &ttl, &tos, server->e->cmsg, eflags,
&errcode);
//try again...
do {
bsize = recvfrom(fd, ioa_network_buffer_data(elem), ioa_network_buffer_get_capacity(), flags, (struct sockaddr*) &(server->sm.m.sm.nd.src_addr), (socklen_t*) &slen);
} while (bsize < 0 && (errno == EINTR));
conn_reset = is_connreset();
to_block = would_block();
#endif
if(conn_reset) {
ioa_network_buffer_delete(server->e, server->sm.m.sm.nd.nbh);
server->sm.m.sm.nd.nbh = NULL;
reopen_server_socket(server);
FUNCEND;
return;
}
}
if(bsize<0) {
if(!to_block && !conn_reset) {
int ern=errno;
perror(__FUNCTION__);
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "%s: recvfrom error %d\n",__FUNCTION__,ern);
}
ioa_network_buffer_delete(server->e, server->sm.m.sm.nd.nbh);
server->sm.m.sm.nd.nbh = NULL;
FUNCEND;
return;
}
if (bsize > 0) {
ioa_network_buffer_set_size(elem, (size_t)bsize);
server->sm.m.sm.s = server->udp_listen_s;
int rc = handle_udp_packet(server, &(server->sm), server->e, server->ts);
if(rc < 0) {
if(eve(server->e->verbose)) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Cannot handle UDP event\n");
}
}
}
ioa_network_buffer_delete(server->e, server->sm.m.sm.nd.nbh);
server->sm.m.sm.nd.nbh = NULL;
if(cycle++<MAX_SINGLE_UDP_BATCH)
goto start_udp_cycle;
FUNCEND;
}
static int sd_udpinput(t_addr *const curr_laddr, const t_laddr_info *laddr_info,
int ssocket, int usocket)
{
int err;
psock_t_socklen errlen;
t_packet * upacket;
if (laddr_info == NULL) {
(void)ssocket;
}
err = 0;
errlen = sizeof(err);
if (psock_getsockopt(usocket,PSOCK_SOL_SOCKET,PSOCK_SO_ERROR,&err,&errlen)<0)
{
eventlog(eventlog_level_error,"sd_udpinput","[%d] unable to read socket error (psock_getsockopt: %s)",usocket,strerror(psock_errno()));
return -1;
}
if (errlen && err) /* if it was an error, there is no packet to read */
{
eventlog(eventlog_level_error,"sd_udpinput","[%d] async UDP socket error notification (psock_getsockopt: %s)",usocket,strerror(err));
return -1;
}
if (!(upacket = packet_create(packet_class_udp)))
{
eventlog(eventlog_level_error,"sd_udpinput","could not allocate raw packet for input");
return -1;
}
{
struct sockaddr_in fromaddr;
psock_t_socklen fromlen;
int len;
fromlen = sizeof(fromaddr);
if ((len = psock_recvfrom(usocket,packet_get_raw_data_build(upacket,0),MAX_PACKET_SIZE,0,(struct sockaddr *)&fromaddr,&fromlen))<0)
{
if (
#ifdef PSOCK_EINTR
psock_errno()!=PSOCK_EINTR &&
#endif
#ifdef PSOCK_EAGAIN
psock_errno()!=PSOCK_EAGAIN &&
#endif
#ifdef PSOCK_EWOULDBLOCK
psock_errno()!=PSOCK_EWOULDBLOCK &&
#endif
1)
eventlog(eventlog_level_error,"sd_udpinput","could not recv UDP datagram (psock_recvfrom: %s)",strerror(psock_errno()));
packet_del_ref(upacket);
return -1;
}
if (fromaddr.sin_family!=PSOCK_AF_INET)
{
eventlog(eventlog_level_error,"sd_udpinput","got UDP datagram with bad address family %d",(int)fromaddr.sin_family);
packet_del_ref(upacket);
return -1;
}
packet_set_size(upacket,len);
if (hexstrm)
{
char tempa[32];
if (!addr_get_addr_str(curr_laddr,tempa,sizeof(tempa)))
strcpy(tempa,"x.x.x.x:x");
fprintf(hexstrm,"%d: recv class=%s[0x%02x] type=%s[0x%04x] from=%s to=%s length=%u\n",
usocket,
packet_get_class_str(upacket),(unsigned int)packet_get_class(upacket),
packet_get_type_str(upacket,packet_dir_from_client),packet_get_type(upacket),
addr_num_to_addr_str(ntohl(fromaddr.sin_addr.s_addr),ntohs(fromaddr.sin_port)),
tempa,
packet_get_size(upacket));
hexdump(hexstrm,packet_get_raw_data(upacket,0),packet_get_size(upacket));
}
handle_udp_packet(usocket,ntohl(fromaddr.sin_addr.s_addr),ntohs(fromaddr.sin_port),upacket);
packet_del_ref(upacket);
}
return 0;
}
