Работает только первый wcout - C++ - Ответ 981390

#define _UNICODE
#include "stdafx.h"
#include <windows.h>
#include <wincon.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <Winnetwk.h>
#include <iostream>
#include <clocale>
#include <tchar.h>
#include <string>
using namespace std;
 
BOOL EnumerateFunc(LPNETRESOURCE);
 
/*
The ADAPTER_STATUS structure contains information about a network adapter. This structure 
is pointed to by the ncb_buffer member of the NCB structure. ADAPTER_STATUS is followed by 
as many NAME_BUFFER structures as required to describe the network adapters on the system.
*/
ADAPTER_STATUS Adapter;
 
void GetMacAddresses()
{
    /*
    The NCB structure represents a network control block. It contains information about the 
    command to perform, an optional post routine, an optional event handle, and a pointer to 
    a buffer that is used for messages or other data. A pointer to this structure is passed 
    to the Netbios function. 
    */
    NCB ncb;
    
    UCHAR uRetCode;
    char MacAddress[50];
    memset(&ncb, 0, sizeof(ncb));
    
    /*
    ncb_command : Specifies the command code and a flag that indicates whether the NCB structure 
    is processed asynchronously.
    NCBRESET : Resets a LAN adapter. An adapter must be reset before it can accept any other 
    NCB command that specifies the same number in the ncb_lana_num member.
    */
    ncb.ncb_command = NCBRESET;
 
    /*
    The Netbios function interprets and executes the specified network control block (NCB).
    For synchronous requests, the return value is the return code in the NCB structure. That value 
    is also returned in the ncb_retcode member of the NCB structure.
    */
    uRetCode = Netbios( &ncb );
    
    /*void *memset(void *dest, int c, size_t count);
    Sets buffers to a specified character.
    Parameters:
    dest - Pointer to destination.
    c - Character to set.
    count - Number of characters.
    Return Value: The value of dest.
    Remarks: Sets the first count characters of dest to the character c.
    */
    memset(&ncb, 0, sizeof(ncb));
    
    /*
    NCBENUM : Enumerates LAN adapter (LANA) numbers. When this code is specified, 
    the ncb_buffer member points to a buffer to be filled with a LANA_ENUM structure. 
    NCBENUM is not a standard NetBIOS 3.0 command.
    */
    ncb.ncb_command = NCBENUM;
    
    /*
    The LANA_ENUM structure contains the numbers for the current LAN adapters. 
    The LANA_ENUM structure is pointed to by the ncb_buffer member of the NCB structure 
    when an application issues the NCBENUM command. Members:
    length - Specifies the number of valid entries in the array of LAN adapter numbers.
    lana - Specifies an array of LAN adapter numbers.
    */
    LANA_ENUM myLanaEnum;
    
    /*
    ncb_buffer : Pointer to the message buffer. The buffer must have write access. Its 
    uses are as follows:
    NCBSEND - Contains the message to be sent.  
    NCBRECV - Receives the message.  
    NCBSSTAT - Receives the requested status information. 
    */
    ncb.ncb_buffer = (unsigned char *) &myLanaEnum;
    
    /*
    ncb_length : Specifies the size, in bytes, of the message buffer. For receive commands, 
    this member is set by the Netbios function to indicate the number of bytes received.
    If the buffer length is incorrect, the Netbios function returns the NRC_BUFLEN error code.
    */
    ncb.ncb_length = sizeof(LANA_ENUM);
 
    uRetCode = Netbios( &ncb );
 
    if(uRetCode==0) 
    {
        for (long i = 0; i < myLanaEnum.length; ++i)
        {   
            ncb.ncb_command = NCBRESET;
 
            /*
            Specifies the LAN adapter number. This zero-based number corresponds to a particular transport
            provider using a particular LAN adapter board.
            */
            ncb.ncb_lana_num = myLanaEnum.lana[i];
 
            uRetCode = Netbios( &ncb );
    
            /*
            Retrieves the status of either a local or remote adapter. When this code is specified, 
            the ncb_buffer member points to a buffer to be filled with an ADAPTER_STATUS structure, 
            followed by an array of NAME_BUFFER structures.
            */
            ncb.ncb_command = NCBASTAT;
 
            /*
            ncb_callname : Specifies the name of the remote application. Trailing-space characters 
            should be supplied to make the length of the string equal to NCBNAMSZ.
            */
            strcpy( (char *) ncb.ncb_callname, "*   " );
            ncb.ncb_buffer = (unsigned char *) &Adapter; 
            ncb.ncb_length = sizeof(Adapter);
            uRetCode = Netbios( &ncb );
            printf("LANA_ENUM lana[%i]: %i, MAC Address: ",i,myLanaEnum.lana[i]);
            if(uRetCode==0)
            { 
                sprintf(MacAddress, "%02X-%02X-%02X-%02X-%02X-%02X\n",
                Adapter.adapter_address[0], 
                Adapter.adapter_address[1], 
                Adapter.adapter_address[2], 
                Adapter.adapter_address[3], 
                Adapter.adapter_address[4], 
                Adapter.adapter_address[5]); 
            }
            printf(MacAddress);
        }
    }
}
 
wchar_t ctw(char c)
{
    std::pair<int,int> ctw_pairs[64];
    int i = -32;
    int j = 1072;
    int k = 0;
 
    while ( (i != 0) && (j != 1104) )
    {
        ctw_pairs[k].first = i;
        ctw_pairs[k].second = j;
        i++;
        j++;
        k++;
    }
    i = -64;
    j = 1040;
    while ( (i != -32) && (j != 1072) )
    {
        ctw_pairs[k].first = i;
        ctw_pairs[k].second = j;
        i++;
        j++;
        k++;
    }
 
    k = 0;
    int n = (int) c;
    while (ctw_pairs[k].first != n)
        k++;
    return ctw_pairs[k].second;
}
 
void DisplayStruct(LPNETRESOURCE resourse)
{
    /*
    LPTSTR : An LPWSTR if UNICODE is defined, an LPSTR otherwise.
    LPWSTR : A pointer to a null-terminated string of 16-bit Unicode characters:
             typedef WCHAR *LPWSTR;
    LPSTR  : A pointer to a null-terminated string of 8-bit Windows (ANSI) characters:
             typedef CHAR *LPSTR;
    */
    
    LPSTR s_lpRemoteName = resourse->lpRemoteName;
    int lpRemoteName_length = 0;
    while(s_lpRemoteName[lpRemoteName_length] != '\0')
        lpRemoteName_length++;
 
    wchar_t *w_lpRemoteName = new wchar_t[lpRemoteName_length] ;
    for (int i = 0; i < lpRemoteName_length; i++)
        if ( (int)s_lpRemoteName[i] > 0 )
            w_lpRemoteName[i] = s_lpRemoteName[i];
        else
            w_lpRemoteName[i] = ctw(s_lpRemoteName[i]);
 
    wchar_t aa[] = L"по-русски";
    std::wcout << w_lpRemoteName << aa << std::endl;
 
    EnumerateFunc(resourse);
}
 
BOOL EnumerateFunc(LPNETRESOURCE lpnr)
{ 
    /*
    DWORD : A 32-bit unsigned integer. The range is 0 through 4294967295 decimal.
    This type is declared in WinDef.h as follows:
    typedef unsigned long DWORD;
    */
    DWORD dwResult, dwResultEnum;
 
    /*
    HANDLE : A handle to an object.
    This type is declared in WinNT.h as follows:
    typedef PVOID HANDLE;
 
    Дескриптор (handle) - число, которое задает номер какого-либо ресурса 
    (блок памяти, файл, курсор, шрифт, окно и т. п.) при работе с ним. 
    Дескриптор используется обычно при работе через некоторый интерфейс (API), 
    причем смысл значения дескриптора скрыт за этим интерфейсом. Например, 
    дескриптор блока памяти может означать номер ячейки в таблице адресов 
    блоков памяти; поскольку пользователь API работает с дескриптором, а 
    не с указателем, адрес размещения блока памяти может менятся, и это не 
    скажется на работе с ним через дескриптор.
    */
    HANDLE hEnum;
 
    DWORD cbBuffer = 16384;      // 16K is a good size
    DWORD cEntries = -1;         // enumerate all possible entries
 
    /*
    The NETRESOURCE structure contains information about a network resource.
    */
    LPNETRESOURCE lpnrLocal = NULL;     // pointer to enumerated structures
    
    DWORD i;
    //
    // Call the WNetOpenEnum function to begin the enumeration.
    //
 
    DWORD tmp1 = NO_ERROR;
 
    /*
    The WNetOpenEnum function starts an enumeration of network resources or existing connections.
    Parameters:
    DWORD dwScope : Scope of the enumeration; RESOURCE_GLOBALNET - Enumerate all resources on the network.
    DWORD dwType : Resource types to be enumerated; RESOURCETYTPE_ANY - All resources.
    DWORD dwUsage : Resource usage type to be enumerated; 0 - All resources.
    LPNETRESOURCE lpNetResource : Pointer to a NETRESOURCE structure that specifies the container to enumerate.
                                  If this parameter is NULL, the root of the network is assumed. 
    LPHANDLE lphEnum : Pointer to an enumeration handle that can be used in a subsequent call to WNetEnumResource.
    If the function succeeds, the return value is NO_ERROR.
    */
    dwResult = WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_ANY, 0, lpnr, &hEnum);
 
    if (dwResult != NO_ERROR)
    {  
        return FALSE;
    }
 
    /*
    GlobalAlloc : Allocates the specified number of bytes from the heap.
    UINT uFlags : The memory allocation attributes. 
                  GPTR - Combines GMEM_FIXED and GMEM_ZEROINIT;
                  GMEM_FIXED - Allocates fixed memory. The return value is a pointer;
                  GMEM_ZEROINIT - Initializes memory contents to zero;
    SIZE_T dwBytes : The number of bytes to allocate. If this parameter is zero and the uFlags parameter specifies 
                     GMEM_MOVEABLE, the function returns a handle to a memory object that is marked as discarded.
    If the function succeeds, the return value is a handle to the newly allocated memory object.
    If the function fails, the return value is NULL.
    */
    lpnrLocal = (LPNETRESOURCE) GlobalAlloc(GPTR, cbBuffer);
    if (lpnrLocal == NULL) 
        return FALSE;
 
    do
    {  
        /*
        The ZeroMemory macro fills a block of memory with zeros.
        void ZeroMemory(PVOID Destination, SIZE_T Length);
        Parameters:
        Destination : Pointer to the starting address of the block of memory to fill with zeros. 
        Length : Size of the block of memory to fill with zeros, in bytes.
        */
        ZeroMemory(lpnrLocal, cbBuffer);
 
        /*
        The WNetEnumResource function continues an enumeration of network resources that was 
        started by a call to the WNetOpenEnum function.
 
        DWORD WNetEnumResource(HANDLE hEnum, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize);
 
        Parameters:
        hEnum : Handle that identifies an enumeration instance. This handle must be returned by the 
                WNetOpenEnum function. 
        lpcCount : Pointer to a variable specifying the number of entries requested. If the number 
                   requested is –1, the function returns as many entries as possible. If the function 
                   succeeds, on return the variable pointed to by this parameter contains the number 
                   of entries actually read.
        lpBuffer : Pointer to the buffer that receives the enumeration results. The results are returned 
                   as an array of NETRESOURCE structures. Note that the buffer you allocate must be large 
                   enough to hold the structures, plus the strings to which their members point. The buffer 
                   is valid until the next call using the handle specified by the hEnum parameter. The 
                   order of NETRESOURCE structures in the array is not predictable.
        lpBufferSize : Pointer to a variable that specifies the size of the lpBuffer parameter, in bytes. 
                       If the buffer is too small to receive even one entry, this parameter receives the 
                       required size of the buffer.
        */
        dwResultEnum = WNetEnumResource(hEnum, &cEntries, lpnrLocal, &cbBuffer);
 
        if (dwResultEnum == NO_ERROR)
        {
            for(i = 0; i < cEntries; i++)
            {
                DisplayStruct(&(lpnrLocal[i]));
            }
        }
 
        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;
    }
    std::cout << std::endl;
    return TRUE;
}
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    setlocale(LC_CTYPE, "");
 
    GetMacAddresses();
    getchar();
 
    EnumerateFunc(0);
    getchar();
 
    return 0;
}