コード例 #1
0
		 void IXmlSerializable.ReadXml(XmlReader r)
		{
			r.MoveToContent();
			r.ReadStartElement("Employee");
			
			 r.ReadStartElement("Name");
			 FirstName = r.ReadElementString("First", ns);
			 LastName = r.ReadElementString("Last", ns);
			r.ReadEndElement();
			r.MoveToContent();
			 ID = Int32.Parse(r.ReadElementString("ID", ns));
			 r.ReadEndElement();
			 
		}
コード例 #2
0
ファイル: plist.cs プロジェクト: devorchik/plcopy
    private void _ParseFromReader(XmlReader reader)
    {
        reader.MoveToContent();

        string strToken;
        if (_GetToken(reader, out strToken) && strToken == "plist")
        {
            if (_NextToken(reader))
            {
                _ParseDictionary(reader);
            }
        }
        else
        {
            throw new FormatException("Badly format PLIST -- missing opening element");
        }
    }
コード例 #3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="transaction"></param>
        /// <param name="payment"></param>
        internal static void Read(XmlReader reader, Transaction transaction, bool payment = true)
        {
            if (reader.IsEmptyElement)
            {
                XMLParserUtils.SkipNode(reader);
                return;
            }

            reader.ReadStartElement();
            reader.MoveToContent();

            while (!reader.EOF)
            {
                if (XMLParserUtils.IsEndElement(reader, SerializerHelper.PreApproval))
                {
                    XMLParserUtils.SkipNode(reader);
                    break;
                }

                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case SerializerHelper.Code:
                        transaction.Code = reader.ReadElementContentAsString();
                        break;

                    case SerializerHelper.Date:
                        transaction.Date = reader.ReadElementContentAsDateTime();
                        break;

                    case SerializerHelper.Reference:
                        transaction.Reference = reader.ReadElementContentAsString();
                        break;

                    case SerializerHelper.TransactionType:
                        transaction.TransactionType = reader.ReadElementContentAsInt();
                        break;

                    case SerializerHelper.TransactionStatus:
                        transaction.TransactionStatus = reader.ReadElementContentAsInt();
                        break;

                    case SerializerHelper.PaymentLink:
                        transaction.PaymentLink = reader.ReadElementContentAsString();
                        break;

                    case SerializerHelper.GrossAmount:
                        transaction.GrossAmount = reader.ReadElementContentAsDecimal();
                        break;

                    case SerializerHelper.DiscountAmount:
                        transaction.DiscountAmount = reader.ReadElementContentAsDecimal();
                        break;

                    case SerializerHelper.CreditorFees:
                        CreditorFees creditorFees = new CreditorFees();
                        CreditorFeesSerializer.Read(reader, creditorFees);
                        transaction.CreditorFees = creditorFees;
                        break;

                    case SerializerHelper.FeeAmount:
                        transaction.FeeAmount = reader.ReadElementContentAsDecimal();
                        break;

                    case SerializerHelper.NetAmount:
                        transaction.NetAmount = reader.ReadElementContentAsDecimal();
                        break;

                    case SerializerHelper.ExtraAmount:
                        transaction.ExtraAmount = reader.ReadElementContentAsDecimal();
                        break;

                    case SerializerHelper.LastEventDate:
                        transaction.LastEventDate = reader.ReadElementContentAsDateTime();
                        break;

                    case SerializerHelper.InstallmentCount:
                        transaction.InstallmentCount = reader.ReadElementContentAsInt();
                        break;

                    case PaymentMethodSerializer.PaymentMethod:
                        PaymentMethod paymentMethod = new PaymentMethod();
                        PaymentMethodSerializer.Read(reader, paymentMethod);
                        transaction.PaymentMethod = paymentMethod;
                        break;

                    case ItemListSerializer.Items:
                        ItemListSerializer.Read(reader, transaction.Items);
                        break;

                    case SenderSerializer.Sender:
                        Sender sender = new Sender();
                        SenderSerializer.Read(reader, sender);
                        transaction.Sender = sender;
                        break;

                    case ShippingSerializer.Shipping:
                        Shipping shipping = new Shipping();
                        ShippingSerializer.Read(reader, shipping);
                        transaction.Shipping = shipping;
                        break;

                    default:
                        XMLParserUtils.SkipElement(reader);
                        break;
                    }
                }
                else
                {
                    XMLParserUtils.SkipNode(reader);
                }
            }
        }
コード例 #4
0
        private void AddImage(XmlReader reader, List <RemoteImageInfo> images)
        {
            reader.MoveToContent();

            string bannerType   = null;
            string url          = null;
            int?   bannerSeason = null;
            int?   width        = null;
            int?   height       = null;
            string language     = null;
            double?rating       = null;
            int?   voteCount    = null;
            string thumbnailUrl = null;

            reader.MoveToContent();
            reader.Read();

            // Loop through each element
            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case "Rating":
                    {
                        var val = reader.ReadElementContentAsString() ?? string.Empty;

                        double rval;

                        if (double.TryParse(val, NumberStyles.Any, _usCulture, out rval))
                        {
                            rating = rval;
                        }

                        break;
                    }

                    case "RatingCount":
                    {
                        var val = reader.ReadElementContentAsString() ?? string.Empty;

                        int rval;

                        if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval))
                        {
                            voteCount = rval;
                        }

                        break;
                    }

                    case "Language":
                    {
                        language = reader.ReadElementContentAsString() ?? string.Empty;
                        break;
                    }

                    case "ThumbnailPath":
                    {
                        thumbnailUrl = reader.ReadElementContentAsString() ?? string.Empty;
                        break;
                    }

                    case "BannerType":
                    {
                        bannerType = reader.ReadElementContentAsString() ?? string.Empty;

                        break;
                    }

                    case "BannerPath":
                    {
                        url = reader.ReadElementContentAsString() ?? string.Empty;
                        break;
                    }

                    case "BannerType2":
                    {
                        var bannerType2 = reader.ReadElementContentAsString() ?? string.Empty;

                        // Sometimes the resolution is stuffed in here
                        var resolutionParts = bannerType2.Split('x');

                        if (resolutionParts.Length == 2)
                        {
                            int rval;

                            if (int.TryParse(resolutionParts[0], NumberStyles.Integer, _usCulture, out rval))
                            {
                                width = rval;
                            }

                            if (int.TryParse(resolutionParts[1], NumberStyles.Integer, _usCulture, out rval))
                            {
                                height = rval;
                            }
                        }

                        break;
                    }

                    case "Season":
                    {
                        var val = reader.ReadElementContentAsString();

                        if (!string.IsNullOrWhiteSpace(val))
                        {
                            bannerSeason = int.Parse(val);
                        }
                        break;
                    }


                    default:
                        reader.Skip();
                        break;
                    }
                }
                else
                {
                    reader.Read();
                }
            }

            if (!string.IsNullOrEmpty(url) && !bannerSeason.HasValue)
            {
                var imageInfo = new RemoteImageInfo
                {
                    RatingType      = RatingType.Score,
                    CommunityRating = rating,
                    VoteCount       = voteCount,
                    Url             = TVUtils.BannerUrl + url,
                    ProviderName    = Name,
                    Language        = language,
                    Width           = width,
                    Height          = height
                };

                if (!string.IsNullOrEmpty(thumbnailUrl))
                {
                    imageInfo.ThumbnailUrl = TVUtils.BannerUrl + thumbnailUrl;
                }

                if (string.Equals(bannerType, "poster", StringComparison.OrdinalIgnoreCase))
                {
                    imageInfo.Type = ImageType.Primary;
                    images.Add(imageInfo);
                }
                else if (string.Equals(bannerType, "series", StringComparison.OrdinalIgnoreCase))
                {
                    imageInfo.Type = ImageType.Banner;
                    images.Add(imageInfo);
                }
                else if (string.Equals(bannerType, "fanart", StringComparison.OrdinalIgnoreCase))
                {
                    imageInfo.Type = ImageType.Backdrop;
                    images.Add(imageInfo);
                }
            }
        }
コード例 #5
0
        private bool AnalyzeData(XmlReader xmlRdr)
        {
            xmlRdr.MoveToContent();
            int readinfoChecker = 0;
            int checkend        = 0xFFF;

            while (xmlRdr.Read())
            {
                if (xmlRdr.NodeType == XmlNodeType.Element)
                {
                    if (string.Compare(xmlRdr.Name, ElementHeadInfo.Name, true) == 0)
                    {
                        HeadInfo         = ElementHeadInfo.Create(xmlRdr);
                        readinfoChecker |= 0x1;
                    }
                    else if (string.Compare(xmlRdr.Name, ElementParts.Name, true) == 0)
                    {
                        Parts            = ElementParts.Create(xmlRdr);
                        readinfoChecker |= 0x2;
                    }
                    else if (string.Compare(xmlRdr.Name, ElementPackages.Name, true) == 0)
                    {
                        Packages         = ElementPackages.Create(xmlRdr);
                        readinfoChecker |= 0x4;
                    }
                    else if (string.Compare(xmlRdr.Name, ElementComponents.Name, true) == 0)
                    {
                        Components       = ElementComponents.Create(xmlRdr);
                        readinfoChecker |= 0x8;
                    }
                    else if (string.Compare(xmlRdr.Name, ElementBoardArrays.Name, true) == 0)
                    {
                        BoardArrays      = ElementBoardArrays.Create(xmlRdr);
                        readinfoChecker |= 0x10;
                    }


                    else if (string.Compare(xmlRdr.Name, ElementFootprints.Name, true) == 0)
                    {
                        Footprints       = ElementFootprints.Create(xmlRdr);
                        readinfoChecker |= 0x20;
                    }
                    else if (string.Compare(xmlRdr.Name, ElementPackageBodyShapes.Name, true) == 0)
                    {
                        PackageBodyShapes = ElementPackageBodyShapes.Create(xmlRdr);
                        readinfoChecker  |= 0x40;
                    }
                    else if (string.Compare(xmlRdr.Name, ElementPackageLeadShapes.Name, true) == 0)
                    {
                        PackageLeadShapes = ElementPackageLeadShapes.Create(xmlRdr);
                        readinfoChecker  |= 0x80;
                    }

                    else if (string.Compare(xmlRdr.Name, ElementFootprintLeadShapes.Name, true) == 0)
                    {
                        FootprintLeadShapes = ElementFootprintLeadShapes.Create(xmlRdr);
                        readinfoChecker    |= 0x100;
                    }
                    else if (string.Compare(xmlRdr.Name, ElementBoardFovs.Name, true) == 0)
                    {
                        Boardfovs        = ElementBoardFovs.Create(xmlRdr);
                        readinfoChecker |= 0x200;
                    }
                    else if (string.Compare(xmlRdr.Name, ElementFovs.Name, true) == 0)
                    {
                        Fovs             = ElementFovs.Create(xmlRdr);
                        readinfoChecker |= 0x400;
                    }
                    else if (string.Compare(xmlRdr.Name, ElementBKFovs.Name, true) == 0)
                    {
                        BkFovs           = ElementBKFovs.Create(xmlRdr);
                        readinfoChecker |= 0x800;
                    }


                    else if (!xmlRdr.IsEmptyElement)
                    {
                        xmlRdr.Skip();
                    }

                    if ((readinfoChecker & checkend) == checkend)
                    {
                        break;
                    }
                }
            }

            return(true);
        }
        public void ReadXml(XmlReader reader)
        {
            bool wasEmpty = reader.IsEmptyElement;

            reader.Read();

            if (wasEmpty)
            {
                return;
            }

            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
            {
                reader.ReadStartElement("item");

                //Read key
                reader.ReadStartElement("key");
                reader.ReadStartElement("keyValue");
                FunctionKeys?fk = null;
                if (reader.IsStartElement("functionKey"))
                {
                    reader.ReadStartElement("functionKey");
                    var          functionKeyAsString = reader.ReadString();
                    FunctionKeys localFk;
                    //Remap function keys which have changed names over time
                    if (functionKeyAsString == "AlphaKeyboard")
                    {
                        functionKeyAsString = "Alpha1Keyboard";
                    }
                    else if (functionKeyAsString == "ConversationAlphaKeyboard")
                    {
                        functionKeyAsString = "ConversationAlpha1Keyboard";
                    }
                    if (Enum.TryParse(functionKeyAsString, out localFk))
                    {
                        fk = localFk;
                    }
                    reader.ReadEndElement();
                }
                string s = null;
                if (reader.IsStartElement("str"))
                {
                    reader.ReadStartElement("str");
                    s = reader.ReadString();
                    reader.ReadEndElement();
                }
                reader.ReadEndElement();
                reader.ReadEndElement();
                var key = new KeyValue(fk, s);

                //Read value
                reader.ReadStartElement("value");
                reader.ReadStartElement("ticks");
                var valueAsString = reader.ReadString();
                var value         = string.IsNullOrEmpty(valueAsString) ? TimeSpan.Zero : XmlConvert.ToTimeSpan(valueAsString);
                reader.ReadEndElement();
                reader.ReadEndElement();

                this.Add(key, value);
                reader.ReadEndElement();
                reader.MoveToContent();
            }

            reader.ReadEndElement();
        }
コード例 #7
0
        /// <summary>
        /// Reads XML conforming to https://www.w3.org/TR/2001/PR-xmldsig-core-20010820/#sec-Transforms
        /// </summary>
        /// <param name="reader">a <see cref="XmlReader"/>positioned on a &lt;Transforms> element.</param>
        /// <param name="reference">a <see cref="Reference"/> to attach transforms.</param>
        /// <exception cref="ArgumentNullException">if <paramref name="reader"/> is null.</exception>
        /// <exception cref="ArgumentNullException">if <paramref name="reference"/> is null.</exception>
        /// <exception cref="XmlReadException">if there is a problem reading the XML.</exception>
        public virtual void ReadTransforms(XmlReader reader, Reference reference)
        {
            if (reader == null)
            {
                throw LogArgumentNullException(nameof(reader));
            }

            if (reference == null)
            {
                throw LogArgumentNullException(nameof(reference));
            }

            try
            {
                // <Transforms> - optional
                if (!reader.IsStartElement(XmlSignatureConstants.Elements.Transforms, XmlSignatureConstants.Namespace))
                {
                    return;
                }

                if (reader.IsEmptyElement)
                {
                    reader.Read();
                    return;
                }

                reader.Read();
                // <Transform> - unbounded

                while (reader.IsStartElement(XmlSignatureConstants.Elements.Transform, XmlSignatureConstants.Namespace))
                {
                    var isEmptyElement = reader.IsEmptyElement;
                    var algorithm      = reader.GetAttribute(XmlSignatureConstants.Attributes.Algorithm);
                    if (string.IsNullOrEmpty(algorithm))
                    {
                        throw XmlUtil.LogReadException(LogMessages.IDX30105);
                    }

                    if (TransformFactory.IsSupportedTransform(algorithm))
                    {
                        reference.Transforms.Add(TransformFactory.GetTransform(algorithm));
                        reader.Read();
                    }
                    else if (TransformFactory.IsSupportedCanonicalizingTransfrom(algorithm))
                    {
                        reference.CanonicalizingTransfrom = TransformFactory.GetCanonicalizingTransform(algorithm);
                        reader.Read();
                        // release 5.2.1 did not require 'ec' ns. So, we need to accept names with and without a prefix.
                        if (reader.IsStartElement(XmlSignatureConstants.Elements.InclusiveNamespaces, XmlSignatureConstants.ExclusiveC14nNamespace) || reader.IsStartElement(XmlSignatureConstants.Elements.InclusiveNamespaces))
                        {
                            bool isOnEmptyElement = reader.IsEmptyElement;
                            reference.CanonicalizingTransfrom.InclusiveNamespacesPrefixList = reader.GetAttribute(XmlSignatureConstants.Attributes.PrefixList);
                            reader.ReadStartElement();
                            if (!isOnEmptyElement)
                            {
                                reader.ReadEndElement();
                            }
                        }
                    }
                    else
                    {
                        throw XmlUtil.LogReadException(LogMessages.IDX30210, algorithm);
                    }

                    reader.MoveToContent();
                    if (!isEmptyElement)
                    {
                        reader.ReadEndElement();
                    }
                }

                // </ Transforms>
                reader.MoveToContent();
                reader.ReadEndElement();
            }
            catch (Exception ex)
            {
                if (ex is XmlReadException)
                {
                    throw;
                }

                throw XmlUtil.LogReadException(LogMessages.IDX30016, ex, XmlSignatureConstants.Elements.Transforms);
            }
        }
コード例 #8
0
        public void ReadXml(XmlReader reader)
        {
            AdminId = new HashSet <ulong>();
            bool wasEmpty = reader.IsEmptyElement;

            reader.Read();

            if (wasEmpty)
            {
                return;
            }

            try
            {
                while (reader.MoveToContent() != XmlNodeType.EndElement)
                {
                    var name = reader.Name;
                    // TODO Сделать нормальный парсер (на атрибутах свойств?)
                    switch (name)
                    {
                    case "Token":
                        Token = reader.ReadElementContentAsString();
                        break;

                    case "AnnouncerToken":
                        AnnouncerToken = reader.ReadElementContentAsString();
                        break;

                    case "ImageBaseUrl":
                        ImageBaseUrl = reader.ReadElementContentAsString();
                        break;

                    case "DatabasePath":
                        DatabasePath = reader.ReadElementContentAsString();
                        break;

                    case "GameChannel":
                        GameChannel = ulong.Parse(reader.ReadElementContentAsString());
                        break;

                    case "AdminID":
                        AdminId.Add(ulong.Parse(reader.ReadElementContentAsString()));
                        break;

                    case "Language":
                        LanguageStr = reader.ReadElementContentAsString();
                        break;

                    case "GameType":
                        GameType = reader.ReadElementContentAsString();
                        break;

                    default:
                        reader.Skip();
                        break;
                    }
                }
            }
            finally
            {
                reader.ReadEndElement();
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="transaction"></param>
        internal static void Read(XmlReader reader, TransactionSummary transaction)
        {
            if (reader.IsEmptyElement)
            {
                XMLParserUtils.SkipNode(reader);
                return;
            }

            reader.ReadStartElement(SerializerHelper.Transaction);
            reader.MoveToContent();

            while (!reader.EOF)
            {
                if (XMLParserUtils.IsEndElement(reader, SerializerHelper.Transaction))
                {
                    XMLParserUtils.SkipNode(reader);
                    break;
                }

                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                        case SerializerHelper.Code:
                            transaction.Code = reader.ReadElementContentAsString();
                            break;

                        case SerializerHelper.Date:
                            transaction.Date = reader.ReadElementContentAsDateTime();
                            break;

                        case SerializerHelper.Reference:
                            transaction.Reference = reader.ReadElementContentAsString();
                            break;

                        case SerializerHelper.TransactionType:
                            transaction.TransactionType = reader.ReadElementContentAsInt();
                            break;

                        case SerializerHelper.TransactionStatus:
                            transaction.TransactionStatus = reader.ReadElementContentAsInt();
                            break;

                        case SerializerHelper.PaymentLink:
                            transaction.PaymentLink = reader.ReadElementContentAsString();
                            break;

                        case SerializerHelper.GrossAmount:
                            transaction.GrossAmount = reader.ReadElementContentAsDecimal();
                            break;

                        case SerializerHelper.DiscountAmount:
                            transaction.DiscountAmount = reader.ReadElementContentAsDecimal();
                            break;

                        case SerializerHelper.FeeAmount:
                            transaction.FeeAmount = reader.ReadElementContentAsDecimal();
                            break;

                        case SerializerHelper.NetAmount:
                            transaction.NetAmount = reader.ReadElementContentAsDecimal();
                            break;

                        case SerializerHelper.ExtraAmount:
                            transaction.ExtraAmount = reader.ReadElementContentAsDecimal();
                            break;

                        case SerializerHelper.LastEventDate:
                            transaction.LastEventDate = reader.ReadElementContentAsDateTime();
                            break;

                        case PaymentMethodSerializer.PaymentMethod:
                            PaymentMethod paymentMethod = new PaymentMethod();
                            PaymentMethodSerializer.Read(reader, paymentMethod);
                            transaction.PaymentMethod = paymentMethod;
                            break;

                        default:
                            XMLParserUtils.SkipElement(reader);
                            break;
                    }
                }
                else
                {
                    XMLParserUtils.SkipNode(reader);
                }
            }
        }
コード例 #10
0
ファイル: Param.cs プロジェクト: Aboutdept/CryBlendSpace
        public void ReadXml(XmlReader reader)
        {
            reader.MoveToContent();

            //read all attributes
            Name = reader.GetAttribute("name");

            #region Min

            Min = Single.Parse(reader.GetAttribute("min").TrimStart('+'));

            #endregion

            #region Max

            Max = Single.Parse(reader.GetAttribute("max").TrimStart('+'));

            #endregion

            #region Cells

            Cells = UInt16.Parse(reader.GetAttribute("cells"));

            #endregion

            #region Scale

            if (!String.IsNullOrWhiteSpace(reader.GetAttribute("ParaScale")))
            {
                Scale = Single.Parse(reader.GetAttribute("ParaScale"));
            }

            #endregion

            #region JointName

            if (!String.IsNullOrWhiteSpace(reader.GetAttribute("JointName")))
            {
                JointName = reader.GetAttribute("JointName");
            }

            #endregion

            #region SKey

            if (!String.IsNullOrWhiteSpace(reader.GetAttribute("skey")))
            {
                SKey = Single.Parse(reader.GetAttribute("skey"));
            }

            #endregion

            #region EKey

            if (!String.IsNullOrWhiteSpace(reader.GetAttribute("ekey")))
            {
                EKey = Single.Parse(reader.GetAttribute("ekey"));
            }

            #endregion

            #region Locked

            if (!String.IsNullOrWhiteSpace(reader.GetAttribute("locked")))
            {
                Locked = reader.GetAttribute("locked") == "1" ? true : false;
            }

            #endregion

            #region DeltaExtraction

            if (!String.IsNullOrWhiteSpace(reader.GetAttribute("deltaextraction")))
            {
                DeltaExtraction = reader.GetAttribute("deltaextraction") == "1" ? true : false;
            }

            #endregion

            #region ChooseBlendSpace

            if (!String.IsNullOrWhiteSpace(reader.GetAttribute("ChooseBlendSpace")))
            {
                ChooseBlendSpace = reader.GetAttribute("ChooseBlendSpace") == "1" ? true : false;
            }

            #endregion
        }
コード例 #11
0
ファイル: Validation.cs プロジェクト: xbnr/x3-ws-tester
        public void Validate()
        {
            logger.Log($"Launch {XmlFile} validation ... ");
            XmlReaderSettings settings = new XmlReaderSettings
            {
                //Message:Impossible de résoudre l'attribut 'schemaLocation'.
                //Error while XML validation: Pour des raisons de sécurité, DTD interdite dans ce document XML. Pour activer le traitement DTD, définissez sur Parse la propriété DtdProcessing sur XmlReaderSettings et transmettez les paramètres à la méthode XmlReader.Create. * ***
                DtdProcessing             = DtdProcessing.Parse,
                MaxCharactersFromEntities = 1024,
                ValidationType            = ValidationType.Schema
            };

            try
            {
                settings.ValidationFlags |= XmlSchemaValidationFlags.ProcessInlineSchema;
                settings.ValidationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes;
                // settings.ValidationFlags |= XmlSchemaValidationFlags.ProcessIdentityConstraints;
                // settings.ValidationFlags |= XmlSchemaValidationFlags.ProcessSchemaLocation;
                if (ShowWarnings)
                {
                    settings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings;
                }

                foreach (var xsd_file in XsdFiles)
                {
                    if (File.Exists(xsd_file))
                    {
                        settings.Schemas.Add(null, new XmlTextReader(xsd_file));
                    }
                    else
                    {
                        logger.Log($"{xsd_file} doesn't exist");
                    }
                }
                settings.Schemas.Compile();
                settings.ValidationEventHandler += new ValidationEventHandler(ValidationHandler);
                using (XmlTextReader xmltextReader = new XmlTextReader(this.XmlFile)
                {
                    DtdProcessing = DtdProcessing.Parse
                })
                {
                    using (XmlReader reader = XmlReader.Create(xmltextReader, settings))
                    {
                        reader.MoveToContent();
                        while (reader.Read())
                        {
                        }
                    }
                }
                logger.Log($"{XmlFile} Validation finished successfully");
            }
            catch (Exception e)
            {
                logger.Log($"Error while XML validation: {e.Message}", true);
                logger.Log($"{XmlFile} Validation FAILED");
            }
            finally
            {
                ArrayList a = new ArrayList();
                foreach (var item in settings.Schemas.Schemas())
                {
                    XmlSchema xmlSchema = item as XmlSchema;
                    if (xmlSchema != null)
                    {
                        a.Add(xmlSchema);
                    }
                }
                for (int i = 0; i < a.Count; i++)
                {
                    settings.Schemas.Remove(a[i] as XmlSchema);
                }

                settings.Schemas    = null;
                settings.CloseInput = true;
            }
        }
コード例 #12
0
ファイル: ConfigurationElement.cs プロジェクト: yonder/mono
        protected internal virtual void DeserializeElement(XmlReader reader, bool serializeCollectionKey)
        {
            Hashtable readProps = new Hashtable();

            reader.MoveToContent();
            while (reader.MoveToNextAttribute())
            {
                PropertyInformation prop = ElementInformation.Properties [reader.LocalName];
                if (prop == null || (serializeCollectionKey && !prop.IsKey))
                {
                    /* handle the built in ConfigurationElement attributes here */
                    if (reader.LocalName == "lockAllAttributesExcept")
                    {
                        LockAllAttributesExcept.SetFromList(reader.Value);
                    }
                    else if (reader.LocalName == "lockAllElementsExcept")
                    {
                        LockAllElementsExcept.SetFromList(reader.Value);
                    }
                    else if (reader.LocalName == "lockAttributes")
                    {
                        LockAttributes.SetFromList(reader.Value);
                    }
                    else if (reader.LocalName == "lockElements")
                    {
                        LockElements.SetFromList(reader.Value);
                    }
                    else if (reader.LocalName == "lockItem")
                    {
                        LockItem = (reader.Value.ToLowerInvariant() == "true");
                    }
                    else if (reader.LocalName == "xmlns")
                    {
                        /* ignore */
                    }
                    else if (this is ConfigurationSection && reader.LocalName == "configSource")
                    {
                        /* ignore */
                    }
                    else if (!OnDeserializeUnrecognizedAttribute(reader.LocalName, reader.Value))
                    {
                        throw new ConfigurationErrorsException("Unrecognized attribute '" + reader.LocalName + "'.", reader);
                    }

                    continue;
                }

                if (readProps.ContainsKey(prop))
                {
                    throw new ConfigurationErrorsException("The attribute '" + prop.Name + "' may only appear once in this element.", reader);
                }

                string value = null;
                try {
                    value = reader.Value;
                    ValidateValue(prop.Property, value);
                    prop.SetStringValue(value);
                } catch (ConfigurationErrorsException) {
                    throw;
                } catch (ConfigurationException) {
                    throw;
                } catch (Exception ex) {
                    string msg = String.Format("The value for the property '{0}' is not valid. The error is: {1}", prop.Name, ex.Message);
                    throw new ConfigurationErrorsException(msg, reader);
                }
                readProps [prop] = prop.Name;
            }

            reader.MoveToElement();
            if (reader.IsEmptyElement)
            {
                reader.Skip();
            }
            else
            {
                int depth = reader.Depth;

                reader.ReadStartElement();
                reader.MoveToContent();

                do
                {
                    if (reader.NodeType != XmlNodeType.Element)
                    {
                        reader.Skip();
                        continue;
                    }

                    PropertyInformation prop = ElementInformation.Properties [reader.LocalName];
                    if (prop == null || (serializeCollectionKey && !prop.IsKey))
                    {
                        if (!OnDeserializeUnrecognizedElement(reader.LocalName, reader))
                        {
                            if (prop == null)
                            {
                                ConfigurationElementCollection c = GetDefaultCollection();
                                if (c != null && c.OnDeserializeUnrecognizedElement(reader.LocalName, reader))
                                {
                                    continue;
                                }
                            }
                            throw new ConfigurationErrorsException("Unrecognized element '" + reader.LocalName + "'.", reader);
                        }
                        continue;
                    }

                    if (!prop.IsElement)
                    {
                        throw new ConfigurationException("Property '" + prop.Name + "' is not a ConfigurationElement.");
                    }

                    if (readProps.Contains(prop))
                    {
                        throw new ConfigurationErrorsException("The element <" + prop.Name + "> may only appear once in this section.", reader);
                    }

                    ConfigurationElement val = (ConfigurationElement)prop.Value;
                    val.DeserializeElement(reader, serializeCollectionKey);
                    readProps [prop] = prop.Name;

                    if (depth == reader.Depth)
                    {
                        reader.Read();
                    }
                } while (depth < reader.Depth);
            }

            modified = false;

            foreach (PropertyInformation prop in ElementInformation.Properties)
            {
                if (!String.IsNullOrEmpty(prop.Name) && prop.IsRequired && !readProps.ContainsKey(prop))
                {
                    PropertyInformation p = ElementInformation.Properties [prop.Name];
                    if (p == null)
                    {
                        object val = OnRequiredPropertyNotFound(prop.Name);
                        if (!object.Equals(val, prop.DefaultValue))
                        {
                            prop.Value      = val;
                            prop.IsModified = false;
                        }
                    }
                }
            }

            PostDeserialize();
        }
コード例 #13
0
ファイル: DrawingTool.cs プロジェクト: jfpk/kinoveaIDS
        private static DrawingTool ParseTool(XmlReader r)
        {
            r.MoveToContent();
            r.ReadStartElement();

            string version = r.ReadElementContentAsString("FormatVersion", "");

            if (version != "1.0")
            {
                log.ErrorFormat("Unsupported format version ({0}) for tool description.", version);
                return(null);
            }

            Guid         id          = Guid.Empty;
            string       name        = "";
            string       displayName = "";
            Bitmap       icon        = null;
            Type         drawingType = null;
            bool         attached    = true;
            bool         keepToolAfterDrawingCreation = false;
            bool         keepToolAfterFrameChange     = false;
            DrawingStyle style = null;

            while (r.NodeType == XmlNodeType.Element)
            {
                switch (r.Name)
                {
                case "Id":
                    id = new Guid(r.ReadElementContentAsString());
                    break;

                case "Name":
                    name = r.ReadElementContentAsString();
                    break;

                case "DisplayName":
                    displayName = r.ReadElementContentAsString();
                    break;

                case "Icon":
                    string iconReference = r.ReadElementContentAsString();
                    if (!string.IsNullOrEmpty(iconReference))
                    {
                        icon = Properties.Drawings.ResourceManager.GetObject(iconReference) as Bitmap;
                    }
                    break;

                case "DrawingClass":
                    string drawingClass = r.ReadElementContentAsString();
                    drawingType = FindType(drawingClass);
                    break;

                case "Attached":
                    attached = XmlHelper.ParseBoolean(r.ReadElementContentAsString());
                    break;

                case "KeepToolAfterDrawingCreation":
                    keepToolAfterDrawingCreation = XmlHelper.ParseBoolean(r.ReadElementContentAsString());
                    break;

                case "KeepToolAfterFrameChange":
                    keepToolAfterFrameChange = XmlHelper.ParseBoolean(r.ReadElementContentAsString());
                    break;

                case "DefaultStyle":
                    style = new DrawingStyle(r);
                    break;

                default:
                    string unparsed = r.ReadOuterXml();
                    log.DebugFormat("Unparsed content in Drawing Tool XML: {0}", unparsed);
                    break;
                }
            }

            r.ReadEndElement();

            if (icon == null)
            {
                icon = Properties.Drawings.generic_posture;
            }

            DrawingTool tool = new DrawingTool(id, name, displayName, icon, drawingType, attached, keepToolAfterDrawingCreation, keepToolAfterFrameChange, style);

            return(tool);
        }
コード例 #14
0
        private void Process()
        {
            bool savedEnforceConstraints =
                dataset.EnforceConstraints;

            try
            {
                dataset.EnforceConstraints = false;
                reader.MoveToContent();

                if (mode == XmlReadMode.Fragment)
                {
                    while (reader.NodeType == XmlNodeType.Element && !reader.EOF)
                    {
                        ReadTopLevelElement();
                    }
                }
                else
                {
                    ReadTopLevelElement();
                }
            }
            finally
            {
                dataset.EnforceConstraints =
                    savedEnforceConstraints;
            }
        }
コード例 #15
0
        void VerifyInput(MessageBuffer buf)
        {
            Message input = buf.CreateMessage();

/*
 * XmlWriterSettings settings = new XmlWriterSettings ();
 * settings.Indent = true;
 * using (XmlWriter w = XmlWriter.Create (Console.Error, settings)) {
 * buf.CreateMessage ().WriteMessage (w);
 * }
 * Console.Error.WriteLine ("******************** DONE ********************");
 * Console.Error.Flush ();
 */

            Assert.AreEqual("http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue", input.Headers.Action, "GetToken.Request.Action");
            Assert.IsNotNull(input.Headers.MessageId, "GetToken.Request.MessageID");
            // in the raw Message it is "http://www.w3.org/2005/08/addressing/anonymous", but it is replaced by MessageHeaders implementation.
            Assert.AreEqual(new EndpointAddress("http://schemas.microsoft.com/2005/12/ServiceModel/Addressing/Anonymous"), input.Headers.ReplyTo, "GetToken.Request.ReplyTo");

            // o:Security
            // FIXME: test WSSecurity more
            // <o:Security>
            //  <u:Timestamp>
            //   <u:Created>...</u:Created>
            //   <u:Expires>...</u:Expires>
            //  </u:Timestamp>
            //  <o:BinarySecurityToken>...</o:BinarySecurityToken>
            //  <e:EncryptedKey>
            //   <e:EncryptionMethod><DigestMethod/></e:EncryptionMethod>
            //   <KeyInfo>
            //    <o:SecurityTokenReference><o:Reference/></o:SecurityTokenReference>
            //   </KeyInfo>
            //   <e:CipherData>
            //    <e:CipherValue>...</e:CipherValue>
            //   </e:CipherData>
            //  </e:EncryptedKey>
            //  [
            //  <c:DerivedKeyToken>
            //   <o:SecurityTokenReference><o:Reference/></o:SecurityTokenReference>
            //   <c:Offset>...</c:Offset>
            //   <c:Length>...</c:Length>
            //   <c:Nonce>...</c:Nonce>
            //  </c:DerivedKeyToken>
            //  ]
            //  <e:ReferenceList>
            //   [
            //   <e:DataReference>
            //   ]
            //  </e:ReferenceList>
            //  <e:EncryptedData>
            //   <e:EncryptionMethod/>
            //   <KeyInfo> {{....}} </KeyInfo>
            //   <e:CipherData> {{....}} </e:CipherData>
            //  </e:EncryptedData>
            // </o:Security>
            int i = input.Headers.FindHeader("Security", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");

            Assert.IsTrue(i >= 0, "Security header existence");
            MessageHeaderInfo info = input.Headers [i];

            Assert.IsNotNull(info, "Security header item");
            XmlReader r = input.Headers.GetReaderAtHeader(i);

            // FIXME: test WSSecurity more
            // <o:Security>
            r.MoveToContent();
            r.ReadStartElement("Security", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
            //  <u:Timestamp>
            r.MoveToContent();
            r.ReadStartElement("Timestamp", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
            //   <u:Created>...</u:Created>
            r.MoveToContent();
            r.ReadStartElement("Created", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
            r.ReadString();
            r.MoveToContent();
            r.ReadEndElement();
            //   <u:Expires>...</u:Expires>
            r.MoveToContent();
            r.ReadStartElement("Expires", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
            r.ReadString();
            r.MoveToContent();
            r.ReadEndElement();
            //  </u:Timestamp>
            r.MoveToContent();
            r.ReadEndElement();
            //  <o:BinarySecurityToken>...</o:BinarySecurityToken>
            r.MoveToContent();
            r.ReadStartElement("BinarySecurityToken", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
            byte [] rawcert = Convert.FromBase64String(r.ReadString());
            r.ReadEndElement();
            X509Certificate2 cert = new X509Certificate2(rawcert);

            // FIXME: test EncryptedKey
            r.MoveToContent();
            r.Skip();
            //  <e:EncryptedKey>
            //   <e:EncryptionMethod><DigestMethod/></e:EncryptionMethod>
            //   <KeyInfo>
            //    <o:SecurityTokenReference><o:Reference/></o:SecurityTokenReference>
            //   </KeyInfo>
            //   <e:CipherData>
            //    <e:CipherValue>...</e:CipherValue>
            //   </e:CipherData>
            //  </e:EncryptedKey>

            // FIXME: test DerivedKeyTokens
            r.MoveToContent();
            while (r.LocalName == "DerivedKeyToken")
            {
                r.Skip();
                r.MoveToContent();
            }
            //  [
            //  <c:DerivedKeyToken>
            //   <o:SecurityTokenReference><o:Reference/></o:SecurityTokenReference>
            //   <c:Offset>...</c:Offset>
            //   <c:Length>...</c:Length>
            //   <c:Nonce>...</c:Nonce>
            //  </c:DerivedKeyToken>
            //  ]

            //  <e:ReferenceList>
            //   [
            //   <e:DataReference>
            //   ]
            //  </e:ReferenceList>
            //  <e:EncryptedData>
            //   <e:EncryptionMethod/>
            //   <KeyInfo> {{....}} </KeyInfo>
            //   <e:CipherData> {{....}} </e:CipherData>
            //  </e:EncryptedData>
            // </o:Security>

            // SOAP Body
            r = input.GetReaderAtBodyContents();              // just verifying itself ;)
        }
コード例 #16
0
        public static void ReadObjectProperties(XmlReader reader, object obj, PropertyConversionHandler handler = null)
        {
            // Build property lookup table
            PropertyInfo[] props = obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
            Dictionary<string, PropertyInfo> propHash = new Dictionary<string, PropertyInfo>(props.Length);
            foreach (var pi in props)
                if (!Attribute.IsDefined(pi, typeof(XmlIgnoreAttribute), false))
                    propHash.Add(GetPropertyElementName(pi), pi);

            while (reader.MoveToContent() == System.Xml.XmlNodeType.Element)
            {
                PropertyInfo pi;
                if (propHash.TryGetValue(reader.LocalName, out pi))
                {
                    if (IsStandardType(pi.PropertyType))
                    {
                        object value = null;
                        if (pi.PropertyType.IsEnum)
                            value = Enum.Parse(pi.PropertyType, reader.ReadElementContentAsString());
                        else
                            value = reader.ReadElementContentAs(pi.PropertyType, null);

                        if (handler != null)
                            handler(pi, obj, ref value);

                        pi.SetValue(obj, value, null);
                    }
                    else
                    {
                        ReadObject(reader, pi.GetValue(obj, null));
                    }
                }
                else
                {
                    reader.Skip();
                    reader.MoveToContent();
                }
            }
        }
コード例 #17
0
 public override Task <XmlNodeType> MoveToContentAsync() => Task.FromResult(_reader.MoveToContent());
コード例 #18
0
        public void ReadXml(XmlReader reader)
        {
            bool wasEmpty = reader.IsEmptyElement;

            reader.Read();

            if (wasEmpty)
            {
                return;
            }

            try
            {
                while (reader.MoveToContent() != XmlNodeType.EndElement)
                {
                    var name = reader.Name;
                    // TODO Сделать нормальный парсер (на атрибутах свойств?)
                    switch (name)
                    {
                    case "MuteOnDeath":
                        MuteOnDeath = bool.Parse(reader.ReadElementContentAsString());
                        break;

                    case "StartFromNight":
                        StartFromNight = bool.Parse(reader.ReadElementContentAsString());
                        break;

                    case "ShowNightActions":
                        ShowNightActions = bool.Parse(reader.ReadElementContentAsString());
                        break;

                    case "IsMafiaEnabled":
                        IsMafiaEnabled = bool.Parse(reader.ReadElementContentAsString());
                        break;

                    case "IsYakuzaEnabled":
                        IsYakuzaEnabled = bool.Parse(reader.ReadElementContentAsString());
                        break;

                    case "MafPercent":
                        MafPercent = short.Parse(reader.ReadElementContentAsString());
                        break;

                    case "MinPlayers":
                        MinPlayers = int.Parse(reader.ReadElementContentAsString());
                        break;

                    case "PlayerCollectingTime":
                        PlayerCollectingTime = int.Parse(reader.ReadElementContentAsString());
                        break;

                    case "PauseTime":
                        PauseTime = int.Parse(reader.ReadElementContentAsString());
                        break;

                    case "MorningTime":
                        MorningTime = int.Parse(reader.ReadElementContentAsString());
                        break;

                    case "DayTime":
                        DayTime = int.Parse(reader.ReadElementContentAsString());
                        break;

                    case "EveningTime":
                        EveningTime = int.Parse(reader.ReadElementContentAsString());
                        break;

                    case "NightTime":
                        NightTime = int.Parse(reader.ReadElementContentAsString());
                        break;

                    case "MinNotificationInterval":
                        MinNotificationInterval = int.Parse(reader.ReadElementContentAsString());
                        break;

                    case "MaxUsersToNotify":
                        MaxUsersToNotify = byte.Parse(reader.ReadElementContentAsString());
                        break;

                    case "MaxInactiveDays":
                        MaxInactiveDays = int.Parse(reader.ReadElementContentAsString());
                        break;

                    case "InfectionChancePercent":
                        InfectionChancePercent = short.Parse(reader.ReadElementContentAsString());
                        break;

                    case "Nickname":
                        Nickname = reader.ReadElementContentAsString();
                        break;

                    case "AvatarPath":
                        AvatarPath = reader.ReadElementContentAsString();
                        break;

                    default:
                        reader.Skip();
                        break;
                    }
                }
            }
            finally
            {
                reader.ReadEndElement();
            }
        }
コード例 #19
0
        /// <summary>
        /// Reads XML conforming to https://www.w3.org/TR/2001/PR-xmldsig-core-20010820/#sec-Reference
        /// </summary>
        /// <param name="reader">a <see cref="XmlReader"/>positioned on a &lt;Reference> element.</param>
        /// <exception cref="ArgumentNullException">if <paramref name="reader"/> is null.</exception>
        /// <exception cref="XmlReadException">if there is a problem reading the XML.</exception>
        /// <returns><see cref="Reference"/></returns>
        public virtual Reference ReadReference(XmlReader reader)
        {
            XmlUtil.CheckReaderOnEntry(reader, XmlSignatureConstants.Elements.Reference, XmlSignatureConstants.Namespace);

            try
            {
                var reference = new Reference
                {
                    Prefix = reader.Prefix,
                    Id     = reader.GetAttribute(XmlSignatureConstants.Attributes.Id, null),
                    Type   = reader.GetAttribute(XmlSignatureConstants.Attributes.Type, null),
                    Uri    = reader.GetAttribute(XmlSignatureConstants.Attributes.URI, null)
                };

                reader.Read();
                ReadTransforms(reader, reference);

                // <DigestMethod> - required
                XmlUtil.CheckReaderOnEntry(reader, XmlSignatureConstants.Elements.DigestMethod, XmlSignatureConstants.Namespace);
                bool isEmptyElement = reader.IsEmptyElement;
                var  digestMethod   = reader.GetAttribute(XmlSignatureConstants.Attributes.Algorithm, null);
                if (string.IsNullOrEmpty(digestMethod))
                {
                    throw XmlUtil.OnRequiredAttributeMissing(XmlSignatureConstants.Elements.DigestMethod, XmlSignatureConstants.Attributes.Algorithm);
                }

                reference.DigestMethod = digestMethod;

                reader.Read();
                reader.MoveToContent();
                if (!isEmptyElement)
                {
                    reader.ReadEndElement();
                }

                // <DigestValue>
                XmlUtil.CheckReaderOnEntry(reader, XmlSignatureConstants.Elements.DigestValue, XmlSignatureConstants.Namespace);
                var digestValue = reader.ReadElementContentAsString().Trim();
                if (string.IsNullOrEmpty(digestValue))
                {
                    throw XmlUtil.LogReadException(LogMessages.IDX30206, reference.Uri ?? reference.Id);
                }

                reference.DigestValue = digestValue;

                // </Reference>
                reader.MoveToContent();
                reader.ReadEndElement();

                return(reference);
            }
            catch (Exception ex)
            {
                if (ex is XmlReadException)
                {
                    throw;
                }

                throw XmlUtil.LogReadException(LogMessages.IDX30016, ex, XmlSignatureConstants.Elements.Reference);
            }
        }
        internal static void Read(XmlReader reader, Transaction transaction)
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }
            if (transaction == null)
            {
                throw new ArgumentNullException("transaction");
            }

            if (reader.IsEmptyElement)
            {
                SerializationHelper.SkipNode(reader);
                return;
            }

            reader.ReadStartElement(TransactionSerializerHelper.Transaction);
            reader.MoveToContent();

            while (!reader.EOF)
            {
                if (SerializationHelper.IsEndElement(reader, TransactionSerializerHelper.Transaction))
                {
                    SerializationHelper.SkipNode(reader);
                    break;
                }

                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case TransactionSerializerHelper.Code:
                        transaction.Code = reader.ReadElementContentAsString();
                        break;

                    case TransactionSerializerHelper.Date:
                        transaction.Date = reader.ReadElementContentAsDateTime();
                        break;

                    case TransactionSerializerHelper.Reference:
                        transaction.Reference = reader.ReadElementContentAsString();
                        break;

                    case TransactionSerializerHelper.TransactionType:
                        transaction.TransactionType = reader.ReadElementContentAsInt();
                        break;

                    case TransactionSerializerHelper.TransactionStatus:
                        transaction.TransactionStatus = reader.ReadElementContentAsInt();
                        break;

                    case TransactionSerializerHelper.GrossAmount:
                        transaction.GrossAmount = reader.ReadElementContentAsDecimal();
                        break;

                    case TransactionSerializerHelper.DiscountAmount:
                        transaction.DiscountAmount = reader.ReadElementContentAsDecimal();
                        break;

                    case TransactionSerializerHelper.FeeAmount:
                        transaction.FeeAmount = reader.ReadElementContentAsDecimal();
                        break;

                    case TransactionSerializerHelper.NetAmount:
                        transaction.NetAmount = reader.ReadElementContentAsDecimal();
                        break;

                    case TransactionSerializerHelper.ExtraAmount:
                        transaction.ExtraAmount = reader.ReadElementContentAsDecimal();
                        break;

                    case TransactionSerializerHelper.LastEventDate:
                        transaction.LastEventDate = reader.ReadElementContentAsDateTime();
                        break;

                    case TransactionSerializerHelper.InstallmentCount:
                        transaction.InstallmentCount = reader.ReadElementContentAsInt();
                        break;

                    case PaymentMethodSerializer.PaymentMethod:
                        PaymentMethod paymentMethod = new PaymentMethod();
                        PaymentMethodSerializer.Read(reader, paymentMethod);
                        transaction.PaymentMethod = paymentMethod;
                        break;

                    case ItemListSerializer.Items:
                        ItemListSerializer.Read(reader, transaction.Items);
                        break;

                    case SenderSerializer.Sender:
                        Sender sender = new Sender();
                        SenderSerializer.Read(reader, sender);
                        transaction.Sender = sender;
                        break;

                    case ShippingSerializer.Shipping:
                        Shipping shipping = new Shipping();
                        ShippingSerializer.Read(reader, shipping);
                        transaction.Shipping = shipping;
                        break;

                    default:
                        SerializationHelper.SkipElement(reader);
                        break;
                    }
                }
                else
                {
                    SerializationHelper.SkipNode(reader);
                }
            }
        }
コード例 #21
0
        /// <summary>
        /// ストリームからデータを復元します
        /// </summary>
        /// <param name="reader"></param>
        /// <returns></returns>
        public static SequenceData Deserialize(XmlReader reader)
        {
            SequenceData ret = null;

            reader.ReadStartElement(typeof(SequenceData).Name);
            byte[]          titleBytes = null, sequenceBytes = null;
            LabelingBorders border     = null;
            string          tmp;
            MemoryStream    tmpStream;
            StreamWriter    tmpWriter;

            for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None; reader.MoveToContent())
            {
                if (reader.IsEmptyElement)
                {
                    reader.Skip();
                    continue;
                }
                switch (reader.Name)
                {
                case "Title":
                    tmp       = reader.ReadElementContentAsString();
                    tmpStream = new MemoryStream();
                    tmpWriter = new StreamWriter(tmpStream);
                    tmpWriter.Write(tmp);
                    tmpWriter.Flush();
                    titleBytes = tmpStream.ToArray();
                    break;

                case "Sequence":
                    tmp       = reader.ReadElementContentAsString();
                    tmpStream = new MemoryStream();
                    tmpWriter = new StreamWriter(tmpStream);
                    tmpWriter.Write(tmp);
                    tmpWriter.Flush();
                    sequenceBytes = tmpStream.ToArray();
                    break;

                case "Border":
                    reader.ReadStartElement();
                    border = LabelingBorders.Deserialize(reader.ReadSubtree());
                    for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None; reader.MoveToContent())
                    {
                        reader.Skip();
                    }
                    reader.ReadEndElement();
                    break;

                default:
                    reader.Skip();
                    break;
                }
            }
            reader.ReadEndElement();
            if (titleBytes != null && sequenceBytes != null && border != null)
            {
                ret         = new SequenceData();
                ret.Borders = border;
                using (MemoryStream stream2 = new MemoryStream(sequenceBytes)) {
                    ret.Values = TimeSeriesValues.Deserialize(stream2);
                }
                using (MemoryStream stream2 = new MemoryStream(titleBytes)) {
                    ret.RetrieveDataHeader(stream2);
                }
            }
            return(ret);
        }
コード例 #22
0
        public SilverlightClientConfiguration Load(XmlReader reader)
        {
            var ret = new SilverlightClientConfiguration();

            ret.Bindings = new BindingsConfiguration();
            ret.Client   = new ClientConfiguration();

            reader.MoveToContent();
            if (reader.IsEmptyElement)
            {
                return(ret);
            }
            reader.ReadStartElement("configuration");

            for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
            {
                if (reader.NodeType != XmlNodeType.Element ||
                    reader.LocalName != "system.serviceModel" ||
                    reader.IsEmptyElement)
                {
                    reader.Skip();
                    continue;
                }
                // in <system.serviceModel>
                reader.ReadStartElement();
                for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
                {
                    if (reader.NodeType != XmlNodeType.Element ||
                        reader.IsEmptyElement)
                    {
                        reader.Skip();
                        continue;
                    }
                    switch (reader.LocalName)
                    {
                    case "bindings":
                        reader.ReadStartElement();
                        for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
                        {
                            if (reader.NodeType != XmlNodeType.Element ||
                                reader.IsEmptyElement)
                            {
                                reader.Skip();
                                continue;
                            }
                            switch (reader.LocalName)
                            {
                            case "customBinding":
                                reader.ReadStartElement();
                                for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
                                {
                                    if (reader.NodeType != XmlNodeType.Element ||
                                        reader.LocalName != "binding")
                                    {
                                        reader.Skip();
                                        continue;
                                    }
                                    ret.Bindings.CustomBinding.Add(ReadCustomBinding(reader));
                                }
                                reader.ReadEndElement();
                                break;

                            case "basicHttpBinding":
                                reader.ReadStartElement();
                                for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
                                {
                                    if (reader.NodeType != XmlNodeType.Element ||
                                        reader.LocalName != "binding")
                                    {
                                        reader.Skip();
                                        continue;
                                    }
                                    ret.Bindings.BasicHttpBinding.Add(ReadBasicHttpBinding(reader));
                                }
                                reader.ReadEndElement();
                                break;
                            }
                        }
                        reader.ReadEndElement();
                        break;

                    case "client":
                        reader.ReadStartElement();
                        for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent())
                        {
                            if (reader.NodeType != XmlNodeType.Element ||
                                reader.LocalName != "endpoint")
                            {
                                reader.Skip();
                                continue;
                            }
                            ret.Client.Endpoints.Add(ReadEndpoint(reader));
                        }
                        reader.ReadEndElement();
                        break;
                    }
                }
                reader.ReadEndElement();
                // out <system.serviceModel>
            }
            reader.ReadEndElement();
            // out <configuration>

            return(ret);
        }
コード例 #23
0
        // Token: 0x0600256B RID: 9579 RVA: 0x00087AA4 File Offset: 0x00085CA4
        protected override void LoadSymbolsMapFromFile(string filePath, Dictionary <string, List <ScriptSharpSymbolWrapper> > symbolMaps, Dictionary <uint, string> sourceFileIdMap, ClientWatsonFunctionNamePool functionNamePool)
        {
            Dictionary <string, int> dictionary = new Dictionary <string, int>();
            Dictionary <int, List <ScriptSharpSymbolWrapper> >         dictionary2 = new Dictionary <int, List <ScriptSharpSymbolWrapper> >();
            Stack <ScriptSharpSourceMapLoader.ContainingMethodContext> stack       = new Stack <ScriptSharpSourceMapLoader.ContainingMethodContext>();
            Stack <ScriptSharpSourceMapLoader.ParentContext>           stack2      = new Stack <ScriptSharpSourceMapLoader.ParentContext>();
            string arg   = null;
            string arg2  = null;
            int    num   = -1;
            int    key   = -1;
            int    count = sourceFileIdMap.Count;

            using (XmlReader xmlReader = XmlReader.Create(filePath))
            {
                while (xmlReader.Read())
                {
                    XmlNodeType xmlNodeType = xmlReader.MoveToContent();
                    if (xmlNodeType == XmlNodeType.Element)
                    {
                        if (xmlReader.Name == "Statement")
                        {
                            ScriptSharpSourceMapLoader.ContainingMethodContext containingMethodContext = stack.Peek();
                            ScriptSharpSymbol scriptSharpSymbol;
                            if (ScriptSharpSourceMapLoader.TryParseSymbol(xmlReader, containingMethodContext.ScriptOffset, containingMethodContext.FunctionNameIndex, num, out scriptSharpSymbol))
                            {
                                ScriptSharpSourceMapLoader.PopNonParentSymbolsOut(stack2, scriptSharpSymbol, dictionary2[key]);
                                stack2.Push(new ScriptSharpSourceMapLoader.ParentContext(scriptSharpSymbol));
                            }
                        }
                        else if (xmlReader.Name == "Method")
                        {
                            string attribute = xmlReader.GetAttribute("SourceFile");
                            if (string.IsNullOrEmpty(attribute))
                            {
                                ScriptSharpSourceMapLoader.SkipSubTree(xmlReader, "Method");
                            }
                            else
                            {
                                if (!dictionary.TryGetValue(attribute, out num))
                                {
                                    num = dictionary.Count + count;
                                    dictionary.Add(attribute, num);
                                }
                                arg2 = xmlReader.GetAttribute("Name");
                                string            name = string.Format("{0}.{1}", arg, arg2);
                                int               orAddFunctionNameIndex = functionNamePool.GetOrAddFunctionNameIndex(name);
                                ScriptSharpSymbol symbol;
                                if (!ScriptSharpSourceMapLoader.TryParseSymbol(xmlReader, 0, orAddFunctionNameIndex, num, out symbol))
                                {
                                    ScriptSharpSourceMapLoader.SkipSubTree(xmlReader, "Method");
                                }
                                else if (!xmlReader.IsEmptyElement)
                                {
                                    stack.Push(new ScriptSharpSourceMapLoader.ContainingMethodContext(symbol.ScriptStartPosition, orAddFunctionNameIndex));
                                    stack2.Push(new ScriptSharpSourceMapLoader.ParentContext(symbol, true));
                                }
                                else
                                {
                                    dictionary2[key].Add(new ScriptSharpSymbolWrapper(symbol));
                                }
                            }
                        }
                        else if (xmlReader.Name == "AnonymousMethod")
                        {
                            ScriptSharpSourceMapLoader.ContainingMethodContext containingMethodContext2 = stack.Peek();
                            string            name2 = string.Format("{0}.<{1}>anonymous", arg, arg2);
                            int               orAddFunctionNameIndex2 = functionNamePool.GetOrAddFunctionNameIndex(name2);
                            ScriptSharpSymbol scriptSharpSymbol2;
                            if (!ScriptSharpSourceMapLoader.TryParseSymbol(xmlReader, containingMethodContext2.ScriptOffset, orAddFunctionNameIndex2, num, out scriptSharpSymbol2))
                            {
                                ScriptSharpSourceMapLoader.SkipSubTree(xmlReader, "AnonymousMethod");
                            }
                            else
                            {
                                List <ScriptSharpSymbolWrapper>          list          = dictionary2[key];
                                ScriptSharpSourceMapLoader.ParentContext parentContext = ScriptSharpSourceMapLoader.PopNonParentSymbolsOut(stack2, scriptSharpSymbol2, list);
                                if (!xmlReader.IsEmptyElement)
                                {
                                    stack.Push(new ScriptSharpSourceMapLoader.ContainingMethodContext(scriptSharpSymbol2.ScriptStartPosition, orAddFunctionNameIndex2));
                                    stack2.Push(new ScriptSharpSourceMapLoader.ParentContext(scriptSharpSymbol2, true));
                                }
                                else
                                {
                                    parentContext.Children.Add(list.Count);
                                    list.Add(new ScriptSharpSymbolWrapper(scriptSharpSymbol2));
                                }
                            }
                        }
                        else if (xmlReader.Name == "Type")
                        {
                            arg = xmlReader.GetAttribute("Name");
                            string attribute2 = xmlReader.GetAttribute("SegmentRef");
                            if (string.IsNullOrEmpty(attribute2) || !int.TryParse(attribute2, out key))
                            {
                                ScriptSharpSourceMapLoader.SkipSubTree(xmlReader, "Type");
                            }
                            else if (!dictionary2.ContainsKey(key))
                            {
                                dictionary2.Add(key, new List <ScriptSharpSymbolWrapper>(1024));
                            }
                        }
                        else if (xmlReader.Name == "Segments")
                        {
IL_3CE:
                            while (xmlReader.Read())
                            {
                                if (xmlReader.IsStartElement("Segment"))
                                {
                                    string attribute3 = xmlReader.GetAttribute("Id");
                                    int    key2;
                                    List <ScriptSharpSymbolWrapper> list2;
                                    if (int.TryParse(attribute3, out key2) && dictionary2.TryGetValue(key2, out list2))
                                    {
                                        string packageName = ScriptSharpSourceMapLoader.GetPackageName(xmlReader, filePath);
                                        try
                                        {
                                            symbolMaps.Add(packageName, list2);
                                            list2.TrimExcess();
                                        }
                                        catch (ArgumentException exception)
                                        {
                                            string extraData = string.Format("Package: {0}, File name: {1}", packageName, filePath);
                                            ExWatson.SendReport(exception, ReportOptions.DoNotCollectDumps, extraData);
                                        }
                                    }
                                }
                            }
                            goto IL_3E5;
                        }
                    }
                    else if (xmlNodeType == XmlNodeType.EndElement && (xmlReader.Name == "Method" || xmlReader.Name == "AnonymousMethod"))
                    {
                        stack.Pop();
                        List <ScriptSharpSymbolWrapper> symbolList = dictionary2[key];
                        bool flag = false;
                        while (stack2.Count > 0 && !flag)
                        {
                            ScriptSharpSourceMapLoader.ParentContext parentContext2 = ScriptSharpSourceMapLoader.PopItemAndAddToList(stack2, symbolList);
                            flag = parentContext2.IsMethod;
                        }
                    }
                }
                goto IL_3CE;
            }
IL_3E5:
            foreach (KeyValuePair <string, int> keyValuePair in dictionary)
            {
                sourceFileIdMap.Add((uint)keyValuePair.Value, keyValuePair.Key);
            }
        }
コード例 #24
0
        /// <summary>
        /// Handler method for SOAP control requests.
        /// </summary>
        /// <param name="service">The service whose action was called.</param>
        /// <param name="messageStream">The stream which contains the HTTP message body with the SOAP envelope.</param>
        /// <param name="streamEncoding">Encoding of the <paramref name="messageStream"/>.</param>
        /// <param name="subscriberSupportsUPnP11">Should be set if the requester sent a user agent header which denotes a UPnP
        /// version of 1.1. If set to <c>false</c>, in- and out-parameters with extended data type will be deserialized/serialized
        /// using the string-equivalent of the values.</param>
        /// <param name="context">Context object holding data for the current action call.</param>
        /// <param name="result">SOAP result - may be an action result, a SOAP fault or <c>null</c> if no body should
        /// be sent in the HTTP response.</param>
        /// <returns>HTTP status code to be sent. Should be
        /// <list>
        /// <item><see cref="HttpStatusCode.OK"/> If the action could be evaluated correctly and produced a SOAP result.</item>
        /// <item><see cref="HttpStatusCode.InternalServerError"/> If the result is a SOAP fault.</item>
        /// <item><see cref="HttpStatusCode.BadRequest"/> If the message stream was malformed.</item>
        /// </list>
        /// </returns>
        public static HttpStatusCode HandleRequest(DvService service, Stream messageStream, Encoding streamEncoding,
                                                   bool subscriberSupportsUPnP11, CallContext context, out string result)
        {
            UPnPError res;

            try
            {
                IList <object> inParameterValues = null; // Default to null if there aren't parameters, will be lazily initialized later
                DvAction       action;
                using (StreamReader streamReader = new StreamReader(messageStream, streamEncoding))
                    using (XmlReader reader = XmlReader.Create(streamReader, UPnPConfiguration.DEFAULT_XML_READER_SETTINGS))
                    {
                        reader.MoveToContent();
                        // Parse SOAP envelope
                        reader.ReadStartElement("Envelope", UPnPConsts.NS_SOAP_ENVELOPE);
                        reader.ReadStartElement("Body", UPnPConsts.NS_SOAP_ENVELOPE);
                        // Reader is positioned at the action element
                        string serviceTypeVersion_URN = reader.NamespaceURI;
                        string type;
                        int    version;
                        // Parse service and action
                        if (!ParserHelper.TryParseTypeVersion_URN(serviceTypeVersion_URN, out type, out version))
                        {
                            throw new MediaPortal.Utilities.Exceptions.InvalidDataException("Unable to parse service type and version URN '{0}'", serviceTypeVersion_URN);
                        }
                        string actionName = reader.LocalName;
                        if (!service.Actions.TryGetValue(actionName, out action))
                        {
                            result = CreateFaultDocument(401, "Invalid Action");
                            return(HttpStatusCode.InternalServerError);
                        }
                        IEnumerator <DvArgument> formalArgumentEnumer = action.InArguments.GetEnumerator();
                        if (!SoapHelper.ReadEmptyStartElement(reader)) // Action name
                        {
                            while (reader.NodeType != XmlNodeType.EndElement)
                            {
                                string argumentName = reader.Name; // Arguments don't have a namespace, so take full name
                                if (!formalArgumentEnumer.MoveNext() || formalArgumentEnumer.Current.Name != argumentName)
                                {                                  // Too many arguments
                                    result = CreateFaultDocument(402, "Invalid Args");
                                    return(HttpStatusCode.InternalServerError);
                                }
                                object value;
                                if (SoapHelper.ReadNull(reader))
                                {
                                    value = null;
                                }
                                else
                                {
                                    res = formalArgumentEnumer.Current.SoapParseArgument(reader, !subscriberSupportsUPnP11, out value);
                                    if (res != null)
                                    {
                                        result = CreateFaultDocument(res.ErrorCode, res.ErrorDescription);
                                        return(HttpStatusCode.InternalServerError);
                                    }
                                }
                                if (inParameterValues == null)
                                {
                                    inParameterValues = new List <object>();
                                }
                                inParameterValues.Add(value);
                            }
                        }
                        if (formalArgumentEnumer.MoveNext())
                        { // Too few arguments
                            result = CreateFaultDocument(402, "Invalid Args");
                            return(HttpStatusCode.InternalServerError);
                        }
                    }
                IList <object> outParameterValues;
                // Invoke action
                try
                {
                    res = action.InvokeAction(inParameterValues, out outParameterValues, false, context);
                    // outParameterValues can be null if the action has no output parameters. Setting it to an empty list makes
                    // it easier to check parameter count later.
                    if (outParameterValues == null)
                    {
                        outParameterValues = EMPTY_OBJECT_LIST;
                    }
                }
                catch (Exception e)
                {
                    UPnPConfiguration.LOGGER.Warn("SOAPHandler: Error invoking UPnP action '{0}'", e, action.Name);
                    result = CreateFaultDocument(501, "Action Failed");
                    return(HttpStatusCode.InternalServerError);
                }
                if (res != null)
                {
                    result = CreateFaultDocument(res.ErrorCode, res.ErrorDescription);
                    return(HttpStatusCode.InternalServerError);
                }
                // Check output parameters
                IList <DvArgument> formalArguments = action.OutArguments;
                if (outParameterValues.Count != formalArguments.Count)
                {
                    result = CreateFaultDocument(501, "Action Failed");
                    return(HttpStatusCode.InternalServerError);
                }
                IList <OutParameter> outParams = formalArguments.Select((t, i) => new OutParameter(t, outParameterValues[i])).ToList();
                result = CreateResultDocument(action, outParams, !subscriberSupportsUPnP11);
                return(HttpStatusCode.OK);
            }
            catch (Exception e)
            {
                UPnPConfiguration.LOGGER.Warn("Error handling SOAP request: " + e.Message); // Don't log the whole exception; it's only a communication error with a client
                result = null;
                return(HttpStatusCode.BadRequest);
            }
        }
コード例 #25
0
        //=====================================================================

        /// <summary>
        /// Load the collection from the related file
        /// </summary>
        /// <remarks>This will be done automatically at constructor.  This can
        /// be called to reload the collection if needed.</remarks>
        public void Load()
        {
            XmlReaderSettings settings = new XmlReaderSettings();
            XmlReader         xr = null;
            string            defTopicId, splitTopicId;
            Topic             t;

            try
            {
                this.Clear();
                settings.CloseInput = true;

                xr = XmlReader.Create(fileItem.FullPath, settings);
                xr.MoveToContent();

                // These are old options from versions prior to 1.9.0.0
                defTopicId   = xr.GetAttribute("defaultTopic");
                splitTopicId = xr.GetAttribute("splitTOCTopic");

                while (!xr.EOF && xr.NodeType != XmlNodeType.EndElement)
                {
                    if (xr.NodeType == XmlNodeType.Element && xr.Name == "Topic")
                    {
                        t = new Topic();
                        t.ReadXml(xr);
                        this.Add(t);
                    }

                    xr.Read();
                }
            }
            finally
            {
                if (xr != null)
                {
                    xr.Close();
                }
            }

            // Set the default topic if defined from a prior version
            if (!String.IsNullOrEmpty(defTopicId))
            {
                t = this[defTopicId];

                if (t != null)
                {
                    t.IsDefaultTopic = true;
                }
            }

            // Set the "split TOC" option if defined from a prior version
            if (!String.IsNullOrEmpty(splitTopicId))
            {
                t = this[splitTopicId];

                if (t != null)
                {
                    t.ApiParentMode = ApiParentMode.InsertAfter;
                }
            }

            this.MatchProjectFilesToTopics();
        }
コード例 #26
0
        private static object ReadElementAs(this XmlReader reader, string localName, Type type, ReaderState state)
        {
            reader.MoveToContent();
            var isEmptyElement = reader.IsEmptyElement;

            if (reader.Name != localName)
            {
                if (!type.CanBeNull())
                {
                    throw new SerializationException(string.Format("Failed reading element: {0}, could not find it.", localName));
                }
                return(null);
            }
            if (!reader.CanResolveEntity)
            {
                throw new SerializationException("!reader.CanResolveEntity");
            }
            if (type == typeof(string))
            {
                var value = reader.ReadElementContentAsString();
                return(value);
            }
            if (type.IsEnum)
            {
                var value = Enum.Parse(type, reader.ReadElementContentAsString());
                return(value);
            }
            if (ReadElementContentAsTypes.Contains(type))
            {
                var value = reader.ReadElementValueAs(type);
                VerifyNullable(value, localName, type);
                return(value);
            }
            if (type.IsInterface)
            {
                if (typeof(IXmlSerializable).IsAssignableFrom(type))
                {
                    Type instanceType;
                    if (state == ReaderState.ReadingListItem)
                    {
                        instanceType = type.Assembly.GetTypes()
                                       .Where(x => !x.IsInterface && !x.IsAbstract)
                                       .SingleOrDefault(x => x.Name == reader.LocalName);
                        // This is on the simple side for now ^
                        if (instanceType == null)
                        {
                            throw new SerializationException(string.Format("Failed deserializing {0}", reader.Name));
                        }
                    }
                    else
                    {
                        reader.ReadStartElement();
                        instanceType = type.Assembly.GetTypes()
                                       .Where(x => !x.IsInterface && !x.IsAbstract)
                                       .SingleOrDefault(x => x.Name == reader.LocalName);
                        // This is on the simple side for now ^
                        if (instanceType == null)
                        {
                            throw new SerializationException(string.Format("Failed deserializing {0}", reader.Name));
                        }
                    }

                    var instance = (IXmlSerializable)Activator.CreateInstance(instanceType, true);
                    instance.ReadXml(reader);
                    if (state != ReaderState.ReadingListItem)
                    {
                        reader.ReadEndElement();
                    }
                    return(instance);
                }
                else
                {
                    throw new NotImplementedException("Cannot write interface type that is not IXmlSerializable");
                }
            }
            if (typeof(IXmlSerializable).IsAssignableFrom(type))
            {
                var instanceType = type;
                var instance     = (IXmlSerializable)Activator.CreateInstance(instanceType, true);
                instance.ReadXml(reader);
                return(instance);
            }
            if (type.IsList())
            {
                var listElementType = type.ListElementType();
                reader.ReadStartElement();
                var values = (IList)Activator.CreateInstance(type);
                while (reader.NodeType == XmlNodeType.Element)
                {
                    var item = reader.ReadElementAs(reader.Name, listElementType, ReaderState.ReadingListItem);
                    values.Add(item);
                }
                if (!isEmptyElement)
                {
                    reader.ReadEndElement();
                }
                return(values);
            }
            reader.ReadStartElement();
            var serializer   = new XmlSerializer(type);
            var deserialized = serializer.Deserialize(reader);

            if (!isEmptyElement)
            {
                reader.ReadEndElement();
            }
            VerifyNullable(deserialized, localName, type);
            return(deserialized);
        }
コード例 #27
0
        protected void ReadReferencedElements()
        {
            reader.MoveToContent();
            XmlNodeType nt = reader.NodeType;

            while (nt != XmlNodeType.EndElement && nt != XmlNodeType.None)
            {
                whileIterationCount++;
                readCount++;
                ReadReferencedElement();
                reader.MoveToContent();
                nt = reader.NodeType;
            }
            whileIterationCount = 0;

            // Registers delayed list

            if (delayedListFixups != null)
            {
                foreach (DictionaryEntry entry in delayedListFixups)
                {
                    AddTarget((string)entry.Key, entry.Value);
                }
            }
            // Fix arrays

            if (collItemFixups != null)
            {
                foreach (CollectionItemFixup itemFixup in collItemFixups)
                {
                    itemFixup.Collection.SetValue(GetTarget(itemFixup.Id), itemFixup.Index);
                }
            }

            // Fills collections

            if (collFixups != null)
            {
                ICollection cfixups = collFixups.Values;
                foreach (CollectionFixup fixup in cfixups)
                {
                    fixup.Callback(fixup.Collection, fixup.CollectionItems);
                }
            }

            // Fills class instances

            if (fixups != null)
            {
                foreach (Fixup fixup in fixups)
                {
                    fixup.Callback(fixup);
                }
            }

            if (targets != null)
            {
                foreach (DictionaryEntry e in targets)
                {
                    if (e.Value != null && (referencedObjects == null || !referencedObjects.Contains(e.Value)))
                    {
                        UnreferencedObject((string)e.Key, e.Value);
                    }
                }
            }
        }
コード例 #28
0
        public static GAPAuthenticatorValueDTO?ReadXmlv2(XmlReader reader, string?password = null)
        {
            GAPAuthenticatorValueDTO?authenticator = null;
            var authenticatorType = reader.GetAttribute("type");

            if (!string.IsNullOrEmpty(authenticatorType))
            {
                authenticatorType = authenticatorType.Replace(
                    "WindowsAuthenticator.",
                    typeof(GAPAuthenticatorValueDTO).FullName + ".");
                var authenticatorType_ = Assembly.GetExecutingAssembly().GetType(authenticatorType, false, true);
                authenticator = Activator.CreateInstance(authenticatorType_.ThrowIsNull(nameof(authenticatorType_))) as GAPAuthenticatorValueDTO;
            }
            if (authenticator == null)
            {
                return(null);
            }

            reader.MoveToContent();
            if (reader.IsEmptyElement)
            {
                reader.Read();
                return(null);
            }

            reader.Read();
            while (reader.EOF == false)
            {
                if (reader.IsStartElement())
                {
                    switch (reader.Name)
                    {
                    case "servertimediff":
                        authenticator.ServerTimeDiff = reader.ReadElementContentAsLong();
                        break;

                    //case "restorecodeverified":
                    //	authenticator.RestoreCodeVerified = reader.ReadElementContentAsBoolean();
                    //	break;

                    case "secretdata":
                        var encrypted = reader.GetAttribute("encrypted");
                        var data      = reader.ReadElementContentAsString();

                        var passwordType = DecodePasswordTypes(encrypted);

                        if (passwordType != PasswordTypes.None)
                        {
                            // this is an old version so there is no hash
                            data = DecryptSequence(data, passwordType, password);
                        }

                        authenticator.PasswordType = PasswordTypes.None;
                        authenticator.SecretData   = data;

                        break;

                    default:
                        if (authenticator.ReadExtraXml(reader, reader.Name) == false)
                        {
                            reader.Skip();
                        }
                        break;
                    }
                }
                else
                {
                    reader.Read();
                    break;
                }
            }

            return(authenticator);
        }
コード例 #29
0
        private static Dictionary <ExchangeUser, FreeBusy> ParseRasterFreeBusyResponse(
            ExchangeUserDict users,
            DateTime baseTime,
            Stream response)
        {
            Dictionary <ExchangeUser, FreeBusy> result = new Dictionary <ExchangeUser, FreeBusy>();
            string            emailAddress             = null;
            string            freeBusyRaster           = null;
            string            elementName = null;
            XmlReaderSettings settings    = new XmlReaderSettings();

            settings.XmlResolver      = null;
            settings.IgnoreComments   = true;
            settings.IgnoreWhitespace = true;
            settings.ValidationType   = ValidationType.None;
            settings.ValidationFlags  = XmlSchemaValidationFlags.None;
            XmlReader reader = XmlReader.Create(response, settings);

            reader.MoveToContent();
            while (reader.Read())
            {
                switch (reader.NodeType)
                {
                case XmlNodeType.Element:
                    elementName = reader.LocalName;
                    if (elementName == "item")
                    {
                        emailAddress   = null;
                        freeBusyRaster = null;
                    }

                    break;

                case XmlNodeType.Text:
                    if (elementName == "email")
                    {
                        emailAddress = reader.Value.ToLower();
                    }
                    else
                    {
                        if (elementName == "fbdata")
                        {
                            freeBusyRaster = reader.Value;
                        }
                    }

                    break;

                case XmlNodeType.EndElement:
                    if (reader.LocalName == "item")
                    {
                        ParseFreeBusyRaster(users,
                                            baseTime,
                                            emailAddress,
                                            freeBusyRaster,
                                            result);

                        emailAddress   = null;
                        freeBusyRaster = null;
                    }
                    elementName = string.Empty;

                    break;
                }
            }

            return(result);
        }
コード例 #30
0
        public bool ReadXml(XmlReader reader, string?password = null)
        {
            // decode the password type
            var encrypted    = reader.GetAttribute("encrypted");
            var passwordType = DecodePasswordTypes(encrypted);

            PasswordType = passwordType;

            if (passwordType != PasswordTypes.None)
            {
                // read the encrypted text from the node
                EncryptedData = reader.ReadElementContentAsString();
                return(Unprotect(password));

                //// decrypt
                //try
                //{
                //	string data = Authenticator.DecryptSequence(this.EncryptedData, passwordType, password);
                //	using (MemoryStream ms = new MemoryStream(Authenticator.StringToByteArray(data)))
                //	{
                //		reader = XmlReader.Create(ms);
                //		this.ReadXml(reader, password);
                //	}
                //}
                //catch (EncryptedSecretDataException)
                //{
                //	this.RequiresPassword = true;
                //	throw;
                //}
                //finally
                //{
                //	this.PasswordType = passwordType;
                //}
            }

            reader.MoveToContent();
            if (reader.IsEmptyElement)
            {
                reader.Read();
                return(false);
            }

            reader.Read();
            while (reader.EOF == false)
            {
                if (reader.IsStartElement())
                {
                    switch (reader.Name)
                    {
                    case "lastservertime":
                        LastServerTime = reader.ReadElementContentAsLong();
                        break;

                    case "servertimediff":
                        ServerTimeDiff = reader.ReadElementContentAsLong();
                        break;

                    case "secretdata":
                        SecretData = reader.ReadElementContentAsString();
                        break;

                    default:
                        if (ReadExtraXml(reader, reader.Name) == false)
                        {
                            reader.Skip();
                        }
                        break;
                    }
                }
                else
                {
                    reader.Read();
                    break;
                }
            }

            // check if we need to sync, or if it's been a day
#pragma warning disable CS0612 // 类型或成员已过时
            if (this is HOTPAuthenticator)
#pragma warning restore CS0612 // 类型或成员已过时
            {
                // no time sync
                return(true);
            }
            else if (ServerTimeDiff == 0 || LastServerTime == 0 || LastServerTime < DateTime.Now.AddHours(-24).Ticks)
            {
                Sync();
                return(true);
            }
            else
            {
                return(false);
            }
        }
コード例 #31
0
        private void ReadXml(XmlReader r)
        {
            try
            {
                r.MoveToContent();

                if (!(r.Name == "KinoveaPostureTool"))
                {
                    return;
                }

                r.ReadStartElement();
                r.ReadElementContentAsString("FormatVersion", "");

                while (r.NodeType == XmlNodeType.Element)
                {
                    switch (r.Name)
                    {
                    case "Icon":
                        r.ReadOuterXml();
                        break;

                    case "Id":
                        Id = new Guid(r.ReadElementContentAsString());
                        break;

                    case "Name":
                        Name = r.ReadElementContentAsString();
                        break;

                    case "DisplayName":
                        DisplayName = r.ReadElementContentAsString();
                        break;

                    case "PointCount":
                        ParsePointCount(r);
                        break;

                    case "Segments":
                        ParseSegments(r);
                        break;

                    case "Ellipses":
                        ParseEllipses(r);
                        break;

                    case "Angles":
                        ParseAngles(r);
                        break;

                    case "Distances":
                        ParseDistances(r);
                        break;

                    case "Positions":
                        ParsePositions(r);
                        break;

                    case "Handles":
                        ParseHandles(r);
                        break;

                    case "ComputedPoints":
                        ParseComputedPoints(r);
                        break;

                    case "HitZone":
                        ParseHitZone(r);
                        break;

                    case "TrackingProfile":
                        CustomTrackingProfile.ReadXml(r);
                        break;

                    case "DefaultOptions":
                        ParseDefaultOptions(r);
                        break;

                    case "Capabilities":
                        ParseCapabilities(r);
                        break;

                    case "InitialConfiguration":
                        ParseInitialConfiguration(r);
                        break;

                    default:
                        string unparsed = r.ReadOuterXml();
                        log.DebugFormat("Unparsed content in XML: {0}", unparsed);
                        break;
                    }
                }

                r.ReadEndElement();

                ImportOptionGroups();
            }
            catch (Exception e)
            {
                log.ErrorFormat("An error occurred during the parsing of a custom tool.");
                log.ErrorFormat(e.ToString());
            }
        }
コード例 #32
0
        /// <summary>
        /// Deserialize a struct member
        /// </summary>
        /// <param name="reader">XML Reader that contains XML Stream</param>
        /// <param name="arrayItemType">Type of Array Object</param>
        /// <param name="containedInArray">Indicates if a parameter is in Array</param>
        /// <returns>Object element</returns>
        private static object DeserializeParamStruct(XmlReader reader, Type arrayItemType, bool containedInArray)
        {
            Dictionary <object, object>     structInfo         = new Dictionary <object, object>();
            Dictionary <object, XMLRpcType> structDataTypeInfo = new Dictionary <object, XMLRpcType>();

            if (containedInArray)
            {
                reader.MoveToContent();
            }
            if (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    //<struct>
                    if (reader.Name == "struct")
                    {
                        if (XNode.ReadFrom(reader) is XElement el)
                        {
                            //get array of <member>
                            var arrayOfProperties = el.Elements();
                            foreach (var property in arrayOfProperties)
                            {
                                //<name>
                                var    nameNode     = property.FirstNode as XElement;
                                string propertyName = NormalizePropertyName(nameNode.Value);
                                //<value>
                                var valueNode = property.LastNode as XElement;
                                //Get DataType From Tag
                                var dataTypeNode = valueNode.FirstNode as XElement;
                                var dataType     = (XMLRpcType)StringEnum.Parse(typeof(XMLRpcType), dataTypeNode.Name.LocalName, true);
                                var readedValue  = new object();
                                switch (dataType)
                                {
                                case XMLRpcType.Int:
                                case XMLRpcType.Boolean:
                                case XMLRpcType.Double:
                                case XMLRpcType.String:
                                case XMLRpcType.Datetime:
                                    readedValue = dataTypeNode.Value;
                                    break;

                                case XMLRpcType.Array:

                                case XMLRpcType.Struct:

                                default:
                                    break;
                                }

                                structInfo.Add(propertyName, readedValue);
                                structDataTypeInfo.Add(propertyName, dataType);
                            }
                        }
                    }
                    else
                    {
                        throw new InvalidCastException("Can not find the struct specification");
                    }
                }
            }
            PropertyInfo[] arrayPropertyInfos = arrayItemType.GetProperties();
            Type           objType            = Type.GetType(arrayItemType.AssemblyQualifiedName);
            var            newObject          = Activator.CreateInstance(objType);

            foreach (PropertyInfo property in arrayPropertyInfos)
            {
                if (structInfo.ContainsKey(property.Name))
                {
                    property.SetValue(newObject, ConvertToType(property.PropertyType, structInfo[property.Name], property.Name));
                }
            }
            return(newObject);
        }
コード例 #33
0
        public static void ReadObject(XmlReader reader, object obj, PropertyConversionHandler handler = null)
        {
            if (obj == null)
                throw new ArgumentNullException("obj");

            reader.MoveToContent();

            if (obj is IXmlSerializable)
            {
                ((IXmlSerializable)obj).ReadXml(reader);
            }
            else
            {
                object oVal = null;
                string oName = GetAttributeValue(obj.GetType(), typeof(XmlRootAttribute), "ElementName", true, ref oVal) ? oVal.ToString() : obj.GetType().Name;
                if (reader.LocalName != oName)
                    throw new XmlException("XML element name does not match object.");

                if (!reader.IsEmptyElement)
                {
                    reader.ReadStartElement();
                    reader.MoveToContent();
                    ReadObjectProperties(reader, obj, handler);
                    reader.ReadEndElement();
                }
                else
                    reader.Skip();
            }
        }
コード例 #34
0
        public void ReadXml(XmlReader reader, string password = null)
        {
            reader.MoveToContent();

            if (reader.IsEmptyElement)
            {
                reader.Read();
                return;
            }

            reader.Read();
            while (reader.EOF == false)
            {
                if (reader.IsStartElement())
                {
                    switch (reader.Name)
                    {
                    case "modifiers":
                        Modifiers = (WinAPI.KeyModifiers)BitConverter.ToInt32(Authenticator.StringToByteArray(reader.ReadElementContentAsString()), 0);
                        break;

                    case "hotkey":
                        HotKey = (WinAPI.VirtualKeyCode)BitConverter.ToUInt16(Authenticator.StringToByteArray(reader.ReadElementContentAsString()), 0);
                        break;

                    case "windowtitle":
                        WindowTitle = reader.ReadElementContentAsString();
                        break;

                    case "windowtitleregex":
                        WindowTitleRegex = reader.ReadElementContentAsBoolean();
                        break;

                    case "processname":
                        ProcessName = reader.ReadElementContentAsString();
                        break;

                    case "advanced":
                        Advanced = reader.ReadElementContentAsBoolean();
                        break;

                    case "script":
                        string encrypted = reader.GetAttribute("encrypted");
                        string data      = reader.ReadElementContentAsString();

                        if (string.IsNullOrEmpty(encrypted) == false)
                        {
                            Authenticator.PasswordTypes passwordType = Authenticator.DecodePasswordTypes(encrypted);
                            data = Authenticator.DecryptSequence(data, passwordType, password, null, true);
                            //byte[] plain = Authenticator.StringToByteArray(data);
                            //data = Encoding.UTF8.GetString(plain, 0, plain.Length);

/*
 *              char[] encTypes = encrypted.ToCharArray();
 *              // we read the string in reverse order (the order they were encrypted)
 *              for (int i = encTypes.Length - 1; i >= 0; i--)
 *              {
 *                char encryptedType = encTypes[i];
 *                switch (encryptedType)
 *                {
 *                  case 'u':
 *                    {
 *                      // we are going to decrypt with the Windows User account key
 *                      byte[] cipher = Authenticator.StringToByteArray(data);
 *                      byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.CurrentUser);
 *                      data = Encoding.UTF8.GetString(plain, 0, plain.Length);
 *                      break;
 *                    }
 *                  case 'm':
 *                    {
 *                      // we are going to decrypt with the Windows local machine key
 *                      byte[] cipher = Authenticator.StringToByteArray(data);
 *                      byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.LocalMachine);
 *                      data = Encoding.UTF8.GetString(plain, 0, plain.Length);
 *                      break;
 *                    }
 *                  case 'y':
 *                    {
 *                      // we use an explicit password to encrypt data
 *                      if (string.IsNullOrEmpty(password) == true)
 *                      {
 *                        throw new EncryptedSecretDataException();
 *                      }
 *                      data = Authenticator.Decrypt(data, password, true);
 *                      byte[] plain = Authenticator.StringToByteArray(data);
 *                      data = Encoding.UTF8.GetString(plain, 0, plain.Length);
 *                      break;
 *                    }
 *                  default:
 *                    break;
 *                }
 *              }
 */
                        }

                        AdvancedScript = data;

                        break;

                    default:
                        reader.Skip();
                        break;
                    }
                }
                else
                {
                    reader.Read();
                    break;
                }
            }
        }