public override void Write(RecordType type, TlsVersion version, byte[] data) { var cipher = GetCipher().Cipher; // TODO parametrised from CipherSpec var explicitNonceLength = 8; var nonce = RandomGenerator.RandomBytes(explicitNonceLength); var aad = new byte[13]; Array.Copy(EndianBitConverter.Big.GetBytes(State.WriteSeqNum++), 0, aad, 0, 8); Array.Copy(new[] { (byte)type, version.Major, version.Major }, 0, aad, 8, 3); Array.Copy(EndianBitConverter.Big.GetBytes((ushort)data.Length), 0, aad, 11, 2); var payload = new byte[explicitNonceLength + data.Length + cipher.TagLength]; Array.Copy(nonce, payload, explicitNonceLength); cipher.Init(State.GetAEADParameters(false, aad, nonce)); var payloadLength = explicitNonceLength; payloadLength += cipher.Encrypt(data, 0, payload, payloadLength, data.Length); payloadLength += cipher.EncryptFinal(payload, payloadLength); Writer.Write(type); Writer.Write(version); Writer.Write((ushort)payloadLength); Writer.Write(payload, 0, payloadLength); }
public void AssertMxRecordAncestorIsObsolete(RecordType recordType) { var expectedMessage = "Obsolete - use an MX record."; var attribute = recordType.Attribute<ObsoleteAttribute>(); Assert.That(attribute.Message, Is.EqualTo(expectedMessage)); }
public override Record Read(RecordType type, TlsVersion version, ushort length) { var cipher = GetCipher().Cipher; // TODO parametrised from CipherSpec var explicitNonceLength = 8; var nonce = Reader.ReadBytes(explicitNonceLength); var payload = Reader.ReadBytes(length - explicitNonceLength); var aad = new byte[13]; Array.Copy(EndianBitConverter.Big.GetBytes(State.ReadSeqNum++), 0, aad, 0, 8); Array.Copy(new[] { (byte)type, version.Major, version.Major }, 0, aad, 8, 3); Array.Copy(EndianBitConverter.Big.GetBytes((ushort)(length - explicitNonceLength - cipher.TagLength)), 0, aad, 11, 2); cipher.Init(State.GetAEADParameters(true, aad, nonce)); var plaintext = new byte[payload.Length - cipher.TagLength]; var plaintextLength = cipher.Decrypt(payload, 0, plaintext, 0, payload.Length - cipher.TagLength); plaintextLength += cipher.DecryptFinal(payload, plaintextLength, plaintext, plaintextLength); Array.Resize(ref plaintext, plaintextLength); return new Record(type, version, plaintext); }
protected DnsRecordBase(string name, RecordType recordType, RecordClass recordClass, int timeToLive) { Name = name ?? String.Empty; RecordType = recordType; RecordClass = recordClass; TimeToLive = timeToLive; }
public static RecordData RecordDataFor(RecordType recordType) { switch (recordType) { case RecordType.A: return new AddressData(recordType); case RecordType.AAAA: return new IPv6AddressData(recordType); case RecordType.CNAME: case RecordType.MB: // Experimental case RecordType.MD: // Obsolete.. Should throw exception instead? Or use MX? case RecordType.MF: // Obsolete.. Should throw exception instead? Or use MX? case RecordType.MG: // Experimental case RecordType.MR: // Experimental case RecordType.NS: case RecordType.PTR: return new DomainNameData(recordType); case RecordType.HINFO: return new HostInformationData(recordType); case RecordType.MINFO: return new MailInformationData(recordType); case RecordType.MX: return new MailExchangeData(recordType); case RecordType.SOA: return new StartOfAuthorityData(recordType); case RecordType.TXT: return new TextData(recordType); case RecordType.WKS: return new WellKnownServiceData(recordType); case RecordType.NULL: // Experimental return new NullData(recordType); } return new NullData(recordType); }
public void WriteQuestion(Name name, RecordType qtype, RecordClass qclass = RecordClass.Internet) { WriteName(name); WriteUInt16((ushort)qtype); WriteUInt16((ushort)qclass); _questionCount++; }
public void Add(string controllerId, int count, string reason, RecordType type=RecordType.Permanent) { if (!Records.ContainsKey(controllerId)) Records[controllerId] = new List<ScoreRecord>(); Records[controllerId].Add(new ScoreRecord(count, reason, world.Clocks.CurrentTime, type)); if (ScoresChanged != null) ScoresChanged(); }
private Record(List<DateTime> records, int minutes, DateTime day, RecordType type) { mRecordsOfDay = records; mMinutes = minutes; mDay = day; mType = type; }
protected ResourceRecordBase(string name, int timeToLive, RecordType recordType, string recordClass = "IN") { Name = name; TimeToLive = timeToLive; _recordType = recordType; RecordClass = recordClass; }
public Record(Socket socket, Buffers receive_buffer) : this() { if (socket == null) throw new ArgumentNullException ("socket"); CompatArraySegment<byte> header_buffer = receive_buffer.EnforceHeaderLength (HeaderSize); // Read the 8 byte record header. ReceiveAll (socket, header_buffer, HeaderSize); // Read the values from the data. version = header_buffer [0]; type = (RecordType) header_buffer [1]; request_id = ReadUInt16 (header_buffer, 2); BodyLength = ReadUInt16 (header_buffer, 4); byte padding_length = header_buffer [6]; CompatArraySegment<byte> body_buffer = receive_buffer.EnforceBodyLength (BodyLength); // Read the record data, and throw an exception if the // complete data cannot be read. if (BodyLength > 0) ReceiveAll (socket, body_buffer, BodyLength); CompatArraySegment<byte> padding_buffer = receive_buffer.EnforcePaddingLength (padding_length); if(padding_length > 0) ReceiveAll(socket, padding_buffer, padding_length); buffers = receive_buffer; Logger.Write (LogLevel.Debug, Strings.Record_Received, Type, RequestID, BodyLength); }
public Record (byte version, RecordType type, ushort requestID, byte[] bodyData, int bodyIndex, int bodyLength) { if (bodyData == null) throw new ArgumentNullException ("bodyData"); if (bodyIndex < 0 || bodyIndex > bodyData.Length) throw new ArgumentOutOfRangeException ( "bodyIndex"); if (bodyLength < 0) bodyLength = bodyData.Length - bodyIndex; if (bodyLength > MaxBodySize) throw new ArgumentException ( Strings.Record_DataTooBig, "data"); this.Version = version; this.Type = type; this.RequestId = requestID; this.Body = bodyData; this.BodyOffset = bodyIndex; this.BodyLength = (ushort)bodyLength; this.PaddingLength = 0; }
public AudioParameters(RecordType recordType, int durationLimit, int sizeLimit, params string[] supportedExtensions) { DurationLimit = durationLimit; SizeLimit = sizeLimit; SupportedExtensions = supportedExtensions; AudioRecordType = recordType; }
internal ResourceRecord(string name, RecordType type, RecordClass rClass, DateTime expiry) { _name = name; _type = type; _class = rClass; _expiry = expiry; }
private DnsResponse(ushort messageId, DnsName queryName, RecordType queryType, RecordClass queryClass) { this.MessageId = messageId; this.QueryName = queryName; this.QueryType = queryType; this.QueryClass = queryClass; }
public ResourceRecord(DnsReader br) { _domain = br.ReadDomain(); _qtype = (RecordType)br.ReadInt16(); _qclass = (RecordClass)br.ReadInt16(); _ttl = br.ReadInt32(); int recordLength = br.ReadInt16(); if (recordLength != 0) { switch (_qtype) { case RecordType.A: _record = new ARecord(br); break; case RecordType.CNAME: _record = new CNAMERecord(br); break; case RecordType.MX: _record = new MXRecord(br); break; case RecordType.NS: _record = new NSRecord(br); break; case RecordType.SOA: _record = new SOARecord(br); break; case RecordType.TXT: _record = new TXTRecord(br); break; case RecordType.PTR: _record = new PTRERecord(br); break; // NetBIOS related records case RecordType.NB: _record = new NBRecord(br); break; default: br += recordLength; break; } } }
public WellKnownServiceData(RecordType recordType) { _address = new AddressData(recordType); _protocol = 0; _bitMap = new byte[0]; _recordType = recordType; }
/// <summary> /// Retrieves whois information /// </summary> /// <param name="domainName">The registrar or domain or name server whose whois information to be retrieved</param> /// <param name="recordType">The type of record i.e a domain, nameserver or a registrar</param> /// <returns></returns> public static string Lookup(string domainName, RecordType recordType) { string whoisServerName = WhoisServerResolver.GetWhoisServerName(domainName); using (TcpClient whoisClient = new TcpClient()) { whoisClient.Connect(whoisServerName, Whois_Server_Default_PortNumber); string domainQuery = recordType.ToString() + " " + domainName + "\r\n"; byte[] domainQueryBytes = Encoding.ASCII.GetBytes(domainQuery.ToCharArray()); Stream whoisStream = whoisClient.GetStream(); whoisStream.Write(domainQueryBytes, 0, domainQueryBytes.Length); StreamReader whoisStreamReader = new StreamReader(whoisClient.GetStream(), Encoding.ASCII); string streamOutputContent = ""; List<string> whoisData = new List<string>(); while (null != (streamOutputContent = whoisStreamReader.ReadLine())) { whoisData.Add(streamOutputContent); } whoisClient.Close(); return String.Join(Environment.NewLine, whoisData); } }
public override Record Read(RecordType type, TlsVersion version, ushort length) { SecurityAssert.SAssert(length <= 0x4000); var data = Reader.ReadBytes(length); return new Record(type, version, data); }
/// <summary> /// Creates a RecordSet within a DNS zone. /// </summary> /// <param name='operations'> /// Reference to the /// Microsoft.Azure.Management.Dns.IRecordSetOperations. /// </param> /// <param name='resourceGroupName'> /// Required. The name of the resource group. /// </param> /// <param name='zoneName'> /// Required. The name of the zone without a terminating dot. /// </param> /// <param name='relativeRecordSetName'> /// Required. The name of the RecordSet, relative to the name of the /// zone. /// </param> /// <param name='recordType'> /// Required. The type of DNS record. /// </param> /// <param name='parameters'> /// Required. Parameters supplied to the CreateOrUpdate operation. /// </param> /// <returns> /// The response to a RecordSet CreateOrUpdate operation. /// </returns> public static RecordSetCreateOrUpdateResponse CreateOrUpdate(this IRecordSetOperations operations, string resourceGroupName, string zoneName, string relativeRecordSetName, RecordType recordType, RecordSetCreateOrUpdateParameters parameters) { return Task.Factory.StartNew((object s) => { return ((IRecordSetOperations)s).CreateOrUpdateAsync(resourceGroupName, zoneName, relativeRecordSetName, recordType, parameters); } , operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult(); }
public ScoreRecord(int count, string reason, double time, RecordType type=RecordType.Permanent) { Count = count; Reason = reason; Time = time; Type = type; }
public Record(RecordType type, TlsVersion version, byte[] data) { Type = type; Version = version; SecurityAssert.NotNull(data); Data = data; }
public Record (byte version, RecordType type, ushort requestID, int bodyLength, Buffers buffers) : this() { Version = version; Type = type; RequestID = requestID; BodyLength = (ushort) bodyLength; Content = buffers; }
public override void Write(RecordType type, TlsVersion version, byte[] data) { Writer.Write(type); Writer.Write(version); Writer.Write((ushort)data.Length); Writer.Write(data, 0, data.Length); }
protected virtual Record Read(RecordType recordType, string text) { var reader = readers.Resolve(recordType); if (reader != null) return reader.Read(text); return new Record(recordType, text); }
public Recorder(ISimulation hostsimulator, RecordType recordtype, string recordfile) { this.hostsimulator = hostsimulator; this.recordtype = recordtype; this.recordfile = recordfile; potentialfile = spikefile = null; potentialwriter = spikewriter = null; }
protected DnsMessageBase(ushort messageId, DnsName queryName, RecordType queryType, RecordClass queryClass) : this() { this.MessageId = messageId; this.QueryCount = 1; this.QueryName = queryName; this.QueryType = queryType; this.QueryClass = queryClass; }
public ResourceRecord(Domain domain, byte[] data, RecordType type, RecordClass klass = RecordClass.IN, TimeSpan ttl = default(TimeSpan)) { this.domain = domain; this.type = type; this.klass = klass; this.ttl = ttl; this.data = data; }
public static void DoSystemEventRecord(Device device, string systemEvent, RecordType recordType = RecordType.Event) { RecordManager.WriteDataToLog(device, systemEvent, recordType); if (analysisToolOpen) { SendToAnalysisWindow(systemEvent); } }
/// <summary> /// Queries for specified records. /// </summary> /// <param name="name"> Name, that should be queried </param> /// <param name="recordType"> Type the should be queried </param> /// <returns> All available responses on the local network </returns> public List<LlmnrMessage> Resolve(DomainName name, RecordType recordType = RecordType.A) { if (name == null) throw new ArgumentNullException(nameof(name), "Name must be provided"); LlmnrMessage message = new LlmnrMessage { IsQuery = true, OperationCode = OperationCode.Query }; message.Questions.Add(new DnsQuestion(name, recordType, RecordClass.INet)); return SendMessageParallel(message); }
internal IP4AddressRecord(string name, RecordType type, RecordClass rClass, DateTime expiry, PacketReader reader) : base(name, type, rClass, expiry) { ushort dataLen = reader.ReadUShort(); int pos = reader.Position; _address = new IPAddress(reader.ReadBytes(dataLen)); reader.Position = pos + dataLen; }
public BulkCopyFieldValueRequest(RecordType recordType, IEnumerable <IRecord> recordsToUpdate) : this() { RecordType = recordType; _recordsToUpdate = recordsToUpdate; }
/// <summary> /// Removes a RecordSet from a DNS zone. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='zoneName'> /// The name of the zone without a terminating dot. /// </param> /// <param name='relativeRecordSetName'> /// The name of the RecordSet, relative to the name of the zone. /// </param> /// <param name='recordType'> /// The type of DNS record. Possible values include: 'A', 'AAAA', 'CNAME', /// 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT' /// </param> /// <param name='ifMatch'> /// Defines the If-Match condition. The delete operation will be performed /// only if the ETag of the zone on the server matches this value. /// </param> /// <param name='ifNoneMatch'> /// Defines the If-None-Match condition. The delete operation will be /// performed only if the ETag of the zone on the server does not match this /// value. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task DeleteAsync(this IRecordSetsOperations operations, string resourceGroupName, string zoneName, string relativeRecordSetName, RecordType recordType, string ifMatch = default(string), string ifNoneMatch = default(string), CancellationToken cancellationToken = default(CancellationToken)) { await operations.DeleteWithHttpMessagesAsync(resourceGroupName, zoneName, relativeRecordSetName, recordType, ifMatch, ifNoneMatch, null, cancellationToken).ConfigureAwait(false); }
/// <summary> /// Gets a RecordSet. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='zoneName'> /// The name of the zone without a terminating dot. /// </param> /// <param name='relativeRecordSetName'> /// The name of the RecordSet, relative to the name of the zone. /// </param> /// <param name='recordType'> /// The type of DNS record. Possible values include: 'A', 'AAAA', 'CNAME', /// 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT' /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <RecordSet> GetAsync(this IRecordSetsOperations operations, string resourceGroupName, string zoneName, string relativeRecordSetName, RecordType recordType, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.GetWithHttpMessagesAsync(resourceGroupName, zoneName, relativeRecordSetName, recordType, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Lists the RecordSets of a specified type in a DNS zone. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group that contains the zone. /// </param> /// <param name='zoneName'> /// The name of the zone from which to enumerate RecordsSets. /// </param> /// <param name='recordType'> /// The type of record sets to enumerate. Possible values include: 'A', /// 'AAAA', 'CNAME', 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT' /// </param> /// <param name='top'> /// Query parameters. If null is passed returns the default number of zones. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <IPage <RecordSet> > ListByTypeAsync(this IRecordSetsOperations operations, string resourceGroupName, string zoneName, RecordType recordType, string top = default(string), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.ListByTypeWithHttpMessagesAsync(resourceGroupName, zoneName, recordType, top, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Updates a RecordSet within a DNS zone. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='zoneName'> /// The name of the zone without a terminating dot. /// </param> /// <param name='relativeRecordSetName'> /// The name of the RecordSet, relative to the name of the zone. /// </param> /// <param name='recordType'> /// The type of DNS record. Possible values include: 'A', 'AAAA', 'CNAME', /// 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT' /// </param> /// <param name='parameters'> /// Parameters supplied to the Update operation. /// </param> /// <param name='ifMatch'> /// The etag of Zone. /// </param> /// <param name='ifNoneMatch'> /// Defines the If-None-Match condition. Set to '*' to force /// Create-If-Not-Exist. Other values will be ignored. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <RecordSet> UpdateAsync(this IRecordSetsOperations operations, string resourceGroupName, string zoneName, string relativeRecordSetName, RecordType recordType, RecordSet parameters, string ifMatch = default(string), string ifNoneMatch = default(string), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.UpdateWithHttpMessagesAsync(resourceGroupName, zoneName, relativeRecordSetName, recordType, parameters, ifMatch, ifNoneMatch, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public bool Equals(A x, A y) => RecordType <A> .EqualityTyped(x, y);
/// <summary> /// Sends a record to the client. /// </summary> /// <param name="type"> /// A <see cref="RecordType" /> specifying the type of record /// to send. /// </param> /// <param name="requestID"> /// A <see cref="ushort" /> containing the ID of the request /// the record is associated with. /// </param> /// <param name="bodyData"> /// A <see cref="byte[]" /> containing the body data for the /// request. /// </param> /// <remarks> /// If the socket is not connected, the record will not be /// sent. /// </remarks> /// <exception cref="ArgumentNullException"> /// <paramref name="bodyData" /> is <see langword="null" />. /// </exception> public void SendRecord(RecordType type, ushort requestID, byte [] bodyData) { SendRecord(type, requestID, bodyData, 0, -1); }
/// <summary> /// 加载存档,如果存档不存在则创建新存档 /// </summary> /// <param name="recordType">存档类型,注意需要与文件名相同</param> public static void InitOrCreateRecord(RecordType recordType) { InitOrCreateRecord(recordType.ToString()); }
public static async Task <RecordSet> GetOrDefaultAsync(this IRecordSetsOperations operations, string resourceGroupName, string zoneName, string relativeRecordSetName, RecordType recordType) { try { return(await operations.GetAsync(resourceGroupName, zoneName, relativeRecordSetName, RecordType.TXT)); } catch { return(null); } }
public override void Validate(object state) { base.Validate(state); //if (XPath.IsNull()) // throw new ChoRecordConfigurationException("XPath can't be null or whitespace."); if (XPath.IsNullOrWhiteSpace()) { if (!IsDynamicObject && (RecordType.IsGenericType && RecordType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>))) { NodeName = NodeName.IsNullOrWhiteSpace() ? "KeyValuePair" : NodeName; RootName = RootName.IsNullOrWhiteSpace() ? "KeyValuePairs" : RootName; } else if (!IsDynamicObject && !typeof(IChoScalarObject).IsAssignableFrom(RecordType)) { NodeName = NodeName.IsNullOrWhiteSpace() ? RecordType.Name : NodeName; RootName = RootName.IsNullOrWhiteSpace() ? NodeName.ToPlural() : RootName; } } else { RootName = RootName.IsNullOrWhiteSpace() ? XPath.SplitNTrim("/").Where(t => !t.IsNullOrWhiteSpace() && t.NTrim() != "." && t.NTrim() != ".." && t.NTrim() != "*").FirstOrDefault() : RootName; NodeName = NodeName.IsNullOrWhiteSpace() ? XPath.SplitNTrim("/").Where(t => !t.IsNullOrWhiteSpace() && t.NTrim() != "." && t.NTrim() != ".." && t.NTrim() != "*").Skip(1).FirstOrDefault() : NodeName; } string rootName = null; string nodeName = null; ChoXmlDocumentRootAttribute da = TypeDescriptor.GetAttributes(RecordType).OfType <ChoXmlDocumentRootAttribute>().FirstOrDefault(); if (da != null) { rootName = da.Name; } else { XmlRootAttribute ra = TypeDescriptor.GetAttributes(RecordType).OfType <XmlRootAttribute>().FirstOrDefault(); if (ra != null) { nodeName = ra.ElementName; } } RootName = RootName.IsNullOrWhiteSpace() && !rootName.IsNullOrWhiteSpace() ? rootName : RootName; NodeName = NodeName.IsNullOrWhiteSpace() && !nodeName.IsNullOrWhiteSpace() ? nodeName : NodeName; RootName = RootName.IsNullOrWhiteSpace() && !NodeName.IsNullOrWhiteSpace() ? NodeName.ToPlural() : RootName; if (!RootName.IsNullOrWhiteSpace() && RootName.ToSingular() != RootName) { NodeName = NodeName.IsNullOrWhiteSpace() && !RootName.IsNullOrWhiteSpace() ? RootName.ToSingular() : NodeName; } if (RootName.IsNullOrWhiteSpace()) { RootName = "Root"; } if (NodeName.IsNullOrWhiteSpace()) { NodeName = "XElement"; } //Encode Root and node names RootName = System.Net.WebUtility.HtmlEncode(RootName); NodeName = System.Net.WebUtility.HtmlEncode(NodeName); string[] fieldNames = null; XElement xpr = null; if (state is Tuple <long, XElement> ) { xpr = ((Tuple <long, XElement>)state).Item2; } else { fieldNames = state as string[]; } if (AutoDiscoverColumns && XmlRecordFieldConfigurations.Count == 0) { if (RecordType != null && !IsDynamicObject && ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().Any()).Any()) { DiscoverRecordFields(RecordType); } else if (xpr != null) { XmlRecordFieldConfigurations.AddRange(DiscoverRecordFieldsFromXElement(xpr)); } else if (!fieldNames.IsNullOrEmpty()) { foreach (string fn in fieldNames) { if (IgnoredFields.Contains(fn)) { continue; } if (fn.StartsWith("_")) { string fn1 = fn.Substring(1); var obj = new ChoXmlRecordFieldConfiguration(fn, xPath: $"./{fn1}"); obj.FieldName = fn1; obj.IsXmlAttribute = true; XmlRecordFieldConfigurations.Add(obj); } else if (fn.EndsWith("_")) { string fn1 = fn.Substring(0, fn.Length - 1); var obj = new ChoXmlRecordFieldConfiguration(fn, xPath: $"./{fn1}"); obj.FieldName = fn1; obj.IsXmlCDATA = true; XmlRecordFieldConfigurations.Add(obj); } else { var obj = new ChoXmlRecordFieldConfiguration(fn, xPath: $"./{fn}"); XmlRecordFieldConfigurations.Add(obj); } } } } else { IsComplexXPathUsed = false; foreach (var fc in XmlRecordFieldConfigurations) { if (fc.IsArray == null) { fc.IsArray = typeof(ICollection).IsAssignableFrom(fc.FieldType); } if (fc.FieldName.IsNullOrWhiteSpace()) { fc.FieldName = fc.Name; } if (fc.XPath.IsNullOrWhiteSpace()) { fc.XPath = $"/{fc.FieldName}|/@{fc.FieldName}"; } else { if (fc.XPath == fc.FieldName || fc.XPath == $"/{fc.FieldName}" || fc.XPath == $"/{fc.FieldName}" || fc.XPath == $"/{fc.FieldName}" || fc.XPath == $"/@{fc.FieldName}" || fc.XPath == $"/@{fc.FieldName}" || fc.XPath == $"/@{fc.FieldName}" ) { } else { IsComplexXPathUsed = true; fc.UseCache = false; } } } } if (XmlRecordFieldConfigurations.Count <= 0) { throw new ChoRecordConfigurationException("No record fields specified."); } //Validate each record field foreach (var fieldConfig in XmlRecordFieldConfigurations) { fieldConfig.Validate(this); } //Check field position for duplicate string[] dupFields = XmlRecordFieldConfigurations.GroupBy(i => i.Name) .Where(g => g.Count() > 1) .Select(g => g.Key).ToArray(); if (dupFields.Length > 0) { throw new ChoRecordConfigurationException("Duplicate field(s) [Name(s): {0}] found.".FormatString(String.Join(",", dupFields))); } PIDict = new Dictionary <string, System.Reflection.PropertyInfo>(); PDDict = new Dictionary <string, PropertyDescriptor>(); foreach (var fc in XmlRecordFieldConfigurations) { if (fc.PropertyDescriptor == null) { fc.PropertyDescriptor = ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Name == fc.Name).FirstOrDefault(); } if (fc.PropertyDescriptor == null) { continue; } PIDict.Add(fc.Name, fc.PropertyDescriptor.ComponentType.GetProperty(fc.PropertyDescriptor.Name)); PDDict.Add(fc.Name, fc.PropertyDescriptor); } RecordFieldConfigurationsDict = XmlRecordFieldConfigurations.OrderBy(c => c.IsXmlAttribute).Where(i => !i.Name.IsNullOrWhiteSpace()).ToDictionary(i => i.Name); if (XmlRecordFieldConfigurations.Where(e => e.IsNullable).Any() || NullValueHandling == ChoNullValueHandling.Default) { if (NamespaceManager != null) { if (!NamespaceManager.HasNamespace("xsi")) { NamespaceManager.AddNamespace("xsi", ChoXmlSettings.XmlSchemaInstanceNamespace); } if (!NamespaceManager.HasNamespace("xsd")) { NamespaceManager.AddNamespace("xsd", ChoXmlSettings.XmlSchemaNamespace); } } } LoadNCacheMembers(XmlRecordFieldConfigurations); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="Record" /> populating it with a specified version, /// type, ID, and body. /// </summary> /// <param name="version"> /// A <see cref="byte" /> containing the FastCGI version the /// record is structured for. /// </param> /// <param name="type"> /// A <see cref="RecordType" /> containing the type of /// record to create. /// </param> /// <param name="requestID"> /// A <see cref="ushort" /> containing the ID of the request /// associated with the new record. /// </param> /// <param name="bodyData"> /// A <see cref="byte[]" /> containing the contents to use /// in the new record. /// </param> /// <remarks> /// <note type="caution"> /// The new instance will store a reference to <paramref /// name="bodyData" /> and as such be invalid when the /// value changes externally. /// </note> /// </remarks> /// <exception cref="ArgumentNullException"> /// <paramref name="bodyData" /> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="bodyData" /> contains more than 65535 /// bytes and cannot be sent. /// </exception> public Record(byte version, RecordType type, ushort requestID, byte [] bodyData) : this(version, type, requestID, bodyData, 0, -1) { }
protected async Task <DnsResolveResult <TRecord> > ResolveDnsAsync <TRecord>(DomainName domain, RecordType recordType, CancellationToken token) where TRecord : DnsRecordBase { try { var records = await DnsResolver.ResolveAsync <TRecord>(domain, recordType, token : token); return(new DnsResolveResult <TRecord>(ReturnCode.NoError, records)); } catch { return(new DnsResolveResult <TRecord>(ReturnCode.ServerFailure, null)); } }
private async Task <bool?> IsIpMatchAsync <TRecord>(DomainName domain, IPAddress ipAddress, int?prefix, RecordType recordType, CancellationToken token) where TRecord : DnsRecordBase, IAddressRecord { DnsResolveResult <TRecord> dnsResult = await ResolveDnsAsync <TRecord>(domain, recordType, token); if ((dnsResult == null) || ((dnsResult.ReturnCode != ReturnCode.NoError) && (dnsResult.ReturnCode != ReturnCode.NxDomain))) { return(null); } foreach (var dnsRecord in dnsResult.Records) { if (prefix.HasValue) { if (ipAddress.Equals(dnsRecord.Address.GetNetworkAddress(prefix.Value))) { return(true); } } else { if (ipAddress.Equals(dnsRecord.Address)) { return(true); } } } return(false); }
/// <summary> /// Initializes a new instance of the <see cref = "VersionManager<T>" /> class. /// </summary> /// <param name = "recType">Type of the record.</param> public VersionManager(RecordType recType) { RecordType = recType; }
/// <summary> /// Creates a new instance of the RecordExistsPrequisite class /// </summary> /// <param name="name"> Name of record that should be checked </param> /// <param name="recordType"> Type of record that should be checked </param> public RecordExistsPrequisite(DomainName name, RecordType recordType) : base(name, recordType, RecordClass.Any, 0) { }
/// <summary> /// 删除存档 /// </summary> public static void DeleteRecord(RecordType recordType) { EZSave.Instance.DeletRecord(recordType.ToString()); }
public int GetHashCode(A x) => RecordType <A> .Hash(x);
private void RecordTypePage_TimeSeriesNextClick(object sender, RoutedEventArgs e) { RecordTypePage.Visibility = Visibility.Collapsed; DatePage.Visibility = Visibility.Visible; RecordType = RecordType.RegularTimeSeries; }
public int Compare(A x, A y) => RecordType <A> .Compare(x, y);
private void RecordTypePage_PairedDataNextClick(object sender, RoutedEventArgs e) { RecordTypePage.Visibility = Visibility.Collapsed; OrdinatePage.Visibility = Visibility.Visible; RecordType = RecordType.PairedData; }
/// <summary> /// Updates a RecordSet within a DNS zone. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='zoneName'> /// The name of the zone without a terminating dot. /// </param> /// <param name='relativeRecordSetName'> /// The name of the RecordSet, relative to the name of the zone. /// </param> /// <param name='recordType'> /// The type of DNS record. Possible values include: 'A', 'AAAA', 'CNAME', /// 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT' /// </param> /// <param name='parameters'> /// Parameters supplied to the Update operation. /// </param> /// <param name='ifMatch'> /// The etag of Zone. /// </param> /// <param name='ifNoneMatch'> /// Defines the If-None-Match condition. Set to '*' to force /// Create-If-Not-Exist. Other values will be ignored. /// </param> public static RecordSet Update(this IRecordSetsOperations operations, string resourceGroupName, string zoneName, string relativeRecordSetName, RecordType recordType, RecordSet parameters, string ifMatch = default(string), string ifNoneMatch = default(string)) { return(Task.Factory.StartNew(s => ((IRecordSetsOperations)s).UpdateAsync(resourceGroupName, zoneName, relativeRecordSetName, recordType, parameters, ifMatch, ifNoneMatch), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
private IList <IResourceRecord> Get(Domain domain, RecordType type) { return(entries.Where(e => Matches(domain, e.Name) && e.Type == type).ToList()); }
/// <summary> /// Lists the RecordSets of a specified type in a DNS zone. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group that contains the zone. /// </param> /// <param name='zoneName'> /// The name of the zone from which to enumerate RecordsSets. /// </param> /// <param name='recordType'> /// The type of record sets to enumerate. Possible values include: 'A', /// 'AAAA', 'CNAME', 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT' /// </param> /// <param name='top'> /// Query parameters. If null is passed returns the default number of zones. /// </param> public static IPage <RecordSet> ListByType(this IRecordSetsOperations operations, string resourceGroupName, string zoneName, RecordType recordType, string top = default(string)) { return(Task.Factory.StartNew(s => ((IRecordSetsOperations)s).ListByTypeAsync(resourceGroupName, zoneName, recordType, top), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
private void WriteRecord(RecordType rt, int value) { s_stream !.WriteByte((byte)rt); WriteInt32(value); }
/// <summary> /// Gets a RecordSet. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='zoneName'> /// The name of the zone without a terminating dot. /// </param> /// <param name='relativeRecordSetName'> /// The name of the RecordSet, relative to the name of the zone. /// </param> /// <param name='recordType'> /// The type of DNS record. Possible values include: 'A', 'AAAA', 'CNAME', /// 'MX', 'NS', 'PTR', 'SOA', 'SRV', 'TXT' /// </param> public static RecordSet Get(this IRecordSetsOperations operations, string resourceGroupName, string zoneName, string relativeRecordSetName, RecordType recordType) { return(Task.Factory.StartNew(s => ((IRecordSetsOperations)s).GetAsync(resourceGroupName, zoneName, relativeRecordSetName, recordType), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
public ConfigureAutonumberRequest(RecordType recordType) { RecordType = recordType; }
public BulkReplaceRequest(RecordType recordType, IEnumerable <IRecord> recordsToUpdate) { RecordType = recordType; _recordsToUpdate = recordsToUpdate; }
public RecordBase(RecordType type, ushort requestId) : this() { RecordType = type; RequestId = requestId; }
partial void ConditionsCustomParse(OverlayStream stream, long finalPos, int offset, RecordType type, PreviousParse lastParsed) { Conditions = ConditionBinaryOverlay.ConstructBinayOverlayList(stream, _package); }
public Record(string message = "", RecordType recordType = RecordType.Output) { Message = message; Written = DateTime.Now; RecordType = recordType; }