bool StunClient::refresh()
{
stun_buffer buf;
stun_init_request(STUN_METHOD_REFRESH, &buf);
uint32_t lt = htonl(567);
stun_attr_add(&buf, STUN_ATTRIBUTE_LIFETIME, (const char*)<, 4);
stun_attr_add(&buf, STUN_ATTRIBUTE_USERNAME, STUN_USERNAME, strlen(STUN_USERNAME));
stun_attr_add(&buf, STUN_ATTRIBUTE_REALM, m_realm.data(), m_realm.length());
stun_attr_add(&buf, STUN_ATTRIBUTE_NONCE, m_nonce.data(), m_nonce.length());
stun_attr_add_integrity_by_user_str(buf.buf, &buf.len, (u08bits*)STUN_USERNAME,
(u08bits*)m_realm.data(), (u08bits*)STUN_PASSWORD,
(u08bits*)m_nonce.data(), SHATYPE_SHA1);
stun_attr_add_fingerprint_str((unsigned char*)&buf.buf, &buf.len);
qint64 ret = m_stun_sock->writeDatagram(QByteArray((char*)buf.buf, buf.len), QHostAddress(STUN_SERVER_ADDR), STUN_SERVER_PORT);
qDebug()<<"write relayed data:"<<ret<<buf.len<<m_peer_addr<<m_relayed_addr;
return true;
}
int turn_tcp_connect(int verbose, app_ur_conn_info *clnet_info, ioa_addr *peer_addr) {
{
int cp_sent = 0;
stun_buffer message;
stun_init_request(STUN_METHOD_CONNECT, &message);
stun_attr_add_addr(&message, STUN_ATTRIBUTE_XOR_PEER_ADDRESS, peer_addr);
add_origin(&message);
if(add_integrity(clnet_info, &message)<0) return -1;
stun_attr_add_fingerprint_str(message.buf,(size_t*)&(message.len));
while (!cp_sent) {
int len = send_buffer(clnet_info, &message, 0,0);
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "tcp connect sent\n");
}
cp_sent = 1;
} else {
perror("send");
exit(1);
}
}
}
////////////<<==connect send
return 0;
}
static int turn_create_permission(int verbose, app_ur_conn_info *clnet_info,
ioa_addr *peer_addr, int addrnum)
{
if(no_permissions || (addrnum<1))
return 0;
char saddr[129]="\0";
if (verbose) {
addr_to_string(peer_addr,(u08bits*)saddr);
}
stun_buffer request_message, response_message;
beg_cp:
{
int cp_sent = 0;
stun_init_request(STUN_METHOD_CREATE_PERMISSION, &request_message);
{
int addrindex;
for(addrindex=0;addrindex<addrnum;++addrindex) {
stun_attr_add_addr(&request_message, STUN_ATTRIBUTE_XOR_PEER_ADDRESS, peer_addr+addrindex);
}
}
add_origin(&request_message);
if(add_integrity(clnet_info, &request_message)<0) return -1;
stun_attr_add_fingerprint_str(request_message.buf,(size_t*)&(request_message.len));
while (!cp_sent) {
int len = send_buffer(clnet_info, &request_message, 0,0);
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "create perm sent: %s\n",saddr);
}
cp_sent = 1;
} else {
perror("send");
exit(1);
}
}
}
////////////<<==create permission send
if(not_rare_event()) return 0;
////////create permission response==>>
{
int cp_received = 0;
while (!cp_received) {
int len = recv_buffer(clnet_info, &response_message, 1, 0, NULL, &request_message);
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"cp response received: \n");
}
int err_code = 0;
u08bits err_msg[129];
if (stun_is_success_response(&response_message)) {
cp_received = 1;
if(clnet_info->nonce[0]) {
if(check_integrity(clnet_info, &response_message)<0)
return -1;
}
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "success\n");
}
} else if (stun_is_challenge_response_str(response_message.buf, (size_t)response_message.len,
&err_code,err_msg,sizeof(err_msg),
clnet_info->realm,clnet_info->nonce,
clnet_info->server_name, &(clnet_info->oauth))) {
goto beg_cp;
} else if (stun_is_error_response(&response_message, &err_code,err_msg,sizeof(err_msg))) {
cp_received = 1;
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "create permission error %d (%s)\n",
err_code,(char*)err_msg);
return -1;
} else {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "unknown create permission response\n");
/* Try again ? */
}
} else {
perror("recv");
exit(-1);
}
}
}
return 0;
}
static int turn_channel_bind(int verbose, uint16_t *chn,
app_ur_conn_info *clnet_info, ioa_addr *peer_addr) {
stun_buffer request_message, response_message;
beg_bind:
{
int cb_sent = 0;
if(negative_test) {
*chn = stun_set_channel_bind_request(&request_message, peer_addr, (u16bits)random());
} else {
*chn = stun_set_channel_bind_request(&request_message, peer_addr, *chn);
}
add_origin(&request_message);
if(add_integrity(clnet_info, &request_message)<0) return -1;
stun_attr_add_fingerprint_str(request_message.buf,(size_t*)&(request_message.len));
while (!cb_sent) {
int len = send_buffer(clnet_info, &request_message, 0,0);
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "channel bind sent\n");
}
cb_sent = 1;
} else {
perror("send");
exit(1);
}
}
}
////////////<<==channel bind send
if(not_rare_event()) return 0;
////////channel bind response==>>
{
int cb_received = 0;
while (!cb_received) {
int len = recv_buffer(clnet_info, &response_message, 1, 0, NULL, &request_message);
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"cb response received: \n");
}
int err_code = 0;
u08bits err_msg[129];
if (stun_is_success_response(&response_message)) {
cb_received = 1;
if(clnet_info->nonce[0]) {
if(check_integrity(clnet_info, &response_message)<0)
return -1;
}
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "success: 0x%x\n",
(int) (*chn));
}
} else if (stun_is_challenge_response_str(response_message.buf, (size_t)response_message.len,
&err_code,err_msg,sizeof(err_msg),
clnet_info->realm,clnet_info->nonce,
clnet_info->server_name, &(clnet_info->oauth))) {
goto beg_bind;
} else if (stun_is_error_response(&response_message, &err_code,err_msg,sizeof(err_msg))) {
cb_received = 1;
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "channel bind: error %d (%s)\n",
err_code,(char*)err_msg);
return -1;
} else {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "unknown channel bind response\n");
/* Try again ? */
}
} else {
perror("recv");
exit(-1);
break;
}
}
}
return 0;
}
static int clnet_allocate(int verbose,
app_ur_conn_info *clnet_info,
ioa_addr *relay_addr,
int af,
char *turn_addr, u16bits *turn_port) {
int af_cycle = 0;
int reopen_socket = 0;
int allocate_finished;
stun_buffer request_message, response_message;
beg_allocate:
allocate_finished=0;
while (!allocate_finished && af_cycle++ < 32) {
int allocate_sent = 0;
if(reopen_socket && !use_tcp) {
socket_closesocket(clnet_info->fd);
clnet_info->fd = -1;
if (clnet_connect(addr_get_port(&(clnet_info->remote_addr)), clnet_info->rsaddr, (u08bits*)clnet_info->ifname, clnet_info->lsaddr,
verbose, clnet_info) < 0) {
exit(-1);
}
reopen_socket = 0;
}
int af4 = dual_allocation || (af == STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY_VALUE_IPV4);
int af6 = dual_allocation || (af == STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY_VALUE_IPV6);
uint64_t reservation_token = 0;
char* rt = NULL;
int ep = !no_rtcp && !dual_allocation;
if(!no_rtcp) {
if (!never_allocate_rtcp && allocate_rtcp) {
reservation_token = ioa_ntoh64(current_reservation_token);
rt = (char*) (&reservation_token);
}
}
if(is_TCP_relay()) {
ep = -1;
} else if(rt) {
ep = -1;
} else if(!ep) {
ep = (((u08bits)random()) % 2);
ep = ep-1;
}
if(!dos)
stun_set_allocate_request(&request_message, UCLIENT_SESSION_LIFETIME, af4, af6, relay_transport, mobility, rt, ep);
else
stun_set_allocate_request(&request_message, UCLIENT_SESSION_LIFETIME/3, af4, af6, relay_transport, mobility, rt, ep);
if(bps)
stun_attr_add_bandwidth_str(request_message.buf, (size_t*)(&(request_message.len)), bps);
if(dont_fragment)
stun_attr_add(&request_message, STUN_ATTRIBUTE_DONT_FRAGMENT, NULL, 0);
add_origin(&request_message);
if(add_integrity(clnet_info, &request_message)<0) return -1;
stun_attr_add_fingerprint_str(request_message.buf,(size_t*)&(request_message.len));
while (!allocate_sent) {
int len = send_buffer(clnet_info, &request_message,0,0);
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "allocate sent\n");
}
allocate_sent = 1;
} else {
perror("send");
exit(1);
}
}
////////////<<==allocate send
if(not_rare_event()) return 0;
////////allocate response==>>
{
int allocate_received = 0;
while (!allocate_received) {
int len = recv_buffer(clnet_info, &response_message, 1, 0, NULL, &request_message);
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"allocate response received: \n");
}
response_message.len = len;
int err_code = 0;
u08bits err_msg[129];
if (stun_is_success_response(&response_message)) {
allocate_received = 1;
allocate_finished = 1;
if(clnet_info->nonce[0]) {
if(check_integrity(clnet_info, &response_message)<0)
return -1;
}
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "success\n");
}
{
int found = 0;
stun_attr_ref sar = stun_attr_get_first(&response_message);
while (sar) {
int attr_type = stun_attr_get_type(sar);
if(attr_type == STUN_ATTRIBUTE_XOR_RELAYED_ADDRESS) {
if (stun_attr_get_addr(&response_message, sar, relay_addr, NULL) < 0) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"%s: !!!: relay addr cannot be received (1)\n",
__FUNCTION__);
return -1;
} else {
if (verbose) {
ioa_addr raddr;
memcpy(&raddr, relay_addr,sizeof(ioa_addr));
addr_debug_print(verbose, &raddr,"Received relay addr");
}
if(!addr_any(relay_addr)) {
if(relay_addr->ss.sa_family == AF_INET) {
if(default_address_family != STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY_VALUE_IPV6) {
found = 1;
addr_cpy(&(clnet_info->relay_addr),relay_addr);
break;
}
}
if(relay_addr->ss.sa_family == AF_INET6) {
if(default_address_family == STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY_VALUE_IPV6) {
found = 1;
addr_cpy(&(clnet_info->relay_addr),relay_addr);
break;
}
}
}
}
}
sar = stun_attr_get_next(&response_message,sar);
}
if(!found) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"%s: !!!: relay addr cannot be received (2)\n",
__FUNCTION__);
return -1;
}
}
stun_attr_ref rt_sar = stun_attr_get_first_by_type(
&response_message, STUN_ATTRIBUTE_RESERVATION_TOKEN);
uint64_t rtv = stun_attr_get_reservation_token_value(rt_sar);
current_reservation_token = rtv;
if (verbose)
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"%s: rtv=%llu\n", __FUNCTION__, (long long unsigned int)rtv);
read_mobility_ticket(clnet_info, &response_message);
} else if (stun_is_challenge_response_str(response_message.buf, (size_t)response_message.len,
&err_code,err_msg,sizeof(err_msg),
clnet_info->realm,clnet_info->nonce,
clnet_info->server_name, &(clnet_info->oauth))) {
goto beg_allocate;
} else if (stun_is_error_response(&response_message, &err_code,err_msg,sizeof(err_msg))) {
allocate_received = 1;
if(err_code == 300) {
if(clnet_info->nonce[0]) {
if(check_integrity(clnet_info, &response_message)<0)
return -1;
}
ioa_addr alternate_server;
if(stun_attr_get_first_addr(&response_message, STUN_ATTRIBUTE_ALTERNATE_SERVER, &alternate_server, NULL)==-1) {
//error
} else if(turn_addr && turn_port){
addr_to_string_no_port(&alternate_server, (u08bits*)turn_addr);
*turn_port = (u16bits)addr_get_port(&alternate_server);
}
}
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "error %d (%s)\n",
err_code,(char*)err_msg);
if (err_code != 437) {
allocate_finished = 1;
current_reservation_token = 0;
return -1;
} else {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"trying allocate again %d...\n", err_code);
sleep(1);
reopen_socket = 1;
}
} else {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"unknown allocate response\n");
/* Try again ? */
}
} else {
perror("recv");
exit(-1);
break;
}
}
}
}
////////////<<== allocate response received
if(rare_event()) return 0;
if(!allocate_finished) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,
"Cannot complete Allocation\n");
exit(-1);
}
allocate_rtcp = !allocate_rtcp;
if (1) {
af_cycle = 0;
if(clnet_info->s_mobile_id[0]) {
int fd = clnet_info->fd;
SSL* ssl = clnet_info->ssl;
int close_now = (int)(random()%2);
if(close_now) {
int close_socket = (int)(random()%2);
if(ssl && !close_socket) {
SSL_shutdown(ssl);
SSL_FREE(ssl);
fd = -1;
} else if(fd>=0) {
close(fd);
fd = -1;
ssl = NULL;
}
}
app_ur_conn_info ci;
ns_bcopy(clnet_info,&ci,sizeof(ci));
ci.fd = -1;
ci.ssl = NULL;
clnet_info->fd = -1;
clnet_info->ssl = NULL;
//Reopen:
if(clnet_connect(addr_get_port(&(ci.remote_addr)), ci.rsaddr,
(unsigned char*)ci.ifname, ci.lsaddr, clnet_verbose,
clnet_info)<0) {
exit(-1);
}
if(ssl) {
SSL_shutdown(ssl);
SSL_FREE(ssl);
} else if(fd>=0) {
close(fd);
}
}
beg_refresh:
if(af_cycle++>32) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,
"Cannot complete Refresh\n");
exit(-1);
}
//==>>refresh request, for an example only:
{
int refresh_sent = 0;
stun_init_request(STUN_METHOD_REFRESH, &request_message);
uint32_t lt = htonl(UCLIENT_SESSION_LIFETIME);
stun_attr_add(&request_message, STUN_ATTRIBUTE_LIFETIME, (const char*) <, 4);
if(clnet_info->s_mobile_id[0]) {
stun_attr_add(&request_message, STUN_ATTRIBUTE_MOBILITY_TICKET, (const char*)clnet_info->s_mobile_id, strlen(clnet_info->s_mobile_id));
}
if(dual_allocation && !mobility) {
int t = ((u08bits)random())%3;
if(t) {
u08bits field[4];
field[0] = (t==1) ? (u08bits)STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY_VALUE_IPV4 : (u08bits)STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY_VALUE_IPV6;
field[1]=0;
field[2]=0;
field[3]=0;
stun_attr_add(&request_message, STUN_ATTRIBUTE_REQUESTED_ADDRESS_FAMILY, (const char*) field, 4);
}
}
add_origin(&request_message);
if(add_integrity(clnet_info, &request_message)<0) return -1;
stun_attr_add_fingerprint_str(request_message.buf,(size_t*)&(request_message.len));
while (!refresh_sent) {
int len = send_buffer(clnet_info, &request_message, 0,0);
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "refresh sent\n");
}
refresh_sent = 1;
if(clnet_info->s_mobile_id[0]) {
usleep(10000);
send_buffer(clnet_info, &request_message, 0,0);
}
} else {
perror("send");
exit(1);
}
}
}
if(not_rare_event()) return 0;
////////refresh response==>>
{
int refresh_received = 0;
while (!refresh_received) {
int len = recv_buffer(clnet_info, &response_message, 1, 0, NULL, &request_message);
if(clnet_info->s_mobile_id[0]) {
len = recv_buffer(clnet_info, &response_message, 1, 0, NULL, &request_message);
}
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"refresh response received: \n");
}
response_message.len = len;
int err_code = 0;
u08bits err_msg[129];
if (stun_is_success_response(&response_message)) {
read_mobility_ticket(clnet_info, &response_message);
refresh_received = 1;
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "success\n");
}
} else if (stun_is_challenge_response_str(response_message.buf, (size_t)response_message.len,
&err_code,err_msg,sizeof(err_msg),
clnet_info->realm,clnet_info->nonce,
clnet_info->server_name, &(clnet_info->oauth))) {
goto beg_refresh;
} else if (stun_is_error_response(&response_message, &err_code,err_msg,sizeof(err_msg))) {
refresh_received = 1;
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "error %d (%s)\n",
err_code,(char*)err_msg);
return -1;
} else {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "unknown refresh response\n");
/* Try again ? */
}
} else {
perror("recv");
exit(-1);
break;
}
}
}
}
return 0;
}
static int turn_tcp_connection_bind(int verbose, app_ur_conn_info *clnet_info, app_tcp_conn_info *atc, int errorOK) {
stun_buffer request_message, response_message;
beg_cb:
{
int cb_sent = 0;
u32bits cid = atc->cid;
stun_init_request(STUN_METHOD_CONNECTION_BIND, &request_message);
stun_attr_add(&request_message, STUN_ATTRIBUTE_CONNECTION_ID, (const s08bits*)&cid,4);
add_origin(&request_message);
if(add_integrity(clnet_info, &request_message)<0) return -1;
stun_attr_add_fingerprint_str(request_message.buf,(size_t*)&(request_message.len));
while (!cb_sent) {
int len = send_buffer(clnet_info, &request_message, 1, atc);
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "connection bind sent\n");
}
cb_sent = 1;
} else {
if(errorOK)
return 0;
perror("send");
exit(1);
}
}
}
////////////<<==connection bind send
if(not_rare_event()) return 0;
////////connection bind response==>>
{
int cb_received = 0;
while (!cb_received) {
int len = recv_buffer(clnet_info, &response_message, 1, 1, atc, &request_message);
if (len > 0) {
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"connect bind response received: \n");
}
int err_code = 0;
u08bits err_msg[129];
if (stun_is_success_response(&response_message)) {
if(clnet_info->nonce[0]) {
if(check_integrity(clnet_info, &response_message)<0)
return -1;
}
if(stun_get_method(&response_message)!=STUN_METHOD_CONNECTION_BIND)
continue;
cb_received = 1;
if (verbose) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "success\n");
}
atc->tcp_data_bound = 1;
} else if (stun_is_challenge_response_str(response_message.buf, (size_t)response_message.len,
&err_code,err_msg,sizeof(err_msg),
clnet_info->realm,clnet_info->nonce,
clnet_info->server_name, &(clnet_info->oauth))) {
goto beg_cb;
} else if (stun_is_error_response(&response_message, &err_code,err_msg,sizeof(err_msg))) {
cb_received = 1;
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "connection bind error %d (%s)\n",
err_code,(char*)err_msg);
return -1;
} else {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "unknown connection bind response\n");
/* Try again ? */
}
} else {
if(errorOK)
return 0;
perror("recv");
exit(-1);
}
}
}
return 0;
}