jellyfin/Emby.Common.Implementations/IO/SharpCifs/Smb/SmbFile.cs

// This code is derived from jcifs smb client library <jcifs at samba dot org>
// Ported by J. Arturo <webmaster at komodosoft dot net>
//  
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Text;
using SharpCifs.Dcerpc;
using SharpCifs.Dcerpc.Msrpc;
using SharpCifs.Netbios;
using SharpCifs.Util;
using SharpCifs.Util.Sharpen;
using System.Threading.Tasks;

namespace SharpCifs.Smb
{
    /// <summary>This class represents a resource on an SMB network.</summary>
    /// <remarks>
    /// This class represents a resource on an SMB network. Mainly these
    /// resources are files and directories however an <code>SmbFile</code>
    /// may also refer to servers and workgroups. If the resource is a file or
    /// directory the methods of <code>SmbFile</code> follow the behavior of
    /// the well known
    /// <see cref="FilePath">Sharpen.FilePath</see>
    /// class. One fundamental difference
    /// is the usage of a URL scheme [1] to specify the target file or
    /// directory. SmbFile URLs have the following syntax:
    /// <blockquote><pre>
    /// smb://[[[domain;]username[:password]@]server[:port]/[[share/[dir/]file]]][?[param=value[param2=value2[...]]]
    /// </pre></blockquote>
    /// This example:
    /// <blockquote><pre>
    /// smb://storage15/public/foo.txt
    /// </pre></blockquote>
    /// would reference the file <code>foo.txt</code> in the share
    /// <code>public</code> on the server <code>storage15</code>. In addition
    /// to referencing files and directories, jCIFS can also address servers,
    /// and workgroups.
    /// <p>
    /// <font color="#800000"><i>Important: all SMB URLs that represent
    /// workgroups, servers, shares, or directories require a trailing slash '/'.
    /// </i></font>
    /// <p>
    /// When using the <tt>java.net.URL</tt> class with
    /// 'smb://' URLs it is necessary to first call the static
    /// <tt>jcifs.Config.registerSmbURLHandler();</tt> method. This is required
    /// to register the SMB protocol handler.
    /// <p>
    /// The userinfo component of the SMB URL (<tt>domain;user:pass</tt>) must
    /// be URL encoded if it contains reserved characters. According to RFC 2396
    /// these characters are non US-ASCII characters and most meta characters
    /// however jCIFS will work correctly with anything but '@' which is used
    /// to delimit the userinfo component from the server and '%' which is the
    /// URL escape character itself.
    /// <p>
    /// The server
    /// component may a traditional NetBIOS name, a DNS name, or IP
    /// address. These name resolution mechanisms and their resolution order
    /// can be changed (See <a href="../../../resolver.html">Setting Name
    /// Resolution Properties</a>). The servername and path components are
    /// not case sensitive but the domain, username, and password components
    /// are. It is also likely that properties must be specified for jcifs
    /// to function (See <a href="../../overview-summary.html#scp">Setting
    /// JCIFS Properties</a>). Here are some examples of SMB URLs with brief
    /// descriptions of what they do:
    /// <p>[1] This URL scheme is based largely on the <i>SMB
    /// Filesharing URL Scheme</i> IETF draft.
    /// <p><table border="1" cellpadding="3" cellspacing="0" width="100%">
    /// <tr bgcolor="#ccccff">
    /// <td colspan="2"><b>SMB URL Examples</b></td>
    /// <tr><td width="20%"><b>URL</b></td><td><b>Description</b></td></tr>
    /// <tr><td width="20%"><code>smb://users-nyc;miallen:mypass@angus/tmp/</code></td><td>
    /// This URL references a share called <code>tmp</code> on the server
    /// <code>angus</code> as user <code>miallen</code> who's password is
    /// <code>mypass</code>.
    /// </td></tr>
    /// <tr><td width="20%">
    /// <code>smb://Administrator:P%40ss@msmith1/c/WINDOWS/Desktop/foo.txt</code></td><td>
    /// A relativly sophisticated example that references a file
    /// <code>msmith1</code>'s desktop as user <code>Administrator</code>. Notice the '@' is URL encoded with the '%40' hexcode escape.
    /// </td></tr>
    /// <tr><td width="20%"><code>smb://angus/</code></td><td>
    /// This references only a server. The behavior of some methods is different
    /// in this context(e.g. you cannot <code>delete</code> a server) however
    /// as you might expect the <code>list</code> method will list the available
    /// shares on this server.
    /// </td></tr>
    /// <tr><td width="20%"><code>smb://myworkgroup/</code></td><td>
    /// This syntactically is identical to the above example. However if
    /// <code>myworkgroup</code> happends to be a workgroup(which is indeed
    /// suggested by the name) the <code>list</code> method will return
    /// a list of servers that have registered themselves as members of
    /// <code>myworkgroup</code>.
    /// </td></tr>
    /// <tr><td width="20%"><code>smb://</code></td><td>
    /// Just as <code>smb://server/</code> lists shares and
    /// <code>smb://workgroup/</code> lists servers, the <code>smb://</code>
    /// URL lists all available workgroups on a netbios LAN. Again,
    /// in this context many methods are not valid and return default
    /// values(e.g. <code>isHidden</code> will always return false).
    /// </td></tr>
    /// <tr><td width="20%"><code>smb://angus.foo.net/d/jcifs/pipes.doc</code></td><td>
    /// The server name may also be a DNS name as it is in this example. See
    /// <a href="../../../resolver.html">Setting Name Resolution Properties</a>
    /// for details.
    /// </td></tr>
    /// <tr><td width="20%"><code>smb://192.168.1.15/ADMIN$/</code></td><td>
    /// The server name may also be an IP address. See &lt;a
    /// href="../../../resolver.html"&gt;Setting Name Resolution Properties</a>
    /// for details.
    /// </td></tr>
    /// <tr><td width="20%">
    /// <code>smb://domain;username:password@server/share/path/to/file.txt</code></td><td>
    /// A prototypical example that uses all the fields.
    /// </td></tr>
    /// <tr><td width="20%"><code>smb://myworkgroup/angus/ &lt;-- ILLEGAL </code></td><td>
    /// Despite the hierarchial relationship between workgroups, servers, and
    /// filesystems this example is not valid.
    /// </td></tr>
    /// <tr><td width="20%">
    /// <code>smb://server/share/path/to/dir &lt;-- ILLEGAL </code></td><td>
    /// URLs that represent workgroups, servers, shares, or directories require a trailing slash '/'.
    /// </td></tr>
    /// <tr><td width="20%">
    /// <code>smb://MYGROUP/?SERVER=192.168.10.15</code></td><td>
    /// SMB URLs support some query string parameters. In this example
    /// the <code>SERVER</code> parameter is used to override the
    /// server name service lookup to contact the server 192.168.10.15
    /// (presumably known to be a master
    /// browser) for the server list in workgroup <code>MYGROUP</code>.
    /// </td></tr>
    /// </table>
    /// <p>A second constructor argument may be specified to augment the URL
    /// for better programmatic control when processing many files under
    /// a common base. This is slightly different from the corresponding
    /// <code>java.io.File</code> usage; a '/' at the beginning of the second
    /// parameter will still use the server component of the first parameter. The
    /// examples below illustrate the resulting URLs when this second contructor
    /// argument is used.
    /// <p><table border="1" cellpadding="3" cellspacing="0" width="100%">
    /// <tr bgcolor="#ccccff">
    /// <td colspan="3">
    /// <b>Examples Of SMB URLs When Augmented With A Second Constructor Parameter</b></td>
    /// <tr><td width="20%">
    /// <b>First Parameter</b></td><td><b>Second Parameter</b></td><td><b>Result</b></td></tr>
    /// <tr><td width="20%"><code>
    /// smb://host/share/a/b/
    /// </code></td><td width="20%"><code>
    /// c/d/
    /// </code></td><td><code>
    /// smb://host/share/a/b/c/d/
    /// </code></td></tr>
    /// <tr><td width="20%"><code>
    /// smb://host/share/foo/bar/
    /// </code></td><td width="20%"><code>
    /// /share2/zig/zag
    /// </code></td><td><code>
    /// smb://host/share2/zig/zag
    /// </code></td></tr>
    /// <tr><td width="20%"><code>
    /// smb://host/share/foo/bar/
    /// </code></td><td width="20%"><code>
    /// ../zip/
    /// </code></td><td><code>
    /// smb://host/share/foo/zip/
    /// </code></td></tr>
    /// <tr><td width="20%"><code>
    /// smb://host/share/zig/zag
    /// </code></td><td width="20%"><code>
    /// smb://foo/bar/
    /// </code></td><td><code>
    /// smb://foo/bar/
    /// </code></td></tr>
    /// <tr><td width="20%"><code>
    /// smb://host/share/foo/
    /// </code></td><td width="20%"><code>
    /// ../.././.././../foo/
    /// </code></td><td><code>
    /// smb://host/foo/
    /// </code></td></tr>
    /// <tr><td width="20%"><code>
    /// smb://host/share/zig/zag
    /// </code></td><td width="20%"><code>
    /// /
    /// </code></td><td><code>
    /// smb://host/
    /// </code></td></tr>
    /// <tr><td width="20%"><code>
    /// smb://server/
    /// </code></td><td width="20%"><code>
    /// ../
    /// </code></td><td><code>
    /// smb://server/
    /// </code></td></tr>
    /// <tr><td width="20%"><code>
    /// smb://
    /// </code></td><td width="20%"><code>
    /// myworkgroup/
    /// </code></td><td><code>
    /// smb://myworkgroup/
    /// </code></td></tr>
    /// <tr><td width="20%"><code>
    /// smb://myworkgroup/
    /// </code></td><td width="20%"><code>
    /// angus/
    /// </code></td><td><code>
    /// smb://myworkgroup/angus/ &lt;-- ILLEGAL<br />(But if you first create an <tt>SmbFile</tt> with 'smb://workgroup/' and use and use it as the first parameter to a constructor that accepts it with a second <tt>String</tt> parameter jCIFS will factor out the 'workgroup'.)
    /// </code></td></tr>
    /// </table>
    /// <p>Instances of the <code>SmbFile</code> class are immutable; that is,
    /// once created, the abstract pathname represented by an SmbFile object
    /// will never change.
    /// </remarks>
    /// <seealso cref="FilePath">Sharpen.FilePath</seealso>
    public class SmbFile : UrlConnection
    {
        public static void Initialize()
        {
            SmbTransport.ClearCachedConnections();
            SmbConstants.ApplyConfig();
        }



        internal const int ORdonly = 0x01;

        internal const int OWronly = 0x02;

        internal const int ORdwr = 0x03;

        internal const int OAppend = 0x04;

        internal const int OCreat = 0x0010;

        internal const int OExcl = 0x0020;

        internal const int OTrunc = 0x0040;

        /// <summary>
        /// When specified as the <tt>shareAccess</tt> constructor parameter,
        /// other SMB clients (including other threads making calls into jCIFS)
        /// will not be permitted to access the target file and will receive "The
        /// file is being accessed by another process" message.
        /// </summary>
        /// <remarks>
        /// When specified as the <tt>shareAccess</tt> constructor parameter,
        /// other SMB clients (including other threads making calls into jCIFS)
        /// will not be permitted to access the target file and will receive "The
        /// file is being accessed by another process" message.
        /// </remarks>
        public const int FileNoShare = 0x00;

        /// <summary>
        /// When specified as the <tt>shareAccess</tt> constructor parameter,
        /// other SMB clients will be permitted to read from the target file while
        /// this file is open.
        /// </summary>
        /// <remarks>
        /// When specified as the <tt>shareAccess</tt> constructor parameter,
        /// other SMB clients will be permitted to read from the target file while
        /// this file is open. This constant may be logically OR'd with other share
        /// access flags.
        /// </remarks>
        public const int FileShareRead = 0x01;

        /// <summary>
        /// When specified as the <tt>shareAccess</tt> constructor parameter,
        /// other SMB clients will be permitted to write to the target file while
        /// this file is open.
        /// </summary>
        /// <remarks>
        /// When specified as the <tt>shareAccess</tt> constructor parameter,
        /// other SMB clients will be permitted to write to the target file while
        /// this file is open. This constant may be logically OR'd with other share
        /// access flags.
        /// </remarks>
        public const int FileShareWrite = 0x02;

        /// <summary>
        /// When specified as the <tt>shareAccess</tt> constructor parameter,
        /// other SMB clients will be permitted to delete the target file while
        /// this file is open.
        /// </summary>
        /// <remarks>
        /// When specified as the <tt>shareAccess</tt> constructor parameter,
        /// other SMB clients will be permitted to delete the target file while
        /// this file is open. This constant may be logically OR'd with other share
        /// access flags.
        /// </remarks>
        public const int FileShareDelete = 0x04;

        /// <summary>
        /// A file with this bit on as returned by <tt>getAttributes()</tt> or set
        /// with <tt>setAttributes()</tt> will be read-only
        /// </summary>
        public const int AttrReadonly = 0x01;

        /// <summary>
        /// A file with this bit on as returned by <tt>getAttributes()</tt> or set
        /// with <tt>setAttributes()</tt> will be hidden
        /// </summary>
        public const int AttrHidden = 0x02;

        /// <summary>
        /// A file with this bit on as returned by <tt>getAttributes()</tt> or set
        /// with <tt>setAttributes()</tt> will be a system file
        /// </summary>
        public const int AttrSystem = 0x04;

        /// <summary>
        /// A file with this bit on as returned by <tt>getAttributes()</tt> is
        /// a volume
        /// </summary>
        public const int AttrVolume = 0x08;

        /// <summary>
        /// A file with this bit on as returned by <tt>getAttributes()</tt> is
        /// a directory
        /// </summary>
        public const int AttrDirectory = 0x10;

        /// <summary>
        /// A file with this bit on as returned by <tt>getAttributes()</tt> or set
        /// with <tt>setAttributes()</tt> is an archived file
        /// </summary>
        public const int AttrArchive = 0x20;

        internal const int AttrCompressed = 0x800;

        internal const int AttrNormal = 0x080;

        internal const int AttrTemporary = 0x100;

        internal const int AttrGetMask = 0x7FFF;

        internal const int AttrSetMask = 0x30A7;

        internal const int DefaultAttrExpirationPeriod = 5000;

        internal static readonly int HashDot = ".".GetHashCode();

        internal static readonly int HashDotDot = "..".GetHashCode();

        //internal static LogStream log = LogStream.GetInstance();
        public LogStream Log
        {
            get { return LogStream.GetInstance(); }
        }

        internal static long AttrExpirationPeriod;

        internal static bool IgnoreCopyToException;

        static SmbFile()
        {
            // Open Function Encoding
            // create if the file does not exist
            // fail if the file exists
            // truncate if the file exists
            // share access
            // file attribute encoding
            // extended file attribute encoding(others same as above)
            /*try
            {
                Sharpen.Runtime.GetType("jcifs.Config");
            }
            catch (TypeLoadException cnfe)
            {
                Sharpen.Runtime.PrintStackTrace(cnfe);
            }*/

            AttrExpirationPeriod
                = Config.GetLong("jcifs.smb.client.attrExpirationPeriod", DefaultAttrExpirationPeriod);
            IgnoreCopyToException
                = Config.GetBoolean("jcifs.smb.client.ignoreCopyToException", true);
            Dfs = new Dfs();
        }

        /// <summary>
        /// Returned by
        /// <see cref="GetType()">GetType()</see>
        /// if the resource this <tt>SmbFile</tt>
        /// represents is a regular file or directory.
        /// </summary>
        public const int TypeFilesystem = 0x01;

        /// <summary>
        /// Returned by
        /// <see cref="GetType()">GetType()</see>
        /// if the resource this <tt>SmbFile</tt>
        /// represents is a workgroup.
        /// </summary>
        public const int TypeWorkgroup = 0x02;

        /// <summary>
        /// Returned by
        /// <see cref="GetType()">GetType()</see>
        /// if the resource this <tt>SmbFile</tt>
        /// represents is a server.
        /// </summary>
        public const int TypeServer = 0x04;

        /// <summary>
        /// Returned by
        /// <see cref="GetType()">GetType()</see>
        /// if the resource this <tt>SmbFile</tt>
        /// represents is a share.
        /// </summary>
        public const int TypeShare = 0x08;

        /// <summary>
        /// Returned by
        /// <see cref="GetType()">GetType()</see>
        /// if the resource this <tt>SmbFile</tt>
        /// represents is a named pipe.
        /// </summary>
        public const int TypeNamedPipe = 0x10;

        /// <summary>
        /// Returned by
        /// <see cref="GetType()">GetType()</see>
        /// if the resource this <tt>SmbFile</tt>
        /// represents is a printer.
        /// </summary>
        public const int TypePrinter = 0x20;

        /// <summary>
        /// Returned by
        /// <see cref="GetType()">GetType()</see>
        /// if the resource this <tt>SmbFile</tt>
        /// represents is a communications device.
        /// </summary>
        public const int TypeComm = 0x40;

        private string _canon;

        private string _share;

        private long _createTime;

        private long _lastModified;

        private int _attributes;

        private long _attrExpiration;

        private long _size;

        private long _sizeExpiration;

        private bool _isExists;

        private int _shareAccess = FileShareRead | FileShareWrite | FileShareDelete;

        private bool _enableDfs = Config.GetBoolean("jcifs.smb.client.enabledfs", false);

        private SmbComBlankResponse _blankResp;

        private DfsReferral _dfsReferral;

        protected internal static Dfs Dfs;

        internal NtlmPasswordAuthentication Auth;

        internal SmbTree Tree;

        internal string Unc;

        internal int Fid;

        internal int Type;

        internal bool Opened;

        internal int TreeNum;

        public bool EnableDfs
        {
            get { return _enableDfs; }
            set { _enableDfs = value; }
        }

        /// <summary>
        /// Constructs an SmbFile representing a resource on an SMB network such as
        /// a file or directory.
        /// </summary>
        /// <remarks>
        /// Constructs an SmbFile representing a resource on an SMB network such as
        /// a file or directory. See the description and examples of smb URLs above.
        /// </remarks>
        /// <param name="url">A URL string</param>
        /// <exception cref="System.UriFormatException">
        /// If the <code>parent</code> and <code>child</code> parameters
        /// do not follow the prescribed syntax
        /// </exception>
        public SmbFile(string url)
            : this(new Uri(url))
        {
        }

        /// <summary>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory.
        /// </summary>
        /// <remarks>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory. The second parameter is a relative path from
        /// the <code>parent SmbFile</code>. See the description above for examples
        /// of using the second <code>name</code> parameter.
        /// </remarks>
        /// <param name="context">A base <code>SmbFile</code></param>
        /// <param name="name">A path string relative to the <code>parent</code> paremeter</param>
        /// <exception cref="System.UriFormatException">
        /// If the <code>parent</code> and <code>child</code> parameters
        /// do not follow the prescribed syntax
        /// </exception>
        /// <exception cref="UnknownHostException">If the server or workgroup of the <tt>context</tt> file cannot be determined
        /// </exception>
        public SmbFile(SmbFile context, string name)
            : this(context.IsWorkgroup0()
                    ? new Uri("smb://" + name)
                    : new Uri(context.Url.AbsoluteUri + name),
                   context.Auth)
        {
            this._enableDfs = context.EnableDfs;

            if (!context.IsWorkgroup0())
            {
                Addresses = context.Addresses;

                if (context._share != null)
                {
                    Tree = context.Tree;
                    _dfsReferral = context._dfsReferral;
                }
            }
        }

        /// <summary>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory.
        /// </summary>
        /// <remarks>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory. The second parameter is a relative path from
        /// the <code>parent</code>. See the description above for examples of
        /// using the second <code>chile</code> parameter.
        /// </remarks>
        /// <param name="context">A URL string</param>
        /// <param name="name">A path string relative to the <code>context</code> paremeter</param>
        /// <exception cref="System.UriFormatException">
        /// If the <code>context</code> and <code>name</code> parameters
        /// do not follow the prescribed syntax
        /// </exception>
        /*public SmbFile(string context, string name)
            : this(new Uri(new Uri(null, context), name))
        {
        }*/

        public SmbFile(string context, string name)
            : this(new Uri(context + name))
        {
        }


        /// <summary>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory.
        /// </summary>
        /// <remarks>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory.
        /// </remarks>
        /// <param name="url">A URL string</param>
        /// <param name="auth">The credentials the client should use for authentication</param>
        /// <exception cref="System.UriFormatException">If the <code>url</code> parameter does not follow the prescribed syntax
        /// </exception>
        public SmbFile(string url, NtlmPasswordAuthentication auth)
            : this(new Uri(url, UriKind.RelativeOrAbsolute), auth)
        {
        }

        /// <summary>Constructs an SmbFile representing a file on an SMB network.</summary>
        /// <remarks>
        /// Constructs an SmbFile representing a file on an SMB network. The
        /// <tt>shareAccess</tt> parameter controls what permissions other
        /// clients have when trying to access the same file while this instance
        /// is still open. This value is either <tt>FILE_NO_SHARE</tt> or any
        /// combination of <tt>FILE_SHARE_READ</tt>, <tt>FILE_SHARE_WRITE</tt>,
        /// and <tt>FILE_SHARE_DELETE</tt> logically OR'd together.
        /// </remarks>
        /// <param name="url">A URL string</param>
        /// <param name="auth">The credentials the client should use for authentication</param>
        /// <param name="shareAccess">Specifies what access other clients have while this file is open.
        /// </param>
        /// <exception cref="System.UriFormatException">If the <code>url</code> parameter does not follow the prescribed syntax
        /// </exception>
        public SmbFile(string url, NtlmPasswordAuthentication auth, int shareAccess)
            : this(new Uri(url), auth)
        {
            // Initially null; set by getUncPath; dir must end with '/'
            // Can be null
            // For getDfsPath() and getServerWithDfs()
            // Cannot be null
            // Initially null
            // Initially null; set by getUncPath; never ends with '/'
            // Initially 0; set by open()
            if ((shareAccess & ~(FileShareRead | FileShareWrite | FileShareDelete)) != 0)
            {
                throw new RuntimeException("Illegal shareAccess parameter");
            }
            this._shareAccess = shareAccess;
        }

        /// <summary>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory.
        /// </summary>
        /// <remarks>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory. The second parameter is a relative path from
        /// the <code>context</code>. See the description above for examples of
        /// using the second <code>name</code> parameter.
        /// </remarks>
        /// <param name="context">A URL string</param>
        /// <param name="name">A path string relative to the <code>context</code> paremeter</param>
        /// <param name="auth">The credentials the client should use for authentication</param>
        /// <exception cref="System.UriFormatException">
        /// If the <code>context</code> and <code>name</code> parameters
        /// do not follow the prescribed syntax
        /// </exception>
        public SmbFile(string context, string name, NtlmPasswordAuthentication auth)
            : this(new Uri(context + name), auth)
        {
        }


        /// <summary>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory.
        /// </summary>
        /// <remarks>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory. The second parameter is a relative path from
        /// the <code>context</code>. See the description above for examples of
        /// using the second <code>name</code> parameter. The <tt>shareAccess</tt>
        /// parameter controls what permissions other clients have when trying
        /// to access the same file while this instance is still open. This
        /// value is either <tt>FILE_NO_SHARE</tt> or any combination
        /// of <tt>FILE_SHARE_READ</tt>, <tt>FILE_SHARE_WRITE</tt>, and
        /// <tt>FILE_SHARE_DELETE</tt> logically OR'd together.
        /// </remarks>
        /// <param name="context">A URL string</param>
        /// <param name="name">A path string relative to the <code>context</code> paremeter</param>
        /// <param name="auth">The credentials the client should use for authentication</param>
        /// <param name="shareAccess">Specifies what access other clients have while this file is open.
        /// </param>
        /// <exception cref="System.UriFormatException">
        /// If the <code>context</code> and <code>name</code> parameters
        /// do not follow the prescribed syntax
        /// </exception>
        public SmbFile(string context,
                       string name,
                       NtlmPasswordAuthentication auth,
                       int shareAccess)
            : this(new Uri(context + name), auth)
        {
            if ((shareAccess & ~(FileShareRead | FileShareWrite | FileShareDelete)) != 0)
            {
                throw new RuntimeException("Illegal shareAccess parameter");
            }
            this._shareAccess = shareAccess;
        }

        /// <summary>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory.
        /// </summary>
        /// <remarks>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory. The second parameter is a relative path from
        /// the <code>context</code>. See the description above for examples of
        /// using the second <code>name</code> parameter. The <tt>shareAccess</tt>
        /// parameter controls what permissions other clients have when trying
        /// to access the same file while this instance is still open. This
        /// value is either <tt>FILE_NO_SHARE</tt> or any combination
        /// of <tt>FILE_SHARE_READ</tt>, <tt>FILE_SHARE_WRITE</tt>, and
        /// <tt>FILE_SHARE_DELETE</tt> logically OR'd together.
        /// </remarks>
        /// <param name="context">A base <code>SmbFile</code></param>
        /// <param name="name">A path string relative to the <code>context</code> file path</param>
        /// <param name="shareAccess">Specifies what access other clients have while this file is open.
        /// </param>
        /// <exception cref="System.UriFormatException">
        /// If the <code>context</code> and <code>name</code> parameters
        /// do not follow the prescribed syntax
        /// </exception>
        /// <exception cref="UnknownHostException"></exception>
        public SmbFile(SmbFile context, string name, int shareAccess)
            : this(context.IsWorkgroup0()
                        ? new Uri("smb://" + name)
                        : new Uri(context.Url.AbsoluteUri + name),
                   context.Auth)
        {
            if ((shareAccess & ~(FileShareRead | FileShareWrite | FileShareDelete)) != 0)
            {
                throw new RuntimeException("Illegal shareAccess parameter");
            }

            if (!context.IsWorkgroup0())
            {
                this.Addresses = context.Addresses;

                if (context._share != null || context.Tree != null)
                {
                    Tree = context.Tree;
                    _dfsReferral = context._dfsReferral;
                }
            }

            this._shareAccess = shareAccess;
            this._enableDfs = context.EnableDfs;
        }

        /// <summary>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory from a <tt>URL</tt> object.
        /// </summary>
        /// <remarks>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory from a <tt>URL</tt> object.
        /// </remarks>
        /// <param name="url">The URL of the target resource</param>
        protected SmbFile(Uri url)
            : this(url, new NtlmPasswordAuthentication(url.GetUserInfo()))
        {
        }

        /// <summary>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory from a <tt>URL</tt> object and an
        /// <tt>NtlmPasswordAuthentication</tt> object.
        /// </summary>
        /// <remarks>
        /// Constructs an SmbFile representing a resource on an SMB network such
        /// as a file or directory from a <tt>URL</tt> object and an
        /// <tt>NtlmPasswordAuthentication</tt> object.
        /// </remarks>
        /// <param name="url">The URL of the target resource</param>
        /// <param name="auth">The credentials the client should use for authentication</param>
        public SmbFile(Uri url, NtlmPasswordAuthentication auth)
        {
            this.Auth = auth ?? new NtlmPasswordAuthentication(url.GetUserInfo());
            Url = url;
            GetUncPath0();
        }

        /// <exception cref="System.UriFormatException"></exception>
        /// <exception cref="UnknownHostException"></exception>
        internal SmbFile(SmbFile context,
                         string name,
                         int type,
                         int attributes,
                         long createTime,
                         long lastModified,
                         long size)
            : this(context.IsWorkgroup0()
                        ? new Uri("smb://" + name + "/")
                        : new Uri(context.Url.AbsoluteUri + name + ((attributes & AttrDirectory) > 0
                                                                        ? "/"
                                                                        : string.Empty)))
        {
            Auth = context.Auth;
            if (context._share != null)
            {
                Tree = context.Tree;
                _dfsReferral = context._dfsReferral;
            }
            int last = name.Length - 1;
            if (name[last] == '/')
            {
                name = Runtime.Substring(name, 0, last);
            }
            if (context._share == null)
            {
                Unc = "\\";
            }
            else
            {
                if (context.Unc.Equals("\\"))
                {
                    Unc = '\\' + name;
                }
                else
                {
                    Unc = context.Unc + '\\' + name;
                }
            }

            if (!context.IsWorkgroup0())
            {
                Addresses = context.Addresses;
            }

            this._enableDfs = context.EnableDfs;

            this.Type = type;
            this._attributes = attributes;
            this._createTime = createTime;
            this._lastModified = lastModified;
            this._size = size;
            _isExists = true;
            _attrExpiration = _sizeExpiration = Runtime.CurrentTimeMillis() + AttrExpirationPeriod;
        }

        private SmbComBlankResponse Blank_resp()
        {
            if (_blankResp == null)
            {
                _blankResp = new SmbComBlankResponse();
            }
            return _blankResp;
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void ResolveDfs(ServerMessageBlock request)
        {
            if (!_enableDfs)
            {
                Connect0();
                return;
            }

            if (request is SmbComClose)
            {
                return;
            }
            Connect0();
            DfsReferral dr = Dfs.Resolve(Tree.Session.transport.TconHostName, Tree.Share, Unc, Auth);
            if (dr != null)
            {
                string service = null;
                if (request != null)
                {
                    switch (request.Command)
                    {
                        case ServerMessageBlock.SmbComTransaction:
                        case ServerMessageBlock.SmbComTransaction2:
                            {
                                switch (((SmbComTransaction)request).SubCommand & 0xFF)
                                {
                                    case SmbComTransaction.Trans2GetDfsReferral:
                                        {
                                            break;
                                        }

                                    default:
                                        {
                                            service = "A:";
                                            break;
                                        }
                                }
                                break;
                            }

                        default:
                            {
                                service = "A:";
                                break;
                            }
                    }
                }
                DfsReferral start = dr;
                SmbException se = null;
                do
                {
                    try
                    {
                        if (Log.Level >= 2)
                        {
                            Log.WriteLine("DFS redirect: " + dr);
                        }
                        UniAddress addr = UniAddress.GetByName(dr.Server);
                        SmbTransport trans = SmbTransport.GetSmbTransport(addr, Url.Port);
                        trans.Connect();
                        Tree = trans.GetSmbSession(Auth).GetSmbTree(dr.Share, service);
                        if (dr != start && dr.Key != null)
                        {
                            dr.Map.Put(dr.Key, dr);
                        }
                        se = null;
                        break;
                    }
                    catch (IOException ioe)
                    {
                        if (ioe is SmbException)
                        {
                            se = (SmbException)ioe;
                        }
                        else
                        {
                            se = new SmbException(dr.Server, ioe);
                        }
                    }
                    dr = dr.Next;
                }
                while (dr != start);
                if (se != null)
                {
                    throw se;
                }
                if (Log.Level >= 3)
                {
                    Log.WriteLine(dr);
                }
                _dfsReferral = dr;
                if (dr.PathConsumed < 0)
                {
                    dr.PathConsumed = 0;
                }
                else
                {
                    if (dr.PathConsumed > Unc.Length)
                    {
                        dr.PathConsumed = Unc.Length;
                    }
                }
                string dunc = Runtime.Substring(Unc, dr.PathConsumed);
                if (dunc.Equals(string.Empty))
                {
                    dunc = "\\";
                }
                if (!dr.Path.Equals(string.Empty))
                {
                    dunc = "\\" + dr.Path + dunc;
                }
                Unc = dunc;
                if (request != null
                    && request.Path != null
                    && request.Path.EndsWith("\\")
                    && dunc.EndsWith("\\") == false)
                {
                    dunc += "\\";
                }
                if (request != null)
                {
                    request.Path = dunc;
                    request.Flags2 |= SmbConstants.Flags2ResolvePathsInDfs;
                }
            }
            else
            {
                if (Tree.InDomainDfs
                    && !(request is NtTransQuerySecurityDesc)
                    && !(request is SmbComClose)
                    && !(request is SmbComFindClose2))
                {
                    throw new SmbException(NtStatus.NtStatusNotFound, false);
                }
                if (request != null)
                {
                    request.Flags2 &= ~SmbConstants.Flags2ResolvePathsInDfs;
                }
            }
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void Send(ServerMessageBlock request, ServerMessageBlock response)
        {
            for (;;)
            {
                ResolveDfs(request);
                try
                {
                    Tree.Send(request, response);
                    break;
                }
                catch (DfsReferral dre)
                {
                    if (dre.ResolveHashes)
                    {
                        throw;
                    }
                    request.Reset();
                }
            }
        }

        internal static string QueryLookup(string query, string param)
        {
            char[] instr = query.ToCharArray();
            int i;
            int ch;
            int st;
            int eq;
            st = eq = 0;
            for (i = 0; i < instr.Length; i++)
            {
                ch = instr[i];
                if (ch == '&')
                {
                    if (eq > st)
                    {
                        string p = new string(instr, st, eq - st);
                        if (Runtime.EqualsIgnoreCase(p, param))
                        {
                            eq++;
                            return new string(instr, eq, i - eq);
                        }
                    }
                    st = i + 1;
                }
                else
                {
                    if (ch == '=')
                    {
                        eq = i;
                    }
                }
            }
            if (eq > st)
            {
                string p = new string(instr, st, eq - st);
                if (Runtime.EqualsIgnoreCase(p, param))
                {
                    eq++;
                    return new string(instr, eq, instr.Length - eq);
                }
            }
            return null;
        }

        internal UniAddress[] Addresses;

        internal int AddressIndex;

        /// <exception cref="UnknownHostException"></exception>
        internal virtual UniAddress GetAddress()
        {
            if (AddressIndex == 0)
            {
                return GetFirstAddress();
            }
            return Addresses[AddressIndex - 1];
        }

        /// <exception cref="UnknownHostException"></exception>
        internal virtual UniAddress GetFirstAddress()
        {
            AddressIndex = 0;
            string host = Url.GetHost();
            string path = Url.AbsolutePath;
            string query = Url.GetQuery();

            if (Addresses != null && Addresses.Length > 0)
            {
                return GetNextAddress();
            }

            if (query != null)
            {
                string server = QueryLookup(query, "server");
                if (!string.IsNullOrEmpty(server))
                {
                    Addresses = new UniAddress[1];
                    Addresses[0] = UniAddress.GetByName(server);
                    return GetNextAddress();
                }
                string address = QueryLookup(query, "address");
                if (!string.IsNullOrEmpty(address))
                {
                    byte[] ip = Extensions.GetAddressByName(address).GetAddressBytes();
                    Addresses = new UniAddress[1];
                    //addresses[0] = new UniAddress(IPAddress.Parse(host, ip));
                    Addresses[0] = new UniAddress(IPAddress.Parse(host));
                    return GetNextAddress();
                }
            }
            if (host.Length == 0)
            {
                try
                {
                    NbtAddress addr = NbtAddress.GetByName(NbtAddress.MasterBrowserName, 0x01, null);
                    Addresses = new UniAddress[1];
                    Addresses[0] = UniAddress.GetByName(addr.GetHostAddress());
                }
                catch (UnknownHostException uhe)
                {
                    NtlmPasswordAuthentication.InitDefaults();
                    if (NtlmPasswordAuthentication.DefaultDomain.Equals("?"))
                    {
                        throw;
                    }
                    Addresses = UniAddress.GetAllByName(NtlmPasswordAuthentication.DefaultDomain,
                                                        true);
                }
            }
            else
            {
                if (path.Length == 0 || path.Equals("/"))
                {
                    Addresses = UniAddress.GetAllByName(host, true);
                }
                else
                {
                    Addresses = UniAddress.GetAllByName(host, false);
                }
            }
            return GetNextAddress();
        }

        internal virtual UniAddress GetNextAddress()
        {
            UniAddress addr = null;
            if (AddressIndex < Addresses.Length)
            {
                addr = Addresses[AddressIndex++];
            }
            return addr;
        }

        internal virtual bool HasNextAddress()
        {
            return AddressIndex < Addresses.Length;
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void Connect0()
        {
            try
            {
                Connect();
            }
            catch (UnknownHostException uhe)
            {
                throw new SmbException("Failed to connect to server", uhe);
            }
            catch (SmbException se)
            {
                throw;
            }
            catch (IOException ioe)
            {
                throw new SmbException("Failed to connect to server", ioe);
            }
        }

        /// <exception cref="System.IO.IOException"></exception>
        internal virtual void DoConnect()
        {
            SmbTransport trans;
            UniAddress addr;
            addr = GetAddress();

            if (Tree != null && Tree.Session.transport.Address.Equals(addr))
            {
                trans = Tree.Session.transport;
            }
            else
            {
                trans = SmbTransport.GetSmbTransport(addr, Url.Port);
                Tree = trans.GetSmbSession(Auth).GetSmbTree(_share, null);
            }


            string hostName = GetServerWithDfs();
            if (_enableDfs)
            {
                Tree.InDomainDfs = Dfs.Resolve(hostName, Tree.Share, null, Auth) != null;
            }
            if (Tree.InDomainDfs)
            {
                Tree.ConnectionState = 2;
            }
            try
            {
                if (Log.Level >= 3)
                {
                    Log.WriteLine("doConnect: " + addr);
                }
                Tree.TreeConnect(null, null);
            }
            catch (SmbAuthException sae)
            {
                NtlmPasswordAuthentication a;
                SmbSession ssn;
                if (_share == null)
                {
                    // IPC$ - try "anonymous" credentials
                    ssn = trans.GetSmbSession(NtlmPasswordAuthentication.Null);
                    Tree = ssn.GetSmbTree(null, null);
                    Tree.TreeConnect(null, null);
                }
                else
                {
                    if ((a = NtlmAuthenticator.RequestNtlmPasswordAuthentication(Url.ToString(), sae))
                        != null)
                    {
                        Auth = a;
                        ssn = trans.GetSmbSession(Auth);
                        Tree = ssn.GetSmbTree(_share, null);
                        Tree.InDomainDfs = Dfs.Resolve(hostName, Tree.Share, null, Auth) != null;
                        if (Tree.InDomainDfs)
                        {
                            Tree.ConnectionState = 2;
                        }
                        Tree.TreeConnect(null, null);
                    }
                    else
                    {
                        if (Log.Level >= 1 && HasNextAddress())
                        {
                            Runtime.PrintStackTrace(sae, Log);
                        }
                        throw;
                    }
                }
            }
        }

        /// <summary>It is not necessary to call this method directly.</summary>
        /// <remarks>
        /// It is not necessary to call this method directly. This is the
        /// <tt>URLConnection</tt> implementation of <tt>connect()</tt>.
        /// </remarks>
        /// <exception cref="System.IO.IOException"></exception>
        public void Connect()
        {
            SmbTransport trans;
            SmbSession ssn;
            UniAddress addr;
            if (IsConnected())
            {
                return;
            }
            GetUncPath0();
            GetFirstAddress();
            for (;;)
            {
                try
                {
                    DoConnect();
                    return;
                }
                catch (SmbAuthException sae)
                {
                    throw;
                }
                catch (SmbException se)
                {
                    // Prevents account lockout on servers with multiple IPs
                    if (GetNextAddress() == null)
                    {
                        throw;
                    }
                    else
                    {
                        RemoveCurrentAddress();
                    }

                    if (Log.Level >= 3)
                    {
                        Runtime.PrintStackTrace(se, Log);
                    }
                }
            }
        }

        internal virtual bool IsConnected()
        {
            return Tree != null && Tree.ConnectionState == 2;
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual int Open0(int flags, int access, int attrs, int options)
        {
            int f;
            Connect0();
            if (Log.Level >= 3)
            {
                Log.WriteLine("open0: " + Unc);
            }
            if (Tree.Session.transport.HasCapability(SmbConstants.CapNtSmbs))
            {
                SmbComNtCreateAndXResponse response = new SmbComNtCreateAndXResponse();
                SmbComNtCreateAndX request = new SmbComNtCreateAndX(Unc,
                                                                    flags,
                                                                    access,
                                                                    _shareAccess,
                                                                    attrs,
                                                                    options,
                                                                    null);
                if (this is SmbNamedPipe)
                {
                    request.Flags0 |= 0x16;
                    request.DesiredAccess |= 0x20000;
                    response.IsExtended = true;
                }
                Send(request, response);
                f = response.Fid;
                _attributes = response.ExtFileAttributes & AttrGetMask;
                _attrExpiration = Runtime.CurrentTimeMillis() + AttrExpirationPeriod;
                _isExists = true;
            }
            else
            {
                SmbComOpenAndXResponse response = new SmbComOpenAndXResponse();
                Send(new SmbComOpenAndX(Unc, access, flags, null), response);
                f = response.Fid;
            }
            return f;
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void Open(int flags, int access, int attrs, int options)
        {
            if (IsOpen())
            {
                return;
            }
            Fid = Open0(flags, access, attrs, options);
            Opened = true;
            TreeNum = Tree.TreeNum;
        }

        internal virtual bool IsOpen()
        {
            bool ans = Opened && IsConnected() && TreeNum == Tree.TreeNum;
            return ans;
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void Close(int f, long lastWriteTime)
        {
            if (Log.Level >= 3)
            {
                Log.WriteLine("close: " + f);
            }
            Send(new SmbComClose(f, lastWriteTime), Blank_resp());
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void Close(long lastWriteTime)
        {
            if (IsOpen() == false)
            {
                return;
            }
            Close(Fid, lastWriteTime);
            Opened = false;
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void Close()
        {
            Close(0L);
        }

        /// <summary>
        /// Returns the <tt>NtlmPasswordAuthentication</tt> object used as
        /// credentials with this file or pipe.
        /// </summary>
        /// <remarks>
        /// Returns the <tt>NtlmPasswordAuthentication</tt> object used as
        /// credentials with this file or pipe. This can be used to retrieve the
        /// username for example:
        /// <tt>
        /// String username = f.getPrincipal().getName();
        /// </tt>
        /// The <tt>Principal</tt> object returned will never be <tt>null</tt>
        /// however the username can be <tt>null</tt> indication anonymous
        /// credentials were used (e.g. some IPC$ services).
        /// </remarks>
        public virtual Principal GetPrincipal()
        {
            return Auth;
        }

        /// <summary>Returns the last component of the target URL.</summary>
        /// <remarks>
        /// Returns the last component of the target URL. This will
        /// effectively be the name of the file or directory represented by this
        /// <code>SmbFile</code> or in the case of URLs that only specify a server
        /// or workgroup, the server or workgroup will be returned. The name of
        /// the root URL <code>smb://</code> is also <code>smb://</code>. If this
        /// <tt>SmbFile</tt> refers to a workgroup, server, share, or directory,
        /// the name will include a trailing slash '/' so that composing new
        /// <tt>SmbFile</tt>s will maintain the trailing slash requirement.
        /// </remarks>
        /// <returns>
        /// The last component of the URL associated with this SMB
        /// resource or <code>smb://</code> if the resource is <code>smb://</code>
        /// itself.
        /// </returns>
        public virtual string GetName()
        {
            GetUncPath0();
            if (_canon.Length > 1)
            {
                int i = _canon.Length - 2;
                while (_canon[i] != '/')
                {
                    i--;
                }
                return Runtime.Substring(_canon, i + 1);
            }
            if (_share != null)
            {
                return _share + '/';
            }
            if (Url.GetHost().Length > 0)
            {
                return Url.GetHost() + '/';
            }
            return "smb://";
        }

        /// <summary>
        /// Everything but the last component of the URL representing this SMB
        /// resource is effectivly it's parent.
        /// </summary>
        /// <remarks>
        /// Everything but the last component of the URL representing this SMB
        /// resource is effectivly it's parent. The root URL <code>smb://</code>
        /// does not have a parent. In this case <code>smb://</code> is returned.
        /// </remarks>
        /// <returns>
        /// The parent directory of this SMB resource or
        /// <code>smb://</code> if the resource refers to the root of the URL
        /// hierarchy which incedentally is also <code>smb://</code>.
        /// </returns>
        public virtual string GetParent()
        {
            string str = Url.Authority;
            if (str.Length > 0)
            {
                StringBuilder sb = new StringBuilder("smb://");
                sb.Append(str);
                GetUncPath0();
                if (_canon.Length > 1)
                {
                    sb.Append(_canon);
                }
                else
                {
                    sb.Append('/');
                }
                str = sb.ToString();
                int i = str.Length - 2;
                while (str[i] != '/')
                {
                    i--;
                }
                return Runtime.Substring(str, 0, i + 1);
            }
            return "smb://";
        }

        /// <summary>Returns the full uncanonicalized URL of this SMB resource.</summary>
        /// <remarks>
        /// Returns the full uncanonicalized URL of this SMB resource. An
        /// <code>SmbFile</code> constructed with the result of this method will
        /// result in an <code>SmbFile</code> that is equal to the original.
        /// </remarks>
        /// <returns>The uncanonicalized full URL of this SMB resource.</returns>
        public virtual string GetPath()
        {
            return Url.ToString();
        }

        internal virtual string GetUncPath0()
        {
            if (Unc == null)
            {
                char[] instr = Url.LocalPath.ToCharArray();
                char[] outstr = new char[instr.Length];
                int length = instr.Length;
                int i;
                int o;
                int state;

                state = 0;
                o = 0;
                for (i = 0; i < length; i++)
                {
                    switch (state)
                    {
                        case 0:
                            {
                                if (instr[i] != '/')
                                {
                                    return null;
                                }
                                outstr[o++] = instr[i];
                                state = 1;
                                break;
                            }

                        case 1:
                            {
                                if (instr[i] == '/')
                                {
                                    break;
                                }
                                if (instr[i] == '.' && ((i + 1) >= length || instr[i + 1] == '/'))
                                {
                                    i++;
                                    break;
                                }
                                if ((i + 1) < length
                                    && instr[i] == '.'
                                    && instr[i + 1] == '.'
                                    && ((i + 2) >= length || instr[i + 2] == '/'))
                                {
                                    i += 2;
                                    if (o == 1)
                                    {
                                        break;
                                    }
                                    do
                                    {
                                        o--;
                                    }
                                    while (o > 1 && outstr[o - 1] != '/');
                                    break;
                                }
                                state = 2;
                                goto case 2;
                            }

                        case 2:
                            {
                                if (instr[i] == '/')
                                {
                                    state = 1;
                                }
                                outstr[o++] = instr[i];
                                break;
                            }
                    }
                }
                _canon = new string(outstr, 0, o);
                if (o > 1)
                {
                    o--;
                    i = _canon.IndexOf('/', 1);
                    if (i < 0)
                    {
                        _share = Runtime.Substring(_canon, 1);
                        Unc = "\\";
                    }
                    else
                    {
                        if (i == o)
                        {
                            _share = Runtime.Substring(_canon, 1, i);
                            Unc = "\\";
                        }
                        else
                        {
                            _share = Runtime.Substring(_canon, 1, i);
                            Unc = Runtime.Substring(_canon, i, outstr[o] == '/' ? o : o + 1);
                            Unc = Unc.Replace('/', '\\');
                        }
                    }
                }
                else
                {
                    _share = null;
                    Unc = "\\";
                }
            }
            return Unc;
        }

        /// <summary>Retuns the Windows UNC style path with backslashs intead of forward slashes.
        /// </summary>
        /// <remarks>Retuns the Windows UNC style path with backslashs intead of forward slashes.
        /// </remarks>
        /// <returns>The UNC path.</returns>
        public virtual string GetUncPath()
        {
            GetUncPath0();
            if (_share == null)
            {
                return "\\\\" + Url.GetHost();
            }
            return "\\\\" + Url.GetHost() + _canon.Replace('/', '\\');
        }

        /// <summary>
        /// Returns the full URL of this SMB resource with '.' and '..' components
        /// factored out.
        /// </summary>
        /// <remarks>
        /// Returns the full URL of this SMB resource with '.' and '..' components
        /// factored out. An <code>SmbFile</code> constructed with the result of
        /// this method will result in an <code>SmbFile</code> that is equal to
        /// the original.
        /// </remarks>
        /// <returns>The canonicalized URL of this SMB resource.</returns>
        public virtual string GetCanonicalPath()
        {
            string str = Url.Authority;
            GetUncPath0();
            if (str.Length > 0)
            {
                return "smb://" + Url.Authority + _canon;
            }
            return "smb://";
        }

        /// <summary>Retrieves the share associated with this SMB resource.</summary>
        /// <remarks>
        /// Retrieves the share associated with this SMB resource. In
        /// the case of <code>smb://</code>, <code>smb://workgroup/</code>,
        /// and <code>smb://server/</code> URLs which do not specify a share,
        /// <code>null</code> will be returned.
        /// </remarks>
        /// <returns>The share component or <code>null</code> if there is no share</returns>
        public virtual string GetShare()
        {
            return _share;
        }

        internal virtual string GetServerWithDfs()
        {
            if (_dfsReferral != null)
            {
                return _dfsReferral.Server;
            }
            return GetServer();
        }

        /// <summary>Retrieve the hostname of the server for this SMB resource.</summary>
        /// <remarks>
        /// Retrieve the hostname of the server for this SMB resource. If this
        /// <code>SmbFile</code> references a workgroup, the name of the workgroup
        /// is returned. If this <code>SmbFile</code> refers to the root of this
        /// SMB network hierarchy, <code>null</code> is returned.
        /// </remarks>
        /// <returns>
        /// The server or workgroup name or <code>null</code> if this
        /// <code>SmbFile</code> refers to the root <code>smb://</code> resource.
        /// </returns>
        public virtual string GetServer()
        {
            string str = Url.GetHost();
            if (str.Length == 0)
            {
                return null;
            }
            return str;
        }

        /// <summary>Returns type of of object this <tt>SmbFile</tt> represents.</summary>
        /// <remarks>Returns type of of object this <tt>SmbFile</tt> represents.</remarks>
        /// <returns>
        /// <tt>TYPE_FILESYSTEM, TYPE_WORKGROUP, TYPE_SERVER, TYPE_SHARE,
        /// TYPE_PRINTER, TYPE_NAMED_PIPE</tt>, or <tt>TYPE_COMM</tt>.
        /// </returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public new virtual int GetType()
        {
            if (Type == 0)
            {
                if (GetUncPath0().Length > 1)
                {
                    Type = TypeFilesystem;
                }
                else
                {
                    if (_share != null)
                    {
                        // treeConnect good enough to test service type
                        Connect0();
                        if (_share.Equals("IPC$"))
                        {
                            Type = TypeNamedPipe;
                        }
                        else
                        {
                            if (Tree.Service.Equals("LPT1:"))
                            {
                                Type = TypePrinter;
                            }
                            else
                            {
                                if (Tree.Service.Equals("COMM"))
                                {
                                    Type = TypeComm;
                                }
                                else
                                {
                                    Type = TypeShare;
                                }
                            }
                        }
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(Url.Authority))
                        {
                            Type = TypeWorkgroup;
                        }
                        else
                        {
                            UniAddress addr;
                            try
                            {
                                addr = GetAddress();
                            }
                            catch (UnknownHostException uhe)
                            {
                                throw new SmbException(Url.ToString(), uhe);
                            }
                            if (addr.GetAddress() is NbtAddress)
                            {
                                int code = ((NbtAddress)addr.GetAddress()).GetNameType();
                                if (code == 0x1d || code == 0x1b)
                                {
                                    Type = TypeWorkgroup;
                                    return Type;
                                }
                            }
                            Type = TypeServer;
                        }
                    }
                }
            }
            return Type;
        }

        /// <exception cref="UnknownHostException"></exception>
        internal virtual bool IsWorkgroup0()
        {
            if (Type == TypeWorkgroup || Url.GetHost().Length == 0)
            {
                Type = TypeWorkgroup;
                return true;
            }
            GetUncPath0();
            if (_share == null)
            {
                UniAddress addr = GetAddress();
                if (addr.GetAddress() is NbtAddress)
                {
                    int code = ((NbtAddress)addr.GetAddress()).GetNameType();
                    if (code == 0x1d || code == 0x1b)
                    {
                        Type = TypeWorkgroup;
                        return true;
                    }
                }
                Type = TypeServer;
            }
            return false;
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual IInfo QueryPath(string path, int infoLevel)
        {
            Connect0();
            if (Log.Level >= 3)
            {
                Log.WriteLine("queryPath: " + path);
            }
            if (Tree.Session.transport.HasCapability(SmbConstants.CapNtSmbs))
            {
                Trans2QueryPathInformationResponse response
                    = new Trans2QueryPathInformationResponse(infoLevel);
                Send(new Trans2QueryPathInformation(path, infoLevel), response);
                return response.Info;
            }
            else
            {
                SmbComQueryInformationResponse response
                    = new SmbComQueryInformationResponse(Tree.Session.transport.Server.ServerTimeZone
                                                         * 1000
                                                         * 60L);
                Send(new SmbComQueryInformation(path), response);
                return response;
            }
        }

        /// <summary>Tests to see if the SMB resource exists.</summary>
        /// <remarks>
        /// Tests to see if the SMB resource exists. If the resource refers
        /// only to a server, this method determines if the server exists on the
        /// network and is advertising SMB services. If this resource refers to
        /// a workgroup, this method determines if the workgroup name is valid on
        /// the local SMB network. If this <code>SmbFile</code> refers to the root
        /// <code>smb://</code> resource <code>true</code> is always returned. If
        /// this <code>SmbFile</code> is a traditional file or directory, it will
        /// be queried for on the specified server as expected.
        /// </remarks>
        /// <returns>
        /// <code>true</code> if the resource exists or is alive or
        /// <code>false</code> otherwise
        /// </returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual bool Exists()
        {
            if (_attrExpiration > Runtime.CurrentTimeMillis())
            {
                return _isExists;
            }
            _attributes = AttrReadonly | AttrDirectory;
            _createTime = 0L;
            _lastModified = 0L;
            _isExists = false;
            try
            {
                if (Url.GetHost().Length == 0)
                {
                }
                else
                {
                    if (_share == null)
                    {
                        if (GetType() == TypeWorkgroup)
                        {
                            UniAddress.GetByName(Url.GetHost(), true);
                        }
                        else
                        {
                            UniAddress.GetByName(Url.GetHost()).GetHostName();
                        }
                    }
                    else
                    {
                        if (GetUncPath0().Length == 1 || Runtime.EqualsIgnoreCase(_share, "IPC$"))
                        {
                            Connect0();
                        }
                        else
                        {
                            // treeConnect is good enough
                            IInfo info = QueryPath(GetUncPath0(),
                                                   Trans2QueryPathInformationResponse.SMB_QUERY_FILE_BASIC_INFO);
                            _attributes = info.GetAttributes();
                            _createTime = info.GetCreateTime();
                            _lastModified = info.GetLastWriteTime();
                        }
                    }
                }
                _isExists = true;
            }
            catch (UnknownHostException)
            {
            }
            catch (SmbException se)
            {
                switch (se.GetNtStatus())
                {
                    case NtStatus.NtStatusNoSuchFile:
                    case NtStatus.NtStatusObjectNameInvalid:
                    case NtStatus.NtStatusObjectNameNotFound:
                    case NtStatus.NtStatusObjectPathNotFound:
                        {
                            break;
                        }

                    default:
                        {
                            throw;
                        }
                }
            }
            _attrExpiration = Runtime.CurrentTimeMillis() + AttrExpirationPeriod;
            return _isExists;
        }

        /// <summary>
        /// Tests to see if the file this <code>SmbFile</code> represents can be
        /// read.
        /// </summary>
        /// <remarks>
        /// Tests to see if the file this <code>SmbFile</code> represents can be
        /// read. Because any file, directory, or other resource can be read if it
        /// exists, this method simply calls the <code>exists</code> method.
        /// </remarks>
        /// <returns><code>true</code> if the file is read-only</returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual bool CanRead()
        {
            if (GetType() == TypeNamedPipe)
            {
                // try opening the pipe for reading?
                return true;
            }
            return Exists();
        }

        // try opening and catch sharing violation?
        /// <summary>
        /// Tests to see if the file this <code>SmbFile</code> represents
        /// exists and is not marked read-only.
        /// </summary>
        /// <remarks>
        /// Tests to see if the file this <code>SmbFile</code> represents
        /// exists and is not marked read-only. By default, resources are
        /// considered to be read-only and therefore for <code>smb://</code>,
        /// <code>smb://workgroup/</code>, and <code>smb://server/</code> resources
        /// will be read-only.
        /// </remarks>
        /// <returns>
        /// <code>true</code> if the resource exists is not marked
        /// read-only
        /// </returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual bool CanWrite()
        {
            if (GetType() == TypeNamedPipe)
            {
                // try opening the pipe for writing?
                return true;
            }
            return Exists() && (_attributes & AttrReadonly) == 0;
        }

        /// <summary>Tests to see if the file this <code>SmbFile</code> represents is a directory.
        /// </summary>
        /// <remarks>Tests to see if the file this <code>SmbFile</code> represents is a directory.
        /// </remarks>
        /// <returns><code>true</code> if this <code>SmbFile</code> is a directory</returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual bool IsDirectory()
        {
            if (GetUncPath0().Length == 1)
            {
                return true;
            }
            if (!Exists())
            {
                return false;
            }
            return (_attributes & AttrDirectory) == AttrDirectory;
        }

        /// <summary>Tests to see if the file this <code>SmbFile</code> represents is not a directory.
        /// </summary>
        /// <remarks>Tests to see if the file this <code>SmbFile</code> represents is not a directory.
        /// </remarks>
        /// <returns><code>true</code> if this <code>SmbFile</code> is not a directory</returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual bool IsFile()
        {
            if (GetUncPath0().Length == 1)
            {
                return false;
            }
            Exists();
            return (_attributes & AttrDirectory) == 0;
        }

        /// <summary>
        /// Tests to see if the file this SmbFile represents is marked as
        /// hidden.
        /// </summary>
        /// <remarks>
        /// Tests to see if the file this SmbFile represents is marked as
        /// hidden. This method will also return true for shares with names that
        /// end with '$' such as <code>IPC$</code> or <code>C$</code>.
        /// </remarks>
        /// <returns><code>true</code> if the <code>SmbFile</code> is marked as being hidden</returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual bool IsHidden()
        {
            if (_share == null)
            {
                return false;
            }
            if (GetUncPath0().Length == 1)
            {
                if (_share.EndsWith("$"))
                {
                    return true;
                }
                return false;
            }
            Exists();
            return (_attributes & AttrHidden) == AttrHidden;
        }

        /// <summary>
        /// If the path of this <code>SmbFile</code> falls within a DFS volume,
        /// this method will return the referral path to which it maps.
        /// </summary>
        /// <remarks>
        /// If the path of this <code>SmbFile</code> falls within a DFS volume,
        /// this method will return the referral path to which it maps. Otherwise
        /// <code>null</code> is returned.
        /// </remarks>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual string GetDfsPath()
        {
            ResolveDfs(null);
            if (_dfsReferral == null)
            {
                return null;
            }
            string path = "smb:/" + _dfsReferral.Server + "/" + _dfsReferral.Share + Unc;
            path = path.Replace('\\', '/');
            if (IsDirectory())
            {
                path += '/';
            }
            return path;
        }

        /// <summary>Retrieve the time this <code>SmbFile</code> was created.</summary>
        /// <remarks>
        /// Retrieve the time this <code>SmbFile</code> was created. The value
        /// returned is suitable for constructing a
        /// <see cref="System.DateTime">System.DateTime</see>
        /// object
        /// (i.e. seconds since Epoch 1970). Times should be the same as those
        /// reported using the properties dialog of the Windows Explorer program.
        /// For Win95/98/Me this is actually the last write time. It is currently
        /// not possible to retrieve the create time from files on these systems.
        /// </remarks>
        /// <returns>
        /// The number of milliseconds since the 00:00:00 GMT, January 1,
        /// 1970 as a <code>long</code> value
        /// </returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual long CreateTime()
        {
            if (GetUncPath0().Length > 1)
            {
                Exists();
                return _createTime;
            }
            return 0L;
        }

        /// <summary>
        /// Retrieve the last time the file represented by this
        /// <code>SmbFile</code> was modified.
        /// </summary>
        /// <remarks>
        /// Retrieve the last time the file represented by this
        /// <code>SmbFile</code> was modified. The value returned is suitable for
        /// constructing a
        /// <see cref="System.DateTime">System.DateTime</see>
        /// object (i.e. seconds since Epoch
        /// 1970). Times should be the same as those reported using the properties
        /// dialog of the Windows Explorer program.
        /// </remarks>
        /// <returns>
        /// The number of milliseconds since the 00:00:00 GMT, January 1,
        /// 1970 as a <code>long</code> value
        /// </returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual long LastModified()
        {
            if (GetUncPath0().Length > 1)
            {
                Exists();
                return _lastModified;
            }
            return 0L;
        }

        /// <summary>List the contents of this SMB resource.</summary>
        /// <remarks>
        /// List the contents of this SMB resource. The list returned by this
        /// method will be;
        /// <ul>
        /// <li> files and directories contained within this resource if the
        /// resource is a normal disk file directory,
        /// <li> all available NetBIOS workgroups or domains if this resource is
        /// the top level URL <code>smb://</code>,
        /// <li> all servers registered as members of a NetBIOS workgroup if this
        /// resource refers to a workgroup in a <code>smb://workgroup/</code> URL,
        /// <li> all browseable shares of a server including printers, IPC
        /// services, or disk volumes if this resource is a server URL in the form
        /// <code>smb://server/</code>,
        /// <li> or <code>null</code> if the resource cannot be resolved.
        /// </ul>
        /// </remarks>
        /// <returns>
        /// A <code>String[]</code> array of files and directories,
        /// workgroups, servers, or shares depending on the context of the
        /// resource URL
        /// </returns>
        /// <exception cref="SmbException"></exception>
        public virtual string[] List()
        {
            return List("*", AttrDirectory | AttrHidden | AttrSystem, null, null);
        }

        /// <summary>List the contents of this SMB resource.</summary>
        /// <remarks>
        /// List the contents of this SMB resource. The list returned will be
        /// identical to the list returned by the parameterless <code>list()</code>
        /// method minus filenames filtered by the specified filter.
        /// </remarks>
        /// <param name="filter">a filename filter to exclude filenames from the results</param>
        /// <exception cref="SmbException"># @return An array of filenames</exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual string[] List(ISmbFilenameFilter filter)
        {
            return List("*", AttrDirectory | AttrHidden | AttrSystem, filter, null);
        }

        /// <summary>
        /// List the contents of this SMB resource as an array of
        /// <code>SmbFile</code> objects.
        /// </summary>
        /// <remarks>
        /// List the contents of this SMB resource as an array of
        /// <code>SmbFile</code> objects. This method is much more efficient than
        /// the regular <code>list</code> method when querying attributes of each
        /// file in the result set.
        /// <p>
        /// The list of <code>SmbFile</code>s returned by this method will be;
        /// <ul>
        /// <li> files and directories contained within this resource if the
        /// resource is a normal disk file directory,
        /// <li> all available NetBIOS workgroups or domains if this resource is
        /// the top level URL <code>smb://</code>,
        /// <li> all servers registered as members of a NetBIOS workgroup if this
        /// resource refers to a workgroup in a <code>smb://workgroup/</code> URL,
        /// <li> all browseable shares of a server including printers, IPC
        /// services, or disk volumes if this resource is a server URL in the form
        /// <code>smb://server/</code>,
        /// <li> or <code>null</code> if the resource cannot be resolved.
        /// </ul>
        /// </remarks>
        /// <returns>
        /// An array of <code>SmbFile</code> objects representing file
        /// and directories, workgroups, servers, or shares depending on the context
        /// of the resource URL
        /// </returns>
        /// <exception cref="SmbException"></exception>
        public virtual SmbFile[] ListFiles()
        {
            return ListFiles("*", AttrDirectory | AttrHidden | AttrSystem, null, null);
        }

        /// <summary>
        /// The CIFS protocol provides for DOS "wildcards" to be used as
        /// a performance enhancement.
        /// </summary>
        /// <remarks>
        /// The CIFS protocol provides for DOS "wildcards" to be used as
        /// a performance enhancement. The client does not have to filter
        /// the names and the server does not have to return all directory
        /// entries.
        /// <p>
        /// The wildcard expression may consist of two special meta
        /// characters in addition to the normal filename characters. The '*'
        /// character matches any number of characters in part of a name. If
        /// the expression begins with one or more '?'s then exactly that
        /// many characters will be matched whereas if it ends with '?'s
        /// it will match that many characters <i>or less</i>.
        /// <p>
        /// Wildcard expressions will not filter workgroup names or server names.
        /// <blockquote><pre>
        /// winnt&gt; ls c?o
        /// clock.avi                  -rw--      82944 Mon Oct 14 1996 1:38 AM
        /// Cookies                    drw--          0 Fri Nov 13 1998 9:42 PM
        /// 2 items in 5ms
        /// </pre></blockquote>
        /// </remarks>
        /// <param name="wildcard">a wildcard expression</param>
        /// <exception cref="SmbException">SmbException</exception>
        /// <returns>
        /// An array of <code>SmbFile</code> objects representing file
        /// and directories, workgroups, servers, or shares depending on the context
        /// of the resource URL
        /// </returns>
        /// <exception cref="SmbException"></exception>
        public virtual SmbFile[] ListFiles(string wildcard)
        {
            return ListFiles(wildcard,
                             AttrDirectory | AttrHidden | AttrSystem,
                             null,
                             null);
        }

        /// <summary>List the contents of this SMB resource.</summary>
        /// <remarks>
        /// List the contents of this SMB resource. The list returned will be
        /// identical to the list returned by the parameterless <code>listFiles()</code>
        /// method minus files filtered by the specified filename filter.
        /// </remarks>
        /// <param name="filter">a filter to exclude files from the results</param>
        /// <returns>An array of <tt>SmbFile</tt> objects</returns>
        /// <exception cref="SmbException">SmbException</exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual SmbFile[] ListFiles(ISmbFilenameFilter filter)
        {
            return ListFiles("*", AttrDirectory | AttrHidden | AttrSystem, filter, null);
        }

        /// <summary>List the contents of this SMB resource.</summary>
        /// <remarks>
        /// List the contents of this SMB resource. The list returned will be
        /// identical to the list returned by the parameterless <code>listFiles()</code>
        /// method minus filenames filtered by the specified filter.
        /// </remarks>
        /// <param name="filter">a file filter to exclude files from the results</param>
        /// <returns>An array of <tt>SmbFile</tt> objects</returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual SmbFile[] ListFiles(ISmbFileFilter filter)
        {
            return ListFiles("*", AttrDirectory | AttrHidden | AttrSystem, null, filter);
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual string[] List(string wildcard,
                                       int searchAttributes,
                                       ISmbFilenameFilter fnf,
                                       ISmbFileFilter ff)
        {
            List<object> list = new List<object>();
            DoEnum(list, false, wildcard, searchAttributes, fnf, ff);

            return Collections.ToArray<string>(list); //Collections.ToArray<string>(list);
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual SmbFile[] ListFiles(string wildcard,
                                             int searchAttributes,
                                             ISmbFilenameFilter fnf,
                                             ISmbFileFilter ff)
        {
            List<object> list = new List<object>();
            DoEnum(list, true, wildcard, searchAttributes, fnf, ff);

            return Collections.ToArray<SmbFile>(list); //Collections.ToArray<SmbFile>(list);
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void DoEnum(List<object> list,
                                     bool files,
                                     string wildcard,
                                     int searchAttributes,
                                     ISmbFilenameFilter fnf,
                                     ISmbFileFilter ff)
        {
            if (ff != null && ff is DosFileFilter)
            {
                DosFileFilter dff = (DosFileFilter)ff;
                if (dff.Wildcard != null)
                {
                    wildcard = dff.Wildcard;
                }
                searchAttributes = dff.Attributes;
            }
            try
            {
                int hostlen = Url.GetHost() != null
                                ? Url.GetHost().Length
                                : 0;
                if (hostlen == 0 || GetType() == TypeWorkgroup)
                {
                    DoNetServerEnum(list, files, wildcard, searchAttributes, fnf, ff);
                }
                else
                {
                    if (_share == null)
                    {
                        DoShareEnum(list, files, wildcard, searchAttributes, fnf, ff);
                    }
                    else
                    {
                        DoFindFirstNext(list, files, wildcard, searchAttributes, fnf, ff);
                    }
                }
            }
            catch (UnknownHostException uhe)
            {
                throw new SmbException(Url.ToString(), uhe);
            }
            catch (UriFormatException mue)
            {
                throw new SmbException(Url.ToString(), mue);
            }
        }

        private void RemoveCurrentAddress()
        {
            if (AddressIndex >= 1)
            {
                UniAddress[] aux = new UniAddress[Addresses.Length - 1];

                Array.Copy(Addresses, 1, aux, 0, Addresses.Length - 1);

                Addresses = aux;
                AddressIndex--;
            }
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        /// <exception cref="UnknownHostException"></exception>
        /// <exception cref="System.UriFormatException"></exception>
        internal virtual void DoShareEnum(List<object> list,
                                          bool files,
                                          string wildcard,
                                          int searchAttributes,
                                          ISmbFilenameFilter fnf,
                                          ISmbFileFilter ff)
        {
            string p = Url.AbsolutePath;
            IOException last = null;
            IFileEntry[] entries;
            UniAddress addr;
            IFileEntry e;
            Hashtable map;
            if (p.LastIndexOf('/') != (p.Length - 1))
            {
                throw new SmbException(Url + " directory must end with '/'");
            }
            if (GetType() != TypeServer)
            {
                throw new SmbException("The requested list operations is invalid: " + Url);
            }
            map = new Hashtable();
            if (_enableDfs && Dfs.IsTrustedDomain(GetServer(), Auth))
            {
                try
                {
                    entries = DoDfsRootEnum();
                    for (int ei = 0; ei < entries.Length; ei++)
                    {
                        e = entries[ei];
                        if (map.ContainsKey(e) == false)
                        {
                            map.Put(e, e);
                        }
                    }
                }
                catch (IOException ioe)
                {
                    if (Log.Level >= 4)
                    {
                        Runtime.PrintStackTrace(ioe, Log);
                    }
                }
            }
            addr = GetFirstAddress();
            while (addr != null)
            {
                try
                {
                    last = null;

                    DoConnect();
                    try
                    {
                        entries = DoMsrpcShareEnum();
                    }
                    catch (IOException ioe)
                    {
                        if (Log.Level >= 3)
                        {
                            Runtime.PrintStackTrace(ioe, Log);
                        }
                        entries = DoNetShareEnum();
                    }
                    for (int ei = 0; ei < entries.Length; ei++)
                    {
                        e = entries[ei];
                        if (map.ContainsKey(e) == false)
                        {
                            map.Put(e, e);
                        }
                    }
                    break;
                }
                catch (IOException ioe)
                {
                    if (Log.Level >= 3)
                    {
                        Runtime.PrintStackTrace(ioe, Log);
                    }
                    last = ioe;

                    if (!(ioe is SmbAuthException))
                    {
                        RemoveCurrentAddress();

                        addr = GetNextAddress();
                    }
                    else
                    {
                        break;
                    }
                }

            }
            if (last != null && map.Count == 0)
            {
                if (last is SmbException == false)
                {
                    throw new SmbException(Url.ToString(), last);
                }
                throw (SmbException)last;
            }
            //Iterator iter = map.Keys.Iterator();
            //while (iter.HasNext())
            foreach (var item in map.Keys)
            {
                e = (IFileEntry)item;
                string name = e.GetName();
                if (fnf != null && fnf.Accept(this, name) == false)
                {
                    continue;
                }
                if (name.Length > 0)
                {
                    // if !files we don't need to create SmbFiles here
                    SmbFile f = new SmbFile(this,
                                            name,
                                            e.GetType(),
                                            AttrReadonly | AttrDirectory,
                                            0L,
                                            0L,
                                            0L);
                    if (ff != null && ff.Accept(f) == false)
                    {
                        continue;
                    }
                    if (files)
                    {
                        list.Add(f);
                    }
                    else
                    {
                        list.Add(name);
                    }
                }
            }
        }

        /// <exception cref="System.IO.IOException"></exception>
        internal virtual IFileEntry[] DoDfsRootEnum()
        {
            MsrpcDfsRootEnum rpc;
            DcerpcHandle handle = null;
            IFileEntry[] entries;
            handle = DcerpcHandle.GetHandle("ncacn_np:"
                                                + GetAddress().GetHostAddress()
                                                + "[\\PIPE\\netdfs]",
                                            Auth);
            try
            {
                rpc = new MsrpcDfsRootEnum(GetServer());
                handle.Sendrecv(rpc);
                if (rpc.Retval != 0)
                {
                    throw new SmbException(rpc.Retval, true);
                }
                return rpc.GetEntries();
            }
            finally
            {
                try
                {
                    handle.Close();
                }
                catch (IOException ioe)
                {
                    if (Log.Level >= 4)
                    {
                        Runtime.PrintStackTrace(ioe, Log);
                    }
                }
            }
        }

        /// <exception cref="System.IO.IOException"></exception>
        internal virtual IFileEntry[] DoMsrpcShareEnum()
        {
            MsrpcShareEnum rpc;
            DcerpcHandle handle;
            rpc = new MsrpcShareEnum(Url.GetHost());
            handle = DcerpcHandle.GetHandle("ncacn_np:"
                                                + GetAddress().GetHostAddress()
                                                + "[\\PIPE\\srvsvc]",
                                            Auth);
            try
            {
                handle.Sendrecv(rpc);
                if (rpc.Retval != 0)
                {
                    throw new SmbException(rpc.Retval, true);
                }
                return rpc.GetEntries();
            }
            finally
            {
                try
                {
                    handle.Close();
                }
                catch (IOException ioe)
                {
                    if (Log.Level >= 4)
                    {
                        Runtime.PrintStackTrace(ioe, Log);
                    }
                }
            }
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual IFileEntry[] DoNetShareEnum()
        {
            SmbComTransaction req = new NetShareEnum();
            SmbComTransactionResponse resp = new NetShareEnumResponse();
            Send(req, resp);
            if (resp.Status != WinError.ErrorSuccess)
            {
                throw new SmbException(resp.Status, true);
            }
            return resp.Results;
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        /// <exception cref="UnknownHostException"></exception>
        /// <exception cref="System.UriFormatException"></exception>
        internal virtual void DoNetServerEnum(List<object> list,
                                              bool files,
                                              string wildcard,
                                              int searchAttributes,
                                              ISmbFilenameFilter fnf,
                                              ISmbFileFilter ff)
        {
            int listType = Url.GetHost().Length == 0
                                ? 0
                                : GetType();
            SmbComTransaction req;
            SmbComTransactionResponse resp;
            if (listType == 0)
            {
                Connect0();
                req = new NetServerEnum2(Tree.Session.transport.Server.OemDomainName,
                                         NetServerEnum2.SvTypeDomainEnum);
                resp = new NetServerEnum2Response();
            }
            else
            {
                if (listType == TypeWorkgroup)
                {
                    req = new NetServerEnum2(Url.GetHost(), NetServerEnum2.SvTypeAll);
                    resp = new NetServerEnum2Response();
                }
                else
                {
                    throw new SmbException("The requested list operations is invalid: " + Url);
                }
            }
            bool more;
            do
            {
                int n;
                Send(req, resp);
                if (resp.Status != WinError.ErrorSuccess && resp.Status != WinError.ErrorMoreData)
                {
                    throw new SmbException(resp.Status, true);
                }
                more = resp.Status == WinError.ErrorMoreData;
                n = more ? resp.NumEntries - 1 : resp.NumEntries;
                for (int i = 0; i < n; i++)
                {
                    IFileEntry e = resp.Results[i];
                    string name = e.GetName();
                    if (fnf != null && fnf.Accept(this, name) == false)
                    {
                        continue;
                    }
                    if (name.Length > 0)
                    {
                        // if !files we don't need to create SmbFiles here
                        SmbFile f = new SmbFile(this,
                                                name,
                                                e.GetType(),
                                                AttrReadonly | AttrDirectory,
                                                0L,
                                                0L,
                                                0L);
                        if (ff != null && ff.Accept(f) == false)
                        {
                            continue;
                        }
                        if (files)
                        {
                            list.Add(f);
                        }
                        else
                        {
                            list.Add(name);
                        }
                    }
                }
                if (GetType() != TypeWorkgroup)
                {
                    break;
                }
                req.SubCommand = unchecked(SmbComTransaction.NetServerEnum3);
                req.Reset(0, ((NetServerEnum2Response)resp).LastName);
                resp.Reset();
            }
            while (more);
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        /// <exception cref="UnknownHostException"></exception>
        /// <exception cref="System.UriFormatException"></exception>
        internal virtual void DoFindFirstNext(List<object> list,
                                              bool files,
                                              string wildcard,
                                              int searchAttributes,
                                              ISmbFilenameFilter fnf,
                                              ISmbFileFilter ff)
        {
            SmbComTransaction req;
            Trans2FindFirst2Response resp;
            int sid;
            string path = GetUncPath0();
            string p = Url.AbsolutePath;
            if (p.LastIndexOf('/') != (p.Length - 1))
            {
                throw new SmbException(Url + " directory must end with '/'");
            }
            req = new Trans2FindFirst2(path, wildcard, searchAttributes);
            resp = new Trans2FindFirst2Response();
            if (Log.Level >= 3)
            {
                Log.WriteLine("doFindFirstNext: " + req.Path);
            }
            Send(req, resp);
            sid = resp.Sid;
            req = new Trans2FindNext2(sid, resp.ResumeKey, resp.LastName);
            resp.SubCommand = SmbComTransaction.Trans2FindNext2;
            for (;;)
            {
                for (int i = 0; i < resp.NumEntries; i++)
                {
                    IFileEntry e = resp.Results[i];
                    string name = e.GetName();
                    if (name.Length < 3)
                    {
                        int h = name.GetHashCode();
                        if (h == HashDot || h == HashDotDot)
                        {
                            if (name.Equals(".") || name.Equals(".."))
                            {
                                continue;
                            }
                        }
                    }
                    if (fnf != null && fnf.Accept(this, name) == false)
                    {
                        continue;
                    }
                    if (name.Length > 0)
                    {
                        SmbFile f = new SmbFile(this,
                                                name,
                                                TypeFilesystem,
                                                e.GetAttributes(),
                                                e.CreateTime(),
                                                e.LastModified(),
                                                e.Length());
                        if (ff != null && ff.Accept(f) == false)
                        {
                            continue;
                        }
                        if (files)
                        {
                            list.Add(f);
                        }
                        else
                        {
                            list.Add(name);
                        }
                    }
                }
                if (resp.IsEndOfSearch || resp.NumEntries == 0)
                {
                    break;
                }
                req.Reset(resp.ResumeKey, resp.LastName);
                resp.Reset();
                Send(req, resp);
            }
            try
            {
                Send(new SmbComFindClose2(sid), Blank_resp());
            }
            catch (SmbException se)
            {
                if (Log.Level >= 4)
                {
                    Runtime.PrintStackTrace(se, Log);
                }
            }
        }

        /// <summary>
        /// Changes the name of the file this <code>SmbFile</code> represents to the name
        /// designated by the <code>SmbFile</code> argument.
        /// </summary>
        /// <remarks>
        /// Changes the name of the file this <code>SmbFile</code> represents to the name
        /// designated by the <code>SmbFile</code> argument.
        /// <p/>
        /// <i>Remember: <code>SmbFile</code>s are immutible and therefore
        /// the path associated with this <code>SmbFile</code> object will not
        /// change). To access the renamed file it is necessary to construct a
        /// new <tt>SmbFile</tt></i>.
        /// </remarks>
        /// <param name="dest">An <code>SmbFile</code> that represents the new pathname</param>
        /// <exception cref="System.ArgumentNullException">If the <code>dest</code> argument is <code>null</code>
        /// </exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual void RenameTo(SmbFile dest)
        {
            if (GetUncPath0().Length == 1 || dest.GetUncPath0().Length == 1)
            {
                throw new SmbException("Invalid operation for workgroups, servers, or shares");
            }
            ResolveDfs(null);
            dest.ResolveDfs(null);
            if (!Tree.Equals(dest.Tree))
            {
                throw new SmbException("Invalid operation for workgroups, servers, or shares");
            }
            if (Log.Level >= 3)
            {
                Log.WriteLine("renameTo: " + Unc + " -> " + dest.Unc);
            }
            _attrExpiration = _sizeExpiration = 0;
            dest._attrExpiration = 0;
            Send(new SmbComRename(Unc, dest.Unc), Blank_resp());
        }

        internal class WriterThread : Thread
        {
            internal byte[] B;

            internal int N;

            internal long Off;

            internal bool Ready;

            internal SmbFile Dest;

            internal SmbException E;

            internal bool UseNtSmbs;

            internal SmbComWriteAndX Reqx;

            internal SmbComWrite Req;

            internal ServerMessageBlock Resp;

            /// <exception cref="SharpCifs.Smb.SmbException"></exception>
            public WriterThread(SmbFile enclosing)
                : base("JCIFS-WriterThread")
            {
                this._enclosing = enclosing;
                UseNtSmbs = this._enclosing.Tree
                                           .Session
                                           .transport
                                           .HasCapability(SmbConstants.CapNtSmbs);
                if (UseNtSmbs)
                {
                    Reqx = new SmbComWriteAndX();
                    Resp = new SmbComWriteAndXResponse();
                }
                else
                {
                    Req = new SmbComWrite();
                    Resp = new SmbComWriteResponse();
                }
                Ready = false;
            }

            internal virtual void Write(byte[] b, int n, SmbFile dest, long off)
            {
                lock (this)
                {
                    this.B = b;
                    this.N = n;
                    this.Dest = dest;
                    this.Off = off;
                    Ready = false;
                    Runtime.Notify(this);
                }
            }

            public override void Run()
            {
                lock (this)
                {
                    try
                    {
                        for (;;)
                        {
                            Runtime.Notify(this);
                            Ready = true;
                            while (Ready)
                            {
                                Runtime.Wait(this);
                            }
                            if (N == -1)
                            {
                                return;
                            }
                            if (UseNtSmbs)
                            {
                                Reqx.SetParam(Dest.Fid, Off, N, B, 0, N);
                                Dest.Send(Reqx, Resp);
                            }
                            else
                            {
                                Req.SetParam(Dest.Fid, Off, N, B, 0, N);
                                Dest.Send(Req, Resp);
                            }
                        }
                    }
                    catch (SmbException e)
                    {
                        this.E = e;
                    }
                    catch (Exception x)
                    {
                        E = new SmbException("WriterThread", x);
                    }
                    Runtime.Notify(this);
                }
            }

            private readonly SmbFile _enclosing;
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void CopyTo0(SmbFile dest,
                                      byte[][] b,
                                      int bsize,
                                      WriterThread w,
                                      SmbComReadAndX req,
                                      SmbComReadAndXResponse resp)
        {
            int i;
            if (_attrExpiration < Runtime.CurrentTimeMillis())
            {
                _attributes = AttrReadonly | AttrDirectory;
                _createTime = 0L;
                _lastModified = 0L;
                _isExists = false;
                IInfo info = QueryPath(GetUncPath0(),
                                       Trans2QueryPathInformationResponse.SMB_QUERY_FILE_BASIC_INFO);
                _attributes = info.GetAttributes();
                _createTime = info.GetCreateTime();
                _lastModified = info.GetLastWriteTime();
                _isExists = true;
                _attrExpiration = Runtime.CurrentTimeMillis() + AttrExpirationPeriod;
            }
            if (IsDirectory())
            {
                SmbFile[] files;
                SmbFile ndest;
                string path = dest.GetUncPath0();
                if (path.Length > 1)
                {
                    try
                    {
                        dest.Mkdir();
                        dest.SetPathInformation(_attributes, _createTime, _lastModified);
                    }
                    catch (SmbException se)
                    {
                        if (se.GetNtStatus() != NtStatus.NtStatusAccessDenied
                            && se.GetNtStatus() != NtStatus.NtStatusObjectNameCollision)
                        {
                            throw;
                        }
                    }
                }
                files = ListFiles("*", AttrDirectory | AttrHidden | AttrSystem, null, null);
                try
                {
                    for (i = 0; i < files.Length; i++)
                    {
                        ndest = new SmbFile(dest,
                                            files[i].GetName(),
                                            files[i].Type,
                                            files[i]._attributes,
                                            files[i]._createTime,
                                            files[i]._lastModified,
                                            files[i]._size);
                        files[i].CopyTo0(ndest, b, bsize, w, req, resp);
                    }
                }
                catch (UnknownHostException uhe)
                {
                    throw new SmbException(Url.ToString(), uhe);
                }
                catch (UriFormatException mue)
                {
                    throw new SmbException(Url.ToString(), mue);
                }
            }
            else
            {
                long off;
                try
                {
                    Open(ORdonly, 0, AttrNormal, 0);
                    try
                    {
                        dest.Open(OCreat | OWronly | OTrunc,
                                  SmbConstants.FileWriteData | SmbConstants.FileWriteAttributes,
                                  _attributes,
                                  0);
                    }
                    catch (SmbAuthException sae)
                    {
                        if ((dest._attributes & AttrReadonly) != 0)
                        {
                            dest.SetPathInformation(dest._attributes & ~AttrReadonly, 0L, 0L);
                            dest.Open(OCreat | OWronly | OTrunc,
                                      SmbConstants.FileWriteData | SmbConstants.FileWriteAttributes,
                                      _attributes,
                                      0);
                        }
                        else
                        {
                            throw;
                        }
                    }
                    i = 0;
                    off = 0L;
                    for (;;)
                    {
                        req.SetParam(Fid, off, bsize);
                        resp.SetParam(b[i], 0);
                        Send(req, resp);
                        lock (w)
                        {
                            if (w.E != null)
                            {
                                throw w.E;
                            }
                            while (!w.Ready)
                            {
                                try
                                {
                                    Runtime.Wait(w);
                                }
                                catch (Exception ie)
                                {
                                    throw new SmbException(dest.Url.ToString(), ie);
                                }
                            }
                            if (w.E != null)
                            {
                                throw w.E;
                            }
                            if (resp.DataLength <= 0)
                            {
                                break;
                            }
                            w.Write(b[i], resp.DataLength, dest, off);
                        }
                        i = i == 1 ? 0 : 1;
                        off += resp.DataLength;
                    }
                    dest.Send(new Trans2SetFileInformation(dest.Fid,
                                                           _attributes,
                                                           _createTime,
                                                           _lastModified),
                              new Trans2SetFileInformationResponse());
                    dest.Close(0L);
                }
                catch (SmbException se)
                {
                    if (IgnoreCopyToException == false)
                    {
                        throw new SmbException("Failed to copy file from "
                                               + "[" + ToString() + "] to [" + dest + "]", se);
                    }
                    if (Log.Level > 1)
                    {
                        Runtime.PrintStackTrace(se, Log);
                    }
                }
                finally
                {
                    Close();
                }
            }
        }

        /// <summary>
        /// This method will copy the file or directory represented by this
        /// <tt>SmbFile</tt> and it's sub-contents to the location specified by the
        /// <tt>dest</tt> parameter.
        /// </summary>
        /// <remarks>
        /// This method will copy the file or directory represented by this
        /// <tt>SmbFile</tt> and it's sub-contents to the location specified by the
        /// <tt>dest</tt> parameter. This file and the destination file do not
        /// need to be on the same host. This operation does not copy extended
        /// file attibutes such as ACLs but it does copy regular attributes as
        /// well as create and last write times. This method is almost twice as
        /// efficient as manually copying as it employs an additional write
        /// thread to read and write data concurrently.
        /// <p/>
        /// It is not possible (nor meaningful) to copy entire workgroups or
        /// servers.
        /// </remarks>
        /// <param name="dest">the destination file or directory</param>
        /// <exception cref="SmbException">SmbException</exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual void CopyTo(SmbFile dest)
        {
            SmbComReadAndX req;
            SmbComReadAndXResponse resp;
            WriterThread w;
            int bsize;
            byte[][] b;
            if (_share == null || dest._share == null)
            {
                throw new SmbException("Invalid operation for workgroups or servers");
            }
            req = new SmbComReadAndX();
            resp = new SmbComReadAndXResponse();
            Connect0();
            dest.Connect0();
            ResolveDfs(null);
            try
            {
                if (GetAddress().Equals(dest.GetAddress())
                    && _canon.RegionMatches(true, 0, dest._canon, 0, Math.Min(_canon.Length, dest._canon.Length)))
                {
                    throw new SmbException("Source and destination paths overlap.");
                }
            }
            catch (UnknownHostException)
            {
            }
            w = new WriterThread(this);
            w.SetDaemon(true);
            w.Start(true);

            SmbTransport t1 = Tree.Session.transport;
            SmbTransport t2 = dest.Tree.Session.transport;
            if (t1.SndBufSize < t2.SndBufSize)
            {
                t2.SndBufSize = t1.SndBufSize;
            }
            else
            {
                t1.SndBufSize = t2.SndBufSize;
            }
            bsize = Math.Min(t1.RcvBufSize - 70, t1.SndBufSize - 70);
            b = new[] { new byte[bsize], new byte[bsize] };
            try
            {
                CopyTo0(dest, b, bsize, w, req, resp);
            }
            finally
            {
                w.Write(null, -1, null, 0);
            }
        }

        /// <summary>
        /// This method will delete the file or directory specified by this
        /// <code>SmbFile</code>.
        /// </summary>
        /// <remarks>
        /// This method will delete the file or directory specified by this
        /// <code>SmbFile</code>. If the target is a directory, the contents of
        /// the directory will be deleted as well. If a file within the directory or
        /// it's sub-directories is marked read-only, the read-only status will
        /// be removed and the file will be deleted.
        /// </remarks>
        /// <exception cref="SmbException">SmbException</exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual void Delete()
        {
            Exists();
            GetUncPath0();
            Delete(Unc);
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void Delete(string fileName)
        {
            if (GetUncPath0().Length == 1)
            {
                throw new SmbException("Invalid operation for workgroups, servers, or shares");
            }
            if (Runtime.CurrentTimeMillis() > _attrExpiration)
            {
                _attributes = AttrReadonly | AttrDirectory;
                _createTime = 0L;
                _lastModified = 0L;
                _isExists = false;
                IInfo info = QueryPath(GetUncPath0(),
                                       Trans2QueryPathInformationResponse.SMB_QUERY_FILE_BASIC_INFO);
                _attributes = info.GetAttributes();
                _createTime = info.GetCreateTime();
                _lastModified = info.GetLastWriteTime();
                _attrExpiration = Runtime.CurrentTimeMillis() + AttrExpirationPeriod;
                _isExists = true;
            }
            if ((_attributes & AttrReadonly) != 0)
            {
                SetReadWrite();
            }
            if (Log.Level >= 3)
            {
                Log.WriteLine("delete: " + fileName);
            }
            if ((_attributes & AttrDirectory) != 0)
            {
                try
                {
                    SmbFile[] l = ListFiles("*", AttrDirectory | AttrHidden | AttrSystem, null, null);
                    for (int i = 0; i < l.Length; i++)
                    {
                        l[i].Delete();
                    }
                }
                catch (SmbException se)
                {
                    if (se.GetNtStatus() != NtStatus.NtStatusNoSuchFile)
                    {
                        throw;
                    }
                }
                Send(new SmbComDeleteDirectory(fileName), Blank_resp());
            }
            else
            {
                Send(new SmbComDelete(fileName), Blank_resp());
            }
            _attrExpiration = _sizeExpiration = 0;
        }

        /// <summary>Returns the length of this <tt>SmbFile</tt> in bytes.</summary>
        /// <remarks>
        /// Returns the length of this <tt>SmbFile</tt> in bytes. If this object
        /// is a <tt>TYPE_SHARE</tt> the total capacity of the disk shared in
        /// bytes is returned. If this object is a directory or a type other than
        /// <tt>TYPE_SHARE</tt>, 0L is returned.
        /// </remarks>
        /// <returns>
        /// The length of the file in bytes or 0 if this
        /// <code>SmbFile</code> is not a file.
        /// </returns>
        /// <exception cref="SmbException">SmbException</exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual long Length()
        {
            if (_sizeExpiration > Runtime.CurrentTimeMillis())
            {
                return _size;
            }
            if (GetType() == TypeShare)
            {
                Trans2QueryFsInformationResponse response;
                int level = Trans2QueryFsInformationResponse.SMB_INFO_ALLOCATION;
                response = new Trans2QueryFsInformationResponse(level);
                Send(new Trans2QueryFsInformation(level), response);
                _size = response.Info.GetCapacity();
            }
            else
            {
                if (GetUncPath0().Length > 1 && Type != TypeNamedPipe)
                {
                    IInfo info = QueryPath(GetUncPath0(),
                                           Trans2QueryPathInformationResponse.SMB_QUERY_FILE_STANDARD_INFO);
                    _size = info.GetSize();
                }
                else
                {
                    _size = 0L;
                }
            }
            _sizeExpiration = Runtime.CurrentTimeMillis() + AttrExpirationPeriod;
            return _size;
        }

        /// <summary>
        /// This method returns the free disk space in bytes of the drive this share
        /// represents or the drive on which the directory or file resides.
        /// </summary>
        /// <remarks>
        /// This method returns the free disk space in bytes of the drive this share
        /// represents or the drive on which the directory or file resides. Objects
        /// other than <tt>TYPE_SHARE</tt> or <tt>TYPE_FILESYSTEM</tt> will result
        /// in 0L being returned.
        /// </remarks>
        /// <returns>
        /// the free disk space in bytes of the drive on which this file or
        /// directory resides
        /// </returns>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual long GetDiskFreeSpace()
        {
            if (GetType() == TypeShare || Type == TypeFilesystem)
            {
                int level = Trans2QueryFsInformationResponse.SmbFsFullSizeInformation;
                try
                {
                    return QueryFsInformation(level);
                }
                catch (SmbException ex)
                {
                    switch (ex.GetNtStatus())
                    {
                        case NtStatus.NtStatusInvalidInfoClass:
                        case NtStatus.NtStatusUnsuccessful:
                            {
                                // NetApp Filer
                                // SMB_FS_FULL_SIZE_INFORMATION not supported by the server.
                                level = Trans2QueryFsInformationResponse.SMB_INFO_ALLOCATION;
                                return QueryFsInformation(level);
                            }
                    }
                    throw;
                }
            }
            return 0L;
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        private long QueryFsInformation(int level)
        {
            Trans2QueryFsInformationResponse response;
            response = new Trans2QueryFsInformationResponse(level);
            Send(new Trans2QueryFsInformation(level), response);
            if (Type == TypeShare)
            {
                _size = response.Info.GetCapacity();
                _sizeExpiration = Runtime.CurrentTimeMillis() + AttrExpirationPeriod;
            }
            return response.Info.GetFree();
        }

        /// <summary>
        /// Creates a directory with the path specified by this
        /// <code>SmbFile</code>.
        /// </summary>
        /// <remarks>
        /// Creates a directory with the path specified by this
        /// <code>SmbFile</code>. For this method to be successful, the target
        /// must not already exist. This method will fail when
        /// used with <code>smb://</code>, <code>smb://workgroup/</code>,
        /// <code>smb://server/</code>, or <code>smb://server/share/</code> URLs
        /// because workgroups, servers, and shares cannot be dynamically created
        /// (although in the future it may be possible to create shares).
        /// </remarks>
        /// <exception cref="SmbException">SmbException</exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual void Mkdir()
        {
            string path = GetUncPath0();
            if (path.Length == 1)
            {
                throw new SmbException("Invalid operation for workgroups, servers, or shares");
            }
            if (Log.Level >= 3)
            {
                Log.WriteLine("mkdir: " + path);
            }
            Send(new SmbComCreateDirectory(path), Blank_resp());
            _attrExpiration = _sizeExpiration = 0;
        }

        /// <summary>
        /// Creates a directory with the path specified by this <tt>SmbFile</tt>
        /// and any parent directories that do not exist.
        /// </summary>
        /// <remarks>
        /// Creates a directory with the path specified by this <tt>SmbFile</tt>
        /// and any parent directories that do not exist. This method will fail
        /// when used with <code>smb://</code>, <code>smb://workgroup/</code>,
        /// <code>smb://server/</code>, or <code>smb://server/share/</code> URLs
        /// because workgroups, servers, and shares cannot be dynamically created
        /// (although in the future it may be possible to create shares).
        /// </remarks>
        /// <exception cref="SmbException">SmbException</exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual void Mkdirs()
        {
            SmbFile parent;
            try
            {
                parent = new SmbFile(GetParent(), Auth);
            }
            catch (IOException)
            {
                return;
            }
            if (parent.Exists() == false)
            {
                parent.Mkdirs();
            }
            Mkdir();
        }

        /// <summary>Create a new file but fail if it already exists.</summary>
        /// <remarks>
        /// Create a new file but fail if it already exists. The check for
        /// existance of the file and it's creation are an atomic operation with
        /// respect to other filesystem activities.
        /// </remarks>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual void CreateNewFile()
        {
            if (GetUncPath0().Length == 1)
            {
                throw new SmbException("Invalid operation for workgroups, servers, or shares");
            }
            Close(Open0(ORdwr | OCreat | OExcl, 0, AttrNormal, 0), 0L);
        }

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        internal virtual void SetPathInformation(int attrs, long ctime, long mtime)
        {
            int f;
            int dir;
            Exists();
            dir = _attributes & AttrDirectory;
            f = Open0(ORdonly,
                      SmbConstants.FileWriteAttributes,
                      dir,
                      dir != 0
                        ? 0x0001
                        : 0x0040);
            Send(new Trans2SetFileInformation(f, attrs | dir, ctime, mtime),
                 new Trans2SetFileInformationResponse());
            Close(f, 0L);
            _attrExpiration = 0;
        }

        /// <summary>Set the create time of the file.</summary>
        /// <remarks>
        /// Set the create time of the file. The time is specified as milliseconds
        /// from Jan 1, 1970 which is the same as that which is returned by the
        /// <tt>createTime()</tt> method.
        /// <p/>
        /// This method does not apply to workgroups, servers, or shares.
        /// </remarks>
        /// <param name="time">the create time as milliseconds since Jan 1, 1970</param>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual void SetCreateTime(long time)
        {
            if (GetUncPath0().Length == 1)
            {
                throw new SmbException("Invalid operation for workgroups, servers, or shares");
            }
            SetPathInformation(0, time, 0L);
        }

        /// <summary>Set the last modified time of the file.</summary>
        /// <remarks>
        /// Set the last modified time of the file. The time is specified as milliseconds
        /// from Jan 1, 1970 which is the same as that which is returned by the
        /// <tt>lastModified()</tt>, <tt>getLastModified()</tt>, and <tt>getDate()</tt> methods.
        /// <p/>
        /// This method does not apply to workgroups, servers, or shares.
        /// </remarks>
        /// <param name="time">the last modified time as milliseconds since Jan 1, 1970</param>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual void SetLastModified(long time)
        {
            if (GetUncPath0().Length == 1)
            {
                throw new SmbException("Invalid operation for workgroups, servers, or shares");
            }
            SetPathInformation(0, 0L, time);
        }

        /// <summary>Return the attributes of this file.</summary>
        /// <remarks>
        /// Return the attributes of this file. Attributes are represented as a
        /// bitset that must be masked with <tt>ATTR_*</tt> constants to determine
        /// if they are set or unset. The value returned is suitable for use with
        /// the <tt>setAttributes()</tt> method.
        /// </remarks>
        /// <returns>the <tt>ATTR_*</tt> attributes associated with this file</returns>
        /// <exception cref="SmbException">SmbException</exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual int GetAttributes()
        {
            if (GetUncPath0().Length == 1)
            {
                return 0;
            }
            Exists();
            return _attributes & AttrGetMask;
        }

        /// <summary>Set the attributes of this file.</summary>
        /// <remarks>
        /// Set the attributes of this file. Attributes are composed into a
        /// bitset by bitwise ORing the <tt>ATTR_*</tt> constants. Setting the
        /// value returned by <tt>getAttributes</tt> will result in both files
        /// having the same attributes.
        /// </remarks>
        /// <exception cref="SmbException">SmbException</exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual void SetAttributes(int attrs)
        {
            if (GetUncPath0().Length == 1)
            {
                throw new SmbException("Invalid operation for workgroups, servers, or shares");
            }
            SetPathInformation(attrs & AttrSetMask, 0L, 0L);
        }

        /// <summary>Make this file read-only.</summary>
        /// <remarks>
        /// Make this file read-only. This is shorthand for <tt>setAttributes(
        /// getAttributes() | ATTR_READ_ONLY )</tt>.
        /// </remarks>
        /// <exception cref="SmbException">SmbException</exception>
        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        public virtual void SetReadOnly()
        {
            SetAttributes(GetAttributes() | AttrReadonly);
        }

        /// <summary>Turn off the read-only attribute of this file.</summary>
        /// <remarks>
        /// Turn off the read-only attribute of this file. This is shorthand for
        /// <tt>setAttributes( getAttributes() & ~ATTR_READONLY )</tt>.
        /// </remarks>
        /// <exception cref="SmbException">SmbException</exception>
        /// <exception cref="SmbException"></exception>
        public virtual void SetReadWrite()
        {
            SetAttributes(GetAttributes() & ~AttrReadonly);
        }

        /// <summary>
        /// Returns a
        /// <see cref="System.Uri">System.Uri</see>
        /// for this <code>SmbFile</code>. The
        /// <code>URL</code> may be used as any other <code>URL</code> might to
        /// access an SMB resource. Currently only retrieving data and information
        /// is supported (i.e. no <tt>doOutput</tt>).
        /// </summary>
        /// <returns>
        /// A new <code>
        /// <see cref="System.Uri">System.Uri</see>
        /// </code> for this <code>SmbFile</code>
        /// </returns>
        /// <exception cref="System.UriFormatException">System.UriFormatException</exception>
        [Obsolete(@"Use getURL() instead")]
        public virtual Uri ToUrl()
        {
            return Url;
        }

        /// <summary>
        /// Computes a hashCode for this file based on the URL string and IP
        /// address if the server.
        /// </summary>
        /// <remarks>
        /// Computes a hashCode for this file based on the URL string and IP
        /// address if the server. The hashing function uses the hashcode of the
        /// server address, the canonical representation of the URL, and does not
        /// compare authentication information. In essance, two
        /// <code>SmbFile</code> objects that refer to
        /// the same file should generate the same hashcode provided it is possible
        /// to make such a determination.
        /// </remarks>
        /// <returns>A hashcode for this abstract file</returns>
        /// <exception cref="SmbException">SmbException</exception>
        public override int GetHashCode()
        {
            int hash;
            try
            {
                hash = GetAddress().GetHashCode();
            }
            catch (UnknownHostException)
            {
                hash = GetServer().ToUpper().GetHashCode();
            }
            GetUncPath0();
            return hash + _canon.ToUpper().GetHashCode();
        }

        protected internal virtual bool PathNamesPossiblyEqual(string path1, string path2)
        {
            int p1;
            int p2;
            int l1;
            int l2;
            // if unsure return this method returns true
            p1 = path1.LastIndexOf('/');
            p2 = path2.LastIndexOf('/');
            l1 = path1.Length - p1;
            l2 = path2.Length - p2;
            // anything with dots voids comparison
            if (l1 > 1 && path1[p1 + 1] == '.')
            {
                return true;
            }
            if (l2 > 1 && path2[p2 + 1] == '.')
            {
                return true;
            }
            return l1 == l2 && path1.RegionMatches(true, p1, path2, p2, l1);
        }

        /// <summary>Tests to see if two <code>SmbFile</code> objects are equal.</summary>
        /// <remarks>
        /// Tests to see if two <code>SmbFile</code> objects are equal. Two
        /// SmbFile objects are equal when they reference the same SMB
        /// resource. More specifically, two <code>SmbFile</code> objects are
        /// equals if their server IP addresses are equal and the canonicalized
        /// representation of their URLs, minus authentication parameters, are
        /// case insensitivly and lexographically equal.
        /// <p/>
        /// For example, assuming the server <code>angus</code> resolves to the
        /// <code>192.168.1.15</code> IP address, the below URLs would result in
        /// <code>SmbFile</code>s that are equal.
        /// <p><blockquote><pre>
        /// smb://192.168.1.15/share/DIR/foo.txt
        /// smb://angus/share/data/../dir/foo.txt
        /// </pre></blockquote>
        /// </remarks>
        /// <param name="obj">Another <code>SmbFile</code> object to compare for equality</param>
        /// <returns>
        /// <code>true</code> if the two objects refer to the same SMB resource
        /// and <code>false</code> otherwise
        /// </returns>
        /// <exception cref="SmbException">SmbException</exception>
        public override bool Equals(object obj)
        {
            if (obj is SmbFile)
            {
                SmbFile f = (SmbFile)obj;
                bool ret;
                if (this == f)
                {
                    return true;
                }
                if (PathNamesPossiblyEqual(Url.AbsolutePath, f.Url.AbsolutePath))
                {
                    GetUncPath0();
                    f.GetUncPath0();
                    if (Runtime.EqualsIgnoreCase(_canon, f._canon))
                    {
                        try
                        {
                            ret = GetAddress().Equals(f.GetAddress());
                        }
                        catch (UnknownHostException)
                        {
                            ret = Runtime.EqualsIgnoreCase(GetServer(), f.GetServer());
                        }
                        return ret;
                    }
                }
            }
            return false;
        }

        /// <summary>Returns the string representation of this SmbFile object.</summary>
        /// <remarks>
        /// Returns the string representation of this SmbFile object. This will
        /// be the same as the URL used to construct this <code>SmbFile</code>.
        /// This method will return the same value
        /// as <code>getPath</code>.
        /// </remarks>
        /// <returns>The original URL representation of this SMB resource</returns>
        /// <exception cref="SmbException">SmbException</exception>
        public override string ToString()
        {
            return Url.ToString();
        }

        /// <summary>This URLConnection method just returns the result of <tt>length()</tt>.</summary>
        /// <remarks>This URLConnection method just returns the result of <tt>length()</tt>.</remarks>
        /// <returns>the length of this file or 0 if it refers to a directory</returns>
        public int GetContentLength()
        {
            try
            {
                return (int)(Length() & unchecked(0xFFFFFFFFL));
            }
            catch (SmbException)
            {
            }
            return 0;
        }

        /// <summary>This URLConnection method just returns the result of <tt>lastModified</tt>.
        /// </summary>
        /// <remarks>This URLConnection method just returns the result of <tt>lastModified</tt>.
        /// </remarks>
        /// <returns>the last modified data as milliseconds since Jan 1, 1970</returns>
        public long GetDate()
        {
            try
            {
                return LastModified();
            }
            catch (SmbException)
            {
            }
            return 0L;
        }

        /// <summary>This URLConnection method just returns the result of <tt>lastModified</tt>.
        /// </summary>
        /// <remarks>This URLConnection method just returns the result of <tt>lastModified</tt>.
        /// </remarks>
        /// <returns>the last modified data as milliseconds since Jan 1, 1970</returns>
        public long GetLastModified()
        {
            try
            {
                return LastModified();
            }
            catch (SmbException)
            {
            }
            return 0L;
        }

        /// <summary>This URLConnection method just returns a new <tt>SmbFileInputStream</tt> created with this file.
        /// </summary>
        /// <remarks>This URLConnection method just returns a new <tt>SmbFileInputStream</tt> created with this file.
        /// </remarks>
        /// <exception cref="System.IO.IOException">thrown by <tt>SmbFileInputStream</tt> constructor
        /// </exception>
        public InputStream GetInputStream()
        {
            return new SmbFileInputStream(this);
        }

        /// <summary>This URLConnection method just returns a new <tt>SmbFileOutputStream</tt> created with this file.
        /// </summary>
        /// <remarks>This URLConnection method just returns a new <tt>SmbFileOutputStream</tt> created with this file.
        /// </remarks>
        /// <exception cref="System.IO.IOException">thrown by <tt>SmbFileOutputStream</tt> constructor
        /// </exception>
        public OutputStream GetOutputStream()
        {
            return new SmbFileOutputStream(this);
        }

        /// <exception cref="System.IO.IOException"></exception>
        private void ProcessAces(Ace[] aces, bool resolveSids)
        {
            string server = GetServerWithDfs();
            int ai;
            if (resolveSids)
            {
                Sid[] sids = new Sid[aces.Length];
                string[] names = null;
                for (ai = 0; ai < aces.Length; ai++)
                {
                    sids[ai] = aces[ai].Sid;
                }
                for (int off = 0; off < sids.Length; off += 64)
                {
                    int len = sids.Length - off;
                    if (len > 64)
                    {
                        len = 64;
                    }
                    Sid.ResolveSids(server, Auth, sids, off, len);
                }
            }
            else
            {
                for (ai = 0; ai < aces.Length; ai++)
                {
                    aces[ai].Sid.OriginServer = server;
                    aces[ai].Sid.OriginAuth = Auth;
                }
            }
        }

        /// <summary>
        /// Return an array of Access Control Entry (ACE) objects representing
        /// the security descriptor associated with this file or directory.
        /// </summary>
        /// <remarks>
        /// Return an array of Access Control Entry (ACE) objects representing
        /// the security descriptor associated with this file or directory.
        /// If no DACL is present, null is returned. If the DACL is empty, an array with 0 elements is returned.
        /// </remarks>
        /// <param name="resolveSids">
        /// Attempt to resolve the SIDs within each ACE form
        /// their numeric representation to their corresponding account names.
        /// </param>
        /// <exception cref="System.IO.IOException"></exception>
        public virtual Ace[] GetSecurity(bool resolveSids)
        {
            int f;
            Ace[] aces;
            f = Open0(ORdonly, SmbConstants.ReadControl, 0, IsDirectory() ? 1 : 0);
            NtTransQuerySecurityDesc request = new NtTransQuerySecurityDesc(f, 0x04);
            NtTransQuerySecurityDescResponse response = new NtTransQuerySecurityDescResponse();
            try
            {
                Send(request, response);
            }
            finally
            {
                Close(f, 0L);
            }
            aces = response.SecurityDescriptor.Aces;
            if (aces != null)
            {
                ProcessAces(aces, resolveSids);
            }
            return aces;
        }

        /// <summary>
        /// Return an array of Access Control Entry (ACE) objects representing
        /// the share permissions on the share exporting this file or directory.
        /// </summary>
        /// <remarks>
        /// Return an array of Access Control Entry (ACE) objects representing
        /// the share permissions on the share exporting this file or directory.
        /// If no DACL is present, null is returned. If the DACL is empty, an array with 0 elements is returned.
        /// <p>
        /// Note that this is different from calling <tt>getSecurity</tt> on a
        /// share. There are actually two different ACLs for shares - the ACL on
        /// the share and the ACL on the folder being shared.
        /// Go to <i>Computer Management</i>
        /// &gt; <i>System Tools</i> &gt; <i>Shared Folders</i> &gt <i>Shares</i> and
        /// look at the <i>Properties</i> for a share. You will see two tabs - one
        /// for "Share Permissions" and another for "Security". These correspond to
        /// the ACLs returned by <tt>getShareSecurity</tt> and <tt>getSecurity</tt>
        /// respectively.
        /// </remarks>
        /// <param name="resolveSids">
        /// Attempt to resolve the SIDs within each ACE form
        /// their numeric representation to their corresponding account names.
        /// </param>
        /// <exception cref="System.IO.IOException"></exception>
        public virtual Ace[] GetShareSecurity(bool resolveSids)
        {
            string p = Url.AbsolutePath;
            MsrpcShareGetInfo rpc;
            DcerpcHandle handle;
            Ace[] aces;
            ResolveDfs(null);
            string server = GetServerWithDfs();
            rpc = new MsrpcShareGetInfo(server, Tree.Share);
            handle = DcerpcHandle.GetHandle("ncacn_np:" + server + "[\\PIPE\\srvsvc]", Auth);
            try
            {
                handle.Sendrecv(rpc);
                if (rpc.Retval != 0)
                {
                    throw new SmbException(rpc.Retval, true);
                }
                aces = rpc.GetSecurity();
                if (aces != null)
                {
                    ProcessAces(aces, resolveSids);
                }
            }
            finally
            {
                try
                {
                    handle.Close();
                }
                catch (IOException ioe)
                {
                    if (Log.Level >= 1)
                    {
                        Runtime.PrintStackTrace(ioe, Log);
                    }
                }
            }
            return aces;
        }

        /// <summary>
        /// Return an array of Access Control Entry (ACE) objects representing
        /// the security descriptor associated with this file or directory.
        /// </summary>
        /// <remarks>
        /// Return an array of Access Control Entry (ACE) objects representing
        /// the security descriptor associated with this file or directory.
        /// <p>
        /// Initially, the SIDs within each ACE will not be resolved however when
        /// <tt>getType()</tt>, <tt>getDomainName()</tt>, <tt>getAccountName()</tt>,
        /// or <tt>toString()</tt> is called, the names will attempt to be
        /// resolved. If the names cannot be resolved (e.g. due to temporary
        /// network failure), the said methods will return default values (usually
        /// <tt>S-X-Y-Z</tt> strings of fragments of).
        /// <p>
        /// Alternatively <tt>getSecurity(true)</tt> may be used to resolve all
        /// SIDs together and detect network failures.
        /// </remarks>
        /// <exception cref="System.IO.IOException"></exception>
        public virtual Ace[] GetSecurity()
        {
            return GetSecurity(false);
        }
    }
}