winbootmgr.cpp

关注

原创最新推荐文章于 2026-11-12 23:40:11 发布 1k 阅读 AI 写同款· GEO 优化 ›

政府科技管理者如何提升科技成果转化项目进场交易的备案效率？.docx 政府科技管理者如何提升科技成果转化项目进场交易的备案效率？立即下载

by mj0011

// winbootmgr.cpp : Defines the entry point for the console application. 
// 
#include "stdafx.h" 
#include "windows.h" 
#include "winbase.h" 
#include "stdio.h" 
#include <stdlib.h> 
#define BOOT_MGR_TYPE 0x10100002 
#define BOOT_MGR_NAME_ELEMENTS 12000004 
#define BOOT_MGR_LOCAL 12000005 
#define BOOT_MGR_PTR_TO_DEFULT_OS 23000003 
#define BOOT_MGR_PTR_TO_DEFULT_REMUSE 23000006 
#define BOOT_MGR_BOOT_OS_LIST 24000001 
#define BOOT_MGR_PTR_TO_MEMTEST 24000010 
#define BOOT_MGR_WAIT_TIME    25000004 
#define OS_BOOTLOADER_PATH 12000002 
#define OS_NAME 12000004 
#define OS_LOCALE_LANGUAGE 12000005 
#define OS_SYSTEM_PATH 22000002 
// typedef struct BOOT_MGR{ 
//     
// }; 
void    DisplayOSNodeInfo(HKEY hkeyObjects ,
                          LPCSTR OsGUIDName)
{
    ULONG xret ; 
        CHAR xxName[100];
        
        HKEY hkeyOS ; 
        sprintf(xxName , "%s//Elements//%u" , OsGUIDName , OS_BOOTLOADER_PATH );
        xret = RegOpenKey(hkeyObjects , xxName , &hkeyOS );
        if (xret != ERROR_SUCCESS)
        {
            printf("error open Key :%s , err = %u/n" , xxName , xret);
        }
        else
        {
            ULONG Type , retlen = 100; 
            CHAR OSBootLoaderPath[100];
            xret = RegQueryValueEx(hkeyOS , "Element" , 0 , &Type , (LPBYTE)OSBootLoaderPath , &retlen );
            if (xret != ERROR_SUCCESS)
            {
                printf("error query value key , err = %u/n", xret);
            }
            else
            {
                printf("OsBootLoader Path :%s/n" , OSBootLoaderPath);
            }
            RegCloseKey(hkeyOS);
        }
        sprintf(xxName , "%s//Elements//%u" , OsGUIDName , OS_NAME  );
        
        
        xret = RegOpenKey(hkeyObjects , xxName , &hkeyOS );
        
        if (xret != ERROR_SUCCESS)
        {
            printf("error open Key :%s , err = %u/n" , xxName , xret);
            
            
        }
        else
        {
            ULONG Type , retlen = 100; 
            CHAR OsName[100];
            
            xret = RegQueryValueEx(hkeyOS , "Element" , 0 , &Type , (LPBYTE)OsName , &retlen );
            if (xret != ERROR_SUCCESS)
            {
                printf("error query value key , err = %u/n", xret);
            }
            else
            {
                printf("OS Name :%s/n" , OsName);
                
            }
            RegCloseKey(hkeyOS);
        }
        sprintf(xxName , "%s//Elements//%u" , OsGUIDName , OS_LOCALE_LANGUAGE  );
        
        
        xret = RegOpenKey(hkeyObjects , xxName , &hkeyOS );
        
        if (xret != ERROR_SUCCESS)
        {
            //printf("error open Key :%s , err = %u/n" , xxName , xret); 
            printf("Locale Language : N/A/n");
            
        }
        else
        {
            ULONG Type , retlen = 100; 
            CHAR OsLocale[100];
            
            xret = RegQueryValueEx(hkeyOS , "Element" , 0 , &Type , (LPBYTE)OsLocale , &retlen );
            if (xret != ERROR_SUCCESS)
            {
                printf("error query value key , err = %u/n", xret);
            }
            else
            {
                printf("Os Locale Language :%s/n" , OsLocale);
                
            }
            RegCloseKey(hkeyOS);
        }
        sprintf(xxName , "%s//Elements//%u" , OsGUIDName , OS_SYSTEM_PATH    );
        
        
        xret = RegOpenKey(hkeyObjects , xxName , &hkeyOS );
        
        if (xret != ERROR_SUCCESS)
        {
        //    printf("error open Key :%s , err = %u/n" , xxName , xret); 
            printf("Os System Path :N/A/n");    
            
        }
        else
        {
            ULONG Type , retlen = 100; 
            CHAR OsSystemPath[100];
            
            xret = RegQueryValueEx(hkeyOS , "Element" , 0 , &Type , (LPBYTE)OsSystemPath , &retlen );
            if (xret != ERROR_SUCCESS)
            {
                printf("error query value key , err = %u/n", xret);
            }
            else
            {
                printf("Os System Path :%s/n/n" , OsSystemPath);
                
            }
            RegCloseKey(hkeyOS);
        }
        return ; 
}
BOOL    ConnectBootMgr()
{
    HKEY hkey ; 
    ULONG xret ; 
    xret = RegOpenKey(HKEY_LOCAL_MACHINE , "BCD00000000" , &hkey);
    if (xret != ERROR_SUCCESS)
    {
        printf("open bcd main key failed , err = %u/n" , xret);
        return 3 ;
    }
    ULONG Index = 0 ;
    CHAR KeyName[100] = "";
    ULONG uret = ERROR_SUCCESS ; 
    BOOL    bFind = FALSE ; 
    while(uret == ERROR_SUCCESS)
    {
        if (!stricmp(KeyName , "Objects"))
        {
            bFind = TRUE ; 
            break ; 
        }
        uret = RegEnumKey(hkey , Index , KeyName , 100) ; 
        Index ++ ; 
    }
    if (!bFind)
    {
        RegCloseKey(hkey);
        printf("cannot found BCDMgr->Objects!/n");
        return FALSE ;
    }
    
    HKEY hkeyObject ; 
    xret = RegOpenKey(hkey , KeyName , &hkeyObject) ; 
    
    if (xret != ERROR_SUCCESS)
    {
        printf("error open BCDMgr->Objects! err = %u/n" , xret);
        RegCloseKey(hkey);
        return FALSE;
    }
    Index = 0 ; 
    uret = ERROR_SUCCESS ;
    bFind = FALSE ; 
    RegCloseKey(hkey);
    while(uret == ERROR_SUCCESS)
    {
        uret = RegEnumKey(hkeyObject , Index , KeyName , 100) ; 
        if (uret == ERROR_SUCCESS)
        {
            CHAR DescObject[100];
            HKEY hkeyDesc ; 
            sprintf(DescObject , "%s//%s" , KeyName , "Description");
            xret = RegOpenKey(hkeyObject , DescObject , &hkeyDesc)  ;
            if ( xret != ERROR_SUCCESS)
            {
                printf("error open Object Description , err = %u/n" , xret);
                RegCloseKey(hkeyObject);
                RegCloseKey(hkey);
                return FALSE ;
            }
            ULONG value ,type ,retlen = sizeof(ULONG); 
            xret = RegQueryValueEx(hkeyDesc , "Type" , 0 , &type ,  (LPBYTE)&value , &retlen) ; 
            if (xret  !=ERROR_SUCCESS)
            {
                printf("error query object description type err = %u/n" , xret);
                RegCloseKey(hkeyDesc);
                RegCloseKey(hkeyObject);
                RegCloseKey(hkey);
                return FALSE ;
            }
            if (value == BOOT_MGR_TYPE)
            {
                printf("BootMgr Object GUID = %s/n/n" , KeyName);
                bFind = TRUE ; 
                            
                break ; 
            }
            else
            {
                RegCloseKey(hkeyDesc);
            }
        }
        Index ++ ; 
    }
    CHAR ElementName[100];
    HKEY htemp ; 
    sprintf(ElementName , "%s//Elements//%u" , KeyName , BOOT_MGR_NAME_ELEMENTS);
    xret = RegOpenKey(hkeyObject , ElementName , &htemp );
    if (xret != ERROR_SUCCESS)
    {
        printf("error open Elements:BOOT_MGR_NAME_ELEMENTS Key :%s , err = %u/n" , ElementName , xret);
    }
    else
    {
        CHAR BootMgrName[100];
        ULONG size = 100 , Type ; 
        xret= RegQueryValueEx(htemp , "Element" , 0 , &Type ,(LPBYTE)BootMgrName , &size) ; 
        if (xret != ERROR_SUCCESS)
        {
            printf("error query element value of BOOT_MGR_NAME_ELEMENTS  err= %u/n" , xret);
        }
        else
        {
            printf("BootMgr Name : %s/n/n" , BootMgrName);
        }
        RegCloseKey(htemp);
    }
    sprintf(ElementName , "%s//Elements//%u" , KeyName , BOOT_MGR_LOCAL);
    
    xret = RegOpenKey(hkeyObject , ElementName , &htemp );
    if (xret != ERROR_SUCCESS)
    {
        printf("error open Elements:BOOT_MGR_LOCAL Key :%s , err = %u/n" , ElementName , xret);
    }
    else
    {
        CHAR Local[100];
        ULONG size = 100 , Type ; 
        
        xret= RegQueryValueEx(htemp , "Element" , 0 , &Type ,(LPBYTE)Local , &size) ; 
        
        if (xret != ERROR_SUCCESS)
        {
            printf("error query element value of BOOT_MGR_LOCAL  err= %u/n" , xret);
        }
        else
        {
            printf("Locale Language : %s/n/n" , Local);
        }
        RegCloseKey(htemp);
        
    }    
    sprintf(ElementName , "%s//Elements//%u" , KeyName , BOOT_MGR_PTR_TO_DEFULT_OS );
    
    xret = RegOpenKey(hkeyObject , ElementName , &htemp );
    if (xret != ERROR_SUCCESS)
    {
        printf("error open Elements:BOOT_MGR_PTR_TO_DEFULT_OS  Key :%s , err = %u/n" , ElementName , xret);
    }
    else
    {
        CHAR DefaultOS[100];
        ULONG size = 100 , Type ; 
        
        xret= RegQueryValueEx(htemp , "Element" , 0 , &Type ,(LPBYTE)DefaultOS , &size) ; 
        
        if (xret != ERROR_SUCCESS)
        {
            printf("error query element value of BOOT_MGR_PTR_TO_DEFULT_OS  err= %u/n" , xret);
        }
        else
        {
            printf("DefaultOS GUID : %s/n/n" , DefaultOS);
        }
        RegCloseKey(htemp);
        
    }
    sprintf(ElementName , "%s//Elements//%u" , KeyName , BOOT_MGR_PTR_TO_DEFULT_REMUSE );
    
    xret = RegOpenKey(hkeyObject , ElementName , &htemp );
    if (xret != ERROR_SUCCESS)
    {
        printf("error open Elements:BOOT_MGR_PTR_TO_DEFULT_REMUSE  Key :%s , err = %u/n" , ElementName , xret);
    }
    else
    {
        CHAR DefaultResume[100];
        ULONG size = 100 , Type ; 
        
        xret= RegQueryValueEx(htemp , "Element" , 0 , &Type ,(LPBYTE)DefaultResume , &size) ; 
        
        if (xret != ERROR_SUCCESS)
        {
            printf("error query element value of BOOT_MGR_PTR_TO_DEFULT_REMUSE  err= %u/n" , xret);
        }
        else
        {
            printf("Default Resume GUID : %s/n/n" , DefaultResume);
            DisplayOSNodeInfo(hkeyObject , DefaultResume);
        }
        RegCloseKey(htemp);
        
    }
    sprintf(ElementName , "%s//Elements//%u" , KeyName , BOOT_MGR_BOOT_OS_LIST  );
    
    xret = RegOpenKey(hkeyObject , ElementName , &htemp );
    if (xret != ERROR_SUCCESS)
    {
        printf("error open Elements:BOOT_MGR_BOOT_OS_LIST  Key :%s , err = %u/n" , ElementName , xret);
    }
    else
    {
        BYTE OSList[1000];
        PBYTE lpOsList = OSList ; 
        ULONG size = 1000 , Type ; 
        
        xret= RegQueryValueEx(htemp , "Element" , 0 , &Type ,(LPBYTE)OSList , &size) ; 
        
        if (xret != ERROR_SUCCESS)
        {
            printf("error query element value of BOOT_MGR_BOOT_OS_LIST    err= %u/n" , xret);
        }
        else
        {
            LPCSTR OsGUIDName  = (LPCSTR)lpOsList ; 
            ULONG OsIndex = 0 ;
            printf("SystemOS List:/n/n");
            while((ULONG)OsGUIDName+1 < (ULONG)lpOsList + size)
            {
                printf("OS[%u] : GUID = %s/n/n", OsIndex , OsGUIDName);
                DisplayOSNodeInfo(hkeyObject , OsGUIDName )    ;
                OsGUIDName = (LPCSTR)((ULONG)OsGUIDName + strlen(OsGUIDName) + 1 ); 
                OsIndex ++ ; 
            }
            
        }
        RegCloseKey(htemp);
        
    }
    sprintf(ElementName , "%s//Elements//%u" , KeyName , BOOT_MGR_PTR_TO_MEMTEST  );
    
    xret = RegOpenKey(hkeyObject , ElementName , &htemp );
    if (xret != ERROR_SUCCESS)
    {
        printf("error open Elements:BOOT_MGR_PTR_TO_MEMTEST  Key :%s , err = %u/n" , ElementName , xret);
    }
    else
    {
        CHAR MemTest[100];
        ULONG size = 100 , Type ; 
        
        xret= RegQueryValueEx(htemp , "Element" , 0 , &Type ,(LPBYTE)MemTest , &size) ; 
        
        if (xret != ERROR_SUCCESS)
        {
            printf("error query element value of BOOT_MGR_PTR_TO_MEMTEST    err= %u/n" , xret);
        }
        else
        {
            printf("BootMemTest GUID : %s/n/n" , MemTest);
            DisplayOSNodeInfo(hkeyObject , MemTest);
        }
        RegCloseKey(htemp);
        
    }
    sprintf(ElementName , "%s//Elements//%u" , KeyName , BOOT_MGR_WAIT_TIME  );
    
    xret = RegOpenKey(hkeyObject , ElementName , &htemp );
    if (xret != ERROR_SUCCESS)
    {
        printf("error open Elements:BOOT_MGR_WAIT_TIME  Key :%s , err = %u/n" , ElementName , xret);
    }
    else
    {
        LARGE_INTEGER WaitTime; 
        ULONG size = 8, Type ; 
        
        xret= RegQueryValueEx(htemp , "Element" , 0 , &Type ,(LPBYTE)&WaitTime , &size) ; 
        
        if (xret != ERROR_SUCCESS)
        {
            printf("error query element value of BOOT_MGR_WAIT_TIME    err= %u/n" , xret);
        }
        else
        {
            printf("Boot Menu Wait Time : %I64u second(s)/n/n" , WaitTime.QuadPart);
        }
        RegCloseKey(htemp);
        
    }
    RegCloseKey(hkeyObject);
    RegCloseKey(hkey);
//    strcpy(BootName ,KeyName); 
    return TRUE ;
}
int main(int argc, char* argv[])
{
    HKEY hkey ; 
    if (RegOpenKey(HKEY_LOCAL_MACHINE,"BCD00000000" , &hkey) != ERROR_SUCCESS)
    {
        MessageBox(GetDesktopWindow() , "Need admin privilege!" , "Error" , MB_OK|MB_ICONWARNING);
        return 0;
    }
    RegCloseKey(hkey);
    printf("Windows Vista BootMgr Demo/n"
        "By MJ0011 2008-7-15/n"
        "/n1.Display BootMgr config/n/n");
    ULONG id = 0 ; 
    fflush(stdin);
    scanf("%u" , &id);
    if (id == 1 )
    {
        ConnectBootMgr();
        system("pause");
    }
    return 0 ;
}