#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <iptypes.h>
#include <iphlpapi.h>
#include <lmserver.h>
#include <lm.h>

using namespace std;

#define ADAPTER_COUNT 3
#define ONE_KB 16384

void DisplayAdapterInfoStruct(int i, IP_ADAPTER_INFO ipAdptrInfo){
    printf("ADAPTER[%d]\n", i);
    cout << "\t" << "Adapter info: " << ipAdptrInfo.Description << endl;
    ULONG j = ipAdptrInfo.AddressLength;
    printf("\tMac address: ");
    for (ULONG k = 0; k < j; k++){
        printf("%02X", ipAdptrInfo.Address[k]);
        k == j - 1 ? printf("\n") : printf("-");
    }
}

void GetAdaptersInfo(){

    PIP_ADAPTER_INFO pAdapterInfo = (PIP_ADAPTER_INFO)malloc(sizeof(IP_ADAPTER_INFO) * ADAPTER_COUNT);
    ULONG ulBufLen = sizeof(IP_ADAPTER_INFO) * ADAPTER_COUNT;

    ULONG errCode = GetAdaptersInfo(pAdapterInfo, &ulBufLen);;

    switch (errCode){
        case ERROR_BUFFER_OVERFLOW:
            cout << "Buffer overflow." << endl;
            break;
        case ERROR_SUCCESS:
            cout << "Retrieved adapters info successfully." << endl;
            break;
        case ERROR_INVALID_DATA:
            cout << "Invalid adapter information was retrieved." << endl;
            break;
        case ERROR_INVALID_PARAMETER:
            cout << "Invalid parameter provided." << endl;
            break;
        case ERROR_NO_DATA:
            cout << "No adapter information exists for the local computer." << endl;
            break;
        case ERROR_NOT_SUPPORTED:
            cout << "The GetAdaptersInfo function is not supported by the operating system running on the local computer." << endl;
            break;
    }

    if (errCode == ERROR_SUCCESS){
        PIP_ADAPTER_INFO pAdapterInfoCurr = pAdapterInfo;
        int i = 1;
        while (pAdapterInfoCurr){
            DisplayAdapterInfoStruct(i++, *pAdapterInfoCurr);
            pAdapterInfoCurr = pAdapterInfoCurr->Next;
        }
    }
    free(pAdapterInfo);
}

void DisplayNetResourceStruct(int i, LPNETRESOURCE lpnrLocal)
{
    printf("NETRESOURCE[%d] Scope: ", i);
    switch (lpnrLocal->dwScope) {
    case (RESOURCE_CONNECTED):
        printf("connected\n");
        break;
    case (RESOURCE_GLOBALNET):
        printf("all resources\n");
        break;
    case (RESOURCE_REMEMBERED):
        printf("remembered\n");
        break;
    default:
        printf("unknown scope %d\n", lpnrLocal->dwScope);
        break;
    }

    printf("NETRESOURCE[%d] Type: ", i);
    switch (lpnrLocal->dwType) {
    case (RESOURCETYPE_ANY):
        printf("any\n");
        break;
    case (RESOURCETYPE_DISK):
        printf("disk\n");
        break;
    case (RESOURCETYPE_PRINT):
        printf("print\n");
        break;
    default:
        printf("unknown type %d\n", lpnrLocal->dwType);
        break;
    }

    printf("NETRESOURCE[%d] DisplayType: ", i);
    switch (lpnrLocal->dwDisplayType) {
    case (RESOURCEDISPLAYTYPE_GENERIC):
        printf("generic\n");
        break;
    case (RESOURCEDISPLAYTYPE_DOMAIN):
        printf("domain\n");
        break;
    case (RESOURCEDISPLAYTYPE_SERVER):
        printf("server\n");
        break;
    case (RESOURCEDISPLAYTYPE_SHARE):
        printf("share\n");
        break;
    case (RESOURCEDISPLAYTYPE_FILE):
        printf("file\n");
        break;
    case (RESOURCEDISPLAYTYPE_GROUP):
        printf("group\n");
        break;
    case (RESOURCEDISPLAYTYPE_NETWORK):
        printf("network\n");
        break;
    default:
        printf("unknown display type %d\n", lpnrLocal->dwDisplayType);
        break;
    }

    printf("NETRESOURCE[%d] Usage: 0x%x = ", i, lpnrLocal->dwUsage);
    if (lpnrLocal->dwUsage & RESOURCEUSAGE_CONNECTABLE)
        printf("connectable ");
    if (lpnrLocal->dwUsage & RESOURCEUSAGE_CONTAINER)
        printf("container ");
    printf("\n");
    printf("NETRESOURCE[%d] Localname: %s\n", i, lpnrLocal->lpLocalName);
    printf("NETRESOURCE[%d] Remotename: %s\n", i, lpnrLocal->lpRemoteName);
    printf("NETRESOURCE[%d] Comment: %s\n", i, lpnrLocal->lpComment);
    printf("NETRESOURCE[%d] Provider: %s\n", i, lpnrLocal->lpProvider);
    printf("\n");
}

void DisplayWNetErrorInfo(DWORD Error, LPSTR lpErrorBuf, LPSTR lpNameBuf){
    printf("Error code: %d\nErrorDescription: %s\nProvider: %s", Error, lpErrorBuf, lpNameBuf);
}

BOOL EnumerateLocalResources(LPNETRESOURCE lpnr){
    HANDLE hEnum;
    DWORD errCode = WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_ANY, 0, lpnr, &hEnum);
    // For extended errors
    DWORD   Error;
    DWORD   nErrorBufSize = 500;
    DWORD   nNameBufSize = 500;
    LPSTR   lpErrorBuf = (LPSTR)malloc(sizeof(char) * nErrorBufSize);
    LPSTR   lpNameBuf = (LPSTR)malloc(sizeof(char) * nNameBufSize);

    if (errCode != NO_ERROR) {
        printf("WnetOpenEnum failed with error: ");
        switch (errCode){
        case ERROR_NOT_CONTAINER:
            printf("ERROR_NOT_CONTAINER");
            break;
        case ERROR_INVALID_PARAMETER:
            printf("ERROR_INVALID_PARAMETER");
            break;
        case ERROR_NO_NETWORK:
            printf("ERROR_NO_NETWORK");
            break;
        case ERROR_EXTENDED_ERROR:
            if (NO_ERROR == WNetGetLastErrorA(&Error, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize)){
                DisplayWNetErrorInfo(Error, lpErrorBuf, lpNameBuf);
            }
            break;
        case ERROR_INVALID_ADDRESS:
            printf("ERROR_INVALID_ADDRESS");
            break;
        }
        printf("\n");
        return FALSE;
    }

    free(lpErrorBuf);
    free(lpNameBuf);

    DWORD cbBuffer = ONE_KB;
    LPNETRESOURCE lpnrLocal = (LPNETRESOURCE)malloc(cbBuffer);
    DWORD dwResultEnum;
    DWORD cEntries = -1;
    DWORD i;
    do {
        ZeroMemory(lpnrLocal, cbBuffer);
        dwResultEnum = WNetEnumResource(hEnum, &cEntries, lpnrLocal, &cbBuffer);
        if (dwResultEnum == NO_ERROR) {
            for (i = 0; i < cEntries; i++) {
                DisplayNetResourceStruct(i, &lpnrLocal[i]);
                if (RESOURCEUSAGE_CONTAINER == (lpnrLocal[i].dwUsage & RESOURCEUSAGE_CONTAINER))
                    if (!EnumerateLocalResources(&lpnrLocal[i]))
                        printf("EnumerateLocalResources 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);
    free(lpnrLocal);
    errCode = WNetCloseEnum(hEnum);
    if (errCode != NO_ERROR) {
        printf("WNetCloseEnum failed with error %d\n", errCode);
        return FALSE;
    }
    cout << "Retrieved network resource info successfully." << endl;
    return TRUE;
}

void EnumerateServers(){
    LPSERVER_INFO_101 pBuf = NULL;
    LPSERVER_INFO_101 pTmpBuf;
    DWORD dwLevel = 100;
    DWORD dwPrefMaxLen = MAX_PREFERRED_LENGTH;
    DWORD dwEntriesRead = 0;
    DWORD dwTotalEntries = 0;
    DWORD dwTotalCount = 0;
    DWORD dwServerType = SV_TYPE_WORKSTATION;
    DWORD dwResumeHandle = 0;
    NET_API_STATUS nStatus;
    LPWSTR pszServerName = NULL;
    LPWSTR pszDomainName = NULL;
    DWORD i;

    nStatus = NetServerEnum(pszServerName,
                            dwLevel,
                            (LPBYTE *) & pBuf,
                            dwPrefMaxLen,
                            &dwEntriesRead,
                            &dwTotalEntries,
                            dwServerType,
                            pszDomainName,
                            &dwResumeHandle);
    if ((nStatus == NERR_Success) || (nStatus == ERROR_MORE_DATA)) {
        if ((pTmpBuf = pBuf) != NULL) {

            for (i = 0; i < dwEntriesRead; i++) {
                if (pTmpBuf == NULL) {
                    printf("An access violation has occurred\n");
                    break;
                }

                printf("\tPlatform: %d\n", pTmpBuf->sv101_platform_id);
                wprintf(L"\tName:     %s\n", pTmpBuf->sv101_name);
                pTmpBuf++;
                dwTotalCount++;
            }
            printf("\nEntries enumerated: %d\n", dwTotalCount);

        } else {
            printf("No servers were found\n");
            printf("The buffer (bufptr) returned was NULL\n");
            printf("entries read: %d\n", dwEntriesRead);
            printf("total entries: %d\n", dwEntriesRead);
        }

    } else
        printf("NetServerEnum failed with error: %d\n", (int)nStatus);
    if (pBuf != NULL)
        NetApiBufferFree(pBuf);
}

int main()
{
    setlocale(LC_ALL, "russian");
    GetAdaptersInfo();
    cout << endl;
    LPNETRESOURCE lpnr = NULL;
    EnumerateLocalResources(lpnr);
    EnumerateServers();
    cout << "Press any key..." << endl;
    getchar();
    Sleep(100000);
    return 0;
}