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

namespace SharpCifs.Dcerpc
{
    public abstract class DcerpcHandle
    {
        /// <exception cref="SharpCifs.Dcerpc.DcerpcException"></exception>
        protected internal static DcerpcBinding ParseBinding(string str)
        {
            int state;
            int mark;
            int si;
            char[] arr = str.ToCharArray();
            string proto = null;
            string key = null;
            DcerpcBinding binding = null;
            state = mark = si = 0;
            do
            {
                char ch = arr[si];
                switch (state)
                {
                    case 0:
                        {
                            if (ch == ':')
                            {
                                proto = Runtime.Substring(str, mark, si);
                                mark = si + 1;
                                state = 1;
                            }
                            break;
                        }

                    case 1:
                        {
                            if (ch == '\\')
                            {
                                mark = si + 1;
                                break;
                            }
                            state = 2;
                            goto case 2;
                        }

                    case 2:
                        {
                            if (ch == '[')
                            {
                                string server = Runtime.Substring(str, mark, si).Trim();
                                if (server.Length == 0)
                                {
                                    server = "127.0.0.1";
                                }
                                binding = new DcerpcBinding(proto, Runtime.Substring(str, mark, si));
                                mark = si + 1;
                                state = 5;
                            }
                            break;
                        }

                    case 5:
                        {
                            if (ch == '=')
                            {
                                key = Runtime.Substring(str, mark, si).Trim();
                                mark = si + 1;
                            }
                            else
                            {
                                if (ch == ',' || ch == ']')
                                {
                                    string val = Runtime.Substring(str, mark, si).Trim();
                                    if (key == null)
                                    {
                                        key = "endpoint";
                                    }
                                    binding.SetOption(key, val);
                                    key = null;
                                }
                            }
                            break;
                        }

                    default:
                        {
                            si = arr.Length;
                            break;
                        }
                }
                si++;
            }
            while (si < arr.Length);
            if (binding == null || binding.Endpoint == null)
            {
                throw new DcerpcException("Invalid binding URL: " + str);
            }
            return binding;
        }

        protected internal DcerpcBinding Binding;

        protected internal int MaxXmit = 4280;

        protected internal int MaxRecv;

        protected internal int State;

        protected internal IDcerpcSecurityProvider SecurityProvider;

        private static int _callId = 1;

        /// <exception cref="UnknownHostException"></exception>
        /// <exception cref="System.UriFormatException"></exception>
        /// <exception cref="SharpCifs.Dcerpc.DcerpcException"></exception>
        public static DcerpcHandle GetHandle(string url, NtlmPasswordAuthentication auth)
        {
            if (url.StartsWith("ncacn_np:"))
            {
                return new DcerpcPipeHandle(url, auth);
            }
            throw new DcerpcException("DCERPC transport not supported: " + url);
        }

        /// <exception cref="SharpCifs.Dcerpc.DcerpcException"></exception>
        /// <exception cref="System.IO.IOException"></exception>
        public virtual void Bind()
        {
            lock (this)
            {
                try
                {
                    State = 1;
                    DcerpcMessage bind = new DcerpcBind(Binding, this);
                    Sendrecv(bind);
                }
                catch (IOException ioe)
                {
                    State = 0;
                    throw;
                }
            }
        }

        /// <exception cref="SharpCifs.Dcerpc.DcerpcException"></exception>
        /// <exception cref="System.IO.IOException"></exception>
        public virtual void Sendrecv(DcerpcMessage msg)
        {
            byte[] stub;
            byte[] frag;
            NdrBuffer buf;
            NdrBuffer fbuf;
            bool isLast;
            bool isDirect;
            DcerpcException de;
            if (State == 0)
            {
                Bind();
            }
            isDirect = true;
            stub = BufferCache.GetBuffer();
            try
            {
                int off;
                int tot;
                int n;
                buf = new NdrBuffer(stub, 0);
                msg.Flags = DcerpcConstants.DcerpcFirstFrag | DcerpcConstants.DcerpcLastFrag;
                msg.CallId = _callId++;
                msg.Encode(buf);
                if (SecurityProvider != null)
                {
                    buf.SetIndex(0);
                    SecurityProvider.Wrap(buf);
                }
                tot = buf.GetLength() - 24;
                off = 0;
                while (off < tot)
                {
                    n = tot - off;
                    if ((24 + n) > MaxXmit)
                    {
                        msg.Flags &= ~DcerpcConstants.DcerpcLastFrag;
                        n = MaxXmit - 24;
                    }
                    else
                    {
                        msg.Flags |= DcerpcConstants.DcerpcLastFrag;
                        isDirect = false;
                        msg.AllocHint = n;
                    }
                    msg.Length = 24 + n;
                    if (off > 0)
                    {
                        msg.Flags &= ~DcerpcConstants.DcerpcFirstFrag;
                    }
                    if (
                        (msg.Flags & (DcerpcConstants.DcerpcFirstFrag | DcerpcConstants.DcerpcLastFrag))
                            != (DcerpcConstants.DcerpcFirstFrag | DcerpcConstants.DcerpcLastFrag)
                    )
                    {
                        buf.Start = off;
                        buf.Reset();
                        msg.Encode_header(buf);
                        buf.Enc_ndr_long(msg.AllocHint);
                        buf.Enc_ndr_short(0);
                        buf.Enc_ndr_short(msg.GetOpnum());
                    }
                    DoSendFragment(stub, off, msg.Length, isDirect);
                    off += n;
                }
                DoReceiveFragment(stub, isDirect);
                buf.Reset();
                buf.SetIndex(8);
                buf.SetLength(buf.Dec_ndr_short());
                if (SecurityProvider != null)
                {
                    SecurityProvider.Unwrap(buf);
                }
                buf.SetIndex(0);
                msg.Decode_header(buf);
                off = 24;
                if (msg.Ptype == 2 && msg.IsFlagSet(DcerpcConstants.DcerpcLastFrag) == false)
                {
                    off = msg.Length;
                }
                frag = null;
                fbuf = null;
                while (msg.IsFlagSet(DcerpcConstants.DcerpcLastFrag) == false)
                {
                    int stubFragLen;
                    if (frag == null)
                    {
                        frag = new byte[MaxRecv];
                        fbuf = new NdrBuffer(frag, 0);
                    }
                    DoReceiveFragment(frag, isDirect);
                    fbuf.Reset();
                    fbuf.SetIndex(8);
                    fbuf.SetLength(fbuf.Dec_ndr_short());
                    if (SecurityProvider != null)
                    {
                        SecurityProvider.Unwrap(fbuf);
                    }
                    fbuf.Reset();
                    msg.Decode_header(fbuf);
                    stubFragLen = msg.Length - 24;
                    if ((off + stubFragLen) > stub.Length)
                    {
                        // shouldn't happen if alloc_hint is correct or greater
                        byte[] tmp = new byte[off + stubFragLen];
                        Array.Copy(stub, 0, tmp, 0, off);
                        stub = tmp;
                    }
                    Array.Copy(frag, 24, stub, off, stubFragLen);
                    off += stubFragLen;
                }
                buf = new NdrBuffer(stub, 0);
                msg.Decode(buf);
            }
            finally
            {
                BufferCache.ReleaseBuffer(stub);
            }
            if ((de = msg.GetResult()) != null)
            {
                throw de;
            }
        }

        public virtual void SetDcerpcSecurityProvider(IDcerpcSecurityProvider securityProvider
            )
        {
            this.SecurityProvider = securityProvider;
        }

        public virtual string GetServer()
        {
            if (this is DcerpcPipeHandle)
            {
                return ((DcerpcPipeHandle)this).Pipe.GetServer();
            }
            return null;
        }

        public virtual Principal GetPrincipal()
        {
            if (this is DcerpcPipeHandle)
            {
                return ((DcerpcPipeHandle)this).Pipe.GetPrincipal();
            }
            return null;
        }

        public override string ToString()
        {
            return Binding.ToString();
        }

        /// <exception cref="System.IO.IOException"></exception>
        protected internal abstract void DoSendFragment(byte[] buf, int off, int length, bool isDirect);

        /// <exception cref="System.IO.IOException"></exception>
        protected internal abstract void DoReceiveFragment(byte[] buf, bool isDirect);

        /// <exception cref="System.IO.IOException"></exception>
        public abstract void Close();

        public DcerpcHandle()
        {
            MaxRecv = MaxXmit;
        }
    }
}