////////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  File:   Services/Smb/FileExp.sg
//
//  Note:
//
//		This file contains the implementation of FileContract.  This contract
//		allows clients to access the contents of files on remote SMB servers.
//		The FileExp class holds a reference to FileContract.Exp, on which it
//		receives file requests (read, write, etc.), and also a reference to
//		SmbTransactor.Imp, which it uses to execute SMB transactions.
//
//		Each instance of FileExp runs in its own thread.  Access to the
//		single TCP connection to the SMB server is multiplexed by the
//		TransportMux class, which is accessed using the SmbTransactor channel.
//
//		The general pattern is that the FileExp thread loops in a switch-receive
//		loop, and when it receives a file request, it translates the request into
//		SMB requests.  It formats those requests, submits them to the transport
//		mux, then waits for the response, and translates the response into
//		FileContract response messages.
//
//		The top-level loop listens for FileContract messages, and listens for
//		ChannelClosed on the FileContract.  If either channel closes, the
//		thread terminates.  While the thread is waiting for responses on its
//		SmbTransactor channel, it also listens for ChannelClosed on its
//		FileContract channel.  This prevents the thread from blocking for a 
//		long time, if either channel closes.
//
//
//	TODO:
//
//		*	Exception handling is poor.
//

using System;
using System.Threading;
using Microsoft.SingSharp;
using Microsoft.Singularity;
using Microsoft.Singularity.Directory;
using Microsoft.Singularity.Channels;
using Smb.PublicChannels;
using Smb.PrivateChannels;
using Smb.Protocol;
using Smb.Shared;

namespace Smb.Client
{
    /*
    This class implements (exports) FileContract.  A thread is devoted to servicing incoming requests.
    The "upper" edge of this thread is FileContract.Exp.  The "lower" edge of this thread is SmbTransactor.Imp,
    which is the internal communications pipe to the SMB request multiplexer.
    
    The service thread will terminate when several conditions occur:
        * The FileContract.Exp channel closes.
        * The SmbTransactor.Imp channel closes.
        * Any internal exception reaches the main switch-receive loop.
    */
	class FileExp
	{
	    public static void CreateServiceThread([Claims]FileContract.Exp:Start! file_exp, string! path, ushort fileId, [Claims]SmbTransactor.Imp:Ready! transactor)
	    {
	        FileExp exp = new FileExp(file_exp, path, fileId, transactor);
			Thread thread = new Thread(new ThreadStart(exp.ThreadServiceRoutine));
			thread.Start();
	    }
	    
		private FileExp([Claims]FileContract.Exp:Start! file_exp, string! path, ushort fileId, [Claims]SmbTransactor.Imp:Ready! transactor)
		{
			_path = path;
			_file_exp = new TRef<FileContract.Exp:Start>(file_exp);
			_fileId = fileId;
			_debugprefix = String.Format("File[{0:x4}:{1}] ", fileId, path);
			_transactor = new TRef<SmbTransactor.Imp:Ready>(transactor);
		}
		
		// These two channels are passed to the service thread.
		// The service thread never transfers ownership of the channels, so after the
		// service thread starts, these TRefs are never used again.
		readonly TRef<FileContract.Exp:Start>! _file_exp;
		readonly TRef<SmbTransactor.Imp:Ready>! _transactor;

        // The absolute path (within the namespace of the SMB client).  Currently this is only used for
        // diagnostic messages.		
		readonly string! _path;
		
		// The 16-bit SMB file handle.  This value is assigned by the SMB server, and is returned in the
		// response to the CreateAndX response.
		readonly ushort _fileId;
		
		readonly string! _debugprefix;
						
		private void ThreadServiceRoutine()
		{
			FileContract.Exp:Start! file = _file_exp.Acquire();
			SmbTransactor.Imp! transactor = _transactor.Acquire();
			
			file.SendSuccess();
			
			DebugLine("Service thread running");
			
			try
			{
				for (;;)
				{
					switch receive
					{
						case file.Read(byte []! in ExHeap buf, long bufOffset, long fileOffset, long maxLength):
							int error;
							long bytesRead = Read(file, transactor, buf, bufOffset, fileOffset, maxLength, out error);
							#if NOISY
							if (bytesRead >= 0)
								DebugLine("Sending AckRead: bytesRead {0}", bytesRead);
							else
								DebugLine("Sending Ackread: bytesRead {0} error {1}", bytesRead, error);
							#endif
							file.SendAckRead(buf, bytesRead, error);
							break;
	                        
						case file.Write(byte []! in ExHeap buf, long bufOffset, long fileOffset, long maxLength):
						    int error;
						    long bytesWritten = Write(file, transactor, buf, bufOffset, fileOffset, maxLength, out error);
						    if (bytesWritten >= 0)
						        DebugLine("Sending AckWrite: bytesWritten {0}", bytesWritten);
						    else
						        DebugLine("Sending AckWrite: bytesWritten {0} error {1}", bytesWritten, error);
						    file.SendAckWrite(buf, bytesWritten, error);
							break;
							
						case file.Close():
							DebugLine("File client has closed gracefully (Close)");
							file.SendAckClose();
							CloseFid(transactor);
							return;
						
						case file.ChannelClosed():
							DebugLine("File client has closed abruptly (ChannelClose)");
							CloseFid(transactor);
							return;
							
						case transactor.ChannelClosed():
						    DebugLine("The transactor channel has closed.  The FileContract service channel will now close.");
						    return;
					}
				}

            } catch(Exception ex) {
                DebugLine("An exception has reached the service loop of FileContract service thread.");
                DebugLine("The service thread will now terminate.");
                Util.ShowExceptionDebug(ex, "FileContract service thread failed");
			} finally {
				delete file;
				delete transactor;
			}
		}
		
		/*
		This method reads a block of data from the remote file server.  The file must already be open;
		the 16-bit file ID is taken from the _fileId field of the class instance of this method.
		If the data block cannot fit into a single SMB request, then this method will issue more than
		one data transfer request.  Therefore, there is no guarantee of any sort of "atomic" data transfer.
		
		This method is synchronous; it will not return until the data has been read, or until an error
		occurs on the SMB client channel (transactor).
		*/
		long Read(
		    FileContract.Exp! file,
			SmbTransactor.Imp! transactor, 
			byte []! in ExHeap buf,
			long bufOffset,
			long fileOffset,
			long maxLength,
			out int error)
		{
			if (TraceSwitches.ShowFileActivity)
				DebugLine("Read: file offset 0x{0:x} max length 0x{1:x}", fileOffset, maxLength);
			
			if (bufOffset < 0 || fileOffset < 0 || maxLength < 0) {
				DebugLine("Invalid parameters.  One or more values are negative.");
				error = (int)ErrorCode.BadArguments;
				return -1;
			}
			
			if (bufOffset + maxLength > buf.Length) {
				maxLength = buf.Length - bufOffset;
			}
			
			// Arbitrary.
			int transferMaxLength = 1024;
			
			long bytesRead = 0;			
			
			for (;;) {
				assert bytesRead <= maxLength;
				long bytesRemaining = maxLength - bytesRead;
				if (bytesRemaining == 0) {
					error = 0;
					return bytesRead;
				}
				
				if (bytesRemaining > transferMaxLength)
					bytesRemaining = transferMaxLength;
				
				int bytesRequested = (int)bytesRemaining;
					
				int requestLength = sizeof(SmbReadAndXRequest);
				byte[] in ExHeap requestEncoded = new[ExHeap] byte[sizeof(SmbReadAndXRequest)];
				ref SmbReadAndXRequest request = ref requestEncoded[0];
				
				long transferFileOffset = fileOffset + bytesRead;
				
				request.Header.Prepare(SmbCommand.ReadAndX, 12);
				request.AndXCommand = 0xff;
				request.AndXReserved = 0;
				request.AndXOffset = 0;
				request.Fid = _fileId;
				request.FileOffsetLow = (uint)(transferFileOffset & 0xffffffffu);
				request.MaxCount = (ushort)bytesRequested;
				request.MinCount = 0;
				request.MaxCountHigh = 0;
				request.Remaining = 0;
				request.FileOffsetHigh = (uint)(transferFileOffset >> 32);				
				request.ByteCount = 0;
				
				transactor.SendRequest(requestEncoded);
				
				// DebugLine("Reading at file offset 0x{0:x}", transferFileOffset);
				
				switch receive
				{
					case transactor.Response(responseEncoded):
					
						ref SmbHeader header = ref responseEncoded[0];
						if (header.IsError) {
							DebugLine("ReadAndX failed: " + header.GetErrorText());
							delete responseEncoded;
							goto return_error;
						} else {
							if (responseEncoded.Length < sizeof(SmbReadAndXResponse)) {
								DebugLine("Response is too small to be a valid SmbReadAndXResponse.");
								delete responseEncoded;
								goto return_error;
							}
							ref SmbReadAndXResponse response = ref responseEncoded[0];
							
							int dataOffset = SmbHeader.FramingHeaderLength + response.DataOffset;
							uint dataLength = response.DataLength | (((uint)response.DataLengthHigh) << 16);

							if (dataLength > bytesRequested) {
								DebugLine("Server returned more bytes than we asked for!!  Truncating.");
								dataLength = (uint)requestLength;
							}
							
							if (dataLength != 0) {
								if (dataOffset < sizeof(SmbReadAndXResponse)
									|| (dataOffset + dataLength) > responseEncoded.Length) {
									DebugLine("Response is invalid.  DataOffset and DataLength are bogus.");
									delete responseEncoded;
									goto return_error;
								}
							//	DebugLine("Transferred 0x{0:x} bytes to buffer offset 0x{1:x}.", dataLength, bufOffset);
								Bitter.Copy(buf, (int)(bufOffset + bytesRead), (int)dataLength, responseEncoded, (int)dataOffset);
								bytesRead += dataLength;
								delete responseEncoded;
							} else {
								DebugLine("Server indicates that zero bytes were transferred in this exchange.");
								DebugLine("Returning {0} bytes read.", bytesRead);
								delete responseEncoded;
								error = 0;
								return bytesRead;
							}
						}						
						break;
						
					case transactor.RequestFailed(tranError):
						DebugLine("ReadAndX failed: " + tranError.ToString());
						goto return_error;
						
					case transactor.ChannelClosed():
						DebugLine("Transactor channel was closed.");
						goto return_error;
						
					case file.ChannelClosed():
					    DebugLine("The FileContract.Exp channel has closed during a ReadAndX transfer.");
					    DebugLine("The FileContract service thread will now close its transactor channel and terminate.");
					    error = -1;
					    return -1;
				}
			}
			
		return_error:
			if (bytesRead > 0) {
				// Some bytes were transferred.
				error = 0;
				return bytesRead;
			} else {
				// No bytes were transferred, and there was an error.
				DebugLine("No bytes transferred.  Returning -1 for bytes transferred.");
				error = -1;
				return -1;
			}
		}
		
		/*
		This method writes a block of data to the remote file server.  The file must already be
		open; the 16-bit file ID is taken from the _fileId field of the class instance of this method.
		If the data block cannot fit into a single SMB request, then this method will issue more than
		one data transfer request.  Therefore, there is no guarantee of any sort of "atomic" data writes.
		
		This method is synchronous; it will not return until the data has been written, or until an error
		occurs on the SMB client channel (transactor).
		*/
		long Write(
		    FileContract.Exp! file,
			SmbTransactor.Imp! transactor, 
			byte []! in ExHeap buf,
			long bufOffset,
			long fileOffset,
			long maxLength,
			out int error)
		{
			DebugLine("Write: file offset 0x{0:x} max length 0x{1:x}", fileOffset, maxLength);
			
			if (bufOffset < 0 || fileOffset < 0 || maxLength < 0) {
				DebugLine("Invalid parameters.  One or more values are negative.");
				error = (int)ErrorCode.BadArguments;
				return -1;
			}
			
			if (bufOffset + maxLength > buf.Length) {
				maxLength = buf.Length - bufOffset;
			}
			
			// Arbitrary.
			int transferMaxLength = 1024;
			
			long bytesWritten = 0;			
			
			for (;;) {
				assert bytesWritten <= maxLength;
				long bytesRemaining = maxLength - bytesWritten;
				if (bytesRemaining == 0) {
					error = 0;
					return bytesWritten;
				}
				
				if (bytesRemaining > transferMaxLength)
					bytesRemaining = transferMaxLength;
				
				// bytesRequested is the number of bytes that we will attempt to transfer in this
				// single request.
				int bytesRequested = (int)bytesRemaining;

				int requestLength = sizeof(SmbWriteAndXRequest);
				requestLength = Util.Align4(requestLength);
				int payloadOffset = requestLength;
				requestLength += bytesRequested;
				requestLength = Util.Align4(requestLength);
				
				byte[] in ExHeap requestEncoded = new[ExHeap] byte[requestLength];
				ref SmbWriteAndXRequest request = ref requestEncoded[0];
				
				long transferFileOffset = fileOffset + bytesWritten;

				request.Header.Prepare(SmbCommand.WriteAndX, SmbWriteAndXRequest.ParameterCount);
				request.AndXCommand = 0xff;
				request.AndXReserved = 0;
				request.AndXOffset = 0;
				request.Fid = _fileId;
				request.FileOffsetLow = (uint)(transferFileOffset & 0xffffffffu);
				request.Reserved = 0;
				request.WriteMode = 0;
				request.Remaining = 0xffff;
				request.DataLengthHigh = (ushort)(bytesRequested >> 16);
				request.DataLengthLow = (ushort)(bytesRequested & 0xffff);
				request.DataOffset = (ushort)(payloadOffset - SmbHeader.FramingHeaderLength);
				request.FileOffsetHigh = (uint)(transferFileOffset >> 32);
				request.ByteCount = 0;

                // Transfer the data from the buffer supplied by FileContract importer to our request buffer.
                // In the future, if we're smarter, we may be able to eliminate this copy by passing this
                // buffer directly to TcpConnectionContract.  That would require modifying TcpConnectionContract
                // so that it returned the (unmodified) buffer.
                Bitter.Copy(requestEncoded, payloadOffset, bytesRequested, buf, (int)(bufOffset + bytesWritten));
				
				transactor.SendRequest(requestEncoded);
				
				DebugLine("Writing at file offset 0x{0:x}", transferFileOffset);
				DebugLine("Waiting for response to WriteAndX");
				
				switch receive
				{
					case transactor.Response(responseEncoded):
					
						ref SmbHeader header = ref responseEncoded[0];
						if (header.IsError) {
							DebugLine("WriteAndX failed: " + header.GetErrorText());
							delete responseEncoded;
							goto return_error;
						} else {
							if (responseEncoded.Length < sizeof(SmbWriteAndXResponse)) {
								DebugLine("Response is too small to be a valid SmbWriteAndXResponse.");
								delete responseEncoded;
								goto return_error;
							}
							ref SmbWriteAndXResponse response = ref responseEncoded[0];
							
							if (response.Count == 0) {
							    // No bytes were transferred.  Assume the remote file server will not accept
							    // any more bytes on this file handle.
							    DebugLine("Response indicates that zero bytes were transferred.  Terminating the transfer.");
							    delete responseEncoded;
							    error = 0;
							    return bytesWritten;
							}
							
							bytesWritten += response.Count;
							DebugLine("Wrote {0} bytes, for a total of {1} bytes", response.Count, bytesWritten);
							delete responseEncoded;
							// Loop for another transfer.
						}						
						break;
						
					case transactor.RequestFailed(tranError):
						DebugLine("WriteAndX failed: " + tranError.ToString());
						goto return_error;

					case transactor.ChannelClosed():
						DebugLine("Transactor channel was closed.");
						goto return_error;

					case file.ChannelClosed():
					    DebugLine("The FileContract.Exp channel has closed during a WriteAndX transfer.");
					    DebugLine("The FileContract service thread will now close its transactor channel and terminate.");
					    error = -1;
					    return -1;
				}

			return_error:
				if (bytesWritten > 0) {
					// Some bytes were transferred.
					error = 0;
					return bytesWritten;
				} else {
					// No bytes were transferred, and there was an error.
					DebugLine("No bytes transferred.  Returning -1 for bytes transferred.");
					error = -1;
					return -1;
				}
			}
		}
		
		void CloseFid(SmbTransactor.Imp! transactor)
		{
			int requestLength = sizeof(SmbCloseFileRequest);
			byte[]! in ExHeap request_encoded = new[ExHeap] byte[requestLength];
			ref SmbCloseFileRequest request = ref request_encoded[0];
			request.Header.Prepare(SmbCommand.CloseFile, 3);
			request.Fid = _fileId;
			request.ByteCount = 0;

			transactor.SendRequest(request_encoded);
			
			DebugLine("Waiting for response to CLOSE FILE");
			switch receive {
			    case transactor.Response(responseEncoded):
			        delete responseEncoded;
			        DebugLine("Received response to CLOSE FILE");
			        break;
			        
			    case transactor.RequestFailed(error):
			        DebugLine("The CLOSE FILE request has failed.  The server returned an error code: " + error);
			        break;
			        
			    case transactor.ChannelClosed():
			        DebugLine("Failed to execute CLOSE FILE request.  The transactor channel has closed.");
			        break;
			        
			    // Don't wait for file.ChannelClosed here, because it has probably already closed.
			    // Even if it had not, we want to finish the transaction, not (potentially, in
			    // some future implementation) interrupt the transaction by closing the transactor
			    // channel.
			}
		}
		
		void DebugLine(string msg)
		{
			SmbDebug.WriteLine(_debugprefix + msg);
		}
		
		void DebugLine(string format, params object[] args)
		{
			DebugLine(String.Format(format, args));
		}
	}
}