Cutlery/jellyfin
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin.git synced 2025-10-31 02:27:18 -04:00
Code Issues Packages Projects Releases Wiki Activity
jellyfin/Emby.Server.Implementations/IO/SharpCifs/Smb/SmbFile.cs

3756 lines
143 KiB
C#
Raw Blame History

// 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;
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
{
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(Jcifs.Smb.SmbFile context, string name, int type, int attributes
, long createTime, long lastModified, long size)
: this(context.IsWorkgroup0() ?
new Uri(null, "smb://" + name + "/") : new Uri(context.url,
name + ((attributes & ATTR_DIRECTORY) > 0 ? "/" : string.Empty)))*/
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();
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);
}
}
}
Reference in New Issue View Git Blame Copy Permalink