[common/c-host] move agnostic code into common library

common/src/platform/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.0)
+project(lg_common_platform LANGUAGES C)
+
+if (UNIX)
+  add_subdirectory("linux")
+elseif(WIN32)
+  add_subdirectory("windows")
+endif()
+
+add_library(lg_common_platform INTERFACE)
+target_link_libraries(lg_common_platform INTERFACE lg_common_platform_code)

common/src/platform/linux/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.0)
+project(lg_common_platform_code LANGUAGES C)
+
+include_directories(
+	${PROJECT_SOURCE_DIR}/include
+)
+
+add_library(lg_common_platform_code STATIC
+    crash.c
+    sysinfo.c
+)

common/src/platform/windows/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.0)
+project(lg_common_platform_code LANGUAGES C)
+
+include_directories(
+	${PROJECT_SOURCE_DIR}/include
+)
+
+add_library(lg_common_platform_code STATIC
+    crash.c
+    sysinfo.c
+    thread.c
+    event.c
+    windebug.c
+)

common/src/platform/windows/event.c

@@ -0,0 +1,221 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+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
+*/
+
+#include "common/event.h"
+#include "common/windebug.h"
+#include "common/time.h"
+
+#include <windows.h>
+
+struct LGEvent
+{
+  volatile int  lock;
+  bool          reset;
+  HANDLE        handle;
+  bool          wrapped;
+  unsigned int  msSpinTime;
+  volatile bool signaled;
+};
+
+LGEvent * lgCreateEvent(bool autoReset, unsigned int msSpinTime)
+{
+  LGEvent * event = (LGEvent *)malloc(sizeof(LGEvent));
+  if (!event)
+  {
+    DEBUG_ERROR("out of ram");
+    return NULL;
+  }
+
+  event->lock       = 0;
+  event->reset      = autoReset;
+  event->handle     = CreateEvent(NULL, autoReset ? FALSE : TRUE, FALSE, NULL);
+  event->wrapped    = false;
+  event->msSpinTime = msSpinTime;
+  event->signaled   = false;
+
+  if (!event->handle)
+  {
+    DEBUG_WINERROR("Failed to create the event", GetLastError());
+    free(event);
+    return NULL;
+  }
+
+  return event;
+}
+
+LGEvent * lgWrapEvent(void * handle)
+{
+  LGEvent * event = (LGEvent *)malloc(sizeof(LGEvent));
+  if (!event)
+  {
+    DEBUG_ERROR("out of ram");
+    return NULL;
+  }
+
+  event->lock       = 0;
+  event->reset      = false;
+  event->handle     = (HANDLE)handle;
+  event->wrapped    = true;
+  event->msSpinTime = 0;
+  event->signaled   = false;
+  return event;
+}
+
+void lgFreeEvent(LGEvent * event)
+{
+  CloseHandle(event->handle);
+}
+
+bool lgWaitEvent(LGEvent * event, unsigned int timeout)
+{
+  // wrapped events can't be enahnced
+  if (!event->wrapped)
+  {
+    if (event->signaled)
+    {
+      if (event->reset)
+        event->signaled = false;
+      return true;
+    }
+
+    if (timeout == 0)
+    {
+      bool ret = event->signaled;
+      if (event->reset)
+        event->signaled = false;
+      return ret;
+    }
+
+    if (event->msSpinTime)
+    {
+      unsigned int spinTime = event->msSpinTime;
+      if (timeout != TIMEOUT_INFINITE)
+      {
+        if (timeout > event->msSpinTime)
+          timeout -= event->msSpinTime;
+        else
+        {
+          spinTime -= timeout;
+          timeout   = 0;
+        }
+      }
+
+      uint64_t now = getMicrotime();
+      uint64_t end = now + spinTime * 1000;
+      while(!event->signaled)
+      {
+        now = getMicrotime();
+        if (now >= end)
+          break;
+      }
+
+      if (event->signaled)
+      {
+        if (event->reset)
+          event->signaled = false;
+        return true;
+      }
+    }
+  }
+
+  const DWORD to = (timeout == TIMEOUT_INFINITE) ? INFINITE : (DWORD)timeout;
+  while(true)
+  {
+    switch(WaitForSingleObject(event->handle, to))
+    {
+      case WAIT_OBJECT_0:
+        if (!event->reset)
+          event->signaled = true;
+        return true;
+
+      case WAIT_ABANDONED:
+        continue;
+
+      case WAIT_TIMEOUT:
+        if (timeout == TIMEOUT_INFINITE)
+          continue;
+
+        return false;
+
+      case WAIT_FAILED:
+        DEBUG_WINERROR("Wait for event failed", GetLastError());
+        return false;
+    }
+
+    DEBUG_ERROR("Unknown wait event return code");
+    return false;
+  }
+}
+
+bool lgWaitEvents(LGEvent * events[], int count, bool waitAll, unsigned int timeout)
+{
+  const DWORD to = (timeout == TIMEOUT_INFINITE) ? INFINITE : (DWORD)timeout;
+
+  HANDLE * handles = (HANDLE *)malloc(sizeof(HANDLE) * count);
+  for(int i = 0; i < count; ++i)
+    handles[i] = events[i]->handle;
+
+  while(true)
+  {
+    DWORD result = WaitForMultipleObjects(count, handles, waitAll, to);
+    if (result >= WAIT_OBJECT_0 && result < count)
+    {
+      // null non signaled events from the handle list
+      for(int i = 0; i < count; ++i)
+        if (i != result && !lgWaitEvent(events[i], 0))
+          handles[i] = NULL;
+      free(handles);
+      return true;
+    }
+
+    if (result >= WAIT_ABANDONED_0 && result - WAIT_ABANDONED_0 < count)
+      continue;
+
+    switch(result)
+    {
+      case WAIT_TIMEOUT:
+        if (timeout == TIMEOUT_INFINITE)
+          continue;
+
+        free(handles);
+        return false;
+
+      case WAIT_FAILED:
+        DEBUG_WINERROR("Wait for event failed", GetLastError());
+        free(handles);
+        return false;
+    }
+
+    DEBUG_ERROR("Unknown wait event return code");
+    free(handles);
+    return false;
+  }
+}
+
+bool lgSignalEvent(LGEvent * event)
+{
+  event->signaled = true;
+  return SetEvent(event->handle);
+}
+
+bool lgResetEvent(LGEvent * event)
+{
+  event->signaled = false;
+  return ResetEvent(event->handle);
+}

common/src/platform/windows/thread.c

@@ -0,0 +1,93 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+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
+*/
+
+#include "common/thread.h"
+#include "common/debug.h"
+#include "common/windebug.h"
+
+#include <windows.h>
+
+struct LGThread
+{
+  const char       * name;
+  LGThreadFunction   function;
+  void             * opaque;
+  HANDLE             handle;
+  DWORD              threadID;
+
+  int                resultCode;
+};
+
+static DWORD WINAPI threadWrapper(LPVOID lpParameter)
+{
+  LGThread * handle = (LGThread *)lpParameter;
+  handle->resultCode = handle->function(handle->opaque);
+  return 0;
+}
+
+bool lgCreateThread(const char * name, LGThreadFunction function, void * opaque, LGThread ** handle)
+{
+  *handle             = (LGThread *)malloc(sizeof(LGThread));
+  (*handle)->name     = name;
+  (*handle)->function = function;
+  (*handle)->opaque   = opaque;
+  (*handle)->handle   = CreateThread(NULL, 0, threadWrapper, *handle, 0, &(*handle)->threadID);
+
+  if (!(*handle)->handle)
+  {
+    free(*handle);
+    *handle = NULL;
+    DEBUG_WINERROR("CreateThread failed", GetLastError());
+    return false;
+  }
+
+  return true;
+}
+
+bool lgJoinThread(LGThread * handle, int * resultCode)
+{
+  while(true)
+  {
+    switch(WaitForSingleObject(handle->handle, INFINITE))
+    {
+      case WAIT_OBJECT_0:
+        if (resultCode)
+          *resultCode = handle->resultCode;
+        CloseHandle(handle->handle);
+        free(handle);
+        return true;
+
+      case WAIT_ABANDONED:
+      case WAIT_TIMEOUT:
+        continue;
+
+      case WAIT_FAILED:
+        DEBUG_WINERROR("Wait for thread failed", GetLastError());
+        CloseHandle(handle->handle);
+        free(handle);
+        return false;
+    }
+
+    break;
+  }
+
+  DEBUG_WINERROR("Unknown failure waiting for thread", GetLastError());
+  return false;
+}
+

common/src/platform/windows/windebug.c

@@ -0,0 +1,42 @@
+/*
+Looking Glass - KVM FrameRelay (KVMFR) Client
+Copyright (C) 2017-2020 Geoffrey McRae <geoff@hostfission.com>
+https://looking-glass.hostfission.com
+
+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
+*/
+
+#include "common/windebug.h"
+#include <stdio.h>
+
+void DebugWinError(const char * file, const unsigned int line, const char * function, const char * desc, HRESULT status)
+{
+  char *buffer;
+  FormatMessageA(
+    FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
+    NULL,
+    status,
+    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+    (char*)&buffer,
+    1024,
+    NULL
+  );
+
+  for(size_t i = strlen(buffer) - 1; i > 0; --i)
+    if (buffer[i] == '\n' || buffer[i] == '\r')
+      buffer[i] = 0;
+
+  fprintf(stderr, "[E] %20s:%-4u | %-30s | %s: 0x%08x (%s)\n", file, line, function, desc, (int)status, buffer);
+  LocalFree(buffer);
+}