Hilfe bei übersetzung einer CPP schleife

[Horst0815]

da andere beispiele(auch Programme) über WMI das SMBios auszulesen mit Fehler80041001 enden muss ich leider diese CPP Funktion verwenden da sie auf meinen Rechner funktioniert


hab erstmal so weit wie ich konnte übersetzt(hoffe richtig) für die auskommentierten stellen brauch ich aber Hilfe ganz speziell bei der Schleife

Code:

bool init_raw_smbios_data()
{
   //zero raw dat memory
   memset(global_buffer.smbios_table_data,0,MAX_DATA);

   bool ret = false;
   HRESULT h_result;

    // Initialize COM.
    h_result =  CoInitializeEx(0, COINIT_MULTITHREADED); 
    if (h_result<0)
    {
        return false;              // Program has failed.
    }

    // Obtain the initial locator to Windows Management
    // on a particular host computer.
    
   IWbemLocator* p_locator = 0;

    h_result = CoCreateInstance(
        CLSID_WbemLocator,             
        0, 
        CLSCTX_INPROC_SERVER, 
        IID_IWbemLocator, (LPVOID *) &p_locator);
 
    if (h_result<0)
    {
        CoUninitialize();
        return false;       // Program has failed.
    }

    IWbemServices* p_service = 0;

    // Connect to the root\cimv2 namespace with the
    // current user and obtain pointer pSvc
    // to make IWbemServices calls.

   h_result = p_locator->ConnectServer(
      BSTR("ROOT\\WMI"),       // WMI namespace
      NULL,                    // User name
        NULL,                    // User password
        0,                       // Locale
        NULL,                    // Security flags                 
        0,                       // Authority       
        0,                       // Context object
        &p_service                 // IWbemServices proxy
   );
    
    if (h_result<0)
   {
        p_locator->Release();     
        CoUninitialize();
        return false;                // Program has failed.
    }

    // Set the IWbemServices proxy so that impersonation
    // of the user (client) occurs.
    h_result = CoSetProxyBlanket(
       p_service,                      // the proxy to set
       RPC_C_AUTHN_WINNT,            // authentication service
       RPC_C_AUTHZ_NONE,             // authorization service
       NULL,                         // Server principal name
       RPC_C_AUTHN_LEVEL_CALL,       // authentication level
       RPC_C_IMP_LEVEL_IMPERSONATE,  // impersonation level
       NULL,                         // client identity 
       EOAC_NONE                     // proxy capabilities     
    );

    if (h_result<0)
    {
        p_service->Release();
      p_locator->Release();
        CoUninitialize();
        return false;               // Program has failed.
    }

    IEnumWbemClassObject* p_enumerator = NULL;
   h_result = p_service->CreateInstanceEnum(BSTR("MSSMBios_RawSMBiosTables"), 0, NULL, &p_enumerator);
    
    if (h_result<0)
    {
        p_service->Release();
        p_locator->Release();     
        CoUninitialize();
        return false;               // Program has failed.
    }
    else
    { 
        do
        {
            IWbemClassObject* p_instance = NULL;
            ULONG dw_count = NULL;

            h_result = p_enumerator->Next(
                WBEM_INFINITE,
                1,
                &p_instance,
                &dw_count);      
         if(h_result>=0)
         {
            VARIANT variant_bios_data;
            VariantInit(&variant_bios_data);
            CIMTYPE type;

            h_result = p_instance->Get(BSTR("SmbiosMajorVersion"),0,&variant_bios_data,&type,NULL);
            if(h_result <0)
            {
               VariantClear(&variant_bios_data);
            }
            else
            {
               global_buffer.smbios_major_version = (unsigned char)variant_bios_data.iVal;
               VariantInit(&variant_bios_data);
               h_result = p_instance->Get(BSTR("SmbiosMinorVersion"),0,&variant_bios_data,&type,NULL);
               if(h_result<0)
               {
                  VariantClear(&variant_bios_data);
               }
               else
               {
                  global_buffer.smbios_minor_version = (unsigned char)variant_bios_data.iVal;
                  VariantInit(&variant_bios_data);
                  h_result = p_instance->Get(BSTR("SMBiosData"),0,&variant_bios_data,&type,NULL);
                  if(h_result>=0)
                  {
                     if ( ( VT_UI1 | VT_ARRAY  ) != variant_bios_data.vt )
                     {
                     }
                     else
                     {
                        SAFEARRAY* p_array = NULL;
                        p_array = V_ARRAY(&variant_bios_data);
                        unsigned char* p_data = (unsigned char *)p_array->pvData;

                        global_buffer.length = p_array->rgsabound[0].cElements;
                        if (global_buffer.length >= MAX_DATA) 
                        {
//                           p(_T("Return global_buffer would overflow.  Abort initialization of raw SMBIOS data.\n"));
                           p_service->Release();
                           p_locator->Release();     
                           CoUninitialize();
                           return false;
                        }
                        memcpy(global_buffer.smbios_table_data,p_data,global_buffer.length);
                     }
                  }
                  VariantClear(&variant_bios_data);
               }
            }
            break;
         }
    
        } while (h_result == WBEM_S_NO_ERROR);
    }
   
    p_service->Release();
    p_locator->Release();     
    CoUninitialize();

   return true;
}

Delphi-Quellcode:

Function init_raw_smbios_data: Boolean;
var // These are all needed for the WMI querying process
  p_Locator: ISWbemLocator;
  p_service: ISWbemServices;
  vNVS: OleVariant;
  p_enumerator, p_instance: OleVariant; // IEnumWbemClassObject;
  dw_count: ULONG;
  variant_bios_data: OleVariant;
  ret: Boolean;
  h_result: HRESULT;
  types: Integer; // CIMTYPE
begin
  // zero raw dat memory
  FillChar(global_buffer.smbios_table_data, MAX_DATA, #0);
  // memset(global_buffer.smbios_table_data,0,MAX_DATA);
  ret := false;
  // Initialize COM.
  h_result := CoInitializeEx(0, COINIT_MULTITHREADED);
  if (h_result < 0) then
    Result := false; // Program has failed.
  // Obtain the initial locator to Windows Management
  // on a particular host computer.
  p_Locator := nil;
  // h_result := CoCreateInstance(CLSID_WbemLocator,0,CLSCTX_INPROC_SERVER,IID_IWbemLocator,{ (LPVOID *) }p_locator);
  if h_result < 0 then
  begin
    CoUninitialize;
    Result := false; // Program has failed.
  end;
  p_service := nil;
  // Connect to the root\cimv2 namespace with the
  // current user and obtain pointer pSvc
  // to make IWbemServices calls.
  // h_result := p_locator.ConnectServer('ROOT\WMI', '', '', '', '', '', 0,&p_service); //vNVS
  if (h_result < 0) then
  begin
    p_Locator._Release;
    CoUninitialize();
    Result := false; // Program has failed.
  end;
  // Set the IWbemServices proxy so that impersonation
  // of the user (client) occurs.
  h_result := CoSetProxyBlanket(p_service, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
    nil, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, nil, EOAC_NONE);
  if h_result < 0 then
  begin
    p_service._Release;
    p_Locator._Release;
    CoUninitialize();
    Result := false; // Program has failed.
  end;
  p_enumerator := 0;
  // h_result := p_service.InstancesOf('MSSMBios_RawSMBiosTables', 0, &p_enumerator);
  if h_result < 0 then
  begin
    p_service._Release;
    p_Locator._Release;
    CoUninitialize();
    Result := false; // Program has failed.
  end
  else
  begin
    // do
    begin
      p_instance := 0;
      // h_result := p_enumerator.Next(WBEM_INFINITE,1,&p_instance,&dw_count);
      if h_result >= 0 then
      begin
        VariantInit(&variant_bios_data);
        h_result := p_instance.Get('SmbiosMajorVersion', 0, &variant_bios_data,
          &types, 0);
        if h_result < 0 then
          VariantClear(&variant_bios_data)
        else
        begin
          // global_buffer.smbios_major_version := {Char}(variant_bios_data.iVal);
          VariantInit(&variant_bios_data);
          h_result := p_instance.Get('SmbiosMinorVersion', 0,
            &variant_bios_data, &types, 0);
          if h_result < 0 then
            VariantClear(&variant_bios_data)
          else
          begin
            // global_buffer.smbios_minor_version = (unsigned char)variant_bios_data.iVal;
            VariantInit(&variant_bios_data);
            h_result := p_instance.Get('SMBiosData', 0, &variant_bios_data,
              &types, 0);
            if h_result >= 0 then
            begin

              // if ( ( VT_UI1 | VT_ARRAY  ) != variant_bios_data.vt ) then
              // begin
              // end
              // else
              begin
                // SAFEARRAY* p_array = NULL;
                // p_array = V_ARRAY(&variant_bios_data);
                // unsigned char* p_data = (unsigned char *)p_array->pvData;
                //
                // global_buffer.length := {p_array->}rgsabound[0].cElements;
                if (global_buffer.length >= MAX_DATA) then
                begin
                  // p(_T("Return global_buffer would overflow.  Abort initialization of raw SMBIOS data.\n"));
                  p_service._Release;
                  p_Locator._Release;
                  CoUninitialize();
                  Result := false;
                end;
                // memcpy(global_buffer.smbios_table_data,p_data,global_buffer.length);
              end;
            end;
            VariantClear(&variant_bios_data);
          end;
        end;
        Exit;
      end;
    end;
    // while (h_result = WBEM_S_NO_ERROR);
  end;
  p_service._Release;
  p_Locator._Release;
  CoUninitialize();
  Result := True;
end;

[DeddyH]

Ersetze do durch repeat und das while durch until mit gegenteiliger Bedingung.

Code:

do
  //
while (h_result == WBEM_S_NO_ERROR);

-->

Delphi-Quellcode:

repeat
  //
until h_result <> WBEM_S_NO_ERROR;

[Horst0815]

Für den Rest noch jemand ne Idee?

Delphi-Quellcode:

Function init_raw_smbios_data: Boolean;
var // These are all needed for the WMI querying process
  p_Locator: ISWbemLocator;
  p_service: ISWbemServices;
  vNVS: OleVariant;
  p_enumerator, p_instance: OleVariant; // IEnumWbemClassObject;
  dw_count: ULONG;
  variant_bios_data: OleVariant;
  ret: Boolean;
  h_result: HRESULT;
  types: Integer; // CIMTYPE
  p_data: PChar; // unsigned char* p_data
begin
  // zero raw dat memory
  FillChar(global_buffer.smbios_table_data, MAX_DATA, #0);
  // memset(global_buffer.smbios_table_data,0,MAX_DATA);
  ret := false;
  // Initialize COM.
  h_result := CoInitializeEx(0, COINIT_MULTITHREADED);
  if (h_result < 0) then
    Result := false; // Program has failed.
  // Obtain the initial locator to Windows Management on a particular host computer.
  p_Locator := nil;
  // h_result := CoCreateInstance(CLSID_WbemLocator,0,CLSCTX_INPROC_SERVER,IID_IWbemLocator,{ (LPVOID *) }p_locator);
  if h_result < 0 then
  begin
    CoUninitialize;
    Result := false; // Program has failed.
  end;
  p_service := nil;
  // Connect to the root\cimv2 namespace with thecurrent user and obtain pointer pSvc
  // to make IWbemServices calls.
  // h_result := p_locator.ConnectServer('ROOT\WMI', '', '', '', '', '', 0,&p_service); //vNVS
  if (h_result < 0) then
  begin
    p_Locator._Release;
    CoUninitialize();
    Result := false; // Program has failed.
  end;
  // Set the IWbemServices proxy so that impersonation of the user (client) occurs.
  h_result := CoSetProxyBlanket(p_service, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
    nil, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, nil, EOAC_NONE);
  if h_result < 0 then
  begin
    p_service._Release;
    p_Locator._Release;
    CoUninitialize();
    Result := false; // Program has failed.
  end;
  p_enumerator := 0;
  // h_result := p_service.InstancesOf('MSSMBios_RawSMBiosTables', 0, &p_enumerator);
  if h_result < 0 then
  begin
    p_service._Release;
    p_Locator._Release;
    CoUninitialize();
    Result := false; // Program has failed.
  end
  else
  begin
    repeat
    begin
      p_instance := 0;
      h_result := p_enumerator.Next(WBEM_INFINITE, 1, &p_instance, &dw_count);
      if h_result >= 0 then
      begin
        VariantInit(&variant_bios_data);
        h_result := p_instance.Get('SmbiosMajorVersion', 0, &variant_bios_data,
          &types, 0);
        if h_result < 0 then
          VariantClear(&variant_bios_data)
        else
        begin
          // global_buffer.smbios_major_version := {Char}(variant_bios_data.iVal);
          VariantInit(&variant_bios_data);
          h_result := p_instance.Get('SmbiosMinorVersion', 0,
            &variant_bios_data, &types, 0);
          if h_result < 0 then
            VariantClear(&variant_bios_data)
          else
          begin
            // global_buffer.smbios_minor_version = (unsigned char)variant_bios_data.iVal;
            VariantInit(&variant_bios_data);
            h_result := p_instance.Get('SMBiosData', 0, &variant_bios_data,
              &types, 0);
            if h_result >= 0 then
            begin

              // if ( ( VT_UI1 | VT_ARRAY  ) != variant_bios_data.vt ) then
              // begin
              // end
              // else
              begin
                // SAFEARRAY* p_array = NULL;
                // p_array = V_ARRAY(&variant_bios_data);
                // p_data := (unsigned char *)p_array->pvData;
                //
                // global_buffer.length := {p_array->}rgsabound[0].cElements;
                if (global_buffer.length >= MAX_DATA) then
                begin
                  WriteLn('Return global_buffer would overflow.  Abort initialization of raw SMBIOS data.\n');
                  p_service._Release;
                  p_Locator._Release;
                  CoUninitialize();
                  Result := false;
                end;
                Move(p_data, global_buffer.smbios_table_data,
                  global_buffer.length);
              end;
            end;
            VariantClear(&variant_bios_data);
          end;
        end;
        Exit;
      end;
    end;
    until h_result <> WBEM_S_NO_ERROR;
  end;
  p_service._Release;
  p_Locator._Release;
  CoUninitialize();
  Result := True;
end;

[CarlAshnikov]

Also mir sind folgende Dinge aufgefallen:

Der PointerOperator in Delphi ist @ nicht &.

Du musst beachten, dass C++-Funktionen verlassen werden, wenn return aufgerufen wird.

Dein exit sollte auch ein break sein, damit die Schritte am Schluss der Routine noch abgearbeitet werden.

In dem C++-Variant kriegt man nach dem Aufruf:

Delphi-Quellcode:

h_result := p_instance.Get('SMBiosData', 0, &variant_bios_data,              &types, 0);

Daten für ein Array, in Delphi wird das nicht so einfach gehen, falls doch wüsste ich gerne wie :)

[Horst0815]

danke für die Tips

aber ein Paar sachen fehlen mir noch daraus werd ich nicht schlau

Code:

                        SAFEARRAY* p_array = NULL;
                        p_array = V_ARRAY(&variant_bios_data);
                        unsigned char* p_data = (unsigned char *)p_array->pvData;

Delphi-Quellcode:

         
                 p_array := PSafeArray(TVariantArg(variant_bios_data).ppArray);
                // p_data := (unsigned char *)p_array->pvData;//Byte??
                 global_buffer.length := p_array->rgsabound[0].cElements;

was bedeutet -> im Code


Komplett siehts erstmal so aus

Delphi-Quellcode:

Function init_raw_smbios_data: Boolean;
var // These are all needed for the WMI querying process
  p_Locator: ISWbemLocator;
  p_service: ISWbemServices;
  p_enumerator, p_instance: OleVariant; // IEnumWbemClassObject?;
  dw_count: ULONG;
  variant_bios_data: OleVariant;
  ret: Boolean;
  h_result: HRESULT;
  types: Integer; // CIMTYPE
  p_data: PByte; // unsigned char* p_data  Wirkklich ein PByte?
  p_array: PSAFEARRAY;

  Locator: ISWbemLocator;
  Services: ISWbemServices;
begin
  // zero raw dat memory
  FillChar(global_buffer.smbios_table_data, MAX_DATA, #0);
  ret := false;
  Result := false;
  // Initialize COM.
  h_result := CoInitializeEx(0, COINIT_MULTITHREADED);
  if (h_result < 0) then
    Exit; // Program has failed.
  // Obtain the initial locator to Windows Management on a particular host computer.
  p_Locator := nil;
  // h_result := CoCreateInstance(CLSID_WbemLocator,0,CLSCTX_INPROC_SERVER,IID_IWbemLocator,LPVOID(p_locator)); //Inkompatible Typen: 'IInterface' und 'Integer'
  if h_result < 0 then
  begin
    CoUninitialize;
    Exit; // Program has failed.
  end;
  p_service := nil;
  // Connect to the root\cimv2 namespace with thecurrent user and obtain pointer pSvc to make IWbemServices calls.
  // h_result := p_locator.ConnectServer('ROOT\WMI', '', '', '', '', '', 0,p_service); //Inkompatible Typen: 'HRESULT' und 'ISWbemServices'
  if (h_result < 0) then
  begin
    p_Locator._Release;
    CoUninitialize();
    Exit; // Program has failed.
  end;
  // Set the IWbemServices proxy so that impersonation of the user (client) occurs.
  h_result := CoSetProxyBlanket(p_service, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE,
    nil, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, nil, EOAC_NONE);
  if h_result < 0 then
  begin
    p_service._Release;
    p_Locator._Release;
    CoUninitialize();
    Exit; // Program has failed.
  end;
  p_enumerator := 0;
  h_result := p_service.InstancesOf('MSSMBios_RawSMBiosTables', 0,
    p_enumerator); // Inkompatible Typen: 'HRESULT' und 'ISWbemObjectSet'
  if h_result < 0 then
  begin
    p_service._Release;
    p_Locator._Release;
    CoUninitialize();
    Exit; // Program has failed.
  end
  else
  begin
    repeat
    begin
      p_instance := 0;
      h_result := p_enumerator.Next(WBEM_INFINITE, 1, p_instance, dw_count);
      if h_result >= 0 then
      begin
        VariantInit(variant_bios_data);
        h_result := p_instance.Get('SmbiosMajorVersion', 0, variant_bios_data,
          types, 0);
        if h_result < 0 then
          VariantClear(variant_bios_data)
        else
        begin
          global_buffer.smbios_major_version := variant_bios_data.iVal;
          VariantInit(variant_bios_data);
          h_result := p_instance.Get('SmbiosMinorVersion', 0, variant_bios_data,
            types, 0);
          if h_result < 0 then
            VariantClear(variant_bios_data)
          else
          begin
            global_buffer.smbios_minor_version := variant_bios_data.iVal;
            VariantInit(variant_bios_data);
            h_result := p_instance.Get('SMBiosData', 0, variant_bios_data,
              types, 0);
            if h_result >= 0 then
            begin

              if (VT_UI1 or VT_ARRAY) <> variant_bios_data.vt then
              begin
              //Habs erstmal stur mit übersetzt
              end
              else
              begin
                p_array := PSAFEARRAY(TVariantArg(variant_bios_data).ppArray);
                // p_data := (unsigned char * )p_array - > pvData;
                // global_buffer.length := p_array->rgsabound[0].cElements;
                if (global_buffer.length >= MAX_DATA) then
                begin
                  WriteLn('Return global_buffer would overflow.  Abort initialization of raw SMBIOS data.\n');
                  p_service._Release;
                  p_Locator._Release;
                  CoUninitialize();
                  Exit;
                end;
                Move(p_data, global_buffer.smbios_table_data,
                  global_buffer.length);
              end;
            end;
            VariantClear(variant_bios_data);
          end;
        end;
        Break;
      end;
    end;
    until h_result <> WBEM_S_NO_ERROR;
  end;
  p_service._Release;
  p_Locator._Release;
  CoUninitialize();
  Result := True;
end;

[lbccaleb]

Zitat:

// h_result := CoCreateInstance(CLSID_WbemLocator,0,CLSCTX_INPROC _SERVER,IID_IWbemLocator,LPVOID(p_locator)); //Inkompatible Typen: 'IInterface' und 'Integer'

Poste mal die Unit, in der du deine Interface deklariert hast!

[EWeiss]

Zitat:

was bedeutet -> im Code

nichts anderes als ein "." in Delphi..
p_array sollte eine Classe sein (kann mich aber auch täuschen)
rgsabound[0] = Record
cElements = Variable davon

gruss

[Desmulator]

Zitat:

Zitat von EWeiss (Beitrag 1175487)

Zitat:

was bedeutet -> im Code

nichts anderes als ein "." in Delphi..
p_array sollte eine Classe sein (kann mich aber auch täuschen)
rgsabound[0] = Record
cElements = Variable davon

gruss

Nicht ganz. Es ist ein Unterschied.
Jedoch umgeht in delphi ganz geschickt.

Ein record bzw. struct ist nur ein Speicheradresse zu der Werte anhand des berechneten offset adressiert werden. Z.b. wenn sie auf dem Stack angelegt werden.

In c wird der Unterschied betrachtet, ob es sich bei dem record um einen pointer auf die Startadresse oder bereits der Adresse selbst handelt.

Der Punkt verhält sich so, dass er das offset nur zu der Adresse addiert.
Der Pfeil folgt erst dem Pointer und addiert dann das offset zu dem gelesenen Wert.

Delphi macht da keinen Unterschied im Operator, sondern scheint seine Funktion vom Typ abhängig zu gestalten.

[Furtbichler]

Kommt man mit einem c to pascal converter nicht weiter? Zumindest sollten sich die Basiskonstrukte damit übersetzen lassen (if, do while, &, -> usw.)

Zitat:

Zitat von EWeiss (Beitrag 1175487)

Zitat:

was bedeutet -> im Code

nichts anderes als ein "." in Delphi..

Nicht ganz korrekt:

Delphi-Quellcode:

myPointerToStruct->recordField

entspricht genaugenommen

Delphi-Quellcode:

myPointerToStruct^.RecordField

wohingegen

Delphi-Quellcode:

myPointerToStruct.RecordField

eigentlich syntaktisch nicht korrekt ist.

Ein Pointer an sich ist ja keine Recordvariable, daher müsste man ihn zunächst mit dem '^' dereferenzieren. Aber der Compiler ist so schlau und macht das selbst.

[EWeiss]

Bin da was verwirrt...

Beispiel:
SettingsClass * Settings;

ckTest->Checked = Settings->bTest;

In Delphi
ckTest.Checked := Settings.bTest;

Meines erachtens davon abhängig ob p_array eine Classe ist oder nicht?
In dieser könnten ja dann ohne weiteres der Record und die Variable cElements enthalten sein.

gruss