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

namespace SharpCifs.Netbios
{
    internal abstract class NameServicePacket
    {
        internal const int Query = 0;

        internal const int Wack = 7;

        internal const int FmtErr = 0x1;

        internal const int SrvErr = 0x2;

        internal const int ImpErr = 0x4;

        internal const int RfsErr = 0x5;

        internal const int ActErr = 0x6;

        internal const int CftErr = 0x7;

        internal const int NbIn = 0x00200001;

        internal const int NbstatIn = 0x00210001;

        internal const int Nb = 0x0020;

        internal const int Nbstat = 0x0021;

        internal const int In = 0x0001;

        internal const int A = 0x0001;

        internal const int Ns = 0x0002;

        internal const int Null = 0x000a;

        internal const int HeaderLength = 12;

        internal const int OpcodeOffset = 2;

        internal const int QuestionOffset = 4;

        internal const int AnswerOffset = 6;

        internal const int AuthorityOffset = 8;

        internal const int AdditionalOffset = 10;

        // opcode
        // rcode
        // type/class
        // header field offsets
        internal static void WriteInt2(int val, byte[] dst, int dstIndex)
        {
            dst[dstIndex++] = unchecked((byte)((val >> 8) & unchecked(0xFF)));
            dst[dstIndex] = unchecked((byte)(val & unchecked(0xFF)));
        }

        internal static void WriteInt4(int val, byte[] dst, int dstIndex)
        {
            dst[dstIndex++] = unchecked((byte)((val >> 24) & unchecked(0xFF)));
            dst[dstIndex++] = unchecked((byte)((val >> 16) & unchecked(0xFF)));
            dst[dstIndex++] = unchecked((byte)((val >> 8) & unchecked(0xFF)));
            dst[dstIndex] = unchecked((byte)(val & unchecked(0xFF)));
        }

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

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

        internal static int ReadNameTrnId(byte[] src, int srcIndex)
        {
            return ReadInt2(src, srcIndex);
        }

        internal int AddrIndex;

        internal NbtAddress[] AddrEntry;

        internal int NameTrnId;

        internal int OpCode;

        internal int ResultCode;

        internal int QuestionCount;

        internal int AnswerCount;

        internal int AuthorityCount;

        internal int AdditionalCount;

        internal bool Received;

        internal bool IsResponse;

        internal bool IsAuthAnswer;

        internal bool IsTruncated;

        internal bool IsRecurDesired;

        internal bool IsRecurAvailable;

        internal bool IsBroadcast;

        internal Name QuestionName;

        internal Name RecordName;

        internal int QuestionType;

        internal int QuestionClass;

        internal int RecordType;

        internal int RecordClass;

        internal int Ttl;

        internal int RDataLength;

        internal IPAddress Addr;

        public NameServicePacket()
        {
            IsRecurDesired = true;
            IsBroadcast = true;
            QuestionCount = 1;
            QuestionClass = In;
        }

        internal virtual int WriteWireFormat(byte[] dst, int dstIndex)
        {
            int start = dstIndex;
            dstIndex += WriteHeaderWireFormat(dst, dstIndex);
            dstIndex += WriteBodyWireFormat(dst, dstIndex);
            return dstIndex - start;
        }

        internal virtual int ReadWireFormat(byte[] src, int srcIndex)
        {
            int start = srcIndex;
            srcIndex += ReadHeaderWireFormat(src, srcIndex);
            srcIndex += ReadBodyWireFormat(src, srcIndex);
            return srcIndex - start;
        }

        internal virtual int WriteHeaderWireFormat(byte[] dst, int dstIndex)
        {
            int start = dstIndex;
            WriteInt2(NameTrnId, dst, dstIndex);
            dst[dstIndex + OpcodeOffset] = unchecked(
                (byte)(
                    (IsResponse
                        ? unchecked(0x80)
                        : unchecked(0x00))
                    + ((OpCode << 3) & unchecked(0x78))
                    + (IsAuthAnswer
                        ? unchecked(0x04)
                        : unchecked(0x00))
                    + (IsTruncated
                        ? unchecked(0x02)
                        : unchecked(0x00))
                    + (IsRecurDesired
                        ? unchecked(0x01)
                        : unchecked(0x00))
                )
            );
            dst[dstIndex + OpcodeOffset + 1] = unchecked(
                (byte)(
                    (IsRecurAvailable
                        ? unchecked(0x80)
                        : unchecked(0x00))
                    + (IsBroadcast
                        ? unchecked(0x10)
                        : unchecked(0x00))
                    + (ResultCode & unchecked(0x0F))
                )
            );
            WriteInt2(QuestionCount, dst, start + QuestionOffset);
            WriteInt2(AnswerCount, dst, start + AnswerOffset);
            WriteInt2(AuthorityCount, dst, start + AuthorityOffset);
            WriteInt2(AdditionalCount, dst, start + AdditionalOffset);
            return HeaderLength;
        }

        internal virtual int ReadHeaderWireFormat(byte[] src, int srcIndex)
        {
            NameTrnId = ReadInt2(src, srcIndex);

            IsResponse = ((src[srcIndex + OpcodeOffset] & unchecked(0x80)) == 0)
                            ? false
                            : true;
            OpCode = (src[srcIndex + OpcodeOffset] & unchecked(0x78)) >> 3;
            IsAuthAnswer = ((src[srcIndex + OpcodeOffset] & unchecked(0x04)) == 0)
                            ? false
                            : true;
            IsTruncated = ((src[srcIndex + OpcodeOffset] & unchecked(0x02)) == 0)
                            ? false
                            : true;
            IsRecurDesired = ((src[srcIndex + OpcodeOffset] & unchecked(0x01)) == 0)
                            ? false
                            : true;
            IsRecurAvailable = ((src[srcIndex + OpcodeOffset + 1] & unchecked(0x80)) == 0)
                            ? false
                            : true;
            IsBroadcast = ((src[srcIndex + OpcodeOffset + 1] & unchecked(0x10)) == 0)
                            ? false
                            : true;
            ResultCode = src[srcIndex + OpcodeOffset + 1] & unchecked(0x0F);
            QuestionCount = ReadInt2(src, srcIndex + QuestionOffset);
            AnswerCount = ReadInt2(src, srcIndex + AnswerOffset);
            AuthorityCount = ReadInt2(src, srcIndex + AuthorityOffset);
            AdditionalCount = ReadInt2(src, srcIndex + AdditionalOffset);
            return HeaderLength;
        }

        internal virtual int WriteQuestionSectionWireFormat(byte[] dst, int dstIndex)
        {
            int start = dstIndex;
            dstIndex += QuestionName.WriteWireFormat(dst, dstIndex);
            WriteInt2(QuestionType, dst, dstIndex);
            dstIndex += 2;
            WriteInt2(QuestionClass, dst, dstIndex);
            dstIndex += 2;
            return dstIndex - start;
        }

        internal virtual int ReadQuestionSectionWireFormat(byte[] src, int srcIndex)
        {
            int start = srcIndex;
            srcIndex += QuestionName.ReadWireFormat(src, srcIndex);
            QuestionType = ReadInt2(src, srcIndex);
            srcIndex += 2;
            QuestionClass = ReadInt2(src, srcIndex);
            srcIndex += 2;
            return srcIndex - start;
        }

        internal virtual int WriteResourceRecordWireFormat(byte[] dst, int dstIndex)
        {
            int start = dstIndex;
            if (RecordName == QuestionName)
            {
                dst[dstIndex++] = unchecked(unchecked(0xC0));
                // label string pointer to
                dst[dstIndex++] = unchecked(unchecked(0x0C));
            }
            else
            {
                // questionName (offset 12)
                dstIndex += RecordName.WriteWireFormat(dst, dstIndex);
            }
            WriteInt2(RecordType, dst, dstIndex);
            dstIndex += 2;
            WriteInt2(RecordClass, dst, dstIndex);
            dstIndex += 2;
            WriteInt4(Ttl, dst, dstIndex);
            dstIndex += 4;
            RDataLength = WriteRDataWireFormat(dst, dstIndex + 2);
            WriteInt2(RDataLength, dst, dstIndex);
            dstIndex += 2 + RDataLength;
            return dstIndex - start;
        }

        internal virtual int ReadResourceRecordWireFormat(byte[] src, int srcIndex)
        {
            int start = srcIndex;
            int end;
            if ((src[srcIndex] & unchecked(0xC0)) == unchecked(0xC0))
            {
                RecordName = QuestionName;
                // label string pointer to questionName
                srcIndex += 2;
            }
            else
            {
                srcIndex += RecordName.ReadWireFormat(src, srcIndex);
            }
            RecordType = ReadInt2(src, srcIndex);
            srcIndex += 2;
            RecordClass = ReadInt2(src, srcIndex);
            srcIndex += 2;
            Ttl = ReadInt4(src, srcIndex);
            srcIndex += 4;
            RDataLength = ReadInt2(src, srcIndex);
            srcIndex += 2;
            AddrEntry = new NbtAddress[RDataLength / 6];
            end = srcIndex + RDataLength;
            for (AddrIndex = 0; srcIndex < end; AddrIndex++)
            {
                srcIndex += ReadRDataWireFormat(src, srcIndex);
            }
            return srcIndex - start;
        }

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

        internal abstract int ReadBodyWireFormat(byte[] src, int srcIndex);

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

        internal abstract int ReadRDataWireFormat(byte[] src, int srcIndex);

        public override string ToString()
        {
            string opCodeString;
            string resultCodeString;
            string questionTypeString;
            string recordTypeString;

            switch (OpCode)
            {
                case Query:
                    {
                        opCodeString = "QUERY";
                        break;
                    }

                case Wack:
                    {
                        opCodeString = "WACK";
                        break;
                    }

                default:
                    {
                        opCodeString = Extensions.ToString(OpCode);
                        break;
                    }
            }
            switch (ResultCode)
            {
                case FmtErr:
                    {
                        resultCodeString = "FMT_ERR";
                        break;
                    }

                case SrvErr:
                    {
                        resultCodeString = "SRV_ERR";
                        break;
                    }

                case ImpErr:
                    {
                        resultCodeString = "IMP_ERR";
                        break;
                    }

                case RfsErr:
                    {
                        resultCodeString = "RFS_ERR";
                        break;
                    }

                case ActErr:
                    {
                        resultCodeString = "ACT_ERR";
                        break;
                    }

                case CftErr:
                    {
                        resultCodeString = "CFT_ERR";
                        break;
                    }

                default:
                    {
                        resultCodeString = "0x" + Hexdump.ToHexString(ResultCode, 1);
                        break;
                    }
            }
            switch (QuestionType)
            {
                case Nb:
                    {
                        questionTypeString = "NB";
                        break;
                    }

                case Nbstat:
                    {
                        questionTypeString = "NBSTAT";
                        break;
                    }

                default:
                    {
                        questionTypeString = "0x" + Hexdump.ToHexString(QuestionType, 4);
                        break;
                    }
            }
            switch (RecordType)
            {
                case A:
                    {
                        recordTypeString = "A";
                        break;
                    }

                case Ns:
                    {
                        recordTypeString = "NS";
                        break;
                    }

                case Null:
                    {
                        recordTypeString = "NULL";
                        break;
                    }

                case Nb:
                    {
                        recordTypeString = "NB";
                        break;
                    }

                case Nbstat:
                    {
                        recordTypeString = "NBSTAT";
                        break;
                    }

                default:
                    {
                        recordTypeString = "0x" + Hexdump.ToHexString(RecordType, 4);
                        break;
                    }
            }
            return "nameTrnId=" + NameTrnId
                    + ",isResponse=" + IsResponse
                    + ",opCode=" + opCodeString
                    + ",isAuthAnswer=" + IsAuthAnswer
                    + ",isTruncated=" + IsTruncated
                    + ",isRecurAvailable=" + IsRecurAvailable
                    + ",isRecurDesired=" + IsRecurDesired
                    + ",isBroadcast=" + IsBroadcast
                    + ",resultCode=" + ResultCode
                    + ",questionCount=" + QuestionCount
                    + ",answerCount=" + AnswerCount
                    + ",authorityCount=" + AuthorityCount
                    + ",additionalCount=" + AdditionalCount
                    + ",questionName=" + QuestionName
                    + ",questionType=" + questionTypeString
                    + ",questionClass=" + (QuestionClass == In
                                            ? "IN"
                                            : "0x" + Hexdump.ToHexString(QuestionClass, 4))
                    + ",recordName=" + RecordName
                    + ",recordType=" + recordTypeString
                    + ",recordClass=" + (RecordClass == In
                                            ? "IN"
                                            : "0x" + Hexdump.ToHexString(RecordClass, 4))
                    + ",ttl=" + Ttl
                    + ",rDataLength=" + RDataLength;
        }
    }
}