public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
var empty = reader.IsEmptyElement;
reader.ReadStartElement();
if (!empty)
{
while (reader.MoveToContent() == XmlNodeType.Element)
{
if (reader.Name == @"ProductName" && !reader.IsEmptyElement)
{
ProductName = reader.ReadElementString();
}
else if (reader.Name == @"GlyphColor" && !reader.IsEmptyElement)
{
GlyphColor = ParseColor(reader.ReadElementString());
}
else
{
// consume the bad element and skip to next sibling or the parent end element tag
reader.ReadOuterXml();
}
}
reader.MoveToContent();
reader.ReadEndElement();
}
}
// TwoWayRequest: Accept two integer values, return their sum
public byte[] TwoWayRequest(WsWsaHeader header, XmlReader reader)
{
try
{
// Find beginning of request
reader.ReadStartElement("TwoWayRequest", SimpleServiceNamespaceUri);
// Find the values to be added
int X = Convert.ToInt32(reader.ReadElementString("X", SimpleServiceNamespaceUri));
int Y = Convert.ToInt32(reader.ReadElementString("Y", SimpleServiceNamespaceUri));
Log.Comment("");
Log.Comment("X = " + X.ToString() + " Y = " + Y.ToString());
Log.Comment(X.ToString() + " + " + Y.ToString() + " = " + ((int)(X + Y)).ToString());
Log.Comment("");
// Return the response
return TwoWayResponse(header, X + Y);
}
catch (Exception e)
{
// Something went wrong
throw new WsFaultException(header, WsFaultType.XmlException, e.ToString());
}
}
public void ReadXml(XmlReader r)
{
r.Read(); // move past container
r.ReadStartElement("dictionary");
while (r.NodeType != XmlNodeType.EndElement) {
r.ReadStartElement("item", NS);
string key = r.ReadElementString("key", NS);
string value = r.ReadElementString("value", NS);
r.ReadEndElement();
r.MoveToContent();
dictionary.Add(key, value);
}
}
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();
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
reader.Read();
reader.ReadStartElement("dictionary");
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.ReadStartElement("item");
string key = reader.ReadElementString("key");
string value = reader.ReadElementString("value");
reader.ReadEndElement();
reader.MoveToContent();
dictionary.Add(key, value);
}
reader.ReadEndElement();
}
private void ReadElement(XmlReader reader, Bag parent) {
var name = XmlConvert.DecodeName(reader.LocalName);
var type = reader["type"];
// is it a value node ? i.e. type=""
if (type != null) {
if (type == "Array") {
// go to first item
parent.SetMember(name, ReadArray(reader));
reader.Read();
}
else {
var typeCode = (TypeCode)Enum.Parse(typeof(TypeCode), type);
var value = SConvert.XmlDecode(typeCode, reader.ReadElementString());
parent.SetMember(name, value);
}
}
else {
var grappe = new Bag();
reader.Read();
parent.SetMember(name, grappe);
while (reader.MoveToContent() == XmlNodeType.Element) {
ReadElement(reader, grappe);
}
reader.Read();
}
}
void AddString(XmlReader reader, Hashtable strings)
{
string key = reader.Name;
if (strings.ContainsKey(key))
throw new InvalidDataException("Already contains key (" + key + ")");
reader.Read();
while (reader.IsStartElement())
{
string name = reader.Name;
string value = reader.ReadElementString();
if (string.IsNullOrEmpty(value))
continue;
if (name == culture.Name)
strings.Add(key, value);
if (name == "default" && culture.Equals(CultureInfo.InvariantCulture))
strings.Add(key, value);
}
reader.ReadEndElement();
}
/// <summary>Reads the Elo from an xml writer.</summary>
/// <remarks>
/// Uses the string parse function of Elo.
/// </remarks>
/// <param name="reader">An xml reader.</param>
void IXmlSerializable.ReadXml(XmlReader reader)
{
var s = reader.ReadElementString();
BotInfo info;
TryParse(s, out info);
m_Name = info.m_Name;
m_Version = info.m_Version;
m_Inactive = info.m_Inactive;
}
private void readBuilding(XmlReader inReader)
{
Building building = new Building();
while (inReader.Read())
{
if (inReader.NodeType == XmlNodeType.Element)
{
switch (inReader.Name.ToLower())
{
case "name":
building.Name = inReader.ReadElementString();
break;
case "identifier":
building.Identifier = inReader.ReadElementString();
break;
case "type":
switch (inReader.ReadElementString().ToLower())
{
case "pollutionreducer":
building.Type = BuildingTypes.PollutionReducer;
break;
case "powerplant":
building.Type = BuildingTypes.Powerplant;
break;
case "house":
building.Type = BuildingTypes.House;
break;
case "storage":
building.Type = BuildingTypes.Storage;
break;
}
break;
case "properties":
readProperties(inReader.ReadSubtree(), building.Values);
break;
case "active":
readActive(inReader.ReadSubtree(), building.Values);
break;
case "passive":
readPassive(inReader.ReadSubtree(), building.Values);
break;
case "construct":
readConstruct(inReader.ReadSubtree(), building.Values);
break;
case "upgrades":
readUpgrades(inReader.ReadSubtree(), building);
break;
}
}
}
if (building.isValid()) Buildings.Add(building);
}
internal Person(XmlReader rdr)
{
rdr.ReadStartElement("person");
this.Id = int.Parse(rdr.ReadElementString("id"));
this.FirstName = rdr.ReadElementString("first_name");
this.LastName = rdr.ReadElementString("last_name");
//Skipping Image Fields
rdr.ReadToFollowing("title");
this.Title = rdr.ReadElementString("title");
this.Company = rdr.ReadElementString("company");
int companyId;
if (int.TryParse(rdr.ReadElementString("company_id"), out companyId))
this.CompanyId = companyId;
this.Tags = Tag.BuildList(rdr);
this.Locations = Location.BuildList(rdr);
this.MegaComments = MegaComment.BuildList(rdr);
this.Notes = rdr.ReadElementString("notes");
this.CreatedAt = rdr.ReadElementString("created_at").FromBatchBookFormat();
this.UpdatedAt = rdr.ReadElementString("updated_at").FromBatchBookFormat();
rdr.ReadEndElement();
}
public byte[] OneWay(WsWsaHeader header, XmlReader reader)
{
try
{
// Find beginning of request
reader.ReadStartElement("OneWay", SimpleServiceNamespaceUri);
// Find the integer value
int number = Convert.ToInt32(reader.ReadElementString("Param", SimpleServiceNamespaceUri));
Log.Comment("");
Log.Comment("Integer = " + number.ToString());
Log.Comment("");
return new byte[0]; // Empty response
}
catch (Exception e)
{
// Something went wrong
throw new WsFaultException(header, WsFaultType.XmlException, e.ToString());
}
}
private Page ParsePage(XmlReader PageElement)
{
Page page = new Page();
int GotCount = 0;
while (PageElement.Read())
{
switch (PageElement.Name)
{
case "title":
page.Title = PageElement.ReadElementString();
GotCount++;
break;
case "redirect":
page.RedirectTo = PageElement.GetAttribute("title");
GotCount++;
break;
case "text":
page.Text = PageElement.ReadElementString();
GotCount++;
break;
}
if (GotCount == 3) break;
}
return page;
}
private static String ReadMethodName(XmlReader reader)
{
RecursiveTypeSerializer.CheckTag(reader, XmlRpcSpec.METHOD_NAME_TAG);
return reader.ReadElementString();
}
public virtual WebPart ImportWebPart(XmlReader reader, out string errorMessage)
{
WebPart part2;
this.Personalization.EnsureEnabled(true);
if (reader == null)
{
throw new ArgumentNullException("reader");
}
bool flag = false;
if (this.UsePermitOnly)
{
this.MinimalPermissionSet.PermitOnly();
flag = true;
}
string str = string.Empty;
try
{
try
{
Type type;
IDictionary personalizablePropertyEntries;
reader.MoveToContent();
reader.ReadStartElement("webParts");
ImportSkipTo(reader, "webPart");
string attribute = reader.GetAttribute("xmlns");
if (string.IsNullOrEmpty(attribute))
{
errorMessage = System.Web.SR.GetString("WebPart_ImportErrorNoVersion");
return null;
}
if (!string.Equals(attribute, "http://schemas.microsoft.com/WebPart/v3", StringComparison.OrdinalIgnoreCase))
{
errorMessage = System.Web.SR.GetString("WebPart_ImportErrorInvalidVersion");
return null;
}
ImportReadTo(reader, "metaData");
reader.ReadStartElement("metaData");
string str3 = null;
string path = null;
ImportSkipTo(reader, "type");
str3 = reader.GetAttribute("name");
path = reader.GetAttribute("src");
ImportSkipTo(reader, "importErrorMessage");
str = reader.ReadElementString();
WebPart part = null;
Control control = null;
try
{
bool isShared = this.Personalization.Scope == PersonalizationScope.Shared;
if (!string.IsNullOrEmpty(str3))
{
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
this.MediumPermissionSet.PermitOnly();
flag = true;
}
type = WebPartUtil.DeserializeType(str3, true);
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
this.MinimalPermissionSet.PermitOnly();
flag = true;
}
if (!this.IsAuthorized(type, null, null, isShared))
{
errorMessage = System.Web.SR.GetString("WebPartManager_ForbiddenType");
return null;
}
if (!type.IsSubclassOf(typeof(WebPart)))
{
if (!type.IsSubclassOf(typeof(Control)))
{
errorMessage = System.Web.SR.GetString("WebPartManager_TypeMustDeriveFromControl");
return null;
}
control = (Control) this.Internals.CreateObjectFromType(type);
control.ID = this.CreateDynamicWebPartID(type);
part = this.CreateWebPart(control);
}
else
{
part = (WebPart) this.Internals.CreateObjectFromType(type);
}
}
else
{
if (!this.IsAuthorized(typeof(UserControl), path, null, isShared))
{
errorMessage = System.Web.SR.GetString("WebPartManager_ForbiddenType");
return null;
}
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
}
control = this.Page.LoadControl(path);
type = control.GetType();
if (this.UsePermitOnly)
{
this.MinimalPermissionSet.PermitOnly();
flag = true;
}
control.ID = this.CreateDynamicWebPartID(type);
part = this.CreateWebPart(control);
}
}
catch
{
if (!string.IsNullOrEmpty(str))
{
errorMessage = str;
}
else
{
errorMessage = System.Web.SR.GetString("WebPartManager_ErrorLoadingWebPartType");
}
return null;
}
if (string.IsNullOrEmpty(str))
{
str = System.Web.SR.GetString("WebPart_DefaultImportErrorMessage");
}
ImportSkipTo(reader, "data");
reader.ReadStartElement("data");
ImportSkipTo(reader, "properties");
if (!reader.IsEmptyElement)
{
reader.ReadStartElement("properties");
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
}
this.ImportIPersonalizable(reader, (control != null) ? control : part);
if (this.UsePermitOnly)
{
this.MinimalPermissionSet.PermitOnly();
flag = true;
}
}
if (control != null)
{
if (!reader.IsEmptyElement)
{
personalizablePropertyEntries = PersonalizableAttribute.GetPersonalizablePropertyEntries(type);
while (reader.Name != "property")
{
reader.Skip();
if (reader.EOF)
{
errorMessage = null;
return part;
}
}
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
}
this.ImportFromReader(personalizablePropertyEntries, control, reader);
if (this.UsePermitOnly)
{
this.MinimalPermissionSet.PermitOnly();
flag = true;
}
}
ImportSkipTo(reader, "genericWebPartProperties");
reader.ReadStartElement("genericWebPartProperties");
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
}
this.ImportIPersonalizable(reader, part);
if (this.UsePermitOnly)
{
this.MinimalPermissionSet.PermitOnly();
flag = true;
}
personalizablePropertyEntries = PersonalizableAttribute.GetPersonalizablePropertyEntries(part.GetType());
}
else
{
personalizablePropertyEntries = PersonalizableAttribute.GetPersonalizablePropertyEntries(type);
}
while (reader.Name != "property")
{
reader.Skip();
if (reader.EOF)
{
errorMessage = null;
return part;
}
}
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
}
this.ImportFromReader(personalizablePropertyEntries, part, reader);
if (this.UsePermitOnly)
{
this.MinimalPermissionSet.PermitOnly();
flag = true;
}
errorMessage = null;
part2 = part;
}
catch (XmlException)
{
errorMessage = System.Web.SR.GetString("WebPartManager_ImportInvalidFormat");
part2 = null;
}
catch (Exception exception)
{
if ((this.Context != null) && this.Context.IsCustomErrorEnabled)
{
errorMessage = (str.Length != 0) ? str : System.Web.SR.GetString("WebPart_DefaultImportErrorMessage");
}
else
{
errorMessage = exception.Message;
}
part2 = null;
}
finally
{
if (flag)
{
CodeAccessPermission.RevertPermitOnly();
}
}
}
catch
{
throw;
}
return part2;
}
public void ReadXml (XmlReader reader)
{
// Read the element enclosing the object
reader.ReadStartElement();
reader.MoveToContent ();
// Reads the "data" element
reader.ReadStartElement();
reader.MoveToContent ();
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.NodeType == XmlNodeType.Element)
{
string key = reader.LocalName;
data [key] = reader.ReadElementString ();
}
else
reader.Skip ();
reader.MoveToContent ();
}
reader.ReadEndElement ();
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
Rows = int.Parse(reader.GetAttribute("rows"));
Cols = int.Parse(reader.GetAttribute("cols"));
reader.ReadStartElement();
if (Rows > 0 && Cols > 0)
{
_asTransposeRef = false;
_matrix = new double[Rows][];
for (int i = 0; i < Rows; i++)
{
reader.ReadStartElement("r");
_matrix[i] = new double[Cols];
for (int j = 0; j < Cols; j++)
_matrix[i][j] = double.Parse(reader.ReadElementString("e"));
reader.ReadEndElement();
}
}
else
throw new InvalidOperationException("Invalid matrix size in XML!");
reader.ReadEndElement();
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
name = reader.GetAttribute("name");
reader.ReadStartElement();
if (!reader.IsEmptyElement)
{
line1 = reader.ReadElementString("line1");
line2 = reader.ReadElementString("line2");
reader.ReadEndElement();
}
}
protected void FromXmlInternal(XmlReader r, List<string> log)
{
while(r.Read())
{
if (r.NodeType == XmlNodeType.EndElement)
{
break;
}
if (r.NodeType == XmlNodeType.Whitespace)
{
continue;
}
switch(r.Name)
{
case "TargetFile":
targetFile = r.ReadElementString();
break;
case "NewFileName":
newFileName = r.ReadElementString();
break;
case "FileType":
fileTypeEnum = AssetFileEnumFromCompressedName(r.ReadElementString());
break;
default:
log.Add(string.Format("In AssetFile.FromXmlInternal, unknown attribute '{0}'", r.Name));
break;
}
}
}
protected bool ReadXmlFileInternal(XmlReader r, List<string> log)
{
//Debug.Assert(root.LocalName == "AssetDefinition");
while(r.Read()) {
if (r.NodeType == XmlNodeType.Whitespace)
{
continue;
}
if (r.NodeType == XmlNodeType.EndElement)
{
break;
}
switch (r.Name)
{
case "Name":
name = r.ReadElementString();
break;
case "Description":
description = r.ReadElementString();
break;
case "Category":
category = r.ReadElementString();
break;
case "Type":
typeEnum = AssetTypeDesc.AssetTypeEnumFromName(r.ReadElementString());
break;
case "Status":
status = AssetTypeDesc.AssetStatusEnumFromName(r.ReadElementString());
break;
case "Breakage":
breakage = r.ReadElementString();
break;
case "Files":
while (r.Read())
{
if (r.NodeType == XmlNodeType.Whitespace)
{
continue;
}
if (r.NodeType == XmlNodeType.EndElement)
{
break;
}
switch (r.Name)
{
case "AssetFile":
files.Add(AssetFile.FromXml(r, log));
break;
}
}
break;
case "Properties":
while (r.Read())
{
if (r.NodeType == XmlNodeType.Whitespace)
{
continue;
}
if (r.NodeType == XmlNodeType.EndElement)
{
break;
}
switch (r.Name)
{
case "Property":
properties.Add(AssetProperty.FromXml(r));
break;
}
}
break;
default:
log.Add(string.Format("In AssetDefinition.ReadXmlFileInternal, unknown attribute '{0}'",
r.Name));
break;
}
}
return true;
}
private PlistDictionary LoadDictionaryContents(XmlReader reader, PlistDictionary dict)
{
Debug.Assert(reader.NodeType == XmlNodeType.Element && reader.LocalName == "key");
while (!reader.EOF && reader.NodeType == XmlNodeType.Element)
{
string key = reader.ReadElementString();
while (reader.NodeType != XmlNodeType.Element && reader.Read())
if (reader.NodeType == XmlNodeType.EndElement)
throw new Exception(String.Format("No value found for key {0}", key));
PlistObjectBase result = LoadFromNode(reader);
if (result != null)
dict.Add(key, result);
reader.ReadToNextSibling("key");
}
return dict;
}
protected override bool ImportXml (XmlReader xr, IWarningLogger log) {
bool gotdir = false;
bool gotname = false;
int depth = xr.Depth;
while (xr.Depth >= depth) {
if (xr.NodeType != XmlNodeType.Element) {
//Console.WriteLine ("skipping {0}: {1} = \"{2}\"", xr.NodeType, xr.Name, xr.Value);
xr.Read ();
continue;
}
switch (xr.Name) {
case "result":
string ignore;
Result r = Result.ImportXml (xr, out ignore, log);
if (r == null)
return true;
if (!(r is MBDirectory)) {
log.Warning (3019, "Result embedded in file result is not directory during XML import", null);
return true;
}
dir = (MBDirectory) r;
gotdir = true;
break;
case "name":
name = xr.ReadElementString ();
gotname = true;
break;
default:
log.Warning (3019, "Unknown element in file result during XML import", xr.Name);
xr.Skip ();
break;
}
}
if (!gotdir) {
log.Warning (3019, "Did not find directory in file element during XML import", null);
return true;
}
if (!gotname) {
log.Warning (3019, "Did not find name in file element during XML import", null);
return true;
}
return false;
}
SoapException ReadSoapException(XmlReader reader) {
XmlQualifiedName faultCode = XmlQualifiedName.Empty;
string faultString = null;
string faultActor = null;
string faultRole = null;
XmlNode detail = null;
SoapFaultSubCode subcode = null;
string lang = null;
bool soap12 = (reader.NamespaceURI == Soap12.Namespace);
if (reader.IsEmptyElement) {
reader.Skip();
}
else {
reader.ReadStartElement();
reader.MoveToContent();
int depth = reader.Depth;
while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None) {
if (reader.NamespaceURI == Soap.Namespace || reader.NamespaceURI == Soap12.Namespace || reader.NamespaceURI == null || reader.NamespaceURI.Length == 0) {
if (reader.LocalName == Soap.Element.FaultCode || reader.LocalName == Soap12.Element.FaultCode) {
if (soap12)
faultCode = ReadSoap12FaultCode(reader, out subcode);
else
faultCode = ReadFaultCode(reader);
}
else if (reader.LocalName == Soap.Element.FaultString) {
lang = reader.GetAttribute(Soap.Attribute.Lang, Soap.XmlNamespace);
reader.MoveToElement();
faultString = reader.ReadElementString();
}
else if (reader.LocalName == Soap12.Element.FaultReason) {
if (reader.IsEmptyElement)
reader.Skip();
else {
reader.ReadStartElement(); // consume Reason element to get to Text child
reader.MoveToContent();
while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None) {
if (reader.LocalName == Soap12.Element.FaultReasonText && reader.NamespaceURI == Soap12.Namespace) {
faultString = reader.ReadElementString();
}
else {
reader.Skip();
}
reader.MoveToContent();
}
while (reader.NodeType == XmlNodeType.Whitespace) reader.Skip();
if (reader.NodeType == XmlNodeType.None) reader.Skip();
else reader.ReadEndElement();
}
}
else if (reader.LocalName == Soap.Element.FaultActor || reader.LocalName == Soap12.Element.FaultNode) {
faultActor = reader.ReadElementString();
}
else if (reader.LocalName == Soap.Element.FaultDetail || reader.LocalName == Soap12.Element.FaultDetail) {
detail = new XmlDocument().ReadNode(reader);
}
else if (reader.LocalName == Soap12.Element.FaultRole) {
faultRole = reader.ReadElementString();
}
else {
reader.Skip();
}
}
else {
reader.Skip();
}
reader.MoveToContent();
}
// Consume soap:Body and soap:Envelope closing tags
while (reader.Read() && depth < reader.Depth) {
// Nothing, just read on
}
// consume end tag
if (reader.NodeType == XmlNodeType.EndElement) {
reader.Read();
}
}
if (detail != null || soap12) // with soap 1.2, can't tell if fault is for header
return new SoapException(faultString, faultCode, faultActor, faultRole, lang, detail, subcode, null);
else
return new SoapHeaderException(faultString, faultCode, faultActor, faultRole, lang, subcode, null);
}
void IXmlSerializable.ReadXml(XmlReader r)
{
char[] buffer = null;
string attribute = r.GetAttribute("nil", "http://www.w3.org/2001/XMLSchema-instance");
if ((attribute != null) && XmlConvert.ToBoolean(attribute))
{
r.ReadElementString();
this.SetNull();
}
else
{
buffer = r.ReadElementString().ToCharArray();
this.SetBuffer(buffer);
}
}
private static string GetIcuOptionFromNode(XmlReader reader)
{
Debug.Assert(reader.NodeType == XmlNodeType.Element);
string result;
switch (reader.Name)
{
case "suppress_contractions":
case "optimize":
result = String.Format(NewLine + "[{0} {1}]", reader.Name.Replace('_', ' '), reader.ReadElementString());
break;
default:
throw new ApplicationException(String.Format("Invalid LDML collation option element: {0}", reader.Name));
}
return result;
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
reader.ReadStartElement();
reader.ReadStartElement();
Name = reader.ReadElementString();
Exists = reader.ReadElementString().DeserializeObject<bool>();
Size = reader.ReadElementString().DeserializeObject<ulong>();
SubFilenames = reader.ReadElementString().DeserializeObject<List<string>>();
InstallTime = reader.ReadElementString().DeserializeObject<DateTime>();
Properties = reader.ReadElementString().DeserializeObject<SerializableDictionary<string, object>>();
reader.ReadEndElement();
reader.ReadEndElement();
}
/// <summary>
/// Global eventing Subscribe stub.
/// </summary>
/// <param name="header">Header object.</param>
/// <param name="reader">An XmlReader positioned at the begining of the Subscribe request body element.</param>
/// <param name="serviceEndpoints">A Collection of serviceEndpoints used to determine what services contain the event source specified in the filter.</param>
/// <returns>Byte array containing a Subscribe response.</returns>
internal WsMessage Subscribe(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints)
{
WsMessage msg = null;
// Parse Subscribe Request
/////////////////////////////
DpwsWseEventSink eventSink = new DpwsWseEventSink();
try
{
reader.ReadStartElement("Subscribe", WsWellKnownUri.WseNamespaceUri);
if (reader.IsStartElement("EndTo", WsWellKnownUri.WseNamespaceUri))
{
eventSink.EndTo = new WsWsaEndpointRef(reader, m_version.AddressingNamespace);
}
reader.ReadStartElement("Delivery", WsWellKnownUri.WseNamespaceUri);
if (reader.IsStartElement("NotifyTo", WsWellKnownUri.WseNamespaceUri))
{
eventSink.NotifyTo = new WsWsaEndpointRef(reader, m_version.AddressingNamespace);
}
else
{
throw new WsFaultException(header, WsFaultType.WseDeliverModeRequestedUnavailable);
}
reader.ReadEndElement();
if (reader.IsStartElement("Expires", WsWellKnownUri.WseNamespaceUri))
{
long expires = new WsDuration(reader.ReadElementString()).DurationInSeconds;
if (expires > 0)
{
eventSink.Expires = expires;
}
else
{
throw new WsFaultException(header, WsFaultType.WseInvalidExpirationTime);
}
}
else
{
// Never Expires
eventSink.Expires = -1;
}
if (reader.IsStartElement("Filter", WsWellKnownUri.WseNamespaceUri))
{
if (reader.MoveToAttribute("Dialect") == false || reader.Value != m_version.WsdpNamespaceUri + "/Action")
{
throw new WsFaultException(header, WsFaultType.WseFilteringRequestedUnavailable);
}
reader.MoveToElement();
String filters = reader.ReadElementString();
if (filters != String.Empty)
{
eventSink.Filters = filters.Split(' ');
}
}
XmlReaderHelper.SkipAllSiblings(reader);
reader.ReadEndElement(); // Subscribe
}
catch (XmlException e)
{
throw new WsFaultException(header, WsFaultType.WseInvalidMessage, e.ToString());
}
// Parse urn:uuid from the To address
string endpointAddress = FixToAddress(header.To);
// Build a temporary collection of device services that match the specified endpoint address.
WsServiceEndpoints matchingServices = new WsServiceEndpoints();
for (int i = 0; i < serviceEndpoints.Count; ++i)
{
if (serviceEndpoints[i].EndpointAddress == endpointAddress)
matchingServices.Add(serviceEndpoints[i]);
}
// For each service with a matching endpoint and event sources add an event sink to the
// event source collection
for (int i = 0; i < matchingServices.Count; ++i)
{
DpwsWseEventSources eventSources = ((DpwsHostedService)matchingServices[i]).EventSources;
// Set the EventSinkID
eventSink.ID = "urn:uuid:" + Guid.NewGuid().ToString();
// If subscribing to all event sources
if (eventSink.Filters == null)
{
int count = eventSources.Count;
for (int ii = 0; i < count; i++)
{
DpwsWseEventSource eventSource = eventSources[ii];
eventSink.StartTime = DateTime.Now.Ticks;
eventSource.EventSinks.Add(eventSink);
}
}
else
{
// If subscribing to a specific event based on an event filter.
DpwsWseEventSource eventSource;
string[] filterList = eventSink.Filters;
int length = filterList.Length;
for (int ii = 0; i < length; i++)
{
if ((eventSource = eventSources[filterList[ii]]) != null)
{
eventSink.StartTime = DateTime.Now.Ticks;
eventSource.EventSinks.Add(eventSink);
}
else
{
throw new Exception("Event source " + filterList[ii] + " was not found.");
}
}
}
}
// Generate Response
//////////////////////////
using(XmlMemoryWriter xmlWriter = XmlMemoryWriter.Create())
{
WsWsaHeader responseHeader = new WsWsaHeader(
WsWellKnownUri.WseNamespaceUri + "/SubscribeResponse", // Action
header.MessageID, // RelatesTo
header.ReplyTo.Address.AbsoluteUri, // To
null, null, null); // ReplyTo, From, Any
msg = new WsMessage(responseHeader, null, WsPrefix.Wse, null,
new WsAppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID));
WsSoapMessageWriter smw = new WsSoapMessageWriter(m_version);
smw.WriteSoapMessageStart(xmlWriter, msg);
// write body
xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "SubscribeResponse", null);
xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "SubscriptionManager", null);
xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "Address", null);
// Create a uri. Use the path (by default will be a uuid) for the sub manager endpoint
Uri subMgrUri = new Uri(((DpwsHostedService)matchingServices[0]).EndpointAddress);
xmlWriter.WriteString("http://" + Device.IPV4Address + ":" + Device.Port + "/" + subMgrUri.AbsolutePath);
xmlWriter.WriteEndElement(); // End Address
xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "ReferenceParameters", null);
xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Identifier", null);
xmlWriter.WriteString(eventSink.ID);
xmlWriter.WriteEndElement(); // End Identifier
xmlWriter.WriteEndElement(); // End ReferenceParameters
xmlWriter.WriteEndElement(); // End SubscriptionManager
xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Expires", null);
xmlWriter.WriteString(new WsDuration(eventSink.Expires).DurationString);
xmlWriter.WriteEndElement(); // End Expires
xmlWriter.WriteEndElement(); // End SubscribeResponse
smw.WriteSoapMessageEnd(xmlWriter);
// Return stream buffer
msg.Body = xmlWriter.ToArray();
}
return msg;
}
private void ImportFromReader(IDictionary personalizableProperties, Control target, XmlReader reader)
{
ImportReadTo(reader, "property");
bool flag = false;
if (this.UsePermitOnly)
{
this.MinimalPermissionSet.PermitOnly();
flag = true;
}
try
{
try
{
IDictionary dictionary;
if (personalizableProperties != null)
{
dictionary = new HybridDictionary();
}
else
{
dictionary = new PersonalizationDictionary();
}
while (reader.Name == "property")
{
string attribute = reader.GetAttribute("name");
string str2 = reader.GetAttribute("type");
string a = reader.GetAttribute("scope");
bool flag2 = string.Equals(reader.GetAttribute("null"), "true", StringComparison.OrdinalIgnoreCase);
if (((attribute == "AuthorizationFilter") || (attribute == "ZoneID")) || (attribute == "ZoneIndex"))
{
reader.ReadElementString();
if (!reader.Read())
{
throw new XmlException();
}
goto Label_03AA;
}
string s = reader.ReadElementString();
object obj2 = null;
bool flag3 = false;
PropertyInfo element = null;
if (personalizableProperties != null)
{
PersonalizablePropertyEntry entry = (PersonalizablePropertyEntry) personalizableProperties[attribute];
if (entry != null)
{
element = entry.PropertyInfo;
if ((Attribute.GetCustomAttribute(element, typeof(UrlPropertyAttribute), true) is UrlPropertyAttribute) && CrossSiteScriptingValidation.IsDangerousUrl(s))
{
throw new InvalidDataException(System.Web.SR.GetString("WebPart_BadUrl", new object[] { s }));
}
}
}
Type exportType = null;
if (!string.IsNullOrEmpty(str2))
{
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
this.MediumPermissionSet.PermitOnly();
flag = true;
}
exportType = GetExportType(str2);
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
this.MinimalPermissionSet.PermitOnly();
flag = true;
}
}
if ((element != null) && ((element.PropertyType == exportType) || (exportType == null)))
{
TypeConverterAttribute attribute2 = Attribute.GetCustomAttribute(element, typeof(TypeConverterAttribute), true) as TypeConverterAttribute;
if (attribute2 != null)
{
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
this.MediumPermissionSet.PermitOnly();
flag = true;
}
Type type = WebPartUtil.DeserializeType(attribute2.ConverterTypeName, false);
if (this.UsePermitOnly)
{
CodeAccessPermission.RevertPermitOnly();
flag = false;
this.MinimalPermissionSet.PermitOnly();
flag = true;
}
if ((type != null) && type.IsSubclassOf(typeof(TypeConverter)))
{
TypeConverter converter = (TypeConverter) this.Internals.CreateObjectFromType(type);
if (Util.CanConvertToFrom(converter, typeof(string)))
{
if (!flag2)
{
obj2 = converter.ConvertFromInvariantString(s);
}
flag3 = true;
}
}
}
if (!flag3)
{
TypeConverter converter2 = TypeDescriptor.GetConverter(element.PropertyType);
if (Util.CanConvertToFrom(converter2, typeof(string)))
{
if (!flag2)
{
obj2 = converter2.ConvertFromInvariantString(s);
}
flag3 = true;
}
}
}
if (!flag3 && (exportType != null))
{
if (exportType == typeof(string))
{
if (!flag2)
{
obj2 = s;
}
flag3 = true;
}
else
{
TypeConverter converter3 = TypeDescriptor.GetConverter(exportType);
if (Util.CanConvertToFrom(converter3, typeof(string)))
{
if (!flag2)
{
obj2 = converter3.ConvertFromInvariantString(s);
}
flag3 = true;
}
}
}
if (flag2 && (personalizableProperties == null))
{
flag3 = true;
}
if (flag3)
{
if (personalizableProperties != null)
{
dictionary.Add(attribute, obj2);
}
else
{
PersonalizationScope scope = string.Equals(a, PersonalizationScope.Shared.ToString(), StringComparison.OrdinalIgnoreCase) ? PersonalizationScope.Shared : PersonalizationScope.User;
dictionary.Add(attribute, new PersonalizationEntry(obj2, scope));
}
goto Label_03AA;
}
throw new HttpException(System.Web.SR.GetString("WebPartManager_ImportInvalidData", new object[] { attribute }));
Label_035C:
if (((reader.EOF || (reader.Name == "genericWebPartProperties")) || (reader.Name == "properties")) || ((reader.Name == "ipersonalizable") && (reader.NodeType == XmlNodeType.EndElement)))
{
break;
}
reader.Skip();
Label_03AA:
if (reader.Name != "property")
{
goto Label_035C;
}
}
if (personalizableProperties != null)
{
IDictionary unknownProperties = BlobPersonalizationState.SetPersonalizedProperties(target, dictionary);
if ((unknownProperties != null) && (unknownProperties.Count > 0))
{
IVersioningPersonalizable personalizable = target as IVersioningPersonalizable;
if (personalizable != null)
{
personalizable.Load(unknownProperties);
}
}
}
else
{
((IPersonalizable) target).Load((PersonalizationDictionary) dictionary);
}
}
finally
{
if (flag)
{
CodeAccessPermission.RevertPermitOnly();
}
}
}
catch
{
throw;
}
}
/// <summary>
/// Event renew stub.
/// </summary>
/// <param name="header">Header object.</param>
/// <param name="reader">An XmlReader positioned at the begining of the Renew request body element.</param>
/// <param name="serviceEndpoints">A Collection of serviceEndpoints used to determine what services contain the specified event.</param>
/// <returns>Byte array containing an Renew response.</returns>
/// <remarks>This method is used by the stack framework. Do not use this method.</remarks>
public WsMessage Renew(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints)
{
long newExpiration = 0;
String eventSinkId = String.Empty;
// Parse Renew request
////////////////////////////
try
{
reader.ReadStartElement("Renew", WsWellKnownUri.WseNamespaceUri);
if (reader.IsStartElement("Expires", WsWellKnownUri.WseNamespaceUri))
{
newExpiration = new WsDuration(reader.ReadElementString()).DurationInSeconds;
if (newExpiration <= 0)
{
throw new WsFaultException(header, WsFaultType.WseInvalidExpirationTime);
}
}
else
{
// Never Expires
newExpiration = -1;
}
eventSinkId = header.Any.GetNodeValue("Identifier", WsWellKnownUri.WseNamespaceUri);
if (eventSinkId == null)
{
throw new XmlException();
}
}
catch (XmlException e)
{
throw new WsFaultException(header, WsFaultType.WseInvalidMessage, e.ToString());
}
// Parse urn:uuid from the To address
string endpointAddress = FixToAddress(header.To);
// Iterate the list of hosted services at the specified endpoint and renew each subscription
// with and event source that matches the eventSinkID
DpwsWseEventSink eventSink;
bool eventSinkFound = false;
DpwsHostedService endpoint = (DpwsHostedService)serviceEndpoints[endpointAddress];
if(endpoint != null)
{
if ((eventSink = GetEventSink(endpoint.EventSources, eventSinkId)) != null)
{
eventSinkFound = true;
// Update event sink expires time
eventSink.Expires = newExpiration;
}
}
// Generate Response
if (eventSinkFound)
return GetStatusResponse(header, newExpiration); // It's just like the GetStatus Response
throw new WsFaultException(header, WsFaultType.WseEventSourceUnableToProcess, "Subscription was not found. ID=" + eventSinkId);
}
void IXmlSerializable.ReadXml(XmlReader r) {
char[] value = null;
string isNull = r.GetAttribute("nil", XmlSchema.InstanceNamespace);
if (isNull != null && XmlConvert.ToBoolean(isNull)) {
// VSTFDevDiv# 479603 - SqlTypes read null value infinitely and never read the next value. Fix - Read the next value.
r.ReadElementString();
SetNull();
}
else {
value = r.ReadElementString().ToCharArray();
SetBuffer(value);
}
}
void IXmlSerializable.ReadXml(XmlReader r)
{
byte[] value = null;
string isNull = r.GetAttribute("nil", XmlSchema.InstanceNamespace);
if (isNull != null && XmlConvert.ToBoolean(isNull))
{
// Read the next value.
r.ReadElementString();
SetNull();
}
else
{
string base64 = r.ReadElementString();
if (base64 == null)
{
value = Array.Empty<byte>();
}
else
{
base64 = base64.Trim();
if (base64.Length == 0)
value = Array.Empty<byte>();
else
value = Convert.FromBase64String(base64);
}
}
SetBuffer(value);
}
