DirectX 9. Использование DirectPlay

        // Главный интерфейс Peer to Peer(при создании делается равным NULL)
IDirectPlay8Peer* lpPeer = NULL;

CoCreateInstance (CLSID_DirectPlay8Peer, // Идентификатор класса объекта
                  NULL,                  // должен быть установлен в NULL
                  CLSCTX_INPROC_SERVER,  // Указывает на то, что объект// реализован как DLL.
                  IID_IDirectPlay8Peer,  // Идентификатор интерфейса
                  (LPVOID*) &lpPeer);    // Ранее объявленный указатель на// интерфейс

lpPeer ->Initialize(PVOID 
  // Информация о пользователе(обычно делается равной NULL)const pvUserContext,   
  // Имя Функции, получающей сообщения от других клиентовconst PFNDPNMESSAGEHANDLER pfn, 
  // Спецификация соединения (обычно делается равной NULL)const DWORD dwFlags);

HRESULT WINAPI DirectPlayMessageHandler(PVOID pvUserContext, 
  DWORD dwMessageId, PVOID pMsgBuffer)
{
 return S_OK;
}

lpPeer ->EnumServiceProviders( 
  const GUID *const pguidServiceProvider,
  const GUID *const pguidApplication,
  const DPN_SERVICE_PROVIDER_INFO *const pSPInfoBuffer,
  DWORD *const pcbEnumData,
  DWORD *const pcReturned,
  const DWORD dwFlags);

DPN_SERVICE_PROVIDER_INFO*  pdnSPInfo         = NULL;
  DPN_SERVICE_PROVIDER_INFO*  pdnSPInfoEnum   = NULL;
  DWORD                       dwItems         = 0;
  DWORD                       dwSize          = 0;

  // Determine the required buffer size
  hr = g_pDP->EnumServiceProviders(NULL, NULL, NULL, &dwSize, &dwItems, 0);

  pdnSPInfo = (DPN_SERVICE_PROVIDER_INFO*) new BYTE[dwSize];
  
  //Fill the buffer with service provider information
  hr = g_pDP->EnumServiceProviders(NULL, NULL, 
    pdnSPInfo, &dwSize, &dwItems, 0)

  // Print the provider descriptions
  pdnSPInfoEnum = pdnSPInfo;
  for(DWORD i = 0; i < dwItems; i++)
  {
    printf("Found Service Provider:  %S\n", pdnSPInfoEnum->pwszName);
    pdnSPInfoEnum++;
  }

        typedef
        struct _DPN_SERVICE_PROVIDER_INFO {
    DWORD dwFlags;                // Флаг использования симулятора сети
    GUID guid;                    // Идентификатор провайдера
    WCHAR *pwszName;              // Имя провайдера
    PVOID pvReserved;             // Зарезервирован – должен быть NULL
    DWORD dwReserved;             // Зарезервирован – должен быть NULL
} DPN_SERVICE_PROVIDER_INFO, *PDPN_SERVICE_PROVIDER_INFO;

        // Создание хоста
HRESULT Host(
  // Специальная структура, описывающая приложениеconst DPN_APPLICATION_DESC *const pdnAppDesc,
  // Указатель на интерфейс (Адрес устройства)
  IDirectPlay8Address **const prgpDeviceInfo,
  // Указывает на количество объектов в rgpDeviceInfoconst DWORD cDeviceInfo,
  // Зарезервировано - NULLconst DPN_SECURITY_DESC *const pdpSecurity,
  // Зарезервировано - NULLconst DPN_SECURITY_CREDENTIALS *const pdpCredentials,
  // Необязательный параметр – увеличивается при присоединение клиента
  VOID *const pvPlayerContext,
  // Флагconst DWORD dwFlags);

        typedef
        struct _DPN_APPLICATION_DESC {
  DWORD dwSize;
  DWORD dwFlags;
  GUID guidInstance;
  GUID guidApplication;
  DWORD dwMaxPlayers;
  DWORD dwCurrentPlayers;
  WCHAR *pwszSessionName;
  WCHAR *pwszPassword;
  PVOID pvReservedData;
  DWORD dwReservedDataSize;
  PVOID pvApplicationReservedData;
  DWORD dwApplicationReservedDataSize;
} DPN_APPLICATION_DESC, *PDPN_APPLICATION_DESC;

HRESULT SetSP(
  // Возможные варианты GUID’ов приведены в таблице 1const GUID *const pguidSP);

HRESULT SetDevice(
  // Идентификатор устройства, полученный фун-ей EnumServiceProvidersconst GUID *const pguidDevice);

        // Объявление указателя на интерфейс IDirectPlay8Address – lpHostAdsress
        // ... 
        // Создание COM объекта, вызов требуемых функций
        // ...
HRESULT AddComponent(
  // назначаем тип – будь то порт, тел. номер...const WCHAR * const pwszName,
  // буфер, откуда будет взята информацияconstvoid * const lpvData,
  // размер буфераconst DWORD dwDataSize,
  // тип буфераconst DWORD dwDataType);

HRESULT Connect(
  // Структура, описывающая сетевое приложение (см. выше)const DPN_APPLICATION_DESC *const pdnAppDesc,
  // Адрес хоста
  IDirectPlay8Address *const pHostAddr,
  // Адрес устройства
  IDirectPlay8Address *const pDeviceInfo,
  // Зарезервировано - NULLconst DPN_SECURITY_DESC *const pdnSecurity,
  // Зарезервировано - NULLconst DPN_SECURITY_CREDENTIALS *const pdnCredentials, 
  // Информация о соединяющемся пользователе (Опционально - NULL)constvoid *const pvUserConnectData,
  // Размер pvUserConnectDataconst DWORD dwUserConnectDataSize,
  // Опционально - NULLvoid *const pvPlayerContext,
  // Опционально - NULLvoid *const pvAsyncContext,
  // Хендл
  DPNHANDLE *const phAsyncHandle,
  // Флагconst DWORD dwFlags
);

HRESULT SetPeerInfo(
  // Структура, характеризующая пользователяconst DPN_PLAYER_INFO * const pdpnPlayerInfo,
  // Ставится чаще всего в NULL
  PVOID const pvAsyncContext,
  // Хендл
  DPNHANDLE *const phAsyncHandle,
  // Флагconst DWORD dwFlags
);

        typedef
        struct _DPN_PLAYER_INFO {
  // Размер структуры
  DWORD dwSize;
  // Флаг 
  DWORD dwInfoFlags;
  // Имя пользователя
  PWSTR pwszName;
  // Информация, описывающая пользователя(буфер)
  PVOID pvData;
  // Размер буфера
  DWORD dwDataSize;
  // Дополнительная информация
  DWORD dwPlayerFlags;
} DPN_PLAYER_INFO, *PDPN_PLAYER_INFO;

        // Идентификатор главного окна
HWND hDirPlay;
// Основной интерфейс DirectPlay
IDirectPlay8Peer * g_pDP = NULL;
// Проверка, будет ли создан сервер
BOOL bHost = TRUE;
// Имя игрока
TCHAR chPlayerName[MAX_PATH];
// Имя сессии
TCHAR chSessionName[MAX_PATH];
// Идентификатор выбранного провайдера
GUID * guidServiceProviderSelect;
// Идентификатор выбранного устройства
GUID * guidSPDevice;
// GUID приложения – сгенерируйте с помощью // инструмента Create GUID в Visual Studiostaticconst GUID ApplicationGuid = ...;

HRESULT InitDirectPlay(HWND hDirPlay)
{
  // g_pDP – указатель на интерфейс IDirectPlay8Peer.

  HRESULT hr = S_OK;
  CoInitialize(NULL);
  //Создание основного объекта DirectPlay
  hr = CoCreateInstance(
    CLSID_DirectPlay8Peer, 
    NULL,
    CLSCTX_INPROC_SERVER,
    IID_IDirectPlay8Peer,
    (LPVOID*)&g_pDP);
  if(FAILED(hr))
  {
    DXTRACE_ERR_MSGBOX(_T("Ошибка при создании объекта"),hr);
    return hr;
  }

  //Инициализация DirectPlay
  hr = g_pDP->Initialize(NULL, DirectPlayMessageHandler, 0);
  if(FAILED(hr))
  {
    DXTRACE_ERR_MSGBOX(_T("Ошибка при инициализации"),hr);
    return hr;
  }
  return S_OK;
}

        struct ArrayHelper
{
  ArrayHelper(BYTE * array){ m_array = array; }
  ArrayHelper(BYTE * array)
  {
    if(m_array)
      delete[] m_array;
  }
  BYTE * m_array;
};
 
// Передаем в функцию только идентификатор окна 
HRESULT FindListProvider(HWND hDirPlay)         
{
  // bHost и guidSPDevice должны быть определены до вызова функции// g_pDP – указатель на интерфейс IDirectPlay8Peer.
  HRESULT hr = S_OK;
  // Переменная цикла
  DWORD = 0;
  // Основное хранилище данных о провайдерах
  DPN_SERVICE_PROVIDER_INFO * pdnSPInfo  = NULL;
  // Резервное хранилище данных о провайдерах
  DPN_SERVICE_PROVIDER_INFO * pdnSPInfoEnum = NULL;
  // Количество провайдеров
  DWORD dwItems = 0;
  // Размер буфера в байтах
  DWORD dwSize = 0;
  // Промежуточная строчка (иия провайдера для вывода)
  TCHAR strBuf[MAX_PATH]= {0};
  // Положение в списке провайдеровint nIndex = 0;
  // Находим число провайдеров и размер буфера
  hr = g_pDP->EnumServiceProviders(NULL, NULL, NULL, 
    &dwSize, &dwItems, NULL);

  // Обрабатываем, если произошла ошибкаif( FAILED(hr) && hr != DPNERR_BUFFERTOOSMALL)
  {
    DXTRACE_ERR_MSGBOX(_T("Error FindListProvider"),hr);
    return hr;
  }

  // Создаем массив полученного размера для хранения данных о провайдерах
  pdnSPInfo = (DPN_SERVICE_PROVIDER_INFO*) new BYTE[dwSize];
  // Контроль памяти, занятой под массив
  ArrayHelper SPInfoHelper(pdnSPInfo);

  // Записываем в созданный массив данные всех провайдеров
  hr = g_pDP->EnumServiceProviders(NULL, NULL, pdnSPInfo, 
    &dwSize, &dwItems, NULL);
  if(FAILED(hr))
  {
    // Обрабатываем возможные ошибки
    DXTRACE_ERR_MSGBOX(_T("Error FindListProvider"),hr);
    return hr;
  }

  // Цикл, выводящий найденнных провайдеров на экран// Копируем в резервную структуру
  pdnSPInfoEnum = pdnSPInfo;
  // Создаем циклfor(DWORD i = 0; i < dwItems; i++)
  {
    // Конвертируем в strBuf имя провайдера
    DXUtil_ConvertWideStringToGenericCch(strBuf, 
      pdnSPInfoEnum->pwszName, MAX_PATH );
    // Добавляем в список IDC_LISTSP
    nIndex = (int)SendDlgItemMessage( hDirPlay, IDC_LISTSP, LB_ADDSTRING,
      0, (LPARAM) strBuf );
    
    // Записываем GUID в список с названиями

    GUID * pGuid = new GUID;
    if(NULL == pGuid)
    {
          DXTRACE_ERR_MSGBOX(_T("Не хватает памяти"), E_OUTOFMEMORY);
          return E_OUTOFMEMORY;
    }
    *pGuid = pdnSPInfoEnum->guid;

    // Добавляем в IDC_LISTSP
    SendDlgItemMessage(hDirPlay, IDC_LISTSP, LB_SETITEMDATA,
              nIndex, (LPARAM)&Guid);
    
    //Переходим на следующего найденного провайдера
    pdnSPInfoEnum++;
  }

  // Если провайдеров не найдено...if(0 == dwItems)
      DXTRACE_ERR_MSGBOX(_T("Провайдеры не найдены"),0);

  return S_OK;
}

HRESULT EnumAdapterSP(HWND hDlg, const GUID* pGuidSP)
{
  // bHost и guidSPDevice должны быть определены до вызова функции// g_pDP – указатель на интерфейс IDirectPlay8Peer.
  HRESULT hr = S_OK;
  // Информация о провайдере
  DPN_SERVICE_PROVIDER_INFO * pdnSPInfo = NULL;
  DWORD dwItems = 0; // Количество провайдеров
  DWORD dwSize = 0; // Размер для создания массиваint nIndex; // Положение в списке//Строковый буфер для хранения имени устройства
  TCHAR strName[MAX_PATH];
  //Обнуляем содержимое элемента
  SendDlgItemMessage(hDlg, IDC_COMBODEVICE, CB_RESETCONTENT, 0, 0);
  // Получить размер для массива от провайдера// Заметьте, первый аргумент заполнен(!!!)
  hr = g_pDP->EnumServiceProviders(pGuidSP, NULL, NULL, &dwSize, &dwItems, 0);

  // Обрабатываем ошибкиif(FAILED(hr) && hr != DPNERR_BUFFERTOOSMALL) 
  {
      DXTRACE_ERR_MSGBOX(_T("Failed Enumerating Service Providers"),hr);
      return hr;
  }

  // Создаем массив полученного размера для хранения данных об устройствах
  pdnSPInfo = (DPN_SERVICE_PROVIDER_INFO*) new BYTE[dwSize]; 
  // Контроль памяти, занятой под массив
  ArrayHelper SPInfoHelper(pdnSPInfo);
  
  // Заполняем массив 
  hr = g_pDP->EnumServiceProviders(pGuidSP, NULL, 
    pdnSPInfo, &dwSize, &dwItems, 0);
  if(FAILED(hr))
  {                                                 
    DXTRACE_ERR_MSGBOX(_T("Failed Enumerating Service Providers"),hr);
    return hr;
  }
  // Резервные данные
  DPN_SERVICE_PROVIDER_INFO* pdnSPInfoEnum;
  pdnSPInfoEnum = pdnSPInfo;
  for (DWORD i = 0; i < dwItems; i++ )       // Пускаем цикл
  {
    // Конвертируем в strName имя устройства 
    DXUtil_ConvertWideStringToGenericCch(strName, 
      pdnSPInfoEnum->pwszName, MAX_PATH );

    // Добавляем в список имя устройства
    nIndex = (int)SendDlgItemMessage(hDlg, IDC_COMBODEVICE, CB_ADDSTRING, 
      0, (LPARAM) strName );

    // Добавляем в список идентификатор устройства
    GUID * pGuid = new GUID;
    if(NULL == pGuid)
    {
          DXTRACE_ERR_MSGBOX(_T("Не хватает памяти"), E_OUTOFMEMORY);
          return E_OUTOFMEMORY;
    }
    *pGuid = pdnSPInfoEnum->guid;

    SendDlgItemMessage(hDlg, IDC_COMBODEVICE, CB_SETITEMDATA,
      nIndex, (LPARAM)&Guid );

    // Переходим к следующему элементу массива
    pdnSPInfoEnum++;
  }

  // Устанавливаем положение в списке (в нулевую позицию)
  SendDlgItemMessage(hDlg, IDC_COMBODEVICE,CB_SETCURSEL, 0, 0);
  return hr;
}

HRESULT SwitchCreateHost(HWND hDlg, GUID* pGuidSP)
{
  // bHost и guidSPDevice должны быть определены до вызова функции// g_pDP – указатель на интерфейс IDirectPlay8Peer.if(pGuidSP == NULL)
    return E_POINTER;
  bHost = IsDlgButtonChecked(hDlg, IDC_CHECKHOST);
  // IDC_COMBODEVICE – элемент, содержащий список устройств// IDC_CHECKHOST – элемент управления CheckButton// IDC_PHONENAMEHOST –обычное текстовое поле, используется // для ввода телефона, если выбран провайдер MODEM, или имени хоста,// если выбран TCP/IP// IDC_LINE1 – метка, поясняющая IDC_PHONENAMEHOST// IDC_PORT –  текстовое поле для ввода порта, в случае выбора TCP/IP// IDC_LINE2 – метка, поясняющая IDC_PORTif(*pGuidSP == CLSID_DP8SP_TCPIP)
  {
    EnableWindow(GetDlgItem(hDlg, IDC_COMBODEVICE), TRUE);
    EnableWindow(GetDlgItem(hDlg, IDOK), TRUE);
    EnableWindow(GetDlgItem(hDlg, IDC_CHECKHOST), TRUE);
    SetWindowText(hDlg, _T("TCP/IP - Вы выбрали"));

    SetDlgItemText(hDlg, IDC_LINE1, _T("Имя хоста:"));
    EnableWindow(GetDlgItem(hDlg, IDC_LINE1), !bHost);
    EnableWindow(GetDlgItem(hDlg, IDC_PHONENAMEHOST), !bHost);
    EnableWindow(GetDlgItem(hDlg, IDC_LINE2), TRUE);
    SetDlgItemText(hDlg,IDC_LINE2, _T("Порт:"));
    EnableWindow(GetDlgItem(hDlg, IDC_PORT), TRUE);
  }
  elseif(*pGuidSP == CLSID_DP8SP_IPX)
  {
    MessageBox( hDlg, 
      _T("Выбраный вами протокол (IPX) НЕ ПОДДЕРЖИВАЕТСЯ"),
      _T("IPX"), MB_OK | MB_ICONQUESTION); 
  }
  elseif(*pGuidSP == CLSID_DP8SP_SERIAL)
  {
    SetWindowText(hDlg, _T("SERIAL - Вы выбрали"));
    EnableWindow(GetDlgItem(hDlg,IDC_COMBODEVICE),TRUE);
    EnableWindow(GetDlgItem(hDlg,IDOK),TRUE);
      EnableWindow(GetDlgItem(hDlg,IDC_CHECKHOST),TRUE);
    SetDlgItemText(hDlg,IDC_LINE1,NULL);
    EnableWindow(GetDlgItem(hDlg,IDC_LINE1),FALSE);
    EnableWindow(GetDlgItem(hDlg,IDC_PHONENAMEHOST),FALSE);
    EnableWindow(GetDlgItem(hDlg,IDC_LINE2),FALSE);
    SetDlgItemText(hDlg,IDC_LINE2,NULL);
    EnableWindow(GetDlgItem(hDlg,IDC_PORT),FALSE); 
  }
  elseif(*pGuidSP == CLSID_DP8SP_MODEM)
  {
    SetWindowText(hDlg, _T("MODEM - Вы выбрали"));
    EnableWindow(GetDlgItem(hDlg, IDC_COMBODEVICE), TRUE);
    EnableWindow(GetDlgItem(hDlg, IDOK), TRUE);
    EnableWindow(GetDlgItem(hDlg, IDC_CHECKHOST), TRUE);
    SetDlgItemText(hDlg,IDC_LINE1, _T("Телефон:"));
    EnableWindow(GetDlgItem(hDlg, IDC_LINE1), TRUE);
    EnableWindow(GetDlgItem(hDlg, IDC_PHONENAMEHOST), TRUE);
    EnableWindow(GetDlgItem(hDlg, IDC_LINE2), FALSE);
    SetDlgItemText(hDlg, IDC_LINE2, NULL);
    EnableWindow(GetDlgItem(hDlg, IDC_PORT), FALSE);
  } 
  else
  {
    MessageBox( hDlg, _T("Выбранный Вами пункт не поддерживается"),
      _T("Произошла ошибка"), MB_OK | MB_ICONQUESTION); 
    SetWindowText(hDlg, _T("Произошла ошибка"));
    SetDlgItemText(hDlg, IDC_LINE1, NULL);
    EnableWindow(GetDlgItem(hDlg, IDC_LINE1), FALSE);
    EnableWindow(GetDlgItem(hDlg, IDC_PHONENAMEHOST), FALSE);
    EnableWindow(GetDlgItem(hDlg, IDC_LINE2), FALSE);
    SetDlgItemText(hDlg, IDC_LINE2, NULL);
    EnableWindow(GetDlgItem(hDlg, IDC_PORT), FALSE);
    SendDlgItemMessage(hDlg, IDC_COMBODEVICE, CB_RESETCONTENT, 0, 0);
    EnableWindow(GetDlgItem(hDlg, IDC_COMBODEVICE), FALSE);
    EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
    EnableWindow(GetDlgItem(hDlg, IDC_CHECKHOST), FALSE);
  }
  return S_OK;
}

HRESULT JoinHostGame(HWND hDlg, GUID * pGuidSP, GUID* guidSPDevice, bool bHost)
{
  
  // g_pDP – указатель на интерфейс IDirectPlay8Peer.
  HRESULT hr = S_OK;
  CComPtr<IDirectPlay8Address> spDeviceAddress; // Адрес устройства
  CComPtr<IDirectPlay8Address> spHostAddress; // Адрес хоста// Начало инициализации адреса устройства
  hr = CoCreateInstance(CLSID_DirectPlay8Address, NULL,
    CLSCTX_INPROC_SERVER, IID_IDirectPlay8Address, (void**)&spDeviceAddress);
  if(FAILED(hr))
  {
      DXTRACE_ERR_MSGBOX(_T("Ошибка при инициализации устройства"),hr);
      return hr;
  }

  // Назначение идентификатора провайдера устройству
  hr = spDeviceAddress->SetSP(pGuidSP);
  if(FAILED(hr))
  {
    DXTRACE_ERR_MSGBOX(_T("Ошибка при назначении провайдера устройству"),hr);
    return hr;
  }

  // Задаем тип устройства
  hr = spDeviceAddress->SetDevice(guidSPDevice);
  if(FAILED(hr))
  {
    DXTRACE_ERR_MSGBOX(_T("Ошибка при назначении устройства"),hr);
    return hr;
  }

  // Если пользователь хочет подключиться к уже готовому хосту, начинаем// инициализацию подключения к удаленному хосту.if(!bHost)
  {
    // Создание адреса хоста
    hr = CoCreateInstance(CLSID_DirectPlay8Address, NULL,
      CLSCTX_INPROC_SERVER, IID_IDirectPlay8Address, (void**)&spHostAddress);
    if(FAILED(hr))
    {
      DXTRACE_ERR_MSGBOX(_T("Ошибка при инициализации хоста"),hr);
      return hr;
    }

    // Задаем идентификатор провайдера
    hr = spHostAddress->SetSP(pGuidSP);
    if(FAILED(hr))
    {
      DXTRACE_ERR_MSGBOX(_T("Ошибка при назначении адреса хоста"),hr);
      return hr;
    }
  }

  // ------------------------------------------------------------------------// Если соединение производится по TCP/IP...if(*pGuidSP == CLSID_DP8SP_TCPIP)
  {
    TCHAR strHostname[MAX_PATH];
    TCHAR strPort[MAX_PATH];

    GetDlgItemText(hDlg, IDC_PHONENAMEHOST, strHostname, MAX_PATH);
    GetDlgItemText(hDlg, IDC_PORT, strPort, MAX_PATH);

    // Если пользователь хочет создать новый хост.if(bHost)
    {
      if(_tcslen(strPort) > 0)
      {
        // Добавляем порт к spDeviceAddress
        DWORD dwPort = _ttoi(strPort);
        hr = spDeviceAddress->AddComponent(DPNA_KEY_PORT,
          &dwPort, sizeof(dwPort),
          DPNA_DATATYPE_DWORD);
        if(FAILED(hr))
        {
         DXTRACE_ERR_MSGBOX(_T("Извините, ошибка при назначении порта"),hr);
         return hr;
        }
      }
    }
    else
    {
      // Если пользователь хочет подключиться к уже готовому хосту, начинаем// инициализацию подключения к удаленному хосту.// Добавляем имя хоста (то есть его IP-адрес) к spHostAddressif(_tcslen(strHostname) > 0)
      {
        WCHAR wstrHostname[MAX_PATH];
        DXUtil_ConvertGenericStringToWideCch(wstrHostname,
          strHostname, MAX_PATH);

        hr = spHostAddress->AddComponent(DPNA_KEY_HOSTNAME,
          wstrHostname, (DWORD) (wcslen(wstrHostname) + 1) * sizeof(WCHAR),
          DPNA_DATATYPE_STRING);
        if(FAILED(hr))
        {
          DXTRACE_ERR_MSGBOX(_T("Ошибка при назначении IP-адреса хоста"),hr);
          return hr;
        }
      }

      if(_tcslen(strPort) > 0)
      {
        // Добавляем порт к spDeviceAddress
        DWORD dwPort = _ttoi(strPort);
        hr = spHostAddress->AddComponent(DPNA_KEY_PORT,
          &dwPort, sizeof(dwPort),
          DPNA_DATATYPE_DWORD);
        if(FAILED(hr))
        {
          DXTRACE_ERR_MSGBOX(_T("Извините, ошибка при назначении порта"),hr);
          return hr;
        }
      }
    }
  }

  // ------------------------------------------------------------------------// Если соединение производится через модем...if(*pGuidSP == CLSID_DP8SP_MODEM)
  {
    // Получаем значение телефонного номера
    TCHAR tchPhoneNumber[MAX_PATH];
    GetDlgItemText(hDlg, IDC_PHONENAMEHOST, tchPhoneNumber, MAX_PATH);

    // Если пользователь хочет подключиться к имеющемуся хостуif(!bHost)
    {
      // Если телефонный номер задан...if(_tcslen(tchPhoneNumber) > 0)
      {
        WCHAR wchPhoneNumber[MAX_PATH];
        // Конвертация из TCHAR в WCHAR
        DXUtil_ConvertGenericStringToWideCch(wchPhoneNumber,
          tchPhoneNumber, MAX_PATH);

        // Добавляем номер телефона к spDeviceAddress
        hr = spHostAddress->AddComponent(DPNA_KEY_PHONENUMBER, wchPhoneNumber,
          (DWORD)(wcslen(wchPhoneNumber) + 1) * sizeof(WCHAR),
          DPNA_DATATYPE_STRING);
        if(FAILED(hr))
        {
        DXTRACE_ERR_MSGBOX(_T("Ошибка при инициализации телефонного номера"),hr);
        return hr;
        }

      }
    }
  }

  // ------------------------------------------------------------------------// Если соединение производится по протоколу SERIAL...if(*pGuidSP == CLSID_DP8SP_SERIAL)
  {
    MessageBox(hDlg, _T("Извините, данный протокол не обрабатывается"),
      _T("DirectSendPlay"), MB_OK | MB_ICONQUESTION);
  }

  // ------------------------------------------------------------------------// Если соединение производится по протоколу IPX...if(*pGuidSP == CLSID_DP8SP_IPX)
  {
    MessageBox(hDlg, _T("Извините, данный протокол не обрабатывается"),
      _T("DirectSendPlay"), MB_OK | MB_ICONQUESTION);
  }

  // ------------------------------------------------------------------------// Заполнение стуктур DPN_PLAYER_INFO, DPN_APPLICATION_DESC
  GetDlgItemText(hDlg, IDC_EDIT1, chPlayerName, MAX_PATH);
  WCHAR wchNamePlayer[MAX_PATH];
  // Преобразование из TCHAR в WCHAR
  DXUtil_ConvertGenericStringToWideCch(wchNamePlayer,
    chPlayerName, MAX_PATH);

  // Структура, описывающая игрока
  DPN_PLAYER_INFO dpPlayerInfo;
  // Обнуляем содержимое структуры
  ZeroMemory(&dpPlayerInfo, sizeof(DPN_PLAYER_INFO));
  // Задаем размер структуры
  dpPlayerInfo.dwSize = sizeof(DPN_PLAYER_INFO);
  // Задаем дополнительные флаги
  dpPlayerInfo.dwInfoFlags = DPNINFO_NAME;
  // Задаем имя игрока
  dpPlayerInfo.pwszName = wchNamePlayer;
  // Задаем информацию об игроке
  hr = g_pDP->SetPeerInfo(&dpPlayerInfo, NULL, NULL, DPNOP_SYNC);
  if(FAILED(hr))
  {
    DXTRACE_ERR_MSGBOX(_T("Ошибка при передаче информации о игроке"),hr);
    return hr;
  }

  // Структура, описывающая сетевое приложение
  DPN_APPLICATION_DESC dpnAppDesc;
  ZeroMemory(&dpnAppDesc, sizeof(DPN_APPLICATION_DESC));
  dpnAppDesc.dwSize = sizeof(DPN_APPLICATION_DESC);
  dpnAppDesc.dwFlags = DPNSESSION_NODPNSVR;
  // Задаем GUID приложения
  dpnAppDesc.guidApplication = ApplicationGuid;
  dpnAppDesc.guidInstance = GUID_NULL;
  // Имя сессии пока инициализируется значением NULL
  dpnAppDesc.pwszSessionName = NULL;

  // -------------------------------------------------------------------------// Создание хостаif(bHost)
  {
    DWORD dwHostFlags = 0;
    // Считываем имя сессии
    GetDlgItemText(hDlg, IDC_NAMESESSION, chSessionName, MAX_PATH);
    // Если строка не пустаif(_tcslen(chSessionName) > 0)
    {
      WCHAR wchSessionName[MAX_PATH];
      DXUtil_ConvertGenericStringToWideCch(wchSessionName,
        chSessionName, MAX_PATH);
      // Задаем имя сессии
      dpnAppDesc.pwszSessionName = wchSessionName;
    }
    // Назначаем хост сессии
    hr = g_pDP->Host(
      // Задаем описание приложения
      &dpnAppDesc,
      // Задаем адрес устройства
      &spDeviceAddress,
      // Указываем, что устройство одно
      1,
      NULL, NULL, NULL,
      // Указываем, что не нужно выводить стандартное окно.// Если нужно, чтобы это окно показывалось, // нужно указать флаг DPNHOST_OKTOQUERYFORADDRESSING.
      0);
    if(FAILED(hr))
    {
      DXTRACE_ERR_MSGBOX(_T("Ошибка при назначении хоста"),hr);
      return hr;
    }
  }
  // ------------------------------------------------------------------------// Соединение с уже созданным хостомelse
  {
    DWORD dwConnectFlags = 0;
    // Установка соединения
    hr = g_pDP->Connect(&dpnAppDesc,
      // Адрес хоста
      spHostAddress,
      // Адрес устройства, через которое производится соединение
      spDeviceAddress,
      NULL,
      NULL,
      NULL,
      // указываем, что в параметре pvUserConnectData данные отсутствуют
      0,
      NULL,
      NULL,
      NULL,
      dwConnectFlags);
    if(FAILED(hr))
    {
      DXTRACE_ERR_MSGBOX(_T("Ошибка при назначении соединения"),hr);
      return hr;
    }
  }
  return(hr);
}

HRESULT WINAPI DirectPlayMessageHandler( PVOID pvUserContext, 
                     DWORD dwMessageId, 
                     PVOID pMsgBuffer )
{
  switch(dwMessageId)
  {
    case DPN_MSGID_CONNECT_COMPLETE:
    {
      PDPNMSG_CONNECT_COMPLETE pConnectCompleteMsg;
      pConnectCompleteMsg=(PDPNMSG_CONNECT_COMPLETE)pMsgBuffer;
      if(FAILED(pConnectCompleteMsg->hResultCode))
      {
        DXTRACE_ERR_MSGBOX(_T("DPN_MSGID_CONNECT_COMPLETE"),  
        pConnectCompleteMsg->hResultCode );
        break;
      }
      else
      MessageBox(hDirPlay,_T("Подключение прошло
      удачно"),_T("Проверка"),MB_OK); 
      break;
    }
  }
  return S_OK;
}