void NicerConnection::initializeGlobals() {
std::lock_guard<std::mutex> guard(nicer_initialization_mutex);
if (!nicer_initialized) {
nicer_initialized = true;
NR_reg_init(NR_REG_MODE_LOCAL);
nr_crypto_openssl_set();
// Set the priorites for candidate type preferences.
// These numbers come from RFC 5245 S. 4.1.2.2
NR_reg_set_uchar(const_cast<char *>(NR_ICE_REG_PREF_TYPE_SRV_RFLX), 100);
NR_reg_set_uchar(const_cast<char *>(NR_ICE_REG_PREF_TYPE_PEER_RFLX), 110);
NR_reg_set_uchar(const_cast<char *>(NR_ICE_REG_PREF_TYPE_HOST), 126);
NR_reg_set_uchar(const_cast<char *>(NR_ICE_REG_PREF_TYPE_RELAYED), 5);
NR_reg_set_uchar(const_cast<char *>(NR_ICE_REG_PREF_TYPE_RELAYED_TCP), 0);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.rl0"), 255);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.wi0"), 254);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.lo0"), 253);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.en1"), 252);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.en0"), 251);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.eth0"), 252);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.eth1"), 251);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.eth2"), 249);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.ppp"), 250);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.ppp0"), 249);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.en2"), 248);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.en3"), 247);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.em0"), 251);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.em1"), 252);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.vmnet0"), 240);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.vmnet1"), 241);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.vmnet3"), 239);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.vmnet4"), 238);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.vmnet5"), 237);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.vmnet6"), 236);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.vmnet7"), 235);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.vmnet8"), 234);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.virbr0"), 233);
NR_reg_set_uchar(const_cast<char *>("ice.pref.interface.wlan0"), 232);
NR_reg_set_uint4(const_cast<char *>("stun.client.maximum_transmits"), 7);
NR_reg_set_uint4(const_cast<char *>(NR_ICE_REG_TRICKLE_GRACE_PERIOD), 5000);
NR_reg_set_char(const_cast<char *>(NR_ICE_REG_ICE_TCP_DISABLE), true);
NR_reg_set_char(const_cast<char *>(NR_STUN_REG_PREF_ALLOW_LINK_LOCAL_ADDRS), 1);
}
}
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
main(int argc, char* argv[])
{
StunAddress4 myAddr;
int myPort = 0;
char verbose=0;
char background=0;
printf("STUN server version %s\n",NR_STUN_VERSION);
fflush(stdout);
nr_crypto_openssl_set();
nr_app_startup("server",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.server.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);
}
myAddr.addr = 0;
myAddr.port = NR_STUN_PORT;
if ( argc <= 2 )
{
usage();
exit(-1);
}
int arg;
for ( arg = 1; arg<argc; arg++ )
{
if ( !strcmp( argv[arg] , "-v" ) )
{
verbose = 1;
}
else if ( !strcmp( argv[arg] , "-b" ) )
{
background = 1;
}
else if ( !strcmp( argv[arg] , "-a" ) )
{
alternate_server = 1;
}
else if ( !strcmp( argv[arg] , "-h" ) )
{
arg++;
if ( argc <= arg )
{
usage();
exit(-1);
}
if (nr_stun_parse_server_name(argv[arg], &myAddr))
{
usage();
exit(-1);
}
}
else if ( !strcmp( argv[arg] , "-p" ) )
{
arg++;
if ( argc <= arg )
{
usage();
exit(-1);
}
myPort = (UINT2)(strtol( argv[arg], NULL, 10));
}
else
{
usage();
exit(-1);
}
}
if ( myPort != 0 )
{
myAddr.port = myPort;
}
if (
( myAddr.addr == 0 ) ||
( myAddr.port == 0 )
)
{
fprintf(stderr,"Bad command line\n");
fflush(stderr);
exit(1);
}
#if defined(WIN32)
int pid=0;
if ( background )
{
fprintf(stderr,"The -b background option does not work in windows\n");
fflush(stderr);
exit(-1);
}
#else
pid_t pid=0;
if ( background )
{
pid = fork();
if (pid < 0)
{
fprintf(stderr,"fork: unable to fork\n");
fflush(stderr);
exit(-1);
}
}
#endif
if (pid == 0) //child or not using background
{
StunServerInfo info;
char ok = 1;
if (nr_stun_init_server(&info, &myAddr))
ok = 0;
int c=0;
while (ok)
{
if (nr_stun_server_process(&info)) {
fprintf(stderr,"Failed\n");
exit(1);
}
c++;
if ( c%10000 == 0 )
{
printf("*");
fflush(stdout);
}
}
}
return 0;
}
