servewin32.cc

Go to the documentation of this file.

/*
Copyright (C) 2002 The Exult Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// Win32 Only file

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif


#if defined(WIN32) && defined(USE_EXULTSTUDIO)

#include <iostream>     /* For debugging msgs. */
#include <cstring>      /* For debugging msgs. */
#include "servemsg.h"
#include "servewin32.h"

using std::cout;
using std::cerr;
using std::endl;

namespace Exult_server
{
static HANDLE hPipeRead = INVALID_HANDLE_VALUE;
static HANDLE hPipeWrite = INVALID_HANDLE_VALUE;

static OVERLAPPED oOverlap;     // Overlap structure
static LPOVERLAPPED lpOverlap = 0;    // Pointer to overlap structure
static OVERLAPPED oOverlapCon;      // Overlap structure
static LPOVERLAPPED lpOverlapCon = 0;   // Pointer to overlap structure
static BOOL bWinNT = FALSE;
static BOOL bClient = FALSE;
static BOOL bBroken = FALSE;
static BOOL bNotifyDis = FALSE;

static const char * const pipe_name = "\\\\.\\pipe\\exultserver-";
static const char * const mail_server = "\\\\.\\mailslot\\exultserver-";
static const char * const mail_client = "\\\\.\\mailslot\\exultclient-";

// static Functions

static char *get_pipe_name(const char *static_path, const char * const pipe_name = Exult_server::pipe_name, bool ms = false)
{
  // Check to make sure that the pipe name hasn't been passed to us
  if (!std::strncmp(static_path, "\\\\.\\pipe\\", std::strlen("\\\\.\\pipe\\"))) {
    char *path = new char[std::strlen(static_path)+1];
    return std::strcpy(path, static_path);
  }

  // Check to make sure that the mailslot name hasn't been passed to us
  if (!std::strncmp(static_path, "\\\\.\\mailslot\\", std::strlen("\\\\.\\mailslot\\"))) {
    char *path = new char[std::strlen(static_path)+1];
    return std::strcpy(path, static_path);
  }

  int num_chars = GetShortPathName(static_path, NULL, 0);
  int head_len = std::strlen(pipe_name);
  char *actual_path;

  if (num_chars) {
    char *temp = new char[num_chars+1];
    GetShortPathName(static_path, temp, num_chars+1);
    num_chars = GetFullPathName(temp, 0, NULL, NULL);
    actual_path = new char[num_chars+head_len+1];
    char *temp2;
    GetFullPathName(temp, num_chars+1, actual_path+head_len, &temp2);
  }
  else {
    cout << "Unable to find actual static path" << endl;
    return 0;
  }

  std::memcpy (actual_path, pipe_name,head_len);

  if (!ms){
    for (char *temp = actual_path+head_len; *temp; temp++)
      if (*temp == '\\') *temp = '/';
  }
  else {
    for (char *temp = actual_path+head_len; *temp; temp++)
      if (*temp == '/') *temp = '\\';
      else if (*temp == ':') *temp = '_';
  }

  if (std::strlen(actual_path) > 255)actual_path[255] = 0;

  while (actual_path[std::strlen(actual_path)-1] == '/') actual_path[std::strlen(actual_path)-1] = 0;
  while (actual_path[std::strlen(actual_path)-1] == '\\') actual_path[std::strlen(actual_path)-1] = 0;

  return actual_path;
}

static void detect_winnt()
{
  OSVERSIONINFO info;
  info.dwOSVersionInfoSize = sizeof (info);
  GetVersionEx (&info);

  // Platform is NT
  if (info.dwPlatformId == 2 && (info.dwMajorVersion > 5 ||
      (info.dwMajorVersion == 5 && info.dwMinorVersion >= 1)))
    bWinNT = TRUE;
}


static bool setup_overlap()
{
  memset(&oOverlap,0, sizeof (oOverlap));
  memset(&oOverlapCon,0, sizeof (oOverlapCon));

  // Platform is NT
  if (bWinNT)
  {
    // Create the overlap event
    oOverlap.hEvent = CreateEvent (NULL, TRUE, TRUE, NULL);
    lpOverlap = &oOverlap;
    oOverlapCon.hEvent = CreateEvent (NULL, TRUE, TRUE, NULL);
    lpOverlapCon = &oOverlapCon;

    return true;
  }

  return false;
}

static void free_overlap()
{
  if (oOverlap.hEvent) CloseHandle(oOverlap.hEvent);
  oOverlap.hEvent = 0;
  lpOverlap = 0;

  if (oOverlapCon.hEvent) CloseHandle(oOverlapCon.hEvent);
  oOverlapCon.hEvent = 0;
  lpOverlapCon = 0;

}

// This sets up mailslots for the interprocess coms on Win9x
static bool setup_server_mailslots(const char *static_path, bool both)
{
  // Create read frst
  if (hPipeRead == INVALID_HANDLE_VALUE)
  {
    char *server_name = Exult_server::get_pipe_name(static_path,mail_server, true);
    hPipeRead = CreateMailslot(server_name, 1024, 0, NULL);

    if (hPipeRead == INVALID_HANDLE_VALUE) {
      std::cout << "Unable to create mailslot : " << server_name << " Code " << GetLastError() << std::endl;
      delete [] server_name ;
      return false;
    }

    
    //cout << "Created mailslot. Name " << server_name << std::endl;
    delete [] server_name ;
    if (!both) return true;
  }

  // Now attempt to create read
  if (hPipeWrite == INVALID_HANDLE_VALUE)
  {
    char *client_name = Exult_server::get_pipe_name(static_path,mail_client, true);

    hPipeWrite = CreateFile (client_name,   // Pipe Name
        GENERIC_WRITE,      // Desired Access
        FILE_SHARE_READ,    // Share Mode
        NULL,       // Security Att
        OPEN_EXISTING,      // Creation Disposition
        FILE_ATTRIBUTE_NORMAL,    // Flags and Attributes
        NULL);        // TemplateFile

    if (hPipeWrite == INVALID_HANDLE_VALUE) {
      //std::cout << "Unable to connect to mailslot: " << client_name <<" Code " << GetLastError() << std::endl;
      delete [] client_name;
      return false;
    }
    //std::cout << "Connected to mailslot. Name " << client_name << std::endl;
    delete [] client_name ;
  }

  return true;
}

// This sets up mailslots for the interprocess coms on Win9x
static bool setup_client_mailslots(const char *static_path)
{
  // Create write frst
  if (hPipeWrite == INVALID_HANDLE_VALUE)
  {
    char *server_name = Exult_server::get_pipe_name(static_path,mail_server, true);

    hPipeWrite = CreateFile (server_name,   // Pipe Name
        GENERIC_WRITE,      // Desired Access
        FILE_SHARE_READ,    // Share Mode
        NULL,       // Security Att
        OPEN_EXISTING,      // Creation Disposition
        FILE_ATTRIBUTE_NORMAL,    // Flags and Attributes
        NULL);        // TemplateFile

    if (hPipeWrite == INVALID_HANDLE_VALUE) {
      //std::cout << "Unable to connect to mailslot: " << server_name <<" Code " << GetLastError() << std::endl;
      delete [] server_name;
      return false;
    }
    //std::cout << "Connected to mailslot. Name " << server_name << std::endl;
    delete [] server_name ;
  }

  // Now attempt to create read
  if (hPipeRead == INVALID_HANDLE_VALUE)
  {
    char *client_name = Exult_server::get_pipe_name(static_path,mail_client, true);
    hPipeRead = CreateMailslot(client_name, 1024, 0, NULL);

    if (hPipeRead == INVALID_HANDLE_VALUE) {
      std::cout << "Unable to create mailslot : " << client_name << " Code " << GetLastError() << std::endl;
      delete [] client_name ;
      CloseHandle(hPipeWrite);
      hPipeWrite = INVALID_HANDLE_VALUE;
      return false;
    }

    //std::cout << "Created mailslot. Name " << client_name << std::endl;
    delete [] client_name ;
  }

  return true;
}

// Hack functions
int write(int file, const void *v, unsigned int len)
{
  DWORD num_written;

  BOOL failed = !WriteFile(hPipeWrite, v, len, &num_written, lpOverlap);

  const unsigned char *data = (unsigned char *)v;
  //cout << "write = " << len << endl;
  //for (int q = 0 ; q < len; q++) cout << ((int) data [q]) << " ";
  //cout << endl;

  if ((!bWinNT && failed) || GetLastError() == ERROR_BROKEN_PIPE) {
    std::cout << "Broken!" << std::endl;
    bBroken = TRUE;
    return 0;
  }

  if (num_written == 0) return -1;

  return num_written;
}

static unsigned char buf[2048];
static unsigned int offset = 2048;
static unsigned int num_left = 0;

int read_win9x(int file, unsigned char *v, unsigned int len)
{
  DWORD num_read;

  //std::cout << "The Num wanted is " << len << std::endl;

  // Buffer is empty, fill it
  if (num_left == 0)
  {
    int total = peek_pipe();

    if (total >= 2048) {
      std::cerr << "Buffer too small. Read failed" << std::endl;
      return 0;
    }
    else if (total == 0) {
      return 0;
    }
    else if (total == -1) {
      return -1;
    }

    ReadFile(hPipeRead, buf, total, &num_read, NULL);
    offset = 0;
    num_left = total;

    //std::cout << "Read " << num_read << " bytes from mailslot" << std::endl;
  }

  // Now copy the amount of bytes, if we can, if we can't call the func recursively
  num_read = 0;

  // Buffer contains enough
  if (num_left >= len) {
    std::memcpy (v, buf+offset, len);
    num_left -= len;
    num_read  = len;
    offset += len;
  } // Uh oh, the buffer doesn't contain enough
  else {
    std::memcpy (v, buf+offset, num_left);
    len -= num_left;
    num_read += num_left;
    offset += num_left;
    num_left = 0;

    num_left += read_win9x(file, v+num_read, len);
  }

  //std::cout << "The Num read is " << num_read << std::endl;
  //std::cout << num_left << " byte left in buffer with offset " << offset<< std::endl;

  bNotifyDis = TRUE;
  return num_read;
}

int read(int file, void *v, unsigned int len)
{
  if (!bWinNT) return read_win9x(file, (unsigned char*) v, len);

  DWORD num_read;
  int total = peek_pipe();

  if (total == -1) return 0;
  else if (len == 0) return 0;
  else if (total == 0) return -1;
  else if (total < len) len = total;

  ReadFile(hPipeRead, v, len, &num_read, NULL);

  const unsigned char *data = (unsigned char *)v;
  //cout << "read = " << num_read << endl;
  //for (int q = 0 ; q < num_read; q++) cout << ((int) data[q]) << " ";
  //cout << endl;

  if (GetLastError() == ERROR_BROKEN_PIPE) {
    bBroken = TRUE;
    return 0;
  }

  return num_read;
}

int close(int file)
{ 
  return 0;
}

// Server Functions

bool create_pipe (const char *static_path)
{
  bBroken = FALSE;

  detect_winnt();

  if (!bWinNT)
  {
    std::cout << "Using mailslots" << std::endl;
    hPipeRead = hPipeWrite= INVALID_HANDLE_VALUE; 
    return setup_server_mailslots(static_path, false);
  }

  char *pipe_name = Exult_server::get_pipe_name(static_path);

  // Must have overlap for now
  DWORD oflag = FILE_FLAG_OVERLAPPED;
  if(!setup_overlap()) {
    cerr << "Pipe Server not supported on Win9x." << endl;
    return true;
  }

  //cout << "Exult Server pipe name: " << pipe_name << endl;

  // Create the Win32 Named pipe
  hPipeRead = hPipeWrite = CreateNamedPipe(pipe_name,   // pipe name
        PIPE_ACCESS_DUPLEX|oflag,   // pipe open mode
        PIPE_TYPE_BYTE|PIPE_READMODE_BYTE,  // pipe-specific modes
        1,          // maximum number of instances
        32768,          // output buffer size
        32768,          // input buffer size
        0,          // time-out interval
        NULL);          // Security Descriptor

  delete [] pipe_name;

  if (hPipeWrite  == INVALID_HANDLE_VALUE) {
    cerr << "Unable to create pipe. Reason: " << GetLastError() << endl;
    free_overlap();
    return false;
  }

  cout << "Created Pipe for Exult Server" << endl;

  setup_connect();

  return true;
}

void setup_connect()
{
  bBroken = FALSE;

  if (!bWinNT) return;

  // Attempt to connect to the pipe
        BOOL fConnected = ConnectNamedPipe(hPipeWrite, lpOverlapCon) ? 
    TRUE : (GetLastError() == ERROR_PIPE_CONNECTED); 

  // If it's connected, signal the event
  if (fConnected) SetEvent(oOverlapCon.hEvent);
}

bool try_connect_to_client(const char *static_path)
{
  bBroken = FALSE;

  if (bWinNT)
  {
    DWORD num_bytes;

    BOOL fConnected = GetOverlappedResult (hPipeWrite, lpOverlapCon, &num_bytes, FALSE);
      
    if (!fConnected) return false;
  }
  else {
    return setup_server_mailslots(static_path, true);
  }

  return true;
}

void disconnect_from_client()
{
  bBroken = FALSE;
  if (bWinNT) {
    FlushFileBuffers (hPipeWrite);
    DisconnectNamedPipe(hPipeWrite);
  }
  else {
    if (hPipeWrite != INVALID_HANDLE_VALUE) {
      FlushFileBuffers (hPipeWrite);
      CloseHandle(hPipeWrite);
    }
    if (hPipeRead != INVALID_HANDLE_VALUE) {
      CloseHandle(hPipeRead);
    }
    hPipeRead = hPipeWrite= INVALID_HANDLE_VALUE;
  }
}

void close_pipe()
{
  bBroken = FALSE;
  if (bWinNT) {
    if (hPipeWrite != INVALID_HANDLE_VALUE) {
      disconnect_from_client();
      free_overlap();
      CloseHandle(hPipeWrite);
      hPipeRead = hPipeWrite = INVALID_HANDLE_VALUE;
    }
  }
  else {
    disconnect_from_client();
  }
}

// Client Functions
int try_connect_to_server (const char *static_path)
{
  bBroken = FALSE;
  detect_winnt();

  if (!bWinNT)
  {
    hPipeRead = hPipeWrite= INVALID_HANDLE_VALUE; 
    return setup_client_mailslots(static_path);
  }

  char *pipe_name = Exult_server::get_pipe_name(static_path);

  // No server
  if (!WaitNamedPipe(pipe_name, 0)) return 0;

  // Must have overlap
  DWORD oflag = FILE_FLAG_OVERLAPPED;
  if(!setup_overlap()) {
    cerr << "Pipe Client not supported on Win9x." << endl;
    return -1;
  }

  //cout << "Attempting to connect to server: " << pipe_name << endl;

  hPipeRead = hPipeWrite = CreateFile (pipe_name,   // Pipe Name
        GENERIC_READ|GENERIC_WRITE, // Desired Access
        0,        // Share Mode
        NULL,       // Security Att
        OPEN_EXISTING,      // Creation Disposition
        oflag,        // Flags and Attributes
        NULL);        // TemplateFile


  if (hPipeWrite == INVALID_HANDLE_VALUE)
  {
    ERROR_ALREADY_EXISTS;
    cout << "Pipe handle was invalid! : " << GetLastError () << endl;
    free_overlap();
    return 0;
  }

  bClient = TRUE;

  return 1;
}

void disconnect_from_server()
{
  //CreateMailslot
  bBroken = FALSE;
  if (bWinNT) {
    if (hPipeWrite != INVALID_HANDLE_VALUE) {
      FlushFileBuffers (hPipeWrite);
      free_overlap();
      CloseHandle(hPipeWrite);
      hPipeRead = hPipeWrite= INVALID_HANDLE_VALUE;
    }
  }
  else
  {
    if (hPipeWrite != INVALID_HANDLE_VALUE) {
      FlushFileBuffers (hPipeWrite);
      CloseHandle(hPipeWrite);
    }
    if (hPipeRead != INVALID_HANDLE_VALUE) {
      CloseHandle(hPipeRead);
    }
    hPipeRead = hPipeWrite= INVALID_HANDLE_VALUE;
  }
}

#define WIN9X_KEEPALIVE_SIZE 1
int peek_pipe()
{
  if (bBroken) return -1;

  DWORD to_get;

  if (bWinNT) {
    PeekNamedPipe(hPipeRead, 0, 0, 0, &to_get, 0);

    if (GetLastError() == ERROR_BROKEN_PIPE) {
      std::cout << "Broken!" << std::endl;
      bBroken = TRUE;
      return -1;
    }

  }
  else {
    DWORD num_read;
    static DWORD last_time = 0;

    // This is a keep alive. It doesn't send anything,
    // But, if the mailslot closes, this will fail.
    // That is the theory, but win9x doesn't quite
    // work that way
#ifdef USE_WIN9X_KEEPALIVE
    if (last_time < GetTickCount()) {
      last_time = GetTickCount() + 5000;
      char buf[WIN9X_KEEPALIVE_SIZE];
      if (!WriteFile(hPipeWrite, buf, WIN9X_KEEPALIVE_SIZE, &num_read, 0)) {
        std::cout << "Broken!" << std::endl;
        bBroken = TRUE;
        return -1;
      }
    }
#endif

    GetMailslotInfo(hPipeRead, NULL, &to_get, NULL, NULL);
    
#ifdef USE_WIN9X_KEEPALIVE
    while (to_get <= WIN9X_KEEPALIVE_SIZE) {
      char buf[WIN9X_KEEPALIVE_SIZE];
      ReadFile(hPipeRead, buf, to_get, &num_read, 0);
      GetMailslotInfo(hPipeRead, NULL, &to_get, NULL, NULL);
    }
#endif
    

    if (to_get == MAILSLOT_NO_MESSAGE) return 0;
  }

  return to_get;
}

bool is_broken() 
{
  return bBroken != FALSE;
}

bool notify_connection_lost()
{
  if (bNotifyDis == TRUE) {
    bNotifyDis = FALSE;
    return true;
  }
  return bWinNT != FALSE;
}

bool is_win9x() 
{
  return bWinNT == FALSE;
}

}

#endif

---