jellyfin-server/Emby.Common.Implementations/IO/SharpCifs/Smb/SmbTree.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.Sharpen;

namespace SharpCifs.Smb
{
	class SmbTree
	{
		private static int _treeConnCounter;

		internal int ConnectionState;

		internal int Tid;

		internal string Share;

		internal string Service = "?????";

		internal string Service0;

		internal SmbSession Session;

		internal bool InDfs;

		internal bool InDomainDfs;

		internal int TreeNum;

		internal SmbTree(SmbSession session, string share, string service)
		{
			// used by SmbFile.isOpen
			this.Session = session;
			this.Share = share.ToUpper();
			if (service != null && service.StartsWith("??") == false)
			{
				this.Service = service;
			}
			Service0 = this.Service;
			ConnectionState = 0;
		}

		internal virtual bool Matches(string share, string service)
		{
			return Runtime.EqualsIgnoreCase(this.Share, share) && (service == null ||
				 service.StartsWith("??") || Runtime.EqualsIgnoreCase(this.Service, service
				));
		}

		public override bool Equals(object obj)
		{
			if (obj is SmbTree)
			{
				SmbTree tree = (SmbTree)obj;
				return Matches(tree.Share, tree.Service);
			}
			return false;
		}

		/// <exception cref="SharpCifs.Smb.SmbException"></exception>
		internal virtual void Send(ServerMessageBlock request, ServerMessageBlock response
			)
		{
			lock (Session.Transport())
			{
				if (response != null)
				{
					response.Received = false;
				}
				TreeConnect(request, response);
				if (request == null || (response != null && response.Received))
				{
					return;
				}
				if (Service.Equals("A:") == false)
				{
					switch (request.Command)
					{
						case ServerMessageBlock.SmbComOpenAndx:
						case ServerMessageBlock.SmbComNtCreateAndx:
						case ServerMessageBlock.SmbComReadAndx:
						case ServerMessageBlock.SmbComWriteAndx:
						case ServerMessageBlock.SmbComClose:
						case ServerMessageBlock.SmbComTreeDisconnect:
						{
							break;
						}

						case ServerMessageBlock.SmbComTransaction:
						case ServerMessageBlock.SmbComTransaction2:
						{
							switch (((SmbComTransaction)request).SubCommand & unchecked(0xFF))
							{
								case SmbComTransaction.NetShareEnum:
								case SmbComTransaction.NetServerEnum2:
								case SmbComTransaction.NetServerEnum3:
								case SmbComTransaction.TransPeekNamedPipe:
								case SmbComTransaction.TransWaitNamedPipe:
								case SmbComTransaction.TransCallNamedPipe:
								case SmbComTransaction.TransTransactNamedPipe:
								case SmbComTransaction.Trans2GetDfsReferral:
								{
									break;
								}

								default:
								{
									throw new SmbException("Invalid operation for " + Service + " service");
								}
							}
							break;
						}

						default:
						{
							throw new SmbException("Invalid operation for " + Service + " service" + request);
						}
					}
				}
				request.Tid = Tid;
				if (InDfs && !Service.Equals("IPC") && !string.IsNullOrEmpty(request.Path))
				{
                    request.Flags2 = SmbConstants.Flags2ResolvePathsInDfs;
					request.Path = '\\' + Session.Transport().TconHostName + '\\' + Share + request.Path;
				}
				try
				{
					Session.Send(request, response);
				}
				catch (SmbException se)
				{
					if (se.GetNtStatus() == NtStatus.NtStatusNetworkNameDeleted)
					{
						TreeDisconnect(true);
					}
					throw;
				}
			}
		}

		/// <exception cref="SharpCifs.Smb.SmbException"></exception>
		internal virtual void TreeConnect(ServerMessageBlock andx, ServerMessageBlock andxResponse
			)
		{
			lock (Session.Transport())
			{
				string unc;
				while (ConnectionState != 0)
				{
					if (ConnectionState == 2 || ConnectionState == 3)
					{
						// connected or disconnecting
						return;
					}
					try
					{
						Runtime.Wait(Session.transport);
					}
					catch (Exception ie)
					{
						throw new SmbException(ie.Message, ie);
					}
				}
				ConnectionState = 1;
				// trying ...
				try
				{
					Session.transport.Connect();
					unc = "\\\\" + Session.transport.TconHostName + '\\' + Share;
					Service = Service0;
					if (Session.transport.Log.Level >= 4)
					{
						Session.transport.Log.WriteLine("treeConnect: unc=" + unc + ",service=" + Service
							);
					}
					SmbComTreeConnectAndXResponse response = new SmbComTreeConnectAndXResponse(andxResponse
						);
					SmbComTreeConnectAndX request = new SmbComTreeConnectAndX(Session, unc, Service, 
						andx);
					Session.Send(request, response);
					Tid = response.Tid;
					Service = response.Service;
					InDfs = response.ShareIsInDfs;
					TreeNum = _treeConnCounter++;
					ConnectionState = 2;
				}
				catch (SmbException se)
				{
					// connected
					TreeDisconnect(true);
					ConnectionState = 0;
					throw;
				}
			}
		}

		internal virtual void TreeDisconnect(bool inError)
		{
			lock (Session.Transport())
			{
				if (ConnectionState != 2)
				{
					// not-connected
					return;
				}
				ConnectionState = 3;
				// disconnecting
				if (!inError && Tid != 0)
				{
					try
					{
						Send(new SmbComTreeDisconnect(), null);
					}
					catch (SmbException se)
					{
						if (Session.transport.Log.Level > 1)
						{
							Runtime.PrintStackTrace(se, Session.transport.Log);
						}
					}
				}
				InDfs = false;
				InDomainDfs = false;
				ConnectionState = 0;
				Runtime.NotifyAll(Session.transport);
			}
		}

		public override string ToString()
		{
			return "SmbTree[share=" + Share + ",service=" + Service + ",tid=" + Tid + ",inDfs="
				 + InDfs + ",inDomainDfs=" + InDomainDfs + ",connectionState=" + ConnectionState
				 + "]";
		}
	}
}