VerInfo.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode utility library.
// Module: Fetch and display version data from VERSION resource.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/VerInfo.h>
#include <uLib/DlgPlate.h>
#include <uLib/UtilFunc.h>
#include <uLib/StrFunc.h>
#include <uLib/Debug.h>

// dwPad and dwAlign are defined in DlgPlate.cpp

extern DWORD_PTR dwPad( DWORD_PTR X );
extern PBYTE dwAlign( PBYTE Ptr );

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Fundamental version info subroutines
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

PVOID GetVersionResource( HMODULE hMod, CSTR ResId, PUINT pSize )
{
    if (!hMod) hMod = GetModuleHandle( NULL ); // This module
    return LoadCustomResource( hMod, ResId, RT_VERSION, pSize );
}

PVOID LoadVersionInfo( CSTR FName, PDWORD pSize )
{
    DWORD Hnd, vSize;
    PVOID vInfo;
    TCHAR name[ MAX_PATH ];

    if (!FName)
    {
        GetModuleFileName( NULL, name, dimof(name) );
        FName = name;
    }
    vSize = GetFileVersionInfoSize( FName, &Hnd );
    if (!vSize) vInfo = NULL;
    else
    {
        if (pSize) *pSize = vSize;
        vInfo = LocalAlloc( LPTR, vSize );
    }
    if (vInfo)
    {
        Hnd = 0; // Ref.MSDN: This is unused.
        if (!GetFileVersionInfo( FName, Hnd, vSize, vInfo ))
        {
            LocalFree( vInfo );
            vInfo = NULL;
        }
    }
    return vInfo;
}

PVOID FreeVersionInfo( PVOID vInfo )
{
    return (PVOID) LocalFree( (HLOCAL) vInfo );
}

// NOTE: GetVersionStr has been superceeded by GetVersionString.
// However, this old version stays around as a Memo until Microsoft re-opens
// a channel to hand in bug reports.. (There should be a law enforcing that!)

#if 0 // 2016-11-12: BUGBUG in VerQueryValueA
// NtDll crashes *trying to write to the resource buffer*.
// VerQueryValueA assumes the resource is writable, and tries to use
// the resource buffer for in-place wide-char to ansi translation.
// (I might even had done that myself if I didn't think twice.)
// However, if given a direct resource pointer (eg. from Load/LockResource)
// the data buffer is read-only, and VerQueryValueA crashes in NtDll.

CSTR GetVersionStr( PVOID VerBuf, CSTR BlockId, CSTR Name )
{
    TCHAR vname[80];
    PVOID buf = NULL;
    UINT  len = 0;

    _stprintf_s( vname, dimof(vname), _T("\\StringFileInfo\\%s\\%s"), BlockId, Name );
    // In Ansi/MB builds VerQueryValue becomes VerQueryValueA, which is flawed..
    if (!VerQueryValue( VerBuf, vname, &buf, &len ) || (len == 0))
        buf = NULL;
    return (CSTR) buf;
}

#else
// NOTE: The bug does not appear in Unicode builds, since that uses VerQueryValueW,
// which doesn't require any resource string translation.

// Work around the bug by always using VerQueryValueW
// and do the string translation manually.

CSTR GetVersionStr( PVOID VerBuf, CSTR BlockId, CSTR Name )
{
    WCHAR vname[80];
    PVOID buf = NULL;
    UINT  len = 0;
  #ifdef _UNICODE
    #define _VNAME_FMT L"\\StringFileInfo\\%s\\%s"
  #else
    #define _VNAME_FMT L"\\StringFileInfo\\%S\\%S"
  #endif

    swprintf_s( vname, dimof(vname), _VNAME_FMT, BlockId, Name );
    if (!VerQueryValueW( VerBuf, vname, &buf, &len ) || (len == 0))
        buf = NULL;
    #ifndef _UNICODE
    else
    {
        #pragma message("ALERT: Using workaround for VerQueryValueA bug. > " __FILE__ ":" PP_NSTR(__LINE__))
        static CHAR szAnsi[ MAX_PATH ]; // Hackfix, use a static buffer

        // Take over the string translation to work around bug.
        // Pray that the szAnsi buffer is big enough so we don't loose info.
        // I do *not* want to bloat this simple function by extraneous heap allocations!
        // It's bad enough that I have to hack around an MS bug (yet again),
        // without being able to report the bug (since they closed all the doors!!)

        WideCharToMultiByte( CP_ACP, 0, (WCSTR)buf, len, szAnsi, dimof(szAnsi), 0,0 );
        buf = szAnsi;
    }
    #endif
    return (CSTR) buf;
    #undef _VNAME_FMT
}
#endif

// New version of GetVersionStr, uses caller supplied destination buffer.

UINT GetVersionString(
    IN PVOID VerBuf, IN CSTR BlockId, IN CSTR Name, OUT TSTR Buffer, IN UINT BufLen
    )
{
    WCHAR vname[ 80 ];
    PVOID buf = NULL;
    UINT  len = 0;
    if (!Buffer || !BufLen)
        SetLastError( ERROR_INVALID_PARAMETER );
    else
    {
        *Buffer = 0;
        #ifdef _UNICODE
          #define _VNAME_FMT L"\\StringFileInfo\\%s\\%s"
        #else
          #define _VNAME_FMT L"\\StringFileInfo\\%S\\%S"
        #endif
        swprintf_s( vname, dimof(vname), _VNAME_FMT, BlockId, Name );
        // Always use VerQueryValueW, since VerQueryValueA is flawed.. (See above)
        if (!VerQueryValueW( VerBuf, vname, &buf, &len ) || (len == 0))
            buf = NULL;
        #ifdef _UNICODE
          else _tcsncpyz( Buffer, (WCSTR)buf, BufLen );
        #else// Take over the flawed VerQueryValueA string translation..
          else WideCharToMultiByte( CP_ACP, 0, (WCSTR)buf, len, Buffer, BufLen, 0,0 );
        #endif
        #undef _VNAME_FMT
    }

    return len;
}

CSTR GetFixedVersionStr( PVOID vInfo )
{
    static TCHAR sInfo[32] = _T("");

    VS_FIXEDFILEINFO* fvi;
    UINT len;

    if (VerQueryValue( vInfo, _T("\\"), (void**)&fvi, &len ))
        _stprintf_s( sInfo, dimof(sInfo), _T("%u.%u.%u.%u"),
            HIWORD( fvi->dwProductVersionMS ), LOWORD( fvi->dwProductVersionMS ),
            HIWORD( fvi->dwProductVersionLS ), LOWORD( fvi->dwProductVersionLS )
            );
    return sInfo;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

bool GetVerTranslations( PVOID vInfo, PVXLT* ppXlt, PUINT pCount )
{
    BOOL ok = VerQueryValue( 
        vInfo, _T("\\VarFileInfo\\Translation"), (void**)ppXlt, pCount
        );
    if (ok) *pCount /= sizeof(VXLT);
    return bool_cast( ok );
}

// Grab the first available translation entry.
// If it fails, return an empty string.

CSTR GetVerTranslationStr( PVOID vInfo )
{
    static TCHAR szXlt[12] = _T("");
    PVXLT pXlt; UINT len;

    if (GetVerTranslations( vInfo, &pXlt, &len ))
        _stprintf_s( szXlt, dimof(szXlt), _T("%04X%04X"), pXlt[0].Lang, pXlt[0].Cp );
    else
    {
        TRACE( DP_WARNING, _T("[uLib] GetVerTranslationStr: No translation spec found!\r\n") );
        szXlt[0] = 0;
    }
    return szXlt;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Version string enumeration
// This is a rather esotheric and finicky task..
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/*
struct Var { 
  WORD  wLength; 
  WORD  wValueLength; 
  WORD  wType; 
  WCHAR szKey[]; 
  WORD  Padding[]; 
  DWORD Value[]; 
};
*/
static const BYTE cbVihFix = 6; // 3 WORDs fixed header size of VIH
typedef struct _viHdr // Version info header
{
    WORD  Length;
    WORD  ValueLen;
    WORD  Type;
    WCHAR Name[1]; // Variable size
    // Additional variably sized fields follow
}
VIH, *PVIH;

// VIH names
static const WCHAR  S_VerInfo[] = L"VS_VERSION_INFO";
static const WCHAR  S_StrInfo[] = L"StringFileInfo";
static const WCHAR  S_VarInfo[] = L"VarFileInfo";
static const WCHAR  S_Trans[]   = L"Translation";

// Padded count of bytes in a const WSTR (less the terminating NUL)

#define CB_CWSTR(s) (BYTE)dwPad( sizeof(s)-sizeof(WCHAR) )

static const BYTE  cbsVerInfo = CB_CWSTR( S_VerInfo );
static const BYTE  cbsStrInfo = CB_CWSTR( S_StrInfo );
static const BYTE  cbsVarInfo = CB_CWSTR( S_VarInfo );
static const BYTE  cbsTrans   = CB_CWSTR( S_Trans );

UINT EnumVersionStrings( PVOID vInfo, PFnEnumVerStr UserFunc, PVOID UserData )
{
    UINT        nStr = 0;
    PVIH        pVroot = (PVIH) vInfo; // Root block
    union {
        PVIH    pVi;    // Ptr to variably sized record.
        PBYTE   pb;     // Ptr for castless byte pointer arithmetics on pVi.
    }_; // Distinguished union name ;)

  #ifdef _DEBUG // VS_FIXEDFILEINFO is located after the Name of the root block
    VS_FIXEDFILEINFO* fvi = (VS_FIXEDFILEINFO*) dwAlign( PBYTE(pVroot) + cbVihFix + cbsVerInfo );
    if (fvi->dwSignature != 0xFEEF04BD) DebugBreak(); // Feefo forbid ;)
  #endif

    _.pVi = pVroot;
    // Forward pVi to the first StringFileInfo or VarFileInfo
    _.pb += dwPad( cbVihFix + cbsVerInfo + pVroot->ValueLen );

    size_t sfiLen = wcslen( S_StrInfo );
    if (wcsncmp( _.pVi->Name, S_StrInfo, sfiLen ) != 0) // If we got the VarFileInfo first
        _.pb += dwPad( _.pVi->Length );         // .. the next one is StringFileInfo, if any

    if (wcsncmp( _.pVi->Name, S_StrInfo, sfiLen ) == 0) // If we got a StringFileInfo block
    {
        PVIH pSfi = _.pVi; // StringFileInfo

        // Just grab the first StringTable block present

        PVIH pStbl = (PVIH)dwAlign( PBYTE(pSfi) + cbVihFix + cbsStrInfo );
        PVIH pEnd = (PVIH)dwAlign( PBYTE(pStbl) + pStbl->Length );

        // Forward to first version info string

        PVIH pvStr = (PVIH)dwAlign( PBYTE(pStbl) + cbVihFix + 16 ); // Name is 8 digit unicode hex str
        while( pvStr < pEnd )
        {
            if (pvStr->Type == 1) // 1==String, 0==Binary
            {
                size_t cbName = wcsbytes( pvStr->Name );
                PCWSTR sVal = pvStr->ValueLen
                    ? (PCWSTR)dwAlign( PBYTE(pvStr) + cbVihFix + cbName ) : L"";
                #ifdef _UNICODE
                    #define szName  pvStr->Name
                    #define szVal   sVal
                #else // Make MB translations for the UI
                    CHAR szName[128], szVal[512];
                    WideCharToMultiByte( CP_ACP,0, pvStr->Name,-1, szName, dimof(szName), NULL,NULL );
                    WideCharToMultiByte( CP_ACP,0, sVal,-1, szVal, dimof(szVal), NULL,NULL );
                #endif

                UserFunc( szName, szVal, UserData ); // --->> Callback
                ++nStr;
            }
            pvStr = (PVIH)dwAlign( PBYTE(pvStr) + pvStr->Length ); // Next
        }
    }
    return nStr;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// AboutVerBox uses a memory template, so it doesn't need a dialog resource.
// Hence it can live comfortably in a library.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

static const WORD  ABT_HELPID  = 1000;
static const WORD  ST_HEADING  = 100;
static const WORD  LB_INFO     = 101;

#ifndef WS_VISICHILD
  #define WS_VISICHILD  (WS_CHILD| WS_VISIBLE)
#endif
#ifndef WS_SCROLL
  #define WS_SCROLL     (WS_VSCROLL| WS_HSCROLL)
#endif

DIALOGPROC _AboutProc( HWND hdlg, UINT msg, WPARAM wp, LPARAM lp );

int AboutVerBox( HWND hOwner, LPCWSTR Caption, CSTR FName )
{
    PDLGTEMPLATEEX pDlg = AllocExDlgTemplate( 2048 );
    PDLGITEMTEMPLATEEX pItem;

    // Setup the dialog template

    pItem = SetExDlgStyle( pDlg,
        DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU,
        0, 0, 200,154, Caption, ABT_HELPID, 3, L"Tahoma", 8, FW_NORMAL, ANSI_CHARSET
        );
    // Static text
    pItem = AddExDlgItem( pItem, ORD_STATIC,
        WS_VISICHILD| WS_GROUP| SS_CENTER| SS_CENTERIMAGE| SS_SUNKEN,
        0, 6,6, 188,16, L"..", ST_HEADING, ABT_HELPID+ST_HEADING
        );
    // Listbox
    pItem = AddExDlgItem( pItem, ORD_LISTBOX,
        WS_VISICHILD| WS_SCROLL| WS_TABSTOP| LBS_USETABSTOPS| LBS_NOINTEGRALHEIGHT,
        WS_EX_STATICEDGE, 6,24, 188,108, L"", LB_INFO, ABT_HELPID+LB_INFO
        );
    // Ok button
    pItem = AddExDlgItem( pItem, ORD_BUTTON,
        WS_VISICHILD| WS_TABSTOP| BS_DEFPUSHBUTTON,
        0, 74,136, 50,14, L"&OK", IDOK, ABT_HELPID+IDOK
        );

    // Run the modal dialog

    int rc = (int) DialogBoxIndirectParam( 
        hInstance, (LPDLGTEMPLATE)pDlg, hOwner, _AboutProc, (LPARAM) FName
        );
    FreeExDlgTemplate( pDlg );
    return rc;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// _AboutProc - Dialog proc for AboutVerBox
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

static void __stdcall addVerStr( CSTR Name, CSTR Val, PVOID pCtl )
{
    static int width;
    if (!Name) width = 0; // Reset width
    else
    {
        TCHAR szItem[ MAX_PATH ];
        HWND hCtl = (HWND) pCtl;
        int len = _stprintf_s( szItem, dimof(szItem), _T("%s\t%s"), Name, Val );
        ListBox_AddString( hCtl, szItem );
        #if 1
        {
            SIZE size;
            HDC hdc = GetDC( hCtl );
            if (GetTextExtentPoint32( hdc, szItem, len, &size ))
            {
                if (size.cx > width)
                {
                    width = size.cx;
                    ListBox_SetHorizontalExtent( hCtl, width );
                }
            }
            ReleaseDC( hCtl, hdc );
        }
        #endif
    }
}

DIALOGPROC _AboutProc( HWND hdlg, UINT msg, WPARAM wp, LPARAM lp )
{
    static HFONT hBold;

    HWND    hCtl;
    int     tablen;
    LOGFONT lf;
    PVOID   verInfo;
    DWORD   verSize;
    CSTR    pcz, fname;

    DRESULT rc = TRUE;

    switch( msg )
    {
    case WM_INITDIALOG:
        tablen = 60;
        hCtl = GetDlgItem( hdlg, LB_INFO );
        ListBox_SetTabStops( hCtl, 1, &tablen );

        fname = (CSTR) lp;
        verInfo = LoadVersionInfo( fname, &verSize );
        if (verInfo)
        {
            CSTR sXlat = GetVerTranslationStr( verInfo );
            if (!*sXlat) sXlat = V_EnMultiBlock; //V_EnUniBlock

            CSTR vStr = GetVersionStr( verInfo, sXlat, V_ProdName );
            if (!vStr) vStr = _T("This Program");
            SetDlgItemText( hdlg, ST_HEADING, vStr );

            addVerStr( NULL,NULL,NULL ); // Reset list width
            IMAGE_NT_HEADERS Hdr;
            if (ReadNTHeaders( NULL, &Hdr, true ))
            {
                pcz = GetMachineStr( Hdr.FileHeader.Machine );
                addVerStr( _T("Machine"), pcz, hCtl );
                pcz = GetSubSystemStr( Hdr.OptionalHeader.Subsystem );
                addVerStr( _T("Subsystem"), pcz, hCtl );
            }
            EnumVersionStrings( verInfo, addVerStr, hCtl );
            FreeVersionInfo( verInfo );
        }
        break;

    case WM_DESTROY:
        hBold = DeleteFontEx( hBold );
        break;

    case WM_COMMAND:
        switch( LOWORD( wp )) {
        case IDOK:
        case IDCANCEL:
            EndDialog( hdlg, LOWORD( wp ));
            break;
        }
        break;

    case WM_SETFONT:
        if (!hBold) { // Make a bold version of the dialog's font
            GetObject( (HFONT)wp, sizeof(lf), &lf );
            lf.lfWeight = FW_BOLD;
            hBold = CreateFontIndirect( &lf );
        }
        break;

    case WM_CTLCOLORSTATIC: // Glorify the heading a bit
        SetTextColor( (HDC)wp, RGB( 0,100,200 ));
        SetBkColor( (HDC)wp, RGB( 255,255,255 ));
        if (hBold) SelectFont( (HDC)wp, hBold );
        rc = (DRESULT) GetStockBrush( WHITE_BRUSH );
        break;

    default:
        rc = FALSE;
    }
    return rc;
}

// EOF