using System;

 using Microsoft.Win32.SafeHandles;

 using System.Text;

 using System.Runtime.InteropServices;

 using System.Threading;

 using System.IO;

 using System.Diagnostics;

 namespace SoundGraph

 {

     public class Server

     {

         [Flags]

         public enum EFileAccess : uint

         {

             //

             // Standart Section

             //

             AccessSystemSecurity = 0x1000000,   // AccessSystemAcl access type

             MaximumAllowed = 0x2000000,     // MaximumAllowed access type

             Delete = 0x10000,

             ReadControl = 0x20000,

             WriteDAC = 0x40000,

             WriteOwner = 0x80000,

             Synchronize = 0x100000,

             StandardRightsRequired = 0xF0000,

             StandardRightsRead = ReadControl,

             StandardRightsWrite = ReadControl,

             StandardRightsExecute = ReadControl,

             StandardRightsAll = 0x1F0000,

             SpecificRightsAll = 0xFFFF,

             FILE_READ_DATA = 0x0001,        // file & pipe

             FILE_LIST_DIRECTORY = 0x0001,       // directory

             FILE_WRITE_DATA = 0x0002,       // file & pipe

             FILE_ADD_FILE = 0x0002,         // directory

             FILE_APPEND_DATA = 0x0004,      // file

             FILE_ADD_SUBDIRECTORY = 0x0004,     // directory

             FILE_CREATE_PIPE_INSTANCE = 0x0004, // named pipe

             FILE_READ_EA = 0x0008,          // file & directory

             FILE_WRITE_EA = 0x0010,         // file & directory

             FILE_EXECUTE = 0x0020,          // file

             FILE_TRAVERSE = 0x0020,         // directory

             FILE_DELETE_CHILD = 0x0040,     // directory

             FILE_READ_ATTRIBUTES = 0x0080,      // all

             FILE_WRITE_ATTRIBUTES = 0x0100,     // all

             //

             // Generic Section

             //

             GenericRead = 0x80000000,

             GenericWrite = 0x40000000,

             GenericExecute = 0x20000000,

             GenericAll = 0x10000000,

             SPECIFIC_RIGHTS_ALL = 0x00FFFF,

             FILE_ALL_ACCESS =

             StandardRightsRequired |

             Synchronize |

             0x1FF,

             FILE_GENERIC_READ =

             StandardRightsRead |

             FILE_READ_DATA |

             FILE_READ_ATTRIBUTES |

             FILE_READ_EA |

             Synchronize,

             FILE_GENERIC_WRITE =

             StandardRightsWrite |

             FILE_WRITE_DATA |

             FILE_WRITE_ATTRIBUTES |

             FILE_WRITE_EA |

             FILE_APPEND_DATA |

             Synchronize,

             FILE_GENERIC_EXECUTE =

             StandardRightsExecute |

               FILE_READ_ATTRIBUTES |

               FILE_EXECUTE |

               Synchronize

         }

         [Flags]

         public enum EFileShare : uint

         {

             /// <summary>

             /// 

             /// </summary>

             None = 0x00000000,

             /// <summary>

             /// Enables subsequent open operations on an object to request read access. 

             /// Otherwise, other processes cannot open the object if they request read access. 

             /// If this flag is not specified, but the object has been opened for read access, the function fails.

             /// </summary>

             Read = 0x00000001,

             /// <summary>

             /// Enables subsequent open operations on an object to request write access. 

             /// Otherwise, other processes cannot open the object if they request write access. 

             /// If this flag is not specified, but the object has been opened for write access, the function fails.

             /// </summary>

             Write = 0x00000002,

             /// <summary>

             /// Enables subsequent open operations on an object to request delete access. 

             /// Otherwise, other processes cannot open the object if they request delete access.

             /// If this flag is not specified, but the object has been opened for delete access, the function fails.

             /// </summary>

             Delete = 0x00000004

         }

         public enum ECreationDisposition : uint

         {

             /// <summary>

             /// Creates a new file. The function fails if a specified file exists.

             /// </summary>

             New = 1,

             /// <summary>

             /// Creates a new file, always. 

             /// If a file exists, the function overwrites the file, clears the existing attributes, combines the specified file attributes, 

             /// and flags with FILE_ATTRIBUTE_ARCHIVE, but does not set the security descriptor that the SECURITY_ATTRIBUTES structure specifies.

             /// </summary>

             CreateAlways = 2,

             /// <summary>

             /// Opens a file. The function fails if the file does not exist. 

             /// </summary>

             OpenExisting = 3,

             /// <summary>

             /// Opens a file, always. 

             /// If a file does not exist, the function creates a file as if dwCreationDisposition is CREATE_NEW.

             /// </summary>

             OpenAlways = 4,

             /// <summary>

             /// Opens a file and truncates it so that its size is 0 (zero) bytes. The function fails if the file does not exist.

             /// The calling process must open the file with the GENERIC_WRITE access right. 

             /// </summary>

             TruncateExisting = 5

         }

         [Flags]

         public enum EFileAttributes : uint

         {

             None = 0x00000000,

             Readonly = 0x00000001,

             Hidden = 0x00000002,

             System = 0x00000004,

             Directory = 0x00000010,

             Archive = 0x00000020,

             Device = 0x00000040,

             Normal = 0x00000080,

             Temporary = 0x00000100,

             SparseFile = 0x00000200,

             ReparsePoint = 0x00000400,

             Compressed = 0x00000800,

             Offline = 0x00001000,

             NotContentIndexed = 0x00002000,

             Encrypted = 0x00004000,

             Write_Through = 0x80000000,

             Overlapped = 0x40000000,

             NoBuffering = 0x20000000,

             RandomAccess = 0x10000000,

             SequentialScan = 0x08000000,

             DeleteOnClose = 0x04000000,

             BackupSemantics = 0x02000000,

             PosixSemantics = 0x01000000,

             OpenReparsePoint = 0x00200000,

             OpenNoRecall = 0x00100000,

             FirstPipeInstance = 0x00080000

         }

         [DllImport("kernel32.dll", SetLastError = true)]

         public static extern SafeFileHandle CreateNamedPipe(

            String pipeName,

            uint dwOpenMode,

            uint dwPipeMode,

            uint nMaxInstances,

            uint nOutBufferSize,

            uint nInBufferSize,

            uint nDefaultTimeOut,

            IntPtr lpSecurityAttributes);

         [DllImport("kernel32.dll", SetLastError = true)]

         public static extern int ConnectNamedPipe(

            SafeFileHandle hNamedPipe,

            IntPtr lpOverlapped);

         [DllImport("kernel32.dll", SetLastError = true)]

         public static extern int DisconnectNamedPipe(

            SafeFileHandle hNamedPipe);

         [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]

         public static extern SafeFileHandle CreateFile(

            string lpFileName,

            EFileAccess dwDesiredAccess,

            EFileShare dwShareMode,

            IntPtr lpSecurityAttributes,

            ECreationDisposition dwCreationDisposition,

            EFileAttributes dwFlagsAndAttributes,

            IntPtr hTemplateFile);

         //[DllImport("kernel32.dll", SetLastError = true)]

         //static extern bool CloseHandle(IntPtr hHandle);

         public const uint PIPE_ACCESS_DUPLEX = (0x00000003);

         public const uint FILE_FLAG_OVERLAPPED = (0x40000000);

         public const uint PIPE_ACCESS_OUTBOUND = (0x00000002);

         public const uint PIPE_ACCESS_INBOUND = (0x00000001);

         public const uint PIPE_TYPE_BYTE = (0x00000000);

         public const uint PIPE_UNLIMITED_INSTANCES = 255;

         public const int BUFFER_SIZE = 256;

         //

         public string iPipeNameOutbound;

         SafeFileHandle iPipeOutbound;

         public FileStream iStreamOutbound;

         //

         public string iPipeNameInbound;

         Thread iThreadInbound;

         SafeFileHandle iPipeInbound;

         public FileStream iStreamInbound;

         private bool iQuit = false;

         public Server(string aPipeNameOutbound, string aPipeNameInbound)

         {

             iPipeNameOutbound = aPipeNameOutbound;

             iPipeNameInbound = aPipeNameInbound;

         }

         /**

          * Start our services.

          */

         public void Start()

         {

             //Start inbound thread to receive messages

             this.iThreadInbound = new Thread(new ThreadStart(ThreadInbound));

             this.iThreadInbound.Start();

         }

         /**

          * Stop our services.

          */

         public void Stop()

         {

             iQuit = true;

         }

         /**

          * Inbound thread is receiving messages from our client

          */

         private void ThreadInbound()

         {

             //Keep on trying to connect on our read pipe

             while ((iPipeInbound == null || iPipeInbound.IsInvalid) && !iQuit)

             {

                 Trace.WriteLine("Trying to connect to inbound pipe...");

                 iPipeInbound = CreateFile(iPipeNameInbound, EFileAccess.GenericRead, EFileShare.None, IntPtr.Zero, ECreationDisposition.OpenExisting, EFileAttributes.None, IntPtr.Zero);

                 System.Threading.Thread.Sleep(1000);

             }

             //Client now connected create our inbound stream

             if (iPipeInbound!=null && !iPipeInbound.IsInvalid)

             {

                 iStreamInbound = new FileStream(iPipeInbound, FileAccess.Read, BUFFER_SIZE, false);

                 if (iStreamInbound.CanRead)

                 {

                     Trace.WriteLine("Inbound stream ready!");

                 }

             }

             //Keep on trying to connect to our write pipe

             while ((iPipeOutbound == null || iPipeOutbound.IsInvalid) && !iQuit)

             {

                 Trace.WriteLine("Trying to connect to outbound pipe...");

                 iPipeOutbound = CreateFile(iPipeNameOutbound, EFileAccess.GenericWrite, EFileShare.None, IntPtr.Zero, ECreationDisposition.OpenExisting, EFileAttributes.None, IntPtr.Zero);

                 System.Threading.Thread.Sleep(1000);

             }

             //Client now connected create our stream

             if (iPipeOutbound!=null && !iPipeOutbound.IsInvalid)

             {

                 iStreamOutbound = new FileStream(iPipeOutbound, FileAccess.Write, BUFFER_SIZE, false);

                 if (iStreamOutbound.CanWrite)

                 {

                     Trace.WriteLine("Outbound stream ready!");

                 }

             }

             //Listening loop

             byte[] buffer = null;

             ASCIIEncoding encoder = new ASCIIEncoding();

             while (!iQuit)

             {                

                 int bytesRead = 0;

                 try

                 {

                     buffer = new byte[BUFFER_SIZE];

                     bytesRead = iStreamInbound.Read(buffer, 0, BUFFER_SIZE);

                 }

                 catch

                 {

                     //read error has occurred

                     break;

                 }

                 //client has disconnected

                 if (bytesRead == 0)

                     break;

                 //fire message received event

                 //if (this.MessageReceived != null)

                 //    this.MessageReceived(clientse, encoder.GetString(buffer, 0, bytesRead));

                 int ReadLength = 0;

                 for (int i = 0; i < BUFFER_SIZE; i++)

                 {

                     //if (buffer[i].ToString("x2") != "cc")

                     if (buffer[i] != 0)

                     {

                         ReadLength++;

                     }

                     else

                         break;

                 }

                 if (ReadLength > 0)

                 {

                     byte[] Rc = new byte[ReadLength];

                     Buffer.BlockCopy(buffer, 0, Rc, 0, ReadLength);

                     string msg = encoder.GetString(Rc, 0, ReadLength);

                     Trace.WriteLine(msg);

                     Trace.WriteLine("Received " + ReadLength + " Bytes: " + msg);

                     buffer.Initialize();

                 }

             }

             //clean up resources

             if (iStreamInbound!=null) iStreamInbound.Close();

             if (iPipeInbound != null) iPipeInbound.Close();

             //

             if (iStreamOutbound != null) iStreamOutbound.Close();

             if (iPipeOutbound != null) iPipeOutbound.Close();

         }

         /**

          * Send a message to our client.

          */

         public void SendMessage(string message)

         {

             byte[] m8 = new byte[message.Length];

             int i = 0;

             foreach (char c in message)

             {

                 m8[i]=System.Convert.ToByte(c);

                 i++;

             }

             //ASCIIEncoding encoder = new ASCIIEncoding();

             //byte[] messageBuffer = encoder.GetBytes(message);

             if (iStreamOutbound != null && iStreamOutbound.CanWrite)

             {

                 //iStreamOutbound.Write(messageBuffer, 0, messageBuffer.Length);

                 iStreamOutbound.Write(m8, 0, message.Length);

                 iStreamOutbound.Flush();

             }

         }

     }

 }