C++ 通过WMI接口设置/获取网卡信息（DHCP、IP、MASK、GW）

最新推荐文章于 2024-04-15 14:08:13 发布
最新推荐文章于 2024-04-15 14:08:13 发布
阅读量1k 收藏 1
点赞数
分类专栏： C/C++ 文章标签： c++ tcp/ip 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulilittle/article/details/130437190
版权 
#include <iostream>
#include <vector>
#include <locale>
#include <codecvt>

#include <comdef.h>
#include <comutil.h>
#include <Wbemidl.h>

#pragma comment(lib, "wbemuuid.lib")

using namespace std;

typedef struct
{
	std::string					Driver;				// 驱动
	std::string					Guid;				// GUID
	std::string					MacAddress;			// MAC地址
	int							Index;				// 索引
	int							InterfaceIndex;		// 网卡索引
	std::vector<std::string>	IPSubnet;	        // 子网	
	std::vector<std::string>	DnsAddresses;		// DNS服务器
	std::vector<std::string>	IPAddresses;		// IP地址
	std::vector<std::string>	DefaultIPGateway;	// 默认网关服务器
	bool						DhcpEnabled;		// 启用DHCP
	int							Metric;				// 跃点
	bool						IPEnabled;			// IP启用
	std::string					ConnectionId;		// 链接ID
	std::string					ScopeId;			// 域ID
	std::string					Caption;			// 标题
	std::string					Description;		// 描述信息
} NetworkInterface;

typedef std::shared_ptr<NetworkInterface> NetworkInterfacePtr;

struct SYSTEM_WINDOWS_COM_INITIALIZED
{
	SYSTEM_WINDOWS_COM_INITIALIZED()
	{
		char messages[1000];
		HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
		if (FAILED(hr))
		{
			sprintf(messages, "Failed to initialize COM library. Error code = 0x%08x", hr);
			throw std::runtime_error(messages);
		}

		hr = CoInitializeSecurity(
			NULL,
			-1,
			NULL,
			NULL,
			RPC_C_AUTHN_LEVEL_DEFAULT,
			RPC_C_IMP_LEVEL_IMPERSONATE,
			NULL,
			EOAC_NONE,
			NULL);
		if (FAILED(hr))
		{
			sprintf(messages, "Failed to initialize security. Error code = 0x%08x", hr);
			throw std::runtime_error(messages);
		}
	}
	~SYSTEM_WINDOWS_COM_INITIALIZED() noexcept
	{
		CoUninitialize();
	}
};

static std::string VARIANT_string(BSTR& bstrVal)
{
	std::string result;
	LPSTR str = _com_util::ConvertBSTRToString(bstrVal);
	if (NULL != str)
	{
		result = str;
		delete[] str;
	}

	SysFreeString(bstrVal);
	return result;
}

static std::string VARIANT_string(VARIANT& vt) noexcept
{
	std::string result;
	if (vt.vt & VT_BSTR)
	{
		result = VARIANT_string(vt.bstrVal);
	}

	if (vt.vt != VT_EMPTY)
	{
		VariantClear(&vt);
	}

	return std::move(result);
}

static std::string VARIANT_string(IWbemClassObject* obj, LPCWSTR name) noexcept
{
	VARIANT vt;
	VariantInit(&vt);

	HRESULT hr = obj->Get(name, 0, &vt, 0, 0);
	if (SUCCEEDED(hr))
	{
		std::string result = VARIANT_string(vt);
		VariantClear(&vt);
		return std::move(result);
	}
	else
	{
		VariantClear(&vt);
		return std::string();
	}
}

template<typename T>
static T VARIANT_value(VARIANT& vt, T defaultValue) noexcept
{
	if (vt.vt == VT_I1)
	{
		return vt.cVal;
	}

	if (vt.vt == VT_I2)
	{
		return vt.iVal;
	}

	if (vt.vt == VT_I4)
	{
		return vt.intVal;
	}

	if (vt.vt == VT_I8)
	{
		return vt.llVal;
	}

	if (vt.vt == VT_UI1)
	{
		return vt.bVal;
	}

	if (vt.vt == VT_UI2)
	{
		return vt.uiVal;
	}

	if (vt.vt == VT_UI4)
	{
		return vt.uintVal;
	}

	if (vt.vt == VT_UI8)
	{
		return vt.ullVal;
	}

	if (vt.vt == VT_BOOL)
	{
		return vt.boolVal != VARIANT_FALSE ? 1 : 0;
	}

	if (vt.vt == VT_R4)
	{
		return vt.fltVal;
	}

	if (vt.vt == VT_R8)
	{
		return vt.dblVal;
	}

	if (vt.vt == VT_PTR)
	{
		return (int64_t)vt.punkVal;
	}

	if (vt.vt == VT_INT_PTR)
	{
		return vt.intVal;
	}

	if (vt.vt == VT_INT_PTR)
	{
		return vt.uintVal;
	}

	return defaultValue;
}

template<typename T>
T VARIANT_value(IWbemClassObject* obj, LPCWSTR name, T defaultValue) noexcept
{
	VARIANT vt;
	VariantInit(&vt);

	HRESULT hr = obj->Get(name, 0, &vt, 0, 0);
	if (SUCCEEDED(hr))
	{
		T result = VARIANT_value<T>(vt, defaultValue);
		VariantClear(&vt);
		return result;
	}
	else
	{
		VariantClear(&vt);
		return defaultValue;
	}
}

template<>
bool VARIANT_value<bool>(IWbemClassObject* obj, LPCWSTR name, bool defaultValue) noexcept
{
	int intValue = VARIANT_value<int>(obj, name, 0);
	return intValue != 0;
}

static bool VARIANT_strings(VARIANT& vt, std::vector<std::string>& strings) noexcept
{
	bool b = false;
	if (vt.vt & VT_ARRAY) /* SafeArrayDestroy */
	{
		SAFEARRAY* parray = vt.parray;
		if (vt.vt & VT_BSTR)
		{
			LONG lBound = 0;
			LONG uBound = 0;

			SafeArrayGetLBound(parray, 1, &lBound);
			SafeArrayGetUBound(parray, 1, &uBound);

			for (LONG i = lBound; i <= uBound; i++)
			{
				BSTR bstrIP;
				HRESULT hr = SafeArrayGetElement(parray, &i, &bstrIP);
				if (SUCCEEDED(hr))
				{
					std::string str = VARIANT_string(bstrIP);
					if (!str.empty())
					{
						b |= true;
						strings.push_back(str);
					}
				}
			}
		}
	}

	VariantClear(&vt);
	return b;
}

static bool VARIANT_strings(IWbemClassObject* obj, LPCWSTR name, std::vector<std::string>& strings) noexcept
{
	VARIANT vt;
	VariantInit(&vt);

	HRESULT hr = obj->Get(name, 0, &vt, 0, 0);
	if (SUCCEEDED(hr))
	{
		bool b = VARIANT_strings(vt, strings);
		VariantClear(&vt);
		return b;
	}

	VariantClear(&vt);
	return false;
}

static bool GetAllNetworkInterfacesInternal(std::vector<NetworkInterfacePtr>& interfaces) noexcept
{
	// 创建WMI服务
	IWbemLocator* pLoc = NULL;
	HRESULT hr = CoCreateInstance(
		CLSID_WbemLocator,
		0,
		CLSCTX_INPROC_SERVER,
		IID_IWbemLocator,
		(LPVOID*)&pLoc);
	if (FAILED(hr))
	{
		return false;
	}

	IWbemServices* pSvc = NULL;
	hr = pLoc->ConnectServer(
		_bstr_t(L"ROOT\\CIMV2"),
		NULL,
		NULL,
		0,
		NULL,
		0,
		0,
		&pSvc);
	if (FAILED(hr))
	{
		pLoc->Release();
		return false;
	}

	// 设置WMI服务安全级别
	hr = CoSetProxyBlanket(
		pSvc,
		RPC_C_AUTHN_WINNT,
		RPC_C_AUTHZ_NONE,
		NULL,
		RPC_C_AUTHN_LEVEL_CALL,
		RPC_C_IMP_LEVEL_IMPERSONATE,
		NULL,
		EOAC_NONE);
	if (FAILED(hr))
	{
		pSvc->Release();
		pLoc->Release();
		return false;
	}

	// 查询网卡信息
	IEnumWbemClassObject* pEnumerator = NULL;
	hr = pSvc->ExecQuery(
		_bstr_t(L"WQL"),
		_bstr_t(L"SELECT * FROM Win32_NetworkAdapterConfiguration"), /*  WHERE IPEnabled = TRUE */
		WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
		NULL,
		&pEnumerator);
	if (FAILED(hr))
	{
		pSvc->Release();
		pLoc->Release();
		return false;
	}

	// 遍历网卡信息
	bool ok = false;
	while (pEnumerator)
	{
		IWbemClassObject* pclsObj = NULL;
		ULONG uReturn = 0;
		hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
		if (FAILED(hr) || 0 == uReturn)
		{
			break;
		}
		else
		{
			NetworkInterfacePtr networkInterface = std::make_shared<NetworkInterface>();
			networkInterface->Description = VARIANT_string(pclsObj, L"Description");
			networkInterface->Driver = VARIANT_string(pclsObj, L"ServiceName");
			networkInterface->Guid = VARIANT_string(pclsObj, L"SettingID");
			networkInterface->Index = VARIANT_value(pclsObj, L"Index", -1);
			networkInterface->InterfaceIndex = VARIANT_value(pclsObj, L"InterfaceIndex", -1);
			networkInterface->Metric = VARIANT_value(pclsObj, L"IPConnectionMetric", -1);
			networkInterface->MacAddress = VARIANT_string(pclsObj, L"MacAddress");
			networkInterface->IPEnabled = VARIANT_value(pclsObj, L"IPEnabled", false);
			networkInterface->DhcpEnabled = VARIANT_value(pclsObj, L"DhcpEnabled", false);
			networkInterface->Caption = VARIANT_string(pclsObj, L"Caption");
			networkInterface->ScopeId = VARIANT_string(pclsObj, L"WINSScopeID");
			networkInterface->ConnectionId = VARIANT_string(pclsObj, L"NetConnectionID");

			VARIANT_strings(pclsObj, L"IPAddress", networkInterface->IPAddresses);
			VARIANT_strings(pclsObj, L"IPSubnet", networkInterface->IPSubnet);
			VARIANT_strings(pclsObj, L"DefaultIPGateway", networkInterface->DefaultIPGateway);

			ok |= true;
			interfaces.push_back(networkInterface);
		}

		pclsObj->Release();
	}

	// 释放COM对象
	pEnumerator->Release();
	pSvc->Release();
	pLoc->Release();

	return ok;
}

static HRESULT VARIANT_create_safe_array(VARIANT& vt, const std::vector<std::string>& list) noexcept
{
	LONG length = list.size();
	if (length < 0)
	{
		length = 0;
	}

	SAFEARRAY* sa = SafeArrayCreateVector(VT_BSTR, 0, length);
	vt.vt = VT_ARRAY | VT_BSTR;
	vt.parray = sa;

	HRESULT hr = ERROR_SUCCESS;
	for (LONG i = 0; i < length; i++)
	{
		_bstr_t bstr(list[i].data());
		hr = SafeArrayPutElement(sa, &i, bstr.GetBSTR());
		if (FAILED(hr))
		{
			break;
		}
	}
	return hr;
}

template<typename InternalCall>
static bool CoCallFunctionInternal(IWbemServices* services, IWbemClassObject* obj, const _bstr_t& clazz, const _bstr_t& method, InternalCall&& internal_call) noexcept
{
	IWbemClassObject* pClass = NULL;
	IWbemClassObject* pInParamsDefinition = NULL;
	IWbemClassObject* pClassInstance = NULL;
	IWbemClassObject* pOutParams = NULL;

	VARIANT vtPATH;
	VariantInit(&vtPATH);

	VARIANT vtRET;
	VariantInit(&vtRET);

	bool ok = false;
	for (;;)
	{
		HRESULT hr = services->GetObject(clazz, 0, NULL, &pClass, NULL);
		if (FAILED(hr))
		{
			break;
		}

		hr = pClass->GetMethod(method, 0, &pInParamsDefinition, NULL);
		if (FAILED(hr))
		{
			break;
		}

		hr = pInParamsDefinition->SpawnInstance(0, &pClassInstance);
		if (FAILED(hr))
		{
			break;
		}

		hr = internal_call(pClassInstance);
		if (FAILED(hr))
		{
			break;
		}

		hr = obj->Get(L"__PATH", 0, &vtPATH, NULL, NULL);
		if (FAILED(hr))
		{
			break;
		}

		hr = services->ExecMethod(
			vtPATH.bstrVal,
			method, /* BSTR(L"SetDNSServerSearchOrder") */
			0,
			NULL,
			pClassInstance,
			&pOutParams,
			NULL);
		if (FAILED(hr))
		{
			break; /* SUCCEEDED */
		}

		hr = pOutParams->Get(_bstr_t(L"ReturnValue"), 0, &vtRET, NULL, 0);
		if (FAILED(hr))
		{
			break;
		}

		int err = VARIANT_value(vtRET, 0);
		if (err)
		{
			break;
		}

		ok = true;
		break;
	}

	if (vtPATH.vt & VT_BSTR)
	{
		SysFreeString(vtPATH.bstrVal);
	}

	if (pOutParams)
	{
		pOutParams->Release();
	}

	if (pClassInstance)
	{
		pClassInstance->Release();
	}

	if (pInParamsDefinition)
	{
		pInParamsDefinition->Release();
	}

	if (pClass)
	{
		pClass->Release();
	}

	VariantClear(&vtRET);
	VariantClear(&vtPATH);
	return ok;
}

// https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/setdnsserversearchorder-method-in-class-win32-networkadapterconfiguration
// https://learn.microsoft.com/zh-cn/windows/win32/wmisdk/example--calling-a-provider-method?source=recommendations
static bool SetNetifAddressesInternal(IWbemServices* services, IWbemClassObject* obj, const _bstr_t& method, LPCWSTR parameter, const std::vector<std::string>& addresses) noexcept
{
	const _bstr_t Win32_NetworkAdapterConfiguration(L"Win32_NetworkAdapterConfiguration");

	return CoCallFunctionInternal(services, obj, Win32_NetworkAdapterConfiguration, method,
		[&addresses, parameter](IWbemClassObject* pClassInstance) noexcept
		{
			VARIANT vt;
			VariantInit(&vt);

			HRESULT hr = VARIANT_create_safe_array(vt, addresses);
			if (SUCCEEDED(hr))
			{
				hr = pClassInstance->Put(parameter, 0, &vt, 0);
			}

			VariantClear(&vt);
			return hr;
		});
}

static bool SetDnsAddressesInternal(IWbemServices* services, IWbemClassObject* obj, const std::vector<std::string>& servers) noexcept
{
	const _bstr_t SetDNSServerSearchOrder(L"SetDNSServerSearchOrder");

	return SetNetifAddressesInternal(services, obj, SetDNSServerSearchOrder, L"DNSServerSearchOrder", servers);
}

template<typename InternalCall>
static bool SetNetifAddressesInternal(int interface_index, InternalCall&& internal_call) noexcept
{
	// 创建WMI服务
	IWbemLocator* pLoc = NULL;
	HRESULT hr = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID*)&pLoc);
	if (FAILED(hr))
	{
		return false;
	}

	IWbemServices* pSvc = NULL;
	hr = pLoc->ConnectServer(_bstr_t(L"ROOT\\CIMV2"), NULL, NULL, 0, NULL, 0, 0, &pSvc);
	if (FAILED(hr))
	{
		pLoc->Release();
		return false;
	}

	// 设置WMI服务安全级别
	hr = CoSetProxyBlanket(pSvc, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE);
	if (FAILED(hr))
	{
		pSvc->Release();
		pLoc->Release();
		return false;
	}

	WCHAR wsql[256];
	if (_snwprintf(wsql, sizeof(wsql), L"SELECT * FROM Win32_NetworkAdapterConfiguration WHERE InterfaceIndex = '%d'", interface_index) < 1)
	{
		pSvc->Release();
		pLoc->Release();
		return false;
	}

	// 查询网卡信息
	IEnumWbemClassObject* pEnumerator = NULL;
	hr = pSvc->ExecQuery(
		_bstr_t(L"WQL"),
		_bstr_t(wsql),
		WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
		NULL,
		&pEnumerator);
	if (FAILED(hr))
	{
		pSvc->Release();
		pLoc->Release();
		return false;
	}

	// 遍历网卡信息
	bool ok = false;
	while (pEnumerator)
	{
		IWbemClassObject* pclsObj = NULL;
		ULONG uReturn = 0;
		hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
		if (FAILED(hr) || 0 == uReturn)
		{
			break;
		}

		ok |= internal_call(pSvc, pclsObj);
		pclsObj->Release();
		break;
	}

	pEnumerator->Release();
	pSvc->Release();
	pLoc->Release();

	return ok;
}

static bool SetNetifIPAddressInternal(IWbemServices* services, IWbemClassObject* obj, const std::vector<std::string>& ips, const std::vector<std::string>& masks) noexcept
{
	const _bstr_t Win32_NetworkAdapterConfiguration(L"Win32_NetworkAdapterConfiguration");
	const _bstr_t EnableStatic(L"EnableStatic");

	return CoCallFunctionInternal(services, obj, Win32_NetworkAdapterConfiguration, EnableStatic,
		[&ips, &masks](IWbemClassObject* pClassInstance) noexcept
		{
			VARIANT vtIPAddress;
			VARIANT vtSubnetMask;

			VariantInit(&vtIPAddress);
			VariantInit(&vtSubnetMask);

			HRESULT hr = VARIANT_create_safe_array(vtIPAddress, ips);
			if (SUCCEEDED(hr))
			{
				hr = pClassInstance->Put(L"IPAddress", 0, &vtIPAddress, 0);
				if (SUCCEEDED(hr))
				{
					hr = VARIANT_create_safe_array(vtSubnetMask, masks);
					if (SUCCEEDED(hr))
					{
						hr = pClassInstance->Put(L"SubnetMask", 0, &vtSubnetMask, 0);
					}
				}
			}

			VariantClear(&vtIPAddress);
			VariantClear(&vtSubnetMask);
			return hr;
		});
	return false;
}

static bool SetDefaultIPGatewayInternal(IWbemServices* services, IWbemClassObject* obj, const std::vector<std::string>& gateways) noexcept
{
	const _bstr_t SetGateways(L"SetGateways");

	return SetNetifAddressesInternal(services, obj, SetGateways, L"DefaultIPGateway", gateways);
}

static bool DhcpEnabledInternal(IWbemServices* services, IWbemClassObject* obj) noexcept
{
	const _bstr_t Win32_NetworkAdapterConfiguration(L"Win32_NetworkAdapterConfiguration");
	const _bstr_t EnableDHCP(L"EnableDHCP");

	VARIANT vtDHCPEnabled;
	VariantInit(&vtDHCPEnabled);

	VARIANT vtPATH;
	VariantInit(&vtPATH);

	vtDHCPEnabled.vt = VT_BOOL;
	vtDHCPEnabled.boolVal = VARIANT_TRUE;

	HRESULT hr = obj->Put(L"DHCPEnabled", 0, &vtDHCPEnabled, 0);
	if (SUCCEEDED(hr))
	{
		hr = obj->Get(L"__PATH", 0, &vtPATH, NULL, NULL);
		if (SUCCEEDED(hr))
		{
			hr = services->ExecMethod(vtPATH.bstrVal, EnableDHCP, 0, NULL, obj, NULL, NULL);
		}
	}

	if (vtPATH.vt & VT_BSTR)
	{
		SysFreeString(vtPATH.bstrVal);
	}

	VariantClear(&vtPATH);
	VariantClear(&vtDHCPEnabled);
	return SUCCEEDED(hr);
}

bool GetAllNetworkInterfaces(std::vector<NetworkInterfacePtr>& interfaces) noexcept
{
	SYSTEM_WINDOWS_COM_INITIALIZED WINDOWS_COM_INITIALIZED;
	return GetAllNetworkInterfacesInternal(interfaces);
}

bool SetDnsAddresses(int interface_index, const std::vector<std::string>& servers) noexcept
{
	SYSTEM_WINDOWS_COM_INITIALIZED WINDOWS_COM_INITIALIZED;
	return SetNetifAddressesInternal(interface_index,
		[&servers](IWbemServices* pSvc, IWbemClassObject* pclsObj) noexcept
		{
			return SetDnsAddressesInternal(pSvc, pclsObj, servers);
		});
}

bool SetDefaultIPGateway(int interface_index, const std::vector<std::string>& servers) noexcept
{
	SYSTEM_WINDOWS_COM_INITIALIZED WINDOWS_COM_INITIALIZED;
	return SetNetifAddressesInternal(interface_index,
		[&servers](IWbemServices* pSvc, IWbemClassObject* pclsObj) noexcept
		{
			return SetDefaultIPGatewayInternal(pSvc, pclsObj, servers);
		});
}

bool SetIPAddresses(int interface_index, const std::vector<std::string>& ips, const std::vector<std::string>& masks) noexcept
{
	SYSTEM_WINDOWS_COM_INITIALIZED WINDOWS_COM_INITIALIZED;
	return SetNetifAddressesInternal(interface_index,
		[&ips, &masks](IWbemServices* pSvc, IWbemClassObject* pclsObj) noexcept
		{
			return SetNetifIPAddressInternal(pSvc, pclsObj, ips, masks);
		});
}

bool DhcpEnabled(int interface_index) noexcept
{
	SYSTEM_WINDOWS_COM_INITIALIZED WINDOWS_COM_INITIALIZED;
	return SetNetifAddressesInternal(interface_index,
		[](IWbemServices* pSvc, IWbemClassObject* pclsObj) noexcept
		{
			return DhcpEnabledInternal(pSvc, pclsObj);
		});
}

int main()
{
	std::vector<NetworkInterfacePtr> interfaces;
	GetAllNetworkInterfaces(interfaces);

	std::vector<std::string> servers = { "1.1.1.1", "8.8.8.8" };
	SetIPAddresses(18, { "10.0.0.2" }, { "255.255.255.0" });
	SetDefaultIPGateway(18, { "10.0.0.1" });
	SetDnsAddresses(18, servers);
	DhcpEnabled(18);
	return 0;
}

liulilittle
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WMI设置网卡及获取网卡信息
03-04
根据网络提供的资料,专门写出NetAdapter类,实现本地连接网卡信息的收集及设置.所下载的资料是一个MFC测试项目,在VS2010中调试通过.需要使用时,使用NetAdapter类即可.
利用WMI 获取IP信息
05-18
利用WMI 获取IP信 using System; using System.Collections.Generic; using System.Text; using System.Management; namespace NetProgram { class WMICardGrab { public static void Main() { //1。 ManagementObjectSearcher query = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPEnabled='TRUE'"); //2。 ManagementObjectCollection queryCollection = query.Get(); foreach (ManagementObject mo in queryCollection) { string[] addresses = (string[])mo["IPAddress"]; string[] subnets = (string[])mo["IPSubnet"]; string[] defaultgateways = (string[])mo["DefaultIPGateway"]; Console.WriteLine("Network Card:{0}", mo["Description"]); Console.WriteLine(" MAC Adress:{0}", mo["MacAddress"]); foreach (string ipaddress in addresses) { Console.WriteLine(" IP Address:{0}", ipaddress); } foreach (string subnet in subnets) { Console.WriteLine(" Subnet Mask:{0}", subnet); } foreach (string defaultgageway in defaultgateways) { Console.WriteLine(" Gateway:{0}", defaultgageway); } } } } }
C#硬件接口开发------一文了解WMI
最新发布
王雪亮
04-15 1130
WMI（Windows Management Instrumentation, Windows管理规范）是Windows 2000/XP管理系统的核心，属于管理数据和操作的基础模块。设计WMI的初衷是达到一种通用性，通过WMI操作系统、应用程序等来管理本地或者远程资源。它支持分布式组件对象模型（DCOM，Distribution Components Object Model）和Windows远程管理（WinRM），用户可通过WMI服务访问、配置、管理和监视Windows所有资源的功能。
一键改ip，mask，gateway，dns
xixaxiia的博客
02-29 418
切换内外网的简便方式，批处理，做个快捷方式发送到桌面，大大的方便。设置自动获取IP的单独命令。
WMI接口设计实现
qq_40569221的博客
03-22 474
WMI是Windows操作系统管理数据和操作的基础设施，系统管理员可以使用VB Script、PowerShell及Windows API（C++、C#等）管理本地或远程计算机。使用WMI框架应用程序可以直接访问EC RAM、 I/O端口、Memory地址、寄存器、Setup NV设定值，以及其他的系统设备资源。
通过WMI获取系统IP
樊立明的专栏-测试轻骑兵
09-27 4705
<br /> <br />通过WMI获取系统IP,这对在多系统下运行自动化测试,自动产生测试结果报告是很有用处的!同时WMI中还有很多可以用的方法!<br /> <br />以下是获取系统IP的Vbscript代码,将下面代码复制,粘贴在QTP中运行,或者粘贴到自建一个空的VBS文件,双击!<br /> <br />'获取系统IP<br />Set objWMIService = GetObject("winmgmts:")<br />Set colNicConfig = objWMIService.Exe
windows比cmd更强大的 WMIC命令使用详解
whl0071的专栏
10-14 5389
windows比cmd更强大的 WMIC命令使用详解
使用getmac命令获取网卡对应的GUID
weixin_34248258的博客
11-16 1046
C:\Users\Godoha>getmac 物理地址 传输名称 =================== ========================================================== F0-7B-CB-52-5B-33 \Device\Tcpip_{5865B774-B375-4D1...
WMI在VC中的使用 -- 设置DHCP和DNS
tongzhipeng5699的专栏
08-10 1528
http://hi.baidu.com/vansbluge/item/4f0d94610e9a0d91c4d24934 此基础上加上了Index的获取，适用于多网卡的使用，Win7系统获取可以考虑InterfaceIndex的使用，因为Win32_NetworkAdapterConfiguration的interfaceIndex就是GetAdapterInfo中的Index。未实际尝试。
c语言获取本机mac函数,C++获取本机MAC，IP，MASK地址的方法
weixin_39619893的博客
05-24 641
本文实例讲述了C++获取本机MAC，IP，MASK地址的方法，分享给大家供大家参考。具体方法如下：#include "InitSock.h"#include #include #pragma comment(lib, "IPHLPAPI.lib")u_char g_ucLocalMac[6];DWORD g_dwGatewayIP;DWORD g_dwLocalIP;DWORD g_dwMask;...
Delphi 使用WMI读取网卡信息及设置IP地址
08-19
MSDN中指出Netsh命令将在后续的版本中废止，今后对系统信息的操作将倾向于WMI（Windows管理工具）因此把我工作中用到的模块做了相应的改动，并分享给大家。程序中使用了AlphaControls控件，如要编译运行，可到我的...
VBA通过WMI技术获取网卡当前设置的IP地址
02-11
VBA通过WMI技术获取网卡当前设置的IP地址 GetObject("winmgmts:\\" & "." & "\root\cimv2").ExecQuery("Select * from Win32_NetworkAdapterConfiguration")
c++封装好的IP的获取和修改源码，通过NetworkCfg和wmi方式，支持Windows和WinCE系统，使用简单
08-28
c++封装好的IP的获取和修改源码，通过NetworkCfg和wmi方式，支持Windows和WinCE系统，实际测试结果准确，使用简单
python使用WMI检测windows系统信息、硬盘信息、网卡信息的方法
09-22
在Python编程中，有时我们需要获取运行在Windows操作系统上的系统信息，包括硬件如硬盘、内存以及CPU的详细数据，以及网络接口的状态。为了实现这一目标，我们可以利用Python的`wmi`库，它允许我们通过Windows ...
c++ windows wmi修改网卡ip+dns
w123l123h的博客
09-03 3760
c++ windows wmi修改网卡ip+dns 注意事项: 项目必须以管理员权限运行 参考main.cpp使用方法 网卡的key可以从注册表获取, 路径: 计算机\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\ 项目下载地址: https://github.com/w123l...
获取ip wmi正解
ck0074451665的专栏
09-02 746
<br />  try<br />            {<br />                ManagementObjectSearcher query = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPEnabled = 'TRUE'");<br />                ManagementObjectCollection queryCollection =
从WMI获取网络接口IP信息(摘抄)
weixin_34032779的博客
12-18 482
本文摘抄自《C#网络应用编程》 电子工业出版社  [美]Richard Blum著 根据需要做了些小小变动。 PS：WMI的详信息可以看MSDN using  System.Management;   class  WMICardGrab  {       public   static   void  Main()       {         ...
Windows客户端开发--获取系统mac地址(使用WMI)
热门推荐
一蓑烟雨任平生 也无风雨也无晴
11-21 1万+
之前写过两篇博客，介绍了windows的WMI技术，以及如果通过WMI获取显卡详细信息： Windows客户端开发–WMI技术介绍 Windows客户端开发–使用WMI获取显卡详细信息(win32控制台程序)关于获取电脑的mac地址，之前也有相关博客进行了介绍，使用的是QT： qt中查看本机mac/ip地址什么是mac地址？ MAC（Media Access Control或者
用c++ 通过wmi查询网卡的所有信息
05-30
要使用 C++ 通过 WMI 查询网卡的所有信息，您可以使用以下步骤： 1. 引用 WMI 类库。您可以在 Visual Studio 的“项目”菜单中选择“添加引用”，然后选择“System.Management”来添加类库。 2. 初始化 COM 库。您...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值