Descent3/networking/directplay.cpp

/*
 * $Logfile: /DescentIII/Main/directplay/directplay.cpp $
 * $Revision: 12 $
 * $Date: 4/14/99 1:12a $
 * $Author: Jeff $
 *
 *	Directplay API
 *
 * $Log: /DescentIII/Main/directplay/directplay.cpp $
 *
 * 12    4/14/99 1:12a Jeff
 * fixed case mismatched #includes
 *
 * 11    2/16/99 12:36a Kevin
 * Fixes for release builds of OEM V3 and KAtmai
 *
 * 10    2/15/99 1:22p Kevin
 * Changes for GameGauge
 *
 * 9     1/21/99 11:15p Jeff
 * pulled out some structs and defines from header files and moved them
 * into seperate header files so that multiplayer dlls don't require major
 * game headers, just those new headers.  Side effect is a shorter build
 * time.  Also cleaned up some header file #includes that weren't needed.
 * This affected polymodel.h, object.h, player.h, vecmat.h, room.h,
 * manage.h and multi.h
 *
 * 8     10/08/98 5:20p Kevin
 * Fixed dependancies and fixed demo config
 *
 * 7     9/02/98 6:54p Kevin
 * Fixed general directplay support up, and got modem-modem working
 *
 * 6     8/24/98 10:55a Kevin
 * new directplay stuff
 *
 * 5     8/19/98 11:49a Kevin
 * Got DirectPlay IPX working, and localized connection DLLs
 *
 * 4     8/14/98 4:54p Kevin
 * More directplay stuff
 *
 * 3     8/13/98 6:36p Kevin
 * checked that  lpDirectPlay4A was non null
 *
 * 2     8/13/98 6:32p Kevin
 * Initial implementation of directplay API
 *
 * 1     8/13/98 6:25p Kevin
 *
 */

#include <windows.h>
#include <winsock.h>
#include <wsipx.h>
#include <ras.h>
#include <objbase.h>

#include "descent.h"
#include "player.h"
#include "appdatabase.h"

#include "pstypes.h"
#include "pserror.h"
#include "mono.h"
#include "networking.h"
#include "ddio.h"
#include "mem.h"
#include "multi.h"

#include "directplay.h"

bool Use_DirectPlay = false;

DPSESSIONDESC2 Directplay_sessions[MAX_DP_GAMES];
int Num_directplay_games = 0;

char Directplay_session_desc[MAX_DP_GAMES][200];
bool Directplay_lobby_launched_game = false;
void *lpAddress = NULL;

// char Directplay_modem_list[MAX_MODEMS][200];
modem_list Modems_found[MAX_MODEMS];
int Num_modems_found = 0;

LPVOID lpConnectionBuffer;
LPDIRECTPLAY4A lpDirectPlay4A = NULL;
LPDIRECTPLAYLOBBY3A lpDirectPlayLobby3A = NULL;
LPDPLCONNECTION lpdplconnection = NULL;

// {915CE160-3125-11d2-BB3D-00104B27BFF0}
static const GUID DPD3_GUID = {0x915ce160, 0x3125, 0x11d2, {0xbb, 0x3d, 0x0, 0x10, 0x4b, 0x27, 0xbf, 0xf0}};

unsigned long Pending_dp_conn[MAX_PENDING_NEW_CONNECTIONS];

typedef struct _dpconnections {
  char name[100];
  void *conn;
} dpconnections;

dpconnections dpconns[MAX_DIRECTPLAY_CONNECTIONS];

BOOL FAR PASCAL DirectPlayEnumConnectionsCallback(LPCGUID lpguidSP, LPVOID lpConnection, DWORD dwConnectionSize,
                                                  LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext) {

  mprintf((0, "Directplay connection found: %s\n", lpName->lpszShortNameA));
  // Do something with the list of connections
  for (int i = 0; i < MAX_DIRECTPLAY_CONNECTIONS; i++) {
    if (dpconns[i].conn == NULL) {
      dpconns[i].conn = mem_malloc(dwConnectionSize);
      memcpy(dpconns[i].conn, lpConnection, dwConnectionSize);
      strcpy(dpconns[i].name, lpName->lpszShortNameA);
      return (TRUE);
    }
  }
  mprintf((0, "No space for Directplay entry.\n"));

  return (TRUE);
}

BOOL FAR PASCAL EnumSessionsCallback(LPCDPSESSIONDESC2 lpSessionDesc, LPDWORD lpdwTimeOut, DWORD dwFlags,
                                     LPVOID lpContext) {
  if (!lpSessionDesc)
    return (FALSE);

  if (Num_directplay_games < MAX_DP_GAMES) {
    mprintf((0, "Found Directplay game[%d]: %s\n", Num_directplay_games, lpSessionDesc->lpszSessionNameA));
    memcpy(&Directplay_sessions[Num_directplay_games], lpSessionDesc, sizeof(DPSESSIONDESC2));
    strcpy(Directplay_session_desc[Num_directplay_games], lpSessionDesc->lpszSessionNameA);
    Directplay_sessions[Num_directplay_games].lpszSessionNameA = Directplay_session_desc[Num_directplay_games];
    // mprintf((0,"Found Directplay game[%d]:
    // %s\n",Num_directplay_games,Directplay_sessions[Num_directplay_games].lpszSessionNameA));
    Num_directplay_games++;
  } else
    return FALSE;

  return (TRUE);
}

int dp_SelectDirectPlayConnection(char *name) {
  HRESULT hr;
  void *connection = NULL;
  int i;
  if (!lpDirectPlay4A)
    return 0;
  if (name) {
    if (lpAddress)
      mem_free(lpAddress);
    lpAddress = NULL;
    for (i = 0; i < MAX_DIRECTPLAY_CONNECTIONS; i++) {
      if (strcmpi(dpconns[i].name, name) == 0) {
        mprintf((0, "Found DirectPlay connection: %s\n", name));
        connection = dpconns[i].conn;
        break;
      }
    }
    if (!connection) {
      mprintf((0, "Unable to find DirectPlay connection: %s\n", name));
      return 0;
    }
  } else
    connection = lpAddress;

  memset(&dpconns, 0, sizeof(dpconnections) * MAX_DIRECTPLAY_CONNECTIONS);

  hr = lpDirectPlay4A->InitializeConnection(connection, 0);

  for (i = 0; i < MAX_DIRECTPLAY_CONNECTIONS; i++) {
    if (dpconns[i].conn != NULL) {
      mem_free(dpconns[i].conn);
      dpconns[i].conn = NULL;
      dpconns[i].name[0] = NULL;
    }
  }

  if (FAILED(hr)) {
    mprintf((0, "lpDirectPlay4A->InitializeConnection() failed.\n"));
    switch (hr) {
    case DPERR_ALREADYINITIALIZED:
      mprintf((0, "Error: DPERR_ALREADYINITIALIZED\n"));
      break;
    case DPERR_INVALIDFLAGS:
      mprintf((0, "Error: DPERR_INVALIDFLAGS\n"));
      break;
    case DPERR_INVALIDPARAMS:
      mprintf((0, "Error: DPERR_INVALIDPARAMS\n"));
      break;
    case DPERR_UNAVAILABLE:
      mprintf((0, "Error: DPERR_UNAVAILABLE\n"));
      break;
    default:
      mprintf((0, "Error: Unknown\n"));
    }

    return 0;
  } else
    return 1;
}

int dp_InitDirectPlay(char *conn_name, void *parms, int num_elements) {
  unsigned long dwAddressSize;
  HRESULT hr;
  char *conn = conn_name;
  for (int i = 0; i < MAX_PENDING_NEW_CONNECTIONS; i++)
    Pending_dp_conn[i] = DPID_UNKNOWN;

  // Delete any previous directplay instance
  if (lpDirectPlay4A)
    lpDirectPlay4A->Release();
  if (SUCCEEDED(CoCreateInstance(CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, IID_IDirectPlay4A,
                                 (LPVOID *)&lpDirectPlay4A))) {
    lpDirectPlay4A->EnumConnections(&DPD3_GUID, DirectPlayEnumConnectionsCallback, 0, 0);
  } else {
    lpDirectPlay4A = NULL;
  }
  if (parms) {
    if (lpDirectPlayLobby3A) {
      lpDirectPlayLobby3A->Release();
      lpDirectPlayLobby3A = NULL;
    }

    hr = CoCreateInstance(CLSID_DirectPlayLobby, NULL, CLSCTX_INPROC_SERVER, IID_IDirectPlayLobby3A,
                          (LPVOID *)&lpDirectPlayLobby3A);
    if (SUCCEEDED(hr)) {
      hr = lpDirectPlayLobby3A->CreateCompoundAddress((LPDPCOMPOUNDADDRESSELEMENT)parms, num_elements, NULL,
                                                      &dwAddressSize);
      if (hr == DPERR_BUFFERTOOSMALL) {
        if (lpAddress)
          mem_free(lpAddress);
        lpAddress = mem_malloc(dwAddressSize);
        hr = lpDirectPlayLobby3A->CreateCompoundAddress((LPDPCOMPOUNDADDRESSELEMENT)parms, num_elements, lpAddress,
                                                        &dwAddressSize);
        if (FAILED(hr)) {
          mprintf((0, "lpDirectPlayLobby3A->CreateCompoundAddress() failed. DirectPlay *NOT* initialized!\n"));
          return 0;
        } else {
          mprintf((0, "lpDirectPlayLobby3A->CreateCompoundAddress() succeeded!\n"));
        }
      } else {
        mprintf((0, "lpDirectPlayLobby3A->CreateCompoundAddress() buffer size request failed. DirectPlay *NOT* "
                    "initialized!\n"));
      }
    }
  }
  if (dp_SelectDirectPlayConnection(conn)) {
    DP_active = TRUE;
    mprintf((0, "DirectPlay Initialized\n"));
    return 1;
  }
  return 0;
}

// Everyone should call this when leaving the game.
void dp_EndGame() {
  mprintf((0, "Ending DirectPlay game.\n"));
  if ((!DP_active) || (!lpDirectPlay4A))
    return;
  lpDirectPlay4A->Close();
  lpDirectPlay4A->Release();
  lpDirectPlay4A = NULL;
}

// This function gets called when a game is started, so Direcplay knows the title, and to listen
int dp_StartGame(char *gamename) {
  long hres;
  DPNAME server_player;
  DPSESSIONDESC2 sessionDesc;

  mprintf((0, "Starting DirectPlay game: %s\n", gamename));

  if ((!DP_active) || (!lpDirectPlay4A)) {
    mprintf((0, "Can't start game because DirectPlay isn't initialized!\n"));
    return 0;
  }
  // Host a new session.
  ZeroMemory(&sessionDesc, sizeof(DPSESSIONDESC2));
  sessionDesc.dwSize = sizeof(DPSESSIONDESC2);
  sessionDesc.dwFlags =
      DPSESSION_CLIENTSERVER | DPSESSION_KEEPALIVE | DPSESSION_OPTIMIZELATENCY | DPSESSION_DIRECTPLAYPROTOCOL;
  sessionDesc.guidApplication = DPD3_GUID;
  sessionDesc.dwMaxPlayers = MAX_NET_PLAYERS;
  sessionDesc.dwCurrentPlayers = 1; // The server is a player
  sessionDesc.lpszSessionNameA = gamename;

  ZeroMemory(&server_player, sizeof(DPNAME));
  server_player.dwSize = sizeof(DPNAME);
  server_player.lpszShortNameA = Players[Player_num].callsign;
  server_player.lpszLongNameA = NULL;

  // if(lpAddress)
  //{
  //	hres = lpDirectPlay4A->Open((DPSESSIONDESC2 *)lpAddress, DPOPEN_CREATE | DPOPEN_RETURNSTATUS);
  //}
  // else
  //{
  hres = lpDirectPlay4A->Open(&sessionDesc, DPOPEN_CREATE | DPOPEN_RETURNSTATUS);
  //}

  if (SUCCEEDED(hres)) {
    NetPlayers[Player_num].hPlayerEvent = CreateEvent(NULL,  // no security
                                                      FALSE, // auto reset
                                                      FALSE, // initial event reset
                                                      NULL); // no name
    if (NetPlayers[Player_num].hPlayerEvent == NULL) {
      mprintf((0, "Failed to create directplay notification event!\n"));
      dp_EndGame();
      DP_active = false;
      return 0;
    }
    hres = lpDirectPlay4A->CreatePlayer(&NetPlayers[Player_num].dpidPlayer, &server_player,
                                        NetPlayers[Player_num].hPlayerEvent, NULL, 0, DPPLAYER_SERVERPLAYER);
    if (FAILED(hres)) {
      mprintf((0, "Failed to create directplay player in dp_StartGame()\n"));
      switch (hres) {
      case DPERR_CANTADDPLAYER:
        mprintf((0, "Unable to create player. Error code: DPERR_CANTADDPLAYER\n"));
        break;
      case DPERR_CANTCREATEPLAYER:
        mprintf((0, "Unable to create player. Error code: DPERR_CANTCREATEPLAYER\n"));
        break;
      case DPERR_CONNECTIONLOST:
        mprintf((0, "Unable to create player. Error code: DPERR_CONNECTIONLOST\n"));
        break;
      case DPERR_INVALIDFLAGS:
        mprintf((0, "Unable to create player. Error code: DPERR_INVALIDFLAGS\n"));
        break;
      case DPERR_INVALIDPARAMS:
        mprintf((0, "Unable to create player. Error code: DPERR_INVALIDPARAMS\n"));
        break;
      case DPERR_NOCONNECTION:
        mprintf((0, "Unable to create player. Error code: DPERR_NOCONNECTION\n"));
        break;
      default:
        mprintf((0, "Unable to create player. Error code: Unknown\n"));
        break;
      }
      return 0;
    }
    // Success
    return 1;
  } else {
    switch (hres) {

    case DPERR_ACCESSDENIED:
      mprintf((0, "Failed to create Directplay session (DPERR_ACCESSDENIED)!\n"));
      break;
    case DPERR_ALREADYINITIALIZED:
      mprintf((0, "Failed to create Directplay session (DPERR_ALREADYINITIALIZED)!\n"));
      break;
    case DPERR_AUTHENTICATIONFAILED:
      mprintf((0, "Failed to create Directplay session (DPERR_AUTHENTICATIONFAILED)!\n"));
      break;
    case DPERR_CANNOTCREATESERVER:
      mprintf((0, "Failed to create Directplay session (DPERR_CANNOTCREATESERVER)!\n"));
      break;
    case DPERR_CANTLOADCAPI:
      mprintf((0, "Failed to create Directplay session (DPERR_CANTLOADCAPI)!\n"));
      break;
    case DPERR_CANTLOADSECURITYPACKAGE:
      mprintf((0, "Failed to create Directplay session (DPERR_CANTLOADSECURITYPACKAGE)!\n"));
      break;
    case DPERR_CANTLOADSSPI:
      mprintf((0, "Failed to create Directplay session (DPERR_CANTLOADSSPI)!\n"));
      break;
    case DPERR_CONNECTING:
      mprintf((0, "Failed to create Directplay session (DPERR_CONNECTING)!\n"));
      break;
    case DPERR_CONNECTIONLOST:
      mprintf((0, "Failed to create Directplay session (DPERR_CONNECTIONLOST)!\n"));
      break;
    case DPERR_ENCRYPTIONFAILED:
      mprintf((0, "Failed to create Directplay session (DPERR_ENCRYPTIONFAILED)!\n"));
      break;
    case DPERR_ENCRYPTIONNOTSUPPORTED:
      mprintf((0, "Failed to create Directplay session (DPERR_ENCRYPTIONNOTSUPPORTED)!\n"));
      break;
    case DPERR_INVALIDFLAGS:
      mprintf((0, "Failed to create Directplay session (DPERR_INVALIDFLAGS)!\n"));
      break;
    case DPERR_INVALIDPARAMS:
      mprintf((0, "Failed to create Directplay session (DPERR_INVALIDPARAMS)!\n"));
      break;
    case DPERR_INVALIDPASSWORD:
      mprintf((0, "Failed to create Directplay session (DPERR_INVALIDPASSWORD)!\n"));
      break;
    case DPERR_LOGONDENIED:
      mprintf((0, "Failed to create Directplay session (DPERR_LOGONDENIED)!\n"));
      break;
    case DPERR_NOCONNECTION:
      mprintf((0, "Failed to create Directplay session (DPERR_NOCONNECTION)!\n"));
      break;
    case DPERR_NONEWPLAYERS:
      mprintf((0, "Failed to create Directplay session (DPERR_NONEWPLAYERS)!\n"));
      break;
    case DPERR_NOSESSIONS:
      mprintf((0, "Failed to create Directplay session (DPERR_NOSESSIONS)!\n"));
      break;
    case DPERR_SIGNFAILED:
      mprintf((0, "Failed to create Directplay session (DPERR_SIGNFAILED)!\n"));
      break;
    case DPERR_TIMEOUT:
      mprintf((0, "Failed to create Directplay session (DPERR_TIMEOUT)!\n"));
      break;
    case DPERR_UNINITIALIZED:
      mprintf((0, "Failed to create Directplay session (DPERR_UNINITIALIZED)!\n"));
      break;
    case DPERR_USERCANCEL:
      mprintf((0, "Failed to create Directplay session (DPERR_USERCANCEL)!\n"));
      break;
    default:
      mprintf((0, "Failed to create Directplay session (unknown)!\n"));
    }
  }
  return 0;
}

int dp_ListDirectPlayGames() {
  DPSESSIONDESC2 sessionDesc;
  HRESULT hr;
  if (!DP_active)
    return DPERR_EXCEPTION;
  if (!lpDirectPlay4A)
    return DPERR_EXCEPTION;

  Num_directplay_games = 0;
  // Search for this kind of session.
  ZeroMemory(&sessionDesc, sizeof(DPSESSIONDESC2));
  sessionDesc.dwSize = sizeof(DPSESSIONDESC2);
  sessionDesc.guidApplication = DPD3_GUID;

  hr = lpDirectPlay4A->EnumSessions(&sessionDesc, 0, EnumSessionsCallback, 0,
                                    DPENUMSESSIONS_AVAILABLE | DPENUMSESSIONS_RETURNSTATUS | DPENUMSESSIONS_ASYNC);
  if (hr == DPERR_CONNECTING) {
    mprintf((0, "Waiting for EnumSessions() to connect.\n"));
    return DPERR_CONNECTING;
  }

  if FAILED (hr) {
    mprintf((0, "Unable to EnumSessions() for Directplay.\n"));
    switch (hr) {
    case DPERR_CONNECTING:
      mprintf((0, "Error code: DPERR_CONNECTING\n"));
      break;
    case DPERR_CONNECTIONLOST:
      mprintf((0, "Error code: DPERR_CONNECTIONLOST\n"));
      break;
    case DPERR_EXCEPTION:
      mprintf((0, "Error code: DPERR_EXCEPTION\n"));
      break;
    case DPERR_GENERIC:
      mprintf((0, "Error code: DPERR_GENERIC\n"));
      break;
    case DPERR_INVALIDOBJECT:
      mprintf((0, "Error code: DPERR_INVALIDOBJECT\n"));
      break;
    case DPERR_INVALIDPARAMS:
      mprintf((0, "Error code: DPERR_INVALIDPARAMS\n"));
      break;
    case DPERR_NOCONNECTION:
      mprintf((0, "Error code: DPERR_NOCONNECTION\n"));
      break;
    case DPERR_UNINITIALIZED:
      mprintf((0, "Error code: DPERR_UNINITIALIZED\n"));
      break;
    case DPERR_USERCANCEL:
      mprintf((0, "Error code: DPERR_USERCANCEL\n"));
      break;
    default:
      mprintf((0, "Error code: Unknown\n"));
      break;
    }
    return DPERR_NOCONNECTION;
  } else
    mprintf((0, "EnumSessions() returned DP_OK\n"));

  return DP_OK;
}

// This function will look for incoming messages, and dispatch them accordingly
void dp_DirectPlayDispatch() {
  HRESULT hr;
  ubyte packet_data[32000];              // MAX_PACKET_SIZE+1];
  unsigned long dwMsgBufferSize = 32000; // MAX_PACKET_SIZE;
  DPID idFrom = 0;
  DPID idTo = 0;
  network_address from_addr;
  LPDPMSG_CREATEPLAYERORGROUP new_player_msg;
  // Put messages in the buffers
  if ((!DP_active) || (!lpDirectPlay4A)) {
    mprintf((0, "Can't dispatch DirectPlay message because DirectPlay isn't active!\n"));
    return;
  }

  hr = lpDirectPlay4A->Receive(&idFrom, &idTo, DPRECEIVE_ALL, packet_data, &dwMsgBufferSize);
  if (FAILED(hr)) {
    switch (hr) {
    case DPERR_BUFFERTOOSMALL:
      mprintf((0, "Error: lpDirectPlay4A->Receive() returned DPERR_BUFFERTOOSMALL -- needs %d\n", dwMsgBufferSize));
      break;
    case DPERR_GENERIC:
      mprintf((0, "Error: lpDirectPlay4A->Receive() returned DPERR_GENERIC\n"));
      break;
    case DPERR_INVALIDOBJECT:
      mprintf((0, "Error: lpDirectPlay4A->Receive() returned DPERR_INVALIDOBJECT\n"));
      break;
    case DPERR_INVALIDPARAMS:
      mprintf((0, "Error: lpDirectPlay4A->Receive() returned DPERR_INVALIDPARAMS\n"));
      break;
    case DPERR_INVALIDPLAYER:
      mprintf((0, "Error: lpDirectPlay4A->Receive() returned DPERR_INVALIDPLAYER\n"));
      break;
    case DPERR_NOMESSAGES:
      // Not really an error....
      // mprintf((0,"Error: lpDirectPlay4A->Receive() returned DPERR_NOMESSAGES\n"));
      break;
    default:
      mprintf((0, "Unknown error code from DirectPlay::Receive() -- %x\n", hr));
    }
  } else {
    // Now we have actual data -- do something with it.
    if (idFrom == DPID_SYSMSG) {
      // This is a system message
      LPDPMSG_GENERIC lpMsg = (LPDPMSG_GENERIC)packet_data;
      switch (lpMsg->dwType) {
      case DPSYS_CREATEPLAYERORGROUP:
        // New player joined the game
        {
          mprintf((0, "Got a DPSYS_CREATEPLAYERORGROUP packet!\n"));
          new_player_msg = (LPDPMSG_CREATEPLAYERORGROUP)lpMsg;
          // Store this player's info
          for (int i = 0; i < MAX_PENDING_NEW_CONNECTIONS; i++) {
            if (Pending_dp_conn[i] == DPID_UNKNOWN) {
              // new connection slot
              Pending_dp_conn[i] = new_player_msg->dpId;
              break;
            }
          }
        }
        break;
      case DPSYS_DESTROYPLAYERORGROUP:
        // Player left the game
        break;
      case DPSYS_ADDPLAYERTOGROUP:
      case DPSYS_DELETEPLAYERFROMGROUP:
      case DPSYS_SESSIONLOST:
      case DPSYS_HOST:
      case DPSYS_SETPLAYERORGROUPDATA:
      case DPSYS_SETPLAYERORGROUPNAME:
      case DPSYS_SENDCOMPLETE:
        break;
      default:
        Int3(); // Get Kevin
        mprintf((0, "Unknown system message from DirectPlay! %d\n", lpMsg->dwType));
      }
    } else {
      if (dwMsgBufferSize >= MAX_PACKET_SIZE) {
        mprintf((0, "Error: Packet too large for D3 to handle! Discarding!!!!!\n"));
      } else {
        // Presumably this is from a player we know about...
        memset(&from_addr, 0, sizeof(network_address));
        from_addr.connection_type = NP_DIRECTPLAY;
        memcpy(from_addr.address, &idFrom, sizeof(DPID));
        nw_psnet_buffer_packet((ubyte *)packet_data, dwMsgBufferSize, &from_addr);
      }
    }
  }
}

//	Send a packet to a direct play user
int dp_DirectPlaySend(network_address *who_to, ubyte *data, int len, bool reliable) {
  DPID idTo;
  HRESULT hr;
  unsigned long send_flags;
  if ((!DP_active) || (!lpDirectPlay4A)) {
    mprintf((0, "Can't send DirectPlay message because DirectPlay isn't active!\n"));
    return 0;
  }

  ASSERT(who_to->connection_type == NP_DIRECTPLAY);

  send_flags = DPSEND_ASYNC;
  if (reliable)
    send_flags |= DPSEND_GUARANTEED;

  memcpy(&idTo, who_to->address, sizeof(DPID));
  hr = lpDirectPlay4A->SendEx(NetPlayers[Player_num].dpidPlayer, idTo, send_flags, data, len, 0, 0, NULL, NULL);

  if (FAILED(hr))
    return 0;
  else
    return 1;
}

void dp_DirectPlayDestroyPlayer(DPID who) {
  HRESULT hr;

  if ((!DP_active) || (!lpDirectPlay4A))
    return;

  hr = lpDirectPlay4A->DestroyPlayer(who);
  if (FAILED(hr)) {
    switch (hr) {
    case DPERR_ACCESSDENIED:
      mprintf((0, "lpDirectPlay4A->DestroyPlayer() returned DPERR_ACCESSDENIED.\n"));
      break;
    case DPERR_CONNECTIONLOST:
      mprintf((0, "lpDirectPlay4A->DestroyPlayer() returned DPERR_CONNECTIONLOST.\n"));
      break;
    case DPERR_INVALIDOBJECT:
      mprintf((0, "lpDirectPlay4A->DestroyPlayer() returned DPERR_INVALIDOBJECT.\n"));
      break;
    case DPERR_INVALIDPLAYER:
      mprintf((0, "lpDirectPlay4A->DestroyPlayer() returned DPERR_INVALIDPLAYER.\n"));
      break;
    case DPERR_UNAVAILABLE:
      mprintf((0, "lpDirectPlay4A->DestroyPlayer() returned DPERR_UNAVAILABLE.\n"));
      break;
    default:
      mprintf((0, "Unknown error returned by nw_DirectPlayDestroyPlayer() -- %x\n", hr));
    }
  }
}

// if(Use_DirectPlay)

int dp_DirectPlayJoinGame(LPDPSESSIONDESC2 session) {
  HRESULT hr;
  do {
    hr = lpDirectPlay4A->Open(session, DPOPEN_JOIN | DPOPEN_RETURNSTATUS);
    if (DPERR_CONNECTING == hr) {
      mprintf((0, "Waiting for Directplay session to start(DPERR_CONNECTING)!\n"));
      Sleep(50);
    }
  } while (DPERR_CONNECTING == hr);
  if (FAILED(hr)) {
    switch (hr) {

    case DPERR_ACCESSDENIED:
      mprintf((0, "Failed to create Directplay session (DPERR_ACCESSDENIED)!\n"));
      break;
    case DPERR_ALREADYINITIALIZED:
      mprintf((0, "Failed to create Directplay session (DPERR_ALREADYINITIALIZED)!\n"));
      break;
    case DPERR_AUTHENTICATIONFAILED:
      mprintf((0, "Failed to create Directplay session (DPERR_AUTHENTICATIONFAILED)!\n"));
      break;
    case DPERR_CANNOTCREATESERVER:
      mprintf((0, "Failed to create Directplay session (DPERR_CANNOTCREATESERVER)!\n"));
      break;
    case DPERR_CANTLOADCAPI:
      mprintf((0, "Failed to create Directplay session (DPERR_CANTLOADCAPI)!\n"));
      break;
    case DPERR_CANTLOADSECURITYPACKAGE:
      mprintf((0, "Failed to create Directplay session (DPERR_CANTLOADSECURITYPACKAGE)!\n"));
      break;
    case DPERR_CANTLOADSSPI:
      mprintf((0, "Failed to create Directplay session (DPERR_CANTLOADSSPI)!\n"));
      break;
    case DPERR_CONNECTIONLOST:
      mprintf((0, "Failed to create Directplay session (DPERR_CONNECTIONLOST)!\n"));
      break;
    case DPERR_ENCRYPTIONFAILED:
      mprintf((0, "Failed to create Directplay session (DPERR_ENCRYPTIONFAILED)!\n"));
      break;
    case DPERR_ENCRYPTIONNOTSUPPORTED:
      mprintf((0, "Failed to create Directplay session (DPERR_ENCRYPTIONNOTSUPPORTED)!\n"));
      break;
    case DPERR_INVALIDFLAGS:
      mprintf((0, "Failed to create Directplay session (DPERR_INVALIDFLAGS)!\n"));
      break;
    case DPERR_INVALIDPARAMS:
      mprintf((0, "Failed to create Directplay session (DPERR_INVALIDPARAMS)!\n"));
      break;
    case DPERR_INVALIDPASSWORD:
      mprintf((0, "Failed to create Directplay session (DPERR_INVALIDPASSWORD)!\n"));
      break;
    case DPERR_LOGONDENIED:
      mprintf((0, "Failed to create Directplay session (DPERR_LOGONDENIED)!\n"));
      break;
    case DPERR_NOCONNECTION:
      mprintf((0, "Failed to create Directplay session (DPERR_NOCONNECTION)!\n"));
      break;
    case DPERR_NONEWPLAYERS:
      mprintf((0, "Failed to create Directplay session (DPERR_NONEWPLAYERS)!\n"));
      break;
    case DPERR_NOSESSIONS:
      mprintf((0, "Failed to create Directplay session (DPERR_NOSESSIONS)!\n"));
      break;
    case DPERR_SIGNFAILED:
      mprintf((0, "Failed to create Directplay session (DPERR_SIGNFAILED)!\n"));
      break;
    case DPERR_TIMEOUT:
      mprintf((0, "Failed to create Directplay session (DPERR_TIMEOUT)!\n"));
      break;
    case DPERR_UNINITIALIZED:
      mprintf((0, "Failed to create Directplay session (DPERR_UNINITIALIZED)!\n"));
      break;
    case DPERR_USERCANCEL:
      mprintf((0, "Failed to create Directplay session (DPERR_USERCANCEL)!\n"));
      break;
    default:
      mprintf((0, "Failed to create Directplay session (unknown)!\n"));
    }
    // return 0;
  } else {
    HRESULT hres;
    DPNAME client_player;
    ZeroMemory(&client_player, sizeof(DPNAME));
    client_player.dwSize = sizeof(DPNAME);
    client_player.lpszShortNameA = Players[Player_num].callsign;
    client_player.lpszLongNameA = NULL;

    mprintf((0, "Creating local player...\n"));
    NetPlayers[Player_num].hPlayerEvent = CreateEvent(NULL,  // no security
                                                      FALSE, // auto reset
                                                      FALSE, // initial event reset
                                                      NULL); // no name
    if (NetPlayers[Player_num].hPlayerEvent == NULL) {
      mprintf((0, "Failed to create directplay notification event!\n"));
      dp_EndGame();
      DP_active = false;
      return 0;
    }
    hres = lpDirectPlay4A->CreatePlayer(&NetPlayers[Player_num].dpidPlayer, &client_player,
                                        NetPlayers[Player_num].hPlayerEvent, NULL, 0, 0);
    if (FAILED(hres)) {
      mprintf((0, "Failed to create directplay player in dp_DirectPlayJoinGame()\n"));
      switch (hres) {
      case DPERR_CANTADDPLAYER:
        mprintf((0, "Unable to create player. Error code: DPERR_CANTADDPLAYER\n"));
        break;
      case DPERR_CANTCREATEPLAYER:
        mprintf((0, "Unable to create player. Error code: DPERR_CANTCREATEPLAYER\n"));
        break;
      case DPERR_CONNECTIONLOST:
        mprintf((0, "Unable to create player. Error code: DPERR_CONNECTIONLOST\n"));
        break;
      case DPERR_INVALIDFLAGS:
        mprintf((0, "Unable to create player. Error code: DPERR_INVALIDFLAGS\n"));
        break;
      case DPERR_INVALIDPARAMS:
        mprintf((0, "Unable to create player. Error code: DPERR_INVALIDPARAMS\n"));
        break;
      case DPERR_NOCONNECTION:
        mprintf((0, "Unable to create player. Error code: DPERR_NOCONNECTION\n"));
        break;
      default:
        mprintf((0, "Unable to create player. Error code: Unknown\n"));
        break;
      }
      return 0;
    }
    return 1;
  }
  return 1;
}

void dp_ShutdownDirectPlay() {
  int i;
  mprintf((0, "Freeing DirectPlay memory\n"));
  for (i = 0; i < MAX_DIRECTPLAY_CONNECTIONS; i++) {
    if (dpconns[i].conn != NULL) {
      mem_free(dpconns[i].conn);
      dpconns[i].conn = NULL;
      dpconns[i].name[0] = NULL;
    }
  }
  if (lpdplconnection)
    mem_free(lpdplconnection);
  if (lpAddress)
    mem_free(lpAddress);
  lpAddress = NULL;
  lpdplconnection = NULL;
  // Delete any previous directplay instance
  mprintf((0, "Releasing DirectPlay COM object (lpDirectPlay4A)\n"));
  // if(lpDirectPlay4A)
  //	lpDirectPlay4A->Release();
  // lpDirectPlay4A = NULL;
  mprintf((0, "Done shutting down DirectPlay.\n"));
}

// ---------------------------------------------------------------------------
// EnumModemAddress
// ---------------------------------------------------------------------------
// Description: Enumeration callback called by DirectPlayLobby.
//              Enumerates the DirectPlay address chunks. If the
//              chunk contains modem strings, add them to the control.
// Arguments:
//  REFGUID     [in] GUID of the address type
//  DWORD       [in] size of chunk
//  LPVOID      [in] pointer to chunk
//  LPVOID      [in] user-defined context
// Returns:
//  BOOL        FALSE to stop enumerating after the first callback
BOOL FAR PASCAL EnumModemAddress(REFGUID lpguidDataType, DWORD dwDataSize, LPCVOID lpData, LPVOID lpContext) {
  HWND hWnd = (HWND)lpContext;
  LPSTR lpszStr = (LPSTR)lpData;

  // modem
  if (IsEqualGUID(lpguidDataType, DPAID_Modem)) {
    // loop over all strings in list
    while (strlen(lpszStr)) {
      mprintf((0, "Found modem: %s\n", lpszStr));
      if (Num_modems_found < MAX_MODEMS) {
        // store modem name
        strcpy(Modems_found[Num_modems_found].name, lpszStr);
        Num_modems_found++;
      }
      // skip to next string
      lpszStr += strlen(lpszStr) + 1;
    }
  }
  return (TRUE);
}

// char Directplay_modem_list[MAX_MODEMS][200];
// int Num_modems_found = 0;

// Call this function with size set to 0, and it will fill in size with
// the amount of buffer space you need
// Otherwise, it will fill in the buffer with a bunch of null delimited
// strings, with a double null at the end.
int dp_GetModemChoices(char *buffer, unsigned long *size) {
  LPDIRECTPLAY4A lpTempDP4;
  HRESULT hr;
  void *connection = NULL;
  ;
  int i;
  Num_modems_found = 0;
  if (SUCCEEDED(
          CoCreateInstance(CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, IID_IDirectPlay4A, (LPVOID *)&lpTempDP4))) {

    lpTempDP4->EnumConnections(&DPD3_GUID, DirectPlayEnumConnectionsCallback, 0, 0);

    for (i = 0; i < MAX_DIRECTPLAY_CONNECTIONS; i++) {
      if (strcmpi(dpconns[i].name, "Modem Connection For DirectPlay") == 0) {
        // mprintf((0,"Found DirectPlay connection: %s\n",name));
        connection = dpconns[i].conn;
        break;
      }
    }
    if (!connection) {
      mprintf((0, "Unable to find DirectPlay Modem connection.\n"));
      return 0;
    }

    memset(&dpconns, 0, sizeof(dpconnections) * MAX_DIRECTPLAY_CONNECTIONS);

    hr = lpTempDP4->InitializeConnection(connection, 0);

    for (i = 0; i < MAX_DIRECTPLAY_CONNECTIONS; i++) {
      if (dpconns[i].conn != NULL) {
        mem_free(dpconns[i].conn);
        dpconns[i].conn = NULL;
        dpconns[i].name[0] = NULL;
      }
    }

    if (FAILED(hr)) {
      mprintf((0, "lpTempDP4->InitializeConnection() failed.\n"));
      switch (hr) {
      case DPERR_ALREADYINITIALIZED:
        mprintf((0, "Error: DPERR_ALREADYINITIALIZED\n"));
        break;
      case DPERR_INVALIDFLAGS:
        mprintf((0, "Error: DPERR_INVALIDFLAGS\n"));
        break;
      case DPERR_INVALIDPARAMS:
        mprintf((0, "Error: DPERR_INVALIDPARAMS\n"));
        break;
      case DPERR_UNAVAILABLE:
        mprintf((0, "Error: DPERR_UNAVAILABLE\n"));
        break;
      default:
        mprintf((0, "Error: Unknown\n"));
      }

      return 0;
    }
    lpTempDP4->GetPlayerAddress(0, buffer, size);
    if (buffer) {
      if (lpDirectPlayLobby3A) {
        lpDirectPlayLobby3A->Release();
        lpDirectPlayLobby3A = NULL;
      }
      hr = CoCreateInstance(CLSID_DirectPlayLobby, NULL, CLSCTX_INPROC_SERVER, IID_IDirectPlayLobby3A,
                            (LPVOID *)&lpDirectPlayLobby3A);
      if (SUCCEEDED(hr))
        lpDirectPlayLobby3A->EnumAddress(EnumModemAddress, buffer, *size, 0);
      else
        mprintf((0, "Couldn't create IID_IDirectPlayLobby3A COM Instance!\n"));
    }

    lpTempDP4->Release();
    return 1;
  }
  return 0;
}

// Register a DirectPlay lobby aware application
// Use this so a directplay lobby provider such as zone.com can launch the game
//
// Parameters:
// appname		The non-localized name of the application (ie. "Descent 3") DON'T LOCALIZE THIS! IT IS AN ID
//	exefile		Executable file name (without path)
//	exepath		Path to executable file
//	arguments	Any command line arguments the app needs
//	workingdir	The Working directory for the application
//	description	Localized description of the application
void dp_RegisterLobbyApplication(char *appname, char *exefile, char *exepath, char *arguments, char *workingdir,
                                 char *description) {
  static DPAPPLICATIONDESC AppDesc;

  AppDesc.dwSize = sizeof(DPAPPLICATIONDESC);
  AppDesc.dwFlags = 0;
  AppDesc.lpszApplicationNameA = appname;
  AppDesc.guidApplication = DPD3_GUID;
  AppDesc.lpszFilenameA = exefile;
  AppDesc.lpszCommandLineA = arguments;
  AppDesc.lpszPathA = exepath;
  AppDesc.lpszCurrentDirectoryA = workingdir;
  AppDesc.lpszDescriptionA = description;

  HRESULT hr;

  mprintf((0, "Registering DirectPlay Lobby application:\n"));
  mprintf((0, "AppDesc.lpszApplicationNameA = %s\n", appname));
  mprintf((0, "AppDesc.lpszFilenameA = %s\n", exefile));
  mprintf((0, "AppDesc.lpszCommandLineA = %s\n", arguments));
  mprintf((0, "AppDesc.lpszPathA = %s\n", exepath));
  mprintf((0, "AppDesc.lpszCurrentDirectoryA = %s\n", workingdir));
  mprintf((0, "AppDesc.lpszDescriptionA = %s\n", description));

  hr = CoCreateInstance(CLSID_DirectPlayLobby, NULL, CLSCTX_INPROC_SERVER, IID_IDirectPlayLobby3A,
                        (LPVOID *)&lpDirectPlayLobby3A);
  if (SUCCEEDED(hr)) {
    hr = lpDirectPlayLobby3A->RegisterApplication(0, &AppDesc);
    if (FAILED(hr)) {
      mprintf((0, "IDirectPlayLobby3::RegisterApplication() failed.\n"));
      if (hr == DPERR_INVALIDFLAGS)
        mprintf((0, "Error = DPERR_INVALIDFLAGS\n"));
      else if (hr == DPERR_INVALIDPARAMS)
        mprintf((0, "Error = DPERR_INVALIDPARAMS\n"));
      else
        mprintf((0, "Error = ??????????? %x\n", hr));
    } else {
      mprintf((0, "IDirectPlayLobby3::RegisterApplication() succeded.\n"));
    }
  } else {
    mprintf((0, "IDirectPlayLobby3 CoCreateInstance() failed.\n"));
    return;
  }

  // lpDirectPlayLobby3A->Release();
}

// Returns TRUE if the game was launched from a lobby
bool dp_DidLobbyLaunchGame() {
  HRESULT hr;
  unsigned long buffersize = sizeof(DPLCONNECTION);

  Directplay_lobby_launched_game = false;
  if (lpDirectPlayLobby3A) {
    lpDirectPlayLobby3A->Release();
    lpDirectPlayLobby3A = NULL;
  }
  CoInitialize(NULL);
  hr = CoCreateInstance(CLSID_DirectPlayLobby, NULL, CLSCTX_INPROC_SERVER, IID_IDirectPlayLobby3A,
                        (LPVOID *)&lpDirectPlayLobby3A);
  if (SUCCEEDED(hr)) {
    hr = lpDirectPlayLobby3A->GetConnectionSettings(0, NULL, &buffersize);
    if (FAILED(hr)) {
      if (hr == DPERR_NOTLOBBIED) {
        mprintf((0, "Application not started from a lobby.\n"));
        lpDirectPlayLobby3A->Release();
        lpDirectPlayLobby3A = NULL;
        return false;
      }
      mprintf((0, "Unable to determine DirectPlay lobby connection info buffer size!!!\n"));
      lpDirectPlayLobby3A->Release();
      lpDirectPlayLobby3A = NULL;
      return false;
    }
    lpdplconnection = (LPDPLCONNECTION)mem_malloc(buffersize);
    hr = lpDirectPlayLobby3A->GetConnectionSettings(0, lpdplconnection, &buffersize);
    lpDirectPlayLobby3A->Release();
    lpDirectPlayLobby3A = NULL;
    if (FAILED(hr)) {
      mprintf((0, "IDirectPlayLobby3::GetConnectionSettings() failed.\n"));
      if (hr == DPERR_NOTLOBBIED) {
        mprintf((0, "Application not started from a lobby.\n"));
        return false;
      } else {
        mprintf((0, "Unknown error from IDirectPlayLobby3::GetConnectionSettings().\n"));
        return false;
      }
    } else {
      mprintf((0, "Application was started from a lobby.\n"));
      Directplay_lobby_launched_game = true;
      return true;
    }
  } else {
    mprintf((0, "IDirectPlayLobby3 CoCreateInstance() failed.\n"));
  }
  return false;
}

// Autoconnects to a game or starts one, based on the directplay lobby stuff
bool dp_AutoConnect() {
  if (!Directplay_lobby_launched_game)
    return false;

  if (lpdplconnection->dwFlags == DPLCONNECTION_CREATESESSION) {
    //	We are hosting a game
    Use_DirectPlay = true;
    // What level do we use? what dll? what pps, etc....

  } else if (lpdplconnection->dwFlags == DPLCONNECTION_JOINSESSION) {
    //	We are joining a game
    Use_DirectPlay = true;
  }

  return false;
}