ReactOS Development > Doxygen

00001 #include <precomp.h>
00002 
00003 WINE_DEFAULT_DEBUG_CHANNEL (shell);
00004 
00005 typedef struct tagINetConnectionItem
00006 {
00007     struct tagINetConnectionItem * Next;
00008     DWORD dwAdapterIndex;
00009     NETCON_PROPERTIES    Props;
00010 } INetConnectionItem, *PINetConnectionItem;
00011 
00012 class CNetConnectionManager:
00013     public INetConnectionManager,
00014     public IEnumNetConnection
00015 {
00016     public:
00017         CNetConnectionManager();
00018         BOOL EnumerateINetConnections();
00019         
00020         // IUnknown
00021         virtual HRESULT WINAPI QueryInterface(REFIID riid, LPVOID *ppvOut);
00022         virtual ULONG WINAPI AddRef();
00023         virtual ULONG WINAPI Release();
00024         
00025         // INetConnectionManager
00026         virtual HRESULT WINAPI EnumConnections(NETCONMGR_ENUM_FLAGS Flags, IEnumNetConnection **ppEnum);
00027         
00028         // IEnumNetConnection
00029         virtual HRESULT WINAPI Next(ULONG celt, INetConnection **rgelt, ULONG *pceltFetched);
00030         virtual HRESULT WINAPI Skip(ULONG celt);
00031         virtual HRESULT WINAPI Reset();
00032         virtual HRESULT WINAPI Clone(IEnumNetConnection **ppenum);
00033     
00034     private:
00035         LONG ref;
00036         PINetConnectionItem pHead;
00037         PINetConnectionItem pCurrent;
00038 };
00039 
00040 class CNetConnection:
00041     public INetConnection
00042 {
00043     public:
00044         CNetConnection(PINetConnectionItem pItem);
00045         
00046         // IUnknown
00047         virtual HRESULT WINAPI QueryInterface(REFIID riid, LPVOID *ppvOut);
00048         virtual ULONG WINAPI AddRef();
00049         virtual ULONG WINAPI Release();
00050         
00051         // INetConnection
00052         HRESULT WINAPI Connect();
00053         HRESULT WINAPI Disconnect();
00054         HRESULT WINAPI Delete();
00055         HRESULT WINAPI Duplicate(LPCWSTR pszwDuplicateName, INetConnection **ppCon);
00056         HRESULT WINAPI GetProperties(NETCON_PROPERTIES **ppProps);
00057         HRESULT WINAPI GetUiObjectClassId(CLSID *pclsid);
00058         HRESULT WINAPI Rename(LPCWSTR pszwDuplicateName);
00059         
00060     private:
00061         LONG ref;
00062         NETCON_PROPERTIES Props;
00063         DWORD dwAdapterIndex;
00064 };
00065 
00066 VOID NormalizeOperStatus(MIB_IFROW *IfEntry, NETCON_PROPERTIES * Props);
00067 
00068 CNetConnectionManager::CNetConnectionManager()
00069 {
00070     ref = 0;
00071     pHead = NULL;
00072     pCurrent = NULL;
00073 }
00074 
00075 HRESULT
00076 WINAPI
00077 CNetConnectionManager::QueryInterface(
00078     REFIID iid,
00079     LPVOID *ppvObj)
00080 {
00081     *ppvObj = NULL;
00082 
00083     if (IsEqualIID(iid, IID_IUnknown) ||
00084         IsEqualIID(iid, IID_INetConnectionManager))
00085     {
00086         *ppvObj = (INetConnectionManager*)this;
00087         AddRef();
00088         return S_OK;
00089     }
00090 
00091     return E_NOINTERFACE;
00092 }
00093 
00094 ULONG
00095 WINAPI
00096 CNetConnectionManager::AddRef()
00097 {
00098     ULONG refCount = InterlockedIncrement(&ref);
00099 
00100     return refCount;
00101 }
00102 
00103 ULONG
00104 WINAPI
00105 CNetConnectionManager::Release()
00106 {
00107     ULONG refCount = InterlockedDecrement(&ref);
00108 
00109     if (!refCount) 
00110         delete this;
00111 
00112     return refCount;
00113 }
00114 
00115 HRESULT
00116 WINAPI
00117 CNetConnectionManager::EnumConnections(
00118     NETCONMGR_ENUM_FLAGS Flags,
00119     IEnumNetConnection **ppEnum)
00120 {
00121     TRACE("EnumConnections\n");
00122 
00123     if (!ppEnum)
00124         return E_POINTER;
00125 
00126     if (Flags != NCME_DEFAULT)
00127         return E_FAIL;
00128 
00129     *ppEnum = (IEnumNetConnection*)this;
00130     AddRef();
00131     return S_OK;
00132 }
00133 
00134 /***************************************************************
00135  * INetConnection Interface
00136  */
00137 
00138 CNetConnection::CNetConnection(PINetConnectionItem pItem)
00139 {
00140     ref = 0;
00141     dwAdapterIndex = pItem->dwAdapterIndex;
00142     CopyMemory(&Props, &pItem->Props, sizeof(NETCON_PROPERTIES));
00143 
00144     if (pItem->Props.pszwName)
00145     {
00146         Props.pszwName = (LPWSTR)CoTaskMemAlloc((wcslen(pItem->Props.pszwName)+1)*sizeof(WCHAR));
00147         if (Props.pszwName)
00148             wcscpy(Props.pszwName, pItem->Props.pszwName);
00149     }
00150 
00151     if (pItem->Props.pszwDeviceName)
00152     {
00153         Props.pszwDeviceName = (LPWSTR)CoTaskMemAlloc((wcslen(pItem->Props.pszwDeviceName)+1)*sizeof(WCHAR));
00154         if (Props.pszwDeviceName)
00155             wcscpy(Props.pszwDeviceName, pItem->Props.pszwDeviceName);
00156     }
00157 }
00158 
00159 HRESULT
00160 WINAPI
00161 CNetConnection::QueryInterface(
00162     REFIID iid,
00163     LPVOID * ppvObj)
00164 {
00165     *ppvObj = NULL;
00166 
00167     if (IsEqualIID(iid, IID_IUnknown) ||
00168         IsEqualIID(iid, IID_INetConnection))
00169     {
00170         *ppvObj = this;
00171         AddRef();
00172         return S_OK;
00173     }
00174 
00175     return E_NOINTERFACE;
00176 }
00177 
00178 ULONG
00179 WINAPI
00180 CNetConnection::AddRef()
00181 {
00182     ULONG refCount = InterlockedIncrement(&ref);
00183 
00184     return refCount;
00185 }
00186 
00187 ULONG
00188 WINAPI
00189 CNetConnection::Release()
00190 {
00191     ULONG refCount = InterlockedDecrement(&ref);
00192 
00193     if (!refCount) 
00194     {
00195         CoTaskMemFree(Props.pszwName);
00196         CoTaskMemFree(Props.pszwDeviceName);
00197         delete this;
00198     }
00199 
00200     return refCount;
00201 }
00202 
00203 HRESULT
00204 WINAPI
00205 CNetConnection::Connect()
00206 {
00207     return E_NOTIMPL;
00208 }
00209 
00210 HRESULT
00211 WINAPI
00212 CNetConnection::Disconnect()
00213 {
00214     return E_NOTIMPL;
00215 }
00216 
00217 HRESULT
00218 WINAPI
00219 CNetConnection::Delete()
00220 {
00221     return E_NOTIMPL;
00222 }
00223 
00224 HRESULT
00225 WINAPI
00226 CNetConnection::Duplicate(
00227     LPCWSTR pszwDuplicateName,
00228     INetConnection **ppCon)
00229 {
00230     return E_NOTIMPL;
00231 }
00232 
00233 HRESULT
00234 WINAPI
00235 CNetConnection::GetProperties(NETCON_PROPERTIES **ppProps)
00236 {
00237     MIB_IFROW IfEntry;
00238     HKEY hKey;
00239     LPOLESTR pStr;
00240     WCHAR szName[140];
00241     DWORD dwShowIcon, dwType, dwSize;
00242     NETCON_PROPERTIES * pProperties;
00243     HRESULT hr;
00244 
00245     if (!ppProps)
00246         return E_POINTER;
00247 
00248     pProperties = (NETCON_PROPERTIES*)CoTaskMemAlloc(sizeof(NETCON_PROPERTIES));
00249     if (!pProperties)
00250         return E_OUTOFMEMORY;
00251 
00252     CopyMemory(pProperties, &Props, sizeof(NETCON_PROPERTIES));
00253     pProperties->pszwName = NULL;
00254 
00255     if (Props.pszwDeviceName)
00256     {
00257         pProperties->pszwDeviceName = (LPWSTR)CoTaskMemAlloc((wcslen(Props.pszwDeviceName)+1)*sizeof(WCHAR));
00258         if (pProperties->pszwDeviceName)
00259             wcscpy(pProperties->pszwDeviceName, Props.pszwDeviceName);
00260     }
00261 
00262     *ppProps = pProperties;
00263 
00264     /* get updated adapter characteristics */
00265     ZeroMemory(&IfEntry, sizeof(IfEntry));
00266     IfEntry.dwIndex = dwAdapterIndex;
00267     if(GetIfEntry(&IfEntry) != NO_ERROR)
00268         return NOERROR;
00269 
00270     NormalizeOperStatus(&IfEntry, pProperties);
00271 
00272 
00273     hr = StringFromCLSID((CLSID)Props.guidId, &pStr);
00274     if (SUCCEEDED(hr))
00275     {
00276         wcscpy(szName, L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\");
00277         wcscat(szName, pStr);
00278         wcscat(szName, L"\\Connection");
00279 
00280         if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szName, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
00281         {
00282             dwSize = sizeof(dwShowIcon);
00283             if (RegQueryValueExW(hKey, L"ShowIcon", NULL, &dwType, (LPBYTE)&dwShowIcon, &dwSize) == ERROR_SUCCESS && dwType == REG_DWORD)
00284             {
00285                 if (dwShowIcon)
00286                     pProperties->dwCharacter |= NCCF_SHOW_ICON;
00287                 else
00288                     pProperties->dwCharacter &= ~NCCF_SHOW_ICON;
00289             }
00290             dwSize = sizeof(szName);
00291             if (RegQueryValueExW(hKey, L"Name", NULL, &dwType, (LPBYTE)szName, &dwSize) == ERROR_SUCCESS)
00292             {
00293                 /* use updated name */
00294                 dwSize = wcslen(szName) + 1;
00295                 pProperties->pszwName = (LPWSTR)CoTaskMemAlloc(dwSize * sizeof(WCHAR));
00296                 if (pProperties->pszwName)
00297                     CopyMemory(pProperties->pszwName, szName, dwSize * sizeof(WCHAR));
00298             }
00299             else
00300             {
00301                 /* use cached name */
00302                 if (Props.pszwName)
00303                 {
00304                     pProperties->pszwName = (LPWSTR)CoTaskMemAlloc((wcslen(Props.pszwName)+1)*sizeof(WCHAR));
00305                     if (pProperties->pszwName)
00306                         wcscpy(pProperties->pszwName, Props.pszwName);
00307                 }
00308             }
00309             RegCloseKey(hKey);
00310         }
00311         CoTaskMemFree(pStr);
00312     }
00313 
00314     return S_OK;
00315 }
00316 
00317 HRESULT
00318 WINAPI
00319 CNetConnection::GetUiObjectClassId(CLSID *pclsid)
00320 {
00321     if (Props.MediaType == NCM_LAN)
00322     {
00323         CopyMemory(pclsid, &CLSID_LANConnectUI, sizeof(CLSID));
00324         return S_OK;
00325     }
00326 
00327     return E_NOTIMPL;
00328 }
00329 
00330 HRESULT
00331 WINAPI
00332 CNetConnection::Rename(LPCWSTR pszwDuplicateName)
00333 {
00334     return E_NOTIMPL;
00335 }
00336 
00337 HRESULT WINAPI IConnection_Constructor(INetConnection **ppv, PINetConnectionItem pItem)
00338 {
00339     if (!ppv)
00340         return E_POINTER;
00341 
00342     CNetConnection *pConnection = new CNetConnection(pItem);
00343     if (!pConnection)
00344         return E_OUTOFMEMORY;
00345 
00346     pConnection->AddRef();
00347     *ppv = (INetConnection *)pConnection;
00348 
00349     return S_OK;
00350 }
00351 
00352 
00353 /***************************************************************
00354  * IEnumNetConnection Interface
00355  */
00356 
00357 HRESULT
00358 WINAPI
00359 CNetConnectionManager::Next(
00360     ULONG celt,
00361     INetConnection **rgelt,
00362     ULONG *pceltFetched)
00363 {
00364     HRESULT hr;
00365 
00366     if (!pceltFetched || !rgelt)
00367         return E_POINTER;
00368 
00369     if (celt != 1)
00370         return E_FAIL;
00371 
00372     if (!pCurrent)
00373         return S_FALSE;
00374 
00375     hr = IConnection_Constructor(rgelt, pCurrent);
00376     pCurrent = pCurrent->Next;
00377 
00378     return hr;
00379 }
00380 
00381 HRESULT
00382 WINAPI
00383 CNetConnectionManager::Skip(ULONG celt)
00384 {
00385     while(pCurrent && celt-- > 0)
00386         pCurrent = pCurrent->Next;
00387 
00388     if (celt)
00389        return S_FALSE;
00390     else
00391        return S_OK;
00392 
00393 }
00394 
00395 HRESULT
00396 WINAPI
00397 CNetConnectionManager::Reset()
00398 {
00399     pCurrent = pHead;
00400     return S_OK;
00401 }
00402 
00403 HRESULT
00404 WINAPI
00405 CNetConnectionManager::Clone(IEnumNetConnection **ppenum)
00406 {
00407     return E_NOTIMPL;
00408 }
00409 
00410 BOOL
00411 GetAdapterIndexFromNetCfgInstanceId(PIP_ADAPTER_INFO pAdapterInfo, LPWSTR szNetCfg, PDWORD pIndex)
00412 {
00413     WCHAR szBuffer[50];
00414     IP_ADAPTER_INFO * pCurrentAdapter;
00415 
00416     pCurrentAdapter = pAdapterInfo;
00417     while(pCurrentAdapter)
00418     {
00419         szBuffer[0] = L'\0';
00420         if (MultiByteToWideChar(CP_ACP, 0, pCurrentAdapter->AdapterName, -1, szBuffer, sizeof(szBuffer)/sizeof(szBuffer[0])))
00421         {
00422             szBuffer[(sizeof(szBuffer)/sizeof(WCHAR))-1] = L'\0';
00423         }
00424         if (!_wcsicmp(szBuffer, szNetCfg))
00425         {
00426             *pIndex = pCurrentAdapter->Index;
00427             return TRUE;
00428         }
00429         pCurrentAdapter = pCurrentAdapter->Next;
00430     }
00431     return FALSE;
00432 }
00433 
00434 VOID
00435 NormalizeOperStatus(
00436     MIB_IFROW *IfEntry,
00437     NETCON_PROPERTIES    * Props)
00438 {
00439     switch(IfEntry->dwOperStatus)
00440     {
00441         case MIB_IF_OPER_STATUS_NON_OPERATIONAL:
00442             Props->Status = NCS_HARDWARE_DISABLED;
00443             break;
00444         case MIB_IF_OPER_STATUS_UNREACHABLE:
00445             Props->Status = NCS_DISCONNECTED;
00446             break;
00447         case MIB_IF_OPER_STATUS_DISCONNECTED:
00448             Props->Status = NCS_MEDIA_DISCONNECTED;
00449             break;
00450         case MIB_IF_OPER_STATUS_CONNECTING:
00451             Props->Status = NCS_CONNECTING;
00452             break;
00453         case MIB_IF_OPER_STATUS_CONNECTED:
00454             Props->Status = NCS_CONNECTED;
00455             break;
00456         case MIB_IF_OPER_STATUS_OPERATIONAL:
00457             Props->Status = NCS_CONNECTED;
00458             break;
00459         default:
00460             break;
00461     }
00462 }
00463 
00464 BOOL
00465 CNetConnectionManager::EnumerateINetConnections()
00466 {
00467     DWORD dwSize, dwResult, dwIndex, dwAdapterIndex, dwShowIcon;
00468     MIB_IFTABLE *pIfTable;
00469     MIB_IFROW IfEntry;
00470     IP_ADAPTER_INFO * pAdapterInfo;
00471     HDEVINFO hInfo;
00472     SP_DEVINFO_DATA DevInfo;
00473     HKEY hSubKey;
00474     WCHAR szNetCfg[50];
00475     WCHAR szAdapterNetCfg[50];
00476     WCHAR szDetail[200] = L"SYSTEM\\CurrentControlSet\\Control\\Class\\";
00477     WCHAR szName[130] = L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\";
00478     PINetConnectionItem pCurrent = NULL;
00479 
00480     /* get the IfTable */
00481     dwSize = 0;
00482     if (GetIfTable(NULL, &dwSize, TRUE) != ERROR_INSUFFICIENT_BUFFER)
00483         return FALSE;
00484 
00485     pIfTable = (PMIB_IFTABLE)CoTaskMemAlloc(dwSize);
00486     if (!pIfTable)
00487         return FALSE;
00488 
00489     dwResult = GetIfTable(pIfTable, &dwSize, TRUE);
00490     if (dwResult != NO_ERROR)
00491     {
00492         CoTaskMemFree(pIfTable);
00493         return FALSE;
00494     }
00495 
00496     dwSize = 0;
00497     dwResult = GetAdaptersInfo(NULL, &dwSize); 
00498     if (dwResult!= ERROR_BUFFER_OVERFLOW)
00499     {
00500         CoTaskMemFree(pIfTable);
00501         return FALSE;
00502     }
00503 
00504     pAdapterInfo = (PIP_ADAPTER_INFO)CoTaskMemAlloc(dwSize);
00505     if (!pAdapterInfo)
00506     {
00507         CoTaskMemFree(pIfTable);
00508         return FALSE;
00509     }
00510 
00511     if (GetAdaptersInfo(pAdapterInfo, &dwSize) != NO_ERROR)
00512     {
00513         CoTaskMemFree(pIfTable);
00514         CoTaskMemFree(pAdapterInfo);
00515         return FALSE;
00516     }
00517 
00518     hInfo = SetupDiGetClassDevs(&GUID_DEVCLASS_NET, NULL, NULL, DIGCF_PRESENT );
00519     if (!hInfo)
00520     {
00521         CoTaskMemFree(pIfTable);
00522         CoTaskMemFree(pAdapterInfo);
00523         return FALSE;
00524     }
00525 
00526     dwIndex = 0;
00527     do
00528     {
00529         ZeroMemory(&DevInfo, sizeof(SP_DEVINFO_DATA));
00530         DevInfo.cbSize = sizeof(DevInfo);
00531 
00532         /* get device info */
00533         if (!SetupDiEnumDeviceInfo(hInfo, dwIndex++, &DevInfo))
00534             break;
00535 
00536         /* get device software registry path */
00537         if (!SetupDiGetDeviceRegistryPropertyW(hInfo, &DevInfo, SPDRP_DRIVER, NULL, (LPBYTE)&szDetail[39], sizeof(szDetail)/sizeof(WCHAR) - 40, &dwSize))
00538             break;
00539 
00540         /* open device registry key */
00541         if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szDetail, 0, KEY_READ, &hSubKey) != ERROR_SUCCESS)
00542             break;
00543 
00544         /* query NetCfgInstanceId for current device */
00545         dwSize = sizeof(szNetCfg);
00546         if (RegQueryValueExW(hSubKey, L"NetCfgInstanceId", NULL, NULL, (LPBYTE)szNetCfg, &dwSize) != ERROR_SUCCESS)
00547         {
00548             RegCloseKey(hSubKey);
00549             break;
00550         }
00551         RegCloseKey(hSubKey);
00552 
00553         /* get the current adapter index from NetCfgInstanceId */
00554         if (!GetAdapterIndexFromNetCfgInstanceId(pAdapterInfo, szNetCfg, &dwAdapterIndex))
00555             continue;
00556 
00557         /* get detailed adapter info */
00558         ZeroMemory(&IfEntry, sizeof(IfEntry));
00559         IfEntry.dwIndex = dwAdapterIndex;
00560         if(GetIfEntry(&IfEntry) != NO_ERROR)
00561             break;
00562 
00563         /* allocate new INetConnectionItem */
00564         PINetConnectionItem pNew = (PINetConnectionItem)CoTaskMemAlloc(sizeof(INetConnectionItem));
00565         if (!pNew)
00566             break;
00567 
00568         ZeroMemory(pNew, sizeof(INetConnectionItem));
00569         pNew->dwAdapterIndex = dwAdapterIndex;
00570         /* store NetCfgInstanceId */
00571         CLSIDFromString(szNetCfg, &pNew->Props.guidId);
00572         NormalizeOperStatus(&IfEntry, &pNew->Props);
00573 
00574         switch(IfEntry.dwType)
00575         {
00576             case IF_TYPE_ETHERNET_CSMACD:
00577                 pNew->Props.MediaType = NCM_LAN;
00578                 break;
00579             case IF_TYPE_IEEE80211:
00580                 pNew->Props.MediaType = NCM_SHAREDACCESSHOST_RAS;
00581                 break;
00582             default:
00583                 break;
00584         }
00585         /*  open network connections details */
00586         wcscpy(&szName[80], szNetCfg);
00587         wcscpy(&szName[118], L"\\Connection");
00588 
00589         if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szName, 0, KEY_READ, &hSubKey) == ERROR_SUCCESS)
00590         {
00591             /* retrieve name of connection */
00592             dwSize = sizeof(szAdapterNetCfg);
00593             if (RegQueryValueExW(hSubKey, L"Name", NULL, NULL, (LPBYTE)szAdapterNetCfg, &dwSize) == ERROR_SUCCESS)
00594             {
00595                 pNew->Props.pszwName = (LPWSTR)CoTaskMemAlloc((wcslen(szAdapterNetCfg)+1) * sizeof(WCHAR));
00596                 if (pNew->Props.pszwName)
00597                     wcscpy(pNew->Props.pszwName, szAdapterNetCfg);
00598             }
00599             dwSize = sizeof(dwShowIcon);
00600             if (RegQueryValueExW(hSubKey, L"ShowIcon", NULL, NULL, (LPBYTE)&dwShowIcon, &dwSize) == ERROR_SUCCESS)
00601             {
00602                 if (dwShowIcon)
00603                     pNew->Props.dwCharacter |= NCCF_SHOW_ICON;
00604             }
00605             RegCloseKey(hSubKey);
00606         }
00607         if (SetupDiGetDeviceRegistryPropertyW(hInfo, &DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szNetCfg, sizeof(szNetCfg)/sizeof(WCHAR), &dwSize))
00608         {
00609             szNetCfg[(sizeof(szNetCfg)/sizeof(WCHAR))-1] = L'\0';
00610             pNew->Props.pszwDeviceName = (LPWSTR)CoTaskMemAlloc((wcslen(szNetCfg)+1) * sizeof(WCHAR));
00611             if (pNew->Props.pszwDeviceName)
00612                 wcscpy(pNew->Props.pszwDeviceName, szNetCfg);
00613         }
00614 
00615         if (pCurrent)
00616             pCurrent->Next = pNew;
00617         else
00618             pHead = pNew;
00619 
00620         pCurrent = pNew;
00621     }while(TRUE);
00622 
00623     CoTaskMemFree(pIfTable);
00624     CoTaskMemFree(pAdapterInfo);
00625     SetupDiDestroyDeviceInfoList(hInfo);
00626 
00627     this->pCurrent = pHead;
00628     return TRUE;
00629 }
00630 
00631 HRESULT WINAPI INetConnectionManager_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID * ppv)
00632 {
00633     TRACE("INetConnectionManager_Constructor\n");
00634 
00635     if (!ppv)
00636         return E_POINTER;
00637     if (pUnkOuter)
00638         return CLASS_E_NOAGGREGATION;
00639 
00640     CNetConnectionManager *pConnectionMgr = new CNetConnectionManager;
00641     if (!pConnectionMgr)
00642         return E_OUTOFMEMORY;
00643 
00644     pConnectionMgr->AddRef();
00645     HRESULT hr = pConnectionMgr->QueryInterface(riid, ppv);
00646 
00647     if (SUCCEEDED(hr))
00648         pConnectionMgr->EnumerateINetConnections();
00649 
00650     pConnectionMgr->Release();
00651 
00652     return hr;
00653 }
00654 
00655
Generated on Sat May 26 2012 04:24:01 for ReactOS by
1.7.6.1