public override void Flush() { if (msWriteBuffer.Length > MAX_PACKETLEN) { // send fragmented MemoryStream msFragmentedBuffer = new MemoryStream(packetBuffer, true); int fragmentStart = 4; int fragmentLength; do { fragmentLength = fragmentStart + FRAGMENT_SIZE <= ( int )msWriteBuffer.Length ? FRAGMENT_SIZE : ( int )msWriteBuffer.Length - fragmentStart; msFragmentedBuffer.Position = 0; msFragmentedBuffer.Write(ExBitConverter.GetBytes(connection.OutgoingSequence | FRAGMENT_BIT, true), 0, 4); msFragmentedBuffer.Write(ExBitConverter.GetBytes(fragmentStart, true), 0, 2); msFragmentedBuffer.Write(ExBitConverter.GetBytes(fragmentLength, true), 0, 2); msFragmentedBuffer.Write(msWriteBuffer.GetBuffer(), fragmentStart, fragmentLength); fragmentStart += fragmentLength; (underlying as Socket).Send(msFragmentedBuffer.GetBuffer(), ( int )msFragmentedBuffer.Position, SocketFlags.None); } while (fragmentLength == FRAGMENT_SIZE); } else { (underlying as Socket).Send(msWriteBuffer.GetBuffer(), ( int )msWriteBuffer.Length, SocketFlags.None); } msWriteBuffer.SetLength(0); }
// Token: 0x06001C2E RID: 7214 RVA: 0x0006FA44 File Offset: 0x0006DC44 internal string EncodeCertChain(ChainContext chainContext, bool includeRootCert, X509Certificate2 signersCertificate) { uint count = (uint)chainContext.GetChains().Count; List <byte[]>[] array = new List <byte[]> [count]; uint[] array2 = new uint[count]; uint[] array3 = new uint[count]; uint num = 16U; int num2 = 0; foreach (CertificateChain certificateChain in chainContext.GetChains()) { array3[num2] = 16U; array2[num2] = 0U; array[num2] = new List <byte[]>(certificateChain.Elements.Count); foreach (ChainElement chainElement in certificateChain.Elements) { if (!signersCertificate.Equals(chainElement.Certificate) && (includeRootCert || (chainElement.TrustInformation & TrustInformation.IsSelfSigned) == TrustInformation.None)) { array3[num2] += 12U; byte[] rawData = chainElement.Certificate.RawData; array[num2].Add(rawData); array3[num2] += (uint)rawData.Length; array2[num2] += 1U; } } num += array3[num2]; num2++; } byte[] array4 = new byte[num]; int num3 = 0; num3 += ExBitConverter.Write(num, array4, num3); num3 += ExBitConverter.Write((uint)chainContext.Status, array4, num3); num3 += ExBitConverter.Write((uint)chainContext.TrustInformation, array4, num3); num3 += ExBitConverter.Write(count, array4, num3); num2 = 0; foreach (CertificateChain certificateChain2 in chainContext.GetChains()) { num3 += ExBitConverter.Write(array3[num2], array4, num3); num3 += ExBitConverter.Write((uint)certificateChain2.Status, array4, num3); num3 += ExBitConverter.Write((uint)certificateChain2.TrustInformation, array4, num3); num3 += ExBitConverter.Write(array2[num2], array4, num3); int num4 = 0; foreach (ChainElement chainElement2 in certificateChain2.Elements) { if (!signersCertificate.Equals(chainElement2.Certificate) && (includeRootCert || (chainElement2.TrustInformation & TrustInformation.IsSelfSigned) == TrustInformation.None)) { num3 += ExBitConverter.Write((uint)(array[num2][num4].Length + 12), array4, num3); num3 += ExBitConverter.Write((uint)chainElement2.Status, array4, num3); num3 += ExBitConverter.Write((uint)chainElement2.TrustInformation, array4, num3); Array.Copy(array[num2][num4], 0, array4, num3, array[num2][num4].Length); num3 += array[num2][num4].Length; num4++; } } num2++; } return(Convert.ToBase64String(array4)); }
internal byte[] GetBytes(Encoding encoding) { byte[] array; if (this.orgUnit == null) { array = new byte[6]; array[0] = 1; array[1] = 0; ExBitConverter.Write(0, array, 2); } else { if (this.configUnit.ObjectGuid == Guid.Empty || this.orgUnit.ObjectGuid == Guid.Empty) { throw new InvalidOperationException("OrganizationId is not fully populated and cannot be serialized"); } int byteCount = this.orgUnit.GetByteCount(encoding); int byteCount2 = this.configUnit.GetByteCount(encoding); array = new byte[byteCount + byteCount2 + 8 + 3]; int num = 0; array[num++] = 2; array[num++] = 1; num += ExBitConverter.Write(byteCount, array, num); array[num++] = 2; num += ExBitConverter.Write(byteCount2, array, num); this.orgUnit.GetBytes(encoding, array, num); num += byteCount; this.configUnit.GetBytes(encoding, array, num); } return(array); }
public static void Serialize(StreamPropertyType propId, object value, byte[] buffer, ref int offset) { if (buffer == null || offset > buffer.Length) { throw new ArgumentException("buffer"); } offset += ExBitConverter.Write((short)propId, buffer, offset); PropertyStreamWriter.WriteValue(propId, value, buffer, ref offset); }
private void WriteHeader(EntryId.EntryIdFlags flags, byte[] buffer) { int num = 0; num += ExBitConverter.Write((int)flags, buffer, num); num += ExBitConverter.Write(this.providerGuid, buffer, num); num += ExBitConverter.Write(1, buffer, num); num += ExBitConverter.Write((int)this.displayType, buffer, num); }
internal static void SetDword(byte[] buff, ref int pos, uint dw) { if (buff != null) { AddressBookEntryId.BinaryHelper.CheckBounds(pos, buff.Length, AddressBookEntryId.BinaryHelper.DWordSize); ExBitConverter.Write(dw, buff, pos); } pos += AddressBookEntryId.BinaryHelper.DWordSize; }
// Token: 0x06000B93 RID: 2963 RVA: 0x00033628 File Offset: 0x00031828 private void SendPageNumbersToSource(object dummy) { Exception ex = null; IOBuffer iobuffer = null; int num = this.m_pageList.Length; try { this.GetChannel(); SeedPageReaderMultiplePageRequest seedPageReaderMultiplePageRequest = new SeedPageReaderMultiplePageRequest(this.m_channel, this.m_databaseGuid, this.m_databaseName, this.m_databasePath, (long)this.m_pageList.Length); seedPageReaderMultiplePageRequest.Send(); iobuffer = IOBufferPool.Allocate(); iobuffer.AppendOffset = 0; foreach (long num2 in this.m_pageList) { if (iobuffer.RemainingSpace >= 4) { DiagCore.RetailAssert(num2 <= 2147483647L, "ese uses 31bit page numbers but {0} was passed", new object[] { num2 }); ExBitConverter.Write((uint)num2, iobuffer.Buffer, iobuffer.AppendOffset); iobuffer.AppendOffset += 4; } else { this.m_channel.Write(iobuffer.Buffer, 0, iobuffer.AppendOffset); iobuffer.AppendOffset = 0; } } if (iobuffer.AppendOffset > 0) { this.m_channel.Write(iobuffer.Buffer, 0, iobuffer.AppendOffset); } } catch (NetworkRemoteException ex2) { ex = ex2; } catch (NetworkTransportException ex3) { ex = ex3; } finally { this.m_pageList = null; if (iobuffer != null) { IOBufferPool.Free(iobuffer); } } if (ex != null) { ReplayCrimsonEvents.SendPageNumbersToSourceFailed.Log <Guid, string, int, Exception>(this.m_databaseGuid, this.DatabaseName, num, ex); } }
private static void WriteMultiValuedProperty <T>(StreamPropertyType propId, MultiValuedProperty <T> list, byte[] buffer, ref int offset) { int num = (list != null) ? list.Count : 0; offset += ExBitConverter.Write(num, buffer, offset); for (int i = 0; i < num; i++) { PropertyStreamWriter.WriteValue(propId & ~StreamPropertyType.MultiValuedProperty, list[i], buffer, ref offset); } }
private static void WriteArray <T>(StreamPropertyType propId, T[] array, byte[] buffer, ref int offset) { int num = (array != null) ? array.Length : 0; offset += ExBitConverter.Write(num, buffer, offset); for (int i = 0; i < num; i++) { PropertyStreamWriter.WriteValue(propId & ~StreamPropertyType.Array, array[i], buffer, ref offset); } }
public byte[] GetBytes() { byte[] array = new byte[16]; long value = IPAddress.HostToNetworkOrder((long)this.highBytes); ExBitConverter.Write(value, array, 0); value = IPAddress.HostToNetworkOrder((long)this.lowBytes); ExBitConverter.Write(value, array, 8); return(array); }
public void FromBytes(byte[] data) { int num = 0; this.sentTime = BitConverter.ToInt64(data, num); num += 8; this.messageId = ExBitConverter.ReadAsciiString(data, num); num += this.messageId.Length + 1; this.mailbox = ExBitConverter.ReadAsciiString(data, num); }
public byte[] ToBytes() { byte[] array = new byte[this.mailbox.Length + this.messageId.Length + 10]; int num = 0; num += ExBitConverter.Write(this.sentTime, array, num); num += ExBitConverter.Write(this.messageId, false, array, num); num += ExBitConverter.Write(this.mailbox, false, array, num); return(array); }
private void AppendProperty(OofHistory.PropId propId, byte[] propertyValue) { this.data[this.dataPosition++] = (byte)propId; ushort num = (ushort)propertyValue.Length; ExBitConverter.Write(num, this.data, this.dataPosition); this.dataPosition += 2; Buffer.BlockCopy(propertyValue, 0, this.data, this.dataPosition, (int)num); this.dataPosition += (int)num; }
protected void WriteCoconetBlock(byte[] buf, int offset, int length) { byte[] compressBuf = this.CompressBuf; int num; this.m_coconetCompressor.Compress(buf, offset, length, compressBuf, 9, 1048577, out num); compressBuf[0] = 4; ExBitConverter.Write(num, compressBuf, 1); ExBitConverter.Write(length, compressBuf, 5); this.m_tcpChannel.Write(compressBuf, 0, 9 + num); }
// Token: 0x06000C85 RID: 3205 RVA: 0x00027650 File Offset: 0x00025850 public override byte[] GetBytes() { byte[] bytes = base.MailboxOwnerId.GetBytes(); byte[] array = new byte[16 + bytes.Length + 2]; ExBitConverter.Write((short)bytes.Length, array, 0); int num = 2; Array.Copy(bytes, 0, array, num, bytes.Length); num += bytes.Length; ExBitConverter.Write(this.RuleIdGuid, array, num); return(array); }
public InboxRuleIdParameter(string inboxRuleId) { if (string.IsNullOrEmpty(inboxRuleId)) { throw new ArgumentNullException("inboxRuleId"); } this.rawInput = inboxRuleId; int num = inboxRuleId.Length; int num2; do { num2 = num; num = inboxRuleId.LastIndexOf("\\\\", num2 - 1, num2); }while (num != -1); int num3 = inboxRuleId.LastIndexOf('\\', num2 - 1, num2); if (num3 == 0 || num3 == inboxRuleId.Length - 1) { throw new ArgumentException(Strings.ErrorInvalidParameterFormat("inboxRuleId"), "inboxRuleId"); } string text; string text2; if (num3 > 0) { text = inboxRuleId.Substring(0, num3); text2 = inboxRuleId.Substring(1 + num3); } else { text2 = inboxRuleId; text = null; } if (num2 != inboxRuleId.Length) { text2 = text2.Replace("\\\\", '\\'.ToString()); } if (!string.IsNullOrEmpty(text)) { this.rawMailbox = new MailboxIdParameter(text); } ulong value; if (ulong.TryParse(text2, out value)) { byte[] array = new byte[8]; ExBitConverter.Write((long)value, array, 0); this.rawRuleId = RuleId.Deserialize(array, 0); return; } this.rawRuleName = text2; }
public static byte[] ToBytesFromRegistryFormat(REG_TIMEZONE_INFO timeZoneInfo) { byte[] array = new byte[O11TimeZoneFormatter.OUTLOOK_TIMEZONE_INFO.Size]; ExBitConverter.Write(timeZoneInfo.Bias, array, O11TimeZoneFormatter.OUTLOOK_TIMEZONE_INFO.BiasOffset); ExBitConverter.Write(timeZoneInfo.StandardBias, array, O11TimeZoneFormatter.OUTLOOK_TIMEZONE_INFO.StandardBiasOffset); ExBitConverter.Write(timeZoneInfo.DaylightBias, array, O11TimeZoneFormatter.OUTLOOK_TIMEZONE_INFO.DaylightBiasOffset); ExBitConverter.Write(0, array, O11TimeZoneFormatter.OUTLOOK_TIMEZONE_INFO.StandardYearOffset); timeZoneInfo.StandardDate.Write(new ArraySegment <byte>(array, O11TimeZoneFormatter.OUTLOOK_TIMEZONE_INFO.StandardDateOffset, NativeMethods.SystemTime.Size)); ExBitConverter.Write(0, array, O11TimeZoneFormatter.OUTLOOK_TIMEZONE_INFO.DaylightYearOffset); timeZoneInfo.DaylightDate.Write(new ArraySegment <byte>(array, O11TimeZoneFormatter.OUTLOOK_TIMEZONE_INFO.DaylightDateOffset, NativeMethods.SystemTime.Size)); return(array); }
public string ToBase64String() { int num = 29; byte[] array = new byte[num]; int num2 = 0; num2 += ExBitConverter.Write(1, array, num2); num2 += ExBitConverter.Write(this.mdbGuid, array, num2); num2 += ExBitConverter.Write(this.mapiWatermark, array, num2); array[num2++] = (this.wasEventProcessed ? 1 : 0); return(Convert.ToBase64String(array)); }
// Token: 0x0600043B RID: 1083 RVA: 0x000180C8 File Offset: 0x000162C8 internal byte[] GetBytes() { int byteCount = this.GetByteCount(); byte[] array = new byte[byteCount]; int num = 0; int bytes = Encoding.Unicode.GetBytes(this.stringValue, 0, this.stringValue.Length, array, 4); num += ExBitConverter.Write(bytes, array, num); num += bytes; this.objectIdValue.GetBytes(Encoding.Unicode, array, num); return(array); }
public int ToBytes(ArraySegment <byte> target) { if (target.Count < O12TimeZoneFormatter.ExchangeTimeZoneRule.Size) { throw new ArgumentOutOfRangeException(); } ExBitConverter.Write((short)this.MajorVersion, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneRule.MajorVersionOffset); ExBitConverter.Write((short)this.MinVersion, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneRule.MinVersionOffset); ExBitConverter.Write(this.ruleSize, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneRule.RuleSizeOffset); ExBitConverter.Write(this.Flags, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneRule.FlagsOffset); this.Start.Write(new ArraySegment <byte>(target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneRule.StartOffset, NativeMethods.SystemTime.Size)); this.RegTimeZoneInfo.Write(new ArraySegment <byte>(target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneRule.RegTimeZoneInfoOffset, REG_TIMEZONE_INFO.Size)); return(O12TimeZoneFormatter.ExchangeTimeZoneRule.Size); }
public override byte[] GetBytes() { byte[] array = new byte[16]; ExBitConverter.Write(this.extensionGuid, array, 0); byte[] bytes = base.MailboxOwnerId.GetBytes(); byte[] array2 = new byte[array.Length + bytes.Length + 2]; ExBitConverter.Write((short)bytes.Length, array2, 0); int num = 2; Array.Copy(bytes, 0, array2, num, bytes.Length); num += bytes.Length; Array.Copy(array, 0, array2, num, array.Length); return(array2); }
private static void SetCadataTtlCookie(AesCryptoServiceProvider aes, int flags, HttpRequest httpRequest, HttpResponse httpResponse) { using (ICryptoTransform cryptoTransform = aes.CreateEncryptor()) { FbaModule.DetermineKeyIntervalsIfNecessary(); bool flag = (flags & 4) == 4; bool flag2 = FbaModule.IsMowa(httpRequest, flag); ExDateTime exDateTime = ExDateTime.UtcNow.AddTicks(flag2 ? FbaModule.fbaMowaKeyTTL.Ticks : (flag ? FbaModule.fbaPrivateKeyTTL.Ticks : FbaModule.fbaPublicKeyTTL.Ticks)); byte[] array = new byte[9]; ExBitConverter.Write(exDateTime.UtcTicks, array, 0); array[8] = (byte)flags; byte[] inArray = cryptoTransform.TransformFinalBlock(array, 0, array.Length); FbaModule.CreateAndAddCookieToResponse(httpRequest, httpResponse, "cadataTTL", Convert.ToBase64String(inArray)); } }
public static void ExpandIdSet(IdSet idset, Action <byte[]> action) { foreach (GuidGlobCountSet guidGlobCountSet in idset) { foreach (GlobCountRange globCountRange in guidGlobCountSet.GlobCountSet) { for (ulong num = globCountRange.LowBound; num <= globCountRange.HighBound; num += 1UL) { byte[] array = new byte[22]; int dstOffset = ExBitConverter.Write(guidGlobCountSet.Guid, array, 0); Buffer.BlockCopy(IdConverter.GlobcntIntoByteArray(num), 0, array, dstOffset, 6); action(array); } } } }
public static string GetDiagnosticContextFromThread() { if (!DiagnosticContext.HasData) { return(string.Empty); } byte[] array = DiagnosticContext.PackInfo(); byte[] array2 = new byte[array.Length + 6]; int num = 0; ExBitConverter.Write(0, array2, num); num += 2; ExBitConverter.Write((uint)array.Length, array2, num); num += 4; Array.Copy(array, 0, array2, num, array.Length); return(string.Format("[diag::{0}]", Convert.ToBase64String(array2))); }
public int ToBytes(ArraySegment <byte> target) { int size = this.GetSize(); if (target.Count < size) { throw new ArgumentOutOfRangeException(); } ExBitConverter.Write((short)this.MajorVersion, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneHeader.MajorVersionOffset); ExBitConverter.Write((short)this.MinVersion, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneHeader.MinVersionOffset); ExBitConverter.Write(this.headerSize, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneHeader.HeaderSizeOffset); ExBitConverter.Write(this.flags, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneHeader.FlagsOffset); ExBitConverter.Write(this.KeyNameLength, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneHeader.KeyNameLengthOffset); ExBitConverter.Write(this.KeyName, true, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneHeader.KeyNameOffset); ExBitConverter.Write(this.RuleCount, target.Array, target.Offset + O12TimeZoneFormatter.ExchangeTimeZoneHeader.KeyNameOffset + (int)(this.KeyNameLength * 2)); return(size); }
public static void WriteAttachmentIds(IList <AttachmentId> attachmentIds, byte[] idBytes, int index) { if (attachmentIds != null) { if (attachmentIds.Count > 255) { throw new InvalidIdTooManyAttachmentLevelsException(); } idBytes[index++] = (byte)attachmentIds.Count; for (int i = 0; i < attachmentIds.Count; i++) { byte[] array = attachmentIds[i].ToByteArray(); index += ExBitConverter.Write((short)array.Length, idBytes, index); Array.Copy(array, 0, idBytes, index, array.Length); index += array.Length; } } }
private bool DoConnectionlessHandshake() { string command; byte [] data; this.connState = ConnectionState.Connecting; WriteConnectionlessPacket("getchallenge", null, 0, 0); if (ReadConnectionlessPacket(out command, out data)) { if (command == "challengeResponse") { this.challenge = Convert.ToInt32(Encoding.Default.GetString(data)); MemoryStream ms = new MemoryStream(); ms.Position = 2; Q3HuffmanStream huff = new Q3HuffmanStream(ms, System.IO.Compression.CompressionMode.Compress); string connStr = string.Format(@"\challenge\{0}\qport\{1}\protocol\{2}{3}", this.challenge, this.qport, PROTOCOL_VERSION, userInfo); huff.WriteString(connStr); huff.Flush(); ms.Position = 0; ms.Write(ExBitConverter.GetBytes(( short )connStr.Length, false), 0, 2); this.connState = ConnectionState.Challenging; WriteConnectionlessPacket("connect ", ms.GetBuffer(), 0, ( int )ms.Length); if (ReadConnectionlessPacket(out command, out data)) { if (command == "connectResponse") { this.connState = ConnectionState.Connected; return(true); } } } } return(false); }
private static int RemoveEntriesWithProperty(int historyLength, byte[] buffer, OofHistory.PropId propId, byte[] propValue, long hashCode) { int num = 6; int currentEntryStart = 6; int result = 6; uint num2 = BitConverter.ToUInt32(buffer, 2); if (10000U < num2) { num2 = 10000U; } uint num3 = num2; for (uint num4 = 0U; num4 < num2; num4 += 1U) { if (num >= historyLength) { OofHistory.HandleInsufficientDataCorruption(hashCode, "Unable to get property count of entry " + num4); return(result); } byte propertyCount = buffer[num++]; bool flag; if (OofHistory.MatchAnyPropertiesInEntry(buffer, propId, propValue, propertyCount, historyLength, num4, hashCode, ref num, out flag)) { num3 -= 1U; } else { if (flag) { return(result); } OofHistory.HandleNonMatchingProperty(buffer, num, currentEntryStart, ref result); } currentEntryStart = num; } if (num3 < num2) { ExBitConverter.Write(num3, buffer, 2); } return(result); }
public override void Write(byte [] buffer, int offset, int count) { if (msWriteBuffer.Position == 0) { if (writePacketKind == PacketKind.Connectionless) { msWriteBuffer.Write(new byte [4] { 0xff, 0xff, 0xff, 0xff }, 0, 4); } else if (writePacketKind == PacketKind.ConnectionOriented) { msWriteBuffer.Write(ExBitConverter.GetBytes(connection.OutgoingSequence, true), 0, 4); msWriteBuffer.Write(ExBitConverter.GetBytes(connection.QPort, true), 0, 2); connection.OutgoingSequence++; } } msWriteBuffer.Write(buffer, offset, count); }
public byte[] ToByteArray() { short num = 0; if (this.attachKey != null) { num = (short)this.attachKey.Length; } int num2 = (int)(2 + num); byte[] array = new byte[num2]; int num3 = 0; num3 += ExBitConverter.Write(num, array, num3); if (this.attachKey != null) { this.attachKey.CopyTo(array, num3); } return(array); }