DbApiHandler.cs

using System;
using System.Security.Cryptography;
using System.Text;
using System.Collections.Generic;
using System.IO;
using System.Drawing;
using System.Threading;
using System.Net.Sockets;
using System.Net;
using System.Linq;
using NDB;
using Newtonsoft.Json;
using System.Text.RegularExpressions;
using nboard;
using nbpack;
using System.Drawing.Imaging;		//make ImageFormat.Png working, to save bmp as PNG...
using fractalgen;
using captcha;						//get random captcha or solve this
namespace NServer
{
    /*
        Gives access to various DB and server functions, mainly related to reading/writing posts.
    */
    class DbApiHandler : IRequestHandler
    {
        private PostDb _db;
        private Dictionary<string, Func<string,string,HttpResponse>> _handlers;
        private Dictionary<string, Func<string,byte[],HttpResponse>> _handlers_bin;
		private bool is_lite = false;					//True, when this is request on lite-server, or false, if this is request on full-server.
        public DbApiHandler(PostDb db, bool lite = false, bool SetAllowReput = false, bool SetByPassValidation = false)
        {
            _db = db;
			_handlers = new Dictionary<string, Func<string, string, HttpResponse>>();
			_handlers_bin 	= new Dictionary<string, Func<string, byte[], HttpResponse>>();
			is_lite = lite;	allowReput = SetAllowReput;	bypassValidation = SetByPassValidation;		//set this once, for current Instance.
            if(lite == false){	//all actions allowed for full server
				// filling handlers dictionary with actions that will be called with (request address, request content) args:
				_handlers["get"] 				= 	GetPostByHash;
				_handlers["GetDbAsJSON"] 		= 	GetDbAsJSON;
				_handlers["captcha-index"] 		= 	GetCaptchaAsJsonByIndex;
				_handlers["getlastn"] 			= 	GetLastNPosts;	//from client 3.1	//get last n posts in thread, or last 3 threads in category, to show this.
				_handlers["delete"] 			= 	DeletePost;
				_handlers["add"] 				= 	AddPost;
				_handlers["download-posts"] 	= 	Download_Posts;		//download posts by url, from another nanodb server.
				_handlers["upload-posts"] 		= 	Upload_Posts; 			//upload posts to another nanodb server, like Bitmessage-retranslation.
				_handlers["upload-post"] 		= 	Upload_Post; 			//upload posts to another nanodb server, like Bitmessage-retranslation.
				_handlers["addmany"] 			= 	AddPosts;
				_handlers["readd"] 				= 	ReAddPost;
				_handlers["replies"] 			= 	GetReplies;
			
				//get posts by list with hashes.
				//posts can be parsed from responce
				//GET-query (bytesize limit): http://127.0.0.1:7346/api/getposts/f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35
				//POST-query: http://127.0.0.1:7346/api/getposts/POST/ with value "f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35"
				_handlers["getposts"] 			= 	GetPosts;		//get list of specified posts. Return array with posts in JSON.
			
				_handlers["count"]				= 	GetPostCount;
			//	_handlers["count"]				= 	GetPostCount;			//on lite-server, show number of posts, without "deleted_once"-posts.
				_handlers["nget"] 				= 	GetNthPost;
			
				//GET: http://127.0.0.1:7346/api/prange/?fromto=0-20 							- JSON response with array of posts
				//POST: http://127.0.0.1:7346/api/prange/0-20/									- array with posts
				//GET: http://127.0.0.1:7346/api/prange/?fromto=0-20&only_hashes=only_hashes	- array with hashes only.
				//POST: http://127.0.0.1:7346/api/prange/0-20/	string="only_hashes"			- array with hashes only.
				_handlers["prange"] 			= 	GetPresentRange;
			
				_handlers["pcount"] 			= 	GetPresentCount;
				_handlers["search"] 			= 	Search;
				_handlers["paramset"] 			= 	ParamSet;
				_handlers["paramget"] 			= 	ParamGet;		//get-set (if uncommented). On lite-server get only. And need to make not all params to get.
				_handlers["params"] 			= 	Params;
				_handlers["find-thread"] 		= 	FindThread;
				_handlers["threadsize"] 		= 	ThreadSize;
			
				//GET and POST parameters available. http://127.0.0.1:7346/api/getposts/POST/OnlyRAM|save_files|10 (last value - is limit for connectoins)
				_handlers["png-collect"] 		= 	PngCollect;
				_handlers["download-png"] 		= 	DownloadPNG;
			
			
				//posts from queue can be packed, using link:
				//http://127.0.0.1:7346/api/png-create/f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35
				//or using POST-query to http://127.0.0.1:7346/api/png-create/
				//with value "f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35"
				_handlers["png-create"] 		= 	PngCreate;	//create png with post from queue or not (depending from parameters).
			
				_handlers["run-nbpack"] 		= 	Run_nbpack_with_params;	//Run NBPack.cs with parameters, specified in url.
																	//URL must contains parameters, joined with comma, after EncodeURIComponent();
				_handlers["convert-to-PNG"] 	= 	ConvertToPNG;	//Upload custom picture, convert this to PNG and save in the folder default folder "download/generated" or "containers"
				_handlers["png-collect-avail"] 	= 	(a,b)=>new HttpResponse(_collectAvail ? StatusCode.Ok : StatusCode.NotFound, _collectAvail ? "Finished." : "Collect...");
				_handlers["png-create-avail"] 	= 	(a,b)=>new HttpResponse(_createAvail ? StatusCode.Ok : StatusCode.NotFound, _createAvail ? "Finished." : "Creating PNG...");
				
				_handlers["get_reports"] 		= 	GetReports;
				_handlers["delete_reports"] 	= 	DeleteReportsForPostHash;
				_handlers["undelete_post"] 		= 	UndeletePost;	//undelete post, after this was been "deleted_once" on full-server: http://127.0.0.1:7346/api/undelete_post/{POST_HASH}
				_handlers["random_captcha"] 	= 	RandomCaptcha;	//GET random captcha or solve this (POST)

				_handlers		["echo-string"]					= 	EchoString;			//return the same string, utf-8
				_handlers		["echo-binary-string"]			= 	EchoBinaryString;	//return bytes of binary string
				_handlers_bin	["echo-bytes"]					= 	EchoBytes;			//return bytes back
			}
			else if(lite == true){	//not all actions allowed for lite-server to run this by another anonymous users.

/*
				to make able anonymous to create PNG, need to enable params, paramget (places), createPNG, and pnt-create-avail.
				and also generate fractal, and make able to save this locally, using base64 dataURL, or blob-object.
				Now, this all just is not available, and maybe this will be available in future.
*/
				// filling handlers dictionary with actions that will be called with (request address, request content) args:
				_handlers["get"] 				= 	GetPostByHash;
				_handlers["GetDbAsJSON"] 		= 	GetDbAsJSON;
				_handlers["captcha-index"] 		= 	GetCaptchaAsJsonByIndex;
				_handlers["getlastn"] 			= 	GetLastNPosts;	//from client 3.1	//get last n posts in thread, or last 3 threads in category, to show this.
//				_handlers["delete"] 			= 	DeletePost;

				//Another anonymous can delete all another posts, locally, and send reports for the posts to delete this from the server, by admin.
				//This is strongly not recommended, because Article 19 of "Universal Declaration of Human Rights (UDHR)",
				//but sometimes need to delete posts, for example, after attack server by using wipe-attack by using intensive shitposting.
				//	Warning!
				//	If anyone is not happy with the perversed level of censorship with some admin,
				//	anyone can raise his own server, and talk about anything there, himself, and with his friends.
				_handlers["report"] 			= 	ReportPost;

				_handlers["add"] 				= 	AddPost;				//when bypassValidation == true, posts without captcha can be accepted on lite-server. enable allowReput to use this instead "readd"
//				_handlers["download-posts"] 	= 	Download_Posts;			//disabled for lite-server, because this posts downoloaded in database on full-server.
				_handlers["upload-posts"] 		= 	Upload_Posts; 			//This option is enabled for lite-server. Posts can be uploaded. PostDb.cs: public bool PutPost(Post p, bool allowReput = false, bool bypassValidation = false).
				_handlers["upload-post"] 		= 	Upload_Post; 			//This option is enabled for lite-server. Post can be uploaded.  PostDb.cs: public bool PutPost(Post p, bool allowReput = false, bool bypassValidation = false).
				_handlers["addmany"] 			= 	AddPosts;				//posts without captcha added only when bypassValidation == true;
//				_handlers["readd"] 				= 	ReAddPost;				//disable this on lite-server to don't allow add deleted posts, and restore the posts with wipe. Use just add, when allowReput enabled on the full-server.
				_handlers["replies"] 			= 	GetReplies;
			
				//get posts by list with hashes.
				//posts can be parsed from responce
				//GET-query (bytesize limit): http://127.0.0.1:7346/api/getposts/f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35
				//POST-query: http://127.0.0.1:7346/api/getposts/POST/ with value "f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35"
				_handlers["getposts"] 			= 	GetPosts;		//get list of specified posts. Return array with posts in JSON.
			
				_handlers["count"] 				= 	GetPostCount;
				_handlers["nget"] 				= 	GetNthPost;
			
				//GET: http://127.0.0.1:7346/api/prange/?fromto=0-20 							- JSON response with array of posts
				//POST: http://127.0.0.1:7346/api/prange/0-20/									- array with posts
				//GET: http://127.0.0.1:7346/api/prange/?fromto=0-20&only_hashes=only_hashes	- array with hashes only.
				//POST: http://127.0.0.1:7346/api/prange/0-20/	string="only_hashes"			- array with hashes only.
				_handlers["prange"] 			= 	GetPresentRange;
			
				_handlers["pcount"] 			= 	GetPresentCount;
				_handlers["search"] 			= 	Search;
//				_handlers["paramset"] 			= 	ParamSet;
				_handlers["paramget"] 			= 	ParamGet_lite;		//this can be available for lite-server, to see places and send container there.
//				_handlers["params"] 			= 	Params;				//some params can be available on lite-server, for example, params and paramget. To see places and send container there.
				_handlers["find-thread"] 		= 	FindThread;
				_handlers["threadsize"] 		= 	ThreadSize;
			
				//GET and POST parameters available. http://127.0.0.1:7346/api/getposts/POST/OnlyRAM|save_files|10 (last value - is limit for connectoins)
//				_handlers["png-collect"] 		= 	PngCollect;
				_handlers["download-png"] 		= 	DownloadPNG;
			
				//posts from queue can be packed, using link:
				//http://127.0.0.1:7346/api/png-create/f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35
				//or using POST-query to http://127.0.0.1:7346/api/png-create/
				//with value "f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35"
				_handlers["png-create"] 		= 	PngCreate;	//create png with post from queue or not (depending from parameters).	//This can be available on lite-server to create PNG, but need to make able to save this not in the server-folder, but in browser.
	
				_handlers["run-nbpack"] 		= 	Run_nbpack_with_params;	//Run NBPack.cs with parameters, specified in url.
																			//URL must contains parameters, joined with comma, after EncodeURIComponent();
				_handlers["convert-to-PNG"] 	= 	ConvertToPNG;	//Upload custom picture, convert this to PNG and save it the "download/generated/" folder.
//				_handlers["png-collect-avail"] 	= 	(a,b)=>new HttpResponse(_collectAvail ? StatusCode.Ok : StatusCode.NotFound, _collectAvail ? "Finished." : "Collect...");
				_handlers["png-create-avail"] 	= 	(a,b)=>new HttpResponse(_createAvail ? StatusCode.Ok : StatusCode.NotFound, _createAvail ? "Finished." : "Creating PNG...");
				_handlers["random_captcha"] 	= 	RandomCaptcha;	//GET random captcha or solve this (POST)

//				_handlers		["echo-string"]					= 	EchoString;			//return the same string, utf-8
//				_handlers		["echo-binary-string"]			= 	EchoBinaryString;	//return bytes of binary string encoded with iso-8859-1
//				_handlers_bin	["echo-bytes"]					= 	EchoBytes;			//return bytes back
			}
			
			Set_Timer_To_Delete_Generated_Images();
        }
        
        private static bool allowReput = false;
        private static bool bypassValidation = false;
        /*//true if need to make bypassValidation for posts in containers, while png-collect is processing.*/

		//echo string, in any encoding.
		private HttpResponse EchoString(string stringGET = null, string stringPOST = null){
			string data = param_GET_POST(stringGET, stringPOST);
			return new HttpResponse(StatusCode.Ok, data);
		}

		//echo binary string, as binary response
		private HttpResponse EchoBinaryString(string stringGET = null, string stringPOST = null){
			string data = param_GET_POST(stringGET, stringPOST);
			//Console.WriteLine("EchoBinaryString: data.Length: "+data.Length);
			
			System.Text.Encoding encoding = null;
			if(isLatin1String(data)){
				encoding = System.Text.Encoding.GetEncoding("iso-8859-1");
			}
			else{
				encoding = System.Text.Encoding.UTF8;
			}
			
			//Console.WriteLine("DbApiHandler. EchoBinaryString: data.Length: "+data.Length+", encoding: "+encoding);
			
			return new HttpResponse(StatusCode.Ok, data, MimeType.Mime("App", encoding), true, encoding);	//just return back, the binary string with bytes, in HTTP response.
			//"true", means response is binary, even if this is a string.
		}

		//echo bytes from binary request.
		private HttpResponse EchoBytes(string path = null, byte[] bytes = null){
			//Console.WriteLine("EchoBytes: bytes.Length: "+bytes.Length+", bytes: "+BitConverter.ToString(		bytes		).Replace("-", string.Empty));
			try{
				return new HttpResponse(StatusCode.Ok, bytes, MimeType.Mime("App"));	//just return binary data in HTTP response.
			}catch(Exception ex){
				Console.WriteLine(ex);
				return new HttpResponse(StatusCode.Ok, ex.Message, MimeType.Mime("Html"));	//just return binary data in HTTP response.
			}
		}
		
		//C#: check is string "iso-8859-1"-encoded or not (true/false)
		public static bool isLatin1String(string str){
			lock (_lockObj)
			{
				return	(
							Regex.Match(
									str						//for each char in str
								,	@"[^\u0000-\u00FF]"		//try to match not latin1-char, and stop
								,	RegexOptions.None
							)
							.Length							//then take Length of result
						) == 0								//and compare this to 0
				;	//true/false (non-latin character was not found or was found)
			}
		}
		// JavaScript:
		//function isLatin1String(str){return (str.match(/[^\u0000-\u00FF]/) === null);} //check is string "iso-8859-1"-encoded or not (true/false)

		/*
			This method return string with parameters, from request parameters.
			It return first or second parameter of request query (if second is available).
		*/
		private string param_GET_POST(string GET = null, string POST = null){
			lock (_lockObj){
				if( (POST == null) || (POST == "")){	//if second parameter is empty
//					return GET;								//return first parameter from GET-query, 	as string with parameters.
					return Uri.UnescapeDataString(GET);		//Try to unescape (make decodeURIComponent), if this param was been escaped by encodeURIComponent. Else return GET as is.
				}
				else{
					return POST;							//return second parameter from POST-query, 	as string with parameters.
				}
			}
		}
		
        private string SearchUp(string hash, string categoriesHash, string previousHash)
        {
            var p = _db.GetPost(hash);

            if (p == null)
            {
                return null;
            }

            if (p.replyto == categoriesHash)
            {
                return previousHash;
            }

            previousHash = p.hash;
            hash = p.replyto;
            return SearchUp(hash, categoriesHash, previousHash);
        }

        private HttpResponse FindThread(string postHash, string categoriesHash)
        {
            var prev = postHash;
            var result = SearchUp(postHash, categoriesHash, prev);
            return new HttpResponse(result == null ? StatusCode.NotFound : StatusCode.Ok, result ?? "");
        }
		
		public static Dictionary<string, string> GetParamValue(string GET_STRING){
			Dictionary<string, string> KeyValue = new Dictionary<string, string>();
			string[] parameters = GET_STRING.Split('&');
			for(var i = 0; i<parameters.Length; i++){
				//add this into dictionary
				KeyValue.Add(
						Uri.UnescapeDataString(		(parameters[i]).Split('=')[0]	)
					,	Uri.UnescapeDataString(		(parameters[i]).Split('=')[1]	)
				);
			}
			//and return dictionary.
			return KeyValue;
		}

		private HttpResponse RandomCaptcha(string GET = "", string POST = ""){
			string response = "";
			if(POST == ""){	
				response =
					@"<form action=""/api/random_captcha"" method=""post"">"+
						captcha.Captcha.AddInputsOfRandomCaptchaToSomeForm()
					+@"<button type=""submit"">Solve</button></form>"
				;
			}else{
				Console.WriteLine("POST: "+POST);
				
				Dictionary<string, string> ParamValue = GetParamValue(POST);
				string RandomCaptchaGuid		=	ParamValue["RandomCaptchaGuid"]		;
				string RandomCaptchaGuess		=	ParamValue["RandomCaptchaGuess"]	;
				
				bool result		=	captcha.Captcha.CheckAnswer(RandomCaptchaGuid, RandomCaptchaGuess);
				Console.WriteLine("result: "+result);
				response = result.ToString();
			}

			return new HttpResponse(StatusCode.Ok, response, "text/html");
		}
		
		private HttpResponse GetCaptchaAsJsonByIndex(string GET = "", string POST = ""){
			string CaptchaIndex = param_GET_POST(GET, POST);		//string with queue_and_image, joined with comma. Default value is null, and this string is empty.
			
			string response = captcha.Captcha.GetCaptchaAsJsonByIndex(CaptchaIndex);
			
			return new HttpResponse(StatusCode.Ok, response);
		}

        private HttpResponse DownloadPNG(string GET = "", string POST = "") //default queue value is null
        {
			string params_ = param_GET_POST(GET, POST);		//string with queue_and_image, joined with comma. Default value is null, and this string is empty.
			string [] p = params_.Split('|');
			var obj_Aggregator = new Aggregator(new string [] {p[0], "collect_using_RAM", "save_files", "1" /*max_connections*/});
            return new HttpResponse(StatusCode.Ok, obj_Aggregator.DownloadPNG(p, is_lite));
        }

        private bool _collectAvail = true;
        private bool _createAvail = true;

        private HttpResponse PngCollect(string GET="", string POST = "")
        {
			string parameters = param_GET_POST(GET, POST);			//			string parameters = Uri.UnescapeDataString(param_GET_POST(GET, POST));
			Console.WriteLine("\nPngCollect was been runned, wait the end of collect images...");
			Console.WriteLine("parameters: " + parameters);
			string [] _params_ = (parameters!="") ? parameters.Split('|') : new string[0];
			if(allowReput == true){_params_ = _params_.Concat(new string[] { "allowReput" }).ToArray();}if(bypassValidation == true){_params_ = _params_.Concat(new string[] { "bypassValidation" }).ToArray();}
            _collectAvail = false;
            AggregatorMain.Run(_params_);
            ThreadPool.QueueUserWorkItem(o => 
            {
                while(AggregatorMain.Running) 
                {
                    Thread.Sleep(1000);
                }

                _collectAvail = true;
            });
            return new HttpResponse(StatusCode.Ok, "");
        }

        /*
        private void ParseContainers()
        {
            NBPackMain.Main(new []{"-a", 
                "http://" 
                + Configurator.Instance.GetValue("ip", "127.0.0.1") 
                + ":"
                + Configurator.Instance.GetValue("port", "7346"),
                Configurator.Instance.GetValue("password", "nano")});
        }
        */

		//params in one string, joined with comma, after JavaScript EncodeURIComponent().
		//See NBPack.cs guide, about it.
        private HttpResponse Run_nbpack_with_params(string GET = "", string POST = "")
        {
			//Console.WriteLine("GET {0}, POST {1}", GET, POST);
			string parameters = param_GET_POST(GET, POST);			//string parameters = Uri.UnescapeDataString(param_GET_POST(GET, POST));		//string with queue_and_image, joined with comma. Default value is null, and this string is empty.
			string[] p = parameters.Split('|');
			Console.Write("Start: nbpack");
			for(int i=0; i<p.Length;i++){
				if(																					//if dataURL
							p[i].IndexOf("data:") != -1
						&& 	p[i].IndexOf("base64,")!= -1
						&&	nbpack.NBPackMain.IsBase64Encoded(p[i].Split(',')[1])
				){
					Console.Write(" {0}", p[i].Substring(0, 40) + "...");
				}else{
					Console.Write(" {0}", p[i]);
				}
			}
			Console.Write("\n");
			
			_createAvail = false;
			ThreadPool.QueueUserWorkItem(o => 
			{
				NBPackMain.Main(p);
				_createAvail = true;
			});
			
			string status;
			if(p.Length<=2)	{status = 	"Specify parameters, after encodeURIcomponent, in the end of URL.\n" + 
										"Example: http://127.0.0.1:7346/api/run-nbpack/-u%2Cdownload%2Fcontainer_PNG.png%2Cnano3%2Cdownload%2Fcontainer_posts.json";}
			else if(p[0]=="-u" && p.Length == 3){
				status = JsonConvert.SerializeObject(nbpack.NBPackMain.Unpack(p[1], p[2]));	//return posts in JSON-response.
				//e.g.: http://127.0.0.1:7346/api/run-nbpack/-u%2Cdownload%2Fcontainer_PNG.png%2Cnano3
			}
			else{status = "OK";}
			Console.WriteLine("Done.");
			return new HttpResponse(StatusCode.Ok, status);
        }
		public static string notifications_with_filename = "";
		//posts from queue can be packed, using link:
		//http://127.0.0.1:7346/api/png-create/f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35
		//or using POST-query to http://127.0.0.1:7346/api/png-create/
		//with value "f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35"
        private HttpResponse PngCreate(string GET = "", string POST = "") //default queue value is null
        {
			string queue_and_image = param_GET_POST(GET, POST);		//string with queue_and_image, joined with comma. Default value is null, and this string is empty.
            _createAvail = false;
            ThreadPool.QueueUserWorkItem(o => 
            {
                NBPackMain.Main(new []
                {"-g", 
                    (
						(is_lite == true)
						? "CreatePNG_on_lite_server"
						: (
							"http://"
                    + Configurator.Instance.GetValue("ip", "127.0.0.1")
                    + ":"
							+ Configurator.Instance.GetValue("port", "7346")
						)
					)
					,
                    Configurator.Instance.GetValue("password", Configurator.DefaultPass),
					queue_and_image	//add queue_and_image as parameter
                });
                _createAvail = true;
            });
			
			while(_createAvail!=true){
				Thread.Sleep(1000);
			}
			Thread.Sleep(5000);
			HttpResponse result = new HttpResponse(StatusCode.Ok, notifications_with_filename);//return new HttpResponse(StatusCode.Ok, "PNG successfully created.");
			notifications_with_filename = "";
			return result;
        }
		
		public static Dictionary<string, DateTime> datetime_of_generated_images = new Dictionary<string, DateTime>();
		public static System.Timers.Timer timer_to_delete;
		public static double milliseconds_to_delete_generated_images = 1800000; /*(30 minutes is maximum, to store images in "download/generated", and "download/created")*/
		private void Set_Timer_To_Delete_Generated_Images()
		{
			timer_to_delete = new System.Timers.Timer(milliseconds_to_delete_generated_images);
			timer_to_delete.Elapsed += Delete_Old_Generated_Files;
			timer_to_delete.AutoReset = false;
			timer_to_delete.Enabled = true;
		}
		private void Delete_Old_Generated_Files(Object source, System.Timers.ElapsedEventArgs e)
		{
			if(datetime_of_generated_images.Count == 0){
				timer_to_delete.Stop();
				foreach(System.IO.FileInfo file in ((System.IO.DirectoryInfo) new DirectoryInfo("download"+Path.DirectorySeparatorChar+"generated")).GetFiles()){file.Delete();}
				foreach(System.IO.FileInfo file in ((System.IO.DirectoryInfo) new DirectoryInfo("download"+Path.DirectorySeparatorChar+"created")).GetFiles()){file.Delete();}
			}
			else{
				timer_to_delete.Start();
				foreach(KeyValuePair<string, DateTime> generated_image in datetime_of_generated_images){
					TimeSpan file_stored_time = (DateTime.Now).Subtract(generated_image.Value);
					if(TimeSpan.Compare(file_stored_time, TimeSpan.FromMilliseconds( milliseconds_to_delete_generated_images )) >= 0){
						if(
							File.Exists(generated_image.Key)
						){
							( (System.IO.FileInfo) new FileInfo( generated_image.Key ) ).Delete();
							datetime_of_generated_images.Remove(generated_image.Key);
						}
					}
				}
			}
        }
		private HttpResponse generate_PNG(string query, string pathway = "")//?generate,1920,1080
		{
			//Console.WriteLine("args[0] = {0}, == \"\"", args[0], (args[0]==""));
			int width = 0; int height = 0; int bitlength = 0;
			//if pathway not specified, and if this was been request on lite-server, use "download/generated"-folder, to let them download it.
			//Else - "containers"-folder, for full-server, or using the specified pathway.
			pathway = ((pathway=="") ? ( (is_lite == true) ? "download"+Path.DirectorySeparatorChar+"generated" : "containers" ) : pathway );
			string [] splitted;
			string fractalgen_result = "";
			splitted = query.Split('|');
			string error = 	"Too many parameters.\nUse comma, as delimiter" + 
							"\"../api/convert-to-PNG/?generate_PNG,PNG_WIDTH,PNG_HEIGHT\"," + 
							"or \"../api/convert-to-PNG/generate_PNG/generate_PNG,bitlength_to_pack\"";
			if(splitted.Length>5){
				return new HttpResponse(StatusCode.BadRequest, error);
			}
			else if(splitted.Length==5 && splitted[1]=="fractalgen"){
				fractalgen_result = fractalgen.Program.Main_(new string[]{/*splitted[2],*/ pathway, splitted[3], splitted[4]});
			}
			else if(splitted.Length==4 && splitted[1]=="fractalgen"){
				fractalgen_result = fractalgen.Program.Main_(new string[]{ /*add this*/pathway, splitted[2], splitted[3]});
			}
			else if(splitted.Length==3 && splitted[1]=="fractalgen"){
				fractalgen_result = fractalgen.Program.Main_(new string[]{splitted[2]});
			}
			else if(splitted.Length==2 && splitted[1]=="fractalgen"){
				fractalgen_result = fractalgen.Program.Main_(new string[]{});
			}if(fractalgen_result != ""){if(pathway == "download"+Path.DirectorySeparatorChar+"generated"){timer_to_delete.Start();}
				string [] splitted_result = fractalgen_result.Split(new string[]{"Saved as: "}, StringSplitOptions.None); datetime_of_generated_images[splitted_result[1]] = DateTime.Now;
				fractalgen_result = fractalgen_result+"<br><a href=\"../"
									+	(splitted_result[1]).Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
									+	"\" target=\"_blank\">Open \""
									+	(splitted_result[1]).Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
									+	"\" as image</a>,<br><a href=\"../"
									+	(splitted_result[1]).Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
									+	"\" target=\"_blank\" download=\""
									+	splitted_result[1].Split(Path.DirectorySeparatorChar).Last()
									+	"\">Download "
									+	splitted_result[1].Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar).Split(Path.AltDirectorySeparatorChar).Last()
									+	" as file</a>"
				;
				return new HttpResponse(StatusCode.Ok, fractalgen_result);
			}
			else if(splitted.Length==4){
				/*pathway = ((is_lite == true) ? pathway : splitted[1]); // use default pathway for to prevent change it, and make DDoS, by send many requests, and save many files... */
				width=nbpack.NBPackMain.parse_number(splitted[2]);
				height=nbpack.NBPackMain.parse_number(splitted[3]);}
			else if(splitted.Length==3){width=nbpack.NBPackMain.parse_number(splitted[1]); height=nbpack.NBPackMain.parse_number(splitted[2]);}
			else if(splitted.Length==2){
				bitlength = nbpack.NBPackMain.parse_number(splitted[1]);
				int side = 0;
				if(bitlength!=0){
					side = (int)Math.Ceiling((decimal)Math.Sqrt(((bitlength*8)/3)+32));	//side of square, from bitlength of message to pack
					width = side; height = side;
				}
			}else{
				return new HttpResponse(StatusCode.Ok, ("Specify PNG size to generate.\nUse comma, as delimiter: \n" + 
														"../api/convert-to-PNG/generate_PNG,PNG_WIDTH,PNG_HEIGHT\"," + 
														"or ../api/convert-to-PNG/?generate_PNG,bitlength_to_pack")
				);
			}
			Console.WriteLine("Start generate PNG: width = " + width + ", heigth = " + height + ", bitlength = " + bitlength);
			
			//after width and height values are defined...
			Bitmap bmp = new Bitmap(width, height);						//bitmap
			Random rand = new Random();									//random number
			for (int y = 0; y < height; y++)							//create random pixels
			{
				for (int x = 0; x < width; x++)
				{
					//int a = rand.Next(256);							//generate random ARGB value
					int r = rand.Next(256);								//Just generate RGB
					int g = rand.Next(256);
					int b = rand.Next(256);

					//bmp.SetPixel(x, y, Color.FromArgb(a, r, g, b));	//set ARGB value
					bmp.SetPixel(x, y, Color.FromArgb(r, g, b));		//Just RGB.
				}
			}if(pathway == "download"+Path.DirectorySeparatorChar+"generated"){timer_to_delete.Start();}
			var random_guid = Guid.NewGuid().ToString(); datetime_of_generated_images[(pathway + Path.DirectorySeparatorChar + random_guid + ".png")] = DateTime.Now;
			bmp.Save( pathway + Path.DirectorySeparatorChar + random_guid + ".png", ImageFormat.Png);					//png ImageFormat
			return new
				HttpResponse(
					StatusCode.Ok,
					(
						"Random PNG generated successfully. Width = " + width + ", height = " + height + ".\n" +
						"Generated image saved to: "+(pathway + Path.DirectorySeparatorChar + random_guid + ".png")+
						"<br>"+
						"<a href=\""+
							(("../"+pathway + "/"+ random_guid + ".png").Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar))+
							"\""+
							"target=\"_blank\">"+
							"Open \""+
							(("../"+pathway + "/" + random_guid + ".png").Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar))+
							"\" as image"+
							"</a>,"+
							"<br>"+
							"<a href=\""+
							(("../"+pathway + "/"+ random_guid + ".png").Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar))+
							"\" target=\"_blank\" download=\""+
							(random_guid + ".png")+
							"\">"+
							"Download \""+
							(random_guid + ".png")
							+"\" as file."+
							"</a>"
					)
				);
		}
		
		private HttpResponse ConvertToPNG(string dataURL_GET = "", string dataURL_POST = "") //default queue value is null
        {
			//Console.WriteLine("first {0}, second {1}", dataURL_GET.Substring(0, (dataURL_GET.Length>40)?40:dataURL_GET.Length), dataURL_POST.Substring(0, (dataURL_POST.Length>40)?40:dataURL_POST.Length));
//test split string
//input string with parameters for png-create
//output - splitted and extracted values...
//			int from_last_posts = 0;
			string dataURL = "";
//			string queue = "";															//string with hashes of posts, separated with comma.
//			int from_queue = 0;

			string queue_image_params = "";
//			if(			dataURL_GET.Trim()=="" 		&& 	dataURL_POST.Trim()==""		)	{queue_image_params = "";}
//			else if(	dataURL_POST.Trim()=="" 	&& 	dataURL_GET.Trim()!=""		)	{queue_image_params = dataURL_GET;}
//			else if(	dataURL_POST.Trim()!="" 	&& 	dataURL_GET.Trim()==""		)	{queue_image_params = dataURL_POST;}
//			else if(	dataURL_POST.Trim()!="" 	&& 	dataURL_GET.Trim()!=""		)	{
//				if(			dataURL_GET.IndexOf("%2F")	!=	-1 || dataURL_GET.IndexOf("%2f") != -1	)	{queue_image_params = dataURL_GET;}
//				else if(
//							dataURL_POST.IndexOf("%2F")	!=	-1 || dataURL_POST.IndexOf("%2f") != -1 ||
//							dataURL_POST.IndexOf("\n")	!=	-1 || dataURL_POST.IndexOf("%2Fn")!=-1 	||
//							dataURL_POST.IndexOf("%2fn")!=-1
//				)																						{queue_image_params = dataURL_POST;}
//				else	{
//							//Console.WriteLine("ConvertToPNG: 1. another case...");
//				}
//			}else	{
//						//Console.WriteLine("ConvertToPNG: 2. another case...{0}");
//			}

																						//if string send using GET-query this must to be escaped.
			queue_image_params = param_GET_POST(dataURL_GET, dataURL_POST);		//			queue_image_params = Uri.UnescapeDataString(queue_image_params); 			//Unescape this. "%2F" or "%2f" replaced to "/".
			var splitted = queue_image_params.Split('|');
			string pathway = ( (is_lite == true) ? "download"+Path.DirectorySeparatorChar+"generated" : "containers" );		//if this was been request on lite-server, use "download"-folder, to let them download it. Else - "containers"-folder.
			bool exists = System.IO.Directory.Exists(pathway); if(!exists){System.IO.Directory.CreateDirectory(pathway);} if(pathway == "download"+Path.DirectorySeparatorChar+"generated"){timer_to_delete.Start();}
			for(int i=0;i<splitted.Length;i++){
				if(splitted[i]==""){continue;}						//if empty string - continue. String is empty if '\n' at last of post-content.
				if(		splitted[i].IndexOf("data:") != -1
					&& 	splitted[i].IndexOf("base64,")!= -1
					&& 	nbpack.NBPackMain.IsBase64Encoded(splitted[i].Split(',')[1])
				)	{dataURL = splitted[i];}		//if dataURL specified
				else{
				
					
					//pathway = ((is_lite) ? pathway : splitted[i]);	//just folder name, like "download/generated" or "containers"-folder.
					//Don't set it for request on lite-server, and use default predefined folder, to prevent change this and make DDoS, and StackOverFlow, by sending many requests, to save many files.
				
				}
			}

			if(queue_image_params.IndexOf("generate_PNG")!=-1){return generate_PNG((string)queue_image_params, (string)pathway);}

			if(dataURL==""){dataURL="No_dataURL_specified_for_source_image";}		//if string is null, this is empty string
			//if(queue.Trim().Length == 0){queue = "";}								//if trimmed queue value length == 0, leave this empty

			//Console.WriteLine(
			//	"from_last_posts = {0}\n"
			//	 + "dataURL = {1}\n"
			//	 + "queue = {2}\n"
			//	 + "from_queue = {3}\n"
			//	,
			//	from_last_posts
			//	,dataURL.Substring(0, (	(dataURL.Length>40) ?40: dataURL.Length )	)
			//	,queue
			//	,from_queue
			//);
			
			if(
					dataURL.IndexOf("data:") != -1
				&& dataURL.IndexOf("base64,") != -1
				&& nbpack.NBPackMain.IsBase64Encoded(dataURL.Split(',')[1])
			){
				Console.WriteLine("Custom image uploaded and dataURL found.");
				//create bitmap from dataURL, and save this as PNG-file to Upload folder.
				var base64Data = Regex.Match(dataURL, @"data:image/(?<type>.+?),(?<data>.+)").Groups["data"].Value;
				var binData = Convert.FromBase64String(base64Data);

				string random_guid = Guid.NewGuid().ToString();
				using (var stream = new MemoryStream(binData))
				{
					Image bmp = new Bitmap(stream);
					bmp.Save(pathway + Path.DirectorySeparatorChar + random_guid + ".png", ImageFormat.Png);
					Console.WriteLine("Saved to \""+(pathway + Path.DirectorySeparatorChar + random_guid + ".png")+"\"");
					bmp.Dispose();
				}datetime_of_generated_images[(pathway + Path.DirectorySeparatorChar + random_guid + ".png")] = DateTime.Now;
				return new HttpResponse(
						StatusCode.Ok
						,
						(
							"Saved to: \""+(pathway + Path.DirectorySeparatorChar + random_guid + ".png")
							+"\", <br>"
							+"<a href=\""+("../" + pathway + "/" + random_guid + ".png").Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
							+"\" target=\"_blank\">"+	"Open \""+("../" + pathway + "/" + random_guid + ".png").Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
							+"\" as image"+	"</a>, <br>"
							+	"<a href=\""+("../" + pathway + "/" + random_guid + ".png").Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
							+"\" target=\"_blank\" download=\""+(random_guid + ".png")+"\">"+	"Download \""+(random_guid + ".png")+"\" as file."+	"</a>"
						)
					)
				;
			}
			else{
				Console.WriteLine("DataURL not found. dataURL = {0}", dataURL.Substring(0, (dataURL.Length>40)?40:dataURL.Length));
				return new HttpResponse(StatusCode.Ok, ("dataURL: " + dataURL + "\n\nAfter encodeURIComponent(dataURL), you can send this HERE \nas GET parameter or POST (for big images);"));
			}
        }

        // example: prange/90-10 - gets not deleted posts from 91 to 100 (skip 90, take 10)
        private HttpResponse GetPresentRange(string GET = null, string POST = null)
		{
//			Console.WriteLine("DbApiHandler.cs. GetPresentRange. \n\n\n\n\n ");
			string arguments = param_GET_POST(GET, POST);	//get string with arguments
			
			string[] splitted = arguments.Split('-');		//split this string by "-" and put arguments to array.
			
			//define default values:
			int skip = 0;				//skip posts
			int count = 0;				//number posts to get this
			string only_hashes = null;	//can contains two values, if need to return hashes
			bool append_text = false;	//append text "post_was_deleted", //and "post_is_reported" to base64 of post message or not? (false by default)
			bool show_deleted = false;	//is need to show deleted posts? (false by default)
			
			NDB.Post[] posts;			//result if need to return 	array with posts 		Post[]
			string[] posts_hashes;		//result if "only_hashes" 	array with strings		string[]
			
			if(splitted.Length < 2){	//if lesser than 2 arguments specified
				return new HttpResponse(StatusCode.BadRequest, "DbApiHandler.cs. GetPresentRange. Invalid number of arguments. splitted.Length: "+splitted.Length); //return error.
			}//else, continue...
			
			//parse numbers from strings
			skip = nbpack.NBPackMain.parse_number(splitted[0]);						//skip
			count = nbpack.NBPackMain.parse_number(splitted[1]);					//count
			
			if(splitted.Length == 2){	//if only 2 arguments specified
				posts = _db.RangePresent(skip, count, append_text, show_deleted);		//get array with posts by running method from PostDb.cs, with default arguments.
				return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(posts));	//and return this as JSON.
			}//else, continue...
			if(splitted.Contains("append_text")){	//if need to append text, and this string found in argumets
				append_text = true;						//set it to true.
			}
			if(splitted.Contains("show_deleted")){	//if need to show deleted posts, and this string found in aruments
				show_deleted = true;					//set it to true
			}
			if(splitted.Contains("only_hashes")){	//if need to return only hashes of the posts, and this string found in arguments.
				only_hashes = "only_hashes";		//set this value in this string
				posts_hashes = _db.RangePresent_string(skip, count, only_hashes, show_deleted);			//run another method from NBPack.cs, with defined earlier arguments
				return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(posts_hashes));		//and return hashes of the posts, as JSON.
			}
			else if(splitted.Contains("hashes_with_bytelength")){	//if need to append bytelength to hashes, and this string was found in arguments
				only_hashes = "hashes_with_bytelength";			//set this value in this string
				posts_hashes = _db.RangePresent_string(skip, count, only_hashes, show_deleted);			//run another method from NBPack.cs, with defined earlier arguments
				return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(posts_hashes));		//and return the hashes with bytelength, as JSON.
			}else{																						//else, if no need to return hashes.
				posts = _db.RangePresent(skip, count, append_text, show_deleted);						//get the array with posts with defined earlier artuments.
				//Console.WriteLine("posts.Length"+posts.Length);
				string response = "";
				try{
					response = JsonConvert.SerializeObject(posts);	//hm... 1681 posts not return in browser... 1680 posts - return good, as text... No any catch.
					//Console.WriteLine("response.Length: "+response.Length+", response.Substring(response.Length-100): "+response.Substring(response.Length-100));
					return new HttpResponse(StatusCode.Ok, response);				//and return result as JSON.		Warning... 1681 posts not returned good in JSON...
				}catch (Exception ex){
					return new HttpResponse(StatusCode.BadRequest, ex.ToString());				//return Exception 
				}
			}
		}

		//download all posts as readable json-file, with Formatting.Indented: http://127.0.0.1:7346/api/GetDbAsJSON
		private HttpResponse GetDbAsJSON(string GET = null, string POST = null){
		try{
			int total_posts = _db.GetPresentCount();								//Get number of posts in DataBase
			NDB.Post[] posts = _db.RangePresent(0, total_posts, false, false);		//get array with posts by running method from PostDb.cs, with default arguments.
			foreach(NDB.Post post in posts){										//for each post
					post.message = post.message.FromB64();		//See /DataBase/PostValidator.cs. Decode post.message from Base64 or leave this as is, and escape json special characters.
			}

			//This file can be uploaded in database, by using '\pages\Upload_posts_from_JSON_file.html'
			File.WriteAllText(@"download\All_Posts_in_DataBase.json", JsonConvert.SerializeObject(posts, Formatting.Indented));	//write serialized JSON in file.
			return new HttpResponse(StatusCode.Ok, 	""
													+	"File \"All_Posts_in_DataBase.json\" was been updated sussessfully!<br>"
													+	"<a href=\"../../download/All_Posts_in_DataBase.json\""
													+	"download=\"All_Posts_in_DataBase.json\""
													+	"title=\"This file can be uploaded in database by using \'\\pages\\Upload_posts_from_JSON_file.html\'\">"
													+	"Download \"All_Posts_in_DataBase.json\"!"
													+	"</a>"
													,
													MimeType.Mime("Html")
			);	//and return the link to download it.
		}
		catch(Exception ex){
			Console.WriteLine(ex);
			return new ErrorHandler(StatusCode.NotFound, ex.Message).Handle(null);
		}
		}

		private HttpResponse ParamGet(string addr = null, string content = null)
		{
			if((content == null || content == "") && addr.IndexOf('?')!=-1){
				string[] splitted 	= addr.Split('?');
				addr 				= splitted[0];
				content 			= Uri.UnescapeDataString(splitted[1]);
			}
            return new HttpResponse(StatusCode.Ok, Configurator.Instance.GetValue(addr, content));	//get param or set default.
        }
		
		/*
			get only allowed params for lite-server.
		*/
        private HttpResponse ParamGet_lite(string GET = null, string POST = null)
        {
			var param = param_GET_POST(GET, POST);
				//	parameters, disabled to show on lite-server:
			string[] unallowed_params = new string []	{
														"places",				//places - temporary disabled, and can be available, after PNG-collect working on lite-server.
														"captcha_pack_file",
														"Proxy_List",
														"Services_Returns_External_IP",
														"ip",
														"port",
														"password",
														"no_tcp_delay",
														"check_version_update",
														"show_timestamps",
														"instant_retranslation",
														"detect_URLs",
														"show_deleted",
														"post_offset_in_tree_px",
														"post_delete_timeout",
														"use_spam_filter",
														"spam_filter",
														"remind_if_updates_exists",
														"post_count_notification_time",
														"check_updates_every_hours",
														"Download_Timeout_Sec",
														"last_update",
														"original_captcha_sha256",
														"last_another_repo_version",
														"captcha_url",
														"collect_memory_limit_to_wait",
												}
			;
            if (!Configurator.Instance.HasValue(param) || unallowed_params.Contains(param))
            {
                return new ErrorHandler(StatusCode.NotFound, "No such param.").Handle(null);
            }
            return new HttpResponse(StatusCode.Ok, Configurator.Instance.GetValue(param, ""));			//get param only, because this paramget API-call on public lite-server is opened for anonymous.
        }

        // returns available params in a JSON array
        private HttpResponse Params(string addr, string content)
        {
            var @params = Configurator.Instance.GetParams();
            return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(@params));
        }

        private HttpResponse ParamSet(string addr, string content)
        {
			if(content == null && addr.IndexOf('?')!=-1){	//if second parameter from POST-query not defined, try parse first parameter from GET-query
				string[] splitted 	= addr.Split('?');
				addr 				= splitted[0];
				content 			= Uri.UnescapeDataString(splitted[1]);
			}

//			Console.WriteLine("DbApiHandler.cs. ParamSet. addr: "+addr+", content: "+content);	//show two parameters
			
			if(addr!=null && content!=null){
				Configurator.Instance.SetValue(addr, content);
				return new HttpResponse(StatusCode.Ok, "Ok");
			}
			else{
				return new HttpResponse(StatusCode.BadRequest, "DbApiHandler.cs. ParamSet. Invalid request. Value cann't be null: param:"+addr+", value:"+content);
			}
        }

        private HttpResponse GetPostByHash(string GET = null, string POST = null)
        {
			string arguments = param_GET_POST(GET, POST);
			string[] splitted = arguments.Split('-');
			string hash = splitted[0];
			bool appendText = ((splitted.Length == 2)? bool.Parse(splitted[1]) : false);

            var post = _db.GetPost(hash, appendText);

            if (post == null)
            {
                return new ErrorHandler(StatusCode.NotFound, "No such post.").Handle(null);
            }

            return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(post));
        }

        private HttpResponse GetLastNPosts(string GET = null, string POST = null)	//from client 3.1
        {
			string arguments 	= param_GET_POST(GET, POST);
			string[] splitted 	= arguments.Split('-');
			string hash 		= splitted[0];
			string n 			= splitted[1];
			bool appendText 	= ((splitted.Length >= 3)? bool.Parse(splitted[2]) : false);
			bool fast 			= ((splitted.Length >= 4)? bool.Parse(splitted[3]) : false);

//			Console.WriteLine("GetLastNPosts. hash: "+hash+", n: "+n+", appendText: "+appendText+", fast: "+fast);
            List<NDB.Post> posts;
            try
            {
                posts = _db.GetLastNAnswers(hash, nbpack.NBPackMain.parse_number(n), appendText, fast);	//now ok.
            }
            catch(Exception e)
            {
                return new ErrorHandler(StatusCode.BadRequest, e.Message).Handle(null);
            }

            if (posts == null)
            {
                return new ErrorHandler(StatusCode.NotFound, "No such post.").Handle(null);
            }

            return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(posts));
        }

        // includes deleted
        private HttpResponse GetNthPost(string n, string notUsed = null)
        {
            //var post = _db.GetNthPost(int.Parse(n));
            var post = _db.GetNthPost(nbpack.NBPackMain.parse_number(n));

            if (post == null)
            {
                return new ErrorHandler(StatusCode.NotFound, "No such post.").Handle(null);
            }

            return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(post));
        }

        // returns count of all posts including deleted
        private HttpResponse GetPostCount(string notUsed1, string notUsed = null)
        {
            return new HttpResponse(StatusCode.Ok, _db.GetPostCount().ToString());
        }

        // returns recursive replies count for specified post
        private HttpResponse ThreadSize(string hash, string notUsed = null)
        {
            return new HttpResponse(StatusCode.Ok, _db.GetThreadSize(hash).ToString());
        }

        // returns count of not deleted posts
        private HttpResponse GetPresentCount(string notUsed1, string notUsed = null)
        {
            return new HttpResponse(StatusCode.Ok, _db.GetPresentCount().ToString());
        }

        // returns array of posts with messages including searchString, search avoids [img=..] tag contents.
        private HttpResponse Search(string GET = null, string POST = null)	//notUsed contains base64 encoded searchString, when POST-query sent.
        {
			try{
				string searchString = param_GET_POST(GET, POST);

				string [] splitted = searchString.Split('|');
				searchString = splitted[0].FromB64();
				Console.WriteLine("searchString: \""+searchString+"\"");
				var found = new List<NDB.Post>();
				
				int limit = 500;
//				Console.WriteLine("DbApiHandler.cs. Search. int limit: "+limit);	//maybe this change limit in MaxConsecZeros

				if(splitted.Length==2){
					limit = nbpack.NBPackMain.parse_number(splitted[1]);
				}
				
				for (int i = _db.GetPostCount() - 1; i >= 0; i--)
				{
					var post = _db.GetNthPost(i);
					
					if (post == null){
						continue;
					}

					var msg 	= (						//maybe this need to delete
									(post.message.StartsWith("post_was_deleted"))// || post.message.StartsWith("post_is_reported"))
										? post.message.Substring(16)
										: post.message
								)
								.FromB64();
					
					if (msg.Contains("[img="))
					{
						//msg = Regex.Replace(msg, "\\[img=[A-Za-z0-9+=/]{4,64512}\\]", "");
						msg = Regex.Replace(msg, "\\[img=[A-Za-z0-9+=/]{4,}\\]", "");			//remove limit, because pictures from Karasiq nanoboard can be larger.
					}
					
					//if (msg.Contains(searchString))
					if (msg.IndexOf(searchString, StringComparison.CurrentCultureIgnoreCase)!=-1)
					{
						found.Add(post);
						
						if (found.Count >= limit) break;
					}
				}
				
				return new HttpResponse(StatusCode.Ok, found.Count == 0 ? "[]" : JsonConvert.SerializeObject(found.ToArray()));
			}	
			catch (Exception ex){
				Console.WriteLine(ex);
				return new HttpResponse(StatusCode.BadRequest, "[]");
			}	
        }

        private HttpResponse GetReplies(string GET = null, string POST = null)
        {
			string arguments = param_GET_POST(GET, POST);
			string[] splitted = arguments.Split('-');
			string hash = splitted[0];
			bool appendText = ((splitted.Length == 2) ? bool.Parse(splitted[1]) : false);
            var replies = _db.GetReplies(hash, appendText);
            return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(replies));
        }

		//GET-query: http://127.0.0.1:7346/api/getposts/f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35
		//or POST-query to http://127.0.0.1:7346/api/getposts/POST/
		//with value "f682830a470200d738d32c69e6c2b8a4,cd94a3d60f2f521806abebcd3dc3f549,bdd4b5fc1b3a933367bc6830fef72a35"
		//return JSON-array with posts, corresponding this hashes.
        private HttpResponse GetPosts(string GET = "", string POST = "")						//GET-query or POST query
        {
			try{
				string hashes = param_GET_POST(GET, POST);		//string with hashes, joined with comma. Default value is null, and this string is empty.
//				Console.WriteLine("DbApiHandler.cs: GetPosts. hashes: "+hashes);
				var posts = _db.GetPosts(hashes); //get array with posts, by hash-list in the string.
				return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(posts));
			}
			catch (Exception e){
				Console.WriteLine(e);
				return new HttpResponse(StatusCode.BadRequest, "DbApiHandler.cs. GetPosts. Something is wrong: "+e);
			}
        }

        private HttpResponse AddPost(string replyTo, string content)
        {
            var post = new NDB.Post(replyTo, content);
            var added = _db.PutPost(post, allowReput, bypassValidation);

            if (!added)
            {
                return new ErrorHandler(StatusCode.BadRequest, "Can't add post, probably already exists").Handle(null);
            }

            return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(post));
        }

		//Download posts from another nanodb api, by URL for fast syncronization.
        private HttpResponse Download_Posts(string GET = null, string POST = null)						//GET-query or POST query
        {
			string url = param_GET_POST(GET, POST);			//string with hashes, joined with comma. Default value is null, and this string is empty.
			//Console.WriteLine("url {0}", url);
			
            var status = _db.DownloadPosts(url, allowReput, bypassValidation); //download posts by URL
			
            if (!status)
            {
                return new ErrorHandler(StatusCode.BadRequest, "Can't download posts from url.").Handle(null);
            }
            return new HttpResponse(StatusCode.Ok, "Posts downloaded without any proxy: "+JsonConvert.SerializeObject(status));
        }

		//accept posts in JSON from anywhere, and add this to DataBase, after validation.
        private HttpResponse Upload_Posts(string GET = null, string POST = null) //GET-query or POST query
        {
			//for GET-query, need to use encodeURIComponent (Warning! There is limited data-size!)
			//		GET method, you are limited to a maximum of 2,048 characters, minus the number of characters in the actual path
			//		However, the POST method is not limited by the size of the URL for submitting name and value pairs.
			//for POST-query can be sent clear JSON
			//	https://docs.microsoft.com/en-us/dotnet/api/system.web.configuration.httpruntimesection.maxrequestlength?view=netframework-4.8
			//	The maximum request size in kilobytes. The default size is 4096 KB (4 MB).
			
//			string JSON = null;		//string with hashes, joined with comma. Default value is null, and this string is empty.
//			if(POST==""){									//if string with second value is empty
//				JSON = Uri.UnescapeDataString(GET);			//then get hashes from get query
//			}else{											//else, if contens was been send, using POST-query
//				JSON = POST;								//get hashes from second parameter, without decodeURIComponent()
//			}
			string JSON = param_GET_POST(GET, POST);
		//	Console.WriteLine("JSON: "+JSON.Substring(0, 100));
		//	Console.WriteLine("DbApiHandler.cs. Upload_Posts. Accepted JSON: ");
		//	Console.WriteLine("first: "+JSON.Substring(0, ((JSON.Length >= 100) ? 100 : JSON.Length)));
		//	Console.WriteLine("last: "+JSON.Substring( (JSON.Length>100) ? JSON.Length-100 : 0 ));
			if(JSON.StartsWith("posts_uploading_large_data: [")){
		//		Console.WriteLine("JSON.StartsWith(\"posts_uploading_large_data: [\"): "+JSON.StartsWith("posts_uploading_large_data: ["));
				string json = JSON.Split(new string[] { "posts_uploading_large_data: " }, StringSplitOptions.None)[1];
				string[] object_arr = Newtonsoft.Json.JsonConvert.DeserializeObject<string[]>(json);
				string result = "DbApiHandler.cs. Upload_Posts. Accepted: "+object_arr[0]+" posts. Added in DataBase: "+object_arr[1]+" posts.";
                Console.WriteLine(result);
				return new HttpResponse(StatusCode.Ok, result);
			}
			int[] status = _db.UploadPosts(JSON, allowReput, bypassValidation); //download posts by URL
			Console.WriteLine(
				"DbApiHandler.cs. UploadPosts. "+JsonConvert.SerializeObject(status[0])+" posts was been accepted, "+
				JsonConvert.SerializeObject(status[1])+" added in DataBase."
			);
            return new HttpResponse(
				StatusCode.Ok,
				JsonConvert.SerializeObject(status[0])+" posts was been accepted, "+
				JsonConvert.SerializeObject(status[1])+" added in DataBase."
			);
        }

		//accept posts in JSON from anywhere, and add this to DataBase, after validation.
        private HttpResponse Upload_Post(string GET = null, string POST = null) //GET-query or POST query
        {
			try{
				//for GET-query, need to use encodeURIComponent (Warning! There is limited data-size!)
				//for POST-query can be sent clear JSON.
//				string JSON = null;		//string with hashes, joined with comma. Default value is null, and this string is empty.
//				if(POST=="" || POST == null){					//if string with second value is empty
//					JSON = Uri.UnescapeDataString(GET);			//then get hashes from get query
//				}else{											//else, if contens was been send, using POST-query
//					JSON = POST;			//get hashes from second parameter
//				}
				string JSON = param_GET_POST(GET, POST);			//	Console.WriteLine("JSON: "+JSON.Substring(0, 100));
				bool status = _db.UploadPost(JSON, allowReput, bypassValidation); //download posts by URL
				return new HttpResponse(StatusCode.Ok, "Try to uploading post: "+JSON+"...\n"+status+((!status)?"\nMaybe this post already exist here.":""));
			}catch(Exception ex){
				Console.WriteLine(ex);
				return new HttpResponse(StatusCode.Ok, ex.ToString());
			}
        }
		
        private HttpResponse AddPosts(string none, string content)
        {
            try
            {
                var posts = JsonConvert.DeserializeObject<NDB.Post[]>(content);
                foreach (var p in posts)
                    _db.PutPost(p, allowReput, bypassValidation);
            }
            catch
            {
                return new HttpResponse(StatusCode.InternalServerError, "Error");
            }
            return new HttpResponse(StatusCode.Ok, "Ok");
        }

        // same as add but allows for putting deleted post back
        private HttpResponse ReAddPost(string replyTo, string content)
        {
            var post = new NDB.Post(replyTo, content);
            var added = _db.PutPost(post, true, bypassValidation);

            if (!added)
            {
                return new ErrorHandler(StatusCode.BadRequest, "Can't add post, probably already exists").Handle(null);
            }

            return new HttpResponse(StatusCode.Ok, JsonConvert.SerializeObject(post));
        }

        private static readonly object _lockObj = new object();

		//Delete post "delete_once", or "delete_forever", if post was already "deleted_once".
        private HttpResponse DeletePost(string hash, string notUsed = null)
        {
            int deleted = 0;
        
            lock (_lockObj)
            {
                for (int i = 0; i < 999; i++)
                {
                    try
                    {
                        deleted = _db.DeletePost(hash);
                        i = 1000;
                        break;
                    }
                    catch
                    {
                        Thread.Sleep(i*15);
                    }
                }
            }
			if 			( deleted == 0 )	{
                return new ErrorHandler(StatusCode.BadRequest, "No such post.").Handle(null);
            }else if	( deleted == 1 )	{
			    return new HttpResponse(StatusCode.Ok, "Post "+hash+" was been deleted once.");
            }else if	( deleted == 2 )	{
			    return new HttpResponse(StatusCode.Ok, "Post "+hash+" was been deleted forever.");
            }
			return new HttpResponse(StatusCode.Ok, "Post "+hash+" just deleted.");
        }

		//Add reason of report the post with specified hash.
        private HttpResponse ReportPost(string GET = null, string POST = null)
        {
		
//			Console.WriteLine("GET: "+GET+" POST: "+POST+" URI: "+Uri.UnescapeDataString(GET));
			string hash_reason = null;
			string hash = null;
			string reason = null;
			
			try{
//				if( POST == null ){
//					hash_reason = Uri.UnescapeDataString(GET);
//				}else{
				hash_reason = param_GET_POST(GET, POST);	//					hash_reason = Uri.UnescapeDataString(POST);
//				}
			}catch(Exception ex){
				return new ErrorHandler(StatusCode.BadRequest, "Error report value: "+ex).Handle(null);
			}
			
			//Console.WriteLine("hash_reason: "+hash_reason);
			
			string [] splitted = hash_reason.Split(new string[]{ "|" }, 2, StringSplitOptions.None);
			hash = splitted[0];
			if(hash.Length>=2){
				if(
					splitted[1].Length > 64
				){
					Console.WriteLine(
						"Too long report-text. Maximum is 64 symbols. ("+splitted[1].Length+"> 64): "+
						", report-text, after substring: "+(splitted[1]).Substring(0, 64)
					);
				}
				reason = (splitted[1].Length > 64) ? (splitted[1]).Substring(0, 64) : (splitted[1]);	//limit reason string length = 64 symbols max.
			}else{
				reason = "DbApiHandler.cs. ReportPost. undefined report reason.";
			}

			//Console.WriteLine("hash: "+hash+" reason: "+reason);

            int reported = 0;
        
            lock (_lockObj)
            {
                for (int i = 0; i < 999; i++)
                {
                    try
                    {
                        reported = _db.ReportPost(hash, reason);
                        i = 1000;
                        break;
                    }
                    catch
                    {
                        Thread.Sleep(i*15);
                    }
                }
            }
			if 			( reported == 0 )	{
                return new ErrorHandler(StatusCode.BadRequest, "No such post.").Handle(null);
            }else if	( reported == 1 )	{
			    return new HttpResponse(StatusCode.Ok, "Post "+hash+" was been reported. Reason: "+reason);
            }else{
				return new HttpResponse(StatusCode.Ok, "Post "+hash+" just reported.");
			}
        }

        // returns hashes of posts with reports
        private HttpResponse GetReports(string notUsed1, string notUsed = null)
        {
            return new HttpResponse(StatusCode.Ok, _db.GetReports().ToString());
        }
		
		//Delete reports for post with hash
        private HttpResponse DeleteReportsForPostHash(string hash, string notUsed = null)
        {
			bool reports_deleted = _db.DeleteReportsForPostHash(hash);
			return new HttpResponse(
				(reports_deleted == true)
					? StatusCode.Ok
					: StatusCode.BadRequest
				,
				"Delete reports for post with "+hash+":"+reports_deleted
			);
        }
		
		//Undelete "deleted_once"-post
        private HttpResponse UndeletePost(string hash, string notUsed = null)
        {
//			Console.WriteLine("DbApiHandler.cs. UndeletePost. Try to undelete post...");
			bool post_undeleted = _db.UndeletePost(hash);
			return new HttpResponse(
				(post_undeleted == true)
					? StatusCode.Ok
					: StatusCode.BadRequest
				,
				"Undelete post with "+hash+": "+post_undeleted
			);
        }
		
		public string BytesToHex(byte[] data){return BitConverter.ToString(data).Replace("-", string.Empty);}
		
		private void GetCmdArg(
				string RequestAddress
			,	ref string cmd
			,	ref string arg
			,	ref string handler_
		){
                string[] splitted = RequestAddress.Split(new char[]{'/'}, StringSplitOptions.RemoveEmptyEntries);
				handler_	=	splitted.Length < 1	? "" : splitted[0];
                cmd			=	splitted.Length < 2 ? "" : splitted[1];
                arg			=	splitted.Length < 3 ? "" : splitted[2];
		}
		
		//Handle API-request, and return HttpResponse.
        public HttpResponse Handle(HttpRequest request)
        {
            try
            {
				string cmd = ""; string arg = ""; string handler_ = ""; GetCmdArg(request.Address, ref cmd, ref arg, ref handler_);
				if(cmd.Contains("secure-DHKE")){
					return DHKE(request);	//first request with B, to compute the keys for encryption/decryption
				}
				else if(cmd.Contains("secure-")){				//if encrypted request
					return DHAESSecureHandler(request);			//decrypt this, and return response.
				}

				if(											//if
						_handlers.ContainsKey(cmd)			//handler contains in _handlers Dictionary
				//	&&	request.isBinary == false			//and if it's not binary-request
					//this was been commented, because binary requests can be accepted by handlers, as iso-8859-1 string, too.
				){
					return _handlers[cmd](arg, request.Content); //send request to handler, and return response.
					//for binary-request, send request to "handler" with "iso-8859-1"-encoded string, and return response.
                }

				else if (									//else if 
						_handlers_bin.ContainsKey(cmd)		//and if handler contains in binary handlers
				)
                {
					if(														//if
							request.Content_bytes == null					//but content not found
						||	(												//or
								(request.Content_bytes != null)					//if it's found
							&&	(request.Content_bytes.Length == 0)				//but empty
						)
						&&	request.Content.Length != 0								//and if text found
					){
					//	Console.WriteLine("request.Content"+request.Content);									//it seems, like "iso-8859-1"-text sent, as string.
						byte[] request_bytes = MimeType.DefaultBinaryEncoding.GetBytes(request.Content);		//decode this to bytes, using reversive latin1 encoding.
						return _handlers_bin[cmd](arg, request_bytes); //and send bytes to binary-handler, and return the binary response
					}
					else{ //else if it's was been bytes (Content-Type: application/octet-stream), and request.isBinary == true
						return _handlers_bin[cmd](arg, request.Content_bytes); //send bytes to binary-handler, and return response
					}
                }
				//else if "_handlers" or "_handlers_bin" dictionaries not contains handler "cmd" - return an error:
				return new ErrorHandler(StatusCode.BadRequest, "No such command: " + cmd + ". Available commands: " + JsonConvert.SerializeObject(_handlers.Keys.ToArray())).Handle(request);
            }
            catch (Exception e)
            {
                return new ErrorHandler(StatusCode.InternalServerError, e.Message).Handle(request);	//or return an exception-message
            }
        }

		//		Add supporting of "secure-"-handler, to accept encrypted requests, and return encrypted responses


		//List of handlers, that accept Latin1-strings, not UTF-8 strings.
		//Latin1 encoding allow to encode each byte as 1 char, and transfer bytearrays to strings-handlers, as strings.
		private List<string> Latin1Handlers = new List<string>{
			"echo-binary-string"
		};


		//Guid.NewGuid().ToString() -> {Key, IV, Key2, IV2}
		private static Dictionary<string, string> CashedClientsKeys = new Dictionary<string, string>();
		private static Dictionary<string, long> TimeOfAddingKeys = new Dictionary<string, long>();
		
		public static long GetGMTInMS(DateTime timestamp)
        {
            var unixTime = timestamp.ToUniversalTime() -
                new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

            return (long)unixTime.TotalMilliseconds;
        }
		
		public static void ClearKeysIfNeed(long unixTimestampNow){
			//If too many keys - clear old guids
			int MaxItemsInDictionaryToClearThis = 1000;	//items in dictionary to try clean this
			if(TimeOfAddingKeys.Count > MaxItemsInDictionaryToClearThis){
				List<string> OldItemsToRemove = new List<string>();	//need to create a separate list because keypair can not be removed in foreach cycle.

				foreach (KeyValuePair<string, long> GuidAndTimestamp in TimeOfAddingKeys) {
					int timeout = 300;	//seconds for each guid
					if(unixTimestampNow - GuidAndTimestamp.Value > timeout * 1000){
						OldItemsToRemove.Add(GuidAndTimestamp.Key);
					}
				}

				foreach (string OldItemToRemove in OldItemsToRemove)
				{
					TimeOfAddingKeys				.Remove(OldItemToRemove);
					CashedClientsKeys				.Remove(OldItemToRemove);
				}
				OldItemsToRemove.Clear();	//remove all guids from list.
			}
			//else leave this in memory.
		}
		
		

		private static System.Text.Encoding BinaryEncoding = System.Text.Encoding.GetEncoding("iso-8859-1");	//need to encode keys {Key, IV, Key2, IV2}, as strings.
		
		private string[] ComputeAESKeysAndIVs(
				byte[] Bytes_B	//64 bytes of B, appended at beginning of first encrypted request
			,	string oldDHGuid = null	//optional - oldDHGuid
		){
			//For first request, from B (64 bytes),
			//	compute K from B,
			//	compute {Key, IV, Key2, IV2} from K,
			//	generate random DHGuid,
			//	cache {Key, IV, Key2, IV2} in dictionary by this DHGuid,
			//	and return DHGuid.

			BigInteger K = (
								(new BigInteger(Bytes_B))								//Get B as BigInteger, from bytes
								.modPow(
										(new BigInteger(DH_BigInteger.DHPriv["a"], 10))	//get a as BigInteger, from decimal string
									,	(new BigInteger(DH_BigInteger.DHPriv["p"], 10))	//get p as BigInteger, from decimal string
								)	//compute K = B^a mod p = g^ba mod p = g^ab mod p
							)
			;
			byte[]	Bytes_K = K.getBytes();		//get 64 bytes (512 bits) of "K"-value.

			byte[]	Key		=	new	byte[ 32 ];		//define Key	to encrypt-decrypt request
			byte[]	IV		=	new	byte[ 16 ];		//define IV		to encrypt-decrypt request

			byte[]	Key2	=	new	byte[ 32 ];		//define Key2	to encrypt-decrypt response
			byte[]	IV2		=	new	byte[ 16 ];		//define IV2	to encrypt-decrypt response

			//BytesK -> 64 bytes -> (rest, 16 bytes, 128 bits ) + (IV, 16 bytes, 128 bits) + (Key, 16 bytes, 128 bits)
			int begin = (Bytes_K.Length - (IV.Length + Key.Length));	//first 16 bytes
			//get IV
			Buffer.BlockCopy(				//copy bytes
					Bytes_K					//from BytesK
				,	begin					//from begin-offset
				,	IV						//into IV
				,	0						//into 0 offset of IV
				,	IV.Length				//and copy IV.Length bytes from BytesK to IV
			);
			//get Key
			Buffer.BlockCopy(				//copy bytes
					Bytes_K					//from BytesK
				,	begin+IV.Length			//into (begin+IV.Length) offset
				,	Key						//into Key
				,	0						//into 0 offset of Key
				,	Key.Length				//and copy Key.Length bytes from Bytes to Key
			);

			//BytesK -> 64 bytes -> (rest, 16 bytes, 128 bits ) + (IV, 16 bytes, 128 bits) + (Key, 16 bytes, 128 bits)
			byte[][] ResponseKeys = AESEncryptDecrypt.AESEncryptDecrypt.GetKeyIVFromBytes(Bytes_K);	//get an another ResponseKeys 
			Key2 = ResponseKeys[0];			//Get Key2
			IV2 = ResponseKeys[1];			//Get IV2

			
			string NewDHGuid = "";
			
			string MaybeAlreadyCashedGuid = CashedClientsKeys.FirstOrDefault(
												x
												=>
													x.Value
													==
													(
															BinaryEncoding.GetString(Key)
														+	BinaryEncoding.GetString(IV)
														+	BinaryEncoding.GetString(Key2)
														+	BinaryEncoding.GetString(IV2)
													)
											)
											.Key
				;
			
			if(
					!string.IsNullOrEmpty(MaybeAlreadyCashedGuid)
				&&	CashedClientsKeys.ContainsKey(MaybeAlreadyCashedGuid))
			{
				NewDHGuid = MaybeAlreadyCashedGuid;
			}
			else if(
					!string.IsNullOrEmpty(oldDHGuid)
				&&	CashedClientsKeys.ContainsKey(oldDHGuid)
			){
				byte[] oldKey	= new byte[32];
				byte[] oldIV	= new byte[16];
				byte[] oldKey2	= new byte[32];
				byte[] oldIV2	= new byte[16];
				
				ExtractKeysFromCache(ref oldDHGuid,	ref oldKey, ref oldIV, ref oldKey2, ref oldIV2);	//extract {Key, IV, Key2, IV2}
				if(
						(	BinaryEncoding.GetString(Key)	==	BinaryEncoding.GetString(oldKey)		)
					&&	(	BinaryEncoding.GetString(IV)	==	BinaryEncoding.GetString(oldIV)			)
					&&	(	BinaryEncoding.GetString(Key2)	==	BinaryEncoding.GetString(oldKey2)		)
					&&	(	BinaryEncoding.GetString(IV2)	==	BinaryEncoding.GetString(oldIV2)		)
				){	//only in this case
					Console.WriteLine("Use old specified oldDHGuid: "+oldDHGuid);
					NewDHGuid = oldDHGuid;	//use old DHGuid
				}
			}
			else{
				//generate new guid for client:
				NewDHGuid = Guid.NewGuid().ToString();
				//Console.WriteLine("NewDHGuid was generated: "+NewDHGuid);
				
				long	unixTimestampNow			=	GetGMTInMS(DateTime.Now);
				ClearKeysIfNeed(unixTimestampNow);

				TimeOfAddingKeys.Add(NewDHGuid, unixTimestampNow);

				//cache the keys into list
				CashedClientsKeys[NewDHGuid] = (
							BinaryEncoding.GetString(Key)			//Key	for	decrypt	request		("iso-8859-1"-strings)
						+	BinaryEncoding.GetString(IV)			//IV	for	decrypt	request
						+	BinaryEncoding.GetString(Key2)			//Key2	for	encrypt	response
						+	BinaryEncoding.GetString(IV2)			//IV2	for	encrypt	response
				);
			}

			//and return NewDHGuid
		//	Console.WriteLine("ComputeAESKeysAndIVs: BytesToHex(Bytes_B): "+BytesToHex(Bytes_B));
		//	Console.WriteLine("ComputeAESKeysAndIVs: BytesToHex(Key): "+BytesToHex(Key));
		//	Console.WriteLine("ComputeAESKeysAndIVs: BytesToHex(IV): "+BytesToHex(IV));
		//	Console.WriteLine("ComputeAESKeysAndIVs: BytesToHex(Key2): "+BytesToHex(Key2));
		//	Console.WriteLine("ComputeAESKeysAndIVs: BytesToHex(IV2): "+BytesToHex(IV2));

			return new string[]{
					NewDHGuid		//(DHGuid, as text)
				,	System.Uri.EscapeDataString(AESEncryptDecrypt.AESEncryptDecrypt.EncryptString(NewDHGuid, Key2, IV2))	//DHGuid, as encrypted base64
			};
		}

		//Diffie-Hellman Key Exchange method.
		private void DHKE(
						byte[]	Bytes_B					//For bytes of B, try to compute keys, using ComputeAESKeysAndIVs
			,	ref		string	newClientDHGuid			//save DHGuid here
			,	ref		string	EncryptedClientDHGuid 	//save Encrypted DHGuid here
			,	ref		string	SetGuidInCookies		//and set this in cookies
			,	ref		string	ErrorMessage			//or return ErrorMeassage
			,			string	oldDHGuid = null		//optional, old DHGuid, if exists
		){
			//for first request with 64 bytes of B;
			
			if( (Bytes_B).Length >= DH_BigInteger.bitlength/8 )	//B must to have length 64 bytes or 512 bits.
			{
				//compute K from B, compute {Key, IV, Key2, IV2}, cache this keys, and return DHGuid.
				string[] DHGuids		= ComputeAESKeysAndIVs(Bytes_B, oldDHGuid);
				newClientDHGuid			= DHGuids[0];
				EncryptedClientDHGuid	= DHGuids[1];
				
				string temp = newClientDHGuid;
				newClientDHGuid = EncryptedClientDHGuid;		//replace guid to encrypted guid.

				//Make string, to set DHGuid in cookie
				int MaxAgeOfCookieInSeconds = 300;		//5 minutes = 300 seconds
				SetGuidInCookies = (
										(newClientDHGuid != "")								//if new Guid is available
											?	(												//set this in cookies
													"Set-Cookie: "
													+	"DHGuid="+newClientDHGuid+"; "
												//	+	"Path=/; "								//Path "/" need to show this in JS console.log(document.cookie)
													+	"Path=/; "								//Path "/" need to show this in JS console.log(document.cookie)
												//	+	"Domain=127.0.0.1:7346; "					//Use JavaScript will use window.location.origin by default.
													+	"Max-Age="+MaxAgeOfCookieInSeconds+"; "	//20 sec test.
												//	+	"HttpOnly; "							//disabled, to show this in JS console.log(document.cookie)
											)
											:	""											//or leave this stirng empty, and do not set cookie
									)
				;
				
				newClientDHGuid = temp;
			}
			else{	//else
				ErrorMessage = "Need to generate DH value b on client, compute B, and send this B as 64 bytes.";	//return error, as string, and leave newClientDHGuid empty string.
			}
		}
		

		public bool IsBase64String(string base64)
		{
			base64 = base64.Trim();
			return (base64.Length % 4 == 0) && Regex.IsMatch(base64, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None);
		}
		
		//The same, but this is a handler for first request with 64 bytes of B. Return HttpResponse for HttpRequest.
		private HttpResponse DHKE(
			HttpRequest request
		){
			//define this variables
			string	newClientDHGuid			=	"";
			string	EncryptedClientDHGuid 	=	"";
			string	SetGuidInCookies		=	"";
			string	ErrorMessage			=	"";
			
			DHKE(request.Content_bytes, ref newClientDHGuid, ref EncryptedClientDHGuid, ref SetGuidInCookies, ref ErrorMessage); //Run DHKE-method

			if(!string.IsNullOrEmpty(newClientDHGuid)){
			//	return new HttpResponse(StatusCode.Ok,	newClientDHGuid, null, false, null, SetGuidInCookies);			//return DHGuid, and set DHGuid in cookies		
				return new HttpResponse(StatusCode.Ok,	EncryptedClientDHGuid, null, false, null, SetGuidInCookies);	//return Encrypted DHGuid, and set DHGuid in cookies		
			}
			else if(!string.IsNullOrEmpty(ErrorMessage)){
				return new ErrorHandler( StatusCode.BadRequest, ErrorMessage ).Handle(request);								//or return ErrorMessage
			}
			else{
				return new ErrorHandler( StatusCode.BadRequest, "DbApiHandler.cs. Something wrong in condition: (private HttpResponse DHKE)" ).Handle(request); //or return another error.
			}
		}

		//Method to cut first bytes from ByteArray. 
		private byte[] ExtractFirstBytesAndCutIt(
				ref	byte[] ByteArray
			,	int length
		){
			byte[] FirstValue = new byte[length];
			Buffer.BlockCopy(ByteArray, 0, FirstValue, 0, FirstValue.Length);

			byte[] WithoutFirstValue = new byte[ByteArray.Length - FirstValue.Length];
			Buffer.BlockCopy(ByteArray, FirstValue.Length, WithoutFirstValue, 0, WithoutFirstValue.Length);
			ByteArray = WithoutFirstValue;
			
			return FirstValue;
		}
		//Usage:	byte[] FirstValue = ExtractFirstBytesAndCutIt(ref ByteArray, length)
		
		
		private byte[] GetRandomBytes(
			int NubmerOfBytes
		){
			RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
			byte[] rand = new byte[16];
			rng.GetBytes(rand);
			//Console.WriteLine(BitConverter.ToString(rand).Replace("-", string.Empty));
			return rand;
		}
		
		private static byte[] Combine(byte[][] ByteArrays)
		{
			byte[] bytes = new byte[ByteArrays.Sum(a => a.Length)];
			int offset = 0;
 
			foreach (byte[] array in ByteArrays)
			{
				Buffer.BlockCopy(array, 0, bytes, offset, array.Length);
				offset += array.Length;
			}
 
			return bytes;
		}
		//byte[] combinedByteArray = Combine(new byte[][] {ByteArray1, ByteArray2, ByteArray2, etc...})
		
		//Method to try extract keys from dictionary, by DHGuid
		private bool ExtractKeysFromCache(
				ref	string DHGuid													//By DHGuid
			,	ref byte[] Key, ref byte[] IV, ref byte[] Key2, ref byte[] IV2		//extract {Key, IV, Key2, IV2}
		){
		//	Console.WriteLine("ExtractKeysFromCache. DHGuid: "+DHGuid);
			//From dictionary of cache
			if(CashedClientsKeys.ContainsKey(DHGuid)){								//if Keys contains in cache
				string Keys = CashedClientsKeys[DHGuid];							//get string with all Keys

				Key 	= BinaryEncoding.GetBytes(Keys.Substring(0, 32))	;		//And extract {Key, IV, Key2, IV2} from list.
				IV 		= BinaryEncoding.GetBytes(Keys.Substring(32, 16))	;
				Key2	= BinaryEncoding.GetBytes(Keys.Substring(48, 32))	;		//example code, with BigInteger
				IV2 	= BinaryEncoding.GetBytes(Keys.Substring(80, 16))	;
				return true;
			}
			else{
			//	Console.WriteLine("DbApiHandler.ExtractKeysFromCache. Keys not found by DHGuid: "+DHGuid);	//or show error
				return false;
			}
		}
		//bool KeysExtracted = ExtractKeysFromCache(ref DHGuid, ref Key, ref IV, ref Key2, ref IV2);
		
		
		private static Dictionary<string,IRequestHandler>  HttpServerHandlers = NServer.HttpServer.HttpServerHandlers();
		private static IRequestHandler  RootHandler = NServer.HttpServer.RootHandler();
		//private static Dictionary<string,IRequestHandler>  HttpServerHandlers = NServer.HttpServer._handlers;
		
		//Handle Encrypted requests, try to decrypt this, send decrypted request to the handler, receive response, encrypt this response, and send this as EncryptedResponse.
		private HttpResponse DHAESSecureHandler(	//DHAES secure-handler
			HttpRequest request
		)
		{
		//	Console.WriteLine("DHAESSecureHandler: request.HeadersAsString: "+request.HeadersAsString);
			//HttpServerHandlers from HttpServer.cs -handlers need to send decrypted HttpRequest to this handlers too, from this method.
			
			/*
				To get AES Keys
					1.	DHKE handler can accept request with B (64 bytes); -> return response with Set-Cookie with DHGuid
					2.	Or. DHAESSecureHandler can accept as a first encrypted request with B at beginning (64 bytes). -> return response with Set-Cookie with DHGuid
					3.	Then, DHGuid can contains at beginning of all next requests (36 bytes) + in cookies, in headers, the same DHGuid.
						Keys extracting from temporary cache, by DHGuid.
			*/
			Regex MatchGuid = new Regex(@"^(\{{0,1}([0-9a-fA-F]){8}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){4}-([0-9a-fA-F]){12}\}{0,1})$");
			bool BeginFromDHGuid	=	true;
			bool BeginFromB			=	false;
			
			try
			{
				if((request.Content_bytes).Length < 36){				//if lesser than guid - error
					return new ErrorHandler(StatusCode.BadRequest, "DbApiHandler.DHAESSecureHandler: Invalid request, request.Content_bytes.Length lesser than DHGuid.Length.").Handle(request);
				}
				//else, continue

				byte[] RequestContentBytes = request.Content_bytes;
				byte[] DHGuidBytes = ExtractFirstBytesAndCutIt(ref RequestContentBytes, 36);
				string DHGuid = System.Text.Encoding.GetEncoding("iso-8859-1").GetString(DHGuidBytes);
				
				/*
				if(!(MatchGuid).IsMatch(DHGuid)){
					Console.WriteLine("It's not DHGuid, and seems like B. : DHGuid: "+DHGuid+", now this empty string...");
					DHGuid = "";
				}
				*/				

				if(
						!	((MatchGuid).IsMatch(DHGuid))				//if this was been a part of B and not valid guid
					||	!	CashedClientsKeys.ContainsKey(DHGuid)			//or if this not contains in dictionary
				){			//if Keys not exists by "guid"
					RequestContentBytes	= request.Content_bytes;		//first 16 bytes is not a valid guid
					BeginFromDHGuid = false;
					BeginFromB = true;
				}
				//else, B at first, Or old guid, after restart server.
				//Leave RequestContentBytes with this.



				//Check is DHGuid exists in Cookies?
				if((request.HeadersAsString).IndexOf(DHGuid) != -1){
					//That's ok, do nothing, and skip the following step.
				}
				else if( (request.Headers).ContainsKey("Cookie") )							//if Cookie contains in Header
				{
					Console.WriteLine("Try to extract DHGuid from cookies");
					//Full code, to extract cookies.
					string DHGuidCookies = "";
					//Try to find DHGuid in cookies
					string AllCookies = request.Headers["Cookie"];
					string[] Cookies = AllCookies.Split(' ');
					Dictionary<string, string> CookieValue = new Dictionary<string, string>();
					for(int i = 0; i<Cookies.Length; i++){
						//name=value; name2=value2; name3=value3
						string[] KeyValue = Cookies[i].Split('=');
						CookieValue[KeyValue[0]] = KeyValue[1].Replace(";", "");
					}
					
					if(	CookieValue.ContainsKey("DHGuid")	){	//if cookie with name DHGuid exists.
						DHGuidCookies = CookieValue["DHGuid"];		//extract this.
					}
					else{
						DHGuidCookies = "";							//else, leave this string empty.
					}



					bool DHGuidIsGuid	=	((MatchGuid).IsMatch(DHGuid))	;	//check is DHGuid at beginning of request, is a valid guid or not.
					BeginFromB = !DHGuidIsGuid;
					BeginFromDHGuid = DHGuidIsGuid;
					
					if(DHGuidCookies != DHGuid){									//when DHGuid not in cookie
						if(string.IsNullOrEmpty(DHGuidCookies)){						//and when empty string in cookie
							if(!DHGuidIsGuid){												//and when DHGuid is not guid
								Console.WriteLine("DbApiHandler. no cookie, and not guid in request... Seems like B at beginning");
								RequestContentBytes = request.Content_bytes;	//first request contains B, but next requests can be sent without DHGuid in response, because this exists in header.
								Console.WriteLine("change RequestContentBytes = request.Content_bytes; with B");
							}
							//else, leave DHGuid
						}
						else if(((MatchGuid).IsMatch(DHGuidCookies))){					//and when guid in cookies
							if(!DHGuidIsGuid){												//and when DHGuid not guid
								Console.WriteLine("DbApiHandler. guid in cookie, but not guid in request...");
								DHGuid = DHGuidCookies;											//use DHGuid from cookie
								RequestContentBytes = request.Content_bytes;	//first request contains B, but next requests can be sent without DHGuid in response, because this exists in header.
								Console.WriteLine("change RequestContentBytes = request.Content_bytes; with B");
							}
							//else, leave DHGuid
						}
						else{															//but when there is not guid in cookie
							if(!DHGuidIsGuid){												//and when DHGuid not guid
								Console.WriteLine("DbApiHandler. not guid in cookie, and not guid in request...");
								DHGuid = "";													//leave DHGuid empty
								RequestContentBytes = request.Content_bytes;	//first request contains B, but next requests can be sent without DHGuid in response, because this exists in header.
								Console.WriteLine("change RequestContentBytes = request.Content_bytes; with B");
							}
							//else, leave DHGuid
						}
						//else, leave DHGuid
					}
					//else, leave DHGuid (often)
				}
				else{
					//If this is first-request, with (Bytes_B (64 bytes, 128 bits) + EncryptedCipher)
				//	Console.WriteLine("DbApiHandler.DHAESSecureHandler: else in condition. Seems, like DHGuid not found, in cookies, or cookies not set.");
					BeginFromB = !((MatchGuid).IsMatch(DHGuid));
					if(BeginFromB){
						DHGuid = "";	//reset this.
						RequestContentBytes = request.Content_bytes;
					}
					//else, DHGuid already readed, from beginning of request.
				}
				
			//	Console.WriteLine("DHGuid: "+DHGuid+", BeginFromDHGuid: "+BeginFromDHGuid+", BeginFromB: "+BeginFromB+", RequestContentBytes.Length: "+RequestContentBytes.Length);

				//Extract AES-Keys

				//define this variables
				byte[] Key = new byte[32]	;
				byte[] IV = new byte[16]	;

				byte[] Key2 = new byte[32]	;
				byte[] IV2 = new byte[16]	;

				HttpResponse	RawResponse					=	null	;			//not encrypted response, from handler

				string	newClientDHGuid = "";
				string	EncryptedClientDHGuid = "";
				string	SetGuidInCookies = "";
				string	ErrorMessage = "";
				byte[] Bytes_B = null;
				
				//From dictionary
			//	Console.WriteLine("DHGuid"+DHGuid);
			//	Console.WriteLine("!string.IsNullOrEmpty(DHGuid)"+string.IsNullOrEmpty(DHGuid));
			//	Console.WriteLine("!IsBase64String(DHGuid)"+!IsBase64String(DHGuid));
				
				if(!string.IsNullOrEmpty(DHGuid) && !IsBase64String(DHGuid) && !ExtractKeysFromCache(ref DHGuid, ref Key, ref IV, ref Key2, ref IV2)){
					//compute this, from B, and add into dictionary
					
					//Just assume, in request.ContentBytes contains "B" or maybe (OldDHGuid+B)
					//This can contains OldDHGuid+Cipher, without B;
					string isDHGuid = System.Text.Encoding.GetEncoding("iso-8859-1").GetString(DHGuidBytes);	//get extracted 16 bytes;
					if(
							((MatchGuid).IsMatch(isDHGuid))	//if this is valid guid, and not B
						&&	DHGuid == isDHGuid								//but if this is old guid, that not contains in cache.
					){ //the same string, and not guid, when B appended, there.
						RawResponse = new ErrorHandler( StatusCode.BadRequest, "Keys not found, by this guid. Need to generate b and B." ).Handle(request);
						//as is, without encryption
						goto SendResponseAsIs;
					}
					//else if RequestContentBytes have enough Length to contains B, in first request, and not old guid, and not guid in DHGuid
					else if(RequestContentBytes.Length >= DH_BigInteger.bitlength/8){
						RequestContentBytes = request.Content_bytes;	//take full request.Content_bytes, which not contains DHGuid, but contains 64 bytes of B, for first request.
						
						//Console.WriteLine("1test 3: RequestContentBytes.Length: "+RequestContentBytes.Length);
						
						Bytes_B = ExtractFirstBytesAndCutIt(ref RequestContentBytes, 64);
						DHKE(Bytes_B, ref newClientDHGuid, ref EncryptedClientDHGuid, ref SetGuidInCookies, ref ErrorMessage, DHGuid);	//void method - Extract Keys from B, cache this, and use to decrypt, then.
						if(!string.IsNullOrEmpty(newClientDHGuid)){
							DHGuid = newClientDHGuid;
						//	Console.WriteLine("newClientDHGuid not empty: "+newClientDHGuid+", SetGuidInCookies:"+SetGuidInCookies);
						}

					//	Console.WriteLine("ErrorMessage: "+ErrorMessage);

						ExtractKeysFromCache(ref DHGuid, ref Key, ref IV, ref Key2, ref IV2); //extract keys from cache-dictionary, after run DHKE
						//And continue to decrypt encrypted cipher, without B
						
						//Console.WriteLine("2test 3: RequestContentBytes.Length: "+RequestContentBytes.Length);
					}
					else{
						//else, return error
						RawResponse = new ErrorHandler( StatusCode.BadRequest, "DbApiHandler.DHAESSecureHandler: Need to generate DH b and send B." ).Handle(request);
						//as is, without encryption
						goto SendResponseAsIs;
					}
				}
				else{
					if(											//if B contains at beginning of request
							( BeginFromDHGuid == false )		//		and guid not contains in cookie
						&&	( BeginFromB = true )				//		and request beginning from new B
					){
					
						RequestContentBytes = request.Content_bytes;	//take full request.Content_bytes, which not contains DHGuid, but contains 64 bytes of B, for first request.
						
					//	Console.WriteLine("1test 3: RequestContentBytes.Length: "+RequestContentBytes.Length);
						
						Bytes_B = ExtractFirstBytesAndCutIt(ref RequestContentBytes, 64);
						DHKE(Bytes_B, ref newClientDHGuid, ref EncryptedClientDHGuid, ref SetGuidInCookies, ref ErrorMessage, DHGuid);	//void method - Extract Keys from B, cache this, and use to decrypt, then.
						if(!string.IsNullOrEmpty(newClientDHGuid)){
							DHGuid = newClientDHGuid;
						//	Console.WriteLine("2newClientDHGuid not empty: "+newClientDHGuid+", SetGuidInCookies:"+SetGuidInCookies);
						}

						ExtractKeysFromCache(ref DHGuid, ref Key, ref IV, ref Key2, ref IV2); //extract keys from cache-dictionary, after run DHKE
						//And continue to decrypt encrypted cipher, without B
					
//						ExtractFirstBytesAndCutIt(ref RequestContentBytes, 64); //just cut this B from request.
					}
					//else, use keys, extracted by DHGuid, from cache-dictionary
				}

			//	Console.WriteLine("AES ENCRYPT DECRYPT");
			//	Console.WriteLine("DHGuid: "+DHGuid);
			//	Console.WriteLine("BytesToHex(Bytes_B): "+((Bytes_B==null)? "null" : BytesToHex(Bytes_B)));
			//	Console.WriteLine("BytesToHex(Key): "+BytesToHex(Key));
			//	Console.WriteLine("BytesToHex(IV): "+BytesToHex(IV));
			//	Console.WriteLine("BytesToHex(Key2): "+BytesToHex(Key2));
			//	Console.WriteLine("BytesToHex(IV2): "+BytesToHex(IV2));
				
				//Now, decrypt request with "Key" and "IV", get response from handler, and encrypt this response, by "Key2" and "IV2"

				string			ContentOfRawResponse		=	null	;			//not encrypted string from this
				byte[]			ContentBytesOfRawResponse	=	null	;			//or not encrypted bytes from this
				byte[]			EncryptedResponseBytes		=	null	;			//encrypted bytes of crypto-response.
				HttpResponse	EncryptedResponse			=	null	;			//new binary response with encrypted bytes.
				try
				{
					string DecryptedRequestAddress = ""; string cmd = ""; string arg = ""; string handler_ = ""; GetCmdArg(request.Address, ref cmd, ref arg, ref handler_);
					if(cmd.Contains("secure-")){					//if encrypted request
						cmd = cmd.Replace("secure-", "");				//remove "secure-"-prefix.
						cmd = System.Uri.UnescapeDataString(cmd);		// "/" was been escaped, because this char can contains in base64
						cmd = AESEncryptDecrypt.AESEncryptDecrypt.DecryptString(cmd, Key, IV);
						DecryptedRequestAddress = cmd;
						GetCmdArg(cmd, ref cmd, ref arg, ref handler_);
					}
					
				//	Console.WriteLine("DecryptedRequestAddress: "+DecryptedRequestAddress+", handler_: "+handler_+", cmd: "+cmd+", arg: "+arg);
					
					string RequestContent = null;							//to save Decrypted request Text
					byte[] RequestContent_bytes = null;						//to save Decrypted request Text
					byte[] EncryptedContentBytes = RequestContentBytes;		//bytes of encrypted request
					if(EncryptedContentBytes != null){	//if bytes exists, then encrypted bytes received
						AESEncryptDecrypt.AESEncryptDecrypt.AESDecrypt(ref EncryptedContentBytes, ref Key, ref IV, out RequestContent_bytes);	//decrypt it, and save result in RequestContent_bytes
						ExtractFirstBytesAndCutIt(ref RequestContent_bytes, 16 );	//cut random first block, generated on client. This was been need just to change cipher;
					}
					else{
						Console.WriteLine("(EncryptedContentBytes === null): "+(EncryptedContentBytes == null));
					}
					if(
							handler_ == HttpServerBuilder.DBapi
						&&	_handlers.ContainsKey(cmd)
						&&	!_handlers_bin.ContainsKey(cmd)
						&&	!Latin1Handlers.Contains(cmd)
					){
						//text-request: decrypt RequestContent from encrypted request.RequestContent_bytes
						RequestContent = System.Text.Encoding.UTF8.GetString(RequestContent_bytes);					//use UTF-8
						
					//	Console.WriteLine("1 RequestContent: "+RequestContent+", RequestContent.Length: "+RequestContent.Length+", RequestContentBytes.Length: "+RequestContentBytes.Length);
						
						//Content = MimeType.DefaultBinaryEncoding.GetString(RequestContent_bytes);
						RequestContent_bytes = null;
					}
					else if(
							handler_ == HttpServerBuilder.DBapi
						&&	_handlers.ContainsKey(cmd)
						&& 	!_handlers_bin.ContainsKey(cmd)
						&&	Latin1Handlers.Contains(cmd)
					){
						//text-request: decrypt RequestContent from encrypted request.RequestContent_bytes
						RequestContent = MimeType.DefaultBinaryEncoding.GetString(RequestContent_bytes);			//use iso-8859-1

					//	Console.WriteLine("2 RequestContent: "+RequestContent+", RequestContent.Length: "+RequestContent.Length+", RequestContentBytes.Length: "+RequestContentBytes.Length);

						RequestContent_bytes = null;
					}
					if(											//if
							handler_ == HttpServerBuilder.DBapi
						&&	_handlers.ContainsKey(cmd)			//handler contains in _handlers Dictionary
					//	&&	request.isBinary == false			//and if it's not binary-request
						//this was been commented, because binary requests can be accepted by handlers, as iso-8859-1 string, too.
						||	Latin1Handlers.Contains(cmd)
					){
						RawResponse = _handlers[cmd](arg, RequestContent); //send request to handler, and return response.
						//for binary-request, send request to "handler" with "iso-8859-1"-encoded string, and return response.
						goto EncryptResponseAndSend;
					}
					else if (									//else if
							handler_ == HttpServerBuilder.DBapi
						&&	_handlers_bin.ContainsKey(cmd)		//and if handler contains in binary handlers
					)
					{
						if(														//if
								RequestContent_bytes == null					//but content not found
							||	(												//or
									(RequestContent_bytes != null)					//if it's found
								&&	(RequestContent_bytes.Length == 0)				//but empty
							)
							&&	RequestContent.Length != 0								//and if text found
						){
							byte[] request_bytes = MimeType.DefaultBinaryEncoding.GetBytes(RequestContent);		//decode this to bytes, using reversive latin1 encoding.
							RawResponse = _handlers_bin[cmd](arg, request_bytes); //and send bytes to binary-handler, and return the binary response
							goto EncryptResponseAndSend;
						}
						else{ //else if it's was been bytes (Content-Type: application/octet-stream), and request.isBinary == true
							RawResponse = _handlers_bin[cmd](arg, RequestContent_bytes); //send bytes to binary-handler, and return response
							goto EncryptResponseAndSend;
						}
					}
					else if(																			//Else if this is a handler_ from HttpServerHandlers
							handler_ != HttpServerBuilder.DBapi
						&&	(
								HttpServerHandlers.ContainsKey(handler_)
							||	string.IsNullOrEmpty(handler_)
							||	(
										!string.IsNullOrEmpty(handler_)
									&&	DecryptedRequestAddress.Count(a => a == '/') == 1
							)
						)
					)
					{
						//Try to send an encrypted request on HttpServerHandler, and return response from this
							try{
								//See HttpRequest.cs
							request = new HttpRequest(
											request					//old encrypted request
										,	request.isBinary		//NewIsBinaryRequest
										,	false					//NewInvalid
										,	RequestContent			//NewRequestText
										,	RequestContent_bytes	//NewRequestBytes
										,	request.Connection		//NewConn
										,	null					//NewMethod
										,	DecryptedRequestAddress	//NewAddress
										,	null					//NewHost
										,	null					//NewHeadersString
										,	null					//NewHeaders
									)
							;

							if (DecryptedRequestAddress == "/" || DecryptedRequestAddress == "" || DecryptedRequestAddress.Contains("captcha.nbc"))
							{
								RawResponse = RootHandler.Handle(request);
							//	goto SendResponseAsIs;
								goto EncryptResponseAndSend;
							}

							var splitted = DecryptedRequestAddress.Split(new char[]{ '/' }, StringSplitOptions.RemoveEmptyEntries);

							if (splitted.Length == 0)
							{
								RawResponse =  new ErrorHandler(StatusCode.BadRequest, "Invalid address").Handle(request);
							//	goto SendResponseAsIs;
								goto EncryptResponseAndSend;
							}

							var endpoint = splitted[0];
				
							bool lite_server = is_lite;
							bool is_lite_server = is_lite;
				
							if(endpoint == "download" && (splitted.Length>1 && (splitted[1] == "generated" || splitted[1] == "created"))){endpoint = "download/"+splitted[1];}
							else if( lite_server == true && is_lite_server == true){

							//	Console.WriteLine("HttpServer.cs. Lite server: "+( lite_server == true && is_lite_server == true)+"Process. Replace endpoint");

								//Change endpoint for lite-server, if port of request is corresponding of default port for lite-server:
								//	/pages 		-> 		/pages_lite
								//	/scripts 	->		/scripts_lite
								//	/api		->		/api_lite
								//	etc...

								if(
										endpoint == "pages"
									|| 	endpoint == "scripts"
									|| 	endpoint == "api"
									||	endpoint == "shutdown"
									||	endpoint == "restart"
									||	endpoint == "reports"
									||	endpoint == "notif"		||	endpoint == "containers"
								){
									endpoint = endpoint + "_lite";
								}
							}
							if(DecryptedRequestAddress == "/favicon.ico"){endpoint = "images";}				
							if (HttpServerHandlers.ContainsKey(endpoint))
							{
								RawResponse =  HttpServerHandlers[endpoint].Handle(request);
							//	goto SendResponseAsIs;
								goto EncryptResponseAndSend;
							}
							else if(endpoint == "shutdown"){
								using (StreamWriter sw = File.AppendText("shutdown_requests.log")) 
								{
									sw.WriteLine(is_lite_server+", "+DateTime.Now+": http://"+( ( ((HttpServer.CheckHost).Match(request.Host).Success)	== false ) ? request.Headers["Host"] : request.Host )+DecryptedRequestAddress);
								//	sw.WriteLine("connection.RequestText: "+connection.RequestText);
									sw.WriteLine("connection.RequestText: "+RequestContent);
									sw.WriteLine("\n");
								}
								RawResponse =  new ErrorHandler(StatusCode.Ok, "Server was shutdown.").Handle(request);
					
								System.Threading.Thread.Sleep(500);
				
								HttpServer.Stop(true);
					
							//	goto SendResponseAsIs;
								goto EncryptResponseAndSend;
							}
							else{
								RawResponse =  new ErrorHandler(
									StatusCode.BadRequest, 
									"Unknown endpoint: "	+	endpoint
									+ ". Supported: "		+	JsonConvert.SerializeObject(	HttpServerHandlers.Keys.ToArray()	)
								).Handle(request);

							//	goto SendResponseAsIs;
								goto EncryptResponseAndSend;
							}
						}
						catch(Exception ex){
							Console.WriteLine("HttpServer.cs. Process. Exception: "+ex);
						}
					}
					else{	//if handler_ not found in dictionaries - return error:
						Console.WriteLine("Error: Handler not found in DbApiHandler or HttpServerHandlers... handler_"+handler_+", cmd: "+cmd);
						//else if "_handlers" or "_handlers_bin" dictionaries not contains handler "cmd" - return an error:
						RawResponse = new ErrorHandler(
									StatusCode.BadRequest
								,	(
											"No such command: " + cmd
										+	". Available commands for DbApiHandler: "
										+	JsonConvert.SerializeObject(_handlers.Keys.ToArray())
										+	". Available commands for HttpServerHandlers: "
										+	JsonConvert.SerializeObject(HttpServerHandlers.Keys.ToArray())
									)
							)
							.Handle(request)
						;
						goto SendResponseAsIs;
					}
				}
				catch (Exception e)
				{
					RawResponse = new ErrorHandler(StatusCode.InternalServerError, e.ToString()).Handle(request);	//or return an exception-message
					goto SendResponseAsIs;
				}
			
				//When RawResponse defined, extract bytes from this, and encrypt this bytes:
			
				EncryptResponseAndSend:
					byte[] test = RawResponse.GetBinaryContent();
					if(RawResponse._isBinary == true){
						ContentBytesOfRawResponse = RawResponse.GetBinaryContent();
					}else{
						ContentOfRawResponse = RawResponse.GetContent();
						ContentBytesOfRawResponse = System.Text.Encoding.UTF8.GetBytes(ContentOfRawResponse);
					}
					ContentBytesOfRawResponse = Combine(new byte[][] {GetRandomBytes(16), ContentBytesOfRawResponse});	//add random bytes in the first block, to change cipherText
					AESEncryptDecrypt.AESEncryptDecrypt.AESEncrypt(ref ContentBytesOfRawResponse, ref Key2, ref IV2, out EncryptedResponseBytes);
					goto SendBinaryResponse;
			
				SendBinaryResponse:
				//	EncryptedResponse = new HttpResponse(StatusCode.Ok,	EncryptedResponseBytes, MimeType.Mime("App"), null, SetGuidInCookies);
					//MimeType: "application/octet-stream", is valid, for encrypted cipher,
					//but mimetype of decrypted content - is unknown.
					//So, need to different interpretation, for decrypted bytes, on client.

					EncryptedResponse = new HttpResponse(StatusCode.Ok,	EncryptedResponseBytes, RawResponse.GetContentType(), null, SetGuidInCookies);
					//send response with MimeType of RawResponse, but with encrypted cipher in bytes.
					
					return EncryptedResponse;

				SendResponseAsIs:
					return RawResponse;
			}
			catch(Exception ex){
				return new ErrorHandler(StatusCode.InternalServerError, ex.ToString()).Handle(request);	//or return an exception-message
			}
		}
    }
}