// Decompiled with JetBrains decompiler
// Type: Rei.Fs.Webdav.WebdavFs
// Assembly: Rei.Fs.Webdav, Version=1.13.2.18288, Culture=neutral, PublicKeyToken=null
// MVID: D30DD1E3-8520-48B5-AAE5-C87970350A82
// Assembly location: F:\Eigene Dateien\Dropbox\portable Collection\Progs\CarotDAV\Rei.Fs.Webdav.dll

using Microsoft.VisualBasic.CompilerServices;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Net;
using System.Net.Security;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Xml;

namespace Rei.Fs.Webdav
{
  public class WebdavFs : FsBase
  {
    public const string NameSpace_DAV = "DAV:";
    public const string NameSpace_urnmicrosoft = "urn:schemas-microsoft-com:";
    public const string DAV_CreationDate = "DAV:creationdate";
    public const string DAV_DisplayName = "DAV:displayname";
    public const string DAV_GetContentLanguage = "DAV:getcontentlanguage";
    public const string DAV_GetContentLength = "DAV:getcontentlength";
    public const string DAV_GetContentType = "DAV:getcontenttype";
    public const string DAV_GetETag = "DAV:getetag";
    public const string DAV_GetLastModified = "DAV:getlastmodified";
    public const string DAV_ResourceType = "DAV:resourcetype";
    public const string Microsoft_Win32CreationTime = "urn:schemas-microsoft-com:Win32CreationTime";
    public const string Microsoft_Win32LastModifiedTime = "urn:schemas-microsoft-com:Win32LastModifiedTime";
    public const string Microsoft_Win32LastAccessTime = "urn:schemas-microsoft-com:Win32LastAccessTime";
    public const string Microsoft_Win32FileAttribute = "urn:schemas-microsoft-com:Win32FileAttributes";
    private static string pDefClientName;
    private static FieldInfo WebHeader_InnerCollectionInfo;
    private static FieldInfo s_ModuleBindingInfo;
    private static FieldInfo m_StoreInfo;
    private static FieldInfo challengeCacheinfo;
    private static WebdavFs.WebDAVCredentialManager pCredentialPolicy;
    public bool UseDefaultCredential;
    public bool UsePreAuthentication_Basic;
    public bool UsePreAuthentication_WSSE;
    private string[] pAuthModules;
    public X509Certificate2Collection ClientCertificates;
    private bool UsePassportAuthentication;
    public SslProtocols DisableTlsVersions;
    public Encoding URIRequestEncoding;
    public Encoding URIResponseEncoding;
    public Encoding CredentialEncoding;
    public bool DontRequestGzip;
    public bool DontRequestDeflate;
    public bool RequestTranslatef;
    public bool DontExpect100;
    public bool SendEmptyPUT;
    public bool DontUpdateProperty;
    public bool UseFullUriInDestinationHeader;
    public string UploadCompression;
    public int MaxRedirection;
    public bool DontVerifyContentRange;
    public bool RedirectionCollectionOnly;
    public bool RemoveLastSlashOnMKCOL;
    public bool DisableUploadResume;
    public IWebProxy Proxy;
    public int ReadWriteTimeout;
    public int ConnectTimeout;
    private PassportAuthHelper pPassportAuthHelper;
    private string pLastAuthType;
    private List<ServicePoint> pServicePointList;
    private Uri pLastUri;

    static WebdavFs()
    {
      UriParserFixer.Register();
      AuthenticationManager.Register((IAuthenticationModule) new WsseClient());
      WebdavFs.pCredentialPolicy = new WebdavFs.WebDAVCredentialManager();
      AuthenticationManager.CredentialPolicy = (ICredentialPolicy) WebdavFs.pCredentialPolicy;
      WebdavFs.WebHeader_InnerCollectionInfo = typeof (WebHeaderCollection).GetField("m_InnerCollection", BindingFlags.Instance | BindingFlags.NonPublic);
      try
      {
        object obj = (object) null;
        IEnumerator registeredModules = AuthenticationManager.RegisteredModules;
        while (registeredModules.MoveNext())
        {
          if (Operators.CompareString(((IAuthenticationModule) registeredModules.Current).AuthenticationType, "Digest", false) == 0)
          {
            obj = (object) (IAuthenticationModule) registeredModules.Current;
            break;
          }
        }
        if (obj == null)
          throw new Exception("No digest authentication module");
        WebdavFs.s_ModuleBindingInfo = typeof (AuthenticationManager).GetField("s_ModuleBinding", BindingFlags.Static | BindingFlags.NonPublic);
        WebdavFs.m_StoreInfo = WebdavFs.s_ModuleBindingInfo.FieldType.GetField("m_Store", BindingFlags.Instance | BindingFlags.NonPublic);
        WebdavFs.challengeCacheinfo = obj.GetType().GetField("challengeCache", BindingFlags.Static | BindingFlags.NonPublic);
      }
      catch (Exception ex)
      {
        ProjectData.SetProjectError(ex);
        ProjectData.ClearProjectError();
      }
      Assembly executingAssembly = Assembly.GetExecutingAssembly();
      WebdavFs.pDefClientName = ((AssemblyProductAttribute) executingAssembly.GetCustomAttributes(typeof (AssemblyProductAttribute), false)[0]).Product + "/" + executingAssembly.GetName().Version.ToString(3);
    }

    internal static bool ShouldSendCredential(Uri challengeUri, WebRequest request, NetworkCredential credential, IAuthenticationModule authenticationModule)
    {
      string lower = authenticationModule.AuthenticationType.ToLower();
      ConnectionSetting connectionSetting = WebRequestCertificateValidationManager.GetConnectionSetting(request) as ConnectionSetting;
      if (connectionSetting == null)
        return false;
      string[] authModules = connectionSetting.AuthModules;
      if (authModules == null || authModules.Length == 0)
        return true;
      string[] strArray = authModules;
      int index = 0;
      while (index < strArray.Length)
      {
        if (Operators.CompareString(strArray[index].ToLower(), lower, false) == 0)
          return true;
        checked { ++index; }
      }
      return false;
    }

    public WebdavFs(ConnectionSetting setting)
      : base((ConnectionSettingBase) setting)
    {
      this.ClientName = WebdavFs.pDefClientName;
      this.ReadWriteTimeout = 10000;
      this.ConnectTimeout = 10000;
      this.URIRequestEncoding = Encoding.GetEncoding("utf-8");
      this.URIResponseEncoding = Encoding.GetEncoding("utf-8");
      this.CredentialEncoding = Encoding.GetEncoding("utf-8");
      this.AuthModules = new string[0];
      this.ClientCertificates = new X509Certificate2Collection();
      this.UploadCompression = "None";
      this.MaxRedirection = 2;
      this.pServicePointList = new List<ServicePoint>();
    }

    public string[] AuthModules
    {
      get
      {
        return this.pAuthModules;
      }
      set
      {
        if (value == null)
          value = new string[0];
        this.pAuthModules = value;
        int num1 = 0;
        int num2 = checked (this.pAuthModules.Length - 1);
        int index = num1;
        while (index <= num2)
        {
          if (Operators.CompareString(this.pAuthModules[index].ToUpper(), "Passport".ToUpper(), false) == 0)
          {
            this.UsePassportAuthentication = true;
            return;
          }
          checked { ++index; }
        }
        if (this.pAuthModules.Length == 0)
          this.UsePassportAuthentication = true;
        else
          this.UsePassportAuthentication = false;
      }
    }

    public PassportAuthHelper PassportAuth
    {
      get
      {
        if (this.pPassportAuthHelper == null)
        {
          this.pPassportAuthHelper = new PassportAuthHelper();
          this.pPassportAuthHelper.UserAgent = this.ClientName;
          this.pPassportAuthHelper.Proxy = this.Proxy;
          this.pPassportAuthHelper.ReadWriteTimeout = this.ReadWriteTimeout;
          this.pPassportAuthHelper.ConnectTimeout = this.ConnectTimeout;
          this.pPassportAuthHelper.CookieContainer = this.ConnectionSetting.CookieContainer;
          this.pPassportAuthHelper.GroupName = this.GroupName;
        }
        return this.pPassportAuthHelper;
      }
    }

    public string LastAuthType
    {
      get
      {
        return this.pLastAuthType;
      }
    }

    public override SecureType LastSecureType
    {
      get
      {
        if ((object) this.pLastUri != null && Operators.CompareString(this.pLastUri.Scheme, Uri.UriSchemeHttps, false) == 0)
          return this.ConnectionSetting.LastCertError == SslPolicyErrors.None ? SecureType.Secure : SecureType.Warning;
        return Operators.CompareString(this.LastAuthType.ToLowerInvariant(), "basic", false) == 0 ? SecureType.Warning : SecureType.None;
      }
    }

    public override FsAbility Ability
    {
      get
      {
        return this.DisableUploadResume ? FsAbility.AdvancedFs | FsAbility.Times | FsAbility.Lock | FsAbility.MoveOver | FsAbility.CopyOver | FsAbility.PartialRead | FsAbility.Property : FsAbility.All;
      }
    }

    public override void ResetConnection()
    {
      bool flag1 = true;
      List<ServicePoint>.Enumerator enumerator;
      try
      {
        enumerator = this.pServicePointList.GetEnumerator();
        while (enumerator.MoveNext())
        {
          ServicePoint current = enumerator.Current;
          try
          {
            flag1 &= current.CloseConnectionGroup(this.GroupName);
          }
          catch (Exception ex)
          {
            ProjectData.SetProjectError(ex);
            ProjectData.ClearProjectError();
          }
        }
      }
      finally
      {
        enumerator.Dispose();
      }
      this.pServicePointList.Clear();
      try
      {
        if (this.pPassportAuthHelper != null)
        {
          bool flag2 = flag1 & this.pPassportAuthHelper.ResetConnection();
        }
      }
      catch (Exception ex)
      {
        ProjectData.SetProjectError(ex);
        ProjectData.ClearProjectError();
      }
      base.ResetConnection();
    }

    public Uri HeadResource(Uri target)
    {
      int num = 0;
      string str = (string) null;
      WebdavFs.CheckUri(target);
      Uri uri = UriUtil.UriEncodeConvert(target, (Encoding) null, this.URIRequestEncoding);
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri);
        request.Method = "HEAD";
        request.ContentLength = 0L;
        if (str != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str);
        try
        {
          using (HttpWebResponse response = this.GetResponse(request, true))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(response))
              str = this.PassportAuth.GetPassportToken(response, this.UserName, this.Password);
            else if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri = new Uri(uri, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (!WebdavFs.CheckStatus(response))
                throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              return UriUtil.UriEncodeConvert(response.ResponseUri, this.URIResponseEncoding, (Encoding) null);
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(target, (Exception) simpleWebException);
            throw;
          }
        }
      }
    }

    public DavResourceOptions GetResourceOptions(Uri target)
    {
      int num = 0;
      string str = (string) null;
      WebdavFs.CheckUri(target);
      Uri uri = UriUtil.UriEncodeConvert(target, (Encoding) null, this.URIRequestEncoding);
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri);
        request.Method = "OPTIONS";
        if (str != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str);
        try
        {
          using (HttpWebResponse response = this.GetResponse(request, true))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(response))
              str = this.PassportAuth.GetPassportToken(response, this.UserName, this.Password);
            else if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri = new Uri(uri, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (!WebdavFs.CheckStatus(response))
                throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              return new DavResourceOptions(UriUtil.UriEncodeConvert(response.ResponseUri, this.URIResponseEncoding, (Encoding) null), response);
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(target, (Exception) simpleWebException);
            throw;
          }
        }
      }
    }

    public override ResourceInfo GetInfo(Uri targeturi)
    {
      WebdavFs.CheckUri(targeturi);
      return this.InnerGetInfo(targeturi, WebdavFs.DepthType.Depth_0)[0];
    }

    public override ResourceInfo GetInfo(ResourceId id)
    {
      return this.InnerGetInfo(id.Uri, WebdavFs.DepthType.Depth_0)[0];
    }

    public override ResourceInfo GetInfo(ResourceId parentid, string name)
    {
      return this.InnerGetInfo(UriUtil.CombineName(parentid.Uri, name), WebdavFs.DepthType.Depth_0)[0];
    }

    public override ResourceInfo[] GetEntries(ResourceId id)
    {
      List<ResourceInfo> info = this.InnerGetInfo(id.Uri, WebdavFs.DepthType.Depth_1);
      if (info.Count >= 1)
        info.RemoveAt(0);
      return info.ToArray();
    }

    public override ResourceInfo[] GetInfoAndEntries(ResourceId id)
    {
      return this.InnerGetInfo(id.Uri, WebdavFs.DepthType.Depth_1).ToArray();
    }

    public override ResourceInfo[] GetInfoAndEntries(Uri targeturi)
    {
      WebdavFs.CheckUri(targeturi);
      return this.InnerGetInfo(targeturi, WebdavFs.DepthType.Depth_1).ToArray();
    }

    public override ResourceInfo[] GetParentInfoAndEntries(ResourceId childid)
    {
      return this.InnerGetInfo(UriUtil.GetParent(childid.Uri), WebdavFs.DepthType.Depth_1).ToArray();
    }

    private List<ResourceInfo> InnerGetInfo(Uri target, WebdavFs.DepthType depth)
    {
      int num = 0;
      string str1 = (string) null;
      Uri uri = UriUtil.UriEncodeConvert(target, (Encoding) null, this.URIRequestEncoding);
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri);
        request.Method = "PROPFIND";
        string str2 = string.Empty;
        if (!this.DontRequestDeflate)
          str2 = "deflate";
        if (!this.DontRequestGzip)
        {
          if (str2.Length > 0)
            str2 += ", ";
          str2 += "gzip";
        }
        if (str2.Length > 0)
          request.Headers.Add(HttpRequestHeader.AcceptEncoding, str2);
        switch (depth)
        {
          case WebdavFs.DepthType.Depth_infinity:
            request.Headers.Add("Depth", "infinity");
            break;
          case WebdavFs.DepthType.Depth_0:
            request.Headers.Add("Depth", "0");
            break;
          case WebdavFs.DepthType.Depth_1:
            request.Headers.Add("Depth", "1");
            break;
        }
        request.ContentLength = 0L;
        if (str1 != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str1);
        try
        {
          using (HttpWebResponse response = this.GetResponse(request, true))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(response))
              str1 = this.PassportAuth.GetPassportToken(response, this.UserName, this.Password);
            else if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri = new Uri(uri, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (response.StatusCode != (HttpStatusCode) 207)
                throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              List<ResourceInfo> propfindResponse = this.ParsePROPFINDResponse(this.GetResponseBody(response), response.ResponseUri);
              if (this.RedirectionCollectionOnly && !propfindResponse[0].IsCollection)
                propfindResponse[0].Id = new ResourceId(target, (FsBase) this);
              return propfindResponse;
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(target, (Exception) simpleWebException);
            throw;
          }
        }
      }
    }

    public override ReturnedInfo CreateCollection(ResourceId parendid, string name)
    {
      Uri uri1 = UriUtil.AddLastSlash(UriUtil.CombineName(parendid.Uri, name));
      int num = 0;
      string str = (string) null;
      Uri uri2 = !this.RemoveLastSlashOnMKCOL ? UriUtil.UriEncodeConvert(uri1, (Encoding) null, this.URIRequestEncoding) : UriUtil.UriEncodeConvert(UriUtil.RemoveLastSlash(uri1), (Encoding) null, this.URIRequestEncoding);
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri2);
        request.Method = "MKCOL";
        request.ContentLength = 0L;
        if (str != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str);
        try
        {
          using (HttpWebResponse response = this.GetResponse(request, true))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(response))
              str = this.PassportAuth.GetPassportToken(response, this.UserName, this.Password);
            else if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri2 = new Uri(uri2, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (!WebdavFs.CheckStatus(response))
                throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              break;
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri2.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri2 = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(uri1, (Exception) simpleWebException);
            throw;
          }
        }
      }
      return (ReturnedInfo) new ResourceId(uri1, (FsBase) this);
    }

    public override void Delete(ResourceId id)
    {
      Uri uri1 = id.Uri;
      int num = 0;
      string str = (string) null;
      WebdavFs.CheckUri(uri1);
      Uri uri2 = UriUtil.UriEncodeConvert(uri1, (Encoding) null, this.URIRequestEncoding);
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri2);
        request.Method = "DELETE";
        if (str != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str);
        try
        {
          using (HttpWebResponse response = this.GetResponse(request, true))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(response))
              str = this.PassportAuth.GetPassportToken(response, this.UserName, this.Password);
            else if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri2 = new Uri(uri2, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (WebdavFs.CheckStatus(response))
                break;
              throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri2.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri2 = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(uri1, (Exception) simpleWebException);
            throw;
          }
        }
      }
    }

    public override ReturnedInfo Move(ResourceId id, ResourceId newparentid, string newname, bool overwrite)
    {
      if (newname == null)
        newname = UriUtil.GetLastName(id.Uri);
      Uri baseuri = (object) newparentid != null ? newparentid.Uri : UriUtil.GetParent(id.Uri);
      Uri uri1 = id.Uri;
      Uri target1 = UriUtil.CombineName(baseuri, newname);
      Uri uri2 = !UriUtil.EndWithSlash(uri1) ? UriUtil.RemoveLastSlash(target1) : UriUtil.AddLastSlash(target1);
      int num = 0;
      string str = (string) null;
      if (UriUtil.UriEquals(uri1, uri2, this.IsCaseSensitiveFs))
        throw new DestinationAlreadyExistsException(uri2);
      Uri uri3 = UriUtil.UriEncodeConvert(uri1, (Encoding) null, this.URIRequestEncoding);
      Uri target2 = UriUtil.UriEncodeConvert(uri2, (Encoding) null, this.URIRequestEncoding);
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri3);
        request.Method = "MOVE";
        if (this.UseFullUriInDestinationHeader)
          request.Headers.Add("Destination", target2.AbsoluteUri);
        else if (Operators.CompareString(UriUtil.GetAuthority(uri3), UriUtil.GetAuthority(target2), false) != 0)
          request.Headers.Add("Destination", target2.AbsoluteUri);
        else
          request.Headers.Add("Destination", target2.AbsolutePath);
        if (overwrite)
          request.Headers.Add("Overwrite", "T");
        else
          request.Headers.Add("Overwrite", "F");
        if (str != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str);
        try
        {
          using (HttpWebResponse response = this.GetResponse(request, true))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(response))
              str = this.PassportAuth.GetPassportToken(response, this.UserName, this.Password);
            else if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri3 = new Uri(uri3, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (!WebdavFs.CheckStatus(response))
                throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              break;
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri3.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri3 = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(uri1, (Exception) simpleWebException);
            if (simpleWebException.StatusCode == 412)
              throw new DestinationAlreadyExistsException(uri2, (Exception) simpleWebException);
            throw;
          }
        }
      }
      return (ReturnedInfo) new ResourceId(uri2, (FsBase) this);
    }

    public override ReturnedInfo Copy(ResourceId id, ResourceId newparentid, string newname, bool overwrite)
    {
      if (newname == null)
        newname = UriUtil.GetLastName(id.Uri);
      Uri baseuri = (object) newparentid != null ? newparentid.Uri : UriUtil.GetParent(id.Uri);
      Uri uri1 = id.Uri;
      Uri target1 = UriUtil.CombineName(baseuri, newname);
      Uri uri2 = !UriUtil.EndWithSlash(uri1) ? UriUtil.RemoveLastSlash(target1) : UriUtil.AddLastSlash(target1);
      int num = 0;
      string str = (string) null;
      WebdavFs.CheckUri(uri1);
      WebdavFs.CheckUri(uri2);
      if (UriUtil.UriEquals(uri1, uri2, this.IsCaseSensitiveFs))
        throw new DestinationAlreadyExistsException(uri2);
      Uri uri3 = UriUtil.UriEncodeConvert(uri1, (Encoding) null, this.URIRequestEncoding);
      Uri target2 = UriUtil.UriEncodeConvert(uri2, (Encoding) null, this.URIRequestEncoding);
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri3);
        request.Method = "COPY";
        if (this.UseFullUriInDestinationHeader)
          request.Headers.Add("Destination", target2.AbsoluteUri);
        else if (Operators.CompareString(UriUtil.GetAuthority(uri3), UriUtil.GetAuthority(target2), false) != 0)
          request.Headers.Add("Destination", target2.AbsoluteUri);
        else
          request.Headers.Add("Destination", target2.AbsolutePath);
        if (overwrite)
          request.Headers.Add("Overwrite", "T");
        else
          request.Headers.Add("Overwrite", "F");
        request.Headers.Add("Depth", "infinity");
        if (str != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str);
        try
        {
          using (HttpWebResponse response = this.GetResponse(request, true))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(response))
              str = this.PassportAuth.GetPassportToken(response, this.UserName, this.Password);
            else if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri3 = new Uri(uri3, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (!WebdavFs.CheckStatus(response))
                throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              break;
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri3.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri3 = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(uri1, (Exception) simpleWebException);
            if (simpleWebException.StatusCode == 412)
              throw new DestinationAlreadyExistsException(uri2, (Exception) simpleWebException);
            throw;
          }
        }
      }
      return (ReturnedInfo) new ResourceId(uri2, (FsBase) this);
    }

    public override ReturnedInfo SetResourceInfo(ResourceInfo info, ResourceInfo original)
    {
      if (this.DontUpdateProperty)
        return (ReturnedInfo) info;
      int num = 0;
      string str = (string) null;
      Uri uri1 = info.Id.Uri;
      WebdavFs.CheckUri(uri1);
      Uri uri2 = UriUtil.UriEncodeConvert(uri1, (Encoding) null, this.URIRequestEncoding);
      string proppatchRequest = WebdavFs.CreatePROPPATCHRequest(info, original);
      if (proppatchRequest == null)
        return (ReturnedInfo) info;
      byte[] bytes = Encoding.UTF8.GetBytes(proppatchRequest);
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri2);
        request.Method = "PROPPATCH";
        request.ContentType = "text/xml; charset=\"utf-8\"";
        request.ContentLength = (long) bytes.Length;
        if (str != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str);
        try
        {
          using (Stream requestStream = this.GetRequestStream(request))
            requestStream.Write(bytes, 0, bytes.Length);
          using (HttpWebResponse response = this.GetResponse(request, false))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(response))
              str = this.PassportAuth.GetPassportToken(response, this.UserName, this.Password);
            else if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri2 = new Uri(uri2, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (response.StatusCode != (HttpStatusCode) 207)
                throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              if (!WebdavFs.CheckPROPPATCHResponse(this.GetResponseBody(response)))
                throw new SimpleWebException("Cannot PROPPATCH", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              break;
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri2.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri2 = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(uri1, (Exception) simpleWebException);
            throw;
          }
        }
      }
      return (ReturnedInfo) info;
    }

    public override ReturnedInfo SetTimes(ResourceId id, DateTime lastmodifiedtime, DateTime creationtime, DateTime lastaccesstime)
    {
      if (DateTime.Compare(lastmodifiedtime, DateTime.MinValue) == 0 && DateTime.Compare(creationtime, DateTime.MinValue) == 0 && DateTime.Compare(lastaccesstime, DateTime.MinValue) == 0)
        throw new InvalidOperationException();
      Uri uri1 = id.Uri;
      if (this.DontUpdateProperty)
        return (ReturnedInfo) id;
      int num = 0;
      string str = (string) null;
      WebdavFs.CheckUri(uri1);
      Uri uri2 = UriUtil.UriEncodeConvert(uri1, (Encoding) null, this.URIRequestEncoding);
      StringBuilder stringBuilder = new StringBuilder();
      stringBuilder.Append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
      stringBuilder.Append("<D:propertyupdate xmlns:D=\"DAV:\" xmlns:Z=\"urn:schemas-microsoft-com:\">");
      stringBuilder.Append("<D:set><D:prop>");
      if (DateTime.Compare(creationtime, DateTime.MinValue) != 0)
      {
        stringBuilder.Append("<Z:Win32CreationTime>");
        stringBuilder.Append(creationtime.ToUniversalTime().ToString("r"));
        stringBuilder.Append("</Z:Win32CreationTime>");
      }
      if (DateTime.Compare(lastaccesstime, DateTime.MinValue) != 0)
      {
        stringBuilder.Append("<Z:Win32LastAccessTime>");
        stringBuilder.Append(lastaccesstime.ToUniversalTime().ToString("r"));
        stringBuilder.Append("</Z:Win32LastAccessTime>");
      }
      if (DateTime.Compare(lastmodifiedtime, DateTime.MinValue) != 0)
      {
        stringBuilder.Append("<Z:Win32LastModifiedTime>");
        stringBuilder.Append(lastmodifiedtime.ToUniversalTime().ToString("r"));
        stringBuilder.Append("</Z:Win32LastModifiedTime>");
      }
      stringBuilder.Append("</D:prop></D:set>");
      stringBuilder.Append("</D:propertyupdate>");
      byte[] bytes = Encoding.UTF8.GetBytes(stringBuilder.ToString());
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri2);
        request.Method = "PROPPATCH";
        request.ContentType = "text/xml; charset=\"utf-8\"";
        request.ContentLength = (long) bytes.Length;
        if (str != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str);
        try
        {
          using (Stream requestStream = this.GetRequestStream(request))
            requestStream.Write(bytes, 0, bytes.Length);
          using (HttpWebResponse response = this.GetResponse(request, false))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(response))
              str = this.PassportAuth.GetPassportToken(response, this.UserName, this.Password);
            else if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri2 = new Uri(uri2, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (response.StatusCode != (HttpStatusCode) 207)
                throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              if (!WebdavFs.CheckPROPPATCHResponse(this.GetResponseBody(response)))
                throw new SimpleWebException("Cannot PROPPATCH", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              break;
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri2.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri2 = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(uri1, (Exception) simpleWebException);
            throw;
          }
        }
      }
      return (ReturnedInfo) id;
    }

    public override Stream OpenRead(Uri targeturi)
    {
      Uri target = targeturi;
      long start = 0;
      long length = -1;
      return this.InnerOpenRead(target, ref start, ref length);
    }

    public override Stream OpenRead(ResourceId id, ref long start, ref long length)
    {
      if (start < 0L)
        throw new ArgumentOutOfRangeException(nameof (start));
      WebdavFs.CheckUri(id.Uri);
      return this.InnerOpenRead(id.Uri, ref start, ref length);
    }

    private Stream InnerOpenRead(Uri target, ref long start, ref long length)
    {
      WebdavFs.CheckUri(target);
      HttpWebResponse httpWebResponse = (HttpWebResponse) null;
      int num = 0;
      string str1 = (string) null;
      if (start < 0L && length < 0L)
        throw new ArgumentOutOfRangeException(nameof (start));
      if (length == 0L)
        throw new ArgumentOutOfRangeException(nameof (length));
      Uri uri = UriUtil.UriEncodeConvert(target, (Encoding) null, this.URIRequestEncoding);
      WebdavFs.ExtWebHeaderCollection headerCollection;
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri);
        request.Method = "GET";
        request.Accept = "*/*";
        if (this.RequestTranslatef)
          request.Headers.Add("Translate", "f");
        headerCollection = new WebdavFs.ExtWebHeaderCollection();
        if (start == 0L)
        {
          if (length >= 0L)
            headerCollection.Add("Range", "bytes=0-" + checked (start + length - 1L).ToString());
        }
        else if (start < 0L)
          headerCollection.Add("Range", "bytes=-" + length.ToString());
        else if (length < 0L)
          headerCollection.Add("Range", "bytes=" + start.ToString() + "-");
        else
          headerCollection.Add("Range", "bytes=" + start.ToString() + "-" + checked (start + length - 1L).ToString());
        if (headerCollection.Count > 0)
        {
          NameValueCollection nameValueCollection = (NameValueCollection) WebdavFs.WebHeader_InnerCollectionInfo.GetValue((object) request.Headers);
          try
          {
            foreach (object obj in (WebHeaderCollection) headerCollection)
            {
              string name = Conversions.ToString(obj);
              nameValueCollection.Add(name, headerCollection[name]);
            }
          }
          finally
          {
            IEnumerator enumerator;
            if (enumerator is IDisposable)
              (enumerator as IDisposable).Dispose();
          }
        }
        else
        {
          string str2 = string.Empty;
          if (!this.DontRequestDeflate)
            str2 = "deflate";
          if (!this.DontRequestGzip)
          {
            if (str2.Length > 0)
              str2 += ", ";
            str2 += "gzip";
          }
          if (str2.Length > 0)
            request.Headers.Add(HttpRequestHeader.AcceptEncoding, str2);
        }
        if (str1 != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str1);
        try
        {
          httpWebResponse = this.GetResponse(request, true);
          checked { ++num; }
          if (num > this.MaxRedirection)
          {
            httpWebResponse.Close();
            throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) httpWebResponse);
          }
          if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(httpWebResponse))
            str1 = this.PassportAuth.GetPassportToken(httpWebResponse, this.UserName, this.Password);
          else if (httpWebResponse.StatusCode >= HttpStatusCode.MultipleChoices)
          {
            if (httpWebResponse.StatusCode < HttpStatusCode.BadRequest)
            {
              httpWebResponse.Close();
              uri = new Uri(uri, httpWebResponse.Headers[HttpResponseHeader.Location]);
            }
            else
              break;
          }
          else
            break;
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (httpWebResponse != null)
            httpWebResponse.Close();
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(target, (Exception) simpleWebException);
            if (simpleWebException.StatusCode == 416)
              throw new InvalidRangeException((Exception) simpleWebException);
            throw;
          }
        }
      }
      if (!WebdavFs.CheckStatus(httpWebResponse))
      {
        SimpleWebException simpleWebException = new SimpleWebException("Unassumed " + httpWebResponse.Method + " response\r\nStatus: " + Conversions.ToString((int) httpWebResponse.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) httpWebResponse);
        httpWebResponse.Close();
        throw simpleWebException;
      }
      try
      {
        if (this.DontVerifyContentRange)
        {
          if (httpWebResponse.StatusCode != HttpStatusCode.PartialContent)
          {
            start = 0L;
            length = httpWebResponse.ContentLength;
          }
        }
        else if (httpWebResponse.Headers[HttpResponseHeader.ContentRange] == null)
        {
          if (httpWebResponse.StatusCode == HttpStatusCode.PartialContent)
            throw new InvalidServerResponseException("\"206 Partial Content\" MUST contain Content-Range Header.");
          start = 0L;
          length = httpWebResponse.ContentLength;
        }
        else
        {
          if (headerCollection.Count == 0)
            throw new InvalidServerResponseException("Unexpected Content-Range Header");
          FsBase.ParseContentRange(httpWebResponse.Headers[HttpResponseHeader.ContentRange], ref start, ref length, true);
        }
      }
      catch (InvalidServerResponseException ex)
      {
        ProjectData.SetProjectError((Exception) ex);
        InvalidServerResponseException responseException = ex;
        httpWebResponse.Close();
        throw new InvalidRangeException((Exception) responseException);
      }
      catch (Exception ex)
      {
        ProjectData.SetProjectError(ex);
        httpWebResponse.Close();
        throw;
      }
      Stream stream = (Stream) null;
      try
      {
        stream = httpWebResponse.GetResponseStream();
        if (httpWebResponse.Headers[HttpResponseHeader.ContentEncoding] != null)
        {
          string lower = httpWebResponse.Headers[HttpResponseHeader.ContentEncoding].ToLower();
          if (Operators.CompareString(lower, "gzip", false) == 0 || Operators.CompareString(lower, "x-gzip", false) == 0)
          {
            stream = (Stream) new GZipStream(stream, CompressionMode.Decompress);
            length = -1L;
          }
          else
          {
            if (Operators.CompareString(lower, "deflate", false) != 0)
              throw new InvalidServerResponseException("invalid content encoding");
            stream = (Stream) new ZlibStream(stream, CompressionMode.Decompress, false, true);
            length = -1L;
          }
        }
        return (Stream) new PartialStream(stream, length);
      }
      catch (Exception ex)
      {
        ProjectData.SetProjectError(ex);
        if (stream != null)
          stream.Close();
        throw;
      }
    }

    public override Stream OpenWrite(ResourceId parentid, string name, long length)
    {
      return this.InnerOpenWrite(UriUtil.CombineName(parentid.Uri, name), (string) null, length);
    }

    public override Stream OpenWriteOver(ResourceId id, long length)
    {
      return this.InnerOpenWrite(id.Uri, (string) null, length);
    }

    public override Stream OpenWriteResume(ResourceId id, ref long start, ref long length)
    {
      Uri uri = id.Uri;
      if (start < 0L)
        throw new ArgumentOutOfRangeException(nameof (start));
      if (length < 0L)
        throw new ArgumentOutOfRangeException(nameof (length));
      string contentrange;
      if (length < 0L)
        contentrange = "bytes " + start.ToString() + "-/*";
      else
        contentrange = "bytes " + start.ToString() + "-" + checked (start + length - 1L).ToString() + "/*";
      return this.InnerOpenWrite(uri, contentrange, length);
    }

    private Stream InnerOpenWrite(Uri target, string contentrange, long length)
    {
      int num = 0;
      string str = (string) null;
      WebdavFs.CheckUri(target);
      Uri uri = UriUtil.UriEncodeConvert(target, (Encoding) null, this.URIRequestEncoding);
      HttpWebRequest request1;
      Stream stream;
      while (true)
      {
        try
        {
          string lowerInvariant = this.LastAuthType.ToLowerInvariant();
          if (Operators.CompareString(lowerInvariant, "negotiate", false) == 0 || Operators.CompareString(lowerInvariant, "ntlm", false) == 0 || Operators.CompareString(lowerInvariant, "kerberos", false) == 0)
          {
            HttpWebRequest request2 = this.CreateRequest(uri);
            request2.Method = "PUT";
            request2.Headers.Add(HttpRequestHeader.Allow, "PUT");
            request2.ContentLength = 0L;
            request2.AllowWriteStreamBuffering = true;
            request2.PreAuthenticate = false;
            if (str != null)
              request2.Headers.Add(HttpRequestHeader.Authorization, str);
            using (HttpWebResponse response = this.GetResponse(request2, true))
            {
              checked { ++num; }
              if (num > this.MaxRedirection)
                throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              if (response.StatusCode >= HttpStatusCode.MultipleChoices)
              {
                if (response.StatusCode < HttpStatusCode.BadRequest)
                {
                  uri = new Uri(uri, response.Headers[HttpResponseHeader.Location]);
                  continue;
                }
              }
            }
            this.SendEmptyPUT = true;
            request1 = this.CreateRequest(uri);
            request1.PreAuthenticate = false;
            request1.UnsafeAuthenticatedConnectionSharing = true;
            request1.Credentials = (ICredentials) null;
          }
          else if (this.SendEmptyPUT)
          {
            HttpWebRequest request2 = this.CreateRequest(uri);
            request2.Method = "PUT";
            request2.Headers.Add(HttpRequestHeader.Allow, "PUT");
            request2.ContentLength = 0L;
            request2.AllowWriteStreamBuffering = true;
            request2.PreAuthenticate = true;
            if (str != null)
              request2.Headers.Add(HttpRequestHeader.Authorization, str);
            using (HttpWebResponse response = this.GetResponse(request2, true))
            {
              checked { ++num; }
              if (num > this.MaxRedirection)
                throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              if (this.UsePassportAuthentication && PassportAuthHelper.CheckPassportAuth(response))
              {
                str = this.PassportAuth.GetPassportToken(response, this.UserName, this.Password);
                continue;
              }
              if (response.StatusCode >= HttpStatusCode.MultipleChoices)
              {
                if (response.StatusCode < HttpStatusCode.BadRequest)
                {
                  uri = new Uri(uri, response.Headers[HttpResponseHeader.Location]);
                  continue;
                }
              }
            }
            this.SendEmptyPUT = true;
            request1 = this.CreateRequest(uri);
            request1.PreAuthenticate = true;
          }
          else
          {
            request1 = this.CreateRequest(uri);
            request1.PreAuthenticate = true;
          }
          request1.Method = "PUT";
          request1.AllowWriteStreamBuffering = false;
          if (Operators.CompareString(this.UploadCompression.ToLower(), "gzip", false) == 0)
          {
            request1.Headers.Add(HttpRequestHeader.ContentEncoding, "gzip");
            request1.SendChunked = true;
          }
          else if (Operators.CompareString(this.UploadCompression.ToLower(), "deflate", false) == 0)
          {
            request1.Headers.Add(HttpRequestHeader.ContentEncoding, "deflate");
            request1.SendChunked = true;
          }
          else if (length >= 0L)
            request1.ContentLength = length;
          else
            request1.SendChunked = true;
          request1.ContentType = "application/octet-stream";
          if (contentrange != null)
            request1.Headers.Add(HttpRequestHeader.ContentRange, contentrange);
          stream = this.GetRequestStream(request1);
          break;
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(target, (Exception) simpleWebException);
            if (simpleWebException.StatusCode == 416)
              throw new InvalidRangeException((Exception) simpleWebException);
            throw;
          }
        }
      }
      if (Operators.CompareString(this.UploadCompression.ToLower(), "gzip", false) == 0)
        stream = (Stream) new GZipStream(stream, CompressionMode.Compress, false);
      else if (Operators.CompareString(this.UploadCompression.ToLower(), "deflate", false) == 0)
        stream = (Stream) new ZlibStream(stream, CompressionMode.Compress);
      CloseNotifyStream closeNotifyStream;
      try
      {
        closeNotifyStream = new CloseNotifyStream(stream);
        closeNotifyStream.ClosingEvent += new EventHandler(this.WriteStream_Closing);
        closeNotifyStream.ClosedEvent += new EventHandler(this.WriteStream_Closed);
      }
      catch (Exception ex)
      {
        ProjectData.SetProjectError(ex);
        if (stream != null)
          stream.Close();
        throw;
      }
      closeNotifyStream.Tag = (object) new object[3]
      {
        (object) request1,
        (object) target,
        (object) new ResourceId(target, (FsBase) this)
      };
      return (Stream) closeNotifyStream;
    }

    public override ReturnedInfo CloseWrite(Stream st)
    {
      st.Close();
      return (ReturnedInfo) ((object[]) ((CloseNotifyStream) st).Tag)[2];
    }

    public override string GetLock(ResourceId id, string owner, int timeoutseconds, FsBase.LockScope scope)
    {
      Uri uri1 = id.Uri;
      int num = 0;
      string str = (string) null;
      WebdavFs.CheckUri(uri1);
      Uri uri2 = UriUtil.UriEncodeConvert(uri1, (Encoding) null, this.URIRequestEncoding);
      StringBuilder sb = new StringBuilder(200);
      StringWriter stringWriter = new StringWriter(sb);
      stringWriter.Write("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
      stringWriter.Write("<D:lockinfo xmlns:D=\"DAV:\">");
      stringWriter.Write("<D:lockscope>");
      if (scope == FsBase.LockScope.Exclusive)
        stringWriter.Write("<D:exclusive/>");
      else if (scope == FsBase.LockScope.Shared)
        stringWriter.Write("<D:shared/>");
      stringWriter.Write("</D:lockscope>");
      stringWriter.Write("<D:locktype>");
      stringWriter.Write("<D:write/>");
      stringWriter.Write("</D:locktype>");
      stringWriter.Write("<D:owner>");
      stringWriter.Write(owner);
      stringWriter.Write("</D:owner>");
      stringWriter.Write("</D:lockinfo>");
      stringWriter.Close();
      byte[] bytes = Encoding.UTF8.GetBytes(sb.ToString());
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri2);
        request.Method = "LOCK";
        request.ContentType = "text/xml; charset=\"utf-8\"";
        request.ContentLength = (long) bytes.Length;
        if (timeoutseconds > 0)
          request.Headers.Add("Timeout", "Second-" + timeoutseconds.ToString());
        if (str != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str);
        try
        {
          using (Stream requestStream = this.GetRequestStream(request))
            requestStream.Write(bytes, 0, bytes.Length);
          using (HttpWebResponse response = this.GetResponse(request, false))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri2 = new Uri(uri2, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (!WebdavFs.CheckStatus(response))
                throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              string header = response.Headers["Lock-Token"];
              if (header != null || header.Length == 0)
                throw new SimpleWebException("Invalid Lock Token", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
              return header;
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri2.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri2 = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(uri1, (Exception) simpleWebException);
            throw;
          }
        }
      }
    }

    public override void ReleaseLock(ResourceId id, string locktoken)
    {
      Uri uri1 = id.Uri;
      int num = 0;
      string str = (string) null;
      WebdavFs.CheckUri(uri1);
      Uri uri2 = UriUtil.UriEncodeConvert(uri1, (Encoding) null, this.URIRequestEncoding);
      while (true)
      {
        HttpWebRequest request = this.CreateRequest(uri2);
        request.Method = "UNLOCK";
        request.Headers.Add("Lock-Token", locktoken);
        if (str != null)
          request.Headers.Add(HttpRequestHeader.Authorization, str);
        try
        {
          using (HttpWebResponse response = this.GetResponse(request, true))
          {
            checked { ++num; }
            if (num > this.MaxRedirection)
              throw new SimpleWebException("Too many redirection", (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            if (response.StatusCode >= HttpStatusCode.MultipleChoices && response.StatusCode < HttpStatusCode.BadRequest)
            {
              uri2 = new Uri(uri2, response.Headers[HttpResponseHeader.Location]);
            }
            else
            {
              if (WebdavFs.CheckStatus(response))
                break;
              throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
            }
          }
        }
        catch (SimpleWebException ex)
        {
          ProjectData.SetProjectError((Exception) ex);
          SimpleWebException simpleWebException = ex;
          if (simpleWebException.Status == WebExceptionStatus.KeepAliveFailure)
            ProjectData.ClearProjectError();
          else if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
          {
            if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
              throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
            throw;
          }
          else if (simpleWebException.StatusCode == 401)
          {
            if (Operators.CompareString(simpleWebException.ResponseUri.AbsolutePath, uri2.AbsolutePath, false) == 0)
              throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
            uri2 = simpleWebException.ResponseUri;
            ProjectData.ClearProjectError();
          }
          else
          {
            if (simpleWebException.StatusCode == 404)
              throw new RemoteResourceNotFoundException(uri1, (Exception) simpleWebException);
            throw;
          }
        }
      }
    }

    private HttpWebRequest CreateRequest(Uri target)
    {
      ServicePointManager.SecurityProtocol = (SecurityProtocolType) (~this.DisableTlsVersions & FsBase.AvailableTlss());
      ServicePoint servicePoint = ServicePointManager.FindServicePoint(target, this.Proxy);
      if (!this.pServicePointList.Contains(servicePoint))
      {
        this.pServicePointList.Add(servicePoint);
        servicePoint.ConnectionLimit = 1;
        servicePoint.Expect100Continue = !this.DontExpect100;
      }
      HttpWebRequest httpWebRequest = (HttpWebRequest) WebRequest.Create(target);
      if (this.UseDefaultCredential)
      {
        httpWebRequest.UseDefaultCredentials = true;
      }
      else
      {
        httpWebRequest.UseDefaultCredentials = false;
        string userName = string.Empty;
        string password = string.Empty;
        string domain = string.Empty;
        if (this.UserName.Length > 0)
        {
          userName = this.UserName;
          password = this.Password;
          int length = userName.IndexOf('\\');
          if (length > 0)
          {
            domain = userName.Substring(0, length);
            userName = userName.Substring(checked (length + 1));
          }
        }
        if (this.UsePreAuthentication_Basic)
        {
          string s = userName + ":" + password;
          if (this.CredentialEncoding == null)
            httpWebRequest.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(s)));
          else
            httpWebRequest.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(this.CredentialEncoding.GetBytes(s)));
        }
        else if (this.UsePreAuthentication_WSSE)
        {
          httpWebRequest.Headers.Add("Authorization", "WSSE profile=\"UsernameToken\"");
          httpWebRequest.Headers.Add("X-WSSE", WsseClient.GetAuthString(new NetworkCredential(userName, password), this.CredentialEncoding));
        }
        else
          httpWebRequest.Credentials = domain.Length <= 0 ? (ICredentials) new NetworkCredential(userName, password) : (ICredentials) new NetworkCredential(userName, password, domain);
      }
      httpWebRequest.ConnectionGroupName = this.GroupName;
      httpWebRequest.UserAgent = this.ClientName;
      httpWebRequest.KeepAlive = true;
      httpWebRequest.PreAuthenticate = true;
      httpWebRequest.UnsafeAuthenticatedConnectionSharing = true;
      if (this.ClientCertificates.Count > 0)
        httpWebRequest.ClientCertificates = (X509CertificateCollection) this.ClientCertificates;
      httpWebRequest.Proxy = this.Proxy;
      httpWebRequest.ReadWriteTimeout = this.ReadWriteTimeout;
      httpWebRequest.Timeout = this.ConnectTimeout;
      httpWebRequest.CookieContainer = this.ConnectionSetting.CookieContainer;
      httpWebRequest.AllowAutoRedirect = false;
      this.pLastUri = httpWebRequest.RequestUri;
      this.ConnectionSetting.LastCertError = SslPolicyErrors.None;
      WebRequestCertificateValidationManager.Register((WebRequest) httpWebRequest, this.ConnectionSetting);
      return httpWebRequest;
    }

    private HttpWebResponse GetResponse(HttpWebRequest request, bool notreqstream)
    {
      string str = "";
      if (notreqstream)
      {
        string message = str + "\r\n> " + request.Method + " " + request.RequestUri.PathAndQuery + " HTTP/" + request.ProtocolVersion.ToString();
        try
        {
          foreach (object key in request.Headers.Keys)
          {
            string index = Conversions.ToString(key);
            if (Operators.CompareString(index.ToLower(), "authorization", false) == 0 && request.Headers[index].ToLower().StartsWith("basic"))
              message = message + "\r\n> " + index + ": Basic *****";
            else
              message = message + "\r\n> " + index + ": " + request.Headers[index];
          }
        }
        finally
        {
          IEnumerator enumerator;
          if (enumerator is IDisposable)
            (enumerator as IDisposable).Dispose();
        }
        this.OnLogMessage(message);
      }
      HttpWebResponse httpWebResponse1 = (HttpWebResponse) null;
      try
      {
        IAsyncResult response = request.BeginGetResponse((AsyncCallback) null, (object) null);
        if (!response.AsyncWaitHandle.WaitOne(this.ConnectTimeout, false))
        {
          try
          {
            request.Abort();
            httpWebResponse1 = (HttpWebResponse) request.EndGetResponse(response);
          }
          catch (WebException ex)
          {
            ProjectData.SetProjectError((Exception) ex);
            throw new WebException("Timeout", (Exception) null, WebExceptionStatus.Timeout, ex.Response);
          }
          throw new WebException("Timeout", (Exception) null, WebExceptionStatus.Timeout, (WebResponse) httpWebResponse1);
        }
        httpWebResponse1 = (HttpWebResponse) request.EndGetResponse(response);
        WebdavFs.FixDigestAuthDomain(request);
      }
      catch (WebException ex1)
      {
        ProjectData.SetProjectError((Exception) ex1);
        WebException ex2 = ex1;
        using (WebResponse response = ex2.Response)
        {
          this.CheckAuthType(request);
          string message = "AuthorizationMethod = " + this.LastAuthType + "\r\n" + ex2.ToString() + "\r\n";
          HttpWebResponse httpWebResponse2 = response as HttpWebResponse;
          if (httpWebResponse2 != null)
          {
            WebdavFs.FixDigestAuthDomain(request);
            message = message + "<HTTP/" + httpWebResponse2.ProtocolVersion.ToString() + " " + ((int) httpWebResponse2.StatusCode).ToString() + " " + httpWebResponse2.StatusDescription;
            try
            {
              foreach (object key in response.Headers.Keys)
              {
                string index = Conversions.ToString(key);
                message = message + "\r\n< " + index + ": " + response.Headers[index];
              }
            }
            finally
            {
              IEnumerator enumerator;
              if (enumerator is IDisposable)
                (enumerator as IDisposable).Dispose();
            }
          }
          this.OnLogMessage(message);
          string responsebody = (string) null;
          if (response != null)
          {
            try
            {
              using (StreamReader streamReader = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding("shift-jis")))
                responsebody = streamReader.ReadToEnd();
            }
            catch (Exception ex3)
            {
              ProjectData.SetProjectError(ex3);
              ProjectData.ClearProjectError();
            }
          }
          throw new SimpleWebException(ex2, responsebody);
        }
      }
      finally
      {
        WebRequestCertificateValidationManager.UnRegister((WebRequest) request);
      }
      this.CheckAuthType(request);
      string message1 = "AuthorizationMethod = " + this.LastAuthType + "\r\n" + "<HTTP/" + httpWebResponse1.ProtocolVersion.ToString() + " " + ((int) httpWebResponse1.StatusCode).ToString() + " " + httpWebResponse1.StatusDescription;
      try
      {
        foreach (object key in httpWebResponse1.Headers.Keys)
        {
          string index = Conversions.ToString(key);
          message1 = message1 + "\r\n< " + index + ": " + httpWebResponse1.Headers[index];
        }
      }
      finally
      {
        IEnumerator enumerator;
        if (enumerator is IDisposable)
          (enumerator as IDisposable).Dispose();
      }
      this.OnLogMessage(message1);
      return httpWebResponse1;
    }

    private Stream GetRequestStream(HttpWebRequest request)
    {
      string message1 = "" + "\r\n> " + request.Method + " " + request.RequestUri.PathAndQuery + " HTTP/" + request.ProtocolVersion.ToString();
      try
      {
        foreach (object key in request.Headers.Keys)
        {
          string index = Conversions.ToString(key);
          if (Operators.CompareString(index.ToLower(), "authorization", false) == 0 && request.Headers[index].ToLower().StartsWith("basic"))
            message1 = message1 + "\r\n> " + index + ": Basic *****";
          else
            message1 = message1 + "\r\n> " + index + ": " + request.Headers[index];
        }
      }
      finally
      {
        IEnumerator enumerator;
        if (enumerator is IDisposable)
          (enumerator as IDisposable).Dispose();
      }
      this.OnLogMessage(message1);
      Stream requestStream1;
      try
      {
        IAsyncResult requestStream2 = request.BeginGetRequestStream((AsyncCallback) null, (object) null);
        if (!requestStream2.AsyncWaitHandle.WaitOne(this.ConnectTimeout, false))
        {
          try
          {
            request.Abort();
            request.EndGetRequestStream(requestStream2);
          }
          catch (WebException ex)
          {
            ProjectData.SetProjectError((Exception) ex);
            throw new WebException("Timeout", (Exception) null, WebExceptionStatus.Timeout, ex.Response);
          }
          throw new WebException("Timeout", (Exception) null, WebExceptionStatus.Timeout, (WebResponse) null);
        }
        requestStream1 = request.EndGetRequestStream(requestStream2);
        WebdavFs.FixDigestAuthDomain(request);
      }
      catch (WebException ex1)
      {
        ProjectData.SetProjectError((Exception) ex1);
        WebException ex2 = ex1;
        using (WebResponse response = ex2.Response)
        {
          this.CheckAuthType(request);
          string message2 = "AuthorizationMethod = " + this.LastAuthType + "\r\n";
          HttpWebResponse httpWebResponse = response as HttpWebResponse;
          if (httpWebResponse != null)
          {
            WebdavFs.FixDigestAuthDomain(request);
            message2 = message2 + "<HTTP/" + httpWebResponse.ProtocolVersion.ToString() + " " + ((int) httpWebResponse.StatusCode).ToString() + " " + httpWebResponse.StatusDescription;
            try
            {
              foreach (object key in response.Headers.Keys)
              {
                string index = Conversions.ToString(key);
                message2 = message2 + "\r\n< " + index + ": " + response.Headers[index];
              }
            }
            finally
            {
              IEnumerator enumerator;
              if (enumerator is IDisposable)
                (enumerator as IDisposable).Dispose();
            }
          }
          this.OnLogMessage(message2);
          string responsebody = (string) null;
          if (response != null)
          {
            try
            {
              using (StreamReader streamReader = new StreamReader(response.GetResponseStream()))
                responsebody = streamReader.ReadToEnd();
            }
            catch (Exception ex3)
            {
              ProjectData.SetProjectError(ex3);
              ProjectData.ClearProjectError();
            }
          }
          WebRequestCertificateValidationManager.UnRegister((WebRequest) request);
          throw new SimpleWebException(ex2, responsebody);
        }
      }
      catch (Exception ex)
      {
        ProjectData.SetProjectError(ex);
        Exception exception = ex;
        WebRequestCertificateValidationManager.UnRegister((WebRequest) request);
        throw exception;
      }
      return requestStream1;
    }

    protected void WriteStream_Closing(object sender, EventArgs e)
    {
    }

    protected void WriteStream_Closed(object sender, EventArgs e)
    {
      object[] tag = (object[]) ((CloseNotifyStream) sender).Tag;
      HttpWebRequest request = (HttpWebRequest) tag[0];
      Uri uri = (Uri) tag[1];
      try
      {
        using (HttpWebResponse response = this.GetResponse(request, false))
        {
          if (!WebdavFs.CheckStatus(response))
            throw new SimpleWebException("Unassumed " + response.Method + " response\r\nStatus: " + Conversions.ToString((int) response.StatusCode), (Exception) null, WebExceptionStatus.ProtocolError, (WebResponse) response);
          this.GetResponseBody(response);
        }
      }
      catch (SimpleWebException ex)
      {
        ProjectData.SetProjectError((Exception) ex);
        SimpleWebException simpleWebException = ex;
        if (simpleWebException.Status == WebExceptionStatus.TrustFailure)
        {
          if (this.ConnectionSetting.LastCertError != SslPolicyErrors.None)
            throw new RemoteCertificateErrorException((Exception) simpleWebException, this.ConnectionSetting.LastCertError);
          throw;
        }
        else
        {
          if (simpleWebException.StatusCode == 401)
            throw new UnauthorizedException((Exception) simpleWebException, !this.UseDefaultCredential);
          if (simpleWebException.StatusCode == 404)
            throw new RemoteResourceNotFoundException(uri, (Exception) simpleWebException);
          throw;
        }
      }
    }

    private string GetResponseBody(HttpWebResponse res)
    {
      int length1 = res.ContentType.IndexOf(";");
      string lower;
      string target;
      if (length1 < 0)
      {
        lower = res.ContentType.ToLower();
        target = "";
      }
      else
      {
        lower = res.ContentType.Substring(0, length1).ToLower();
        target = res.ContentType.Substring(checked (length1 + 1)).Trim();
      }
      int length2 = lower.IndexOf("/");
      string str1;
      string Left;
      if (length2 < 0)
      {
        str1 = lower.Trim();
        Left = "";
      }
      else
      {
        str1 = lower.Substring(0, length2).Trim();
        Left = lower.Substring(checked (length2 + 1)).Trim();
      }
      string str2 = str1 + "/" + Left;
      string str3 = "";
      int num1 = WebdavFs.IndexOfWithQuote(target, "charset", StringComparison.InvariantCultureIgnoreCase);
      if (num1 >= 0 && checked (num1 + 7) < target.Length)
      {
        string str4 = target.Substring(checked (num1 + 7)).Trim();
        if (Operators.CompareString(Conversions.ToString(str4[0]), "=", false) == 0)
        {
          string str5 = str4.Substring(1).Trim();
          if (Operators.CompareString(Conversions.ToString(str5[0]), "\"", false) == 0)
          {
            int num2 = str5.IndexOf("\"", 1);
            if (num2 < 0)
              num2 = str5.Length;
            str3 = str5.Substring(1, checked (num2 - 1));
          }
          else
            str3 = str5;
        }
      }
      Encoding encoding;
      if (Operators.CompareString(str3, "", false) != 0)
      {
        try
        {
          encoding = Encoding.GetEncoding(str3);
          goto label_19;
        }
        catch (Exception ex)
        {
          ProjectData.SetProjectError(ex);
          ProjectData.ClearProjectError();
        }
      }
      string name = "ISO-8859-1";
      if (Operators.CompareString(Left, "xml", false) == 0)
        name = "UTF-8";
      encoding = Encoding.GetEncoding(name);
label_19:
      return this.GetResponseBody(res, encoding);
    }

    private string GetResponseBody(HttpWebResponse res, Encoding encoding)
    {
      byte[] responseBodyInBytes = this.GetResponseBodyInBytes(res);
      encoding.GetString(responseBodyInBytes);
      string str = encoding.CodePage != 65001 || responseBodyInBytes.Length <= 3 || ((int) responseBodyInBytes[0] != 239 || (int) responseBodyInBytes[1] != 187) || (int) responseBodyInBytes[2] != 191 ? encoding.GetString(responseBodyInBytes) : encoding.GetString(responseBodyInBytes, 3, checked (responseBodyInBytes.Length - 3));
      this.OnLogMessage("<  [MESSAGEBODY LENGTH:" + str.Length.ToString() + "]");
      return str;
    }

    private byte[] GetResponseBodyInBytes(HttpWebResponse res)
    {
      Stream stream = res.GetResponseStream();
      List<byte[]> numArrayList = new List<byte[]>();
      List<int> intList = new List<int>();
      int num1;
      try
      {
        if (res.Headers[HttpResponseHeader.ContentEncoding] != null)
        {
          string lower = res.Headers[HttpResponseHeader.ContentEncoding].ToLower();
          if (Operators.CompareString(lower, "gzip", false) == 0 || Operators.CompareString(lower, "x-gzip", false) == 0)
            stream = (Stream) new GZipStream(stream, CompressionMode.Decompress);
          else if (Operators.CompareString(lower, "deflate", false) == 0)
            stream = (Stream) new ZlibStream(stream, CompressionMode.Decompress, false, true);
        }
        while (true)
        {
          byte[] buffer = new byte[4096];
          int num2 = stream.Read(buffer, 0, buffer.Length);
          if (num2 != 0)
          {
            intList.Add(num2);
            numArrayList.Add(buffer);
            checked { num1 += num2; }
          }
          else
            break;
        }
      }
      finally
      {
        stream.Close();
        res.Close();
      }
      byte[] numArray = new byte[checked (num1 - 1 + 1)];
      int destinationIndex = 0;
      int num3 = 0;
      int num4 = checked (numArrayList.Count - 1);
      int index = num3;
      while (index <= num4)
      {
        Array.Copy((Array) numArrayList[index], 0, (Array) numArray, destinationIndex, intList[index]);
        checked { destinationIndex += intList[index]; }
        checked { ++index; }
      }
      return numArray;
    }

    private static void CheckUri(Uri target)
    {
      if (!target.IsAbsoluteUri)
        throw new CannotProcessRequest(target, "Target URI is not absolute.");
      if (target.Fragment.Length > 0)
        throw new CannotProcessRequest(target, "Target URI cannot contain fragment.");
      if (target.UserInfo.Length > 0)
        throw new CannotProcessRequest(target, "Target URI cannot contain userinfo.");
      if (Operators.CompareString(target.Scheme, Uri.UriSchemeHttp, false) != 0 && Operators.CompareString(target.Scheme, Uri.UriSchemeHttps, false) != 0)
        throw new CannotProcessRequest(target, "Scheme of target Uri is not supported.");
    }

    private static bool CheckStatus(HttpWebResponse response)
    {
      return response.StatusCode >= HttpStatusCode.OK && response.StatusCode < HttpStatusCode.MultipleChoices && response.StatusCode != (HttpStatusCode) 207;
    }

    private static bool IsStatusOK(int statuscode)
    {
      return statuscode >= 200 && statuscode < 300;
    }

    private void CheckAuthType(HttpWebRequest req)
    {
      if (req.Headers[HttpRequestHeader.Authorization] == null)
      {
        this.pLastAuthType = "";
      }
      else
      {
        string header = req.Headers[HttpRequestHeader.Authorization];
        int length = header.IndexOf(' ');
        if (length < 0)
          this.pLastAuthType = "";
        else
          this.pLastAuthType = header.Substring(0, length);
      }
    }

    private List<ResourceInfo> ParsePROPFINDResponse(string message, Uri responseuri)
    {
      List<ResourceInfo> resourceInfoList = new List<ResourceInfo>();
      XmlDocument xmlDocument = new XmlDocument();
      try
      {
        xmlDocument.LoadXml(message);
      }
      catch (Exception ex)
      {
        ProjectData.SetProjectError(ex);
        Exception innerException = ex;
        throw new InvalidServerResponseException("Cannot Parse PROPFIND Response. Xml Error.", message, innerException);
      }
      XmlElement xmlElement = xmlDocument["multistatus", "DAV:"];
      if (xmlElement == null)
        throw new InvalidServerResponseException("Cannot Parse PROPFIND Response. No multistatus element.", message);
      try
      {
        foreach (XmlNode childNode in xmlElement.ChildNodes)
        {
          if (Operators.CompareString(childNode.LocalName, "response", false) == 0 && Operators.CompareString(childNode.NamespaceURI, "DAV:", false) == 0)
          {
            Uri result1 = (Uri) null;
            XmlNode xmlNode1 = (XmlNode) childNode["location", "DAV:"];
            if (xmlNode1 != null)
            {
              string innerText = xmlNode1["href", "DAV:"].InnerText;
              if (!Uri.TryCreate(innerText, UriKind.Absolute, out result1) && !Uri.TryCreate(responseuri, innerText, out result1))
                ;
            }
            if (childNode["propstat", "DAV:"] != null)
            {
              ResourceInfo resourceInfo = new ResourceInfo();
              try
              {
                foreach (XmlNode xmlNode2 in childNode)
                {
                  if (Operators.CompareString(xmlNode2.NamespaceURI, "DAV:", false) == 0)
                  {
                    if (Operators.CompareString(xmlNode2.LocalName, "href", false) == 0)
                    {
                      Uri result2 = (Uri) null;
                      if (!Uri.TryCreate(xmlNode2.InnerText, UriKind.Absolute, out result2) && !Uri.TryCreate(responseuri, xmlNode2.InnerText, out result2))
                        throw new InvalidServerResponseException("Cannot Parse PROPFIND Response. Cannot create URI from href element.", message);
                      result2 = UriUtil.UriEncodeConvert(result2, this.URIResponseEncoding, (Encoding) null);
                      if (Operators.CompareString(result2.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped), responseuri.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped), false) != 0)
                        result2 = new UriBuilder(result2)
                        {
                          Scheme = responseuri.Scheme,
                          Host = responseuri.Host,
                          Port = responseuri.Port
                        }.Uri;
                      resourceInfo.Id = new ResourceId(result2, (FsBase) this);
                    }
                    else if (Operators.CompareString(xmlNode2.LocalName, "propstat", false) == 0)
                    {
                      bool haserror;
                      string statedescription;
                      string str;
                      if (xmlNode2["status", "DAV:"] == null)
                      {
                        haserror = true;
                        statedescription = "No Status-Line";
                        str = "No Status-Line";
                        XmlNode xmlNode3 = (XmlNode) xmlNode2["error", "DAV:"];
                        if (xmlNode3 != null)
                          statedescription = statedescription + "\r\n" + xmlNode3.InnerText;
                        XmlNode xmlNode4 = (XmlNode) xmlNode2["responsedescription", "DAV:"];
                        if (xmlNode4 != null)
                          statedescription = statedescription + "\r\n" + xmlNode4.InnerText;
                      }
                      else
                      {
                        WebdavFs.Statusline statusline = new WebdavFs.Statusline(xmlNode2["status", "DAV:"].InnerText);
                        haserror = !statusline.IsStatusOK;
                        statedescription = statusline.StatusCode.ToString() + " " + statusline.StatusDescription;
                        str = statusline.ToString();
                        XmlNode xmlNode3 = (XmlNode) xmlNode2["error", "DAV:"];
                        if (xmlNode3 != null)
                          statedescription = statedescription + "\r\n" + xmlNode3.InnerText;
                        XmlNode xmlNode4 = (XmlNode) xmlNode2["responsedescription", "DAV:"];
                        if (xmlNode4 != null)
                          statedescription = statedescription + "\r\n" + xmlNode4.InnerText;
                      }
                      resourceInfo.HasError = resourceInfo.HasError || haserror;
                      resourceInfo.StatusDescription = resourceInfo.StatusDescription != null ? WebdavFs.Statusline.StatusHTTP11MultiStatus.ToString() : str;
                      try
                      {
                        foreach (XmlNode xmlNode3 in xmlNode2)
                        {
                          if (Operators.CompareString(xmlNode3.LocalName, "prop", false) == 0)
                          {
                            if (Operators.CompareString(xmlNode3.NamespaceURI, "DAV:", false) == 0)
                            {
                              try
                              {
                                foreach (XmlNode xmlNode4 in xmlNode3)
                                {
                                  string name = xmlNode4.LocalName;
                                  if (xmlNode4.NamespaceURI != null)
                                    name = xmlNode4.NamespaceURI + name;
                                  resourceInfo.Properties.Add(name, xmlNode4.InnerXml, statedescription, haserror);
                                }
                              }
                              finally
                              {
                                IEnumerator enumerator;
                                if (enumerator is IDisposable)
                                  (enumerator as IDisposable).Dispose();
                              }
                            }
                          }
                        }
                      }
                      finally
                      {
                        IEnumerator enumerator;
                        if (enumerator is IDisposable)
                          (enumerator as IDisposable).Dispose();
                      }
                    }
                  }
                }
              }
              finally
              {
                IEnumerator enumerator;
                if (enumerator is IDisposable)
                  (enumerator as IDisposable).Dispose();
              }
              if ((object) resourceInfo.Id != null)
              {
                resourceInfo.IsCollection = resourceInfo.Id.IsCollection;
                resourceInfoList.Add(resourceInfo);
              }
            }
            else
            {
              bool flag;
              string str1;
              string str2;
              if (childNode["status", "DAV:"] == null)
              {
                flag = true;
                string str3 = "No Status-Line";
                str1 = "No Status-Line";
                XmlNode xmlNode2 = (XmlNode) childNode["error", "DAV:"];
                if (xmlNode2 != null)
                  str3 = str3 + "\r\n" + xmlNode2.InnerText;
                XmlNode xmlNode3 = (XmlNode) childNode["responsedescription", "DAV:"];
                if (xmlNode3 != null)
                  str2 = str3 + "\r\n" + xmlNode3.InnerText;
              }
              else
              {
                WebdavFs.Statusline statusline = new WebdavFs.Statusline(childNode["status", "DAV:"].InnerText);
                flag = !statusline.IsStatusOK;
                string str3 = statusline.StatusCode.ToString() + " " + statusline.StatusDescription;
                str1 = statusline.ToString();
                XmlNode xmlNode2 = (XmlNode) childNode["error", "DAV:"];
                if (xmlNode2 != null)
                  str3 = str3 + "\r\n" + xmlNode2.InnerText;
                XmlNode xmlNode3 = (XmlNode) childNode["responsedescription", "DAV:"];
                if (xmlNode3 != null)
                  str2 = str3 + "\r\n" + xmlNode3.InnerText;
              }
              try
              {
                foreach (XmlNode xmlNode2 in childNode)
                {
                  if (Operators.CompareString(xmlNode2.LocalName, "href", false) == 0 && Operators.CompareString(xmlNode2.NamespaceURI, "DAV:", false) == 0)
                  {
                    ResourceInfo resourceInfo = new ResourceInfo();
                    Uri result2 = (Uri) null;
                    if (!Uri.TryCreate(xmlNode2.InnerText, UriKind.Absolute, out result2) && !Uri.TryCreate(responseuri, xmlNode2.InnerText, out result2))
                      throw new InvalidServerResponseException("Cannot Parse PROPFIND Response. Cannot create URI from href element.", message);
                    result2 = UriUtil.UriEncodeConvert(result2, this.URIResponseEncoding, (Encoding) null);
                    if (Operators.CompareString(result2.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped), responseuri.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped), false) != 0)
                      result2 = new UriBuilder(result2)
                      {
                        Scheme = responseuri.Scheme,
                        Host = responseuri.Host,
                        Port = responseuri.Port
                      }.Uri;
                    resourceInfo.Id = new ResourceId(result2, (FsBase) this);
                    resourceInfo.HasError = resourceInfo.HasError || flag;
                    resourceInfo.StatusDescription = str1;
                    resourceInfoList.Add(resourceInfo);
                  }
                }
              }
              finally
              {
                IEnumerator enumerator;
                if (enumerator is IDisposable)
                  (enumerator as IDisposable).Dispose();
              }
            }
          }
        }
      }
      finally
      {
        IEnumerator enumerator;
        if (enumerator is IDisposable)
          (enumerator as IDisposable).Dispose();
      }
      if (resourceInfoList.Count == 0)
        throw new InvalidServerResponseException("Cannot Parse PROPFIND Response. No response element.", message);
      int num1 = 1;
      int num2 = checked (resourceInfoList.Count - 1);
      int index1 = num1;
      while (index1 <= num2)
      {
        if (resourceInfoList[index1].Id.Uri.Segments.Length < resourceInfoList[0].Id.Uri.Segments.Length)
        {
          ResourceInfo resourceInfo = resourceInfoList[0];
          resourceInfoList[0] = resourceInfoList[index1];
          resourceInfoList[index1] = resourceInfo;
        }
        checked { ++index1; }
      }
      List<ResourceInfo>.Enumerator enumerator1;
      try
      {
        enumerator1 = resourceInfoList.GetEnumerator();
        while (enumerator1.MoveNext())
        {
          ResourceInfo current = enumerator1.Current;
          int index2 = current.Properties.IndexOf("DAV:getcontentlength");
          long result1;
          current.Size = index2 < 0 || current.Properties[index2].HasError || !long.TryParse(current.Properties[index2].Value, out result1) ? -1L : result1;
          int index3 = current.Properties.IndexOf("urn:schemas-microsoft-com:Win32LastModifiedTime");
          DateTime result2;
          if (index3 >= 0 && !current.Properties[index3].HasError && DateTime.TryParse(current.Properties[index3].Value, out result2))
          {
            current.LastModifiedTime = result2;
          }
          else
          {
            int index4 = current.Properties.IndexOf("DAV:getlastmodified");
            if (index4 >= 0 && !current.Properties[index4].HasError && DateTime.TryParse(current.Properties[index4].Value, out result2))
              current.LastModifiedTime = result2;
          }
          int index5 = current.Properties.IndexOf("urn:schemas-microsoft-com:Win32CreationTime");
          if (index5 >= 0 && !current.Properties[index5].HasError && DateTime.TryParse(current.Properties[index5].Value, out result2))
          {
            current.CreationTime = result2;
          }
          else
          {
            int index4 = current.Properties.IndexOf("DAV:creationdate");
            if (index4 >= 0 && !current.Properties[index4].HasError && DateTime.TryParse(current.Properties[index4].Value, out result2))
              current.CreationTime = result2;
          }
          int index6 = current.Properties.IndexOf("urn:schemas-microsoft-com:Win32LastAccessTime");
          if (index6 >= 0 && !current.Properties[index6].HasError && DateTime.TryParse(current.Properties[index6].Value, out result2))
            current.LastAccessTime = result2;
          XmlReaderSettings settings = new XmlReaderSettings();
          XmlParserContext inputContext = (XmlParserContext) null;
          settings.ConformanceLevel = ConformanceLevel.Fragment;
          int index7 = current.Properties.IndexOf("DAV:resourcetype");
          if (index7 >= 0 && !current.Properties[index7].HasError)
          {
            if (current.Properties[index7].Value.Length > 0)
            {
              try
              {
                bool flag = false;
                using (XmlReader xmlReader = XmlReader.Create((TextReader) new StringReader(current.Properties[index7].Value), settings, inputContext))
                {
                  while (xmlReader.Read())
                  {
                    if (xmlReader.NodeType == XmlNodeType.Element && Operators.CompareString(xmlReader.LocalName, "collection", false) == 0 && Operators.CompareString(xmlReader.NamespaceURI, "DAV:", false) == 0)
                      flag = true;
                  }
                }
                current.IsCollection = flag;
              }
              catch (Exception ex)
              {
                ProjectData.SetProjectError(ex);
                ProjectData.ClearProjectError();
              }
              current.Types.Sort();
            }
          }
          if (current.IsCollection)
          {
            if (!UriUtil.EndWithSlash(current.Id.Uri))
              current.Id = new ResourceId(UriUtil.AddLastSlash(current.Id.Uri), (FsBase) this);
          }
          else if (UriUtil.EndWithSlash(current.Id.Uri))
            current.Id = new ResourceId(UriUtil.RemoveLastSlash(current.Id.Uri), (FsBase) this);
          current.CanCopy = true;
          current.CanDelete = true;
          current.CanMove = true;
          current.CanRename = true;
          current.CanSetInfo = true;
        }
      }
      finally
      {
        enumerator1.Dispose();
      }
      return resourceInfoList;
    }

    private static bool CheckPROPPATCHResponse(string message)
    {
      XmlDocument xmlDocument = new XmlDocument();
      try
      {
        xmlDocument.LoadXml(message);
      }
      catch (Exception ex)
      {
        ProjectData.SetProjectError(ex);
        Exception innerException = ex;
        throw new InvalidServerResponseException("Cannot Parse PROPFIND Response. Xml Error.", message, innerException);
      }
      XmlElement xmlElement = xmlDocument["multistatus", "DAV:"];
      if (xmlElement == null)
        throw new InvalidServerResponseException("Cannot Parse PROPFIND Response. No multistatus element.", message);
      try
      {
        foreach (XmlNode childNode in xmlElement.ChildNodes)
        {
          if (Operators.CompareString(childNode.LocalName, "response", false) == 0 && Operators.CompareString(childNode.NamespaceURI, "DAV:", false) == 0)
          {
            if (childNode["propstat", "DAV:"] != null)
            {
              try
              {
                foreach (XmlNode xmlNode in childNode)
                {
                  if (Operators.CompareString(xmlNode.LocalName, "propstat", false) == 0 && Operators.CompareString(xmlNode.NamespaceURI, "DAV:", false) == 0 && xmlNode["status", "DAV:"] != null)
                  {
                    string innerText = xmlNode["status", "DAV:"].InnerText;
                    int result;
                    if (innerText.Length < 12 || !int.TryParse(innerText.Substring(9, 3), out result) || result < 200 | result >= 300)
                      return false;
                  }
                }
              }
              finally
              {
                IEnumerator enumerator;
                if (enumerator is IDisposable)
                  (enumerator as IDisposable).Dispose();
              }
            }
            else if (childNode["status", "DAV:"] != null)
            {
              string str = "";
              string innerText = childNode["status", "DAV:"].InnerText;
              int result;
              if (innerText.Length < 12 || !int.TryParse(innerText.Substring(9, 3), out result) || result < 200 | result >= 300)
                return false;
              str = childNode["status", "DAV:"].InnerText;
            }
          }
        }
      }
      finally
      {
        IEnumerator enumerator;
        if (enumerator is IDisposable)
          (enumerator as IDisposable).Dispose();
      }
      return true;
    }

    private static string CreatePROPPATCHRequest(ResourceInfo newinfo, ResourceInfo originalinfo)
    {
      StringBuilder stringBuilder = new StringBuilder();
      bool flag = false;
      stringBuilder.Append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
      stringBuilder.Append("<D:propertyupdate xmlns:D=\"DAV:\">\r\n");
      List<ResourceInfo.ResourceProperty>.Enumerator enumerator1;
      try
      {
        enumerator1 = newinfo.Properties.GetEnumerator();
        while (enumerator1.MoveNext())
        {
          ResourceInfo.ResourceProperty current = enumerator1.Current;
          int index = originalinfo.Properties.IndexOf(current.Name);
          if (index < 0 || Operators.CompareString(originalinfo.Properties[index].Value, current.Value, false) != 0)
          {
            int num = current.Name.LastIndexOf(":");
            string str1;
            string str2;
            if (num < 0)
            {
              str1 = current.Name;
              str2 = "";
            }
            else
            {
              str1 = "P:" + current.Name.Substring(checked (num + 1));
              str2 = " xmlns:P=\"" + current.Name.Substring(0, checked (num + 1)) + "\"";
            }
            stringBuilder.Append("<D:set><D:prop>\r\n");
            stringBuilder.Append("<" + str1 + str2 + ">");
            stringBuilder.Append(current.Value);
            stringBuilder.Append("</" + str1 + ">");
            stringBuilder.Append("</D:prop></D:set>\r\n");
            flag = true;
          }
        }
      }
      finally
      {
        enumerator1.Dispose();
      }
      List<ResourceInfo.ResourceProperty>.Enumerator enumerator2;
      try
      {
        enumerator2 = originalinfo.Properties.GetEnumerator();
        while (enumerator2.MoveNext())
        {
          ResourceInfo.ResourceProperty current = enumerator2.Current;
          if (newinfo.Properties.IndexOf(current.Name) < 0)
          {
            int num = current.Name.LastIndexOf(":");
            string str1;
            string str2;
            if (num < 0)
            {
              str1 = current.Name;
              str2 = "";
            }
            else
            {
              str1 = "P:" + current.Name.Substring(checked (num + 1));
              str2 = " xmlns:P=\"" + current.Name.Substring(0, checked (num + 1)) + "\"";
            }
            stringBuilder.Append("<D:remove><D:prop>\r\n");
            stringBuilder.Append("<" + str1 + str2 + ">");
            stringBuilder.Append(current.Value);
            stringBuilder.Append("</" + str1 + ">");
            stringBuilder.Append("</D:prop></D:remove>\r\n");
            flag = true;
          }
        }
      }
      finally
      {
        enumerator2.Dispose();
      }
      stringBuilder.Append("</D:propertyupdate>");
      if (!flag)
        return (string) null;
      return stringBuilder.ToString();
    }

    private static int IndexOfWithQuote(string target, string value, StringComparison comparisontype)
    {
      int startIndex = 0;
      int length = target.Length;
      do
      {
        int num1 = target.IndexOf("\"");
        if (num1 < 0)
          num1 = length;
        int num2 = target.Substring(startIndex, checked (num1 - startIndex)).IndexOf(value, comparisontype);
        if (num2 >= 0)
          return num2;
        if (checked (num1 + 1) >= length)
          return -1;
        startIndex = target.IndexOf("\"", checked (num1 + 1));
      }
      while (startIndex >= 0 && checked (startIndex + 1) < length);
      return -1;
    }

    private static void FixDigestAuthDomain(HttpWebRequest request)
    {
      string[] challenges = WebRequestCertificateValidationManager.GetChallenges((WebRequest) request);
      List<string[]> strArrayList = new List<string[]>();
      string[] strArray1 = challenges;
      int index1 = 0;
      while (index1 < strArray1.Length)
      {
        string[] values = new WebHeaderCollection()
        {
          {
            HttpResponseHeader.WwwAuthenticate,
            strArray1[index1]
          }
        }.GetValues(0);
        int index2 = 0;
        while (index2 < values.Length)
        {
          string str1 = values[index2];
          if (str1.Length > 7 && Operators.CompareString(str1.Substring(0, 7).ToLowerInvariant(), "digest ", false) == 0)
          {
            int startIndex1 = 7;
            while (startIndex1 < str1.Length)
            {
              while (startIndex1 < str1.Length && (int) str1[startIndex1] == 32)
                checked { ++startIndex1; }
              int index3 = checked (startIndex1 + 1);
              while (index3 < str1.Length && (int) str1[index3] != 61)
                checked { ++index3; }
              string Left = str1.Substring(startIndex1, checked (index3 - startIndex1)).Trim();
              int startIndex2 = checked (index3 + 1);
              while (startIndex2 < str1.Length && (int) str1[startIndex2] == 32)
                checked { ++startIndex2; }
              string str2;
              if ((int) str1[startIndex2] == 34)
              {
                int startIndex3 = checked (startIndex2 + 1);
                int num = str1.IndexOf('"', startIndex3);
                if (num < 0)
                  num = str1.Length;
                str2 = str1.Substring(startIndex3, checked (num - startIndex3));
                startIndex1 = checked (num + 1);
              }
              else
              {
                int index4 = checked (startIndex2 + 1);
                while (index4 < str1.Length && (int) str1[index4] != 32)
                  checked { ++index4; }
                str2 = str1.Substring(startIndex2, checked (index4 - startIndex2));
                startIndex1 = checked (index4 + 1);
              }
              if (Operators.CompareString(Left, "domain", false) == 0)
              {
                string[] strArray2 = str2.Split(new char[1]
                {
                  ' '
                }, StringSplitOptions.RemoveEmptyEntries);
                int num1 = 0;
                int num2 = checked (strArray2.Length - 1);
                int index4 = num1;
                while (index4 <= num2)
                {
                  Uri result = (Uri) null;
                  if (Uri.TryCreate(request.RequestUri, strArray2[index4], out result))
                    strArrayList.Add(new string[2]
                    {
                      result.AbsoluteUri,
                      strArray2[index4]
                    });
                  checked { ++index4; }
                }
                break;
              }
            }
          }
          checked { ++index2; }
        }
        checked { ++index1; }
      }
      if (strArrayList.Count <= 0)
        return;
      object objectValue1 = RuntimeHelpers.GetObjectValue(WebdavFs.s_ModuleBindingInfo.GetValue((object) null));
      object objectValue2 = RuntimeHelpers.GetObjectValue(WebdavFs.challengeCacheinfo.GetValue((object) null));
      Hashtable hashtable1 = (Hashtable) WebdavFs.m_StoreInfo.GetValue(RuntimeHelpers.GetObjectValue(objectValue1));
      Hashtable hashtable2 = (Hashtable) WebdavFs.m_StoreInfo.GetValue(RuntimeHelpers.GetObjectValue(objectValue2));
      int num3 = 0;
      int num4 = checked (strArrayList.Count - 1);
      int index5 = num3;
      while (index5 <= num4)
      {
        object Expression = objectValue1;
        ObjectFlowControl.CheckForSyncLockOnValueType(Expression);
        Monitor.Enter(Expression);
        try
        {
          lock (hashtable1)
          {
            hashtable1[(object) strArrayList[index5][0]] = RuntimeHelpers.GetObjectValue(hashtable1[(object) strArrayList[index5][1]]);
            hashtable1.Remove((object) strArrayList[index5][1]);
          }
        }
        finally
        {
          Monitor.Exit(Expression);
        }
        lock (hashtable2)
        {
          hashtable2[(object) strArrayList[index5][0]] = RuntimeHelpers.GetObjectValue(hashtable2[(object) strArrayList[index5][1]]);
          hashtable2.Remove((object) strArrayList[index5][1]);
        }
        checked { ++index5; }
      }
    }

    internal class WebDAVCredentialManager : ICredentialPolicy
    {
      public bool ShouldSendCredential(Uri challengeUri, WebRequest request, NetworkCredential credential, IAuthenticationModule authenticationModule)
      {
        return WebdavFs.ShouldSendCredential(challengeUri, request, credential, authenticationModule);
      }
    }

    private class ExtWebHeaderCollection : WebHeaderCollection
    {
      public override void Add(string name, string value)
      {
        this.AddWithoutValidate(name, value);
      }

      public override void GetObjectData(SerializationInfo serializationInfo, StreamingContext streamingContext)
      {
        serializationInfo.AddValue("Count", this.Count);
        int num1 = 0;
        int num2 = checked (this.Count - 1);
        int index = num1;
        while (index <= num2)
        {
          serializationInfo.AddValue(index.ToString((IFormatProvider) NumberFormatInfo.InvariantInfo), (object) this.GetKey(index));
          serializationInfo.AddValue(checked (index + this.Count).ToString((IFormatProvider) NumberFormatInfo.InvariantInfo), (object) this.Get(index));
          checked { ++index; }
        }
      }
    }

    private class Statusline
    {
      public static WebdavFs.Statusline StatusHTTP11OK = new WebdavFs.Statusline("HTTP/1.1 200 OK");
      public static WebdavFs.Statusline StatusHTTP11MultiStatus = new WebdavFs.Statusline("HTTP/1.1 207 Multi-Status");
      private const string HTTPStatuslineHeader = "HTTP/";
      private int _statuscode;
      private Version _version;
      private string _description;

      public Statusline(string line)
      {
        line = line.Trim();
        if (Operators.CompareString(line.Substring(0, 5), "HTTP/", false) != 0)
          throw new ArgumentException();
        this._version = new Version(line.Substring(5, 3));
        this._statuscode = int.Parse(line.Substring(9, 3));
        if (line.Length < 14)
          this._description = "";
        else
          this._description = line.Substring(13).Trim();
      }

      public Statusline(HttpWebResponse response)
      {
        this._version = (Version) response.ProtocolVersion.Clone();
        this._statuscode = (int) response.StatusCode;
        this._description = response.StatusDescription;
      }

      public Version ProtocolVersion
      {
        get
        {
          return this._version;
        }
      }

      public int StatusCode
      {
        get
        {
          return this._statuscode;
        }
      }

      public string StatusDescription
      {
        get
        {
          return this._description;
        }
      }

      public bool IsStatusOK
      {
        get
        {
          return this._statuscode >= 200 && this._statuscode < 300;
        }
      }

      public override string ToString()
      {
        return string.Join(" ", new string[3]
        {
          "HTTP/" + this._version.ToString(),
          this._statuscode.ToString(),
          this._description
        });
      }
    }

    private enum DepthType
    {
      Depth_infinity = -1,
      Depth_0 = 0,
      Depth_1 = 1,
    }
  }
}