เดเตปเดเตเดฐเดฟ
เดเดฐเต เดเตเดฑเดฟเดฏ เดตเตเดฌเต เดธเตเดตเดจเด เดเดฃเตเดเดพเดเตเดเดพเตป เดเดฐเต เดธเดนเดชเตเดฐเดตเตผเดคเตเดคเดเตป เดจเดฟเตผเดฆเตเดฆเตเดถเดฟเดเตเดเดคเตเดเตเดฏเดพเดฃเต เดเดคเตเดฒเตเดฒเดพเด เดเดฐเดเดญเดฟเดเตเดเดคเต. เดเดคเต เดเดฐเต เดเดฟเตปเดกเตผ เดชเตเดฒเตเดฏเดพเดฏเดฟเดฐเดฟเดเตเดเดฃเด, เดชเดเตเดทเต เดเดฐเต เดเดเดฟ เดนเดพเดเดเตเดเดเตเดเดฟเดจเดพเดฏเดฟ. เดชเตเดฐเดตเตผเดคเตเดคเดจเด เดตเดณเดฐเต เดฒเดณเดฟเดคเดฎเดพเดฃเต, เดจเดฟเดเตเดเตพ เดฐเดเดฟเดธเตเดฑเตเดฑเตผ เดเตเดฏเตเดฏเตเด, เดเดฐเต เดชเตเดฐเตเดซเตเตฝ เดชเตเดฐเดฟเดชเตเดชเดฟเดเตเดเต เดชเตเดฐเดงเดพเดจ เดชเตเดฏเดฟเดจเตเดฑเดฟเดฒเตเดเตเดเต เดจเตเดเตเดเตเด, เด
เดคเดพเดฏเดคเต, เดเดฐเต เดเดจเตเดฑเตผเดฒเตเดเตเดเตเดเตเดเตผ เดเดฃเตเดเตเดคเตเดคเตเดเดฏเตเด เดจเดฟเดเตเดเดณเตเดเต เดเดฃเดเตเดทเดจเตเดเตพ เดตเดฟเดเดธเดฟเดชเตเดชเดฟเดเตเดเตเดเดฏเตเด เดชเตเดคเดฟเดฏ เดชเดฐเดฟเดเดฏเดเตเดเดพเดฐเต เดเดฃเตเดเดพเดเตเดเตเดเดฏเตเด เดเตเดฏเตเดฏเตเด.
เดเดตเดฟเดเต เดเดพเตป เดตเตเดฏเดคเดฟเดเดฒเดฟเดเตเดเตเดเดฏเตเด เดเดจเตเดจเตเดเตเดเตเดฑเดฟเดเตเดเต เดเตเดฑเดเตเดเต เดชเดฑเดฏเตเดเดฏเตเด เดตเตเดฃเด, เด เดคเตเดตเดดเดฟ เดเดพเตป เดตเดฟเดเดธเดจเดคเตเดคเดฟเตฝ เดเดจเตเดคเตเดเตเดฃเตเดเดพเดฃเต เด เดคเตเดคเดฐเด เดจเดเดชเดเดฟเดเตพ เดธเตเดตเตเดเดฐเดฟเดเตเดเดคเตเดจเตเดจเต เดญเดพเดตเดฟเดฏเดฟเตฝ เดเตเดเตเดคเตฝ เดตเตเดฏเดเตเดคเดฎเดพเดเตเด.
เดเดชเตเดชเตเตพ เดเดพเตป เดเดฐเต เดเตเดฏเดฟเด เดธเตเดฑเตเดฑเตเดกเดฟเดฏเตเดฏเดฟเตฝ เดเตเดเตโเดจเดฟเดเตเดเตฝ เดเตผเดเตเดเดฟเดธเตโเดฑเตเดฑเดฟเดจเตเดฑเต เดธเตเดฅเดพเดจเด เดตเดนเดฟเดเตเดเตเดจเตเดจเต, เดเดจเตเดฑเต เดธเดฟ# เดชเตเดฐเตเดเตเดฐเดพเดฎเดฟเดเดเต เด เดจเตเดญเดตเด เดฏเตเดฃเดฟเดฑเตเดฑเดฟเดฏเตโเดเตเดเดพเดฏเดฟ เดธเตโเดเตเดฐเดฟเดชเตเดฑเตเดฑเตเดเดณเตเด เดฏเตเดเตเดเดฟเดฒเดฟเดฑเตเดฑเดฟเดเดณเตเด เดเดดเตเดคเตเดจเตเดจเดคเดฟเตฝ เดฎเดพเดคเตเดฐเด เด เดงเดฟเดทเตโเด เดฟเดคเดฎเดพเดฏเดฟเดฐเตเดจเตเดจเต, เดเตเดเดพเดคเต, เดเตปเดกเตเดฐเตเดฏเดฟเดกเต เดเดชเดเดฐเดฃเดเตเดเดณเดฟเตฝ เดคเดพเดดเตเดจเตเดจ เดจเดฟเดฒเดฏเดฟเดฒเตเดณเตเดณ เดเตเดฒเดฟเดเตพเดเตเดเดพเดฏเดฟ เดชเตเดฒเดเดฟเดจเตเดเตพ เดธเตเดทเตโเดเดฟเดเตเดเตเดจเตเดจเต. เด เดฒเตเดเดคเตเดคเดฟเดจเต เดชเตเดฑเดคเตเดคเต, เดเดพเตป เดเดคเตเดตเดฐเต เด เดคเตเดคเดฐเดฎเตเดฐเต เด เดตเดธเดฐเด เดคเดฟเดฐเดเตเดเตเดเตเดคเตเดคเดฟเดเตเดเดฟเดฒเตเดฒ.
เดญเดพเดเด 1. เดซเตเดฐเตเดฏเดฟเด เดชเตเดฐเตเดเตเดเตเดเตเดชเตเดชเดฟเดเดเต
เด เดธเตเดตเดจเด เดเดเตเดเดจเตเดฏเดพเดฏเดฟเดฐเดฟเดเตเดเตเดฎเตเดจเตเดจเต เดคเตเดฐเตเดฎเดพเดจเดฟเดเตเด เดถเตเดทเด, เดจเดเดชเตเดชเดฟเดฒเดพเดเตเดเตเดจเตเดจเดคเดฟเดจเตเดณเตเดณ เดเดชเตเดทเดจเตเดเตพ เดเดพเตป เดจเตเดเตเดเดพเตป เดคเตเดเดเตเดเดฟ. เดเดฐเตเดคเดฐเด เดฑเตเดกเดฟเดฎเตเดฏเตเดกเต เดชเดฐเดฟเดนเดพเดฐเด เดเดฃเตเดเตเดคเตเดคเตเด เดเดจเตเดจเดคเดพเดฃเต เดเดฑเตเดฑเดตเตเด เดเดณเตเดชเตเดชเดฎเตเดณเตเดณ เดฎเดพเตผเดเด, เด
เดคเดฟเตฝ, เดเดฐเต เดญเตเดเตเดณเดคเตเดคเดฟเดฒเต เดเดฐเต เดฎเตเดเตเดเดฏเตเดชเตเดชเตเดฒเต, เดจเดฟเดเตเดเตพเดเตเดเต เดเดเตเดเดณเตเดเต เดฎเตเดเตเดเดพเดจเดฟเดเตเดเตเดเตพ เดตเดฒเดฟเดเตเดเตเดฑเดฟเดฏเดพเดจเตเด เดชเตเดคเตเดเดจเดพเดญเดฟเดชเตเดฐเดพเดฏเดคเตเดคเดฟเดจเดพเดฏเดฟ เดเดฒเตเดฒเดพเด เดจเดฟเดฐเดคเตเดคเดพเดจเตเด เดเดดเดฟเดฏเตเด.
เดเดจเตเดจเดพเตฝ เดเดคเต เดฐเดธเดเดฐเดฎเดฒเตเดฒ, เดเดคเดฟเตฝ เดเดฐเต เดตเตเดฒเตเดฒเตเดตเดฟเดณเดฟเดฏเตเด เด
เตผเดคเตเดฅเดตเตเด เดเดพเตป เดเดฃเตเดเดฟเดฒเตเดฒ, เด
เดคเดฟเดจเดพเตฝ เดเดพเตป เดตเตเดฌเต เดธเดพเดเตเดเตเดคเดฟเดเดตเดฟเดฆเตเดฏเดเดณเตเด เด
เดตเดฐเตเดฎเดพเดฏเดฟ เดเดเดชเดดเดเตเดจเตเดจ เดฐเตเดคเดฟเดเดณเตเด เดชเด เดฟเดเตเดเดพเตป เดคเตเดเดเตเดเดฟ.
C # .Net-เดฒเต เดฒเตเดเดจเดเตเดเดณเตเด เดกเตเดเตเดฏเตเดฎเตเดจเตเดฑเตเดทเดจเตเดเดณเตเด เดเดฃเตเดเดพเดฃเต เดชเด เดจเด เดเดฐเดเดญเดฟเดเตเดเดคเต. เดเดตเดฟเดเต เดเดพเตป เดเตเดฎเดคเดฒ เดชเตเตผเดคเตเดคเดฟเดฏเดพเดเตเดเดพเตป เดตเดฟเดตเดฟเดง เดฎเดพเตผเดเดเตเดเตพ เดเดฃเตเดเตเดคเตเดคเดฟ. ASP.Net เด เดฒเตเดฒเตเดเตเดเดฟเตฝ Azure เดธเตเดตเดจเดเตเดเตพ เดชเตเดฒเตเดฏเตเดณเตเดณ เดชเตเตผเดฃเตเดฃเดฎเดพเดฏ เดชเดฐเดฟเดนเดพเดฐเดเตเดเตพ เดฎเตเดคเตฝ TcpHttp เดเดฃเดเตเดทเดจเตเดเดณเตเดฎเดพเดฏเตเดณเตเดณ เดจเตเดฐเดฟเดเตเดเตเดณเตเดณ เดเดเดชเตเดเตฝ เดตเดฐเต เดจเตเดฑเตเดฑเตโเดตเตผเดเตเดเตเดฎเดพเดฏเดฟ เดธเดเดตเดฆเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเต เดจเดฟเดฐเดตเดงเดฟ เดธเดเดตเดฟเดงเดพเดจเดเตเดเดณเตเดฃเตเดเต.
เดเดเดธเตเดชเดฟเดฏเตเดฎเดพเดฏเดฟ เดเดฆเตเดฏ เดถเตเดฐเดฎเด เดจเดเดคเตเดคเดฟเดฏเดคเดฟเดจเดพเตฝ, เดเดพเตป เด
เดคเต เดเดเตป เดฑเดฆเตเดฆเดพเดเตเดเดฟ, เดเดเตเดเดณเตเดเต เดธเตเดตเดจเดคเตเดคเดฟเดจเต เดเดคเต เดตเดณเดฐเต เดฌเตเดฆเตเดงเดฟเดฎเตเดเตเดเตเดณเตเดณ เดคเตเดฐเตเดฎเดพเดจเดฎเดพเดฏเดฟเดฐเตเดจเตเดจเต. เด เดชเตเดฒเดพเดฑเตเดฑเตโเดซเตเดฎเดฟเดจเตเดฑเต เดถเตเดทเดฟเดฏเตเดเต เดฎเตเดจเตเดจเดฟเดฒเตเดจเตเดจเต เดชเตเดฒเตเด เดเดเตเดเตพ เดเดชเดฏเตเดเดฟเดเตเดเดฟเดฒเตเดฒ, เด
เดคเดฟเดจเดพเตฝ เดเดพเตป เดเดจเตเดฑเต เดคเดฟเดฐเดฏเตฝ เดคเตเดเตผเดจเตเดจเต. เดเดฟเดธเดฟเดชเดฟ, เดเดเตเดเตเดเดฟเดเดฟเดชเดฟ เดเตเดฒเดฏเดจเตเดฑเต-เดธเตเตผเดตเตผ เดเดจเตเดจเดฟเดตเดฏเตเดเตเดเดฟเดเดฏเดฟเดฒเดพเดฃเต เดคเดฟเดฐเดเตเดเตเดเตเดชเตเดชเต. เดเดตเดฟเดเต, เดนเดฌเตเดฐเตเดฏเดฟเตฝ, เด
เดคเดฟเดจเตเดเตเดเตเดฑเดฟเดเตเดเตเดณเตเดณ เดเดฐเต เดฒเตเดเดจเด เดเดพเตป เดเดฃเตเดเต
เดธเตเตผเดตเดฑเดฟเดจเตเดฑเต เดเดฆเตเดฏ เดชเดคเดฟเดชเตเดชเดฟเตฝ เดเดฃเดเตเดทเดจเตเดเตพ เดเตเดเดพเดฐเตเดฏเด เดเตเดฏเตเดฏเตฝ, เดธเตเดฑเตเดฑเดพเดฑเตเดฑเดฟเดเต เดตเตเดฌเต เดชเตเดเต เดเดณเตเดณเดเดเตเดเด เดจเตฝเดเตฝ, เดเดฐเต เดเดชเดฏเตเดเตเดคเต เดกเดพเดฑเตเดฑเดพเดฌเตเดธเต เดเดจเตเดจเดฟเดต เดเตพเดชเตเดชเตเดเตเดจเตเดจเต. เดคเตเดเดเตเดเดเตเดเดพเตผเดเตเดเดพเดฏเดฟ, เดธเตเดฑเตเดฑเตเดฎเดพเดฏเดฟ เดชเตเดฐเดตเตผเดคเตเดคเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเต เดเดฐเต เดซเดเดเตเดทเดฃเตฝ เดจเดฟเตผเดฎเตเดฎเดฟเดเตเดเดพเตป เดเดพเตป เดคเตเดฐเตเดฎเดพเดจเดฟเดเตเดเต, เด เดคเตเดตเดดเดฟ เดชเดฟเดจเตเดจเตเดเต เดเดจเดฟเดเตเดเต Android, ios เดเดจเตเดจเดฟเดตเดฏเดฟเดฒเต เดเดชเตเดฒเดฟเดเตเดเตเดทเตป เดชเตเดฐเตเดธเดธเตเดธเดฟเดเดเต เดเดตเดฟเดเต เดฌเดจเตเดงเดฟเดชเตเดชเดฟเดเตเดเดพเตป เดเดดเดฟเดฏเตเด.
เดเดฟเดฒ เดเตเดกเต เดเดคเดพ
เด
เดจเดจเตเดคเดฎเดพเดฏ เดฒเตเดชเตเดชเดฟเตฝ เดเตเดฒเดฏเดจเตเดฑเตเดเดณเต เดธเตเดตเตเดเดฐเดฟเดเตเดเตเดจเตเดจ เดชเตเดฐเดงเดพเดจ เดคเตเดฐเตเดกเต:
using System;
using System.Net.Sockets;
using System.Net;
using System.Threading;
namespace ClearServer
{
class Server
{
TcpListener Listener;
public Server(int Port)
{
Listener = new TcpListener(IPAddress.Any, Port);
Listener.Start();
while (true)
{
TcpClient Client = Listener.AcceptTcpClient();
Thread Thread = new Thread(new ParameterizedThreadStart(ClientThread));
Thread.Start(Client);
}
}
static void ClientThread(Object StateInfo)
{
new Client((TcpClient)StateInfo);
}
~Server()
{
if (Listener != null)
{
Listener.Stop();
}
}
static void Main(string[] args)
{
DatabaseWorker sqlBase = DatabaseWorker.GetInstance;
new Server(80);
}
}
}
เดเตเดฒเดฏเดจเตเดฑเต เดนเดพเตปเดกเตโเดฒเตผ เดคเดจเตเดจเต:
using System; using System.IO; using System.Net.Sockets; using System.Text; using System.Text.RegularExpressions; namespace ClearServer { class Client { public Client(TcpClient Client) { string Message = ""; byte[] Buffer = new byte[1024]; int Count; while ((Count = Client.GetStream().Read(Buffer, 0, Buffer.Length)) > 0) { Message += Encoding.UTF8.GetString(Buffer, 0, Count); if (Message.IndexOf("rnrn") >= 0 || Message.Length > 4096) { Console.WriteLine(Message); break; } } Match ReqMatch = Regex.Match(Message, @"^w+s+([^s?]+)[^s]*s+HTTP/.*|"); if (ReqMatch == Match.Empty) { ErrorWorker.SendError(Client, 400); return; } string RequestUri = ReqMatch.Groups[1].Value; RequestUri = Uri.UnescapeDataString(RequestUri); if (RequestUri.IndexOf("..") >= 0) { ErrorWorker.SendError(Client, 400); return; } if (RequestUri.EndsWith("/")) { RequestUri += "index.html"; } string FilePath =
quot;D:/Web/TestSite{RequestUri}";
if (!File.Exists(FilePath))
{
ErrorWorker.SendError(Client, 404);
return;
}string Extension = RequestUri.Substring(RequestUri.LastIndexOf('.'));
string ContentType = "";
switch (Extension)
{
case ".htm":
case ".html":
ContentType = "text/html";
break;
case ".css":
ContentType = "text/css";
break;
case ".js":
ContentType = "text/javascript";
break;
case ".jpg":
ContentType = "image/jpeg";
break;
case ".jpeg":
case ".png":
case ".gif":
ContentType =quot;image/{Extension.Substring(1)}";
break;
default:
if (Extension.Length > 1)
{
ContentType =quot;application/{Extension.Substring(1)}";
}
else
{
ContentType = "application/unknown";
}
break;
}FileStream FS;
try
{
FS = new FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
}
catch (Exception)
{
ErrorWorker.SendError(Client, 500);
return;
}string Headers =
quot;HTTP/1.1 200 OKnContent-Type: {ContentType}nContent-Length: {FS.Length}nn";
byte[] HeadersBuffer = Encoding.ASCII.GetBytes(Headers);
Client.GetStream().Write(HeadersBuffer, 0, HeadersBuffer.Length);while (FS.Position < FS.Length)
{
Count = FS.Read(Buffer, 0, Buffer.Length);
Client.GetStream().Write(Buffer, 0, Count);
}
FS.Close();
Client.Close();
}
}
}
เดฒเตเดเตเดเตฝ SQL-เตฝ เดจเดฟเตผเดฎเตเดฎเดฟเดเตเด เดเดฆเตเดฏเดคเตเดคเต เดกเดพเดฑเตเดฑเดพเดฌเตเดธเต:using System; using System.Data.Linq; namespace ClearServer { class DatabaseWorker { private static DatabaseWorker instance; public static DatabaseWorker GetInstance { get { if (instance == null) instance = new DatabaseWorker(); return instance; } } private DatabaseWorker() { string connectionStr = databasePath; using (DataContext db = new DataContext(connectionStr)) { Table<User> users = db.GetTable<User>(); foreach (var item in users) { Console.WriteLine(
quot;{item.login} {item.password}");
}
}
}
}
}
เดจเดฟเดเตเดเตพเดเตเดเต เดเดพเดฃเดพเดจเดพเดเตเดจเตเดจเดคเตเดชเตเดฒเต, เด เดชเดคเดฟเดชเตเดชเต เดฒเตเดเดจเดคเตเดคเดฟเตฝ เดจเดฟเดจเตเดจเต เดตเดณเดฐเต เดตเตเดฏเดคเตเดฏเดธเตเดคเดฎเดพเดฃเต. เดตเดพเดธเตเดคเดตเดคเตเดคเดฟเตฝ, เดเดฎเตเดชเตเดฏเตเดเตเดเดฑเดฟเดฒเต เดเดฐเต เดซเตเตพเดกเดฑเดฟเตฝ เดจเดฟเดจเตเดจเตเด เดกเดพเดฑเตเดฑเดพเดฌเตเดธเดฟเตฝ เดจเดฟเดจเตเดจเตเด เดชเตเดเตเดเตพ เดฒเตเดกเตเดเตเดฏเตเดฏเตเดจเตเดจเดคเต เดฎเดพเดคเตเดฐเดฎเดพเดฃเต เดเดตเดฟเดเต เดเตเตผเดคเตเดคเดคเต (เดเดคเต เดคเตเดฑเตเดฑเดพเดฏ เดเดฃเดเตเดทเตป เดเตผเดเตเดเดฟเดเตเดเตเดเตผ เดเดพเดฐเดฃเด, เด เดชเดคเดฟเดชเตเดชเดฟเตฝ เดชเตเดฐเดตเตผเดคเตเดคเดฟเดเตเดเดฟเดฒเตเดฒ).เด เดฆเตเดงเตเดฏเดพเดฏเด 2
เดธเตเตผเดตเตผ เดชเดฐเดฟเดถเตเดงเดฟเดเตเด เดถเตเดทเด, เดเดคเต เดเดฐเต เดฎเดฟเดเดเตเด เดชเดฐเดฟเดนเดพเดฐเดฎเดพเดเตเดฎเตเดจเตเดจ เดจเดฟเดเดฎเดจเดคเตเดคเดฟเตฝ เดเดพเตป เดเดคเตเดคเดฟ (เดธเตโเดชเตเดฏเดฟเดฒเตผ: เดเดฒเตเดฒ), เดเดเตเดเดณเตเดเต เดธเตเดตเดจเดคเตเดคเดฟเดจเดพเดฏเดฟ, เด เดคเดฟเดจเดพเตฝ เดชเตเดฐเตเดเดเตเดฑเตเดฑเต เดฒเตเดเดฟเดเต เดธเตเดตเดจเตเดคเดฎเดพเดเตเดเดพเตป เดคเตเดเดเตเดเดฟ.
เดเดเตเดเด เดเดเตเดเดฎเดพเดฏเดฟ, เดชเตเดคเดฟเดฏ เดฎเตเดกเตเดฏเตเดณเตเดเตพ เดชเตเดฐเดคเตเดฏเดเตเดทเดชเตเดชเตเดเดพเตป เดคเตเดเดเตเดเดฟ, เดธเตเตผเดตเดฑเดฟเดจเตเดฑเต เดชเตเดฐเดตเตผเดคเตเดคเดจเด เดตเตผเดฆเตเดงเดฟเดเตเดเต. เดธเตเตผเดตเดฑเดฟเดจเต เดเดฐเต เดเตเดธเตเดฑเตเดฑเต เดกเตเดฎเตเดฏเตโเดจเตเด ssl เดเดฃเดเตเดทเตป เดเตปเดเตเดฐเดฟเดชเตเดทเดจเตเด เดฒเดญเดฟเดเตเดเต.เดธเตเตผเดตเดฑเดฟเดจเตเดฑเต เดฏเตเดเตเดคเดฟเดฏเตเด เดเตเดฒเดฏเดจเตเดฑเตเดเดณเตเดเต เดชเตเดฐเตเดธเดธเตเดธเดฟเดเดเตเด เดตเดฟเดตเดฐเดฟเดเตเดเตเดจเตเดจ เดเตเดฑเดเตเดเตเดเตเดเดฟ เดเตเดกเต
เดเดฐเต เดธเตผเดเตเดเดฟเดซเดฟเดเตเดเดฑเตเดฑเดฟเดจเตเดฑเต เดเดชเดฏเตเดเด เดเตพเดชเตเดชเตเดเต เดธเตเตผเดตเดฑเดฟเดจเตเดฑเต เด เดชเตโเดกเตเดฑเตเดฑเต เดเตเดฏเตโเดค เดชเดคเดฟเดชเตเดชเต.using System; using System.Net; using System.Net.Sockets; using System.Reflection; using System.Security; using System.Security.Cryptography.X509Certificates; using System.Security.Permissions; using System.Security.Policy; using System.Threading; namespace ClearServer { sealed class Server { readonly bool ServerRunning = true; readonly TcpListener sslListner; public static X509Certificate serverCertificate = null; Server() { serverCertificate = X509Certificate.CreateFromSignedFile(@"C:sslitinder.online.crt"); sslListner = new TcpListener(IPAddress.Any, 443); sslListner.Start(); Console.WriteLine("Starting server.." + serverCertificate.Subject + "n" + Assembly.GetExecutingAssembly().Location); while (ServerRunning) { TcpClient SslClient = sslListner.AcceptTcpClient(); Thread SslThread = new Thread(new ParameterizedThreadStart(ClientThread)); SslThread.Start(SslClient); } } static void ClientThread(Object StateInfo) { new Client((TcpClient)StateInfo); } ~Server() { if (sslListner != null) { sslListner.Stop(); } } public static void Main(string[] args) { if (AppDomain.CurrentDomain.IsDefaultAppDomain()) { Console.WriteLine("Switching another domain"); new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase }; var current = AppDomain.CurrentDomain; var strongNames = new StrongName[0]; var domain = AppDomain.CreateDomain( "ClearServer", null, current.SetupInformation, new PermissionSet(PermissionState.Unrestricted), strongNames); domain.ExecuteAssembly(Assembly.GetExecutingAssembly().Location); } new Server(); } } }
ssl เดตเดดเดฟเดฏเตเดณเตเดณ เด เดเดเตเดเดพเดฐเดฎเตเดณเตเดณ เดเดฐเต เดชเตเดคเดฟเดฏ เดเตเดฒเดฏเดจเตเดฑเต เดนเดพเตปเดกเตโเดฒเดฑเตเด:
using ClearServer.Core.Requester; using System; using System.Net.Security; using System.Net.Sockets; namespace ClearServer { public class Client { public Client(TcpClient Client) { SslStream SSlClientStream = new SslStream(Client.GetStream(), false); try { SSlClientStream.AuthenticateAsServer(Server.serverCertificate, clientCertificateRequired: false, checkCertificateRevocation: true); } catch (Exception e) { Console.WriteLine( "---------------------------------------------------------------------n" +
quot;|{DateTime.Now:g}n|------------n|{Client.Client.RemoteEndPoint}n|------------n|Exception: {e.Message}n|------------n|Authentication failed - closing the connection.n" +
"---------------------------------------------------------------------n");
SSlClientStream.Close();
Client.Close();
}
new RequestContext(SSlClientStream, Client);
}
}
}
เดเดจเตเดจเดพเตฝ เดธเตเตผเดตเตผ เดเดฐเต เดเดฟเดธเดฟเดชเดฟ เดเดฃเดเตเดทเดจเดฟเตฝ เดฎเดพเดคเตเดฐเดฎเดพเดฏเดฟ เดชเตเดฐเดตเตผเดคเตเดคเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเดพเตฝ, เด เดญเตเดฏเตผเดคเตเดฅเดจ เดธเดจเตเดฆเตผเดญเด เดคเดฟเดฐเดฟเดเตเดเดฑเดฟเดฏเดพเตป เดเดดเดฟเดฏเตเดจเตเดจ เดเดฐเต เดฎเตเดกเตเดฏเตเตพ เดธเตเดทเตเดเดฟเดเตเดเตเดฃเตเดเดคเต เดเดตเดถเตเดฏเดฎเดพเดฃเต. เดเตเดฒเดฏเดจเตเดฑเดฟเตฝ เดจเดฟเดจเตเดจเตเดณเตเดณ เด เดญเตเดฏเตผเดคเตเดฅเดจเดฏเต เดชเตเดฐเดคเตเดฏเตเด เดญเดพเดเดเตเดเดณเดพเดฏเดฟ เดตเดฟเดญเดเดฟเดเตเดเตเดจเตเดจ เดเดฐเต เดชเดพเดดเตเดธเตผ เดเดตเดฟเดเต เด เดจเตเดฏเตเดเตเดฏเดฎเดพเดฃเตเดจเตเดจเต เดเดพเตป เดคเตเดฐเตเดฎเดพเดจเดฟเดเตเดเต, เด เดคเต เดเตเดฒเดฏเดจเตเดฑเดฟเดจเต เดเดตเดถเตเดฏเดฎเดพเดฏ เดเดคเตเดคเดฐเดเตเดเตพ เดจเตฝเดเตเดจเตเดจเดคเดฟเดจเต เดเดจเดฟเดเตเดเต เดธเดเดตเดฆเดฟเดเตเดเดพเตป เดเดดเดฟเดฏเตเด.เดชเดพเตผเดธเตผ
using ClearServer.Core.UserController; using ReServer.Core.Classes; using System; using System.Collections.Generic; using System.Linq; using System.Net.Security; using System.Net.Sockets; using System.Text; using System.Text.RegularExpressions; namespace ClearServer.Core.Requester { public class RequestContext { public string Message = ""; private readonly byte[] buffer = new byte[1024]; public string RequestMethod; public string RequestUrl; public User RequestProfile; public User CurrentUser = null; public List<RequestValues> HeadersValues; public List<RequestValues> FormValues; private TcpClient TcpClient; private event Action<SslStream, RequestContext> OnRead = RequestHandler.OnHandle; DatabaseWorker databaseWorker = new DatabaseWorker(); public RequestContext(SslStream ClientStream, TcpClient Client) { this.TcpClient = Client; try { ClientStream.BeginRead(buffer, 0, buffer.Length, ClientRead, ClientStream); } catch { return; } } private void ClientRead(IAsyncResult ar) { SslStream ClientStream = (SslStream)ar.AsyncState; if (ar.IsCompleted) { Message = Encoding.UTF8.GetString(buffer); Message = Uri.UnescapeDataString(Message); Console.WriteLine(
quot;n{DateTime.Now:g} Client IP:{TcpClient.Client.RemoteEndPoint}n{Message}");
RequestParse();
HeadersValues = HeaderValues();
FormValues = ContentValues();
UserParse();
ProfileParse();
OnRead?.Invoke(ClientStream, this);
}
}private void RequestParse()
{
Match methodParse = Regex.Match(Message, @"(^w+)s+([^s?]+)[^s]*s+HTTP/.*|");
RequestMethod = methodParse.Groups[1].Value.Trim();
RequestUrl = methodParse.Groups[2].Value.Trim();
}
private void UserParse()
{
string cookie;
try
{
if (HeadersValues.Any(x => x.Name.Contains("Cookie")))
{
cookie = HeadersValues.FirstOrDefault(x => x.Name.Contains("Cookie")).Value;
try
{
CurrentUser = databaseWorker.CookieValidate(cookie);
}
catch { }
}
}
catch { }}
private List<RequestValues> HeaderValues()
{
var values = new List<RequestValues>();
var parse = Regex.Matches(Message, @"(.*?): (.*?)n");
foreach (Match match in parse)
{
values.Add(new RequestValues()
{
Name = match.Groups[1].Value.Trim(),
Value = match.Groups[2].Value.Trim()
});
}
return values;
}
private void ProfileParse()
{
if (RequestUrl.Contains("@"))
{
RequestProfile = databaseWorker.FindUser(RequestUrl.Substring(2));
RequestUrl = "/profile";
}
}
private List<RequestValues> ContentValues()
{
var values = new List<RequestValues>();
var output = Message.Trim('n').Split().Last();
var parse = Regex.Matches(output, @"([^&].*?)=([^&]*b)");
foreach (Match match in parse)
{
values.Add(new RequestValues()
{
Name = match.Groups[1].Value.Trim(),
Value = match.Groups[2].Value.Trim().Replace('+', ' ')
});
}
return values;
}
}
}
เดชเดคเดฟเดตเต เดชเดฆเดชเตเดฐเดฏเตเดเดเตเดเดณเตเดเต เดธเดนเดพเดฏเดคเตเดคเตเดเต เด เดญเตเดฏเตผเดคเตเดฅเดจเดฏเต เดญเดพเดเดเตเดเดณเดพเดฏเดฟ เดตเดฟเดญเดเดฟเดเตเดเตเด เดเดจเตเดจเดคเดพเดฃเต เดเดคเดฟเดจเตเดฑเต เดธเดพเดฐเดพเดเดถเด. เดเตเดฒเดฏเดจเตเดฑเดฟเตฝ เดจเดฟเดจเตเดจเต เดเดเตเดเตพเดเตเดเต เดเดฐเต เดธเดจเตเดฆเตเดถเด เดฒเดญเดฟเดเตเดเตเดจเตเดจเต, เดเดฆเตเดฏ เดตเดฐเดฟ เดคเดฟเดฐเดเตเดเตเดเตเดเตเดเตเด, เด เดคเดฟเตฝ เดฐเตเดคเดฟเดฏเตเด เด เดญเตเดฏเตผเดคเตเดฅเดจ url เดเด เด เดเดเตเดเดฟเดฏเดฟเดฐเดฟเดเตเดเตเดจเตเดจเต. เดคเตเดเตผเดจเตเดจเต เดเดเตเดเตพ เดคเดฒเดเตเดเตเดเตเดเตเดเตพ เดตเดพเดฏเดฟเดเตเดเตเดจเตเดจเต, เด เดคเต เดเดเตเดเตพ HeaderName = เดเดณเตเดณเดเดเตเดเด เดเดจเตเดจ เดซเตเดฎเดฟเดจเตเดฑเต เดเดฐเต เดถเตเดฐเตเดฃเดฟเดฏเดฟเดฒเตเดเตเดเต เดจเดฏเดฟเดเตเดเตเด, เดเตเดเดพเดคเต เดเดเตเดเตพ เดธเดฎเดพเดจเดฎเดพเดฏ เด เดฑเตเดฏเดฟเดฒเตเดเตเดเต เดกเตเดฐเตเดตเต เดเตเดฏเตเดฏเตเดจเตเดจ เด เดจเตเดฌเดจเตเดง เดเดณเตเดณเดเดเตเดเด (เดเดฆเดพเดนเดฐเดฃเดคเตเดคเดฟเดจเต, เดเตเดตเดฑเดฟเดธเตเดเตเดฐเดฟเดเดเต) เดเดฃเตเดเตเดคเตเดคเตเดเดฏเตเด เดเตเดฏเตเดฏเตเดจเตเดจเต. เดเตเดเดพเดคเต, เดจเดฟเดฒเดตเดฟเดฒเต เดเตเดฒเดฏเดจเตเดฑเต เด เดเดเตเดเตเดคเดฎเดพเดฃเต เดเดจเตเดจเต เดชเดพเดดเตโเดธเตผ เดเดฃเตเดเตเดคเตเดคเตเดเดฏเตเด เด เดตเดจเตเดฑเต เดกเดพเดฑเตเดฑ เดธเดเดฐเดเตเดทเดฟเดเตเดเตเดเดฏเตเด เดเตเดฏเตเดฏเตเดจเตเดจเต. เด เดเดเตเดเตเดค เดเตเดฒเดฏเดจเตเดฑเตเดเดณเดฟเตฝ เดจเดฟเดจเตเดจเตเดณเตเดณ เดเดฒเตเดฒเดพ เด เดญเตเดฏเตผเดคเตเดฅเดจเดเดณเดฟเดฒเตเด เดเดฐเต เด เดเดเตเดเตเดค เดนเดพเดทเต เด เดเดเตเดเดฟเดฏเดฟเดฐเดฟเดเตเดเตเดจเตเดจเต, เด เดคเต เดเตเดเตเดเดฟเดเดณเดฟเตฝ เดธเดเดญเดฐเดฟเดเตเดเดฟเดฐเดฟเดเตเดเตเดจเตเดจเต, เดเดคเดฟเดจเต เดจเดจเตเดฆเดฟ, เดฐเดฃเตเดเต เดคเดฐเด เดเตเดฒเดฏเดจเตเดฑเตเดเตพเดเตเดเต เดเตเดเตเดคเตฝ เดตเตผเดเตเดเต เดฒเตเดเดฟเดเต เดตเตเตผเดคเดฟเดฐเดฟเดเตเดเดพเดจเตเด เด เดตเตผเดเตเดเต เดถเดฐเดฟเดฏเดพเดฏ เดเดคเตเดคเดฐเดเตเดเตพ เดจเตฝเดเดพเดจเตเด เดเดดเดฟเดฏเตเด.เดถเดฐเดฟ, "site.com/@UserName" เดชเตเดฒเตเดณเตเดณ เด เดญเตเดฏเตผเดคเตเดฅเดจเดเตพ เดกเตเดจเดพเดฎเดฟเดเต เดเดฏเดฟ เดเดจเดฑเตเดฑเตเดฑเต เดเตเดฏเตเดค เดเดชเดฏเตเดเตเดคเต เดชเตเดเตเดเดณเดพเดเตเดเดฟ เดฎเดพเดฑเตเดฑเตเดจเตเดจ เดเดฐเต เดชเตเดฐเดคเตเดฏเตเด เดฎเตเดกเตเดฏเตเดณเดฟเดฒเตเดเตเดเต เดจเตเดเตเดเตเดฃเตเด เดเตเดฑเตเดคเตเด เดฎเดจเตเดนเดฐเดตเตเดฎเดพเดฏ เดเดฐเต เดซเตเดเตเดเตผ. เด เดญเตเดฏเตผเดคเตเดฅเดจ เดชเตเดฐเตเดธเดธเตเดธเต เดเตเดฏเตเดค เดถเตเดทเด, เดเดจเดฟเดชเตเดชเดฑเดฏเตเดจเตเดจ เดฎเตเดกเตเดฏเตเดณเตเดเตพ เดชเตเดฐเดตเตผเดคเตเดคเดฟเดเตเดเตเดจเตเดจเต.
เด เดงเตเดฏเดพเดฏเด 3. เดนเดพเตปเดกเดฟเตฝเดฌเดพเตผ เดเตปเดธเตเดฑเตเดฑเดพเตพ เดเตเดฏเตเดฏเตเด, เดเตเดฏเดฟเตป เดฒเตเดฌเตเดฐเดฟเดเตเดเตเดฑเตเดฑเต เดเตเดฏเตเดฏเตเด
เดชเดพเตผเดธเตผ เดชเตเตผเดคเตเดคเดฟเดฏเดพเดเตเดเดฟเดฏ เดเดเตป, เดนเดพเตปเดกเตโเดฒเตผ เดชเตเดฐเดตเตผเดคเตเดคเดฟเดเตเดเตเดจเตเดจเต, เดธเตเตผเดตเดฑเดฟเดจเต เดเตเดเตเดคเตฝ เดจเดฟเตผเดฆเตเดฆเตเดถเดเตเดเตพ เดจเตฝเดเตเดเดฏเตเด เดจเดฟเดฏเดจเตเดคเตเดฐเดฃเด เดฐเดฃเตเดเต เดญเดพเดเดเตเดเดณเดพเดฏเดฟ เดตเดฟเดญเดเดฟเดเตเดเตเดเดฏเตเด เดเตเดฏเตเดฏเตเดจเตเดจเต.
เดฒเดณเดฟเดคเดฎเดพเดฏ เดนเดพเตปเดกเตเดฒเตผ
using ClearServer.Core.UserController; using System.Net.Security; namespace ClearServer.Core.Requester { public class RequestHandler { public static void OnHandle(SslStream ClientStream, RequestContext context) { if (context.CurrentUser != null) { new AuthUserController(ClientStream, context); } else { new NonAuthUserController(ClientStream, context); }; } } }
เดตเดพเดธเตเดคเดตเดคเตเดคเดฟเตฝ, เดเดชเดฏเตเดเตเดคเต เด เดเดเตเดเดพเดฐเดคเตเดคเดฟเดจเดพเดฏเดฟ เดเดฐเต เดชเดฐเดฟเดถเตเดงเดจ เดฎเดพเดคเตเดฐเดฎเตเดฏเตเดณเตเดณเต, เด เดคเดฟเดจเตเดถเตเดทเด เด เดญเตเดฏเตผเดคเตเดฅเดจ เดชเตเดฐเตเดธเดธเตเดธเดฟเดเดเต เดเดฐเดเดญเดฟเดเตเดเตเดจเตเดจเต.
เดเตเดฒเดฏเดจเตเดฑเต เดเตบเดเตเดฐเตเดณเตผเดฎเดพเตผ
เดเดชเดฏเตเดเตเดคเดพเดตเดฟเดจเต เด เดเดเตเดเดพเดฐเด เดเดฒเตเดฒเตเดเตเดเดฟเตฝ, เดเดชเดฏเตเดเตเดคเต เดชเตเดฐเตเดซเตเดฒเตเดเดณเตเดเต เดชเตเดฐเดฆเตผเดถเดจเดคเตเดคเตเดฏเตเด เด เดเดเตเดเดพเดฐ เดฐเดเดฟเดธเตเดเตเดฐเตเดทเตป เดตเดฟเตปเดกเตเดฏเตเดฏเตเด เดฎเดพเดคเตเดฐเด เด เดเดฟเดธเตเดฅเดพเดจเดฎเดพเดเตเดเดฟเดฏเตเดณเตเดณเดคเดพเดฃเต เดชเตเดฐเดตเตผเดคเตเดคเดจเดเตเดทเดฎเดค. เดเดฐเต เด เดเดเตเดเตเดค เดเดชเดฏเตเดเตเดคเดพเดตเดฟเดจเตเดณเตเดณ เดเตเดกเต เดเดคเดพเดฃเตเดเต เดธเดฎเดพเดจเดฎเดพเดฃเต, เด เดคเดฟเดจเดพเตฝ เดเดคเต เดคเดจเดฟเดชเตเดชเดเตผเดชเตเดชเดพเดเตเดเดพเดจเตเดณเตเดณ เดเดพเดฐเดฃเดฎเตเดจเตเดจเตเด เดเดพเตป เดเดพเดฃเตเดจเตเดจเดฟเดฒเตเดฒ.เด เดเดเตเดเตเดคเดฎเดฒเตเดฒเดพเดคเตเดค เดเดชเดฏเตเดเตเดคเดพเดตเต
using ClearServer.Core.Requester; using System.IO; using System.Net.Security; namespace ClearServer.Core.UserController { internal class NonAuthUserController { private readonly SslStream ClientStream; private readonly RequestContext Context; private readonly WriteController WriteController; private readonly AuthorizationController AuthorizationController; private readonly string ViewPath = "C:/Users/drdre/source/repos/ClearServer/View"; public NonAuthUserController(SslStream clientStream, RequestContext context) { this.ClientStream = clientStream; this.Context = context; this.WriteController = new WriteController(clientStream); this.AuthorizationController = new AuthorizationController(clientStream, context); ResourceLoad(); } void ResourceLoad() { string[] blockextension = new string[] {"cshtml", "html", "htm"}; bool block = false; foreach (var item in blockextension) { if (Context.RequestUrl.Contains(item)) { block = true; break; } } string FilePath = ""; string Header = ""; var RazorController = new RazorController(Context, ClientStream); switch (Context.RequestMethod) { case "GET": switch (Context.RequestUrl) { case "/": FilePath = ViewPath + "/loginForm.html"; Header =
quot;HTTP/1.1 200 OKnContent-Type: text/html";
WriteController.DefaultWriter(Header, FilePath);
break;
case "/profile":
RazorController.ProfileLoader(ViewPath);
break;
default:
//ะฒ ะดะฐะฝะฝะพะผ ะฑะปะพะบะต ะบะพะดะฐ ะฟัะพะธัั ะพะดะธั ะพััะตัะตะฝะธะต ะทะฐะฟัะพัะพะฒ ะบ ัะตัะฒะตัั ะฟะพ ะฟััะผะพะผั ะฐะดัะตัั ัััะฐะฝะธัั ะฒะธะดะฐ site.com/page.html
if (!File.Exists(ViewPath + Context.RequestUrl) | block)
{
RazorController.ErrorLoader(404);}
else if (Path.HasExtension(Context.RequestUrl) && File.Exists(ViewPath + Context.RequestUrl))
{
Header = WriteController.ContentType(Context.RequestUrl);
FilePath = ViewPath + Context.RequestUrl;
WriteController.DefaultWriter(Header, FilePath);
}
break;
}
break;case "POST":
AuthorizationController.MethodRecognizer();
break;}
}
}
}
เดคเตเตผเดเตเดเดฏเดพเดฏเตเด, เดเดชเดฏเตเดเตเดคเดพเดตเดฟเดจเต เดชเตเดเตเดเดณเตเดเต เดเดฟเดฒ เดเดณเตเดณเดเดเตเดเด เดฒเดญเดฟเดเตเดเดฃเด, เด เดคเดฟเดจเดพเตฝ เดเดคเตเดคเดฐเดเตเดเตพเดเตเดเดพเดฏเดฟ เดเดจเดฟเดชเตเดชเดฑเดฏเตเดจเตเดจ เดฎเตเดกเตเดฏเตเตพ เดเดฃเตเดเต, เด เดคเต เดเดฑเดตเดฟเดเดเตเดเตพเดเตเดเดพเดฏเตเดณเตเดณ เดเดฐเต เด เดญเตเดฏเตผเดคเตเดฅเดจเดฏเตเดเต เดชเตเดฐเดคเดฟเดเดฐเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเต เดเดคเตเดคเดฐเดตเดพเดฆเดฟเดฏเดพเดฃเต.เดฑเตเดฑเตเดฑเตผ เดเตบเดเตเดฐเตเดณเตผ
using System; using System.IO; using System.Net.Security; using System.Text; namespace ClearServer.Core.UserController { public class WriteController { SslStream ClientStream; public WriteController(SslStream ClientStream) { this.ClientStream = ClientStream; } public void DefaultWriter(string Header, string FilePath) { FileStream fileStream; try { fileStream = new FileStream(FilePath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite); Header =
quot;{Header}nContent-Length: {fileStream.Length}nn";
ClientStream.Write(Encoding.UTF8.GetBytes(Header));
byte[] response = new byte[fileStream.Length];
fileStream.BeginRead(response, 0, response.Length, OnFileRead, response);
}
catch { }
}public string ContentType(string Uri)
{
string extension = Path.GetExtension(Uri);
string Header = "HTTP/1.1 200 OKnContent-Type:";
switch (extension)
{
case ".html":
case ".htm":
returnquot;{Header} text/html";
case ".css":
returnquot;{Header} text/css";
case ".js":
returnquot;{Header} text/javascript";
case ".jpg":
case ".jpeg":
case ".png":
case ".gif":
returnquot;{Header} image/{extension}";
default:
if (extension.Length > 1)
{
returnquot;{Header} application/" + extension.Substring(1);
}
else
{
returnquot;{Header} application/unknown";
}
}
}public void OnFileRead(IAsyncResult ar)
{
if (ar.IsCompleted)
{
var file = (byte[])ar.AsyncState;
ClientStream.BeginWrite(file, 0, file.Length, OnClientSend, null);
}
}
public void OnClientSend(IAsyncResult ar)
{
if (ar.IsCompleted)
{
ClientStream.Close();
}
}
}
เดเดจเตเดจเดพเตฝ เดเดชเดฏเตเดเตเดคเดพเดตเดฟเดจเต เด เดตเดจเตเดฑเต เดชเตเดฐเตเดซเตเดฒเตเด เดฎเดฑเตเดฑเต เดเดชเดฏเตเดเตเดคเดพเดเตเดเดณเตเดเต เดชเตเดฐเตเดซเตเดฒเตเดเดณเตเด เดเดพเดฃเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเต, RazorEngine เด เดฒเตเดฒเตเดเตเดเดฟเตฝ เด เดคเดฟเดจเตเดฑเต เดเดฐเต เดญเดพเดเด เดเดชเดฏเตเดเดฟเดเตเดเดพเตป เดเดพเตป เดคเตเดฐเตเดฎเดพเดจเดฟเดเตเดเต. เดฎเตเดถเด เด เดญเตเดฏเตผเดคเตเดฅเดจเดเตพ เดเตเดเดพเดฐเตเดฏเด เดเตเดฏเตเดฏเตเดจเตเดจเดคเตเด เดเดเดฟเดคเดฎเดพเดฏ เดชเดฟเดถเดเต เดเตเดกเต เดจเตฝเดเตเดจเตเดจเดคเตเด เดเดคเดฟเตฝ เดเตพเดชเตเดชเตเดเตเดจเตเดจเต.เดฑเตเดธเตผ เดเตบเดเตเดฐเตเดณเตผ
using ClearServer.Core.Requester; using RazorEngine; using RazorEngine.Templating; using System; using System.IO; using System.Net; using System.Net.Security; namespace ClearServer.Core.UserController { internal class RazorController { private RequestContext Context; private SslStream ClientStream; dynamic PageContent; public RazorController(RequestContext context, SslStream clientStream) { this.Context = context; this.ClientStream = clientStream; } public void ProfileLoader(string ViewPath) { string Filepath = ViewPath + "/profile.cshtml"; if (Context.RequestProfile != null) { if (Context.CurrentUser != null && Context.RequestProfile.login == Context.CurrentUser.login) { try { PageContent = new { isAuth = true, Name = Context.CurrentUser.name, Login = Context.CurrentUser.login, Skills = Context.CurrentUser.skills }; ClientSend(Filepath, Context.CurrentUser.login); } catch (Exception e) { Console.WriteLine(e); } } else { try { PageContent = new { isAuth = false, Name = Context.RequestProfile.name, Login = Context.RequestProfile.login, Skills = Context.RequestProfile.skills }; ClientSend(Filepath, "PublicProfile:"+ Context.RequestProfile.login); } catch (Exception e) { Console.WriteLine(e); } } } else { ErrorLoader(404); } } public void ErrorLoader(int Code) { try { PageContent = new { ErrorCode = Code, Message = ((HttpStatusCode)Code).ToString() }; string ErrorPage = "C:/Users/drdre/source/repos/ClearServer/View/Errors/ErrorPage.cshtml"; ClientSend(ErrorPage, Code.ToString()); } catch { } } private void ClientSend(string FilePath, string Key) { var template = File.ReadAllText(FilePath); var result = Engine.Razor.RunCompile(template, Key, null, (object)PageContent); byte[] buffer = System.Text.Encoding.UTF8.GetBytes(result); ClientStream.BeginWrite(buffer, 0, buffer.Length, OnClientSend, ClientStream); } private void OnClientSend(IAsyncResult ar) { if (ar.IsCompleted) { ClientStream.Close(); } } } }
เดคเตเตผเดเตเดเดฏเดพเดฏเตเด, เด เดเดเตเดเตเดค เดเดชเดฏเตเดเตเดคเดพเดเตเดเดณเตเดเต เดธเตเดฅเดฟเดฐเตเดเดฐเดฃเด เดชเตเดฐเดตเตผเดคเตเดคเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเต, เด เดเดเตเดเดพเดฐเด เดเดตเดถเตเดฏเดฎเดพเดฃเต. เด เดเดเตเดเดพเดฐ เดฎเตเดกเตเดฏเตเตพ เดกเดพเดฑเตเดฑเดพเดฌเตเดธเตเดฎเดพเดฏเดฟ เดธเดเดตเดฆเดฟเดเตเดเตเดจเตเดจเต. เดธเตเดฑเตเดฑเดฟเดฒเต เดซเตเดฎเตเดเดณเดฟเตฝ เดจเดฟเดจเตเดจเต เดฒเดญเดฟเดเตเด เดกเดพเดฑเตเดฑ เดธเดจเตเดฆเตผเดญเดคเตเดคเดฟเตฝ เดจเดฟเดจเตเดจเต เดชเดพเดดเตโเดธเต เดเตเดฏเตเดฏเตเดจเตเดจเต, เดเดชเดฏเตเดเตเดคเดพเดตเต เดธเดเดฐเดเตเดทเดฟเดเตเดเดชเตเดชเตเดเตเดเดฏเตเด เดเตเดเตเดเดฟเดเดณเตเด เดธเตเดตเดจเดคเตเดคเดฟเดฒเตเดเตเดเตเดณเตเดณ เดเดเตโเดธเดธเต เดฒเดญเดฟเดเตเดเตเดเดฏเตเด เดเตเดฏเตเดฏเตเดจเตเดจเต.
เด เดเดเตเดเดพเดฐ เดฎเตเดกเตเดฏเตเตพ
using ClearServer.Core.Cookies; using ClearServer.Core.Requester; using ClearServer.Core.Security; using System; using System.Linq; using System.Net.Security; using System.Text; namespace ClearServer.Core.UserController { internal class AuthorizationController { private SslStream ClientStream; private RequestContext Context; private UserCookies cookies; private WriteController WriteController; DatabaseWorker DatabaseWorker; RazorController RazorController; PasswordHasher PasswordHasher; public AuthorizationController(SslStream clientStream, RequestContext context) { ClientStream = clientStream; Context = context; DatabaseWorker = new DatabaseWorker(); WriteController = new WriteController(ClientStream); RazorController = new RazorController(context, clientStream); PasswordHasher = new PasswordHasher(); } internal void MethodRecognizer() { if (Context.FormValues.Count == 2 && Context.FormValues.Any(x => x.Name == "password")) Authorize(); else if (Context.FormValues.Count == 3 && Context.FormValues.Any(x => x.Name == "regPass")) Registration(); else { RazorController.ErrorLoader(401); } } private void Authorize() { var values = Context.FormValues; var user = new User() { login = values[0].Value, password = PasswordHasher.PasswordHash(values[1].Value) }; user = DatabaseWorker.UserAuth(user); if (user != null) { cookies = new UserCookies(user.login, user.password); user.cookie = cookies.AuthCookie; DatabaseWorker.UserUpdate(user); var response = Encoding.UTF8.GetBytes(
quot;HTTP/1.1 301 Moved PermanentlynLocation: /@{user.login}nSet-Cookie: {cookies.AuthCookie}; Expires={DateTime.Now.AddDays(2):R}; Secure; HttpOnlynn");
ClientStream.BeginWrite(response, 0, response.Length, WriteController.OnClientSend, null);}
else
{
RazorController.ErrorLoader(401);}
}private void Registration()
{
var values = Context.FormValues;
var user = new User()
{
name = values[0].Value,
login = values[1].Value,
password = PasswordHasher.PasswordHash(values[2].Value),
};
cookies = new UserCookies(user.login, user.password);
user.cookie = cookies.AuthCookie;
if (DatabaseWorker.LoginValidate(user.login))
{
Console.WriteLine("User ready");
Console.WriteLine(quot;{user.password} {user.password.Trim().Length}");
DatabaseWorker.UserRegister(user);
var response = Encoding.UTF8.GetBytes(
quot;HTTP/1.1 301 Moved PermanentlynLocation: /@{user.login}nSet-Cookie: {user.cookie}; Expires={DateTime.Now.AddDays(2):R}; Secure; HttpOnlynn");
ClientStream.BeginWrite(response, 0, response.Length, WriteController.OnClientSend, null);
}
else
{
RazorController.ErrorLoader(401);
}
}
}
}
เดกเดพเดฑเตเดฑเดพเดฌเตเดธเต เดเดเตเดเดจเตเดฏเดพเดฃเต เดเดพเดฃเดชเตเดชเตเดเตเดจเตเดจเดคเต:เดกเดพเดฑเตเดฑเดพเดฌเตเดธเต
using ClearServer.Core.UserController; using System; using System.Data.Linq; using System.Linq; namespace ClearServer { class DatabaseWorker { private readonly Table<User> users = null; private readonly DataContext DataBase = null; private const string connectionStr = @"ะฟัััะบะฑะฐะทะต"; public DatabaseWorker() { DataBase = new DataContext(connectionStr); users = DataBase.GetTable<User>(); } public User UserAuth(User User) { try { var user = users.SingleOrDefault(t => t.login.ToLower() == User.login.ToLower() && t.password == User.password); if (user != null) return user; else return null; } catch (Exception) { return null; } } public void UserRegister(User user) { try { users.InsertOnSubmit(user); DataBase.SubmitChanges(); Console.WriteLine(
quot;User{user.name} with id {user.uid} added");
foreach (var item in users)
{
Console.WriteLine(item.login + "n");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}}
public bool LoginValidate(string login)
{
if (users.Any(x => x.login.ToLower() == login.ToLower()))
{
Console.WriteLine("Login already exists");
return false;
}
return true;
}
public void UserUpdate(User user)
{
var UserToUpdate = users.FirstOrDefault(x => x.uid == user.uid);
UserToUpdate = user;
DataBase.SubmitChanges();
Console.WriteLine(quot;User {UserToUpdate.name} with id {UserToUpdate.uid} updated");
foreach (var item in users)
{
Console.WriteLine(item.login + "n");
}
}
public User CookieValidate(string CookieInput)
{
User user = null;
try
{
user = users.SingleOrDefault(x => x.cookie == CookieInput);
}
catch
{
return null;
}
if (user != null) return user;
else return null;
}
public User FindUser(string login)
{
User user = null;
try
{
user = users.Single(x => x.login.ToLower() == login.ToLower());
if (user != null)
{
return user;
}
else
{
return null;
}
}
catch (Exception)
{
return null;
}
}
}
}
เดเตเดฒเตเดเตเดเต เดตเตผเดเตเดเต, เด เดเดเตเดเดพเดฐเด, เดฐเดเดฟเดธเตเดเตเดฐเตเดทเตป เดเตเดฒเดฟเดเตพ เดเดจเตเดจเดฟเดต เดชเตเดฒเต เดเดฒเตเดฒเดพเด เดชเตเดฐเดตเตผเดคเตเดคเดฟเดเตเดเตเดจเตเดจเต, เดธเตเดตเดจเดคเตเดคเดฟเดฒเตเดเตเดเตเดณเตเดณ เดเดเตโเดธเดธเดฟเดจเตเดฑเต เดเดฑเตเดฑเดตเตเด เดเตเดฑเดเตเด เดชเตเดฐเดตเตผเดคเตเดคเดจเด เดเดคเดฟเดจเดเด เดฒเดญเตเดฏเดฎเดพเดฃเต, เดเตเดเดพเดคเต เดเดฐเต เดเดชเตเดฒเดฟเดเตเดเตเดทเตป เดเดดเตเดคเดพเดจเตเด เดเดฒเตเดฒเดพเด เดชเตเตผเดคเตเดคเดฟเดฏเดพเดเตเดเดฟเดฏ เดชเตเดฐเดงเดพเดจ เดชเตเดฐเดตเตผเดคเตเดคเดจเดเตเดเดณเตเดฎเดพเดฏเดฟ เดฎเตเดดเตเดตเตป เดเดพเดฐเตเดฏเดตเตเด เดฌเดจเตเดงเดฟเดชเตเดชเดฟเดเตเดเดพเดจเตเด เดธเดฎเดฏเดฎเดพเดฏเดฟ.เด เดงเตเดฏเดพเดฏเด 4
เดฐเดฃเตเดเต เดชเตเดฒเดพเดฑเตเดฑเตเดซเตเดฎเตเดเตพเดเตเดเดพเดฏเดฟ เดฐเดฃเตเดเต เดเดชเตเดฒเดฟเดเตเดเตเดทเดจเตเดเตพ เดเดดเตเดคเตเดจเตเดจเดคเดฟเดจเตเดณเตเดณ เดคเตเดดเดฟเตฝ เดเตเดฒเดตเต เดเตเดฑเดฏเตเดเตเดเตเดจเตเดจเดคเดฟเดจเต, Xamarin.Forms-เตฝ เดเดฐเต เดเตเดฐเตเดธเต เดชเตเดฒเดพเดฑเตเดฑเตเดซเตเด เดเดฃเตเดเดพเดเตเดเดพเตป เดเดพเตป เดคเตเดฐเตเดฎเดพเดจเดฟเดเตเดเต. เดตเตเดฃเตเดเตเด, เด เดคเต C#-เตฝ เดเดฏเดคเดฟเดจเต เดจเดจเตเดฆเดฟ. เดธเตเตผเดตเดฑเดฟเดฒเตเดเตเดเต เดกเดพเดฑเตเดฑ เด เดฏเดฏเตเดเตเดเตเดจเตเดจ เดเดฐเต เดเตเดธเตเดฑเตเดฑเต เดเดชเตเดฒเดฟเดเตเดเตเดทเตป เดเดฃเตเดเดพเดเตเดเดฟเดฏ เดถเตเดทเด, เดเดพเตป เดฐเดธเดเดฐเดฎเดพเดฏ เดเดฐเต เดจเดฟเดฎเดฟเดทเดคเตเดคเดฟเดฒเตเดเตเดเต เดเดเดฟ. เดเดชเดเดฐเดฃเดคเตเดคเดฟเตฝ เดจเดฟเดจเตเดจเตเดณเตเดณ เดเดฐเต เด เดญเตเดฏเตผเดคเตเดฅเดจเดฏเตเดเตเดเดพเดฏเดฟ, เดตเดฟเดจเตเดฆเดคเตเดคเดฟเดจเดพเดฏเดฟ, เดเดพเตป เดเดคเต HttpClient-เตฝ เดจเดเดชเตเดชเดฟเดฒเดพเดเตเดเดฟ, json เดซเตเตผเดฎเดพเดฑเตเดฑเดฟเดฒเตเดณเตเดณ เด เดเดเตเดเดพเดฐ เดซเตเดฎเดฟเตฝ เดจเดฟเดจเตเดจเตเดณเตเดณ เดกเดพเดฑเตเดฑ เด เดเดเตเดเตเดจเตเดจ HttpRequestMessage เดธเตเตผเดตเดฑเดฟเตฝ เดเดฑเดฟเดเตเดเต. เดชเตเดฐเดคเตเดฏเตเดเดฟเดเตเดเต เดเดจเตเดจเตเด เดชเตเดฐเดคเตเดเตเดทเดฟเดเตเดเดพเดคเต, เดเดพเตป เดธเตเตผเดตเตผ เดฒเตเดเต เดคเตเดฑเดจเตเดจเต เด เดตเดฟเดเตเดฏเตเดณเตเดณ เดเดฒเตเดฒเดพ เดกเดพเดฑเตเดฑเดฏเตเด เดเดณเตเดณ เดเดชเดเดฐเดฃเดคเตเดคเดฟเตฝ เดจเดฟเดจเตเดจเต เดเดฐเต เด เดญเตเดฏเตผเดคเตเดฅเดจ เดเดฃเตเดเต. เดจเตเดฐเดฟเดฏ เดฎเดฏเดเตเดเด, เดเดดเดฟเดเตเด 3 เดเดดเตโเดเดเตพ เดเตเดทเตเดฃเดฟเดเตเด เดธเดพเดฏเดพเดนเตเดจเดคเตเดคเดฟเตฝ เดเตเดฏเตโเดค เดเดฒเตเดฒเดพ เดเดพเดฐเตเดฏเดเตเดเดณเตเดเตเดเตเดฑเดฟเดเตเดเตเด เด เดตเดฌเตเดงเด. เด เดฏเดเตเด เดกเดพเดฑเตเดฑเดฏเตเดเต เดเตเดคเตเดฏเดค เดชเดฐเดฟเดถเตเดงเดฟเดเตเดเดพเตป, เดเดพเตป HttpListner-เตฝ เดเดฐเต เดเตเดธเตเดฑเตเดฑเต เดธเตเตผเดตเตผ เด เดธเดเดฌเดฟเตพ เดเตเดฏเตเดคเต. เด เดคเดฟเตฝ เดเดคเดฟเดจเดเด เดคเดจเตเดจเต เด เดเตเดคเตเดค เด เดญเตเดฏเตผเดคเตเดฅเดจ เดฒเดญเดฟเดเตเดเดคเดฟเดจเดพเตฝ, เดเดพเตป เด เดคเต เดฐเดฃเตเดเต เดตเดฐเดฟ เดเตเดกเตเดเดณเดพเดฏเดฟ เดฎเดพเดฑเตเดฑเดฟ, เดซเตเดฎเดฟเตฝ เดจเดฟเดจเตเดจเต KeyValuePair เดกเดพเดฑเตเดฑ เดฒเดญเดฟเดเตเดเต. เด เดจเตเดตเตเดทเดฃ เดชเดพเดดเตโเดธเดฟเดเดเต เดฐเดฃเตเดเต เดตเดฐเดฟเดเดณเดพเดฏเดฟ เดเตเดฐเตเดเตเดเดฟ.
เดเดพเตป เดเตเดเตเดคเตฝ เดชเดฐเตเดเตเดทเดฟเดเตเดเดพเตป เดคเตเดเดเตเดเดฟ, เดเดคเต เดฎเตเดฎเตเดชเต เดธเตเดเดฟเดชเตเดชเดฟเดเตเดเดฟเดเตเดเดฟเดฒเตเดฒ, เดเดจเตเดจเดพเตฝ เดฎเตเดฎเตเดชเดคเตเดคเต เดธเตเตผเดตเดฑเดฟเตฝ เดเดพเตป เดเดชเตเดชเตเดดเตเด เดตเตเดฌเตโเดธเตเดเตเดเดฑเตเดฑเตเดเดณเดฟเตฝ เดจเดฟเตผเดฎเตเดฎเดฟเดเตเด เดเดฐเต เดเดพเดฑเตเดฑเต เดจเดเดชเตเดชเดฟเดฒเดพเดเตเดเดฟ. เดเดคเต เดตเดณเดฐเต เดจเดจเตเดจเดพเดฏเดฟ เดชเตเดฐเดตเตผเดคเตเดคเดฟเดเตเดเต, เดชเดเตเดทเต Tcp เดตเดดเดฟเดฏเตเดณเตเดณ เดเดเดชเตเดเดฒเดฟเดจเตเดฑเต เดคเดคเตเดตเด เดจเดฟเดฐเดพเดถเดพเดเดจเดเดฎเดพเดฏเดฟเดฐเตเดจเตเดจเต, เดเดคเตเดคเดฟเดเดชเดพเดเตเดเตพ เดฒเตเดเดฟเตป เดเตเดฏเตเดฏเตเดจเตเดจเดคเดฟเดฒเตเดเต เดฐเดฃเตเดเต เดเดชเดฏเตเดเตเดคเดพเดเตเดเดณเตเดเต เดเดเดชเตเดเตฝ เดถเดฐเดฟเดฏเดพเดฏเดฟ เดจเดฟเตผเดฎเตเดฎเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเต เดตเดณเดฐเตเดฏเดงเดฟเดเด เด เดงเดฟเดเดฎเดพเดฏเดฟ เดจเดฟเตผเดฎเตเดฎเดฟเดเตเดเตเดฃเตเดเดคเตเดฃเตเดเต. RFC 6455 เดชเตเดฐเตเดเตเดเตเดเตเดเตเตพ เดเดชเดฏเตเดเดฟเดเตเดเต เดเดฃเดเตเดทเตป เดธเตเดตเดฟเดเตเดเดฟเดเดเดฟเดจเตเดณเตเดณ เดเดฐเต เด เดญเตเดฏเตผเดคเตเดฅเดจ เดชเดพเดดเตโเดธเต เดเตเดฏเตเดฏเตเดจเตเดจเดคเตเด เดชเตเดฐเดคเดฟเดเดฐเดฃเด เดถเตเดเดฐเดฟเดเตเดเตเดจเตเดจเดคเตเด เดเดคเดฟเตฝ เดเตพเดชเตเดชเตเดเตเดจเตเดจเต. เด เดคเดฟเดจเดพเตฝ, เดเตเดธเตเดฑเตเดฑเต เดธเตเตผเดตเดฑเดฟเตฝ, เดเดฐเต เดฒเดณเดฟเดคเดฎเดพเดฏ เดตเตเดฌเตโเดธเตเดเตเดเดฑเตเดฑเต เดเดฃเดเตเดทเตป เดธเตเดทเตเดเดฟเดเตเดเดพเตป เดเดพเตป เดคเตเดฐเตเดฎเดพเดจเดฟเดเตเดเต. เดชเตเตผเดฃเตเดฃเดฎเดพเดฏเตเด เดคเดพเตฝเดชเตเดชเดฐเตเดฏเดคเตเดคเดฟเดจเต เดตเตเดฃเตเดเดฟ.
เดเดพเดฑเตเดฑเต เดเดฃเดเตเดทเตป
private static async void HandleWebsocket(HttpListenerContext context) { var socketContext = await context.AcceptWebSocketAsync(null); var socket = socketContext.WebSocket; Locker.EnterWriteLock(); try { Clients.Add(socket); } finally { Locker.ExitWriteLock(); } while (true) { var buffer = new ArraySegment<byte>(new byte[1024]); var result = await socket.ReceiveAsync(buffer, CancellationToken.None); var str = Encoding.Default.GetString(buffer); Console.WriteLine(str); for (int i = 0; i < Clients.Count; i++) { WebSocket client = Clients[i]; try { if (client.State == WebSocketState.Open) { await client.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); } } catch (ObjectDisposedException) { Locker.EnterWriteLock(); try { Clients.Remove(client); i--; } finally { Locker.ExitWriteLock(); } } } } }
เด เดคเต เดชเตเดฐเดตเตผเดคเตเดคเดฟเดเตเดเตเดเดฏเตเด เดเตเดฏเตเดคเต. เดธเตเตผเดตเตผ เดคเดจเตเดจเต เดเดฃเดเตเดทเตป เดธเดเตเดเดฎเดพเดเตเดเดฟ, เดเดฐเต เดชเตเดฐเดคเดฟเดเดฐเดฃ เดเต เดธเตเดทเตเดเดฟเดเตเดเต. เดเดจเดฟเดเตเดเต ssl เดตเดดเดฟ เดธเตเตผเดตเตผ เดฐเดเดฟเดธเตเดเตเดฐเตเดทเตป เดตเตเดตเตเดตเตเดฑเต เดเตเตบเดซเดฟเดเตผ เดเตเดฏเตเดฏเตเดฃเตเดเดคเดฟเดฒเตเดฒ, เดเดตเดถเตเดฏเดฎเดพเดฏ เดชเตเตผเดเตเดเดฟเตฝ เดธเดฟเดธเตเดฑเตเดฑเดคเตเดคเดฟเดจเต เดเดคเดฟเดจเดเด เดเดฐเต เดธเตผเดเตเดเดฟเดซเดฟเดเตเดเดฑเตเดฑเต เดเตปเดธเตเดฑเตเดฑเดพเตพ เดเตเดฏเตเดคเดพเตฝ เดฎเดคเดฟ.
เดเดชเดเดฐเดฃเดคเตเดคเดฟเดจเตเดฑเต เดตเดถเดคเตเดคเตเด เดธเตเดฑเตเดฑเดฟเดจเตเดฑเต เดตเดถเดคเตเดคเตเด, เดฐเดฃเตเดเต เดเตเดฒเดฏเดจเตเดฑเตเดเตพ เดธเดจเตเดฆเตเดถเดเตเดเตพ เดเตเดฎเดพเดฑเดฟ, เดเดคเตเดฒเตเดฒเดพเด เดฒเตเดเต เดเตเดฏเตเดคเต. เดตเดฒเดฟเดฏ เดชเดพเดดเตโเดธเดฑเตเดเดณเตเดจเตเดจเตเด เดธเตเตผเดตเดฑเดฟเดจเต เดฎเดจเตเดฆเดเดคเดฟเดฏเดฟเดฒเดพเดเตเดเตเดจเตเดจเดฟเดฒเตเดฒ, เดเดคเตเดจเตเดจเตเด เดเดตเดถเตเดฏเดฎเดฟเดฒเตเดฒ. เดชเตเดฐเดคเดฟเดเดฐเดฃ เดธเดฎเดฏเด 200ms เตฝ เดจเดฟเดจเตเดจเต 40-30ms เดเดฏเดฟ เดเตเดฑเดเตเดเต. เดชเดฟเดจเตเดจเต เดเดพเตป เดถเดฐเดฟเดฏเดพเดฏ เดคเตเดฐเตเดฎเดพเดจเดคเตเดคเดฟเดฒเตเดคเตเดคเดฟ.
Tcp-เดฏเดฟเตฝ เดจเดฟเดฒเดตเดฟเดฒเตเดณเตเดณ เดธเตเตผเดตเตผ เดจเดเดชเตเดชเดฟเดฒเดพเดเตเดเตฝ เดเดดเดฟเดตเดพเดเตเดเดฟ Http-เดจเต เดเตเดดเดฟเตฝ เดเดฒเตเดฒเดพเด เดฎเดพเดฑเตเดฑเดฟเดฏเตเดดเตเดคเตเด. เดเดชเตเดชเตเตพ เดชเตเดฐเตเดเดเตเดฑเตเดฑเต เดชเตเดจเตผเดฐเตเดชเดเตฝเดชเตเดชเดจเดฏเตเดเต เดเดเตเดเดคเตเดคเดฟเดฒเดพเดฃเต, เดชเดเตเดทเต เดชเดฐเดธเตเดชเดฐ เดชเตเดฐเดตเตผเดคเตเดคเดจเดคเตเดคเดฟเดจเตเดฑเต เดคเดฟเดเดเตเดเตเด เดตเตเดฏเดคเตเดฏเดธเตเดคเดฎเดพเดฏ เดคเดคเตเดตเดเตเดเตพ เด เดจเตเดธเดฐเดฟเดเตเดเต. เดเดชเดเดฐเดฃเดเตเดเดณเตเดเตเดฏเตเด เดธเตเดฑเตเดฑเดฟเดจเตเดฑเตเดฏเตเด เดชเตเดฐเดตเตผเดคเตเดคเดจเด เดธเดฎเดจเตเดตเดฏเดฟเดชเตเดชเดฟเดเตเดเตเดเดฏเตเด เดกเตเดฌเดเต เดเตเดฏเตเดฏเตเดเดฏเตเด เดเตเดฏเตเดฏเตเดจเตเดจเต, เดเตเดเดพเดคเต เดเดฐเต เดชเตเดคเต เดเดถเดฏเด เดเดฃเตเดเต, เดเดฐเตเดฏเตเดฐเต เดตเตเดฏเดคเตเดฏเดพเดธเดคเตเดคเดฟเตฝ เดเดชเดเดฐเดฃเดเตเดเตพเดเตเดเต html เดชเตเดเตเดเตพ เดธเตเดทเตเดเดฟเดเตเดเตเดฃเตเดเดคเดฟเดฒเตเดฒ.
เดคเตเดฐเตเดฎเดพเดจเด
"เดเตเดเตเด เด เดฑเดฟเดฏเดพเดคเต, เดตเตเดณเตเดณเดคเตเดคเดฟเดฒเตเดเตเดเต เดคเดฒ เดเตเดคเตเดคเดฐเตเดคเต" เดเตเดฒเดฟ เดเดฐเดเดญเดฟเดเตเดเตเดจเตเดจเดคเดฟเดจเต เดฎเตเดฎเตเดชเต, เดฒเดเตเดทเตเดฏเดเตเดเดณเตเด เดฒเดเตเดทเตเดฏเดเตเดเดณเตเด เดเดพเตป เดเตเดเตเดคเตฝ เดตเตเดฏเดเตเดคเดฎเดพเดฏเดฟ เดจเดฟเตผเดตเดเดฟเดเตเดเตเดเดฏเตเด เดตเดฟเดตเดฟเดง เดเตเดฒเดฏเดจเตเดฑเตเดเดณเดฟเตฝ เด เดต เดจเดเดชเตเดชเดฟเดฒเดพเดเตเดเตเดจเตเดจเดคเดฟเดจเต เดเดตเดถเตเดฏเดฎเดพเดฏ เดธเดพเดเตเดเตเดคเดฟเดเดตเดฟเดฆเตเดฏเดเดณเตเด เดฐเตเดคเดฟเดเดณเตเด เดชเด เดฟเดเตเดเตเดเดฏเตเด เดเตเดฏเตเดฏเดฃเดฎเตเดจเตเดจเต เดเดพเตป เดเดฐเตเดคเตเดจเตเดจเต. เดชเตเดฐเตเดเดเตโเดฑเตเดฑเต เดเดคเดฟเดจเดเด เดชเตเตผเดคเตเดคเดฟเดฏเดพเดเดพเดฑเดพเดฏเดฟเดฐเดฟเดเตเดเตเดจเตเดจเต, เดชเดเตเดทเต เดเดฟเดฒ เดเดพเดฐเตเดฏเดเตเดเตพ เดเดพเตป เดตเตเดฃเตเดเตเด เดเดเตเดเดจเต เดชเดฟเดดเตเดคเตเดฑเดฟเดเตเดเต เดเดจเตเดจเดคเดฟเดจเตเดเตเดเตเดฑเดฟเดเตเดเต เดธเดเดธเดพเดฐเดฟเดเตเดเดพเตป เดเดพเตป เดตเตเดฃเตเดเตเด เดตเดจเตเดจเตเดเตเดเดพเด. เดตเดฟเดเดธเดจ เดชเตเดฐเดเตเดฐเดฟเดฏเดฏเดฟเตฝ เดเดพเตป เดเดฐเตเดชเดพเดเต เดเดพเดฐเตเดฏเดเตเดเตพ เดชเด เดฟเดเตเดเต, เดเดจเตเดจเดพเตฝ เดญเดพเดตเดฟเดฏเดฟเตฝ เดเตเดเตเดคเตฝ เดชเด เดฟเดเตเดเดพเดจเตเดฃเตเดเต. เดจเดฟเดเตเดเตพ เดเดคเต เดตเดฐเต เดตเดพเดฏเดฟเดเตเดเดฟเดเตเดเตเดฃเตเดเตเดเตเดเดฟเตฝ, เดตเดพเดฏเดฟเดเตเดเดคเดฟเดจเต เดจเดจเตเดฆเดฟ.
เด เดตเดฒเดเดฌเด: www.habr.com