jellyfin/Emby.Common.Implementations/IO/SharpCifs/Smb/SmbComOpenAndX.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 SharpCifs.Util;
using SharpCifs.Util.Sharpen;

namespace SharpCifs.Smb
{
    internal class SmbComOpenAndX : AndXServerMessageBlock
    {
        private const int FlagsReturnAdditionalInfo = 0x01;

        private const int FlagsRequestOplock = 0x02;

        private const int FlagsRequestBatchOplock = 0x04;

        private const int SharingCompatibility = 0x00;

        private const int SharingDenyReadWriteExecute = 0x10;

        private const int SharingDenyWrite = 0x20;

        private const int SharingDenyReadExecute = 0x30;

        private const int SharingDenyNone = 0x40;

        private const int DoNotCache = 0x1000;

        private const int WriteThrough = 0x4000;

        private const int OpenFnCreate = 0x10;

        private const int OpenFnFailIfExists = 0x00;

        private const int OpenFnOpen = 0x01;

        private const int OpenFnTrunc = 0x02;

        private static readonly int BatchLimit
            = Config.GetInt("jcifs.smb.client.OpenAndX.ReadAndX", 1);

        internal int flags;

        internal int DesiredAccess;

        internal int SearchAttributes;

        internal int FileAttributes;

        internal int CreationTime;

        internal int OpenFunction;

        internal int AllocationSize;

        internal SmbComOpenAndX(string fileName,
                                int access,
                                int flags,
                                ServerMessageBlock andx) : base(andx)
        {
            // flags (not the same as flags constructor argument)
            // Access Mode Encoding for desiredAccess
            // bit 12
            // bit 14
            // flags is NOT the same as flags member
            Path = fileName;
            Command = SmbComOpenAndx;
            DesiredAccess = access & 0x3;
            if (DesiredAccess == 0x3)
            {
                DesiredAccess = 0x2;
            }
            DesiredAccess |= SharingDenyNone;
            DesiredAccess &= ~0x1;
            // Win98 doesn't like GENERIC_READ ?! -- get Access Denied.
            // searchAttributes
            SearchAttributes = SmbConstants.AttrDirectory
                               | SmbConstants.AttrHidden
                               | SmbConstants.AttrSystem;
            // fileAttributes
            FileAttributes = 0;
            // openFunction
            if ((flags & SmbFile.OTrunc) == SmbFile.OTrunc)
            {
                // truncate the file
                if ((flags & SmbFile.OCreat) == SmbFile.OCreat)
                {
                    // create it if necessary
                    OpenFunction = OpenFnTrunc | OpenFnCreate;
                }
                else
                {
                    OpenFunction = OpenFnTrunc;
                }
            }
            else
            {
                // don't truncate the file
                if ((flags & SmbFile.OCreat) == SmbFile.OCreat)
                {
                    // create it if necessary
                    if ((flags & SmbFile.OExcl) == SmbFile.OExcl)
                    {
                        // fail if already exists
                        OpenFunction = OpenFnCreate | OpenFnFailIfExists;
                    }
                    else
                    {
                        OpenFunction = OpenFnCreate | OpenFnOpen;
                    }
                }
                else
                {
                    OpenFunction = OpenFnOpen;
                }
            }
        }

        internal override int GetBatchLimit(byte command)
        {
            return command == SmbComReadAndx ? BatchLimit : 0;
        }

        internal override int WriteParameterWordsWireFormat(byte[] dst, int dstIndex)
        {
            int start = dstIndex;
            WriteInt2(flags, dst, dstIndex);
            dstIndex += 2;
            WriteInt2(DesiredAccess, dst, dstIndex);
            dstIndex += 2;
            WriteInt2(SearchAttributes, dst, dstIndex);
            dstIndex += 2;
            WriteInt2(FileAttributes, dst, dstIndex);
            dstIndex += 2;
            CreationTime = 0;
            WriteInt4(CreationTime, dst, dstIndex);
            dstIndex += 4;
            WriteInt2(OpenFunction, dst, dstIndex);
            dstIndex += 2;
            WriteInt4(AllocationSize, dst, dstIndex);
            dstIndex += 4;
            for (int i = 0; i < 8; i++)
            {
                dst[dstIndex++] = 0x00;
            }
            return dstIndex - start;
        }

        internal override int WriteBytesWireFormat(byte[] dst, int dstIndex)
        {
            int start = dstIndex;
            if (UseUnicode)
            {
                dst[dstIndex++] = (byte)('\0');
            }
            dstIndex += WriteString(Path, dst, dstIndex);
            return dstIndex - start;
        }

        internal override int ReadParameterWordsWireFormat(byte[] buffer, int bufferIndex)
        {
            return 0;
        }

        internal override int ReadBytesWireFormat(byte[] buffer, int bufferIndex)
        {
            return 0;
        }

        public override string ToString()
        {
            return "SmbComOpenAndX["
                        + base.ToString()
                        + ",flags=0x" + Hexdump.ToHexString(flags, 2)
                        + ",desiredAccess=0x" + Hexdump.ToHexString(DesiredAccess, 4)
                        + ",searchAttributes=0x" + Hexdump.ToHexString(SearchAttributes, 4)
                        + ",fileAttributes=0x" + Hexdump.ToHexString(FileAttributes, 4)
                        + ",creationTime=" + Extensions.CreateDate(CreationTime)
                        + ",openFunction=0x" + Hexdump.ToHexString(OpenFunction, 2)
                        + ",allocationSize=" + AllocationSize
                        + ",fileName=" + Path + "]";
        }
    }
}