COM Server registrieren, aber wie?

Hallo ich nochmal :D

Also ich hab das mal eingebaut und es funktioniert bis zu diesem Punkt:

Code:
pDllGetVersion = (DLLGETVERSIONPROC) GetProcAddress(hDllInst,
                          TEXT("DllGetVersion"));
Da bekomme ich einen NULL Zeiger zurück was bedeutet dass die dll das hier nicht unterstützt:
DLL supports version retrieval function

Es handelt sich bei mir nicht um eine gewöhnliche dll sondern um einen COM InProc Server,
"verpackt" als dll.
Jedoch kann ich im Explorer unter Versions Info alle Einträge einsehen die ich unter Visual Studio gemacht habe...
Hast du ne Idee wie es sonst noch gehen würde

Grüße RuFF
 
Ich glaube, der von mir gepostete Link war nicht so toll, da er nur mit DLLs funktioniert, die die Funktion "DllGetVersion" implementiert haben.
Versuch's mal mit nachfolgendem Code, den ich selber auch verwende (hatte ich bloß gestern abend nicht parat). Maßgeblich ist "GetVersionProperty()", "GetLanguage()" ist nur eine Hilfsfunktion. Ich hoffe, der Funktionskopf ist genügend selbsterklärend.

Gruß
MCoder

Code:
//-------------------------------------------------------------------
//  Versionsinfos einer Datei auslesen
//-------------------------------------------------------------------
//  Parameter
//              pszPath     ... Dateiname mit vollständigem Pfad
//              sRet        ... CString für Ergebnis
//              pProperty   ... Eigenschaft:
//                                  CompanyName
//                                  FileDescription
//                                  FileVersion
//                                  InternalName
//                                  LegalCopyright
//                                  OriginalFilename
//                                  ProductName
//                                  ProductVersion
//                                  Comments
//                                  LegalTrademarks
//                                  PrivateBuild
//                                  SpecialBuild 
//  Return      TRUE/FALSE
//-------------------------------------------------------------------
BOOL GetVersionProperty(LPCTSTR pszPath, CString& sRet, LPCTSTR pProperty)
{
    TCHAR   *lpVersion;
    DWORD   dwVerInfoSize;
    DWORD   dwVerHnd;
    BOOL    bRetCode;
    TCHAR   tchGetName[1024];
    UINT    wVersionLen;
    WORD    wLanguage, wCodePage;
    
    if( !GetLanguage(pszPath, wLanguage, wCodePage) )
    {
        return FALSE;
    }

    _stprintf(tchGetName, _T("\\StringFileInfo\\%04x%04x\\"), wLanguage, wCodePage);
    _tcscat(tchGetName, pProperty);

    dwVerInfoSize = GetFileVersionInfoSize((LPTSTR)pszPath, &dwVerHnd);

    if (dwVerInfoSize)
    {
        TCHAR   *lpstrVffInfo;
        HANDLE  hMem;

        // allocate memory to hold the verinfo block
        hMem          = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
        lpstrVffInfo  = (TCHAR FAR*)GlobalLock(hMem);

        GetFileVersionInfo((LPTSTR)pszPath, 0L, dwVerInfoSize, lpstrVffInfo);

        bRetCode =  VerQueryValue((LPVOID)lpstrVffInfo, (LPTSTR)tchGetName,
                        (void FAR* FAR*)&lpVersion, (UINT FAR *) &wVersionLen);

        if( bRetCode && wVersionLen && lpVersion)
        {
            sRet = lpVersion;   
        }
        else
        {
            GlobalUnlock(hMem);
            GlobalFree(hMem);
            return FALSE;
        }
            
        GlobalUnlock(hMem);
        GlobalFree(hMem);
    }
    else
    {
        return FALSE;
    }
    
    return TRUE;    
}

//-------------------------------------------------------------------
//  Sprachversion ermitteln
//-------------------------------------------------------------------
//  Parameter   pszPath     ... Dateiname mit vollständigem Pfad
//              wLanguage   ... Sprache
//              wCodePage   ... Codepage
//
//  RETURN      TRUE/FALSE
//-------------------------------------------------------------------
BOOL GetLanguage(LPCTSTR pszPath, WORD& wLanguage, WORD& wCodePage)
{
    LANGANDCP FAR   *lpTrans;
    DWORD           dwVerInfoSize;
    DWORD           dwVerHnd;    
    UINT            wNum;       
    UINT            wRetCode = 0;
    BOOL            bRet = TRUE;

    if( _taccess(pszPath, 0) == (-1) )
    {
        return FALSE;
    }

    dwVerInfoSize = GetFileVersionInfoSize((LPTSTR)pszPath, &dwVerHnd);

    if( dwVerInfoSize )
    {
        LPSTR   lpstrVffInfo;
        HANDLE  hMem;

        // allocate memory to hold the verinfo block
        hMem          = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
        lpstrVffInfo  = (char FAR*)GlobalLock(hMem);

        GetFileVersionInfo((LPTSTR)pszPath, 0L, dwVerInfoSize, lpstrVffInfo);
     
        if( VerQueryValue((LPVOID)lpstrVffInfo, _T("\\VarFileInfo\\Translation"),
            (void FAR* FAR*)&lpTrans, (UINT FAR*)&wNum) )
        {
            wLanguage = lpTrans->wLanguage;
            wCodePage = lpTrans->wCodePage;
        }
        else
        {
            bRet = FALSE;
        }

        GlobalUnlock(hMem);
        GlobalFree(hMem);
    }  
    else
    {
        return FALSE;
    }

    return bRet;
}
 
Hallöchen,

erstmal vielen Dank an dich;)
Aber wie zu erwarten hab ich da das eine oder andere Problemchen mti den beiden Funktionen...

Zum einen wer oder was ist "LANGANDCP FAR" in der Funktion "GetLanguage()" ?
Hab nix dazu gefunden, selbst google spuckt nur einen Treffer aus wenn man nach "LANGANDCP " sucht...

Und zum anderen eine Verständnisfrage zur Funktion "GetVersionProperty(LPCTSTR pszPath, CString& sRet, LPCTSTR pProperty)"

Scheinbar erwartet die Funktion diesen Parameter "LPCTSTR pProperty" von mir aber ich weiß net was da rein soll...
Vielmehr will ich nach der Beschreibung des Parameters zu urteilen eben diese Infos haben und nicht ihm übergeben :D

Grüße RuFF
 
Hiilfe :confused:

Habs eingebaut und würde denk ich , nur brauch ich folgendes:

- Definition von:
Code:
LANGANDCP

- Verwendung des Übergabeparameters pProperty in der Funktion:
Code:
BOOL GetVersionProperty(LPCTSTR pszPath, CString& sRet, LPCTSTR pProperty)
Ich versteh hierbei nicht warum Übergabeparameter und nicht Rückgabeparameter...

Danke im Vorraus ;)

Grüße
RuFF
 
RuFFnEcK hat gesagt.:
Zum einen wer oder was ist "LANGANDCP FAR" in der Funktion "GetLanguage()" ?
Sorry, hab leider das zugehörige typedef vergessen:
Code:
typedef struct tagLANGANDCP
{
    WORD wLanguage;
    WORD wCodePage;
} LANGANDCP;
RuFFnEcK hat gesagt.:
Scheinbar erwartet die Funktion diesen Parameter "LPCTSTR pProperty" von mir aber ich weiß net was da rein soll...
Einfach als String übergeben, z.B.: GetVersionProperty("CompanyName", ...
RuFFnEcK hat gesagt.:
Ich versteh hierbei nicht warum Übergabeparameter und nicht Rückgabeparameter...
Der Rückgabeparameter ist schon reserviert, um zu signalisieren, ob's überhaupt geklappt hat. Daher wird der ermittelte Wert dann in "sRet" geschrieben, der übergeben wird.

Ich hoffe, ich habe alle Klarheiten beseitigt :)


Gruß
MCoder
 
Danke für das struct und die Erklärung :D

Habs grad erst gerafft was du meintest mit
MCoder hat gesagt.:
Einfach als String übergeben, z.B.: GetVersionProperty("CompanyName", ...
Der Rückgabeparameter ist schon reserviert, um zu signalisieren, ob's überhaupt geklappt hat. Daher wird der ermittelte Wert dann in "sRet" geschrieben, der übergeben wird.

Also such ich mir eins von denen hier aus:
Code:
//              pProperty   ... Eigenschaft:
//                                  CompanyName
//                                  FileDescription
//                                  FileVersion
//                                  InternalName
//                                  LegalCopyright
//                                  OriginalFilename
//                                  ProductName
//                                  ProductVersion
//                                  Comments
//                                  LegalTrademarks
//                                  PrivateBuild
//                                  SpecialBuild

und übergeb des dann und bekomm es in sRet zurück geliefert ;)

TAUSEND DANK!
Hast mir mal wieder sehr geholfen ;)

Grüße
RuFF
 
Zuletzt bearbeitet:
Es tut mir echt leid dass ich mich so doof anstelle,
aber ich bekomms immer noch nicht hin :(

Also erstes Problem ist die Funktion:

Code:
if( _taccess(pszPath, 0) == (-1) )
    {
        return false;
    }

Genauer "_taccess" kennt mein Compiler nicht...
Mit der Fehlermeldung:
VTB - ManagerDlg.cpp(377) : error C3861: '_access': Bezeichner wurde auch mit einer argumentbezogenen Suche nicht gefunden
Aber da ich mir gedacht hab, da die Funktion nur prüft ob die Datei existier und Zugriff besteht und
ich sowieso vorher schon prüfe ob die Datei existiert, ich die Prüfung rausnehmen kann...

Aber dann bekomm ich beim Aufruf von:
Code:
GetFileVersionInfo((LPTSTR)pszPath, 0L, dwVerInfoSize, lpstrVffInfo);
nix zurück, da
Code:
 if( VerQueryValue((LPVOID)lpstrVffInfo, _T("\\VarFileInfo\\Translation"),
            (void FAR* FAR*)&lpTrans, (UINT FAR*)&wNum) )
fehlschlägt...

Jedoch hat mir
Code:
dwVerInfoSize = GetFileVersionInfoSize((LPTSTR)pszPath, &dwVerHnd);
den Wert "1668" in "dwVerInfoSize" zurück gegeben...

Ich weiß jetzt nicht so genau was das Problem sein könnte...

Sorry dass ich dich die ganze Zeit nerve, aber ich komm net wirklich weiter :(

Danke im Vorraus

Grüße
RuFF
 
Also "_taccess" ist die UINICODE-Variante von "_access". Mit "#include <io.h>" sollte das vielleicht funktionieren.

Hm, ansonsten hat's bei mir eigentlich immer klaglos funktioniert. GetFileVersionInfo() wird ja vor VerQueryValue() aufgerufen. Schaue dir mal den Rückgabewert von GetFileVersionInfo() an und am besten auch, ob die Speicherreservierung davor funktioniert.

Gruß
MCoder
 
Hi

Mit mit include hat es gefunzt!
Die Speicherallozierung einwandfrei...
Code:
        // allocate memory to hold the verinfo block
        hMem          = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
        lpstrVffInfo  = (char FAR*)GlobalLock(hMem);
Sowohl "hMem" als auch "lpstrVffInfo" bekommen eine Adresse...

So hab getz mal bevor ich weiter nach Fehlern suche, einfach mal die version einer exe
ermitteln lassen.
-> Es funktioniert!
Aber scheinbar gilt das nicht für COM Server :(
Tja schade eigentlich...
Hast du vielleicht noch ne Idee, wie ich die blöde Version der COM dll ermitteln kann?
Ich bin mir sicher dass es eine Version gibt, da ich unter Eigenschaften->Version alle Einträge sehen kann...
Was nutzt denn der Explorer für Funktionen, dass er das anzeigen kann

Grüße
RuFF
 
Hier ein (potthässlicher) Codeschnipsel aus meiner Bibliothek, wie man die Version (aus dem Versionstab) aus einer exe-Datei holt. Die Nummer bekommt er nur richtig raus, wenn die durch einen Punkt getrennt sind.

Code:
BOOL GetFileVersion( const char *szFileName, DWORD &dwMajor, DWORD &dwMinor, DWORD &dwBuildNumber)
{

  static BOOL (FAR WINAPI *MyGetFileVersionInfoSize)( LPTSTR, LPDWORD );
  static BOOL (FAR WINAPI *MyGetFileVersionInfo)( LPTSTR, DWORD, DWORD, LPVOID );
  static BOOL (FAR WINAPI *MyVerQueryValue)( const LPVOID, LPTSTR, LPVOID *, PUINT );


  HINSTANCE                 hVersionLib;

  
  // Rückgabewerte auf Dummies setzen
  dwMajor = 0;
  dwMinor = 0;
  dwBuildNumber = 0;

  // damit wir die VERSION.LIB nicht zum Projekt linken müssen
  hVersionLib = LoadLibrary( "version.dll" );
  if ( hVersionLib == NULL )
  {
    return FALSE;
  }

  MyGetFileVersionInfoSize = (int (_stdcall *)(char *,unsigned long *))GetProcAddress( hVersionLib, "GetFileVersionInfoSizeA" );
  if ( MyGetFileVersionInfoSize == NULL )
  {
    FreeLibrary( hVersionLib );
    return FALSE;
  }
  MyGetFileVersionInfo = (int (_stdcall *)( LPTSTR, DWORD, DWORD, LPVOID ))GetProcAddress( hVersionLib, "GetFileVersionInfoA" );
  if ( MyGetFileVersionInfo == NULL )
  {
    FreeLibrary( hVersionLib );
    return FALSE;
  }
  MyVerQueryValue= (int (_stdcall *)( const LPVOID, LPTSTR, LPVOID *, PUINT ))GetProcAddress( hVersionLib, "VerQueryValueA" );
  if ( MyVerQueryValue == NULL )
  {
    FreeLibrary( hVersionLib );
    return FALSE;
  }


  LPSTR       lpVersion;

  UINT        uVersionLen;

  DWORD       dwVerHnd = 0,         // An 'ignored' parameter, always '0'
              dwVerInfoSize = MyGetFileVersionInfoSize ( (char*)szFileName, &dwVerHnd );


  if ( !dwVerInfoSize )
  {
    // die Größe für das File-Info-Struct konnte nicht festgestellt werden
    FreeLibrary( hVersionLib );
    return FALSE;
  }

  // Speicher für File-Info-Struct belegen
  LPSTR lpstrVffInfo = (LPSTR)malloc( dwVerInfoSize );
  if ( lpstrVffInfo == NULL )
  {
    FreeLibrary( hVersionLib );
    return FALSE;
  }

  // Info anfordern
  if ( !MyGetFileVersionInfo( (char*)szFileName, dwVerHnd, dwVerInfoSize, lpstrVffInfo ) ) 
  {
    free( lpstrVffInfo );
    FreeLibrary( hVersionLib );
    return FALSE;
  }

	/* The below 'hex' value looks a little confusing, but
		 essentially what it is, is the hexidecimal representation
		 of a couple different values that represent the language
		 and character set that we are wanting string values for.
		 040904E4 is a very common one, because it means:
		 US English, Windows MultiLingual characterset
		 Or to pull it all apart:
		 04------        = SUBLANG_ENGLISH_USA
		 --09----        = LANG_ENGLISH
		 ----04E4 = 1252 = Codepage for Windows:Multilingual*/

	static char     fileVersion[256];

	LPVOID          version = NULL;

	DWORD           langD;

	BOOL            retVal;


	sprintf( fileVersion, "\\VarFileInfo\\Translation" );
	retVal = MyVerQueryValue( lpstrVffInfo, fileVersion, &version, (UINT*)&uVersionLen );
	if ( ( retVal ) 
  &&   ( uVersionLen == 4 ) )
	{
		memcpy( &langD, version, 4 );
		sprintf( fileVersion, "\\StringFileInfo\\%02X%02X%02X%02X\\FileVersion",
             ( langD & 0xff00 ) >> 8, 
             langD & 0xff, 
             ( langD & 0xff000000 ) >> 24, 
             ( langD & 0xff0000 ) >> 16 );			
	}
	else 
  {
		sprintf( fileVersion, "\\StringFileInfo\\%04X04B0\\FileVersion", GetUserDefaultLangID() );
  }

	if ( !MyVerQueryValue( lpstrVffInfo, fileVersion, (LPVOID *)&lpVersion, (UINT *)&uVersionLen ) )
  {	
		free( lpstrVffInfo );
    FreeLibrary( hVersionLib );
		return FALSE;
  }

  // Now we have a string that looks like this :
  // "MajorVersion.MinorVersion.BuildNumber", so let's parse it

  FreeLibrary( hVersionLib );

  // Get first token (Major version number)
  LPSTR token = strtok( lpVersion, TEXT ( "." ) );
  if ( token == NULL )
  {
    free( lpstrVffInfo );
    return TRUE;
  }
  dwMajor = atoi( token );

  token = strtok( NULL, TEXT( "." ) );
  if ( token == NULL )
  {
    free( lpstrVffInfo );
    return TRUE;
  }
  dwMinor = atoi( token );

  token = strtok( NULL, TEXT( "." ) );
  if ( token == NULL )
  {
    free( lpstrVffInfo );
    return TRUE;
  }
  dwBuildNumber = atoi( token );

	free( lpstrVffInfo );

  return TRUE;

}


Meine Fresse, ist das Stück hässlich.
 

Neue Beiträge

Zurück