C / C++ / MFC

//**************************************************************************
//
// Description:
// Call EnableStatic method of Win32_NetworkAdapterConfiguration
//
// Note:
// The index property of the network adapter instance should be 
// changed depending
// on your target system. Usually on NT4 systems the index of
// the ethernet
// adapter is 1 and on a win2k system the index is 0.
// The EnableStatic method is not supported on Win9x platforms
//
**************************************************************************

#define POLARITY
#define _WIN32_DCOM

#include 
#include 
using namespace std;
#include 
#include 
#include 
#include 
#include 
#include 

#include 

//int main(int iArgCnt, char ** argv)
int WMIEnableStatic()
{
IWbemLocator *pLocator = NULL;
IWbemServices *pNamespace = 0;
IWbemClassObject * pClass = NULL;
IWbemClassObject * pOutInst = NULL;
IWbemClassObject * pInClass = NULL;
IWbemClassObject * pInInst = NULL;

BSTR path = SysAllocString(L"root\\cimv2");
BSTR ClassPath = SysAllocString(L"Win32_NetWorkAdapterConfiguration");
BSTR InstancePath =
SysAllocString(L"Win32_NetWorkAdapterConfiguration.Index='1'");
BSTR MethodName = SysAllocString(L"EnableStatic");
BSTR ArgName1 = SysAllocString(L"IPAddress");
BSTR ArgName2 = SysAllocString(L"SubNetMask");

// Initialize COM and connect up to CIMOM

HRESULT hr = CoInitializeEx(0, COINIT_MULTITHREADED); 

hr = CoInitializeSecurity(NULL, -1, NULL, NULL,
RPC_C_AUTHN_LEVEL_CONNECT, 
RPC_C_IMP_LEVEL_IMPERSONATE, 
NULL, EOAC_NONE, 0
);

hr = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER,
IID_IWbemLocator, (LPVOID *) &pLocator);

hr = pLocator->ConnectServer(path, NULL, NULL, NULL, 0, NULL, NULL,
&pNamespace);

if(hr != WBEM_S_NO_ERROR)
return 1;

cout << "Connected to WMI" << endl;

// Set the proxy so that impersonation of the client occurs.
hr = CoSetProxyBlanket(pNamespace,
RPC_C_AUTHN_WINNT,
RPC_C_AUTHZ_NONE,
NULL,
RPC_C_AUTHN_LEVEL_CALL,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL,
EOAC_NONE
);


// Get the class object

hr = pNamespace->GetObject(ClassPath, 0, NULL, &pClass, NULL);
if(hr != WBEM_S_NO_ERROR)
return 1;


// Get the input argument and set the property

hr = pClass->GetMethod(MethodName, 0, &pInClass, NULL); 
if(hr != WBEM_S_NO_ERROR)
return 1;

hr = pInClass->SpawnInstance(0, &pInInst);
if(hr != WBEM_S_NO_ERROR)
return 1;


BSTR ip;
ip = SysAllocString(L"10.0.0.3");

BSTR mask;
mask = SysAllocString(L"255.255.255.0");

long index[]={0};

SAFEARRAY *ip_list;
ip_list = SafeArrayCreateVector(VT_BSTR,0,1);
SafeArrayPutElement(ip_list,index,ip);

SAFEARRAY *mask_list;
mask_list = SafeArrayCreateVector(VT_BSTR,0,1);
SafeArrayPutElement(mask_list,index,mask);

VARIANT arg1;
arg1.vt = VT_ARRAY|VT_BSTR;
arg1.parray = ip_list;
hr = pInInst->Put(ArgName1, 0, &arg1, 0);

VARIANT arg2;
arg2.vt = VT_ARRAY|VT_BSTR;;
arg2.parray = mask_list;
hr = pInInst->Put(ArgName2, 0, &arg2, 0);

// Call the method

hr = pNamespace->ExecMethod(InstancePath, MethodName, 0, NULL, pInInst,
&pOutInst, NULL);
if(hr != WBEM_S_NO_ERROR){
cout << "ExecMethod failed " << hr;
return 1;
}

// Get the EnableStatic method return value 

VARIANT ret_value;
BSTR strReturnValue = SysAllocString(L"ReturnValue");
hr = pOutInst->Get(strReturnValue, 0, &ret_value, 0, 0);
long ret = V_I4(&ret_value);
if(ret != 0) {
cout << "EnableStatic failed with return code = " << ret;
}else{
cout << "EnableStatic succeeded" << endl;
}

// Free up resources

SysFreeString(strReturnValue);
VariantClear(&ret_value);
SysFreeString(ip);
SysFreeString(mask);
SafeArrayDestroy(ip_list);
SafeArrayDestroy(mask_list);
VariantClear(&arg1);
VariantClear(&arg2);

SysFreeString(path);
SysFreeString(ClassPath);
SysFreeString(InstancePath);
SysFreeString(MethodName);
SysFreeString(ArgName1);
SysFreeString(ArgName2);

pClass->Release();
pInInst->Release();
pInClass->Release();
pOutInst->Release();
pLocator->Release();
pNamespace->Release();
CoUninitialize();
return 0;
}

toxcct wrote:

the function A::f() inherited mush be implemented

odesh wrote:

error C2660: 'B::f()' : function does not take 2 arguments

class B : public A
{
    virtual void f(int a)
    {
        A::f(a, 1);
    }
};

toxcct wrote:

A::f() is virtual, so, not implemented...

Cedric Moonen wrote:

You can perfectly have a virtual function that is implemented in the base class

odesh wrote:

can anyway shed some light ?

<code>
// Get the contents of the file
 //file handle
 HANDLE hFile;
 //something to contain the number of bytes read
 DWORD dwNumRead;
 //a boolean test variable, to test for success of reads
 BOOL bTest;
 //a buffer… can actually be of any type
 char dwBuffer[256];

 // Opening an existing file for reading:
 hFile = CreateFile("File1.txt", GENERIC_READ, FILE_SHARE_READ,NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 // To read from the file:
 bTest= ReadFile(hFile, dwBuffer, sizeof(char)*256, &dwNumRead,NULL);
 char seps[]   = "\n\r";
 char *token;
 char *Lines[10];
 for (int i=0;i<10;i++)
 {
	Lines[i] = NULL;
 }
 /* Establish string and get the first token: */
 token = strtok( dwBuffer, seps );
 int x = 0;
 while( token != NULL )
 {
	/* While there are tokens in "string" */
	Lines[x] = token;
	/* Get next token: */
	token = strtok( NULL, seps );
	x++;
 }
</code>

The only programmers that are better than C programmers are those who code in 1's and 0's.....

Programm3r

« Programm3r » wrote:

The only programmers that are better than C programmers