« back to all changes in this revision
Viewing changes to src/apps/relay/dbdrivers/dbd_sqlite.c
- browse files at revision 11
- compare with another revision
- download diff
- download tarball
- view history from revision 11
- Committer: Package Import Robot
- Author(s): Oleg Moskalenko
- Date: 2014-11-23 00:15:03 UTC
- mfrom: (1.1.7)
- Revision ID: package-import@ubuntu.com-20141123001503-oxzujsbx5ye4ea6i
Tags: 4.3.1.1-1
Sync to 4.3.1.1: SQLite support added.
- examples/var
- examples/var/db
- files removed:
- examples/etc/turnuserdb.conf
- files modified:
- ChangeLog
added
removed
src/apps/relay/dbdrivers/dbd_sqlite.c
1
/*
2
* Copyright (C) 2011, 2012, 2013 Citrix Systems
3
* Copyright (C) 2014 Vivocha S.p.A.
4
*
5
* All rights reserved.
6
*
7
* Redistribution and use in source and binary forms, with or without
8
* modification, are permitted provided that the following conditions
9
* are met:
10
* 1. Redistributions of source code must retain the above copyright
11
* notice, this list of conditions and the following disclaimer.
12
* 2. Redistributions in binary form must reproduce the above copyright
13
* notice, this list of conditions and the following disclaimer in the
14
* documentation and/or other materials provided with the distribution.
15
* 3. Neither the name of the project nor the names of its contributors
16
* may be used to endorse or promote products derived from this software
17
* without specific prior written permission.
18
*
19
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
20
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22
* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
23
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29
* SUCH DAMAGE.
30
*/
31
32
#include "../mainrelay.h"
33
#include "dbd_sqlite.h"
34
35
#if !defined(TURN_NO_SQLITE)
36
37
#include <sqlite3.h>
38
39
#include <unistd.h>
40
#include <sys/types.h>
41
#include <pwd.h>
42
43
///////////////////////////////////////////////////////////////////////////////////////////////////////////
44
45
static int sqlite_init_multithreaded(void) {
46
47
sqlite3_shutdown();
48
49
if (sqlite3_threadsafe() > 0) {
50
int retCode = sqlite3_config(SQLITE_CONFIG_SERIALIZED);
51
if (retCode != SQLITE_OK) {
52
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "setting sqlite thread safe mode to serialized failed!!! return code: %d\n", retCode);
53
return -1;
54
}
55
} else {
56
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Your SQLite database is not compiled to be threadsafe.\n");
57
return -1;
58
}
59
60
return 0;
61
}
62
63
static int donot_print_connection_success = 0;
64
65
static void fix_user_directory(char *dir0) {
66
char *dir = dir0;
67
while(*dir == ' ') ++dir;
68
if(*dir == '~') {
69
char *home=getenv("HOME");
70
if(!home) {
71
struct passwd *pwd = getpwuid(getuid());
72
if(!pwd) {
73
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Cannot figure out the user's HOME directory (1)\n");
74
} else {
75
home = pwd->pw_dir;
76
if(!home) {
77
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Cannot figure out the user's HOME directory\n");
78
return;
79
}
80
}
81
}
82
size_t szh = strlen(home);
83
size_t sz = strlen(dir0)+1+szh;
84
char* dir_fixed = (char*)turn_malloc(sz);
85
strncpy(dir_fixed,home,szh);
86
strncpy(dir_fixed+szh,dir+1,(sz-szh-1));
87
strncpy(dir0,dir_fixed,sz);
88
turn_free(dir_fixed,sz);
89
}
90
}
91
92
static void init_sqlite_database(sqlite3 *sqliteconnection) {
93
94
const char * statements[] = {
95
"CREATE TABLE turnusers_lt ( realm varchar(512) default '', name varchar(512), hmackey char(128), PRIMARY KEY (realm,name))",
96
"CREATE TABLE turnusers_st (name varchar(512) PRIMARY KEY, password varchar(512))",
97
"CREATE TABLE turn_secret (realm varchar(512) default '', value varchar(512), primary key (realm,value))",
98
"CREATE TABLE allowed_peer_ip (realm varchar(512) default '', ip_range varchar(256), primary key (realm,ip_range))",
99
"CREATE TABLE denied_peer_ip (realm varchar(512) default '', ip_range varchar(256), primary key (realm,ip_range))",
100
"CREATE TABLE turn_origin_to_realm (origin varchar(512),realm varchar(512),primary key (origin))",
101
"CREATE TABLE turn_realm_option (realm varchar(512) default '', opt varchar(32), value varchar(128), primary key (realm,opt))",
102
"CREATE TABLE oauth_key (kid varchar(128),ikm_key varchar(256) default '',timestamp bigint default 0,lifetime integer default 0,hkdf_hash_func varchar(64) default '',as_rs_alg varchar(64) default '',as_rs_key varchar(256) default '',auth_alg varchar(64) default '',auth_key varchar(256) default '',primary key (kid))",
103
NULL
104
};
105
106
int i = 0;
107
while(statements[i]) {
108
sqlite3_stmt *statement = NULL;
109
int rc = 0;
110
if ((rc = sqlite3_prepare(sqliteconnection, statements[i], -1, &statement, 0)) == SQLITE_OK) {
111
sqlite3_step(statement);
112
}
113
sqlite3_finalize(statement);
114
++i;
115
}
116
}
117
118
static sqlite3 * get_sqlite_connection(void) {
119
120
persistent_users_db_t *pud = get_persistent_users_db();
121
122
sqlite3 *sqliteconnection = (sqlite3 *)(pud->connection);
123
if(!sqliteconnection) {
124
fix_user_directory(pud->userdb);
125
sqlite_init_multithreaded();
126
int rc = sqlite3_open(pud->userdb, &sqliteconnection);
127
if(!sqliteconnection || (rc != SQLITE_OK)) {
128
const char* errmsg = sqlite3_errmsg(sqliteconnection);
129
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Cannot open SQLite DB connection: <%s>, runtime error:\n %s\n (If your intention is to use a database for the TURN server, then\n check the TURN server process / file / DB directory permissions and\n re-start the TURN server)\n",pud->userdb,errmsg);
130
if(sqliteconnection) {
131
sqlite3_close(sqliteconnection);
132
sqliteconnection=NULL;
133
}
134
turn_params.default_users_db.userdb_type = TURN_USERDB_TYPE_UNKNOWN;
135
} else if(!donot_print_connection_success){
136
init_sqlite_database(sqliteconnection);
137
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "SQLite DB connection success: %s\n",pud->userdb);
138
}
139
pud->connection = sqliteconnection;
140
}
141
return sqliteconnection;
142
}
143
144
///////////////////////////////////////////////////////////////////////////////////////////////////////////
145
146
static int sqlite_get_auth_secrets(secrets_list_t *sl, u08bits *realm)
147
{
148
int ret = -1;
149
sqlite3 *sqliteconnection = get_sqlite_connection();
150
if (sqliteconnection) {
151
char statement[TURN_LONG_STRING_SIZE];
152
sqlite3_stmt *st = NULL;
153
int rc = 0;
154
snprintf(statement, sizeof(statement) - 1, "select value from turn_secret where realm='%s'", realm);
155
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
156
157
int ctotal = sqlite3_column_count(st);
158
ret = 0;
159
160
while (ctotal > 0) {
161
162
int res = sqlite3_step(st);
163
if (res == SQLITE_ROW) {
164
165
int type = sqlite3_column_type(st, 0);
166
if (type != SQLITE_NULL)
167
add_to_secrets_list(sl, (const char*) sqlite3_column_text(st, 0));
168
169
} else if (res == SQLITE_DONE) {
170
break;
171
} else {
172
const char* errmsg = sqlite3_errmsg(sqliteconnection);
173
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
174
ret = -1;
175
break;
176
}
177
}
178
} else {
179
const char* errmsg = sqlite3_errmsg(sqliteconnection);
180
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
181
}
182
sqlite3_finalize(st);
183
}
184
return ret;
185
}
186
187
static int sqlite_get_user_key(u08bits *usname, u08bits *realm, hmackey_t key)
188
{
189
int ret = -1;
190
sqlite3 *sqliteconnection = get_sqlite_connection();
191
if (sqliteconnection) {
192
char statement[TURN_LONG_STRING_SIZE];
193
sqlite3_stmt *st = NULL;
194
int rc = 0;
195
snprintf(statement, sizeof(statement), "select hmackey from turnusers_lt where name='%s' and realm='%s'", usname, realm);
196
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
197
int res = sqlite3_step(st);
198
if (res == SQLITE_ROW) {
199
char *kval = turn_strdup((const char*) sqlite3_column_text(st, 0));
200
size_t sz = get_hmackey_size(turn_params.shatype);
201
if (convert_string_key_to_binary(kval, key, sz) < 0) {
202
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Wrong key: %s, user %s\n", kval, usname);
203
} else {
204
ret = 0;
205
}
206
turn_free(kval,strlen(kval)+1);
207
}
208
} else {
209
const char* errmsg = sqlite3_errmsg(sqliteconnection);
210
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
211
}
212
213
sqlite3_finalize(st);
214
}
215
return ret;
216
}
217
218
static int sqlite_get_user_pwd(u08bits *usname, st_password_t pwd)
219
{
220
int ret = -1;
221
char statement[TURN_LONG_STRING_SIZE];
222
sqlite3_stmt *st = NULL;
223
int rc = 0;
224
snprintf(statement, sizeof(statement), "select password from turnusers_st where name='%s'", usname);
225
226
sqlite3 *sqliteconnection = get_sqlite_connection();
227
if (sqliteconnection) {
228
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
229
int res = sqlite3_step(st);
230
if (res == SQLITE_ROW) {
231
const char *kval = (const char*) sqlite3_column_text(st, 0);
232
if (kval) {
233
strncpy((char*) pwd, kval, sizeof(st_password_t));
234
ret = 0;
235
} else {
236
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Wrong password data for user %s: NULL\n", usname);
237
}
238
}
239
} else {
240
const char* errmsg = sqlite3_errmsg(sqliteconnection);
241
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
242
}
243
244
sqlite3_finalize(st);
245
}
246
return ret;
247
}
248
249
static int sqlite_get_oauth_key(const u08bits *kid, oauth_key_data_raw *key) {
250
251
int ret = -1;
252
253
char statement[TURN_LONG_STRING_SIZE];
254
sqlite3_stmt *st = NULL;
255
int rc = 0;
256
snprintf(statement,sizeof(statement),"select ikm_key,timestamp,lifetime,hkdf_hash_func,as_rs_alg,as_rs_key,auth_alg,auth_key from oauth_key where kid='%s'",(const char*)kid);
257
258
sqlite3 *sqliteconnection = get_sqlite_connection();
259
if(sqliteconnection) {
260
261
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
262
263
int res = sqlite3_step(st);
264
if (res == SQLITE_ROW) {
265
266
STRCPY((char*)key->ikm_key,sqlite3_column_text(st, 0));
267
key->timestamp = (u64bits)strtoll((const char*)sqlite3_column_text(st, 1),NULL,10);
268
key->lifetime = (u32bits)strtol((const char*)sqlite3_column_text(st, 2),NULL,10);
269
STRCPY((char*)key->hkdf_hash_func,sqlite3_column_text(st, 3));
270
STRCPY((char*)key->as_rs_alg,sqlite3_column_text(st, 4));
271
STRCPY((char*)key->as_rs_key,sqlite3_column_text(st, 5));
272
STRCPY((char*)key->auth_alg,sqlite3_column_text(st, 6));
273
STRCPY((char*)key->auth_key,sqlite3_column_text(st, 7));
274
STRCPY((char*)key->kid,kid);
275
ret = 0;
276
}
277
} else {
278
const char* errmsg = sqlite3_errmsg(sqliteconnection);
279
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
280
}
281
282
sqlite3_finalize(st);
283
}
284
285
return ret;
286
}
287
288
static int sqlite_list_oauth_keys(void) {
289
290
oauth_key_data_raw key_;
291
oauth_key_data_raw *key=&key_;
292
293
donot_print_connection_success=1;
294
295
int ret = -1;
296
297
char statement[TURN_LONG_STRING_SIZE];
298
sqlite3_stmt *st = NULL;
299
int rc = 0;
300
snprintf(statement,sizeof(statement),"select ikm_key,timestamp,lifetime,hkdf_hash_func,as_rs_alg,as_rs_key,auth_alg,auth_key,kid from oauth_key order by kid");
301
302
sqlite3 *sqliteconnection = get_sqlite_connection();
303
if(sqliteconnection) {
304
305
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
306
307
ret = 0;
308
while (1) {
309
int res = sqlite3_step(st);
310
if (res == SQLITE_ROW) {
311
312
STRCPY((char*)key->ikm_key,sqlite3_column_text(st, 0));
313
key->timestamp = (u64bits)strtoll((const char*)sqlite3_column_text(st, 1),NULL,10);
314
key->lifetime = (u32bits)strtol((const char*)sqlite3_column_text(st, 2),NULL,10);
315
STRCPY((char*)key->hkdf_hash_func,sqlite3_column_text(st, 3));
316
STRCPY((char*)key->as_rs_alg,sqlite3_column_text(st, 4));
317
STRCPY((char*)key->as_rs_key,sqlite3_column_text(st, 5));
318
STRCPY((char*)key->auth_alg,sqlite3_column_text(st, 6));
319
STRCPY((char*)key->auth_key,sqlite3_column_text(st, 7));
320
STRCPY((char*)key->kid,sqlite3_column_text(st, 7));
321
322
printf(" kid=%s, ikm_key=%s, timestamp=%llu, lifetime=%lu, hkdf_hash_func=%s, as_rs_alg=%s, as_rs_key=%s, auth_alg=%s, auth_key=%s\n",
323
key->kid, key->ikm_key, (unsigned long long)key->timestamp, (unsigned long)key->lifetime, key->hkdf_hash_func,
324
key->as_rs_alg, key->as_rs_key, key->auth_alg, key->auth_key);
325
326
} else if (res == SQLITE_DONE) {
327
break;
328
} else {
329
const char* errmsg = sqlite3_errmsg(sqliteconnection);
330
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
331
ret = -1;
332
break;
333
}
334
}
335
} else {
336
const char* errmsg = sqlite3_errmsg(sqliteconnection);
337
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
338
}
339
340
sqlite3_finalize(st);
341
}
342
343
return ret;
344
}
345
346
static int sqlite_set_user_key(u08bits *usname, u08bits *realm, const char *key)
347
{
348
int ret = -1;
349
char statement[TURN_LONG_STRING_SIZE];
350
sqlite3_stmt *st = NULL;
351
int rc = 0;
352
353
donot_print_connection_success=1;
354
355
sqlite3 *sqliteconnection = get_sqlite_connection();
356
if (sqliteconnection) {
357
358
snprintf(statement, sizeof(statement), "insert or replace into turnusers_lt (realm,name,hmackey) values('%s','%s','%s')", realm, usname, key);
359
360
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
361
sqlite3_step(st);
362
ret = 0;
363
} else {
364
const char* errmsg = sqlite3_errmsg(sqliteconnection);
365
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
366
}
367
sqlite3_finalize(st);
368
}
369
return ret;
370
}
371
372
static int sqlite_set_oauth_key(oauth_key_data_raw *key)
373
{
374
375
int ret = -1;
376
char statement[TURN_LONG_STRING_SIZE];
377
sqlite3_stmt *st = NULL;
378
int rc = 0;
379
380
donot_print_connection_success=1;
381
382
sqlite3 *sqliteconnection = get_sqlite_connection();
383
if (sqliteconnection) {
384
snprintf(
385
statement,
386
sizeof(statement),
387
"insert or replace into oauth_key (kid,ikm_key,timestamp,lifetime,hkdf_hash_func,as_rs_alg,as_rs_key,auth_alg,auth_key) values('%s','%s',%llu,%lu,'%s','%s','%s','%s','%s')",
388
key->kid, key->ikm_key, (unsigned long long) key->timestamp, (unsigned long) key->lifetime, key->hkdf_hash_func, key->as_rs_alg, key->as_rs_key, key->auth_alg,
389
key->auth_key);
390
391
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
392
sqlite3_step(st);
393
ret = 0;
394
} else {
395
const char* errmsg = sqlite3_errmsg(sqliteconnection);
396
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
397
}
398
sqlite3_finalize(st);
399
}
400
return ret;
401
}
402
403
static int sqlite_set_user_pwd(u08bits *usname, st_password_t pwd)
404
{
405
int ret = -1;
406
char statement[TURN_LONG_STRING_SIZE];
407
sqlite3_stmt *st = NULL;
408
int rc = 0;
409
410
donot_print_connection_success=1;
411
412
sqlite3 *sqliteconnection = get_sqlite_connection();
413
if (sqliteconnection) {
414
snprintf(statement, sizeof(statement), "insert or replace into turnusers_st values('%s','%s')", usname, pwd);
415
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
416
sqlite3_step(st);
417
ret = 0;
418
} else {
419
const char* errmsg = sqlite3_errmsg(sqliteconnection);
420
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
421
}
422
sqlite3_finalize(st);
423
}
424
return ret;
425
}
426
427
static int sqlite_del_user(u08bits *usname, int is_st, u08bits *realm)
428
{
429
int ret = -1;
430
char statement[TURN_LONG_STRING_SIZE];
431
sqlite3_stmt *st = NULL;
432
int rc = 0;
433
434
donot_print_connection_success=1;
435
436
sqlite3 *sqliteconnection = get_sqlite_connection();
437
if (sqliteconnection) {
438
if (is_st) {
439
snprintf(statement, sizeof(statement), "delete from turnusers_st where name='%s'", usname);
440
} else {
441
snprintf(statement, sizeof(statement), "delete from turnusers_lt where name='%s' and realm='%s'", usname, realm);
442
}
443
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
444
sqlite3_step(st);
445
ret = 0;
446
} else {
447
const char* errmsg = sqlite3_errmsg(sqliteconnection);
448
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
449
}
450
sqlite3_finalize(st);
451
}
452
return ret;
453
}
454
455
static int sqlite_del_oauth_key(const u08bits *kid)
456
{
457
int ret = -1;
458
char statement[TURN_LONG_STRING_SIZE];
459
sqlite3_stmt *st = NULL;
460
int rc = 0;
461
462
donot_print_connection_success=1;
463
464
sqlite3 *sqliteconnection = get_sqlite_connection();
465
if (sqliteconnection) {
466
snprintf(statement, sizeof(statement), "delete from oauth_key where kid = '%s'", (const char*) kid);
467
468
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
469
sqlite3_step(st);
470
ret = 0;
471
} else {
472
const char* errmsg = sqlite3_errmsg(sqliteconnection);
473
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
474
}
475
sqlite3_finalize(st);
476
}
477
return ret;
478
}
479
480
481
static int sqlite_list_users(int is_st, u08bits *realm)
482
{
483
int ret = -1;
484
char statement[TURN_LONG_STRING_SIZE];
485
sqlite3_stmt *st = NULL;
486
int rc = 0;
487
488
donot_print_connection_success=1;
489
490
sqlite3 *sqliteconnection = get_sqlite_connection();
491
if (sqliteconnection) {
492
if (is_st) {
493
snprintf(statement, sizeof(statement), "select name,'' from turnusers_st order by name");
494
} else if (realm && realm[0]) {
495
snprintf(statement, sizeof(statement), "select name,realm from turnusers_lt where realm='%s' order by name", realm);
496
} else {
497
snprintf(statement, sizeof(statement), "select name,realm from turnusers_lt order by name");
498
}
499
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
500
501
ret = 0;
502
while (1) {
503
int res = sqlite3_step(st);
504
if (res == SQLITE_ROW) {
505
506
const char* kval = (const char*) sqlite3_column_text(st, 0);
507
const char* rval = (const char*) sqlite3_column_text(st, 1);
508
509
if (rval && *rval) {
510
printf("%s[%s]\n", kval, rval);
511
} else {
512
printf("%s\n", kval);
513
}
514
515
} else if (res == SQLITE_DONE) {
516
break;
517
} else {
518
const char* errmsg = sqlite3_errmsg(sqliteconnection);
519
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
520
ret = -1;
521
break;
522
}
523
}
524
} else {
525
const char* errmsg = sqlite3_errmsg(sqliteconnection);
526
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
527
}
528
sqlite3_finalize(st);
529
}
530
return ret;
531
}
532
533
static int sqlite_show_secret(u08bits *realm)
534
{
535
int ret = -1;
536
char statement[TURN_LONG_STRING_SIZE];
537
sqlite3_stmt *st = NULL;
538
int rc = 0;
539
snprintf(statement,sizeof(statement)-1,"select value from turn_secret where realm='%s'",realm);
540
541
donot_print_connection_success=1;
542
543
sqlite3 *sqliteconnection = get_sqlite_connection();
544
if(sqliteconnection) {
545
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
546
int res = sqlite3_step(st);
547
if (res == SQLITE_ROW) {
548
ret = 0;
549
const char* kval = (const char*) sqlite3_column_text(st, 0);
550
if(kval) {
551
printf("%s\n",kval);
552
}
553
}
554
} else {
555
const char* errmsg = sqlite3_errmsg(sqliteconnection);
556
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
557
}
558
sqlite3_finalize(st);
559
}
560
return ret;
561
}
562
563
static int sqlite_del_secret(u08bits *secret, u08bits *realm)
564
{
565
int ret = -1;
566
donot_print_connection_success=1;
567
char statement[TURN_LONG_STRING_SIZE];
568
sqlite3_stmt *st = NULL;
569
int rc = 0;
570
571
sqlite3 *sqliteconnection = get_sqlite_connection();
572
if (sqliteconnection) {
573
if(!secret || (secret[0]==0))
574
snprintf(statement,sizeof(statement),"delete from turn_secret where realm='%s'",realm);
575
else
576
snprintf(statement,sizeof(statement),"delete from turn_secret where value='%s' and realm='%s'",secret,realm);
577
578
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
579
sqlite3_step(st);
580
ret = 0;
581
} else {
582
const char* errmsg = sqlite3_errmsg(sqliteconnection);
583
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
584
}
585
sqlite3_finalize(st);
586
}
587
return ret;
588
}
589
590
static int sqlite_set_secret(u08bits *secret, u08bits *realm)
591
{
592
int ret = -1;
593
donot_print_connection_success = 1;
594
char statement[TURN_LONG_STRING_SIZE];
595
sqlite3_stmt *st = NULL;
596
int rc = 0;
597
598
sqlite3 *sqliteconnection = get_sqlite_connection();
599
if (sqliteconnection) {
600
snprintf(statement,sizeof(statement),"insert or replace into turn_secret (realm,value) values('%s','%s')",realm,secret);
601
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
602
sqlite3_step(st);
603
ret = 0;
604
} else {
605
const char* errmsg = sqlite3_errmsg(sqliteconnection);
606
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
607
}
608
sqlite3_finalize(st);
609
}
610
return ret;
611
}
612
613
static int sqlite_add_origin(u08bits *origin, u08bits *realm)
614
{
615
int ret = -1;
616
char statement[TURN_LONG_STRING_SIZE];
617
sqlite3_stmt *st = NULL;
618
int rc = 0;
619
donot_print_connection_success=1;
620
621
sqlite3 *sqliteconnection = get_sqlite_connection();
622
if(sqliteconnection) {
623
snprintf(statement,sizeof(statement),"insert or replace into turn_origin_to_realm (origin,realm) values('%s','%s')",origin,realm);
624
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
625
sqlite3_step(st);
626
ret = 0;
627
} else {
628
const char* errmsg = sqlite3_errmsg(sqliteconnection);
629
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
630
}
631
sqlite3_finalize(st);
632
}
633
return ret;
634
}
635
636
static int sqlite_del_origin(u08bits *origin)
637
{
638
int ret = -1;
639
char statement[TURN_LONG_STRING_SIZE];
640
sqlite3_stmt *st = NULL;
641
int rc = 0;
642
donot_print_connection_success=1;
643
644
sqlite3 *sqliteconnection = get_sqlite_connection();
645
if(sqliteconnection) {
646
snprintf(statement,sizeof(statement),"delete from turn_origin_to_realm where origin='%s'",origin);
647
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
648
sqlite3_step(st);
649
ret = 0;
650
} else {
651
const char* errmsg = sqlite3_errmsg(sqliteconnection);
652
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
653
}
654
sqlite3_finalize(st);
655
}
656
return ret;
657
}
658
659
static int sqlite_list_origins(u08bits *realm)
660
{
661
int ret = -1;
662
donot_print_connection_success = 1;
663
char statement[TURN_LONG_STRING_SIZE];
664
sqlite3_stmt *st = NULL;
665
int rc = 0;
666
667
sqlite3 *sqliteconnection = get_sqlite_connection();
668
if (sqliteconnection) {
669
if (realm && realm[0]) {
670
snprintf(statement, sizeof(statement), "select origin,realm from turn_origin_to_realm where realm='%s' order by origin", realm);
671
} else {
672
snprintf(statement, sizeof(statement), "select origin,realm from turn_origin_to_realm order by origin,realm");
673
}
674
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
675
676
ret = 0;
677
while (1) {
678
int res = sqlite3_step(st);
679
if (res == SQLITE_ROW) {
680
681
const char* kval = (const char*) sqlite3_column_text(st, 0);
682
const char* rval = (const char*) sqlite3_column_text(st, 1);
683
684
printf("%s ==>> %s\n",kval,rval);
685
686
} else if (res == SQLITE_DONE) {
687
break;
688
} else {
689
const char* errmsg = sqlite3_errmsg(sqliteconnection);
690
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
691
ret = -1;
692
break;
693
}
694
}
695
} else {
696
const char* errmsg = sqlite3_errmsg(sqliteconnection);
697
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
698
}
699
sqlite3_finalize(st);
700
}
701
return ret;
702
}
703
704
static int sqlite_set_realm_option_one(u08bits *realm, unsigned long value, const char* opt)
705
{
706
int ret = -1;
707
char statement[TURN_LONG_STRING_SIZE];
708
sqlite3_stmt *st = NULL;
709
int rc = 0;
710
donot_print_connection_success=1;
711
712
sqlite3 *sqliteconnection = get_sqlite_connection();
713
if(sqliteconnection) {
714
if(value>0) {
715
snprintf(statement,sizeof(statement),"insert or replace into turn_realm_option (realm,opt,value) values('%s','%s','%lu')",realm,opt,(unsigned long)value);
716
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
717
sqlite3_step(st);
718
ret = 0;
719
} else {
720
const char* errmsg = sqlite3_errmsg(sqliteconnection);
721
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
722
}
723
sqlite3_finalize(st);
724
}
725
}
726
return ret;
727
}
728
729
static int sqlite_list_realm_options(u08bits *realm)
730
{
731
int ret = -1;
732
donot_print_connection_success = 1;
733
char statement[TURN_LONG_STRING_SIZE];
734
sqlite3_stmt *st = NULL;
735
int rc = 0;
736
737
sqlite3 *sqliteconnection = get_sqlite_connection();
738
if (sqliteconnection) {
739
if (realm && realm[0]) {
740
snprintf(statement, sizeof(statement), "select realm,opt,value from turn_realm_option where realm='%s' order by realm,opt", realm);
741
} else {
742
snprintf(statement, sizeof(statement), "select realm,opt,value from turn_realm_option order by realm,opt");
743
}
744
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
745
746
ret = 0;
747
748
while (1) {
749
int res = sqlite3_step(st);
750
if (res == SQLITE_ROW) {
751
752
const char* rval = (const char*) sqlite3_column_text(st, 0);
753
const char* oval = (const char*) sqlite3_column_text(st, 1);
754
const char* vval = (const char*) sqlite3_column_text(st, 2);
755
756
printf("%s[%s]=%s\n",oval,rval,vval);
757
758
} else if (res == SQLITE_DONE) {
759
break;
760
} else {
761
const char* errmsg = sqlite3_errmsg(sqliteconnection);
762
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
763
ret = -1;
764
break;
765
}
766
}
767
} else {
768
const char* errmsg = sqlite3_errmsg(sqliteconnection);
769
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
770
}
771
sqlite3_finalize(st);
772
}
773
return ret;
774
}
775
776
static void sqlite_auth_ping(void * rch)
777
{
778
UNUSED_ARG(rch);
779
}
780
781
static int sqlite_get_ip_list(const char *kind, ip_range_list_t * list)
782
{
783
int ret = -1;
784
785
sqlite3 *sqliteconnection = get_sqlite_connection();
786
if (sqliteconnection) {
787
char statement[TURN_LONG_STRING_SIZE];
788
sqlite3_stmt *st = NULL;
789
int rc = 0;
790
snprintf(statement, sizeof(statement), "select ip_range,realm from %s_peer_ip", kind);
791
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
792
793
ret = 0;
794
795
while (1) {
796
int res = sqlite3_step(st);
797
if (res == SQLITE_ROW) {
798
799
const char* kval = (const char*) sqlite3_column_text(st, 0);
800
const char* rval = (const char*) sqlite3_column_text(st, 1);
801
802
add_ip_list_range(kval, rval, list);
803
804
} else if (res == SQLITE_DONE) {
805
break;
806
} else {
807
const char* errmsg = sqlite3_errmsg(sqliteconnection);
808
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
809
ret = -1;
810
break;
811
}
812
}
813
} else {
814
const char* errmsg = sqlite3_errmsg(sqliteconnection);
815
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
816
}
817
sqlite3_finalize(st);
818
}
819
return ret;
820
}
821
822
static void sqlite_reread_realms(secrets_list_t * realms_list)
823
{
824
sqlite3 *sqliteconnection = get_sqlite_connection();
825
if(sqliteconnection) {
826
char statement[TURN_LONG_STRING_SIZE];
827
sqlite3_stmt *st = NULL;
828
int rc = 0;
829
{
830
snprintf(statement,sizeof(statement),"select origin,realm from turn_origin_to_realm");
831
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
832
833
ur_string_map *o_to_realm_new = ur_string_map_create(turn_free_simple);
834
835
while (1) {
836
int res = sqlite3_step(st);
837
if (res == SQLITE_ROW) {
838
839
char* oval = turn_strdup((const char*) sqlite3_column_text(st, 0));
840
char* rval = turn_strdup((const char*) sqlite3_column_text(st, 1));
841
842
get_realm(rval);
843
ur_string_map_value_type value = rval;
844
ur_string_map_put(o_to_realm_new, (const ur_string_map_key_type) oval, value);
845
846
turn_free(oval,strlen(oval)+1);
847
848
} else if (res == SQLITE_DONE) {
849
break;
850
} else {
851
const char* errmsg = sqlite3_errmsg(sqliteconnection);
852
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
853
break;
854
}
855
}
856
857
update_o_to_realm(o_to_realm_new);
858
859
} else {
860
const char* errmsg = sqlite3_errmsg(sqliteconnection);
861
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
862
}
863
sqlite3_finalize(st);
864
}
865
866
{
867
{
868
size_t i = 0;
869
size_t rlsz = 0;
870
871
lock_realms();
872
rlsz = realms_list->sz;
873
unlock_realms();
874
875
for (i = 0; i<rlsz; ++i) {
876
877
char *realm = realms_list->secrets[i];
878
879
realm_params_t* rp = get_realm(realm);
880
881
lock_realms();
882
rp->options.perf_options.max_bps = turn_params.max_bps;
883
unlock_realms();
884
885
lock_realms();
886
rp->options.perf_options.total_quota = turn_params.total_quota;
887
unlock_realms();
888
889
lock_realms();
890
rp->options.perf_options.user_quota = turn_params.user_quota;
891
unlock_realms();
892
893
}
894
}
895
896
snprintf(statement,sizeof(statement),"select realm,opt,value from turn_realm_option");
897
if ((rc = sqlite3_prepare(sqliteconnection, statement, -1, &st, 0)) == SQLITE_OK) {
898
899
while (1) {
900
int res = sqlite3_step(st);
901
if (res == SQLITE_ROW) {
902
903
char* rval = turn_strdup((const char*) sqlite3_column_text(st, 0));
904
const char* oval = (const char*) sqlite3_column_text(st, 1);
905
const char* vval = (const char*) sqlite3_column_text(st, 2);
906
907
realm_params_t* rp = get_realm(rval);
908
if(!strcmp(oval,"max-bps"))
909
rp->options.perf_options.max_bps = (band_limit_t)atol(vval);
910
else if(!strcmp(oval,"total-quota"))
911
rp->options.perf_options.total_quota = (vint)atoi(vval);
912
else if(!strcmp(oval,"user-quota"))
913
rp->options.perf_options.user_quota = (vint)atoi(vval);
914
else {
915
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Unknown realm option: %s\n", oval);
916
}
917
918
turn_free(rval,strlen(rval)+1);
919
920
} else if (res == SQLITE_DONE) {
921
break;
922
} else {
923
const char* errmsg = sqlite3_errmsg(sqliteconnection);
924
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
925
break;
926
}
927
}
928
} else {
929
const char* errmsg = sqlite3_errmsg(sqliteconnection);
930
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error retrieving SQLite DB information: %s\n", errmsg);
931
}
932
sqlite3_finalize(st);
933
}
934
}
935
}
936
937
///////////////////////////////////////////////////////////////////////////////////////////////////////////
938
939
static turn_dbdriver_t driver = {
940
&sqlite_get_auth_secrets,
941
&sqlite_get_user_key,
942
&sqlite_get_user_pwd,
943
&sqlite_set_user_key,
944
&sqlite_set_user_pwd,
945
&sqlite_del_user,
946
&sqlite_list_users,
947
&sqlite_show_secret,
948
&sqlite_del_secret,
949
&sqlite_set_secret,
950
&sqlite_add_origin,
951
&sqlite_del_origin,
952
&sqlite_list_origins,
953
&sqlite_set_realm_option_one,
954
&sqlite_list_realm_options,
955
&sqlite_auth_ping,
956
&sqlite_get_ip_list,
957
&sqlite_reread_realms,
958
&sqlite_set_oauth_key,
959
&sqlite_get_oauth_key,
960
&sqlite_del_oauth_key,
961
&sqlite_list_oauth_keys
962
};
963
964
//////////////////////////////////////////////////
965
966
turn_dbdriver_t * get_sqlite_dbdriver(void) {
967
return &driver;
968
}
969
970
//////////////////////////////////////////////////
971
972
#endif
Loggerhead is a web-based interface for Breezy
Version: 2.0.1