trunk/TSAdminTool/TerminalServices.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Net;
using System.Windows.Forms;
using System.Data;
using log4net;
namespace AnywhereTS
{
    public class TSManager
    {
        // Imports
        [DllImport("wtsapi32.dll")]
        static extern IntPtr WTSOpenServer([MarshalAs(UnmanagedType.LPStr)] String pServerName);

        [DllImport("wtsapi32.dll")]
        public static extern void WTSCloseServer(IntPtr hServer);

        [DllImport("wtsapi32.dll")]
        public static extern Int32 WTSEnumerateSessions(
            IntPtr hServer,
            [MarshalAs(UnmanagedType.U4)] Int32 Reserved,
            [MarshalAs(UnmanagedType.U4)] Int32 Version,
            ref IntPtr ppSessionInfo,
            [MarshalAs(UnmanagedType.U4)] ref Int32 pCount);

        /// <summary>
        /// The WTSQuerySessionInformation function retrieves session information for the specified 
        /// session on the specified terminal server. 
        /// It can be used to query session information on local and remote terminal servers.
        /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/termserv/termserv/wtsquerysessioninformation.asp
        /// </summary>
        /// <param name="hServer">Handle to a terminal server. Specify a handle opened by the WTSOpenServer function, 
        /// or specify <see cref="WTS_CURRENT_SERVER_HANDLE"/> to indicate the terminal server on which your application is running.</param>
        /// <param name="sessionId">A Terminal Services session identifier. To indicate the session in which the calling application is running 
        /// (or the current session) specify <see cref="WTS_CURRENT_SESSION"/>. Only specify <see cref="WTS_CURRENT_SESSION"/> when obtaining session information on the 
        /// local server. If it is specified when querying session information on a remote server, the returned session 
        /// information will be inconsistent. Do not use the returned data in this situation.</param>
        /// <param name="wtsInfoClass">Specifies the type of information to retrieve. This parameter can be one of the values from the <see cref="WTSInfoClass"/> enumeration type. </param>
        /// <param name="ppBuffer">Pointer to a variable that receives a pointer to the requested information. The format and contents of the data depend on the information class specified in the <see cref="WTSInfoClass"/> parameter. 
        /// To free the returned buffer, call the <see cref="WTSFreeMemory"/> function. </param>
        /// <param name="pBytesReturned">Pointer to a variable that receives the size, in bytes, of the data returned in ppBuffer.</param>
        /// <returns>If the function succeeds, the return value is a nonzero value.
        /// If the function fails, the return value is zero. To get extended error information, call GetLastError.
        /// </returns>
        [DllImport("wtsapi32.dll", EntryPoint = "WTSQuerySessionInformation", CallingConvention = CallingConvention.Cdecl)]
        public static extern bool WTSQuerySessionInformation(
            System.IntPtr hServer,
            uint sessionId,
            WTSInfoClass wtsInfoClass,
            out System.IntPtr ppBuffer,
            out uint pBytesReturned);

        [DllImport("wtsapi32.dll")]
        static extern void WTSFreeMemory(IntPtr pMemory);

        // For Lookup of MAC address
        [DllImport("iphlpapi.dll", ExactSpelling = true)]
        public static extern int SendARP(int DestIP, int SrcIP, [Out] byte[]
        pMacAddr, ref int PhyAddrLen);

        // Consts
        public const uint WTS_CURRENT_SESSION = 4294967295; // = -1

        // Type definitions
        
        [StructLayout(LayoutKind.Sequential)]
        
        private struct WTS_SESSION_INFO
        {
            public uint SessionID;

            [MarshalAs(UnmanagedType.LPStr)]
            public String pWinStationName;

            public WTS_CONNECTSTATE_CLASS State;
        }

        public enum WTS_CONNECTSTATE_CLASS
        {
            WTSActive,              // User logged on to WinStation
            WTSConnected,           // WinStation connected to client
            WTSConnectQuery,        // In the process of connecting to client
            WTSShadow,              // Shadowing another WinStation
            WTSDisconnected,        // WinStation logged on without client
            WTSIdle,                // Waiting for client to connect
            WTSListen,              // WinStation is listening for connection
            WTSReset,               // WinStation is being reset
            WTSDown,                // WinStation is down due to error
            WTSInit,                // WinStation in initialization
        };
        
        /// <summary>
        /// Contains values that indicate the type of session information to retrieve in a call to the WTSQuerySessionInformation function.
        /// http://msdn.microsoft.com/en-us/library/windows/desktop/aa383861(v=vs.85).aspx
        /// </summary>
        public enum WTSInfoClass
        {
            /// <summary>
            /// A null-terminated string that contains the name of the initial program that Remote Desktop Services runs when the user logs on.
            /// </summary>
            WTSInitialProgram,
            /// <summary>
            /// A null-terminated string that contains the published name of the application that the session is running.
            /// </summary>
            WTSApplicationName,
            /// <summary>
            /// A null-terminated string that contains the default directory used when launching the initial program.
            /// </summary>
            WTSWorkingDirectory,
            /// <summary>
            /// This value is not used.
            /// </summary>
            WTSOEMId,
            /// <summary>
            /// A ULONG value that contains the session identifier.
            /// </summary>
            WTSSessionId,
            /// <summary>
            /// A null-terminated string that contains the name of the user associated with the session.
            /// </summary>
            WTSUserName,
            /// <summary>
            /// A null-terminated string that contains the name of the Remote Desktop Services session. 
            /// Note  Despite its name, specifying this type does not return the window station name. Rather, it returns the name of the Remote Desktop Services session. Each Remote Desktop Services session is associated with an interactive window station. Because the only supported window station name for an interactive window station is "WinSta0", each session is associated with its own "WinSta0" window station. For more information, see Window Stations.
            /// </summary>
            WTSWinStationName,
            /// <summary>
            /// A null-terminated string that contains the name of the domain to which the logged-on user belongs.
            /// </summary>
            WTSDomainName,
            /// <summary>
            /// The session's current connection state. For more information, see WTS_CONNECTSTATE_CLASS.
            /// </summary>
            WTSConnectState,
            /// <summary>
            /// A ULONG value that contains the build number of the client.
            /// </summary>
            WTSClientBuildNumber,
            /// <summary>
            /// A null-terminated string that contains the name of the client.
            /// </summary>
            WTSClientName,
            /// <summary>
            /// A null-terminated string that contains the directory in which the client is installed.
            /// </summary>
            WTSClientDirectory,
            /// <summary>
            /// A USHORT client-specific product identifier.
            /// </summary>
            WTSClientProductId,
            /// <summary>
            /// A ULONG value that contains a client-specific hardware identifier. This option is reserved for future use. WTSQuerySessionInformation will always return a value of 0.
            /// </summary>
            WTSClientHardwareId,
            /// <summary>
            /// The network type and network address of the client. For more information, see WTS_CLIENT_ADDRESS.
            /// The IP address is offset by two bytes from the start of the Address member of the WTS_CLIENT_ADDRESS structure.
            /// </summary>
            WTSClientAddress,
            /// <summary>
            /// Information about the display resolution of the client. For more information, see WTS_CLIENT_DISPLAY.
            /// </summary>
            WTSClientDisplay,
            /// <summary>
            /// A USHORT value that specifies information about the protocol type for the session. This is one of the following values.
            /// 0: The console session.
            /// 1: This value is retained for legacy purposes.
            /// 2: The RDP protocol.
            /// </summary>
            WTSClientProtocolType,
            /// <summary>
            /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns ERROR_NOT_SUPPORTED. 
            /// Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not used.
            /// </summary>
            WTSIdleTime,
            /// <summary>
            /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns ERROR_NOT_SUPPORTED. 
            /// Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not used.
            /// </summary>
            WTSLogonTime,
            /// <summary>
            /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns ERROR_NOT_SUPPORTED. 
            /// Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not used.
            /// </summary>
            WTSIncomingBytes,
            /// <summary>
            /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns ERROR_NOT_SUPPORTED. 
            /// Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not used.
            /// </summary>
            WTSOutgoingBytes,
            /// <summary>
            /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns ERROR_NOT_SUPPORTED. 
            /// Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not used.
            /// </summary>
            WTSIncomingFrames,
            /// <summary>
            /// This value returns FALSE. If you call GetLastError to get extended error information, GetLastError returns ERROR_NOT_SUPPORTED.
            /// Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not used.
            /// </summary>
            WTSOutgoingFrames,
            /// <summary>
            /// Information about a Remote Desktop Connection (RDC) client. For more information, see WTSCLIENT.
            /// Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not supported. 
            /// This value is supported beginning with Windows Server 2008 and Windows Vista with SP1.
            /// </summary>
            WTSClientInfo,
            /// <summary>
            /// Information about a client session on an RD Session Host server. For more information, see WTSINFO. 
            /// Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not supported.
            /// This value is supported beginning with Windows Server 2008 and Windows Vista with SP1.
            /// </summary>
            WTSSessionInfo,
            /// <summary>
            /// Extended information about a session on an RD Session Host server. For more information, see WTSINFOEX.
            /// Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not supported.
            /// </summary>
            WTSSessionInfoEx,
            /// <summary>
            /// Information about the configuration of an RD Session Host server. 
            /// Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not supported.
            /// </summary>
            WTSConfigInfo,
            /// <summary>
            /// This value is not supported.
            /// </summary>
            WTSValidationInfo,
            /// <summary>
            /// A WTS_SESSION_ADDRESS structure that contains the IPv4 address assigned to the session. If the session does not have a virtual IP address, the WTSQuerySessionInformation function returns ERROR_NOT_SUPPORTED.
            /// Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not supported.
            /// </summary>
            WTSSessionAddressV4,
            /// <summary>
            /// Determines whether the current session is a remote session. The WTSQuerySessionInformation function returns a value of TRUE to indicate that the current session is a remote session, and FALSE to indicate that the current session is a local session. This value can only be used for the local machine, so the hServer parameter of the WTSQuerySessionInformation function must contain WTS_CURRENT_SERVER_HANDLE.
            /// Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, and Windows 2000:  This value is not supported.
            /// </summary>
            WTSIsRemoteSession,
        } ;
        
        public struct WTS_CLIENT_ADDRESS
        {
            public uint AddressFamily;  // AF_INET, AF_IPX, AF_NETBIOS, AF_UNSPEC
            public Byte[] Address;
        };

        public struct WTS_CLIENT_DISPLAY
        {
            public uint HorizontalResolution; // horizontal dimensions, in pixels
            public uint VerticalResolution;   // vertical dimensions, in pixels
            public uint ColorDepth;           // 1=16, 2=256, 4=64K, 8=16M
        };


        // Selected info for terminal server sessions
        public struct TS_SESSION_INFO
        {
            public uint sessionID; 
            public string ipAddress; // The IP address of the client
            public string macAddress; // The MAC address of the client
            public string name; // The (netbios) name of the client
            public string username; // User logged in to the session, if any.
            public WTS_CONNECTSTATE_CLASS state; // The state of the session
            public int HorizontalResolution; // Vertical screen res for the session
            public int VerticalResolution;  // Horiz screen res for the session
            public int ColorDepth; // Screen color depth for the session
        };
        
        
        public static IntPtr OpenServer(String Name)
        {
            IntPtr server = WTSOpenServer(Name);
            return server;
        }
        public static void CloseServer(IntPtr ServerHandle)
        {
            WTSCloseServer(ServerHandle);
        }
        
       
        // Return address for a terminal server session.
        // WTSClientAddress gives a pointer to a WTS_CLIENT_ADDRESS structure containing
        // the network type and network address of the client. If the function is called 
        // from the Terminal Services console, ppBuffer returns a NULL pointer. 
        // Note that the first byte of the IP address returned in the ppBuffer 
        // parameter will be located at an offset of two bytes from the first location
        // of the buffer.
        private static string GetTSClientAddress(uint sessionID, IntPtr server)
        {
            System.IntPtr ppBuffer = System.IntPtr.Zero;
            uint pBytesReturned = 0;
            StringBuilder builder = new StringBuilder();

            // Interface avec API
            WTS_CLIENT_ADDRESS wtsAdr = new WTS_CLIENT_ADDRESS();


            if (WTSQuerySessionInformation(
                server,
                sessionID,
                WTSInfoClass.WTSClientAddress,
                out ppBuffer,
                out pBytesReturned))
            {
                wtsAdr.Address = new Byte[pBytesReturned - 1];
                int run = (int)ppBuffer; // pointeur sur les données
                Type t = typeof(Byte);
                Type t1 = typeof(uint);

                int uintSize = Marshal.SizeOf(t1);
                int byteSize = Marshal.SizeOf(t);

                wtsAdr.AddressFamily = (uint)Marshal.ReadInt32((System.IntPtr)run);

                // Address family can be only:
                // AF_UNSPEC  = 0 (unspecified)
                // AF_INET    = 2 (internetwork: UDP, TCP, etc.)
                // AF_IPX     = AF_NS = 6 (IPX protocols: IPX, SPX, etc.)
                // AF_NETBIOS = 17 (NetBios-style addresses)

                //run+=uintSize;
                //run+=dataSize;                        
                /*switch(wtsAdr.AddressFamily)
                {
                    case 0:builder.Append("AF_UNSPEC");
                        break;
                    case 1:builder.Append("AF_INET");
                        break;
                    case 2:builder.Append("AF_IPX");
                        break;
                    case 3:builder.Append("AF_NETBIOS");
                        break;
                }*/
                for (int i = 0; i < pBytesReturned - 1; i++)
                {
                    wtsAdr.Address[i] = Marshal.ReadByte((System.IntPtr)run);
                    run += byteSize;
                    // TO GET and to SEE ALL the DATA
                    //builder.Append(wtsAdr.Address[i].ToString()+"-");
                }
                //builder.Append("-");

                // The IP address is located in bytes 2, 3, 4, and 5. The other bytes are not used. 
                // If AddressFamily returns AF_UNSPEC, the first byte in Address 
                // is initialized to zero. 

                // Check if the returned address is an IP address
                if (wtsAdr.AddressFamily == 2)
                {   // It is an IP address
                    builder.Append((wtsAdr.Address[4 + 2]).ToString());
                    builder.Append(".");
                    builder.Append((wtsAdr.Address[4 + 3]).ToString());
                    builder.Append(".");
                    builder.Append((wtsAdr.Address[4 + 4]).ToString());
                    builder.Append(".");
                    builder.Append((wtsAdr.Address[4 + 5]).ToString());
                }
            }
            WTSFreeMemory(ppBuffer);
            return builder.ToString();
        }

        // Get display parameters for a user session on a terminal server
        // In: SessionID = identifier for the session
        // In: server = server handle for the server that the session resides on.  
        private static void GetTSClientDisplay(uint sessionID, IntPtr server, out int horizontalResolution, out int verticalResolution, out int colorDepth)
        {
            horizontalResolution = 0;
            verticalResolution = 0;
            colorDepth = 0;

            System.IntPtr ppBuffer = System.IntPtr.Zero;
            uint pBytesReturned = 0;
            StringBuilder sDisplay = new StringBuilder();

            WTS_CLIENT_DISPLAY clientDisplay = new WTS_CLIENT_DISPLAY();
            clientDisplay.HorizontalResolution = 0;
            clientDisplay.VerticalResolution = 0;
            clientDisplay.ColorDepth = 0;

            Type dataType = typeof(WTS_CLIENT_DISPLAY);

            if (WTSQuerySessionInformation(
                server,
                sessionID,
                WTSInfoClass.WTSClientDisplay,
                out ppBuffer,
                out pBytesReturned))
            {
                clientDisplay = (WTS_CLIENT_DISPLAY)Marshal.PtrToStructure(ppBuffer, dataType);
                horizontalResolution = (int)(clientDisplay.HorizontalResolution);
                verticalResolution = (int)(clientDisplay.VerticalResolution);
                colorDepth = (int)(clientDisplay.ColorDepth);
            }

            WTSFreeMemory(ppBuffer);
        }


       // Get Mac from IP, using ARP
        private static string GetMACFromIP(string ipString)
        {

            IPAddress ip = IPAddress.Parse(ipString); // Actual IP
            int rv;
            string macStr;
            byte[] mac = new byte[6];
            int maclen = mac.Length;

            rv = SendARP(BitConverter.ToInt32(ip.GetAddressBytes(), 0), 0, mac, ref maclen);
            if (rv == 0) // If not 0, error
            {
                // macStr = BitConverter.ToString(mac, 0, 6);
                macStr = BitConverter.ToString(mac, 0, 1)+BitConverter.ToString(mac, 1, 1)+BitConverter.ToString(mac, 2, 1)
                    +BitConverter.ToString(mac, 3, 1)+BitConverter.ToString(mac, 4, 1)+BitConverter.ToString(mac, 5, 1);
            }
            else
            {
                macStr = "";
            }
            return macStr;
        }


        private static string GetTSUserName(uint sessionID, IntPtr server)
        {
            System.IntPtr ppBuffer = System.IntPtr.Zero;
            uint pBytesReturned = 0;
            string currentUserName = "";

            if (WTSQuerySessionInformation(
                server,
                sessionID,
                WTSInfoClass.WTSUserName,
                out ppBuffer,
                out pBytesReturned))
            {
                currentUserName = Marshal.PtrToStringAnsi(ppBuffer);
            }

            WTSFreeMemory(ppBuffer);

            return currentUserName;
        }

        public static string GetTSClientName(uint sessionID, IntPtr server)
        {
            System.IntPtr ppBuffer = System.IntPtr.Zero;
            int adrBuffer;
            uint pBytesReturned = 0;
            string clientName = "";

            if (WTSQuerySessionInformation(
                server,
                sessionID,
                WTSInfoClass.WTSClientName,
                out ppBuffer,
                out pBytesReturned))
            {
                adrBuffer = (int)ppBuffer;
                clientName = Marshal.PtrToStringAnsi((System.IntPtr)adrBuffer);
            }

            WTSFreeMemory(ppBuffer);

            return clientName;
        }

        // List all sessions on all registered terminal servers and return in a list with selected data for each session.
        public static List<TS_SESSION_INFO> ListSessions()
        {
            List<TS_SESSION_INFO> ret = new List<TS_SESSION_INFO>();
            if (ATSGlobals.terminalServerConfig == 0) // This server is a terminal server
            {
                ListSessions(ret, "localhost"); // Add sessions from local server
            }
            
            // Add sessions from other terminal servers
            atsDataSet.TerminalServerDataTable datatableTerminalServer;
            datatableTerminalServer = new atsDataSet.TerminalServerDataTable();
            ProSupport.terminalServerTableAdapter.Fill(datatableTerminalServer);
            foreach (DataRow row in datatableTerminalServer.Rows)
            {
                string strError = "";
                try
                {
                    strError = ListSessions(ret, row["Path"].ToString());
                }
                catch
                {
                    //MessageBox.Show("Error: Could not retrieve session data from server '" + row["Path"].ToString() + "'. Error 39092.");
                }
                if (strError.Length != 0)
                {
                    //MessageBox.Show("Warning: " + strError, "AnywhereTS"); 
                }
            }
            return ret;
        }

        // List all sessions on the terminal server and return in a list with selected data for each session.
        public static List<TS_SESSION_INFO> ListSessions(String serverName)
        {
            IntPtr server = IntPtr.Zero;
            List<TS_SESSION_INFO> ret = new List<TS_SESSION_INFO>();
            server = OpenServer(serverName);

            try
            {
                IntPtr ppSessionInfo = IntPtr.Zero;

                Int32 count = 0;
                Int32 retval = WTSEnumerateSessions(server, 0, 1, ref ppSessionInfo, ref count);
                Int32 dataSize = Marshal.SizeOf(typeof(WTS_SESSION_INFO));
                Int32 current = (int)ppSessionInfo;
                TS_SESSION_INFO CurrentClientInfo;

                if (retval != 0)
                {
                    for (int i = 0; i < count; i++) // Iterate through all sessions on the server
                    {   
                        WTS_SESSION_INFO si = (WTS_SESSION_INFO)Marshal.PtrToStructure((System.IntPtr)current, typeof(WTS_SESSION_INFO));
                        current += dataSize;
                        CurrentClientInfo.sessionID = si.SessionID;
                        CurrentClientInfo.ipAddress = GetTSClientAddress(si.SessionID, server);
                        CurrentClientInfo.name = GetTSClientName(si.SessionID, server);
                        CurrentClientInfo.username = GetTSUserName(si.SessionID, server);
                        CurrentClientInfo.state = si.State;
                        if (CurrentClientInfo.name != "")
                        {
                            CurrentClientInfo.macAddress = ProSupport.GetMacAddressFromNameAndDatabase(CurrentClientInfo.name);
                        }
                        else
                        {
                            CurrentClientInfo.macAddress = "";
                        }

                        GetTSClientDisplay(
                            si.SessionID,
                            server,
                            out CurrentClientInfo.HorizontalResolution,
                            out CurrentClientInfo.VerticalResolution,
                            out CurrentClientInfo.ColorDepth);
                        ret.Add(CurrentClientInfo);
                    }

                    WTSFreeMemory(ppSessionInfo);
                }
            }

            finally
            {
                try
                {
                    CloseServer(server);
                }
                catch (Exception e)
                {
                    MessageBox.Show("Error could not close terminal server connection (63210)");
                    using (log4net.NDC.Push(string.Format("SqlException: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
                    {
                        Logging.ATSAdminLog.Error("Error could not close terminal server connection (63210)");
                    }
                }
            }
            return ret;
        }

        // List all sessions on the terminal server and return in a list with selected data for each session.
        public static List<AtsSession> ListTSsessions(String serverName)
        {
            IntPtr server = IntPtr.Zero;
            List<AtsSession> ret = new List<AtsSession>();
            server = OpenServer(serverName);

            try
            {
                IntPtr ppSessionInfo = IntPtr.Zero;

                Int32 count = 0;
                Int32 retval = WTSEnumerateSessions(server, 0, 1, ref ppSessionInfo, ref count);
                Int32 dataSize = Marshal.SizeOf(typeof(WTS_SESSION_INFO));
                Int32 current = (int)ppSessionInfo;
                AtsSession CurrentSession = new AtsSession();

                if (retval != 0)
                {
                    for (int i = 0; i < count; i++) // Iterate through all sessions on the server
                    {
                        WTS_SESSION_INFO si = (WTS_SESSION_INFO)Marshal.PtrToStructure((System.IntPtr)current, typeof(WTS_SESSION_INFO));
                        current += dataSize;
                        CurrentSession.sessionID = si.SessionID;
                        CurrentSession.ipAddress = GetTSClientAddress(si.SessionID, server);
                        CurrentSession.name = GetTSClientName(si.SessionID, server);
                        CurrentSession.username = GetTSUserName(si.SessionID, server);
                        CurrentSession.state = si.State;
                        if (CurrentSession.name != "")
                        {
                            CurrentSession.macAddress = ProSupport.GetMacAddressFromNameAndDatabase(CurrentSession.name);
                        }
                        else
                        {
                            CurrentSession.macAddress = "";
                        }

                        GetTSClientDisplay(
                            si.SessionID,
                            server,
                            out CurrentSession.HorizontalResolution,
                            out CurrentSession.VerticalResolution,
                            out CurrentSession.ColorDepth);
                        ret.Add(CurrentSession);
                    }

                    WTSFreeMemory(ppSessionInfo);
                }
            }

            finally
            {
                try
                {
                    CloseServer(server);
                }
                catch(Exception e)
                {
                    MessageBox.Show("Error could not close terminal server connection (63210)");
                    using (log4net.NDC.Push(string.Format("SqlException: MESSAGE={0}{1}Diagnostics:{1}{2}", e.Message, System.Environment.NewLine, e.ToString())))
                    {
                        Logging.ATSAdminLog.Error("Error could not close terminal server connection (63210)");
                    }
                }
            }
            return ret;
        }


        // List all sessions on the terminal server and adds them to list with selected data for each session.
        // Returns error message or "" if everything went ok.
        public static string ListSessions(List<TS_SESSION_INFO> SessionInfo, String serverName)
        {
            IntPtr server = IntPtr.Zero;
            server = OpenServer(serverName);
            string strError = "Could not retrieve session data from server '" + serverName + "'"; // Assume something went wrong
            if (server != IntPtr.Zero)
            {
                try
                {
                    IntPtr ppSessionInfo = IntPtr.Zero;

                    Int32 count = 0;
                    Int32 retval = WTSEnumerateSessions(server, 0, 1, ref ppSessionInfo, ref count);
                    Int32 dataSize = Marshal.SizeOf(typeof(WTS_SESSION_INFO));
                    Int32 current = (int)ppSessionInfo;
                    TS_SESSION_INFO CurrentClientInfo;

                    if (retval != 0)
                    {
                        for (int i = 0; i < count; i++)
                        {
                            WTS_SESSION_INFO si = (WTS_SESSION_INFO)Marshal.PtrToStructure((System.IntPtr)current, typeof(WTS_SESSION_INFO));
                            current += dataSize;
                            CurrentClientInfo.sessionID = si.SessionID;
                            CurrentClientInfo.ipAddress = GetTSClientAddress(si.SessionID, server);
                            CurrentClientInfo.name = GetTSClientName(si.SessionID, server);
                            CurrentClientInfo.username = GetTSUserName(si.SessionID, server);
                            CurrentClientInfo.state = si.State;
                            if (CurrentClientInfo.name != "")
                            {
                                CurrentClientInfo.macAddress = ProSupport.GetMacAddressFromNameAndDatabase(CurrentClientInfo.name);
                            }
                            else
                            {
                                CurrentClientInfo.macAddress = "";
                            }
                            GetTSClientDisplay(
                                si.SessionID,
                                server,
                                out CurrentClientInfo.HorizontalResolution,
                                out CurrentClientInfo.VerticalResolution,
                                out CurrentClientInfo.ColorDepth);

                            SessionInfo.Add(CurrentClientInfo);
                        }

                        WTSFreeMemory(ppSessionInfo);
                    }
                }

                finally
                {
                    try
                    {
                        CloseServer(server);
                    }
                    finally
                    {
                        // Catch exeception
                    }
                }
                strError = ""; // Everything went ok
            } // end if (server != null)
            return strError;
        }

        // List all sessions on the terminal server and adds them to list with selected data for each session.
        // Returns error message or "" if everything went ok.
        public static string ListSessions(List<AtsSession> SessionInfo, String serverName)
        {
            IntPtr server = IntPtr.Zero;
            server = OpenServer(serverName);
            string strError = "Could not retrieve session data from server '" + serverName + "'"; // Assume something went wrong
            if (server != IntPtr.Zero)
            {
                try
                {
                    IntPtr ppSessionInfo = IntPtr.Zero;

                    Int32 count = 0;
                    Int32 retval = WTSEnumerateSessions(server, 0, 1, ref ppSessionInfo, ref count);
                    Int32 dataSize = Marshal.SizeOf(typeof(WTS_SESSION_INFO));
                    Int32 current = (int)ppSessionInfo;

                    if (retval != 0)
                    {
                        for (int i = 0; i < count; i++)
                        {
                            AtsSession currentSession = new AtsSession();
                            WTS_SESSION_INFO si = (WTS_SESSION_INFO)Marshal.PtrToStructure((System.IntPtr)current, typeof(WTS_SESSION_INFO));
                            current += dataSize;
                            currentSession.TerminalServerName = serverName;
                            currentSession.sessionID = si.SessionID;
                            currentSession.ipAddress = GetTSClientAddress(si.SessionID, server);
                            currentSession.name = GetTSClientName(si.SessionID, server);
                            currentSession.username = GetTSUserName(si.SessionID, server);
                            currentSession.state = si.State;
                            if (currentSession.name != "")
                            {
                                currentSession.macAddress = ProSupport.GetMacAddressFromNameAndDatabase(currentSession.name);
                            }
                            else
                            {
                                currentSession.macAddress = "";
                            }
                            GetTSClientDisplay(
                                si.SessionID,
                                server,
                                out currentSession.HorizontalResolution,
                                out currentSession.VerticalResolution,
                                out currentSession.ColorDepth);

                            SessionInfo.Add(currentSession);
                        }

                        WTSFreeMemory(ppSessionInfo);
                    }
                }
                finally
                {
                    try
                    {
                        CloseServer(server);
                    }
                    finally
                    {
                        // Catch exeception
                    }
                }
                strError = ""; // Everything went ok
            } // end if (server != null)

            return strError;
        }

        // Return matching session for a macAddress, or null, if the mac address is not used in any session.
        // Called when a child node selected in the tree view
        public static AtsSession GetSession(string macAddress)
        {
            foreach (AtsTerminalServer ts in AtsEnvironment.TerminalServers)
            {
                foreach (AtsSession session in ts.Session)
                {
                    // Try to find the MAC adress for the selected client in any of the sessions.
                    if (session.macAddress == macAddress)
                    {
                        return session;
                    }
                }
            }
            // Session not found, return null.
            return null;
        }

        // Convert session state to string
        public static string StateToString(WTS_CONNECTSTATE_CLASS state)
        {
            switch (state)
            {
                case WTS_CONNECTSTATE_CLASS.WTSActive:
                    return "User logged on";
                case WTS_CONNECTSTATE_CLASS.WTSConnected:
                    return "Connected to client";
                case WTS_CONNECTSTATE_CLASS.WTSConnectQuery:
                    return "Connecting to client";
                case WTS_CONNECTSTATE_CLASS.WTSShadow:
                    return "Shadowing";
                case WTS_CONNECTSTATE_CLASS.WTSDisconnected:
                    return "Logged on without client";
                case WTS_CONNECTSTATE_CLASS.WTSIdle:
                    return "Waiting for client to connect";
                case WTS_CONNECTSTATE_CLASS.WTSListen:
                    return "Listening for connection";
                case WTS_CONNECTSTATE_CLASS.WTSReset:
                    return "Being reset";
                case WTS_CONNECTSTATE_CLASS.WTSDown:
                    return "Down due to error";
                case WTS_CONNECTSTATE_CLASS.WTSInit:
                    return "In initialization";
                default:
                    return "Unknown state (error!)";
            }
        }
        public static string GetMyName()
        {
            return GetTSClientName(WTS_CURRENT_SESSION, System.IntPtr.Zero);
        }
        
    } // Class TSManager
} // Namespace TerminalServices