static void set_log_file_name_func(char *base, char *f, size_t fsz)
{
if(simple_log) {
strncpy(f,base,fsz);
return;
}
char logdate[125];
char *tail=turn_strdup(".log");
get_date(logdate,sizeof(logdate));
char *base1=turn_strdup(base);
int len=(int)strlen(base1);
--len;
while(len>=0) {
if((base1[len]==' ')||(base1[len]=='\t')) {
base1[len]='_';
}
--len;
}
len=(int)strlen(base1);
while(len>=0) {
if(base1[len]=='/')
break;
else if(base1[len]=='.') {
turn_free(tail,strlen(tail)+1);
tail=turn_strdup(base1+len);
base1[len]=0;
if(strlen(tail)<2) {
turn_free(tail,strlen(tail)+1);
tail = turn_strdup(".log");
}
break;
}
--len;
}
len=(int)strlen(base1);
if(len>0 && (base1[len-1]!='/') && (base1[len-1]!='-') && (base1[len-1]!='_')) {
snprintf(f, FILE_STR_LEN, "%s_%s%s", base1,logdate,tail);
} else {
snprintf(f, FILE_STR_LEN, "%s%s%s", base1,logdate,tail);
}
turn_free(base1,strlen(base1)+1);
turn_free(tail,strlen(tail)+1);
}
static PGconn *get_pqdb_connection(void) {
persistent_users_db_t *pud = get_persistent_users_db();
PGconn *pqdbconnection = (PGconn*)pthread_getspecific(connection_key);
if(pqdbconnection) {
ConnStatusType status = PQstatus(pqdbconnection);
if(status != CONNECTION_OK) {
PQfinish(pqdbconnection);
pqdbconnection = NULL;
(void) pthread_setspecific(connection_key, pqdbconnection);
}
}
if(!pqdbconnection) {
char *errmsg=NULL;
PQconninfoOption *co = PQconninfoParse(pud->userdb, &errmsg);
if(!co) {
if(errmsg) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Cannot open PostgreSQL DB connection <%s>, connection string format error: %s\n",pud->userdb,errmsg);
turn_free(errmsg,strlen(errmsg)+1);
} else {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Cannot open PostgreSQL DB connection: <%s>, unknown connection string format error\n",pud->userdb);
}
} else {
PQconninfoFree(co);
if(errmsg)
turn_free(errmsg,strlen(errmsg)+1);
pqdbconnection = PQconnectdb(pud->userdb);
if(!pqdbconnection) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Cannot open PostgreSQL DB connection: <%s>, runtime error\n",pud->userdb);
} else {
ConnStatusType status = PQstatus(pqdbconnection);
if(status != CONNECTION_OK) {
PQfinish(pqdbconnection);
pqdbconnection = NULL;
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Cannot open PostgreSQL DB connection: <%s>, runtime error\n",pud->userdb);
} else if(!donot_print_connection_success){
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "PostgreSQL DB connection success: %s\n",pud->userdb);
donot_print_connection_success = 1;
}
}
}
if(pqdbconnection) {
(void) pthread_setspecific(connection_key, pqdbconnection);
}
}
return pqdbconnection;
}
void delete_tcp_connection(tcp_connection *tc)
{
if(tc) {
if(tc->done) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "!!! %s: check on already closed tcp data connection: 0x%lx\n",__FUNCTION__);
return;
}
tc->done = 1;
IOA_EVENT_DEL(tc->peer_conn_timeout);
IOA_EVENT_DEL(tc->conn_bind_timeout);
allocation *a = (allocation*)(tc->owner);
if(a) {
ur_map *map = a->tcp_connections;
if(map) {
ur_map_del(map, (ur_map_key_type)(tc->id),NULL);
}
tcp_connection_list *tcl = &(a->tcl);
while(tcl->next) {
if((void*)(tcl->next) == (void*)tc) {
tcl->next = tc->list.next;
break;
} else {
tcl=tcl->next;
}
}
}
set_ioa_socket_sub_session(tc->client_s,NULL);
IOA_CLOSE_SOCKET(tc->client_s);
set_ioa_socket_sub_session(tc->peer_s,NULL);
IOA_CLOSE_SOCKET(tc->peer_s);
turn_free(tc,sizeof(tcp_connection));
}
}
static void MongoFree(MONGO * info) {
if(info) {
if(info->uri) mongoc_uri_destroy(info->uri);
if(info->client) mongoc_client_destroy(info->client);
turn_free(info, sizeof(MONGO));
}
}
int turn_mutex_init_recursive(turn_mutex* mutex) {
int ret = -1;
if (mutex) {
pthread_mutexattr_t attr;
if (pthread_mutexattr_init(&attr) < 0) {
perror("Cannot init mutex attr");
} else {
if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) < 0) {
perror("Cannot set type on mutex attr");
} else {
mutex->mutex = turn_malloc(sizeof(pthread_mutex_t));
mutex->data = MAGIC_CODE;
if ((ret = pthread_mutex_init((pthread_mutex_t*) mutex->mutex,
&attr)) < 0) {
perror("Cannot init mutex");
mutex->data = 0;
turn_free(mutex->mutex,sizeof(pthread_mutex_t));
mutex->mutex = NULL;
}
}
pthread_mutexattr_destroy(&attr);
}
}
return ret;
}
void recalculate_restapi_hmac(void) {
if (g_use_auth_secret_with_timestamp) {
u08bits hmac[MAXSHASIZE];
unsigned int hmac_len;
hmac_len = SHA256SIZEBYTES;
hmac[0] = 0;
if (stun_calculate_hmac(g_uname, strlen((char*) g_uname),
(u08bits*) g_auth_secret, strlen(g_auth_secret), hmac,
&hmac_len, SHATYPE_SHA256) >= 0) {
size_t pwd_length = 0;
char *pwd = base64_encode(hmac, hmac_len, &pwd_length);
if (pwd) {
if (pwd_length > 0) {
ns_bcopy(pwd,g_upwd,pwd_length);
g_upwd[pwd_length] = 0;
}
}
turn_free(pwd,strlen(pwd)+1);
}
}
}
void clean_secrets_list(secrets_list_t *sl)
{
if(sl) {
if(sl->secrets) {
size_t i = 0;
for(i = 0;i<sl->sz;++i) {
if(sl->secrets[i]) {
turn_free(sl->secrets[i], strlen(sl->secrets[i])+1);
}
}
turn_free(sl->secrets,(sl->sz)*sizeof(char*));
sl->secrets = NULL;
sl->sz = 0;
}
}
}
void turnports_destroy(turnports** tp) {
if(tp && *tp) {
TURN_MUTEX_DESTROY(&((*tp)->mutex));
turn_free(*tp,sizeof(turnports));
*tp=NULL;
}
}
static int clean_server(server_type* server) {
if(server) {
if(server->event_base) event_base_free(server->event_base);
turn_free(server,sizeof(server_type));
}
return 0;
}
void free_turn_permission_map(turn_permission_map *map) {
int i=0;
for(i=0;i<TURN_PERMISSION_MAP_SIZE;i++) {
if((*map)[i]) {
free_cilist((*map)[i]);
(*map)[i]=NULL;
}
}
turn_free(*map,sizeof(turn_permission_info*)*TURN_PERMISSION_MAP_SIZE);
*map=NULL;
}
int turn_mutex_destroy(turn_mutex* mutex) {
if(mutex && mutex->mutex && mutex->data == MAGIC_CODE) {
int ret = 0;
ret = pthread_mutex_destroy((pthread_mutex_t*)(mutex->mutex));
turn_free(mutex->mutex, sizeof(pthread_mutex_t));
mutex->mutex=NULL;
mutex->data=0;
return ret;
} else {
return 0;
}
}
void turnipports_destroy(turnipports** tp)
{
if (tp && *tp) {
ur_addr_map_foreach((*tp)->ip_to_turnports_udp, turnipports_del_func);
ur_addr_map_free(&((*tp)->ip_to_turnports_udp));
ur_addr_map_foreach((*tp)->ip_to_turnports_tcp, turnipports_del_func);
ur_addr_map_free(&((*tp)->ip_to_turnports_tcp));
TURN_MUTEX_DESTROY(&((*tp)->mutex));
turn_free(*tp,sizeof(turnipports));
*tp = NULL;
}
}
static int delete_channel_info_from_allocation_map(ur_map_key_type key, ur_map_value_type value)
{
UNUSED_ARG(key);
if(value) {
ch_info* chn = (ch_info*)value;
turn_permission_info* tinfo = (turn_permission_info*)chn->owner;
if(tinfo) {
allocation* a = (allocation*)tinfo->owner;
if(a) {
ur_map_del(a->channel_to_ch_info, chn->chnum, ch_info_clean);
}
}
turn_free(chn,sizeof(ch_info));
}
return 0;
}
int get_realm_options_by_origin(char *origin, realm_options_t* ro)
{
ur_string_map_value_type value = 0;
TURN_MUTEX_LOCK(&o_to_realm_mutex);
if (ur_string_map_get(o_to_realm, (ur_string_map_key_type) origin, &value) && value) {
char *realm = turn_strdup((char*)value);
TURN_MUTEX_UNLOCK(&o_to_realm_mutex);
realm_params_t rp;
get_realm_data(realm, &rp);
ns_bcopy(&(rp.options),ro,sizeof(realm_options_t));
turn_free(realm,strlen(realm)+1);
return 1;
} else {
TURN_MUTEX_UNLOCK(&o_to_realm_mutex);
get_default_realm_options(ro);
return 0;
}
}
tls_listener_relay_server_type* create_tls_listener_server(const char* ifname,
const char *local_address, int port, int verbose,
ioa_engine_handle e,
ioa_engine_new_connection_event_handler send_socket,
struct relay_server *relay_server)
{
tls_listener_relay_server_type* server =
(tls_listener_relay_server_type*) turn_malloc(sizeof(tls_listener_relay_server_type));
ns_bzero(server, sizeof(tls_listener_relay_server_type));
if (init_server(server, ifname, local_address, port, verbose, e,
send_socket, relay_server) < 0) {
turn_free(server, sizeof(tls_listener_relay_server_type));
return NULL ;
} else {
return server;
}
}
int is_secure_username(const u08bits *username)
{
int ret = 0;
if(username) {
unsigned char *s0 = (unsigned char*)turn_strdup((const char*)username);
unsigned char *s = s0;
while(*s) {
*s = (unsigned char)tolower((int)*s);
++s;
}
s = s0;
if(strstr((char*)s," ")||strstr((char*)s,"\t")||strstr((char*)s,"'")||strstr((char*)s,"\"")||strstr((char*)s,"\n")||strstr((char*)s,"\r")||strstr((char*)s,"\\")) {
;
} else if(strstr((char*)s,"union")&&strstr((char*)s,"select")) {
;
} else {
ret = 1;
}
turn_free(s,strlen((char*)s));
}
return ret;
}
static int mongo_set_realm_option_one(u08bits *realm, unsigned long value, const char* opt) {
mongoc_collection_t * collection = mongo_get_collection("realm");
if(!collection)
return -1;
bson_t query, doc, child;
bson_init(&query);
BSON_APPEND_UTF8(&query, "realm", (const char *)realm);
bson_init(&doc);
size_t klen = 9 + strlen(opt);
char * _k = (char *)turn_malloc(klen);
strcpy(_k, "options.");
strcat(_k, opt);
if (value > 0) {
bson_append_document_begin(&doc, "$set", -1, &child);
BSON_APPEND_INT32(&child, _k, (int32_t)value);
bson_append_document_end(&doc, &child);
} else {
bson_append_document_begin(&doc, "$unset", -1, &child);
BSON_APPEND_INT32(&child, _k, 1);
bson_append_document_end(&doc, &child);
}
turn_free(_k,klen);
int ret = -1;
if (!mongoc_collection_update(collection, MONGOC_UPDATE_MULTI_UPDATE, &query, &doc, NULL, NULL)) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error deleting origin information\n");
} else {
ret = 0;
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&doc);
return ret;
}
dtls_listener_relay_server_type* create_dtls_listener_server(const char* ifname,
const char *local_address,
int port,
int verbose,
ioa_engine_handle e,
turn_turnserver *ts) {
dtls_listener_relay_server_type* server=(dtls_listener_relay_server_type*)
turn_malloc(sizeof(dtls_listener_relay_server_type));
ns_bzero(server,sizeof(dtls_listener_relay_server_type));
if(init_server(server,
ifname, local_address, port,
verbose,
e,
ts)<0) {
turn_free(server,sizeof(dtls_listener_relay_server_type));
return NULL;
} else {
return server;
}
}
static void redisLibeventCleanup(void *privdata)
{
if (privdata) {
struct redisLibeventEvents *e = (struct redisLibeventEvents *) privdata;
if (e->allocated) {
e->allocated = 0;
if (e->rev) {
if(e->rev_set)
event_del(e->rev);
event_free(e->rev);
e->rev = NULL;
}
if (e->wev) {
if(e->wev_set)
event_del(e->wev);
event_free(e->wev);
e->wev = NULL;
}
turn_free(privdata, sizeof(struct redisLibeventEvents));
}
}
}
static void mongo_reread_realms(secrets_list_t * realms_list) {
UNUSED_ARG(realms_list);
mongoc_collection_t * collection = mongo_get_collection("realm");
if (!collection)
return;
bson_t query;
bson_init(&query);
bson_t fields;
bson_init(&fields);
BSON_APPEND_INT32(&fields, "realm", 1);
BSON_APPEND_INT32(&fields, "origin", 1);
BSON_APPEND_INT32(&fields, "options", 1);
mongoc_cursor_t * cursor;
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0,
&query, &fields, NULL);
if (!cursor) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,
"Error querying MongoDB collection 'realm'\n");
} else {
ur_string_map *o_to_realm_new = ur_string_map_create(turn_free_simple);
const bson_t * item;
uint32_t length;
bson_iter_t iter;
while (mongoc_cursor_next(cursor, &item)) {
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "realm")
&& BSON_ITER_HOLDS_UTF8(&iter)) {
char * _realm = turn_strdup(bson_iter_utf8(&iter, &length));
get_realm(_realm);
if (bson_iter_init(&iter, item) && bson_iter_find(&iter,
"origin") && BSON_ITER_HOLDS_ARRAY(&iter)) {
const uint8_t *docbuf = NULL;
uint32_t doclen = 0;
bson_t origin_array;
bson_iter_t origin_iter;
bson_iter_array(&iter, &doclen, &docbuf);
bson_init_static(&origin_array, docbuf, doclen);
if (bson_iter_init(&origin_iter, &origin_array)) {
while (bson_iter_next(&origin_iter)) {
if (BSON_ITER_HOLDS_UTF8(&origin_iter)) {
char* _origin = turn_strdup(bson_iter_utf8(&origin_iter, &length));
char *rval = turn_strdup(_realm);
ur_string_map_value_type value =
(ur_string_map_value_type) (rval);
ur_string_map_put(o_to_realm_new,
(const ur_string_map_key_type) _origin,
value);
turn_free(_origin,strlen(_origin)+1);
}
}
}
}
realm_params_t* rp = get_realm(_realm);
lock_realms();
rp->options.perf_options.max_bps = turn_params.max_bps;
rp->options.perf_options.total_quota = turn_params.total_quota;
rp->options.perf_options.user_quota = turn_params.user_quota;
unlock_realms();
if (bson_iter_init(&iter, item) && bson_iter_find(&iter,
"options") && BSON_ITER_HOLDS_DOCUMENT(&iter)) {
const uint8_t *docbuf = NULL;
uint32_t doclen = 0;
bson_t options;
bson_iter_t options_iter;
bson_iter_document(&iter, &doclen, &docbuf);
bson_init_static(&options, docbuf, doclen);
if (bson_iter_init(&options_iter, &options)) {
while (bson_iter_next(&options_iter)) {
const char * _k = bson_iter_key(&options_iter);
uint64_t _v = 0;
if (BSON_ITER_HOLDS_DOUBLE(&options_iter)) {
_v = (uint64_t) bson_iter_double(&options_iter);
} else if (BSON_ITER_HOLDS_INT32(&options_iter)) {
_v = (uint64_t)bson_iter_int32(&options_iter);
} else if (BSON_ITER_HOLDS_INT64(&options_iter)) {
_v = (uint64_t) bson_iter_int64(&options_iter);
}
if (_v) {
if (!strcmp(_k, "max-bps"))
rp->options.perf_options.max_bps = (band_limit_t) _v;
else if (!strcmp(_k, "total-quota"))
rp->options.perf_options.total_quota = (vint) _v;
else if (!strcmp(_k, "user-quota"))
rp->options.perf_options.user_quota = (vint) _v;
else {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,
"Unknown realm option: %s\n", _k);
}
}
}
}
}
turn_free(_realm,strlen(_realm)+1);
}
}
update_o_to_realm(o_to_realm_new);
mongoc_cursor_destroy(cursor);
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&fields);
}
redis_context_handle redisLibeventAttach(struct event_base *base, char *ip0, int port0, char *pwd, int db)
{
struct redisLibeventEvents *e = NULL;
redisAsyncContext *ac = NULL;
char ip[256];
if(ip0 && ip0[0])
STRCPY(ip,ip0);
else
STRCPY(ip,"127.0.0.1");
int port = DEFAULT_REDIS_PORT;
if(port0>0)
port=port0;
ac = redisAsyncConnect(ip, port);
if (ac->err) {
fprintf(stderr,"Error: %s\n", ac->errstr);
return NULL;
}
/* Create container for context and r/w events */
e = (struct redisLibeventEvents*)turn_malloc(sizeof(struct redisLibeventEvents));
ns_bzero(e,sizeof(struct redisLibeventEvents));
e->allocated = 1;
e->context = ac;
e->base = base;
/* Register functions to start/stop listening for events */
ac->ev.addRead = redisLibeventAddRead;
ac->ev.delRead = redisLibeventDelRead;
ac->ev.addWrite = redisLibeventAddWrite;
ac->ev.delWrite = redisLibeventDelWrite;
ac->ev.cleanup = redisLibeventCleanup;
ac->ev.data = e;
/* Initialize and install read/write events */
e->rev = event_new(e->base,e->context->c.fd,
EV_READ|EV_PERSIST,redisLibeventReadEvent,
e);
e->wev = event_new(e->base,e->context->c.fd,
EV_WRITE,redisLibeventWriteEvent,
e);
if (e->rev == NULL || e->wev == NULL) {
turn_free(e, sizeof(struct redisLibeventEvents));
return NULL;
}
event_add(e->wev, NULL);
e->wev_set = 1;
struct bufferevent *pair[2];
bufferevent_pair_new(base, TURN_BUFFEREVENTS_OPTIONS, pair);
e->in_buf = pair[0];
e->out_buf = pair[1];
bufferevent_setcb(e->in_buf, receive_message_for_redis, NULL, NULL, e);
bufferevent_enable(e->in_buf, EV_READ);
//Authentication
if(pwd)
redisAsyncCommand(ac, NULL, e, "AUTH %s", pwd);
if(db>0)
redisAsyncCommand(ac, NULL, e, "SELECT %d", db);
return ac;
}
static void free_cilist_elem(turn_permission_info *cdi) {
if(cdi) {
turn_permission_clean(cdi);
turn_free(cdi,sizeof(turn_permission_info));
}
}
