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

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

namespace SharpCifs.Smb
{
    internal class TransactNamedPipeInputStream : SmbFileInputStream
    {
        private const int InitPipeSize = 4096;

        private byte[] _pipeBuf = new byte[InitPipeSize];

        private int _begIdx;

        private int _nxtIdx;

        private int _used;

        private bool _dcePipe;

        internal object Lock;

        /// <exception cref="SharpCifs.Smb.SmbException"></exception>
        /// <exception cref="System.UriFormatException"></exception>
        /// <exception cref="UnknownHostException"></exception>
        internal TransactNamedPipeInputStream(SmbNamedPipe pipe) 
            : base(pipe, (pipe.PipeType & unchecked((int)(0xFFFF00FF))) | SmbFile.OExcl)
        {
            _dcePipe = (pipe.PipeType & SmbNamedPipe.PipeTypeDceTransact) 
                            != SmbNamedPipe.PipeTypeDceTransact;
            Lock = new object();
        }

        /// <exception cref="System.IO.IOException"></exception>
        public override int Read()
        {
            int result = -1;
            lock (Lock)
            {
                try
                {
                    while (_used == 0)
                    {
                        Runtime.Wait(Lock);
                    }
                }
                catch (Exception ie)
                {
                    throw new IOException(ie.Message);
                }
                result = _pipeBuf[_begIdx] & unchecked(0xFF);
                _begIdx = (_begIdx + 1) % _pipeBuf.Length;
            }
            return result;
        }

        /// <exception cref="System.IO.IOException"></exception>
        public override int Read(byte[] b)
        {
            return Read(b, 0, b.Length);
        }

        /// <exception cref="System.IO.IOException"></exception>
        public override int Read(byte[] b, int off, int len)
        {
            int result = -1;
            int i;
            if (len <= 0)
            {
                return 0;
            }
            lock (Lock)
            {
                try
                {
                    while (_used == 0)
                    {
                        Runtime.Wait(Lock);
                    }
                }
                catch (Exception ie)
                {
                    throw new IOException(ie.Message);
                }
                i = _pipeBuf.Length - _begIdx;
                result = len > _used ? _used : len;
                if (_used > i && result > i)
                {
                    Array.Copy(_pipeBuf, _begIdx, b, off, i);
                    off += i;
                    Array.Copy(_pipeBuf, 0, b, off, result - i);
                }
                else
                {
                    Array.Copy(_pipeBuf, _begIdx, b, off, result);
                }
                _used -= result;
                _begIdx = (_begIdx + result) % _pipeBuf.Length;
            }
            return result;
        }

        /// <exception cref="System.IO.IOException"></exception>
        public override int Available()
        {
            if (File.Log.Level >= 3)
            {
                File.Log.WriteLine(
                    "Named Pipe available() does not apply to TRANSACT Named Pipes");
            }
            return 0;
        }

        internal virtual int Receive(byte[] b, int off, int len)
        {
            int i;
            if (len > (_pipeBuf.Length - _used))
            {
                byte[] tmp;
                int newSize;
                newSize = _pipeBuf.Length * 2;
                if (len > (newSize - _used))
                {
                    newSize = len + _used;
                }
                tmp = _pipeBuf;
                _pipeBuf = new byte[newSize];
                i = tmp.Length - _begIdx;
                if (_used > i)
                {
                    Array.Copy(tmp, _begIdx, _pipeBuf, 0, i);
                    Array.Copy(tmp, 0, _pipeBuf, i, _used - i);
                }
                else
                {
                    Array.Copy(tmp, _begIdx, _pipeBuf, 0, _used);
                }
                _begIdx = 0;
                _nxtIdx = _used;
                tmp = null;
            }
            i = _pipeBuf.Length - _nxtIdx;
            if (len > i)
            {
                Array.Copy(b, off, _pipeBuf, _nxtIdx, i);
                off += i;
                Array.Copy(b, off, _pipeBuf, 0, len - i);
            }
            else
            {
                Array.Copy(b, off, _pipeBuf, _nxtIdx, len);
            }
            _nxtIdx = (_nxtIdx + len) % _pipeBuf.Length;
            _used += len;
            return len;
        }

        /// <exception cref="System.IO.IOException"></exception>
        public virtual int Dce_read(byte[] b, int off, int len)
        {
            return base.Read(b, off, len);
        }
    }
}