jellyfin/Emby.Common.Implementations/IO/SharpCifs/Smb/SmbFileInputStream.cs
2017-04-01 20:36:06 -04:00

340 lines
9.8 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.IO;
using SharpCifs.Util.Sharpen;
using SharpCifs.Util.Transport;
namespace SharpCifs.Smb
{
/// <summary>This InputStream can read bytes from a file on an SMB file server.</summary>
/// <remarks>This InputStream can read bytes from a file on an SMB file server. Offsets are 64 bits.
/// </remarks>
public class SmbFileInputStream : InputStream
{
private long _fp;
private int _readSize;
private int _openFlags;
private int _access;
private byte[] _tmp = new byte[1];
internal SmbFile File;
/// <summary>
/// Creates an
/// <see cref="System.IO.InputStream">System.IO.InputStream</see>
/// for reading bytes from a file on
/// an SMB server addressed by the <code>url</code> parameter. See
/// <see cref="SmbFile">SmbFile</see>
/// for a detailed description and examples of the smb
/// URL syntax.
/// </summary>
/// <param name="url">An smb URL string representing the file to read from</param>
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
/// <exception cref="System.UriFormatException"></exception>
/// <exception cref="UnknownHostException"></exception>
public SmbFileInputStream(string url) : this(new SmbFile(url))
{
}
/// <summary>
/// Creates an
/// <see cref="System.IO.InputStream">System.IO.InputStream</see>
/// for reading bytes from a file on
/// an SMB server represented by the
/// <see cref="SmbFile">SmbFile</see>
/// parameter. See
/// <see cref="SmbFile">SmbFile</see>
/// for a detailed description and examples of
/// the smb URL syntax.
/// </summary>
/// <param name="file">An <code>SmbFile</code> specifying the file to read from</param>
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
/// <exception cref="System.UriFormatException"></exception>
/// <exception cref="UnknownHostException"></exception>
public SmbFileInputStream(SmbFile file) : this(file, SmbFile.ORdonly)
{
}
/// <exception cref="SharpCifs.Smb.SmbException"></exception>
/// <exception cref="System.UriFormatException"></exception>
/// <exception cref="UnknownHostException"></exception>
internal SmbFileInputStream(SmbFile file, int openFlags)
{
this.File = file;
this._openFlags = openFlags & 0xFFFF;
_access = ((int)(((uint)openFlags) >> 16)) & 0xFFFF;
if (file.Type != SmbFile.TypeNamedPipe)
{
file.Open(openFlags, _access, SmbFile.AttrNormal, 0);
this._openFlags &= ~(SmbFile.OCreat | SmbFile.OTrunc);
}
else
{
file.Connect0();
}
_readSize = Math.Min(file.Tree.Session.transport.RcvBufSize - 70, file.Tree.Session
.transport.Server.MaxBufferSize - 70);
}
protected internal virtual IOException SeToIoe(SmbException se)
{
IOException ioe = se;
Exception root = se.GetRootCause();
if (root is TransportException)
{
ioe = (TransportException)root;
root = ((TransportException)ioe).GetRootCause();
}
if (root is Exception)
{
ioe = new IOException(root.Message);
ioe.InitCause(root);
}
return ioe;
}
/// <summary>Closes this input stream and releases any system resources associated with the stream.
/// </summary>
/// <remarks>Closes this input stream and releases any system resources associated with the stream.
/// </remarks>
/// <exception cref="System.IO.IOException">if a network error occurs</exception>
public override void Close()
{
try
{
File.Close();
_tmp = null;
}
catch (SmbException se)
{
throw SeToIoe(se);
}
}
/// <summary>Reads a byte of data from this input stream.</summary>
/// <remarks>Reads a byte of data from this input stream.</remarks>
/// <exception cref="System.IO.IOException">if a network error occurs</exception>
public override int Read()
{
// need oplocks to cache otherwise use BufferedInputStream
if (Read(_tmp, 0, 1) == -1)
{
return -1;
}
return _tmp[0] & unchecked(0xFF);
}
/// <summary>Reads up to b.length bytes of data from this input stream into an array of bytes.
/// </summary>
/// <remarks>Reads up to b.length bytes of data from this input stream into an array of bytes.
/// </remarks>
/// <exception cref="System.IO.IOException">if a network error occurs</exception>
public override int Read(byte[] b)
{
return Read(b, 0, b.Length);
}
/// <summary>Reads up to len bytes of data from this input stream into an array of bytes.
/// </summary>
/// <remarks>Reads up to len bytes of data from this input stream into an array of bytes.
/// </remarks>
/// <exception cref="System.IO.IOException">if a network error occurs</exception>
public override int Read(byte[] b, int off, int len)
{
return ReadDirect(b, off, len);
}
/// <exception cref="System.IO.IOException"></exception>
public virtual int ReadDirect(byte[] b, int off, int len)
{
if (len <= 0)
{
return 0;
}
long start = _fp;
if (_tmp == null)
{
throw new IOException("Bad file descriptor");
}
// ensure file is open
File.Open(_openFlags, _access, SmbFile.AttrNormal, 0);
if (File.Log.Level >= 4)
{
File.Log.WriteLine("read: fid=" + File.Fid + ",off=" + off + ",len=" + len);
}
SmbComReadAndXResponse response = new SmbComReadAndXResponse(b, off);
if (File.Type == SmbFile.TypeNamedPipe)
{
response.ResponseTimeout = 0;
}
int r;
int n;
do
{
r = len > _readSize ? _readSize : len;
if (File.Log.Level >= 4)
{
File.Log.WriteLine("read: len=" + len + ",r=" + r + ",fp=" + _fp);
}
try
{
SmbComReadAndX request = new SmbComReadAndX(File.Fid, _fp, r, null);
if (File.Type == SmbFile.TypeNamedPipe)
{
request.MinCount = request.MaxCount = request.Remaining = 1024;
}
//<2F><><EFBFBD><EFBFBD><EFBFBD>œǂݍ<C782><DD8D><EFBFBD><EFBFBD>ł<EFBFBD><C582><EFBFBD><EFBFBD><EFBFBD><E782B5><EFBFBD>B
File.Send(request, response);
}
catch (SmbException se)
{
if (File.Type == SmbFile.TypeNamedPipe && se.GetNtStatus() == NtStatus.NtStatusPipeBroken)
{
return -1;
}
throw SeToIoe(se);
}
if ((n = response.DataLength) <= 0)
{
return (int)((_fp - start) > 0L ? _fp - start : -1);
}
_fp += n;
len -= n;
response.Off += n;
}
while (len > 0 && n == r);
return (int)(_fp - start);
}
/// <summary>This stream class is unbuffered.</summary>
/// <remarks>
/// This stream class is unbuffered. Therefore this method will always
/// return 0 for streams connected to regular files. However, a
/// stream created from a Named Pipe this method will query the server using a
/// "peek named pipe" operation and return the number of available bytes
/// on the server.
/// </remarks>
/// <exception cref="System.IO.IOException"></exception>
public override int Available()
{
SmbNamedPipe pipe;
TransPeekNamedPipe req;
TransPeekNamedPipeResponse resp;
if (File.Type != SmbFile.TypeNamedPipe)
{
return 0;
}
try
{
pipe = (SmbNamedPipe)File;
File.Open(SmbFile.OExcl, pipe.PipeType & 0xFF0000, SmbFile.AttrNormal
, 0);
req = new TransPeekNamedPipe(File.Unc, File.Fid);
resp = new TransPeekNamedPipeResponse(pipe);
pipe.Send(req, resp);
if (resp.status == TransPeekNamedPipeResponse.StatusDisconnected || resp.status
== TransPeekNamedPipeResponse.StatusServerEndClosed)
{
File.Opened = false;
return 0;
}
return resp.Available;
}
catch (SmbException se)
{
throw SeToIoe(se);
}
}
/// <summary>Skip n bytes of data on this stream.</summary>
/// <remarks>
/// Skip n bytes of data on this stream. This operation will not result
/// in any IO with the server. Unlink <tt>InputStream</tt> value less than
/// the one provided will not be returned if it exceeds the end of the file
/// (if this is a problem let us know).
/// </remarks>
/// <exception cref="System.IO.IOException"></exception>
public override long Skip(long n)
{
if (n > 0)
{
_fp += n;
return n;
}
return 0;
}
/// <summary>
/// Position in Stream
/// </summary>
/// <remarks>
/// Add by dobes
/// mod interface to WrappedSystemStream readable, for random access.
/// </remarks>
internal override long Position {
get { return this._fp; }
set
{
var tmpPos = value;
var length = File.Length();
if (tmpPos < 0)
tmpPos = 0;
else if (length < tmpPos)
tmpPos = length;
this._fp = tmpPos;
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
/// <remarks>
/// Add by dobes
/// mod interface to WrappedSystemStream readable, for random access.
/// </remarks>
internal override bool CanSeek()
{
return (File.Length() >= 0);
}
/// <summary>
/// Get file length
/// </summary>
public override long Length
{
get { return File.Length(); }
}
}
}