Click here to Skip to main content
14,971,029 members
Please Sign up or sign in to vote.
1.00/5 (1 vote)
See more:
Hello friends, could anyone help me convert this code from C # to C ++?
C#
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Security.AccessControl;
using System.Security.Principal;
namespace FileLockInfo
{

    public class Win32API
    {
        [DllImport("ntdll.dll")]
        public static extern int NtQueryObject(IntPtr ObjectHandle, int
            ObjectInformationClass, IntPtr ObjectInformation, int ObjectInformationLength,
            ref int returnLength);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern uint QueryDosDevice(string lpDeviceName, StringBuilder lpTargetPath, int ucchMax);

        [DllImport("ntdll.dll")]
        public static extern uint NtQuerySystemInformation(int
            SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength,
            ref int returnLength);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        public static extern IntPtr OpenMutex(UInt32 desiredAccess, bool inheritHandle, string name);

        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);

        [DllImport("kernel32.dll")]
        public static extern int CloseHandle(IntPtr hObject);

        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool DuplicateHandle(IntPtr hSourceProcessHandle,
           ushort hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle,
           uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwOptions);

        [DllImport("kernel32.dll")]
        public static extern IntPtr GetCurrentProcess();

        public enum ObjectInformationClass : int
        {
            ObjectBasicInformation = 0,
            ObjectNameInformation = 1,
            ObjectTypeInformation = 2,
            ObjectAllTypesInformation = 3,
            ObjectHandleInformation = 4
        }

        [Flags]
        public enum ProcessAccessFlags : uint
        {
            All = 0x001F0FFF,
            Terminate = 0x00000001,
            CreateThread = 0x00000002,
            VMOperation = 0x00000008,
            VMRead = 0x00000010,
            VMWrite = 0x00000020,
            DupHandle = 0x00000040,
            SetInformation = 0x00000200,
            QueryInformation = 0x00000400,
            Synchronize = 0x00100000
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct OBJECT_BASIC_INFORMATION
        { // Information Class 0
            public int Attributes;
            public int GrantedAccess;
            public int HandleCount;
            public int PointerCount;
            public int PagedPoolUsage;
            public int NonPagedPoolUsage;
            public int Reserved1;
            public int Reserved2;
            public int Reserved3;
            public int NameInformationLength;
            public int TypeInformationLength;
            public int SecurityDescriptorLength;
            public System.Runtime.InteropServices.ComTypes.FILETIME CreateTime;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct OBJECT_TYPE_INFORMATION
        { // Information Class 2
            public UNICODE_STRING Name;
            public int ObjectCount;
            public int HandleCount;
            public int Reserved1;
            public int Reserved2;
            public int Reserved3;
            public int Reserved4;
            public int PeakObjectCount;
            public int PeakHandleCount;
            public int Reserved5;
            public int Reserved6;
            public int Reserved7;
            public int Reserved8;
            public int InvalidAttributes;
            public GENERIC_MAPPING GenericMapping;
            public int ValidAccess;
            public byte Unknown;
            public byte MaintainHandleDatabase;
            public int PoolType;
            public int PagedPoolUsage;
            public int NonPagedPoolUsage;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct OBJECT_NAME_INFORMATION
        { // Information Class 1
            public UNICODE_STRING Name;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public struct UNICODE_STRING
        {
            public ushort Length;
            public ushort MaximumLength;
            public IntPtr Buffer;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct GENERIC_MAPPING
        {
            public int GenericRead;
            public int GenericWrite;
            public int GenericExecute;
            public int GenericAll;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public struct SYSTEM_HANDLE_INFORMATION
        { // Information Class 16
            public int ProcessID;
            public byte ObjectTypeNumber;
            public byte Flags; // 0x01 = PROTECT_FROM_CLOSE, 0x02 = INHERIT
            public ushort Handle;
            public int Object_Pointer;
            public UInt32 GrantedAccess;
        }

        public const int MAX_PATH = 260;
        public const uint STATUS_INFO_LENGTH_MISMATCH = 0xC0000004;
        public const int DUPLICATE_SAME_ACCESS = 0x2;
        public const int DUPLICATE_CLOSE_SOURCE = 0x1;
    }

    public class Win32Processes
    {
        const int CNST_SYSTEM_HANDLE_INFORMATION = 16;
        const uint STATUS_INFO_LENGTH_MISMATCH = 0xc0000004;

        public static string getObjectTypeName(Win32API.SYSTEM_HANDLE_INFORMATION shHandle, Process process)
        {
            IntPtr m_ipProcessHwnd = Win32API.OpenProcess(Win32API.ProcessAccessFlags.All, false, process.Id);
            IntPtr ipHandle = IntPtr.Zero;
            var objBasic = new Win32API.OBJECT_BASIC_INFORMATION();
            IntPtr ipBasic = IntPtr.Zero;
            var objObjectType = new Win32API.OBJECT_TYPE_INFORMATION();
            IntPtr ipObjectType = IntPtr.Zero;
            IntPtr ipObjectName = IntPtr.Zero;
            string strObjectTypeName = "";
            int nLength = 0;
            int nReturn = 0;
            IntPtr ipTemp = IntPtr.Zero;

            if (!Win32API.DuplicateHandle(m_ipProcessHwnd, shHandle.Handle,
                                          Win32API.GetCurrentProcess(), out ipHandle,
                                          0, false, Win32API.DUPLICATE_SAME_ACCESS))
                return null;

            ipBasic = Marshal.AllocHGlobal(Marshal.SizeOf(objBasic));
            Win32API.NtQueryObject(ipHandle, (int)Win32API.ObjectInformationClass.ObjectBasicInformation,
                                   ipBasic, Marshal.SizeOf(objBasic), ref nLength);
            objBasic = (Win32API.OBJECT_BASIC_INFORMATION)Marshal.PtrToStructure(ipBasic, objBasic.GetType());
            Marshal.FreeHGlobal(ipBasic);

            ipObjectType = Marshal.AllocHGlobal(objBasic.TypeInformationLength);
            nLength = objBasic.TypeInformationLength;
            while ((uint)(nReturn = Win32API.NtQueryObject(
                ipHandle, (int)Win32API.ObjectInformationClass.ObjectTypeInformation, ipObjectType,
                  nLength, ref nLength)) ==
                Win32API.STATUS_INFO_LENGTH_MISMATCH)
            {
                Marshal.FreeHGlobal(ipObjectType);
                ipObjectType = Marshal.AllocHGlobal(nLength);
            }

            objObjectType = (Win32API.OBJECT_TYPE_INFORMATION)Marshal.PtrToStructure(ipObjectType, objObjectType.GetType());
            if (Is64Bits())
            {
                ipTemp = new IntPtr(Convert.ToInt64(objObjectType.Name.Buffer.ToString(), 10) >> 32);
            }
            else
            {
                ipTemp = objObjectType.Name.Buffer;
            }

            strObjectTypeName = Marshal.PtrToStringUni(ipTemp, objObjectType.Name.Length >> 1);
            Marshal.FreeHGlobal(ipObjectType);
            return strObjectTypeName;
        }


        public static string getObjectName(Win32API.SYSTEM_HANDLE_INFORMATION shHandle, Process process)
        {
            IntPtr m_ipProcessHwnd = Win32API.OpenProcess(Win32API.ProcessAccessFlags.All, false, process.Id);
            IntPtr ipHandle = IntPtr.Zero;
            var objBasic = new Win32API.OBJECT_BASIC_INFORMATION();
            IntPtr ipBasic = IntPtr.Zero;
            IntPtr ipObjectType = IntPtr.Zero;
            var objObjectName = new Win32API.OBJECT_NAME_INFORMATION();
            IntPtr ipObjectName = IntPtr.Zero;
            string strObjectName = "";
            int nLength = 0;
            int nReturn = 0;
            IntPtr ipTemp = IntPtr.Zero;

            if (!Win32API.DuplicateHandle(m_ipProcessHwnd, shHandle.Handle, Win32API.GetCurrentProcess(),
                                          out ipHandle, 0, false, Win32API.DUPLICATE_SAME_ACCESS))
                return null;

            ipBasic = Marshal.AllocHGlobal(Marshal.SizeOf(objBasic));
            Win32API.NtQueryObject(ipHandle, (int)Win32API.ObjectInformationClass.ObjectBasicInformation,
                                   ipBasic, Marshal.SizeOf(objBasic), ref nLength);
            objBasic = (Win32API.OBJECT_BASIC_INFORMATION)Marshal.PtrToStructure(ipBasic, objBasic.GetType());
            Marshal.FreeHGlobal(ipBasic);


            nLength = objBasic.NameInformationLength;

            ipObjectName = Marshal.AllocHGlobal(nLength);
            while ((uint)(nReturn = Win32API.NtQueryObject(
                     ipHandle, (int)Win32API.ObjectInformationClass.ObjectNameInformation,
                     ipObjectName, nLength, ref nLength))
                   == Win32API.STATUS_INFO_LENGTH_MISMATCH)
            {
                Marshal.FreeHGlobal(ipObjectName);
                ipObjectName = Marshal.AllocHGlobal(nLength);
            }
            objObjectName = (Win32API.OBJECT_NAME_INFORMATION)Marshal.PtrToStructure(ipObjectName, objObjectName.GetType());

            if (Is64Bits())
            {
                ipTemp = new IntPtr(Convert.ToInt64(objObjectName.Name.Buffer.ToString(), 10) >> 32);
            }
            else
            {
                ipTemp = objObjectName.Name.Buffer;
            }

            if (ipTemp != IntPtr.Zero)
            {

                byte[] baTemp2 = new byte[nLength];
                try
                {
                    Marshal.Copy(ipTemp, baTemp2, 0, nLength);

                    strObjectName = Marshal.PtrToStringUni(Is64Bits() ?
                                                           new IntPtr(ipTemp.ToInt64()) :
                                                           new IntPtr(ipTemp.ToInt32()));
                    return strObjectName;
                }
                catch (AccessViolationException)
                {
                    return null;
                }
                finally
                {
                    Marshal.FreeHGlobal(ipObjectName);
                    Win32API.CloseHandle(ipHandle);
                }
            }
            return null;
        }

        public static List<Win32API.SYSTEM_HANDLE_INFORMATION>
        GetHandles(Process process = null, string IN_strObjectTypeName = null, string IN_strObjectName = null)
        {
            uint nStatus;
            int nHandleInfoSize = 0x10000;
            IntPtr ipHandlePointer = Marshal.AllocHGlobal(nHandleInfoSize);
            int nLength = 0;
            IntPtr ipHandle = IntPtr.Zero;

            while ((nStatus = Win32API.NtQuerySystemInformation(CNST_SYSTEM_HANDLE_INFORMATION, ipHandlePointer,
                                                                nHandleInfoSize, ref nLength)) ==
                    STATUS_INFO_LENGTH_MISMATCH)
            {
                nHandleInfoSize = nLength;
                Marshal.FreeHGlobal(ipHandlePointer);
                ipHandlePointer = Marshal.AllocHGlobal(nLength);
            }

            byte[] baTemp = new byte[nLength];
            Marshal.Copy(ipHandlePointer, baTemp, 0, nLength);

            long lHandleCount = 0;
            if (Is64Bits())
            {
                lHandleCount = Marshal.ReadInt64(ipHandlePointer);
                ipHandle = new IntPtr(ipHandlePointer.ToInt64() + 8);
            }
            else
            {
                lHandleCount = Marshal.ReadInt32(ipHandlePointer);
                ipHandle = new IntPtr(ipHandlePointer.ToInt32() + 4);
            }

            Win32API.SYSTEM_HANDLE_INFORMATION shHandle;
            List<Win32API.SYSTEM_HANDLE_INFORMATION> lstHandles = new List<Win32API.SYSTEM_HANDLE_INFORMATION>();

            for (long lIndex = 0; lIndex < lHandleCount; lIndex++)
            {
                shHandle = new Win32API.SYSTEM_HANDLE_INFORMATION();
                if (Is64Bits())
                {
                    shHandle = (Win32API.SYSTEM_HANDLE_INFORMATION)Marshal.PtrToStructure(ipHandle, shHandle.GetType());
                    ipHandle = new IntPtr(ipHandle.ToInt64() + Marshal.SizeOf(shHandle) + 8);
                }
                else
                {
                    ipHandle = new IntPtr(ipHandle.ToInt64() + Marshal.SizeOf(shHandle));
                    shHandle = (Win32API.SYSTEM_HANDLE_INFORMATION)Marshal.PtrToStructure(ipHandle, shHandle.GetType());
                }

                if (process != null)
                {
                    if (shHandle.ProcessID != process.Id) continue;
                }

                string strObjectTypeName = "";
                if (IN_strObjectTypeName != null){
                     strObjectTypeName = getObjectTypeName(shHandle, Process.GetProcessById(shHandle.ProcessID));
                    if (strObjectTypeName != IN_strObjectTypeName) continue;
                }

                string strObjectName = "";
                if (IN_strObjectName != null){
                     strObjectName = getObjectName(shHandle, Process.GetProcessById(shHandle.ProcessID));
                    if (strObjectName != IN_strObjectName) continue;
                }

                string strObjectTypeName2 = getObjectTypeName(shHandle, Process.GetProcessById(shHandle.ProcessID));
                string strObjectName2 = getObjectName(shHandle, Process.GetProcessById(shHandle.ProcessID));
                Console.WriteLine("{0}   {1}   {2}", shHandle.ProcessID, strObjectTypeName2, strObjectName2);

                lstHandles.Add(shHandle);
            }
            return lstHandles;
        }

        public static bool Is64Bits()
        {
            return Marshal.SizeOf(typeof(IntPtr)) == 8 ? true : false;
        }
    }

    class Program
    {
        static void Main(string[] args)		
        {
		
		try
		{
				WindowsIdentity  identity  = WindowsIdentity.GetCurrent();
				WindowsPrincipal principal = new WindowsPrincipal(identity);
				if (!principal.IsInRole(WindowsBuiltInRole.Administrator))
				{
					Console.WriteLine("===========================================================");
					Console.WriteLine("                                                           ");
					Console.WriteLine("Please Run A3-Unlocker.exe as a \"Run As Administrator\" ");					
					Console.WriteLine("                                                           ");
					Console.WriteLine("===========================================================");
					Console.WriteLine("Press Enter to Exit");
				}
		    else {
            String MutexName = "OnceMutexA3Client";
            String ProcessName = "A3Client";
			bool Violated = false;
			Console.WriteLine("===========================================================");
			Console.WriteLine("                                                           ");			
			Console.WriteLine("Welcome To A3 Unlocker, Lets Kill Some Mutex");
			Console.WriteLine("                                                           ");
			Console.WriteLine("===========================================================");
			Console.WriteLine("                                                           ");
			try {
			Process [] processes = Process.GetProcessesByName(ProcessName);
				if (processes.Length == 0) { 
					Console.WriteLine("NO A3 Client Running");
					Console.WriteLine("                                                           ");
					Console.WriteLine(" Please Run A3 Client First!!!");
					Violated = false;
				}
				 else  {
							Console.WriteLine("{0} A3 Instance", processes.Length);
							foreach (var process in processes ) {
								try
									{                
										var handles = Win32Processes.GetHandles(process, "Mutant", "\\Sessions\\1\\BaseNamedObjects\\" + MutexName);
										if (handles.Count == 0) throw new System.ArgumentException("NoMutex", "original");
										foreach (var handle in handles) {
											IntPtr ipHandle = IntPtr.Zero;
											if (!Win32API.DuplicateHandle(Process.GetProcessById(handle.ProcessID).Handle, handle.Handle, Win32API.GetCurrentProcess(), out ipHandle, 0, false, Win32API.DUPLICATE_CLOSE_SOURCE))
											Console.WriteLine("DuplicateHandle() failed, error = {0}", Marshal.GetLastWin32Error());
											Console.WriteLine("Mutex was killed");
											Violated = true;
											}
									}
            
								catch (ArgumentException)
									{
										Console.WriteLine("The Mutex '{0}' was not found in the process '{1}'", MutexName, ProcessName);
										Violated = true;
									}            
							} 
						}			
				}
			catch (IndexOutOfRangeException)
            {
                Console.WriteLine("NO A3 Client Running");
				Console.WriteLine("                                                           ");
				Console.WriteLine(" Please Run A3 Client First!!!");
				Violated = false;
								
            }
			if (Violated) {
			Console.WriteLine("                                                           ");
			Console.WriteLine("We are done!!! Enjoy");
			Console.WriteLine("                                                           ");
			Console.WriteLine("Must close this EXE before running another A3 Instance. Press Enter to exit");			
			}
		}
		}
		 catch (Exception ex)
		{
			if (ex != null) {}
		}
			Console.ReadLine();
        }
    }
}


What I have tried:

I already tried a conversion by APP but it returns me error
C++
#include <string>
#include <vector>
#include <iostream>
#include <stdexcept>

namespace FileLockInfo
    {

    class Win32API
        {
    public:
        enum class ObjectInformationClass : int
            {
            ObjectBasicInformation = 0,
            ObjectNameInformation = 1,
            ObjectTypeInformation = 2,
            ObjectAllTypesInformation = 3,
            ObjectHandleInformation = 4
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [Flags] public enum ProcessAccessFlags : uint
        enum class ProcessAccessFlags : int
            {
            All = 0x001F0FFF,
            Terminate = 0x00000001,
            CreateThread = 0x00000002,
            VMOperation = 0x00000008,
            VMRead = 0x00000010,
            VMWrite = 0x00000020,
            DupHandle = 0x00000040,
            SetInformation = 0x00000200,
            QueryInformation = 0x00000400,
            Synchronize = 0x00100000
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential)] public struct OBJECT_BASIC_INFORMATION
        class OBJECT_BASIC_INFORMATION
            { // Information Class 0
        public:
            int Attributes = 0;
            int GrantedAccess = 0;
            int HandleCount = 0;
            int PointerCount = 0;
            int PagedPoolUsage = 0;
            int NonPagedPoolUsage = 0;
            int Reserved1 = 0;
            int Reserved2 = 0;
            int Reserved3 = 0;
            int NameInformationLength = 0;
            int TypeInformationLength = 0;
            int SecurityDescriptorLength = 0;
            System::Runtime::InteropServices::ComTypes::FILETIME CreateTime;
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential)] public struct OBJECT_TYPE_INFORMATION
        class OBJECT_TYPE_INFORMATION
            { // Information Class 2
        public:
            UNICODE_STRING Name;
            int ObjectCount = 0;
            int HandleCount = 0;
            int Reserved1 = 0;
            int Reserved2 = 0;
            int Reserved3 = 0;
            int Reserved4 = 0;
            int PeakObjectCount = 0;
            int PeakHandleCount = 0;
            int Reserved5 = 0;
            int Reserved6 = 0;
            int Reserved7 = 0;
            int Reserved8 = 0;
            int InvalidAttributes = 0;
            GENERIC_MAPPING GenericMapping;
            int ValidAccess = 0;
            unsigned char Unknown = 0;
            unsigned char MaintainHandleDatabase = 0;
            int PoolType = 0;
            int PagedPoolUsage = 0;
            int NonPagedPoolUsage = 0;
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential)] public struct OBJECT_NAME_INFORMATION
        class OBJECT_NAME_INFORMATION
            { // Information Class 1
        public:
            UNICODE_STRING Name;
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential, Pack = 1)] public struct UNICODE_STRING
        class UNICODE_STRING
            {
        public:
            unsigned short Length = 0;
            unsigned short MaximumLength = 0;
            void* Buffer;
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential)] public struct GENERIC_MAPPING
        class GENERIC_MAPPING
            {
        public:
            int GenericRead = 0;
            int GenericWrite = 0;
            int GenericExecute = 0;
            int GenericAll = 0;
            };

    public:
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [StructLayout(LayoutKind.Sequential, Pack = 1)] public struct SYSTEM_HANDLE_INFORMATION
        class SYSTEM_HANDLE_INFORMATION
            { // Information Class 16
        public:
            int ProcessID = 0;
            unsigned char ObjectTypeNumber = 0;
            unsigned char Flags = 0; // 0x01 = PROTECT_FROM_CLOSE, 0x02 = INHERIT
            unsigned short Handle = 0;
            int Object_Pointer = 0;
            unsigned int GrantedAccess = 0;
            };

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("ntdll.dll")]
    public:
        __declspec( dllimport ) static int NtQueryObject( IntPtr ObjectHandle, int ObjectInformationClass, IntPtr ObjectInformation, int ObjectInformationLength, int& returnLength );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll", SetLastError = true)]
        __declspec( dllimport ) static unsigned int QueryDosDevice( const std::wstring& lpDeviceName, StringBuilder* lpTargetPath, int ucchMax );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("ntdll.dll")]
        __declspec( dllimport ) static unsigned int NtQuerySystemInformation( int SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength, int& returnLength );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll", CharSet = CharSet::Auto, SetLastError = true)]
        __declspec( dllimport ) static IntPtr OpenMutex( unsigned int desiredAccess, bool inheritHandle, const std::wstring& name );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll")]
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [DllImport("kernel32.dll")] public static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);
        __declspec( dllimport ) static IntPtr OpenProcess( ProcessAccessFlags dwDesiredAccess, bool bInheritHandle, int dwProcessId );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll")]
        __declspec( dllimport ) static int CloseHandle( IntPtr hObject );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll", SetLastError = true), return: MarshalAs(UnmanagedType::Bool)]
//C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
//ORIGINAL LINE: [DllImport("kernel32.dll", SetLastError = true)][return: MarshalAs(UnmanagedType.Bool)] public static extern bool DuplicateHandle(IntPtr hSourceProcessHandle, ushort hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle, uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwOptions);
        __declspec( dllimport ) static bool DuplicateHandle( IntPtr hSourceProcessHandle, unsigned short hSourceHandle, IntPtr hTargetProcessHandle, IntPtr& lpTargetHandle, unsigned int dwDesiredAccess, bool bInheritHandle, unsigned int dwOptions );

//C# TO C++ CONVERTER NOTE: The following .NET DllImport attribute was converted using the Microsoft-specific __declspec(dllimport):
//[DllImport("kernel32.dll")]
        __declspec( dllimport ) static IntPtr GetCurrentProcess();

        static constexpr int MAX_PATH = 260;
        static constexpr unsigned int STATUS_INFO_LENGTH_MISMATCH = 0xC0000004;
        static constexpr int DUPLICATE_SAME_ACCESS = 0x2;
        static constexpr int DUPLICATE_CLOSE_SOURCE = 0x1;
        };

    class Win32Processes
        {
    private:
        static constexpr int CNST_SYSTEM_HANDLE_INFORMATION = 16;
        static constexpr unsigned int STATUS_INFO_LENGTH_MISMATCH = 0xc0000004;

    public:
        static std::wstring getObjectTypeName( Win32API::SYSTEM_HANDLE_INFORMATION shHandle, Process* process )
            {
            void* m_ipProcessHwnd = Win32API::OpenProcess( Win32API::ProcessAccessFlags::All, false, process->Id );
            void* ipHandle = void*::Zero;
            auto objBasic = Win32API::OBJECT_BASIC_INFORMATION();
            void* ipBasic = void*::Zero;
            auto objObjectType = Win32API::OBJECT_TYPE_INFORMATION();
            void* ipObjectType = void*::Zero;
            void* ipObjectName = void*::Zero;
            std::wstring strObjectTypeName = L"";
            int nLength = 0;
            int nReturn = 0;
            void* ipTemp = void*::Zero;

            if ( ! Win32API::DuplicateHandle( m_ipProcessHwnd, shHandle.Handle, Win32API::GetCurrentProcess(), ipHandle, 0, false, Win32API::DUPLICATE_SAME_ACCESS ) )
                {
                return L"";
                }

            ipBasic = Marshal::AllocHGlobal( System::Runtime::InteropServices::Marshal::SizeOf( objBasic ) );
            Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectBasicInformation ), ipBasic, System::Runtime::InteropServices::Marshal::SizeOf( objBasic ), nLength );
            objBasic = static_cast<Win32API::OBJECT_BASIC_INFORMATION>( Marshal::PtrToStructure( ipBasic, objBasic->GetType() ) );
            Marshal::FreeHGlobal( ipBasic );

            ipObjectType = Marshal::AllocHGlobal( objBasic->TypeInformationLength );
            nLength = objBasic->TypeInformationLength;
            while ( static_cast<unsigned int>( nReturn = Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectTypeInformation ), ipObjectType, nLength, nLength ) ) == Win32API::STATUS_INFO_LENGTH_MISMATCH )
                {
                Marshal::FreeHGlobal( ipObjectType );
                ipObjectType = Marshal::AllocHGlobal( nLength );
                }

            objObjectType = static_cast<Win32API::OBJECT_TYPE_INFORMATION>( Marshal::PtrToStructure( ipObjectType, objObjectType->GetType() ) );
            if ( Is64Bits() )
                {
//C# TO C++ CONVERTER TODO TASK: There is no native C++ equivalent to 'ToString':
                ipTemp = new void*( Convert::ToInt64( objObjectType->Name->Buffer->ToString(), 10 ) >> 32 );
                } else
                    {
                ipTemp = objObjectType->Name->Buffer;
            }

            strObjectTypeName = Marshal::PtrToStringUni( ipTemp, objObjectType->Name->Length >> 1 );
            Marshal::FreeHGlobal( ipObjectType );
            return strObjectTypeName;
            }


        static std::wstring getObjectName( Win32API::SYSTEM_HANDLE_INFORMATION shHandle, Process* process )
            {
            void* m_ipProcessHwnd = Win32API::OpenProcess( Win32API::ProcessAccessFlags::All, false, process->Id );
            void* ipHandle = void*::Zero;
            auto objBasic = Win32API::OBJECT_BASIC_INFORMATION();
            void* ipBasic = void*::Zero;
            void* ipObjectType = void*::Zero;
            auto objObjectName = Win32API::OBJECT_NAME_INFORMATION();
            void* ipObjectName = void*::Zero;
            std::wstring strObjectName = L"";
            int nLength = 0;
            int nReturn = 0;
            void* ipTemp = void*::Zero;

            if ( ! Win32API::DuplicateHandle( m_ipProcessHwnd, shHandle.Handle, Win32API::GetCurrentProcess(), ipHandle, 0, false, Win32API::DUPLICATE_SAME_ACCESS ) )
                {
                return L"";
                }

            ipBasic = Marshal::AllocHGlobal( System::Runtime::InteropServices::Marshal::SizeOf( objBasic ) );
            Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectBasicInformation ), ipBasic, System::Runtime::InteropServices::Marshal::SizeOf( objBasic ), nLength );
            objBasic = static_cast<Win32API::OBJECT_BASIC_INFORMATION>( Marshal::PtrToStructure( ipBasic, objBasic->GetType() ) );
            Marshal::FreeHGlobal( ipBasic );


            nLength = objBasic->NameInformationLength;

            ipObjectName = Marshal::AllocHGlobal( nLength );
            while ( static_cast<unsigned int>( nReturn = Win32API::NtQueryObject( ipHandle, static_cast<int>( Win32API::ObjectInformationClass::ObjectNameInformation ), ipObjectName, nLength, nLength ) ) == Win32API::STATUS_INFO_LENGTH_MISMATCH )
                {
                Marshal::FreeHGlobal( ipObjectName );
                ipObjectName = Marshal::AllocHGlobal( nLength );
                }
            objObjectName = static_cast<Win32API::OBJECT_NAME_INFORMATION>( Marshal::PtrToStructure( ipObjectName, objObjectName->GetType() ) );

            if ( Is64Bits() )
                {
//C# TO C++ CONVERTER TODO TASK: There is no native C++ equivalent to 'ToString':
                ipTemp = new void*( Convert::ToInt64( objObjectName->Name->Buffer->ToString(), 10 ) >> 32 );
                } else
                    {
                ipTemp = objObjectName->Name->Buffer;
            }

            if ( ipTemp != void*::Zero )
                {

                unsigned char baTemp2[ nLength ];
                try
                    {
                    Marshal::Copy( ipTemp, baTemp2, 0, nLength );

                    strObjectName = Marshal::PtrToStringUni( Is64Bits() ? new void*(ipTemp.ToInt64()) : new void*(ipTemp.ToInt32()) );
                    return strObjectName;
                    } catch ( AccessViolationException e1 )
                        {
                    return L"";
                } finally
                    {
                    Marshal::FreeHGlobal( ipObjectName );
                    Win32API::CloseHandle( ipHandle );
                }
                }
            return L"";
            }

        static std::vector<Win32API::SYSTEM_HANDLE_INFORMATION> GetHandles( Process* process = nullptr, const std::wstring& IN_strObjectTypeName = L"", const std::wstring& IN_strObjectName = L"" )
            {
            unsigned int nStatus;
            int nHandleInfoSize = 0x10000;
            void* ipHandlePointer = Marshal::AllocHGlobal( nHandleInfoSize );
            int nLength = 0;
            void* ipHandle = void*::Zero;

            while ( ( nStatus = Win32API::NtQuerySystemInformation( CNST_SYSTEM_HANDLE_INFORMATION, ipHandlePointer, nHandleInfoSize, nLength ) ) == STATUS_INFO_LENGTH_MISMATCH )
                {
                nHandleInfoSize = nLength;
                Marshal::FreeHGlobal( ipHandlePointer );
                ipHandlePointer = Marshal::AllocHGlobal( nLength );
                }

            unsigned char baTemp[ nLength ];
            Marshal::Copy( ipHandlePointer, baTemp, 0, nLength );

            long long lHandleCount = 0;
            if ( Is64Bits() )
                {
                lHandleCount = Marshal::ReadInt64( ipHandlePointer );
                ipHandle = new void*( ipHandlePointer.ToInt64() + 8 );
                } else
                    {
                lHandleCount = Marshal::ReadInt32( ipHandlePointer );
                ipHandle = new void*( ipHandlePointer.ToInt32() + 4 );
            }

            Win32API::SYSTEM_HANDLE_INFORMATION shHandle;
            std::vector<Win32API::SYSTEM_HANDLE_INFORMATION> lstHandles = std::vector<Win32API::SYSTEM_HANDLE_INFORMATION>();

            for ( long long lIndex = 0; lIndex < lHandleCount; lIndex ++ )
                {
                shHandle = Win32API::SYSTEM_HANDLE_INFORMATION();
                if ( Is64Bits() )
                    {
                    shHandle = static_cast<Win32API::SYSTEM_HANDLE_INFORMATION>( Marshal::PtrToStructure( ipHandle, shHandle.GetType() ) );
                    ipHandle = new void*( ipHandle.ToInt64() + System::Runtime::InteropServices::Marshal::SizeOf(shHandle) + 8 );
                    } else
                        {
                    ipHandle = new void*( ipHandle.ToInt64() + System::Runtime::InteropServices::Marshal::SizeOf(shHandle) );
                    shHandle = static_cast<Win32API::SYSTEM_HANDLE_INFORMATION>( Marshal::PtrToStructure( ipHandle, shHandle.GetType() ) );
                }

                if ( process != nullptr )
                    {
                    if ( shHandle.ProcessID != process->Id )
                        {
                        continue;
                        }
                    }

                std::wstring strObjectTypeName = L"";
                if ( IN_strObjectTypeName != L"" )
                    {
                     strObjectTypeName = getObjectTypeName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
                    if ( strObjectTypeName != IN_strObjectTypeName )
                        {
                        continue;
                        }
                    }

                std::wstring strObjectName = L"";
                if ( IN_strObjectName != L"" )
                    {
                     strObjectName = getObjectName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
                    if ( strObjectName != IN_strObjectName )
                        {
                        continue;
                        }
                    }

                std::wstring strObjectTypeName2 = getObjectTypeName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
                std::wstring strObjectName2 = getObjectName( shHandle, Process::GetProcessById( shHandle.ProcessID ) );
                std::cout << shHandle.ProcessID << std::wstring( L"   " ) << strObjectTypeName2 << std::wstring( L"   " ) << strObjectName2 << std::endl;

                lstHandles.push_back( shHandle );
                }
            return lstHandles;
            }

        static bool Is64Bits()
            {
            return System::Runtime::InteropServices::Marshal::SizeOf( void*::typeid ) == 8 ? true : false;
            }
        };

    class Program
        {
        static void Main( std::wstring& args[] )
            {

        try
            {
                WindowsIdentity* identity = WindowsIdentity::GetCurrent();
                WindowsPrincipal* principal = new WindowsPrincipal( identity );
                if ( ! principal->IsInRole( WindowsBuiltInRole::Administrator ) )
                    {
                    std::cout << std::wstring( L"===========================================================" ) << std::endl;
                    std::cout << std::wstring( L"                                                           " ) << std::endl;
                    std::cout << std::wstring( L"Please Run A3-Unlocker.exe as a \"Run As Administrator\" " ) << std::endl;
                    std::cout << std::wstring( L"                                                           " ) << std::endl;
                    std::cout << std::wstring( L"===========================================================" ) << std::endl;
                    std::cout << std::wstring( L"Press Enter to Exit" ) << std::endl;
                    } else
                        {
            std::wstring MutexName = L"OnceMutexA3Client";
            std::wstring ProcessName = L"A3Client";
            bool Violated = false;
            std::cout << std::wstring( L"===========================================================" ) << std::endl;
            std::cout << std::wstring( L"                                                           " ) << std::endl;
            std::cout << std::wstring( L"Welcome To A3 Unlocker, Lets Kill Some Mutex" ) << std::endl;
            std::cout << std::wstring( L"                                                           " ) << std::endl;
            std::cout << std::wstring( L"===========================================================" ) << std::endl;
            std::cout << std::wstring( L"                                                           " ) << std::endl;
            try
                {
//C# TO C++ CONVERTER WARNING: Since the array size is not known in this declaration, C# to C++ Converter has converted this array to a pointer.  You will need to call 'delete[]' where appropriate:
//ORIGINAL LINE: Process [] processes = Process.GetProcessesByName(ProcessName);
            Process* processes = Process::GetProcessesByName( ProcessName );
                if ( processes->Length == 0 )
                    {
                    std::cout << std::wstring( L"NO A3 Client Running" ) << std::endl;
                    std::cout << std::wstring( L"                                                           " ) << std::endl;
                    std::cout << std::wstring( L" Please Run A3 Client First!!!" ) << std::endl;
                    Violated = false;
                    } else
                        {
                            std::cout << processes->Length << std::endl;
                            for ( auto process : processes )
                                {
                                try
                                    {
                                        auto handles = Win32Processes::GetHandles( process, L"Mutant", std::wstring( L"\\Sessions\\1\\BaseNamedObjects\\" ) + MutexName );
                                        if ( handles->Count == 0 )
                                            {
                                            throw System::ArgumentException( L"NoMutex", L"original" );
                                            }
                                        for ( auto handle : handles )
                                            {
                                            void* ipHandle = void*::Zero;
                                            if ( ! Win32API::DuplicateHandle( Process::GetProcessById( handle->ProcessID )->Handle, handle->Handle, Win32API::GetCurrentProcess(), ipHandle, 0, false, Win32API::DUPLICATE_CLOSE_SOURCE ) )
                                                {
                                            std::cout << std::wstring( L"DuplicateHandle() failed, error = " ) << Marshal::GetLastWin32Error() << std::endl;
                                                }
                                            std::cout << std::wstring( L"Mutex was killed" ) << std::endl;
                                            Violated = true;
                                            }
                                    }

                                catch ( ArgumentException e1 )
                                    {
                                        std::cout << std::wstring( L"The Mutex '" ) << MutexName << std::wstring( L"' was not found in the process '" ) << ProcessName << std::endl;
                                        Violated = true;
                                    }
                                }
                        }
                } catch ( IndexOutOfRangeException e2 )
                    {
                std::cout << std::wstring( L"NO A3 Client Running" ) << std::endl;
                std::cout << std::wstring( L"                                                           " ) << std::endl;
                std::cout << std::wstring( L" Please Run A3 Client First!!!" ) << std::endl;
                Violated = false;

            }
            if ( Violated )
                {
            std::cout << std::wstring( L"                                                           " ) << std::endl;
            std::cout << std::wstring( L"We are done!!! Enjoy" ) << std::endl;
            std::cout << std::wstring( L"                                                           " ) << std::endl;
            std::cout << std::wstring( L"Must close this EXE before running another A3 Instance. Press Enter to exit" ) << std::endl;
                }
        }
            } catch ( std::exception& ex )
                {
            if ( ex != nullptr )
                {
                }
        }
            Console::ReadLine();
            }
        };
    }
Posted
Updated 28-May-21 14:33pm
v3
Comments
Patrice T 26-Aug-19 20:07pm
   
What error ?
Member 14569235 27-Aug-19 8:37am
   
There was no mistake friend, I need to kill a mutex. the code is written in c # i need the code in c ++
Patrice T 27-Aug-19 9:16am
   
Use Improve question to update your question.
So that everyone can pay attention to this information.
Dave Kreskowiak 27-Aug-19 0:02am
   
We're not here to do your work for you. You're going to have to describe the problem you're having.
Stefan_Lang 29-Aug-19 4:02am
   
As pointed out, there are many problems converting a program from one to another, especially one using .NET to one that doesn't.

Maybe if you told us WHY you think you need to use C++ instead of C#, someone could think of an alternative approach in C#?

Read this article about Dynamic DLL Loading to learn about the different approach in C/c++.

Marshalling is a special topic in C# for memory access which you can do in C++ directly. Use new and delete for best results. You need to free all allocated memory yourself.
   
Comments
Maciej Los 27-Aug-19 6:57am
   
5ed!
You are trying to convert from C# back to C++ functions, which are defined in Microsoft h-files. For example:
NtQueryObject function (winternl.h) | Microsoft Docs[^]
NtQuerySystemInformation function (winternl.h) | Microsoft Docs[^]

Use these functions directly from Microsoft h-files.
   
Comments
KarstenK 27-Aug-19 3:35am
   
You are absolutly right. Excellent!
Maciej Los 27-Aug-19 6:57am
   
5ed!
It is almost impossible to convert/translate C# to C++ directly due to several reasons, i.e.:
- C# is based on .NET framework libraries
- C++ (without extensions) does not support .Net framework

You may want to find on-line compilers, but lots of them is able to convert basic code only. I've heard that this one is very interesting alternative: AlterNative - .NET to C++ translator[^]
   
Obviously, this is a simple console program. A lot is much easier and more direct in C ++.
To call Windows system calls, <windows.h> is required.
C++
#include <windows.h>

Main functions converted from C# Code would convert to very simple C++
You should convert beginning with the main function. Here are samples to begin.
This seems to convert to
C#
<pre>class Program {
		static void Main(std::wstring& args[]) {
			try {

C++
void main(int argc, char* args[] ) {

To check elevation write a function
C++
bool IsProcessElevated()
{
	HANDLE hToken = NULL;
	if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken)) 
		return false;

	TOKEN_ELEVATION elevation = { 0 };
	DWORD dwSize = 0;
	BOOL chk = GetTokenInformation(hToken, TokenElevation, &elevation, sizeof(elevation), &dwSize);
	CloseHandle(hToken);

	if (!chk) 
		return false;

	// A nonzero value if the token has elevated privileges
	return (elevation.TokenIsElevated != 0);
}

and call the function instead
C#
WindowsIdentity* identity = WindowsIdentity::GetCurrent();
WindowsPrincipal* principal = new WindowsPrincipal(identity);
if (!principal->IsInRole(WindowsBuiltInRole::Administrator)) {

C++
if(IsProcessElevated()) {

Go on and convert the rest your self.
   
v2
Comments
Dave Kreskowiak 28-May-21 21:17pm
   
I doubt they're still converting the code nearly 2 years later.
merano99 29-May-21 15:22pm
   
You're right, but the original question has recently been changed. That made her stand up again. Thanks for the hint.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)




CodeProject, 20 Bay Street, 11th Floor Toronto, Ontario, Canada M5J 2N8 +1 (416) 849-8900