/// <summary>
/// Read a signed long from the stream (little endian)
/// </summary>
/// <returns></returns>
public long ReadS8le()
{
return(BitConverter.ToInt64(ReadBytesNormalisedLittleEndian(8), 0));
}
public Windows7(byte[] rawBytes, bool is32Bit, int controlSet)
{
Entries = new List <CacheEntry>();
var index = 4;
ControlSet = controlSet;
EntryCount = BitConverter.ToInt32(rawBytes, index);
index = 128;
var position = 0;
if (EntryCount == 0)
{
return;;
}
if (is32Bit)
{
while (index < rawBytes.Length)
{
try
{
var ce = new CacheEntry();
ce.PathSize = BitConverter.ToUInt16(rawBytes, index);
index += 2;
var maxPathSize = BitConverter.ToUInt16(rawBytes, index);
index += 2;
var pathOffset = BitConverter.ToInt32(rawBytes, index);
index += 4;
ce.LastModifiedTimeUTC =
DateTimeOffset.FromFileTime(BitConverter.ToInt64(rawBytes, index)).ToUniversalTime();
if (ce.LastModifiedTimeUTC.Value.Year == 1601)
{
ce.LastModifiedTimeUTC = null;
}
index += 8;
// skip 4 unknown (insertion flags?)
ce.InsertFlags = (AppCompatCache.InsertFlag)BitConverter.ToInt32(rawBytes, index);
index += 4;
// skip 4 unknown (shim flags?)
index += 4;
var ceDataSize = BitConverter.ToUInt32(rawBytes, index);
index += 4;
var dataOffset = BitConverter.ToUInt32(rawBytes, index);
index += 4;
ce.Path = Encoding.Unicode.GetString(rawBytes, pathOffset, ce.PathSize).Replace(@"\??\", "");
if ((ce.InsertFlags & AppCompatCache.InsertFlag.Executed) == AppCompatCache.InsertFlag.Executed)
{
ce.Executed = AppCompatCache.Execute.Yes;
}
else
{
ce.Executed = AppCompatCache.Execute.No;
}
ce.CacheEntryPosition = position;
ce.ControlSet = controlSet;
Entries.Add(ce);
position += 1;
if (Entries.Count == EntryCount)
{
break;
}
}
catch (Exception ex)
{
Log.Error(ex,
"Error parsing cache entry. Position: {Position} Index: {Index}, Error: {Message} ", position, index, ex.Message);
if (Entries.Count < EntryCount)
{
throw;
}
//TODO Report this
Debug.WriteLine(ex.Message);
//take what we can get
break;
}
}
}
else
{
while (index < rawBytes.Length)
{
try
{
var ce1 = new CacheEntry();
ce1.PathSize = BitConverter.ToUInt16(rawBytes, index);
index += 2;
var maxPathSize = BitConverter.ToUInt16(rawBytes, index);
index += 2;
// skip 4 unknown (padding)
index += 4;
var pathOffset = BitConverter.ToInt64(rawBytes, index);
index += 8;
ce1.LastModifiedTimeUTC =
DateTimeOffset.FromFileTime(BitConverter.ToInt64(rawBytes, index)).ToUniversalTime();
index += 8;
// skip 4 unknown (insertion flags?)
ce1.InsertFlags = (AppCompatCache.InsertFlag)BitConverter.ToInt32(rawBytes, index);
index += 4;
// skip 4 unknown (shim flags?)
index += 4;
var ceDataSize = BitConverter.ToUInt64(rawBytes, index);
index += 8;
var dataOffset = BitConverter.ToUInt64(rawBytes, index);
index += 8;
ce1.Path = Encoding.Unicode.GetString(rawBytes, (int)pathOffset, ce1.PathSize).Replace(@"\??\", "");
if ((ce1.InsertFlags & AppCompatCache.InsertFlag.Executed) == AppCompatCache.InsertFlag.Executed)
{
ce1.Executed = AppCompatCache.Execute.Yes;
}
else
{
ce1.Executed = AppCompatCache.Execute.No;
}
ce1.CacheEntryPosition = position;
ce1.ControlSet = controlSet;
Entries.Add(ce1);
position += 1;
if (Entries.Count == EntryCount)
{
break;
}
}
catch (Exception ex)
{
Log.Error(ex,
"Error parsing cache entry. Position: {Position} Index: {Index}, Error: {Message} ", position, index, ex.Message);
//TODO Report this
if (Entries.Count < EntryCount)
{
throw;
}
//take what we can get
break;
}
}
}
}
/// Generates a unique numeric ID. Generated off a GUID and
/// returned as a 64 bit long value
/// </summary>
/// <returns></returns>
public static long GenerateUniqueNumericId()
{
byte[] bytes = Guid.NewGuid().ToByteArray();
return(BitConverter.ToInt64(bytes, 0));
}
public long GetInt64()
{
return(BitConverter.ToInt64(this.GetBytes(8), 0));
}
/// <summary>
/// Compares two streams fast, will fallback to normal stream comaparison if necessary.
/// </summary>
internal static void AssertStreamsAreEqualFast(Stream src, Stream dst)
{
Assert.AreEqual(src.Length, dst.Length);
const int bufferSize = 4 * 1024;
var buffer1 = new byte[bufferSize];
var buffer2 = new byte[bufferSize];
long origDstPosition = dst.Position;
long origSrcPosition = src.Position;
long bytesRead1 = 0;
long bytesRead2 = 0;
while (true)
{
int count1 = src.Read(buffer1, 0, bufferSize);
bytesRead1 += count1;
int count2 = dst.Read(buffer2, 0, bufferSize);
bytesRead2 += count2;
if (count1 != count2 || count1 == 0)
{
break;
}
int iterations = (int)Math.Ceiling((double)count1 / sizeof(Int64));
for (int i = 0; i < iterations; i++)
{
Assert.AreEqual(BitConverter.ToInt64(buffer1, i * sizeof(Int64)), BitConverter.ToInt64(buffer2, i * sizeof(Int64)));
}
}
if (bytesRead1 == bytesRead2)
{
if (bytesRead1 != (src.Length - origSrcPosition))
{
AssertStreamsAreEqual(src, dst);
}
}
else
{
dst.Position = origDstPosition;
src.Position = origSrcPosition;
AssertStreamsAreEqual(src, dst);
}
dst.Position = origDstPosition;
src.Position = origSrcPosition;
}
/// <summary>
/// Configure bytes endian and data type
/// Endian (first character):
/// - ! byte swap (swap pairs of two bytes: based on network order)
/// - < little-endian
/// - > big-endian
///
/// Dtata type(second character)
/// - s string (length third character) only for string
///
/// - c chart
/// - b signed char
///
/// - h short
/// - H unsigend short
/// - i int
/// - I unsigned int
/// - q long long 64 bits
/// - Q unsigned long long
///
/// - f float
/// - d double
///
/// Examples:
///
/// - !>i : byte swap signed int32 big endian
/// - I : unsigned int32 little indian
/// - f : float (32) little endian
/// - !h : signed int16 byte swap
/// - !s10 : byte swap string 10 elements
///
/// </summary>
/// <param name="format"></param>
/// <param name="data"></param>
/// <param name="index"></param>
/// <returns></returns>
public static object Parser(this byte[] data, string format, int index)
{
var byteSwap = format.Contains('!');
var isBigEndian = format.Contains('>');
format = format.TrimStart('!', '<', '>');
var type = format[0];
var changeEndian = isBigEndian == BitConverter.IsLittleEndian;
switch (type)
{
case 's':
{
var len = int.Parse(format.Split(type)[1]);
var res = data.SubArray(index, len, byteSwap);
return(UTF8Encoding.ASCII.GetString(res));
}
case 'b':
{
return((short)(sbyte)data[index]);
}
case 'B':
{
return((ushort)(byte)data[index]);
}
case 'h':
{
var res = data.SubArray(index, 2, byteSwap);
if (changeEndian)
{
Array.Reverse(res);
}
return(BitConverter.ToInt16(res));
}
case 'H':
{
var res = data.SubArray(index, 2, byteSwap);
if (changeEndian)
{
Array.Reverse(res);
}
return(BitConverter.ToUInt16(res));
}
case 'i':
{
var res = data.SubArray(index, 4, byteSwap);
if (changeEndian)
{
Array.Reverse(res);
}
return(BitConverter.ToInt32(res));
}
case 'I':
{
var res = data.SubArray(index, 4, byteSwap);
if (changeEndian)
{
Array.Reverse(res);
}
return(BitConverter.ToUInt32(res));
}
case 'q':
{
var res = data.SubArray(index, 8, byteSwap);
if (changeEndian)
{
Array.Reverse(res);
}
return(BitConverter.ToInt64(res));
}
case 'Q':
{
var res = SubArray(data, index, 8, byteSwap);
if (changeEndian)
{
Array.Reverse(res);
}
return(BitConverter.ToUInt64(res));
}
case 'f':
{
var res = data.SubArray(index, 4, byteSwap);
if (changeEndian)
{
Array.Reverse(res);
}
return(BitConverter.ToSingle(res));
}
case 'd':
{
var res = data.SubArray(index, 8, byteSwap);
if (changeEndian)
{
Array.Reverse(res);
}
return(BitConverter.ToDouble(res));
}
}
throw new ArgumentException("Bad Format parametter");
}
internal Midpoint[] CacheMidpointsAndVerifyHash(int depth, bool skipIndexVerify)
{
var buffer = new byte[4096];
if (depth < 0 || depth > 30)
{
throw new ArgumentOutOfRangeException("depth");
}
var count = Count;
if (count == 0 || depth == 0)
{
return(null);
}
if (skipIndexVerify)
{
Log.Debug("Disabling Verification of PTable");
}
Stream stream = null;
WorkItem workItem = null;
if (Runtime.IsUnixOrMac)
{
workItem = GetWorkItem();
stream = workItem.Stream;
}
else
{
stream = UnbufferedFileStream.Create(_filename, FileMode.Open, FileAccess.Read, FileShare.Read, false,
4096, 4096, false, 4096);
}
try {
int midpointsCount;
Midpoint[] midpoints;
using (MD5 md5 = MD5.Create()) {
try {
midpointsCount = (int)Math.Max(2L, Math.Min((long)1 << depth, count));
midpoints = new Midpoint[midpointsCount];
} catch (OutOfMemoryException exc) {
throw new PossibleToHandleOutOfMemoryException("Failed to allocate memory for Midpoint cache.",
exc);
}
if (skipIndexVerify && (_version >= PTableVersions.IndexV4))
{
if (_midpointsCached == midpointsCount)
{
//index verification is disabled and cached midpoints with the same depth requested are available
//so, we can load them directly from the PTable file
Log.Debug("Loading {midpointsCached} cached midpoints from PTable", _midpointsCached);
long startOffset = stream.Length - MD5Size - PTableFooter.GetSize(_version) -
_midpointsCacheSize;
stream.Seek(startOffset, SeekOrigin.Begin);
for (uint k = 0; k < _midpointsCached; k++)
{
stream.Read(buffer, 0, _indexEntrySize);
IndexEntryKey key;
long index;
if (_version == PTableVersions.IndexV4)
{
key = new IndexEntryKey(BitConverter.ToUInt64(buffer, 8),
BitConverter.ToInt64(buffer, 0));
index = BitConverter.ToInt64(buffer, 8 + 8);
}
else
{
throw new InvalidOperationException("Unknown PTable version: " + _version);
}
midpoints[k] = new Midpoint(key, index);
if (k > 0)
{
if (midpoints[k].Key.GreaterThan(midpoints[k - 1].Key))
{
throw new CorruptIndexException(String.Format(
"Index entry key for midpoint {0} (stream: {1}, version: {2}) < index entry key for midpoint {3} (stream: {4}, version: {5})",
k - 1, midpoints[k - 1].Key.Stream, midpoints[k - 1].Key.Version, k,
midpoints[k].Key.Stream, midpoints[k].Key.Version));
}
else if (midpoints[k - 1].ItemIndex > midpoints[k].ItemIndex)
{
throw new CorruptIndexException(String.Format(
"Item index for midpoint {0} ({1}) > Item index for midpoint {2} ({3})",
k - 1, midpoints[k - 1].ItemIndex, k, midpoints[k].ItemIndex));
}
}
}
return(midpoints);
}
else
{
Log.Debug(
"Skipping loading of cached midpoints from PTable due to count mismatch, cached midpoints: {midpointsCached} / required midpoints: {midpointsCount}",
_midpointsCached, midpointsCount);
}
}
if (!skipIndexVerify)
{
stream.Seek(0, SeekOrigin.Begin);
stream.Read(buffer, 0, PTableHeader.Size);
md5.TransformBlock(buffer, 0, PTableHeader.Size, null, 0);
}
long previousNextIndex = long.MinValue;
var previousKey = new IndexEntryKey(long.MaxValue, long.MaxValue);
for (long k = 0; k < midpointsCount; ++k)
{
long nextIndex = GetMidpointIndex(k, count, midpointsCount);
if (previousNextIndex != nextIndex)
{
if (!skipIndexVerify)
{
ReadUntilWithMd5(PTableHeader.Size + _indexEntrySize * nextIndex, stream, md5);
stream.Read(buffer, 0, _indexKeySize);
md5.TransformBlock(buffer, 0, _indexKeySize, null, 0);
}
else
{
stream.Seek(PTableHeader.Size + _indexEntrySize * nextIndex, SeekOrigin.Begin);
stream.Read(buffer, 0, _indexKeySize);
}
IndexEntryKey key;
if (_version == PTableVersions.IndexV1)
{
key = new IndexEntryKey(BitConverter.ToUInt32(buffer, 4),
BitConverter.ToInt32(buffer, 0));
}
else if (_version == PTableVersions.IndexV2)
{
key = new IndexEntryKey(BitConverter.ToUInt64(buffer, 4),
BitConverter.ToInt32(buffer, 0));
}
else
{
key = new IndexEntryKey(BitConverter.ToUInt64(buffer, 8),
BitConverter.ToInt64(buffer, 0));
}
midpoints[k] = new Midpoint(key, nextIndex);
previousNextIndex = nextIndex;
previousKey = key;
}
else
{
midpoints[k] = new Midpoint(previousKey, previousNextIndex);
}
if (k > 0)
{
if (midpoints[k].Key.GreaterThan(midpoints[k - 1].Key))
{
throw new CorruptIndexException(String.Format(
"Index entry key for midpoint {0} (stream: {1}, version: {2}) < index entry key for midpoint {3} (stream: {4}, version: {5})",
k - 1, midpoints[k - 1].Key.Stream, midpoints[k - 1].Key.Version, k,
midpoints[k].Key.Stream, midpoints[k].Key.Version));
}
else if (midpoints[k - 1].ItemIndex > midpoints[k].ItemIndex)
{
throw new CorruptIndexException(String.Format(
"Item index for midpoint {0} ({1}) > Item index for midpoint {2} ({3})", k - 1,
midpoints[k - 1].ItemIndex, k, midpoints[k].ItemIndex));
}
}
}
if (!skipIndexVerify)
{
ReadUntilWithMd5(stream.Length - MD5Size, stream, md5);
//verify hash (should be at stream.length - MD5Size)
md5.TransformFinalBlock(Empty.ByteArray, 0, 0);
var fileHash = new byte[MD5Size];
stream.Read(fileHash, 0, MD5Size);
ValidateHash(md5.Hash, fileHash);
}
return(midpoints);
}
} catch {
Dispose();
throw;
} finally {
if (Runtime.IsUnixOrMac)
{
if (workItem != null)
{
ReturnWorkItem(workItem);
}
}
else
{
if (stream != null)
{
stream.Dispose();
}
}
}
}
/// <summary>
/// Signature scan.
/// Read data at address which follow matched with the pattern and return it as a pointer.
/// </summary>
/// <param name="pattern">byte pattern signature</param>
/// <param name="offset">offset to read</param>
/// <param name="bRIP">x64 rip relative addressing mode if true</param>
/// <returns>the pointer addresses</returns>
private List <IntPtr> SigScan(string pattern, int offset = 0, bool bRIP = false)
{
if (pattern == null || pattern.Length % 2 != 0)
{
return(new List <IntPtr>());
}
// 1byte = 2char
byte?[] patternByteArray = new byte?[pattern.Length / 2];
// Convert Pattern to "Array of Byte"
for (int i = 0; i < pattern.Length / 2; i++)
{
string text = pattern.Substring(i * 2, 2);
if (text == "??")
{
patternByteArray[i] = null;
}
else
{
patternByteArray[i] = new byte?(Convert.ToByte(text, 16));
}
}
int moduleMemorySize = _process.MainModule.ModuleMemorySize;
IntPtr baseAddress = _process.MainModule.BaseAddress;
IntPtr intPtr_EndOfModuleMemory = IntPtr.Add(baseAddress, moduleMemorySize);
IntPtr intPtr_Scannning = baseAddress;
int splitSizeOfMemory = 65536;
byte[] splitMemoryArray = new byte[splitSizeOfMemory];
List <IntPtr> list = new List <IntPtr>();
// while loop for scan all memory
while (intPtr_Scannning.ToInt64() < intPtr_EndOfModuleMemory.ToInt64())
{
IntPtr nSize = new IntPtr(splitSizeOfMemory);
// if remaining memory size is less than splitSize, change nSize to remaining size
if (IntPtr.Add(intPtr_Scannning, splitSizeOfMemory).ToInt64() > intPtr_EndOfModuleMemory.ToInt64())
{
nSize = (IntPtr)(intPtr_EndOfModuleMemory.ToInt64() - intPtr_Scannning.ToInt64());
}
IntPtr intPtr_NumberOfBytesRead = IntPtr.Zero;
// read memory
if (NativeMethods.ReadProcessMemory(_process.Handle, intPtr_Scannning, splitMemoryArray, nSize, ref intPtr_NumberOfBytesRead))
{
int num = 0;
// slide start point byte bu byte, check with patternByteArray
while ((long)num < intPtr_NumberOfBytesRead.ToInt64() - (long)patternByteArray.Length - (long)offset)
{
int matchCount = 0;
for (int j = 0; j < patternByteArray.Length; j++)
{
// pattern "??" have a null value. in this case, skip the check.
if (!patternByteArray[j].HasValue)
{
matchCount++;
}
else
{
if (patternByteArray[j].Value != splitMemoryArray[num + j])
{
break;
}
matchCount++;
}
}
// if all bytes are match, it means "the pattern found"
if (matchCount == patternByteArray.Length)
{
IntPtr item;
if (bRIP)
{
item = new IntPtr(BitConverter.ToInt32(splitMemoryArray, num + patternByteArray.Length + offset));
item = new IntPtr(intPtr_Scannning.ToInt64() + (long)num + (long)patternByteArray.Length + 4L + item.ToInt64());
}
else if (_mode == FFXIVClientMode.FFXIV_64)
{
item = new IntPtr(BitConverter.ToInt64(splitMemoryArray, num + patternByteArray.Length + offset));
item = new IntPtr(item.ToInt64());
}
else
{
item = new IntPtr(BitConverter.ToInt32(splitMemoryArray, num + patternByteArray.Length + offset));
item = new IntPtr(item.ToInt64());
}
// add the item if not contains already
if (item != IntPtr.Zero && !list.Contains(item))
{
list.Add(item);
}
}
num++;
}
}
intPtr_Scannning = IntPtr.Add(intPtr_Scannning, splitSizeOfMemory - patternByteArray.Length - offset);
}
return(list);
}
// Token: 0x0600008D RID: 141 RVA: 0x000050D4 File Offset: 0x000032D4
private long CVL(int startIndex, int endIndex)
{
checked
{
endIndex++;
byte[] array = new byte[8];
int num = endIndex - startIndex;
bool flag = false;
bool flag2 = num == 0 | num > 9;
long result;
if (flag2)
{
result = 0L;
}
else
{
flag2 = (num == 1);
if (flag2)
{
array[0] = (this.db_bytes[startIndex] & 127);
result = BitConverter.ToInt64(array, 0);
}
else
{
flag2 = (num == 9);
if (flag2)
{
flag = true;
}
int num2 = 1;
int num3 = 7;
int num4 = 0;
flag2 = flag;
if (flag2)
{
array[0] = this.db_bytes[endIndex - 1];
endIndex--;
num4 = 1;
}
for (int i = endIndex - 1; i >= startIndex; i += -1)
{
flag2 = (i - 1 >= startIndex);
if (flag2)
{
array[num4] = (byte)(unchecked (((int)((byte)((uint)this.db_bytes[i] >> (checked (num2 - 1) & 7))) & 255 >> num2) | (int)((byte)(this.db_bytes[checked (i - 1)] << (num3 & 7)))));
num2++;
num4++;
num3--;
}
else
{
flag2 = !flag;
if (flag2)
{
array[num4] = (byte)((int)(unchecked ((byte)((uint)this.db_bytes[i] >> (checked (num2 - 1) & 7)))) & 255 >> num2);
}
}
}
result = BitConverter.ToInt64(array, 0);
}
}
return(result);
}
}
/// <summary>
/// クイックビューを表示
/// </summary>
/// <param name="startIndex"></param>
/// <param name="type"></param>
private void showQuickView(int startIndex, QuickViewType type)
{
var source = Bytes.Skip(startIndex).ToArray();
var showString = string.Empty;
switch (type)
{
case QuickViewType.Byte:
if (source.Length < sizeof(Byte))
{
return;
}
hexTextBox.Select(startIndex * 3, sizeof(Byte) * 3);
showString = string.Format("{0:#,0} (unsigned: {1:#,0})",
(SByte)source[0],
(Byte)source[0]);
break;
case QuickViewType.Int16:
if (source.Length < sizeof(Int16))
{
return;
}
hexTextBox.Select(startIndex * 3, sizeof(Int16) * 3);
showString = string.Format("{0:#,0} (unsigned: {1:#,0})",
BitConverter.ToInt16(source, 0),
BitConverter.ToUInt16(source, 0));
break;
case QuickViewType.Int32:
if (source.Length < sizeof(Int32))
{
return;
}
hexTextBox.Select(startIndex * 3, sizeof(Int32) * 3);
showString = string.Format("{0:#,0} (unsigned: {1:#,0})",
BitConverter.ToInt32(source, 0),
BitConverter.ToUInt32(source, 0));
break;
case QuickViewType.Int64:
if (source.Length < sizeof(Int64))
{
return;
}
hexTextBox.Select(startIndex * 3, sizeof(Int64) * 3);
showString = string.Format("{0:#,0} (unsigned: {1:#,0})",
BitConverter.ToInt64(source, 0),
BitConverter.ToUInt64(source, 0));
break;
case QuickViewType.Single:
if (source.Length < sizeof(Single))
{
return;
}
hexTextBox.Select(startIndex * 3, sizeof(Single) * 3);
showString = string.Format("{0}", BitConverter.ToSingle(source, 0));
break;
}
var point = hexTextBox.PointToClient(Cursor.Position);
point.Offset(0, 15);
quickViewToolTip.Show(showString, hexTextBox, point);
}
private void copyAsInt64ToolStripMenuItem1_Click(object sender, EventArgs e)
{
Clipboard.SetText(
BitConverter.ToInt64(getSelectedBytes(), 0).ToString()
);
}
/// <summary>
/// 从流中读取一个long数据
/// </summary>
/// <returns></returns>
public long ReadLong()
{
byte[] arr = new byte[8];
base.Read(arr, 0, 8);
return(BitConverter.ToInt64(arr, 0));
}
internal miINT64() :
base(buff => BitConverter.ToInt64(buff, 0), 8)
{
}
/// <summary>
/// Read a signed long from the stream (big endian)
/// </summary>
/// <returns></returns>
public long ReadS8be()
{
return(BitConverter.ToInt64(ReadBytesNormalisedBigEndian(8), 0));
}
public Организации(byte[] УникальныйИдентификатор, int Глубина)
{
if (Глубина > 3)
{
return;
}
if (new Guid(УникальныйИдентификатор) == Guid.Empty)
{
return;
}
using (var Подключение = new SqlConnection(СтрокаСоединения))
{
Подключение.Open();
using (var Команда = Подключение.CreateCommand())
{
Команда.CommandText = @"Select top 1
_IDRRef [Ссылка]
,_Version [Версия]
,_Marked [ПометкаУдаления]
,_IsMetadata [Предопределенный]
,_Code [Код]
,_Description [Наименование]
,_Fld1550 [Префикс]
,_Fld1526 [ИНН]
,_Fld1536 [КПП]
,_Fld1553 [РегистрационныйНомерПФР]
,_Fld1524RRef [ГоловнаяОрганизация]
,_Fld1543 [НаименованиеПолное]
,_Fld1535 [КодПоОКПО]
,_Fld1534 [КодПоОКАТО]
,_Fld1529 [КодИМНС]
,_Fld1551 [РайонныйКоэффициент]
,_Fld1562RRef [ЮрФизЛицо]
,_Fld1561RRef [ТерриториальныеУсловияПФР]
,_Fld1549RRef [ОсновнойБанковскийСчет]
,_Fld1523RRef [ВидСтавокЕСНиПФР]
,_Fld1542 [НаименованиеПлательщикаПриПеречисленииНалогов]
,_Fld1527 [ИностраннаяОрганизация]
,_Fld1525 [ДатаРегистрации]
,_Fld1532 [КодОКОПФ]
,_Fld1540 [НаименованиеОКОПФ]
,_Fld1533 [КодОКФС]
,_Fld1541 [НаименованиеОКФС]
,_Fld1558 [СвидетельствоСерияНомер]
,_Fld1555 [СвидетельствоДатаВыдачи]
,_Fld1557 [СвидетельствоНаименованиеОргана]
,_Fld1556 [СвидетельствоКодОргана]
,_Fld1560RRef [СтранаРегистрации]
,_Fld1559RRef [СтранаПостоянногоМестонахождения]
,_Fld1528 [КодВСтранеРегистрации]
,_Fld1548 [ОГРН]
,_Fld1538 [НаименованиеИнострОрганизации]
,_Fld1554 [РегистрационныйНомерФСС]
,_Fld1537 [НаименованиеИМНС]
,_Fld1530 [КодОКВЭД]
,_Fld1539 [НаименованиеОКВЭД]
,_Fld1531 [КодОКОНХ]
,_Fld1563RRef [ИндивидуальныйПредприниматель]
,_Fld1544 [УдалитьОбменЗадействован]
,_Fld1547 [ОбменКодАбонента]
,_Fld1545 [ОбменКаталогОтправкиДанныхОтчетности]
,_Fld1546 [ОбменКаталогПрограммыЭлектроннойПочты]
,_Fld1552 [РайонныйКоэффициентРФ]
,_Fld1564 [ОтражатьВРегламентированномУчете]
,_Fld22976 [КодИФНСПолучателя]
,_Fld22669 [НаименованиеТерриториальногоОрганаПФР]
,_Fld26550 [НаименованиеСокращенное]
,_Fld26551RRef [ВидОбменаСКонтролирующимиОрганами]
,_Fld26552RRef [УчетнаяЗаписьОбмена]
,_Fld26553 [КодОрганаПФР]
,_Fld26554 [КодОрганаФСГС]
,_Fld26555 [ДополнительныйКодФСС]
,_Fld26556 [КодПодчиненностиФСС]
,_Fld26557 [ЦифровойИндексОбособленногоПодразделения]
,_Fld26558 [РегистрационныйНомерТФОМС]
,_Fld26559 [ИПРегистрационныйНомерПФР]
,_Fld26560 [ИПРегистрационныйНомерФСС]
,_Fld26561 [ИПКодПодчиненностиФСС]
,_Fld26562 [ИПРегистрационныйНомерТФОМС]
,_Fld26563 [НаименованиеТерриториальногоОрганаФСС]
From _Reference105(NOLOCK)
Where _IDRRef=@УникальныйИдентификатор " ;
Команда.Parameters.AddWithValue("УникальныйИдентификатор", УникальныйИдентификатор);
using (var Читалка = Команда.ExecuteReader())
{
if (Читалка.Read())
{
//ToDo: Читать нужно через GetValues()
Ссылка = new Guid((byte[])Читалка.GetValue(0));
var ПотокВерсии = ((byte[])Читалка.GetValue(1));
Array.Reverse(ПотокВерсии);
Версия = BitConverter.ToInt64(ПотокВерсии, 0);
ВерсияДанных = Convert.ToBase64String(ПотокВерсии);
ПометкаУдаления = ((byte[])Читалка.GetValue(2))[0] == 1;
Предопределенный = ((byte[])Читалка.GetValue(3))[0] == 1;
Код = Читалка.GetString(4);
Наименование = Читалка.GetString(5);
Префикс = Читалка.GetString(6);
ИНН = Читалка.GetString(7);
КПП = Читалка.GetString(8);
егистрационныйНомерПФР = Читалка.GetString(9);
ГоловнаяОрганизация = new V82.СправочникиСсылка.Организации((byte[])Читалка.GetValue(10), Глубина + 1);
НаименованиеПолное = Читалка.GetString(11);
КодПоОКПО = Читалка.GetString(12);
КодПоОКАТО = Читалка.GetString(13);
КодИМНС = Читалка.GetString(14);
айонныйКоэффициент = Читалка.GetDecimal(15);
ЮрФизЛицо = V82.Перечисления /*Ссылка*/.ЮрФизЛицо.ПустаяСсылка.Получить((byte[])Читалка.GetValue(16));
ТерриториальныеУсловияПФР = new V82.СправочникиСсылка.ТерриториальныеУсловия((byte[])Читалка.GetValue(17), Глубина + 1);
ОсновнойБанковскийСчет = new V82.СправочникиСсылка.БанковскиеСчета((byte[])Читалка.GetValue(18), Глубина + 1);
ВидСтавокЕСНиПФР = V82.Перечисления /*Ссылка*/.ВидыСтавокЕСНиПФР.ПустаяСсылка.Получить((byte[])Читалка.GetValue(19));
НаименованиеПлательщикаПриПеречисленииНалогов = Читалка.GetString(20);
ИностраннаяОрганизация = ((byte[])Читалка.GetValue(21))[0] == 1;
ДатаРегистрации = Читалка.GetDateTime(22);
КодОКОПФ = Читалка.GetString(23);
НаименованиеОКОПФ = Читалка.GetString(24);
КодОКФС = Читалка.GetString(25);
НаименованиеОКФС = Читалка.GetString(26);
СвидетельствоСерияНомер = Читалка.GetString(27);
СвидетельствоДатаВыдачи = Читалка.GetDateTime(28);
СвидетельствоНаименованиеОргана = Читалка.GetString(29);
СвидетельствоКодОргана = Читалка.GetString(30);
СтранаРегистрации = new V82.СправочникиСсылка.КлассификаторСтранМира((byte[])Читалка.GetValue(31), Глубина + 1);
СтранаПостоянногоМестонахождения = new V82.СправочникиСсылка.КлассификаторСтранМира((byte[])Читалка.GetValue(32), Глубина + 1);
КодВСтранеРегистрации = Читалка.GetString(33);
ОГРН = Читалка.GetString(34);
НаименованиеИнострОрганизации = Читалка.GetString(35);
егистрационныйНомерФСС = Читалка.GetString(36);
НаименованиеИМНС = Читалка.GetString(37);
КодОКВЭД = Читалка.GetString(38);
НаименованиеОКВЭД = Читалка.GetString(39);
КодОКОНХ = Читалка.GetString(40);
ИндивидуальныйПредприниматель = new V82.СправочникиСсылка.ФизическиеЛица((byte[])Читалка.GetValue(41), Глубина + 1);
УдалитьОбменЗадействован = ((byte[])Читалка.GetValue(42))[0] == 1;
ОбменКодАбонента = Читалка.GetString(43);
ОбменКаталогОтправкиДанныхОтчетности = Читалка.GetString(44);
ОбменКаталогПрограммыЭлектроннойПочты = Читалка.GetString(45);
айонныйКоэффициентРФ = Читалка.GetDecimal(46);
ОтражатьВРегламентированномУчете = ((byte[])Читалка.GetValue(47))[0] == 1;
КодИФНСПолучателя = Читалка.GetString(48);
НаименованиеТерриториальногоОрганаПФР = Читалка.GetString(49);
НаименованиеСокращенное = Читалка.GetString(50);
ВидОбменаСКонтролирующимиОрганами = V82.Перечисления /*Ссылка*/.ВидыОбменаСКонтролирующимиОрганами.ПустаяСсылка.Получить((byte[])Читалка.GetValue(51));
УчетнаяЗаписьОбмена = new V82.СправочникиСсылка.УчетныеЗаписиДокументооборота((byte[])Читалка.GetValue(52), Глубина + 1);
КодОрганаПФР = Читалка.GetString(53);
КодОрганаФСГС = Читалка.GetString(54);
ДополнительныйКодФСС = Читалка.GetString(55);
КодПодчиненностиФСС = Читалка.GetString(56);
ЦифровойИндексОбособленногоПодразделения = Читалка.GetDecimal(57);
егистрационныйНомерТФОМС = Читалка.GetString(58);
ИПРегистрационныйНомерПФР = Читалка.GetString(59);
ИПРегистрационныйНомерФСС = Читалка.GetString(60);
ИПКодПодчиненностиФСС = Читалка.GetString(61);
ИПРегистрационныйНомерТФОМС = Читалка.GetString(62);
НаименованиеТерриториальногоОрганаФСС = Читалка.GetString(63);
//return Ссылка;
}
else
{
//return null;
}
}
}
}
}
private void InitializeNetwork()
{
lock (m_initializeLock)
{
m_configuration.Lock();
if (m_status == NetPeerStatus.Running)
{
return;
}
if (m_configuration.m_enableUPnP)
{
m_upnp = new NetUPnP(this);
}
InitializePools();
m_releasedIncomingMessages.Clear();
m_unsentUnconnectedMessages.Clear();
m_handshakes.Clear();
// bind to socket
IPEndPoint iep = null;
iep = new IPEndPoint(m_configuration.LocalAddress, m_configuration.Port);
EndPoint ep = (EndPoint)iep;
m_socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
m_socket.ReceiveBufferSize = m_configuration.ReceiveBufferSize;
m_socket.SendBufferSize = m_configuration.SendBufferSize;
m_socket.Blocking = false;
m_socket.Bind(ep);
IPEndPoint boundEp = m_socket.LocalEndPoint as IPEndPoint;
LogDebug("Socket bound to " + boundEp + ": " + m_socket.IsBound);
m_listenPort = boundEp.Port;
m_receiveBuffer = new byte[m_configuration.ReceiveBufferSize];
m_sendBuffer = new byte[m_configuration.SendBufferSize];
m_readHelperMessage = new NetIncomingMessage(NetIncomingMessageType.Error);
m_readHelperMessage.m_data = m_receiveBuffer;
byte[] macBytes = new byte[8];
NetRandom.Instance.NextBytes(macBytes);
#if IS_MAC_AVAILABLE
try
{
System.Net.NetworkInformation.PhysicalAddress pa = NetUtility.GetMacAddress();
if (pa != null)
{
macBytes = pa.GetAddressBytes();
LogVerbose("Mac address is " + NetUtility.ToHexString(macBytes));
}
else
{
LogWarning("Failed to get Mac address");
}
}
catch (NotSupportedException)
{
// not supported; lets just keep the random bytes set above
}
#endif
byte[] epBytes = BitConverter.GetBytes(boundEp.GetHashCode());
byte[] combined = new byte[epBytes.Length + macBytes.Length];
Array.Copy(epBytes, 0, combined, 0, epBytes.Length);
Array.Copy(macBytes, 0, combined, epBytes.Length, macBytes.Length);
m_uniqueIdentifier = BitConverter.ToInt64(SHA1.Create().ComputeHash(combined), 0);
m_status = NetPeerStatus.Running;
}
}
public static IEnumerable <PingerHost> PingAll(string subNets, int timeOut = 1500)
{
ushort packetID = (ushort)new Random().Next(0, ushort.MaxValue);
//Init
using Socket rawSock = new(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.Icmp);
rawSock.Bind(new IPEndPoint(IPAddress.Any, 0));
rawSock.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.IpTimeToLive, 255);
rawSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, int.MaxValue);
rawSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, int.MaxValue);
rawSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, false);
HashSet <PingerHost> aliveIPs = new();
//** Receiver **
Task receiver = Task.Factory.StartNew(() => {
byte[] received = new byte[64];
EndPoint remoteAddress = new IPEndPoint(IPAddress.Any, 0);
while (true)
{
try {
rawSock.ReceiveFrom(received, ref remoteAddress);
}
catch { return; }
ushort replyId = BitConverter.ToUInt16(received, IP_HEADER_LEN + OFFSET_ID);
if (received[IP_HEADER_LEN] == ICMP_ECHO_REPLY && replyId == packetID)
{
long ticksInPong = BitConverter.ToInt64(received, IP_HEADER_LEN + ICMP_HEADER_LEN);
int duration = (int)((DateTime.Now.Ticks - ticksInPong) / TimeSpan.TicksPerMillisecond);
PingerHost host = new(((IPEndPoint)remoteAddress).Address.ToString(), duration);
lock (aliveIPs) {
aliveIPs.Add(host);
}
}
}
}, TaskCreationOptions.LongRunning);
Task.Yield(); //Give a chance to listener task to start.
//** Sender **
foreach (string ip in GetIPAddresses(subNets))
{
byte[] packet = CreatePacket(packetID, BitConverter.GetBytes(DateTime.Now.Ticks));
IPEndPoint dest = new IPEndPoint(IPAddress.Parse(ip), 0);
try {
rawSock.SendTo(packet, dest);
}
catch (Exception ex) {
Console.WriteLine(ex.Message);
Console.WriteLine($"==>{ip}");
}
}
Task.WaitAny(receiver, Task.Delay(timeOut));
return(aliveIPs);
}
private static long Hash(long x, HashAlgorithm hashAlg)
{
return(BitConverter.ToInt64(hashAlg.ComputeHash(BitConverter.GetBytes(x), 0, 8), 0));
}
private static void ReadCentralDirectoryFooter(ZipFile zf)
{
Stream s = zf.ReadStream;
int signature = Frame.Utils.Ionic.Zip.SharedUtilities.ReadSignature(s);
byte[] block = null;
int j = 0;
if (signature == ZipConstants.Zip64EndOfCentralDirectoryRecordSignature)
{
// We have a ZIP64 EOCD
// This data block is 4 bytes sig, 8 bytes size, 44 bytes fixed data,
// followed by a variable-sized extension block. We have read the sig already.
// 8 - datasize (64 bits)
// 2 - version made by
// 2 - version needed to extract
// 4 - number of this disk
// 4 - number of the disk with the start of the CD
// 8 - total number of entries in the CD on this disk
// 8 - total number of entries in the CD
// 8 - size of the CD
// 8 - offset of the CD
// -----------------------
// 52 bytes
block = new byte[8 + 44];
s.Read(block, 0, block.Length);
Int64 DataSize = BitConverter.ToInt64(block, 0); // == 44 + the variable length
if (DataSize < 44)
throw new ZipException("Bad size in the ZIP64 Central Directory.");
zf._versionMadeBy = BitConverter.ToUInt16(block, j);
j += 2;
zf._versionNeededToExtract = BitConverter.ToUInt16(block, j);
j += 2;
zf._diskNumberWithCd = BitConverter.ToUInt32(block, j);
j += 2;
//zf._diskNumberWithCd++; // hack!!
// read the extended block
block = new byte[DataSize - 44];
s.Read(block, 0, block.Length);
// discard the result
signature = Frame.Utils.Ionic.Zip.SharedUtilities.ReadSignature(s);
if (signature != ZipConstants.Zip64EndOfCentralDirectoryLocatorSignature)
throw new ZipException("Inconsistent metadata in the ZIP64 Central Directory.");
block = new byte[16];
s.Read(block, 0, block.Length);
// discard the result
signature = Frame.Utils.Ionic.Zip.SharedUtilities.ReadSignature(s);
}
// Throw if this is not a signature for "end of central directory record"
// This is a sanity check.
if (signature != ZipConstants.EndOfCentralDirectorySignature)
{
s.Seek(-4, SeekOrigin.Current);
throw new BadReadException(String.Format("Bad signature ({0:X8}) at position 0x{1:X8}",
signature, s.Position));
}
// read the End-of-Central-Directory-Record
block = new byte[16];
zf.ReadStream.Read(block, 0, block.Length);
// off sz data
// -------------------------------------------------------
// 0 4 end of central dir signature (0x06054b50)
// 4 2 number of this disk
// 6 2 number of the disk with start of the central directory
// 8 2 total number of entries in the central directory on this disk
// 10 2 total number of entries in the central directory
// 12 4 size of the central directory
// 16 4 offset of start of central directory with respect to the starting disk number
// 20 2 ZIP file comment length
// 22 ?? ZIP file comment
if (zf._diskNumberWithCd == 0)
{
zf._diskNumberWithCd = BitConverter.ToUInt16(block, 2);
//zf._diskNumberWithCd++; // hack!!
}
// read the comment here
ReadZipFileComment(zf);
}
/**
* 读取一个long数据
*/
public long ReadLong(bool isLittleEndian = false)
{
return(BitConverter.ToInt64(Read(8, isLittleEndian), 0));
}
public static InterfaceDescriptionOption Parse(BinaryReader binaryReader, bool reverseByteOrder, Action <Exception> ActionOnException)
{
//Contract.Requires<ArgumentNullException>(binaryReader != null, "binaryReader cannot be null");
InterfaceDescriptionOption option = new InterfaceDescriptionOption();
List <KeyValuePair <ushort, byte[]> > optionsList = EkstractOptions(binaryReader, reverseByteOrder, ActionOnException);
if (optionsList.Any())
{
foreach (var item in optionsList)
{
try
{
switch (item.Key)
{
case (ushort)InterfaceDescriptionOptionCode.CommentCode:
option.Comment = UTF8Encoding.UTF8.GetString(item.Value);
break;
case (ushort)InterfaceDescriptionOptionCode.NameCode:
option.Name = UTF8Encoding.UTF8.GetString(item.Value);
break;
case (ushort)InterfaceDescriptionOptionCode.DescriptionCode:
option.Description = UTF8Encoding.UTF8.GetString(item.Value);
break;
case (ushort)InterfaceDescriptionOptionCode.IPv4AddressCode:
if (item.Value.Length == 8)
{
option.IPv4Address = new IPAddress_v4(item.Value);
}
else
{
throw new ArgumentException(string.Format("[InterfaceDescriptio.Parse] IPv4AddressCode contains invalid length. Received: {0} bytes, expected: {1}", item.Value.Length, 8));
}
break;
case (ushort)InterfaceDescriptionOptionCode.IPv6AddressCode:
if (item.Value.Length == 17)
{
option.IPv6Address = new IPAddress_v6(item.Value);
}
else
{
throw new ArgumentException(string.Format("[InterfaceDescriptio.Parse] IPv6AddressCode contains invalid length. Received: {0} bytes, expected: {1}", item.Value.Length, 17));
}
break;
case (ushort)InterfaceDescriptionOptionCode.MacAddressCode:
if (item.Value.Length == 6)
{
option.MacAddress = new PhysicalAddress(item.Value);
}
else
{
throw new ArgumentException(string.Format("[InterfaceDescriptio.Parse] MacAddressCode contains invalid length. Received: {0} bytes, expected: {1}", item.Value.Length, 6));
}
break;
case (ushort)InterfaceDescriptionOptionCode.EuiAddressCode:
if (item.Value.Length == 8)
{
option.EuiAddress = item.Value;
}
else
{
throw new ArgumentException(string.Format("[InterfaceDescriptio.Parse] EuiAddressCode contains invalid length. Received: {0} bytes, expected: {1}", item.Value.Length, 8));
}
break;
case (ushort)InterfaceDescriptionOptionCode.SpeedCode:
if (item.Value.Length == 8)
{
option.Speed = (BitConverter.ToInt64(item.Value, 0)).ReverseByteOrder(reverseByteOrder);
}
else
{
throw new ArgumentException(string.Format("[InterfaceDescriptio.Parse] SpeedCode contains invalid length. Received: {0} bytes, expected: {1}", item.Value.Length, 8));
}
break;
case (ushort)InterfaceDescriptionOptionCode.TimestampResolutionCode:
if (item.Value.Length == 1)
{
option.TimestampResolution = item.Value[0];
}
else
{
throw new ArgumentException(string.Format("[InterfaceDescriptio.Parse] TimestampResolutionCode contains invalid length. Received: {0} bytes, expected: {1}", item.Value.Length, 1));
}
break;
case (ushort)InterfaceDescriptionOptionCode.TimeZoneCode:
if (item.Value.Length == 4)
{
option.TimeZone = (BitConverter.ToInt32(item.Value, 0)).ReverseByteOrder(reverseByteOrder); // GMT offset
}
else
{
throw new ArgumentException(string.Format("[InterfaceDescriptio.Parse] TimeZoneCode contains invalid length. Received: {0} bytes, expected: {1}", item.Value.Length, 4));
}
break;
case (ushort)InterfaceDescriptionOptionCode.FilterCode:
option.Filter = item.Value;
break;
case (ushort)InterfaceDescriptionOptionCode.OperatingSystemCode:
option.OperatingSystem = UTF8Encoding.UTF8.GetString(item.Value);
break;
case (ushort)InterfaceDescriptionOptionCode.FrameCheckSequenceCode:
if (item.Value.Length == 1)
{
option.FrameCheckSequence = item.Value[0];
}
else
{
throw new ArgumentException(string.Format("[InterfaceDescriptio.Parse] FrameCheckSequenceCode contains invalid length. Received: {0} bytes, expected: {1}", item.Value.Length, 1));
}
break;
case (ushort)InterfaceDescriptionOptionCode.TimeOffsetSecondsCode:
if (item.Value.Length == 8)
{
option.TimeOffsetSeconds = (BitConverter.ToInt64(item.Value, 0)).ReverseByteOrder(reverseByteOrder);
}
else
{
throw new ArgumentException(string.Format("[InterfaceDescriptio.Parse] TimeOffsetSecondsCode contains invalid length. Received: {0} bytes, expected: {1}", item.Value.Length, 8));
}
break;
case (ushort)InterfaceDescriptionOptionCode.EndOfOptionsCode:
default:
break;
}
}
catch (Exception exc)
{
if (ActionOnException != null)
{
ActionOnException(exc);
}
}
}
}
return(option);
}
/// <summary>
/// 一些基元类型解压缩
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="byte"></param>
/// <param name="flag"></param>
/// <param name="value"></param>
/// <returns></returns>
protected bool TryDecompressTargetTypeFlag <T>(byte[] @byte, byte flag, TargetTypeFlag enumFlag, out T value)
{
value = default(T);
try
{
switch (enumFlag)
{
case TargetTypeFlag.@char:
{
value = (T)(dynamic)BitConverter.ToChar(@byte, 0);
return(true);
}
case TargetTypeFlag.@bool:
{
value = (T)(dynamic)BitConverter.ToBoolean(@byte, 0);
return(true);
}
case TargetTypeFlag.@byte:
{
value = (T)(dynamic)((byte)BitConverter.ToInt16(@byte, 0));
return(true);
}
case TargetTypeFlag.@short:
{
value = (T)(dynamic)BitConverter.ToInt16(@byte, 0);
return(true);
}
case TargetTypeFlag.@ushort:
{
value = (T)(dynamic)BitConverter.ToUInt16(@byte, 0);
return(true);
}
case TargetTypeFlag.@int:
{
value = (T)(dynamic)BitConverter.ToInt32(@byte, 0);
return(true);
}
case TargetTypeFlag.@uint:
{
value = (T)(dynamic)BitConverter.ToUInt32(@byte, 0);
return(true);
}
case TargetTypeFlag.@long:
{
value = (T)(dynamic)BitConverter.ToInt64(@byte, 0);
return(true);
}
case TargetTypeFlag.@ulong:
{
value = (T)(dynamic)BitConverter.ToUInt64(@byte, 0);
return(true);
}
case TargetTypeFlag.@float:
{
value = (T)(dynamic)BitConverter.ToSingle(@byte, 0);
return(true);
}
case TargetTypeFlag.@double:
{
value = (T)(dynamic)BitConverter.ToDouble(@byte, 0);
return(true);
}
case TargetTypeFlag.@decimal:
{
value = (T)(dynamic)((decimal)BitConverter.ToDouble(@byte, 0));
return(true);
}
case TargetTypeFlag.@timespan:
{
value = (T)(dynamic)TimeSpan.FromMilliseconds(BitConverter.ToDouble(@byte, 0));
return(true);
}
case TargetTypeFlag.@datetime:
{
value = (T)(dynamic) new DateTime(BitConverter.ToInt64(@byte, 0));
return(true);
}
}
}
catch
{
}
return(false);
}
/// <summary>
/// 反序列化
/// </summary>
/// <param name="type"></param>
/// <param name="datas"></param>
/// <param name="offset"></param>
/// <returns></returns>
private static object Deserialize(Type type, byte[] datas, ref int offset)
{
dynamic obj = null;
var len = 0;
byte[] data = null;
len = BitConverter.ToInt32(datas, offset);
offset += 4;
if (len > 0)
{
data = new byte[len];
Buffer.BlockCopy(datas, offset, data, 0, len);
offset += len;
if (type == stringType)
{
obj = Encoding.UTF8.GetString(data);
}
else if (type == typeof(byte))
{
obj = (data);
}
else if (type == typeof(bool))
{
obj = (BitConverter.ToBoolean(data, 0));
}
else if (type == typeof(short))
{
obj = (BitConverter.ToInt16(data, 0));
}
else if (type == typeof(int))
{
obj = (BitConverter.ToInt32(data, 0));
}
else if (type == typeof(long))
{
obj = (BitConverter.ToInt64(data, 0));
}
else if (type == typeof(float))
{
obj = (BitConverter.ToSingle(data, 0));
}
else if (type == typeof(double))
{
obj = (BitConverter.ToDouble(data, 0));
}
else if (type == typeof(decimal))
{
obj = (BitConverter.ToDouble(data, 0));
}
else if (type == typeof(DateTime))
{
var dstr = Encoding.UTF8.GetString(data);
var ticks = long.Parse(StringHelper.Substring(dstr, 2));
obj = (new DateTime(ticks));
}
else if (type.BaseType == typeof(Enum))
{
var numType = Enum.GetUnderlyingType(type);
if (numType == typeof(byte))
{
obj = Enum.ToObject(type, data[0]);
}
else if (numType == typeof(short))
{
obj = Enum.ToObject(type, BitConverter.ToInt16(data, 0));
}
else if (numType == typeof(int))
{
obj = Enum.ToObject(type, BitConverter.ToInt32(data, 0));
}
else
{
obj = Enum.ToObject(type, BitConverter.ToInt64(data, 0));
}
}
else if (type == typeof(byte[]))
{
obj = (byte[])data;
}
else if (type.IsGenericType)
{
if (TypeHelper.ListTypeStrs.Contains(type.Name))
{
obj = DeserializeList(type, data);
}
else if (TypeHelper.DicTypeStrs.Contains(type.Name))
{
obj = DeserializeDic(type, data);
}
else
{
obj = DeserializeClass(type, data);
}
}
else if (type.IsClass)
{
obj = DeserializeClass(type, data);
}
else if (type.IsArray)
{
obj = DeserializeArray(type, data);
}
else
{
throw new Exception("ParamsSerializeUtil.Deserialize 未定义的类型：" + type.ToString());
}
}
return(obj);
}
public void Read(out long value)
{
Align(sizeof(long));
value = BitConverter.ToInt64(data, offset);
offset += sizeof(long);
}
public static int WriteToFile(DateTime date)//每天凌晨写入昨天的数据到文件，可以考虑用服务或计划任务;数据库只保留当天的记录；调度程序负责删除过期记录;历史数据应支持合并
{
int year = date.Year; int month = date.Month; int day = date.Day;
string path = string.Concat(m_Path, "\\", year.ToString(), "-", month.ToString(), ".bin");
if (CreateFile(year, month))//如该月文件不存在，则创建；否则写入
{
using (FileStream stream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
stream.Seek(day * 8, SeekOrigin.Begin); //先读入索引区，定位到该日期的指针
byte[] bits = new byte[8];
stream.Read(bits, 0, 8); //如果该位置指针为>0的正数，说明该区域已有数据
if (BitConverter.ToInt64(bits, 0) > 0)
{
return(-1);
}
}
using (var dataReader = DataHelper.Instance.ExecuteProcedureReader("WRITEHDATA", DataHelper.CreateParam("@DATE", SqlDbType.DateTime, date)))
{
if (dataReader == null)
{
return(-10);
}
else
{
dataReader.Read();
int cont = dataReader.GetInt32(0);//读入标签数量
if (cont == 0)
{
return(-2);
}
string path2 = path + ".temp";
try
{
File.Copy(path, path2, true);//先把原文件全部复制到临时文件
//Stopwatch sw = Stopwatch.StartNew();
using (FileStream stream = File.Open(path2, FileMode.Open))
{
//w.Seek(8 + day * 8, SeekOrigin.Begin);
//w.Seek(0x100, SeekOrigin.Begin);
long start = stream.Seek(0, SeekOrigin.End);//定位到文件末尾
long end = 0;
using (BinaryWriter w = new BinaryWriter(stream))
{
w.Write(new SqlDateTime(date).DayTicks); //写入日期
w.Write(cont); ///写入标签数量
int count = dataReader.GetInt32(1);
w.Write(count);
HDataFormat[] list = new HDataFormat[count];
if (dataReader.NextResult())
{
int p = 0;
int x = 0;
while (dataReader.Read()) //写入标签元数据
{
short id = dataReader.GetInt16(0); //ID号
byte type = dataReader.GetByte(1); //数据类型
int cn = dataReader.GetInt32(2); //标签个数
//list[x].ID = id;
list[x].Type = (DataType)type;
list[x].Count = cn;
//list[x].Offset = p;
w.Write(id);
w.Write(type);
w.Write(cn);
w.Write(p);
p += cn * dataLen[type];
x++;
}
if (dataReader.NextResult())
{
for (int i = 0; i < list.Length; i++)
{
int len = list[i].Count;
for (int j = 0; j < len; j++)
{
if (dataReader.Read())
{
w.Write(dataReader.GetTimeTick(0));
switch (list[i].Type)
{
case DataType.BOOL:
w.Write(dataReader.GetFloat(1) > 0);
break;
case DataType.BYTE:
w.Write((byte)dataReader.GetFloat(1));
break;
case DataType.WORD:
case DataType.SHORT:
w.Write((short)dataReader.GetFloat(1));
break;
case DataType.INT:
w.Write((int)dataReader.GetFloat(1));
break;
case DataType.FLOAT:
w.Write(dataReader.GetFloat(1));
break;
}
}
}
}
}
}
end = stream.Position; //文件的结尾，总长度
w.Seek((day - 1) * 8, SeekOrigin.Begin); //定位到索引区
w.Write(start); //写入当日指针
w.Write(end); //写入下一日指针
//w.Close();
}
}
File.Copy(path2, path, true);
}
catch (Exception err)
{
DataHelper.AddErrorLog(err);
return(-3);
}
finally
{
if (File.Exists(path2))
{
File.Delete(path2);
}
}
//dataReader.Close();
return(0);
/*写入失败，则将备份文件还原；数据库不做删除动作，保留记录，次日服务检查数据文件是否存在，不存在则合并写入
* 可在服务内建XML文件保存失败记录的日期列表，以便还原；用File.Mov；定时间隔、开始时间也可XML定义。
* 先备份二进制归档库，再加载数据库数据，写入文件；如成功，删除数据库当日记录并删除备份文件
* sw.Stop();
* if (sw.ElapsedTicks > 0) { }
*/
}
}
}
return(-10);
}
public bool FromBytes(byte[] bodyData)
{
Result = BitConverter.ToInt16(bodyData, 0);
RoomUserUniqueId = BitConverter.ToInt64(bodyData, 2);
return(true);
}
/// <summary>
/// Read a long from the Buffer
/// </summary>
/// <returns></returns>
public Int64 ReadLong()
{
return(BitConverter.ToInt64(ReadBigEndianBytes(8), 0));
}
public bool FromBytes(byte[] bodyData)
{
UserUniqueId = BitConverter.ToInt64(bodyData, 0);
return(true);
}
/// <summary>
/// Converts some binary data into the form used in the CLR.
/// </summary>
/// <param name="type">The type of data to convert from.</param>
/// <param name="data">The data to convert.</param>
/// <param name="parsedData">The parsed CLR object.</param>
/// <returns>Indication if the parsed data could be parsed correctly as the specified type. If false, data is always a byte[].</returns>
public static bool TryConvertValueDataToObject(RegValueType type, byte[] data, out object parsedData)
{
parsedData = data;
switch (type)
{
case RegValueType.REG_NONE:
// NONE format shouldn't be specified, ever.
return(false);
case RegValueType.REG_LINK: // This is a unicode string
case RegValueType.REG_EXPAND_SZ: // This is a unicode string
case RegValueType.REG_SZ:
if (data.Length % 2 != 0)
{
// UTF-16 strings are always an even number of bytes
return(false);
}
// Remove all the trailing nulls
int toIndex = 0;
while (data.Length > toIndex + 2 && (data[toIndex] != 0 || data[toIndex + 1] != 0))
{
toIndex += 2;
}
parsedData = StringEncoding.GetString(data, 0, toIndex);
return(true);
case RegValueType.REG_BINARY:
return(true);
case RegValueType.REG_DWORD:
if (data.Length != 4)
{
return(false);
}
parsedData = BitConverter.ToInt32(data, 0);
return(true);
case RegValueType.REG_DWORD_BIG_ENDIAN:
if (data.Length != 4)
{
return(false);
}
Array.Reverse(data);
parsedData = BitConverter.ToInt32(data, 0);
return(true);
case RegValueType.REG_MULTI_SZ:
// Get string without the ending null
if (data.Length % 2 != 0)
{
// Invalid string data, must always be even in length
return(false);
}
if (data.Length == 0)
{
// A badly formatted list
return(false);
}
if (data.Length == 2 && data[0] == 0 && data[1] == 0)
{
// An empty list is identified by: \0
parsedData = new string[0];
return(true);
}
if (data[data.Length - 4] != 0 || data[data.Length - 3] != 0 || data[data.Length - 2] != 0 ||
data[data.Length - 1] != 0)
{
// Must always end with four nulls
return(false);
}
string s2 = StringEncoding.GetString(data, 0, data.Length - 4);
parsedData = s2.Split(new[] { '\0' });
return(true);
case RegValueType.REG_RESOURCE_LIST:
return(true);
case RegValueType.REG_FULL_RESOURCE_DESCRIPTOR:
return(true);
case RegValueType.REG_RESOURCE_REQUIREMENTS_LIST:
return(true);
case RegValueType.REG_QWORD:
if (data.Length != 8)
{
return(false);
}
parsedData = BitConverter.ToInt64(data, 0);
return(true);
default:
throw new ArgumentOutOfRangeException("TryConvertValueDataToObject was given an invalid RegValueType: " + type);
}
}
/// <summary>
/// 生成Guid
/// </summary>
/// <returns></returns>
public static long GenerateId()
{
byte[] buffer = Guid.NewGuid().ToByteArray();
return(BitConverter.ToInt64(buffer, 0));
}
