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

namespace SharpCifs.Smb
{
    public abstract class ServerMessageBlock : Response
    {
        internal static LogStream Log = LogStream.GetInstance();

        internal static long Ticks1601 = new DateTime(1601, 1, 1).Ticks;

        internal static readonly byte[] Header =
        {
            0xFF, (byte)('S'), (byte)('M'), (byte)('B'), 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00
        };

        internal static void WriteInt2(long val, byte[] dst, int dstIndex)
        {
            dst[dstIndex] = unchecked((byte)(val));
            dst[++dstIndex] = unchecked((byte)(val >> 8));
        }

        internal static void WriteInt4(long val, byte[] dst, int dstIndex)
        {
            dst[dstIndex] = unchecked((byte)(val));
            dst[++dstIndex] = unchecked((byte)(val >>= 8));
            dst[++dstIndex] = unchecked((byte)(val >>= 8));
            dst[++dstIndex] = unchecked((byte)(val >> 8));
        }

        internal static int ReadInt2(byte[] src, int srcIndex)
        {
            return unchecked(src[srcIndex] & 0xFF)
                             + ((src[srcIndex + 1] & 0xFF) << 8);
        }

        internal static int ReadInt4(byte[] src, int srcIndex)
        {
            return unchecked(src[srcIndex] & 0xFF)
                             + ((src[srcIndex + 1] & 0xFF) << 8)
                             + ((src[srcIndex + 2] & 0xFF) << 16)
                             + ((src[srcIndex + 3] & 0xFF) << 24);
        }

        internal static long ReadInt8(byte[] src, int srcIndex)
        {
            return unchecked(ReadInt4(src, srcIndex) & unchecked(0xFFFFFFFFL))
                   + unchecked((long)(ReadInt4(src, srcIndex + 4)) << 32);
        }

        internal static void WriteInt8(long val, byte[] dst, int dstIndex)
        {
            dst[dstIndex] = unchecked((byte)(val));
            dst[++dstIndex] = unchecked((byte)(val >>= 8));
            dst[++dstIndex] = unchecked((byte)(val >>= 8));
            dst[++dstIndex] = unchecked((byte)(val >>= 8));
            dst[++dstIndex] = unchecked((byte)(val >>= 8));
            dst[++dstIndex] = unchecked((byte)(val >>= 8));
            dst[++dstIndex] = unchecked((byte)(val >>= 8));
            dst[++dstIndex] = unchecked((byte)(val >> 8));
        }

        internal static long ReadTime(byte[] src, int srcIndex)
        {
            int low = ReadInt4(src, srcIndex);
            int hi = ReadInt4(src, srcIndex + 4);
            long t = ((long)hi << (int)32L) | (low & unchecked((long)(0xFFFFFFFFL)));
            t = (t / 10000L - SmbConstants.MillisecondsBetween1970And1601);
            return t;
        }

        internal static void WriteTime(long t, byte[] dst, int dstIndex)
        {
            if (t != 0L)
            {
                t = (t + SmbConstants.MillisecondsBetween1970And1601) * 10000L;
            }
            WriteInt8(t, dst, dstIndex);
        }

        internal static long ReadUTime(byte[] buffer, int bufferIndex)
        {
            return ReadInt4(buffer, bufferIndex) * 1000L;
        }

        internal static void WriteUTime(long t, byte[] dst, int dstIndex)
        {
            if (t == 0L || t == unchecked((long)(0xFFFFFFFFFFFFFFFFL)))
            {
                WriteInt4(unchecked((int)(0xFFFFFFFF)), dst, dstIndex);
                return;
            }
            // t isn't in DST either
            WriteInt4((int)(t / 1000L), dst, dstIndex);
        }

        internal const byte SmbComCreateDirectory = 0x00;

        internal const byte SmbComDeleteDirectory = 0x01;

        internal const byte SmbComClose = 0x04;

        internal const byte SmbComDelete = 0x06;

        internal const byte SmbComRename = 0x07;

        internal const byte SmbComQueryInformation = 0x08;

        internal const byte SmbComWrite = 0x0B;

        internal const byte SmbComCheckDirectory = 0x10;

        internal const byte SmbComTransaction = 0x25;

        internal const byte SmbComTransactionSecondary = 0x26;

        internal const byte SmbComMove = 0x2A;

        internal const byte SmbComEcho = 0x2B;

        internal const byte SmbComOpenAndx = 0x2D;

        internal const byte SmbComReadAndx = 0x2E;

        internal const byte SmbComWriteAndx = 0x2F;

        internal const byte SmbComTransaction2 = 0x32;

        internal const byte SmbComFindClose2 = 0x34;

        internal const byte SmbComTreeDisconnect = 0x71;

        internal const byte SmbComNegotiate = 0x72;

        internal const byte SmbComSessionSetupAndx = 0x73;

        internal const byte SmbComLogoffAndx = 0x74;

        internal const byte SmbComTreeConnectAndx = 0x75;

        internal const byte SmbComNtTransact = 0xA0;

        internal const byte SmbComNtTransactSecondary = 0xA1;

        internal const byte SmbComNtCreateAndx = 0xA2;

        internal byte Command;

        internal byte Flags;

        internal int HeaderStart;

        internal int Length;

        internal int BatchLevel;

        internal int ErrorCode;

        internal int Flags2;

        internal int Tid;

        internal int Pid;

        internal int Uid;

        internal int Mid;

        internal int WordCount;

        internal int ByteCount;

        internal bool UseUnicode;

        internal bool Received;

        internal bool ExtendedSecurity;

        internal long ResponseTimeout = 1;

        internal int SignSeq;

        internal bool VerifyFailed;

        internal NtlmPasswordAuthentication Auth = null;

        internal string Path;

        internal SigningDigest Digest;

        internal ServerMessageBlock Response;

        public ServerMessageBlock()
        {
            Flags = unchecked(
                (byte)(SmbConstants.FlagsPathNamesCaseless
                        | SmbConstants.FlagsPathNamesCanonicalized)
            );
            Pid = SmbConstants.Pid;
            BatchLevel = 0;
        }

        internal virtual void Reset()
        {
            Flags = unchecked(
                (byte)(SmbConstants.FlagsPathNamesCaseless
                       | SmbConstants.FlagsPathNamesCanonicalized)
            );
            Flags2 = 0;
            ErrorCode = 0;
            Received = false;
            Digest = null;
        }

        internal virtual int WriteString(string str, byte[] dst, int dstIndex)
        {
            return WriteString(str, dst, dstIndex, UseUnicode);
        }

        internal virtual int WriteString(string str, byte[] dst, int dstIndex, bool useUnicode)
        {
            int start = dstIndex;
            try
            {
                if (useUnicode)
                {
                    // Unicode requires word alignment
                    if (((dstIndex - HeaderStart) % 2) != 0)
                    {
                        dst[dstIndex++] = (byte)('\0');
                    }
                    Array.Copy(Runtime.GetBytesForString(str, SmbConstants.UniEncoding),
                               0, dst, dstIndex, str.Length * 2);
                    dstIndex += str.Length * 2;
                    dst[dstIndex++] = (byte)('\0');
                    dst[dstIndex++] = (byte)('\0');
                }
                else
                {
                    byte[] b = Runtime.GetBytesForString(str, SmbConstants.OemEncoding);
                    Array.Copy(b, 0, dst, dstIndex, b.Length);
                    dstIndex += b.Length;
                    dst[dstIndex++] = (byte)('\0');
                }
            }
            catch (UnsupportedEncodingException uee)
            {
                if (Log.Level > 1)
                {
                    Runtime.PrintStackTrace(uee, Log);
                }
            }
            return dstIndex - start;
        }

        internal virtual string ReadString(byte[] src, int srcIndex)
        {
            return ReadString(src, srcIndex, 256, UseUnicode);
        }

        internal virtual string ReadString(byte[] src, int srcIndex, int maxLen, bool useUnicode)
        {
            int len = 0;
            string str = null;
            try
            {
                if (useUnicode)
                {
                    // Unicode requires word alignment
                    if (((srcIndex - HeaderStart) % 2) != 0)
                    {
                        srcIndex++;
                    }
                    while (src[srcIndex + len] != 0x00 || src[srcIndex
                         + len + 1] != 0x00)
                    {
                        len += 2;
                        if (len > maxLen)
                        {
                            if (Log.Level > 0)
                            {
                                Hexdump.ToHexdump(Console.Error,
                                                  src,
                                                  srcIndex,
                                                  maxLen < 128
                                                    ? maxLen + 8
                                                    : 128);
                            }
                            throw new RuntimeException("zero termination not found");
                        }
                    }
                    str = Runtime.GetStringForBytes(src, srcIndex, len, SmbConstants.UniEncoding);
                }
                else
                {
                    while (src[srcIndex + len] != 0x00)
                    {
                        len++;
                        if (len > maxLen)
                        {
                            if (Log.Level > 0)
                            {
                                Hexdump.ToHexdump(Console.Error,
                                                  src,
                                                  srcIndex,
                                                  maxLen < 128
                                                    ? maxLen + 8
                                                    : 128);
                            }
                            throw new RuntimeException("zero termination not found");
                        }
                    }
                    str = Runtime.GetStringForBytes(src, srcIndex, len, SmbConstants.OemEncoding);
                }
            }
            catch (UnsupportedEncodingException uee)
            {
                if (Log.Level > 1)
                {
                    Runtime.PrintStackTrace(uee, Log);
                }
            }
            return str;
        }

        internal virtual string ReadString(byte[] src,
                                           int srcIndex,
                                           int srcEnd,
                                           int maxLen,
                                           bool useUnicode)
        {
            int len = 0;
            string str = null;
            try
            {
                if (useUnicode)
                {
                    // Unicode requires word alignment
                    if (((srcIndex - HeaderStart) % 2) != 0)
                    {
                        srcIndex++;
                    }
                    for (len = 0; (srcIndex + len + 1) < srcEnd; len += 2)
                    {
                        if (src[srcIndex + len] == 0x00 && src[srcIndex + len + 1] == 0x00)
                        {
                            break;
                        }
                        if (len > maxLen)
                        {
                            if (Log.Level > 0)
                            {
                                Hexdump.ToHexdump(Console.Error,
                                                  src,
                                                  srcIndex,
                                                  maxLen < 128
                                                    ? maxLen + 8
                                                    : 128);
                            }
                            throw new RuntimeException("zero termination not found");
                        }
                    }
                    str = Runtime.GetStringForBytes(src, srcIndex, len, SmbConstants.UniEncoding);
                }
                else
                {
                    for (len = 0; srcIndex < srcEnd; len++)
                    {
                        if (src[srcIndex + len] == 0x00)
                        {
                            break;
                        }
                        if (len > maxLen)
                        {
                            if (Log.Level > 0)
                            {
                                Hexdump.ToHexdump(Console.Error,
                                                  src,
                                                  srcIndex,
                                                  maxLen < 128
                                                    ? maxLen + 8
                                                    : 128);
                            }
                            throw new RuntimeException("zero termination not found");
                        }
                    }
                    str = Runtime.GetStringForBytes(src, srcIndex, len, SmbConstants.OemEncoding);
                }
            }
            catch (UnsupportedEncodingException uee)
            {
                if (Log.Level > 1)
                {
                    Runtime.PrintStackTrace(uee, Log);
                }
            }
            return str;
        }

        internal virtual int StringWireLength(string str, int offset)
        {
            int len = str.Length + 1;
            if (UseUnicode)
            {
                len = str.Length * 2 + 2;
                len = (offset % 2) != 0 ? len + 1 : len;
            }
            return len;
        }

        internal virtual int ReadStringLength(byte[] src, int srcIndex, int max)
        {
            int len = 0;
            while (src[srcIndex + len] != 0x00)
            {
                if (len++ > max)
                {
                    throw new RuntimeException("zero termination not found: " + this);
                }
            }
            return len;
        }

        internal virtual int Encode(byte[] dst, int dstIndex)
        {
            int start = HeaderStart = dstIndex;
            dstIndex += WriteHeaderWireFormat(dst, dstIndex);
            WordCount = WriteParameterWordsWireFormat(dst, dstIndex + 1);
            dst[dstIndex++] = unchecked((byte)((WordCount / 2) & 0xFF));
            dstIndex += WordCount;
            WordCount /= 2;
            ByteCount = WriteBytesWireFormat(dst, dstIndex + 2);
            dst[dstIndex++] = unchecked((byte)(ByteCount & 0xFF));
            dst[dstIndex++] = unchecked((byte)((ByteCount >> 8) & 0xFF));
            dstIndex += ByteCount;
            Length = dstIndex - start;
            if (Digest != null)
            {
                Digest.Sign(dst, HeaderStart, Length, this, Response);
            }
            return Length;
        }

        internal virtual int Decode(byte[] buffer, int bufferIndex)
        {
            int start = HeaderStart = bufferIndex;
            bufferIndex += ReadHeaderWireFormat(buffer, bufferIndex);
            WordCount = buffer[bufferIndex++];
            if (WordCount != 0)
            {
                int n;
                if ((n = ReadParameterWordsWireFormat(buffer, bufferIndex)) != WordCount * 2)
                {
                    if (Log.Level >= 5)
                    {
                        Log.WriteLine("wordCount * 2=" + (WordCount * 2)
                                      + " but readParameterWordsWireFormat returned " + n);
                    }
                }
                bufferIndex += WordCount * 2;
            }
            ByteCount = ReadInt2(buffer, bufferIndex);
            bufferIndex += 2;
            if (ByteCount != 0)
            {
                int n;
                if ((n = ReadBytesWireFormat(buffer, bufferIndex)) != ByteCount)
                {
                    if (Log.Level >= 5)
                    {
                        Log.WriteLine("byteCount=" + ByteCount
                                      + " but readBytesWireFormat returned " + n);
                    }
                }
                // Don't think we can rely on n being correct here. Must use byteCount.
                // Last paragraph of section 3.13.3 eludes to this.
                bufferIndex += ByteCount;
            }
            Length = bufferIndex - start;
            return Length;
        }

        internal virtual int WriteHeaderWireFormat(byte[] dst, int dstIndex)
        {
            Array.Copy(Header, 0, dst, dstIndex, Header.Length);
            dst[dstIndex + SmbConstants.CmdOffset] = Command;
            dst[dstIndex + SmbConstants.FlagsOffset] = Flags;
            WriteInt2(Flags2, dst, dstIndex + SmbConstants.FlagsOffset + 1);
            dstIndex += SmbConstants.TidOffset;
            WriteInt2(Tid, dst, dstIndex);
            WriteInt2(Pid, dst, dstIndex + 2);
            WriteInt2(Uid, dst, dstIndex + 4);
            WriteInt2(Mid, dst, dstIndex + 6);
            return SmbConstants.HeaderLength;
        }

        internal virtual int ReadHeaderWireFormat(byte[] buffer, int bufferIndex)
        {
            Command = buffer[bufferIndex + SmbConstants.CmdOffset];
            ErrorCode = ReadInt4(buffer, bufferIndex + SmbConstants.ErrorCodeOffset);
            Flags = buffer[bufferIndex + SmbConstants.FlagsOffset];
            Flags2 = ReadInt2(buffer, bufferIndex + SmbConstants.FlagsOffset + 1);
            Tid = ReadInt2(buffer, bufferIndex + SmbConstants.TidOffset);
            Pid = ReadInt2(buffer, bufferIndex + SmbConstants.TidOffset + 2);
            Uid = ReadInt2(buffer, bufferIndex + SmbConstants.TidOffset + 4);
            Mid = ReadInt2(buffer, bufferIndex + SmbConstants.TidOffset + 6);
            return SmbConstants.HeaderLength;
        }

        internal virtual bool IsResponse()
        {
            return (Flags & SmbConstants.FlagsResponse) == SmbConstants.FlagsResponse;
        }

        internal abstract int WriteParameterWordsWireFormat(byte[] dst, int dstIndex);

        internal abstract int WriteBytesWireFormat(byte[] dst, int dstIndex);

        internal abstract int ReadParameterWordsWireFormat(byte[] buffer, int bufferIndex);

        internal abstract int ReadBytesWireFormat(byte[] buffer, int bufferIndex);

        public override int GetHashCode()
        {
            return Mid;
        }

        public override bool Equals(object obj)
        {
            return obj is ServerMessageBlock && ((ServerMessageBlock)obj).Mid == Mid;
        }

        public override string ToString()
        {
            string c;
            switch (Command)
            {
                case SmbComNegotiate:
                    {
                        c = "SMB_COM_NEGOTIATE";
                        break;
                    }

                case SmbComSessionSetupAndx:
                    {
                        c = "SMB_COM_SESSION_SETUP_ANDX";
                        break;
                    }

                case SmbComTreeConnectAndx:
                    {
                        c = "SMB_COM_TREE_CONNECT_ANDX";
                        break;
                    }

                case SmbComQueryInformation:
                    {
                        c = "SMB_COM_QUERY_INFORMATION";
                        break;
                    }

                case SmbComCheckDirectory:
                    {
                        c = "SMB_COM_CHECK_DIRECTORY";
                        break;
                    }

                case SmbComTransaction:
                    {
                        c = "SMB_COM_TRANSACTION";
                        break;
                    }

                case SmbComTransaction2:
                    {
                        c = "SMB_COM_TRANSACTION2";
                        break;
                    }

                case SmbComTransactionSecondary:
                    {
                        c = "SMB_COM_TRANSACTION_SECONDARY";
                        break;
                    }

                case SmbComFindClose2:
                    {
                        c = "SMB_COM_FIND_CLOSE2";
                        break;
                    }

                case SmbComTreeDisconnect:
                    {
                        c = "SMB_COM_TREE_DISCONNECT";
                        break;
                    }

                case SmbComLogoffAndx:
                    {
                        c = "SMB_COM_LOGOFF_ANDX";
                        break;
                    }

                case SmbComEcho:
                    {
                        c = "SMB_COM_ECHO";
                        break;
                    }

                case SmbComMove:
                    {
                        c = "SMB_COM_MOVE";
                        break;
                    }

                case SmbComRename:
                    {
                        c = "SMB_COM_RENAME";
                        break;
                    }

                case SmbComDelete:
                    {
                        c = "SMB_COM_DELETE";
                        break;
                    }

                case SmbComDeleteDirectory:
                    {
                        c = "SMB_COM_DELETE_DIRECTORY";
                        break;
                    }

                case SmbComNtCreateAndx:
                    {
                        c = "SMB_COM_NT_CREATE_ANDX";
                        break;
                    }

                case SmbComOpenAndx:
                    {
                        c = "SMB_COM_OPEN_ANDX";
                        break;
                    }

                case SmbComReadAndx:
                    {
                        c = "SMB_COM_READ_ANDX";
                        break;
                    }

                case SmbComClose:
                    {
                        c = "SMB_COM_CLOSE";
                        break;
                    }

                case SmbComWriteAndx:
                    {
                        c = "SMB_COM_WRITE_ANDX";
                        break;
                    }

                case SmbComCreateDirectory:
                    {
                        c = "SMB_COM_CREATE_DIRECTORY";
                        break;
                    }

                case SmbComNtTransact:
                    {
                        c = "SMB_COM_NT_TRANSACT";
                        break;
                    }

                case SmbComNtTransactSecondary:
                    {
                        c = "SMB_COM_NT_TRANSACT_SECONDARY";
                        break;
                    }

                default:
                    {
                        c = "UNKNOWN";
                        break;
                    }
            }
            string str = ErrorCode == 0 
                            ? "0" 
                            : SmbException.GetMessageByCode(ErrorCode);
            return "command=" + c 
                    + ",received=" + Received 
                    + ",errorCode=" + str
                    + ",flags=0x" + Hexdump.ToHexString(Flags & 0xFF, 4) 
                    + ",flags2=0x" + Hexdump.ToHexString(Flags2, 4) 
                    + ",signSeq=" + SignSeq 
                    + ",tid=" + Tid 
                    + ",pid=" + Pid 
                    + ",uid=" + Uid 
                    + ",mid=" + Mid 
                    + ",wordCount=" + WordCount 
                    + ",byteCount=" + ByteCount;
        }
    }
}