public static Create ( |
||
e | ||
translation | ||
defaultCode | uint | |
Résultat |
/// <summary> /// Checks that the filter is valid. /// </summary> public ServiceResult Validate() { // check deadband type enumeration. if ((int)DeadbandType < (int)Opc.Ua.DeadbandType.None || (int)DeadbandType > (int)Opc.Ua.DeadbandType.Percent) { return(ServiceResult.Create( StatusCodes.BadDeadbandFilterInvalid, "Deadband type '{0}' is not recognized.", DeadbandType)); } // check data change trigger enumeration. if ((int)Trigger < (int)DataChangeTrigger.Status || (int)Trigger > (int)DataChangeTrigger.StatusValueTimestamp) { return(ServiceResult.Create( StatusCodes.BadDeadbandFilterInvalid, "Deadband trigger '{0}' is not recognized.", Trigger)); } // deadband value must always be greater than 0. if (DeadbandValue < 0) { return(ServiceResult.Create( StatusCodes.BadDeadbandFilterInvalid, "Deadband value '{0}' cannot be less than zero.", DeadbandValue)); } // deadband percentage must be less than 100. if ((int)DeadbandType == (int)Opc.Ua.DeadbandType.Percent) { if (DeadbandValue > 100) { return(ServiceResult.Create( StatusCodes.BadDeadbandFilterInvalid, "Percentage deadband value '{0}' cannot be greater than 100.", DeadbandValue)); } } // passed initial validation. return(ServiceResult.Good); }
/// <summary> /// Creates a fault message. /// </summary> /// <param name="request">The request.</param> /// <param name="exception">The exception.</param> /// <returns>A fault message.</returns> protected static Exception CreateSoapFault(IServiceRequest request, Exception exception) { ServiceFault fault = CreateFault(request, exception); // get the error from the header. ServiceResult error = fault.ResponseHeader.ServiceResult; if (error == null) { error = ServiceResult.Create(StatusCodes.BadUnexpectedError, "An unknown error occurred."); } // construct the fault code and fault reason. string codeName = StatusCodes.GetBrowseName(error.Code); return(new ServiceResultException((uint)error.StatusCode, codeName, exception)); }
/// <summary> /// Validates the operand (sets the ParsedBrowsePath and ParsedIndexRange properties). /// </summary> public override ServiceResult Validate(FilterContext context, int index) { m_validated = false; // verify attribute id. if (!Attributes.IsValid(m_attributeId)) { return(ServiceResult.Create( StatusCodes.BadAttributeIdInvalid, "SimpleAttributeOperand does not specify a valid AttributeId ({0}).", m_attributeId)); } // initialize as empty. m_parsedIndexRange = NumericRange.Empty; // parse the index range. if (!String.IsNullOrEmpty(m_indexRange)) { try { m_parsedIndexRange = NumericRange.Parse(m_indexRange); } catch (Exception e) { return(ServiceResult.Create( e, StatusCodes.BadIndexRangeInvalid, "SimpleAttributeOperand does not specify a valid BrowsePath ({0}).", m_indexRange)); } if (m_attributeId != Attributes.Value) { return(ServiceResult.Create( StatusCodes.BadIndexRangeInvalid, "SimpleAttributeOperand specifies an IndexRange for an Attribute other than Value ({0}).", m_attributeId)); } } m_validated = true; return(ServiceResult.Good); }
/// <summary> /// Validates a software certificate. /// </summary> public static ServiceResult Validate( CertificateValidator validator, byte[] signedCertificate, out SoftwareCertificate softwareCertificate) { softwareCertificate = null; // validate the certificate. X509Certificate2 certificate = null; try { certificate = new X509Certificate2(signedCertificate); validator.Validate(certificate); } catch (Exception e) { return(ServiceResult.Create(e, StatusCodes.BadDecodingError, "Could not decode software certificate body.")); } // find the software certficate. byte[] encodedData = null; if (encodedData == null) { return(ServiceResult.Create(StatusCodes.BadCertificateInvalid, "Could not find extension containing the software certficate.")); } try { MemoryStream istrm = new MemoryStream(encodedData, false); DataContractSerializer serializer = new DataContractSerializer(typeof(SoftwareCertificate)); softwareCertificate = (SoftwareCertificate)serializer.ReadObject(istrm); softwareCertificate.SignedCertificate = certificate; } catch (Exception e) { return(ServiceResult.Create(e, StatusCodes.BadCertificateInvalid, "Certificate does not contain a valid SoftwareCertificate body.")); } // certificate is valid. return(ServiceResult.Good); }
/// <summary> /// Creates a fault message. /// </summary> /// <param name="request">The request.</param> /// <param name="exception">The exception.</param> /// <returns>A fault message.</returns> protected static Exception CreateSoapFault(IServiceRequest request, Exception exception) { ServiceFault fault = CreateFault(request, exception); // get the error from the header. ServiceResult error = fault.ResponseHeader.ServiceResult; if (error == null) { error = ServiceResult.Create(StatusCodes.BadUnexpectedError, "An unknown error occurred."); } // construct the fault code and fault reason. string codeName = StatusCodes.GetBrowseName(error.Code); FaultCode code = null; FaultReason reason = null; if (!LocalizedText.IsNullOrEmpty(error.LocalizedText)) { reason = new FaultReason(new FaultReasonText(Utils.Format("{0}", error.LocalizedText), CultureInfo.InvariantCulture)); } else { reason = new FaultReason(new FaultReasonText(codeName, CultureInfo.InvariantCulture)); } if (!String.IsNullOrEmpty(error.SymbolicId)) { FaultCode subcode = new FaultCode(error.SymbolicId, error.NamespaceUri); code = new FaultCode(codeName, Namespaces.OpcUa, subcode); } else { code = new FaultCode(codeName, Namespaces.OpcUa); } // throw the fault. return(new FaultException <ServiceFault>(fault, reason, code)); }
/// <summary> /// Validates a read value id parameter. /// </summary> public static ServiceResult Validate(HistoryReadValueId valueId) { // check for null structure. if (valueId == null) { return(StatusCodes.BadStructureMissing); } // null node ids are always invalid. if (NodeId.IsNull(valueId.NodeId)) { return(StatusCodes.BadNodeIdInvalid); } // initialize as empty. valueId.ParsedIndexRange = NumericRange.Empty; // parse the index range if specified. if (!String.IsNullOrEmpty(valueId.IndexRange)) { try { valueId.ParsedIndexRange = NumericRange.Parse(valueId.IndexRange); } catch (Exception e) { return(ServiceResult.Create(e, StatusCodes.BadIndexRangeInvalid, String.Empty)); } } else { valueId.ParsedIndexRange = NumericRange.Empty; } // passed basic validation. return(null); }
/// <summary> /// Does any processing before a condition is enabled or disabled. /// </summary> /// <param name="context">The system context.</param> /// <param name="enabling">True is the condition is being enabled.</param> protected virtual ServiceResult ProcessBeforeEnableDisable(ISystemContext context, bool enabling) { if (enabling && this.EnabledState.Id.Value) { return(StatusCodes.BadConditionAlreadyEnabled); } if (!enabling && !this.EnabledState.Id.Value) { return(StatusCodes.BadConditionAlreadyDisabled); } if (OnEnableDisable != null) { try { return(OnEnableDisable(context, this, enabling)); } catch (Exception e) { return(ServiceResult.Create(e, StatusCodes.BadUnexpectedError, "Unexpected error enabling or disabling a Condition.")); } } return(ServiceResult.Good); }
/// <summary> /// Validates a write value parameter. /// </summary> public static ServiceResult Validate(WriteValue value) { // check for null structure. if (value == null) { return(StatusCodes.BadStructureMissing); } // null node ids are always invalid. if (value.NodeId == null) { return(StatusCodes.BadNodeIdInvalid); } // must be a legimate attribute value. if (!Attributes.IsValid(value.AttributeId)) { return(StatusCodes.BadAttributeIdInvalid); } // initialize as empty. value.ParsedIndexRange = NumericRange.Empty; // parse the index range if specified. if (!String.IsNullOrEmpty(value.IndexRange)) { try { value.ParsedIndexRange = NumericRange.Parse(value.IndexRange); } catch (Exception e) { return(ServiceResult.Create(e, StatusCodes.BadIndexRangeInvalid, String.Empty)); } // check that value provided is actually an array. Array array = value.Value.Value as Array; if (array == null) { return(StatusCodes.BadTypeMismatch); } NumericRange range = value.ParsedIndexRange; // check that the number of elements to write matches the index range. if (range.End >= 0 && (range.End - range.Begin != array.Length - 1)) { return(StatusCodes.BadIndexRangeNoData); } // check for single element. if (range.End < 0 && array.Length != 1) { return(StatusCodes.BadIndexRangeInvalid); } } else { value.ParsedIndexRange = NumericRange.Empty; } // passed basic validation. return(null); }
/// <summary> /// Applies the data encoding to the value. /// </summary> public static ServiceResult ApplyDataEncoding(ServiceMessageContext context, QualifiedName dataEncoding, ref object value) { // check if nothing to do. if (QualifiedName.IsNull(dataEncoding) || value == null) { return(ServiceResult.Good); } // check for supported encoding type. if (dataEncoding.NamespaceIndex != 0) { return(StatusCodes.BadDataEncodingUnsupported); } bool useXml = dataEncoding.Name == DefaultXml; if (!useXml && dataEncoding.Name != DefaultBinary) { return(StatusCodes.BadDataEncodingUnsupported); } try { // check for array of encodeables. IList <IEncodeable> encodeables = value as IList <IEncodeable>; if (encodeables == null) { // check for array of extension objects. IList <ExtensionObject> extensions = value as IList <ExtensionObject>; if (extensions != null) { // convert extension objects to encodeables. encodeables = new IEncodeable[extensions.Count]; for (int ii = 0; ii < encodeables.Count; ii++) { if (ExtensionObject.IsNull(extensions[ii])) { encodeables[ii] = null; continue; } IEncodeable element = extensions[ii].Body as IEncodeable; if (element == null) { return(StatusCodes.BadTypeMismatch); } encodeables[ii] = element; } } } // apply data encoding to the array. if (encodeables != null) { ExtensionObject[] extensions = new ExtensionObject[encodeables.Count]; for (int ii = 0; ii < extensions.Length; ii++) { extensions[ii] = Encode(context, encodeables[ii], useXml); } value = extensions; return(ServiceResult.Good); } // check for scalar value. IEncodeable encodeable = value as IEncodeable; if (encodeable == null) { ExtensionObject extension = value as ExtensionObject; if (extension == null) { return(StatusCodes.BadDataEncodingUnsupported); } encodeable = extension.Body as IEncodeable; } if (encodeable == null) { return(StatusCodes.BadDataEncodingUnsupported); } // do conversion. value = Encode(context, encodeable, useXml); return(ServiceResult.Good); } catch (Exception e) { return(ServiceResult.Create(e, StatusCodes.BadTypeMismatch, "Could not convert value to requested format.")); } }
private static ServiceResult CheckChainStatus(X509ChainStatus status, CertificateIdentifier id, CertificateIdentifier issuer, bool isIssuer) { switch (status.Status) { case X509ChainStatusFlags.NotValidForUsage: { return(ServiceResult.Create( (isIssuer) ? StatusCodes.BadCertificateUseNotAllowed : StatusCodes.BadCertificateIssuerUseNotAllowed, "Certificate may not be used as an application instance certificate. {0}: {1}", status.Status, status.StatusInformation)); } case X509ChainStatusFlags.NoError: case X509ChainStatusFlags.OfflineRevocation: case X509ChainStatusFlags.InvalidBasicConstraints: case X509ChainStatusFlags.PartialChain: { break; } case X509ChainStatusFlags.UntrustedRoot: { // ignore this error because the root check is done // by looking the certificate up in the trusted issuer stores passed to the validator. // the ChainStatus uses the Windows trusted issuer stores. break; } case X509ChainStatusFlags.RevocationStatusUnknown: { if (issuer != null) { if ((issuer.ValidationOptions & CertificateValidationOptions.SuppressRevocationStatusUnknown) != 0) { break; } } // check for meaning less errors for self-signed certificates. if (id.Certificate != null && Utils.CompareDistinguishedName(id.Certificate.Subject, id.Certificate.Subject)) { break; } return(ServiceResult.Create( (isIssuer) ? StatusCodes.BadCertificateIssuerRevocationUnknown : StatusCodes.BadCertificateRevocationUnknown, "Certificate revocation status cannot be verified. {0}: {1}", status.Status, status.StatusInformation)); } case X509ChainStatusFlags.Revoked: { return(ServiceResult.Create( (isIssuer) ? StatusCodes.BadCertificateIssuerRevoked : StatusCodes.BadCertificateRevoked, "Certificate has been revoked. {0}: {1}", status.Status, status.StatusInformation)); } case X509ChainStatusFlags.NotTimeNested: { if (id != null && ((id.ValidationOptions & CertificateValidationOptions.SuppressCertificateExpired) != 0)) { break; } return(ServiceResult.Create( StatusCodes.BadCertificateIssuerTimeInvalid, "Certificate issuer validatity time does not overhas is expired or not yet valid. {0}: {1}", status.Status, status.StatusInformation)); } case X509ChainStatusFlags.NotTimeValid: { if (id != null && ((id.ValidationOptions & CertificateValidationOptions.SuppressCertificateExpired) != 0)) { break; } return(ServiceResult.Create( (isIssuer) ? StatusCodes.BadCertificateIssuerTimeInvalid : StatusCodes.BadCertificateTimeInvalid, "Certificate has is expired or not yet valid. {0}: {1}", status.Status, status.StatusInformation)); } default: { return(ServiceResult.Create( StatusCodes.BadCertificateInvalid, "Certificate validation failed. {0}: {1}", status.Status, status.StatusInformation)); } } return(null); }
/// <summary> /// Validates a write value parameter. /// </summary> public static ServiceResult Validate(WriteValue value) { // check for null structure. if (value == null) { return(StatusCodes.BadStructureMissing); } // null node ids are always invalid. if (value.NodeId == null) { return(StatusCodes.BadNodeIdInvalid); } // must be a legimate attribute value. if (!Attributes.IsValid(value.AttributeId)) { return(StatusCodes.BadAttributeIdInvalid); } // initialize as empty. value.ParsedIndexRange = NumericRange.Empty; // parse the index range if specified. if (!String.IsNullOrEmpty(value.IndexRange)) { try { value.ParsedIndexRange = NumericRange.Parse(value.IndexRange); } catch (Exception e) { return(ServiceResult.Create(e, StatusCodes.BadIndexRangeInvalid, String.Empty)); } if (value.ParsedIndexRange.SubRanges != null) { Matrix matrix = value.Value.Value as Matrix; if (matrix == null) { // Check for String or ByteString arrays. Those DataTypes have special handling // when using sub ranges. bool isArrayWithValidDataType = value.Value.Value is Array && value.Value.WrappedValue.TypeInfo.BuiltInType == BuiltInType.String || value.Value.WrappedValue.TypeInfo.BuiltInType == BuiltInType.ByteString; if (!isArrayWithValidDataType) { return(StatusCodes.BadTypeMismatch); } } } else { // check that value provided is actually an array. Array array = value.Value.Value as Array; string str = value.Value.Value as string; if (array != null) { NumericRange range = value.ParsedIndexRange; // check that the number of elements to write matches the index range. if (range.End >= 0 && (range.End - range.Begin != array.Length - 1)) { return(StatusCodes.BadIndexRangeNoData); } // check for single element. if (range.End < 0 && array.Length != 1) { return(StatusCodes.BadIndexRangeInvalid); } } else if (str != null) { NumericRange range = value.ParsedIndexRange; // check that the number of elements to write matches the index range. if (range.End >= 0 && (range.End - range.Begin != str.Length - 1)) { return(StatusCodes.BadIndexRangeNoData); } // check for single element. if (range.End < 0 && str.Length != 1) { return(StatusCodes.BadIndexRangeInvalid); } } else { return(StatusCodes.BadTypeMismatch); } } } else { value.ParsedIndexRange = NumericRange.Empty; } // passed basic validation. return(null); }
/// <summary> /// Validates the object. /// </summary> public Result Validate(FilterContext context) { Result result = new Result(); // check for top level error. if (m_selectClauses == null || m_selectClauses.Count == 0) { result.Status = ServiceResult.Create( StatusCodes.BadStructureMissing, "EventFilter does not specify any Select Clauses."); return(result); } if (m_whereClause == null) { result.Status = ServiceResult.Create( StatusCodes.BadStructureMissing, "EventFilter does not specify any Where Clauses."); return(result); } result.Status = ServiceResult.Good; // validate select clause. bool error = false; foreach (SimpleAttributeOperand clause in m_selectClauses) { ServiceResult clauseResult = null; // check for null. if (clause == null) { clauseResult = ServiceResult.Create( StatusCodes.BadStructureMissing, "EventFilterSelectClause cannot be null in EventFilter SelectClause."); result.SelectClauseResults.Add(clauseResult); error = true; continue; } // validate clause. clauseResult = clause.Validate(context, 0); if (ServiceResult.IsBad(clauseResult)) { result.SelectClauseResults.Add(clauseResult); error = true; continue; } // clause ok. result.SelectClauseResults.Add(null); } if (error) { result.Status = StatusCodes.BadEventFilterInvalid; } else { result.SelectClauseResults.Clear(); } // validate where clause. result.WhereClauseResult = m_whereClause.Validate(context); if (ServiceResult.IsBad(result.WhereClauseResult.Status)) { result.Status = StatusCodes.BadEventFilterInvalid; } return(result); }
/// <summary> /// Validates the operand. /// </summary> /// <param name="context">The context.</param> /// <param name="index">The index.</param> /// <returns>the result of the validation</returns> public virtual ServiceResult Validate(FilterContext context, int index) { return(ServiceResult.Create(StatusCodes.BadEventFilterInvalid, "A sub-class of FilterOperand must be specified.")); }
/// <summary> /// Validates the content filter element. /// </summary> /// <param name="context">The context.</param> /// <param name="index">The index.</param> /// <returns>The results of the validation.</returns> public virtual ContentFilter.ElementResult Validate(FilterContext context, int index) { ContentFilter.ElementResult result = new ContentFilter.ElementResult(null); // check the number of operands. int operandCount = -1; switch (m_filterOperator) { case FilterOperator.Not: case FilterOperator.IsNull: case FilterOperator.InView: case FilterOperator.OfType: { operandCount = 1; break; } case FilterOperator.And: case FilterOperator.Or: case FilterOperator.Equals: case FilterOperator.GreaterThan: case FilterOperator.GreaterThanOrEqual: case FilterOperator.LessThan: case FilterOperator.LessThanOrEqual: case FilterOperator.Like: case FilterOperator.Cast: { operandCount = 2; break; } case FilterOperator.Between: { operandCount = 3; break; } case FilterOperator.RelatedTo: { operandCount = 4; break; } case FilterOperator.InList: { operandCount = -1; break; } default: { break; } } if (operandCount != -1) { if (operandCount != m_filterOperands.Count) { result.Status = ServiceResult.Create( StatusCodes.BadEventFilterInvalid, "ContentFilterElement does not have the correct number of operands (Operator={0} OperandCount={1}).", m_filterOperator, operandCount); return(result); } } else { if (m_filterOperands.Count < 2) { result.Status = ServiceResult.Create( StatusCodes.BadEventFilterInvalid, "ContentFilterElement does not have the correct number of operands (Operator={0} OperandCount={1}).", m_filterOperator, m_filterOperands.Count); return(result); } } // validate the operands. bool error = false; for (int ii = 0; ii < m_filterOperands.Count; ii++) { ServiceResult operandResult = null; ExtensionObject operand = m_filterOperands[ii]; // check for null. if (ExtensionObject.IsNull(operand)) { operandResult = ServiceResult.Create( StatusCodes.BadEventFilterInvalid, "The FilterOperand cannot be Null."); result.OperandResults.Add(operandResult); error = true; continue; } // check that the extension object contains a filter operand. FilterOperand filterOperand = operand.Body as FilterOperand; if (filterOperand == null) { operandResult = ServiceResult.Create( StatusCodes.BadEventFilterInvalid, "The FilterOperand is not a supported type ({0}).", filterOperand.GetType()); result.OperandResults.Add(operandResult); error = true; continue; } // validate the operand. filterOperand.Parent = this; operandResult = filterOperand.Validate(context, index); if (ServiceResult.IsBad(operandResult)) { result.OperandResults.Add(operandResult); error = true; continue; } result.OperandResults.Add(null); } // ensure the global error code. if (error) { result.Status = StatusCodes.BadContentFilterInvalid; } else { result.OperandResults.Clear(); } return(result); }
/// <summary> /// Parses a string representing a numeric range. /// </summary> /// <param name="textToParse">The text to parse, prior to checking it is within the allowed range</param> /// <param name="range">The parsed range.</param> /// <returns>The reason for any error.</returns> public static ServiceResult Validate(string textToParse, out NumericRange range) { range = NumericRange.Empty; if (String.IsNullOrEmpty(textToParse)) { return(ServiceResult.Good); } // check for multidimensional ranges. int index = textToParse.IndexOf(','); if (index >= 0) { int start = 0; List <NumericRange> subranges = new List <NumericRange>(); for (int ii = 0; ii < textToParse.Length; ii++) { char ch = textToParse[ii]; if (ch == ',' || ii == textToParse.Length - 1) { NumericRange subrange = new NumericRange(); string subtext = (ch == ',') ? textToParse.Substring(start, ii - start) : textToParse.Substring(start); ServiceResult result = Validate(subtext, out subrange); if (ServiceResult.IsBad(result)) { return(result); } subranges.Add(subrange); start = ii + 1; } } // must have at least two entries. if (subranges.Count < 2) { return(StatusCodes.BadIndexRangeInvalid); } range.m_begin = subranges[0].Begin; range.m_end = subranges[0].End; range.m_subranges = subranges.ToArray(); return(ServiceResult.Good); } try { index = textToParse.IndexOf(':'); if (index != -1) { range.Begin = Convert.ToInt32(textToParse.Substring(0, index), CultureInfo.InvariantCulture); range.End = Convert.ToInt32(textToParse.Substring(index + 1), CultureInfo.InvariantCulture); if (range.End < 0) { return(ServiceResult.Create( StatusCodes.BadIndexRangeInvalid, "NumericRange does not have a valid end index ({0}).", range.End)); } if (range.Begin >= range.End) { return(ServiceResult.Create( StatusCodes.BadIndexRangeInvalid, "NumericRange does not have a start index that is less than the end index ({0}).", range)); } } else { range.Begin = Convert.ToInt32(textToParse, CultureInfo.InvariantCulture); range.End = -1; } if (range.Begin < 0) { return(ServiceResult.Create( StatusCodes.BadIndexRangeInvalid, "NumericRange does not have a valid start index ({0}).", range.Begin)); } } catch (Exception e) { return(ServiceResult.Create( e, StatusCodes.BadIndexRangeInvalid, "NumericRange cannot be parsed ({0}).", textToParse)); } return(ServiceResult.Good); }
/// <summary> /// Initializes the exception with a message and an exception. /// </summary> public ServiceResultException(Exception e, uint defaultCode) : base(e.Message, e) { m_status = ServiceResult.Create(e, defaultCode, String.Empty); }