Nsys

/
//                         NSys
/


BOOL    NSys::EnablePrivilege(TCHAR  *  name, BOOL fEnable, HANDLE hToken)
{
    BOOL                bRetVal;
     int                     nError;
    HANDLE                hNewToken  =  NULL;
    TOKEN_PRIVILEGES    priv  =  {  1 , { 0 ,  0 , fEnable  ?  SE_PRIVILEGE_ENABLED :  0 } };

    LookupPrivilegeValue( 0 , name,  & priv.Privileges[ 0 ].Luid);
     if (hToken  ==  NULL)
        OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES,  & hNewToken);
     else
        hNewToken  =  hToken;

    bRetVal  =  AdjustTokenPrivileges(hNewToken, FALSE,  & priv,  sizeof (priv),  0 ,  0 );
     if (bRetVal  ==  FALSE)
    {
        nError  =  ::GetLastError();
         if (hToken  ==  NULL)    
            CloseHandle(hNewToken);

        ::SetLastError(nError);
         return  FALSE;
    }

     if (hToken  ==  NULL)    
        CloseHandle(hNewToken);
     return  TRUE;
}


BOOL    NSys::EnableProcPrivilege(DWORD PID)
{
    HANDLE                    hProc, hToken; 
    BOOL                    bRetVal;

    bRetVal  =  EnablePrivilege(SE_DEBUG_NAME);
     if (bRetVal  ==  FALSE)
         return  FALSE;

     if (PID  ==   0 )
         return  TRUE;

    hProc  =  ::OpenProcess(PROCESS_ALL_ACCESS, TRUE, PID);
     if (hProc  ==  NULL)
         return  FALSE;

    bRetVal  =  OpenProcessToken(hProc, TOKEN_ADJUST_PRIVILEGES  |  TOKEN_QUERY,  & hToken);
     if (bRetVal  ==  FALSE)
    {
        CloseHandle(hProc);
         return  FALSE;
    }

    bRetVal  =  EnablePrivilege(SE_DEBUG_NAME, TRUE, hToken);
    CloseHandle(hToken);
    CloseHandle(hProc);
     if (bRetVal  ==  FALSE)
         return  FALSE;

     return  TRUE;
}


BOOL    NSys::AppMultiRunCheck(CHAR  *  pMutexName)
{
     static  HANDLE    hMutex  =  NULL;

     if (pMutexName  ==  NULL)
    {
        CloseHandle(hMutex);
         return  TRUE;
    }

    hMutex  =  ::CreateMutexA(NULL, FALSE, pMutexName);
     if (GetLastError()  ==  ERROR_ALREADY_EXISTS)
    {
        CloseHandle(hMutex);
         return  FALSE;
    }

     return  TRUE;
}


BOOL    NSys::Execute(CHAR  * pExeFile, CHAR  * pCmdLine, BOOL bWait)
{
    CHAR                    szCommandLine[ 1024 ];
    STARTUPINFOA            si;
    PROCESS_INFORMATION        pi;
    BOOL                    bRetVal;

    memset( & si,  0 ,  sizeof (si));

     if (pCmdLine)
        sprintf(szCommandLine,  " "%s" %s " , pExeFile, pCmdLine);
     else
        strcpy(szCommandLine, pExeFile);

    bRetVal  =  CreateProcessA(NULL, szCommandLine, NULL, NULL, 
        FALSE,  0 , NULL, NULL,  & si,  & pi);
     if (bRetVal  ==  FALSE)
         return  FALSE;

     if (bWait)
        WaitForSingleObject(pi.hProcess, INFINITE);

    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
     return  FALSE;
}


BOOL    NSys::StopService(CHAR  * pServiceName)
{
    SC_HANDLE            hManager;
    SC_HANDLE            hService;
    SERVICE_STATUS        ServiceStatus;
    DWORD                dwTk1, dwTk;
    BOOL                bRetVal;

    hManager  =  OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
     if  (hManager  ==  NULL)
         return  FALSE;

    hService  =  OpenService(hManager, pServiceName, SERVICE_ALL_ACCESS);
     if  (hService  ==  NULL)
    {
        CloseServiceHandle(hManager);
         return  FALSE;
    }

    QueryServiceStatus(hService,  & ServiceStatus);
    bRetVal  =  ControlService(hService, SERVICE_STOPPED,  & ServiceStatus);
     if (bRetVal  ==  FALSE)
         return  FALSE;

    dwTk1  =  GetTickCount();
    dwTk  =   0 ;
     for (; dwTk < 5000 ; dwTk = GetTickCount() - dwTk1)
    {
        bRetVal  =  QueryServiceStatus(hService,  & ServiceStatus);
         if (bRetVal  ==  FALSE)
             break ;

         if (ServiceStatus.dwCurrentState  !=  SERVICE_STOP_PENDING)
             break ;
    }

    CloseServiceHandle(hService);
    CloseServiceHandle(hManager);
     return  TRUE;

}


BOOL    NSys::KillProc(DWORD dwProcId)
{
    HANDLE            hProc;
    DWORD            dwExitCode;
    BOOL            bRetVal;

     if (dwProcId  ==   0 )
        dwProcId  =  GetCurrentProcessId();

    hProc  =  OpenProcess(PROCESS_QUERY_INFORMATION  |  PROCESS_VM_READ  |  PROCESS_TERMINATE, 
        FALSE, dwProcId);
     if (hProc  ==  NULL)
         return  FALSE;

    GetExitCodeProcess(hProc,  & dwExitCode);
    bRetVal  =  TerminateProcess(hProc, dwExitCode);

    CloseHandle(hProc);

     return  bRetVal;
}


BOOL    NSys::KillProc(CHAR  * pProcName)
{
    DWORD            dwProcId;
    BOOL            bRetVal;

    bRetVal  =  GetProcIdFromName(pProcName,  & dwProcId);
     if (bRetVal  ==  FALSE)
         return  FALSE;

     return  KillProc(dwProcId);
}


BOOL    NSys::GetProcIdFromNameNt4(CHAR  * pProcName, DWORD  * pdwProcId)
{
    CHAR            szModuleFileName[MAX_PATH];
    CHAR            szModName[MAX_PATH];
     int                 i;
    DWORD            dwNeedSize, dwSize;
    DWORD             *  pdwProID;
     int                 nCount;
    BOOL            bRetVal;
    DWORD            dwRetVal;
    HANDLE            hProc;

    nCount  =   256 ;
    pdwProID  =  NULL;
     for (i = 0 ; ; i ++ )
    {
         if (pdwProID)
            delete [] pdwProID;

        EnumProcesses(pdwProID, nCount,  & dwNeedSize);
        pdwProID  =   new  DWORD[nCount];
        dwSize  =   sizeof (DWORD)  *  nCount;

        bRetVal  =  EnumProcesses(pdwProID, dwSize,  & dwNeedSize);
         if (bRetVal  ==  FALSE)
        {
             if (pdwProID)
                delete [] pdwProID;
             return  FALSE;
        }

         if (dwSize  !=  dwNeedSize)
             break ;
    }

    nCount  =  dwNeedSize  /   sizeof (DWORD);

     for (i = 0 ; i < nCount; i ++ )
    {
        hProc  =  OpenProcess(PROCESS_QUERY_INFORMATION  |  PROCESS_VM_READ,
            FALSE, pdwProID[i]);
         if (hProc  ==  NULL)
             continue ;

        dwRetVal  =  GetModuleFileNameExA(hProc, NULL, 
            szModuleFileName,  sizeof (szModuleFileName));
         if (dwRetVal  !=   0 )
        {
            NFile::SpliteFilePath(szModuleFileName, NULL, szModName);

             if (stricmp(pProcName, szModName)  ==   0 )
            {
                 * pdwProcId  =  pdwProID[i];
                CloseHandle(hProc);
                 return  TRUE;
            }
        }

        CloseHandle(hProc);
    }

     if (pdwProID)
        delete [] pdwProID;

     return  FALSE;
}


BOOL    NSys::GetProcIdFromNameOther(CHAR  * pProcName, DWORD  * pdwProcId)
{
    CHAR                    szModuleFileName[MAX_PATH];
    BOOL                    bRetVal;
    DWORD                    dwRetVal;
    HANDLE                    hProcShot, hProc;
    PROCESSENTRY32            ProcEntry;
    CHAR                    szModName[MAX_PATH];

    hProcShot  =  CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,  0 );
     if (hProcShot  ==  INVALID_HANDLE_VALUE)
         return  FALSE;

    ProcEntry.dwSize  =   sizeof (ProcEntry);
    bRetVal  =  Process32First(hProcShot,  & ProcEntry);
     if (bRetVal  ==  FALSE)
         return  FALSE;

     for (;;)
    {
        hProc  =  OpenProcess(PROCESS_QUERY_INFORMATION  |  PROCESS_VM_READ, 
            FALSE, ProcEntry.th32ProcessID);
         if (hProc  ==  FALSE)
        {
            bRetVal  =  Process32Next(hProcShot,  & ProcEntry);
             if (bRetVal  ==  FALSE)
                 break ;

             continue ;
        }

        dwRetVal  =  GetModuleFileNameExA(hProc, NULL, 
            szModuleFileName,  sizeof (szModuleFileName));
         if (dwRetVal)
        {
            NFile::SpliteFilePath(szModuleFileName, NULL, szModName);

             if (stricmp(pProcName, szModName)  ==   0 )
            {
                 * pdwProcId  =  ProcEntry.th32ProcessID;
                CloseHandle(hProc);
                 return  TRUE;
            }
        }

        CloseHandle(hProc);
        bRetVal  =  Process32Next(hProcShot,  & ProcEntry);
         if (bRetVal  ==  FALSE)
             break ;
    }

    CloseHandle(hProcShot);
     return  FALSE;
}


BOOL    NSys::GetProcIdFromName(CHAR  * pProcName, DWORD  * pdwProcId)
{
     static      int                 nType  =   - 1 ;
    _bstr_t                    bStrOSName  =   "" ;

     if (nType  ==   - 1 )
    {
        GetOperateSystemName( & bStrOSName);
         if (strstr(bStrOSName,  " Windows NT " ))
            nType  =   0 ;
         else
            nType  =   1 ;
    }

     if (nType  ==   0 )
         return  GetProcIdFromNameNt4(pProcName, pdwProcId);
     else
         return  GetProcIdFromNameOther(pProcName, pdwProcId);

     return  FALSE;
}


BOOL    NSys::GetOperateSystemName(_bstr_t  * pbStrOSVersion)
{
    CHAR                szOSVersion[ 256 ];
    OSVERSIONINFOEXA    OsInfoExA;
    BOOL                bOsVersionInfoEx;
     static     _bstr_t        bStrOSName  =   "" ;

     if (bStrOSName.length()  !=   0 )
    {
         * pbStrOSVersion  =  bStrOSName;
         return  TRUE;
    }


     * pbStrOSVersion  =   " Unknown " ;

    memset( & OsInfoExA,  0 ,  sizeof (OsInfoExA));

    OsInfoExA.dwOSVersionInfoSize  =   sizeof (OSVERSIONINFOEXA);
    bOsVersionInfoEx  =  GetVersionExA((OSVERSIONINFO  * ) & OsInfoExA);
     if (bOsVersionInfoEx  ==  FALSE)
    {
        OsInfoExA.dwOSVersionInfoSize  =   sizeof (OSVERSIONINFOA);

         if (GetVersionExA((OSVERSIONINFO  * ) & OsInfoExA)  ==  FALSE) 
        {
             return  FALSE;
        }
    }

     switch  (OsInfoExA.dwPlatformId)
    {
     case  VER_PLATFORM_WIN32s:
        strcpy(szOSVersion,  " Microsoft Win32s " );
         break ;

     case  VER_PLATFORM_WIN32_WINDOWS:
         if  (OsInfoExA.dwMajorVersion  ==   4 ) 
        {
             if  (OsInfoExA.dwMinorVersion  ==   0 ) 
            {
                strcpy(szOSVersion,  " Windows 95  " );
                 if  (OsInfoExA.szCSDVersion[ 1 ]  ==   ' C '   ||  OsInfoExA.szCSDVersion[ 1 ]  ==   ' B ' )
                    strcat(szOSVersion,  " OSR2  " );
            }
             else   if  (OsInfoExA.dwMinorVersion  ==   10 ) 
            {
                strcpy(szOSVersion,  " Windows 98  " );
                 if  (OsInfoExA.szCSDVersion[ 1 ]  ==   ' A ' )
                    strcat(szOSVersion,  " SE  " );
            }
             else   if  (OsInfoExA.dwMinorVersion  ==   90 ) 
            {
                strcpy(szOSVersion,  " Windows ME " );
            }
             else  
            {
                strcpy(szOSVersion,  " Unknown " );
            }
        }
         break ;

     case  VER_PLATFORM_WIN32_NT:
         if  ((OsInfoExA.dwMajorVersion  ==   5 )  &&
            (OsInfoExA.dwMinorVersion  ==   2 )) 
        {
            strcpy(szOSVersion,  " Windows Server 2003  " );
        } 
         else   if  ((OsInfoExA.dwMajorVersion  ==   5 )  &&
            (OsInfoExA.dwMinorVersion  ==   1 )) 
        {
            strcpy(szOSVersion,  " Windows XP  " );
        } 
         else   if  ((OsInfoExA.dwMajorVersion  ==   5 )  &&
            (OsInfoExA.dwMinorVersion  ==   0 )) 
        {
            strcpy(szOSVersion,  " Windows 2000  " );
        }
         else   if  (OsInfoExA.dwMajorVersion  <=   4 ) 
        {
            strcpy(szOSVersion,  " Windows NT  " );
        }

         * pbStrOSVersion  =  szOSVersion;

         if  (bOsVersionInfoEx) 
        {
             if  (OsInfoExA.wProductType  ==  VER_NT_WORKSTATION)
            {
                 if (OsInfoExA.dwMajorVersion  ==   4 )
                    strcat(szOSVersion,  " Workstation 4.0  " );
                 else   if ( OsInfoExA.wSuiteMask  &  VER_SUITE_PERSONAL )
                    strcat(szOSVersion,  " Home Edition  "  );
                 else
                    strcat(szOSVersion,  " Professional  "  );
            }
             else   if  ( OsInfoExA.wProductType  ==  VER_NT_SERVER )
            {
                 if ( OsInfoExA.dwMajorVersion  ==   5   &&  OsInfoExA.dwMinorVersion  ==   2  )
                {
                     if ( OsInfoExA.wSuiteMask  &  VER_SUITE_DATACENTER )
                        strcat(szOSVersion,  " Datacenter Edition  "  );
                     else   if ( OsInfoExA.wSuiteMask  &  VER_SUITE_ENTERPRISE )
                        strcat(szOSVersion,  " Enterprise Edition  "  );
                     else   if  ( OsInfoExA.wSuiteMask  ==  VER_SUITE_BLADE )
                        strcat(szOSVersion,  " Web Edition  "  );
                     else
                        strcat(szOSVersion,  " Standard Edition  "  );
                }
                 else   if ( OsInfoExA.dwMajorVersion  ==   5   &&  OsInfoExA.dwMinorVersion  ==   0  )
                {
                     if ( OsInfoExA.wSuiteMask  &  VER_SUITE_DATACENTER )
                        strcat(szOSVersion,  " Datacenter Server  "  );
                     else   if ( OsInfoExA.wSuiteMask  &  VER_SUITE_ENTERPRISE )
                        strcat(szOSVersion,  " Advanced Server  "  );
                     else
                        strcat(szOSVersion,  " Server  "  );
                }
                 else    //  Windows NT 4.0
                {
                     if ( OsInfoExA.wSuiteMask  &  VER_SUITE_ENTERPRISE )
                        strcat(szOSVersion,  " Server 4.0, Enterprise Edition  "  );
                     else
                        strcat(szOSVersion,  " Server 4.0  " );
                }
            }
        }
         else  
        {
            HKEY hKey;
             char  szProductType[ 256 ];
            DWORD dwBufLen  =   256 ;
            LONG lRet;

            lRet  =  RegOpenKeyEx( HKEY_LOCAL_MACHINE,  " SYSTEM/CurrentControlSet/Control/ProductOptions " ,  0 , KEY_QUERY_VALUE,  & hKey);
             if (lRet  !=  ERROR_SUCCESS )
                 return  FALSE;

            lRet  =  RegQueryValueEx(hKey,  " ProductType " , NULL, NULL,    (LPBYTE)szProductType,  & dwBufLen);
             if ((lRet  !=  ERROR_SUCCESS)  ||  (dwBufLen  >   256 ))
                 return  FALSE;

            RegCloseKey( hKey );

             if  (stricmp( " WINNT " , szProductType)  ==   0 )
                strcpy(szOSVersion,  " Workstation  " );
             if  ( stricmp(  " LANMANNT " , szProductType)  ==   0  )
                strcpy(szOSVersion,  " Server  " );
             if  ( lstrcmpi(  " SERVERNT " , szProductType)  ==   0  )
                stricmp(szOSVersion,  " Advanced Server  " );
        }

         if (OsInfoExA.dwMajorVersion  ==   6 )
        {
             if (OsInfoExA.dwMinorVersion  ==   0 )
            {
                 if ((OsInfoExA.wProductType  &   0xFF )  ==   1 )
                    strcpy(szOSVersion,  " Microsoft Windows Vista  " );
                 else
                    strcpy(szOSVersion,  " Windows Server "Longhorn"  " );
            }
        }
         break ;

     default :
         return  FALSE;
    }

     * pbStrOSVersion  =  szOSVersion;
    bStrOSName  =  szOSVersion;
     return  TRUE;
}



int         NSys::GetErrorString(_bstr_t  *  pbStrErrStr,  int  nErrorCode)
{
    CHAR    szMsgBuf[ 1000 ];
     if (nErrorCode  ==   0 )
        nErrorCode  =  GetLastError();

    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, nErrorCode,
        MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT), szMsgBuf,  sizeof (szMsgBuf), NULL);

     * pbStrErrStr  =  szMsgBuf;
     return  nErrorCode;
}