/* This takes ownership of nrsock whether it fails or not. */
static int nr_tcp_socket_ctx_create(nr_socket *nrsock, int is_framed,
int max_pending, nr_tcp_socket_ctx **sockp)
{
int r, _status;
nr_tcp_socket_ctx *sock = 0;
nr_socket *tcpsock;
if (!(sock = RCALLOC(sizeof(nr_tcp_socket_ctx)))) {
nr_socket_destroy(&nrsock);
ABORT(R_NO_MEMORY);
}
if ((r=nr_socket_buffered_stun_create(nrsock, max_pending, is_framed ? ICE_TCP_FRAMING : TURN_TCP_FRAMING, &tcpsock))){
nr_socket_destroy(&nrsock);
ABORT(r);
}
sock->inner=tcpsock;
sock->is_framed=is_framed;
if ((r=nr_ip4_port_to_transport_addr(ntohl(INADDR_ANY), 0, IPPROTO_TCP, &sock->remote_addr)))
ABORT(r);
*sockp=sock;
_status=0;
abort:
if (_status) {
r_log(LOG_ICE,LOG_DEBUG,"%s:%d function %s failed with error %d",__FILE__,__LINE__,__FUNCTION__,_status);
nr_tcp_socket_ctx_destroy(&sock);
}
return(_status);
}
int main(int argc, char **argv)
{
int r;
nr_transport_addr my_addr;
nr_socket *my_sock;
int fd;
struct timeval tv;
if (argc != 1)
usage();
nr_app_startup("turn_server",NR_APP_STARTUP_INIT_LOGGING|NR_APP_STARTUP_REGISTRY_LOCAL,&LOG_TURN_SERVER,0,0);
NR_reg_set_char("logging.stderr.enabled", 1);
NR_reg_set_char("logging.syslog.enabled", 1);
NR_reg_set_string("logging.syslog.facility.turn_client.level", "debug");
NR_reg_set_string("logging.stderr.facility.turn_client.level", "debug");
NR_reg_set_string("logging.syslog.facility.stun.level", "debug");
NR_reg_set_string("logging.stderr.facility.stun.level", "debug");
NR_reg_set_string("logging.syslog.facility.turn.level", "debug");
NR_reg_set_string("logging.stderr.facility.turn.level", "debug");
NR_async_timer_init();
gettimeofday(&tv,0);
NR_async_timer_update_time(&tv);
/* Set up the TURN client */
nr_ip4_port_to_transport_addr(ntohl(0), 3478, IPPROTO_UDP, &my_addr);
if(r=nr_socket_local_create(&my_addr,&my_sock)){
fprintf(stderr,"Couldn't create socket\n");
exit(1);
}
/* Now set an async cb */
nr_socket_getfd(my_sock,&fd);
NR_ASYNC_WAIT(fd,NR_ASYNC_WAIT_READ,s_cb,my_sock);
while(1){
int events;
struct timeval towait={0,50};
if(r=NR_async_event_wait2(&events,&towait)){
#if 0
if(r==R_EOD)
break;
if(r!=R_WOULDBLOCK){
fprintf(stderr,"Error in event wait\n");
exit(1);
}
#endif
}
gettimeofday(&tv,0);
NR_async_timer_update_time(&tv);
}
printf("Success!\n");
exit(0);
}
int nr_netaddr_to_transport_addr(const net::NetAddr *netaddr,
nr_transport_addr *addr, int protocol)
{
int _status;
int r;
switch(netaddr->raw.family) {
case AF_INET:
if ((r = nr_ip4_port_to_transport_addr(ntohl(netaddr->inet.ip),
ntohs(netaddr->inet.port),
protocol, addr)))
ABORT(r);
break;
case AF_INET6:
ABORT(R_BAD_ARGS);
default:
MOZ_ASSERT(false);
ABORT(R_BAD_ARGS);
}
_status=0;
abort:
return(_status);
}
int
nr_ice_peer_ctx_parse_global_attributes(nr_ice_peer_ctx *pctx, char **attrs, int attr_ct)
{
int r,_status;
int i;
char *orig = 0;
char *str;
char *component_id;
char *connection_address;
unsigned int port;
in_addr_t addr;
char *ice_option_tag;
for(i=0;i<attr_ct;i++){
orig = str = attrs[i];
component_id = 0;
connection_address = 0;
ice_option_tag = 0;
if (!strncasecmp(str, "remote-candidates:", 18)) {
fast_forward(&str, 18);
skip_whitespace(&str);
while (*str != '\0') {
if ((r=grab_token(&str, &component_id)))
ABORT(r);
if (*str == '\0')
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
if ((r=grab_token(&str, &connection_address)))
ABORT(r);
if (*str == '\0')
ABORT(R_BAD_DATA);
addr = inet_addr(connection_address);
if (addr == INADDR_NONE)
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
if (sscanf(str, "%u", &port) != 1)
ABORT(R_BAD_DATA);
if (port < 1 || port > 0x0FFFF)
ABORT(R_BAD_DATA);
skip_to_past_space(&str);
#if 0
/* TODO: !nn! just drop on the floor for now, later put somewhere */
/* Assume v4 for now */
if(r=nr_ip4_port_to_transport_addr(ntohl(addr),port,IPPROTO_UDP,&candidate->base))
ABORT(r);
TAILQ_INSERT_TAIL(head, elm, field);
#endif
component_id = 0; /* prevent free */
RFREE(connection_address);
connection_address = 0; /* prevent free */
}
}
else if (!strncasecmp(str, "ice-lite", 8)) {
pctx->peer_lite = 1;
fast_forward(&str, 8);
}
else if (!strncasecmp(str, "ice-mismatch", 12)) {
pctx->peer_ice_mismatch = 1;
fast_forward(&str, 12);
}
else if (!strncasecmp(str, "ice-ufrag:", 10)) {
fast_forward(&str, 10);
if (*str == '\0')
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
if ((r=grab_token(&str, &pctx->peer_ufrag)))
ABORT(r);
}
else if (!strncasecmp(str, "ice-pwd:", 8)) {
fast_forward(&str, 8);
if (*str == '\0')
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
if ((r=grab_token(&str, &pctx->peer_pwd)))
ABORT(r);
}
else if (!strncasecmp(str, "ice-options:", 12)) {
fast_forward(&str, 12);
skip_whitespace(&str);
while (*str != '\0') {
if ((r=grab_token(&str, &ice_option_tag)))
ABORT(r);
skip_whitespace(&str);
#if 0
//TODO: !nn! for now, just drop on the floor, later put somewhere
#endif
ice_option_tag = 0; /* prevent free */
}
}
else {
ABORT(R_BAD_DATA);
}
skip_whitespace(&str);
/* it's expected to be at EOD at this point */
assert(strlen(str) == 0);
}
_status=0;
abort:
if (_status) {
if (orig)
r_log(LOG_ICE,LOG_WARNING,"ICE-PEER(%s): Error parsing attribute: %s",pctx->label,orig);
}
RFREE(connection_address);
RFREE(component_id);
RFREE(ice_option_tag);
return(_status);
}
int
nr_ice_peer_candidate_from_attribute(nr_ice_ctx *ctx,char *orig,nr_ice_media_stream *stream,nr_ice_candidate **candp)
{
int r,_status;
char* str = orig;
nr_ice_candidate *cand;
char *connection_address=0;
unsigned int port;
in_addr_t addr;
int i;
unsigned int component_id;
char *rel_addr=0;
if(!(cand=RCALLOC(sizeof(nr_ice_candidate))))
ABORT(R_NO_MEMORY);
if(!(cand->label=r_strdup(orig)))
ABORT(R_NO_MEMORY);
cand->ctx=ctx;
cand->isock=0;
cand->state=NR_ICE_CAND_PEER_CANDIDATE;
cand->stream=stream;
skip_whitespace(&str);
/* Candidate attr */
if (strncasecmp(str, "candidate:", 10))
ABORT(R_BAD_DATA);
fast_forward(&str, 10);
if (*str == '\0')
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
/* Foundation */
if ((r=grab_token(&str, &cand->foundation)))
ABORT(r);
if (*str == '\0')
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
/* component */
if (sscanf(str, "%u", &component_id) != 1)
ABORT(R_BAD_DATA);
if (component_id < 1 || component_id > 256)
ABORT(R_BAD_DATA);
cand->component_id = (UCHAR)component_id;
skip_to_past_space(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
/* Protocol */
if (strncasecmp(str, "UDP", 3))
ABORT(R_BAD_DATA);
fast_forward(&str, 3);
if (*str == '\0')
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
/* priority */
if (sscanf(str, "%u", &cand->priority) != 1)
ABORT(R_BAD_DATA);
if (cand->priority < 1)
ABORT(R_BAD_DATA);
skip_to_past_space(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
/* Peer address/port */
if ((r=grab_token(&str, &connection_address)))
ABORT(r);
if (*str == '\0')
ABORT(R_BAD_DATA);
addr = inet_addr(connection_address);
if (addr == INADDR_NONE)
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
if (sscanf(str, "%u", &port) != 1)
ABORT(R_BAD_DATA);
if (port < 1 || port > 0x0FFFF)
ABORT(R_BAD_DATA);
/* Assume v4 for now */
if(r=nr_ip4_port_to_transport_addr(ntohl(addr),port,IPPROTO_UDP,&cand->addr))
ABORT(r);
skip_to_past_space(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
/* Type */
if (strncasecmp("typ", str, 3))
ABORT(R_BAD_DATA);
fast_forward(&str, 3);
if (*str == '\0')
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
assert(nr_ice_candidate_type_names[0] == 0);
for (i = 1; nr_ice_candidate_type_names[i]; ++i) {
if(!strncasecmp(nr_ice_candidate_type_names[i], str, strlen(nr_ice_candidate_type_names[i]))) {
cand->type=i;
break;
}
}
if (nr_ice_candidate_type_names[i] == 0)
ABORT(R_BAD_DATA);
fast_forward(&str, strlen(nr_ice_candidate_type_names[i]));
/* Look for the other side's raddr, rport */
/* raddr, rport */
switch (cand->type) {
case HOST:
break;
case SERVER_REFLEXIVE:
case PEER_REFLEXIVE:
case RELAYED:
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
if (strncasecmp("raddr", str, 5))
ABORT(R_BAD_DATA);
fast_forward(&str, 5);
if (*str == '\0')
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
if ((r=grab_token(&str, &rel_addr)))
ABORT(r);
if (*str == '\0')
ABORT(R_BAD_DATA);
addr = inet_addr(rel_addr);
if (addr == INADDR_NONE)
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
if (strncasecmp("rport", str, 5))
ABORT(R_BAD_DATA);
fast_forward(&str, 5);
if (*str == '\0')
ABORT(R_BAD_DATA);
skip_whitespace(&str);
if (*str == '\0')
ABORT(R_BAD_DATA);
if (sscanf(str, "%u", &port) != 1)
ABORT(R_BAD_DATA);
if (port < 1 || port > 0x0FFFF)
ABORT(R_BAD_DATA);
/* Assume v4 for now */
if(r=nr_ip4_port_to_transport_addr(ntohl(addr),port,IPPROTO_UDP,&cand->base))
ABORT(r);
skip_to_past_space(&str);
/* it's expected to be at EOD at this point */
break;
default:
ABORT(R_INTERNAL);
break;
}
skip_whitespace(&str);
assert(strlen(str) == 0);
*candp=cand;
_status=0;
abort:
if (_status)
r_log(LOG_ICE,LOG_WARNING,"ICE(%s): Error parsing attribute: %s",ctx->label,orig);
RFREE(connection_address);
RFREE(rel_addr);
return(_status);
}
int
main(int argc, char* argv[])
{
int verbose = 0;
const int maxaddr = 256;
nr_transport_addr addresses[maxaddr];
int has_address = 0;
StunAddress4 address;
int numAddresses = 0;
int i;
int testNum;
int srcPort = 0;
printf("STUN client version %s\n",NR_STUN_VERSION);
fflush(stdout);
nr_crypto_openssl_set();
nr_app_startup("client",NR_APP_STARTUP_INIT_LOGGING|NR_APP_STARTUP_REGISTRY_LOCAL,&NR_LOG_STUN,0,0);
NR_reg_set_char("logging.stderr.enabled", 1);
NR_reg_set_char("logging.syslog.enabled", 1);
NR_reg_set_string("logging.syslog.facility.client.level", "debug");
NR_reg_set_string("logging.syslog.facility.stun.level", "debug");
NR_reg_set_string("logging.stderr.facility.client.level", "debug");
NR_reg_set_string("logging.stderr.facility.stun.level", "debug");
if (nr_stun_startup()) {
printf("Failed to start STUN\n");
exit(1);
}
if (initNetwork()) {
printf("Failed to start STUN\n");
exit(1);
}
StunAddress4 stunServerAddr;
stunServerAddr.addr=0;
int arg;
for ( arg = 1; arg<argc; arg++ )
{
if ( !strcmp( argv[arg] , "-v" ) )
{
verbose = 1;
}
else if ( !strcmp( argv[arg] , "-n" ) )
{
auth_rule = NR_STUN_AUTH_RULE_OPTIONAL;
}
else if ( !strcmp( argv[arg] , "-s" ) )
{
auth_rule = NR_STUN_AUTH_RULE_SHORT_TERM;
}
else if ( !strcmp( argv[arg] , "-l" ) )
{
auth_rule = NR_STUN_AUTH_RULE_LONG_TERM;
}
#ifdef USE_STUND_0_96
else if ( !strcmp( argv[arg] , "-c" ) )
{
stun_mode = NR_STUN_MODE_STUND_0_96;
}
#endif /* USE_STUND_0_96 */
else if ( !strcmp( argv[arg] , "-p" ) )
{
arg++;
if ( argc <= arg )
{
usage();
exit(-1);
}
srcPort = strtol( argv[arg], NULL, 10);
}
else if ( !strcmp( argv[arg] , "-i" ) )
{
arg++;
if ( argc <= arg )
{
usage();
exit(-1);
}
if (nr_stun_parse_server_name( argv[arg], &address))
{
fprintf(stderr,"%s is not a valid host name \n",argv[arg]);
fflush(stderr);
usage();
exit(-1);
}
has_address = 1;
}
else
{
char* ptr;
int t = strtol( argv[arg], &ptr, 10 );
if ( *ptr == 0 )
{
// conversion worked
testNum = t;
printf("running test number %d\n",testNum);
fflush(stdout);
}
else
{
if (nr_stun_parse_server_name( argv[arg], &stunServerAddr))
{
fprintf(stderr,"%s is not a valid host name \n",argv[arg]);
usage();
exit(-1);
}
}
}
}
if (has_address) {
if (nr_ip4_port_to_transport_addr(address.addr, srcPort, IPPROTO_UDP, &addresses[0]))
{
fprintf(stderr,"bad address\n");
exit(1);
}
numAddresses=1;
}
if (numAddresses == 0) {
if (nr_stun_find_local_addresses(addresses, maxaddr, &numAddresses))
numAddresses = 0;
}
else if ( srcPort == 0 )
{
if (nr_stun_randomPort(&srcPort)) {
fprintf(stderr,"Failed\n");
exit(1);
}
}
if (numAddresses == 0) {
address.addr = 0;
address.port = srcPort;
nr_stun_request(&stunServerAddr,1,&address);
}
else for (i = 0; i < numAddresses; ++i) {
address.addr = ntohl(addresses[i].u.addr4.sin_addr.s_addr);
address.port = ntohs(addresses[i].u.addr4.sin_port);
nr_stun_request(&stunServerAddr,1,&address);
}
return 0;
}
int main(int argc, char **argv)
{
int r;
nr_turn_client_ctx *c_turn;
nr_transport_addr my_addr;
nr_socket *my_sock;
int fd;
struct timeval tv;
nr_crypto_openssl_set();
if (argc != 2)
usage();
nr_app_startup("turn_client",NR_APP_STARTUP_INIT_LOGGING|NR_APP_STARTUP_REGISTRY_LOCAL,&LOG_TURN_CLIENT,0,0);
NR_reg_set_char("logging.stderr.enabled", 1);
NR_reg_set_char("logging.syslog.enabled", 1);
NR_reg_set_string("logging.syslog.facility.turn_client.level", "debug");
NR_reg_set_string("logging.stderr.facility.turn_client.level", "debug");
NR_reg_set_string("logging.syslog.facility.stun.level", "debug");
NR_reg_set_string("logging.stderr.facility.stun.level", "debug");
NR_reg_set_string("logging.syslog.facility.turn.level", "debug");
NR_reg_set_string("logging.stderr.facility.turn.level", "debug");
NR_async_timer_init();
gettimeofday(&tv,0);
NR_async_timer_update_time(&tv);
nr_ip4_port_to_transport_addr(ntohl(inet_addr(argv[1])),
3478,IPPROTO_UDP,&remote_addr);
/* Set up the TURN client */
nr_ip4_port_to_transport_addr(ntohl(0), 0, IPPROTO_UDP, &my_addr);
if(r=nr_socket_local_create(&my_addr,&my_sock)){
fprintf(stderr,"Couldn't create socket\n");
exit(1);
}
if(r=nr_turn_client_ctx_create("TEST",my_sock, 0, &remote_addr,0, &c_turn)){
fprintf(stderr,"Couldn't create TURN ctx\n");
exit(1);
}
/* Start TURN */
if(r=nr_turn_client_allocate(c_turn, user, &pass, 123456, 654321, done_cb, c_turn)){
fprintf(stderr,"Couldn't start TURN\n");
exit(1);
}
/* Now set an async cb */
nr_socket_getfd(my_sock,&fd);
NR_ASYNC_WAIT(fd,NR_ASYNC_WAIT_READ,c_cb,c_turn);
while(1){
int events;
struct timeval towait={0,50};
if(r=NR_async_event_wait2(&events,&towait)){
#if 0
if(r==R_EOD)
break;
if(r!=R_WOULDBLOCK){
fprintf(stderr,"Error in event wait\n");
exit(1);
}
#endif
}
gettimeofday(&tv,0);
NR_async_timer_update_time(&tv);
}
printf("Success!\n");
exit(0);
}
int
nr_stun_server_process(StunServerInfo* info)
{
int r,_status;
char msg[NR_STUN_MAX_MESSAGE_SIZE];
int msgLen = sizeof(msg);
char ok = 0;
char recvAltIp =0;
char recvAltPort = 0;
fd_set fdSet;
Socket maxFd=0;
struct timeval tv;
nr_stun_message *req;
nr_stun_message *resp;
Data password = { (UCHAR*)"hello", 5 };
nr_transport_addr from2;
FD_ZERO(&fdSet);
FD_SET(info->myFd,&fdSet);
if ( info->myFd >= maxFd ) maxFd=info->myFd+1;
tv.tv_sec = 1;
tv.tv_usec = 0;
int e = select( maxFd, &fdSet, NULL,NULL, &tv );
if (e < 0)
{
r_log_e(NR_LOG_STUN, LOG_WARNING, "Error on select");
}
else if (e >= 0)
{
StunAddress4 from;
if (FD_ISSET(info->myFd,&fdSet))
{
r_log(NR_LOG_STUN, LOG_DEBUG, "received on A1:P1");
recvAltIp = 0;
recvAltPort = 0;
ok = 1;
if (getMessage( info->myFd, msg, &msgLen, &from.addr, &from.port))
ok = 0;
}
else
{
goto done;
}
if ( !ok )
{
r_log(NR_LOG_STUN, LOG_DEBUG, "Get message did not return a valid message");
goto done;
}
r_log(NR_LOG_STUN, LOG_DEBUG, "Got request (len=%u) from %s",msgLen,nr_ip4toa(&from));
if ( msgLen <= 0 )
{
goto done;
}
if ((r=nr_stun_message_create2(&req, (UCHAR*)msg, msgLen))) {
fprintf(stderr,"Error in nr_stun_message_create2\n");
exit(1);
}
if ((r=nr_stun_decode_message(req, returnpassword, &password))) {
fprintf(stderr,"Error in nr_stun_parse_message\n");
exit(1);
}
if ((r=nr_stun_message_create(&resp))) {
fprintf(stderr,"Error in nr_stun_message_create\n");
exit(1);
}
nr_ip4_port_to_transport_addr(from.addr, from.port, IPPROTO_UDP, &from2);
if ((r=nr_stun_receive_message(0, req))) {
r_log(NR_LOG_STUN, LOG_DEBUG, "Failed to receive message");
nr_stun_form_error_response(req, resp, 400, "Bad Message");
}
else if (alternate_server && from.addr != info->myAddr.addr) {
/* NOTE: this code is broken because we don't want 'from', we want 'to',
* but UNIX doesn't provide a way to easily get that information, so
* the -a flag only works when the client and server reside on the
* same machine */
/* send ALTERNATE-SERVER */
nr_transport_addr alternate_server;
nr_stun_form_error_response(req, resp, 300, "Alternate Server");
nr_ip4_port_to_transport_addr(info->myAddr.addr, info->myAddr.port, IPPROTO_UDP, &alternate_server);
nr_stun_message_add_alternate_server_attribute(resp, &alternate_server);
}
else if ((r=nr_stun_process_request(req,resp))) {
r_log(NR_LOG_STUN, LOG_DEBUG, "Failed to process request");
/* continue, even though failed to parse message, to send error message */
}
else {
nr_stun_form_success_response(req, &from2, &password, resp);
}
if ((r=nr_stun_encode_message(resp)))
{
/* ignore this failure */
}
else if (from.addr != 0 && from.port != 0)
{
if ( info->myFd != INVALID_SOCKET )
{
sendMessage(info->myFd, (char*)resp->buffer, resp->length, from.addr, from.port);
}
}
}
done:
_status=0;
// abort:
return _status;
}
