///////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//

/*

This program is a tool for managing instances of the SMB client service.
The tool allows users to list running instances of the SMB client process,
to display their configuration and status, and to create new SMB client
processes.

This program provides some of the functionality of the Windows "net" command,
such as "net use" command, etc.

*/

using System;
using System.Collections;
using System.Diagnostics;
using System.Net.IP;
using NetStack.Contracts;
using NetStack.Channels.Public;
using Microsoft.Contracts;
using Microsoft.Singularity;
using Microsoft.Singularity.Channels;
using Microsoft.Singularity.Directory;
using Microsoft.Singularity.Applications;
using Microsoft.Singularity.Io;
using Microsoft.Singularity.Configuration;
using Microsoft.SingSharp;
using Microsoft.SingSharp.Reflection;
using Smb.PublicChannels;


[assembly: Transform(typeof(ApplicationResourceTransform))]

namespace Microsoft.Singularity.Applications.Network
{
#if !false
    [ConsoleCategory(HelpMessage="Show help for SMB control client", DefaultAction=true)]
    internal class DefaultCommand {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        reflective internal DefaultCommand();

        internal int AppMain()
        {
			Console.WriteLine("Specify a command to execute, or '-?' for a list of commands.");
			return 0;
        }
    }
#endif
    
    [ConsoleCategory(Action="list", HelpMessage="List active SMB client processes" )]
    internal class ListClientsParameters
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;
        
        //[BoolParameter("v", Mandatory=false, HelpMessage="List details about each client")]
        public bool Verbose = true;

        reflective internal ListClientsParameters();

        internal int AppMain()
        {
			try {
				SmbClientManagerContract.Imp! manager = SmbControl.ConnectSmbClientManagerRequired();
				try {
				
					manager.SendEnumClients();
					
					switch receive {
						case manager.ClientList(char[][]! in ExHeap mountPaths):
						
							for (int i = 0; i < mountPaths.Length; i++) {
								expose (mountPaths[i]) {
									char[] in ExHeap exmountPath = mountPaths[i];
									if (exmountPath == null)
										continue;
										
									string! mountPath = Bitter.ToString2(exmountPath);
									SmbControl.ShowClientInfo(manager, mountPath);
								}
							}
							
							delete mountPaths;
							return 0;						
							
						case manager.RequestFailed(errorCode, optionalErrorText):
							SmbControl.ShowRequestFailed(errorCode, optionalErrorText);
							delete optionalErrorText;
							return -1;
					}				
				} finally {
					delete manager;
				}
				
			} catch (Exception ex) {
				SmbControl.ShowException(ex);
				return 1;
			}
		}
    }
    
    [ConsoleCategory(Action="info", HelpMessage="Shows the status of an SMB client, given its mount path.")]
    internal class ShowInfoCommand
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;
        
        reflective internal ShowInfoCommand();
        
        [StringParameter("mountpath", Mandatory=true, Position=0, HelpMessage="The mount path of the SMB filesystem to query, e.g. /foo.")]
        internal string MountPath;

        internal int AppMain()
        {
			try {
				SmbControl.ShowClientInfo((!)MountPath);
				return 0;
			} catch (Exception ex) {
				SmbControl.ShowException(ex);
				return 1;
			}
				
		}
    }

    [ConsoleCategory(Action="unmount", HelpMessage="Disconnect an SMB client process from the Singularity namespace.")]
    internal class UnmountCommand
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

		[StringParameter("mountpath", Mandatory=true, Position=0, HelpMessage="The mount path of SMB client, e.g. /files")]
		public string MountPath;

        reflective internal UnmountCommand();

        internal int AppMain()
		{
			try {
				string! mountPath = (!)this.MountPath;
				
				SmbClientManagerContract.Imp manager = SmbControl.ConnectSmbClientManager();
				if (manager == null)
					return -1;
					
				try {
					manager.SendStopClient(Bitter.FromString2(mountPath));
					
					switch receive {
						case manager.Ok():
							break;
							
						case manager.RequestFailed(SmbErrorCode error, char[] in ExHeap errortext):
							delete errortext;
							break;
					}
				
				} finally {
					delete manager;
				}
				
				return 0;
			} catch (Exception ex) {
				SmbControl.ShowException(ex);
				return 1;
			}
		}		
    }

#if false // disabled for now
    [ConsoleCategory(Action="reset", HelpMessage="Resets an SMB client, causing it to disconnect and reconnect.")]
    internal class ResetCommand
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

		[StringParameter("clientid", HelpMessage="The local mount path, or control endpoint, of the SMB filesystem to reset.", Mandatory=true, Position=0)]
		public string ClientId;
		
		reflective internal ResetCommand();
		
		int AppMain()
		{
			try {
				SmbClientControlContract.Imp! control = SmbControl.BindSmbControlClient(ClientId);
				try {
					control.SendReconnect();
					switch receive {
						case control.AckReconnect():
							Console.WriteLine("Successfully sent reset/reconnect request to SMB client.");
							return 0;
							
						case control.ChannelClosed():
							Console.WriteLine("SMB client reset channel before responding.");
							return -1;
					}
				} finally {
					delete control;
				}
			} catch(Exception ex) {
				SmbControl.ShowException(ex);
				return -1;
			}
		}
    }
#endif
    
    [ConsoleCategory(Action="mount", HelpMessage="Create a mapping to an SMB file share.")]
    internal class MountCommand
    {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

		[StringParameter("mountpath", Mandatory=true, Position=0, HelpMessage="The local path at which to mount the remote namespace, e.g. /foo")]
		public string MountPath;

		[StringParameter("unc", Mandatory=true, Position=1, HelpMessage=@"The UNC path of the share, e.g. \\server\share")]
		public string UncPath;
		
		[StringParameter("user", Mandatory=false, HelpMessage="The [domain\\]username to use when authenticating.")]
		public string CredentialsName;
		
		[StringParameter("tag", Mandatory=false, HelpMessage="If 'user' is specified, this parameter allows you to pass a credentials tag.")]
		public string Tag;
		
        reflective internal MountCommand();

        internal int AppMain()
        {
			try {
				string! unc = (!)this.UncPath;
				string! mountpath = (!)this.MountPath;

				if (mountpath.Length == 0 || mountpath[0] != '/')
					throw new Exception("The mount path is invalid.  It must be an absolute path.");

				SmbClientManagerContract.Imp manager = SmbControl.ConnectSmbClientManager();
				if (manager == null)
					return -1;

				try {
					SmbClientConfig config = new SmbClientConfig();
					config.UncPath = Bitter.FromString2(unc);
					config.MountPath = Bitter.FromString2(mountpath);
					config.CredentialsName = Bitter.FromString2(this.CredentialsName != null ? this.CredentialsName : "");
					config.Tag = Bitter.FromString2(this.Tag != null ? this.Tag : "");
									
					manager.SendCreateClient(config);
					
					switch receive {
						case manager.Ok():
							Console.WriteLine("Filesystem mapping has been created.");
							Console.WriteLine("");
							Console.WriteLine("Be advised!  Creating the mapping (mount point) does NOT mean");
							Console.WriteLine("that the local SMB redirector (client) has been able to connect");
							Console.WriteLine("to the remote file server.  The mapping represents the goal state;");
							Console.WriteLine("you can see the current state by using the 'net @list' command.");
							break;
							
						case manager.RequestFailed(SmbErrorCode error, char[] in ExHeap errortext):
							Console.WriteLine("The request failed.");
							Console.WriteLine("Error: {0} {1}", error, Bitter.ToString(errortext));
							delete errortext;
							return -1;
							
						case manager.ChannelClosed():
							Console.WriteLine("SMB client closed channel before responding!");
							return -1;
					}
				} finally {
					delete manager;
				}
				
			} catch (Exception ex) {
				SmbControl.ShowException(ex);
			}		
			
			return 0;
		}
    }
    
    class SmbControl
    {
		static void ParseUncPath(string! unc, out string! server, out string! resource)
		{
			if (!unc.StartsWith("\\\\"))
				throw new Exception(String.Format("The UNC path '{0}' is invalid.  All UNC paths must begin with '\\\\'.", unc));
			
			int separator = unc.IndexOf('\\', 2);
			assert (separator < 0) || (separator >= 2);
			if (separator < 0 || separator == 2)
				throw new Exception(String.Format("The UNC path '{0}' is invalid.  The server name is missing.", unc));
			
			if (separator + 1 == unc.Length)
				throw new Exception(String.Format("The UNC path '{0}' is invalid.  The resource name is missing.", unc));
			
			server = unc.Substring(2, separator - 2);
			resource = unc.Substring(separator + 1);
		}
		
		
		public static SmbClientManagerContract.Imp! ConnectSmbClientManagerRequired()
		{
			SmbClientManagerContract.Imp manager = ConnectSmbClientManager();
			if (manager == null)
				throw new Exception("Failed to connect to SMB client manager service.");
			return manager;
		}
		
		// This method connects to the SMB Client Manager service.
		// If it cannot connect to the service, it prints an error message on the text console
		// and returns null.
		public static SmbClientManagerContract.Imp ConnectSmbClientManager()
		{
			DirectoryServiceContract.Imp! rootds = DirectoryService.NewClientEndpoint();
		
			try {
				SmbClientManagerContract.Imp! manager;
				SmbClientManagerContract.Exp! manager_exp;
				SmbClientManagerContract.NewChannel (out manager, out manager_exp);
				
				rootds.SendBind(Bitter.FromString2(SmbClientManagerContract.ManagerControlPath), manager_exp);
				
				switch receive {
					case rootds.AckBind():
						manager.RecvSuccess();
						return manager;
					
					case rootds.NakBind(exp, ErrorCode code):
						Console.WriteLine("Failed to connect to SMB client manager service.");
						Console.WriteLine("The service may not be running.");
						delete exp;
						delete manager;
						return null;
				}
			} finally {
				delete rootds;
			}				
		}
		
		
		static void DebugLine(string msg)
		{
			DebugStub.WriteLine("SMBCONTROL: " + msg);
		}
		
		static void DebugLine(string format, params object[] args)
		{
			DebugLine(String.Format(format, args));
		}
		
		static void Bind(string! path, [Claims]ServiceContract.Exp! exp)
		{
			DirectoryServiceContract.Imp! rootdir = DirectoryService.NewClientEndpoint();
			try {
				ErrorCode errorCode;
				if (SdsUtils.Bind(path, rootdir, exp, out errorCode)) {
					return;
				} else {
					delete rootdir;
					throw new Exception(String.Format("Failed to bind to path '{0}'.  ErrorCode = {1}.", path, SdsUtils.ErrorCodeToString(errorCode)));
				}
			} finally {
				delete rootdir;
			}
		}

		static DirectoryServiceContract.Imp! BindDirectory(string! path)
		{
			DirectoryServiceContract.Exp! dir_exp;
			DirectoryServiceContract.Imp! dir_imp;
			DirectoryServiceContract.NewChannel(out dir_imp, out dir_exp);
			
			DirectoryServiceContract.Imp! rootdir = DirectoryService.NewClientEndpoint();
			
			ErrorCode errorCode;
			if (SdsUtils.Bind(path, rootdir, dir_exp, out errorCode)) {
				delete rootdir;
				dir_imp.RecvSuccess();
				return dir_imp;
			} else {
				delete rootdir;
				delete dir_imp;
				throw new Exception(String.Format("Failed to bind to directory '{0}'.  ErrorCode = {1}.", path, SdsUtils.ErrorCodeToString(errorCode)));
			}
		}
		
		static EnumerationRecords[]! in ExHeap EnumerateDirectory(string! path)
		{
			DirectoryServiceContract.Imp! dir = BindDirectory(path);
			
			try {
				ErrorCode error;
				EnumerationRecords[] in ExHeap records = SdsUtils.EnumerateDirectory(dir, out error);
				if (records != null)
					return records;
				throw new Exception(String.Format("Failed to enumerate contents of path '{0}': {1}", SdsUtils.ErrorCodeToString(error)));
			} finally {
				delete dir;
			}
		}
		
		static internal SmbClientControlContract.Imp! BindSmbControlClient(string! mountPath)
		{
			SmbClientManagerContract.Imp! manager = ConnectSmbClientManagerRequired();
			try {
				return BindSmbControlClient(manager, mountPath);
			} finally {
				delete manager;
			}
		}
		
		static internal SmbClientControlContract.Imp! BindSmbControlClient(SmbClientManagerContract.Imp! manager, string! mountPath)
		{
			SmbClientControlContract.Imp! control_imp;
			SmbClientControlContract.Exp! control_exp;
			SmbClientControlContract.NewChannel(out control_imp, out control_exp);
		
			manager.SendBindClient(Bitter.FromString2(mountPath), control_exp);
			
			switch receive {
				case manager.Ok():
					control_imp.RecvSuccess();
					return control_imp;
					
				case manager.RequestFailed(errorcode, optionalErrorText):
					string local_errorText = Bitter.ToString(optionalErrorText);
					delete optionalErrorText;
					throw new Exception(String.Format("Failed to bind to SMB control endpoint for mount path '{0}': {1} {2}", mountPath, errorcode.ToString(), local_errorText));
			}
		}
		
		
		internal static void ShowClientInfo(string! mountPath)
		{
			SmbClientManagerContract.Imp! manager = ConnectSmbClientManagerRequired();
			try {
				ShowClientInfo(manager, mountPath);
			} finally {
				delete manager;
			}
		}
		
		internal static void ShowClientInfo(SmbClientManagerContract.Imp! manager, string! clientId)
		{		
			Console.WriteLine("SMB client:");
			
			try {
				try {
					
					manager.SendQueryClientConfig(Bitter.FromString2(clientId));
					
					const string format = "    {0,-20} : {1}";
							
					switch receive
					{
						case manager.ClientConfigReport(SmbClientConfig config):
							Console.WriteLine(format, "UNC path", Bitter.ToString2(config.UncPath));
							Console.WriteLine(format, "Mount path", Bitter.ToString2(config.MountPath));						
							Console.WriteLine(format, "User name", Bitter.ToString2(config.CredentialsName));
							config.Dispose();
							break;
							
						case manager.RequestFailed(code, text):
							Console.WriteLine("Failed to query client configuration.");
							SmbControl.ShowRequestFailed(code, text);
							delete text;
							break;
							
						case manager.ChannelClosed():
							Console.WriteLine("SMB service closed channel without responding to control query.");
							break;
					}

					manager.SendQueryClientStatus(Bitter.FromString2(clientId));
					
					switch receive {
						case manager.ClientStatusReport(SmbClientStatus status):
						
							string! connectionStatusText = ToString(status.ConnectionStatus);
							if (status.ConnectionStatus == SmbClientConnectionStatus.Disconnected) {
								connectionStatusText = connectionStatusText + " (reason: " + ToString(status.ReasonDisconnected) + ")";
							}
						
							Console.WriteLine(format, "Connection status", connectionStatusText);
							if (status.ServerMachineName != null)		Console.WriteLine(format, "Server machine name", Bitter.ToString(status.ServerMachineName));
							if (status.ServerDomainName != null)		Console.WriteLine(format, "Server domain name", Bitter.ToString(status.ServerDomainName));
							if (status.ServerOperatingSystem != null)	Console.WriteLine(format, "Server OS", Bitter.ToString(status.ServerOperatingSystem));
							if (status.ActiveCredentialsName != null)	Console.WriteLine(format, "Active Credentials", Bitter.ToString2(status.ActiveCredentialsName));
							
							status.Dispose();
							break;
							
						case manager.RequestFailed(code, text):
							Console.WriteLine("Failed to query client status.");
							SmbControl.ShowRequestFailed(code, text);
							delete text;
							break;
							
						case manager.ChannelClosed():
							Console.WriteLine("Error - Control channel was closed.");
							break;
					}
					
				} finally {
				}
				
			} catch (Exception ex) {
				// Console.WriteLine("Failed to bind to control endpoint '{0}'.", ex);
				ShowException(ex);
			}
			
			Console.WriteLine("");
		}

		static string! ToStringOrNull(char[] in ExHeap str)
		{
		    if (str != null)
		        return Bitter.ToString2(str);
		    else
		        return "(null)";
		}
		
		static string! ToString(SmbClientConnectionStatus status)
		{
			switch (status)
			{
				case SmbClientConnectionStatus.Disconnected: return "Disconnected";
				case SmbClientConnectionStatus.Negotiating: return "Negotiating";				
				case SmbClientConnectionStatus.TransportConnecting: return "Connecting";
				case SmbClientConnectionStatus.Authenticating: return "Authenticating";
				case SmbClientConnectionStatus.Connected: return "Connected";
				default: return "Unknown (" + ((int)status).ToString() + ")";
			}
		}		
		
		static string! ToString(SmbReasonDisconnected reason)
		{
			switch (reason)
			{
				case SmbReasonDisconnected.Idle:					return "Idle";
				case SmbReasonDisconnected.TransportConnectFailed:	return "Failed to connect transport";
				case SmbReasonDisconnected.NegotiationFailed:		return "Negotiation failed";
				case SmbReasonDisconnected.ResourceConnectFailed:	return "Resource connect rejected";
				case SmbReasonDisconnected.AuthenticationFailed:	return "Authentication failed";
				case SmbReasonDisconnected.AuthorizationFailed:		return "Authorization failed";
				case SmbReasonDisconnected.NoResponse:				return "No response from server";
				case SmbReasonDisconnected.ProtocolViolation:		return "Protocol violation";
				case SmbReasonDisconnected.TransportFailure:		return "Transport failure";
				default: return "Unknown (" + ((int)reason).ToString() + ")";
			}
		}		
		
		internal static void ShowException(Exception! chain)
		{
			Exception current = chain;
			while (current != null)
			{
				Console.WriteLine("{0}: {1}", current.GetType().FullName, current.Message);
				current = current.InnerException;
			}
		}
		
		internal static void ShowRequestFailed(SmbErrorCode code, char[] in ExHeap optionalErrorText)
		{
			if (optionalErrorText != null)
				Console.WriteLine("Error: SmbErrorCode.{0} : {1}", code, Bitter.ToString2(optionalErrorText));
			else
				Console.WriteLine("Error: SmbErrorCode.{0}", code);
		}
    }
}