// 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;
		}
	}
}