origins admin page

src/apps/relay/dbdrivers/dbd_mongo.c

@@ -750,71 +750,82 @@ static int mongo_del_origin(u08bits *origin) {
   return ret;
 }
   
-static int mongo_list_origins(u08bits *realm) {
-  mongoc_collection_t * collection = mongo_get_collection("realm"); 
+static int mongo_list_origins(u08bits *realm, secrets_list_t *origins, secrets_list_t *realms)
+{
+	mongoc_collection_t * collection = mongo_get_collection("realm");
 
 	if(!collection)
-    return -1;
+		return -1;
 
-  bson_t query, child;
-  bson_init(&query);
-  bson_append_document_begin(&query, "$orderby", -1, &child);
-  BSON_APPEND_INT32(&child, "realm", 1);
-  bson_append_document_end(&query, &child);
-  bson_append_document_begin(&query, "$query", -1, &child);
-  if (realm && realm[0]) {
-    BSON_APPEND_UTF8(&child, "realm", (const char *)realm);
-  }
-  bson_append_document_end(&query, &child);
+	u08bits realm0[STUN_MAX_REALM_SIZE+1] = "\0";
+	if(!realm) realm=realm0;
 
-  bson_t fields;
-  bson_init(&fields);
-  BSON_APPEND_INT32(&fields, "origin", 1);
-  BSON_APPEND_INT32(&fields, "realm", 1);
+	bson_t query, child;
+	bson_init(&query);
+	bson_append_document_begin(&query, "$orderby", -1, &child);
+	BSON_APPEND_INT32(&child, "realm", 1);
+	bson_append_document_end(&query, &child);
+	bson_append_document_begin(&query, "$query", -1, &child);
+	if (realm && realm[0]) {
+		BSON_APPEND_UTF8(&child, "realm", (const char *)realm);
+	}
+	bson_append_document_end(&query, &child);
+
+	bson_t fields;
+	bson_init(&fields);
+	BSON_APPEND_INT32(&fields, "origin", 1);
+	BSON_APPEND_INT32(&fields, "realm", 1);
   
-  mongoc_cursor_t * cursor;
-  cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, &query, &fields, NULL);
+	mongoc_cursor_t * cursor;
+	cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, &query, &fields, NULL);
 
-  int ret = -1;
+	int ret = -1;
   
-  if (!cursor) {
+	if (!cursor) {
 		TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Error querying MongoDB collection 'realm'\n");
-  } else {
-    const bson_t * item;
-    uint32_t length;
-    bson_iter_t iter;
+	} else {
+		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)) {
-        const char * _realm = bson_iter_utf8(&iter, &length);
+		while (mongoc_cursor_next(cursor, &item)) {
+			if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "realm") && BSON_ITER_HOLDS_UTF8(&iter)) {
+				const char * _realm = bson_iter_utf8(&iter, &length);
 
-        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;
+				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);
+					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)) {
-                const char * _origin = bson_iter_utf8(&origin_iter, &length);
-  							printf("%s ==>> %s\n", _realm, _origin);
-              }
-            }
-          }
-        }
-      }
-    }
-    mongoc_cursor_destroy(cursor);
-    ret = 0;
-  }
-  mongoc_collection_destroy(collection);
-  bson_destroy(&query);
-  bson_destroy(&fields);
-  return ret;
+					if (bson_iter_init(&origin_iter, &origin_array)) {
+						while(bson_iter_next(&origin_iter)) {
+							if (BSON_ITER_HOLDS_UTF8(&origin_iter)) {
+								const char * _origin = bson_iter_utf8(&origin_iter, &length);
+								if(origins) {
+									add_to_secrets_list(origins,_origin);
+									if(realms) {
+										add_to_secrets_list(realms,_realm);
+									}
+								} else {
+									printf("%s ==>> %s\n", _realm, _origin);
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		mongoc_cursor_destroy(cursor);
+		ret = 0;
+	}
+	mongoc_collection_destroy(collection);
+	bson_destroy(&query);
+	bson_destroy(&fields);
+	return ret;
 }
   
 static int mongo_set_realm_option_one(u08bits *realm, unsigned long value, const char* opt) {

src/apps/relay/dbdrivers/dbd_mysql.c

@@ -740,16 +740,22 @@ static int mysql_del_origin(u08bits *origin) {
   return ret;
 }
   
-static int mysql_list_origins(u08bits *realm) {
-  int ret = -1;
+static int mysql_list_origins(u08bits *realm, secrets_list_t *origins, secrets_list_t *realms)
+{
+	int ret = -1;
+
+	u08bits realm0[STUN_MAX_REALM_SIZE+1] = "\0";
+	if(!realm) realm=realm0;
+
 	donot_print_connection_success = 1;
-	char statement[TURN_LONG_STRING_SIZE];
+
 	MYSQL * myc = get_mydb_connection();
 	if(myc) {
+		char statement[TURN_LONG_STRING_SIZE];
 		if(realm && realm[0]) {
 			snprintf(statement,sizeof(statement),"select origin,realm from turn_origin_to_realm where realm='%s' order by origin",realm);
 		} else {
-			snprintf(statement,sizeof(statement),"select origin,realm from turn_origin_to_realm order by origin,realm");
+			snprintf(statement,sizeof(statement),"select origin,realm from turn_origin_to_realm order by realm,origin");
 		}
 		int res = mysql_query(myc, statement);
 		if(res) {
@@ -767,7 +773,20 @@ static int mysql_list_origins(u08bits *realm) {
 						break;
 					} else {
 						if(row[0] && row[1]) {
-							printf("%s ==>> %s\n",row[0],row[1]);
+							const char* kval = row[0];
+							const char* rval = row[1];
+							if(origins) {
+								add_to_secrets_list(origins,kval);
+								if(realms) {
+									if(rval && *rval) {
+										add_to_secrets_list(realms,rval);
+									} else {
+										add_to_secrets_list(realms,(char*)realm);
+									}
+								}
+							} else {
+								printf("%s ==>> %s\n",kval,rval);
+							}
 						}
 					}
 				}

src/apps/relay/dbdrivers/dbd_pgsql.c

@@ -508,16 +508,25 @@ static int pgsql_del_origin(u08bits *origin) {
   return ret;
 }
   
-static int pgsql_list_origins(u08bits *realm) {
-  int ret = -1;
+static int pgsql_list_origins(u08bits *realm, secrets_list_t *origins, secrets_list_t *realms)
+{
+	int ret = -1;
+
+	u08bits realm0[STUN_MAX_REALM_SIZE+1] = "\0";
+	if(!realm) realm=realm0;
+
 	donot_print_connection_success = 1;
-	char statement[TURN_LONG_STRING_SIZE];
+
 	PGconn *pqc = get_pqdb_connection();
+
 	if(pqc) {
+
+		char statement[TURN_LONG_STRING_SIZE];
+
 		if(realm && realm[0]) {
 		  snprintf(statement,sizeof(statement),"select origin,realm from turn_origin_to_realm where realm='%s' order by origin",realm);
 		} else {
-		  snprintf(statement,sizeof(statement),"select origin,realm from turn_origin_to_realm order by origin,realm");
+		  snprintf(statement,sizeof(statement),"select origin,realm from turn_origin_to_realm order by realm,origin");
 		}
 		PGresult *res = PQexec(pqc, statement);
 		if(!res || (PQresultStatus(res) != PGRES_TUPLES_OK)) {
@@ -525,21 +534,32 @@ static int pgsql_list_origins(u08bits *realm) {
 		} else {
 			int i = 0;
 			for(i=0;i<PQntuples(res);i++) {
-				char *oval = PQgetvalue(res,i,0);
-				if(oval) {
+				char *kval = PQgetvalue(res,i,0);
+				if(kval) {
 					char *rval = PQgetvalue(res,i,1);
 					if(rval) {
-						printf("%s ==>> %s\n",oval,rval);
+						if(origins) {
+							add_to_secrets_list(origins,kval);
+							if(realms) {
+								if(rval && *rval) {
+									add_to_secrets_list(realms,rval);
+								} else {
+									add_to_secrets_list(realms,(char*)realm);
+								}
+							}
+						} else {
+							printf("%s ==>> %s\n",kval,rval);
+						}
 					}
 				}
 			}
-      ret = 0;
+			ret = 0;
 		}
 		if(res) {
 			PQclear(res);
 		}
 	}
-  return ret;
+	return ret;
 }
   
 static int pgsql_set_realm_option_one(u08bits *realm, unsigned long value, const char* opt) {

src/apps/relay/dbdrivers/dbd_redis.c

@@ -840,9 +840,15 @@ static int redis_del_origin(u08bits *origin) {
   return ret;
 }
   
-static int redis_list_origins(u08bits *realm) {
-  int ret = -1;
+static int redis_list_origins(u08bits *realm, secrets_list_t *origins, secrets_list_t *realms)
+{
+	int ret = -1;
+
+	u08bits realm0[STUN_MAX_REALM_SIZE+1] = "\0";
+	if(!realm) realm=realm0;
+
 	donot_print_connection_success = 1;
+
 	redisContext *rc = get_redis_connection();
 	if(rc) {
 		secrets_list_t keys;
@@ -873,6 +879,7 @@ static int redis_list_origins(u08bits *realm) {
 		}
 
 		for(isz=0;isz<keys.sz;++isz) {
+
 			char *o = keys.secrets[isz];
 
 			reply = (redisReply*)redisCommand(rc, "get turn/origin/%s",o);
@@ -885,7 +892,14 @@ static int redis_list_origins(u08bits *realm) {
 						TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "Unexpected type: %d\n", reply->type);
 				} else {
 					if(!(realm && realm[0] && strcmp((char*)realm,reply->str))) {
-						printf("%s ==>> %s\n",o,reply->str);
+						if(origins) {
+							add_to_secrets_list(origins,o);
+							if(realms) {
+								add_to_secrets_list(realms,reply->str);
+							}
+						} else {
+							printf("%s ==>> %s\n",o,reply->str);
+						}
 					}
 				}
 				turnFreeRedisReply(reply);
@@ -893,9 +907,9 @@ static int redis_list_origins(u08bits *realm) {
 		}
 
 		clean_secrets_list(&keys);
-    ret = 0;
+		ret = 0;
 	}
-  return ret;
+	return ret;
 }
   
 static int redis_set_realm_option_one(u08bits *realm, unsigned long value, const char* opt) {

src/apps/relay/dbdrivers/dbd_sqlite.c

@@ -761,20 +761,25 @@ static int sqlite_del_origin(u08bits *origin)
 	return ret;
 }
 
-static int sqlite_list_origins(u08bits *realm)
+static int sqlite_list_origins(u08bits *realm, secrets_list_t *origins, secrets_list_t *realms)
 {
 	int ret = -1;
+
+	u08bits realm0[STUN_MAX_REALM_SIZE+1] = "\0";
+	if(!realm) realm=realm0;
+
 	donot_print_connection_success = 1;
-	char statement[TURN_LONG_STRING_SIZE];
+
 	sqlite3_stmt *st = NULL;
 	int rc = 0;
 
 	sqlite3 *sqliteconnection = get_sqlite_connection();
 	if (sqliteconnection) {
+		char statement[TURN_LONG_STRING_SIZE];
 		if (realm && realm[0]) {
 			snprintf(statement, sizeof(statement), "select origin,realm from turn_origin_to_realm where realm='%s' order by origin", realm);
 		} else {
-			snprintf(statement, sizeof(statement), "select origin,realm from turn_origin_to_realm order by origin,realm");
+			snprintf(statement, sizeof(statement), "select origin,realm from turn_origin_to_realm order by realm,origin");
 		}
 
 		sqlite_lock(0);
@@ -789,8 +794,18 @@ static int sqlite_list_origins(u08bits *realm)
 					const char* kval = (const char*) sqlite3_column_text(st, 0);
 					const char* rval = (const char*) sqlite3_column_text(st, 1);
 
-					printf("%s ==>> %s\n",kval,rval);
-
+					if(origins) {
+						add_to_secrets_list(origins,kval);
+						if(realms) {
+							if(rval && *rval) {
+								add_to_secrets_list(realms,rval);
+							} else {
+								add_to_secrets_list(realms,(char*)realm);
+							}
+						}
+					} else {
+						printf("%s ==>> %s\n",kval,rval);
+					}
 				} else if (res == SQLITE_DONE) {
 					break;
 				} else {

src/apps/relay/dbdrivers/dbdriver.h

@@ -53,12 +53,12 @@ typedef struct _turn_dbdriver_t {
   int (*set_user_key)(u08bits *usname, u08bits *realm, const char *key);
   int (*del_user)(u08bits *usname, u08bits *realm);
   int (*list_users)(u08bits *realm, secrets_list_t *users, secrets_list_t *realms);
-  int (*list_secrets)(u08bits *realm, secrets_list_t *users, secrets_list_t *realms);
+  int (*list_secrets)(u08bits *realm, secrets_list_t *secrets, secrets_list_t *realms);
   int (*del_secret)(u08bits *secret, u08bits *realm);
   int (*set_secret)(u08bits *secret, u08bits *realm);
   int (*add_origin)(u08bits *origin, u08bits *realm);
   int (*del_origin)(u08bits *origin);
-  int (*list_origins)(u08bits *realm);
+  int (*list_origins)(u08bits *realm, secrets_list_t *origins, secrets_list_t *realms);
   int (*set_realm_option_one)(u08bits *realm, unsigned long value, const char* opt);
   int (*list_realm_options)(u08bits *realm);
   void (*auth_ping)(void * rch);

src/apps/relay/turn_admin_server.c

@@ -1362,6 +1362,7 @@ enum _AS_FORM {
 	AS_FORM_PS,
 	AS_FORM_USERS,
 	AS_FORM_SS,
+	AS_FORM_OS,
 	AS_FORM_UNKNOWN
 };
 
@@ -1374,6 +1375,7 @@ typedef enum _AS_FORM AS_FORM;
 #define HR_ADD_USER "add_user"
 #define HR_ADD_REALM "add_user_realm"
 #define HR_ADD_SECRET "add_secret"
+#define HR_ADD_ORIGIN "add_origin"
 #define HR_CLIENT_PROTOCOL "cprotocol"
 #define HR_USER_PATTERN "puser"
 #define HR_MAX_SESSIONS "maxsess"
@@ -1381,6 +1383,7 @@ typedef enum _AS_FORM AS_FORM;
 #define HR_DELETE_USER "du"
 #define HR_DELETE_REALM "dr"
 #define HR_DELETE_SECRET "ds"
+#define HR_DELETE_ORIGIN "do"
 
 struct form_name {
 	AS_FORM form;
@@ -1397,6 +1400,7 @@ static struct form_name form_names[] = {
 				{AS_FORM_PS,"/ps"},
 				{AS_FORM_USERS,"/us"},
 				{AS_FORM_SS,"/ss"},
+				{AS_FORM_OS,"/os"},
 				{AS_FORM_UNKNOWN,NULL}
 };
 
@@ -1539,6 +1543,10 @@ static void write_https_home_page(ioa_socket_handle s)
 			str_buffer_append(sb,form_names[AS_FORM_SS].name);
 			str_buffer_append(sb,"\">");
 
+			str_buffer_append(sb,"<br><input type=\"submit\" value=\"Origins\" formaction=\"");
+			str_buffer_append(sb,form_names[AS_FORM_OS].name);
+			str_buffer_append(sb,"\">");
+
 			str_buffer_append(sb,"</fieldset>\r\n");
 			str_buffer_append(sb,"</form>\r\n");
 
@@ -2250,7 +2258,7 @@ static size_t https_print_users(struct str_buffer* sb)
 		size_t i;
 		for(i=0;i<sz;++i) {
 			str_buffer_append(sb,"<tr><td>");
-			str_buffer_append_sz(sb,i);
+			str_buffer_append_sz(sb,i+1);
 			str_buffer_append(sb,"</td>");
 			str_buffer_append(sb,"<td>");
 			str_buffer_append(sb,get_secrets_list_elem(&users,i));
@@ -2415,7 +2423,7 @@ static size_t https_print_secrets(struct str_buffer* sb)
 		size_t i;
 		for(i=0;i<sz;++i) {
 			str_buffer_append(sb,"<tr><td>");
-			str_buffer_append_sz(sb,i);
+			str_buffer_append_sz(sb,i+1);
 			str_buffer_append(sb,"</td>");
 			str_buffer_append(sb,"<td>");
 			str_buffer_append(sb,get_secrets_list_elem(&secrets,i));
@@ -2552,6 +2560,156 @@ static void write_shared_secrets_page(ioa_socket_handle s, const char* add_secre
 	}
 }
 
+static size_t https_print_origins(struct str_buffer* sb)
+{
+	size_t ret = 0;
+	const turn_dbdriver_t * dbd = get_dbdriver();
+	if (dbd && dbd->list_origins) {
+		secrets_list_t origins,realms;
+		init_secrets_list(&origins);
+		init_secrets_list(&realms);
+		dbd->list_origins((u08bits*)current_socket->as_eff_realm,&origins,&realms);
+
+		size_t sz = get_secrets_list_size(&origins);
+		size_t i;
+		for(i=0;i<sz;++i) {
+			str_buffer_append(sb,"<tr><td>");
+			str_buffer_append_sz(sb,i+1);
+			str_buffer_append(sb,"</td>");
+			str_buffer_append(sb,"<td>");
+			str_buffer_append(sb,get_secrets_list_elem(&origins,i));
+			str_buffer_append(sb,"</td>");
+			if(!current_socket->as_eff_realm[0]) {
+				str_buffer_append(sb,"<td>");
+				str_buffer_append(sb,get_secrets_list_elem(&realms,i));
+				str_buffer_append(sb,"</td>");
+			}
+			if(is_superuser()) {
+				str_buffer_append(sb,"<td> <a href=\"");
+				str_buffer_append(sb,form_names[AS_FORM_OS].name);
+				str_buffer_append(sb,"?");
+				str_buffer_append(sb,HR_DELETE_ORIGIN);
+				str_buffer_append(sb,"=");
+				str_buffer_append(sb,get_secrets_list_elem(&origins,i));
+				str_buffer_append(sb,"\">delete</a>");
+				str_buffer_append(sb,"</td>");
+			}
+			str_buffer_append(sb,"</tr>");
+			++ret;
+		}
+
+		clean_secrets_list(&origins);
+		clean_secrets_list(&realms);
+	}
+
+	return ret;
+}
+
+static void write_origins_page(ioa_socket_handle s, const char* add_origin, const char* add_realm, const char* msg)
+{
+	if(s && !ioa_socket_tobeclosed(s)) {
+
+		if(!(s->as_ok)) {
+			write_https_logon_page(s);
+		} else {
+
+			struct str_buffer* sb = str_buffer_new();
+
+			str_buffer_append(sb,"<!DOCTYPE html>\r\n<html>\r\n  <head>\r\n    <title>");
+			str_buffer_append(sb,admin_title);
+			str_buffer_append(sb,"</title>\r\n <style> table, th, td { border: 1px solid black; } table#msg th { color: red; background-color: white; } </style> </head>\r\n  <body>\r\n    ");
+			str_buffer_append(sb,bold_admin_title);
+			str_buffer_append(sb,"<br>\r\n");
+			str_buffer_append(sb,home_link);
+			str_buffer_append(sb,"<br>\r\n");
+
+			str_buffer_append(sb,"<form action=\"");
+			str_buffer_append(sb,form_names[AS_FORM_OS].name);
+			str_buffer_append(sb,"\" method=\"POST\">\r\n");
+			str_buffer_append(sb,"  <fieldset><legend>Filter:</legend>\r\n");
+
+			str_buffer_append(sb,"  <br>Realm name: <input type=\"text\" name=\"");
+			str_buffer_append(sb,HR_REALM);
+			str_buffer_append(sb,"\" value=\"");
+			str_buffer_append(sb,get_eff_realm());
+			str_buffer_append(sb,"\"");
+			if(!is_superuser()) {
+				str_buffer_append(sb," disabled ");
+			}
+			str_buffer_append(sb,">");
+
+			str_buffer_append(sb,"<br><input type=\"submit\" value=\"Filter\">");
+
+			str_buffer_append(sb,"</fieldset>\r\n");
+			str_buffer_append(sb,"</form>\r\n");
+
+			if(is_superuser()) {
+				str_buffer_append(sb,"<form action=\"");
+				str_buffer_append(sb,form_names[AS_FORM_OS].name);
+				str_buffer_append(sb,"\" method=\"POST\">\r\n");
+				str_buffer_append(sb,"  <fieldset><legend>Origin:</legend>\r\n");
+
+				if(msg && msg[0]) {
+					str_buffer_append(sb,"<br><table id=\"msg\"><th>");
+					str_buffer_append(sb,msg);
+					str_buffer_append(sb,"</th></table><br>");
+				}
+
+				str_buffer_append(sb,"  <br>Realm name: <input type=\"text\" name=\"");
+				str_buffer_append(sb,HR_ADD_REALM);
+				str_buffer_append(sb,"\" value=\"");
+				str_buffer_append(sb,(const char*)add_realm);
+				str_buffer_append(sb,"\"");
+				str_buffer_append(sb,"><br>\r\n");
+
+				str_buffer_append(sb,"  <br>Origin: <input type=\"text\" name=\"");
+				str_buffer_append(sb,HR_ADD_ORIGIN);
+				str_buffer_append(sb,"\" value=\"");
+				str_buffer_append(sb,(const char*)add_origin);
+				str_buffer_append(sb,"\"");
+				str_buffer_append(sb,"><br>\r\n");
+
+				str_buffer_append(sb,"<br><input type=\"submit\" value=\"Add origin\">");
+
+				str_buffer_append(sb,"</fieldset>\r\n");
+				str_buffer_append(sb,"</form>\r\n");
+			}
+
+			str_buffer_append(sb,"Origins:<br>\r\n");
+			str_buffer_append(sb,"<table>\r\n");
+			str_buffer_append(sb,"<tr><th>N</th><th>Value</th>");
+			if(!current_socket->as_eff_realm[0]) {
+				str_buffer_append(sb,"<th>Realm</th>");
+			}
+			if(is_superuser()) {
+				str_buffer_append(sb,"<th> </th>");
+			}
+			str_buffer_append(sb,"</tr>\r\n");
+
+			size_t total_sz = https_print_origins(sb);
+
+			str_buffer_append(sb,"\r\n</table>\r\n");
+
+			str_buffer_append(sb,"<br>Total origins = ");
+			str_buffer_append_sz(sb,total_sz);
+			str_buffer_append(sb,"<br>\r\n");
+
+			str_buffer_append(sb,"</body>\r\n</html>\r\n");
+
+			send_str_from_ioa_socket_tcp(s,"HTTP/1.1 200 OK\r\nServer: ");
+			send_str_from_ioa_socket_tcp(s,TURN_SOFTWARE);
+			send_str_from_ioa_socket_tcp(s,"\r\nContent-Type: text/html; charset=UTF-8\r\nContent-Length: ");
+
+			send_ulong_from_ioa_socket_tcp(s,str_buffer_get_str_len(sb));
+
+			send_str_from_ioa_socket_tcp(s,"\r\n\r\n");
+			send_str_from_ioa_socket_tcp(s,str_buffer_get_str(sb));
+
+			str_buffer_free(sb);
+		}
+	}
+}
+
 static void handle_toggle_request(ioa_socket_handle s, struct http_request* hr)
 {
 	if(s && hr) {
@@ -2732,6 +2890,9 @@ static void handle_https(ioa_socket_handle s, ioa_network_buffer_handle nbh)
 						if(!add_realm[0]) {
 							add_realm=(const u08bits*)current_socket->as_eff_realm;
 						}
+						if(!add_realm[0]) {
+							add_realm = (const u08bits*)get_realm(NULL)->options.name;
+						}
 						if(wrong_html_name((const char*)add_realm)) {
 							msg = "Error: wrong realm name";
 							add_realm = (const u08bits*)"";
@@ -2835,6 +2996,9 @@ static void handle_https(ioa_socket_handle s, ioa_network_buffer_handle nbh)
 						if(!add_realm[0]) {
 							add_realm=(const u08bits*)current_socket->as_eff_realm;
 						}
+						if(!add_realm[0]) {
+							add_realm = (const u08bits*)get_realm(NULL)->options.name;
+						}
 						if(wrong_html_name((const char*)add_realm)) {
 							msg = "Error: wrong realm name";
 							add_realm = (const u08bits*)"";
@@ -2861,6 +3025,74 @@ static void handle_https(ioa_socket_handle s, ioa_network_buffer_handle nbh)
 				}
 				break;
 			}
+			case AS_FORM_OS: {
+				if(s->as_ok) {
+					{
+						const char *realm0 = get_http_header_value(hr, HR_REALM);
+						if(!realm0)
+							realm0="";
+						if(!is_superuser())
+							realm0 = current_socket->as_realm;
+						STRCPY(current_socket->as_eff_realm,realm0);
+					}
+
+					if(is_superuser()) {
+						const u08bits *origin = (const u08bits*)get_http_header_value(hr, HR_DELETE_ORIGIN);
+						if(origin && origin[0]) {
+							const turn_dbdriver_t * dbd = get_dbdriver();
+							if (dbd && dbd->del_origin) {
+								u08bits o[STUN_MAX_ORIGIN_SIZE+1];
+								STRCPY(o,origin);
+								dbd->del_origin(o);
+								u08bits corigin[STUN_MAX_ORIGIN_SIZE+1];
+								get_canonic_origin((const char *)origin, (char *)corigin, sizeof(corigin)-1);
+								dbd->del_origin(corigin);
+							}
+						}
+					}
+
+					const u08bits *add_realm = (const u08bits*)current_socket->as_eff_realm;
+					const u08bits *add_origin = (const u08bits*)get_http_header_value(hr, HR_ADD_ORIGIN);
+					const char* msg = "";
+					if(!add_origin) add_origin = (const u08bits*)"";
+					u08bits corigin[STUN_MAX_ORIGIN_SIZE+1];
+					get_canonic_origin((const char *)add_origin, (char *)corigin, sizeof(corigin)-1);
+					if(corigin[0]) {
+						add_realm = (const u08bits*)get_http_header_value(hr, HR_ADD_REALM);
+						if(!add_realm) {
+							add_realm=(const u08bits*)"";
+						}
+						if(!is_superuser()) {
+							add_realm = (const u08bits*)current_socket->as_realm;
+						}
+						if(!add_realm[0]) {
+							add_realm=(const u08bits*)current_socket->as_eff_realm;
+						}
+						if(!add_realm[0]) {
+							add_realm = (const u08bits*)get_realm(NULL)->options.name;
+						}
+						if(add_realm[0]) {
+							const turn_dbdriver_t * dbd = get_dbdriver();
+							if (dbd && dbd->add_origin) {
+								u08bits o[STUN_MAX_ORIGIN_SIZE+1];
+								u08bits r[STUN_MAX_REALM_SIZE+1];
+								STRCPY(o,corigin);
+								STRCPY(r,add_realm);
+								(*dbd->add_origin)(o, r);
+							}
+
+							add_origin=(const u08bits*)"";
+							add_realm=(const u08bits*)"";
+						}
+					}
+
+					write_origins_page(s,(const char*)add_origin,(const char*)add_realm,msg);
+
+				} else {
+					write_https_logon_page(s);
+				}
+				break;
+			}
 			case AS_FORM_TOGGLE:
 				if(s->as_ok) {
 					handle_toggle_request(s,hr);

src/apps/relay/userdb.c

@@ -828,9 +828,9 @@ static int add_origin(u08bits *origin0, u08bits *realm)
 
 	get_canonic_origin((const char *)origin0, (char *)origin, sizeof(origin)-1);
 
-  const turn_dbdriver_t * dbd = get_dbdriver();
-  if (dbd && dbd->add_origin) {
-    (*dbd->add_origin)(origin, realm);
+	const turn_dbdriver_t * dbd = get_dbdriver();
+	if (dbd && dbd->add_origin) {
+		(*dbd->add_origin)(origin, realm);
 	}
 
 	return 0;
@@ -842,9 +842,9 @@ static int del_origin(u08bits *origin0)
 
 	get_canonic_origin((const char *)origin0, (char *)origin, sizeof(origin)-1);
 
-  const turn_dbdriver_t * dbd = get_dbdriver();
-  if (dbd && dbd->del_origin) {
-    (*dbd->del_origin)(origin);
+	const turn_dbdriver_t * dbd = get_dbdriver();
+	if (dbd && dbd->del_origin) {
+		(*dbd->del_origin)(origin);
 	}
 
 	return 0;
@@ -854,10 +854,10 @@ static int list_origins(u08bits *realm)
 {
   const turn_dbdriver_t * dbd = get_dbdriver();
   if (dbd && dbd->list_origins) {
-    (*dbd->list_origins)(realm);
-	}
+    (*dbd->list_origins)(realm,NULL,NULL);
+  }
 
-	return 0;
+  return 0;
 }
 
 static int set_realm_option_one(u08bits *realm, unsigned long value, const char* opt)
@@ -865,9 +865,9 @@ static int set_realm_option_one(u08bits *realm, unsigned long value, const char*
 	if(value == (unsigned long)-1)
 		return 0;
 
-  const turn_dbdriver_t * dbd = get_dbdriver();
-  if (dbd && dbd->set_realm_option_one) {
-    (*dbd->set_realm_option_one)(realm, value, opt);
+	const turn_dbdriver_t * dbd = get_dbdriver();
+	if (dbd && dbd->set_realm_option_one) {
+		(*dbd->set_realm_option_one)(realm, value, opt);
 	}
 
 	return 0;