704 lines
28 KiB
C#
704 lines
28 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Net;
|
||
using System.Net.Sockets;
|
||
using System.Text;
|
||
using System.Threading.Tasks;
|
||
using System.Globalization;
|
||
using System.IO;
|
||
|
||
namespace ShowTrend3.Libs
|
||
{
|
||
public class NetClient
|
||
{
|
||
private readonly string ServerStr = "10.10.45.152";
|
||
private readonly int PortStr = 1070;
|
||
private readonly IPEndPoint IpPoint;
|
||
private enum Cmd
|
||
{
|
||
pasp_download = 4,
|
||
history = 20,
|
||
download_nh = 21,
|
||
dir_browse = 23
|
||
}
|
||
|
||
public NetClient()
|
||
{
|
||
IpPoint = new IPEndPoint(IPAddress.Parse(ServerStr), PortStr);
|
||
}
|
||
public Queue<string> DirBrowse(string dir)
|
||
{
|
||
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
|
||
{
|
||
ReceiveTimeout = 5000,
|
||
SendTimeout = 5000
|
||
};
|
||
try
|
||
{
|
||
//Connect
|
||
socket.Connect(IpPoint);
|
||
//SendRequest
|
||
socket.Send(CreateCommand(Cmd.dir_browse, dir, 0).ToArray());
|
||
Queue<string> result = new Queue<string>();
|
||
//GetRequest
|
||
byte mark;
|
||
while (true)
|
||
{
|
||
mark = SocketReceiveByte(ref socket);
|
||
if (mark == 0xff || mark == 0x00)
|
||
break;
|
||
if (mark == 0x01)
|
||
{
|
||
string r = SocketReceiveString(ref socket);
|
||
if (r != "" || r != "." || r != "..")
|
||
result.Enqueue(r);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return new Queue<string>();
|
||
}
|
||
finally
|
||
{
|
||
socket.Disconnect(false);
|
||
}
|
||
}
|
||
public PasportVDP PaspDownload(string dir)
|
||
{
|
||
PasportVDP result = new PasportVDP();
|
||
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
|
||
{
|
||
ReceiveTimeout = 5000,
|
||
SendTimeout = 2000
|
||
};
|
||
try
|
||
{
|
||
//Connect
|
||
socket.Connect(IpPoint);
|
||
//SendRequest
|
||
socket.Send(CreateCommand(Cmd.pasp_download, dir).ToArray());
|
||
|
||
//GetRequest1
|
||
if (SocketReceiveByte(ref socket) != 0x01)
|
||
return result;
|
||
byte[] t = SocketReceiveBytes(ref socket, 15);
|
||
if (t.Length != 15)
|
||
return result;
|
||
//ConvertPasport1
|
||
result.NumberVDP = t[0];
|
||
result.TimeStart = new DateTime(t[1] + t[2] * 256, t[3], t[4], t[5], t[6], t[7]);
|
||
result.TimeEnd = new DateTime(t[8] + t[9] * 256, t[10], t[11], t[12], t[13], t[14]);
|
||
result.HaveDate = true;
|
||
|
||
//GetRequest2
|
||
if (SocketReceiveByte(ref socket) != 0x01)
|
||
return result;
|
||
t = SocketReceiveBytes(ref socket, 1512);
|
||
if (t.Length != 1512)
|
||
return result;
|
||
//ConvertPasport2
|
||
int caret = 0;
|
||
result.KodNPlav = BitConverter.ToInt32(t, 0); caret += 4;
|
||
result.NPlav = ConvertBytesToString(t, caret, 12); caret += 12;
|
||
result.RM = ConvertBytesToString(t, caret, 11); caret += 11;
|
||
result.Splav = ConvertBytesToString(t, caret, 101); caret += 101;
|
||
result._is = ConvertBytesToString(t, caret, 51); caret += 51;
|
||
result.Notd = BitConverter.ToUInt16(t, caret); caret += 2;
|
||
result.VesSlit = BitConverter.ToUInt16(t, caret); caret += 2;
|
||
result.Diam = BitConverter.ToUInt16(t, caret); caret += 2;
|
||
result.PrPl = BitConverter.ToUInt16(t, caret); caret += 2;
|
||
result.Tin = ConvertBytesToString(t, caret, 9); caret += 9;
|
||
result.Dzap = ConvertBytesToString(t, caret, 9); caret += 9;
|
||
result.Dlog = BitConverter.ToUInt16(t, caret); caret += 2;
|
||
result.Last = BitConverter.ToUInt16(t, caret); caret += 2;
|
||
result.Dlper = BitConverter.ToUInt16(t, caret); caret += 2;
|
||
result.Nazn = ConvertBytesToString(t, caret, 51); caret += 51;
|
||
result.Kompl = BitConverter.ToUInt16(t, caret); caret += 2;
|
||
result.Izl = BitConverter.ToUInt16(t, caret); caret += 2;
|
||
result.Robm = BitConverter.ToSingle(t, caret); caret += 4;
|
||
result.Rizol = BitConverter.ToSingle(t, caret); caret += 4;
|
||
result.Dkr = BitConverter.ToUInt16(t, caret); caret += 2;
|
||
result.Nkon = ConvertBytesToString(t, caret, 51); caret += 51;
|
||
result.Pos = ConvertBytesToString(t, caret, 6); caret += 6;
|
||
result.Ukaz = ConvertBytesToString(t, caret, 51); caret += 51;
|
||
result.Zakaz = ConvertBytesToString(t, caret, 51); caret += 51;
|
||
result.Kat = ConvertBytesToString(t, caret, 51); caret += 51;
|
||
result.Pril = ConvertBytesToString(t, caret, 3); caret += 3;
|
||
result.Reserved = ConvertBytesToString(t, caret, 1023); caret += 1023;
|
||
result.HavePasport = true;
|
||
return result;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return result;
|
||
}
|
||
finally
|
||
{
|
||
socket.Disconnect(false);
|
||
}
|
||
}
|
||
public async Task<SortedList<DateTime, int>> TechCycle(int VDP, DateTime TimeStart, DateTime TimeEnd)
|
||
{
|
||
SortedList<DateTime, int> result = new SortedList<DateTime, int>();
|
||
List<Task<Queue<byte>>> tasks = new List<Task<Queue<byte>>>();
|
||
try
|
||
{
|
||
//Check Params
|
||
if (VDP < 0 || (VDP > 50 && VDP < 90) || VDP > 94)
|
||
throw new Exception("Нет печи №" + VDP);
|
||
if (TimeStart > TimeEnd)
|
||
throw new Exception("Не верно задано время.");
|
||
|
||
//PreStart
|
||
DateTime tempDateTime = TimeStart;
|
||
List<string> requests = new List<string>();
|
||
bool flag = false;
|
||
while (!flag)
|
||
{
|
||
requests.Add(
|
||
tempDateTime.Year.ToString() + tempDateTime.Month.ToString("D2") +
|
||
tempDateTime.Day.ToString("D2") + "." + VDP.ToString("D2") + "3");
|
||
flag = (tempDateTime.Year >= TimeEnd.Year &&
|
||
tempDateTime.Month >= TimeEnd.Month &&
|
||
tempDateTime.Day >= TimeEnd.Day);
|
||
tempDateTime = tempDateTime.AddDays(1);
|
||
}
|
||
|
||
//LoadAllList
|
||
if (TimeStart <= DateTime.Now.AddDays(-9) &&
|
||
!await UploadArchiveToServer(VDP, 3, TimeStart, TimeEnd))
|
||
throw new Exception("Не загружен архив.");
|
||
|
||
//SendRequests
|
||
foreach (var e in requests)
|
||
tasks.Add(DownloadAllPackage(CreateCommand(Cmd.download_nh, e).ToArray()));
|
||
|
||
//ConvertResult
|
||
foreach (var e in tasks)
|
||
{
|
||
e.Wait();
|
||
var r = e.Result;
|
||
while (true)
|
||
{
|
||
if (r.Count == 0)
|
||
break;
|
||
string x = "";
|
||
while (r.Peek() != 0x09 && r.Peek() != 0x0a)
|
||
x += ConvertByteToChar(r.Dequeue());
|
||
int value = int.Parse(x);
|
||
r.Dequeue();
|
||
|
||
while (r.Peek() != 0x09 && r.Peek() != 0x0a)
|
||
r.Dequeue();
|
||
r.Dequeue();
|
||
|
||
x = "";
|
||
while (r.Peek() != 0x09 && r.Peek() != 0x0a)
|
||
x += ConvertByteToChar(r.Dequeue());
|
||
DateTime key = ConvertUnixTimeToDateTime(int.Parse(x));
|
||
r.Dequeue();
|
||
if (result.ContainsKey(key))
|
||
result[key] = value;
|
||
else
|
||
result.Add(key, value);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return new SortedList<DateTime, int>();
|
||
}
|
||
}
|
||
public async Task<AnalogSignals> Analog(int VDP, DateTime TimeStart, DateTime TimeEnd, int[] listSignals)
|
||
{
|
||
Queue<Task> tasks = new Queue<Task>();
|
||
List<string> requests = new List<string>();
|
||
try
|
||
{
|
||
//Check Params
|
||
if (VDP < 0 || (VDP > 50 && VDP < 90) || VDP > 94)
|
||
throw new Exception("Нет печи №" + VDP);
|
||
if (TimeStart > TimeEnd)
|
||
throw new Exception("Не верно задано время.");
|
||
//PreStart
|
||
DateTime tempDateTime = TimeStart;
|
||
bool flag = false;
|
||
while (!flag)
|
||
{
|
||
requests.Add(
|
||
tempDateTime.Year.ToString() + tempDateTime.Month.ToString("D2") +
|
||
tempDateTime.Day.ToString("D2") + "." + VDP.ToString("D2") + "1");
|
||
flag = (tempDateTime.Year == TimeEnd.Year &&
|
||
tempDateTime.Month == TimeEnd.Month &&
|
||
tempDateTime.Day == TimeEnd.Day);
|
||
tempDateTime = tempDateTime.AddDays(1);
|
||
TempDir.LockRead(requests.Last());
|
||
}
|
||
|
||
//Load All List
|
||
if (TimeStart <= DateTime.Now.AddDays(-9) &&
|
||
!await UploadArchiveToServer(VDP, 1, TimeStart, TimeEnd))
|
||
throw new Exception("Не загружен архив.");
|
||
|
||
//Send Requests
|
||
foreach (var e in requests)
|
||
tasks.Enqueue(DownloadAllPackage(e));
|
||
|
||
//Result
|
||
AnalogSignals result = new AnalogSignals(VDP){ retAnalogs = listSignals};
|
||
double step = (VDP >= 0 && VDP <= 50) ? 0.5 : 1;
|
||
for (int e = 0; e < requests.Count; e++)
|
||
{
|
||
|
||
await tasks.Dequeue();
|
||
Console.WriteLine("read_" + (e + 1) + ": " + DateTime.Now.ToLongTimeString());
|
||
double secondsCount = 0;
|
||
List<byte?> row = new List<byte?>();
|
||
DateTime d = DateTime.ParseExact(requests[e].Substring(0, 8), "yyyyMMdd", CultureInfo.InvariantCulture).ToUniversalTime();
|
||
int tic = 60;
|
||
while (!TempDir.CanRead(requests[e]))
|
||
{
|
||
await Task.Delay(1000);
|
||
if (tic-- == 0)
|
||
throw new Exception("Занят локальный архив: " + requests[e]);
|
||
}
|
||
using (FileStream r = TempDir.StartRead(requests[e]))
|
||
{
|
||
while (r.Position < r.Length)
|
||
{
|
||
var t = r.ReadByte();
|
||
switch (t)
|
||
{
|
||
case 0xfb:
|
||
if (row.Count != 0 &&
|
||
d.AddSeconds((double)secondsCount) > TimeStart &&
|
||
d.AddSeconds((double)secondsCount) < TimeEnd)
|
||
result.AddSignals(d.AddSeconds((double)secondsCount), row);
|
||
secondsCount = step * BitConverter.ToInt32(new byte[] { (byte)r.ReadByte(), (byte)r.ReadByte(), (byte)r.ReadByte(), (byte)r.ReadByte() }, 0);
|
||
break;
|
||
case 0xfc:
|
||
if (row.Count == 0)
|
||
row.Add(null);
|
||
if (d.AddSeconds((double)secondsCount) > TimeStart &&
|
||
d.AddSeconds((double)secondsCount) < TimeEnd)
|
||
result.AddSignals(d.AddSeconds((double)secondsCount), row);
|
||
for (var j = 0; j < row.Count; j++)
|
||
row[j] = null;
|
||
secondsCount = step * BitConverter.ToInt32(new byte[] { (byte)r.ReadByte(), (byte)r.ReadByte(), (byte)r.ReadByte(), (byte)r.ReadByte() }, 0);
|
||
if (d.AddSeconds((double)secondsCount) > TimeStart &&
|
||
d.AddSeconds((double)secondsCount) < TimeEnd)
|
||
result.AddSignals(d.AddSeconds((double)secondsCount), row);
|
||
break;
|
||
case 0xfe:
|
||
if (row.Count != 0 &&
|
||
d.AddSeconds((double)secondsCount) > TimeStart &&
|
||
d.AddSeconds((double)secondsCount) < TimeEnd)
|
||
result.AddSignals(d.AddSeconds((double)secondsCount), row);
|
||
secondsCount += step * BitConverter.ToInt16(new byte[] { (byte)r.ReadByte(), (byte)r.ReadByte() }, 0);
|
||
break;
|
||
case 0xff:
|
||
if (row.Count != 0 &&
|
||
d.AddSeconds((double)secondsCount) > TimeStart &&
|
||
d.AddSeconds((double)secondsCount) < TimeEnd)
|
||
result.AddSignals(d.AddSeconds((double)secondsCount), row);
|
||
secondsCount += step;
|
||
break;
|
||
default:
|
||
while (row.Count <= t)
|
||
row.Add(null);
|
||
row[t] = (byte)r.ReadByte();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return new AnalogSignals(VDP) { retAnalogs = listSignals };
|
||
}
|
||
finally
|
||
{
|
||
foreach(var e in requests)
|
||
TempDir.FreeRead(e);
|
||
}
|
||
|
||
}
|
||
|
||
private Queue<byte> CreateCommand(Cmd cmd, string val, int dir = 0)
|
||
{
|
||
Queue<byte> q = new Queue<byte>();
|
||
foreach (var e in BitConverter.GetBytes((uint)cmd))
|
||
q.Enqueue(e);
|
||
if (cmd == Cmd.dir_browse)
|
||
q.Enqueue((byte)dir);
|
||
foreach (var e in BitConverter.GetBytes((uint)val.Length))
|
||
q.Enqueue(e);
|
||
foreach (var e in val)
|
||
q.Enqueue((byte)e);
|
||
q.Enqueue(0x00);
|
||
return q;
|
||
}
|
||
private byte SocketReceiveByte(ref Socket socket)
|
||
{
|
||
try
|
||
{
|
||
byte[] t = new byte[1];
|
||
int countbyte = socket.Receive(t);
|
||
if (countbyte != 1)
|
||
throw new Exception("Ошибка получение Байта");
|
||
return t[0];
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return 0xff;
|
||
}
|
||
}
|
||
private bool SocketReceiveBytes(ref Socket socket, ref Queue<byte> q, int length)
|
||
{
|
||
try
|
||
{
|
||
while (length != 0)
|
||
{
|
||
byte[] b = new byte[length];
|
||
int countbytes = socket.Receive(b);
|
||
for (int i = 0; i < countbytes; i++)
|
||
q.Enqueue(b[i]);
|
||
length -= countbytes;
|
||
}
|
||
return true;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return false;
|
||
}
|
||
}
|
||
private byte[] SocketReceiveBytes(ref Socket socket, int length)
|
||
{
|
||
List<byte> result = new List<byte>();
|
||
try
|
||
{
|
||
while (result.Count != length)
|
||
{
|
||
int count = length - result.Count;
|
||
byte[] t = new byte[count];
|
||
int countbytes = socket.Receive(t);
|
||
if (countbytes > 0)
|
||
result.AddRange(t.Take(countbytes));
|
||
}
|
||
return result.ToArray();
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return new byte[0];
|
||
}
|
||
}
|
||
private string SocketReceiveString(ref Socket socket)
|
||
{
|
||
Queue<byte> q = new Queue<byte>();
|
||
if (SocketReceiveBytes(ref socket, ref q, (int)BitConverter.ToUInt32(SocketReceiveBytes(ref socket, 4), 0) + 1))
|
||
return ConvertBytesToString(ref q);
|
||
return "";
|
||
}
|
||
|
||
private async Task<bool> UploadArchiveToServer(int vdp, int type, DateTime tStart, DateTime tEnd)
|
||
{
|
||
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
|
||
{
|
||
ReceiveTimeout = 5000,
|
||
SendTimeout = 5000
|
||
};
|
||
socket.Connect(IpPoint);
|
||
try
|
||
{
|
||
int caret = 0;
|
||
byte[] t = new byte[15];
|
||
foreach (var e in BitConverter.GetBytes((uint)Cmd.history))
|
||
t[caret++] = e;
|
||
t[caret++] = (byte)vdp;
|
||
t[caret++] = (byte)type;
|
||
t[caret++] = 0x01;
|
||
t[caret++] = Convert.ToByte(tStart.Year % 256);
|
||
t[caret++] = Convert.ToByte(tStart.Year / 256);
|
||
t[caret++] = (byte)tStart.Month;
|
||
t[caret++] = (byte)tStart.Day;
|
||
t[caret++] = Convert.ToByte(tEnd.Year % 256);
|
||
t[caret++] = Convert.ToByte(tEnd.Year / 256);
|
||
t[caret++] = (byte)tEnd.Month;
|
||
t[caret++] = (byte)tEnd.Day;
|
||
socket.Send(t);
|
||
while (true)
|
||
{
|
||
byte mark = SocketReceiveByte(ref socket);
|
||
switch (mark)
|
||
{
|
||
case 0x03:
|
||
await Task.Delay(100);
|
||
continue;
|
||
case 0x01:
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return false;
|
||
}
|
||
}
|
||
private async Task<Queue<byte>> DownloadAllPackage(byte[] cmd)
|
||
{
|
||
await Task.Delay(0);
|
||
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
|
||
{
|
||
ReceiveTimeout = 5000,
|
||
SendTimeout = 5000
|
||
};
|
||
Queue<byte> result = new Queue<byte>();
|
||
try
|
||
{
|
||
int TotlalLength = 0;
|
||
socket.Connect(IpPoint);
|
||
socket.Send(cmd);
|
||
byte mark = 0x00;
|
||
do
|
||
{
|
||
mark = SocketReceiveByte(ref socket);
|
||
switch (mark)
|
||
{
|
||
case 0x01:
|
||
if (!SocketReceiveBytes(ref socket, ref result,
|
||
BitConverter.ToInt32(
|
||
SocketReceiveBytes(ref socket, 4), 0)))
|
||
throw new Exception("Ошибка получения части пакета.");
|
||
break;
|
||
case 0x02:
|
||
TotlalLength = BitConverter.ToInt32(SocketReceiveBytes(ref socket, 4), 0);
|
||
break;
|
||
}
|
||
} while (mark != 0xFF);
|
||
return result;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return new Queue<byte>();
|
||
}
|
||
finally
|
||
{
|
||
socket.Disconnect(false);
|
||
}
|
||
}
|
||
private async Task DownloadAllPackage(string name)
|
||
{
|
||
if (TempDir.CheckFileExist(name))
|
||
return;
|
||
var stream = TempDir.StartWrite(name);
|
||
await Task.Delay(0);
|
||
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
|
||
{
|
||
ReceiveTimeout = 5000,
|
||
SendTimeout = 5000
|
||
};
|
||
try
|
||
{
|
||
int TotlalLength = 0;
|
||
socket.Connect(IpPoint);
|
||
socket.Send(CreateCommand(Cmd.download_nh, name).ToArray());
|
||
byte mark = 0x00;
|
||
do
|
||
{
|
||
mark = SocketReceiveByte(ref socket);
|
||
switch (mark)
|
||
{
|
||
case 0x01:
|
||
int size = BitConverter.ToInt32(SocketReceiveBytes(ref socket, 4), 0);
|
||
stream.Write(SocketReceiveBytes(ref socket, size), 0, size);
|
||
break;
|
||
case 0x02:
|
||
TotlalLength = BitConverter.ToInt32(SocketReceiveBytes(ref socket, 4), 0);
|
||
break;
|
||
}
|
||
} while (mark != 0xFF);
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return;
|
||
}
|
||
finally
|
||
{
|
||
TempDir.EndWrite(name);
|
||
stream.Close();
|
||
socket.Disconnect(false);
|
||
}
|
||
}
|
||
|
||
private string ConvertBytesToString(ref Queue<byte> q)
|
||
{
|
||
StringBuilder result = new StringBuilder();
|
||
while (q.Count != 0)
|
||
result.Append(ConvertByteToChar(q.Dequeue()));
|
||
return result.ToString().Trim();
|
||
}
|
||
private string ConvertBytesToString(byte[] b, int caret, int length)
|
||
{
|
||
StringBuilder result = new StringBuilder();
|
||
for (int i = caret; i < length + caret; i++)
|
||
result.Append(ConvertByteToChar(b[i]));
|
||
return result.ToString().Trim();
|
||
}
|
||
private char ConvertByteToChar(byte b)
|
||
{
|
||
char temp;
|
||
switch (b)
|
||
{
|
||
case 0x00: temp = ' '; break;
|
||
case 0x80: temp = 'А'; break;
|
||
case 0x81: temp = 'Б'; break;
|
||
case 0x82: temp = 'В'; break;
|
||
case 0x83: temp = 'Г'; break;
|
||
case 0x84: temp = 'Д'; break;
|
||
case 0x85: temp = 'Е'; break;
|
||
case 0x86: temp = 'Ж'; break;
|
||
case 0x87: temp = 'З'; break;
|
||
case 0x88: temp = 'И'; break;
|
||
case 0x89: temp = 'Й'; break;
|
||
case 0x8a: temp = 'К'; break;
|
||
case 0x8b: temp = 'Л'; break;
|
||
case 0x8c: temp = 'М'; break;
|
||
case 0x8d: temp = 'Н'; break;
|
||
case 0x8e: temp = 'О'; break;
|
||
case 0x8f: temp = 'П'; break;
|
||
case 0x90: temp = 'Р'; break;
|
||
case 0x91: temp = 'С'; break;
|
||
case 0x92: temp = 'Т'; break;
|
||
case 0x93: temp = 'У'; break;
|
||
case 0x94: temp = 'Ф'; break;
|
||
case 0x95: temp = 'Х'; break;
|
||
case 0x96: temp = 'Ц'; break;
|
||
case 0x97: temp = 'Ч'; break;
|
||
case 0x98: temp = 'Ш'; break;
|
||
case 0x99: temp = 'Щ'; break;
|
||
case 0x9a: temp = 'Ъ'; break;
|
||
case 0x9b: temp = 'Ы'; break;
|
||
case 0x9c: temp = 'Ь'; break;
|
||
case 0x9d: temp = 'Э'; break;
|
||
case 0x9e: temp = 'Ю'; break;
|
||
case 0x9f: temp = 'Я'; break;
|
||
case 0xa0: temp = 'а'; break;
|
||
case 0xa1: temp = 'б'; break;
|
||
case 0xa2: temp = 'в'; break;
|
||
case 0xa3: temp = 'г'; break;
|
||
case 0xa4: temp = 'д'; break;
|
||
case 0xa5: temp = 'е'; break;
|
||
case 0xa6: temp = 'ж'; break;
|
||
case 0xa7: temp = 'з'; break;
|
||
case 0xa8: temp = 'и'; break;
|
||
case 0xa9: temp = 'й'; break;
|
||
case 0xaa: temp = 'к'; break;
|
||
case 0xab: temp = 'л'; break;
|
||
case 0xac: temp = 'м'; break;
|
||
case 0xad: temp = 'н'; break;
|
||
case 0xae: temp = 'о'; break;
|
||
case 0xaf: temp = 'п'; break;
|
||
case 0xe0: temp = 'р'; break;
|
||
case 0xe1: temp = 'c'; break;
|
||
case 0xe2: temp = 'т'; break;
|
||
case 0xe3: temp = 'у'; break;
|
||
case 0xe4: temp = 'ф'; break;
|
||
case 0xe5: temp = 'х'; break;
|
||
case 0xe6: temp = 'ц'; break;
|
||
case 0xe7: temp = 'ч'; break;
|
||
case 0xe8: temp = 'ш'; break;
|
||
case 0xe9: temp = 'щ'; break;
|
||
case 0xea: temp = 'ъ'; break;
|
||
case 0xeb: temp = 'ы'; break;
|
||
case 0xec: temp = 'ь'; break;
|
||
case 0xed: temp = 'э'; break;
|
||
case 0xee: temp = 'ю'; break;
|
||
case 0xef: temp = 'я'; break;
|
||
case 0xf0: temp = 'Ё'; break;
|
||
case 0xf1: temp = 'ё'; break;
|
||
default: temp = Convert.ToChar(b); break;
|
||
}
|
||
return temp;
|
||
}
|
||
private DateTime ConvertUnixTimeToDateTime(int unixTimeStamp)
|
||
{
|
||
DateTime dtDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0);
|
||
dtDateTime = dtDateTime.AddSeconds(unixTimeStamp).AddHours(5);
|
||
return dtDateTime;
|
||
}
|
||
|
||
}
|
||
|
||
class Old
|
||
{
|
||
private enum Cmd
|
||
{
|
||
pasp_download = 4,
|
||
history = 20,
|
||
download_nh = 21,
|
||
dir_browse = 23
|
||
}
|
||
private void CreateCommand(ref Queue<Byte> q, Cmd cmd, string val, int dir = 0)
|
||
{
|
||
q.Clear();
|
||
foreach (var e in BitConverter.GetBytes((uint)cmd))
|
||
q.Enqueue(e);
|
||
if (cmd == Cmd.dir_browse)
|
||
q.Enqueue((byte)dir);
|
||
foreach (var e in val)
|
||
q.Enqueue((byte)e);
|
||
q.Enqueue(0x00);
|
||
}
|
||
private bool SocketSendCommand(ref Socket socket, Cmd cmd, string val, int dir = 0)
|
||
{
|
||
try
|
||
{
|
||
int l = 5 + val.Length;
|
||
if (cmd == Cmd.dir_browse)
|
||
l++;
|
||
byte[] s = new byte[l];
|
||
l = 0;
|
||
foreach (var e in BitConverter.GetBytes((uint)cmd))
|
||
s[l++] = e;
|
||
if (cmd == Cmd.dir_browse)
|
||
s[l++] = (byte)dir;
|
||
foreach (var e in val)
|
||
s[l++] = (byte)e;
|
||
socket.Send(s);
|
||
return true;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.Message);
|
||
return false;
|
||
}
|
||
}
|
||
private string ConvertBytesToString(ref Queue<byte> q, int l)
|
||
{
|
||
StringBuilder result = new StringBuilder();
|
||
//for (int i = 0; i < l; i++)
|
||
// result.Append(ConvertByteToChar(q.Dequeue()));
|
||
return result.ToString().Trim();
|
||
}
|
||
|
||
}
|
||
}
|