如何获取当前机器上安装的modem及其占用端口

[白乔]

请问如何获取当前机器上安装的modem及其占用端口，以及连接参数？
我做手机串口通讯
只能一个一个连接试着看：（

[白乔]

你这是注册表读写吧？
不是我需要的吧？

[ksaiy]

给这么多的分啊!
好,给你一个我写软件看看!
http://www.freewebs.com/zf2002/Modem.rar

#include "stdafx.h"
#include "RegistryEx.h"

CRegistryEx::CRegistryEx(HKEY hKeyRoot)
{
m_hKey = hKeyRoot;
}

CRegistryEx::~CRegistryEx()
{
Close();
}


BOOL CRegistryEx::VerifyKey (HKEY hKeyRoot, LPCTSTR pszPath)
{
ASSERT (hKeyRoot);
ASSERT (pszPath);

LONG ReturnValue = RegOpenKeyEx (hKeyRoot, pszPath, 0L,
KEY_ALL_ACCESS, &m_hKey);
if(ReturnValue == ERROR_SUCCESS)
return TRUE;

m_Info.lMessage = ReturnValue;
m_Info.dwSize = 0L;
m_Info.dwType = 0L;

return FALSE;
}

BOOL CRegistryEx::VerifyKey (LPCTSTR pszPath)
{
ASSERT (m_hKey);

LONG ReturnValue = RegOpenKeyEx (m_hKey, pszPath, 0L,
KEY_ALL_ACCESS, &m_hKey);

m_Info.lMessage = ReturnValue;
m_Info.dwSize = 0L;
m_Info.dwType = 0L;

if(ReturnValue == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::VerifyValue (LPCTSTR pszValue)
{
ASSERT(m_hKey);
LONG lReturn = RegQueryValueEx(m_hKey, pszValue, NULL,
NULL, NULL, NULL);

m_Info.lMessage = lReturn;
m_Info.dwSize = 0L;
m_Info.dwType = 0L;

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::CreateKey (HKEY hKeyRoot, LPCTSTR pszPath)
{
DWORD dw;

LONG ReturnValue = RegCreateKeyEx (hKeyRoot, pszPath, 0L, NULL,
REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL,
&m_hKey, &dw);

m_Info.lMessage = ReturnValue;
m_Info.dwSize = 0L;
m_Info.dwType = 0L;

if(ReturnValue == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Open (HKEY hKeyRoot, LPCTSTR pszPath)
{
m_sPath = pszPath;

LONG ReturnValue = RegOpenKeyEx (hKeyRoot, pszPath, 0L,
KEY_ALL_ACCESS, &m_hKey);

m_Info.lMessage = ReturnValue;
m_Info.dwSize = 0L;
m_Info.dwType = 0L;

if(ReturnValue == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

void CRegistryEx::Close()
{
if (m_hKey)
{
RegCloseKey (m_hKey);
m_hKey = NULL;
}
}

BOOL CRegistryEx::Write (LPCTSTR pszKey, int iVal)
{
DWORD dwValue;

ASSERT(m_hKey);
ASSERT(pszKey);

dwValue = (DWORD)iVal;
LONG ReturnValue = RegSetValueEx (m_hKey, pszKey, 0L, REG_DWORD,
(CONST BYTE*) &dwValue, sizeof(DWORD));

m_Info.lMessage = ReturnValue;
m_Info.dwSize = sizeof(DWORD);
m_Info.dwType = REG_DWORD;

if(ReturnValue == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Write (LPCTSTR pszKey, DWORD dwVal)
{
ASSERT(m_hKey);
ASSERT(pszKey);
return RegSetValueEx (m_hKey, pszKey, 0L, REG_DWORD,
(CONST BYTE*) &dwVal, sizeof(DWORD));
}

BOOL CRegistryEx::Write (LPCTSTR pszKey, LPCTSTR pszData)
{
ASSERT(m_hKey);
ASSERT(pszKey);
ASSERT(pszData);
ASSERT(AfxIsValidAddress(pszData, strlen(pszData), FALSE));

LONG ReturnValue = RegSetValueEx (m_hKey, pszKey, 0L, REG_SZ,
(CONST BYTE*) pszData, strlen(pszData) + 1);

m_Info.lMessage = ReturnValue;
m_Info.dwSize = strlen(pszData) + 1;
m_Info.dwType = REG_SZ;

if(ReturnValue == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Write (LPCTSTR pszKey, CStringList& scStringList)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 4096;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

CMemFile file(byData, iMaxChars, 16);
CArchive ar(&file, CArchive::store);
ASSERT(scStringList.IsSerializable());
scStringList.Serialize(ar);
ar.Close();
const DWORD dwLen = file.GetLength();
ASSERT(dwLen < iMaxChars);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
file.Detach(), dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_BINARY;

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Write (LPCTSTR pszKey, CByteArray& bcArray)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 4096;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

CMemFile file(byData, iMaxChars, 16);
CArchive ar(&file, CArchive::store);
ASSERT(bcArray.IsSerializable());
bcArray.Serialize(ar);
ar.Close();
const DWORD dwLen = file.GetLength();
ASSERT(dwLen < iMaxChars);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
file.Detach(), dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_BINARY;

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Write (LPCTSTR pszKey, CDWordArray& dwcArray)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 4096;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

CMemFile file(byData, iMaxChars, 16);
CArchive ar(&file, CArchive::store);
ASSERT(dwcArray.IsSerializable());
dwcArray.Serialize(ar);
ar.Close();
const DWORD dwLen = file.GetLength();
ASSERT(dwLen < iMaxChars);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
file.Detach(), dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_BINARY;

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Write (LPCTSTR pszKey, CWordArray& wcArray)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 4096;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

CMemFile file(byData, iMaxChars, 16);
CArchive ar(&file, CArchive::store);
ASSERT(wcArray.IsSerializable());
wcArray.Serialize(ar);
ar.Close();
const DWORD dwLen = file.GetLength();
ASSERT(dwLen < iMaxChars);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
file.Detach(), dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_BINARY;

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Write (LPCTSTR pszKey, CStringArray& scArray)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 4096;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

CMemFile file(byData, iMaxChars, 16);
CArchive ar(&file, CArchive::store);
ASSERT(scArray.IsSerializable());
scArray.Serialize(ar);
ar.Close();
const DWORD dwLen = file.GetLength();
ASSERT(dwLen < iMaxChars);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
file.Detach(), dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_BINARY;

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Write(LPCTSTR pszKey, LPCRECT rcRect)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 30;
CDWordArray dwcArray;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

dwcArray.SetSize(5);
dwcArray.SetAt(0, rcRect->top);
dwcArray.SetAt(1, rcRect->bottom);
dwcArray.SetAt(2, rcRect->left);
dwcArray.SetAt(3, rcRect->right);

CMemFile file(byData, iMaxChars, 16);
CArchive ar(&file, CArchive::store);
ASSERT(dwcArray.IsSerializable());
dwcArray.Serialize(ar);
ar.Close();
const DWORD dwLen = file.GetLength();
ASSERT(dwLen < iMaxChars);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
file.Detach(), dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_RECT;

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

[ksaiy]

BOOL CRegistryEx::Write(LPCTSTR pszKey, LPPOINT& lpPoint)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 20;
CDWordArray dwcArray;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

dwcArray.SetSize(5);
dwcArray.SetAt(0, lpPoint->x);
dwcArray.SetAt(1, lpPoint->y);

CMemFile file(byData, iMaxChars, 16);
CArchive ar(&file, CArchive::store);
ASSERT(dwcArray.IsSerializable());
dwcArray.Serialize(ar);
ar.Close();
const DWORD dwLen = file.GetLength();
ASSERT(dwLen < iMaxChars);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
file.Detach(), dwLen);

m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_POINT;

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Read(LPCTSTR pszKey, int& iVal)
{
ASSERT(m_hKey);
ASSERT(pszKey);

DWORD dwType;
DWORD dwSize = sizeof (DWORD);
DWORD dwDest;

LONG lReturn = RegQueryValueEx (m_hKey, (LPSTR) pszKey, NULL,
&dwType, (BYTE *) &dwDest, &dwSize);

m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwSize;

if(lReturn == ERROR_SUCCESS)
{
iVal = (int)dwDest;
return TRUE;
}

return FALSE;
}

BOOL CRegistryEx::Read (LPCTSTR pszKey, LPSTR lpszBuffer, int nBufferSize )
{
ASSERT(m_hKey);
ASSERT(pszKey);

DWORD dwType;
DWORD dwSize = nBufferSize;
char szString[255];

LONG lReturn = RegQueryValueEx (m_hKey, (LPSTR) pszKey, NULL,
&dwType, (BYTE *) szString, &dwSize);

m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwSize;

if(lReturn == ERROR_SUCCESS)
{
memcpy( lpszBuffer, szString, (int) dwSize );
nBufferSize = (int) dwSize;
return TRUE;
}

return FALSE;
}

BOOL CRegistryEx::Read (LPCTSTR pszKey, DWORD& dwVal)
{
ASSERT(m_hKey);
ASSERT(pszKey);

DWORD dwType;
DWORD dwSize = sizeof (DWORD);
DWORD dwDest;

LONG lReturn = RegQueryValueEx (m_hKey, (LPSTR) pszKey, NULL,
&dwType, (BYTE *) &dwDest, &dwSize);

m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwSize;

if(lReturn == ERROR_SUCCESS)
{
dwVal = dwDest;
return TRUE;
}

return FALSE;
}

BOOL CRegistryEx::Read (LPCTSTR pszKey, CString& sVal)
{
ASSERT(m_hKey);
ASSERT(pszKey);

DWORD dwType;
DWORD dwSize = 200;
char szString[255];

LONG lReturn = RegQueryValueEx (m_hKey, (LPSTR) pszKey, NULL,
&dwType, (BYTE *) szString, &dwSize);

m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwSize;

if(lReturn == ERROR_SUCCESS)
{
sVal = szString;
return TRUE;
}

return FALSE;
}

BOOL CRegistryEx::Read (LPCTSTR pszKey, CStringList& scStringList)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 4096;
DWORD dwType;
DWORD dwData = iMaxChars;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
byData, &dwData);

m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwData;

if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
ASSERT(dwData < iMaxChars);
CMemFile file(byData, dwData);
CArchive ar(&file, CArchive::load);
ar.m_bForceFlat = FALSE;
ASSERT(ar.IsLoading());
ASSERT(scStringList.IsSerializable());
scStringList.RemoveAll();
scStringList.Serialize(ar);
ar.Close();
file.Close();
}

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

[ksaiy]

BOOL CRegistryEx::Read (LPCTSTR pszKey, CByteArray& bcArray)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 4096;
int OldSize = bcArray.GetSize();
DWORD dwType;
DWORD dwData = iMaxChars;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
byData, &dwData);

m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwData;

if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
ASSERT(dwData < iMaxChars);
CMemFile file(byData, dwData);
CArchive ar(&file, CArchive::load);
ar.m_bForceFlat = FALSE;
ASSERT(ar.IsLoading());
ASSERT(bcArray.IsSerializable());
bcArray.RemoveAll();
bcArray.SetSize(10);
bcArray.Serialize(ar);
bcArray.SetSize(OldSize);
ar.Close();
file.Close();
}

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Read (LPCTSTR pszKey, CDWordArray& dwcArray)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 4096;
int OldSize = dwcArray.GetSize();
DWORD dwType;
DWORD dwData = iMaxChars;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
byData, &dwData);

m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwData;

if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
ASSERT(dwData < iMaxChars);
CMemFile file(byData, dwData);
CArchive ar(&file, CArchive::load);
ar.m_bForceFlat = FALSE;
ASSERT(ar.IsLoading());
ASSERT(dwcArray.IsSerializable());
dwcArray.RemoveAll();
dwcArray.SetSize(10);
dwcArray.Serialize(ar);
dwcArray.SetSize(OldSize);
ar.Close();
file.Close();
}

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Read (LPCTSTR pszKey, CWordArray& wcArray)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 4096;
int OldSize = wcArray.GetSize();
DWORD dwType;
DWORD dwData = iMaxChars;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
byData, &dwData);

m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwData;

if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
ASSERT(dwData < iMaxChars);
CMemFile file(byData, dwData);
CArchive ar(&file, CArchive::load);
ar.m_bForceFlat = FALSE;
ASSERT(ar.IsLoading());
ASSERT(wcArray.IsSerializable());
wcArray.RemoveAll();
wcArray.SetSize(10);
wcArray.Serialize(ar);
wcArray.SetSize(OldSize);
ar.Close();
file.Close();
}

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Read (LPCTSTR pszKey, CStringArray& scArray)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 4096;
int OldSize = scArray.GetSize();
DWORD dwType;
DWORD dwData = iMaxChars;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
byData, &dwData);

m_Info.lMessage = lReturn;
m_Info.dwType = dwType;
m_Info.dwSize = dwData;

if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
ASSERT(dwData < iMaxChars);
CMemFile file(byData, dwData);
CArchive ar(&file, CArchive::load);
ar.m_bForceFlat = FALSE;
ASSERT(ar.IsLoading());
ASSERT(scArray.IsSerializable());
scArray.RemoveAll();
scArray.SetSize(10);
scArray.Serialize(ar);
scArray.SetSize(OldSize);
ar.Close();
file.Close();
}

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

BOOL CRegistryEx::Read(LPCTSTR pszKey, LPRECT& rcRect)
{
ASSERT(m_hKey);
ASSERT(pszKey);
const int iMaxChars = 30;
CDWordArray dwcArray;
DWORD dwType;
DWORD dwData = iMaxChars;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);

LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
byData, &dwData);

if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
ASSERT(dwData < iMaxChars);
CMemFile file(byData, dwData);
CArchive ar(&file, CArchive::load);
ar.m_bForceFlat = FALSE;
ASSERT(ar.IsLoading());
ASSERT(dwcArray.IsSerializable());
dwcArray.RemoveAll();
dwcArray.SetSize(5);
dwcArray.Serialize(ar);
ar.Close();
file.Close();
rcRect->top = dwcArray.GetAt(0);
rcRect->bottom = dwcArray.GetAt(1);
rcRect->left = dwcArray.GetAt(2);
rcRect->right = dwcArray.GetAt(3);
}

m_Info.lMessage = lReturn;
m_Info.dwType = REG_RECT;
m_Info.dwSize = sizeof(RECT);

if(byData)
{
free(byData);
byData = NULL;
}

if(lReturn == ERROR_SUCCESS)
return TRUE;

return FALSE;
}

[theone]

如果设备已经正常安装，可以从注册表里面查询出硬件信息及端口。你也可以给每个COM口发AT命令查询设备，有正确回复的就是行。参考TAPI。

[seanzh]

关注，我也想知道

[seanzh]

哦？注册表里面的该如何查？
TAPI里面好象没有得到硬件信息的内容吧？

[seanzh]

应该是在HKEY_LOCAL_MACHINE里面吧？

[seanzh]

具体的是哪个项下面？