public override string ReadBytes(Stream stream)
{
int len = stream.ReadInt32();
byte[] bytes = stream.ReadBytes(len);
return(DefaultEncoding.GetString(bytes));
}
private void reencode(string value)
{
if (ReplaceEndStringChar)
{
int _NeededBytes = DefaultEncoding.GetByteCount(value);
if (_NeededBytes < _m_Size)
{
AppendEndStringChar = true;
}
else
{
value = value.Remove(value.Length - 1);
AppendEndStringChar = true;
}
}
if (AppendEndStringChar)
{
value = value + (char)0x00;
}
_m_name = new byte[_m_Size];
byte[] data = DefaultEncoding.GetBytes(value);
if (data.Length > _m_Size)
{
Buffer.BlockCopy(data, 0, _m_name, 0, _m_Size);
return;
}
Buffer.BlockCopy(data, 0, _m_name, 0, data.Length);
}
internal override void Write(BinaryWriter writer)
{
writer.Write(Version);
writer.Write(VersionNeededToExtract);
writer.Write(Flags);
writer.Write(CompressionMethod);
writer.Write(LastModifiedTime);
writer.Write(LastModifiedDate);
writer.Write(Crc);
writer.Write(CompressedSize);
writer.Write(UncompressedSize);
byte[] nameBytes = DefaultEncoding.GetBytes(Name);
writer.Write((ushort)nameBytes.Length);
writer.Write((ushort)Extra.Length);
writer.Write((ushort)Comment.Length);
writer.Write(DiskNumberStart);
writer.Write(InternalFileAttributes);
writer.Write(ExternalFileAttributes);
writer.Write(RelativeOffsetOfEntryHeader);
writer.Write(nameBytes);
writer.Write(Extra);
writer.Write(Comment);
}
private static void ReadZipFileComment(ZipFile zf)
{
// read the comment here
byte[] block = new byte[2];
zf.ReadStream.Read(block, 0, block.Length);
Int16 commentLength = (short)(block[0] + block[1] * 256);
if (commentLength > 0)
{
block = new byte[commentLength];
zf.ReadStream.Read(block, 0, block.Length);
// workitem 6513 - only use UTF8 as necessary
// test reflexivity
string s1 = DefaultEncoding.GetString(block, 0, block.Length);
byte[] b2 = DefaultEncoding.GetBytes(s1);
if (BlocksAreEqual(block, b2))
{
zf.Comment = s1;
}
else
{
// need alternate (non IBM437) encoding
// workitem 6415
// use UTF8 if the caller hasn't already set a non-default encoding
System.Text.Encoding e = (zf._provisionalAlternateEncoding.CodePage == 437)
? System.Text.Encoding.UTF8
: zf._provisionalAlternateEncoding;
zf.Comment = e.GetString(block, 0, block.Length);
}
}
}
private byte[] GeneratePeerId()
{
MemoryStream ms = new MemoryStream(20);
byte[] clientIdBytes = DefaultEncoding.GetBytes(ClientId);
ms.Write(clientIdBytes, 0, clientIdBytes.Length);
byte[] dateBytes = BitConverter.GetBytes(DateTime.Now.ToBinary().GetHashCode());
byte hash = 0;
foreach (byte b in dateBytes)
{
hash ^= b;
}
ms.WriteByte(hash);
ms.WriteByte((byte)System.Diagnostics.Process.GetCurrentProcess().Id);
int padCount = (int)(20 - ms.Length);
for (int i = padCount; i > 0; i--)
{
ms.WriteByte((byte)'0');
}
return(ms.ToArray());
}
/// <summary>
/// Calcula o tamanho do parametro.
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
private long ComputeParameterLength(MultipartFormDataParameter parameter)
{
var letterLenght = DefaultEncoding.GetByteCount("&");
var boundrayLenght = DefaultEncoding.GetByteCount(_boundary);
long length = 0;
return(DefaultEncoding.GetByteCount("--") + boundrayLenght + (letterLenght * 2) + DefaultEncoding.GetByteCount(string.Format("Content-Type: {0}", parameter.ContentType)) + (letterLenght * 2) + DefaultEncoding.GetByteCount("Content-Disposition: form-data; name=\"") + DefaultEncoding.GetByteCount(HttpUtility.UrlEncode(parameter.Name) ?? "") + letterLenght + (parameter is IFileMultipartFormDataParameter ? string.Format("; filename=\"{0}\"", (((IFileMultipartFormDataParameter)parameter).FileName)).Length : 0) + (letterLenght * 2) + (letterLenght * 2) + (parameter.TryComputeLength(out length) ? length : 0) + (letterLenght * 2));
}
/// <summary>
/// Converts bytes using the default encoding
/// </summary>
private string ConvertBytesToStringWithDefaultEncoding(byte[] line)
{
if (line == null)
{
return("");
}
return(DefaultEncoding.GetString(line));
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="buff"></param>
public void Send(byte[] buff)
{
string recv = DefaultEncoding.GetString(buff);
LogRevMsg.LogText("发送", recv);
Lib.LogManager.Logger.LogInfo("发送:" + "\r" + recv);
this.comm.Write(buff, 0, buff.Length);
//MachineAdapter.Common.Manager.MonitorManager.Instance.SendLog(recv);
}
private void ParseBody(byte[] data)
{
this.UnprocessedData = new byte[] { };
if (StartBoundary == "--") //isEmpty = > singlepart
{
this._bodyBytes = data;
}
else //multipart
{
var crlf = DefaultEncoding.GetBytes(CRLF);
int index = 0;
byte[] stringBytes;
//чтение собственного текста
{
int nextIndex = index;
while (readLine(data, ref nextIndex, out stringBytes))
{
if (stringBytes.ValueEquals(this.StartBoundaryBytes1) || stringBytes.ValueEquals(this.EndBoundaryBytes))
{
this._bodyBytes = data.GetSubArray(0, index);
break;
}
index = nextIndex;
}
index = nextIndex;
}
//достигнут конец данных
if (stringBytes == null || stringBytes.ValueEquals(this.EndBoundaryBytes))
{
return;
}
int endIndex = BytesExtensions.IndexOf(data, this.EndBoundaryBytes, index);
if (endIndex == -1)
{
endIndex = data.Length;
}
while (index < endIndex)
{
int nextIndex = BytesExtensions.IndexOf(data, this.StartBoundaryBytes1, index);
if (nextIndex == -1)
{
nextIndex = data.Length + crlf.Length;
}
var childData = data.GetSubArray(index, nextIndex - index - crlf.Length);
var child = createMimeReader(this, childData);
this.Children.Add(child);
index = nextIndex + this.StartBoundaryBytes1.Length + crlf.Length;
}
}
}
//------------------------------------------------------------------------------------------------------------------
public static byte[] StringToBuffer(ref string Str)
{
if (Str == null || Str == "")
{
return(new byte[0]);
}
else
{
return(DefaultEncoding.GetBytes(Str));
}
}
/// <summary>
/// Decrypt with private key
/// </summary>
/// <param name="data"></param>
/// <param name="encryptionEncodeMode"><see cref="CryptoBase.DefaultEncryptionEncodeMode"/></param>
/// <param name="privateKey">Private key</param>
/// <returns></returns>
public string Decrypt(string data, EncodeMode encryptionEncodeMode, string privateKey)
{
if (string.IsNullOrWhiteSpace(data))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(data));
}
if (string.IsNullOrWhiteSpace(privateKey))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(privateKey));
}
return(DefaultEncoding.GetString(Decrypt(encryptionEncodeMode.DecodeToBytes(data, DefaultEncoding), privateKey)));
}
/// <summary>
/// Encrypt with public key
/// </summary>
/// <param name="data"></param>
/// <param name="encryptionEncodeMode"><see cref="CryptoBase.DefaultEncryptionEncodeMode"/></param>
/// <param name="publicKey">Public key</param>
/// <returns></returns>
public string Encrypt(string data, EncodeMode encryptionEncodeMode, string publicKey)
{
if (string.IsNullOrWhiteSpace(data))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(data));
}
if (string.IsNullOrWhiteSpace(publicKey))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(publicKey));
}
return(encryptionEncodeMode.EncodeToString(Encrypt(DefaultEncoding.GetBytes(data), publicKey), DefaultEncoding));
}
/// <summary>
/// Sign with private key
/// </summary>
/// <param name="data"></param>
/// <param name="signatureEncodeMode"><see cref="CryptoAndSignatureBase.DefaultSignatureEncodeMode"/></param>
/// <param name="privateKey">Private key</param>
/// <returns></returns>
public string SignData(string data, EncodeMode signatureEncodeMode, string privateKey)
{
if (string.IsNullOrWhiteSpace(data))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(data));
}
if (string.IsNullOrWhiteSpace(privateKey))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(privateKey));
}
return(signatureEncodeMode.EncodeToString(SignData(DefaultEncoding.GetBytes(data), privateKey), DefaultEncoding));
}
/// <summary>String preceeded by uint length</summary>
/// <param name="message"></param>
public void WriteUIntPascalString(string message)
{
if (message.Length > 0)
{
byte[] bytes = DefaultEncoding.GetBytes(message);
WriteUInt(bytes.Length + 1);
Write(bytes);
Write((byte)0);
}
else
{
WriteUInt(0);
}
}
public OctetsStream Marshal(string str, Encoding encoding)
{
try
{
Marshal(encoding == null
? DefaultEncoding.GetBytes(str)
: encoding.GetBytes(str));
}
catch
{
throw new MarshalException();
}
return(this);
}
public override int GetHashCode()
{
unchecked
{
int hashCode = DataTypeId != null?DataTypeId.GetHashCode() : 0;
hashCode = (hashCode * 397) ^ (Name != null ? Name.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (DefaultEncoding != null ? DefaultEncoding.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (BaseDataType != null ? BaseDataType.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ StructureType;
hashCode = (hashCode * 397) ^ (Fields != null ? Fields.GetHashCode() : 0);
return(hashCode);
}
}
/// <summary>
/// 加密
/// </summary>
/// <param name="data"></param>
/// <param name="key">密钥</param>
/// <returns></returns>
public virtual string Encrypt(string data, string key)
{
if (string.IsNullOrWhiteSpace(data))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(data));
}
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(key));
}
var bytes = DefaultEncoding.GetBytes(data);
var encrypt = Encrypt(bytes, key);
return(DefaultEncryptionEncodeMode.EncodeToString(encrypt, DefaultEncoding));
}
public void KoreanTest()
{
byte[] bytes = new byte[] { 0x48, 0x6f, 0x6e, 0x67, 0x5e, 0x47, 0x69, 0x6c, 0x64, 0x6f, 0x6e, 0x67, 0x3d, 0x1b, 0x24, 0x29,
0x43, 0xfb, 0xf3, 0x5e, 0x1b, 0x24, 0x29, 0x43, 0xd1, 0xce, 0xd4, 0xd7, 0x3d, 0x1b, 0x24, 0x29,
0x43, 0xc8, 0xab, 0x5e, 0x1b, 0x24, 0x29, 0x43, 0xb1, 0xe6, 0xb5, 0xbf };
string unicode = @"Hong^Gildong=洪^吉洞=홍^길동";
// first test the default encoding
DefaultEncoding encoding = new DefaultEncoding();
string temp = encoding.GetString(bytes);
Assert.AreEqual(temp, "Hong^Gildong=\x00d71b$)C\x00d7fb\x00d7f3^\x00d71b$)C\x00d7d1\x00d7ce\x00d7d4\x00d7d7=\x00d71b$)C\x00d7c8\x00d7ab^\x00d71b$)C\x00d7b1\x00d7e6\x00d7b5\x00d7bf", "Default decoding failed.");
EncodeDecodeTest(@"\ISO 2022 IR 149", unicode, bytes);
}
public int SetString(string key, string text, int maxLen)
{
byte[] bytes = DefaultEncoding.GetBytes(text);
int len = Math.Min(bytes.Length, maxLen);
foreach (int offset in ifsCurrentIniFileSection.GetIntList(key))
{
Array.Copy(bytes, 0, Data, BaseOffset + offset, len);
for (int i = len; i < maxLen; i++)
{
Data[BaseOffset + offset + i] = 0;
}
}
return(len);
}
internal override void Read(MarkingBinaryReader reader)
{
Version = reader.ReadUInt16();
Flags = reader.ReadUInt16();
CompressionMethod = reader.ReadUInt16();
LastModifiedTime = reader.ReadUInt16();
LastModifiedDate = reader.ReadUInt16();
Crc = reader.ReadUInt32();
CompressedSize = reader.ReadUInt32();
UncompressedSize = reader.ReadUInt32();
ushort nameLength = reader.ReadUInt16();
ushort extraLength = reader.ReadUInt16();
byte[] name = reader.ReadBytes(nameLength);
Extra = reader.ReadBytes(extraLength);
Name = DefaultEncoding.GetString(name, 0, name.Length);
}
/// <summary>
/// Verification with public key
/// </summary>
/// <param name="data"></param>
/// <param name="signature"></param>
/// <param name="signatureEncodeMode"><see cref="CryptoAndSignatureBase.DefaultSignatureEncodeMode"/></param>
/// <param name="publicKey">Public key</param>
/// <returns></returns>
public bool VerifyData(string data, string signature, EncodeMode signatureEncodeMode, string publicKey)
{
if (string.IsNullOrWhiteSpace(data))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(data));
}
if (string.IsNullOrWhiteSpace(signature))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(signature));
}
if (string.IsNullOrWhiteSpace(publicKey))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(publicKey));
}
return(VerifyData(DefaultEncoding.GetBytes(data), signatureEncodeMode.DecodeToBytes(signature, DefaultEncoding), publicKey));
}
/// <summary>
/// Gets the size of the table info.
/// </summary>
/// <returns>Size of the table info.</returns>
public int GetInfoSize()
{
int size = 1; // End node type
foreach (ElementInfo info in this.files)
{
size += 1; // Node type
size += DefaultEncoding.GetByteCount(info.Name);
}
foreach (ElementInfo info in this.folders)
{
size += 3; // Node type + folder ID
size += DefaultEncoding.GetByteCount(info.Name);
}
return(size);
}
public string GetString(string key, int maxLen)
{
int[] offsets = ifsCurrentIniFileSection.GetIntList(key);
if (offsets.Length == 0)
{
return(null);
}
int length = GetByte(key + "Length");
if (length == 0)
{
length = maxLen;
}
return(DefaultEncoding.GetString(Data, BaseOffset + offsets[0], length).TrimEnd('\0'));
}
protected override void WriteMessageInternal(BinaryWriter writer)
{
base.WriteMessageInternal(writer);
var topicData = Topic != null?DefaultEncoding.GetBytes(Topic) : new byte[]
{
};
var contentTypeData = ContentType != null?DefaultEncoding.GetBytes(ContentType) : new byte[]
{
};
WriteString(writer, ContentType);
WriteString(writer, Topic);
writer.Write((long)Data.Length);
writer.Write(Data);
}
public string Unmarshal_string(Encoding encoding)
{
try
{
int size = Uncompact_uint32();
if (_pos + size > Size)
{
throw new MarshalException();
}
int cur = _pos;
_pos += size;
return((encoding == null) ?
DefaultEncoding.GetString(Buffer(), cur, size) : encoding.GetString(Buffer(), cur, size));
}
catch
{
throw new MarshalException();
}
}
internal static Decoder GetThreadStatic(this Decoder nonDefault)
{
if (nonDefault != null)
{
nonDefault.Reset();
return(nonDefault);
}
var decoder = _perThreadDecoder;
if (decoder == null)
{
_perThreadDecoder = decoder = DefaultEncoding.GetDecoder();
}
else
{
decoder.Reset();
}
return(decoder);
}
/// <summary>
/// Tries to parse the given raw <paramref name="message" /> to the contract of the <see cref="T:Arcus.Messaging.Pumps.Abstractions.MessageHandling.IMessageHandler`2" />.
/// </summary>
/// <param name="message">The raw incoming message that will be tried to parse against the <see cref="T:Arcus.Messaging.Pumps.Abstractions.MessageHandling.IMessageHandler`2" />'s message contract.</param>
/// <param name="messageType">The type of the message that the message handler can process.</param>
/// <param name="result">The resulted parsed message when the <paramref name="message" /> conforms with the message handlers' contract.</param>
/// <returns>
/// [true] if the <paramref name="message" /> conforms the <see cref="T:Arcus.Messaging.Pumps.Abstractions.MessageHandling.IMessageHandler`2" />'s contract; otherwise [false].
/// </returns>
public override bool TryDeserializeToMessageFormat(string message, Type messageType, out object result)
{
try
{
if (messageType == typeof(CloudEvent))
{
CloudEvent cloudEvent = JsonEventFormatter.DecodeStructuredEvent(DefaultEncoding.GetBytes(message));
result = cloudEvent;
return(true);
}
}
catch (Exception exception)
{
Logger.LogWarning(exception, "Unable to deserialize the CloudEvent");
}
result = null;
return(false);
}
private static byte[] GetContentByteArray(IEnumerable <KeyValuePair <string, string> > nameValues)
{
if (nameValues == null)
{
throw new ArgumentNullException("nameValues");
}
var stringBuilder = new StringBuilder();
foreach (var current in nameValues)
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append('&');
}
stringBuilder.Append(Encode(current.Key));
stringBuilder.Append('=');
stringBuilder.Append(Encode(current.Value));
}
return(DefaultEncoding.GetBytes(stringBuilder.ToString()));
}
internal static Encoder GetThreadStatic(this Encoder nonDefault)
{
if (nonDefault != null)
{
nonDefault.Reset();
return(nonDefault);
}
var encoder = _perThreadEncoder;
if (encoder == null)
{
_perThreadEncoder = encoder = DefaultEncoding.GetEncoder();
}
else
{
encoder.Reset();
}
return(encoder);
}
private string GetString(IEnumerable <byte> list)
{
var bytes = list.ToArray();
var te = GetTransferEncoding();
switch (te)
{
case System.Net.Mime.TransferEncoding.Base64:
return(Convert.ToBase64String(bytes));
case System.Net.Mime.TransferEncoding.QuotedPrintable:
{
var encoding = GetEncoding(this.ContentType.CharSet);
return(encoding.GetString(bytes));
}
default:
return(DefaultEncoding.GetString(bytes));
}
}
