jellyfin/Emby.Common.Implementations/IO/SharpCifs/Dcerpc/Rpc.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.Dcerpc.Ndr;

namespace SharpCifs.Dcerpc
{
    public class Rpc
    {
        public class UuidT : NdrObject
        {
            public int TimeLow;

            public short TimeMid;

            public short TimeHiAndVersion;

            public byte ClockSeqHiAndReserved;

            public byte ClockSeqLow;

            public byte[] Node;

            /// <exception cref="SharpCifs.Dcerpc.Ndr.NdrException"></exception>
            public override void Encode(NdrBuffer dst)
            {
                dst.Align(4);
                dst.Enc_ndr_long(TimeLow);
                dst.Enc_ndr_short(TimeMid);
                dst.Enc_ndr_short(TimeHiAndVersion);
                dst.Enc_ndr_small(ClockSeqHiAndReserved);
                dst.Enc_ndr_small(ClockSeqLow);
                int nodes = 6;
                int nodei = dst.Index;
                dst.Advance(1 * nodes);
                dst = dst.Derive(nodei);
                for (int i = 0; i < nodes; i++)
                {
                    dst.Enc_ndr_small(Node[i]);
                }
            }

            /// <exception cref="SharpCifs.Dcerpc.Ndr.NdrException"></exception>
            public override void Decode(NdrBuffer src)
            {
                src.Align(4);
                TimeLow = src.Dec_ndr_long();
                TimeMid = (short)src.Dec_ndr_short();
                TimeHiAndVersion = (short)src.Dec_ndr_short();
                ClockSeqHiAndReserved = unchecked((byte)src.Dec_ndr_small());
                ClockSeqLow = unchecked((byte)src.Dec_ndr_small());
                int nodes = 6;
                int nodei = src.Index;
                src.Advance(1 * nodes);
                if (Node == null)
                {
                    if (nodes < 0 || nodes > unchecked(0xFFFF))
                    {
                        throw new NdrException(NdrException.InvalidConformance);
                    }
                    Node = new byte[nodes];
                }
                src = src.Derive(nodei);
                for (int i = 0; i < nodes; i++)
                {
                    Node[i] = unchecked((byte)src.Dec_ndr_small());
                }
            }
        }

        public class PolicyHandle : NdrObject
        {
            public int Type;

            public UuidT Uuid;

            /// <exception cref="SharpCifs.Dcerpc.Ndr.NdrException"></exception>
            public override void Encode(NdrBuffer dst)
            {
                dst.Align(4);
                dst.Enc_ndr_long(Type);
                dst.Enc_ndr_long(Uuid.TimeLow);
                dst.Enc_ndr_short(Uuid.TimeMid);
                dst.Enc_ndr_short(Uuid.TimeHiAndVersion);
                dst.Enc_ndr_small(Uuid.ClockSeqHiAndReserved);
                dst.Enc_ndr_small(Uuid.ClockSeqLow);
                int uuidNodes = 6;
                int uuidNodei = dst.Index;
                dst.Advance(1 * uuidNodes);
                dst = dst.Derive(uuidNodei);
                for (int i = 0; i < uuidNodes; i++)
                {
                    dst.Enc_ndr_small(Uuid.Node[i]);
                }
            }

            /// <exception cref="SharpCifs.Dcerpc.Ndr.NdrException"></exception>
            public override void Decode(NdrBuffer src)
            {
                src.Align(4);
                Type = src.Dec_ndr_long();
                src.Align(4);
                if (Uuid == null)
                {
                    Uuid = new UuidT();
                }
                Uuid.TimeLow = src.Dec_ndr_long();
                Uuid.TimeMid = (short)src.Dec_ndr_short();
                Uuid.TimeHiAndVersion = (short)src.Dec_ndr_short();
                Uuid.ClockSeqHiAndReserved = unchecked((byte)src.Dec_ndr_small());
                Uuid.ClockSeqLow = unchecked((byte)src.Dec_ndr_small());
                int uuidNodes = 6;
                int uuidNodei = src.Index;
                src.Advance(1 * uuidNodes);
                if (Uuid.Node == null)
                {
                    if (uuidNodes < 0 || uuidNodes > unchecked(0xFFFF))
                    {
                        throw new NdrException(NdrException.InvalidConformance);
                    }
                    Uuid.Node = new byte[uuidNodes];
                }
                src = src.Derive(uuidNodei);
                for (int i = 0; i < uuidNodes; i++)
                {
                    Uuid.Node[i] = unchecked((byte)src.Dec_ndr_small());
                }
            }
        }

        public class Unicode_string : NdrObject
        {
            public short Length;

            public short MaximumLength;

            public short[] Buffer;

            /// <exception cref="SharpCifs.Dcerpc.Ndr.NdrException"></exception>
            public override void Encode(NdrBuffer dst)
            {
                dst.Align(4);
                dst.Enc_ndr_short(Length);
                dst.Enc_ndr_short(MaximumLength);
                dst.Enc_ndr_referent(Buffer, 1);
                if (Buffer != null)
                {
                    dst = dst.Deferred;
                    int bufferl = Length / 2;
                    int buffers = MaximumLength / 2;
                    dst.Enc_ndr_long(buffers);
                    dst.Enc_ndr_long(0);
                    dst.Enc_ndr_long(bufferl);
                    int bufferi = dst.Index;
                    dst.Advance(2 * bufferl);
                    dst = dst.Derive(bufferi);
                    for (int i = 0; i < bufferl; i++)
                    {
                        dst.Enc_ndr_short(Buffer[i]);
                    }
                }
            }

            /// <exception cref="SharpCifs.Dcerpc.Ndr.NdrException"></exception>
            public override void Decode(NdrBuffer src)
            {
                src.Align(4);
                Length = (short)src.Dec_ndr_short();
                MaximumLength = (short)src.Dec_ndr_short();
                int bufferp = src.Dec_ndr_long();
                if (bufferp != 0)
                {
                    src = src.Deferred;
                    int buffers = src.Dec_ndr_long();
                    src.Dec_ndr_long();
                    int bufferl = src.Dec_ndr_long();
                    int bufferi = src.Index;
                    src.Advance(2 * bufferl);
                    if (Buffer == null)
                    {
                        if (buffers < 0 || buffers > unchecked(0xFFFF))
                        {
                            throw new NdrException(NdrException.InvalidConformance);
                        }
                        Buffer = new short[buffers];
                    }
                    src = src.Derive(bufferi);
                    for (int i = 0; i < bufferl; i++)
                    {
                        Buffer[i] = (short)src.Dec_ndr_short();
                    }
                }
            }
        }

        public class SidT : NdrObject
        {
            public byte Revision;

            public byte SubAuthorityCount;

            public byte[] IdentifierAuthority;

            public int[] SubAuthority;

            /// <exception cref="SharpCifs.Dcerpc.Ndr.NdrException"></exception>
            public override void Encode(NdrBuffer dst)
            {
                dst.Align(4);
                int subAuthoritys = SubAuthorityCount;
                dst.Enc_ndr_long(subAuthoritys);
                dst.Enc_ndr_small(Revision);
                dst.Enc_ndr_small(SubAuthorityCount);
                int identifierAuthoritys = 6;
                int identifierAuthorityi = dst.Index;
                dst.Advance(1 * identifierAuthoritys);
                int subAuthorityi = dst.Index;
                dst.Advance(4 * subAuthoritys);
                dst = dst.Derive(identifierAuthorityi);
                for (int i = 0; i < identifierAuthoritys; i++)
                {
                    dst.Enc_ndr_small(IdentifierAuthority[i]);
                }
                dst = dst.Derive(subAuthorityi);
                for (int i1 = 0; i1 < subAuthoritys; i1++)
                {
                    dst.Enc_ndr_long(SubAuthority[i1]);
                }
            }

            /// <exception cref="SharpCifs.Dcerpc.Ndr.NdrException"></exception>
            public override void Decode(NdrBuffer src)
            {
                src.Align(4);
                int subAuthoritys = src.Dec_ndr_long();
                Revision = unchecked((byte)src.Dec_ndr_small());
                SubAuthorityCount = unchecked((byte)src.Dec_ndr_small());
                int identifierAuthoritys = 6;
                int identifierAuthorityi = src.Index;
                src.Advance(1 * identifierAuthoritys);
                int subAuthorityi = src.Index;
                src.Advance(4 * subAuthoritys);
                if (IdentifierAuthority == null)
                {
                    if (identifierAuthoritys < 0 || identifierAuthoritys > unchecked(0xFFFF))
                    {
                        throw new NdrException(NdrException.InvalidConformance);
                    }
                    IdentifierAuthority = new byte[identifierAuthoritys];
                }
                src = src.Derive(identifierAuthorityi);
                for (int i = 0; i < identifierAuthoritys; i++)
                {
                    IdentifierAuthority[i] = unchecked((byte)src.Dec_ndr_small());
                }
                if (SubAuthority == null)
                {
                    if (subAuthoritys < 0 || subAuthoritys > unchecked(0xFFFF))
                    {
                        throw new NdrException(NdrException.InvalidConformance);
                    }
                    SubAuthority = new int[subAuthoritys];
                }
                src = src.Derive(subAuthorityi);
                for (int i1 = 0; i1 < subAuthoritys; i1++)
                {
                    SubAuthority[i1] = src.Dec_ndr_long();
                }
            }
        }
    }
}